1.TCP协议介绍
1.TCP协议
Transmission Control Protocol 传输控制协议
传输层协议
2.有连接：连接两个进程，再传输
3.可靠传输
4.面向字节流
2.UDP协议
User Datagram Protocol 用户数据报协议
传输层协议
2.无连接：直接传数据
3.不可靠传输
4.面向数据报
3.理解
特别的：不可靠和可靠其实是一种中性词，它用于不同的场景。可靠是有成本的，写出的协议一定是比较复杂的，并且维护的成本高；不可靠没有成本，比较简单就可以设计和使用了。
2.网络字节序
数据在内存中存储，但是不同的主机大小端不同，所以会出现不同主机的大小端不同。那么如果不做任何改变，网络传输时，数据给到另一台大小端不同时，会出现数据的问题。
现在的问题是，不知道接收到的数据是大端还是小端，发送也不知道对方认识大端还是小端
因此，规定在网络中传输的数据一定是大端。
发送逻辑
发送主机通常将发送缓冲区中的数据按内存地址从低到高的顺序发出；
2.接收主机把从网络上接到的字节依次保存在接收缓冲区中,也是按内存地址从低到高的顺序保存；
因此,网络数据流的地址应这样规定:先发出的数据是低地址,后发出的数据是高地址；
TCP/IP协议规定,网络数据流应采用大端字节序,即低地址高字节
不管这台主机是大端还是小端, 都会按照这个TCP/IP规定的网络字节序来发送/接收数据；
6.如果当前发送主机是小端, 就需要先将数据转成大端; 否则就忽略, 直接发送即可
系统有专门的接口对数据进行大小端转换：
主机转网络htonl，htons；
网络转主机ntohl，ntohs；
1.服务端
namespace Server{ enum { USAGE_ERR = 1, SOCKET_ERR, BIND_ERR, OPEN_ERR }; static const std::string defaultIp = "0.0.0.0"; static const int gnum = 1024; typedef std::function func_t; class udpServer { public: udpServer(const func_t &cb, const uint16_t port, const std::string ip = defaultIp) : _callback(cb), _port(port), _ip(ip), _sockfd(-1) { } void initServer() { // 1.创建套接字 _sockfd = socket(AF_INET, SOCK_DGRAM, 0); if (_sockfd == -1) { std::cerr << "socket error: " << errno << " : " << strerror(errno) << std::endl; exit(SOCKET_ERR); } // 告诉操作系统，当前的IP和PORT是多少，上面的代码只是把数据存在堆栈上 // 2.绑定IP接口 struct sockaddr_in local; bzero(&local, sizeof local); // 清空结构体 local.sin_family = AF_INET; local.sin_port = htons(_port); // local.sin_addr.s_addr = INADDR_ANY; int n = bind(_sockfd, (struct sockaddr *)&local, sizeof local); if (n == -1) { std::cerr << "bind error: " << errno << " : " << strerror(errno) << std::endl; exit(BIND_ERR); } } void start() { // 服务器的本质其实就是死循环 char buffer[gnum]; for (;;) { struct sockaddr_in peer; socklen_t len = sizeof peer; ssize_t s = recvfrom(_sockfd, buffer, sizeof(buffer) - 1, 0, (struct sockaddr *)&peer, (socklen_t *)&len); // 1.数据是什么2.谁发的 if (s > 0) { std::string clientip = inet_ntoa(peer.sin_addr); uint16_t clientport = ntohs(peer.sin_port); std::string massage = buffer; std::cout << clientip << "[" << clientport << "]# " << massage << std::endl; _callback(_sockfd, clientip, clientport, massage); } } } ~udpServer() { } private: uint16_t _port; std::string _ip; // 实际上，一款网络服务器不建议只绑定一个IP int _sockfd; func_t _callback; };}
1.成员函数
uint16_t _port：服务器指定的端口号
2.std::string _ip：客户端发送给服务器的IP，一般建议设置为0，表示任意IP路径过来的都可以访问
3.int _sockfd：需要生成的服务器端网络套接字
4.func_t _callback：回调函数，用于服务器业务处理的
2.接口
initServer()创建套接字，先初始化套接字，生成对应的套接字，随后将当前的IP和port绑定(bind)起来
start()死循环的执行服务器的任务，把需要发送给客户端发送的语句接收到，随后把客户端的IP和port记录，最后执行回调函数
3.main函数
// ./udpServer portint main(int arGC, char *argv[]){ if (argc != 2) { Usage(argv[0]); exit(USAGE_ERR); } uint16_t port = atoi(argv[1]); signal(2, reload); std::unique_ptr usvt(new udpServer(Message, port)); usvt->initServer(); usvt->start(); return 0;}
main函数先选定需要执行的回调函数，随后创建套接字，运行服务器即可
popen=pipe+fork+exec --- 先打开管道pipe，做重定向与文件指针关联，文件内部fork进程，执行exec
4.回调函数
// demo1const std::string dictTxt = "./dict.txt";unordered_map dict;static bool cutString(const string &target, string *s1, string *s2, const string &sep){ auto pos = target.find(sep); if (pos == string::npos) return false; *s1 = target.substr(0, pos); //[) *s2 = target.substr(pos + sep.size()); //[) return true;}static void debugPrint(){ for (auto &e : dict) { cout << e.first << " " << e.second << endl; }}void reload(){ (void)signo; initDict();}static void initDict(){ ifstream in(dictTxt, std::iOS::binary); if (!in.is_open()) { cerr << "open file " << dictTxt << " error" << endl; exit(OPEN_ERR); } string line; string key, value; while (getline(in, line)) { // cout << line << endl; if (cutString(line, &key, &value, ":")) { dict.insert({key, value}); } } in.close(); cout << "load dict success!" << endl;}void handlerMessage(int sockfd, std::string clientip, uint16_t clientport, std::string message){ // 处理业务 string response_message; auto iter = dict.find(message); if (iter == dict.end()) response_message = "unkonw"; else response_message = iter->second; struct sockaddr_in client; bzero(&client, sizeof client); client.sin_family = AF_INET; client.sin_port = htons(clientport); client.sin_addr.s_addr = inet_addr(clientip.c_str()); sendto(sockfd, response_message.c_str(), response_message.size(), 0, (struct sockaddr *)&client, sizeof client);}// demo2void execMessage(int sockfd, std::string clientip, uint16_t clientport, std::string cmd){ string response; FILE *fp = popen(cmd.c_str(), "r"); if (fp == NULL) { response = cmd + " exec failed"; } char line[1024]; while (fget(line, sizeof line, fp)) { response += line; } pclose(fp); struct sockaddr_in client; bzero(&client, sizeof client); client.sin_family = AF_INET; client.sin_port = htons(clientport); client.sin_addr.s_addr = inet_addr(clientip.c_str()); sendto(sockfd, response_message.c_str(), response_message.size(), 0, (struct sockaddr *)&client, sizeof client);}// demo3class User{public: User(const string &ip, const uint16_t &port) : _ip(ip), _port(port) { } ~User() { } string ip(){ return _ip; } uint16_t port(){ return _port; }private: string _ip; uint16_t _port;};class OnlineUser{public: OnlineUser() {} ~OnlineUser() {} void addUser(const string &ip, const uint16_t &port) { string id = ip + "-" + to_string(port); users.insert(make_pair(id, User(ip, port))); } void delUser(const string &ip, const uint16_t &port) { string id = ip + "-" + to_string(port); users.erase(id); } bool isOnline(const string &ip, const uint16_t &port) { string id = ip + "-" + to_string(port); return users.find(id) == users.end() ? false : true; } void broadcastMessage(int sockfd, const string &ip, const uint16_t &port, const string &message) { for (auto &user : users) { struct sockaddr_in client; bzero(&client, sizeof(client)); client.sin_family = AF_INET; client.sin_port = htons(user.second.port()); client.sin_addr.s_addr = inet_addr(user.second.ip().c_str()); string s = ip + "-" + to_string(port) + "# "; s += message; sendto(sockfd, s.c_str(), s.size(), 0, (struct sockaddr *)&client, sizeof(client)); } }private: unordered_map users;};void routeMessage(int sockfd, string clientip, uint16_t clientport, string message){ if (message == "online") onlineuser.addUser(clientip, clientport); if (message == "offline") onlineuser.delUser(clientip, clientport); if (onlineuser.isOnline(clientip, clientport)) { // 消息的路由 onlineuser.broadcastMessage(sockfd, clientip, clientport, message); } else { struct sockaddr_in client; bzero(&client, sizeof(client)); client.sin_family = AF_INET; client.sin_port = htons(clientport); client.sin_addr.s_addr = inet_addr(clientip.c_str()); string response = "你还没有上线，请先上线，运行: online"; sendto(sockfd, response.c_str(), response.size(), 0, (struct sockaddr *)&client, sizeof(client)); }}
demo的逻辑都是先接收到客户端的信息，通过回调函数执行对应的任务，最后把结果发送给客户端。
此外，将服务端的类和回调函数分离，这样使得耦合度变低，只在main函数修改每一次的指令即可更换命任务。
2.客户端
namespace Client{ class udpClient { public: udpClient(const std::string serverip, const uint16_t serverport) : _sockfd(-1), _serverport(serverport), _serverip(serverip), _quit(false) { } void initClient() { // 1.创建套接字 _sockfd = socket(AF_INET, SOCK_DGRAM, 0); if (_sockfd == -1) { std::cerr << "socket error: " << errno << " : " << strerror(errno) << std::endl; exit(2); } std::cout << "socket success: " << _sockfd << std::endl; // 2.绑定IP接口,Client不需要程序员显示的bind,由操作系统进行绑定 } void run() { struct sockaddr_in server; memset(&server, 0, sizeof server); server.sin_family = AF_INET; server.sin_addr.s_addr = inet_addr(_serverip.c_str()); server.sin_port = htons(_serverport); std::string massage; while (!_quit) { std::cout << "Please Enter# "; std::cin >> massage; sendto(_sockfd, massage.c_str(), massage.size(), 0, (struct sockaddr *)&server, sizeof server); char buffer[1024]; struct sockaddr_in temp; socklen_t temp_len = sizeof temp; ssize_t n = recvfrom(_sockfd, buffer, sizeof(buffer) - 1, 0, (struct sockaddr *)&temp, &temp_len); if (n > 0) buffer[n] = 0; std::cout << "服务器的翻译结果：" << buffer << std::endl; } } //demo3的设计 // static void *readMessage(void *args) // { // int sockfd = *(static_cast(args)); // pthread_detach(pthread_self()); // while (true) // { // char buffer[1024]; // struct sockaddr_in temp; // socklen_t temp_len = sizeof(temp); // size_t n = recvfrom(sockfd, buffer, sizeof(buffer) - 1, 0, (struct sockaddr *)&temp, &temp_len); // if (n >= 0) // buffer[n] = 0; // cout << buffer << endl; // } // return nullptr; // } // void run() // { // pthread_create(&_reader, nullptr, readMessage, (void *)&_sockfd); // struct sockaddr_in server; // memset(&server, 0, sizeof(server)); // server.sin_family = AF_INET; // server.sin_addr.s_addr = inet_addr(_serverip.c_str()); // server.sin_port = htons(_serverport); // string message; // char cmdline[1024]; // while (!_quit) // { // // cerr << "# "; // ls -a -l // // cin >> message; // fprintf(stderr, "Enter# "); // fflush(stderr); // fgets(cmdline, sizeof(cmdline), stdin); // cmdline[strlen(cmdline) - 1] = 0; // 回车置为/0 // message = cmdline; // sendto(_sockfd, message.c_str(), message.size(), 0, (struct sockaddr *)&server, sizeof(server)); // } // } ~udpClient() { } private: int _sockfd; std::string _serverip; uint16_t _serverport; bool _quit; };}
1.成员函数
int _sockfd：客户端的套接字
std::string _serverip：服务器的IP地址
uint16_t _serverport：服务器的端口号
bool _quit：执行条件逻辑判断变量
2.接口
initClient()初始化客户端的套接字，再绑定套接字
run()，客户端先准备好数据，发送给服务端，随着服务端的任务处理，把最终服务端的套接字发送给运行的客户端，得到自己的需求
3.main函数
static void Usage(string proc){ cout << "Usage:\n\t" << proc << " server_ip server_port\n\n";}// ./udpClient server_ip server_portint main(int argc, char *argv[]){ if (argc != 3) { Usage(argv[0]); exit(1); } uint16_t serverport = atoi(argv[2]); std::string serverip = argv[1]; std::unique_ptr ucli(new udpClient(serverip, serverport)); ucli->initClient(); ucli->run(); return 0;}
main函数初始化套接字，随后运行即可。
https://blog.csdn.net/m0_63488627/article/details/131967378?spm=1001.2014.3001.5501
0