downfromftp.c

linux下http和ftp下载工具

            	    break;
            	}
    	}
    	if(FALSE==connected)
        {
    		close(sock);
    		sleep(5);
    		DownLoadFtp(pCreatThread);
    		return 0;
    	}

        memset(dataget, 0, 512);
    	
    	boolprint=0;
        /* 如果其它线程在下载该线程的数据，退出线程*/
    	if(s_info->booldown==1&&s_info->allowotherdown==1)
            return 0;   
      	
    	
        while((bytesleft>0) && (pDloadInfo->bTaskExit==FTPHTTP_NORMAL))
        {	
        	readen = ReadEn(sockdata,30);
            /*接受数据超时*/
        	if(readen<1)
            {
        		close(sockdata);
        		sleep(2);
        		pthread_mutex_lock(&(pDloadInfo->lock));
        		    s_info->booldown=0;
        		    s_info->allowotherdown=0;
        		pthread_mutex_unlock(&(pDloadInfo->lock));
        		DownLoadFtp(pCreatThread);
        		return 0;
    	    }
    	
            pthread_mutex_lock(&(pDloadInfo->lock));
            	if(s_info->booldown==0){
            		s_info->booldown=1;
            		s_info->allowotherdown=0;
            	}
            	else if(s_info->allowotherdown == 1)
                    return 0;//this means the other thread is downloading its part
            pthread_mutex_unlock(&(pDloadInfo->lock));
            
        	boolprint++;
    	    if(boolprint==10)
                boolprint=0;
        
    	    if(bytesleft>=1024)
            {
        		bytesget=recv(sockdata,buf,1024,MSG_DONTWAIT);
        		if(bytesget<0)
                {
            		close(sockdata);
            		close(s_info->fd);
            		pthread_mutex_lock(&(pDloadInfo->lock));
            		s_info->booldown=0;
            		s_info->allowotherdown=0;
                			pthread_mutex_unlock(&(pDloadInfo->lock));
            		DownLoadFtp(pCreatThread);
            		return 0;	
        	    }
        		write(s_info->fd,buf,bytesget);
          		bytesleft-=bytesget;
          		offset+=bytesget;
        	    s_info->a1+=bytesget;
                pthread_mutex_lock(&(pDloadInfo->lock));
          		pTmpFileInfo->sizeget+=bytesget;
                pthread_mutex_unlock(&(pDloadInfo->lock));
        	}
      	    else
            {
        		bytesget=recv(sockdata,buf,bytesleft,MSG_DONTWAIT);
          		if(bytesget<0)
                {
            		//s_info->a1+=offset;
            		close(sockdata);
            		close(s_info->fd);
            		pthread_mutex_lock(&(pDloadInfo->lock));
            		s_info->booldown=0;
            		s_info->allowotherdown=0;
    			    pthread_mutex_unlock(&(pDloadInfo->lock));
            		DownLoadFtp(pCreatThread);
            		return 0;	
    	        }
                
                write(s_info->fd,buf,bytesget);
                bytesleft-=bytesget;
                offset+=bytesget;
                s_info->a1+=bytesget;
                pthread_mutex_lock(&(pDloadInfo->lock));
          		pTmpFileInfo->sizeget+=bytesget;
                pthread_mutex_unlock(&(pDloadInfo->lock));
          		
                
                /*如果后面的线程未开始下载，下载下一个线程负责的数据*/
        		if(bytesleft<1024)
                {
        			nextthread++;
        		    if(pTmpFileInfo->astPthread[s_info->threadnumber+nextthread].booldown==0
                            &&pTmpFileInfo->astPthread[s_info->threadnumber+nextthread].allowotherdown==1)
                        {
                			pthread_mutex_lock(&(pDloadInfo->lock));
            			    pTmpFileInfo->astPthread[s_info->threadnumber+nextthread].booldown=1;
                			pthread_mutex_unlock(&(pDloadInfo->lock));
            			    bytesleft+=pTmpFileInfo->astPthread[s_info->threadnumber+nextthread].a2
                                -pTmpFileInfo->astPthread[s_info->threadnumber+nextthread].a1+1;
            			    s_info->a2=pTmpFileInfo->astPthread[s_info->threadnumber+nextthread].a2;
        		        }       
        		}
          	}
    	
        	if(boolprint==0){
                char filestat[256];
        		pthread_mutex_lock(&(pDloadInfo->lock));
                /* likun 保存路径，多久保留一次?*/
                strncpy(filestat, pDloadInfo->FileInfo.filename, 256);
                strcat(filestat, ".ftpbrfile");
        		SaveThreadStat(pTmpFileInfo, filestat);
        		pthread_mutex_unlock(&(pDloadInfo->lock));
                printprocess(pTmpFileInfo->sizeget,pTmpFileInfo->filelength);
        	}

	        memset(buf, 0, 1024);
        }
        if(0==bytesleft)
            s_info->boolend = 1;
        free(pCreatThread);
        close(sock);
        close(sockdata);
        return 0;
    }
    else
    {
        pDloadInfo->bTaskExit = FTPHTTP_UNREACH;
        free(pCreatThread);
        return -1;
    }
}

