C 语言http GET请求超小纯净下载工具（暂时只支持http）第一季_c语言下载文件用什么最小最方便-优快云博客

本文链接：https://blog.youkuaiyun.com/trw777/article/details/104459563

该根据HTTP协议中的GET请求利用C语言写的一个测试行的小下载工具，BUG还是挺多请大家多指教，概念性的知识点来自网络摘抄,~~写作功底较差请见谅。~~

一、概念

协议是指计算机通信网络中两台计算机之间进行通信所必须共同遵守的规定或规则，超文本传输协议(HTTP)是一种通信协议，它允许将超文本标记语言(HTML)文档从Web服务器传送到客户端的浏览器。

HTTP/1.1协议中共定义了八种方法（有时也叫“动作”）来表明Request-URI指定的资源的不同操作方式：
OPTIONS - 返回服务器针对特定资源所支持的HTTP请求方法。也可以利用向Web服务器发送'*'的请求来测试服务器的功能性。
HEAD- 向服务器索要与GET请求相一致的响应，只不过响应体将不会被返回。这一方法可以在不必传输整个响应内容的情况下，就可以获取包含在响应消息头中的元信息。该方法常用于测试超链接的有效性，是否可以访问，以及最近是否更新。
GET - 向特定的资源发出请求。
POST - 向指定资源提交数据进行处理请求（例如提交表单或者上传文件）。数据被包含在请求体中。POST请求可能会导致新的资源的建立和/或已有资源的修改。
PUT - 向指定资源位置上传其最新内容。
DELETE - 请求服务器删除Request-URI所标识的资源。
TRACE- 回显服务器收到的请求，主要用于测试或诊断。
CONNECT - HTTP/1.1协议中预留给能够将连接改为管道方式的代理服务器。
PATCH - 用来将局部修改应用于某一资源，添加于规范RFC5789。
方法名称是区分大小写的。当某个请求所针对的资源不支持对应的请求方法的时候，服务器应当返回状态码405（Method Not Allowed）；当服务器不认识或者不支持对应的请求方法的时候，应当返回状态码501（Not Implemented）。
HTTP服务器至少应该实现GET和HEAD方法，其他方法都是可选的。此外，除了上述方法，特定的HTTP服务器还能够扩展自定义的方法。

1、请求信息有三个部分，分别是：请求行、消息报头、请求正文。

1.1、请求行：GET 目录文件名协议\r\n

案例：GET /20191229/4241_7fa7053c/%E6%9E%AA%E7%A5%9E%E8%AE%B0%E7%AC%AC28%E8%AF%9D.mp4 HTTP/1.1

1.2、消息报头:

案例：Connection: Keep-alive
host: okzy.xzokzyzy.com
Range: bytes=-1

除了HOST选项外其他都可以省略

1、If-Modified-Since：把浏览器端缓存页面的最后修改时间发送到服务器去，服务器会把这个时间与服务器上实际文件的最后修改时间进行对比。如果时间一致，那么返回304，客户端就直接使用本地缓存文件。如果时间不一致，就会返回200和新的文件内容。客户端接到之后，会丢弃旧文件，把新文件缓存起来，并显示在浏览器中。

例如：If-Modified-Since: Thu, 09 Feb 2012 09:07:57 GMT

If-None-Match：If-None-Match和ETag一起工作，工作原理是在HTTP Response中添加ETag信息。当用户再次请求该资源时，将在HTTP Request 中加入If-None-Match信息(ETag的值)。如果服务器验证资源的ETag没有改变（该资源没有更新），将返回一个304状态告诉客户端使用本地缓存文件。否则将返回200状态和新的资源和Etag. 使用这样的机制将提高网站的性能。例如: If-None-Match: "03f2b33c0bfcc1:0"。

2、Pragma：指定“no-cache”值表示服务器必须返回一个刷新后的文档，即使它是代理服务器而且已经有了页面的本地拷贝；在HTTP/1.1版本中，它和Cache-Control:no-cache作用一模一样。Pargma只有一个用法，例如： Pragma: no-cache

注意: 在HTTP/1.0版本中，只实现了Pragema:no-cache, 没有实现Cache-Control

3、Cache-Control：指定请求和响应遵循的缓存机制。缓存指令是单向的（响应中出现的缓存指令在请求中未必会出现），且是独立的（在请求消息或响应消息中设置Cache-Control并不会修改另一个消息处理过程中的缓存处理过程）。请求时的缓存指令包括no-cache、no-store、max-age、max-stale、min-fresh、only-if-cached，响应消息中的指令包括public、private、no-cache、no-store、no-transform、must-revalidate、proxy-revalidate、max-age、s-maxage。

Cache-Control:Public 可以被任何缓存所缓存

Cache-Control:Private 内容只缓存到私有缓存中

Cache-Control:no-cache 所有内容都不会被缓存

Cache-Control:no-store 用于防止重要的信息被无意的发布。在请求消息中发送将使得请求和响应消息都不使用缓存。

Cache-Control:max-age 指示客户机可以接收生存期不大于指定时间（以秒为单位）的响应。

Cache-Control:min-fresh 指示客户机可以接收响应时间小于当前时间加上指定时间的响应。

Cache-Control:max-stale 指示客户机可以接收超出超时期间的响应消息。如果指定max-stale消息的值，那么客户机可以接收超出超时期指定值之内的响应消息。

