网络：udptcp套接字

协议

网络传输基本流程

网络编程套接字

udp套接字编程

udp相关代码实现

sock函数

bind函数

recvfrom函数

sendto函数

udp执行指令代码

popen函数

udp多线程版收发消息

tcp套接字编程

tcp套接字代码

listen函数

accept函数

read/write函数

connect函数

recv/send函数

协议

协议本质就是一种约定，网络上一定要硬件上有标志，软件上有协议

关于协议分层

1.操作系统要进行协议管理：先描述，在组织
2.协议本质就是软件，软件是可以”分层‘
3.协议在设计的时候，就是被层状的划分的
4.要划分为层状结构是因为： a. 场景复杂 b.功能解耦，便于人们进行各种维护

所以网络协议也是层状的

OSI七层模型：物理层、数据链路层、网络层、传输层、会话层、表示层、应用层这7层

但是, OSI七层模型既复杂又不实用; 所以我们按照TCP/IP四(五)层模型来讲解，即(物理层)、数据链路层、网络层、传输层、应用层

TCP/IP通讯协议采用了5层的层级结构，每一层都呼叫它的下一层所提供的网络来完成自己的需求，物理层我们不关心

传输层和网络层是在操作系统中实现的

对于一台主机, 它的操作系统内核实现了从传输层到网络层
对于一台路由器, 它实现了从网络层到物理层
对于一台交换机, 它实现了从数据链路层到物理层
对于集线器, 它只实现了物理层

网络传输基本流程

下面几层对应的代表性的协议

网络通信的过程中：

在逻辑上：在应用层相互直接传输
在物理上： 必须得自顶向下(从应用层->链路层)将数据报文交付到最底层，然后在以太网上传输，被你的主机收到后，再自底向上(从链路层->应用层)交付到应用层

每层都有自己的协议定制方案,
每层协议都要有自己的协议报头
从上到下交付数据的时候，要添加报头
从下到上递交数据的时候，要去掉报头

协议报头就是收到的报文当中，多出来的数据内容，可以理解为同层协议提前约定好的共识字段

把自顶向下交付的过程，称之为封装的过程，封装的本质：添加报头

自底向上交付的时候，需要将报头和有效载荷做分离，分析报头的字段，去决定将它的有效载荷向上应该交付给哪一个协议

把自底向上交付的过程，称之为解包的过程，解包的本质：去掉报头，展开分析

在局域网中两台主机是可以直接通信的

例如有5台主机都在一个局域网里，主机1和主机2通信，表面上是这两个主机单独通信，实际其他主机也都能看到他们通信的内容，只是每个主机对比自己的MAC地址，看是不是再和自己通信，如果不是，将当前报文丢弃即可

通过MAC地址来标识局域网中主机的唯一性

IP地址和MAC地址的区别：

IP就类似于旅游时，想从陕西去新疆去，所以此时的源IP就是陕西，目的IP就是新疆

在去的路途中，加入当前在甘肃省，当地人说下一站应该去青海省，所以此时的源MAC地址就是甘肃，下一站MAC地址就是青海

将数据在主机间转发仅仅是手段，机器收到之后，需要将数据交付给指定的进程
因此真正的网络通信过程，本质其实是进程间通信

在使用TCP/IP协议的网络中，IP及其向上的协议，看到的报文都是一样的。

应用层数据通过协议栈发到网络上时,每层协议都要加上一个数据首部,称为封装

数据封装成帧后发到传输介质上,到达目的主机后每层协议再剥掉相应的首部, 根据首部中的 "上层协议字段" 将数据交给对应的上层协议处理.

网络编程套接字

网络4件套，只要将下面四种头文件都包含，网络中所需要的就都能使用了

#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>

IP协议有两个版本, IPv4和IPv6，没有特殊说明的, 默认都是指IPv4，IPv4来说, IP地址是一个4字节, 32位的整数

IP地址,就例如：192.168.0.1，用点分割的每一个数字表示一个字节, 范围是 0 - 255;所以理论上，表示一个IP地址，其实4字节就够了，而192.168.0.1这个字符串却需要11个字节，所以点分十进制字符串风格的IP地址，需要和4字节的IP地址互相转换

IP地址(公网IP)，它标定了主机的唯一性

端口号一般是16位的整数

端口号是标识特定主机上的网络进程的唯一性

一个进程可以绑定多个端口号; 但是一个端口号不能被多个进程绑定

所以IP+端口号就可以得到全网唯一的一个进程了

我们把IP地址+端口号，称之为套接字

UDP协议

UDP协议叫做用户数据报协议，它的特点：无连接、不可靠传输、面向数据报

无连接：在使用UDP通信时，不用写代码时建立连接，直接发送数据即可

不可靠传输：UDP可能出现网络丢包的问题，或是数据包乱序重复等问题

TCP协议

TCP协议叫做用户数据报协议，它的特点：有连接、可靠传输、面向字节流

可靠传输：指TCP不会出现上述UDP的网络丢包等问题

那么UDP是不可靠传输，而TCP是可靠传输，为什么我们还需要学UDP呢，直接学TCP就好了呀

其实很简单，TCP保证可靠性，就一定决定了它在数据通信的过程中，要为了保证可靠性，而设计更多的策略，各种制度机制，都要靠协议自己完成，往往更复杂，成本更高

而UDP只要将数据发出去，就不用管可不可靠的问题了，UDP更为简单，成本更低，TCP则更为安全，所以UDP/TCP是各有所长的

因此在应用场景中，除非场景非常适合UDP，那么我们都选择TCP协议

像直播、视频一类的使用UDP更好，例如在看直播时，突然人物卡顿一下，掉帧一下，都是因为使用的UDP，导致的丢包问题，但是并不会影响我们观看直播

网络字节序

假设两个主机通信，一个主机是大端存储，一个主机是小段存储，那么在通信时，肯定会发生错误，因为两个主机存储的方式都不一样，肯定无法正确的通信

所以计算机网络规定，所有网络数据，都必须是大端存储的

操作系统提供了4个接口，头文件是arpa/inet.h

uint32_t htonl(uint32_t hostlong) ;
uint16_t htons(uint16_t hostshort) ;
uint32_t ntohl(uint32_t netlong) ;
uint16_t ntohs(uint16_t netshort) ;

