WinHttp异步实现GET, POST, 多线程下载文件

CWinHttpClient.h

2. #pragma once
4. #include <Windows.h>
5. #include <WinHttp.h>
6. #include <stdint.h>
7. #include <string>
8. #include <vector>
9. #include <functional>
10. #include <map>
11. #include <set>
12. #include <thread>
13. #include <time.h>
14. #include <tchar.h>
16. #ifdef _UNICODE
17. using _tstring = std::wstring;
18. #else
19. using _tstring = std::string;
20. #endif
22. #pragma comment(lib, "winhttp.lib")
23. #define WINHTTP_AGENT_HTTPS "(Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/122.0.0.0 Safari/537.36 Edg/122.0.0.0)"
25. // 响应结果
26. class CWinHttpResult
27. {
28. public:
29.     CWinHttpResult() :code(0) {}
30.     std::string result;             //响应结果
31.     uint32_t code;                  //响应状态码
32. };
34. // 进度信息
35. typedef struct _WINHTTP_PROGRESS_INFO
36. {
37.     ULONGLONG ullCur;           // 当前下载量(字节)
38.     ULONGLONG ullTotal;         // 总数据量(字节)
39.     double lfProgress;          // 当前进度(0.0f - 1.0f)
40.     double lfSpeed;             // 当前速度(字节/秒)
41.     double lfRemainTime;        // 剩余时间(毫秒)
42.     clock_t costTime;           // 消耗时间(毫秒)
43.     uint32_t nActiveThread;     // 活动任务数
44.     uint32_t nTotalThread;      // 总任务线程数
45. }WINHTTP_PROGRESS_INFO, *LPWINHTTP_PROGRESS_INFO;
47. // 异步数据
48. typedef struct _WHTTP_ASYNC_DATA
49. {
50.     DWORD_PTR dwContext;                // 上下文
51.     HANDLE hEvent;                      // 事件
52.     DWORD dwWait;                       // 事件等待结果
53.     DWORD dwSize;                       // 传输数据大小
54.     WINHTTP_ASYNC_RESULT AsyncResult;   // 异步结果
55. }WHTTP_ASYNC_DATA, *LPWHTTP_ASYNC_DATA;
57. // 进度回调
58. using WinHttpCallback = std::function<bool(const WINHTTP_PROGRESS_INFO& progress)>;
60. class CWinHttpValue;
61. using CWinHttpObject = std::map<_tstring, CWinHttpValue>;
62. using CWinHttpArray = std::vector<CWinHttpValue>;
64. // WinHttp客户端参数类
65. class CWinHttpValue
66. {
67. public:
69.     CWinHttpValue();
70.     CWinHttpValue(bool val);
71.     CWinHttpValue(int val);
72.     CWinHttpValue(double val);
73.     CWinHttpValue(const LPCTSTR val);
74.     CWinHttpValue(const _tstring& val);
75.     CWinHttpValue(const CWinHttpObject& val);
76.     CWinHttpValue(const CWinHttpValue& val);
77.     CWinHttpValue(const CWinHttpArray& val);
78.     CWinHttpValue(CWinHttpValue&& val) noexcept;
79.     ~CWinHttpValue();
81.     bool IsEmpty() const;
82.     _tstring AsGetString() const;
83.     _tstring AsJsonString() const;
84.     _tstring AsHeaderString() const;
86. private:
87.     _tstring _AsGetString() const;
88.     _tstring _AsJsonString() const;
89.     _tstring _AsHeaderString(int depth) const;
90.     static void _DumpString(_tstring& append_str, const _tstring& text, bool flag_escape);
91.     static bool _GetUnicodeString(_tstring& append_str, const TCHAR* data_ptr, const TCHAR** end_ptr);
93. private:
95.     union _WIN_HTTP_VALUE_DATA
96.     {
97.         bool                _Bool;
98.         int                 _Int;
99.         double              _Float;
100.         _tstring*           _StringPtr;
101.         CWinHttpObject*     _ObjectPtr;
102.         CWinHttpArray*      _ArrayPtr;
103.     }m_Data;
105.     enum _WIN_HTTP_VALUE_TPYE
106.     {
107.         TypeNull,
108.         TypeBool,
109.         TypeInt,
110.         TypeFloat,
111.         TpyeString,
112.         TpyeObject,
113.         TpyeArray
114.     }m_Type;
115. };
117. // WinHttp客户端辅助类
118. class CWinHttpClient
119. {
120. public:
122.     CWinHttpClient();
124.     ~CWinHttpClient();
126.     // 关闭
127.     void Close();
129.     // 发送 GET 请求
130.     CWinHttpResult Get(const _tstring& url, const CWinHttpValue& param = {}, const CWinHttpValue& header = {}, WinHttpCallback cb = nullptr);
132.     // 发送 POST 请求
133.     CWinHttpResult Post(const _tstring& url, const CWinHttpValue& param = {}, const CWinHttpValue& header = {}, WinHttpCallback cb = nullptr);
135.     // 发送 GET 请求(多线程)
136.     CWinHttpResult GetEx(const _tstring& url, const CWinHttpValue& param = {}, const CWinHttpValue& header = {}, WinHttpCallback cb = nullptr, DWORD dwThreadCount = 1);
138.     // 多线程下载文件
139.     CWinHttpResult DownloadFile(const _tstring& url, const _tstring& path = _T(""), const CWinHttpValue& header = {}, WinHttpCallback cb = nullptr, DWORD dwThreadCount = 4);
141.     // 设置用户代理字符串
142.     void SetAgent(const _tstring strAgent = _T(WINHTTP_AGENT_HTTPS));
144.     // 设置请求数据范围
145.     void SetReQuestDataRange(ULONGLONG ullStart = 0, ULONGLONG ullLength = -1);
147.     // 设置异步状态打印
148.     void SetPrintStatus(bool fEnable = true);
150. public:
152.     // 字符串转UTF-8编码字符串
153.     static std::string TStrToU8Str(const _tstring& str);
155.     // 字符串转宽字节字符串
156.     static std::wstring TStrToWStr(const _tstring& str);
158.     // 宽字节字符串转字符串
159.     static _tstring WStrToTStr(const std::wstring& str);
161.     // 控制台打印
162.     static void ConsoleOutput(LPCTSTR pFormat, ...);
164.     // 编码Utf8字符串
165.     static std::string EncoderFromUtf8(const std::string& strContent);
167.     // 解码Utf8字符串
168.     static std::string DecoderFromUtf8(const std::string& strContent);
170. private:
172.     // 发送 GET 请求
173.     CWinHttpResult _Get(const _tstring& url, WinHttpCallback cb = nullptr);
175.     // 发送 POST 请求
176.     CWinHttpResult _Post(const _tstring& url, WinHttpCallback cb = nullptr);
178.     // 执行请求
179.     CWinHttpResult _DoRequest(const _tstring& url, const _tstring& strMethod, const std::string& strParam);
181.     // 执行请求(多线程)
182.     CWinHttpResult _GetEx(const _tstring& url, WinHttpCallback cb = nullptr, DWORD dwThreadCount = 1);
184.     CWinHttpResult _MultiThreadRequest(const _tstring& url, ULONGLONG ullContentLength, DWORD dwThreadCount = 1);
186.     // 读取网络流
187.     bool _InternetReadData(std::string& strData);
189.     // 查询资源大小
190.     bool _QueryContentLength(PULONGLONG lpUllContentLength);
192.     // 查询是否支持接收范围
193.     bool _IsSupportAcceptRanges();
195.     // 设置请求数据范围
196.     bool _SetRequestDataRange(LONGLONG nBegin, LONGLONG nLength);
198.     // 获取状态码
199.     DWORD _GetStatusCode(HINTERNET hRequest);
201.     // 错误输出
202.     void _PrintError(LPCTSTR lpszError) const;
204.     // 状态码打印
205.     static void _PrintStatus(DWORD dwCode, LPVOID lpvStatusInformation, DWORD dwStatusInformationLength);
207.     // 状态回调
208.     static VOID CALLBACK WinHttpStatusCallback(HINTERNET hInternet, DWORD_PTR dwContext, DWORD dwStatus, LPVOID lpvInfo, DWORD dwInfoLength);
210.     // 状态回调
211.     void _WinHttpStatusCallback(HINTERNET hInternet, DWORD dwStatus, LPVOID lpvInfo, DWORD dwInfoLength);
213.     // 等待异步事件
214.     bool _WaitForAsyncEvent(DWORD dwMilliseconds = INFINITE);
216.     // 打开会话
217.     bool _WinHttpOpen(LPCWSTR pszAgentW, DWORD dwAccessType, LPCWSTR pszProxyW, LPCWSTR pszProxyBypassW, DWORD dwFlags);
219.     // 设置会话超时
220.     bool _WinHttpSetSessionTimeouts(int nResolveTimeout, int nConnectTimeout,int nSendTimeout,int nReceiveTimeout);
222.     // 设置请求超时
223.     bool _WinHttpSetRequestTimeouts(int nResolveTimeout, int nConnectTimeout,int nSendTimeout,int nReceiveTimeout);
225.     // 设置状态回调
226.     bool _WinHttpSetStatusCallback(WINHTTP_STATUS_CALLBACK lpfnInternetCallback, DWORD dwNotificationFlags);
228.     // 设置会话选项
229.     bool _WinHttpSetSessionOption(DWORD dwOption, LPVOID lpBuffer, DWORD dwBufferLength);
231.     // 设置请求选项
232.     bool _WinHttpSetRequestOption(DWORD dwOption, LPVOID lpBuffer, DWORD dwBufferLength);
234.     // 连接会话
235.     bool _WinHttpConnect(LPCWSTR pswzServerName, INTERNET_PORT nServerPort);
237.     // 打开请求
238.     bool _WinHttpOpenRequest(const _tstring& strVerb, LPCWSTR pwszObjectName, LPCWSTR pwszVersion, LPCWSTR pwszReferrer, LPCWSTR *ppwszAcceptTypes, DWORD dwFlags);
240.     // 发送请求
241.     bool _WinHttpSendRequest(_tstring strHeader, LPVOID lpData, DWORD dwSize, DWORD_PTR dwContext);
243.     // 查询请求头
244.     bool _WinHttpQueryHeaders(DWORD dwInfoLevel, LPCWSTR pwszName, LPVOID lpBuffer, LPDWORD lpdwBufferLength, LPDWORD lpdwIndex);
246.     // 接收响应数据
247.     bool _WinHttpReceiveResponse(HINTERNET hRequest);
249.     // 查询请求数据是否可用
250.     bool _WinHttpQueryDataAvailable(LPDWORD lpdwNumberOfBytesAvailable);
252.     // 读取请求数据
253.     bool _WinHttpReadData(LPVOID lpBuffer, DWORD dwNumberOfBytesToRead, LPDWORD lpdwNumberOfBytesRead);
255.     // 宽字节字符串转多字节字符串
256.     static std::string _WStrToMultiStr(UINT CodePage, const std::wstring& str);
258.     // 多字节字符串转宽字节字符串
259.     static std::wstring _MultiStrToWStr(UINT CodePage, const std::string& str);
261. private:
262.     HINTERNET m_hSession;                           // 会话句柄
263.     HINTERNET m_hConnect;                           // 连接句柄
264.     HINTERNET m_hRequest;                           // 请求句柄
266.     WinHttpCallback m_cbProgress;                   // 进度回调
267.     WHTTP_ASYNC_DATA        m_AsyncData;            // 异步信息
268.     _tstring                m_strAgent;             // 代理字符串
269.     _tstring                m_strFilePath;          // 保存文件路径
271.     _tstring                m_strUrl;               // 请求链接
272.     _tstring                m_strHeader;            // 请求头信息
273.     _tstring                m_strParam;             // 请求参数
275.     ULONGLONG               m_ullStart;             // 请求数据起始位置
276.     ULONGLONG               m_ullLength;            // 请求长度
277.     ULONGLONG               m_ullDownload;          // 已下载数据
278.     bool                    m_fAbort;               // 终止
279.     bool                    m_fPrint;               // 打印进度
280. };

复制代码

CWinHttpClient.cpp