int GetFtpData(FtpHttpDLoadInfo *pDloadInfo)
{
    char head[256];
    char headhost[256];
    char dataget[512];
    int threadsize=0;
    int i_sock,i;
    pthread_t thrd[30];
    float timeuse;
    DLoadFileInfo *pFileInfo;
    int ret;

    if(!pDloadInfo)
    {
        return -1;
    }
    
    pFileInfo = &(pDloadInfo->FileInfo);
    threadsize = GetThreadSize(pFileInfo);
    gettimeofday(&(pDloadInfo->tpstart),NULL);
    pDloadInfo->TotalLastGet = pFileInfo->sizeget;
    for(i=0;i<=(pFileInfo->nthread)-1;i++)
    {
        /*likun*/
        DloadForCreatThread *pCreatThread;
        pCreatThread = malloc(sizeof(DloadForCreatThread));

        memset(pCreatThread, 0, sizeof(DloadForCreatThread));
    	if(FALSE==pDloadInfo->bBreakPoint)
        {
            /*resume*/
    		pthread_mutex_lock(&(pDloadInfo->lock));		
        		pFileInfo->astPthread[i].booldown = 0;
                pFileInfo->astPthread[i].allowotherdown=1; 
                pFileInfo->astPthread[i].boolend=0;
     		pthread_mutex_unlock(&(pDloadInfo->lock));
            
    		pFileInfo->astPthread[i].threadnumber = i ;
           	pFileInfo->astPthread[i].a1 = threadsize*i;
        	pFileInfo->astPthread[i].a2 = pFileInfo->astPthread[i].a1 + threadsize-1;
    		if(i == (pFileInfo->nthread - 1)) //last thread
                pFileInfo->astPthread[i].a2 = pFileInfo->filelength - 1;
    		pFileInfo->astPthread[i].bytesleft = 
                pFileInfo->astPthread[i].a2-pFileInfo->astPthread[i].a1+1;
        }
        else
        {
            /*likun*/
    		if(pFileInfo->astPthread[i].boolend == 1)
                pFileInfo->astPthread[i].booldown = 1;
    		else 
                pFileInfo->astPthread[i].booldown=0;
    		    //g[i].allowotherdown=0;
    	
    	}

        pCreatThread->pInfo = pDloadInfo;
        pCreatThread->threadId = i;
        ret = pthread_create(&thrd[i],NULL,(void*)DownLoadFtp,(void*)pCreatThread);
    }

    for(i=0;i<=(pFileInfo->nthread-1);i++)
        pthread_join(thrd[i],NULL);
    
    /*下载完成退出*/
    if(FTPHTTP_NORMAL == pDloadInfo->bTaskExit)
    {
        char filestat[256];
        Ftp_Debug("Finish Task: %s dataget: %d\r\n",pFileInfo->filename,pFileInfo->sizeget);
        pDloadInfo->fnFinish(&pDloadInfo);
        /*删除断点文件*/        
        strncpy(filestat, pDloadInfo->FileInfo.filename, 256);
        strcat(filestat, ".ftpbrfile");
        unlink(filestat);

    }
    else if(FTPHTTP_DEL == pDloadInfo->bTaskExit)
    {
        Ftp_Debug("Delete Task: %s dataget: %d\r\n",pFileInfo->filename,pFileInfo->sizeget);
    }
    else if(FTPHTTP_PAUSE == pDloadInfo->bTaskExit)
    {
        Ftp_Debug("Pause Task: %s dataget: %d\r\n",pFileInfo->filename,pFileInfo->sizeget);
    }
    else
    {
        Ftp_Debug("Unknown Cause\r\n");
    }
    gettimeofday(&(pDloadInfo->tpend),NULL);
    return 0;
}

