linux下c/c++方式访问curl的帮助手册

桃扇骨 2022-07-12 15:49 281阅读 0赞

转自：[http://blog.chinaunix.net/u1/47395/showart\_1768832.html][http_blog.chinaunix.net_u1_47395_showart_1768832.html]

有个业务需求需要通过curl 代理的方式来访问外网

百度了一把，测试可以正常使用。记录下来方便后续查找

example:  
  1. http://curl.haxx.se/libcurl/c/example.html  
  2. http://www.libcurl.org/  
book:  
  1. http://www.linuxdevcenter.com/pub/a/linux/2005/05/05/libcurl.html  
others:  
  http://www.haxx.se/curl.html  
  http://curl.haxx.se/lxr/source/docs/examples/  
=======================================================================  
from: http://blog.dayuer.com/archives/2007/04/21/225.html

## curl使用笔记 ##

CURLOPT\_HEADER：设为1，则在返回的内容里包含http header；

CURLOPT\_FOLLOWLOCATION：设为0，则不会自动301，302跳转；

\*CURLOPT\_INFILESIZE: 当你上传一个文件到远程站点，这个选项告诉PHP你上传文件的大小。  
\*CURLOPT\_VERBOSE: 如果你想CURL报告每一件意外的事情，设置这个选项为一个非零值。  
\*CURLOPT\_HEADER: 如果你想把一个头包含在输出中，设置这个选项为一个非零值。  
\*CURLOPT\_NOPROGRESS: 如果你不会PHP为CURL传输显示一个进程条，设置这个选项为一个非零值。

注意：PHP自动设置这个选项为非零值，你应该仅仅为了调试的目的来改变这个选项。

\*CURLOPT\_NOBODY: 如果你不想在输出中包含body部分，设置这个选项为一个非零值。  
\*CURLOPT\_FAILONERROR: 如果你想让PHP在发生错误(HTTP代码返回大于等于300)时，不显示，设置这个选项为一人非零值。默认行为是返回一个正常页，忽略代码。  
\*CURLOPT\_UPLOAD: 如果你想让PHP为上传做准备，设置这个选项为一个非零值。  
\*CURLOPT\_POST: 如果你想PHP去做一个正规的HTTP POST，设置这个选项为一个非零值。这个POST是普通的 application/x-www-from-urlencoded 类型，多数被HTML表单使用。  
\*CURLOPT\_FTPLISTONLY: 设置这个选项为非零值，PHP将列出FTP的目录名列表。  
\*CURLOPT\_FTPAPPEND: 设置这个选项为一个非零值，PHP将应用远程文件代替覆盖它。  
\*CURLOPT\_NETRC: 设置这个选项为一个非零值，PHP将在你的 ~./netrc 文件中查找你要建立连接的远程站点的用户名及密码。  
\*CURLOPT\_FOLLOWLOCATION: 设置这个选项为一个非零值(象 “Location: “)的头，服务器会把它当做HTTP头的一部分发送(注意这是递归的，PHP将发送形如 “Location: “的头)。  
\*CURLOPT\_PUT: 设置这个选项为一个非零值去用HTTP上传一个文件。要上传这个文件必须设置CURLOPT\_INFILE和CURLOPT\_INFILESIZE选项.  
\*CURLOPT\_MUTE: 设置这个选项为一个非零值，PHP对于CURL函数将完全沉默。  
\*CURLOPT\_TIMEOUT: 设置一个长整形数，作为最大延续多少秒。  
\*CURLOPT\_LOW\_SPEED\_LIMIT: 设置一个长整形数，控制传送多少字节。  
\*CURLOPT\_LOW\_SPEED\_TIME: 设置一个长整形数，控制多少秒传送CURLOPT\_LOW\_SPEED\_LIMIT规定的字节数。  
\*CURLOPT\_RESUME\_FROM: 传递一个包含字节偏移地址的长整形参数，(你想转移到的开始表单)。  
\*CURLOPT\_SSLVERSION: 传递一个包含SSL版本的长参数。默认PHP将被它自己努力的确定，在更多的安全中你必须手工设置。  
\*CURLOPT\_TIMECONDITION: 传递一个长参数，指定怎么处理CURLOPT\_TIMEVALUE参数。你可以设置这个参数为TIMECOND\_IFMODSINCE 或 TIMECOND\_ISUNMODSINCE。这仅用于HTTP。  
\*CURLOPT\_TIMEVALUE: 传递一个从1970-1-1开始到现在的秒数。这个时间将被CURLOPT\_TIMEVALUE选项作为指定值使用，或被默认TIMECOND\_IFMODSINCE使用。

下列选项的值将被作为字符串：

\*CURLOPT\_URL: 这是你想用PHP取回的URL地址。你也可以在用curl\_init()函数初始化时设置这个选项。  
\*CURLOPT\_USERPWD: 传递一个形如\[username\]:\[password\]风格的字符串,作用PHP去连接。  
\*CURLOPT\_PROXYUSERPWD: 传递一个形如\[username\]:\[password\] 格式的字符串去连接HTTP代理。  
\*CURLOPT\_RANGE: 传递一个你想指定的范围。它应该是”X-Y”格式，X或Y是被除外的。HTTP传送同样支持几个间隔，用逗句来分隔(X-Y,N-M)。  
\*CURLOPT\_POSTFIELDS: 传递一个作为HTTP “POST”操作的所有数据的字符串。  
\*CURLOPT\_REFERER: 在HTTP请求中包含一个”referer”头的字符串。  
\*CURLOPT\_USERAGENT: 在HTTP请求中包含一个”user-agent”头的字符串。  
\*CURLOPT\_FTPPORT: 传递一个包含被ftp “POST”指令使用的IP地址。这个POST指令告诉远程服务器去连接我们指定的IP地址。这个字符串可以是一个IP地址，一个主机名，一个网络界面名(在UNIX下)，或是‘-’(使用系统默认IP地址)。  
\*CURLOPT\_COOKIE: 传递一个包含HTTP cookie的头连接。  
\*CURLOPT\_SSLCERT: 传递一个包含PEM格式证书的字符串。  
\*CURLOPT\_SSLCERTPASSWD: 传递一个包含使用CURLOPT\_SSLCERT证书必需的密码。  
\*CURLOPT\_COOKIEFILE: 传递一个包含cookie数据的文件的名字的字符串。这个cookie文件可以是Netscape格式，或是堆存在文件中的HTTP风格的头。  
\*CURLOPT\_CUSTOMREQUEST: 当进行HTTP请求时，传递一个字符被GET或HEAD使用。为进行DELETE或其它操作是有益的，更Pass a string to be used instead of GET or HEAD when doing an HTTP request. This is useful for doing or another, more obscure, HTTP request.

注意: 在确认你的服务器支持命令先不要去这样做。

下列的选项要求一个文件描述(通过使用fopen()函数获得)：

\*CURLOPT\_FILE: 这个文件将是你放置传送的输出文件，默认是STDOUT.  
\*CURLOPT\_INFILE: 这个文件是你传送过来的输入文件。  
\*CURLOPT\_WRITEHEADER: 这个文件写有你输出的头部分。  
\*CURLOPT\_STDERR: 这个文件写有错误而不是stderr。

=======================================================================  
from: http://www.linuxidc.com/Linux/2008-01/10891p2.htm  
  
Linux curl使用简单介绍  
\[日期：2008-01-29\]     来源：Linux公社  作者：notech      
  
  
Curl是Linux下一个很强大的http命令行工具，其功能十分强大。  
  
1) 二话不说，先从这里开始吧！  
  
$ curl http://www.linuxidc.com  
  
回车之后，www.linuxidc.com 的html就稀里哗啦地显示在屏幕上了    ~  
  
2) 嗯，要想把读过来页面存下来，是不是要这样呢？  
  
$ curl http://www.linuxidc.com > page.html  
  
当然可以，但不用这么麻烦的！  
  
用curl的内置option就好，存下http的结果，用这个option: -o  
  
$ curl -o page.html http://www.linuxidc.com  
  
这样，你就可以看到屏幕上出现一个下载页面进度指示。等进展到100%，自然就 OK咯  
  
3) 什么什么？！访问不到？肯定是你的proxy没有设定了。  
  
使用curl的时候，用这个option可以指定http访问所使用的proxy服务器及其端口： -x  
  
$ curl -x 123.45.67.89:1080 -o page.html http://www.linuxidc.com  
  
4) 访问有些网站的时候比较讨厌，他使用cookie来记录session信息。  
  
像IE/NN这样的浏览器，当然可以轻易处理cookie信息，但我们的curl呢？.....  
  
我们来学习这个option: -D <— 这个是把http的response里面的cookie信息存到一个特别的文件中去  
  