4、Accept：浏览器端可以接受的MIME类型。例如：Accept: text/html 代表浏览器可以接受服务器回发的类型为 text/html 也就是我们常说的html文档，如果服务器无法返回text/html类型的数据，服务器应该返回一个406错误(non acceptable)。通配符 * 代表任意类型，例如 Accept: */* 代表浏览器可以处理所有类型，(一般浏览器发给服务器都是发这个)。

5、Accept-Encoding：浏览器申明自己可接收的编码方法，通常指定压缩方法，是否支持压缩，支持什么压缩方法（gzip，deflate）;Servlet能够向支持gzip的浏览器返回经gzip编码的HTML页面。许多情形下这可以减少5到10倍的下载时间。例如： Accept-Encoding: gzip, deflate。如果请求消息中没有设置这个域，服务器假定客户端对各种内容编码都可以接受。

6、Accept-Language：浏览器申明自己接收的语言。语言跟字符集的区别：中文是语言，中文有多种字符集，比如big5，gb2312，gbk等等；例如：Accept-Language: en-us。如果请求消息中没有设置这个报头域，服务器假定客户端对各种语言都可以接受。

7、Accept-Charset：浏览器可接受的字符集。如果在请求消息中没有设置这个域，缺省表示任何字符集都可以接受。

8、User-Agent：告诉HTTP服务器，客户端使用的操作系统和浏览器的名称和版本。

例如：

User-Agent: Mozilla/4.0 (compatible; MSIE 8.0; Windows NT 5.1;

Trident/4.0; CIBA; .NET CLR 2.0.50727; .NET CLR 3.0.4506.2152; .NET CLR

3.5.30729; .NET4.0C; InfoPath.2; .NET4.0E)。

9、Content-Type：例如：Content-Type: application/x-www-form-urlencoded。

10、Referer：包含一个URL，用户从该URL代表的页面出发访问当前请求的页面。提供了Request的上下文信息的服务器，告诉服务器我是从哪个链接过来的，比如从我主页上链接到一个朋友那里，他的服务器就能够从HTTP Referer中统计出每天有多少用户点击我主页上的链接访问他的网站。

例如: Referer:http://translate.google.cn/?hl=zh-cn&tab=wT

11、Connection：

例如：Connection:keep-alive

当一个网页打开完成后，客户端和服务器之间用于传输HTTP数据的TCP连接不会关闭，如果客户端再次访问这个服务器上的网页，会继续使用这一条已经建立的连接。HTTP 1.1默认进行持久连接。利用持久连接的优点，当页面包含多个元素时（例如Applet，图片），显著地减少下载所需要的时间。要实现这一点，Servlet需要在应答中发送一个Content-Length头，最简单的实现方法是：先把内容写入ByteArrayOutputStream，然后在正式写出内容之前计算它的大小。

Connection: close 代表一个Request完成后，客户端和服务器之间用于传输HTTP数据的TCP连接会关闭，当客户端再次发送Request，需要重新建立TCP连接。

12、Host：（发送请求时，该头域是必需的）主要用于指定被请求资源的Internet主机和端口号，它通常从HTTP URL中提取出来的。HTTP/1.1请求必须包含主机头域，否则系统会以400状态码返回。

例如:

我们在浏览器中输入：http://www.guet.edu.cn/index.html，浏览器发送的请求消息中，就会包含Host请求头域：Host：http://www.guet.edu.cn，此处使用缺省端口号80，若指定了端口号，则变成：Host：指定端口号。

13、Cookie：最重要的请求头之一, 将cookie的值发送给HTTP服务器。

14、Content-Length：表示请求消息正文的长度。例如：Content-Length: 38。

15、Authorization：授权信息，通常出现在对服务器发送的WWW-Authenticate头的应答中。主要用于证明客户端有权查看某个资源。当浏览器访问一个页面时，如果收到服务器的响应代码为401（未授权），可以发送一个包含Authorization请求报头域的请求，要求服务器对其进行验证。

UA-Pixels，UA-Color，UA-OS，UA-CPU：由某些版本的IE浏览器所发送的非标准的请求头，表示屏幕大小、颜色深度、操作系统和CPU类型。

16、From：请求发送者的email地址，由一些特殊的Web客户程序使用，浏览器不会用到它。

17、Range：可以请求实体的一个或者多个子范围。例如，

表示头500个字节：bytes=0-499

表示第二个500字节：bytes=500-999

表示最后500个字节：bytes=-500

表示500字节以后的范围：bytes=500-

第一个和最后一个字节：bytes=0-0,-1

同时指定几个范围：bytes=500-600,601-999

但是服务器可以忽略此请求头，如果无条件GET包含Range请求头，响应会以状态码206（PartialContent）返回而不是以200（OK）。

2、响应信息也有三个部分，分别是：状态行、消息报头、响应正文。。

1.1、请求行：协议状态码状态\r\n

案例：HTTP/1.1 206 Partial Content

1.2、消息报头:

案例：Server: nginx
Date: Sun, 23 Feb 2020 06:45:43 GMT
Content-Type: application/octet-stream
Content-Length: 1
Last-Modified: Sun, 29 Dec 2019 02:08:09 GMT
Connection: keep-alive
ETag: "5e080a89-7c72870"
Content-Range: bytes 130492527-130492527/130492528

1、Allow：服务器支持哪些请求方法（如GET、POST等）。

2、Date：表示消息发送的时间，时间的描述格式由rfc822定义。例如，Date:Mon,31Dec200104:25:57GMT。Date描述的时间表示世界标准时，换算成本地时间，需要知道用户所在的时区。你可以用setDateHeader来设置这个头以避免转换时间格式的麻烦

3、Expires：指明应该在什么时候认为文档已经过期，从而不再缓存它，重新从服务器获取，会更新缓存。过期之前使用本地缓存。HTTP1.1的客户端和缓存会将非法的日期格式（包括0）看作已经过期。eg：为了让浏览器不要缓存页面，我们也可以将Expires实体报头域，设置为0。

例如: Expires: Tue, 08 Feb 2022 11:35:14 GMT

4、P3P：用于跨域设置Cookie, 这样可以解决iframe跨域访问cookie的问题

例如: P3P: CP=CURa ADMa DEVa PSAo PSDo OUR BUS UNI PUR INT DEM STA PRE COM NAV OTC NOI DSP COR

5、Set-Cookie：非常重要的header, 用于把cookie发送到客户端浏览器，每一个写入cookie都会生成一个Set-Cookie。

例如: Set-Cookie: sc=4c31523a; path=/; domain=.acookie.taobao.com

6、ETag：和If-None-Match 配合使用。

7、Last-Modified：用于指示资源的最后修改日期和时间。Last-Modified也可用setDateHeader方法来设置。

8、Content-Type：WEB服务器告诉浏览器自己响应的对象的类型和字符集。Servlet默认为text/plain，但通常需要显式地指定为text/html。由于经常要设置Content-Type，因此HttpServletResponse提供了一个专用的方法setContentType。可在web.xml文件中配置扩展名和MIME类型的对应关系。

例如:Content-Type: text/html;charset=utf-8

Content-Type:text/html;charset=GB2312

Content-Type: image/jpeg

媒体类型的格式为：大类/小类，比如text/html。

IANA(The Internet Assigned Numbers Authority，互联网数字分配机构)定义了8个大类的媒体类型，分别是:

application— (比如: application/vnd.ms-excel.)

audio (比如: audio/mpeg.)

image (比如: image/png.)

message (比如,:message/http.)

model(比如:model/vrml.)

multipart (比如:multipart/form-data.)

text(比如:text/html.)

video(比如:video/quicktime.)

9、Content-Range：用于指定整个实体中的一部分的插入位置，他也指示了整个实体的长度。在服务器向客户返回一个部分响应，它必须描述响应覆盖的范围和整个实体长度。一般格式：Content-Range:bytes-unitSPfirst-byte-pos-last-byte-pos/entity-length。

例如，传送头500个字节次字段的形式：Content-Range:bytes0-499/1234如果一个http消息包含此节（例如，对范围请求的响应或对一系列范围的重叠请求），Content-Range表示传送的范围。

10、Content-Length：指明实体正文的长度，以字节方式存储的十进制数字来表示。在数据下行的过程中，Content-Length的方式要预先在服务器中缓存所有数据，然后所有数据再一股脑儿地发给客户端。只有当浏览器使用持久HTTP连接时才需要这个数据。如果你想要利用持久连接的优势，可以把输出文档写入ByteArrayOutputStram，完成后查看其大小，然后把该值放入Content-Length头，最后通过byteArrayStream.writeTo(response.getOutputStream()发送内容。

例如: Content-Length: 19847

11、Content-Encoding：WEB服务器表明自己使用了什么压缩方法（gzip，deflate）压缩响应中的对象。只有在解码之后才可以得到Content-Type头指定的内容类型。利用gzip压缩文档能够显著地减少HTML文档的下载时间。Java的GZIPOutputStream可以很方便地进行gzip压缩，但只有Unix上的Netscape和Windows上的IE 4、IE 5才支持它。因此，Servlet应该通过查看Accept-Encoding头（即request.getHeader("Accept-Encoding")）检查浏览器是否支持gzip，为支持gzip的浏览器返回经gzip压缩的HTML页面，为其他浏览器返回普通页面。

例如：Content-Encoding：gzip

12、Content-Language：WEB服务器告诉浏览器自己响应的对象所用的自然语言。例如： Content-Language:da。没有设置该域则认为实体内容将提供给所有的语言阅读。

13、Server：指明HTTP服务器用来处理请求的软件信息。例如：Server: Microsoft-IIS/7.5、Server：Apache-Coyote/1.1。此域能包含多个产品标识和注释，产品标识一般按照重要性排序。

X-AspNet-Version：如果网站是用ASP.NET开发的，这个header用来表示ASP.NET的版本。

例如: X-AspNet-Version: 4.0.30319

X-Powered-By：表示网站是用什么技术开发的。

例如： X-Powered-By: ASP.NET

Connection：

例如：Connection: keep-alive 当一个网页打开完成后，客户端和服务器之间用于传输HTTP数据的TCP连接不会关闭，如果客户端再次访问这个服务器上的网页，会继续使用这一条已经建立的连接。

Connection: close 代表一个Request完成后，客户端和服务器之间用于传输HTTP数据的TCP连接会关闭，当客户端再次发送Request，需要重新建立TCP连接。

14、Location：用于重定向一个新的位置，包含新的URL地址。表示客户应当到哪里去提取文档。Location通常不是直接设置的，而是通过HttpServletResponse的sendRedirect方法，该方法同时设置状态代码为302。Location响应报头域常用在更换域名的时候。

Refresh：表示浏览器应该在多少时间之后刷新文档，以秒计。除了刷新当前文档之外，你还可以通过setHeader("Refresh", "5; URL=http://host/path")让浏览器读取指定的页面。注意这种功能通常是通过设置HTML页面HEAD区的实现，这是因为，自动刷新或重定向对于那些不能使用CGI或Servlet的HTML编写者十分重要。但是，对于Servlet来说，直接设置Refresh头更加方便。注意Refresh的意义是“N秒之后刷新本页面或访问指定页面”，而不是“每隔N秒刷新本页面或访问指定页面”。因此，连续刷新要求每次都发送一个Refresh头，而发送204状态代码则可以阻止浏览器继续刷新，不管是使用Refresh头还是。注意Refresh头不属于HTTP 1.1正式规范的一部分，而是一个扩展，但Netscape和IE都支持它。

WWW-Authenticate：该响应报头域必须被包含在401（未授权的）响应消息中，客户端收到401响应消息时候，并发送Authorization报头域请求服务器对其进行验证时，服务端响应报头就包含该报头域。

二、程序代码

主要功能判断文件是否支持断点下载，然后执行线程下载或是单线程下载。

代码组成部分分为：头文件--global.h ，源文件--字符转换(ANSI_to_UTF8.cpp), 下载功能(Download.cpp) 和main（main.cpp）

头文件

global.h

#pragma once
#include<stdio.h>
#include<iostream>
#include<WinSock2.h>
#include<process.h>					//多线程头文件
#include<synchapi.h>					//互斥锁头文件,可不添加从Winsock2.h可以连接到
using namespace std;
#pragma comment(lib, "ws2_32.lib")
#define THREAD 3
extern HANDLE hMutex;
extern int errq;


//保存URL信息
typedef struct httpurl {
	char Http[6] = "";
	char Host[64] = "";
	char Directories[128] = "";
	char Filename[64] = "";
}HTTPURL, * PHTTPURL;

//保存HTTP请求信息
typedef struct resphead {
	char Statusline[32] = "";
	long ContentLength = 0;
	long ContentBlock = 0;
	char ContentMD5[40] = "";
	bool Breakpoint = false;
}RESPHEAD, * PRESPHEAD;

//保存下载缓存文件休息
typedef struct threadtmp {
	int ThreadNum = 0;
	FILE* ThreadFtmp = nullptr;
	long ThreadBlock = 0;
	long ThreadStart = 0;
	long ThreadEnd = 0;
	bool Complete = false;
}THREADTMP, * PTHREADTMP;

//线程信息
typedef struct Param {
	PRESPHEAD prh = nullptr;
	PTHREADTMP ftmp;
	int n = 0;
}PARAM, * PPARAM;

//多字节转UTF函数
char* ANSIToUTF8(const char* str);

源文件

ANSI_to_UTF8.cpp

#include <stdio.h>
#include <windows.h>
//#include <wchar.h>
#define BUFF_SIZE 1024
//#pragma warning(disable : 4996)
//#pragma warning(disable : 6387)

/*多字符转换为宽字符 --- ANSI -to- Unicode*/
wchar_t* ANSIToUnicode(const char* str)
{
    int textlen;
    wchar_t* result;
    textlen = MultiByteToWideChar(CP_ACP, 0, str, -1, NULL, 0);
    result = (wchar_t*)malloc((textlen + 1) * sizeof(wchar_t));
    if (0 < (result = (wchar_t*)malloc((textlen + 1) * sizeof(wchar_t))))
    {
        memset(result, 0, (textlen + 1) * sizeof(wchar_t));
        MultiByteToWideChar(CP_ACP, 0, str, -1, (LPWSTR)result, textlen);
        return result;
    }
    return 0;
}