int FtpStartATask(FtpHttpDLoadInfo *pDloadInfo)
{
    pthread_t thrd;
    pthread_attr_t attr;
    if(!pDloadInfo)
        return -1;
    
    pthread_attr_init(&attr);
    pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
    pthread_create(&thrd, &attr, (void *)GetFtpData, (void*)pDloadInfo);
    return 0;    
}

int FtpInitFileInfoFromFile(HDLProtocolHandle *phProtocolHandle, const char *file)
{
    FtpHttpDLoadInfo *pTmp = NULL;
    pTmp = (FtpHttpDLoadInfo *)malloc(sizeof(FtpHttpDLoadInfo));
    if(!pTmp)
        return -1;

    memset(pTmp, 0, sizeof(FtpHttpDLoadInfo));
    GetThreadStat(&(pTmp->FileInfo),file);
    pTmp->bBreakPoint = TRUE;
    pTmp->bTaskExit = FTPHTTP_NORMAL;
    pthread_mutex_init(&(pTmp->lock), NULL);

    *phProtocolHandle = pTmp;
    return 0;
}

int FtpInitFileInfoFromUrl(HDLProtocolHandle *phProtocolHandle, DLoadUrlInfo *pUrlInfo)
{
    FtpHttpDLoadInfo *pTmp = NULL;

    if(!pUrlInfo)
        return -1;
    pTmp = (FtpHttpDLoadInfo *)malloc(sizeof(FtpHttpDLoadInfo));
    if(!pTmp)
        return -1;
    memset(pTmp, 0, sizeof(FtpHttpDLoadInfo));
    
    pTmp->bBreakPoint = FALSE;
    pTmp->bTaskExit = FTPHTTP_NORMAL;    
    pTmp->FileInfo.nthread = pUrlInfo->threadNum;
    pthread_mutex_init(&(pTmp->lock), NULL);
    strncpy(pTmp->FileInfo.localpath, pUrlInfo->FilePath,
                    sizeof(pTmp->FileInfo.localpath));
    pTmp->FileInfo.ftpPort = 21;    
    pTmp->FileInfo.sizeget = 0;
    Ftp_Debug("Url: %s, User:%s, pass:%s,path:%s",
        pUrlInfo->DownloadUrl, pUrlInfo->Account,pUrlInfo->Password,pUrlInfo->FilePath);
    strncpy(pTmp->FileInfo.user, "anonymous",
                sizeof(pTmp->FileInfo.user));
    strncpy(pTmp->FileInfo.pass, "123456",
                sizeof(pTmp->FileInfo.pass));

    if(-1==GetFtpUrlInfo(pUrlInfo->DownloadUrl,&(pTmp->FileInfo)))
    {
        free(pTmp);
        return -1;
    }
    
    Ftp_Debug("Url: %s, User:%s, pass:%s,path:%s",
        pUrlInfo->DownloadUrl, pUrlInfo->Account,pUrlInfo->Password,pUrlInfo->FilePath);
    /*likun,对空间的判断*/
    strcat(pTmp->FileInfo.localpath, pTmp->FileInfo.filename);

    *phProtocolHandle = pTmp;
    return 0;
}

int FtpUnInitFileInfoFromUrl(HDLProtocolHandle phProtocolHandle)
{
    FtpHttpDLoadInfo *pTmp = NULL;
    if(!phProtocolHandle)
        return -1;
    pTmp = (FtpHttpDLoadInfo *)phProtocolHandle;
    free(pTmp);
    pTmp = NULL;
    return 0;
}


int FtpStartTask(HDLProtocolHandle hProtocolHandle)
{
    FtpHttpDLoadInfo *pDloadInfo = NULL;
    if(!hProtocolHandle)
        return -1;
    
    pDloadInfo = (FtpHttpDLoadInfo *)hProtocolHandle;
    return FtpStartATask(pDloadInfo);
}