$ curl -x 123.45.67.89:1080 -o page.html -D cookie0001.txt http://www.linuxidc.com  
  
这样，当页面被存到page.html的同时，cookie信息也被存到了cookie0001.txt里面了  
  
5）那么，下一次访问的时候，如何继续使用上次留下的cookie信息呢？要知道，很多网站都是靠监视你的cookie信息，来判断你是不是不按规矩访问他们的网站的。  
  
这次我们使用这个option来把上次的cookie信息追加到http request里面去： -b  
  
$ curl -x 123.45.67.89:1080 -o page1.html -D cookie0002.txt -b cookie0001.txt http://www.linuxidc.com  
  
这样，我们就可以几乎模拟所有的IE操作，去访问网页了！  
  
6）稍微等等    ~我好像忘记什么了    ~  
  
对了！是浏览器信息  
  
有些讨厌的网站总要我们使用某些特定的浏览器去访问他们，有时候更过分的是，还要使用某些特定的版本     NND，哪里有时间为了它去找这些怪异的浏览器呢！？  
  
好在curl给我们提供了一个有用的option，可以让我们随意指定自己这次访问所宣称的自己的浏览器信息： -A  
  
$ curl -A "Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.0)" -x 123.45.67.89:1080 -o page.html -D cookie0001.txt http://www.linuxidc.com  
  
这样，服务器端接到访问的要求，会认为你是一个运行在Windows 2000上的 IE6.0，嘿嘿嘿，其实也许你用的是苹果机呢！  
  
而"Mozilla/4.73 \[en\] (X11; U; Linux 2.2; 15 i686"则可以告诉对方你是一台 PC上跑着的Linux，用的是Netscape 4.73，呵呵呵  
  
7）另外一个服务器端常用的限制方法，就是检查http访问的referer。比如你先访问首页，再访问里面所指定的下载页，这第二次访问的 referer地址就是第一次访问成功后的页面地址。这样，服务器端只要发现对下载页面某次访问的referer地址不是首页的地址，就可以断定那是个盗连了    ~  
  
讨厌讨厌 ~我就是要盗连    ~！！  
  
幸好curl给我们提供了设定referer的option： -e  
  
$ curl -A "Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.0)" -x 123.45.67.89:1080 -e "mail.linuxidc.com" -o page.html -D cookie0001.txt http://www.linuxidc.com  
  
这样，就可以骗对方的服务器，你是从mail.linuxidc.com点击某个链接过来的了，呵呵呵  
  
8）写着写着发现漏掉什么重要的东西了！——- 利用curl 下载文件  
  
刚才讲过了，下载页面到一个文件里，可以使用 -o ，下载文件也是一样。比如，  
  
$ curl -o 1.jpg http://cgi2.tky.3web.ne.jp/~zzh/screen1.JPG  
  
这里教大家一个新的option： -O 大写的O，这么用：  
  
$ curl -O http://cgi2.tky.3web.ne.jp/~zzh/screen1.JPG  
  
这样，就可以按照服务器上的文件名，自动存在本地了！  
  
再来一个更好用的。  
  
如果screen1.JPG以外还有screen2.JPG、screen3.JPG、....、screen10.JPG需要下载，难不成还要让我们写一个script来完成这些操作？  
  
不干！  
  
在curl里面，这么写就可以了：  
  
$ curl -O http://cgi2.tky.3web.ne.jp/~zzh/screen\[1-10\].JPG  
  
呵呵呵，厉害吧？！ ~  
  
9）再来，我们继续讲解下载！  
  
$ curl -O http://cgi2.tky.3web.ne.jp/~\{zzh,nick\}/\[001-201\].JPG  
  
这样产生的下载，就是  
  
~zzh/001.JPG  
  
~zzh/002.JPG  
  
...  
  
~zzh/201.JPG  
  
~nick/001.JPG  
  
~nick/002.JPG  
  
...  
  
~nick/201.JPG  
  
够方便的了吧？哈哈哈  
  
咦？高兴得太早了。  
  
由于zzh/nick下的文件名都是001，002...，201，下载下来的文件重名，后面的把前面的文件都给覆盖掉了 ~  
  
没关系，我们还有更狠的！  
  
$ curl -o \#2\_\#1.jpg http://cgi2.tky.3web.ne.jp/~\{zzh,nick\}/\[001-201\].JPG  
  
—这是.....自定义文件名的下载？ —对头，呵呵！  
  
这样，自定义出来下载下来的文件名，就变成了这样：原来： ~zzh/001.JPG —-> 下载后： 001-zzh.JPG 原来： ~nick/001.JPG —-> 下载后： 001-nick.JPG  
  
这样一来，就不怕文件重名啦，呵呵  
\-------------------------------------------------------  
Linux curl使用简单介绍  
\[日期：2008-01-29\]     来源：Linux公社  作者：notech      
  
  
9）继续讲下载  
  
我们平时在windows平台上，flashget这样的工具可以帮我们分块并行下载，还可以断线续传。curl在这些方面也不输给谁，嘿嘿  
  
比如我们下载screen1.JPG中，突然掉线了，我们就可以这样开始续传  
  
$ curl -c -O http://cgi2.tky.3wb.ne.jp/~zzh/screen1.JPG  
  
当然，你不要拿个flashget下载了一半的文件来糊弄我    别的下载软件的半截文件可不一定能用哦 ~  
  
分块下载，我们使用这个option就可以了： -r  
  
举例说明  
  
比如我们有一个http://cgi2.tky.3web.ne.jp/~zzh/zhao1.MP3 要下载（赵老师的电话朗诵 :D ）我们就可以用这样的命令：  
  
$ curl -r 0-10240 -o "zhao.part1" http:/cgi2.tky.3web.ne.jp/~zzh/zhao1.MP3 &/  
  
$ curl -r 10241-20480 -o "zhao.part1" http:/cgi2.tky.3web.ne.jp/~zzh/zhao1.MP3 &/  
  
$ curl -r 20481-40960 -o "zhao.part1" http:/cgi2.tky.3web.ne.jp/~zzh/zhao1.MP3 &/  
  
$ curl -r 40961- -o "zhao.part1" http:/cgi2.tky.3web.ne.jp/~zzh/zhao1.MP3  
  
这样就可以分块下载啦。不过你需要自己把这些破碎的文件合并起来如果你用UNIX或苹果，用 cat zhao.part\* > zhao.MP3就可以如果用的是Windows，用copy /b 来解决吧，呵呵  
  
上面讲的都是http协议的下载，其实ftp也一样可以用。用法嘛，  
  
$ curl -u name:passwd ftp://ip:port/path/file  
  
或者大家熟悉的  
  
$ curl ftp://name:passwd@ip:port/path/file  
  
10) 说完了下载，接下来自然该讲上传咯上传的option是 -T  
  
比如我们向ftp传一个文件：  
  
$ curl -T localfile -u name:passwd ftp://upload\_site:port/path/  
  
当然，向http服务器上传文件也可以比如  
  
$ curl -T localfile http://cgi2.tky.3web.ne.jp/~zzh/abc.cgi  
  
注意，这时候，使用的协议是HTTP的PUT method  
  
刚才说到PUT，嘿嘿，自然让老服想起来了其他几种methos还没讲呢！ GET和POST都不能忘哦。  
  
http提交一个表单，比较常用的是POST模式和GET模式  
  
GET模式什么option都不用，只需要把变量写在url里面就可以了比如：  
  
$ curl http://www.linuxidc.com/login.cgi?user=nickwolfe&password=12345  
  
而POST模式的option则是 -d  
  
比如，  
  
$ curl -d "user=nickwolfe&password=12345" http://www.linuxidc.com/login.cgi  
  
就相当于向这个站点发出一次登陆申请    ~  
  
到底该用GET模式还是POST模式，要看对面服务器的程序设定。  
  
一点需要注意的是，POST模式下的文件上的文件上传，比如  
  
<form method="POST" enctype="multipar/form-data" action="http://cgi2.tky.3web.ne.jp/~zzh/up\_file.cgi">  
  
<input type=file name=upload>  
  
<input type=submit name=nick value="go">  
  
</form>  
  
这样一个HTTP表单，我们要用curl进行模拟，就该是这样的语法：  
  
$ curl -F upload=@localfile -F nick=go http://cgi2.tky.3web.ne.jp/~zzh/up\_file.cgi  
  
罗罗嗦嗦讲了这么多，其实curl还有很多很多技巧和用法比如 https的时候使用本地证书，就可以这样  
  
$ curl -E localcert.pem https://remote\_server  
  
再比如，你还可以用curl通过dict协议去查字典    ~  
  
$ curl dict://dict.org/d:computer  
=======================================================================  
from: http://blog.csdn.net/hwz119/archive/2007/04/29/1591920.aspx

#  [Libcurl 简明使用指南][Libcurl]收藏 #