/*宽字符转换为多字符 --- Unicode -to- ANSI*/
char* UnicodeToANSI(const wchar_t* str)
{
    char* result;
    int textlen;
    textlen = WideCharToMultiByte(CP_ACP, 0, str, -1, NULL, 0, NULL, NULL);
    result = (char*)malloc((textlen + 1) * sizeof(char));
    if (0 < result)
    {
        memset(result, 0, sizeof(char) * (textlen + 1));
        WideCharToMultiByte(CP_ACP, 0, str, -1, result, textlen, NULL, NULL);
        return result;
    }
    return 0;
}

/*UTF8转换为宽字符 --- UTF8 -to- Unicode */
wchar_t* UTF8ToUnicode(const char* str)
{
    int textlen;
    wchar_t* result;
    textlen = MultiByteToWideChar(CP_UTF8, 0, str, -1, NULL, 0);
    result = (wchar_t*)malloc((textlen + 1) * sizeof(wchar_t));
    if (0 < result)
    {
        memset(result, 0, (textlen + 1) * sizeof(wchar_t));
        MultiByteToWideChar(CP_UTF8, 0, str, -1, (LPWSTR)result, textlen);
        return result;
    }
    return 0;
}

/*宽字符转换为UTF8 --- Unicode -to- UTF8 */
char* UnicodeToUTF8(const wchar_t* str)
{
    char* result;
    int textlen;
    textlen = WideCharToMultiByte(CP_UTF8, 0, str, -1, NULL, 0, NULL, NULL);
    result = (char*)malloc((textlen + 1) * sizeof(char));
    if (0 < result)
    {
        memset(result, 0, sizeof(char) * (textlen + 1));
        WideCharToMultiByte(CP_UTF8, 0, str, -1, result, textlen, NULL, NULL);
        return result;
    }
    return 0;
}