其中h表示host，表示本地；n表示network，表示网络；l表示long，4字节；s表示short，2字节

所以hton就表示主机转网络，即无论主机是什么序列都会转成大端

ntoh就表示网络转主机

常见套接字：

域间socket、原始socket、网络socket

其中网络socket是使用的最多

理论上，这三种套接字是三种应用场景，对应的应该是三套接口，而Linux为了使用更方便，不想设计过多的接口，而是使用同一套接口，如下所示：

创建 socket 文件描述符 (TCP/UDP, 客户端 + 服务器)
int socket(int domain, int type, int protocol);

绑定端口号 (TCP/UDP, 服务器)
int bind(int socket, const struct sockaddr *address, socklen_t address_len);

开始监听socket (TCP, 服务器)
int listen(int socket, int backlog);

接收请求 (TCP, 服务器)
int accept(int socket, struct sockaddr* address, socklen_t* address_len);

建立连接 (TCP, 客户端)
int connect(int sockfd, const struct sockaddr *addr, socklen_t addrlen);

通过观察可以发现，每一个接口都有一个共同的结构sockaddr

其中网络socket是sockaddr_in结构，它的前两个字节是AF_INET

域间socket是sockaddr_un结构，它的前两个字节是AF_UNIX

那么这个公共的结构sockaddr，前两个字节就可以用来辨别是网络socket还是域间socket，sockaddr就如同我们C语言中的void*的概念

udp套接字编程

udp相关代码实现

下面初步实现服务端与客户端链接，客户端发消息，服务端可以回复消息，如下所示：

下面是几个需要使用的函数接口：

sock函数

sock函数是计算机网络给我们提供的系统调用接口，对传输层做了文件系统级别封装的接口

socket函数需要包含头文件：sys/types.h和sys/socket.h

函数返回值：返回一个文件描述符，返回-1就表示失败，errno就表明出错的原因

函数参数：

第一个参数domain：一般表示套接字的域，有AF_INET(网络通信)、AF_UNIX(本地通信)等等

第二个参数type：type表示类型，代表你想创建这个套接字的通信种类是什么，一般填的是SOCK_DGRAM，表示用户数据报套接字

第三个参数protocol：protocol表示协议，一般前两个参数确定了，协议也就确定了，所以一般是0

使用示例如下：

bind函数

bind函数：将用户设置的ip和port在内核中和我们当前的进程强关联

bind函数需要包含头文件：sys/types.h和sys/socket.h

函数返回值：成功返回0，否则返回-1，errno就表明出错的原因

函数参数：

第一个参数sockfd：是刚刚创建的套接字，需要将ip和port与套接字关联起来

第二个参数addr：上面提到了填充ip和port信息的结构体

第三个参数addrlen：是addr的大小，用sizeof就能计算出来

使用示例如下：

因为bind接口的第二个参数类型是struct sockaddr*的，而我们创建的local的类型是struct sockaddr_in的，所以需要强转一下

recvfrom函数

recvfrom函数是读取数据的函数

函数返回值：ssize_t是有符号整数，失败会返回-1

函数参数：

第一个参数：表示刚刚创建成功的套接字

第二/三个参数：表示一段缓冲区，len表示大小

第四个参数：表示读取的方式，默认为0，表示以阻塞方式读取

第五/六个参数：表示两个输出型参数，需要我们传入特定的结构体，及特定结构体的其他信息，方便我们把客户端的IP和端口提上来，服务器就能够知道是谁发的消息，进而把消息再转发回去

除了拿到数据，我们也想知道是谁给我发的消息，即得到src_ip(源IP)，src_port(源端口号)，即客户端的IP和端口号，当client发送给server时，server就需要得到client_ip和client_port

使用示例如下：

sendto函数

sendto函数是返回消息的接口

第一个参数：表示创建的套接字

第二/三个参数：表示要发送的数据buf缓冲区，和它的长度len

第三个参数：flag默认设置为0

第四/五个参数：表示需要把缓冲区发给谁，长度是多少

使用示例如下：

关于127.0.0.1，这个IP地址称为本地环回，client和server发送数据只在本地协议栈中进行数据流动，不会吧我们的数据发送到网络中

通常用于本地网络服务器的测试，如果在127.0.0.1这里测试通过了，即客户端发消息，server能收到，那如果联通网络，再进行测试时，发现联不通，这时的问题大概率就是网络的问题

在云服务器中：

云服务器无法bind公网IP，也不建议bind公网IP

对于server来讲，我们也不推荐bind确定的IP

推荐使用任意IP的方案，如下

所以服务器服务端，写IP地址填充的时候，都是INADDR_ANY，当然如果未来有特殊需求，也可以在构造函数中给指定的IP，这样就bind指定的IP了

代码如下：

makefile：

.PHONY:all
all:udp_client udp_serverudp_client:udp_client.ccg++ -o $@ $^ -std=c++11
udp_server:udp_server.ccg++ -o $@ $^ -std=c++11.PHONY:clean
clean:rm -f udp_client udp_server

udp_client.cc：

#include <iostream>
#include <cstdio>
#include <cstring>
#include <string>
#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>static void usage(std::string proc)
{std::cout << "\nUsage: " << proc << " ServerIp ServerPort\n" << std::endl;
}int main(int argc, char* argv[])
{if(argc != 3){usage(argv[0]);exit(1);}//创建客户端套接字int sock = socket(AF_INET, SOCK_DGRAM, 0);if(sock < 0){std::cerr << "socket error" << std::endl;exit(2);}//   client当然也需要bind//但是一般client不会显示bind，即程序员不需要自己bind//client是一个客户端，是被普通人下载安装使用的//如果程序员自己bind了，client就bind了一个固定的port//万一其他客户端提前占用了这个port，该client就不会启动了//client一般不需要显示的bind指定port，而是让0S自动随机选择std::string message;        struct sockaddr_in server;memset(&server,0,sizeof(server));//初始化为0server.sin_family = AF_INET;server.sin_port = htons(atoi(argv[2]));//inet_addr将点分十进制字符串转为4字节，再将4字节主机序列->网络序列server.sin_addr.s_addr = inet_addr(argv[1]);char buffer[1024];while(true){std::cout << "请输入你的信息# ";std::getline(std::cin, message);if(message == "quit")break;//当client首次发送消息给服务器的时候，OS会自动给client bind他自己的IP和portsendto(sock,message.c_str(),message.size(),0,(struct sockaddr*)&server,sizeof(server));//读数据struct sockaddr_in temp;socklen_t len = sizeof(temp);ssize_t s = recvfrom(sock, buffer, sizeof(buffer), 0, (struct sockaddr*)&temp, &len);if(s > 0){buffer[s] = 0;std::cout << "server echo# " << buffer << std::endl;}}   close(sock);//关闭套接字return 0;
}

