libcurl 库的ftp上传和下载代码

本文主要是介绍libcurl 库的ftp上传和下载代码，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

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

上传代码：

[cpp] view plain copy print ?

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 <stdlib.h>    
6. //#include <stdio.h>    
7. //#include <curl/curl.h>    
8. //#include <string.h>    
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 < 0)    
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. //}   

下载代码如下：

[cpp] view plain copy print ?

1. //ftp下载实例  
2. #include <stdio.h>;   
3. #include <curl/curl.h>;   
4. #include <curl/types.h>;   
5. #include <curl/easy.h>;   
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. }  

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

[cpp] view plain copy print ?

1. #include <stdlib.h>  
2. #include <stdio.h>  
3. #include <curl/curl.h>  
4. #include <sys/stat.h>  
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 < tries); 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. } 
     

这篇关于libcurl 库的ftp上传和下载代码的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！

---