基于OpenCV C++的网络实时视频流传输——Windows下使用TCP/IP编程原理

1.TCP/IP编程

1.1 概念

IP 是英文 Internet Protocol （网络之间互连的协议）的缩写，也就是为计算机网络相互连接进行通信而设计的协议。任一系统，只要遵守 IP协议就可以与因特网互连互通。

所谓IP地址就是给每个遵循tcp/ip协议连接在Internet上的主机分配的一个32bit地址。按照TCP/IP协议规定，IP地址用二进制来表示，每个IP地址长32bit，比特换算成字节，就是4个字节。为了方便人们的使用，IP地址经常被写成十进制的形式，中间使用符号 "." 分开不同的字节，如：192.168.1.1。在因特网中，主机的标识便是它ip地址。

常见的获取服务器ip的方法是使用系统自带的ping命令。例，打开cmd输入：ping http://www.xxxx.com

1.2 Socket

socket的英文原义是"孔"或"插座"。作为4BDS UNIX的进程通信机制，取后一种意思。通常也称作"套接字"，用于描述IP地址和端口，是一个通信链的句柄。Scoket程勋分为服务端与客户端，服务端程序监听端口，等待客户端程序的连接。客户端程序发起连接，等待服务端的相应。客户端想要连接上服务端的话，需要 知道服务端的ip地址。

例如，客户想要访问百度网站的首页，通过浏览器访问http://www.baidu.com。浏览器发出请求之后，先是DNS服务器将百度的域名解析成ip地址之后，访问到ip地址为115.239.210.27服务器的80端口（http协议默认在80端口），请求发送后，百度的服务器作为响应将页面的源代码发送至客户端（通过浏览器右键->源代码，或者ctrl+u到服务器返回的页面源代码），随后浏览器将源代码渲染成页面。这样用户就看到了百度网站的

1.3 服务端与客户端

服务端与客户端在计算机的世界里，凡是提供服务的一方我们称为服务端（Server），而接受服务的另一方我们称作客户端（Client）。网站提供网页数据的服务，使用者接受网站所提供的数据服务，所以使用者在这里就是客户端，响应使用者要求的网站即称为服务端。不过客户端及服务端的关系不见得一定建立在两台分开的机器上，同一台机器中也有这种主从关系的存在，提供服务的服务端及接受服务的客户端也有可能都在同一台机器上。例如我们在提供网页的服务器上执行浏览器浏览本机所提供的网页，这样在同一台机器上就同时扮演服务端及客户端。

实现流程 :

服务器端创建套接字后连续调用bind、listen函数进入等待状态，客户端通过调用connect函数发起连接请求。需要注意的是，客户端只能等到服务器调用listen函数后才能调用connect()函数。同时要清楚，客户端调用connect()函数前，服务器端有可能率先调用accept()函数。当然，此时服务器在调用accept()函数是进入阻塞状态，直到客户端调用connect()函数为止。

2、Windows与Linux下TCP/IP编程

2.1 函数说明

Windows套接字大部分是参考BSD系列UNIX套接字设计的，所以很多地方都跟Linux套接字类似。大多数项目都在Linux系列的操作系统下开发服务器端，而多数客户端是在windows平台下开发的。

在windows下做网络编程，需要做如下准备：导入头文件winsock2.h、链接ws2_32.lib。

Windows 下的 socket 程序和 Linux 思路相同，但细节有所差别：

Windows 下的 socket 程序依赖Winsock.dll 或 ws2_32.dll，必须提前加载。Windows Socket编程依赖于系统提供的动态链接库(DLL)，有两个版本：较早的DLL是 wsock32.dll，大小为 28KB，对应的头文件为 winsock1.h；最新的DLL是 ws2_32.dll，大小为 69KB，对应的头文件为 winsock2.h。几乎所有的 Windows 操作系统都已经支持 ws2_32.dll，包括个人操作系统 Windows 95 OSR2、Windows 98、Windows Me、Windows 2000、XP、Vista、Win7、Win8、Win10 以及服务器操作系统 Windows NT 4.0 SP4、Windows Server 2003、Windows Server 2008 等，所以你可以毫不犹豫地使用最新的 ws2_32.dll。

使用 DLL 之前必须把 DLL 加载到当前程序，你可以在编译时加载，也可以在程序运行时加载。这里使用#pragma命令，在编译时加载：#pragma comment (lib, "ws2_32.lib")