/*多字符转换为UTF8 --- Unicode -to- UTF8 */
char* ANSIToUTF8(const char* str)
{
    return UnicodeToUTF8(ANSIToUnicode(str));
}

/*UTF8转换为多字符 --- UTF8 -to- ANSI */
char* UTF8ToANSI(const char* str)
{
    return UnicodeToANSI(UTF8ToUnicode(str));
}

Download.cpp

#include"global.h"
#include<stdlib.h>
#include<WS2tcpip.h>
//#include <fcntl.h>
//#include <io.h>
#include <time.h>
#define SENDBUFSIZE 1412
#define RECVBUFSIZE 8192
SOCKADDR_IN addr = { 0 };
#pragma warning(disable : 4996)
char ReqHead[512] = "";

int InitHttpurl(PHTTPURL phu) {
	char Url[256] = "";
	cout << "\n\n请输入下载地址：";
	scanf_s("%s", Url, 256);
	char sbuf[256] = "";
	sscanf_s(Url, "%[^:]", phu->Http, sizeof(phu->Http));
	cout << "Http = " << phu->Http << endl;
	memset(sbuf, 0, 256);
	sprintf_s(sbuf, "%s://%%[^/]", phu->Http);
	/*cout << "buf1 = " << sbuf << endl;*/
	sscanf_s(Url, (const char*)sbuf, phu->Host, sizeof(phu->Host));
	cout << "Host = " << phu->Host << endl;
	memset(sbuf, 0, 256);
	sprintf_s(sbuf, "%s://%s%%s", phu->Http, phu->Host);
	/*cout << "buf2 = " << sbuf << endl;*/
	sscanf_s(Url, sbuf, phu->Directories, sizeof(phu->Directories));
	cout << "Directories = " << phu->Directories << endl;
	const char* sret = strrchr(Url, '/');
	strcpy_s(phu->Filename, sret + 1);
	cout << "Filename = " << phu->Filename << endl;
	memset(sbuf, 0, 256);
	for (size_t i = 0; i < strlen(phu->Directories); i++)
	{
		if (phu->Directories[i] < 0) {
			char hbuf[5] = "";
			memset(hbuf, 0, 5);
			memcpy_s(hbuf, 2, &phu->Directories[i], 2);
			memcpy_s(hbuf, 4, ANSIToUTF8(hbuf), 4);
			for (size_t i = 0; i < strlen(hbuf); i++)
			{
				sprintf_s(sbuf, "%s%%%hhX", sbuf, hbuf[i]);
			}
			++i;
		}
		else
		{
			int p = strlen(sbuf);
			sbuf[p] = phu->Directories[i];
			sbuf[p + 1] = 0;
		}
	}

	//sprintf_s(ReqHead, "GET %s HTTP/1.1\r\nConnection: close\r\n", sbuf);
	sprintf_s(ReqHead, "GET %s HTTP/1.1\r\nConnection: Keep-alive\r\n", sbuf);
	sprintf_s(ReqHead, "%shost: %s\r\n", ReqHead, phu->Host);
	return 0;
}