udp_server.hpp：

#ifndef _UDP_SERVER_HPP
#define _UDP_SERVER_HPP#include "log.hpp"
#include <iostream>
#include <string>
#include <cstdio>
#include <memory>
#include <cstring>
#include <strings.h>
#include <cerrno>
#include <cstdlib>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <unistd.h>#define SIZE 1024class UdpServer
{
public:UdpServer(uint16_t port, std::string ip=""):_port(port),_ip(ip),_sock(-1){}//初始化服务器bool initServer(){//从这里开始，就是新的系统调用，来完成网络功能// 1.创建套接字_sock = socket(AF_INET, SOCK_DGRAM, 0);if(_sock < 0)//_sock < 0表示创建套接字失败{//strerror将错误码转化为错误码描述logMessage(FATAL,"%d:%s", errno, strerror(errno));exit(2);}// 2. bind:将用户设置的ip和port在内核中和我们当前的进程强关联//sockaddr_in是结构体封装的整数struct sockaddr_in local;//结构体需要进行清0，使用bzero函数bzero(&local, sizeof(local));   //上面传入的参数是AF_INET，这里的sin_family也就是AF_INETlocal.sin_family = AF_INET; //服务器的IP和端口未来也是要发送给对方主机的->先要将数据发送到网络//所以需要将_port主机转网络local.sin_port = htons(_port);//1.同上，先要将点分十进制字符串风格的IP地址-> 4字节//2. 4字节主机序列->网络序列//有一套接口inet_addr，可以一次帮我们做完上述这两件事情//宏INADDR_ANY就是0，让服务器在工作过程中，可以从任意IP中获取数据local.sin_addr.s_addr = _ip.empty() ? INADDR_ANY : inet_addr(_ip.c_str());//绑定if(bind(_sock,(struct sockaddr*)&local, sizeof(local)) < 0){logMessage(FATAL,"%d:%s", errno, strerror(errno));exit(2);}   logMessage(NORMAL, "init udp server done %s", strerror(errno));//初始化结束return true;}//启动服务器void Start(){//作为一款网络服务器，永远不退出的//服务器启动->常驻进程->永远在内存中存在，除非挂了，所以要小心内存泄漏的问题//echo server: client给我们发送消息，我们原封不动返回即可//创建缓冲区char buffer[SIZE];for( ; ; ){//倒数第二个参数peer是纯输出型参数            struct sockaddr_in peer;bzero(&peer,sizeof(peer));//最后一个参数，既可以输入又可以输出//输入时：peer缓冲区的大小//输出时：实际读到的的peersocklen_t len = sizeof(peer);//start : 读取数据ssize_t s = recvfrom(_sock, buffer, sizeof(buffer)-1, 0, (struct sockaddr*)&peer, &len);//s>0表示读取数据成功if(s > 0){buffer[s] = 0;//我们目前数据当做字符串// 1.输出发送的信息 2. 知道是谁发送的 //从网络中来，所以需要网络转主机，即ntohuint16_t cli_port = ntohs(peer.sin_port);//4字节的网络序列的IP -> 本主机的点分十进制风格的IP,使用inet_ntoa函数std::string cli_ip = inet_ntoa(peer.sin_addr);printf("[%s:%d]# %s\n", cli_ip.c_str(), cli_port, buffer);}//分析和处理数据//end : 写回数据sendto(_sock, buffer, strlen(buffer), 0, (struct sockaddr*)&peer, len);}}~UdpServer(){if(_sock >= 0)close(_sock);//关闭套接字}
private://一个服务器，一般必须需要ip地址和port(16位的整数)uint16_t _port;std::string _ip;    int _sock;//通信的套接字
};#endif

udp_server.cc：

#include "udp_server.hpp"
#include <memory>
#include <cstdlib>static void usage(std::string proc)
{std::cout << "\nUsage:" << proc << " port\n" << std::endl;
}// ./udp_server port
//命令行参数，argc是2
//argv[0]/[1]分别是./udp_server/port
int main(int argc, char* argv[])
{if(argc != 2){usage(argv[0]);exit(1);}//std::string ip = argv[1];uint16_t port = atoi(argv[1]);std::unique_ptr<UdpServer> svr(new UdpServer(port));//初始化服务器、启动服务器svr->initServer();svr->Start();return 0;
}

以及使用的以前实现的log.hpp：

#pragma once#include <iostream>
#include <cstdio>
#include <cstdarg>
#include <string>
#include <ctime>//日志等级
#define DEBUG   0
#define NORMAL  1
#define WARNING 2
#define ERROR   3
#define FATAL   4//日志等级的映射表
const char* gLevelMap[]={"DEBUG","NORMAL","WARNING","ERROR","FATAL"
};//日志功能至少：日志等级 时间；支持用户自定义(日志内容等等)
//format是输出格式例如%s之类的
void logMessage(int level, const char* format, ...)
{
//条件编译，如果定义了DEBUG_SHOW这个宏，在打印时就正常打印
//如果没有定义这个DEBUG_SHOW宏，所以level是DEBUG的语句就不再打印了
//我们可以在makefile命令行中定义宏，加上-D选项即可
#ifndef DEBUG_SHOWif(level == DEBUG) return;
#endif//                                        vprintf/vfprintf/vsprintf/ vsnprintf//是把传入的参数按照可变的方式分别进行显示到 显示器 /  文件  / 字符串 /指定长度的字符串//stdBuffer是日志的标准部分，如日志等级 时间//logBuffer是日志的自定义部分，如日志内容等char stdBuffer[1024];char logBuffer[1024];//这里的时间采用较为简单的时间戳表示time_t tm = time(nullptr);snprintf(stdBuffer, sizeof stdBuffer, "[%s] [%ld]", gLevelMap[level], tm);va_list args;va_start(args, format);vsnprintf(logBuffer,sizeof logBuffer, format, args);va_end(args);//拼接两个字符串的内容，一块打印出来printf("%s %s\n", stdBuffer, logBuffer);
}