使用 DLL 之前，还需要调用 WSAStartup() 函数进行初始化，以指明 WinSock 规范的版本，并初始化相应版本的库。它的原型为：int WSAStartup(WORD wVersionRequested, LPWSADATA lpWSAData);

int WSAStartup(WORD wVersionRequested, LPWSADATA lpWSAData);

wVersionRequested：该参数为WinSock 规范的版本号，低字节为主版本号，高字节为副版本号（修正版本号）；
lpWSAData：该参数为指向 WSAData 结构体的指针；

WinSock 规范的最新版本号为 2.2，较早的有 2.1、2.0、1.1、1.0，ws2_32.dll 支持所有的规范，而 wsock32.dll 仅支持 1.0 和 1.1。若版本为1.2，则其中1是主版本号，2是副版本号，应传递0x0201。
wsock32.dll 已经能够很好的支持 TCP/IP 通信程序的开发，ws2_32.dll 主要增加了对其他协议的支持，不过建议使用最新的 2.2 版本。

wVersionRequested 参数用来指明我们希望使用的版本号，它的类型为 WORD，等价于 unsigned short，是一个整数，所以需要用 MAKEWORD() 宏函数对版本号进行转换。例如：
MAKEWORD(1, 2); //主版本号为1，副版本号为2，返回 0x0201
MAKEWORD(2, 2); //主版本号为2，副版本号为2，返回 0x0202

Linux 使用"文件描述符"的概念，而 Windows 使用"文件句柄"的概念；

Linux 中的一切都是文件，每个文件都有一个整数类型的文件描述符，socket 也是一个文件，也有文件描述符，所以Linux 不区分 socket 文件和普通文件，而 Windows 区分；

Linux 下 socket() 函数的返回值为 int 类型，而 Windows 下为 SOCKET 类型，也就是句柄。

Linux 下使用 read() / write() 函数读写，而 Windows 下使用 recv() / send() 函数发送和接收。

关闭 socket 时，Linux 使用 close() 函数，而 Windows 使用 closesocket() 函数。

socket编程的基本函数有socket()、bind()、listen()、accept()、send()、sendto()、recv()以及recvfrom()等。

2.2 socket()

Linux 中的一切都是文件，每个文件都有一个整数类型的文件描述符；socket 也是一个文件，也有文件描述符。使用 socket() 函数创建套接字以后，返回值就是一个 int 类型的文件描述符。

Windows 会区分 socket 和普通文件，它把 socket 当做一个网络连接来对待，调用 socket() 以后，返回值是 SOCKET 类型，用来表示一个套接字。

不管是 Windows 还是 Linux，都使用 socket() 函数来创建套接字。socket() 在两个平台下的参数是相同的，不同的是返回值。

|------|---------|---------|----------------------------|
| 头文件 | Linux | #include <sys/socket.h> ||
| 头文件 | Windows | #include <winsock2.h> ||
| 函数原型 | Linux | int socket(int family,int type,int protocol); ||
| 函数原型 | Windows | SOCKET socket(int family, int type, int protocol); ||
| 作用 | 该函数用于创建一个套接字，同时指定协议和类型 |||
| 参数 | family：协议族（AF前缀和PF前缀是等价的） || AF_INET（PF_INET）：IPv4协议族 |
| 参数 | family：协议族（AF前缀和PF前缀是等价的） || AF_INET6（PF_INET6）：IPv6协议族 |
| 参数 | family：协议族（AF前缀和PF前缀是等价的） || AF_LOCAL：UNIX域协议族 |
| 参数 | family：协议族（AF前缀和PF前缀是等价的） || AF_ROUTE：路由套接字协议族 |
| 参数 | family：协议族（AF前缀和PF前缀是等价的） || AF_KEY：密钥套接字协议族 |
| 参数 | type：套接字类型，即套接字的数据传输方式（有的协议族中存在多种数据传输方式，所以协议族和数据传输方式分开） || SOCK_STREAM：流式套接字 |
| 参数 | type：套接字类型，即套接字的数据传输方式（有的协议族中存在多种数据传输方式，所以协议族和数据传输方式分开） || SOCK_DGRAM：数据报套接字 |
| 参数 | type：套接字类型，即套接字的数据传输方式（有的协议族中存在多种数据传输方式，所以协议族和数据传输方式分开） || SOCK_RAM：原始套接字 |
| 参数 | Protocol：传输协议（该参数一般置0，原始套接字除外），比如满足AF_INET和SOCK_STREAM这两个条件的只有IPPROTO_TCP，满足AF_INET和SOCK_DGRAM这两个条件的只有IPPTOTO_UDP || IPPROTO_TCP：TCP协议 |
| 参数 | Protocol：传输协议（该参数一般置0，原始套接字除外），比如满足AF_INET和SOCK_STREAM这两个条件的只有IPPROTO_TCP，满足AF_INET和SOCK_DGRAM这两个条件的只有IPPTOTO_UDP || IPPTOTO_UDP：UDP协议 |
| 返回值 | 成功 | Linux | 非负套接字文件描述符 |
| 返回值 | 成功 | Windows | 套接字句柄 |
| 返回值 | 失败 | Linux | -1 |
| 返回值 | 失败 | Windows | INVALID_SOCKET |