int InitSocket(PHTTPURL phu) {
	WSADATA WsaData;
	if (0 != WSAStartup(MAKEWORD(2, 2), &WsaData)) {
		cout << "!!初始化socket库文件失败:[" << WSAGetLastError() << "]!!" << endl;
		Sleep(3000);
		return -101;
	}
	else {
		cout << "** 初始化socket库文件成功 **" << endl;
	}

	//域名转换IP
	PHOSTENT HostIp;
	char* pchr = nullptr;
	char chost[64] = "";
	if (nullptr == (pchr = strchr(phu->Host, ':')))
	{
		strcpy_s(chost, phu->Host);
		if (!strcmp(phu->Http, "http"))
		{
			addr.sin_port = htons(80);
		}
		else if (!strcmp(phu->Http, "https"))
		{
			addr.sin_port = htons(443);
		}
	}
	else
	{
		int port = 0;
		sscanf_s(phu->Host, "%[^:]", chost, sizeof(chost));
		sscanf_s(pchr + 1, "%d", &port);
		addr.sin_port = htons(port);
	}
	HostIp = gethostbyname(chost);
	if (HostIp == NULL)
	{
		cout << "!!域名转换IP失败:[" << WSAGetLastError() << "]!!" << endl;
		Sleep(3000);
		return -102;
	}
	else {
		cout << "** 域名转换IP成功 **" << endl;
	}
	addr.sin_addr = *((LPIN_ADDR)*HostIp->h_addr_list);
	/*addr.sin_addr.S_un.S_addr = inet_addr("106.14.230.53");*/
	addr.sin_family = AF_INET;
	inet_ntop(addr.sin_family, &addr.sin_addr.S_un.S_addr, chost, 17);
	cout << "IP:PORT = " << chost << ":" << ntohs(addr.sin_port) << endl;
	return 0;
}

int CraeteSocket(SOCKET* sockid,int n) {
	*sockid = 0;
	if (-1 == (*sockid = socket(AF_INET, SOCK_STREAM, 0)))
	{
		cout << "!! 线程[" << n << "]创建socket失败:[" << WSAGetLastError() << "] !!" << endl;
		Sleep(3000);
		return 103;
	}
	else {
		cout << "** 线程[" << n << "]创建socket成功 -- server_sockid:[" << *sockid << "] **" << endl;
	}

	if (SOCKET_ERROR == connect(*sockid, (SOCKADDR*)&addr, sizeof(addr)))
	{
		cout << "!! 线程[" << n << "]链接服务器失败:[" << WSAGetLastError() << "] !!" << endl;
		closesocket(*sockid);
		return -104;
	}
	else {
		cout << "** 线程[" << n << "]链接服务器成功 **" << endl;
	}
	return 0;
}

