lwchsz

lwchsz

关注
发信
关注(28)粉丝(399)

libcurl 库的ftp上传和下载代码

昨天考虑好了IM传送图片的方式，用的是FTP做缓存来传递图片，以减少聊天服务器的压力，用的是libcurl库，自己下载了一个Server-U 服务器，下面是测试程序，上传和下载都跑通了，剩下的就是在程序中写逻辑来实现具体的功能了。

上传代码：

  1. //ftp上传实例  
  2. // 服务器地址：192.168.0.185 账号：spider 密码：spider  
  3. // 在服务器路径 a上建立一个a.txt ，本地文件是test.txt  
  4. // 命令行参数192.168.0.185 spider spider a a.txt D:/test.txt  
  5. //#include     
  6. //#include     
  7. //#include     
  8. //#include     
  9. //  
  10. //int debugFun(CURL* curl, curl_infotype type, char* str, size_t len, void* stream)    
  11. //{    
  12. //    //只打印CURLINFO_TEXT类型的信息   
  13. //    if(type == CURLINFO_TEXT)    
  14. //    {    
  15. //        fwrite(str, 1, len, (FILE*)stream);    
  16. //    }    
  17. //    return 0;  
  18. //}    
  19. //  
  20. //int main(int argc, char** argv)    
  21. //{    
  22. //    CURL* curl;    
  23. //    CURLcode res;    
  24. //    char errorBuf[CURL_ERROR_SIZE];    
  25. //    FILE *sendFile, *debugFile;    
  26. //    char ftpurl[256 + 1];    
  27. //    char usrpasswd[64 + 1];    
  28. //  
  29. //    curl_slist *slist=NULL;    
  30. //  
  31. //    if(argc != 7)    
  32. //    {    
  33. //        printf("Usage:\n\t./ftp ip username password ftpPath destFileName srcFile");    
  34. //        return -1;    
  35. //    }    
  36. //  
  37. //    //将相关的调试信息打印到dubugFile.txt中   
  38. //    if(NULL == (debugFile = fopen("debugFile.txt", "a+")))    
  39. //        return -1;    
  40. //  
  41. //    //打开ftp上传的源文件   
  42. //    if(NULL == (sendFile = fopen(argv[6], "r")))    
  43. //    {    
  44. //        fclose(debugFile);    
  45. //        return -1;    
  46. //    }    
  47. //  
  48. //    //获取需要发送文件的大小   
  49. //    fseek(sendFile, 0, SEEK_END);    
  50. //    int sendSize = ftell(sendFile);    
  51. //    if(sendSize   
  52. //    {    
  53. //        fclose(debugFile);    
  54. //        fclose(sendFile);    
  55. //        return -1;    
  56. //    }    
  57. //    fseek(sendFile, 0L, SEEK_SET);    
  58. //  
  59. //    if((res = curl_global_init(CURL_GLOBAL_ALL)) != 0)    
  60. //    {    
  61. //        fclose(debugFile);    
  62. //        fclose(sendFile);    
  63. //        return -1;    
  64. //    }    
  65. //    if((curl = curl_easy_init()) == NULL)    
  66. //    {    
  67. //        fclose(debugFile);    
  68. //        fclose(sendFile);    
  69. //        curl_global_cleanup();    
  70. //        return -1;    
  71. //    }    
  72. //  
  73. //    if(argv[4][strlen(argv[4]) - 1] != '/')    
  74. //        sprintf(ftpurl, "ftp://%s/%s/%s", argv[1], argv[4], argv[5]);    
  75. //    else   
  76. //        sprintf(ftpurl, "ftp://%s/%s%s", argv[1], argv[4], argv[5]);    
  77. //    curl_easy_setopt(curl, CURLOPT_URL, ftpurl);    
  78. //    //设置ftp上传url,组成如下的URL    
  79. //    //ftp://192.168.31.145//root/subdir/curl/testftp.txt    
  80. //  
  81. //    sprintf(usrpasswd, "%s:%s", argv[2], argv[3]);    
  82. //    curl_easy_setopt(curl, CURLOPT_USERPWD, usrpasswd);    
  83. //  
  84. //    curl_easy_setopt(curl, CURLOPT_VERBOSE, 1);    
  85. //    curl_easy_setopt(curl, CURLOPT_DEBUGDATA, debugFile);    
  86. //  
  87. //    curl_easy_setopt(curl, CURLOPT_READDATA, sendFile);    
  88. //    curl_easy_setopt(curl, CURLOPT_UPLOAD, 1);    
  89. //    curl_easy_setopt(curl, CURLOPT_INFILESIZE, sendSize);    
  90. //    curl_easy_setopt(curl, CURLOPT_FTP_CREATE_MISSING_DIRS, 1);    
  91. //  
  92. //    curl_easy_setopt(curl, CURLOPT_DEBUGFUNCTION, debugFun);    
  93. //  
  94. //    res = curl_easy_perform(curl);    
  95. //    if(0 != res)    
  96. //    {    
  97. //        fclose(sendFile);    
  98. //        fclose(debugFile);    
  99. //        curl_easy_cleanup(curl);    
  100. //        curl_global_cleanup();    
  101. //        return -1;    
  102. //    }    
  103. //  
  104. //    curl_easy_cleanup(curl);    
  105. //    fclose(sendFile);    
  106. //    fclose(debugFile);      
  107. //    curl_global_cleanup();    
  108. //    getchar();  
  109. //    return 0;       
  110. //}   

