dload.c

linux下http和ftp下载工具

        case DLOAD_ASYN_DLOAD_CTRLCMD:
        {
            THListNode *pstTmpNode = NULL;
            DLoadMsgCtrCmd *pMsgTmp = (DLoadMsgCtrCmd *)pMsg;
            DLoadTaskHandle HTaskHandle = pMsgTmp->hTaskHandle;
            DLoadCtrCmd ctrlcmd = pMsgTmp->cmd;
            pstTmpNode = HList_Find(&g_DLoadList, 
                        &HTaskHandle,fnFindTaskByHandle);
            
            DLOAD_PRINT("Break point, pstTmpNode: %d, HTaskHandle: %d, CtrCmd: %d", pstTmpNode,HTaskHandle,ctrlcmd);
            if(pstTmpNode)
            {
                DLoadTaskPrivateInfo *pTmpTaskInfo = 
                        (DLoadTaskPrivateInfo *)pstTmpNode->pUserData;
                switch(ctrlcmd)
                {
                    case DLOAD_CMD_START:                        
                        if(DLOAD_STAT_DOING != pTmpTaskInfo->CurStat)
                        {
                            if(g_DLoadTaskNum < DLOAD_MAX_TASK)
                            {
                                pTmpTaskInfo->fnPlug.fnStartTask(pTmpTaskInfo->pProtocolInfo);
                                pTmpTaskInfo->CurStat = DLOAD_STAT_DOING;
                                g_DLoadTaskNum++;
                            }
                            else
                                pTmpTaskInfo->CurStat = DLOAD_STAT_WAIT;
                        }
                        break;
                    case DLOAD_CMD_PAUSE:
                        pTmpTaskInfo->fnPlug.fnPauseTask(pTmpTaskInfo->pProtocolInfo);
                        pTmpTaskInfo->CurStat = DLOAD_STAT_PAUSE;
                        g_DLoadTaskNum--;
                        DLoadStartWaitTask();
                        break;
                    case DLOAD_CMD_RESUME:
                        if(DLOAD_STAT_DOING != pTmpTaskInfo->CurStat)
                        {
                            if(g_DLoadTaskNum < DLOAD_MAX_TASK)
                            {
                                pTmpTaskInfo->fnPlug.fnResumeTask(pTmpTaskInfo->pProtocolInfo);
                                pTmpTaskInfo->CurStat = DLOAD_STAT_DOING;
                                g_DLoadTaskNum++;
                            }
                            else
                                pTmpTaskInfo->CurStat = DLOAD_STAT_WAIT;
                        }
                        break;
                    case DLOAD_CMD_DEL:
                        pTmpTaskInfo->fnPlug.fnDelTask(pTmpTaskInfo->pProtocolInfo);
                        /* likun 删除已经下载的文件、记录下载信息的文件*/
                        g_DLoadTaskNum--;
                        DLoadStartWaitTask();
                        break;
                    default:
                        break;
                }
            }
            
            break;
        }
        /*增加下载任务，只是向下载任务队列里增加该下载任务信息
        此时并不开始下载任务，该下载任务此时状态为"暂停" */
        case DLOAD_SYNC_DLOAD_ADDTASK:
        {
            /* likun 需要修改增加下载任务的结构体，增加与服务器交互*/
            char *pcUrl = NULL;
            DLoadTaskPrivateInfo *pTaskInfo = NULL;
            THListNode *pstTmpNode = NULL;
            DLoadUrlInfo UrlInfo;
            DLoadMsgAddATask *pMsgTmp = (DLoadMsgAddATask *)pMsg;

            DLoadGetFileInfoByFileID(&(pMsgTmp->stNewTask), &UrlInfo);
            DLOAD_PRINT("Protocol: %d, ThreadNum: %d, FilePath: %s, Url: %s Account: %s, PassWd: %s", 
                        UrlInfo.protocolType, UrlInfo.threadNum, UrlInfo.FilePath, UrlInfo.DownloadUrl,UrlInfo.Account, UrlInfo.Password);
            pTaskInfo = malloc(sizeof(DLoadTaskPrivateInfo));
            if(!pTaskInfo)
                return -1;
            memset(pTaskInfo, 0, sizeof(DLoadTaskPrivateInfo));
            if(-1 == DLoadAddANewTask(&UrlInfo, pTaskInfo))
            {
                free(pTaskInfo);
                return -1;
            }

            pstTmpNode = (THListNode *)malloc(sizeof(THListNode));
            if(!pstTmpNode){
                free(pTaskInfo);
                return -1;
            }
            memset(pstTmpNode, 0, sizeof(THListNode));
            pstTmpNode->pUserData = pTaskInfo;
            HList_AddTail(&g_DLoadList, pstTmpNode);
            /* likun 调用开始下载的接口*/
            DLoadStarTask(pTaskInfo->hDloadTaskHandle);
            break;
        }
        case DLOAD_SYNC_DLOAD_ADDTASK_TEST:
        {
            /* likun 需要修改增加下载任务的结构体，增加与服务器交互*/
            char *pcUrl = NULL;
            DLoadTaskPrivateInfo *pTaskInfo = NULL;
            THListNode *pstTmpNode = NULL;
            DLoadUrlInfo UrlInfo;
            DLoadMsgAddATaskTest *pMsgTmp = (DLoadMsgAddATaskTest *)pMsg;

            UrlInfo.protocolType =  DLoadParseProtocol(pMsgTmp->url);
            UrlInfo.threadNum = 10;        
            strcpy(UrlInfo.DownloadUrl,pMsgTmp->url);
            strcpy(UrlInfo.FilePath, "/mnt/film/");
            
            //DLoadGetFileInfoByFileID(&(pMsgTmp->stNewTask), &UrlInfo);
            DLOAD_PRINT("Protocol: %d, ThreadNum: %d, FilePath: %s, Url: %s Account: %s, PassWd: %s", 
                        UrlInfo.protocolType, UrlInfo.threadNum, UrlInfo.FilePath, UrlInfo.DownloadUrl,UrlInfo.Account, UrlInfo.Password);
            pTaskInfo = malloc(sizeof(DLoadTaskPrivateInfo));
            if(!pTaskInfo)
                return -1;
            memset(pTaskInfo, 0, sizeof(DLoadTaskPrivateInfo));
            if(-1==DLoadAddANewTask(&UrlInfo, pTaskInfo))
            {
                free(pTaskInfo);
                return -1;
            }
            pstTmpNode = (THListNode *)malloc(sizeof(THListNode));
            if(!pstTmpNode){
                free(pTaskInfo);
                return -1;
            }
            memset(pstTmpNode, 0, sizeof(THListNode));
            pstTmpNode->pUserData = pTaskInfo;
            HList_AddTail(&g_DLoadList, pstTmpNode);
            /* likun 调用开始下载的接口*/
            DLoadStarTask(pTaskInfo->hDloadTaskHandle);
            break;

        }
        case DLOAD_SYNC_DLOAD_GETFIRSTTASK_INFO:
        {
            int ret;
            THListNode *pstTmpNode = NULL;
            DLoadMsgGetInfo *pMsgTmp = (DLoadMsgGetInfo *)pMsg;
            DLoadTaskHandle HTaskHandle = pMsgTmp->hTaskHandle;
            DLoadMsgTaskPubInfo reqPubInfo;
            DLoadTaskPrivateInfo *privateInfo = NULL;
            pstTmpNode = HList_GetHead(&g_DLoadList);
            memset(&reqPubInfo, 0, sizeof(DLoadMsgTaskPubInfo));
            if(!pstTmpNode)
            {
                reqPubInfo.pubInfo.RetCode = -1;
            }
            else
            {
                privateInfo = (DLoadTaskPrivateInfo *)pstTmpNode->pUserData;
                privateInfo->fnPlug.fnGetTaskInfo(privateInfo->pProtocolInfo,
                                &(reqPubInfo.pubInfo));
                reqPubInfo.pubInfo.CurStat = privateInfo->CurStat;
                if(DLOAD_STAT_DOING!=reqPubInfo.pubInfo.CurStat)
                    reqPubInfo.pubInfo.rate = 0;
                reqPubInfo.pubInfo.RetCode = 0;
                reqPubInfo.pubInfo.hDloadTask = privateInfo->hDloadTaskHandle;
            }
            ret = HOS_MsgReply(NULL, pMsg, (TMsg *)&reqPubInfo, sizeof(DLoadMsgTaskPubInfo));
            break;
        }
        case DLOAD_SYNC_DLOAD_GETTASK_INFO_BYHANDLE:
        {
            THListNode *pstTmpNode = NULL;
            DLoadMsgGetInfo *pMsgTmp = (DLoadMsgGetInfo *)pMsg;
            DLoadTaskHandle HTaskHandle = pMsgTmp->hTaskHandle;
            DLoadMsgTaskPubInfo reqPubInfo;
            DLoadTaskPrivateInfo *privateInfo = NULL;
            pstTmpNode = HList_Find(&g_DLoadList, 
                &HTaskHandle,fnFindTaskByHandle);
            if(!pstTmpNode)
                return -1;

            memset(&reqPubInfo, 0, sizeof(DLoadMsgTaskPubInfo));
            privateInfo = (DLoadTaskPrivateInfo *)pstTmpNode->pUserData;
            privateInfo->fnPlug.fnGetTaskInfo(privateInfo->pProtocolInfo,
                            &(reqPubInfo.pubInfo));
            reqPubInfo.pubInfo.CurStat = privateInfo->CurStat;
            if(DLOAD_STAT_DOING!=reqPubInfo.pubInfo.CurStat)
                reqPubInfo.pubInfo.rate = 0;
            reqPubInfo.pubInfo.hDloadTask = privateInfo->hDloadTaskHandle;
            
            HOS_MsgReply(NULL, pMsg, (TMsg *)&reqPubInfo, sizeof(DLoadMsgTaskPubInfo));
            break;
        }    
        case DLOAD_SYNC_DLOAD_GETNEXTTASK_INFO_BYHANDLE:
        {
            THListNode *pstTmpNode = NULL;
            THListNode *pstTmpNextNode = NULL;
            DLoadMsgGetInfo *pMsgTmp = (DLoadMsgGetInfo *)pMsg;
            DLoadTaskHandle HTaskHandle = pMsgTmp->hTaskHandle;
            DLoadMsgTaskPubInfo reqPubInfo;
            DLoadTaskPrivateInfo *privateInfo = NULL;

            memset(&reqPubInfo, 0, sizeof(DLoadMsgTaskPubInfo));
            pstTmpNode = HList_Find(&g_DLoadList, 
                &HTaskHandle,fnFindTaskByHandle);
            if(!pstTmpNode)
                return -1;
            pstTmpNextNode = HList_GetNext(&g_DLoadList, pstTmpNode);
            if(!pstTmpNextNode)
            {
                reqPubInfo.pubInfo.RetCode = -1;
            }
            else
            {
                privateInfo = (DLoadTaskPrivateInfo *)pstTmpNextNode->pUserData;
                privateInfo->fnPlug.fnGetTaskInfo(privateInfo->pProtocolInfo,
                                &(reqPubInfo.pubInfo));
                reqPubInfo.pubInfo.CurStat = privateInfo->CurStat;
                if(DLOAD_STAT_DOING!=reqPubInfo.pubInfo.CurStat)
                    reqPubInfo.pubInfo.rate = 0;
                reqPubInfo.pubInfo.hDloadTask = privateInfo->hDloadTaskHandle;
                reqPubInfo.pubInfo.RetCode = 0;
            }
            HOS_MsgReply(NULL, pMsg, (TMsg *)&reqPubInfo, sizeof(DLoadMsgTaskPubInfo));
            break;
        }
        case DLOAD_SYNC_DLOAD_GET_TASKNUM:
        {
            DLoadMsgTaskNum reqTaskNum;

            memset(&reqTaskNum, 0, sizeof(DLoadMsgTaskNum));
            reqTaskNum.taskNum = g_DLoadList.ulCount;
            HOS_MsgReply(NULL, pMsg, (TMsg *)&reqTaskNum, sizeof(DLoadMsgTaskNum));
            break;
        }
        default:
            break;
    }

    return 0;
}