int FtpPauseTask(HDLProtocolHandle hProtocolHandle)
{
    FtpHttpDLoadInfo *pDloadInfo = NULL;
    if(!hProtocolHandle)
        return -1;
    pDloadInfo = (FtpHttpDLoadInfo *)hProtocolHandle;
    pDloadInfo->bTaskExit = FTPHTTP_PAUSE;
    //pDloadInfo->FileInfo.sizeget = 0;
    Ftp_Debug("pDloadInfo->bTaskExit: %d", pDloadInfo->bTaskExit);
    return 0;
}

int FtpResumeTask(HDLProtocolHandle hProtocolHandle)
{
    FtpHttpDLoadInfo *pDloadInfo = NULL;
    if(!hProtocolHandle)
        return -1;    
    pDloadInfo = (FtpHttpDLoadInfo *)hProtocolHandle;
    pDloadInfo->bTaskExit = FTPHTTP_NORMAL;
    pDloadInfo->bBreakPoint = TRUE;
    return FtpStartATask(pDloadInfo);
}

int FtpDelTask(HDLProtocolHandle hProtocolHandle)
{
    FtpHttpDLoadInfo *pDloadInfo = NULL;
    if(!hProtocolHandle)
        return -1;
    pDloadInfo = (FtpHttpDLoadInfo *)hProtocolHandle;
    pDloadInfo->bTaskExit = FTPHTTP_DEL;
    /*likun 删除文件*/
    
    return 0;
}

/*likun, 其它几项需要在上层赋值*/
int FtpGetTaskInfo(HDLProtocolHandle hProtocolHandle, DLoadTaskPubInfo *pDloadTaskPub)
{
    FtpHttpDLoadInfo *pDloadFileInfo = NULL;
    unsigned long timeuse;

    if(!hProtocolHandle || !pDloadTaskPub)
        return -1;

    pDloadFileInfo = (FtpHttpDLoadInfo *)hProtocolHandle;
    strncpy(pDloadTaskPub->acFileName, pDloadFileInfo->FileInfo.filename, sizeof(pDloadTaskPub->acFileName));
    pDloadTaskPub->FileSize = pDloadFileInfo->FileInfo.filelength;
    pDloadTaskPub->SizeGet = pDloadFileInfo->FileInfo.sizeget;
    pDloadTaskPub->scale = (float)(pDloadFileInfo->FileInfo.sizeget)/(float)(pDloadFileInfo->FileInfo.filelength);
    gettimeofday(&pDloadFileInfo->tpend,NULL);
    timeuse=1000000*(pDloadFileInfo->tpend.tv_sec-pDloadFileInfo->tpstart.tv_sec) 
            + pDloadFileInfo->tpend.tv_usec-pDloadFileInfo->tpstart.tv_usec;
    timeuse/=1000000;
    pDloadTaskPub->rate = (float)(pDloadFileInfo->FileInfo.sizeget-pDloadFileInfo->TotalLastGet)/(float)(1000*(float)timeuse);

    return 0;
}


int FtpRegFinishCallback(HDLProtocolHandle hProtocolHandle, int (*fnDLoadFinish)(void *))
{
    FtpHttpDLoadInfo *pDloadFileInfo = NULL;

    if(!hProtocolHandle)
        return -1;
    pDloadFileInfo = (FtpHttpDLoadInfo *)hProtocolHandle;
    pDloadFileInfo->fnFinish = fnDLoadFinish;

    return 0;
}

int FtpSerUserPasswd(HDLProtocolHandle hProtocolHandle, char *UserName, char *PassWd)
{
    FtpHttpDLoadInfo *pDloadFileInfo = NULL;
    if(!hProtocolHandle)
        return -1;

    pDloadFileInfo = (FtpHttpDLoadInfo *)hProtocolHandle;
    if(!UserName || !PassWd)
    {
        strncpy(pDloadFileInfo->FileInfo.user, "anonymous",
                    sizeof(pDloadFileInfo->FileInfo.user));
        strncpy(pDloadFileInfo->FileInfo.pass, "123456",
                    sizeof(pDloadFileInfo->FileInfo.pass));
    }
    else
    {
        strncpy(pDloadFileInfo->FileInfo.user, UserName,
                    sizeof(pDloadFileInfo->FileInfo.user));
        strncpy(pDloadFileInfo->FileInfo.pass, PassWd,
                    sizeof(pDloadFileInfo->FileInfo.pass));
    }
    return 0;
}

#ifdef _cplusplus
}
#endif