下载libCURL源码

使用VS2015命令行编译

编译32位静态库

  1. nmake /f Makefile.vc mode=static ENABLE_IPV6=no DEBUG=yes MACHINE=x86 VC=14 ENABLE_SSPI=no ENABLE_IDN=no ENABLE_WINSSL=no

导入QT使用

  1. // 导入头文件
  2. #include <WinSock2.h>
  3. #include <Ws2tcpip.h>
  4. #include <windows.h>
  5. #include <Wincrypt.h>
  7. // 链接WIN32的静态库
  8. #pragma comment(lib, "Ws2_32.lib")
  9. #pragma comment(lib, "winmm.lib")
  10. #pragma comment(lib, "wldap32.lib")
  11. #pragma comment(lib, "Advapi32.lib")
  14. // 用于使用静态库
  15. #define BUILDING_LIBCURL
  17. // 用于自动查找到CURL目录下的lib文件
  18. #define   LIBPATH(p,f)   p##f 
  20. // 用于链接不同版本的静态库
  21. #ifdef QT_NO_DEBUG 
  22. #pragma comment(lib, LIBPATH(__FILE__,   ".dir/../libcurl.lib"))
  23. #else
  24. #pragma comment(lib, LIBPATH(__FILE__,   ".dir/../libcurl_debug.lib"))
  25. #endif
  27. // 包含CURL 头文件
  28. #include "curl/curl.h"

一个帮助类

helper.h

  1. #ifndef HUGOPEIXOTO_NET_REQUESTS_H_
  2. #define HUGOPEIXOTO_NET_REQUESTS_H_
  5. // 导入头文件
  6. #include <WinSock2.h>
  7. #include <Ws2tcpip.h>
  8. #include <windows.h>
  9. #include <Wincrypt.h>
  10. #include <map>
  11. #include <string>
  13. // 链接WIN32的静态库
  14. #pragma comment(lib, "Ws2_32.lib")
  15. #pragma comment(lib, "winmm.lib")
  16. #pragma comment(lib, "wldap32.lib")
  17. #pragma comment(lib, "Advapi32.lib")
  20. // 用于使用静态库
  21. #define BUILDING_LIBCURL
  23. // 用于自动查找到CURL目录下的lib文件
  24. #define   LIBPATH(p,f)   p##f 
  26. // 用于链接不同版本的静态库
  27. #ifdef QT_NO_DEBUG 
  28. #pragma comment(lib, LIBPATH(__FILE__,   ".dir/../libcurl.lib"))
  29. #else
  30. #pragma comment(lib, LIBPATH(__FILE__,   ".dir/../libcurl_debug.lib"))
  31. #endif
  33. // 包含CURL 头文件
  34. #include "curl/curl.h"
  36. namespace requests {
  37. typedef std::multimap<std::string, std::string> Headers;
  39. struct Response {
  40.     uint32_t status_code;
  41.     Headers headers;
  42.     std::string body;
  44.     Response();
  45. };
  47. struct Request {
  48.     std::string method;
  49.     std::string url;
  50.     std::string proxyURL;
  51.     Headers headers;
  52.     std::string body;
  53. };
  55. Response get(std::string url, const std::string proxyURL="", Headers = {});
  56. Response post(std::string url, const std::string &body, const std::string proxyURL="", Headers = {});
  57. Response put(std::string url, const std::string &body, const std::string proxyURL="", Headers = {});
  58. Response call(const Request &req);
  59. }
  61. #endif

helper.cpp

  1. #include "requests.h"
  3. static int body_writer(char *data, size_t size, size_t nmemb,
  4.                        requests::Response *response) {
  5.     response->body.append(data, size * nmemb);
  6.     return size * nmemb;
  7. }
  9. static int header_writer(char *data, size_t size, size_t nmemb,
  10.                          requests::Response *response) {
  11.     std::string header(data, size*nmemb);
  13.     auto idx = header.find(':');
  14.     if (idx != std::string::npos && idx > 0 && idx + 4 < header.size()) {
  15.         response->headers.insert(std::make_pair(
  16.                                      header.substr(0, idx),
  17.                                      header.substr(idx+2, header.size()-idx-4)));
  18.     }
  20.     return size * nmemb;
  21. }
  23. requests::Response::Response() { status_code = 0; }
  26. requests::Response requests::get(std::string url, const std::string proxyURL, Headers headers) {
  27.     Request req;
  29.     req.method = "GET";
  30.     req.url = url;
  31.     req.headers = headers;
  32.     req.proxyURL = proxyURL;
  34.     return call(req);
  35. }
  37. requests::Response requests::post(std::string url, const std::string &body,
  38.                                   const std::string proxyURL, Headers headers) {
  39.     Request req;
  41.     req.method = "POST";
  42.     req.url = url;
  43.     req.headers = headers;
  44.     req.body = body;
  45.     req.proxyURL = proxyURL;
  47.     return call(req);
  48. }
  50. requests::Response requests::put(std::string url, const std::string &body,
  51.                                  const std::string proxyURL, Headers headers) {
  52.     Request req;
  54.     req.method = "PUT";
  55.     req.url = url;
  56.     req.headers = headers;
  57.     req.body = body;
  58.     req.proxyURL = proxyURL;
  60.     return call(req);
  61. }
  63. requests::Response requests::call(const Request &request) {
  64.     requests::Response response;
  66.     CURL *curl = curl_easy_init();
  68.     struct curl_slist *headers = nullptr;
  70.     for (auto header : request.headers) {
  71.         std::string header_line = header.first + ": " + header.second;
  72.         headers = curl_slist_append(headers, header_line.c_str());
  73.     }
  75.     curl_easy_setopt(curl, CURLOPT_CUSTOMREQUEST, request.method.c_str());
  76.     curl_easy_setopt(curl, CURLOPT_URL, request.url.c_str());
  77.     curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers);
  78.     curl_easy_setopt(curl, CURLOPT_POSTFIELDS, request.body.c_str());
  80.     curl_easy_setopt(curl, CURLOPT_NOSIGNAL, 1);
  82.     // curl_easy_setopt(curl, CURLOPT_TIMEOUT, 10);
  83.     // curl_easy_setopt(curl, CURLOPT_ENCODING, "identity");
  85.     curl_easy_setopt(curl, CURLOPT_MAXREDIRS, 10);
  86.     curl_easy_setopt(curl, CURLOPT_FOLLOWLOCATION, 1);
  88.     curl_easy_setopt(curl, CURLOPT_HEADER, 0);
  90.     if(request.proxyURL.length() > 0)
  91.     {
  92.         curl_easy_setopt(curl, CURLOPT_PROXY, request.proxyURL.c_str());
  93.     }
  95.     curl_easy_setopt(curl, CURLOPT_WRITEDATA, &response);
  96.     curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, body_writer);
  98.     curl_easy_setopt(curl, CURLOPT_WRITEHEADER, &response);
  99.     curl_easy_setopt(curl, CURLOPT_HEADERFUNCTION, header_writer);
  101.     curl_easy_perform(curl);
  102.     curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE, &response.status_code);
  104.     curl_slist_free_all(headers);
  105.     curl_easy_cleanup(curl);
  107.     return response;
  108. }