int DLoadAddANewTask(DLoadUrlInfo *pUrlInfo, DLoadTaskPrivateInfo *pTaskInfo)
{
    DLOAD_PROTOCOL hosttype;
    char *url = NULL;
    int lRet = 0;
    if(!pTaskInfo || !pUrlInfo)
        return -1;
    
    //hosttype = DLoadParseProtocol(url);
    /*likun,默认线程数*/
    if(0==pUrlInfo->threadNum)
        pUrlInfo->threadNum = DLOAD_MAX_TREADNUM;
    hosttype = (DLOAD_PROTOCOL)pUrlInfo->protocolType;
    url = pUrlInfo->DownloadUrl;
    /*likun 增加对URL的判断*/
    strncpy(pTaskInfo->url, pUrlInfo->DownloadUrl, sizeof(pTaskInfo->url));
    
    switch(hosttype)
    {
        case DLOAD_PROTOCOL_HTTP:
        {
            lRet = HttpInitFileInfoFromUrl(&(pTaskInfo->pProtocolInfo),pUrlInfo);
            if(0!=lRet)
            {
                DLOAD_PRINT("http init fileinfo failed");
            }
            HttpRegFinishCallback(pTaskInfo->pProtocolInfo, DLoadFinishNotify);
            HttpInitFnPlug(&(pTaskInfo->fnPlug));
            break;
        }
        case DLOAD_PROTOCOL_FTP:
        {
            FtpInitFileInfoFromUrl(&(pTaskInfo->pProtocolInfo),pUrlInfo);
            FtpRegFinishCallback(pTaskInfo->pProtocolInfo, DLoadFinishNotify);
            /*likun， url里面的和这个到底用哪个?*/
            //FtpSerUserPasswd(pTaskInfo->pProtocolInfo, pUrlInfo->Account,
            //                pUrlInfo->Password);
            FtpInitFnPlug(&(pTaskInfo->fnPlug));
            break;
        }
        case DLOAD_PROTOCOL_BT:
            DLOAD_PRINT("BT protocol current not be suppored");
            return -1;
        default:
            DLOAD_PRINT("this protocol current not be suppored");
            return -1;
    }
    pTaskInfo->hDloadTaskHandle = DLoadTaskHandleCreat();
    pTaskInfo->CurStat = DLOAD_STAT_WAIT;
    return 0;
}