2. #include "CWinHttpClient.h"
3. #include <strsafe.h>
4. #include <thread>
5. #include <atomic>
6. #include <map>
8. std::map<int32_t, std::string> g_utf8Code;
9. static std::map<int32_t, std::string> GetUtf8Code();
11. typedef struct _WINHTTP_URL_INFO
12. {
13.     std::wstring strScheme;
14.     std::wstring strHostName;
15.     std::wstring strUserName;
16.     std::wstring strPassword;
17.     std::wstring urlPath;
18.     std::wstring strExtraInfo;
20.     URL_COMPONENTS uc = { 0 };
22.     _WINHTTP_URL_INFO()
23.     {
24.         memset(&uc, 0, sizeof(uc));
26.         try
27.         {
28.             strScheme.resize(32);
29.             strHostName.resize(128);
30.             strUserName.resize(128);
31.             strPassword.resize(128);
32.             urlPath.resize(2048);
33.             strExtraInfo.resize(512);
35.             this->uc.dwStructSize = sizeof(this->uc);
36.             this->uc.lpszScheme = &this->strScheme[0];
37.             this->uc.dwSchemeLength = (DWORD)strScheme.size();
38.             this->uc.lpszHostName = &this->strHostName[0];
39.             this->uc.dwHostNameLength = (DWORD)strHostName.size();
40.             this->uc.lpszUserName = &this->strUserName[0];
41.             this->uc.dwUserNameLength = (DWORD)strUserName.size();
42.             this->uc.lpszPassword = &this->strPassword[0];
43.             this->uc.dwPasswordLength = (DWORD)strPassword.size();
44.             this->uc.lpszUrlPath = &this->urlPath[0];
45.             this->uc.dwUrlPathLength = (DWORD)urlPath.size();
46.             this->uc.lpszExtraInfo = &this->strExtraInfo[0];
47.             this->uc.dwExtraInfoLength = (DWORD)strExtraInfo.size();
48.         }
49.         catch (...)
50.         {
52.         }
53.     }
54. }WINHTTP_URL_INFO, *PWINHTTP_URL_INFO;
58. CWinHttpValue::CWinHttpValue()
59.     :
60.     m_Data{ 0 },
61.     m_Type(_WIN_HTTP_VALUE_TPYE::TypeNull)
62. {
63. }
65. CWinHttpValue::CWinHttpValue(bool val) : CWinHttpValue()
66. {
67.     m_Data._Bool = val;
68.     m_Type = _WIN_HTTP_VALUE_TPYE::TypeBool;
69. }
71. CWinHttpValue::CWinHttpValue(int val) : CWinHttpValue()
72. {
73.     m_Data._Int = val;
74.     m_Type = _WIN_HTTP_VALUE_TPYE::TypeInt;
75. }
77. CWinHttpValue::CWinHttpValue(double val) : CWinHttpValue()
78. {
79.     m_Data._Float = val;
80.     m_Type = _WIN_HTTP_VALUE_TPYE::TypeFloat;
81. }
83. CWinHttpValue::CWinHttpValue(const LPCTSTR val) : CWinHttpValue()
84. {
85.     if (val)
86.     {
87.         m_Data._StringPtr = new (std::nothrow) _tstring(val);
88.     }
90.     m_Type = _WIN_HTTP_VALUE_TPYE::TpyeString;
91. }
93. CWinHttpValue::CWinHttpValue(const _tstring& val) : CWinHttpValue()
94. {
95.     m_Data._StringPtr = new (std::nothrow) _tstring(val);
96.     m_Type = _WIN_HTTP_VALUE_TPYE::TpyeString;
97. }
99. CWinHttpValue::CWinHttpValue(const CWinHttpObject& val) : CWinHttpValue()
100. {
101.     m_Data._ObjectPtr = new (std::nothrow) CWinHttpObject(val);
102.     m_Type = _WIN_HTTP_VALUE_TPYE::TpyeObject;
103. }
105. CWinHttpValue::CWinHttpValue(const CWinHttpArray& val) : CWinHttpValue()
106. {
107.     m_Data._ArrayPtr = new (std::nothrow) CWinHttpArray(val);
108.     m_Type = _WIN_HTTP_VALUE_TPYE::TpyeArray;
109. }
111. CWinHttpValue::CWinHttpValue(const CWinHttpValue& val) : CWinHttpValue()
112. {
113.     if (_WIN_HTTP_VALUE_TPYE::TpyeString == val.m_Type && val.m_Data._StringPtr)
114.     {
115.         m_Data._StringPtr = new (std::nothrow) _tstring(*val.m_Data._StringPtr);
116.     }
117.     else if (_WIN_HTTP_VALUE_TPYE::TpyeObject == val.m_Type && val.m_Data._ObjectPtr)
118.     {
119.         m_Data._ObjectPtr = new (std::nothrow) CWinHttpObject(*val.m_Data._ObjectPtr);
120.     }
121.     else if (_WIN_HTTP_VALUE_TPYE::TpyeArray == val.m_Type && val.m_Data._ArrayPtr)
122.     {
123.         m_Data._ArrayPtr = new (std::nothrow) CWinHttpArray(*val.m_Data._ArrayPtr);
124.     }
127.     m_Type = val.m_Type;
128. }
130. CWinHttpValue::CWinHttpValue(CWinHttpValue&& val) noexcept
131. {
132.     m_Data = val.m_Data;
133.     m_Type = val.m_Type;
134.     val.m_Data = { 0 };
135.     val.m_Type = _WIN_HTTP_VALUE_TPYE::TypeBool;
136. }
138. CWinHttpValue::~CWinHttpValue()
139. {
140.     if (_WIN_HTTP_VALUE_TPYE::TpyeString == m_Type)
141.     {
142.         delete m_Data._StringPtr;
143.     }
144.     else if (_WIN_HTTP_VALUE_TPYE::TpyeObject == m_Type)
145.     {
146.         delete m_Data._ObjectPtr;
147.     }
148.     else if (_WIN_HTTP_VALUE_TPYE::TpyeArray == m_Type)
149.     {
150.         delete m_Data._ArrayPtr;
151.     }
153.     m_Data = { 0 };
154.     m_Type = _WIN_HTTP_VALUE_TPYE::TypeBool;
155. }
157. bool CWinHttpValue::IsEmpty() const
158. {
159.     if (_WIN_HTTP_VALUE_TPYE::TpyeObject == m_Type && m_Data._ObjectPtr)
160.     {
161.         return m_Data._ObjectPtr->empty();
162.     }
164.     return false;
165. }
167. _tstring CWinHttpValue::AsGetString() const
168. {
169.     _tstring strResult;
171.     if (IsEmpty())
172.     {
173.         return strResult;
174.     }
176.     return _AsGetString();
177. }
179. _tstring CWinHttpValue::AsJsonString() const
180. {
181.     return _AsJsonString();
182. }
184. _tstring CWinHttpValue::AsHeaderString() const
185. {
186.     return _AsHeaderString(0);
187. }
189. bool CWinHttpValue::_GetUnicodeString(_tstring& append_str, const TCHAR* data_ptr, const TCHAR** end_ptr)
190. {
191.     TCHAR ch = *data_ptr;
193. #ifdef _UNICODE
194.     _tchar text_buffer[32] = { 0 };
195.     _json_stprintf_s(text_buffer, sizeof(text_buffer) / sizeof(_tchar), _T(R"(\u%.4x)"), ch);
196.     append_str += text_buffer;
197.     data_ptr++;
199. #else
200.     if (ch >= 0xC0)
201.     {
202.         // The number of bytes used to obtain characters.
203.         size_t byte_count = 0;
204.         uint32_t cp32 = 0;
206.         if (ch >= 0xE0 && ch <= 0xEF)
207.         {
208.             byte_count = 3;
209.             cp32 = ch & 0x0F;
210.         }
211.         else if (ch >= 0xC0 && ch <= 0xDF)
212.         {
213.             byte_count = 2;
214.             cp32 = ch & 0x1F;
215.         }
216.         else if (ch >= 0xF0 && ch <= 0xF7)
217.         {
218.             byte_count = 4;
219.             cp32 = ch & 0x07;
220.         }
221.         else if (ch >= 0xF8 && ch <= 0xFB)
222.         {
223.             byte_count = 5;
224.             cp32 = ch & 0x03;
225.         }
226.         else if (ch >= 0xFC && ch <= 0xFD)
227.         {
228.             byte_count = 6;
229.             cp32 = ch & 0x01;
230.         }
232.         if (0 == byte_count)
233.         {
234.             return false;
235.         }
237.         for (size_t i = 1; i < byte_count; i++)
238.         {
239.             cp32 = cp32 << 6;
240.             cp32 |= data_ptr[i] & 0x3F;
241.         }
243.         char text_buffer[32] = { 0 };
244.         if (cp32 < 0x10000)
245.         {
246.             snprintf(text_buffer, sizeof(text_buffer), R"(\u%.4x)", cp32);
247.             append_str.append(text_buffer, 6);
248.         }
249.         else
250.         {
251.             uint32_t cp = (uint16_t)(cp32 - 0x10000);
252.             uint16_t cp32_high = (uint16_t)(cp >> 10) + 0xD800;
253.             uint16_t cp32_low = (uint16_t)(cp & 0x3FF) + 0xDC00;
255.             snprintf(text_buffer, sizeof(text_buffer), R"(\u%.4x\u%.4x)", cp32_high, cp32_low);
256.             append_str.append(text_buffer, 12);
257.         }
259.         data_ptr += byte_count;
260.     }
261. #endif
263.     if (end_ptr)
264.     {
265.         *end_ptr = data_ptr;
266.     }
268.     return false;
269. }
271. void CWinHttpValue::_DumpString(_tstring& append_str, const _tstring& text, bool flag_escape)
272. {
273.     const TCHAR* data_ptr = text.c_str();
275.     while (_T('\0') != *data_ptr)
276.     {
277.         TCHAR ch = *data_ptr;
279.         switch (ch)
280.         {
281.         case _T('\b'):
282.         {
283.             append_str += _T(R"(\b)");
284.         }
285.         break;
286.         case _T('\t'):
287.         {
288.             append_str += _T(R"(\t)");
289.         }
290.         break;
291.         case _T('\n'):
292.         {
293.             append_str += _T(R"(\n)");
294.         }
295.         break;
296.         case _T('\f'):
297.         {
298.             append_str += _T(R"(\f)");
299.         }
300.         break;
301.         case _T('\r'):
302.         {
303.             append_str += _T(R"(\r)");
304.         }
305.         break;
306.         case _T('"'):
307.         {
308.             append_str += _T(R"(")");
309.         }
310.         break;
311.         case _T('/'):
312.         {
313.             append_str += _T(R"(/)");
314.         }
315.         case _T('\\'):
316.         {
317.             append_str += _T(R"(\\)");
318.         }
319.         break;
320.         default:
321.         {
322.             if (ch < 0x80 || !flag_escape)
323.             {
324.                 append_str.push_back(ch);
325.             }
326.             else
327.             {
328.                 _GetUnicodeString(append_str, data_ptr, &data_ptr);
329.                 continue;
330.             }
331.         }
332.         break;
333.         }
335.         data_ptr++;
336.     }
337. }
339. _tstring CWinHttpValue::_AsGetString() const
340. {
341.     _tstring strResult;
342.     if (_WIN_HTTP_VALUE_TPYE::TypeBool == m_Type)
343.     {
344.         strResult = m_Data._Bool ? _T("true") : _T("false");
345.     }
346.     else if (_WIN_HTTP_VALUE_TPYE::TypeInt == m_Type)
347.     {
348.         TCHAR szBuf[MAX_PATH] = { 0 };
349.         ::StringCchPrintf(szBuf, _countof(szBuf), _T("%d"), m_Data._Int);
350.         strResult = szBuf;
351.     }
352.     else if (_WIN_HTTP_VALUE_TPYE::TypeFloat == m_Type)
353.     {
354.         TCHAR szBuf[MAX_PATH] = { 0 };
355.         ::StringCchPrintf(szBuf, _countof(szBuf), _T("%.16g"), m_Data._Float);
356.         strResult = szBuf;
358.         TCHAR* chPtr = szBuf;
359.         bool flag_dot = false;
360.         bool flag_exponent = false;
362.         while (_T('\0') != *chPtr)
363.         {
364.             TCHAR ch = *chPtr;
365.             if (_T('.') == ch)
366.             {
367.                 flag_dot = true;
368.             }
369.             else if (_T('e') == ch)
370.             {
371.                 flag_exponent = true;
372.             }
373.             chPtr++;
374.         }
376.         if (!flag_dot && 0 == !flag_exponent)
377.         {
378.             strResult += _T(".0");
379.         }
380.     }
381.     else if (_WIN_HTTP_VALUE_TPYE::TpyeString == m_Type)
382.     {
383.         strResult = *m_Data._StringPtr;
384.     }
385.     else if (_WIN_HTTP_VALUE_TPYE::TpyeObject == m_Type)
386.     {
387.         const CWinHttpObject& object = *m_Data._ObjectPtr;
388.         size_t size = object.size();
389.         if (!object.empty())
390.         {
391.             strResult += _T("?");
392.             for (const auto& item : object)
393.             {
394.                 strResult += item.first;
395.                 strResult += _T("=");
396.                 strResult += item.second._AsGetString();
397.                 size--;
398.                 if (size > 0)
399.                 {
400.                     strResult += _T("&");
401.                 }
402.             }
403.         }
404.     }
405.     else if (_WIN_HTTP_VALUE_TPYE::TpyeArray == m_Type)
406.     {
407.         const CWinHttpArray& object = *m_Data._ArrayPtr;
408.         size_t size = object.size();
409.         for (const auto& item : object)
410.         {
411.             strResult += item._AsGetString();
412.             size--;
413.             if (size > 0)
414.             {
415.                 strResult += _T(",");
416.             }
417.         }
418.     }
420.     return strResult;
421. }
423. _tstring CWinHttpValue::_AsJsonString() const
424. {
425.     _tstring strResult;
426.     if (_WIN_HTTP_VALUE_TPYE::TypeBool == m_Type)
427.     {
428.         strResult = m_Data._Bool ? _T("true") : _T("false");
429.     }
430.     else if (_WIN_HTTP_VALUE_TPYE::TypeInt == m_Type)
431.     {
432.         TCHAR szBuf[MAX_PATH] = { 0 };
433.         ::StringCchPrintf(szBuf, _countof(szBuf), _T("%d"), m_Data._Int);
434.         strResult = szBuf;
435.     }
436.     else if (_WIN_HTTP_VALUE_TPYE::TypeFloat == m_Type)
437.     {
438.         TCHAR szBuf[MAX_PATH] = { 0 };
439.         ::StringCchPrintf(szBuf, _countof(szBuf), _T("%.16g"), m_Data._Float);
440.         strResult = szBuf;
442.         TCHAR* chPtr = szBuf;
443.         bool flag_dot = false;
444.         bool flag_exponent = false;
446.         while (_T('\0') != *chPtr)
447.         {
448.             TCHAR ch = *chPtr;
449.             if (_T('.') == ch)
450.             {
451.                 flag_dot = true;
452.             }
453.             else if (_T('e') == ch)
454.             {
455.                 flag_exponent = true;
456.             }
457.             chPtr++;
458.         }
460.         if (!flag_dot && 0 == !flag_exponent)
461.         {
462.             strResult += _T(".0");
463.         }
464.     }
465.     else if (_WIN_HTTP_VALUE_TPYE::TpyeString == m_Type)
466.     {
467.         strResult += _T(""");
468.         _DumpString(strResult, *m_Data._StringPtr, false);
469.         strResult += _T(""");
470.     }
471.     else if (_WIN_HTTP_VALUE_TPYE::TpyeObject == m_Type)
472.     {
473.         const CWinHttpObject& object = *m_Data._ObjectPtr;
474.         size_t size = object.size();
475.         if (!object.empty())
476.         {
477.             strResult += _T("{");
478.             for (const auto& item : object)
479.             {
480.                 strResult += _T(""");
481.                 _DumpString(strResult, item.first, false);
482.                 strResult += _T(""");
483.                 strResult += _T(":");
484.                 strResult += item.second._AsJsonString();
485.                 size--;
486.                 if (size > 0)
487.                 {
488.                     strResult += _T(",");
489.                 }
490.             }
491.             strResult += _T("}");
492.         }
493.     }
494.     else if (_WIN_HTTP_VALUE_TPYE::TpyeArray == m_Type)
495.     {
496.         const CWinHttpArray& object = *m_Data._ArrayPtr;
497.         size_t size = object.size();
498.         strResult += _T("[");
499.         for (const auto& item : object)
500.         {
501.             strResult += item._AsJsonString();
502.             size--;
503.             if (size > 0)
504.             {
505.                 strResult += _T(",");
506.             }
507.         }
508.         strResult += _T("]");
509.     }
511.     return strResult;
512. }
514. _tstring CWinHttpValue::_AsHeaderString(int depth) const
515. {
516.     _tstring strResult;
517.     if (_WIN_HTTP_VALUE_TPYE::TypeBool == m_Type)
518.     {
519.         strResult = m_Data._Bool ? _T("true") : _T("false");
520.     }
521.     else if (_WIN_HTTP_VALUE_TPYE::TypeInt == m_Type)
522.     {
523.         TCHAR szBuf[MAX_PATH] = { 0 };
524.         ::StringCchPrintf(szBuf, _countof(szBuf), _T("%d"), m_Data._Int);
525.         strResult = szBuf;
526.     }
527.     else if (_WIN_HTTP_VALUE_TPYE::TypeFloat == m_Type)
528.     {
529.         TCHAR szBuf[MAX_PATH] = { 0 };
530.         ::StringCchPrintf(szBuf, _countof(szBuf), _T("%.16g"), m_Data._Float);
531.         strResult = szBuf;
533.         TCHAR* chPtr = szBuf;
534.         bool flag_dot = false;
535.         bool flag_exponent = false;
537.         while (_T('\0') != *chPtr)
538.         {
539.             TCHAR ch = *chPtr;
540.             if (_T('.') == ch)
541.             {
542.                 flag_dot = true;
543.             }
544.             else if (_T('e') == ch)
545.             {
546.                 flag_exponent = true;
547.             }
548.             chPtr++;
549.         }
551.         if (!flag_dot && 0 == !flag_exponent)
552.         {
553.             strResult += _T(".0");
554.         }
555.     }
556.     else if (_WIN_HTTP_VALUE_TPYE::TpyeString == m_Type)
557.     {
558.         strResult += *m_Data._StringPtr;
559.     }
560.     else if (_WIN_HTTP_VALUE_TPYE::TpyeObject == m_Type)
561.     {
562.         const CWinHttpObject& object = *m_Data._ObjectPtr;
563.         size_t size = object.size();
564.         if (!object.empty())
565.         {
566.             for (const auto& item : object)
567.             {
568.                 strResult += item.first;
570.                 strResult += _T(": ");
571.                 strResult += item.second._AsHeaderString(depth + 1);
572.                 size--;
573.                 if (size > 0)
574.                 {
575.                     strResult += _T("\r\n");
576.                 }
577.             }
578.         }
579.     }
580.     else if (_WIN_HTTP_VALUE_TPYE::TpyeArray == m_Type)
581.     {
582.         const CWinHttpArray& object = *m_Data._ArrayPtr;
583.         size_t size = object.size();
584.         for (const auto& item : object)
585.         {
586.             strResult += item._AsHeaderString(depth + 1);
587.             size--;
588.             if (size > 0)
589.             {
590.                 strResult += _T(", ");
591.             }
592.         }
593.     }
595.     return strResult;
596. }
598. CWinHttpClient::CWinHttpClient()
599.     :
600.     m_hSession(NULL),
601.     m_hConnect(NULL),
602.     m_hRequest(NULL),
603.     m_fAbort(false),
604.     m_fPrint(false),
605.     m_ullStart(0),
606.     m_ullLength(-1),
607.     m_ullDownload(0),
608.     m_AsyncData{ 0 }
609. {
610.     m_AsyncData.hEvent = ::CreateEvent(NULL, FALSE, FALSE, NULL);
612.     return;
613. }
615. CWinHttpClient::~CWinHttpClient()
616. {
617.     Close();
619.     if (NULL != m_AsyncData.hEvent)
620.     {
621.         ::CloseHandle(m_AsyncData.hEvent);
622.     }
623. }
625. void CWinHttpClient::Close()
626. {
627.     m_fAbort = true;
629.     if (NULL != m_AsyncData.hEvent)
630.     {
631.         ::SetEvent(m_AsyncData.hEvent);
632.     }
634.     if (m_hRequest)
635.     {
636.         ::WinHttpCloseHandle(m_hRequest);
637.         m_hRequest = NULL;
638.     }
640.     if (m_hConnect)
641.     {
642.         ::WinHttpCloseHandle(m_hConnect);
643.         m_hConnect = NULL;
644.     }
646.     if (m_hSession)
647.     {
648.         ::WinHttpCloseHandle(m_hSession);
649.         m_hSession = NULL;
650.     }
652.     m_fAbort = false;
653. }
655. std::string FormatA(LPCSTR pFormat, ...)
656. {
657.     size_t nCchCount = MAX_PATH;
658.     std::string strResult(nCchCount, 0);
659.     va_list args;
661.     va_start(args, pFormat);
663.     do
664.     {
665.         //成功则赋值字符串并终止循环
666.         int nSize = _vsnprintf_s(&strResult[0], nCchCount, _TRUNCATE, pFormat, args);
667.         if (-1 != nSize)
668.         {
669.             strResult.resize(nSize);
670.             break;
671.         }
673.         //缓冲大小超限终止
674.         if (nCchCount >= INT32_MAX)
675.         {
676.             break;
677.         }
679.         //重新分配缓冲
680.         nCchCount *= 2;
681.         strResult.resize(nCchCount);
683.     } while (true);
685.     va_end(args);
687.     return strResult;
688. }
690. std::map<int32_t, std::string> GetUtf8Code()
691. {
692.     std::map<int32_t, std::string> mapCode;
694.     uint8_t szBuf[MAX_PATH] = { 0 };
695.     for (uint32_t i = 0x4E00; i <= 0x9FFF; i++)
696.     {
697.         // 1字节
698.         // 0xxxxxxx
699.         if (i >= 0x00000000 && i <= 0x0000007F)
700.         {
701.             szBuf[0] = i;
702.             szBuf[1] = 0;
703.         }
705.         // 2字节
706.         // 110xxxxx 10xxxxxx
707.         if (i >= 0x00000080 && i <= 0x000007FF)
708.         {
709.             szBuf[0] = ((i >> 6) & 0x1F) | 0xC0;
710.             szBuf[1] = ( i & 0x3F) | 0x80;
711.             szBuf[2] = 0;
712.         }
714.         // 3字节
715.         // 1110xxxx 10xxxxxx 10xxxxxx
716.         if (i >= 0x00000800 && i <= 0x0000FFFF)
717.         {
718.             szBuf[0] = ((i >> 12) & 0x0F) | 0xE0;
719.             szBuf[1] = ((i >> 6) & 0x3F) | 0x80;
720.             szBuf[2] = (i & 0x3F) | 0x80;
721.             szBuf[3] = 0;
722.         }
724.         mapCode.insert(std::make_pair(i, (char*)szBuf));
725.     }
727.     return mapCode;
728. }
730. bool IsUtf8String(const std::string& strContent)
731. {
732.     bool fResult = false;
733.     size_t nLength = strContent.size();
734.     const char* pStr = strContent.c_str();
735.     bool fAscii = true;
736.     int nBytes = 0;
738.     for (int i = 0; i < nLength; i++)
739.     {
740.         char ch = pStr[i];
742.         if (0 != (ch & 0x80))
743.         {
744.             fAscii = false;
745.         }
747.         if (ch >= 0x80)
748.         {
749.             // 1111110x 10xxxxxx 10xxxxxx 10xxxxxx 10xxxxxx 10xxxxxx
750.             if (ch >= 0xFC && ch <= 0xFD)
751.             {
752.                 nBytes = 6;
753.             }
754.             // 111110xx 10xxxxxx 10xxxxxx 10xxxxxx 10xxxxxx 10xxxxxx
755.             else if (ch >= 0xF8 && ch <= 0xFB)
756.             {
757.                 nBytes = 5;
758.             }
759.             // 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx 10xxxxxx 10xxxxxx
760.             else if (ch >= 0xF0 && ch <= 0xF7)
761.             {
762.                 nBytes = 4;
763.             }
764.             // 1110xxxx 10xxxxxx 10xxxxxx 10xxxxxx 10xxxxxx 10xxxxxx
765.             else if (ch >= 0xE0 && ch <= 0xEF)
766.             {
767.                 nBytes = 3;
768.             }
769.             // 110xxxxx 10xxxxxx 10xxxxxx 10xxxxxx 10xxxxxx 10xxxxxx
770.             else if (ch >= 0xC0 && ch <= 0xDF)
771.             {
772.                 nBytes = 2;
773.             }
774.             else
775.             {
776.                 return FALSE;
777.             }
779.             nBytes--;
780.         }
781.     }
783.     return fResult;
784. }
785. std::string CWinHttpClient::EncoderFromUtf8(const std::string& strContent)
786. {
787.     std::string strResult;
791.     return strResult;
792. }
794. std::string CWinHttpClient::DecoderFromUtf8(const std::string& strContent)
795. {
796.     std::string strResult;
797.     strResult.reserve(strContent.capacity());
799.     size_t nLength = strContent.size();
800.     const char* pStr = strContent.c_str();
802.     for (int i = 0; i < nLength; i++)
803.     {
804.         // 转义解码
805.         if (('\\' == pStr[i]))
806.         {
807.             // Unicode 字符
808.             if ((i + 5) < nLength && 'u' == pStr[i + 1])
809.             {
810.                 char szCode[8] = { 0 };
811.                 szCode[0] = pStr[i + 2];
812.                 szCode[1] = pStr[i + 3];
813.                 szCode[2] = pStr[i + 4];
814.                 szCode[3] = pStr[i + 5];
815.                 uint32_t uCode = _strtoui64(szCode, nullptr, 16);
817.                 // 1字节
818.                 // 0xxxxxxx
819.                 if (uCode >= 0x00000000 && uCode <= 0x0000007F)
820.                 {
821.                     szCode[0] = uCode;
822.                     szCode[1] = 0;
823.                 }
825.                 // 2字节
826.                 // 110xxxxx 10xxxxxx
827.                 if (uCode >= 0x00000080 && uCode <= 0x000007FF)
828.                 {
829.                     szCode[0] = ((uCode >> 6) & 0x1F) | 0xC0;
830.                     szCode[1] = ( uCode & 0x3F) | 0x80;
831.                     szCode[2] = 0;
832.                 }
834.                 // 3字节
835.                 // 1110xxxx 10xxxxxx 10xxxxxx
836.                 if (uCode >= 0x00000800 && uCode <= 0x0000FFFF)
837.                 {
838.                     szCode[0] = ((uCode >> 12) & 0x0F) | 0xE0;
839.                     szCode[1] = ((uCode >> 6) & 0x3F) | 0x80;
840.                     szCode[2] = (uCode & 0x3F) | 0x80;
841.                     szCode[3] = 0;
842.                 }
844.                 // 4字节
845.                 // 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
846.                 if (uCode >= 0x00010000 && uCode <= 0x001FFFFF)
847.                 {
848.                     szCode[0] = ((uCode >> 18) & 0x07) | 0xF0;
849.                     szCode[1] = ((uCode >> 12) & 0x3F) | 0x80;
850.                     szCode[2] = ((uCode >> 6) & 0x3F) | 0x80;
851.                     szCode[3] = (uCode & 0x3F) | 0x80;
852.                     szCode[4] = 0;
853.                 }
855.                 // 5字节
856.                 // 111110xx 10xxxxxx 10xxxxxx 10xxxxxx 10xxxxxx
857.                 if (uCode >= 0x00200000 && uCode <= 0x03FFFFFF)
858.                 {
859.                     szCode[0] = ((uCode >> 24) & 0x03) | 0xF8;
860.                     szCode[1] = ((uCode >> 18) & 0x3F) | 0x80;
861.                     szCode[2] = ((uCode >> 12) & 0x3F) | 0x80;
862.                     szCode[3] = ((uCode >> 6) & 0x3F) | 0x80;
863.                     szCode[4] = (uCode & 0x3F) | 0x80;
864.                     szCode[5] = 0;
865.                 }
867.                 // 6字节
868.                 // 1111110x 10xxxxxx 10xxxxxx 10xxxxxx 10xxxxxx 10xxxxxx
869.                 if (uCode >= 0x04000000 && uCode <= 0x7FFFFFFF)
870.                 {
871.                     szCode[0] = ((uCode >> 30) & 0x01) | 0xFC;
872.                     szCode[1] = ((uCode >> 24) & 0x3F) | 0x80;
873.                     szCode[2] = ((uCode >> 18) & 0x3F) | 0x80;
874.                     szCode[3] = ((uCode >> 12) & 0x3F) | 0x80;
875.                     szCode[4] = ((uCode >> 6) & 0x3F) | 0x80;
876.                     szCode[5] = (uCode & 0x3F) | 0x80;
877.                     szCode[6] = 0;
878.                 }
880.                 strResult += szCode;
882.                 i += 5;
883.             }
885.             // 转义字符
886.             switch (pStr[i + 1])
887.             {
888.             case '"':
889.             {
890.                 strResult.push_back('"');
891.                 i += 1;
892.             }
893.             break;
894.             case '/':
895.             {
896.                 strResult.push_back('"');
897.                 i += 1;
898.             }
899.             break;
900.             case 'b':
901.             {
902.                 strResult.push_back('\b');
903.                 i += 1;
904.             }
905.             break;
906.             case 'f':
907.             {
908.                 strResult.push_back('\f');
909.                 i += 1;
910.             }
911.             break;
912.             case 't':
913.             {
914.                 strResult.push_back('\t');
915.                 i += 1;
916.             }
917.             break;
918.             case 'r':
919.             {
920.                 strResult.push_back('\r');
921.                 i += 1;
922.             }
923.             break;
924.             case 'n':
925.             {
926.                 strResult.push_back('\n');
927.                 i += 1;
928.             }
929.             break;
930.             case '<':
931.             {
932.                 strResult.push_back('<');
933.                 i += 1;
934.             }
935.             break;
936.             case '>':
937.             {
938.                 strResult.push_back('>');
939.                 i += 1;
940.             }
941.             break;
942.             case '&':
943.             {
944.                 strResult.push_back('&');
945.                 i += 1;
946.             }
947.             break;
948.             }
949.         }
950.         else
951.         {
952.             strResult.push_back(pStr[i]);
953.         }
954.     }
956.     strResult.push_back('\0');
958.     return strResult;
959. }
961. static bool _CrackUrl(const _tstring& url, PWINHTTP_URL_INFO lpUrlInfo)
962. {
963.     // 将 URL 分解到其组件部件中
964.     // https://learn.microsoft.com/zh-cn/windows/win32/api/winhttp/nf-winhttp-winhttpcrackurl
965.     // 即使在异步模式下使用 WinHTTP (即在 WinHttpOpen) 中设置了WINHTTP_FLAG_ASYNC时，此函数也会同步运行。
966.     if (!::WinHttpCrackUrl(CWinHttpClient::TStrToWStr(url).c_str(), 0, 0, &lpUrlInfo->uc))
967.     {
968.         return false;
969.     }
971.     lpUrlInfo->strScheme.resize(wcslen(lpUrlInfo->strScheme.c_str()));
972.     lpUrlInfo->strExtraInfo.resize(wcslen(lpUrlInfo->strExtraInfo.c_str()));
973.     lpUrlInfo->strHostName.resize(wcslen(lpUrlInfo->strHostName.c_str()));
974.     lpUrlInfo->strUserName.resize(wcslen(lpUrlInfo->strUserName.c_str()));
975.     lpUrlInfo->strPassword.resize(wcslen(lpUrlInfo->strPassword.c_str()));
976.     lpUrlInfo->urlPath.resize(wcslen(lpUrlInfo->urlPath.c_str()));
978.     if (!lpUrlInfo->strExtraInfo.empty())
979.     {
980.         lpUrlInfo->urlPath += lpUrlInfo->strExtraInfo;
981.     }
983.     // 协议检查
984.     if (!(INTERNET_SCHEME_HTTPS == lpUrlInfo->uc.nScheme || INTERNET_SCHEME_HTTP == lpUrlInfo->uc.nScheme))
985.     {
986.         return false;
987.     }
989.     return true;
990. }
992. CWinHttpResult CWinHttpClient::Get(const _tstring& url, const CWinHttpValue& param/* = {}*/, const CWinHttpValue& header/* = {}*/, WinHttpCallback cb/* = nullptr*/)
993. {
994.     m_strFilePath.clear();
995.     m_cbProgress = cb;
997.     m_strUrl = url;
998.     m_strParam = param.AsGetString();
999.     m_strHeader = header.AsHeaderString();
1001.     return _Get(url, cb);
1002. }
1004. CWinHttpResult CWinHttpClient::Post(const _tstring& url, const CWinHttpValue& param/* = {}*/, const CWinHttpValue& header/* = {}*/, WinHttpCallback cb/* = nullptr*/)
1005. {
1006.     m_strFilePath.clear();
1007.     m_cbProgress = cb;
1009.     m_strUrl = url;
1010.     m_strParam = param.AsJsonString();
1011.     m_strHeader = header.AsHeaderString();
1013.     return _Post(url, cb);
1014. }
1016. CWinHttpResult CWinHttpClient::GetEx(const _tstring& url, const CWinHttpValue& param/* = {}*/, const CWinHttpValue& header/* = {}*/, WinHttpCallback cb/* = nullptr*/, DWORD dwThreadCount/* = 1*/)
1017. {
1018.     m_strFilePath.clear();
1019.     m_cbProgress = cb;
1021.     m_strUrl = url;
1022.     m_strParam = param.AsJsonString();
1023.     m_strHeader = header.AsHeaderString();
1025.     return _GetEx(url, cb, dwThreadCount);
1026. }
1028. CWinHttpResult CWinHttpClient::DownloadFile(const _tstring& url, const _tstring& strFile, const CWinHttpValue& header/* = {}*/, WinHttpCallback cb/* = nullptr*/, DWORD dwThreadCount/* = 4*/)
1029. {
1030.     m_strFilePath = strFile;
1032.     m_strUrl = url;
1033.     m_strParam.clear();
1034.     m_strHeader = header.AsHeaderString();
1036.     if (m_strFilePath.empty())
1037.     {
1038.         size_t nPos = url.find_last_of(_T("/"));
1039.         if (_tstring::npos != nPos)
1040.         {
1041.             m_strFilePath = url.substr(nPos + 1);
1042.         }
1043.     }
1045.     // 清空文件
1046.     HANDLE hFile = INVALID_HANDLE_VALUE;
1047.     hFile = ::CreateFile(strFile.c_str(),
1048.         GENERIC_READ | GENERIC_WRITE, FILE_SHARE_WRITE,
1049.         NULL,
1050.         TRUNCATE_EXISTING,
1051.         FILE_ATTRIBUTE_ARCHIVE,
1052.         NULL);
1054.     if (INVALID_HANDLE_VALUE != hFile)
1055.     {
1056.         ::CloseHandle(hFile);
1057.     }
1059.     CWinHttpResult httpResult = _GetEx(url, cb, dwThreadCount);
1061.     return httpResult;
1062. }
1064. CWinHttpResult CWinHttpClient::_Get(const _tstring& url, WinHttpCallback cb/* = nullptr*/)
1065. {
1066.     _tstring urlAddr = url;
1068.     if (!m_strParam.empty())
1069.     {
1070.         urlAddr += m_strParam;
1071.     }
1073.     return _DoRequest(urlAddr, _T("GET"), "");
1074. }
1076. CWinHttpResult CWinHttpClient::_Post(const _tstring& url, WinHttpCallback cb/* = nullptr*/)
1077. {
1078.     std::string strParam = TStrToU8Str(m_strParam);
1079.     return _DoRequest(url, _T("POST"), strParam);
1080. }
1082. CWinHttpResult CWinHttpClient::_DoRequest(const _tstring& url, const _tstring& strMethod, const std::string& strParam)
1083. {
1084.     WINHTTP_URL_INFO urlInfo;
1085.     CWinHttpResult httpResult;
1087.     if (!_CrackUrl(url, &urlInfo))
1088.     {
1089.         _PrintError(_T("_CrackUrl"));
1090.         return httpResult;
1091.     }
1093.     do
1094.     {
1095.         // 初始化 HTTP 会话
1096.         std::wstring wstrAgent = TStrToWStr(m_strAgent);
1097.         DWORD dwAccessType = WINHTTP_ACCESS_TYPE_AUTOMATIC_PROXY;
1098.         LPCWSTR pszProxy = WINHTTP_NO_PROXY_NAME;
1099.         LPCWSTR pszProxyBypass = WINHTTP_NO_PROXY_BYPASS;
1100.         DWORD dwSessionFlags = WINHTTP_FLAG_ASYNC;    //WINHTTP_FLAG_ASYNC / WINHTTP_FLAG_SECURE_DEFAULTS
1101.         if (!_WinHttpOpen(wstrAgent.c_str(), dwAccessType, pszProxy, pszProxyBypass, dwSessionFlags))
1102.         {
1103.             _PrintError(_T("_WinHttpOpen"));
1104.             break;
1105.         }
1107.         // 设置回调函数
1108.         if (!_WinHttpSetStatusCallback(WinHttpStatusCallback, WINHTTP_CALLBACK_FLAG_ALL_NOTIFICATIONS))
1109.         {
1110.             _PrintError(_T("WinHttpSetStatusCallback"));
1111.             break;
1112.         }
1114.         // 设置状态回调上下文
1115.         DWORD_PTR dwContext = (DWORD_PTR)this;
1116.         if (!_WinHttpSetSessionOption(WINHTTP_OPTION_CONTEXT_VALUE, &dwContext, sizeof(dwContext)))
1117.         {
1118.             _PrintError(_T("WinHttpSetOption"));
1119.             break;
1120.         }
1122.         // 连接 HTTP 会话
1123.         if (!_WinHttpConnect(urlInfo.strHostName.c_str(), urlInfo.uc.nPort))
1124.         {
1125.             _PrintError(_T("_WinHttpConnect"));
1126.             break;
1127.         }
1129.         // 创建 HTTP 请求句柄
1130.         LPCWSTR pwszReferrer = WINHTTP_NO_REFERER;
1131.         LPCWSTR* pwszAcceptTypes = WINHTTP_DEFAULT_ACCEPT_TYPES;
1132.         DWORD dwRequestFlags = (INTERNET_SCHEME_HTTPS == urlInfo.uc.nScheme) ? WINHTTP_FLAG_SECURE : 0;
1133.         if (!_WinHttpOpenRequest(strMethod, urlInfo.urlPath.c_str(), NULL, pwszReferrer, pwszAcceptTypes, dwRequestFlags))
1134.         {
1135.             _PrintError(_T("_WinHttpOpenRequest"));
1136.             break;
1137.         }
1139.         // 设置请求超时
1140.         if (!_WinHttpSetRequestTimeouts(500, 500, 1000, 1000))
1141.         {
1142.             _PrintError(_T("WinHttpSetTimeouts"));
1143.             break;
1144.         }
1146.         // 设置请求范围
1147.         if (!_SetRequestDataRange(m_ullStart, m_ullLength))
1148.         {
1149.             _PrintError(_T("_SetRequestDataRange"));
1150.             break;
1151.         }
1153.         // 发送请求
1154.         if (!_WinHttpSendRequest(m_strHeader, (LPVOID)strParam.data(), (DWORD)strParam.size(), (DWORD_PTR)this))
1155.         {
1156.             _PrintError(_T("_WinHttpSendRequest"));
1157.             break;
1158.         }
1160.         // 等待接收请求响应
1161.         if (!_WinHttpReceiveResponse(m_hRequest))
1162.         {
1163.             _PrintError(_T("_WinHttpReceiveResponse"));
1164.             break;
1165.         }
1167.         // 查询文件大小
1168.         ULONGLONG UllContentLength = 0;
1169.         if (!_QueryContentLength(&UllContentLength))
1170.         {
1171.             _PrintError(_T("_QueryContentLength"));
1172.             break;
1173.         }
1175.         // 获取响应码
1176.         httpResult.code = _GetStatusCode(m_hRequest);
1177.         if (httpResult.code < 200 || httpResult.code >= 300)
1178.         {
1179.             _PrintError(_T("_GetStatusCode"));
1180.             break;
1181.         }
1183.         // 接收请求数据
1184.         if (!_InternetReadData(httpResult.result))
1185.         {
1186.             _PrintError(_T("_InternetReadData"));
1187.             break;
1188.         }
1190.     } while (false);
1192.     // 关闭相关句柄
1193.     Close();
1195.     return httpResult;
1196. }
1198. CWinHttpResult CWinHttpClient::_GetEx(const _tstring& url, WinHttpCallback cb/* = nullptr*/, DWORD dwThreadCount/* = 6*/)
1199. {
1200.     WINHTTP_URL_INFO urlInfo;
1201.     CWinHttpResult httpResult;
1203.     if (!_CrackUrl(url, &urlInfo))
1204.     {
1205.         _PrintError(_T("_CrackUrl"));
1206.         return httpResult;
1207.     }
1209.     m_cbProgress = cb;
1211.     do
1212.     {
1213.         // 初始化 HTTP 会话
1214.         std::wstring wstrAgent = TStrToWStr(m_strAgent);
1215.         DWORD dwAccessType = WINHTTP_ACCESS_TYPE_AUTOMATIC_PROXY;
1216.         LPCWSTR pszProxy = WINHTTP_NO_PROXY_NAME;
1217.         LPCWSTR pszProxyBypass = WINHTTP_NO_PROXY_BYPASS;
1218.         DWORD dwSessionFlags = WINHTTP_FLAG_ASYNC;    //WINHTTP_FLAG_ASYNC / WINHTTP_FLAG_SECURE_DEFAULTS
1219.         if (!_WinHttpOpen(wstrAgent.c_str(), dwAccessType, pszProxy, pszProxyBypass, dwSessionFlags))
1220.         {
1221.             _PrintError(_T("_WinHttpOpen"));
1222.             break;
1223.         }
1225.         // 设置回调函数
1226.         if (!_WinHttpSetStatusCallback(WinHttpStatusCallback, WINHTTP_CALLBACK_FLAG_ALL_NOTIFICATIONS))
1227.         {
1228.             _PrintError(_T("WinHttpSetStatusCallback"));
1229.             break;
1230.         }
1232.         // 设置状态回调上下文
1233.         DWORD_PTR dwContext = (DWORD_PTR)this;
1234.         if (!_WinHttpSetSessionOption(WINHTTP_OPTION_CONTEXT_VALUE, &dwContext, sizeof(dwContext)))
1235.         {
1236.             _PrintError(_T("WinHttpSetOption"));
1237.             break;
1238.         }
1240.         // 连接 HTTP 会话
1241.         if (!_WinHttpConnect(urlInfo.strHostName.c_str(), urlInfo.uc.nPort))
1242.         {
1243.             _PrintError(_T("_WinHttpConnect"));
1244.             break;
1245.         }
1247.         // 创建 HTTP 请求句柄
1248.         LPCWSTR pwszReferrer = WINHTTP_NO_REFERER;
1249.         LPCWSTR* pwszAcceptTypes = WINHTTP_DEFAULT_ACCEPT_TYPES;
1250.         DWORD dwRequestFlags = (INTERNET_SCHEME_HTTPS == urlInfo.uc.nScheme) ? WINHTTP_FLAG_SECURE : 0;
1251.         if (!_WinHttpOpenRequest(_T("GET"), urlInfo.urlPath.c_str(), NULL, pwszReferrer, pwszAcceptTypes, dwRequestFlags))
1252.         {
1253.             _PrintError(_T("_WinHttpOpenRequest"));
1254.             break;
1255.         }
1257.         // 设置请求超时
1258.         if (!_WinHttpSetRequestTimeouts(1000, 1000, 3000, 5000))
1259.         {
1260.             _PrintError(_T("WinHttpSetTimeouts"));
1261.             break;
1262.         }
1264.         // 发送请求
1265.         if (!_WinHttpSendRequest(m_strHeader, NULL, 0, (DWORD_PTR)this))
1266.         {
1267.             _PrintError(_T("_WinHttpSendRequest"));
1268.             break;
1269.         }
1271.         // 等待接收请求响应
1272.         if (!_WinHttpReceiveResponse(m_hRequest))
1273.         {
1274.             _PrintError(_T("_WinHttpReceiveResponse"));
1275.             break;
1276.         }
1278.         // 获取响应码
1279.         httpResult.code = _GetStatusCode(m_hRequest);
1280.         if (httpResult.code < 200 || httpResult.code >= 300)
1281.         {
1282.             _PrintError(_T("_GetStatusCode"));
1283.             break;
1284.         }
1286.         // 查询文件大小
1287.         ULONGLONG ullContentLength = 0;
1288.         if (!_QueryContentLength(&ullContentLength))
1289.         {
1290.             _PrintError(_T("QueryContentLength"));
1291.             break;
1292.         }
1294.         // 是否支持接收范围请求
1295.         bool fAcceptRange =  _IsSupportAcceptRanges();
1297.         // 多线程接收请求数据
1298.         if (ullContentLength > 0 && fAcceptRange && dwThreadCount > 1)
1299.         {
1300.             httpResult = _MultiThreadRequest(url, ullContentLength, dwThreadCount);
1301.         }
1302.         else
1303.         {
1304.             // 单线程接收请求数据
1305.             if (!_InternetReadData(httpResult.result))
1306.             {
1307.                 _PrintError(_T("_InternetReadData"));
1308.                 break;
1309.             }
1310.         }
1312.     } while (false);
1314.     // 关闭相关句柄
1315.     Close();
1317.     return httpResult;
1318. }
1320. CWinHttpResult CWinHttpClient::_MultiThreadRequest(const _tstring& url, ULONGLONG ullContentLength, DWORD dwThreadCount/* = 1*/)
1321. {
1322.     CWinHttpResult httpResult;
1324.     std::atomic<int> nTaskCount = dwThreadCount;
1325.     bool fQuit = false;
1326.     DWORD ullSinglePackageSize = ullContentLength / dwThreadCount;
1328.     std::vector<CWinHttpClient> vTaskClients;
1329.     vTaskClients.resize(dwThreadCount);
1331.     std::vector<CWinHttpResult> vTaskResults;
1332.     vTaskResults.resize(dwThreadCount);
1334.     std::vector<std::thread> vTaskThreads;
1336.     for (DWORD i = 0; i < dwThreadCount; i++)
1337.     {
1338.         ULONGLONG ullBeginPos = ullSinglePackageSize * i;
1339.         ULONGLONG ullPackageSize = (i != dwThreadCount - 1) ? ullSinglePackageSize : ullContentLength - ullBeginPos;
1340.         vTaskClients[i].SetReQuestDataRange(ullBeginPos, ullPackageSize);
1342.         vTaskClients[i].m_strAgent = m_strAgent;
1343.         vTaskClients[i].m_strHeader = m_strHeader;
1344.         vTaskClients[i].m_strParam = m_strParam;
1345.         vTaskClients[i].m_strUrl = m_strUrl;
1346.         vTaskClients[i].m_strFilePath = m_strFilePath;
1347.         vTaskClients[i].m_fPrint = m_fPrint;
1349.         vTaskThreads.emplace_back(std::thread([&vTaskClients, &vTaskResults, i, url, &nTaskCount, &fQuit, this]() {
1351.             while (!fQuit)
1352.             {
1353.                 vTaskClients[i].m_AsyncData.AsyncResult.dwResult = 0;
1354.                 vTaskClients[i].m_AsyncData.AsyncResult.dwError = 0;
1356.                 // 修改请求起始位置
1357.                 vTaskClients[i].m_ullStart += vTaskClients[i].m_ullDownload;
1358.                 vTaskResults[i] = vTaskClients[i]._Get(url, [](const WINHTTP_PROGRESS_INFO& progress) {
1359.                     return true;
1360.                     }
1361.                 );
1363.                 if (vTaskResults[i].code >= 200 && vTaskResults[i].code < 300)
1364.                 {
1365.                     break;
1366.                 }
1367.             }
1369.             nTaskCount--;
1371.             }
1372.         )
1373.         );
1374.     }
1376.     // 进度统计用变量
1377.     clock_t refreshInterval = 1000;
1378.     clock_t curTime = ::clock();
1379.     clock_t startTime = curTime;
1380.     clock_t lastTime = curTime;
1381.     double lfRemainTime = 0.0f;
1382.     double lfSpeed = 0.0f;
1383.     ULONGLONG ullLastDownload = 0;
1384.     ULONGLONG ullTotalLength = ullContentLength;
1386.     while (!fQuit)
1387.     {
1388.         ULONGLONG ullDownloaded = 0;
1390.         // 进度计算
1391.         if (m_cbProgress)
1392.         {
1393.             // 速度计算
1394.             clock_t curTime = ::clock();
1395.             if (curTime - lastTime >= refreshInterval  || 0 == nTaskCount)
1396.             {
1397.                 for (auto& item : vTaskClients)
1398.                 {
1399.                     ullDownloaded += item.m_ullDownload;
1400.                 }
1402.                 lfSpeed = (double)(ullDownloaded - ullLastDownload) / ((double)refreshInterval / 1000.0f);
1403.                 if (isinf(lfSpeed) || isnan(lfSpeed))
1404.                 {
1405.                     lfSpeed = 0.0f;
1406.                 }
1408.                 // 进度报告
1409.                 {
1410.                     WINHTTP_PROGRESS_INFO progress = { 0 };
1411.                     progress.lfProgress = (double)ullDownloaded / (double)ullTotalLength;
1412.                     progress.ullCur = ullDownloaded;
1413.                     progress.ullTotal = ullTotalLength;
1414.                     progress.lfSpeed = lfSpeed;
1415.                     progress.costTime = curTime - startTime;
1416.                     progress.lfRemainTime = ((double)(ullTotalLength - ullDownloaded)) / lfSpeed;
1417.                     progress.nActiveThread = nTaskCount;
1418.                     progress.nTotalThread = dwThreadCount;
1420.                     if (!m_cbProgress(progress))
1421.                     {
1422.                         fQuit = true;
1423.                         break;
1424.                     }
1425.                 }
1427.                 lastTime = curTime;
1428.                 ullLastDownload = ullDownloaded;
1429.             }
1430.         }
1432.         if (0 == nTaskCount)
1433.         {
1434.             break;
1435.         }
1437.         ::Sleep(10);
1438.     }
1440.     // 主动退出
1441.     if (fQuit)
1442.     {
1443.         for (auto& item : vTaskClients)
1444.         {
1445.             item.Close();
1446.         }
1447.     }
1449.     // 等待线程结束
1450.     for (auto& item : vTaskThreads)
1451.     {
1452.         if (item.joinable())
1453.         {
1454.             item.join();
1455.         }
1456.     }
1458.     // 结果拼接
1459.     if(m_strFilePath.empty())
1460.     {
1461.         for (auto& item : vTaskResults)
1462.         {
1463.             httpResult.result += item.result;
1465.             if (item.code >= 200 && item.code < 300)
1466.             {
1467.                 httpResult.code = item.code;
1468.             }
1469.             else
1470.             {
1471.                 httpResult.code = 0;
1472.             }
1473.         }
1474.     }
1476.     return httpResult;
1477. }
1479. std::string CWinHttpClient::_WStrToMultiStr(UINT CodePage, const std::wstring& str)
1480. {
1481.     int cbMultiByte = ::WideCharToMultiByte(CodePage, 0, str.c_str(), -1, NULL, 0, NULL, 0);
1482.     std::string strResult(cbMultiByte, 0);
1483.     size_t nConverted = ::WideCharToMultiByte(CodePage, 0, str.c_str(), (int)str.size(), &strResult[0], (int)strResult.size(), NULL, NULL);
1484.     strResult.resize(nConverted);
1485.     return strResult;
1486. }
1488. std::wstring CWinHttpClient::_MultiStrToWStr(UINT CodePage, const std::string& str)
1489. {
1490.     int cchWideChar = ::MultiByteToWideChar(CodePage, 0, str.c_str(), -1, NULL, NULL);
1491.     std::wstring strResult(cchWideChar, 0);
1492.     size_t nConverted = ::MultiByteToWideChar(CodePage, 0, str.c_str(), (int)str.size(), &strResult[0], (int)strResult.size());
1493.     strResult.resize(nConverted);
1494.     return strResult;
1495. }
1497. std::string CWinHttpClient::TStrToU8Str(const _tstring& str)
1498. {
1499. #ifdef _UNICODE
1500.     return _WStrToMultiStr(CP_UTF8, str);
1501. #else
1502.     return _WStrToMultiStr(CP_UTF8, _MultiStrToWStr(CP_ACP, str));
1503. #endif
1504. }
1506. std::wstring CWinHttpClient::TStrToWStr(const _tstring& str)
1507. {
1508. #ifdef _UNICODE
1509.     return str;
1510. #else
1511.     return _MultiStrToWStr(CP_ACP, str);
1512. #endif
1513. }
1515. _tstring CWinHttpClient::WStrToTStr(const std::wstring& str)
1516. {
1517. #ifdef _UNICODE
1518.     return str;
1519. #else
1520.     return _WStrToMultiStr(CP_ACP, str);
1521. #endif
1522. }
1524. void CWinHttpClient::SetAgent(const _tstring strAgent)
1525. {
1526.     m_strAgent = strAgent;
1527. }
1529. void CWinHttpClient::SetReQuestDataRange(ULONGLONG ullStart, ULONGLONG ullLength)
1530. {
1531.     m_ullStart = ullStart;
1532.     m_ullLength = ullLength;
1533. }
1535. void CWinHttpClient::SetPrintStatus(bool fEnable/* = true*/)
1536. {
1537.     m_fPrint = fEnable;
1538. }
1540. bool CWinHttpClient::_QueryContentLength(PULONGLONG lpUllContentLength)
1541. {
1542.     DWORD dwInfoLevel = WINHTTP_QUERY_CONTENT_LENGTH | WINHTTP_QUERY_FLAG_NUMBER64;
1543.     ULONGLONG ullContentLength = 0;
1544.     DWORD dwBufferLength = sizeof(ullContentLength);
1545.     DWORD dwIndex = 0;
1546.     if (!_WinHttpQueryHeaders(dwInfoLevel, WINHTTP_HEADER_NAME_BY_INDEX, &ullContentLength, &dwBufferLength, &dwIndex))
1547.     {
1548.         // 无法找到请求的标头
1549.         if (ERROR_WINHTTP_HEADER_NOT_FOUND == ::GetLastError())
1550.         {
1551.             *lpUllContentLength = -1;
1552.             return true;
1553.         }
1555.         _PrintError(_T("WinHttpQueryHeaders"));
1556.         *lpUllContentLength = 0;
1557.         return false;
1558.     }
1560.     *lpUllContentLength = ullContentLength;
1562.     return true;
1563. }
1565. bool CWinHttpClient::_IsSupportAcceptRanges()
1566. {
1567.     WCHAR szBuf[MAX_PATH] = { 0 };
1568.     DWORD dwBufferLength = sizeof(szBuf);
1569.     DWORD dwIndex = 0;
1571.     if (!_WinHttpQueryHeaders(WINHTTP_QUERY_ACCEPT_RANGES, WINHTTP_HEADER_NAME_BY_INDEX, &szBuf, &dwBufferLength, &dwIndex))
1572.     {
1573.         return false;
1574.     }
1576.     if (0 == _wcsicmp(szBuf, L"bytes"))
1577.     {
1578.         return true;
1579.     }
1581.     return false;
1582. }
1584. bool CWinHttpClient::_SetRequestDataRange(LONGLONG nBegin, LONGLONG nLength)
1585. {
1586.     WCHAR szBuf[MAX_PATH] = { 0 };
1588.     if (0 == nLength)
1589.     {
1590.         (void)::StringCchPrintfW(szBuf, _countof(szBuf), L"Range:bytes=%lld-%lld", nBegin, nBegin);
1591.     }
1592.     else if (nLength > 0)
1593.     {
1594.         (void)::StringCchPrintfW(szBuf, _countof(szBuf), L"Range:bytes=%lld-%lld", nBegin, nBegin + nLength - 1);
1595.     }
1596.     else
1597.     {
1598.         (void)::StringCchPrintfW(szBuf, _countof(szBuf), L"Range:bytes=%lld-", nBegin);
1599.     }
1601.     return ::WinHttpAddRequestHeaders(m_hRequest, szBuf, (DWORD)wcslen(szBuf), 0);
1602. }
1604. DWORD CWinHttpClient::_GetStatusCode(HINTERNET hRequest)
1605. {
1606.     DWORD dwInfoLevel = WINHTTP_QUERY_STATUS_CODE | WINHTTP_QUERY_FLAG_NUMBER;
1607.     DWORD dwRespCode = 0;
1608.     DWORD dwBufferLength = sizeof(dwRespCode);
1609.     DWORD dwIndex = 0;
1610.     if (!_WinHttpQueryHeaders(dwInfoLevel, WINHTTP_HEADER_NAME_BY_INDEX, &dwRespCode, &dwBufferLength, &dwIndex))
1611.     {
1612.         return dwRespCode;
1613.     }
1615.     return dwRespCode;
1616. }
1618. bool CWinHttpClient::_InternetReadData(std::string& strData)
1619. {
1620.     HANDLE hFile = INVALID_HANDLE_VALUE;
1621.     bool fResult = false;
1623.     // 查询文件大小
1624.     ULONGLONG ullContentLength = 0;
1625.     if (!_QueryContentLength(&ullContentLength))
1626.     {
1627.         _PrintError(_T("QueryContentLength"));
1628.         return false;
1629.     }
1631.     // 分配数据缓冲
1632.     try
1633.     {
1634.         if (-1 != ullContentLength)
1635.         {
1636.             strData.resize(ullContentLength, 0);
1637.         }
1638.     }
1639.     catch (...)
1640.     {
1641.         _PrintError(_T("std::string resize"));
1642.         return false;
1643.     }
1645.     // 接收数据
1646.     LPBYTE lpBufPos = (LPBYTE)strData.data();
1647.     std::string strBuf;
1648.     ULONGLONG ullDownloaded = 0;
1649.     ULONGLONG ullTotalLength = ullContentLength;
1650.     ULONGLONG ullLastDownload = 0;
1652.     // 进度统计用变量
1653.     clock_t refreshInterval = 1000;
1654.     clock_t curTime = ::clock();
1655.     clock_t startTime = curTime;
1656.     clock_t lastTime = curTime;
1657.     double lfRemainTime = 0.0f;
1658.     double lfSpeed = 0.0f;
1660.     if (!m_strFilePath.empty())
1661.     {
1662.         LARGE_INTEGER liDistanceToMove = { 0 };
1664.         // 共享读写 创建/打开 文件, 多线程读写
1665.         hFile = ::CreateFile(m_strFilePath.c_str(),
1666.             GENERIC_READ | GENERIC_WRITE, FILE_SHARE_READ | FILE_SHARE_WRITE,
1667.             NULL,
1668.             OPEN_ALWAYS,
1669.             FILE_ATTRIBUTE_ARCHIVE,
1670.             NULL);
1672.         if (INVALID_HANDLE_VALUE == hFile)
1673.         {
1674.             _PrintError(_T("CreateFile"));
1675.             return false;
1676.         }
1678.         // 设置数据写入位置
1679.         liDistanceToMove.QuadPart = m_ullStart;
1680.         ::SetFilePointerEx(hFile, liDistanceToMove, NULL, FILE_BEGIN);
1681.     }
1683.     do
1684.     {
1685.         // 检查可用数据
1686.         DWORD dwNumberOfBytesAvailable = 0;
1687.         DWORD dwNumberOfBytesRead = 0;
1688.         if (!_WinHttpQueryDataAvailable(&dwNumberOfBytesAvailable))
1689.         {
1690.             _PrintError(_T("_WinHttpQueryDataAvailable"));
1691.             break;
1692.         }
1694.         if (dwNumberOfBytesAvailable > 0)
1695.         {
1696.             try
1697.             {
1698.                 strBuf.resize(dwNumberOfBytesAvailable);
1699.             }
1700.             catch (...)
1701.             {
1702.                 _PrintError(_T("std::vector resize"));
1703.                 break;
1704.             }
1706.             if (!_WinHttpReadData(&strBuf[0], dwNumberOfBytesAvailable, &dwNumberOfBytesRead))
1707.             {
1708.                 _PrintError(_T("_WinHttpReadData"));
1709.                 break;
1710.             }
1712.             // 写入到缓冲
1713.             if (-1 == ullContentLength)
1714.             {
1715.                 strData += strBuf;
1716.                 ullDownloaded += strBuf.size();
1717.             }
1718.             else
1719.             {
1720.                 memcpy(lpBufPos, &strBuf[0], dwNumberOfBytesRead);
1721.                 lpBufPos += dwNumberOfBytesRead;
1722.                 ullDownloaded += dwNumberOfBytesRead;
1723.             }
1725.             if (INVALID_HANDLE_VALUE != hFile)
1726.             {
1727.                 DWORD dwWritten = 0;
1728.                 if (!::WriteFile(hFile, strBuf.data(), dwNumberOfBytesRead, &dwWritten, NULL))
1729.                 {
1730.                     _PrintError(_T("WriteFile"));
1731.                     break;
1732.                 }
1733.             }
1735.             m_ullDownload += dwNumberOfBytesRead;
1736.         }
1738.         // 进度计算
1739.         if (m_cbProgress)
1740.         {
1741.             // 速度计算
1742.             clock_t curTime = ::clock();
1743.             if (curTime - lastTime >= refreshInterval  || 0 == dwNumberOfBytesAvailable)
1744.             {
1745.                 lfSpeed = (double)(ullDownloaded - ullLastDownload) / ((double)refreshInterval / 1000.0f);
1746.                 if (isinf(lfSpeed) || isnan(lfSpeed))
1747.                 {
1748.                     lfSpeed = 0.0f;
1749.                 }
1751.                 if (0 == dwNumberOfBytesAvailable)
1752.                 {
1753.                     ullTotalLength = ullDownloaded;
1754.                 }
1756.                 // 进度报告
1757.                 {
1758.                     WINHTTP_PROGRESS_INFO progress = { 0 };
1759.                     progress.lfProgress = (double)ullDownloaded / (double)ullTotalLength;
1760.                     progress.ullCur = ullDownloaded;
1761.                     progress.ullTotal = ullTotalLength;
1762.                     progress.lfSpeed = lfSpeed;
1763.                     progress.costTime = curTime - startTime;
1764.                     progress.lfRemainTime = ((double)(ullTotalLength - ullDownloaded)) / lfSpeed;
1765.                     progress.nActiveThread = 1;
1766.                     progress.nTotalThread = 1;
1768.                     if (!m_cbProgress(progress))
1769.                     {
1770.                         break;
1771.                     }
1772.                 }
1774.                 lastTime = curTime;
1775.                 ullLastDownload = ullDownloaded;
1776.             }
1777.         }
1779.         // 检查读取是否结束
1780.         if (!dwNumberOfBytesAvailable)
1781.         {
1782.             fResult = true;
1783.             break;
1784.         }
1786.     } while (true);
1788.     if (INVALID_HANDLE_VALUE != hFile)
1789.     {
1790.         ::CloseHandle(hFile);
1791.     }
1793.     return fResult;
1794. }
1796. void CWinHttpClient::_PrintError(LPCTSTR lpszError) const
1797. {
1798.     return;
1799.     ConsoleOutput(_T("[Error][LastError: %d Error: %d Result: %d][%s]\r\n"),
1800.         ::GetLastError(),
1801.         m_AsyncData.AsyncResult.dwError,
1802.         m_AsyncData.AsyncResult.dwResult,
1803.         lpszError
1804.     );
1805. }
1807. void CWinHttpClient::ConsoleOutput(LPCTSTR pFormat, ...)
1808. {
1809.     size_t nCchCount = MAX_PATH;
1810.     _tstring strResult(nCchCount, 0);
1811.     va_list args;
1813.     va_start(args, pFormat);
1815.     do
1816.     {
1817.         //格式化输出字符串
1818.         int nSize = _vsntprintf_s(&strResult[0], nCchCount, _TRUNCATE, pFormat, args);
1819.         if (-1 != nSize)
1820.         {
1821.             HANDLE console = GetStdHandle(STD_OUTPUT_HANDLE);
1822.             ::WriteConsole(console, strResult.c_str(), nSize, NULL, NULL);
1823.             break;
1824.         }
1826.         //缓冲大小超限终止
1827.         if (nCchCount >= INT32_MAX)
1828.         {
1829.             break;
1830.         }
1832.         //重新分配缓冲
1833.         nCchCount *= 2;
1834.         strResult.resize(nCchCount);
1836.     } while (true);
1838.     va_end(args);
1839. }
1841. #define WINHTTP_STATUS_TEXT(_code)  std::make_pair(_code, _T(#_code)),
1843. void CWinHttpClient::_PrintStatus(DWORD dwCode, LPVOID lpvStatusInfo, DWORD dwStatusInfoLength)
1844. {
1845.     std::map<DWORD, _tstring> mapWinHttpCode = {
1846.         WINHTTP_STATUS_TEXT(WINHTTP_CALLBACK_STATUS_RESOLVING_NAME             )
1847.         WINHTTP_STATUS_TEXT(WINHTTP_CALLBACK_STATUS_NAME_RESOLVED              )
1848.         WINHTTP_STATUS_TEXT(WINHTTP_CALLBACK_STATUS_CONNECTING_TO_SERVER       )
1849.         WINHTTP_STATUS_TEXT(WINHTTP_CALLBACK_STATUS_CONNECTED_TO_SERVER        )
1850.         WINHTTP_STATUS_TEXT(WINHTTP_CALLBACK_STATUS_SENDING_REQUEST            )
1851.         WINHTTP_STATUS_TEXT(WINHTTP_CALLBACK_STATUS_REQUEST_SENT               )
1852.         WINHTTP_STATUS_TEXT(WINHTTP_CALLBACK_STATUS_RECEIVING_RESPONSE         )
1853.         WINHTTP_STATUS_TEXT(WINHTTP_CALLBACK_STATUS_RESPONSE_RECEIVED          )
1854.         WINHTTP_STATUS_TEXT(WINHTTP_CALLBACK_STATUS_CLOSING_CONNECTION         )
1855.         WINHTTP_STATUS_TEXT(WINHTTP_CALLBACK_STATUS_CONNECTION_CLOSED          )
1856.         WINHTTP_STATUS_TEXT(WINHTTP_CALLBACK_STATUS_HANDLE_CREATED             )
1857.         WINHTTP_STATUS_TEXT(WINHTTP_CALLBACK_STATUS_HANDLE_CLOSING             )
1858.         WINHTTP_STATUS_TEXT(WINHTTP_CALLBACK_STATUS_DETECTING_PROXY            )
1859.         WINHTTP_STATUS_TEXT(WINHTTP_CALLBACK_STATUS_REDIRECT                   )
1860.         WINHTTP_STATUS_TEXT(WINHTTP_CALLBACK_STATUS_INTERMEDIATE_RESPONSE      )
1861.         WINHTTP_STATUS_TEXT(WINHTTP_CALLBACK_STATUS_SECURE_FAILURE             )
1862.         WINHTTP_STATUS_TEXT(WINHTTP_CALLBACK_STATUS_HEADERS_AVAILABLE          )
1863.         WINHTTP_STATUS_TEXT(WINHTTP_CALLBACK_STATUS_DATA_AVAILABLE             )
1864.         WINHTTP_STATUS_TEXT(WINHTTP_CALLBACK_STATUS_READ_COMPLETE              )
1865.         WINHTTP_STATUS_TEXT(WINHTTP_CALLBACK_STATUS_WRITE_COMPLETE             )
1866.         WINHTTP_STATUS_TEXT(WINHTTP_CALLBACK_STATUS_REQUEST_ERROR              )
1867.         WINHTTP_STATUS_TEXT(WINHTTP_CALLBACK_STATUS_SENDREQUEST_COMPLETE       )
1868.         WINHTTP_STATUS_TEXT(WINHTTP_CALLBACK_STATUS_GETPROXYFORURL_COMPLETE    )
1869.         WINHTTP_STATUS_TEXT(WINHTTP_CALLBACK_STATUS_CLOSE_COMPLETE             )
1870.         WINHTTP_STATUS_TEXT(WINHTTP_CALLBACK_STATUS_SHUTDOWN_COMPLETE          )
1871.         WINHTTP_STATUS_TEXT(WINHTTP_CALLBACK_STATUS_GETPROXYSETTINGS_COMPLETE  )
1872.         WINHTTP_STATUS_TEXT(WINHTTP_CALLBACK_STATUS_SETTINGS_WRITE_COMPLETE    )
1873.         WINHTTP_STATUS_TEXT(WINHTTP_CALLBACK_STATUS_SETTINGS_READ_COMPLETE     )
1874.     };
1876.     auto itFind = mapWinHttpCode.find(dwCode);
1878.     if (mapWinHttpCode.end() != itFind)
1879.     {
1880.         ConsoleOutput(_T("%08X %-50s "), itFind->first, itFind->second.c_str());
1881.     }
1883.     if (dwCode == WINHTTP_CALLBACK_STATUS_CONNECTED_TO_SERVER ||
1884.         dwCode == WINHTTP_CALLBACK_STATUS_CONNECTING_TO_SERVER ||
1885.         dwCode == WINHTTP_CALLBACK_STATUS_NAME_RESOLVED ||
1886.         dwCode == WINHTTP_CALLBACK_STATUS_REDIRECT
1887.         )
1888.     {
1889.         if (NULL != lpvStatusInfo)
1890.         {
1891.             LPWSTR lpData = (LPWSTR)lpvStatusInfo;
1892.             ConsoleOutput(_T("Data %s"), WStrToTStr(lpData).c_str());
1893.         }
1894.     }
1896.     if (dwCode == WINHTTP_CALLBACK_STATUS_DATA_AVAILABLE ||
1897.         dwCode == WINHTTP_CALLBACK_STATUS_INTERMEDIATE_RESPONSE ||
1898.         dwCode == WINHTTP_CALLBACK_STATUS_REQUEST_SENT ||
1899.         dwCode == WINHTTP_CALLBACK_STATUS_RESPONSE_RECEIVED ||
1900.         dwCode == WINHTTP_CALLBACK_STATUS_WRITE_COMPLETE ||
1901.         dwCode == WINHTTP_CALLBACK_STATUS_SECURE_FAILURE
1902.         )
1903.     {
1904.         if (NULL != lpvStatusInfo)
1905.         {
1906.             LPDWORD lpData = (LPDWORD)lpvStatusInfo;
1907.             ConsoleOutput(_T("Data %d(%08X)"), *lpData, *lpData);
1908.         }
1909.     }
1911.     if (dwCode == WINHTTP_CALLBACK_STATUS_REQUEST_ERROR
1912.         )
1913.     {
1914.         if (NULL != lpvStatusInfo)
1915.         {
1916.             LPWINHTTP_ASYNC_RESULT lpData = (LPWINHTTP_ASYNC_RESULT)lpvStatusInfo;
1917.             ConsoleOutput(_T("Error %d(%08X) Result: %d(%08X)"),
1918.                 lpData->dwError, lpData->dwError,
1919.                 lpData->dwResult, lpData->dwResult
1920.             );
1921.         }
1922.     }
1924.     ConsoleOutput(_T("\r\n"));
1925. }
1927. VOID CALLBACK CWinHttpClient::WinHttpStatusCallback(HINTERNET hInternet, DWORD_PTR dwContext, DWORD dwStatus, LPVOID lpvInfo, DWORD dwInfoLength)
1928. {
1929.     CWinHttpClient* pThis = (CWinHttpClient*)dwContext;
1930.     if (nullptr != pThis)
1931.     {
1932.         pThis->_WinHttpStatusCallback(hInternet, dwStatus, lpvInfo, dwInfoLength);
1933.     }
1934. }
1936. // 状态回调
1937. void CWinHttpClient::_WinHttpStatusCallback(HINTERNET hInternet, DWORD dwStatus, LPVOID lpvInfo, DWORD dwInfoLength)
1938. {
1939.     if (m_fPrint)
1940.     {
1941.         _PrintStatus(dwStatus, lpvInfo, dwInfoLength);
1942.     }
1944.     switch (dwStatus)
1945.     {
1947.         // 关闭与服务器的连接。 lpvStatusInformation 参数为 NULL。
1948.     case WINHTTP_CALLBACK_STATUS_CLOSING_CONNECTION:
1949.     {
1950.         break;
1951.     }
1953.     // 已成功连接到服务器。 lpvStatusInformation 参数包含指向 LPWSTR 的指针，该指针以点表示法指示服务器的 IP 地址。
1954.     case WINHTTP_CALLBACK_STATUS_CONNECTED_TO_SERVER:
1955.     {
1956.         LPWSTR lpData = (LPWSTR)lpvInfo;
1957.         break;
1958.     }
1960.     // 连接到服务器。 lpvStatusInformation 参数包含指向 LPWSTR 的指针，该指针以点表示法指示服务器的 IP 地址。
1961.     case WINHTTP_CALLBACK_STATUS_CONNECTING_TO_SERVER:
1962.     {
1963.         LPWSTR lpData = (LPWSTR)lpvInfo;
1964.         break;
1965.     }
1967.     // 已成功关闭与服务器的连接。 lpvStatusInformation 参数为 NULL。
1968.     case WINHTTP_CALLBACK_STATUS_CONNECTION_CLOSED:
1969.     {
1970.         break;
1971.     }
1973.     // 可以使用 WinHttpReadData 检索数据。 lpvStatusInformation 参数指向包含可用数据字节数的 DWORD。
1974.     // dwStatusInformationLength 参数本身是 4 (DWORD) 的大小。
1975.     case WINHTTP_CALLBACK_STATUS_DATA_AVAILABLE:// WinHttpQueryDataAvailable 完成
1976.     {
1977.         DWORD lpSize = *(LPDWORD)lpvInfo;
1978.         m_AsyncData.dwSize = lpSize;
1979.         m_AsyncData.AsyncResult.dwResult = 0;
1980.         ::SetEvent(m_AsyncData.hEvent);
1981.         break;
1982.     }
1984.     // 已创建 HINTERNET 句柄。 lpvStatusInformation 参数包含指向 HINTERNET 句柄的指针。
1985.     case WINHTTP_CALLBACK_STATUS_HANDLE_CREATED:
1986.     {
1987.         LPHINTERNET pHandle = (LPHINTERNET)lpvInfo;
1988.         m_AsyncData.dwContext = (DWORD_PTR)*pHandle;
1989.         ::SetEvent(m_AsyncData.hEvent);
1990.         break;
1991.     }
1993.     // 此句柄值已终止。 lpvStatusInformation 参数包含指向 HINTERNET 句柄的指针。 此句柄不再有回调。
1994.     case WINHTTP_CALLBACK_STATUS_HANDLE_CLOSING:
1995.     {
1996.         LPHINTERNET pHandle = (LPHINTERNET)lpvInfo;
1997.         break;
1998.     }
2000.     // 响应标头已收到，可用于 WinHttpQueryHeaders。 lpvStatusInformation 参数为 NULL。
2001.     case WINHTTP_CALLBACK_STATUS_HEADERS_AVAILABLE: // WinHttpReceiveResponse 完成
2002.     {
2003.         m_AsyncData.AsyncResult.dwResult = 0;
2004.         ::SetEvent(m_AsyncData.hEvent);
2005.         break;
2006.     }
2008.     // 从服务器收到中间 (100 级别) 状态代码消息。 lpvStatusInformation 参数包含指向指示状态代码的 DWORD 的指针。
2009.     case WINHTTP_CALLBACK_STATUS_INTERMEDIATE_RESPONSE:
2010.     {
2011.         LPDWORD pStatusCode = (LPDWORD)lpvInfo;
2012.         break;
2013.     }
2015.     // 已成功找到服务器的 IP 地址。 lpvStatusInformation 参数包含指向 LPWSTR 的指针，该指针指示已解析的名称。
2016.     case WINHTTP_CALLBACK_STATUS_NAME_RESOLVED:
2017.     {
2018.         LPWSTR lpResolved = (LPWSTR)lpvInfo;
2019.         break;
2020.     }
2022.     // 已成功从服务器读取数据。
2023.     // lpvStatusInformation 参数包含指向调用 WinHttpReadData 中指定的缓冲区的指针。
2024.     // dwStatusInformationLength 参数包含读取的字节数。
2025.     // WinHttpWebSocketReceive 使用时，lpvStatusInformation 参数包含指向WINHTTP_WEB_SOCKET_STATUS结构的指针，
2026.     // dwStatusInformationLength 参数指示 lpvStatusInformation 的大小。
2027.     case WINHTTP_CALLBACK_STATUS_READ_COMPLETE: // WinHttpReadData 完成
2028.     {
2029.         LPBYTE* ppBuf = (LPBYTE*)lpvInfo;
2030.         DWORD dwRead = dwInfoLength;
2031.         m_AsyncData.AsyncResult.dwResult = 0;
2032.         m_AsyncData.dwSize = dwRead;
2033.         ::SetEvent(m_AsyncData.hEvent);
2034.         break;
2035.     }
2037.     // 等待服务器响应请求。 lpvStatusInformation 参数为 NULL。
2038.     case WINHTTP_CALLBACK_STATUS_RECEIVING_RESPONSE:
2039.     {
2040.         break;
2041.     }
2043.     // HTTP 请求将自动重定向请求。 lpvStatusInformation 参数包含指向指示新 URL 的 LPWSTR 的指针。
2044.     // 此时，应用程序可以使用重定向响应读取服务器返回的任何数据，并且可以查询响应标头。 它还可以通过关闭句柄来取消操作。
2045.     case WINHTTP_CALLBACK_STATUS_REDIRECT:
2046.     {
2047.         LPWSTR lpData = (LPWSTR)lpvInfo;
2048.         break;
2049.     }
2051.     // 发送 HTTP 请求时出错。 lpvStatusInformation 参数包含指向WINHTTP_ASYNC_RESULT结构的指针。
2052.     // 其 dwResult 成员指示被调用函数的 ID，dwError 指示返回值。
2053.     case WINHTTP_CALLBACK_STATUS_REQUEST_ERROR:
2054.     {
2055.         DWORD dwError = ERROR_WINHTTP_INCORRECT_HANDLE_STATE;
2056.         LPWINHTTP_ASYNC_RESULT pAsyncResult = (LPWINHTTP_ASYNC_RESULT)lpvInfo;
2057.         m_AsyncData.AsyncResult = *pAsyncResult;
2058.         ::SetEvent(m_AsyncData.hEvent);
2059.         break;
2060.     }
2062.     // 已成功将信息请求发送到服务器。 lpvStatusInformation 参数包含指向 DWORD 的指针，该指针指示发送的字节数。
2063.     case WINHTTP_CALLBACK_STATUS_REQUEST_SENT:
2064.     {
2065.         LPDWORD pSentBytes = (LPDWORD)lpvInfo;
2066.         break;
2067.     }
2069.     // 查找服务器名称的 IP 地址。 lpvStatusInformation 参数包含指向要解析的服务器名称的指针。
2070.     case WINHTTP_CALLBACK_STATUS_RESOLVING_NAME:
2071.     {
2072.         LPWSTR lpName = (LPWSTR)lpvInfo;
2073.         break;
2074.     }
2076.     // 已成功从服务器收到响应。 lpvStatusInformation 参数包含指向指示接收字节数的 DWORD 的指针。
2077.     case WINHTTP_CALLBACK_STATUS_RESPONSE_RECEIVED:
2078.     {
2079.         LPDWORD pRecv = (LPDWORD)lpvInfo;
2080.         break;
2081.     }
2083.     // 在与服务器建立安全 (HTTPS) 连接时遇到一个或多个错误。
2084.     // lpvStatusInformation 参数包含指向 DWORD 的指针，该指针是错误值的按位 OR 组合。
2085.     // 有关详细信息，请参阅 lpvStatusInformation 的说明。
2086.     case WINHTTP_CALLBACK_STATUS_SECURE_FAILURE:
2087.     {
2088.         DWORD dwCode = *(LPDWORD)lpvInfo;
2089.         switch (dwCode)
2090.         {
2091.             // 证书吊销检查已启用，但吊销检查未能验证证书是否已吊销。 用于检查吊销的服务器可能无法访问
2092.         case WINHTTP_CALLBACK_STATUS_FLAG_CERT_REV_FAILED:
2093.         {
2094.             break;
2095.         }
2096.         // SSL 证书无效
2097.         case WINHTTP_CALLBACK_STATUS_FLAG_INVALID_CERT:
2098.         {
2099.             break;
2100.         }
2101.         // SSL 证书已吊销
2102.         case WINHTTP_CALLBACK_STATUS_FLAG_CERT_REVOKED:
2103.         {
2104.             break;
2105.         }
2106.         // 函数不熟悉生成服务器证书的证书颁发机构
2107.         case WINHTTP_CALLBACK_STATUS_FLAG_INVALID_CA:
2108.         {
2109.             break;
2110.         }
2111.         // SSL 证书公用名 (主机名字段) 不正确，例如，如果输入 www.microsoft.com 且证书上的公用名显示 www.msn.com
2112.         case WINHTTP_CALLBACK_STATUS_FLAG_CERT_CN_INVALID:
2113.         {
2114.             break;
2115.         }
2116.         // 从服务器收到的 SSL 证书日期不正确。 证书已过期。
2117.         case WINHTTP_CALLBACK_STATUS_FLAG_CERT_DATE_INVALID:
2118.         {
2119.             break;
2120.         }
2121.         // 应用程序在加载 SSL 库时遇到内部错误
2122.         case WINHTTP_CALLBACK_STATUS_FLAG_SECURITY_CHANNEL_ERROR:
2123.         {
2124.             break;
2125.         }
2126.         }
2128.         break;
2129.     }
2131.     // 将信息请求发送到服务器。 lpvStatusInformation 参数为 NULL。
2132.     case WINHTTP_CALLBACK_STATUS_SENDING_REQUEST:
2133.     {
2134.         break;
2135.     }
2137.     // 请求已成功完成。
2138.     // lpvStatusInformation 参数是传递给 WinHttpSendRequest (初始请求正文) 的 lpOptional 值，
2139.     // dwStatusInformationLength 参数指示 (传递到 WinHttpSendRequest) 传递到 winHttpSendRequest 的 dwOptionalLength 值成功写入此类初始正文字节的数目。
2140.     case WINHTTP_CALLBACK_STATUS_SENDREQUEST_COMPLETE:  // WinHttpSendRequest 完成
2141.     {
2142.         m_AsyncData.AsyncResult.dwResult = 0;
2143.         ::SetEvent(m_AsyncData.hEvent);
2144.         break;
2145.     }
2147.     // 数据已成功写入服务器。 lpvStatusInformation 参数包含指向 DWORD 的指针，该指针指示写入的字节数。
2148.     // 当 WinHttpWebSocketSend 使用时， lpvStatusInformation 参数包含指向WINHTTP_WEB_SOCKET_STATUS结构的指针，
2149.     // dwStatusInformationLength 参数指示 lpvStatusInformation 的大小。
2150.     case WINHTTP_CALLBACK_STATUS_WRITE_COMPLETE:    // WinHttpWriteData 完成
2151.     {
2152.         m_AsyncData.AsyncResult.dwResult = 0;
2153.         ::SetEvent(m_AsyncData.hEvent);
2154.         break;
2155.     }
2157.     // 通过调用 WinHttpGetProxyForUrlEx 启动的操作已完成。 可以使用 WinHttpReadData 检索数据。
2158.     case WINHTTP_CALLBACK_STATUS_GETPROXYFORURL_COMPLETE:
2159.     {
2160.         break;
2161.     }
2162.     // 通过调用 WinHttpWebSocketClose 成功关闭了连接。 lpvStatusInformation 参数为 NULL。
2163.     case WINHTTP_CALLBACK_STATUS_CLOSE_COMPLETE:
2164.     {
2165.         break;
2166.     }
2167.     // 通过调用 WinHttpWebSocketShutdown 成功关闭连接。 lpvStatusInformation 参数为 NULL。
2168.     case WINHTTP_CALLBACK_STATUS_SHUTDOWN_COMPLETE:
2169.     {
2170.         break;
2171.     }
2172.     }
2173. }
2175. bool CWinHttpClient::_WinHttpOpen(LPCWSTR pszAgentW, DWORD dwAccessType, LPCWSTR pszProxyW, LPCWSTR pszProxyBypassW, DWORD dwFlags)
2176. {
2177.     // 初始化 WinHTTP 函数的使用并返回 WinHTTP 会话句柄。
2178.     // https://learn.microsoft.com/zh-cn/windows/win32/api/winhttp/nf-winhttp-winhttpopen
2179.     m_hSession = ::WinHttpOpen(
2180.         pszAgentW,                      // 指向字符串变量的指针，此名称用作 HTTP 协议中的 用户代理
2181.         dwAccessType,                   // 所需的访问类型
2182.         pszProxyW,                      // 代理访问时要使用的代理服务器的名称
2183.         pszProxyBypassW,                // 代理访问时要使用的代理服务器的密码
2184.         dwFlags                         // 指示影响此函数行为的各种选项的标志
2185.     );
2187.     return NULL != m_hSession;
2188. }
2190. bool CWinHttpClient::_WinHttpConnect(LPCWSTR pswzServerName, INTERNET_PORT nServerPort)
2191. {
2192.     // 指定 HTTP 请求的初始目标服务器，并将 HINTERNET 连接句柄返回到该初始目标的 HTTP 会话
2193.     // https://learn.microsoft.com/zh-cn/windows/win32/api/winhttp/nf-winhttp-winhttpconnect
2194.     // 即使 WinHTTP 在异步模式下使用（即在 WinHttpOpen中设置 WINHTTP_FLAG_ASYNC），此函数也会同步运行
2195.     m_hConnect = ::WinHttpConnect(
2196.         m_hSession,                   // 由先前调用 WinHttpOpen 返回的有效 HINTERNETWinHTTP 会话句柄
2197.         pswzServerName,             // HTTP 服务器的主机名
2198.         nServerPort,                // 建立连接的服务器上的 TCP/IP 端口
2199.         0                           // 保留参数, 必须为0
2200.     );
2202.     return NULL != m_hConnect;
2203. }
2205. bool CWinHttpClient::_WinHttpOpenRequest(const _tstring& strVerb, LPCWSTR pwszObjectName, LPCWSTR pwszVersion, LPCWSTR pwszReferrer, LPCWSTR *ppwszAcceptTypes, DWORD dwFlags)
2206. {
2207.     // 创建 HTTP 请求句柄
2208.     // https://learn.microsoft.com/zh-cn/windows/win32/api/winhttp/nf-winhttp-winhttpopenrequest
2209.     HINTERNET hRequest = ::WinHttpOpenRequest(
2210.         m_hConnect,                         // WinHttpConnect 返回的 HTTP 会话的 HINTERNET 连接句柄
2211.         TStrToWStr(strVerb).c_str(),        // 请求的 HTTP 谓词
2212.         pwszObjectName,                     // 指定 HTTP 谓词的目标资源名称
2213.         pwszVersion,                        // HTTP 版本的字符串的指针
2214.         pwszReferrer,                       // 指定从中获取 请求 pwszObjectName 中的 URL 的文档的 URL
2215.         ppwszAcceptTypes,                   // 指定客户端接受的媒体类型
2216.         dwFlags                             // Internet 标志值
2217.     );
2219.     // 等待异步请求完成
2220.     if (!_WaitForAsyncEvent())
2221.     {
2222.         return NULL;
2223.     }
2225.     m_hRequest = (HINTERNET)m_AsyncData.dwContext;
2227.     return NULL != m_hRequest;
2228. }
2230. bool CWinHttpClient::_WinHttpSetSessionTimeouts(int nResolveTimeout, int nConnectTimeout,int nSendTimeout,int nReceiveTimeout)
2231. {
2232.     // 设置与 HTTP 事务相关的超时。
2233.     // https://learn.microsoft.com/zh-cn/windows/win32/api/winhttp/nf-winhttp-winhttpsettimeouts
2234.     // 即使在异步模式下使用 WinHTTP (即在 WinHttpOpen) 中设置了WINHTTP_FLAG_ASYNC时，此函数也会同步运行。
2235.     return ::WinHttpSetTimeouts(
2236.         m_hSession,             // WinHttpOpen 或 WinHttpOpenRequest 返回的 HINTERNET 句柄。
2237.         nResolveTimeout,        // 名称解析的超时值（以毫秒为单位）
2238.         nConnectTimeout,        // 服务器连接请求的超时值（以毫秒为单位）
2239.         nSendTimeout,           // 发送请求的超时值（以毫秒为单位）
2240.         nReceiveTimeout         // 接收对请求的响应超超时值（以毫秒为单位）
2241.     );
2242. }
2244. bool CWinHttpClient::_WinHttpSetRequestTimeouts(int nResolveTimeout, int nConnectTimeout,int nSendTimeout,int nReceiveTimeout)
2245. {
2246.     // 设置与 HTTP 事务相关的超时。
2247.     // https://learn.microsoft.com/zh-cn/windows/win32/api/winhttp/nf-winhttp-winhttpsettimeouts
2248.     // 即使在异步模式下使用 WinHTTP (即在 WinHttpOpen) 中设置了WINHTTP_FLAG_ASYNC时，此函数也会同步运行。
2249.     return ::WinHttpSetTimeouts(
2250.         m_hRequest,             // WinHttpOpen 或 WinHttpOpenRequest 返回的 HINTERNET 句柄。
2251.         nResolveTimeout,        // 名称解析的超时值（以毫秒为单位）
2252.         nConnectTimeout,        // 服务器连接请求的超时值（以毫秒为单位）
2253.         nSendTimeout,           // 发送请求的超时值（以毫秒为单位）
2254.         nReceiveTimeout         // 接收对请求的响应超超时值（以毫秒为单位）
2255.     );
2256. }
2258. bool CWinHttpClient::_WinHttpSetStatusCallback(WINHTTP_STATUS_CALLBACK lpfnInternetCallback, DWORD dwNotificationFlags
2259. )
2260. {
2261.     // 设置回调函数
2262.     // https://learn.microsoft.com/zh-cn/windows/win32/api/winhttp/nf-winhttp-winhttpsetstatuscallback
2263.     WINHTTP_STATUS_CALLBACK statusCallback = ::WinHttpSetStatusCallback(
2264.         m_hSession,                 // 要为其设置回调的 HINTERNET 句柄
2265.         lpfnInternetCallback,       // 指向进度时要调用的回调函数的指针
2266.         dwNotificationFlags,        // 无符号长整数值，该值指定标志以指示哪些事件激活回调函数
2267.         0
2268.     );
2270.     if (WINHTTP_INVALID_STATUS_CALLBACK == statusCallback)
2271.     {
2272.         return false;
2273.     }
2275.     return true;
2276. }
2278. bool CWinHttpClient::_WaitForAsyncEvent(DWORD dwMilliseconds/* = INFINITE*/)
2279. {
2280.     // 等待异步事件响应
2281.     m_AsyncData.dwWait = ::WaitForSingleObject(m_AsyncData.hEvent, dwMilliseconds);
2282.     if (m_fAbort)
2283.     {
2284.         return false;
2285.     }
2287.     if (WAIT_OBJECT_0 == m_AsyncData.dwWait && 0 == m_AsyncData.AsyncResult.dwResult)
2288.     {
2289.         return true;
2290.     }
2292.     return false;
2293. }
2295. bool CWinHttpClient::_WinHttpSetSessionOption(DWORD dwOption, LPVOID lpBuffer, DWORD dwBufferLength)
2296. {
2297.     // 设置 Internet 选项。
2298.     // https://learn.microsoft.com/zh-cn/windows/win32/api/winhttp/nf-winhttp-winhttpsetoption
2299.     return ::WinHttpSetOption(m_hSession, dwOption, lpBuffer, dwBufferLength);
2300. }
2302. bool CWinHttpClient::_WinHttpSetRequestOption(DWORD dwOption, LPVOID lpBuffer, DWORD dwBufferLength)
2303. {
2304.     // 设置 Internet 选项。
2305.     // https://learn.microsoft.com/zh-cn/windows/win32/api/winhttp/nf-winhttp-winhttpsetoption
2306.     return ::WinHttpSetOption(m_hRequest, dwOption, lpBuffer, dwBufferLength);
2307. }
2309. bool CWinHttpClient::_WinHttpSendRequest(_tstring strHeader, LPVOID lpData, DWORD dwSize, DWORD_PTR dwContext)
2310. {
2311.     std::wstring wstrHeader = TStrToWStr(strHeader);
2312.     LPCWSTR lpHeader = (LPCWSTR)wstrHeader.data();
2313.     DWORD dwHeaderSize = (DWORD)wstrHeader.size();
2315.     if (wstrHeader.empty())
2316.     {
2317.         lpHeader = WINHTTP_NO_ADDITIONAL_HEADERS;
2318.         dwHeaderSize = 0;
2319.     }
2321.     bool fResult = false;
2323.     do
2324.     {
2325.         // 发送请求
2326.         // 将指定的请求发送到 HTTP 服务器。
2327.         // https://learn.microsoft.com/zh-cn/windows/win32/api/winhttp/nf-winhttp-winhttpsendrequest
2328.         if (::WinHttpSendRequest(
2329.             m_hRequest,             //WinHttpOpenRequest 返回的 HINTERNET 句柄
2330.             lpHeader,               //要追加到请求的其他标头
2331.             dwHeaderSize,           //附加标头的长度（以字符为单位）
2332.             lpData,                 //请求标头之后发送的任何可选数据
2333.             dwSize,                 //可选数据的长度（以字节为单位）
2334.             dwSize,                 //发送的总数据的长度
2335.             dwContext               //上下文
2336.         ))
2337.         {
2338.             fResult = true;
2339.             break;
2340.         }
2342.         // 安全 HTTP 服务器需要客户端证书
2343.         if (ERROR_WINHTTP_CLIENT_AUTH_CERT_NEEDED != ::GetLastError())
2344.         {
2345.             break;
2346.         }
2348.         // 设置 Internet 选项
2349.         // https://learn.microsoft.com/zh-cn/windows/win32/api/winhttp/nf-winhttp-winhttpsetoption
2350.         if (!_WinHttpSetRequestOption(
2351.             WINHTTP_OPTION_CLIENT_CERT_CONTEXT,
2352.             WINHTTP_NO_CLIENT_CERT_CONTEXT,
2353.             0
2354.         ))
2355.         {
2356.             break;
2357.         }
2359.         // 再次发送请求
2360.         // 将指定的请求发送到 HTTP 服务器。
2361.         // https://learn.microsoft.com/zh-cn/windows/win32/api/winhttp/nf-winhttp-winhttpsendrequest
2362.         if (!::WinHttpSendRequest(
2363.             m_hRequest,             // WinHttpOpenRequest 返回的 HINTERNET 句柄
2364.             lpHeader,               // 要追加到请求的其他标头
2365.             dwHeaderSize,           // 附加标头的长度（以字符为单位）
2366.             lpData,                 // 请求标头之后发送的任何可选数据
2367.             dwSize,                 // 可选数据的长度（以字节为单位）
2368.             dwSize,                 // 发送的总数据的长度
2369.             NULL
2370.         ))
2371.         {
2372.             break;
2373.         }
2375.         fResult = true;
2377.     } while (false);
2379.     if (!fResult)
2380.     {
2381.         return false;
2382.     }
2384.     // 等待异步请求完成
2385.     return _WaitForAsyncEvent();
2386. }
2388. bool CWinHttpClient::_WinHttpReceiveResponse(HINTERNET hRequest)
2389. {
2390.     // 等待接收 WinHttpSendRequest 发起的 HTTP 请求的响应。
2391.     // https://learn.microsoft.com/zh-cn/windows/win32/api/winhttp/nf-winhttp-winhttpreceiveresponse
2392.     if (!::WinHttpReceiveResponse(
2393.         hRequest,       // WINHttpOpenRequest 返回并由 WinHttpSendRequest 发送的 HINTERNET 句柄。
2394.         NULL            // 此参数是保留的，必须为 NULL。
2395.     ))
2396.     {
2397.         return false;
2398.     }
2400.     // 等待异步请求完成
2401.     return _WaitForAsyncEvent();
2402. }
2404. bool CWinHttpClient::_WinHttpQueryHeaders(DWORD dwInfoLevel, LPCWSTR pwszName, LPVOID lpBuffer, LPDWORD lpdwBufferLength, LPDWORD lpdwIndex)
2405. {
2406.     return ::WinHttpQueryHeaders(
2407.         m_hRequest,                     //WinHttpOpenRequest 返回的 HINTERNET 请求句柄
2408.         dwInfoLevel,                    //指定“查询信息标志”页上列出的属性标志和修饰符标志的组合
2409.         pwszName,                       //标头名称
2410.         lpBuffer,                       //接收信息的缓冲区
2411.         lpdwBufferLength,               //数据缓冲区的长度
2412.         lpdwIndex                       //从零开始的标头索引的指针，用于枚举具有相同名称的多个标头
2413.     );
2414. }
2416. bool CWinHttpClient::_WinHttpQueryDataAvailable(LPDWORD lpdwNumberOfBytesAvailable)
2417. {
2418.     m_AsyncData.dwSize = 0;
2420.     // 返回可使用 WinHttpReadData 读取的数据量（以字节为单位）。
2421.     // https://learn.microsoft.com/zh-cn/windows/win32/api/winhttp/nf-winhttp-winhttpquerydataavailable
2422.     if (!::WinHttpQueryDataAvailable(
2423.         m_hRequest,                     // WinHttpOpenRequest 返回的有效 HINTERNET 句柄。
2424.                                         // WinHttpReceiveResponse 必须已为此句柄调用，并在调用 WinHttpQueryDataAvailable 之前完成。
2425.         NULL                            // 指向接收可用字节数的无符号长整数变量的指针。
2426.                                         // 在异步模式下使用 WinHTTP 时，始终将此参数设置为 NULL ，并在回调函数中检索数据;
2427.                                         // 不这样做可能会导致内存故障。
2428.     ))
2429.     {
2430.         return false;
2431.     }
2433.     // 等待异步请求完成
2434.     if (!_WaitForAsyncEvent())
2435.     {
2436.         return false;
2437.     }
2439.     *lpdwNumberOfBytesAvailable = m_AsyncData.dwSize;
2440.     return true;
2441. }
2443. bool CWinHttpClient::_WinHttpReadData(LPVOID lpBuffer, DWORD dwNumberOfBytesToRead, LPDWORD lpdwNumberOfBytesRead)
2444. {
2445.     m_AsyncData.dwSize = 0;
2447.     // 从 WinHttpOpenRequest 函数打开的句柄读取数据。
2448.     // https://learn.microsoft.com/zh-cn/windows/win32/api/winhttp/nf-winhttp-winhttpreaddata
2449.     if (!::WinHttpReadData(
2450.         m_hRequest,             // 从上一次调用 WinHttpOpenRequest 返回的有效 HINTERNET 句柄。
2451.         lpBuffer,               // 指向接收读取数据的缓冲区的指针。 确保此缓冲区在 WinHttpReadData 完成之前保持有效。
2452.         dwNumberOfBytesToRead,  // 要读取的字节数的无符号长整数值。
2453.         NULL                    // 指向接收读取字节数的无符号长整数变量的指针。
2454.                                 // WinHttpReadData 在执行任何工作或错误检查之前将此值设置为零。
2455.                                 // 异步使用 WinHTTP 时，始终将此参数设置为 NULL ，并在回调函数中检索信息;
2456.                                 // 不这样做可能会导致内存故障。
2457.     ))
2458.     {
2459.         return false;
2460.     }
2462.     // 等待异步请求完成
2463.     if (!_WaitForAsyncEvent())
2464.     {
2465.         return false;
2466.     }
2468.     *lpdwNumberOfBytesRead = m_AsyncData.dwSize;
2469.     return true;
2470. }

