源IP地址和目的IP地址源IP地址标识数据包的发送者即数据产生的源头主机。目的IP地址标识数据包的接收者即数据最终要到达的目标主机。端口号概念端口号是一个2字节16位的整数;端口号用来标识一个进程, 告诉操作系统, 当前的这个数据要交给哪一个进程来处理;IP地址 端口号能够标识网络上的某一台主机的某一个进程;一个端口号只能被一个进程占用.核心作用多路复用一台电脑只有一个公网 IP但可以同时运行微信、浏览器、游戏等多个网络程序。端口号的作用就是让操作系统知道收到的网络数据包应该交给哪个程序处理。进程ID与端口号的联系与区别维度进程 ID (PID)端口号 (Port)作用域操作系统内部网络通信主要职责唯一标识一个正在运行的进程唯一标识一个网络服务 / 连接变化规律动态随机进程启动时分配相对静态服务通常绑定固定端口生命周期随进程生灭进程结束即释放可被不同进程复用服务重启后可重新绑定类比身份证号唯一标识一个人房间号标识楼里的一个服务点一个进程可以绑定多个端口号; 但是一个端口号不能被多个进程绑定。源端口号和目的端口号源端口号标识发送方主机上的具体应用程序。通常由操作系统随机分配用于接收响应。目的端口号标识接收方主机上等待连接的服务。通常是固定且已知的如HTTP服务的80端口。TCP协议概念TCPTransmission Control Protocol传输控制协议是互联网的“可靠数据管道”。它位于 OSI 模型的传输层建立在 IP 协议之上核心任务是在不可靠的 IP 网络上通过复杂的机制实现数据的可靠、有序、无差错的传输。核心特性TCP可靠的原因特性实现机制通俗理解1. 面向连接三次握手建立连接四次挥手断开连接。打电话前先拨通说 “喂”挂断前说 “再见”。2. 可靠传输ACK 确认 超时重传。收到数据必须回复确认没收到就重发。快递签收收到货发短信没收到就投诉补发。3. 顺序传输序列号。每个字节都有编号接收方按序重组。拼图游戏每块都有编号按顺序拼。4. 流量控制滑动窗口。根据接收方处理能力动态调整发送速度。水龙头接水看桶快满了就关小点防止溢出。5. 拥塞控制慢启动、拥塞避免。感知网络拥堵主动降速。交通管制发现路口堵车就让后续车辆慢点进。6. 全双工双方可同时发送和接收数据。真实电话可以同时听和说不像对讲机。报文结构一个 TCP 报文段Segment由首部Header和数据Data组成。字段长度作用源端口 / 目的端口16 bit标识发送和接收的应用程序构成 Socket。序列号32 bit本报文段所发送数据的第一个字节的编号。确认号32 bit期望收到的下一个报文段的序列号即确认号 - 1 之前的数据已收到。标志位6 bitURG紧急、ACK确认、PSH推送、RST重置、SYN同步、FIN结束。窗口大小16 bit用于流量控制告知对方自己还能接收多少数据。连接管理三次握手目的同步双方的初始序列号确认双方收发能力正常。为什么是三次两次无法防止已失效的连接请求旧 SYN 包突然到达服务器导致服务器空等造成资源浪费。三次握手确保了双方“发”和“收”的能力都正常。四次挥手目的双方都确认没有数据要发送了才能安全关闭。为什么是四次因为 TCP 是全双工的。A 发完数据可以关但 B 可能还有数据要发所以需要两次独立的 FIN 和 ACK。TIME_WAIT 状态主动关闭方最后要等待2MSLMaximum Segment Lifetime报文最大生存时间。目的是1确保最后的 ACK 能到达如果丢失对方会重发 FIN。2让本次连接的所有报文在网络中“消失”防止影响下一次新连接。UDP协议它位于 OSI 模型的传输层核心设计哲学是简单、快速、无连接。核心特性特性说明现实比喻无连接发送前无需建立连接无握手。像寄平信写好地址就扔进邮筒不管对方在不在家。不可靠不保证数据到达、不保证顺序、不重传。像校园广播播完即止没听到的学生自己负责。无状态不维护连接状态不进行流量 / 拥塞控制。资源消耗极低一台服务器可同时应对百万级请求。面向报文对应用层交下来的报文既不合并也不拆分直接加上 UDP 头就发送。像快递员不拆你的包裹原样投递。报文结构UDP 头部固定为8 字节相比 TCP20-60字节极其轻量。字段长度作用源端口16 bit发送方端口号可省略为 0。目的端口16 bit接收方端口号用于多路分解。长度16 bit整个 UDP 数据报的长度含头。校验和16 bit检测数据是否出错可选但通常启用。关键点UDP 头部没有序列号、确认号、窗口大小等复杂字段因此无法实现可靠传输和流量控制。UDP快的原因无连接建立开销没有三次握手直接发送延迟极低RTT 为 0。头部开销小固定 8 字节网络带宽利用率高。无拥塞控制不管网络是否拥堵一直以恒速发送。这对实时应用是优点如视频流宁愿丢包也不愿卡顿。TCP与UDP区别维度TCPUDP连接面向连接可靠无连接不可靠可靠性保证数据不丢失、不重复、有序尽最大努力交付可能丢包、乱序速度慢有握手、确认、重传开销快头部小无控制开销头部大小20-60 字节复杂8 字节固定简单流量控制有滑动窗口无拥塞控制有慢启动、拥塞避免无应用场景网页HTTP、邮件SMTP、文件传输FTP视频流、语音通话、DNS、游戏选择原则要可靠、要数据完整选 TCP要速度、能容忍少量丢包选 UDP。网络字节序内存中的多字节数据相对于内存地址有大端和小端之分, 磁盘文件中的多字节数据相对于文件中的偏 移地址也有大端小端之分, 网络数据流同样有大端小端之分.概念网络字节序Network Byte Order是 TCP/IP 协议栈中规定的数据表示标准特指大端序。它的存在是为了解决不同架构计算机大端/小端在通信时可能产生的数据解析错误。发送主机通常将发送缓冲区中的数据按内存地址从低到高的顺序发出;接收主机把从网络上接到的字节依次保存在接收缓冲区中,也是按内存地址从低到高的顺序保存;因此,网络数据流的地址应这样规定:先发出的数据是低地址,后发出的数据是高地址. TCP/IP协议规定,网络数据流应采用大端字节序,即低地址高字节. 不管这台主机是大端机还是小端机, 都会按照这个TCP/IP规定的网络字节序来发送/接收数据;如果当前发送主机是小端, 就需要先将数据转成大端; 否则就忽略, 直接发送即可。本质维度网络字节序主机字节序定义标准大端序本地 CPU 的字节序x86 通常是小端作用域网络传输协议头部内存存储、CPU 运算转换发送前需将主机序转为网络序接收后需将网络序转回主机序核心函数为使网络程序具有可移植性,使同样的C代码在大端和小端计算机上编译后都能正常运行,可以调用以下库函数做网络 字节序和主机字节序的转换。函数作用示例htons()Host to Network Short16 位如端口号sockaddr_in.sin_port htons(8080);htonl()Host to Network Long32 位如 IP 地址sockaddr_in.sin_addr.s_addr htonl(INADDR_ANY);ntohs()Network to Host Short接收端还原port ntohs(sin.sin_port);ntohl()Network to Host Long接收端还原ip ntohl(addr.s_addr);这些函数名很好记,h表示host,n表示network,l表示32位长整数,s表示16位短整数。例如htonl表示将32位的长整数从主机字节序转换为网络字节序,例如将IP地址转换后准备发送。如果主机是小端字节序,这些函数将参数做相应的大小端转换然后返回 ;如果主机是大端字节序,这些 函数不做转换,将参数原封不动地返回。socket编程接口socket常见APIsocket--创建 socket 文件描述符 (TCP/UDP, 客户端 服务器)#include sys/socket.h int socket(int domain, int type, int protocol);功能创建通信端点返回套接字描述符类似文件描述符。参数domain协议族。AF_INET(IPv4), AF_INET6(IPv6)。type套接字类型。SOCK_STREAM(TCP), SOCK_DGRAM(UDP)。protocol通常为 0自动选择。返回值成功返回描述符≥0失败返回 -1。示例int tcp_sock socket(AF_INET, SOCK_STREAM, 0); // TCP int udp_sock socket(AF_INET, SOCK_DGRAM, 0); // UDPbind--绑定端口号 (TCP/UDP, 服务器)int bind(int sockfd, const struct sockaddr *addr, socklen_t addrlen);功能将套接字与本地 IP 地址和端口绑定服务器必须调用。参数addr指向包含 IP 和端口的结构体struct sockaddr_in。注意客户端通常不需要显式 bind由系统自动分配临时端口。示例struct sockaddr_in server_addr; server_addr.sin_family AF_INET; server_addr.sin_port htons(8080); // 端口 server_addr.sin_addr.s_addr INADDR_ANY; // 监听所有网卡 bind(sockfd, (struct sockaddr*)server_addr, sizeof(server_addr));listen--开始监听socket (TCP, 服务器)int listen(int sockfd, int backlog);功能将主动套接字转为被动监听套接字等待客户端连接。参数backlog是已完成三次握手队列的最大长度通常 5-128。accept--接收请求 (TCP, 服务器)int accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen);功能从已完成连接队列中取出一个连接返回新的套接字描述符用于通信。关键监听套接字只用于接受连接实际数据传输用 accept返回的新套接字。connect--建立连接 (TCP, 客户端)int connect(int sockfd, const struct sockaddr *addr, socklen_t addrlen);功能客户端向服务器发起 TCP 连接触发三次握手。sockaddr结构socket API是一层抽象的网络编程接口,适用于各种底层网络协议,如IPv4、IPv6各种网络协议的地址格式并不相同。如果为每种协议设计不同的 API代码会变得复杂。于是sockaddr作为一个通用的、类型兼容的结构体成为了所有地址结构的基础。sockaddr#include sys/socket.h struct sockaddr { sa_family_t sa_family; // 地址族2字节 char sa_data[14]; // 协议特定地址14字节 };参数sa_family标识地址类型AF_INETIPv4AF_INET6IPv6AF_UNIX/AF_LOCAL本地套接字sa_data存储具体的地址信息对 IPv4 来说就是 IP 端口注意实际编程中几乎从不直接使用这个结构而是使用更具体的结构然后强制转换为struct sockaddr*传入 API。sockaddr_inIPV4#include netinet/in.h struct sockaddr_in { sa_family_t sin_family; // 地址族AF_INET in_port_t sin_port; // 端口号16位网络字节序 struct in_addr sin_addr; // IP地址32位网络字节序 unsigned char sin_zero[8]; // 填充字节通常设为0 }; struct in_addr { in_addr_t s_addr; // 32位IPv4地址 };示例struct sockaddr_in server_addr; server_addr.sin_family AF_INET; // IPv4 server_addr.sin_port htons(8080); // 端口 inet_pton(AF_INET, 192.168.1.100, server_addr.sin_addr); // IP地址 memset(server_addr.sin_zero, 0, 8); // 填充零sockaddr_un本地地址#include sys/un.h struct sockaddr_un { sa_family_t sun_family; // AF_UNIX/AF_LOCAL char sun_path[108]; // 路径名 };用于同一台机器上的进程间通信性能比网络套接字更高。地址转换函数inet_aton#include arpa/inet.h int inet_aton(const char *strptr, struct in_addr *addrptr);作用将点分十进制字符串如192.168.1.1转换为struct in_addr格式的二进制网络序地址返回值成功返回非 0失败返回 0。inet_addr#include arpa/inet.h in_addr_t inet_addr(const char *strptr);作用将点分十进制字符串直接转换为in_addr_t类型32 位网络序整数注意不推荐使用无法区分255.255.255.255和错误返回值inet_pton#include arpa/inet.h int inet_pton(int family, const char *strptr, void *addrptr);作用通用地址转换函数支持 IPv4AF_INET和 IPv6AF_INET6参数family地址族AF_INETIPv4/AF_INET6IPv6strptr点分十进制 / 冒分十六进制字符串addrptr存储转换后的二进制地址struct in_addr*/struct in6_addr*返回值成功返回 1格式错误返回 0失败返回 - 1inet_ntoa#include arpa/inet.h char *inet_ntoa(struct in_addr inaddr);作用将struct in_addr格式的二进制地址转换为点分十进制字符串注意静态缓冲区实现非线程安全多线程环境需加锁inet_ntoa这个函数返回了一个char*, 很显然是这个函数自己在内部为我们申请了一块内存来保存ip的结果. 那么是 否需要调用者手动释放呢?man手册上说, inet_ntoa函数, 是把这个返回结果放到了静态存储区. 这个时候不需要我们手动进行释放.如果我们调用多次这个函数, 会有什么样的效果呢?因为inet_ntoa把结果放到自己内部的一个静态存储区, 这样第二次调用时的结果会覆盖掉上一次的结果。inet_ntop#include arpa/inet.h const char *inet_ntop(int family, const void *addrptr, char *strptr, size_t len);作用通用地址转换函数支持 IPv4/IPv6线程安全参数family地址族AF_INET/AF_INET6addrptr二进制地址struct in_addr*/struct in6_addr*strptr存储转换后的字符串的缓冲区len缓冲区长度IPv4 用INET_ADDRSTRLENIPv6 用INET6_ADDRSTRLEN返回值成功返回strptr失败返回 NULLUDP网络程序我们用UDP来实现一个简单的英译汉功能UdpSocket 封装udp_socket.hpp#pragma once #include stdio.h #include string.h #include stdlib.h #include cassert #include string #include unistd.h #include sys/socket.h #include netinet/in.h #include arpa/inet.h typedef struct sockaddr sockaddr; typedef struct sockaddr_in sockaddr_in; class UdpSocket { public: UdpSocket() : fd_(-1) {} bool Socket() { fd_ socket(AF_INET, SOCK_DGRAM, 0); if (fd_ 0) { perror(socket); return false; } return true; } bool Close() { close(fd_); return true; } bool Bind(const std::string ip, uint16_t port) { sockaddr_in addr; addr.sin_family AF_INET; addr.sin_addr.s_addr inet_addr(ip.c_str()); addr.sin_port htons(port); int ret bind(fd_, (sockaddr*)addr, sizeof(addr)); if (ret 0) { perror(bind); return false; } return true; } bool RecvFrom(std::string* buf, std::string* ip NULL, uint16_t* port NULL) { char tmp[1024 * 10] {0}; sockaddr_in peer; socklen_t len sizeof(peer); ssize_t read_size recvfrom(fd_, tmp, sizeof(tmp) - 1, 0, (sockaddr*)peer, len); if (read_size 0) { perror(recvfrom); return false; } // 将读到的缓冲区内容放到输出参数中 buf-assign(tmp, read_size); if (ip ! NULL) { *ip inet_ntoa(peer.sin_addr); } if (port ! NULL) { *port ntohs(peer.sin_port); } return true; } bool SendTo(const std::string buf, const std::string ip, uint16_t port) { sockaddr_in addr; addr.sin_family AF_INET; addr.sin_addr.s_addr inet_addr(ip.c_str()); addr.sin_port htons(port); ssize_t write_size sendto(fd_, buf.data(), buf.size(), 0, (sockaddr*)addr, sizeof(addr)); if (write_size 0) { perror(sendto); return false; } return true; } private: int fd_; };UDP 通用服务器udp_server.hpp#pragma once #include udp_socket.hpp // C 式写法 // typedef void (*Handler)(const std::string req, std::string* resp); // C 11 式写法能够兼容函数指针仿函数和 lamda #include functional typedef std::functionvoid (const std::string, std::string* resp) Handler; class UdpServer { public: UdpServer() { assert(sock_.Socket()); } ~UdpServer() { sock_.Close(); } bool Start(const std::string ip, uint16_t port, Handler handler) { // 1. 创建 socket // 2. 绑定端口号 bool ret sock_.Bind(ip, port); if (!ret) { return false; } // 3. 进入事件循环 for (;;) { // 4. 尝试读取请求 std::string req; std::string remote_ip; uint16_t remote_port 0; bool ret sock_.RecvFrom(req, remote_ip, remote_port); if (!ret) { continue; } std::string resp; // 5. 根据请求计算响应 handler(req, resp); // 6. 返回响应给客户端 sock_.SendTo(resp, remote_ip, remote_port); printf([%s:%d] req: %s, resp: %s\n, remote_ip.c_str(), remote_port, req.c_str(), resp.c_str()); } sock_.Close(); return true; } private: UdpSocket sock_; };英译汉服务器实现dict_server.cc、#include udp_server.hpp #include unordered_map #include iostream std::unordered_mapstd::string, std::string g_dict; void Translate(const std::string req, std::string* resp) { auto it g_dict.find(req); if (it g_dict.end()) { *resp 未查到!; return; } *resp it-second; } int main(int argc, char* argv[]) { if (argc ! 3) { printf(Usage ./dict_server [ip] [port]\n); return 1; } // 1. 数据初始化 g_dict.insert(std::make_pair(hello, 你好)); g_dict.insert(std::make_pair(world, 世界)); g_dict.insert(std::make_pair(c, 最好的编程语言)); g_dict.insert(std::make_pair(bit, 特别NB)); // 2. 启动服务器 UdpServer server; server.Start(argv[1], atoi(argv[2]), Translate); return 0; }UDP 通用客户端udp_client.hpp#pragma once #include udp_socket.hpp class UdpClient { public: UdpClient(const std::string ip, uint16_t port) : ip_(ip), port_(port) { assert(sock_.Socket()); } ~UdpClient() { sock_.Close(); } bool RecvFrom(std::string* buf) { return sock_.RecvFrom(buf); } bool SendTo(const std::string buf) { return sock_.SendTo(buf, ip_, port_); } private: UdpSocket sock_; // 服务器端的 IP 和 端口号 std::string ip_; uint16_t port_; };英译汉客户端实现dict_client.cc#include udp_client.hpp #include iostream int main(int argc, char* argv[]) { if (argc ! 3) { printf(Usage ./dict_client [ip] [port]\n); return 1; } UdpClient client(argv[1], atoi(argv[2])); for (;;) { std::string word; std::cout 请输入您要查的单词: ; std::cin word; if (std::cin Good Bye std::endl; break; } client.SendTo(word); std::string result; client.RecvFrom(result); std::cout word 意思是 result std::endl; } return 0; }TCP网络程序用TCP来实现英译汉功能TcpSocket 封装tcp_socket.hpp#pragma once #include stdio.h #include string.h #include stdlib.h #include cassert #include string #include unistd.h #include sys/socket.h #include netinet/in.h #include arpa/inet.h typedef struct sockaddr sockaddr; typedef struct sockaddr_in sockaddr_in; class TcpSocket { public: TcpSocket() : fd_(-1) {} TcpSocket(int fd) : fd_(fd) {} // 创建套接字 bool Socket() { fd_ socket(AF_INET, SOCK_STREAM, 0); if (fd_ 0) { perror(socket); return false; } return true; } // 关闭套接字 bool Close() { close(fd_); return true; } // 绑定 监听 bool Bind(const std::string ip, uint16_t port) { sockaddr_in addr; addr.sin_family AF_INET; addr.sin_addr.s_addr inet_addr(ip.c_str()); addr.sin_port htons(port); if (bind(fd_, (sockaddr*)addr, sizeof(addr)) 0) { perror(bind); return false; } return true; } bool Listen(int num 10) { if (listen(fd_, num) 0) { perror(listen); return false; } return true; } // 接受连接返回新的 fd bool Accept(int* new_fd, std::string* peer_ip, uint16_t* peer_port) { sockaddr_in peer; socklen_t len sizeof(peer); int client_fd accept(fd_, (sockaddr*)peer, len); if (client_fd 0) { perror(accept); return false; } *new_fd client_fd; if (peer_ip) *peer_ip inet_ntoa(peer.sin_addr); if (peer_port) *peer_port ntohs(peer.sin_port); return true; } // 连接服务器客户端用 bool Connect(const std::string ip, uint16_t port) { sockaddr_in addr; addr.sin_family AF_INET; addr.sin_addr.s_addr inet_addr(ip.c_str()); addr.sin_port htons(port); if (connect(fd_, (sockaddr*)addr, sizeof(addr)) 0) { perror(connect); return false; } return true; } // 发送数据 bool Send(const std::string buf) { ssize_t ret send(fd_, buf.data(), buf.size(), 0); return ret 0; } // 接收数据 bool Recv(std::string* out) { char buf[1024] {0}; ssize_t ret recv(fd_, buf, sizeof(buf) - 1, 0); if (ret 0) return false; out-assign(buf, ret); return true; } int GetFd() { return fd_; } private: int fd_; };TCP 服务器tcp_server.hpp#pragma once #include tcp_socket.hpp #include functional #include thread using Handler std::functionvoid(const std::string req, std::string* resp); class TcpServer { public: TcpServer(const std::string ip, uint16_t port) : ip_(ip), port_(port) {} bool Start(Handler handler) { // 1. 创建套接字 if (!sock_.Socket()) return false; // 2. 绑定 监听 if (!sock_.Bind(ip_, port_)) return false; if (!sock_.Listen()) return false; printf(Server start on %s:%d...\n, ip_.c_str(), port_); // 3. 循环接受客户端 for (;;) { int client_fd; std::string cip; uint16_t cport; if (!sock_.Accept(client_fd, cip, cport)) continue; // 创建线程处理客户端TCP 必须这样 std::thread th(ServiceOneClient, TcpSocket(client_fd), cip, cport, handler); th.detach(); } } static void ServiceOneClient( TcpSocket sock, std::string ip, uint16_t port, Handler handler ) { printf(Client [%s:%d] connected\n, ip.c_str(), port); std::string req, resp; while (sock.Recv(req)) { handler(req, resp); sock.Send(resp); printf([%s:%d] req: %s → resp: %s\n, ip.c_str(), port, req.c_str(), resp.c_str()); req.clear(); resp.clear(); } printf(Client [%s:%d] disconnected\n, ip.c_str(), port); sock.Close(); } private: TcpSocket sock_; std::string ip_; uint16_t port_; };TCP 英译汉服务器dict_server.cc#include tcp_server.hpp #include unordered_map #include iostream std::unordered_mapstd::string, std::string dict { {hello, 你好}, {world, 世界}, {computer, 电脑}, {student, 学生}, {teacher, 老师}, {network, 网络}, {socket, 套接字}, {tcp, 可靠传输协议} }; void Translate(const std::string req, std::string* resp) { auto it dict.find(req); if (it ! dict.end()) { *resp it-second; } else { *resp 查无此词; } } int main() { TcpServer server(0.0.0.0, 8080); server.Start(Translate); return 0; }TCP 客户端tcp_client.hpp#pragma once #include tcp_socket.hpp #include string class TcpClient { public: TcpClient(const std::string ip, uint16_t port) : ip_(ip), port_(port) {} bool Connect() { return sock_.Socket() sock_.Connect(ip_, port_); } bool Send(const std::string msg) { return sock_.Send(msg); } bool Recv(std::string* out) { return sock_.Recv(out); } void Close() { sock_.Close(); } private: TcpSocket sock_; std::string ip_; uint16_t port_; };TCP 英译汉客户端dict_client.cc#include tcp_client.hpp #include iostream using namespace std; int main() { TcpClient client(127.0.0.1, 8080); if (!client.Connect()) { cout 连接服务器失败 endl; return 1; } cout 已连接词典服务器输入单词查询输入 exit 退出 endl; string word, ans; while (true) { cout \n请输入英文单词; cin word; if (word exit) break; client.Send(word); client.Recv(ans); cout 翻译结果 ans endl; } client.Close(); return 0; }