下载代码如下：


  1. //ftp下载实例  
  2. #include ;   
  3. #include ;   
  4. #include ;   
  5. #include ;   
  6.    
  7. struct FtpFile   //定义一个结构为了传递给my_fwrite函数.可用curl_easy_setopt的CURLOPT_WRITEDATA选项传递  
  8. {   
  9.         char *filename;   
  10.         FILE *stream;   
  11. };   
  12.    
  13. int my_fwrite(void *buffer, size_t size, size_t nmemb, void *stream)   
  14. {   
  15.         struct FtpFile *out=(struct FtpFile *)stream; // stream指针其实就是指向struct FtpFile ftpfile的  
  16.         if(out && !out->stream)   
  17.         {   
  18.                 out->stream=fopen(out->filename, "wb"); //没有这个流的话就创建一个名字是out->filename.   
  19.                 if(!out->stream)   
  20.                 return -1;   
  21.         }   
  22.         return fwrite(buffer, size, nmemb, out->stream);   
  23. }   
  24.    
  25. int main(int argc, char *argv[])   
  26. {   
  27.         CURL *curl;   
  28.         CURLcode res;    
  29.         struct FtpFile ftpfile={"D:/Success.txt",NULL}; //初始化一个FtpFile结构   
  30.         curl_global_init(CURL_GLOBAL_DEFAULT);   
  31.    
  32.         curl = curl_easy_init();   
  33.         if(curl)   
  34.         {   
  35.                 curl_easy_setopt(curl, CURLOPT_URL,"ftp://192.168.0.185/a/a.txt");    
  36.    
  37.                 curl_easy_setopt(curl, CURLOPT_USERPWD,"spider:spider");  
  38.                 curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, my_fwrite);   
  39.                 curl_easy_setopt(curl, CURLOPT_WRITEDATA, &ftpfile); //给相关函数的第四个参数传递一个结构体的指针  
  40.                 curl_easy_setopt(curl, CURLOPT_VERBOSE, TRUE);//CURLOPT_VERBOSE 这个选项很常用用来在屏幕上显示对服务器相关操作返回的信息  
  41.    
  42.                 res = curl_easy_perform(curl);   
  43.                 curl_easy_cleanup(curl);   
  44.    
  45.                 if(CURLE_OK != res)   
  46.                         fprintf(stderr, "curl told us %d\n", res);   
  47.         }   
  48.         if(ftpfile.stream)   
  49.         fclose(ftpfile.stream);   
  50.         curl_global_cleanup();   
  51.    
  52.         return 0;   
  53. }  