DLoadTaskHandle DLoadTaskHandleCreat(void)
{
#define DLOAD_MAX_TASKHANDLE 4294967295
    static int itaskHandle = 0;
    if(itaskHandle < DLOAD_MAX_TASKHANDLE)
        itaskHandle++;
    else
        itaskHandle = 1;
    
    return itaskHandle;
}

DLOAD_PROTOCOL DLoadParseProtocol(const char *url)
{
    char *p;

    if(!url)
        return DLOAD_PROTOCOL_BULL;
    p = rindex(url, '.');
    if(p++){
        /*BT种子文件*/
        if(0==strncasecmp(p,"torrent", 7))
            return DLOAD_PROTOCOL_BT;
    }
    
    if(!strncasecmp(url,"http://",7))
        return DLOAD_PROTOCOL_HTTP;
    else if(!strncasecmp(url,"ftp://",6))
        return DLOAD_PROTOCOL_FTP;
	else{
        fprintf(stderr,"\r\nCurrent not Support");
        return DLOAD_PROTOCOL_BULL;
    }
}

int FtpInitFnPlug(fnDLoadPlug *fn)    
{
    fn->fnDelTask = FtpDelTask;
    //fn->fnFinishTask = FtpRegFinishCallback;
    fn->fnGetTaskInfo = FtpGetTaskInfo;
    fn->fnPauseTask = FtpPauseTask;
    fn->fnResumeTask = FtpResumeTask;
    fn->fnStartTask = FtpStartTask;
    fn->fnUninitProtocolInfo = FtpUnInitFileInfoFromUrl;
}

int HttpInitFnPlug(fnDLoadPlug *fn)    
{
    fn->fnDelTask = HttpDelTask;
    //fn->fnFinishTask = FtpRegFinishCallback;
    fn->fnGetTaskInfo = HttpGetTaskInfo;
    fn->fnPauseTask = HttpPauseTask;
    fn->fnResumeTask = HttpResumeTask;
    fn->fnStartTask = HttpStartTask;
    fn->fnUninitProtocolInfo = HttpUnInitFileInfoFromUrl;
}

/*likun*/
int DLoadFinishCallBack(void *para)
{

}


#ifdef _cplusplus
}
#endif