int InitRespHead(PRESPHEAD prh) {
	SOCKET sockid = NULL;
	FILE* ftmp = nullptr;
	int ret = 0, err = 0;
	char* SendBuf = new char[SENDBUFSIZE];
	memset(SendBuf, 0, SENDBUFSIZE);

	//发送断点下载请求
	if (0 != (err = CraeteSocket(&sockid,0))) return err;
	memset(SendBuf, 0, SENDBUFSIZE);
	sprintf_s(SendBuf, SENDBUFSIZE, "%sRange: bytes=-1\r\n\r\n", ReqHead);
	cout << "----------------SendData2-----------------------\n" << SendBuf << "----------------end---------------------- " << endl;
	ret = send(sockid, SendBuf, strlen(SendBuf), 0);
	if (ret == strlen(SendBuf)) {
		cout << "ReqHead 数据发送成功" << endl;
	}
	else {
		cout << "ReqHead 数据发送失败" << endl;
		return -202;
		exit(1);
	}
	memset(SendBuf, 0, SENDBUFSIZE);
	delete[] SendBuf;
	SendBuf = nullptr;

	//接收断点请求应答，获取是否支持断点下载
	char* RecvBuf = new char[SENDBUFSIZE];
	memset(RecvBuf, 0, SENDBUFSIZE);
	ret = recv(sockid, RecvBuf, SENDBUFSIZE, 0);
	cout << "----------------RecvData2-----------------------\n" << RecvBuf << endl << "----------------end---------------------- " << endl;
	tmpfile_s(&ftmp);
	fwrite(RecvBuf, 1, ret, ftmp);
	rewind(ftmp);
	fscanf_s(ftmp, "%[^\r]", prh->Statusline, sizeof(prh->Statusline));
	if (!strncmp(prh->Statusline, "HTTP/1.1 206", 12)) {
		cout << "服务器持断点下载:" << prh->Statusline << endl;
		prh->Breakpoint = true;
	}
	else
	{
		cout << "服务器不支持断点下载:" << prh->Statusline << endl;
		prh->Breakpoint = false;
	}
	char  sbuf[128];
	memset(sbuf, 0, 128);
	while (0 == strcmp(prh->ContentMD5, "") || 0 == prh->ContentLength)
	{
		memset(sbuf, 0, 128);
		fscanf_s(ftmp, " %[^:\r]%*c", sbuf, 128);
		sbuf[strlen(sbuf)] = 0;
		if (!strcmp(sbuf, "Content-Range")) {
			while (fgetc(ftmp) != '/');
			fscanf_s(ftmp, "%d", &prh->ContentLength);
			prh->ContentBlock = prh->ContentLength / THREAD;
			cout << "文件总大小为:" << prh->ContentLength << endl;
		}
		else if (!strcmp(sbuf, "Content-MD5")) {
			fscanf_s(ftmp, "%s", prh->ContentMD5, sizeof(prh->ContentMD5));
			cout << "文件MD5为:" << prh->ContentMD5 << endl;
		}
		else if (ret <= ftell(ftmp)) 
			break;
	}
	memset(RecvBuf, 0, SENDBUFSIZE);
	delete[] RecvBuf;
	RecvBuf = nullptr;
	fclose(ftmp);
	ftmp = nullptr;
	closesocket(sockid);
	sockid = NULL;
	Sleep(3000);
	return 0;
}

int InitThreadTmp(PRESPHEAD prh,PTHREADTMP ftmp) {
	for (size_t i = 0; i < THREAD; i++)
	{
		ftmp[i].ThreadNum = i;
		tmpfile_s(&ftmp[i].ThreadFtmp);
		ftmp[i].Complete = false;
		ftmp[i].ThreadStart = i * prh->ContentBlock;
		if (THREAD-1 > i)
		{
			ftmp[i].ThreadEnd = (i + 1) * prh->ContentBlock - 1;
			ftmp[i].ThreadBlock = prh->ContentBlock;
		}
		else {
			ftmp[i].ThreadEnd = prh->ContentLength - 1;
			ftmp[i].ThreadBlock = prh->ContentLength - ftmp[i].ThreadStart;
		}
	}
	return 0;
}

int Download1(PRESPHEAD prh, PHTTPURL phu) {
	SOCKET sockid; 
	char* SendBuf = new char[SENDBUFSIZE];
	memset(SendBuf, 0, SENDBUFSIZE);
	char sbuf[128];
	memset(sbuf, 0, 128);
	FILE* DFile;
	int ret = 0, err = 0;
	long Fsize1 = 0, Fsize2 = 0, Ltime1 = 0, Ltime2 = 0;
	if (0 != (err = CraeteSocket(&sockid,0))) return err;
	sprintf_s(SendBuf, SENDBUFSIZE, "%s\r\n", ReqHead);
	cout << "----------------SendData3-----------------------\n" << SendBuf << "----------------end---------------------- " << endl;
	ret = send(sockid, SendBuf, strlen(SendBuf), 0);
	if (ret == strlen(SendBuf)) {
		cout << "ReqHead 数据发送成功" << endl;
	}
	else {
		cout << "ReqHead 数据发送失败" << endl;
		return -201;
		exit(1);
	}
	delete[] SendBuf;
	SendBuf = nullptr;
	char* RecvBuf = new char[RECVBUFSIZE];
	memset(RecvBuf, 0, RECVBUFSIZE);
	ret = recv(sockid, RecvBuf, RECVBUFSIZE, 0);
	/*cout << "----------------RecvData3:" << strlen(RecvBuf) << "-----------------------\n" << RecvBuf << endl << "----------------end---------------------- " << endl;*/
	sscanf_s(RecvBuf, "%[^\r]", sbuf, sizeof(sbuf));
	sbuf[strlen(sbuf)] = 0;
	if (0 != strncmp(sbuf, "HTTP/1.1 200 OK", 15)) {
		cout << "服务器应答报错：" << prh->Statusline << endl;
		return -203;
		exit(1);
	}
	char* pEnd = strstr(RecvBuf, "\r\n\r\n") + 4;
	CreateDirectory("./Download", nullptr);
	char fname[64];
	sprintf_s(fname, "./Download/%s", phu->Filename);
	fopen_s(&DFile, fname, "wb");
	if (NULL != DFile) {
		fwrite(pEnd, 1, ret - (int)(pEnd - RecvBuf), DFile);
		while ((ret = recv(sockid, RecvBuf, RECVBUFSIZE, 0)) > 0)
		{
			cout << ret << "-";
			Ltime2 = clock();
			if (Ltime2 - Ltime1 >= 1000) {
				cout << "下载速度：" << (Fsize2 - Fsize1) / 1024 << "KB/s,已下载：" << Fsize2 / 1024 << "KB,总大小：" << Fsize2 << " - " << prh->ContentLength << endl;
				Fsize1 = Fsize2;
				Ltime1 = Ltime2;
			}
			fwrite(RecvBuf, 1, ret, DFile);
			Fsize2 = ftell(DFile);
			if (Fsize2 >= prh->ContentLength) {
				cout << "下载速度：" << (Fsize2 - Fsize1) / 1024 << "KB/s,已下载：" << Fsize2 / 1024 << "KB,总大小：" << Fsize2 << " - " << prh->ContentLength << endl;
				break;
			}
			memset(RecvBuf, 0, RECVBUFSIZE);
		}
		delete[]RecvBuf;
		SendBuf = nullptr;
		fclose(DFile);
		DFile = nullptr;
	}
	closesocket(sockid);
	sockid = NULL;
	return 0;
}