注意：

protocol 表示传输协议，常用的有 IPPROTO_TCP 和 IPPTOTO_UDP，分别表示 TCP 传输协议和 UDP 传输协议。有了地址类型和数据传输方式，还不足以决定采用哪种协议吗？为什么还需要第三个参数呢？

正如大家所想，一般情况下有了 af 和 type 两个参数就可以创建套接字了，操作系统会自动推演出协议类型，除非遇到这样的情况：有两种不同的协议支持同一种地址类型和数据传输类型。如果我们不指明使用哪种协议，操作系统是没办法自动推演的。

当参数 family 的值为 PF_INET时：

如果使用 SOCK_STREAM 传输数据，那么满足这两个条件的协议只有 TCP，因此可以这样来调用 socket() 函数：

int tcp_socket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP); //IPPROTO_TCP表示TCP协议 这种套接字称为 TCP 套接字

如果使用 SOCK_DGRAM 传输方式，那么满足这两个条件的协议只有 UDP，因此可以这样来调用 socket() 函数：

int udp_socket = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP); //IPPROTO_UDP表示UDP协议 这种套接字称为 UDP 套接字

上面两种情况都只有一种协议满足条件，可以将 protocol 的值设为 0，系统会自动推演出应该使用什么协议，如下所示：

int tcp_socket = socket(AF_INET, SOCK_STREAM, 0); //创建TCP套接字

int udp_socket = socket(AF_INET, SOCK_DGRAM, 0); //创建UDP套接字

2.3 bind()

它主要用于服务器，客户端创建的套接字可以不绑定地址。绑定时一般要指定IP地址和端口号，否则内核会随意分配一个临时端口给该套接字，IP地址可以是本机的IP地址，或者使用宏INADDR_ANY，允许将套接字与服务器的任意网络接口（如eth0、eth0:1、eth1等）进行绑定。

|------|---------|---------|--------------|
| 头文件 | Linux | #include <sys/socket.h> ||
| 头文件 | Windows | #include <winsock2.h> ||
| 函数原型 | Linux | int bind(int sockfd, struct sockaddr *addr, socklen_t addrlen); ||
| 函数原型 | Windows | int bind(SOCKET sockfd, const struct sockaddr *addr, int addrlen); ||
| 作用 | 给服务器套接字分配IP地址和端口号 |||
| 参数 | sockfd | 套接字描述符（服务器端socket函数的的返回值） ||
| 参数 | addr | 绑定的地址（struct sockaddr_in强转） ||
| 参数 | addrlen | 地址长度（sizeof（server_addr)) ||
| 返回值 | 成功 | Linux | 0 |
| 返回值 | 成功 | Windows | 0 |
| 返回值 | 失败 | Linux | -1 |
| 返回值 | 失败 | Windows | SOCKET_ERROR |

2.4 listen()

在服务器端程序成功建立套接字并与地址进行绑定之后，通过调用listen()函数将服务器套接字设置成被动监听模式（被动模式），并且设置客户端请求连接的队列长度。所谓被动监听，是指套接字一直处于"睡眠"中，直到客户端发起请求才会被"唤醒"。

