downfromhttp.c

linux下http和ftp下载工具

    			
          		}
          		else
                {
        			bytesget=recv(sock,buf,bytesleft,0);
                    if(bytesget==0)
                        boolbyte++;
          			if(bytesget<0||(bytesget==0&&boolbyte>=10))
                    {
        				close(sock);
        				close(s_info->fd);
        				pthread_mutex_lock(&(pDloadInfo->lock));
        				s_info->booldown=0;
        				s_info->allowotherdown=0;
        				pthread_mutex_unlock(&(pDloadInfo->lock));
        				DownLoadHttp(pCreatThread);
        				return 0;	
        			}
          			write(s_info->fd,buf,bytesget);
          			offset+=bytesget;
                    pthread_mutex_lock(&(pDloadInfo->lock));
          			pTmpFileInfo->sizeget+=bytesget;
                    pthread_mutex_unlock(&(pDloadInfo->lock));
    			    s_info->a1+=bytesget;
          			bytesleft-=bytesget;
    	
            		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;
                        }       
    		         }
    		    }
                memset(buf, 0, 1024);
    	    }
      	    if(boolprint==0)
            {   
            /*likun 断点续传文件的生成方式需要考虑*/
                char filestat[256];
        		pthread_mutex_lock(&(pDloadInfo->lock));
                strncpy(filestat, pDloadInfo->FileInfo.filename, 256);
                strcat(filestat, ".httpbrfile");
                SaveThreadStat(pTmpFileInfo, filestat);
        		pthread_mutex_unlock(&(pDloadInfo->lock));
                printprocess(pTmpFileInfo->sizeget,pTmpFileInfo->filelength);
        	}
        }
        if(0==bytesleft)
            s_info->boolend = 1;
        free(pCreatThread);
	    close(sock);
        return 0;
    }
    else {
        return -1;
    }
}

int GetHttpData(FtpHttpDLoadInfo *pDloadInfo)
{
    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++)
    {
        DloadForCreatThread *pCreatThread;
        pCreatThread = malloc(sizeof(DloadForCreatThread));
        memset(pCreatThread, 0, sizeof(DloadForCreatThread));
    	if(FALSE==pDloadInfo->bBreakPoint){
    		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))pFileInfo->astPthread[i].a2=pFileInfo->filelength-1;
    		pFileInfo->astPthread[i].bytesleft=pFileInfo->astPthread[i].a2-pFileInfo->astPthread[i].a1+1;

    	}
        else{
    		if(pFileInfo->astPthread[i].boolend==1)
            {      
                pFileInfo->astPthread[i].booldown=1;
              }
    		else 
            {      
                pFileInfo->astPthread[i].booldown=0;
            }
    	}

        pCreatThread->pInfo = pDloadInfo;
        pCreatThread->threadId = i;
        ret = pthread_create(&thrd[i],NULL,(void*)DownLoadHttp,(void*)pCreatThread);
    }
    
    for(i=0;i<=(pFileInfo->nthread)-1;i++)
        pthread_join(thrd[i],NULL);

    /*下载完成退出*/
    if(FTPHTTP_NORMAL == pDloadInfo->bTaskExit)
    {
        char filestat[256];
        fprintf(stderr,"\r\nFinish Task: %s\r\n",pFileInfo->filename);
        /*likun test*/
        pDloadInfo->FileInfo.sizeget = pDloadInfo->FileInfo.filelength;
        pDloadInfo->fnFinish(&pDloadInfo);
        /*删除断点文件*/        
        strncpy(filestat, pDloadInfo->FileInfo.filename, 256);
        strcat(filestat, ".httpbrfile");
        unlink(filestat);
    }
    else if(FTPHTTP_DEL == pDloadInfo->bTaskExit)
    {
        fprintf(stderr,"\r\nDelete Task: %s\r\n",pFileInfo->filename);
    }
    else if(FTPHTTP_PAUSE== pDloadInfo->bTaskExit)
    {
        fprintf(stderr,"\r\nPause Task: %s\r\n",pFileInfo->filename);
    }
    else
    {
        fprintf(stderr,"\r\nUnknown Cause\r\n");
    }
    gettimeofday(&(pDloadInfo->tpend),NULL);
    return 0;
    
}

/*likun, 修改*/
int HttpStartATask(FtpHttpDLoadInfo *pDloadInfo)
{
    int ret;
    pthread_t thrd;
    pthread_attr_t attr;
    if(!pDloadInfo)
        return -1;
    
    pthread_attr_init(&attr);
    pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
    ret = pthread_create(&thrd, &attr, (void *)GetHttpData, (void*)pDloadInfo);
    return ret;    
}


int HttpInitFileInfoFromFile(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;
}

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

    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.httpPort = 80;
    pTmp->FileInfo.sizeget = 0;
    if(-1==GetHttpUrlInfo(pUrlInfo->DownloadUrl, NULL,&(pTmp->FileInfo)))
    {
        fprintf(stderr, "\r\nBreak point %s, %d", __FILE__,__LINE__);
        return -1;    
    }
    /*likun,对空间的判断*/
    strcat(pTmp->FileInfo.localpath, pTmp->FileInfo.filename);
    *phProtocolHandle = pTmp;
    return 0;
}

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

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

int HttpPauseTask(HDLProtocolHandle hProtocolHandle)
{
    FtpHttpDLoadInfo *pDloadInfo = NULL;
    if(!hProtocolHandle)
        return -1;
    pDloadInfo = (FtpHttpDLoadInfo *)hProtocolHandle;
    pDloadInfo->bTaskExit = FTPHTTP_PAUSE;
    fprintf(stderr,"\r\npDloadInfo->bTaskExit: %d", pDloadInfo->bTaskExit);
    return 0;
}

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

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

/*likun, 其它几项需要在上层赋值*/
int HttpGetTaskInfo(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 HttpRegFinishCallback(HDLProtocolHandle hProtocolHandle, int (*fnDLoadFinish)(void *))
{
    FtpHttpDLoadInfo *pDloadFileInfo = NULL;

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

    return 0;
}

#ifdef _cplusplus
}
#endif