复制代码

main.cpp

2. #include <iostream>
3. #include "CWinHttpClient.h"
5. #define UPDATE_URL1          _T("https://gitee.com/flame_cyclone/fc_font_tool/raw/master/Release/update.json")
6. #define UPDATE_URL2          _T("https://gitee.com/flame_cyclone/fc_font_tool/releases/download/1.0.0.4/FC_Font_Tool.exe")
7. #define TEST_NVIDIA_DRIVER   _T("https://cn.download.nvidia.com/Windows/561.09/561.09-desktop-win10-win11-64bit-international-dch-whql.exe")
8. #define TEST_AMD_DRIVER      _T("https://drivers.amd.com/drivers/whql-amd-software-adrenalin-edition-24.8.1-win10-win11-aug-rdna.exe")
9. #define TEST_BILIBILI_DM     _T("https://api.live.bilibili.com/xlive/web-room/v1/dM/gethistory?roomid=4412054")
10. #define TEST_WEPE_URL        _T("https://mirrors.lzu.edu.cn/wepe/WePE_64_V2.3.exe")
12. int main()
13. {
14.     CWinHttpClient obj;
16.     CWinHttpValue header = CWinHttpObject{
17.         {_T("User-Agent"), _T("Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/130.0.0.0 Safari/537.36 Edg/130.0.0.0")},
18.         {_T("Content-Type"), _T("application/json;charset=UTF-8")},
19.         {_T("Accept"), _T("*/*")},
20.         {_T("Referer"), _T("https://www.amd.com/")},
21.     };
23.     CWinHttpValue param = CWinHttpObject{
24.         {_T("Accept"), _T("application/x-clarity-gzip")},
25.         {_T("Accept-Encoding"), CWinHttpArray {_T("gzip"), _T("deflate"), _T("br"), _T("zstd")}},
26.         {_T("Accept-Language"), CWinHttpArray {_T("zh-CN"), _T("zh;q=0.9"), _T("en;q=0.8"), _T("en-GB;q=0.7"), _T("en-US;q=0.6")}},
27.     };
29.     _tstring strGet = param.AsGetString();
30.     _tstring strJsonParam = param.AsJsonString();
31.     _tstring strHeader = param.AsHeaderString();
33.     CWinHttpResult get = obj.Get(_T(R"(https://api.live.bilibili.com/xlive/web-room/v1/dM/gethistory?roomid=4412054)"), {}, header, nullptr);
35.     get.result = obj.DecoderFromUtf8(get.result);
37.     std::string strResult = CWinHttpClient::DecoderFromUtf8(R"({"string":"\uD83C\uDF0D\u6211\u662F\u5730\u7403"})");
39.     bool fResult;
40.     clock_t startTime = ::clock();
42.     CWinHttpResult downResult = obj.DownloadFile(TEST_AMD_DRIVER, _T(""), header.AsHeaderString(), [](const WINHTTP_PROGRESS_INFO& progress) {
43.         CWinHttpClient::ConsoleOutput(_T("%d/%d Time: %.3lfs Progress: %.3lf%% %.1lfMB/%.1lfMB Speed: %.1lf Mbps %.1lfMB/s RemainTime: %.1lfs\n"),
44.         progress.nActiveThread, progress.nTotalThread,
45.         (double)progress.costTime / 1000.0f,
46.         progress.lfProgress * 100,
47.         (double)progress.ullCur / (1024.0f * 1024.0f), (double)progress.ullTotal / (1024.0f * 1024.0f),
48.         progress.lfSpeed / (1024.0f * 1024.0f) * 8.0f,
49.         progress.lfSpeed / (1024.0f * 1024.0f),
50.         progress.lfRemainTime
51.         );
53.     return true;
54.         }, 2
55.     );
57.     clock_t endTime = ::clock();
59.     CWinHttpClient::ConsoleOutput(_T("Cost Time: %dms\r\n"), endTime - startTime);
61.     return 0;
62. }

复制代码

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！qidao123.com:ToB企服之家，中国第一个企服评测及软件市场,开放入驻,技术点评得现金