udp执行指令代码

如果是上面的聊天，发送的就是文本，如果是指令例如ls -a -l，我们想把命令执行完，把执行的结果再返回，下面实现远程实现命令的功能：

popen函数

popen可以执行传入的command指令，先建立pipe管道，然后再fork()，子进程执行(exec*，即exec系列的接口)command的命令，

返回值FILE *:可以将执行结果通过FILE*指针进行读取

此功能实现，仅仅改变了udp_server.hpp，其他文件没有变化：

#ifndef _UDP_SERVER_HPP
#define _UDP_SERVER_HPP#include "log.hpp"
#include <iostream>
#include <string>
#include <cstdio>
#include <memory>
#include <cstring>
#include <strings.h>
#include <cerrno>
#include <cstdlib>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <unistd.h>#define SIZE 1024class UdpServer
{
public:UdpServer(uint16_t port, std::string ip=""):_port(port),_ip(ip),_sock(-1){}//初始化服务器bool initServer(){//从这里开始，就是新的系统调用，来完成网络功能// 1.创建套接字_sock = socket(AF_INET, SOCK_DGRAM, 0);if(_sock < 0)//_sock < 0表示创建套接字失败{//strerror将错误码转化为错误码描述logMessage(FATAL,"%d:%s", errno, strerror(errno));exit(2);}// 2. bind:将用户设置的ip和port在内核中和我们当前的进程强关联//sockaddr_in是结构体封装的整数struct sockaddr_in local;//结构体需要进行清0，使用bzero函数bzero(&local, sizeof(local));   //上面传入的参数是AF_INET，这里的sin_family也就是AF_INETlocal.sin_family = AF_INET; //服务器的IP和端口未来也是要发送给对方主机的->先要将数据发送到网络//所以需要将_port主机转网络local.sin_port = htons(_port);//1.同上，先要将点分十进制字符串风格的IP地址-> 4字节//2. 4字节主机序列->网络序列//有一套接口inet_addr，可以一次帮我们做完上述这两件事情//宏INADDR_ANY就是0，让服务器在工作过程中，可以从任意IP中获取数据local.sin_addr.s_addr = _ip.empty() ? INADDR_ANY : inet_addr(_ip.c_str());//绑定if(bind(_sock,(struct sockaddr*)&local, sizeof(local)) < 0){logMessage(FATAL,"%d:%s", errno, strerror(errno));exit(2);}   logMessage(NORMAL, "init udp server done %s", strerror(errno));//初始化结束return true;}//启动服务器void Start(){//作为一款网络服务器，永远不退出的//服务器启动->常驻进程->永远在内存中存在，除非挂了，所以要小心内存泄漏的问题//echo server: client给我们发送消息，我们原封不动返回即可//创建缓冲区char buffer[SIZE];for( ; ; ){//倒数第二个参数peer是纯输出型参数            struct sockaddr_in peer;bzero(&peer,sizeof(peer));//最后一个参数，既可以输入又可以输出//输入时：peer缓冲区的大小//输出时：实际读到的的peersocklen_t len = sizeof(peer);char result[256];//将fgets读到的都放到result中std::string cmd_echo;//start : 读取数据ssize_t s = recvfrom(_sock, buffer, sizeof(buffer)-1, 0, (struct sockaddr*)&peer, &len);//s>0表示读取数据成功if(s > 0){buffer[s] = 0;//我们目前数据当做字符串//判断命令中不能有rm相关的指令if(strcasestr(buffer,"rm") != nullptr || strcasestr(buffer,"rmdir") != nullptr){std::string err_message = "非法请求: ";std::cout << err_message << buffer << std::endl;sendto(_sock, err_message.c_str(), err_message.size(), 0, (struct sockaddr*)&peer, len);continue;}FILE* fp = popen(buffer, "r");if(fp == nullptr){logMessage(ERROR,"%d:%s", errno, strerror(errno));continue;}while(fgets(result, sizeof(result), fp) != nullptr)//读取成功{cmd_echo += result;}fclose(fp);}//分析和处理数据//end : 写回数据//sendto(_sock, buffer, strlen(buffer), 0, (struct sockaddr*)&peer, len);sendto(_sock, cmd_echo.c_str(), cmd_echo.size(), 0, (struct sockaddr*)&peer, len);}}~UdpServer(){if(_sock >= 0)close(_sock);//关闭套接字}
private://一个服务器，一般必须需要ip地址和port(16位的整数)uint16_t _port;std::string _ip;    int _sock;//通信的套接字
};#endif

udp多线程版收发消息

下面再加以改进，把所有访问当前服务器的人都记录下来，每次一个客户端发消息，另一个客户端能够收到别的客户端发送的消息

下面演示效果：有两个客户端使用mkfifo创建命名管道，分别是clientA和clientB，每一个客户端都设立两个窗口，一个窗口发数据，将收到的数据输出重定向到管道中，另一个窗口使用cat从管道读出来：

上述是4个窗口，上面两个是clientA的，下面两个是clientB的，左边的窗口发送数据，右边的窗口接收数据，并且可以根据端口号看出来是谁发的消息，例如端口号为32795的就是clientA，而端口号为44280的就是clientB

下面是服务端：

最开始运行./udp_server 8080后，直到clientA发送数据后，服务端就会打印init，key，add这三条语句，并且每当其中一个客户端发送数据，服务端都会将这条数据发送给每一个客户端，两个push语句就能够很好地体现这一点

下面是相关代码：

makefile的udp_client后面需要加-lpthread，因为要使用pthread库

并且这里引用了前面曾经实现过的thread.hpp

udp_server.hpp：