void Download2(PVOID Pparam) {
	PPARAM param = (PPARAM)Pparam;
	long Fsize = 0;
	WaitForSingleObject(hMutex, INFINITE);
	int n = param->n;
	++param->n;
	param->ftmp[n].Complete = false;
	ReleaseMutex(hMutex);
	SOCKET sockid;
	char* SendBuf = new char[SENDBUFSIZE];
	memset(SendBuf, 0, SENDBUFSIZE);
	char sbuf[128];
	memset(sbuf, 0, 128);
	int ret = 0, err = 0;
	if (0 != (err = CraeteSocket(&sockid,n))) return ;
	sprintf_s(SendBuf, SENDBUFSIZE, "%sRange: bytes=%ld-%ld\r\n\r\n", ReqHead, param->ftmp[n].ThreadStart, param->ftmp[n].ThreadEnd);
	ret = send(sockid, SendBuf, strlen(SendBuf), 0);
	if (ret == strlen(SendBuf)) {
		/*cout << "ReqHead 数据发送成功" << endl;*/
	}
	else {
		/*cout << "ReqHead 数据发送失败" << endl;*/
		return ;
		exit(1);
	}
	delete[] SendBuf;
	SendBuf = nullptr;
	char* RecvBuf = new char[RECVBUFSIZE];
	memset(RecvBuf, 0, RECVBUFSIZE);
	ret = recv(sockid, RecvBuf, RECVBUFSIZE, 0);
	sscanf_s(RecvBuf, "%[^\r]", sbuf, sizeof(sbuf));
	sbuf[strlen(sbuf)] = 0;
	if (0 != strncmp(sbuf, "HTTP/1.1 206", 12)) {
		cout << "线程["<<n<<"]服务器应答报错：" << sbuf << endl;
		return ;
		exit(1);
	}
	char* pEnd = strstr(RecvBuf, "\r\n\r\n");
	if (NULL != pEnd)
	{
		pEnd += 4;
		WaitForSingleObject(hMutex, INFINITE);
		rewind(param->ftmp[n].ThreadFtmp);
		fwrite(pEnd, 1, ret - (int)(pEnd - RecvBuf), param->ftmp[n].ThreadFtmp);
		ReleaseMutex(hMutex);
	}
	while ((ret = recv(sockid, RecvBuf, RECVBUFSIZE, 0)) > 0)
	{
		WaitForSingleObject(hMutex, INFINITE);
		fwrite(RecvBuf, 1, ret, param->ftmp[n].ThreadFtmp);
		memset(RecvBuf, 0, RECVBUFSIZE);
		Fsize = ftell(param->ftmp[n].ThreadFtmp);
		if (Fsize >= (param->prh->ContentLength / THREAD)) {
			param->ftmp[n].Complete = true;
			break;
		}
		ReleaseMutex(hMutex);
	}
	delete[]RecvBuf;
	SendBuf = nullptr;
	closesocket(sockid);
	sockid = NULL;
	return ;
}