### [新一篇: Linux系统各项开机服务介绍][Linux] | [旧一篇: HTTP协议的C语言编程实现实例][HTTP_C] ###

## [Libcurl 简明使用指南][Libcurl 1] ##

Libcurl为一个免费开源的，客户端url传输库，支持FTP，FTPS，TFTP，HTTP，HTTPS，GOPHER，TELNET，DICT，FILE和LDAP，跨平台，支持Windows，Unix，Linux等，线程安全，支持Ipv6。并且易于使用。

[http://curl.haxx.se/libcurl/][http_curl.haxx.se_libcurl]

从http://curl.haxx.se/libcurl/ 下载一个稳定的版本，注意选择OS。

### 编译libcurl ###

下载下来的是源码包，需要编译。

解压zip文件，进入curl-7.14.0/lib目录（我下载的是7.14.0）。

编译Debug版本。新建一个批处理bat文件，如buildDebug.bat，内容如下：

call "C:/Program Files/Microsoft Visual Studio/VC98/Bin/vcvars32.bat"

set CFG=debug-dll-ssl-dll-zlib-dll

set OPENSSL\_PATH=E:/SSL/openssl-0.9.7e

set ZLIB\_PATH=E:/zip/zlib123

nmake -f Makefile.vc6

其输出：libcurld\_imp.lib, libcurld.dll

编译Release版本。新建一个批处理文件BuildRelease.bat，内容如下：

call "C:/Program Files/Microsoft Visual Studio/VC98/Bin/vcvars32.bat"

set CFG=release-dll-ssl-dll-zlib-dll

set OPENSSL\_PATH=E:/SSL/openssl-0.9.7e

set ZLIB\_PATH=E:/zip/zlib123

nmake -f Makefile.vc6

其输出：libcurl\_imp.lib, libcurl.dll

上面编译的是libcurl的 dll，使用OpenSSL Dll版本和Zlib Dll版本。如果没有，可以从[www.openssl.org][] 或者[http://www.zlib.net/][http_www.zlib.net] 下载。

如果需要编译其他版本，可查看Makefile.vc6，设定相应的CFG 参数即可。

商业软件使用libcurl时，只需要包含其copywrite声明即可。

### Sample ###

![None.gif][] \#include  < stdio.h >   
![None.gif][]\#include  " ../curl-7.14.0/include/curl/curl.h "   
![None.gif][]\#pragma comment(lib,  " ../curl-7.14.0/lib/libcurl\_imp.lib " )  
![None.gif][]  
![None.gif][] int  main( void )  
![ExpandedBlockStart.gif][]![ContractedBlock.gif][] ![dot.gif][] \{  
![InBlock.gif][]  curl = curl\_easy\_init();  
![ExpandedSubBlockStart.gif][]![ContractedSubBlock.gif][]  if(curl) ![dot.gif][]\{  
![InBlock.gif][]  
![InBlock.gif][]    CURLcode res;      
![InBlock.gif][]    res = curl\_easy\_setopt(curl, CURLOPT\_PROXY, "Test-pxy08:8080");  
![InBlock.gif][]    res = curl\_easy\_setopt(curl, CURLOPT\_PROXYTYPE, CURLPROXY\_HTTP);  
![InBlock.gif][]    res = curl\_easy\_setopt(curl, CURLOPT\_URL, "http://www.vckbase.com");  
![InBlock.gif][]    res = curl\_easy\_perform(curl);  
![InBlock.gif][]  
![ExpandedSubBlockStart.gif][]![ContractedSubBlock.gif][]    if(CURLE\_OK == res) ![dot.gif][]\{  
![InBlock.gif][]      char \*ct;  
![ExpandedSubBlockStart.gif][]![ContractedSubBlock.gif][]      /\*\*//\* ask for the content-type \*/  
![ExpandedSubBlockStart.gif][]![ContractedSubBlock.gif][]      /\*\*//\* **http://curl.haxx.se/libcurl/c/curl\_easy\_getinfo.html **\*/  
![InBlock.gif][]      res = curl\_easy\_getinfo(curl, CURLINFO\_CONTENT\_TYPE, &ct);  
![InBlock.gif][]  
![InBlock.gif][]      if((CURLE\_OK == res) && ct)  
![InBlock.gif][]        printf("We received Content-Type: %s ", ct);  
![ExpandedSubBlockEnd.gif][]    \}  
![InBlock.gif][]  
![ExpandedSubBlockStart.gif][]![ContractedSubBlock.gif][]    /\*\*//\* always cleanup \*/  
![InBlock.gif][]    curl\_easy\_cleanup(curl);  
![ExpandedSubBlockEnd.gif][]  \}  
![InBlock.gif][]  return 0;  
![ExpandedBlockEnd.gif][]\}

=======================================================================  
from: http://www.cppblog.com/qiujian5628/archive/2008/06/28/54873.html

## [libcurl使用心得][libcurl] ##

[http://curl.haxx.se/libcurl/][http_curl.haxx.se_libcurl]

从http://curl.haxx.se/libcurl/ 下载一个稳定的版本，注意选择OS。  
在使用之前请大家多阅读libcurl的文档：因为如果要实际运用到项目中，最好对libcurl有具体的了解，具体在  
[http://curl.haxx.se/libcurl/c/][http_curl.haxx.se_libcurl_c]  
[curl\_easy\_setopt()][curl_easy_setopt]  
[curl\_easy\_perform()][curl_easy_perform]  
[curl\_easy\_getinfo()][curl_easy_getinfo]  
这三个函数的使用上，需要多去钻研，多看Samples，你才能灵活使用libcurl。  
感谢这篇文章:  
[http://blog.163.com/xu\_chao2000/blog/static/27770610200801303252802/][http_blog.163.com_xu_chao2000_blog_static_27770610200801303252802]  
给了我许多启发，再次感谢！  
  
给出我的一个简单的代码例子：  
说明:  
1.PM...等参数，没有具体意义，就是long,bool，int,char\*等进行特殊封装过，你可以用普通类型取代。  
  
2.关键在curl\_easy\_setopt函数设置option,可以设置ftp,http,get,post等许多选项，请根据具体使用情况设置。  
  
3.对取回来的数据需要进行判断，比如http下载文件，如果文件不存在，需要进行处理。因为writer是可以将buf填充404 not found等网页内容的，不能将这个内容当成文件内容，所以需要判断http web返回来的code，进行判断。  
  
4.我有个问题，就是想得到服务器上filename的具体名称，verbose调试已经返回了，但是我在getinfo的时候，试过好多选项，但未找到这个存放真实服务器文件名的选项，如果有知道的麻烦告诉我，谢谢了！

![None.gif 1][]\#include "curl/curl.h"  
![None.gif 1][]\#pragma comment(lib, "libcurl.lib")  
![None.gif 1][]  
![None.gif 1][]PM\_ULONG writer(PM\_VOID \*data, PM\_INT size, PM\_INT nmemb, PmString &content);  
![None.gif 1][]PM\_BOOL  CurlInit(CURL \*&curl, PM\_LPCSTR url,PmString &content);  
![None.gif 1][]PM\_BOOL  GetURLDataBycurl(PM\_LPCSTR URL,     PmString &content);  
![None.gif 1][]  
![None.gif 1][]void main()  
![ExpandedBlockStart.gif 1][]![ContractedBlock.gif 1][]![dot.gif 1][]\{  
![InBlock.gif 1][]    //PM\_LPSTR url="http://down1.chinaunix.net/distfiles/libpcap-1.0.20050129.tar.gz";  
![InBlock.gif 1][]    PM\_LPCSTR url ="http://www.baidu.com/img/baidu.gif";  
![InBlock.gif 1][]    PmString content;  
![InBlock.gif 1][]    if ( GetURLDataBycurl(url,content))  
![ExpandedSubBlockStart.gif 1][]![ContractedSubBlock.gif 1][]    ![dot.gif 1][]\{  
![InBlock.gif 1][]        printf("%s/n",content);  
![InBlock.gif 1][]  
![ExpandedSubBlockEnd.gif 1][]    \}  
![InBlock.gif 1][]    getchar();  
![ExpandedBlockEnd.gif 1][]\}  
![None.gif 1][]  
![None.gif 1][]PM\_BOOL CurlInit(CURL \*&curl, PM\_LPCSTR url,PmString &content)  
![ExpandedBlockStart.gif 1][]![ContractedBlock.gif 1][]![dot.gif 1][]\{  
![InBlock.gif 1][]    CURLcode code;  
![InBlock.gif 1][]    PmString error;  
![InBlock.gif 1][]    curl = curl\_easy\_init();  
![InBlock.gif 1][]    if (curl == NULL)  
![ExpandedSubBlockStart.gif 1][]![ContractedSubBlock.gif 1][]    ![dot.gif 1][]\{  
![InBlock.gif 1][]        debug0( "Failed to create CURL connection/n");  
![InBlock.gif 1][]        return PM\_FALSE;  
![ExpandedSubBlockEnd.gif 1][]    \}  
![InBlock.gif 1][]    code = curl\_easy\_setopt(curl, CURLOPT\_ERRORBUFFER, error);  
![InBlock.gif 1][]    if (code != CURLE\_OK)  
![ExpandedSubBlockStart.gif 1][]![ContractedSubBlock.gif 1][]    ![dot.gif 1][]\{  
![InBlock.gif 1][]        debug1( "Failed to set error buffer \[%d\]/n", code );  
![InBlock.gif 1][]        return PM\_FALSE;  
![ExpandedSubBlockEnd.gif 1][]    \}  
![InBlock.gif 1][]    curl\_easy\_setopt(curl, CURLOPT\_VERBOSE, 1L);  
![InBlock.gif 1][]    code = curl\_easy\_setopt(curl, CURLOPT\_URL, url);  
![InBlock.gif 1][]    if (code != CURLE\_OK)  
![ExpandedSubBlockStart.gif 1][]![ContractedSubBlock.gif 1][]    ![dot.gif 1][]\{  
![InBlock.gif 1][]        debug1("Failed to set URL \[%s\]/n", error);  
![InBlock.gif 1][]        return PM\_FALSE;  
![ExpandedSubBlockEnd.gif 1][]    \}  
![InBlock.gif 1][]    code = curl\_easy\_setopt(curl, CURLOPT\_FOLLOWLOCATION, 1);  
![InBlock.gif 1][]    if (code != CURLE\_OK)  
![ExpandedSubBlockStart.gif 1][]![ContractedSubBlock.gif 1][]    ![dot.gif 1][]\{  
![InBlock.gif 1][]        debug1( "Failed to set redirect option \[%s\]/n", error );  
![InBlock.gif 1][]        return PM\_FALSE;  
![ExpandedSubBlockEnd.gif 1][]    \}  
![InBlock.gif 1][]    code = curl\_easy\_setopt(curl, CURLOPT\_WRITEFUNCTION, writer);  
![InBlock.gif 1][]    if (code != CURLE\_OK)  
![ExpandedSubBlockStart.gif 1][]![ContractedSubBlock.gif 1][]    ![dot.gif 1][]\{  
![InBlock.gif 1][]        debug1( "Failed to set writer \[%s\]/n", error);  
![InBlock.gif 1][]        return PM\_FALSE;  
![ExpandedSubBlockEnd.gif 1][]    \}  
![InBlock.gif 1][]    code = curl\_easy\_setopt(curl, CURLOPT\_WRITEDATA, &content);  
![InBlock.gif 1][]    if (code != CURLE\_OK)  
![ExpandedSubBlockStart.gif 1][]![ContractedSubBlock.gif 1][]    ![dot.gif 1][]\{  
![InBlock.gif 1][]        debug1( "Failed to set write data \[%s\]/n", error );  
![InBlock.gif 1][]        return PM\_FALSE;  
![ExpandedSubBlockEnd.gif 1][]    \}  
![InBlock.gif 1][]    return PM\_TRUE;  
![ExpandedBlockEnd.gif 1][]\}  
![None.gif 1][]  
![None.gif 1][]PM\_ULONG writer(PM\_VOID \*data, PM\_INT size, PM\_INT nmemb, PmString &content)  
![ExpandedBlockStart.gif 1][]![ContractedBlock.gif 1][]![dot.gif 1][]\{  
![InBlock.gif 1][]    PM\_ULONG sizes = size \* nmemb;  
![InBlock.gif 1][]    PmString temp(data,sizes);  
![InBlock.gif 1][]    content \+= temp;   
![InBlock.gif 1][]    return sizes;  
![ExpandedBlockEnd.gif 1][]\}  
![None.gif 1][]  
![None.gif 1][]PM\_BOOL  GetURLDataBycurl(PM\_LPCSTR URL,  PmString &content)  
![ExpandedBlockStart.gif 1][]![ContractedBlock.gif 1][]![dot.gif 1][]\{  
![InBlock.gif 1][]    CURL \*curl = NULL;  
![InBlock.gif 1][]    CURLcode code;  
![InBlock.gif 1][]    PmString error;  
![InBlock.gif 1][]  
![InBlock.gif 1][]    code = curl\_global\_init(CURL\_GLOBAL\_DEFAULT);  
![InBlock.gif 1][]    if (code != CURLE\_OK)  
![ExpandedSubBlockStart.gif 1][]![ContractedSubBlock.gif 1][]    ![dot.gif 1][]\{  
![InBlock.gif 1][]        debug1( "Failed to global init default \[%d\]/n", code );  
![InBlock.gif 1][]        return PM\_FALSE;  
![ExpandedSubBlockEnd.gif 1][]    \}   
![InBlock.gif 1][]      
![InBlock.gif 1][]    if ( !CurlInit(curl,URL,content) )  
![ExpandedSubBlockStart.gif 1][]![ContractedSubBlock.gif 1][]    ![dot.gif 1][]\{  
![InBlock.gif 1][]        debug0( "Failed to global init default \[%d\]/n" );  
![InBlock.gif 1][]        return PM\_FALSE;  
![ExpandedSubBlockEnd.gif 1][]    \}  
![InBlock.gif 1][]    code = curl\_easy\_perform(curl);  
![InBlock.gif 1][]    if (code != CURLE\_OK)  
![ExpandedSubBlockStart.gif 1][]![ContractedSubBlock.gif 1][]    ![dot.gif 1][]\{  
![InBlock.gif 1][]        debug2( "Failed to get '%s' \[%s\]/n", URL, error);  
![InBlock.gif 1][]        return PM\_FALSE;  
![ExpandedSubBlockEnd.gif 1][]    \}  
![InBlock.gif 1][]    PM\_ULONG retcode = 0;  
![InBlock.gif 1][]    code = curl\_easy\_getinfo(curl, CURLINFO\_RESPONSE\_CODE , &retcode);   
![InBlock.gif 1][]    if ( (code == CURLE\_OK) && retcode == 200 )  
![ExpandedSubBlockStart.gif 1][]![ContractedSubBlock.gif 1][]    ![dot.gif 1][]\{  
![InBlock.gif 1][]        PM\_DOUBLE length = 0;  
![InBlock.gif 1][]        code = curl\_easy\_getinfo(curl, CURLINFO\_CONTENT\_LENGTH\_DOWNLOAD , &length);   
![InBlock.gif 1][]        printf("%d",retcode);  
![InBlock.gif 1][]        FILE \* file = fopen("1.gif","wb");  
![InBlock.gif 1][]        fseek(file,0,SEEK\_SET);  
![InBlock.gif 1][]        fwrite(content.c\_str(),1,length,file);  
![InBlock.gif 1][]        fclose(file);  
![InBlock.gif 1][]  
![InBlock.gif 1][]        //struct curl\_slist \*list;  
![InBlock.gif 1][]        //code = curl\_easy\_getinfo(curl,CURLINFO\_COOKIELIST,&list);  
![InBlock.gif 1][]        //curl\_slist\_free\_all (list);  
![InBlock.gif 1][]  
![InBlock.gif 1][]        return PM\_TRUE;  
![ExpandedSubBlockEnd.gif 1][]    \}  
![InBlock.gif 1][]    else  
![ExpandedSubBlockStart.gif 1][]![ContractedSubBlock.gif 1][]    ![dot.gif 1][]\{  
![InBlock.gif 1][]    //    debug1( "%s /n ",getStatusCode(retcode));  
![InBlock.gif 1][]        return PM\_FALSE;  
![ExpandedSubBlockEnd.gif 1][]    \}  
![InBlock.gif 1][]    curl\_easy\_cleanup(curl);  
![InBlock.gif 1][]    return PM\_FALSE;  
![ExpandedBlockEnd.gif 1][]\}  
  
=======================================================================  
**from:http://topic.csdn.net/u/20081224/17/80bb810e-9b74-429f-8282-2c224f8fe372.html  
  
使用libcurl库如何才能够得到重定向之后的url? ![blank.gif][] ![blank.gif][]**  
  
  
首先调用curl\_setopt($curl, CURLOPT\_FOLLOWLOCATION, 1)使其跟踪重定向，  
然后调用curl\_getinfo()获得返回的内容，返回的内容中便会包含重定向之后的url。  
你试试看行不行？  
=======================================================================  
from: http://www.maycode.com/index.php/linux/54-linuxdevelop/1151-curl.html

### LibCurl编程手册以及代码实例 ###

[Joomla! 开源天空][Joomla_]  作者：管理员  2008-11-03 21:57

*  摘要：本文详细说了了如何使用curl,libcurl进行网络程序的编写，并给出了代码实例。
 *

2.1 LibCurl编程流程

在基于LibCurl的程序里，主要采用callback function （回调函数）的形式完成传输任务，用户在启动传输前设置好各类参数和回调函数，当满足条件时libcurl将调用用户的回调函数实现特定功能。下面是利用libcurl完成传输任务的流程：

1.       调用curl\_global\_init()初始化libcurl

2.       调用 curl\_easy\_init()函数得到 easy interface型指针

3.       调用curl\_easy\_setopt设置传输选项

4.       根据curl\_easy\_setopt设置的传输选项，实现回调函数以完成用户特定任务

5.       调用curl\_easy\_perform（）函数完成传输任务

6.       调用curl\_easy\_cleanup（）释放内存

在整过过程中设置curl\_easy\_setopt()参数是最关键的，几乎所有的libcurl程序都要使用它。

2.2 重要函数

1.CURLcode curl\_global\_init(long flags);

描述：  
这个函数只能用一次。(其实在调用curl\_global\_cleanup 函数后仍然可再用)  
如果这个函数在curl\_easy\_init函数调用时还没调用，它讲由libcurl库自动完成。  
  
参数：flags  
CURL\_GLOBAL\_ALL                      //初始化所有的可能的调用。  
CURL\_GLOBAL\_SSL                      //初始化支持 安全套接字层。  
CURL\_GLOBAL\_WIN32            //初始化win32套接字库。  
CURL\_GLOBAL\_NOTHING         //没有额外的初始化。

2 void curl\_global\_cleanup(void);  
描述：在结束libcurl使用的时候，用来对curl\_global\_init做的工作清理。类似于close的函数。  
  
3 char \*curl\_version( );  
描述: 打印当前libcurl库的版本。  
  
4 CURL \*curl\_easy\_init( );  
描述:  
curl\_easy\_init用来初始化一个CURL的指针(有些像返回FILE类型的指针一样). 相应的在调用结束时要用curl\_easy\_cleanup函数清理.  
一般curl\_easy\_init意味着一个会话的开始. 它的返回值一般都用在easy系列的函数中.  
  
5 void curl\_easy\_cleanup(CURL \*handle);  
描述:  
这个调用用来结束一个会话.与curl\_easy\_init配合着用.  
参数:  
CURL类型的指针.  
  
6 CURLcode curl\_easy\_setopt(CURL \*handle, CURLoption option, parameter);  
  
描述: 这个函数最重要了.几乎所有的curl 程序都要频繁的使用它.它告诉curl库.程序将有如何的行为. 比如要查看一个网页的html代码等.(这个函数有些像ioctl函数)  
  
参数:  
1 CURL类型的指针  
2 各种CURLoption类型的选项.(都在curl.h库里有定义,man 也可以查看到)  
3 parameter 这个参数 既可以是个函数的指针,也可以是某个对象的指针,也可以是个long型的变量.它用什么这取决于第二个参数.  
CURLoption 这个参数的取值很多.具体的可以查看man手册.  
  
7 CURLcode curl\_easy\_perform(CURL \*handle);  
描述:这个函数在初始化CURL类型的指针 以及curl\_easy\_setopt完成后调用. 就像字面的意思所说perform就像是个舞台.让我们设置的  
option 运作起来.  
  参数:  
    CURL类型的指针.

3.3 curl\_easy\_setopt函数介绍

本节主要介绍curl\_easy\_setopt中跟http相关的参数。注意本节的阐述都是以libcurl作为主体，其它为客体来阐述的。

1.     CURLOPT\_URL  
设置访问URL

2.       CURLOPT\_WRITEFUNCTION，CURLOPT\_WRITEDATA  
回调函数原型为：size\_t function( void \*ptr, size\_t size, size\_t nmemb, void \*stream); 函数将在libcurl接收到数据后被调用，因此函数多做数据保存的功能，如处理下载文件。CURLOPT\_WRITEDATA 用于表明CURLOPT\_WRITEFUNCTION函数中的stream指针的来源。

3.      CURLOPT\_HEADERFUNCTION，CURLOPT\_HEADERDATA  
回调函数原型为 size\_t function( void \*ptr, size\_t size,size\_t nmemb, void \*stream); libcurl一旦接收到http 头部数据后将调用该函数。CURLOPT\_WRITEDATA 传递指针给libcurl，该指针表明CURLOPT\_HEADERFUNCTION 函数的stream指针的来源。

4.       CURLOPT\_READFUNCTION CURLOPT\_READDATA  
libCurl需要读取数据传递给远程主机时将调用CURLOPT\_READFUNCTION指定的函数，函数原型是：size\_t function(void \*ptr, size\_t size, size\_t nmemb,void \*stream). CURLOPT\_READDATA 表明CURLOPT\_READFUNCTION函数原型中的stream指针来源。

5.       CURLOPT\_NOPROGRESS，CURLOPT\_PROGRESSFUNCTION，CURLOPT\_PROGRESSDATA  
跟数据传输进度相关的参数。CURLOPT\_PROGRESSFUNCTION 指定的函数正常情况下每秒被libcurl调用一次，为了使CURLOPT\_PROGRESSFUNCTION被调用，CURLOPT\_NOPROGRESS必须被设置为false，CURLOPT\_PROGRESSDATA指定的参数将作为 CURLOPT\_PROGRESSFUNCTION指定函数的第一个参数

6.       CURLOPT\_TIMEOUT，CURLOPT\_CONNECTIONTIMEOUT:  
CURLOPT\_TIMEOUT 由于设置传输时间，CURLOPT\_CONNECTIONTIMEOUT 设置连接等待时间

7.       CURLOPT\_FOLLOWLOCATION  
设置重定位URL

CURLOPT\_RANGE: CURLOPT\_RESUME\_FROM:  
断点续传相关设置。CURLOPT\_RANGE 指定char \*参数传递给libcurl，用于指明http域的RANGE头域，例如：  
表示头500个字节：bytes=0-499  
表示第二个500字节：bytes=500-999  
表示最后500个字节：bytes=-500  
表示500字节以后的范围：bytes=500-  
第一个和最后一个字节：bytes=0-0,-1

同时指定几个范围：bytes=500-600,601-999  
    CURLOPT\_RESUME\_FROM 传递一个long参数给libcurl，指定你希望开始传递的

偏移量。

3.4 curl\_easy\_perform 函数说明（error 状态码）

该函数完成curl\_easy\_setopt指定的所有选项，本节重点介绍curl\_easy\_perform的返回值。返回0意味一切ok，非0代表错误发生。主要错误码说明：  
1.    CURLE\_OK  
    任务完成一切都好

2     CURLE\_UNSUPPORTED\_PROTOCOL

不支持的协议，由URL的头部指定

3     CURLE\_COULDNT\_CONNECT

不能连接到remote 主机或者代理

4     CURLE\_REMOTE\_ACCESS\_DENIED

访问被拒绝

5     CURLE\_HTTP\_RETURNED\_ERROR

Http返回错误

6           CURLE\_READ\_ERROR  
读本地文件错误

3.1 获取html网页

\#include <stdio.h>

\#include <curl/curl.h>

\#include <stdlib.h>

int main(int argc, char \*argv\[\])

CURL \*curl;             //定义CURL类型的指针

CURLcode res;           //定义CURLcode类型的变量，保存返回状态码

if(argc!=2)

printf("Usage : file <url>;/n");

exit(1);

curl = curl\_easy\_init();        //初始化一个CURL类型的指针

if(curl!=NULL)

//设置curl选项. 其中CURLOPT\_URL是让用户指定url. argv\[1\]中存放的命令行传进来的网址

curl\_easy\_setopt(curl, CURLOPT\_URL, argv\[1\]);

//调用curl\_easy\_perform 执行我们的设置.并进行相关的操作. 在这里只在屏幕上显示出来.

res = curl\_easy\_perform(curl);

//清除curl操作.

curl\_easy\_cleanup(curl);

return 0;

编译gcc  get\_http.c  -o get\_http –lcurl

./ get\_http [www.baidu.com][]

3.2 网页下载保存实例

// 采用CURLOPT\_WRITEFUNCTION 实现网页下载保存功能

\#include <stdio.h>;

\#include <stdlib.h>;

\#include <unistd.h>;

\#include <curl/curl.h>;

\#include <curl/types.h>;

\#include <curl/easy.h>;

FILE \*fp;  //定义FILE类型指针

//这个函数是为了符合CURLOPT\_WRITEFUNCTION而构造的

//完成数据保存功能

size\_t write\_data(void \*ptr, size\_t size, size\_t nmemb, void \*stream)

int written = fwrite(ptr, size, nmemb, (FILE \*)fp);

return written;

int main(int argc, char \*argv\[\])

CURL \*curl;

curl\_global\_init(CURL\_GLOBAL\_ALL);

curl=curl\_easy\_init();

curl\_easy\_setopt(curl, CURLOPT\_URL, argv\[1\]);

if((fp=fopen(argv\[2\],"w"))==NULL)

curl\_easy\_cleanup(curl);

exit(1);

CURLOPT\_WRITEFUNCTION 将后继的动作交给write\_data函数处理

curl\_easy\_setopt(curl, CURLOPT\_WRITEFUNCTION, write\_data);

curl\_easy\_perform(curl);

curl\_easy\_cleanup(curl);

exit(0);

编译gcc  save\_http.c  -o save\_http –lcurl

./ save\_http [www.baidu.com][]  /tmp/baidu

3.3 进度条实例??显示文件下载进度

// 采用CURLOPT\_NOPROGRESS， CURLOPT\_PROGRESSFUNCTION    CURLOPT\_PROGRESSDATA 实现文件传输进度提示功能

//函数采用了gtk库，故编译时需指定gtk库

//函数启动专门的线程用于显示gtk 进度条bar

\#include <stdio.h>

\#include <gtk/gtk.h>

\#include <curl/curl.h>

\#include <curl/types.h> /\* new for v7 \*/

\#include <curl/easy.h> /\* new for v7 \*/

GtkWidget \*Bar;

这个函数是为了符合CURLOPT\_WRITEFUNCTION而构造的

//完成数据保存功能

size\_t my\_write\_func(void \*ptr, size\_t size, size\_t nmemb, FILE \*stream)

return fwrite(ptr, size, nmemb, stream);

//这个函数是为了符合CURLOPT\_READFUNCTION而构造的

//数据上传时使用

size\_t my\_read\_func(void \*ptr, size\_t size, size\_t nmemb, FILE \*stream)

return fread(ptr, size, nmemb, stream);

//这个函数是为了符合CURLOPT\_PROGRESSFUNCTION而构造的

//显示文件传输进度，t代表文件大小，d代表传输已经完成部分

int my\_progress\_func(GtkWidget \*bar,

double t, /\* dltotal \*/

double d, /\* dlnow \*/

double ultotal,

double ulnow)

/\*  printf("%d / %d (%g %%)/n", d, t, d\*100.0/t);\*/

gdk\_threads\_enter();

gtk\_progress\_set\_value(GTK\_PROGRESS(bar), d\*100.0/t);

gdk\_threads\_leave();

return 0;

void \*my\_thread(void \*ptr)

CURL \*curl;

CURLcode res;

FILE \*outfile;

gchar \*url = ptr;

curl = curl\_easy\_init();

if(curl)

outfile = fopen("test.curl", "w");

curl\_easy\_setopt(curl, CURLOPT\_URL, url);

curl\_easy\_setopt(curl, CURLOPT\_WRITEDATA, outfile);

curl\_easy\_setopt(curl, CURLOPT\_WRITEFUNCTION, my\_write\_func);

curl\_easy\_setopt(curl, CURLOPT\_READFUNCTION, my\_read\_func);

curl\_easy\_setopt(curl, CURLOPT\_NOPROGRESS, 0L);

curl\_easy\_setopt(curl, CURLOPT\_PROGRESSFUNCTION, my\_progress\_func);

curl\_easy\_setopt(curl, CURLOPT\_PROGRESSDATA, Bar);

res = curl\_easy\_perform(curl);

fclose(outfile);

/\* always cleanup \*/

curl\_easy\_cleanup(curl);

return NULL;

int main(int argc, char \*\*argv)

GtkWidget \*Window, \*Frame, \*Frame2;

GtkAdjustment \*adj;

/\* Must initialize libcurl before any threads are started \*/

curl\_global\_init(CURL\_GLOBAL\_ALL);

/\* Init thread \*/

g\_thread\_init(NULL);

gtk\_init(&argc, &argv);

Window = gtk\_window\_new(GTK\_WINDOW\_TOPLEVEL);

Frame = gtk\_frame\_new(NULL);

gtk\_frame\_set\_shadow\_type(GTK\_FRAME(Frame), GTK\_SHADOW\_OUT);

gtk\_container\_add(GTK\_CONTAINER(Window), Frame);

Frame2 = gtk\_frame\_new(NULL);

gtk\_frame\_set\_shadow\_type(GTK\_FRAME(Frame2), GTK\_SHADOW\_IN);

gtk\_container\_add(GTK\_CONTAINER(Frame), Frame2);

gtk\_container\_set\_border\_width(GTK\_CONTAINER(Frame2), 5);

adj = (GtkAdjustment\*)gtk\_adjustment\_new(0, 0, 100, 0, 0, 0);

Bar = gtk\_progress\_bar\_new\_with\_adjustment(adj);

gtk\_container\_add(GTK\_CONTAINER(Frame2), Bar);

gtk\_widget\_show\_all(Window);

if (!g\_thread\_create(&my\_thread, argv\[1\], FALSE, NULL) != 0)

g\_warning("can't create the thread");

gdk\_threads\_enter();

gtk\_main();

gdk\_threads\_leave();

return 0;

编译export PKG\_CONFIG\_PATH=/usr/lib/pkgconfig/  
gcc progress.c –o progress \` pkg-config --libs –cflags gtk+-2..0\` -lcurl –lgthread-2.0

./ progress  [http://software.sky-union.cn/index.asp][http_software.sky-union.cn_index.asp]

3.4 断点续传实例

//采用CURLOPT\_RESUME\_FROM\_LARGE 实现文件断点续传功能

\#include <stdlib.h>

\#include <stdio.h>

\#include <sys/stat.h>

\#include <curl/curl.h>

//这个函数为CURLOPT\_HEADERFUNCTION参数构造

/\* 从http头部获取文件size\*/

size\_t getcontentlengthfunc(void \*ptr, size\_t size, size\_t nmemb, void \*stream) \{

int r;

long len = 0;

/\* \_snscanf() is Win32 specific \*/

// r = \_snscanf(ptr, size \* nmemb, "Content-Length: %ld/n", &len);

r = sscanf(ptr, "Content-Length: %ld/n", &len);

if (r) /\* Microsoft: we don't read the specs \*/

\*((long \*) stream) = len;

return size \* nmemb;

/\* 保存下载文件 \*/

size\_t wirtefunc(void \*ptr, size\_t size, size\_t nmemb, void \*stream)

return fwrite(ptr, size, nmemb, stream);

/\*读取上传文件 \*/

size\_t readfunc(void \*ptr, size\_t size, size\_t nmemb, void \*stream)

FILE \*f = stream;

size\_t n;

if (ferror(f))

return CURL\_READFUNC\_ABORT;

n = fread(ptr, size, nmemb, f) \* size;

return n;

// 下载 或者上传文件函数

int download(CURL \*curlhandle, const char \* remotepath, const char \* localpath,

long timeout, long tries)

FILE \*f;

curl\_off\_t local\_file\_len = -1 ;

long filesize =0 ;

CURLcode r = CURLE\_GOT\_NOTHING;

int c;

struct stat file\_info;

int use\_resume = 0;

/\* 得到本地文件大小 \*/

//if(access(localpath,F\_OK) ==0)

if(stat(localpath, &file\_info) == 0)

local\_file\_len =  file\_info.st\_size;

use\_resume  = 1;

//采用追加方式打开文件，便于实现文件断点续传工作

f = fopen(localpath, "ab+");

if (f == NULL) \{

perror(NULL);

return 0;

//curl\_easy\_setopt(curlhandle, CURLOPT\_UPLOAD, 1L);

curl\_easy\_setopt(curlhandle, CURLOPT\_URL, remotepath);

curl\_easy\_setopt(curlhandle, CURLOPT\_CONNECTTIMEOUT, timeout);  // 设置连接超时，单位秒

//设置http 头部处理函数

curl\_easy\_setopt(curlhandle, CURLOPT\_HEADERFUNCTION, getcontentlengthfunc);

curl\_easy\_setopt(curlhandle, CURLOPT\_HEADERDATA, &filesize);

// 设置文件续传的位置给libcurl

curl\_easy\_setopt(curlhandle, CURLOPT\_RESUME\_FROM\_LARGE, use\_resume?local\_file\_len:0);

curl\_easy\_setopt(curlhandle, CURLOPT\_WRITEDATA, f);

curl\_easy\_setopt(curlhandle, CURLOPT\_WRITEFUNCTION, wirtefunc);

//curl\_easy\_setopt(curlhandle, CURLOPT\_READFUNCTION, readfunc);

//curl\_easy\_setopt(curlhandle, CURLOPT\_READDATA, f);

curl\_easy\_setopt(curlhandle, CURLOPT\_NOPROGRESS, 1L);

curl\_easy\_setopt(curlhandle, CURLOPT\_VERBOSE, 1L);

r = curl\_easy\_perform(curlhandle);

fclose(f);

if (r == CURLE\_OK)

return 1;

else \{

fprintf(stderr, "%s/n", curl\_easy\_strerror(r));

return 0;

int main(int c, char \*\*argv) \{

CURL \*curlhandle = NULL;

curl\_global\_init(CURL\_GLOBAL\_ALL);

curlhandle = curl\_easy\_init();

//download(curlhandle, "[ftp://user:pass@host/path/file][ftp_user_pass_host_path_file]", "C://file", 0, 3);

download(curlhandle , "[http://software.sky-union.cn/index.asp","/work/index.asp",1,3][http_software.sky-union.cn_index.asp_work_index.asp_1_3]);

curl\_easy\_cleanup(curlhandle);

curl\_global\_cleanup();

return 0;

编译gcc  resume.c  -o resume –lcurl

./ resume

3.5 LibCurl调试实例

//采用CURLOPT\_DEBUGFUNCTION参数实现libcurl调试功能

\#include <stdio.h>

\#include <curl/curl.h>

struct data \{

char trace\_ascii; /\* 1 or 0 \*/

\};

static

void dump(const char \*text,

FILE \*stream, unsigned char \*ptr, size\_t size,

char nohex)

size\_t i;

size\_t c;

unsigned int width=0x10;

if(nohex)

/\* without the hex output, we can fit more on screen \*/

width = 0x40;

fprintf(stream, "%s, %zd bytes (0x%zx)/n", text, size, size);

for(i=0; i<size; i+= width) \{

fprintf(stream, "%04zx: ", i);

if(!nohex) \{

/\* hex not disabled, show it \*/

for(c = 0; c < width; c++)

if(i+c < size)

fprintf(stream, "%02x ", ptr\[i+c\]);

else

fputs("   ", stream);

for(c = 0; (c < width) && (i+c < size); c++) \{

/\* check for 0D0A; if found, skip past and start a new line of output \*/

if (nohex && (i+c+1 < size) && ptr\[i+c\]==0x0D && ptr\[i+c+1\]==0x0A) \{

i+=(c+2-width);

break;

fprintf(stream, "%c",

(ptr\[i+c\]>=0x20) && (ptr\[i+c\]<0x80)?ptr\[i+c\]:'.');

/\* check again for 0D0A, to avoid an extra /n if it's at width \*/

if (nohex && (i+c+2 < size) && ptr\[i+c+1\]==0x0D && ptr\[i+c+2\]==0x0A) \{

i+=(c+3-width);

break;

fputc('/n', stream); /\* newline \*/

fflush(stream);

static

int my\_trace(CURL \*handle, curl\_infotype type,

char \*data, size\_t size,

void \*userp)

struct data \*config = (struct data \*)userp;

const char \*text;

(void)handle; /\* prevent compiler warning \*/

switch (type) \{

case CURLINFO\_TEXT:

fprintf(stderr, "== Info: %s", data);

default: /\* in case a new one is introduced to shock us \*/

return 0;

case CURLINFO\_HEADER\_OUT:

text = "=> Send header";

break;

case CURLINFO\_DATA\_OUT:

text = "=> Send data";

break;

case CURLINFO\_SSL\_DATA\_OUT:

text = "=> Send SSL data";

break;

case CURLINFO\_HEADER\_IN:

text = "<= Recv header";

break;

case CURLINFO\_DATA\_IN:

text = "<= Recv data";

break;

case CURLINFO\_SSL\_DATA\_IN:

text = "<= Recv SSL data";

break;

dump(text, stderr, (unsigned char \*)data, size, config->trace\_ascii);

return 0;

int main(void)

CURL \*curl;

CURLcode res;

struct data config;

config.trace\_ascii = 1; /\* enable ascii tracing \*/  
   
=======================================================================

### [libwww,libcurl以及其他][libwww_libcurl]    ###

[http://blog.devep.net/virushuo/2007/03/11/libwww-or-libcurl.html][libwww_libcurl]

--------------------

最近我需要写点页面分析的东西，这些东西某些程度上类似搜索引擎的“爬虫->parser->存储”的过程。

过去我常用的抓取页面的库是[libcurl][libcurl 1]，这个东西是unix常用命令curl的基础，curl被称做“命令行浏览器”，功能强大，支持的协议也全面。遗憾的是libcurl仅仅是个支持多协议的抓取库，不能做解析。

找来找去，发现了w3c的[Libwww][]库，这东西功能强大的吓人，不仅有解析，还有robot(也就是爬虫了，或是叫internet walker）功能。在Libwww基础上完成的程序很多，最著名的大概是字符模式的浏览器lynx。我几乎就觉得这就我需要的东西了，立刻dive into。

一整天之后，我终于能用这东西抓下来页面，并且从html页面中分析出来一些信息了，但是想更进一步就变的异常困难。因为这个库功能太复杂了。这东西文档不详细，被人提及的也少。Libwww最近的Release 5.3.2，发布于2000年12月20日。一个有这么多年历史的东西，竟然没多少开发者在讨论，非常不正常。

找来找去，最后在libcurl的FAQ里面看到了和Libwww的[比较][Link 1]，精选的读者来信告诉我，不仅仅是我一个人被Libwww的复杂弄的晕了头脑，我才花了一整天，写信的那个哥们竟然用了一人月，还是在里面打转，直到换了 curl才好。虽然这是libcurl推销自己的方法，不过这些失败的前辈的经验让我对自己的智商重新有了信心。看来这东西没多少人讨论是正常的...

好吧，我也投降，libcurl没html解析功能，这没关系，我找别的办法好了...这么复杂的库，再好我也实在没办法忍受下去了，再说我需要的功能其实也真没Libwww那么复杂的。

写程序其实很容易迷失，你会看到一个似乎很完美，什么都能做的东西，一下子就喜欢上它，但是最后往往还是无福消受。往往是那些，不那么成熟，多少有点小毛病的库，组合在一起才是真正的解决方案。

=======================================================================  
from: http://www.9php.com/FAQ/cxsjl/c/2008/09/2520639129348.html  
  
使用libcurl的post方法上传数据，很奇怪奇怪的问题！！。。。  
  
使用libcurl的（9php.com）post方法上传数据，很奇怪奇怪的（9php.com）问题！！。。。  
  
我用libcurl将网页下载写到一个string对象中，然后对其处理－－取词。再用libcurl的（9php.com）post方法将内容上传，处理一条后就接着上传，60多条记录下来，发现有30多条没有上传上去。不知道什么原因。大家帮忙分析一下。。。  
  
2008-9-11 15:44lemonniu  
上传代码：  
int CurlUpload(string XMLCode，string xmlUid)  
\{        
  
CURL \*curl;                                                                                        
//        CURLcode response;    //定义CURLcode类型的（9php.com）变量  
        CURLcode code;  
        CURLcode retcode;  
        
        code=curl\_global\_init(CURL\_GLOBAL\_ALL);    //初始化所有可能的（9php.com）调用  
        if(code！=CURLE\_OK)  
        \{  
                cout<<"upload global init failed"<<endl;  
                return -1;  
        \}  
  
        curl = curl\_easy\_init();    //初始化一个CURL类型的（9php.com）指针  
        if(curl==NULL)  
        \{  
                cout<<"upload Failed create CURL connection"<<endl;        
                curl\_easy\_cleanup(curl);  
                return -1;  
        \}  
        
                code=curl\_easy\_setopt(curl，CURLOPT\_URL，"http://192.168.1.210/parser/save");  
                if(code！=CURLE\_OK)  
                \{  
                        cout<<"upload Failed set url"<<endl;  
                        curl\_easy\_cleanup(curl);  
                        return -1;  
                \}  
                string request="uid="+xmlUid;  
                request+="&xml="+XMLCode;  
  
                code=curl\_easy\_setopt(curl， CURLOPT\_POST， 1);  
                if(code！=CURLE\_OK)  
                \{  
                        curl\_easy\_cleanup(curl);  
                        cout<<"upload Failed set POST"<<endl;  
                        return -1;  
                \}  
                //code=curl\_easy\_setopt(curl， CURLOPT\_POSTFIELDS，request.c\_str());  
                code=curl\_easy\_setopt(curl，CURLOPT\_COPYPOSTFIELDS，request.c\_str());  
                if(code！=CURLE\_OK)  
                \{  
                        curl\_easy\_cleanup(curl);  
                        cout<<"upload Failed set postfields"<<endl;  
                        return -1;  
                \}  
  
                code=curl\_easy\_perform(curl);  
                if(code！=CURLE\_OK)  
                \{  
                        curl\_easy\_cleanup(curl);  
                        cout<<"upload Failed to upload data"<<endl;  
                        return -1;  
                \}  
  
                code=curl\_easy\_getinfo(curl，CURLINFO\_RESPONSE\_CODE，&retcode);  
                if ( (code == CURLE\_OK) && retcode == 200 )  
                \{        
                        cout<<retcode<<endl;  
                        cout<<"send ok"<<endl;  
                        sum++;  
                        curl\_easy\_cleanup(curl);  
                        return 1;  
                \}  
                else  
                \{  
                        //curl\_easy\_cleanup(curl);  
                        return -1;  
                \}  
                
\}  
=======================================================================  
from: http://blog.163.com/xu\_chao2000/blog/static/27770610200801303252802/  
  
libcurl应用：如何把下载内容写入内存

libcurl 的文档中有getinmemory.c这个例子，把下载的网页写入自己定义的一个memorystruct中，看了这个例子的做法，它需要自己照顾内存的开辟，特别是需要在curl\_easy\_perform的调用函数中释放已开辟的内存，很不利于函数的封装，而且应用于multihandle的时候，运行时会出莫名其妙的assert错误。因此改写了一下，将下载的内容放入stl的string中，这样根本不需要自己照顾内存的开辟和释放。源代码如下：

\#include <string>  
\#include "curl.h"

using namespace std;  
static char errorBuffer\[CURL\_ERROR\_SIZE\];  
static int writer(char \*, size\_t, size\_t, string \*);  
static bool init(CURL \*&, char \*,string \*);

int main()  
\{  
    CURL \*conn = NULL;  
    CURLcode code;  
 string buffer;  
   
    curl\_global\_init(CURL\_GLOBAL\_DEFAULT);  
    char\* url="[http://cool.haxx.se/][http_cool.haxx.se]";  
 if (!init(conn,url,&buffer ))  
    \{  
        fprintf(stderr, "Connection initializion failed/n");  
        exit(EXIT\_FAILURE);  
    \}  
    code = curl\_easy\_perform(conn);  
    
    if (code != CURLE\_OK)  
    \{  
        fprintf(stderr, "Failed to get '%s' \[%s\]/n", url, errorBuffer);  
        exit(EXIT\_FAILURE);  
    \}  
 curl\_easy\_cleanup(conn);  
 printf("%s/n",buffer.c\_str());  
    return 0;  
     
\}

static bool init(CURL \*&conn, char \*url,string \*p\_buffer)  
\{  
    CURLcode code;  
    conn = curl\_easy\_init();  
    if (conn == NULL)  
    \{  
        fprintf(stderr, "Failed to create CURL connection/n");  
        exit(EXIT\_FAILURE);  
    \}  
    code = curl\_easy\_setopt(conn, CURLOPT\_ERRORBUFFER, errorBuffer);  
    if (code != CURLE\_OK)  
    \{  
        fprintf(stderr, "Failed to set error buffer \[%d\]/n", code);  
        return false;  
    \}  
    code = curl\_easy\_setopt(conn, CURLOPT\_URL, url);  
    if (code != CURLE\_OK)  
    \{  
        fprintf(stderr, "Failed to set URL \[%s\]/n", errorBuffer);  
        return false;  
    \}  
    code = curl\_easy\_setopt(conn, CURLOPT\_FOLLOWLOCATION, 1);  
    if (code != CURLE\_OK)  
    \{  
        fprintf(stderr, "Failed to set redirect option \[%s\]/n", errorBuffer);  
        return false;  
    \}  
    code = curl\_easy\_setopt(conn, CURLOPT\_WRITEFUNCTION, writer);  
    if (code != CURLE\_OK)  
    \{  
        fprintf(stderr, "Failed to set writer \[%s\]/n", errorBuffer);  
        return false;  
    \}  
    code = curl\_easy\_setopt(conn, CURLOPT\_WRITEDATA, p\_buffer);  
    if (code != CURLE\_OK)  
    \{  
        fprintf(stderr, "Failed to set write data \[%s\]/n", errorBuffer);  
        return false;  
    \}  
    return true;  
\}

static int writer(char \*data, size\_t size, size\_t nmemb, string \*writerData)  
\{  
    unsigned long sizes = size \* nmemb;  
    if (writerData == NULL) return 0;  
    writerData->append(data, sizes);  
    return sizes;  
\}

[http_blog.chinaunix.net_u1_47395_showart_1768832.html]: http://blog.chinaunix.net/u1/47395/showart_1768832.html
[Libcurl]: http://blog.csdn.net/hwz119/archive/2007/04/29/1591920.aspx
[Linux]: http://blog.csdn.net/hwz119/archive/2007/04/30/1592577.aspx
[HTTP_C]: http://blog.csdn.net/hwz119/archive/2007/04/29/1591817.aspx
[Libcurl 1]: http://blog.vckbase.com/michael/archive/2005/11/29/15426.html
[http_curl.haxx.se_libcurl]: http://curl.haxx.se/libcurl/
[www.openssl.org]: http://www.openssl.org/
[http_www.zlib.net]: http://www.zlib.net/
[None.gif]: http://blog.vckbase.com/Images/OutliningIndicators/None.gif
[ExpandedBlockStart.gif]: http://blog.vckbase.com/Images/OutliningIndicators/ExpandedBlockStart.gif
[ContractedBlock.gif]: http://blog.vckbase.com/Images/OutliningIndicators/ContractedBlock.gif
[dot.gif]: http://blog.vckbase.com/Images/dot.gif
[InBlock.gif]: http://blog.vckbase.com/Images/OutliningIndicators/InBlock.gif
[ExpandedSubBlockStart.gif]: http://blog.vckbase.com/Images/OutliningIndicators/ExpandedSubBlockStart.gif
[ContractedSubBlock.gif]: http://blog.vckbase.com/Images/OutliningIndicators/ContractedSubBlock.gif
[ExpandedSubBlockEnd.gif]: http://blog.vckbase.com/Images/OutliningIndicators/ExpandedSubBlockEnd.gif
[ExpandedBlockEnd.gif]: http://blog.vckbase.com/Images/OutliningIndicators/ExpandedBlockEnd.gif
[libcurl]: http://www.cppblog.com/qiujian5628/archive/2008/06/28/54873.html
[http_curl.haxx.se_libcurl_c]: http://curl.haxx.se/libcurl/c/
[curl_easy_setopt]: http://curl.haxx.se/libcurl/c/curl_easy_setopt.html
[curl_easy_perform]: http://curl.haxx.se/libcurl/c/curl_easy_perform.html
[curl_easy_getinfo]: http://curl.haxx.se/libcurl/c/curl_easy_getinfo.html
[http_blog.163.com_xu_chao2000_blog_static_27770610200801303252802]: http://blog.163.com/xu_chao2000/blog/static/27770610200801303252802/
[None.gif 1]: /images/20220709/79804dfc44a54e3993dd28860819a8fb.png
[ExpandedBlockStart.gif 1]: http://www.cppblog.com/Images/OutliningIndicators/ExpandedBlockStart.gif
[ContractedBlock.gif 1]: http://www.cppblog.com/Images/OutliningIndicators/ContractedBlock.gif
[dot.gif 1]: /images/20220709/b990de52321b469582cb040f9b89a138.png
[InBlock.gif 1]: /images/20220709/055909e6a9b848189d10a493b336a21f.png
[ExpandedSubBlockStart.gif 1]: http://www.cppblog.com/Images/OutliningIndicators/ExpandedSubBlockStart.gif
[ContractedSubBlock.gif 1]: http://www.cppblog.com/Images/OutliningIndicators/ContractedSubBlock.gif
[ExpandedSubBlockEnd.gif 1]: /images/20220709/d926b61ad24a4ff885150c629f7e8901.png
[ExpandedBlockEnd.gif 1]: /images/20220709/330297d35ad44681b555d63c37924389.png
[blank.gif]: /images/20220709/db3c43f494e8405096581ddbfa1753d8.png
[Joomla_]: http://www.maycode.com/
[www.baidu.com]: http://www.baidu.com/
[http_software.sky-union.cn_index.asp]: http://software.sky-union.cn/index.asp
[ftp_user_pass_host_path_file]: ftp://user:pass@host/path/file
[http_software.sky-union.cn_index.asp_work_index.asp_1_3]: http://software.sky-union.cn/index.asp%22,%22/work/index.asp%22,1,3
[libwww_libcurl]: http://blog.devep.net/virushuo/2007/03/11/libwww-or-libcurl.html
[libcurl 1]: http://curl.haxx.se/libcurl
[Libwww]: http://www.w3.org/Library/
[Link 1]: http://curl.haxx.se/libcurl/libwww.html
[http_cool.haxx.se]: http://cool.haxx.se/