#ifndef _UDP_SERVER_HPP
#define _UDP_SERVER_HPP#include "log.hpp"
#include <iostream>
#include <string>
#include <unordered_map>
#include <cstdio>
#include <memory>
#include <cstring>
#include <strings.h>
#include <cerrno>
#include <cstdlib>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <unistd.h>#define SIZE 1024class UdpServer
{
public:UdpServer(uint16_t port, std::string ip=""):_port(port),_ip(ip),_sock(-1){}//初始化服务器bool initServer(){//从这里开始，就是新的系统调用，来完成网络功能// 1.创建套接字_sock = socket(AF_INET, SOCK_DGRAM, 0);if(_sock < 0)//_sock < 0表示创建套接字失败{//strerror将错误码转化为错误码描述logMessage(FATAL,"%d:%s", errno, strerror(errno));exit(2);}// 2. bind:将用户设置的ip和port在内核中和我们当前的进程强关联//sockaddr_in是结构体封装的整数struct sockaddr_in local;//结构体需要进行清0，使用bzero函数bzero(&local, sizeof(local));   //上面传入的参数是AF_INET，这里的sin_family也就是AF_INETlocal.sin_family = AF_INET; //服务器的IP和端口未来也是要发送给对方主机的->先要将数据发送到网络//所以需要将_port主机转网络local.sin_port = htons(_port);//1.同上，先要将点分十进制字符串风格的IP地址-> 4字节//2. 4字节主机序列->网络序列//有一套接口inet_addr，可以一次帮我们做完上述这两件事情//宏INADDR_ANY就是0，让服务器在工作过程中，可以从任意IP中获取数据local.sin_addr.s_addr = _ip.empty() ? INADDR_ANY : inet_addr(_ip.c_str());//绑定if(bind(_sock,(struct sockaddr*)&local, sizeof(local)) < 0){logMessage(FATAL,"%d:%s", errno, strerror(errno));exit(2);}   logMessage(NORMAL, "init udp server done %s", strerror(errno));//初始化结束return true;}//启动服务器void Start(){//作为一款网络服务器，永远不退出的//服务器启动->常驻进程->永远在内存中存在，除非挂了，所以要小心内存泄漏的问题//echo server: client给我们发送消息，我们原封不动返回即可//创建缓冲区char buffer[SIZE];for( ; ; ){//倒数第二个参数peer是纯输出型参数            struct sockaddr_in peer;bzero(&peer,sizeof(peer));//最后一个参数，既可以输入又可以输出//输入时：peer缓冲区的大小//输出时：实际读到的的peersocklen_t len = sizeof(peer);char key[64];char result[256];//将fgets读到的都放到result中std::string cmd_echo;//start : 读取数据ssize_t s = recvfrom(_sock, buffer, sizeof(buffer)-1, 0, (struct sockaddr*)&peer, &len);//s>0表示读取数据成功if(s > 0){buffer[s] = 0;//我们目前数据当做字符串//提取ip和portuint16_t cli_port = ntohs(peer.sin_port);//4字节的网络序列的IP -> 本主机的点分十进制风格的IP,使用inet_ntoa函数std::string cli_ip = inet_ntoa(peer.sin_addr);snprintf(key,sizeof(key),"%s-%u",cli_ip.c_str(),cli_port);logMessage(NORMAL, "key:%s", key);auto it = _users.find(key);//查找keyif(it == _users.end()){logMessage(NORMAL,"add new user : %s", key);//说明用户不存在_users.insert({key,peer});}}//分析和处理数据//end : 写回数据//sendto(_sock, buffer, strlen(buffer), 0, (struct sockaddr*)&peer, len);for(auto& iter : _users){std::string sendMessage = key;sendMessage += "# ";sendMessage += buffer;//因为直接发送消息，并不知道是谁发的消息，所以在消息前加上发送消息的 “IP+port#” logMessage(NORMAL,"push message to %s", iter.first.c_str());sendto(_sock, sendMessage.c_str(), sendMessage.size(), 0, (struct sockaddr*)&(iter.second), sizeof(iter.second));}}}~UdpServer(){if(_sock >= 0)close(_sock);//关闭套接字}
private://一个服务器，一般必须需要ip地址和port(16位的整数)uint16_t _port;std::string _ip;    int _sock;//通信的套接字std::unordered_map<std::string, struct sockaddr_in> _users;
};#endif

udp_server.cc：

#include "udp_server.hpp"
#include <memory>
#include <cstdlib>static void usage(std::string proc)
{std::cout << "\nUsage:" << proc << " port\n" << std::endl;
}// ./udp_server port
//命令行参数，argc是2
//argv[0]/[1]分别是./udp_server/port
int main(int argc, char* argv[])
{if(argc != 2){usage(argv[0]);exit(1);}//std::string ip = argv[1];uint16_t port = atoi(argv[1]);std::unique_ptr<UdpServer> svr(new UdpServer(port));//初始化服务器、启动服务器svr->initServer();svr->Start();return 0;
}

udP_client.cc：