|------|---------|---------|--------------|
| 头文件 | Linux | #include <sys/socket.h> ||
| 头文件 | Windows | #include <winsock2.h> ||
| 函数原型 | Linux | int listen(int sockfd, int backlog); ||
| 函数原型 | Windows | int listen(SOCKET sockfd, int backlog); ||
| 作用 | 该函数将服务器套接字转为可接收连接状态 |||
| 参数 | sockfd | 套接字描述符(服务器端的套接字） ||
| 参数 | backlog | 请求队列中允许的最大请求数，大多数系统默认值为5，最大为1024 ||
| 返回值 | 成功 | Linux | 0 |
| 返回值 | 成功 | Windows | 0 |
| 返回值 | 失败 | Linux | -1 |
| 返回值 | 失败 | Windows | SOCKET_ERROR |

sock 为需要进入监听状态的套接字，backlog 为请求队列的最大长度。

所谓被动监听，是指当没有客户端请求时，套接字处于"睡眠"状态，只有当接收到客户端请求时，套接字才会被"唤醒"来响应请求。

当套接字正在处理客户端时，如果有新的客户端请求进来，套接字是没法处理的，只能把它放进缓冲区进行排队，待当前客户端处理完毕后，再从缓冲区中读取出来处理。如果不断有新的请求进来，它们就按照先后顺序在缓冲区中排队，直到缓冲区满。这个缓冲区，就称为请求队列（Request Queue）。

缓冲区的长度（能存放多少个客户端请求）可以通过 listen() 函数的 backlog 参数指定，但究竟为多少并没有什么标准，可以根据你的需求来定，并发量小的话可以是10或者20。

如果将 backlog 的值设置为 SOMAXCONN，就由系统来决定请求队列长度，这个值一般比较大，可能是几百，或者更多。

当请求队列满时，就不再接收新的请求，对于 Linux，客户端会收到 ECONNREFUSED 错误，对于 Windows，客户端会收到 WSAECONNREFUSED 错误。

注意：listen() 只是让套接字处于监听状态，将各个客户端的请求放入缓冲区进行排队，并没有处理客户端的请求。接受请求需要使用 accept() 函数。

2.5 accept()

服务器端通过调用accept()函数等待并处理客户端的连接请求,程序一旦执行到 accept() 就会被阻塞（暂停运行），直到客户端发起请求。建立好TCP连接后，该函数会返回一个新的已连接的套接字。

|------|---------|---------|----------------|
| 头文件 | Linux | #include <sys/socket.h> ||
| 头文件 | Windows | #include <winsock2.h> ||
| 函数原型 | Linux | int accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen); ||
| 函数原型 | Windows | SOCKET accept(SOCKET sockfd, struct sockaddr *addr, int *addrlen); ||
| 作用 | 该函数用来处理连接请求，如果在没有连接请求，该函数不会返回。一直到有连接请求为止 |||
| 参数 | sockfd | 套接字描述符（服务器的套接字） ||
| 参数 | addr | 用于保存连接的客户端的地址 ||
| 参数 | addrlen | 地址长度 ||
| 返回值 | 成功 | Linux | 建立好连接的套接字描述符 |
| 返回值 | 成功 | Windows | 建立好连接的套接字句柄 |
| 返回值 | 失败 | Linux | -1 |
| 返回值 | 失败 | Windows | INVALID_SOCKET |

accept()函数受理连接请求等待队列呆处理的客户端连接请求。函数调用成功时，accept()函数内部将产生用于数据I/O的套接字，并返回其文件描述符。需要强调的是，套接字是自动创建的，并自动与发起连接请求的客户端建立连接

它的参数与 listen() 和 connect() 是相同的：sock 为服务器端套接字，addr 为 sockaddr_in 结构体变量，addrlen 为参数 addr 的长度，可由 sizeof() 求得。

accept() 返回一个新的套接字来和客户端通信，addr 保存了客户端的IP地址和端口号，而 sock 是服务器端的套接字，大家注意区分。后面和客户端通信时，要使用这个新生成的套接字，而不是原来服务器端的套接字。

最后需要说明的是：listen() 只是让套接字进入监听状态，并没有真正接收客户端请求，listen() 后面的代码会继续执行，直到遇到 accept()。accept() 会阻塞程序执行（后面代码不能被执行），直到有新的请求到来。

2.6 connect()

客户端通过该函数向服务器端的监听套接字发送连接请求，直到服务器传回数据后，connect() 才运行结束。

客户端调用connect()函数后，发生以下情况之一才会返回：服务器端接受连接请求、发生断网等异常情况而中断连接请求。

