笔记整理--LibCurl开发
LibCurl开发_未了的雨_百度空间 - Google Chrome (2013/7/26 21:11:15)
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（）释放内存
二：重要函数
1、CURLcode curl_global_init(long flags); //初始化libcurl
描述：这个函数只能用一次。(其实在调用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( ); //得到 easy interface型指针
描述: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型的变量.它用什么这取决于第二个参数.
(4) CURLoption 这个参数的取值很多.具体的可以查看man手册.
描述:这个函数在初始化CURL类型的指针 以及curl_easy_setopt完成后调用. 就像字面的意思所说perform就像是个舞台.让我们设置的option 运作起来.
参数:CURL类型的指针.
补充：
(1)在连接过程中，如果出现异常，如网线拔掉，返回CURLE_COULDNT_CONNECT;
(2)在下载过程中，即已经连接上了，后面如果出现异常，如网线拔掉,返回CURLE_OPERATION_TIMEOUTED
9、curl_slist_free_all(slist); // free the list again
10、curl_formadd(struct curl_httppost ** firstitem, struct curl_httppost ** lastitem, ...) //add a section to a multipart/formdata HTTP POST
/****************************************************************/
libcurl note（Http应用)
设置Callback function处理Http头，返回内容，进度
CURLOPT_WRITEFUNCTION
CURLOPT_WRITEDATA
CURLOPT_HEADERDATA
CURLOPT_PROGRESSFUNCTION
CURLOPT_PROGRESSDATA
设置连接等待时间，传输等待时间：
CURLOPT_TIMEOUT:CURLOPT_CONNECTIONTIMEOUT:
设置重定位URL：
CURLOPT_FOLLOWLOCATION实现断点续传：
CURLOPT_RANGE:
CURLOPT_RESUME_FROM:
CURLOPT_RESUME_FROM:
注： 在我的测试中 这两个参数无效。
设置RANGE后 下载全部数据，而不是后续数据;
设置RESUME_FROM后，程序无响应。
Range: bytes=xx- [可以用来实现断点续传]
User-Agent: xx
Location: [网页重定位 url]
Set-Cookie: [Cookie]
Content-Length: [报文长度]
Content-Type: [报文类型]
/****************************************************************/
三：应用实例
1、为什么要使用libcurl,
(1)作为http的客户端，可以直接用socket连接服务器，然后对到的数据进行http解析，但要分析协议头，实现代理…这样太麻烦了。
(2)libcurl是一个开源的客户端url传输库，支持FTP，FTPS，TFTP，HTTP，HTTPS，GOPHER，TELNET，DICT，FILE和LDAP，支持Windows，Unix，Linux等平台，简单易用，且库文件占用空间不到200K。
2、get和post方式
客户端在http连接时向服务提交数据的方式分为get和post两种
(1)Get方式将所要传输的数据附在网址后面，然后一起送达服务器，它的优点是效率比较高；缺点是安全性差、数据不超过1024个字符、必须是7位的ASCII编码；查询时经常用此方法。
(2)Post通过Http post处理发送数据，它的优点是安全性较强、支持数据量大、支持字符多；缺点是效率相对低；编辑修改时多使用此方法。
3、cookie与session
(1)cookie是发送到客户浏览器的文本串句柄，并保存在客户机硬盘上，可以用来在某个Web站点会话之间持久地保持数据。cookie在客户端。
(2)session是访问者从到达某个特定主页到离开为止的那段时间。每一访问者都会单独获得一个session，实现站点多个用户之间在所有页面中共享信息。session在服务器上。
(3)libcurl中使用cookie,保存cookie, 使之后的链接与此链接使用相同的cookie
(3.1)在关闭链接的时候把cookie写入指定的文件: curl_easy_setopt(curl, CURLOPT_COOKIEJAR, "/tmp/cookie.txt");
(3.2)取用现在有的cookie，而不重新得到cookie: curl_easy_setopt(curl, CURLOPT_COOKIEFILE, "/tmp/cookie.txt");
4、http与https的区别
(1)Http是明文发送，任何人都可以拦截并读取内容
(2)Https是加密传输协议，用它传输的内容都是加密过的，https是http的扩展，其安全基础是SSL协议
5、base64编码
(1)如果要传一段包含特殊字符比较多的数据，直接上传就需要处理转意符之类的很多问题，用base64编码，它可以把数据转成可读的字串，base64由a-z, A-Z, +/总计64个字符组成。
(2)由于base64的组成部分有加号，而加号是url中的转意字符，所以无论是get方式还是post，传到服务器的过程中，都会把加号转成空格，所以在传base64之前需要把base64编码后的加号替换成”%2B”，这样就可以正常发送了。
6、curl_setop()函数中的参数中文说明
curl_setopt()函数将为一个CURL会话设置选项。option参数是你想要的设置，value是这个选项给定的值。下列选项的值将被作为长整形使用(在option参数中指定)
代码例程
libcurl 使用笔记 - 喜欢初美 - 博客大巴 - Google Chrome (2013/7/26 17:50:53)
libcurl 使用笔记
日期：2009-12-24 | 分类：c & c++
使用 cURL 和 libcurl 通过 Internet 进行对话 - Google Chrome (2013/7/26 16:58:48)
使用 cURL 和 libcurl 通过 Internet 进行对话
将 libcurl 与 C 以及 Python 结合使用
简介： cURL 是一个命令行工具，可以对文件传输使用许多协议，包括 HTTP、FTP、Secure Copy (SCP)、Telnet 等等。但是，除了可以用命令行通过 Internet 与端点对话外，还可以使用 libcurl 编写简单或复杂的程序，以自动化执行应用层的协议任务。本文将介绍 cURL 命令行工具，然后向您展示如何使用 libcurl 以及 C 和 Python 构建一个 HTTP 客户端。
开发 HTTP 和 FTP 之类依赖于应用层协议的应用程序并不复杂，但也不简单。进一步讲，这不是应用程序的重点，因为大部分情况下，协议之上的内容才是真正重要的内容。因此，libcurl 引起了许多人的兴趣，因为它的重点是应用程序而不是开发的各个方面。注意，很少有应用程序开发自己的 TCP/IP 堆栈，所以老话重提：尽可能重用以最小化开发安排并提高应用程序的可靠性。
本文首先简单介绍应用层协议，然后介绍 cURL、libcurl 并解释它们的用法。
如今构建应用程序已与过去大不相同。现在的应用程序需要能够通过网络或 Internet 进行通讯（提供人类可用的网络 API 或接口），还要能支持用户脚本化以提高灵活性。现代应用程序通常使用 HTTP 公开 Web 接口，并通过 Simple Mail Transport Protocol (SMTP) 提供警告通知。这些协议允许您将 Web 浏览器指向设备以获得配置或状态信息，并从设备或常用的电子邮件客户端接收标准电子邮件（分别通过 HTTP 和 SMTP）。
这些 Web 服务通常构建在网络堆栈的套接字层上（见图 1）。套接字层实现一个最先出现在 Berkeley Software Distribution (BSD) 操作系统上的 API，并提取底层传输和网络层协议的详细信息。
图 1. 网络堆栈和 libcurl
Web 服务发生在客户端和服务器之间的协议对话中。在 HTTP 上下文中，服务器是终端设备，客户端是位于端点上的浏览器。对于 SMTP，服务器是邮件网关或端点用户，客户端是终端设备。在某些情况下，协议对话发生在两个步骤（请求和响应）中，但另一些情况下，需要协商和通讯的通信量更多。这种协商可能增加了大量复杂性，这可以通过 API 进行抽象，比如 libcurl。
cURL 最初的设计初衷是使用不同的协议（比如 FTP、HTTP、SCP 等）在端点之间移动文件。它最初是一个命令行实用工具，但现在也是一个绑定了 30 多种语言的库。因此，现在不仅可以通过 shell 使用 cURL，您还可以构建合并了这个重要功能的应用程序。libcurl 库也是可以移植的，支持 Linux®、IBM®AIX®操作系统、BSD、Solaris 以及许多其他 UNIX®变体。
获取和安装 libcurl 非常简单，取决于您所运行的 Linux 发行版。如果运行的是 Ubuntu，您可以使用 apt-get轻松安装这些包。以下行演示了如何为 libcurl 安装 libcurl 和 Python 绑定：
$ sudo apt-get install libcurl3 $ sudo apt-get install python-pycurl |
apt-get实用工具确保该过程满足所有的依赖关系。
cURL 最开始是一个命令行工具，可以使用 Uniform Resource Locator (URL) 语法执行数据传输。考虑到它在命令行上的流行度，后来创建了一个可以在应用程序中生成这些行为的库。如今，命令行 cURL 是 cURL 库的包装器。本文首先研究 cURL 作为命令行的功能，然后深入探讨如何将它作为库使用。
cURL 的两种常见用法是使用 HTTP 和 FTP 协议进行文件传输。cURL 为这些协议提供一个简单的接口。要使用 HTTP 从网站获取文件，只需告诉 cURL 您要将网页写入到其中的本地文件的文件名、网站的 URL 以及要获取的文件。让我们看一下清单 1 中的简单命令行示例。
清单 1. 使用 cURL 从网站获取文件的示例
$ curl -o test html www.exampledomain.com
% Total % Received % Xferd Average Speed Time Time Time Current
Dload Upload Total Spent Left Speed
100 43320 100 43320 0 0 55831 0 --:--:-- --:--:-- --:--:-- 89299
$
|
注意，由于我指定了域而不是文件，我将获得根文件（index.html）。要使用 cURL 将该文件移动到 FTP 站点，可以使用 -T选项指定要上传的文件，然后提供 FTP 站点的 URL 以及文件的路径。
清单 2. 使用 cURL 将文件上传到 FTP 站点的示例
$ curl -T test.html ftp://user:password@ftp.exampledomain.com/ftpdir/
% Total % Received % Xferd Average Speed Time Time Time Current
Dload Upload Total Spent Left Speed
100 43320 0 0 100 43320 0 38946 0:00:01 0:00:01 --:--:-- 124k
$
|
是不是很简单？学习了一些模式之后您会发现，cURL 使用起来非常简单。但是您可以使用的选项非常多 —在 cURL 命令行中请求帮助（使用 --help）可以得到 129 行选项。如果您觉得这还不算太多，那么还有一大批其他控制选项（从详细度到安全性），以及特定于协议的配置项。
从开发人员的角度看，这还不算是 cURL 最令人兴奋的地方。让我们深入了解 cURL 库，学习如何向应用程序添加文件传输协议。
如果您有 10 年以上的脚本语言经验，您就会注意到它们的标记有很大的变化。Python、Ruby、Perl 等这些脚本语言不仅包含套接字层（C 或 C++ 中也有），还包含了应用层协议 API。这些脚本语言合并了高级功能，可以创建 HTTP 服务器或客户端。libcurl 库为 C 和 C++ 之类的语言添加了类似的功能，但是它可以在不同的语言之间移植。在所有它支持的语言中都能找到与 libcurl 相当的行为，但是由于这些语言的差异很大（设想一下 C 和 Scheme），提供这些行为的方式也很不相同。
libcurl 库以 API 的形式封装清单 1和清单 2中描述的行为，因此它可以被高级语言使用（如今已超过 30 种）。本文提供了 libcurl 的两个示例。第一个示例研究使用 c 构建的简单 HTTP 客户端（适合构建 Web 爬行器），第二个示例是一个使用 Python 创建的简单 HTTP 客户端。
C API 在 libcurl 功能上提供了两个 API。easy 接口是一个简单的同步 API（意味着当您使用请求调用 libcurl 时，将能够满足您的请求，直到完成或发生错误）。多接口可以进一步控制 libcurl，您的应用程序可以执行多个同步传输，并控制 libcurl 何时何地移动数据。
该示例使用 easy 接口。该 API 还能控制数据移动过程（使用回调），但正如其名称所示，使用起来非常简单。清单 3 提供了 HTTP 的 C 语言示例。
清单 3. 使用 libcurl easy 接口的 C HTTP 客户端
#include <stdio.h>
#include <string.h>
#include <curl/curl.h>
#define MAX_BUF 65536
char wr_buf[MAX_BUF+1];
int wr_index;
/*
* Write data callback function (called within the context of
* curl_easy_perform.
*/
size_t write_data( void *buffer, size_t size, size_t nmemb, void *userp )
{
int segsize = size * nmemb;
/* Check to see if this data exceeds the size of our buffer. If so,
* set the user-defined context value and return 0 to indicate a
* problem to curl.
*/
if ( wr_index + segsize > MAX_BUF ) {
*(int *)userp = 1;
return 0;
}
/* Copy the data from the curl buffer into our buffer */
memcpy( (void *)&wr_buf[wr_index], buffer, (size_t)segsize );
/* Update the write index */
wr_index += segsize;
/* Null terminate the buffer */
wr_buf[wr_index] = 0;
/* Return the number of bytes received, indicating to curl that all is okay */
return segsize;
}
/*
* Simple curl application to read the index.html file from a Web site.
*/
int main( void )
{
CURL *curl;
CURLcode ret;
int wr_error;
wr_error = 0;
wr_index = 0;
/* First step, init curl */
curl = curl_easy_init();
if (!curl) {
printf("couldn't init curl\n");
return 0;
}
/* Tell curl the URL of the file we're going to retrieve */
curl_easy_setopt( curl, CURLOPT_URL, "www.exampledomain.com" );
/* Tell curl that we'll receive data to the function write_data, and
* also provide it with a context pointer for our error return.
*/
curl_easy_setopt( curl, CURLOPT_WRITEDATA, (void *)&wr_error );
curl_easy_setopt( curl, CURLOPT_WRITEFUNCTION, write_data );
/* Allow curl to perform the action */
ret = curl_easy_perform( curl );
printf( "ret = %d (write_error = %d)\n", ret, wr_error );
/* Emit the page if curl indicates that no errors occurred */
if ( ret == 0 ) printf( "%s\n", wr_buf );
curl_easy_cleanup( curl );
return 0;
}
|
最上方是必需的 include文件，包括 cURL 根文件。接下来，我定义了两个用于传输的变量。第一个变量是 wr_buf，表示将在其中写入传入数据的缓冲区。wr_index表示缓冲区的当前写入索引。
转到 main函数，该函数使用 easy API 进行设置。所有 cURL 调用都通过维护特定请求状态的句柄进行操作。这称为 CURL指针引用。本例还创建一个特殊的返回码，称为 CURLcode。在使用任何 libcurl 函数之前，您需要调用 curl_easy_init获取 CURL句柄。接下来，注意 curl_easy_setopt调用的数量。它们为特定的操作配置句柄。对于这些调用，您提供句柄、命令和选项。首先，本例使用CURLOPT_URL指定要获取的 URL。然后，它使用 CURL_WRITEDATA提供一个上下文变量（在本例中，它是内部的 write 错误变量）。最后，它使用 CURLOPT_WRITEFUNCTION指定数据可用时应该调用的函数。在启动 API 之后，API 将使用它读取的数据多次调用该函数。
要开始传输，调用 curl_easy_perform。它的工作是根据之前的配置执行传输。调用该函数时，在完成传输或发生错误之前该函数不会返回。main的最后一步是提交返回状态，提交页面读取，最后使用 curl_easy_cleanup清除（当使用句柄执行完操作后）。
现在看看 write_data函数。该函数是针对特定操作收到数据时调用的回调。注意，当您从网站读取数据时，将写入该数据（write_data）。将向回调提供一个缓冲区（包含可用数据）、成员数量和大小（缓冲中可用数据总量）、上下文指针。第一个任务是确保缓冲区（wr_buf）的空间足以写入数据。如果不够，它将设置上下文指针并返回 0，表示出现问题。否则，它将 cURL 缓冲区的数据复制到您的缓冲区，并增加索引，指向要写入的下一个位置。本例还终止字符串，稍后可以对其使用 printf。最后，它返回 libcurl 操作的字节数量。这将告诉 libcurl 数据被提取，它也可以丢弃该数据。这就是从网站将文件读取到内存的相对简单的方法。
本节提供的示例类似于基于 C 的 HTTP 客户端，不过它使用的是 Python。Python 是一种非常有用的面向对象的脚本语言，在原型化和构建生产软件方面非常突出。示例假设您较熟悉 Python，但使用不多，因此不要期望过高。
这个简单的 Python HTTP 客户端使用 pycurl，如清单 4 所示。
清单 4. 使用 libcurl 的
pycurl接口的 Python HTTP 客户端import sys import pycurl wr_buf = '' def write_data( buf ): global wr_buf wr_buf += buf def main(): c = pycurl.Curl() c.setopt( pycurl.URL, 'http://www.exampledomain.com' ) c.setopt( pycurl.WRITEFUNCTION, write_data ) c.perform() c.close() main() sys.stdout.write(wr_buf) |
这比 C 语言版本简单的多。它首先导入必需的模块（用于标准系统的sys和 pycurl模块）。接下来，它定义 write 缓冲区（wr_buf）。像 C 程序中一样，我声明一个 write_data函数。注意，该函数只有一个参数：从 HTTP 服务器中读取的数据缓冲区。我将该缓冲区连接到全局 write 缓冲区。main函数首先创建一个 Curl句柄，然后使用 setopt方法为传输定义 URL和 WRITEFUNCTION。它调用 perform方法启动传输并关闭句柄。最后，它调用 main函数，并将 write 缓冲区提交到 stdout。注意，在这种情况下，您不需要错误上下文指针，因为您使用了 Python 字符串连接，这就是说您不会使用大小固定的字符串。
本文仅仅简单介绍了 libcurl，介绍了它支持的多种协议和语言。希望这能够展示它如何轻松构建使用应用层协议（如 HTTP）的应用程序。libcurl 网站（见 参考资料）提供了很多示例和有用的文档。下一次开发 Web 浏览器、爬行器或其他有应用层协议要求的应用程序时，试试 libcurl。它一定能大大减少您的开发时间，并找回编码的乐趣。
学习
- cURL是一个命令行工具和库，实现了各种客户端协议。它支持 12 种以上的协议，包括 FTP、HTTP、Telnet 以及其他安全变体。许多平台上都能找到 cURL，包括 Linux、AIX、BSD 和 Solaris，它支持 30 多种语言。
- PycURL是 libcurl API 之上的一个薄层，PycURL 速度非常快。使用 PycURL，您可以使用 libcurl 库开发 Python 应用程序。
- 说到应用程序灵活性，您可以在 “用 Guile 编写脚本” 中了解更多有关将脚本功能集成到应用程序的内容。
- 要收听有关软件开发人员的有趣采访和讨论，请查看 developerWorks 网络广播。
- 了解最新的 developerWorks 技术活动 和 网络广播。
- 在 Twitter 上跟随 developerWorks。
- 查阅最近将在全球举办的面向 IBM 开放源码开发人员的研讨会、交易展览、网络广播和其他 活动。
- 访问 developerWorks 开源专区获得丰富的 how-to 信息、工具和项目更新，帮助您用开放源码技术进行开发，并与 IBM 产品结合使用。
- 查看免费的 developerWorks On demand 演示，观看并了解 IBM 及开源技术和产品功能。
获得产品和技术
- 使用 IBM 试用软件改进您的下一个开发项目，这些软件可以通过下载中心获得。
- 下载 IBM 产品评估版 或 在 IBM SOA Sandbox 中研究在线试用版，开始使用来自 DB2®、Lotus®、Rational®、Tivoli®和 WebSphere®的应用程序开发工具和中间件产品。
fatal error: curl/curl.h: No such file or directory | Ubuntu 12.04 from alexsleat.co.uk - Google Chr (2013/7/26 16:49:05)
fatal error: curl/curl.h: No such file or directory | Ubuntu 12.04
If you’re missing the curl/curl.h header file, chances are you’re just missing the correct dev package file for the curl library.
That should fix it.
curl_easy_getinfo() -- 从 curl 句柄里获得附加信息|Functions - 曲径通幽 - Standing on the shoulders of giants - Goo (2013/5/23 17:52:30)
curl_easy_getinfo() 函数原型声明如下：1 2 | #include <curl/curl.h>CURLcode curl_easy_getinfo(CURL *curl, CURLINFO info, ... ); |
使用该函数可以在请求求 curl 会话中的相关信息。注意，第 3 个参数必须是一个 long 型，或char型，或curl_slist型，抑或是double型的指针。函数所请求信息只有在函数返回 CURLE_OK 时才会被有效填充，该函数一般用在 perform 函数(如 curl_easy_perform() )之后。
第 2 个参数有众多选项，每个选项都有其相应的含义：
CURLINFO_SIZE_DOWNLOAD
使用该选项时要求第 3 个参数是个 double 型的指针，这样在一次传输成功后会将本次传输所下载的字节数赋值到指针所指向的 double 型变量中。注意，这个字节数只能反映最近一次的下载。
CURLINFO_SPEED_DOWNLOAD
该选项要求传递一个 double 型参数指针，用以接收下载的平均速度，这个速度不是即时速度，而是下载完成后的速度，单位是 字节/秒 。
CURLINFO_TOTAL_TIME
该选项要求传递一个 double 指针到函数中，double 型变量指示了传输的总耗时(单位为秒)，这个总的时间里包括了域名解析，以及 TCP 连接过程中所需要的时间。
CURLINFO_CONTENT_TYPE
该选项获得 HTTP 中从服务器端收到的头部中的 Content-Type 信息。
测试代码：
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 | #include <stdio.h>#include <curl/curl.h>#include <stdlib.h>#include <string.h>int main(void){ CURL *curl; CURLcode res; FILE *fp; if (!(fp = fopen ("info.html", "w+"))) { perror("fopen error:"); exit (EXIT_FAILURE); } curl = curl_easy_init(); if(curl) { res = curl_easy_perform(curl); if(CURLE_OK == res) { char *contype; res = curl_easy_getinfo(curl, CURLINFO_CONTENT_TYPE, &contype); if((CURLE_OK == res) && ct) fwrite (contype, 1, strlen(contype), fp); fwrite ("\n\0", 1, 1, fp); //为了在 vi 里看起来完全正常,需要添加换行符和 NULL } close (fp); curl_easy_cleanup(curl); } return 0;} |
运行输出：
$ cat info.html
text/html;charset=gb2312
CURLINFO_FILETIME
使用该选项时需要传递一个 long 型指针到函数，该 long 型变量中保存了远程主机上的文件的最近修改日期。如果使用该值时函数返回 -1，原因是多样的(比如一些未知的，比如服务器对此日期信息做了隐藏，或者是服务器不支持获取文档时间的命令等等)。需要注意的是，在使用该选项时，需要先在 curl_easy_setopt() 函数中使用 CURLOPT_FILETIME 选项，然后再运行 curl_easy_perform() 后，方能获得服务器上的文档时间。
CURLINFO_CONTENT_LENGTH_DOWNLOAD
使用该选项时要求传递一个 double 型指针到函数中，该 double 型变量用来存放所要下载文件(或者是所要查询的文件)的 content-length (文档长度) 的信息。如果文件大小无法获取，那么函数返回值为 -1 。
CURLINFO_FILETIME 和 CURLINFO_CONTENT_LENGTH_DOWNLOAD 选项使用示例，下面代码获取 FTP 服务器上的一个文件的时间和大小信息：
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 | #include <stdio.h>#include <stdlib.h>#include <string.h>#include <curl/curl.h>#include <curl/easy.h>static size_t save_header(void *ptr, size_t size, size_t nmemb, void *data){ return (size_t)(size * nmemb);}int main(void){ CURL *curl; CURLcode res; const time_t filetime; const double filesize; const char *filename = strrchr(ftpurl, '/') + 1; curl_global_init(CURL_GLOBAL_ALL); curl = curl_easy_init(); if (curl) { curl_easy_setopt(curl, CURLOPT_URL, ftpurl); curl_easy_setopt(curl, CURLOPT_NOBODY, 1L); curl_easy_setopt(curl, CURLOPT_FILETIME, 1L); curl_easy_setopt(curl, CURLOPT_HEADERFUNCTION, save_header); curl_easy_setopt(curl, CURLOPT_HEADER, 0L); //curl_easy_setopt(curl, CURLOPT_VERBOSE, 1L); curl_easy_perform(curl); if (res != CURLE_OK) { res = curl_easy_getinfo(curl, CURLINFO_FILETIME, &filetime); if ((CURLE_OK == res) && filetime) printf ("filetime %s: %s", filename, ctime(&filetime)); res = curl_easy_getinfo(curl, CURLINFO_CONTENT_LENGTH_DOWNLOAD, &filesize); if ((CURLE_OK == res) && (filesize > 0)) printf ("filesize %s: %0.0f bytes\n", filename, filesize); } else { fprintf (stderr, "curl told us %d\n", res); } curl_easy_cleanup(curl); } curl_global_cleanup(); return 0;} |
运行输出：
beyes@debian:~/C/curl$ ./getftpinfo
Last-Modified: Mon, 25 Apr 2011 15:26:56 GMT
Content-Length: 1758
Accept-ranges: bytes
filetime favicon.ico: Mon Apr 25 11:26:56 2011
filesize favicon.ico: 1758 bytes
C++ 用libcurl库进行http通讯网络编程 - 绿色冰点 - 博客园 - Google Chrome (2013/5/23 16:59:53)
一、LibCurl基本编程框架 二、一些基本的函数 三、curl_easy_setopt函数部分选项介绍 四、curl_easy_perform 函数说明（error 状态码） 五、libcurl使用的HTTP消息头
六、获取http应答头信息 七、多线程问题 八、什么时候libcurl无法正常工作 九、关于密码 十、HTTP验证 十一、代码示例 1.基本的http GET/POST操作 2 获取html网页 3 网页下载保存实例 4 进度条实例显示文件下载进度 5 断点续传实例
libcurl是一个跨平台的网络协议库，支持http, https, ftp, gopher, telnet, dict, file, 和ldap 协议。libcurl同样支持HTTPS证书授权，HTTP POST, HTTP PUT, FTP 上传, HTTP基本表单上传，代理，cookies,和用户认证。想要知道更多关于libcurl的介绍，可以到官网 http://curl.haxx.se/上去了解，在这里不再详述。
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程序都要使用它。
二、一些基本的函数
1.CURLcode curl_global_init(long flags);
描述：
这个函数只能用一次。(其实在调用curl_global_cleanup 函数后仍然可再用)
如果这个函数在curl_easy_init函数调用时还没调用，它讲由libcurl库自动调用，所以多线程下最好主动调用该函数以防止在线程中curl_easy_init时多次调用。
参数：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_handle(CURL*对象), 一般都用在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);
option 运作起来.参数:
CURL类型的指针.
三、 curl_easy_setopt函数部分选项介绍
本节主要介绍curl_easy_setopt中跟http相关的参数。该函数是curl中非常重要的函数，curl所有设置都是在该函数中完成的，该函数的设置选项众多，注意本节的阐述的只是部分常见选项。
设置访问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
8. 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，指定你希望开始传递的 偏移量。
四、 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
读本地文件错误
五、libcurl使用的HTTP消息头
当使用libcurl发送http请求时，它会自动添加一些http头。我们可以通过CURLOPT_HTTPHEADER属性手动替换、添加或删除相应
的HTTP消息头。
Host
http1.1（大部分http1.0)版本都要求客户端请求提供这个信息头。
Pragma
"no-cache"。表示不要缓冲数据。
Accept
"*/*"。表示允许接收任何类型的数据。
Expect
以POST的方式向HTTP服务器提交请求时，libcurl会设置该消息头为"100-continue"，它要求服务器在正式处理该请求之前，返回一
个"OK"消息。如果POST的数据很小，libcurl可能不会设置该消息头。
自定义选项
当前越来越多的协议都构建在HTTP协议之上（如：soap），这主要归功于HTTP的可靠性，以及被广泛使用的代理支持（可以穿透大部分防火墙）。
这些协议的使用方式与传统HTTP可能有很大的不同。对此，libcurl作了很好的支持。
自定义请求方式(CustomRequest)
HTTP支持GET,
HEAD或者POST提交请求。可以设置CURLOPT_CUSTOMREQUEST来设置自定义的请求方式，libcurl默认以GET方式提交请求：
curl_easy_setopt(easy_handle,
CURLOPT_CUSTOMREQUEST, "MYOWNREQUEST");
修改消息头
HTTP协议提供了消息头，请求消息头用于告诉服务器如何处理请求；响应消息头则告诉浏览器如何处理接收到的数据。在libcurl中，你可以自由的添加
这些消息头：
struct curl_slist *headers=NULL; /* init to NULL is important */ headers = curl_slist_append(headers, "Hey-server-hey: how are you?"); headers = curl_slist_append(headers, "X-silly-content: yes"); /* pass our list of custom made headers */ curl_easy_setopt(easyhandle, CURLOPT_HTTPHEADER, headers); curl_easy_perform(easyhandle); /* transfer http */ curl_slist_free_all(headers); /* free the header list */
对于已经存在的消息头，可以重新设置它的值：
headers = curl_slist_append(headers, "Accept: Agent-007"); headers = curl_slist_append(headers, "Host: munged.host.line");
删除消息头
对于一个已经存在的消息头，设置它的内容为空，libcurl在发送请求时就不会同时提交该消息头：
headers = curl_slist_append(headers, "Accept:");
六、获取http应答头信息
发出http请求后，服务器会返回应答头信息和应答数据，如果仅仅是打印应答头的所有内容，则直接可以通过curl_easy_setopt(curl,
CURLOPT_HEADERFUNCTION,
打印函数)的方式来完成，这里需要获取的是应答头中特定的信息，比如应答码、cookies列表等，则需要通过下面这个函数：
CURLcode
curl_easy_getinfo(CURL *curl, CURLINFO info, ... );
info参数就是我们需要获取的内容，下面是一些参数值:
1.CURLINFO_RESPONSE_CODE
获取应答码
2.CURLINFO_HEADER_SIZE
头大小
3.CURLINFO_COOKIELIST
cookies列表
除了获取应答信息外，这个函数还能获取curl的一些内部信息，如请求时间、连接时间等等。
更多的参数可以参考API文档。
七、多线程问题
首先一个基本原则就是：绝对不应该在线程之间共享同一个libcurl handle(CURL *对象)，不管是easy handle还是multi
handle（本文只介绍easy_handle）。一个线程每次只能使用一个handle。
libcurl是线程安全的，但有两点例外：信号(signals)和SSL/TLS handler。 信号用于超时失效名字解析(timing out name
resolves)。libcurl依赖其他的库来支持SSL/STL，所以用多线程的方式访问HTTPS或FTPS的URL时，应该满足这些库对多线程
操作的一些要求。详细可以参考：
OpenSSL: http://www.openssl.org/docs/crypto/threads.html#DESCRIPTION
GnuTLS: http://www.gnu.org/software/gnutls/manual/html_node/Multi_002dthreaded-applications.html
NSS: 宣称是多线程安全的。
八、什么时候libcurl无法正常工作
传输失败总是有原因的。你可能错误的设置了一些libcurl的属性或者没有正确的理解某些属性的含义，或者是远程主机返回一些无法被正确解析的内容。
这里有一个黄金法则来处理这些问题：将CURLOPT_VERBOSE属性设置为1，libcurl会输出通信过程中的一些细节。如果使用的是http协
议，请求头/响应头也会被输出。将CURLOPT_HEADER设为1，这些头信息将出现在消息的内容中。
当然不可否认的是，libcurl还存在bug。
如果你对相关的协议了解越多，在使用libcurl时，就越不容易犯错。
九、关于密码
客户端向服务器发送请求时，许多协议都要求提供用户名与密码。libcurl提供了多种方式来设置它们。
一些协议支持在URL中直接指定用户名和密码，类似于：
protocol://user:password@example.com/path/。libcurl能正确的识别这种URL中的用户名与密码并执行
相应的操作。如果你提供的用户名和密码中有特殊字符，首先应该对其进行URL编码。
也可以通过CURLOPT_USERPWD属性来设置用户名与密码。参数是格式如 “user:password ”的字符串：
curl_easy_setopt(easy_handle,
CURLOPT_USERPWD, "user_name:password");
有时候在访问代理服务器的时候，可能时时要求提供用户名和密码进行用户身份验证。这种情况下，libcurl提供了另
一个属性CURLOPT_PROXYUSERPWD：
curl_easy_setopt(easy_handle,
CURLOPT_PROXYUSERPWD, "user_name:password");
在UNIX平台下，访问FTP的用户名和密码可能会被保存在$HOME/.netrc文件中。libcurl支持直接从这个文件中获取用户名与密码：
curl_easy_setopt(easy_handle,
CURLOPT_NETRC, 1L);
在使用SSL时，可能需要提供一个私钥用于数据安全传输，通过CURLOPT_KEYPASSWD来设置私钥：
curl_easy_setopt(easy_handle,
CURLOPT_KEYPASSWD, "keypassword");
十、HTTP验证
在使用HTTP协议时，客户端有很多种方式向服务器提供验证信息。默认的
HTTP验证方法是"Basic”，它将用户名与密码以明文的方式、经Base64编码后保存在HTTP请求头中，发往服务器。当然这不太安全。
当前版本的libcurl支持的验证方法有：basic, Digest, NTLM, Negotiate, GSS-Negotiate and
SPNEGO。（译者感叹：搞Web这么多年，尽然不知道这些Http的验证方式，实在惭愧。）可以通过CURLOPT_HTTPAUTH属性来设置具体
的验证方式：
curl_easy_setopt(easy_handle,
CURLOPT_HTTPAUTH, CURLAUTH_DIGEST);
向代理服务器发送验证信息时，可以通过CURLOPT_PROXYAUTH设置验证方式：
curl_easy_setopt(easy_handle,
CURLOPT_PROXYAUTH, CURLAUTH_NTLM);
也可以同时设置多种验证方式（通过按位与），
使用‘CURLAUTH_ANY‘将允许libcurl可以选择任何它所支持的验证方式。通过CURLOPT_HTTPAUTH或
CURLOPT_PROXYAUTH属性设置的多种验证方式，libcurl会在运行时选择一种它认为是最好的方式与服务器通信：
curl_easy_setopt(easy_handle,
CURLOPT_HTTPAUTH, CURLAUTH_DIGEST|CURLAUTH_BASIC);
//
curl_easy_setopt(easy_handle, CURLOPT_HTTPAUTH,
CURLAUTH_ANY);
#include <stdio.h> #include <curl/curl.h> bool getUrl(char *filename) { CURL *curl; CURLcode res; FILE *fp; if ((fp = fopen(filename, "w")) == NULL) // 返回结果用文件存储 return false; struct curl_slist *headers = NULL; headers = curl_slist_append(headers, "Accept: Agent-007"); curl = curl_easy_init(); // 初始化 if (curl) { //curl_easy_setopt(curl, CURLOPT_PROXY, "10.99.60.201:8080");// 代理 curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers);// 改协议头 curl_easy_setopt(curl, CURLOPT_URL,"http://www.baidu.com"); curl_easy_setopt(curl, CURLOPT_WRITEDATA, fp); //将返回的http头输出到fp指向的文件 curl_easy_setopt(curl, CURLOPT_HEADERDATA, fp); //将返回的html主体数据输出到fp指向的文件 res = curl_easy_perform(curl); // 执行 if (res != 0) { curl_slist_free_all(headers); curl_easy_cleanup(curl); } fclose(fp); return true; } } bool postUrl(char *filename) { CURL *curl; CURLcode res; FILE *fp; if ((fp = fopen(filename, "w")) == NULL) return false; curl = curl_easy_init(); if (curl) { curl_easy_setopt(curl, CURLOPT_COOKIEFILE, "/tmp/cookie.txt"); // 指定cookie文件 curl_easy_setopt(curl, CURLOPT_POSTFIELDS, "&logintype=uid&u=xieyan&psw=xxx86"); // 指定post内容 //curl_easy_setopt(curl, CURLOPT_PROXY, "10.99.60.201:8080"); curl_easy_setopt(curl, CURLOPT_URL, " http://mail.sina.com.cn/cgi-bin/login.cgi "); // 指定url curl_easy_setopt(curl, CURLOPT_WRITEDATA, fp); res = curl_easy_perform(curl); curl_easy_cleanup(curl); } fclose(fp); return true; } int main(void) { getUrl("/tmp/get.html"); postUrl("/tmp/post.html"); }
编译gcc get_post.c -o get_post –lcurl
./ get_post
2 获取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
// 采用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); }
./ save_http www.baidu.com
/tmp/baidu
4 进度条实例显示文件下载进度
// 采用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; }
gcc progress.c –o progress ` pkg-config --libs –cflags gtk+-2..0` -lcurl –lgthread-2.0
./ progress http://software.sky-union.cn/index.asp
5 断点续传实例
//采用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", "C:\\file", 0, 3); download(curlhandle , "http://software.sky-union.cn/index.asp","/work/index.asp",1,3); curl_easy_cleanup(curlhandle); curl_global_cleanup(); return 0; }
./ resume
Linux libcurl使用（一）(收藏)_留风的贝壳_百度空间 - Google Chrome (2013/5/23 15:17:01)
Linux libcurl使用（一）(收藏)
LibCurl编程 http://wangjiajun53880.blog.163.com/blog/static/117001394200992011257363/
Linux 2009-10-20 13:07 阅读 评论字号： 大大 中中 小小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网页
view plaincopy to clipboardprint?
#include <stdio.h>;
#include <stdlib.h>;
#include <unistd.h>;
#include <curl/curl.h>;
#include <curl/types.h>;
#include <curl/easy.h>;
FILE *fp; //定义FILE类型指针
size_t write_data(void *ptr, size_t size, size_t nmemb, void *stream) //这个函数是为了符合CURLOPT_WRITEFUNCTION, 而构造的
{
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[1],"w"))==NULL)
{
curl_easy_cleanup(curl);
exit(1);
}
curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, write_data); //CURLOPT_WRITEFUNCTION 将后继的动作交给write_data函数处理
curl_easy_perform(curl);
curl_easy_cleanup(curl);
exit(0);
}
#include <stdio.h>;
#include <stdlib.h>;
#include <unistd.h>;
#include <curl/curl.h>;
#include <curl/types.h>;
#include <curl/easy.h>;
FILE *fp; //定义FILE类型指针
size_t write_data(void *ptr, size_t size, size_t nmemb, void *stream) //这个函数是为了符合CURLOPT_WRITEFUNCTION, 而构造的
{
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[1],"w"))==NULL)
{
curl_easy_cleanup(curl);
exit(1);
}
curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, write_data); //CURLOPT_WRITEFUNCTION 将后继的动作交给write_data函数处理
curl_easy_perform(curl);
curl_easy_cleanup(curl);
exit(0);
}
把获得的html代码存入相应的文件中.看下面一个例子
view plaincopy to clipboardprint?
#include <stdio.h>;
#include <stdlib.h>;
#include <unistd.h>;
#include <curl/curl.h>;
#include <curl/types.h>;
#include <curl/easy.h>;
FILE *fp; //定义FILE类型指针
size_t write_data(void *ptr, size_t size, size_t nmemb, void *stream) //这个函数是为了符合CURLOPT_WRITEFUNCTION, 而构造的
{
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[1],"w"))==NULL)
{
curl_easy_cleanup(curl);
exit(1);
}
curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, write_data); //CURLOPT_WRITEFUNCTION 将后继的动作交给write_data函数处理
curl_easy_perform(curl);
curl_easy_cleanup(curl);
exit(0);
}
#include <stdio.h>;
#include <stdlib.h>;
#include <unistd.h>;
#include <curl/curl.h>;
#include <curl/types.h>;
#include <curl/easy.h>;
FILE *fp; //定义FILE类型指针
size_t write_data(void *ptr, size_t size, size_t nmemb, void *stream) //这个函数是为了符合CURLOPT_WRITEFUNCTION, 而构造的
{
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[1],"w"))==NULL)
{
curl_easy_cleanup(curl);
exit(1);
}
curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, write_data); //CURLOPT_WRITEFUNCTION 将后继的动作交给write_data函数处理
curl_easy_perform(curl);
curl_easy_cleanup(curl);
exit(0);
}
从ftp站点下载文件的例子.
view plaincopy to clipboardprint?
#include <stdio.h>;
#include <curl/curl.h>;
#include <curl/types.h>;
#include <curl/easy.h>;
struct FtpFile //定义一个结构为了传递给my_fwrite函数.可用curl_easy_setopt的CURLOPT_WRITEDATA选项传递
{
char *filename;
FILE *stream;
};
int my_fwrite(void *buffer, size_t size, size_t nmemb, void *stream)
{
struct FtpFile *out=(struct FtpFile *)stream; // stream指针其实就是 指向struct FtpFile ftpfile的
if(out && !out->stream)
{
out->;stream=fopen(out->filename, "wb"); //没有这个流的话就创建一个 名字是out->filename.
if(!out->stream)
return -1;
}
return fwrite(buffer, size, nmemb, out->stream);
}
int main(int argc, char *argv[])
{
CURL *curl;
CURLcode res;
struct FtpFile ftpfile={argv[2],NULL}; //初始化一个FtpFile结构
curl_global_init(CURL_GLOBAL_DEFAULT);
curl = curl_easy_init();
if(curl)
{
curl_easy_setopt(curl, CURLOPT_URL,argv[1]);
curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, my_fwrite);
curl_easy_setopt(curl, CURLOPT_WRITEDATA, &ftpfile); //给相关函数的第四个参数 传递一个结构体的指针
curl_easy_setopt(curl, CURLOPT_VERBOSE, TRUE); //CURLOPT_VERBOSE 这个选项很常用 用来在屏幕上显示对服务器相关操作返回的信息
res = curl_easy_perform(curl);
curl_easy_cleanup(curl);
if(CURLE_OK != res)
fprintf(stderr, "curl told us %d\n", res);
}
if(ftpfile.stream)
fclose(ftpfile.stream);
curl_global_cleanup();
return 0;
}
#include <stdio.h>;
#include <curl/curl.h>;
#include <curl/types.h>;
#include <curl/easy.h>;
struct FtpFile //定义一个结构为了传递给my_fwrite函数.可用curl_easy_setopt的CURLOPT_WRITEDATA选项传递
{
char *filename;
FILE *stream;
};
int my_fwrite(void *buffer, size_t size, size_t nmemb, void *stream)
{
struct FtpFile *out=(struct FtpFile *)stream; // stream指针其实就是 指向struct FtpFile ftpfile的
if(out && !out->stream)
{
out->;stream=fopen(out->filename, "wb"); //没有这个流的话就创建一个 名字是out->filename.
if(!out->stream)
return -1;
}
return fwrite(buffer, size, nmemb, out->stream);
}
int main(int argc, char *argv[])
{
CURL *curl;
CURLcode res;
struct FtpFile ftpfile={argv[2],NULL}; //初始化一个FtpFile结构
curl_global_init(CURL_GLOBAL_DEFAULT);
curl = curl_easy_init();
if(curl)
{
curl_easy_setopt(curl, CURLOPT_URL,argv[1]);
curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, my_fwrite);
curl_easy_setopt(curl, CURLOPT_WRITEDATA, &ftpfile); //给相关函数的第四个参数 传递一个结构体的指针
curl_easy_setopt(curl, CURLOPT_VERBOSE, TRUE); //CURLOPT_VERBOSE 这个选项很常用 用来在屏幕上显示对服务器相关操作返回的信息
res = curl_easy_perform(curl);
curl_easy_cleanup(curl);
if(CURLE_OK != res)
fprintf(stderr, "curl told us %d\n", res);
}
if(ftpfile.stream)
fclose(ftpfile.stream);
curl_global_cleanup();
return 0;
}
进度条实例??显示文件下载进度
view plaincopy to clipboardprint?
// 采用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;
}
【Curl (libcurl) 开发 】Cocos2dx之libcurl（curl_easy）的编程教程（帮助手册）！ | 黑米GameDev街区 - Google Chrome (2013/5/23 14:56:10)
本篇介绍使用libcurl编程的一般原则和一些基本方法。本文主要是介绍 c 语言的调用接口，同时也可能很好的适用于其他类 c 语言的接口。
libcurl库背后的开发人员投入了相当大的努力确保libcurl可以在很多不同的系统和环境里工作。
程序必须初始化一些libcurl的全局函数。这意味着不管你准备使用libcurl多少次，你都应该，且只初始化一次。当你的程序开始的时候，使用
curl_global_init()
这个函数需要一个参数来告诉它如何来初始化。使用CURL_GLOBAL_ALL ,它将用通常是比较好的默认参数来初始化所有已知的内部子模块。还有两个可选值：
CURL_GLOBAL_WIN32
这个参数只被用在windows 操作系统上。它让libcurl初始化win32套接字的的东西。没有正确的初始化，你的程序将不能正确的使用套接字。你应该只为每个程序做一次这样的操作，如果你的程序的其他库这样了，你就不要再让libcurl这样做。
CURL_GLOBAL_SSL
这个参数会使libcurl具有SSL的能力。你应该只为每个程序做一次这样的操作，如果你的程序的其他库这样了，你就不要再让libcurl这样做。
libcurl有个默认的保护机制，检测如果curl_global_init没有在curl_easy_perform之前被调用，那么libcurl会猜测该使用的初始化模式来执行程序。请注意，依靠默认的保护机制来这么做一点都不好。
当程序不再使用libcurl，请调用curl_global_cleanup函数来对应初始化函数所做的工作，它会做逆向的工作来清理curl_global_init所初始化的资源。
请避免重复的调用curl_global_init和 curl_global_cleanup。他们每个仅被调用一次。
确定libcurl所提供功能的最佳办法是在运行的时候而不是在编译的时候。通过调用curl_version_info函数，然后查看返回信息的结构体，你知道当前的libcurl版本所支持的功能了。
首先介绍libcurl的简单接口(easy interface)，这些接口都有curl_easy的前缀。 libcurl的最近版本还提供了复杂接口(multi interface)。更多关系该接口的信息将另作讨论，为了更好的理解复杂接口，你仍然需要先了解简单接口。
为了使用简单接口，你先需要创建一个简单接口的句柄。每一个简单接口的数据通信都需要这个句柄。一般来说，你需要为每个准备传输数据的线程使用一个句柄。但你绝不能在多线程里共享相同的句柄。
获取简单句柄
easyhandle = curl_easy_init();
这个函数返回一个简单接口句柄。接下来的操作力，可以在这个`easyhandle设置各种选项。在随后的一个或者多次数据传输中，句柄只是一个逻辑实体。 通过 curl_easy_setopt设置句柄的属性和选项，它们控制随后的数据传输。这些属性和选项的设置一个保存在句柄里直到它再次被设置为其他值。多次网络请求使用相同的句柄，它们的句柄选择和属性也是相同的。
很多用于设置libcurl属性都是字符串，一个指向一段以0结尾数据。当你用字符串设置 curl_easy_setopt(），libcurl会复制这个字符串的一个副本，所以你在设置后不用再保存那个字符串的内存。
在句柄上最经常设置的属性是URL。你可以这样设置它
curl_easy_setopt(handle, CURLOPT_URL, ”http://domain.com/”);
假如你希望得到指定URL上的远程主机的数据资源到本地。如果你想自己处理得到的数据而不是直接显示在标准输出里，你可以写一个符合下面原型的函数
size_t write_data(void *buffer, size_t size, size_t nmemb, void *userp);
你可以用类似下面这样的代码来控制libcurl将得到的数据传递到你写的函数里
curl_easy_setopt(easyhandle, CURLOPT_WRITEFUNCTION, write_data);
你还可以控制你的回调函数第四个参数得到的数据，用这样的函数原型
curl_easy_setopt(easyhandle, CURLOPT_WRITEDATA, &internal_struct);
使用这种原型，你可以很容易在你程序和被libcurl调用函数之间传递本地数据。使用 CURLOPT_WRITEDATA,libcurl不会处理你所传递的数据。
假如你没用使用CURLOPT_WRITEFUNCTION设置回调函数，libcurl会有默认的处理。它只是把接收到的数据输出到标准输出里。你可以使用传递一个FILE *的打开文件参数，设置默认处理函数CURLOPT_WRITEDATA ,它把得到的数据存放在一个文件里。
这里有一个与平台有关的缺陷。有时候libcurl不能操作一个呗程序所打开的文件。如果你用CURLOPT_WRITEDATA给默认的回调函数传递一个打开的文件，程序可能崩溃。(CURLOPT_WRITEDATA 原来的名称为CURLOPT_FILE,它们是同样的工作机理)。
如果你以 win32 dll的方式使用libcurl，如果你设置了，CURLOPT_WRITEDATA ，也必须用CURLOPT_WRITEFUNCTION ，否则你会遇到程序崩溃。 还有其他很多的选项可以设置，我们放在后面再详细讨论，接着往下看
success = curl_easy_perform(easyhandle);
curl_easy_perform函数将会连接远程的站点，发送必要的命令和接受传输的数据。当它收到了数据，它就会调用我们先前设置的回调函数。这个函数可能一次得到一个字节或者几千个字节。libcurl会尽可能多的，尽可能快的传回数据。我们回调函数返回它所得到数据的大小。如果返回的数据大小与传递给它数据大小不一致，libcurl将会终止操作，并返回一个错误代码。
当数据传输完成，curl_easy_perform返回一个代码来告诉你是否成功。如果你仅返回一个代码还不够，你可以使用CURLOPT_ERRORBUFFER ,让libcurl缓存许多可读的错误信息
如果你还想传输其他数据，已有的句柄可以多次使用。记住，鼓励你使用现有的句柄来传输其他数据，libcurl会尝试已经先前已经建立好的连接。
对于某些协议，下载文件可能涉及到很多复杂的协议用来记录信息，设置传输模式，更改当前的目录并最终传递数据。传递一个文件的URL，libcurl会为你掌管所有细节，把文件从一台机器移动到两一台机器。
最基本的原则是绝对不要同时在多个线程之间共享一个libcurl的句柄。确保任何时候一个句柄只是在一个线程里使用。你可以在多个线程之间传递句柄，但是你不能使用。
libcurl是线程安全的，除了以下两种情况：信号量和SSL/TLS句柄。信号量用于超时失效名字解析(在域名解析的时候)。
如果你通过多线程方式来访问HTTPS 或者 FTPS 网址，你可以使用底层的SSL库，多线程库。这些库可能有它们独有的要求，你要多加注意详细参考
OpenSSL
http://www.openssl.org/docs/crypto/threads.html#DESCRIPTION
GnuTLS
http://www.gnu.org/software/gnutls/manual/html_node/Multi_002dthreaded-applications.html
NSS 它宣称是线程安全，没有任何特殊的要求。 PolarSSL 未知。yassl 未知。axTLS 未知。
当你使用多线程的时候，你应当为所有的句柄设置CURLOPT_NOSIGNAL 选项。所有的时候都可以工作正常除了DNS查询超时的时候。 同样，CURLOPT_DNS_USE_GLOBAL_CACHE 也不是线程安全的。
总是有各种原因导致网络传输失败。你可能设置错误的libcurl选项，误解了libcurl某些选项的实际作用，或者远程服务器返回libcurl一个非标准的应答。
当发生错误的时候，这里有一个黄金法:设置CURLOPT_VERBOSE 选项为1。这将导致libcurl显示出所有发送的实体协议的细节，或者还有一些内部的信息和一些收到协议的数据(尤其是 FTP)。如果你使用HTTP ,CURLOPT_HEADER设为1,请求头/响应头也会被输出,这些头信息将出现在消息的内容中。
如果CURLOPT_VERBOSE 还不够，你设置CURLOPT_DEBUGFUNCTION来调试你的数据。
libcurl尽量保持与协议无关性，就是上传文件到远程的FTP跟用PUT方式上传数据到HTTP服务器和非常类似的。 我们写一个程序，很可能想libcurl按照我们的要求上传数据。我需要设置如下函数原型的读数据的回调函数
size_t function(char *bufptr, size_t size, size_t nitems, void *userp);
bufptr 参数指向一段准备上传数据的缓冲区，nitem是这段缓冲区的大小，userp是一个用户自定义指针，libcurl不对该指针作任何操作，它只是简单的传递该指针。可以使用该指针在应用程序与libcurl之间传递信息。
curl_easy_setopt(easyhandle, CURLOPT_READFUNCTION, read_function);
curl_easy_setopt(easyhandle, CURLOPT_READDATA, &filedata);
Tell libcurl that we want to upload:
curl_easy_setopt(easyhandle, CURLOPT_UPLOAD, 1L);
有几个协议将不能正常工作当上传的时候没有告诉上传文件的大小。所以设置上传文件的大小请使用CURLOPT_INFILESIZE_LARGE
/* in this example, file_size must be an curl_off_t variable */
curl_easy_setopt(easyhandle, CURLOPT_INFILESIZE_LARGE, file_size);
当你调用curl_easy_perform()的时候，libcurl会执行所有的必要动作，当开始上传的时候，它会调用我的回调函数。程序会尽可能多，尽可能快的的上传数据。回调函数返回写入缓冲区的数据的大小。返回0的时候就表示上传结束了。
许多协议要求用户名和密码才能下载或者上传你所选择的数据。libcurl提供了指定的几种方法。
许多协议都支持用户名和密码包含在指定的URL里。libcurl会检测并相应的使用它们。可以按照这样的格式写
protocol://user:password@example.com/path/
如果你的用户名和密码需要一些奇特的字符，你应该使用URLd编码，像%XX，其中ＸＸ是两位十六进制的数字。
libcurl同事也提供了一个设置各种类型密码的选项。设置CURLOPT_USERPWD 选项如下
curl_easy_setopt(easyhandle, CURLOPT_USERPWD, ”myname:thesecret”);
在某些情况下可能会多次用到用户名和密码，可以使用代码来验证身份。libcurl提供一个CURLOPT_PROXYUSERPWD选项来实现这种功能,跟CURLOPT_USERPWD 选项很类似
curl_easy_setopt(easyhandle, CURLOPT_PROXYUSERPWD, ”myname:thesecret”);
先前的章节我们显示了如何为需要验证的URL设置用户和密码。当我们使用HTTP协议的时候，客户端有许多不同的向服务器发送身份验证。最基本的HTTP认证为Basic认证，它发送base64编码的明文用户和密码，这不安全。 如今，libcrul支持使用Basic, Digest, NTLM, Negotiate, GSS-Negotiate and SPNEGO等方式的认证，你可以设置CURLOPT_HTTPAUTH 告诉libcurl使用那种认证。
curl_easy_setopt(easyhandle, CURLOPT_HTTPAUTH, CURLAUTH_DIGEST);
当你想代理服务器认证的时候，你可以使用
CURLOPT_PROXYAUTH:
curl_easy_setopt(easyhandle, CURLOPT_PROXYAUTH, CURLAUTH_NTLM);
你可以组合多种认证方式，libcurl会以合理的方式处理 curl_easy_setopt(easyhandle, CURLOPT_HTTPAUTH, CURLAUTH_DIGEST|CURLAUTH_BASIC);
为了方便起见，你还可以使用CURLAUTH_ANY，它允许libcurl使用任何想要的方法。
HTML最简单的也是最常见的POST是使用<form>这个标签来实现的。我们提供了一个指向数据段 指针，然后告诉licurl把它发送到远程站点：
char *data=”name=daniel&project=curl”;
curl_easy_setopt(easyhandle, CURLOPT_POSTFIELDS, data);
curl_easy_setopt(easyhandle, CURLOPT_URL, ”http://posthere.com/”);
curl_easy_perform(easyhandle); /* post away! */
是不是很简单。当你设置了CURLOPT_POSTFIELDS选项，它会自动切换句柄来POST接下的请求。
如果你想发送二进制的数据，需要设置一下数据头，用来知名数据的类型和数据的大小。如下
struct curl_slist *headers=NULL;
headers = curl_slist_append(headers, ”Content-Type: text/xml”);
/* post binary data */
curl_easy_setopt(easyhandle, CURLOPT_POSTFIELDS, binaryptr);
/* set the size of the postfields data */
curl_easy_setopt(easyhandle, CURLOPT_POSTFIELDSIZE, 23L);
/* pass our list of custom made headers */
curl_easy_setopt(easyhandle, CURLOPT_HTTPHEADER, headers);
curl_easy_perform(easyhandle); /* post away! */
curl_slist_free_all(headers); /* free the header list */
还有一种是multi-part 表单提交,这被认为是一种更好的方法提交二进制的数据。libcrul同样也支持这种方法。下面是例子:
struct curl_httppost *post=NULL;
struct curl_httppost *last=NULL;
curl_formadd(&post, &last, CURLFORM_COPYNAME, ”name”, CURLFORM_COPYCONTENTS, ”daniel”, CURLFORM_END);
curl_formadd(&post, &last, CURLFORM_COPYNAME, ”project”, CURLFORM_COPYCONTENTS, ”curl”, CURLFORM_END);
curl_formadd(&post, &last, CURLFORM_COPYNAME, ”logotype-image”, CURLFORM_FILECONTENT, ”curl.png”,
CURLFORM_END);
/* Set the form info */
curl_easy_setopt(easyhandle, CURLOPT_HTTPPOST, post);
curl_easy_perform(easyhandle); /* post away! */
/* free the post data again */
curl_formfree(post);
libcurl还允许你在每个定义的部分设置头。下面就是例子
struct curl_slist *headers=NULL;
headers = curl_slist_append(headers, ”Content-Type: text/xml”);
curl_formadd(&post, &last, CURLFORM_COPYNAME, ”logotype-image”, CURLFORM_FILECONTENT, ”curl.xml”,
CURLFORM_CONTENTHEADER, headers, CURLFORM_END);
curl_easy_perform(easyhandle); /* post away! */
curl_formfree(post);
/* free post */
curl_slist_free_all(headers);
/* free custom header list */
所有对简单接口句柄都是”粘的”，这些属性会一直保持不变除非你在调用 curl_easy_perform之前改过。通过将CURLOPT_HTTPGET设为1可以使简单接口句柄回到最原始的状态：
curl_easy_setopt(easyhandle, CURLOPT_HTTPGET, 1L);
只设置CURLOPT_POSTFIELDS 的只为”"或者NULL是不会停止libcurl做POST请求的，这只会做提交空数据的POST。
通过将CURLOPT_NOPROCESS设置为0开启进度支持。该选项默认值为1。对大多数应用程序，我们需要提供一个进度显示回调。libcurl会不定期的将当前传输的进度通过回调函数告诉你的程序。
//回调函数原型
int progress_callback(void *clientp, double dltotal,
double dlnow, double ultotal, double ulnow);
/*通过CURLOPT_PROGRESSFUNCTION注册该回调函数。
参数clientp是一个用户自定义指针，应用程序通过CURLOPT_PROCESSDATA
属性将该自定义指定传递给libcurl。libcurl对该参数不作任何处理，
只是简单将其传递给回调函数。*/
只有一件需要特别注意的是回调函数不能使类的非静态成员函数。如
class AClass
{
static size_t write_data(void *ptr, size_t size, size_t nmemb,
void *ourpointer)
{
/* do what you want with the data */
}
}
略过，有兴趣请参考原文。
当需要发送多次请求时，应该重复使用easy handle。
每次执行完curl_easy_perform，licurl会继续保持与服务器的连接。接下来的请求可以使用这个连接而不必创建新的连接（如果目标主机是同一个的话）。这样可以减少网络开销。 即使连接被释放了，libcurl也会缓存这些连接的会话信息，这样下次再连接到目标主机上时，就可以使用这些信息，从而减少重新连接所需的时间。
FTP连接可能会被保存较长的时间。因为客户端要与FTP服务器进行频繁的命令交互。对于有访问人数上限的FTP服务器，保持一个长连接，可以使你不需要排除等待，就直接可以与FTP服务器通信。
libcurl会缓存DNS的解析结果。
在今后的libcurl版本中，还会添加一些特性来提高数据通信的效率。 每个简单接口句柄都会保存最近使用的几个连接，以备重用。默认是5个。可以通过CURLOPT_MAXCONNECTS属性来设置保存连接的数量。
如果你不想重用连接，将CURLOPT_FRESH_CONNECT属性设置为1。这样每次提交请求时，libcurl都会先关闭以前创建的连接，然后重新创建一个新的连接。也可以将CURLOPT_FORBID_REUSE设置为1，这样每次执行完请求，连接就会马上关闭。
当使用libcurl发送http请求时，它会自动添加一些http头。我们可以通过CURLOPT_HTTPHEADER属性手动替换、添加或删除相应的HTTP消息头。
例外：以POST的方式向HTTP服务器提交请求时，libcurl会设置该消息头为”100-continue”，它要求服务器在正式处理该请求之前，返回一个”OK”消息。如果POST的数据很小，libcurl可能不会设置该消息头。
当前越来越多的协议都构建在HTTP协议之上（如：soap），这主要归功于HTTP的可靠性，以及被广泛使用的代理支持（可以穿透大部分防火墙）。 这些协议的使用方式与传统HTTP可能有很大的不同。对此，libcurl作了很好的支持。
cookie是一个键值对的集合，HTTP服务器发给客户端的cookie，客户端提交请求的时候，也会将cookie发送到服务器。服务器可以根据cookie来跟踪用户的会话信息。cookie有过期时间，超时后cookie就会失效。cookie有域名和路径限制，cookie只能发给指定域名和路径的HTTP服务器。
在libcurl中，可以通过CURLOPT_COOKIE属性来设置发往服务器的cookie：
curl_easy_setopt(easyhandle, CURLOPT_COOKIE, ”name1=var1; name2=var2;”);
在实在的应用场景中，你可能需要保存服务器发送给你的cookie，并在接下来的请求中，把这些cookie一并发往服务器。所以，可以把上次从服务器收到的所有响应头信息保存到文本文件中，当下次需要向服务器发送请求时，通过CURLOPT_COOKIEFILE属性告诉libcurl从该文件中读取cookie信息。 设置CURLOPT_COOKIEFILE属性意味着激活libcurl的cookie parser。在cookie parser被激活之前，libcurl忽略所以之前接收到的cookie信息。cookie parser被激活之后，cookie信息将被保存内存中，在接下来的请求中，libcurl会自动将这些cookie信息添加到消息头里，你的应用程序不需要做任何事件。大多数情况下，这已经足够了。需要注意的是，通过CURLOPT_COOKIEFILE属性来激活cookie parser，给CURLOPT_COOKIEFILE属性设置的一个保存cookie信息的文本文件路径，可能并不需要在磁盘上物理存在。 如果你需要使用NetScape或者FireFox浏览器的cookie文件，你只要用这些浏览器的cookie文件的路径来初始化CURLOPT_COOKIEFILE属性，libcurl会自动分析cookie文件，并在接下来的请求过程中使用这些cookie信息。 libcurl甚至能够把接收到的cookie信息保存成能被Netscape/Mozilla的浏览器所识别的cookie文件。通过把这些称为cookie-jar。通过设置CURLOPT_COOKIEJAR选项，在调用curl_easy_cleanup释放easy handle的时候，所有的这些cookie信息都会保存到cookie-jar文件中。这就使得cookie信息能在不同的easy handle甚至在浏览器之间实现共享。
curl使用笔记 | 大鱼儿@Live - Google Chrome (2013/5/22 15:34:11)
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。
libcurl 是一个很不错的库，支持http，ftp等很多的协议。使用库最大的心得就是，不仔细看文档，仅仅看着例子就写程序，是一件危险的事情。我的程序崩溃了，我怀疑是自己代码写的问题，后来发现是库没用对。不仔细看文档（有时候文档本身也比较差劲，这时除了看仔细外，还要多动脑子，考虑它是怎么实现的），后果很严重。不加思索的使用别人的库或者代码，有时候很惬意，但是出问题时，却是寝食难安的。
1. CURLcode curl_global_init(long flags); 在多线程应用中，需要在主线程中调用这个函数。这个函数设置libcurl所需的环境。通常情况，如果不显式的调用它，第一次调用curl_easy_init()时，curl_easy_init 会调用 curl_global_init，在单线程环境下，这不是问题。但是多线程下就不行了，因为curl_global_init不是线程安全的。在多个线程中调用curl_easy_int，然后如果两个线程同时发现curl_global_init还没有被调用，同时调用curl_global_init，悲剧就发生了。这种情况发生的概率很小，但可能性是存在的。
2. libcurl 有个很好的特性，它甚至可以控制域名解析的超时。但是在默认情况下，它是使用alarm + siglongjmp 实现的。用alarm在多线程下做超时，本身就几乎不可能。如果只是使用alarm，并不会导致程序崩溃，但是，再加上siglongjmp，就要命了（程序崩溃的很可怕，core中几乎看不出有用信息），因为其需要一个sigjmp_buf型的全局变量，多线程修改它。（通常情况下，可以每个线程一个 sigjmp_buf 型的变量，这种情况下，多线程中使用 siglongjmp 是没有问题的，但是libcurl只有一个全局变量，所有的线程都会用）。
具体是类似 curl_easy_setopt(curl, CURLOPT_TIMEOUT, 30L) 的超时设置，导致alarm的使用（估计发生在域名解析阶段），如前所述，这在多线程中是不行的。解决方式是禁用掉alarm这种超时， curl_easy_setopt(curl, CURLOPT_NOSIGNAL, 1L)。
这样，多线程中使用超时就安全了。但是域名解析就没了超时机制，碰到很慢的域名解析，也很麻烦。文档的建议是 Consider building libcurl with c-ares support to enable asynchronous DNS lookups, which enables nice timeouts for name resolves without signals. c-ares 是异步的 DNS 解决方案。
curl_slist_append() 函数声明如下：
|
1
2 |
#include <curl/curl.h>struct curl_slist *curl_slist_append(struct curl_slist * list, const char *
string ); |
该函数将一个字符串追加到 slist 链表中。第 1 个参数是 struct_slist 类型链表；第 2 个参数是要增加到链表节点结构中的字符串。函数完成后，返回指向该链表的指针。
struct curl_slist 的类型定义在 curl.h 中：
|
1
2
3
4
5 |
/* linked-list structure for the CURLOPT_QUOTE option
(and other) */struct curl_slist { char *data; struct curl_slist *next;}; |
使用了该函数，在工作完成后应该使用 curl_slist_free_all() 对其链表进行释放。
curl/types.h: No such file or directory问题的解决
发布时间: 2012-08-27 09:49 来源: blog.csdn.net
在程序中用到了libcurl，编译时出现
curl/types.h: No such file or directory错误
查找到http://projects.springlobby.info/issues/1575中提到了这个问题
This is a problem on archlinux which just got curl 7.21.7.curl devs removed curl/types.h and put its content in curl/curl.h.
意思是在新版中把curl/types.h合并到了curl/curl.h中
我的解决方法是在
- cd /usr/include/curl/
- sudo ln -s curl.h types.h
再编译，问题没有了。
linux curl命令详解 - - ITeye技术网站 - Google Chrome (2013/5/22 15:31:00)
个人技术博客：http://demi-panda.com
一、参数详解
| -M/--manual | 显示全手动 |
| -n/--netrc | 从netrc文件中读取用户名和密码 |
| --netrc-optional | 使用 .netrc 或者 URL来覆盖-n |
| --ntlm | 使用 HTTP NTLM 身份验证 |
| -N/--no-buffer | 禁用缓冲输出 |
| -o/--output | 把输出写到该文件中 |
| -O/--remote-name | 把输出写到该文件中，保留远程文件的文件名 |
| -p/--proxytunnel | 使用HTTP代理 |
| --proxy-anyauth | 选择任一代理身份验证方法 |
| --proxy-basic | 在代理上使用基本身份验证 |
| --proxy-digest | 在代理上使用数字身份验证 |
| --proxy-ntlm | 在代理上使用ntlm身份验证 |
| -P/--ftp-port <address> | 使用端口地址，而不是使用PASV |
| -Q/--quote <cmd> | 文件传输前，发送命令到服务器 |
| -r/--range <range> | 检索来自HTTP/1.1或FTP服务器字节范围 |
| --range-file | 读取（SSL）的随机文件 |
| -R/--remote-time | 在本地生成文件时，保留远程文件时间 |
| --retry <num> | 传输出现问题时，重试的次数 |
| --retry-delay <seconds> | 传输出现问题时，设置重试间隔时间 |
| --retry-max-time <seconds> | 传输出现问题时，设置最大重试时间 |
| -s/--silent | 静音模式。不输出任何东西 |
| -S/--show-error | 显示错误 |
| --socks4 <host[:port]> | 用socks4代理给定主机和端口 |
| --socks5 <host[:port]> | 用socks5代理给定主机和端口 |
| -t/--telnet-option <OPT=val> | Telnet选项设置 |
| --trace <file> | 对指定文件进行debug |
| --trace-ascii <file> Like | 跟踪但没有hex输出 |
| --trace-time | 跟踪/详细输出时，添加时间戳 |
| -T/--upload-file <file> | 上传文件 |
| --url <URL> | Spet URL to work with |
| -u/--user <user[:password]> | 设置服务器的用户和密码 |
| -U/--proxy-user <user[:password]> | 设置代理用户名和密码 |
| -V/--version | 显示版本信息 |
| -w/--write-out [format] | 什么输出完成后 |
| -x/--proxy <host[:port]> | 在给定的端口上使用HTTP代理 |
| -X/--request <command> | 指定什么命令 |
| -y/--speed-time | 放弃限速所要的时间。默认为30 |
| -Y/--speed-limit | 停止传输速度的限制，速度时间'秒 |
| -z/--time-cond | 传送时间设置 |
| -0/--http1.0 | 使用HTTP 1.0 |
| -1/--tlsv1 | 使用TLSv1（SSL） |
| -2/--sslv2 | 使用SSLv2的（SSL） |
| -3/--sslv3 | 使用的SSLv3（SSL） |
| --3p-quote | like -Q for the source URL for 3rd party transfer |
| --3p-url | 使用url，进行第三方传送 |
| --3p-user | 使用用户名和密码，进行第三方传送 |
| -4/--ipv4 | 使用IP4 |
| -6/--ipv6 | 使用IP6 |
| -#/--progress-bar | 用进度条显示当前的传送状态 |
二，常用curl实例
|
1，抓取页面内容到一个文件中
[root@10.10.90.97 ~]# curl -o home.html http://www.sina.com.cn 2，用-O（大写的），后面的url要具体到某个文件，不然抓不下来。我们还可以用正则来抓取东西 [root@10.10.90.97 ~]# curl -O http://www.it415.com/czxt/linux/25002_3.html 3，模拟表单信息，模拟登录，保存cookie信息 [root@10.10.90.97 ~]# curl -c ./cookie_c.txt -F log=aaaa -F pwd=****** http://blog.51yip.com/wp-login.php 4，模拟表单信息，模拟登录，保存头信息 [root@10.10.90.97 ~]# curl -D ./cookie_D.txt -F log=aaaa -F pwd=****** http://blog.51yip.com/wp-login.php -c(小写)产生的cookie和-D里面的cookie是不一样的。 5，使用cookie文件
[root@10.10.90.97 ~]# curl -b ./cookie_c.txt http://blog.51yip.com/wp-admin 7，传送数据,最好用登录页面测试，因为你传值过去后，curl回抓数据，你可以看到你传值有没有成功 [root@10.10.90.97 ~]# curl -d log=aaaa http://blog.51yip.com/wp-login.php 8，显示抓取错误 [root@10.10.90.97 ~]# curl -f http://www.sina.com.cn/asdf curl: (22) The requested URL returned error: 404 [root@10.10.90.97 ~]# curl http://www.sina.com.cn/asdf <HTML><HEAD><TITLE>404,not found</TITLE> 。。。。。。。。。。。。 10，当我们经常用curl去搞人家东西的时候，人家会把你的IP给屏蔽掉的,这个时候,我们可以用代理
[root@10.10.90.97 ~]# curl -x 10.10.90.83:80 -o home.html http://www.sina.com.cn 11，比较大的东西，我们可以分段下载
[root@10.10.90.97 ~]# curl -r 0-100 -o img.part1 http://i2.f.itc.cn/thumb/180/bj/6018/b_60178154.jpg % Total % Received % Xferd Average Speed Time Time Time Current Dload Upload Total Spent Left Speed 100 101 100 101 0 0 1926 0 --:--:-- --:--:-- --:--:-- 0 [root@10.10.90.97 ~]# curl -r 100-200 -o img.part2 http://i2.f.itc.cn/thumb/180/bj/6018/b_60178154.jpg % Total % Received % Xferd Average Speed Time Time Time Current Dload Upload Total Spent Left Speed 100 101 100 101 0 0 3498 0 --:--:-- --:--:-- --:--:-- 98k [root@10.10.90.97 ~]# curl -r 200- -o img.part3 http://i2.f.itc.cn/thumb/180/bj/6018/b_60178154.jpg % Total % Received % Xferd Average Speed Time Time Time Current Dload Upload Total Spent Left Speed 100 13515 100 13515 0 0 154k 0 --:--:-- --:--:-- --:--:-- 280k [root@10.10.90.97 ~]# ll |grep img.part -rw-r--r-- 1 root root 101 Jan 24 10:59 img.part1 -rw-r--r-- 1 root root 101 Jan 24 11:00 img.part2 -rw-r--r-- 1 root root 13515 Jan 24 11:00 img.part3 用的时候，把他们cat一下就OK了,cat img.part* >img.jpg 12，不显示下载进度信息
[root@10.10.90.97 ~]# curl -s -o aaa.jpg 13，显示下载进度条
[root@10.10.90.97 ~]# curl -# -O http://www.it415.com/czxt/linux/25002_3.html ######################################################################## 100.0% 14,通过ftp下载文件
[root@10.10.90.97 ~]# curl -u 用户名:密码 -O http://blog.51yip.com/demo/curtain/bbstudy_files/style.css % Total % Received % Xferd Average Speed Time Time Time Current Dload Upload Total Spent Left Speed 101 1934 101 1934 0 0 3184 0 --:--:-- --:--:-- --:--:-- 7136 或者用下面的方式 [root@10.10.90.97 ~]# curl -O ftp://xukai:test@192.168.242.144:21/www/focus/enhouse/index.php % Total % Received % Xferd Average Speed Time Time Time Current Dload Upload Total Spent Left Speed 100 87518 100 87518 0 0 2312k 0 --:--:-- --:--:-- --:--:-- 11.5M 15，通过ftp上传 [root@10.10.90.97 ~]# curl -T xukai.php ftp://xukai:test@192.168.242.144:21/www/focus/enhouse/ % Total % Received % Xferd Average Speed Time Time Time Current Dload Upload Total Spent Left Speed 100 87518 0 0 100 87518 0 2040k --:--:-- --:--:-- --:--:-- 8901k |
本文来自博客园，作者：suntl，转载请注明原文链接：https://www.cnblogs.com/stlong/p/6290380.html