int PrintSpeed(PRESPHEAD prh, THREADTMP ftmp[THREAD]) {
	long Fsize1[THREAD] = { 0 };
	long Fsize2[THREAD] = { 0 };
	long FsizeNew = 0;
	long FsizeOld = 0;
	long Ltime1 = 0;
	long Ltime2 = 0;
	long Ltime = 0;
	float A = 0, B = 0, C = 0;
	bool b = true;
	while (true)
	{
		Ltime2 = clock();
		if (Ltime2 - Ltime1 >= 2000) {
			Ltime += 2;
			FsizeNew = 0;
			for (size_t i = 0; i < THREAD; i++)
			{
				Fsize2[i] = 0;
				Fsize2[i] = ftell(ftmp[i].ThreadFtmp);
				FsizeNew += Fsize2[i];
			}
			A = (float)(FsizeNew - FsizeOld) / 1024 / 1024 / 2;
			B = (float)FsizeNew / 1024 / 1024 ;
			C = (float)prh->ContentLength / 1024 / 1024;
			SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), 12);
			printf_s("下  载  速  度 :%6.3fMB/s,已下载:%6.3fMB/s,总大小:%8.3fMB(bytes:%9ld-%-9ld) |(已用时间%02ld分%02ld秒)\n", A, B, C, FsizeNew, prh->ContentLength,Ltime/60, Ltime%60);
			SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), 7);
			for (size_t i = 0; i < THREAD; i++)
			{
				A = (float)(Fsize2[i] - Fsize1[i]) / 1024 / 1024 / 2;
				B = (float)Fsize2[i] / 1024 / 1024;
				C = (float)prh->ContentLength / 1024 / 1024 / THREAD;
				SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), 10);
				
				printf_s("线程[%d]下载速度:%6.3fMB/s,已下载:%6.3fMB/s,总大小:%8.3fMB(bytes:%9ld-%-9ld),块位置bytes:%9ld-%-9ld\n", i, A, B, C, Fsize2[i], ftmp[i].ThreadBlock, ftmp[i].ThreadStart, ftmp[i].ThreadEnd);
				FsizeOld = 0;
				Fsize1[i] = 0;
				Fsize1[i] = Fsize2[i];
				FsizeOld += Fsize1[i];
			}
			SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), 7);
			
			FsizeOld = FsizeNew;
			Ltime1 = Ltime2;
		}
		b = true;
		for (size_t i = 0; i < THREAD; i++)
		{
			b = b & ftmp[i].Complete;
			if (!b) {
				break;
			}
		}
		if (b) {
			SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), 12);
			cout << "\n\n* * * 文件下载完成 * * *" << endl;
			SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), 7);
			break;
		}
		if (0 != errq)
		{
			break;
		}
	}
	return 0;
}

int Create_File(PHTTPURL phu, THREADTMP ftmp[THREAD]) {
	FILE* DFile;
	CreateDirectory("./Download", nullptr);
	char fname[64];
	sprintf_s(fname, "./Download/%s", phu->Filename);
	fopen_s(&DFile, fname, "wb");
	if (NULL != DFile) {
			
		for (size_t i = 0; i < THREAD; i++)
		{
			char c = 0;
			rewind(ftmp[i].ThreadFtmp);
			while (true) //EOF是文件结束标志
			{
				c = fgetc(ftmp[i].ThreadFtmp);
				if (feof(ftmp[i].ThreadFtmp))
				{
					break;
				}
				fputc(c, DFile);
			}
			fclose(ftmp[i].ThreadFtmp);
			ftmp[i].ThreadFtmp = nullptr;
		}
		fclose(DFile);
		DFile = nullptr;
		SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), 12);
		cout << "\n\n* * * 文件保存完成 * * *" << endl;
		SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), 7);
	}
	return 0;
}

main.cpp

#include"global.h"
HANDLE hMutex = CreateMutex(NULL, FALSE, "trw");		//创建互斥句柄，命名为“trw”
int errq = 0;
int Download(PRESPHEAD prh, PHTTPURL phu);
int InitHttpurl(PHTTPURL phurl);
int InitSocket(PHTTPURL phurl);
int InitRespHead(PRESPHEAD prh);
int InitThreadTmp(PRESPHEAD prh, PTHREADTMP ftmp);
int Download1(PRESPHEAD prh, PHTTPURL phu);
void Download2(PVOID Pparam);
int PrintSpeed(PRESPHEAD prh, THREADTMP ftmp[THREAD]);
int Create_File(PHTTPURL phu, THREADTMP ftmp[THREAD]);



int main() {
	HTTPURL HttpUil = { 0 };
	THREADTMP FileTmp[THREAD];
	RESPHEAD RespHead ;
	PARAM SParam = { NULL };
	int S = 14, T = 10;
	SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), T);
	printf_s("┌────────────────────────────────────────────────┐\n");
	printf_s("%-50s%s\n%-7s", "│", "│", "│");
	SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), S);
	printf_s("%-43s", "作    者：仝 （TRW666）");
	SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), T);
	printf_s("%s\n%-50s%s\n%-7s", "│", "│", "│", "│");
	SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), S);
	printf_s("%-43s", "博客地址：https://blog.youkuaiyun.com/trw777");
	SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), T);
	printf_s("%s\n%-50s%s\n", "│", "│", "│");
	printf_s("└────────────────────────────────────────────────┘\n");
	SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), 7);

	errq = InitHttpurl(&HttpUil);
	if (0 != errq) {
		cout << "错误码:ERR = " << errq << endl;
		system("pause");
		return errq;
	}
	errq = InitSocket(&HttpUil);
	if (0 != errq) {
		cout << "错误码:ERR = " << errq << endl;
		system("pause");
		return errq;
	}
	errq = InitRespHead(&RespHead);
	if (0 != errq) {
		cout << "错误码:ERR = " << errq << endl;
		system("pause");
		return errq;
	}

	/*Download(&RespHead, &HttpUil);*/
	if (RespHead.Breakpoint)
	{
		InitThreadTmp(&RespHead,FileTmp);
		SParam.prh = &RespHead;
		SParam.ftmp = FileTmp;
		SParam.n = 0;
		
		for (size_t i = 0; i < THREAD; i++)
		{
			_beginthread(Download2, 0, (PVOID)&SParam);
			while (SParam.n == i){
				WaitForSingleObject(hMutex, INFINITE);
				Sleep(10);
				ReleaseMutex(hMutex);
			}
		}
		PrintSpeed(&RespHead, FileTmp);
		Create_File(&HttpUil, FileTmp);
	}
	else
	{
		Download1(&RespHead, &HttpUil);
	}
	WSACleanup();
	if (0 != errq)
	{
		cout << "错误码:ERR = " << errq << endl;
	}
	system("pause");
	return errq;
}