需要注意，所谓的"接受连接请求"并不意味着服务器端调用accept()函数，其实是服务器端用listen()把客户端连接请求信息记录到等待队列。因此connect()函数返回后并不立即进行数据交换。

客户端在调用connect()函数时会自动给套接字分配IP地址和端口号，不需要调用bind()函数进行分配。

|-----|-----------|---------|------------|
| 头文件 | Linux | #include <sys/socket.h> ||
| 头文件 | Windows | #include <winsock2.h> ||
| 头文件 | Linux | int connect(int sockfd, struct sockaddr *serv_addr, socklen_t addrlen); ||
| 头文件 | Windows | int connect(SOCKET sockfd, const struct sockaddr *serv_addr, int addrlen); ||
| 作用 | 该函数用来向服务器发送连接请求 |||
| 参数 | sockfd | 套接字描述符（客户端的套接字） ||
| 参数 | serv_addr | 要连接的服务器端的IP地址信息 ||
| 参数 | addrlen | 地址长度 ||
| 返回值 | 成功 | Linux | 0 |
| 返回值 | 成功 | Windows | 0 |
| 返回值 | 失败 | Linux | -1 |
| 返回值 | 失败 | Windows | SOCK_ERROR |

2.7 send()和recv()

|------|---------|---------|--------------|
| 头文件 | Linux | #include <sys/socket.h> ||
| 头文件 | Windows | #include <winsock2.h> ||
| 函数原型 | Linux | int send(int sockfd,const void *buf,int len,int flags); ||
| 函数原型 | Windows | int send(SOCKET sockfd, const char *buf, int len, int flags); ||
| 作用 | 该函数用来发送数据 |||
| 参数 | sockfd | 套接字描述符（客户端的套接字） ||
| 参数 | buf | 发送缓冲区的地址 ||
| 参数 | len | 发送数据的长度 ||
| 参数 | flags | 一般为0 ||
| 返回值 | 成功 | Linux | 实际发送的字节数 |
| 返回值 | 成功 | Windows | 实际发送的字节数 |
| 返回值 | 失败 | Linux | -1 |
| 返回值 | 失败 | Windows | SOCKET_ERROR |

|------|---------|---------|---------------------|
| 头文件 | Linux | #include <sys/socket.h> ||
| 头文件 | Windows | #include <winsock2.h> ||
| 函数原型 | Linux | int recv(int sockfd,void *buf,int len,unsigned int flags); ||
| 函数原型 | Windows | int recv(SOCKET sockfd, char *buf, int len, int flags); ||
| 作用 | 该函数用来接收数据 |||
| 参数 | sockfd | 套接字描述符（客户端的套接字描述符） ||
| 参数 | buf | 存放接收数据的缓冲区地址 ||
| 参数 | len | 接收数据的长度 ||
| 参数 | flags | 一般为0 ||
| 返回值 | 成功 | Linux | 实际接收到的字节数（收到EOF时为0） |
| 返回值 | 成功 | Windows | 实际接收到的字节数（收到EOF时为0） |
| 返回值 | 失败 | Linux | -1 |
| 返回值 | 失败 | Windows | SOCKET_ERROR |

2.8 sendto()和recvfrom()

这两个函数一般在UDP通信过程中用于发送和接收数据。当用在TCP时，后面的几个与地址有关的参数不起作用，函数作用等同于send()和recv()**

|------|--------|------------------|
| 头文件 | #include <sys/socket.h> ||
| 函数原型 | int sendto(int sockfd,const void *buf,int len, unsigned int flags,const struct sockaddr *to,int tolen); ||
| 作用 | 该函数用来发送数据 ||
| 参数 | sockfd | 套接字描述符 |
| 参数 | buf | 发送缓冲区的地址 |
| 参数 | len | 发送数据的长度 |
| 参数 | flags | 一般为0 |
| 参数 | to | 接收方的套接字的IP地址和端口号 |
| 参数 | tolen | 地址长度 |
| 返回值 | 成功 | 实际发送的字节数 |
| 返回值 | 失败 | -1 |

|------|---------|----------------|
| 头文件 | #include <sys/socket.h> ||
| 函数原型 | int recvfrom(int sockfd,void *buf,int len,unsigned int flags,struct sockaddr *from,int *fromlen); ||
| 作用 | 该函数用来接收数据 ||
| 参数 | sockfd | 套接字描述符 |
| 参数 | buf | 存放接收数据的缓冲区地址 |
| 参数 | len | 接收数据的长度 |
| 参数 | flags | 一般为0 |
| 参数 | from | 发送方的IP地址和端口号信息 |
| 参数 | Fromlen | 地址长度 |
| 返回值 | 成功 | 实际接收到的字节数 |
| 返回值 | 失败 | -1 |