最后记录一个比较好用的：


  1. #include   
  2. #include   
  3. #include   
  4. #include   
  5. /* parse headers for Content-Length */  
  6. size_t getcontentlengthfunc(void *ptr, size_t size, size_t nmemb, void *stream)   
  7. {  
  8.     int r;  
  9.     long len = 0;  
  10.     /* _snscanf() is Win32 specific */  
  11.     //r = _snscanf(ptr, size * nmemb, "Content-Length: %ld\n", &len);  
  12.     r = sscanf((const char*)ptr, "Content-Length: %ld\n", &len);  
  13.     if (r) /* Microsoft: we don't read the specs */  
  14.         *((long *) stream) = len;  
  15.     return size * nmemb;  
  16. }  
  17. /* discard downloaded data */  
  18. size_t discardfunc(void *ptr, size_t size, size_t nmemb, void *stream)   
  19. {  
  20.     return size * nmemb;  
  21. }  
  22. //write data to upload  
  23. size_t writefunc(void *ptr, size_t size, size_t nmemb, void *stream)  
  24. {  
  25.     return fwrite(ptr, size, nmemb, (FILE*)stream);  
  26. }  
  27. /* read data to upload */  
  28. size_t readfunc(void *ptr, size_t size, size_t nmemb, void *stream)  
  29. {  
  30.     FILE *f = (FILE*)stream;  
  31.     size_t n;  
  32.     if (ferror(f))  
  33.         return CURL_READFUNC_ABORT;  
  34.     n = fread(ptr, size, nmemb, f) * size;  
  35.     return n;  
  36. }  
  37. int upload(CURL *curlhandle, const char * remotepath, const char * localpath, long timeout, long tries)  
  38. {  
  39.     FILE *f;  
  40.     long uploaded_len = 0;  
  41.     CURLcode r = CURLE_GOT_NOTHING;  
  42.     int c;  
  43.     f = fopen(localpath, "rb");  
  44.     if (f == NULL) {  
  45.         perror(NULL);  
  46.         return 0;  
  47.     }  
  48.     curl_easy_setopt(curlhandle, CURLOPT_UPLOAD, 1L);  
  49.     curl_easy_setopt(curlhandle, CURLOPT_URL, remotepath);  
  50.     curl_easy_setopt(curlhandle, CURLOPT_USERPWD, "spider:spider");     
  51.     if (timeout)  
  52.         curl_easy_setopt(curlhandle, CURLOPT_FTP_RESPONSE_TIMEOUT, timeout);  
  53.     curl_easy_setopt(curlhandle, CURLOPT_HEADERFUNCTION, getcontentlengthfunc);  
  54.     curl_easy_setopt(curlhandle, CURLOPT_HEADERDATA, &uploaded_len);  
  55.     curl_easy_setopt(curlhandle, CURLOPT_WRITEFUNCTION, discardfunc);  
  56.     curl_easy_setopt(curlhandle, CURLOPT_READFUNCTION, readfunc);  
  57.     curl_easy_setopt(curlhandle, CURLOPT_READDATA, f);  
  58.     curl_easy_setopt(curlhandle, CURLOPT_FTPPORT, "-"); /* disable passive mode */  
  59.     curl_easy_setopt(curlhandle, CURLOPT_FTP_CREATE_MISSING_DIRS, 1L);  
  60.     curl_easy_setopt(curlhandle, CURLOPT_VERBOSE, 1L);  
  61.     for (c = 0; (r != CURLE_OK) && (c 
  62.         /* are we resuming? */  
  63.         if (c) { /* yes */  
  64.             /* determine the length of the file already written */  
  65.             /* 
  66.             * With NOBODY and NOHEADER, libcurl will issue a SIZE 
  67.             * command, but the only way to retrieve the result is 
  68.             * to parse the returned Content-Length header. Thus, 
  69.             * getcontentlengthfunc(). We need discardfunc() above 
  70.             * because HEADER will dump the headers to stdout 
  71.             * without it. 
  72.             */  
  73.             curl_easy_setopt(curlhandle, CURLOPT_NOBODY, 1L);  
  74.             curl_easy_setopt(curlhandle, CURLOPT_HEADER, 1L);  
  75.             r = curl_easy_perform(curlhandle);  
  76.             if (r != CURLE_OK)  
  77.                 continue;  
  78.             curl_easy_setopt(curlhandle, CURLOPT_NOBODY, 0L);  
  79.             curl_easy_setopt(curlhandle, CURLOPT_HEADER, 0L);  
  80.             fseek(f, uploaded_len, SEEK_SET);  
  81.             curl_easy_setopt(curlhandle, CURLOPT_APPEND, 1L);  
  82.         }  
  83.         else { /* no */  
  84.             curl_easy_setopt(curlhandle, CURLOPT_APPEND, 0L);  
  85.         }  
  86.         r = curl_easy_perform(curlhandle);  
  87.     }  
  88.     fclose(f);  
  89.     if (r == CURLE_OK)  
  90.         return 1;  
  91.     else {  
  92.         fprintf(stderr, "%s\n", curl_easy_strerror(r));  
  93.         return 0;  
  94.     }  
  95. }  
  96. // 下载  
  97. int download(CURL *curlhandle, const char * remotepath, const char * localpath, long timeout, long tries)  
  98. {  
  99.     FILE *f;  
  100.     curl_off_t local_file_len = -1 ;  
  101.     long filesize =0 ;  
  102.     CURLcode r = CURLE_GOT_NOTHING;  
  103.     struct stat file_info;  
  104.     int use_resume = 0;  
  105.     //获取本地文件大小信息  
  106.     if(stat(localpath, &file_info) == 0)  
  107.     {  
  108.         local_file_len = file_info.st_size;   
  109.         use_resume = 1;  
  110.     }  
  111.     //追加方式打开文件，实现断点续传  
  112.     f = fopen(localpath, "ab+");  
  113.     if (f == NULL) {  
  114.         perror(NULL);  
  115.         return 0;  
  116.     }  
  117.     curl_easy_setopt(curlhandle, CURLOPT_URL, remotepath);  
  118.     curl_easy_setopt(curlhandle, CURLOPT_USERPWD, "spider:spider");     
  119.     //连接超时设置  
  120.     curl_easy_setopt(curlhandle, CURLOPT_CONNECTTIMEOUT, timeout);  
  121.     //设置头处理函数  
  122.     curl_easy_setopt(curlhandle, CURLOPT_HEADERFUNCTION, getcontentlengthfunc);  
  123.     curl_easy_setopt(curlhandle, CURLOPT_HEADERDATA, &filesize);  
  124.     // 设置断点续传  
  125.     curl_easy_setopt(curlhandle, CURLOPT_RESUME_FROM_LARGE, use_resume?local_file_len:0);  
  126.     curl_easy_setopt(curlhandle, CURLOPT_WRITEFUNCTION, writefunc);  
  127.     curl_easy_setopt(curlhandle, CURLOPT_WRITEDATA, f);  
  128.     curl_easy_setopt(curlhandle, CURLOPT_NOPROGRESS, 1L);  
  129.     curl_easy_setopt(curlhandle, CURLOPT_VERBOSE, 1L);  
  130.     r = curl_easy_perform(curlhandle);  
  131.     fclose(f);  
  132.     if (r == CURLE_OK)  
  133.         return 1;  
  134.     else {  
  135.         fprintf(stderr, "%s\n", curl_easy_strerror(r));  
  136.         return 0;  
  137.     }  
  138. }  
  139. int main(int c, char **argv)   
  140. {  
  141.     CURL *curlhandle = NULL;  
  142.     CURL *curldwn = NULL;  
  143.     curl_global_init(CURL_GLOBAL_ALL);  
  144.     curlhandle = curl_easy_init();  
  145.     curldwn = curl_easy_init();  
  146.     upload(curlhandle, "ftp://192.168.0.185/a/success", "D:/abc.jpg", 1, 3);  
  147.     download(curldwn, "ftp://192.168.0.185/a/success", "D:/abc1.jpg", 1, 3);  
  148.     curl_easy_cleanup(curlhandle);  
  149.     curl_easy_cleanup(curldwn);  
  150.     curl_global_cleanup();  
  151.     return 0;  
  152. }  
01-07 01:45
Powered by LMLPHP ©2024 lwchsz 0.079153