#include <iostream>
#include <cstdio>
#include <cstring>
#include <string>
#include <memory>
#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <pthread.h>
#include "thread.hpp"//我们发现:无论是多线程读还是写，用的sock都是一个，sock代表就是文件，UDP是全双工的->可以同时进行收发而不受干扰uint16_t serverport = 0;
std::string serverip;static void usage(std::string proc)
{std::cout << "\nUsage: " << proc << " ServerIp ServerPort\n"<< std::endl;
}// 发送方
static void *udpSend(void *args)
{// 拿到sock和线程名nameint sock = *(int *)((ThreadData *)args)->args_;std::string name = ((ThreadData *)args)->name_;std::string message;struct sockaddr_in server;memset(&server, 0, sizeof(server)); // 初始化为0server.sin_family = AF_INET;server.sin_port = htons(serverport);// inet_addr将点分十进制字符串转为4字节，再将4字节主机序列->网络序列server.sin_addr.s_addr = inet_addr(serverip.c_str());// 不断的给对方发送数据while (true){std::cerr << "请输入你的信息# "; //cerr标准错误，向文件描述符2打印std::getline(std::cin, message);if (message == "quit")break;// 当client首次发送消息给服务器的时候，OS会自动给client bind他自己的IP和portsendto(sock, message.c_str(), message.size(), 0, (struct sockaddr *)&server, sizeof(server));}return nullptr;
}//收消息 
static void *udpRecv(void *args)
{int sock = *(int *)((ThreadData *)args)->args_;std::string name = ((ThreadData *)args)->name_;char buffer[1024];while (true){memset(buffer, 0, sizeof(buffer));// 读数据struct sockaddr_in temp;socklen_t len = sizeof(temp);ssize_t s = recvfrom(sock, buffer, sizeof(buffer), 0, (struct sockaddr *)&temp, &len);if (s > 0){buffer[s] = 0;std::cout << buffer << std::endl;}}
}int main(int argc, char *argv[])
{if (argc != 3){usage(argv[0]);exit(1);}// 创建客户端套接字int sock = socket(AF_INET, SOCK_DGRAM, 0);if (sock < 0){std::cerr << "socket error" << std::endl;exit(2);}serverport = atoi(argv[2]);serverip = argv[1];// 两个线程，一个发送数据，一个接收数据std::unique_ptr<Thread> sender(new Thread(1, udpSend, (void *)&sock));std::unique_ptr<Thread> recver(new Thread(1, udpRecv, (void *)&sock));sender->start();recver->start();sender->join();recver->join();close(sock); // 关闭套接字//   client当然也需要bind// 但是一般client不会显示bind，即程序员不需要自己bind// client是一个客户端，是被普通人下载安装使用的// 如果程序员自己bind了，client就bind了一个固定的port// 万一其他客户端提前占用了这个port，该client就不会启动了// client一般不需要显示的bind指定port，而是让0S自动随机选择// std::string message;// struct sockaddr_in server;// memset(&server,0,sizeof(server));//初始化为0// server.sin_family = AF_INET;// server.sin_port = htons(atoi(argv[2]));// //inet_addr将点分十进制字符串转为4字节，再将4字节主机序列->网络序列// server.sin_addr.s_addr = inet_addr(argv[1]);// char buffer[1024];// while(true)// {//     //多线程//     std::cout << "请输入你的信息# ";//     std::getline(std::cin, message);//     if(message == "quit")//         break;//     //当client首次发送消息给服务器的时候，OS会自动给client bind他自己的IP和port//     sendto(sock,message.c_str(),message.size(),0,(struct sockaddr*)&server,sizeof(server));//     //读数据//     struct sockaddr_in temp;//     socklen_t len = sizeof(temp);//     ssize_t s = recvfrom(sock, buffer, sizeof(buffer), 0, (struct sockaddr*)&temp, &len);//     if(s > 0)//     {//         buffer[s] = 0;//         std::cout << "server echo# " << buffer << std::endl;//     }// }return 0;
}

thread.hpp：

#pragma once#include <iostream>
#include <unistd.h>
#include <vector>
#include <pthread.h>
#include <queue>
#include <string>
#include <cstdio>typedef void*(*func_t)(void*); //设置ThreadData是为了未来创建线程的时候，把名字也传进去
class ThreadData
{
public:void* args_;std::string name_;
};class Thread
{
public:Thread(int num, func_t callback, void* args):func_(callback){//构造函数中初始化name_char namebuffer[64];snprintf(namebuffer, sizeof namebuffer, "thread->%d", num);name_ = namebuffer;tdata_.args_ = args;tdata_.name_ = name_;}//创建线程void start(){pthread_create(&tid_, nullptr, func_, (void*)&tdata_);}//线程等待void join(){pthread_join(tid_, nullptr);}std::string name(){return name_;}~Thread(){}
private:std::string name_;func_t func_;ThreadData tdata_;pthread_t tid_;
};

tcp套接字编程

tcp套接字代码

tcp同样，需要socket先创建套接字：

与udp一样，第一个参数需要传AF_INET，因为是网络通信

第二个参数就与udp不同了，传入的是SOCK_STREAM，代表套接字类型是stream

第三个参数同样默认为0

listen函数

因为TCP是面向连接的，当我们正式通信的时候，需要先建立连接，所以就需要用到listen，阿金套接字状态设置为监听状态

函数参数：

第一个参数就是创建好的套接字

第二个参数叫做全链接队列长度

返回值：

成功返回0，失败返回-1，错误码被设置

此时执行完listen函数后，在一个窗口执行./tcp_server 8080后，另一个窗口使用netstat -antp，可以观察到./tcp_server的状态是LISTEN，表示此时的服务器已经运行，且处于监听状态

accept函数

accept函数用于获取新连接

函数参数：

第一个参数：是创建好的套接字

第二/三个参数：addr是输出型参数，addrlen是输入输出型参数，在recvfrom中使用方式一样，详细见上面的recvfrom函数

返回值：

成功的话返回一个合法的整数套接字，失败返回-1，错误码被设置

read/write函数

在udp中，读取数据使用的是recvfrom函数，而tcp中不使用这个函数，读使用read，写使用write

这里的read和write在读写文件时使用过，网络这里也可以直接使用（也可以使用后面的recv/send函数）

read：

使用方式如下：

注意这里的sizeof(buffer)-1，是将buffer后面的\0减掉了

write：

使用方式如下：

注意这里的strlen算的是buffer里的字符数量，没有减去\0

connect函数

connect是进行连接的函数，connect函数会自动绑定当前客户端的IP和端口，能够进行后续通信

函数参数：

第一个参数：套接字

第二/三个参数：代表想要连接谁，和sendto的后两个参数一样

返回值：

成功返回0，失败返回-1，错误码被设置

recv/send函数

send函数也是基于tcp向目标服务器发送消息的

它的前三个参数和write一样，最后一个flag参数默认设为0即可

同样和recvfrom的前三个参数一样，最后一个flag参数默认设为0即可

最终可以通过改变tcp_server.hpp中的原始的server函数，从而实现不同的功能，下面实现了通信、大小写转换、英汉互译等功能，以大小写转换为例，示范：

用户端：

服务端：

代码如下：

Threadpool中的Task.hpp改变如下：

#pragma once#include "log.hpp"
#include <iostream>
#include <functional>
#include <string>// typedef function<void(int, const std::string&, const uint16_t&)> fun_t;
using fun_t = function<void(int, const std::string&, const uint16_t&, const std::string&)>;class Task
{
public:Task(){}Task(int sock,const std::string ip,uint16_t port,fun_t func):_sock(sock),_ip(ip),_port(port),_func(func){}//仿函数void operator()(const std::string& name){_func(_sock, _ip, _port, name);}
public:int _sock;      //套接字std::string _ip;//ipuint16_t _port; //端口fun_t _func;    
};

makefile：

.PHONY:all
all:tcp_client tcp_servertcp_client:tcp_client.ccg++ -o $@ $^ -std=c++11
tcp_server:tcp_server.ccg++ -o $@ $^ -std=c++11 -lpthread.PHONY:clean
clean:rm -f tcp_client tcp_server

tcp_client.cc：

#include <iostream>
#include <string>
#include <cstdio>
#include <cstring>
#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>static void usage(std::string proc)
{std::cout << "\nUsage: " << proc << " serverIp serverPort\n"<< std::endl;
}//./tcp_client serverip serverport
int main(int argc, char *argv[])
{if (argc != 3){usage(argv[0]);exit(1);}std::string serverip = argv[1];uint16_t serverport = atoi(argv[2]);bool alive = false;int sock = 0;std::string line;while (true){//alive为false，表示需要创建套接字if (!alive){// 创建套接字sock = socket(AF_INET, SOCK_STREAM, 0);if (sock < 0) // 创建套接字失败{std::cerr << "socket error" << std::endl;exit(2);}// client不需要手动bind，需要OS自动进行选择// client需要连接别人的能力struct sockaddr_in server;memset(&server, 0, sizeof(server)); // 置空server.sin_family = AF_INET;server.sin_port = htons(serverport);server.sin_addr.s_addr = inet_addr(serverip.c_str());// connec进行连接if (connect(sock, (struct sockaddr *)&server, sizeof(server)) < 0){std::cerr << "connect error" << std::endl;exit(3);}// 连接成功std::cout << "connect success" << std::endl;alive = true;}std::cout << "请输入# ";std::getline(std::cin, line);if (line == "quit")break;ssize_t ret = send(sock, line.c_str(), line.size(), 0);//如果发送成功if (ret > 0){char buffer[1024];ssize_t s = recv(sock, buffer, sizeof(buffer) - 1, 0);if (s > 0){// 读取成功buffer[s] = 0; // 当做字符串处理std::cout << "server 回显# " << buffer << std::endl;}else if (s == 0){alive = false;close(sock);}}//发送失败else{alive = false;close(sock);}// else if (s == 0)// {//     break;// }// else// {//     break;// }}return 0;
}

tcp_server.cc：

#include "tcp_server.hpp"
#include <memory>static void usage(std::string proc)
{std::cout << "\nUsage: " << proc << " port\n" << std::endl;
}//./tcp_server port
int main(int argc, char* argv[])
{if(argc != 2){usage(argv[0]);exit(1);}uint16_t port = atoi(argv[1]);std::unique_ptr<TcpServer> svr(new TcpServer(port));svr->initServer();svr->Start();return 0;
}

tcp_server.hpp：

#pragma once#include <iostream>
#include <string>
#include <cstring>
#include <unistd.h>
#include <cassert>
#include <unordered_map>
#include <memory>
#include <signal.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <sys/wait.h>
#include <pthread.h>
#include <ctype.h>
#include "threadpool/log.hpp"
#include "threadpool/lockGuard.hpp"
#include "threadpool/Task.hpp"
#include "threadpool/threadPool.hpp"
#include "threadpool/thread.hpp"// static void service(int sock, const std::string& clientip, const uint16_t& clientport)
// {
//     //echo server
//     char buffer[1024];
//     while(true)
//     {
//         //read && write可以直接使用
//         ssize_t s = read(sock, buffer, sizeof(buffer)-1);//         //read成功
//         if(s > 0)
//         {
//             buffer[s] = 0;//将发过来的数据当做字符串
//             std::cout << clientip << ":" << clientport << "#" << buffer << std::endl;
//         }
//         else if(s == 0) //对端关闭连接
//         {
//             logMessage(NORMAL, "%s:%d shutdown, me too", clientip.c_str(), clientport);
//             break;
//         }
//         else
//         {
//             logMessage(ERROR, "read socket error, %d:%s", errno, strerror(errno));
//             break;
//         }
//         write(sock, buffer, strlen(buffer));
//     }
//     close(sock);
// }static void service(int sock, const std::string &clientip, const uint16_t &clientport, const std::string &thread_name)
{// echo server// 所以，我们一般服务器进程业务处理，如果是从连上，到断开，要一直保持这个链接，长连接//char buffer[1024];while (true){// read && write可以直接使用ssize_t s = read(sock, buffer, sizeof(buffer) - 1);// read成功if (s > 0){buffer[s] = 0; // 将发过来的数据当做字符串std::cout << thread_name << "|" << clientip << ":" << clientport << "#" << buffer << std::endl;}else if (s == 0) // 对端关闭连接{logMessage(NORMAL, "%s:%d shutdown, me too", clientip.c_str(), clientport);break;}else{logMessage(ERROR, "read socket error, %d:%s", errno, strerror(errno));break;}write(sock, buffer, strlen(buffer));}close(sock);
}// 改为大小写转换的方法
static void change(int sock, const std::string &clientip, const uint16_t &clientport, const std::string &thread_name)
{// echo server// 所以，我们一般服务器进程业务处理，如果是从连上，到断开，要一直保持这个链接，长连接//char buffer[1024];// read && write可以直接使用ssize_t s = read(sock, buffer, sizeof(buffer) - 1);// read成功if (s > 0){buffer[s] = 0; // 将发过来的数据当做字符串std::cout << thread_name << "|" << clientip << ":" << clientport << "#" << buffer << std::endl;std::string message;char* start = buffer;while(*start){char c;if(islower(*start)) c = toupper(*start);else c = *start;message.push_back(c);start++;}write(sock, message.c_str(), message.size());}else if (s == 0) // 对端关闭连接{logMessage(NORMAL, "%s:%d shutdown, me too", clientip.c_str(), clientport);}else{logMessage(ERROR, "read socket error, %d:%s", errno, strerror(errno));}close(sock);
}// 改为英汉互译的方法
static void dictOnline(int sock, const std::string &clientip, const uint16_t &clientport, const std::string &thread_name)
{// echo server// 所以，我们一般服务器进程业务处理，如果是从连上，到断开，要一直保持这个链接，长连接char buffer[1024];static std::unordered_map<std::string, std::string> dict = {{"apple","苹果"},{"pencil","铅笔"},{"bus","公交车"},{"ruler","尺子"}};// read && write可以直接使用ssize_t s = read(sock, buffer, sizeof(buffer) - 1);// read成功if (s > 0){buffer[s] = 0; // 将发过来的数据当做字符串std::cout << thread_name << "|" << clientip << ":" << clientport << "#" << buffer << std::endl;std::string message;auto iter = dict.find(buffer);if(iter == dict.end())message = "我不知道";elsemessage = iter->second;write(sock, message.c_str(), message.size());}else if (s == 0) // 对端关闭连接{logMessage(NORMAL, "%s:%d shutdown, me too", clientip.c_str(), clientport);}else{logMessage(ERROR, "read socket error, %d:%s", errno, strerror(errno));}close(sock);
}// class ThreadDate
// {
// public:
//     int _sock;
//     std::string _ip;
//     uint16_t _port;
// };class TcpServer
{
private:const static int gbacklog = 20; // 一般不能太大，也不能太小，后面在进行详细解释// 类内会有默认参数this，不符合回调函数的参数类型，所以设置为static的//  static void* threadRoutine(void* args)//  {//      //线程分离，设置分离状态后主线程就不需要再join线程了，线程退出时，自动释放线程资源//      pthread_detach(pthread_self());//      ThreadDate* td = static_cast<ThreadDate*>(args);//      service(td->_sock, td->_ip, td->_port);//      delete td;//     return nullptr;// }
public:TcpServer(uint16_t port, std::string ip = ""): _port(port), _ip(ip), _listensock(-1), _threadpool_ptr(ThreadPool<Task>::getThreadPool()){}void initServer(){// 1. socket创建套接字 进程 + 文件_listensock = socket(AF_INET, SOCK_STREAM, 0);if (socket < 0){logMessage(FATAL, "create socket error,%d:%s", errno, strerror(errno));exit(2);}// 文件描述符012默认打开，所以再创建就是3logMessage(NORMAL, "create socket success, _listensock: %d", _listensock);// 2. bind  文件 + 网络struct sockaddr_in local;memset(&local, 0, sizeof(local));local.sin_family = AF_INET;local.sin_port = htons(_port);local.sin_addr.s_addr = _ip.empty() ? INADDR_ANY : inet_addr(_ip.c_str());// binf失败if (bind(_listensock, (struct sockaddr *)&local, sizeof(local)) < 0){logMessage(FATAL, "bind error,%d:%s", errno, strerror(errno));exit(3);}// 3.因为TCP是面向连接的，当我们正式通信的时候，需要先建立连接if (listen(_listensock, gbacklog) < 0){// 创建失败logMessage(FATAL, "listen error,%d:%s", errno, strerror(errno));exit(4);}logMessage(NORMAL, "init server success");}void Start(){_threadpool_ptr->run(); // 运行线程池// signal(SIGCHLD, SIG_IGN);//忽略SIG_CHLD信号，子进程退出时会自动释放自己的僵尸状态// 服务器需要周而复始的运行，所以while(true)while (true){// 获取连接struct sockaddr_in src;socklen_t len = sizeof(src);// serversock和_listensock都是套接字，区别如下：// serversock(未来进行网络通信服务) vs _listensock(只是获取新连接)int serversock = accept(_listensock, (struct sockaddr *)&src, &len);if (serversock < 0){// 获取连接失败，continue继续获取连接logMessage(ERROR, "accept error,%d : %s", errno, strerror(errno));continue;}// 获取连接成功uint16_t client_port = ntohs(src.sin_port);std::string client_ip = inet_ntoa(src.sin_addr);logMessage(NORMAL, "link success, serversock: %d | %s : %d | \n",serversock, client_ip.c_str(), client_port);// version 4 -- 线程池版本// Task t(serversock, client_ip, client_port, service);// Task t(serversock, client_ip, client_port, change);Task t(serversock, client_ip, client_port, dictOnline);_threadpool_ptr->pushTask(t);// //version 3 -- 多线程版本// ThreadDate* td = new ThreadDate();// td->_ip = client_ip;// td->_port = client_port;// td->_sock = serversock; // pthread_t tid;// pthread_create(&tid, nullptr, threadRoutine, td);// close(serversock)// version 2.1 -- 多进程版本 -- 创建子进程(不使用signal)//  pid_t id = fork();//  assert(id != -1);//  if(id == 0)//  {//      //子进程//      close(_listensock);//      if(fork() > 0)//          exit(0);//子进程本身直接退出//      //下面的是孙子进程，孤儿进程，OS领养，OS在孤儿进程退出的时候，由OS自动回收孤儿进程//      service(serversock, client_ip, client_port);//      exit(0);//  }//  //父进程//  waitpid(id, nullptr, 0);//不会阻塞，因为子进程再创建孙子进程时就exit退出了//  close(serversock);// 开始进行通信服务//  version 1.0 -- 单进程循环版本// 只能够进行一次处理一个客户端，处理完一个，才能处理下一个客户端// 很显然version 1 是不能直接被使用，因为是单进程的// 使用service函数实现//  service(serversock, client_ip, client_port);// version 2.0 -- 多进程版本 -- 创建子进程// 让子进程给新的连接提供服务，子进程能够打开父进程曾经打开的文件fd//  pid_t id = fork();//  assert(id != -1);//  if(id == 0)//  {//      //子进程会继承父进程打开的文件与文件fd//      //子进程是来进行提供服务的，所以不需要知道监听socket，所以close掉监听socket//      close(_listensock);//      //子进程对新的连接提供服务，父进程则继续accept新连接//      service(serversock, client_ip, client_port);//      exit(0); // 子进程退出后变为僵尸状态//  }// 父进程// 需要等待子进程，但是这里最好不要使用waitpid()，因为这时阻塞等待的，设置为非阻塞也比较麻烦// 所以这里采用信号的方式signal，子进程退出会主动向父进程发送SIG_CHLD信号，所以可以忽略SIG_CHLD信号// 子进程退出的时候，会自动释放自己的僵尸状态// close(serversock);//父进程只需要listensocket，不需要serversock，所以close掉serversock// 如果父进程关闭servicesock，会不会影响子进程?}}~TcpServer(){}private:uint16_t _port;  // 端口std::string _ip; // IPint _listensock; // 监听套接字std::unique_ptr<ThreadPool<Task>> _threadpool_ptr;
};

以上即为udp、tcp套接字编程的全部内容