2.9 close()

|------|---------|---------|--------------|
| 头文件 | Linux | #include <sys/socket.h> ||
| 头文件 | Windows | #include <winsock2.h> ||
| 函数原型 | Linux | int close(int sockfd); ||
| 函数原型 | Windows | int closesocket(SOCKET sockfd); ||
| 作用 | 关闭套接字 |||
| 参数 | sockfd | 套接字描述符 ||
| 返回值 | 成功 | Linux | 0 |
| 返回值 | 成功 | Windows | 0 |
| 返回值 | 失败 | Linux | -1 |
| 返回值 | 失败 | Windows | SOCKET_ERROR |

3.代码实现

3.1 server.cpp

#include<WINSOCK2.H>
#include<stdio.h>
#pragma comment(lib,"WS2_32.lib")
#define   BUFFER_SIZE 1024 //缓冲区大小
int main()
{
    WSADATA WSAData;
    SOCKET sClient;    //用于和客户端socket进行通信
    SOCKET sServer; //用于和本地地址绑定的socket
    int err_code; //存储返回的错误代码
    char buffer[BUFFER_SIZE]; //缓冲区
    if(WSAStartup(MAKEWORD(2,2),&WSAData)!=0)
    {
        printf("WSAStartup failed,错误代码:%d\n",WSAGetLastError());
       return -1;
    }      //初始化winsock

    sServer=socket(AF_INET,SOCK_STREAM,IPPROTO_TCP); //创建监听的socket

    if(sServer==INVALID_SOCKET)
    {
        printf("创建Socket失败,错误代码:%d\n",WSAGetLastError());
       WSACleanup();//清除初始化的Winsock
     return -1;
    }  

    SOCKADDR_IN addrServ;  //在监听的SOCKET绑定到本地之前，需要设置服务器Socket的地址
    addrServ.sin_family=AF_INET;
    addrServ.sin_port=htons(9990);//这里为什么不能用htonl()函数来转换呢,因为SOCKADDR_IN里面声明的端口号为u_shortk类型
    addrServ.sin_addr.S_un.S_addr=htons(INADDR_ANY);//服务器监听端口为INADDR_ANY,即在任意本地地址(0.0.0.0)上进行监听

    err_code=bind(sServer,(const sockaddr *)&addrServ,sizeof(SOCKADDR_IN));    //将用于绑定的sService绑定到本地地址

    if(err_code==SOCKET_ERROR){
        printf("bind failed,错误代码:%d\n",WSAGetLastError());
        closesocket(sServer);
        WSACleanup();
        return -1;


}
    err_code=listen(sServer,1);  //监听客户端socket,第一个参数为与本地地址绑定的socket,第二个参数表示等待连接队列的最大长度
    if(err_code==SOCKET_ERROR){
        printf("listener failed,错误代码:%d\n",WSAGetLastError());
        closesocket(sServer);
        WSACleanup();
        return -1;
    }
    printf("TCP Server start...\n");
    sockaddr_in addrClient;
    int addrClientlen=sizeof(addrClient);
    sClient=accept(sServer,(sockaddr *)&addrClient,&addrClientlen);

    if(INVALID_SOCKET==sClient){
        printf("accept failed!,错误代码:%d\n",WSAGetLastError());
        closesocket(sServer);      
        WSACleanup();
        return -1;
    }

    //循环接收客户端的数据
    while(true){
        ZeroMemory(buffer,BUFFER_SIZE);//初始化缓冲区,把缓冲区置0
        err_code=recv(sClient,buffer,sizeof(buffer),0);
        if(err_code==SOCKET_ERROR){
            printf("Recv failed !,错误代码:%d\n",WSAGetLastError());
                closesocket(sClient);
                closesocket(sServer);
                WSACleanup();
                return -1;
        }
        if(strcmp(buffer,"quit")==0){ //当客户端发来quit时，服务器就关闭
            send(sClient,"quit",strlen("quit"),0);
            break;
        }else{
            char msg[BUFFER_SIZE]="我是服务器,我已收到:";
            printf("接收来自客户端[%s:%d]的消息 :%s\n",inet_ntoa(addrClient.sin_addr),addrClient.sin_port,buffer);
            strcat(msg,buffer);//拼接起来发送给主机，表示服务器已收到消息
            err_code=send(sClient,msg,strlen(msg),0);
            if(err_code==SOCKET_ERROR){
                printf("send failed !错误代码:%d\n",WSAGetLastError());
            closesocket(sServer);
            closesocket(sClient);
            WSACleanup();
            return -1;
            }

        }


    }
    closesocket(sClient); //关闭用于通信的socket
     closesocket(sServer);//关闭与本地地址绑定的socket
    WSACleanup();//释放资源
    system("pause");
    return 0;
}

3.2 Client.cpp

#include<stdio.h>
#include<WINSOCK2.H>
#include<string.h>
#include<iphlpapi.h>
#pragma comment(lib,"WS2_32.lib")
#define BUFFER_SIZE 1024 //缓冲区大小
int main(){
    WSADATA WSAData;
    SOCKET s_Host;//本机socket
    sockaddr_in addrServer ;//服务器地址 
    char buf[BUFFER_SIZE]; //缓冲区字符数组
    int return_info;//存储返回的错误代码

          if(WSAStartup(MAKEWORD(2,2),&WSAData)!=0){ //初始化Winsock2.2
        printf("无法完成初始化,错误代码:%d",WSAGetLastError());
        WSACleanup();
          return 0;
    }
    s_Host=socket(AF_INET,SOCK_STREAM,IPPROTO_TCP);
    if(s_Host==INVALID_SOCKET){
        printf("创建sockets失败,错误代码:%d\n",WSAGetLastError());
        WSACleanup();
        return -1;
    }

    addrServer.sin_family=AF_INET;
    addrServer.sin_port=htons(9990);
    addrServer.sin_addr.S_un.S_addr=inet_addr("127.0.0.1");

    return_info=connect(s_Host,(sockaddr*)&addrServer,sizeof(addrServer));
    if(SOCKET_ERROR==return_info){
        printf("连接服务器失败,错误代码:%d",WSAGetLastError());
        closesocket(s_Host);
        WSACleanup();
        return -1;
    }

    //循环给服务器发送消息
    while(1){
    printf("请输入要发送的消息:");
    gets(buf);
    return_info=send(s_Host,buf,strlen(buf),0);//这里用strlen()哦，用sizeof()就吧缓冲区那么大的数据传过去了!!!
    if(return_info==SOCKET_ERROR){
        printf("发送消息失败,错误代码:%d",WSAGetLastError());
        closesocket(s_Host);
        WSACleanup();
        return -1;
    }
    return_info= recv(s_Host,buf,sizeof(buf),0);    //recv()函数返回接收到的字节数
       if(return_info==SOCKET_ERROR){
               printf("接受服务器消息失败, 错误代码:%d",WSAGetLastError());
                closesocket(s_Host);
               WSACleanup();
                return -1;
       }else{
        buf[return_info]='\0';
    }
           if(strcmp(buf,"quit")==0){//当收到"quit"退出
              printf("退出...\n");
                     break;
           }else{
                printf("%s\n",buf);
           }
    }

    if(WSACleanup()==SOCKET_ERROR){
           printf("WSACleanUp出错!!!");
    }  //做一些清除工作
    system("pause");
    return 0;
}
/*
     乱码解决方案:
大部分编译程序 在编译的时候就把sizeof计算过了 是类型或是变量的长度这就是sizeof(x)可以用来定义数组维数的原因 
char str[20]="0123456789";
int a=strlen(str); //a=10;
int b=sizeof(str); //而b=20;

1.所以,在调用recv()函数时,用sizeof(),因为recv函数把接收缓冲中的数据copy到buf中
（注意协议接收到的数据可能大于buf的长度所以在这种情况下要调用几次recv函数才能把s的接收缓冲中的数据copy完。
recv函数仅仅是copy数据，真正的接收数据是协议来完成的），
recv函数返回其实际copy的字节数。如果recv在copy时出错，
那么它返回SOCKET_ERROR；
如果recv函数在等待协议接收数据时网络中断了，那么它返回0。
2.在调用send()函数时,用strlen(),因为这样就会将输入多少数据，转换为字节直接传过去。而接受就不一样了，接收的buf是缓冲区

*/