网络编程套接字
- 🐛预备知识
- 🦋理解源IP地址和目的IP地址
- 🐌认识端口号
- 🐞 理解 "端口号" 和 "进程ID"
- 🐜简单认识TCP协议
- 🦟简单认识UDP协议
- 🦗 什么是网络字节序
- 🕷相关函数端口介绍
- 🕸 socket相关API介绍
- 🦂sockaddr结构
- 🐢 sockaddr_in结构
- 🐍 简单的UDP网络程序
- 🦎log.hpp 日志文件
- 🦖 udpClient.cc 客户端
- 🦕 udpServer.cc 服务器
- 🐙 makefile文件
- 运行:
🐛预备知识
🦋理解源IP地址和目的IP地址
源IP地址（Source IP Address）：
源IP地址是数据包发送方（或数据流出发点）的唯一标识符。它用于在互联网或本地网络中定位发送数据包的设备或主机。源IP地址是数据包的出发点，即数据从这个地址开始传送，向目的IP地址指示的设备发送。
在TCP/IP协议中，源IP地址通常由发送方的操作系统或网络栈分配，并在数据包的IP首部中进行标记。
目的IP地址（Destination IP Address）：
目的IP地址是数据包的接收方（或数据流的目标点）的唯一标识符。它用于在互联网或本地网络中定位接收数据包的设备或主机。目的IP地址是数据包的终点，即数据传输的目标地址，数据包应该传输到这个地址。
在TCP/IP协议中，目的IP地址通常由应用程序或网络栈设置，并在数据包的IP首部中进行标记。
这两个地址在数据包传输过程中起着非常重要的作用，确保数据从源设备正确地传递到目标设备，实现网络通信。IP地址是一个32位的二进制数，通常用点分十进制表示（例如，192.168.0.1），其中前24位表示网络地址，后8位表示主机地址。
🐌认识端口号
端口号(port)是传输层协议的内容.
端口号是一个2字节16位的整数;
端口号用来标识一个进程, 告诉操作系统, 当前的这个数据要交给哪一个进程来处理;
IP地址 + 端口号能够标识网络上的某一台主机的某一个进程;
一个端口号只能被一个进程占用.
🐞 理解 “端口号” 和 “进程ID”
- 端口号（Port Number）和进程ID（Process ID）是在计算机网络和操作系统中用于不同目的的标识符。
端口号：
端口号是在计算机网络中用于标识特定进程或服务的数字。 它是一个16位的无符号整数，取值范围是0到65535。
在TCP/IP网络中，每个传输控制协议（TCP）和用户数据报协议（UDP）的通信端点都与一个端口号相关联。 这样，计算机上的不同进程或服务可以通过不同的端口号进行通信，从而实现多个应用程序的并发运行。
例如，HTTP服务通常使用端口号80，HTTPS使用端口号443，SMTP使用端口号25等。
进程ID：
进程ID是操作系统中用于标识运行中进程（或线程）的唯一标识符。 它是一个非负整数，通常由操作系统在进程创建时分配。
在多任务操作系统中，每个运行中的进程都有一个唯一的进程ID，操作系统通过进程ID来跟踪和管理不同的进程。
进程ID的范围通常由操作系统定义，可以是一个较小的数值范围，也可以是一个较大的范围。
区别：
端口号是在计算机网络中用于标识不同进程或服务的通信端点，用于实现多个应用程序的并发运行。 进程ID是操作系统中用于标识运行中进程的唯一标识符，用于跟踪和管理不同的进程。
端口号是在网络通信中使用的，而进程ID是在操作系统层级使用的。
端口号是一个16位的数字，进程ID是一个非负整数。
🐜简单认识TCP协议
传输层协议
有连接
可靠传输
面向字节流
🦟简单认识UDP协议
传输层协议
无连接
不可靠传输
面向数据报
🦗 什么是网络字节序
网络字节序是一种在计算机网络中使用的固定字节顺序，用于在不同计算机体系结构和操作系统之间传递数据。 在计算机内部，不同的体系结构（例如x86、ARM、SPARC等）和操作系统（例如Windows、Linux、iOS等）可能使用不同的字节顺序，这可能导致在网络通信中出现问题。
为了解决这个问题，网络通信中使用了统一的字节顺序，即网络字节序。 网络字节序采用大端字节序（Big-Endian）表示法，其中较高的字节位于较低的内存地址上，较低的字节位于较高的内存地址上。
举例说明：
假设一个16位整数0x1234（十进制为4660）在内存中存储为两个字节：0x12和0x34。
在大端字节序中，较高的字节（0x12）存储在较低的内存地址，较低的字节（0x34）存储在较高的内存地址。 即内存地址由高到低，数据依次为0x12 0x34。
在小端字节序中，较低的字节（0x34）存储在较低的内存地址，较高的字节（0x12）存储在较高的内存地址。 即内存地址由高到低，数据依次为0x34 0x12。
在网络通信中，发送方将数据转换为网络字节序后发送，接收方收到数据后将其转换为本地字节序进行处理，以保证在不同计算机体系结构和操作系统之间正确地传递数据。 常用的网络编程库（例如Socket编程）通常会自动处理字节序的转换。
🕷相关函数端口介绍
🕸 socket相关API介绍
- man手册
Socket（套接字）是一种用于网络通信的编程接口，它允许计算机之间通过网络传输数据。 在Socket编程中，我们可以使用一组API函数来创建、绑定、连接、发送和接收数据等操作。
- 以下是常用的Socket API函数及其参数：
- socket()函数：
- 描述：创建一个新的套接字。
- 参数：int socket(int domain, int type, int protocol)
- domain：套接字的地址族，常用的有AF_INET（IPv4）和AF_INET6（IPv6）。
- type：套接字的类型，常用的有SOCK_STREAM（流式套接字，用于TCP）和SOCK_DGRAM（数据报套接字，用于UDP）。
- protocol：使用的协议，通常为0（自动选择与type相关的默认协议）。
- bind()函数：
- 描述：将套接字绑定到一个特定的地址和端口。
- 参数：int bind(int sockfd, const struct sockaddr *addr, socklen_t addrlen)
- sockfd：套接字描述符。
- addr：指向要绑定的地址结构的指针，通常是struct sockaddr_in（IPv4）或struct sockaddr_in6（IPv6）。
- addrlen：地址结构的长度。
- connect()函数：
- 描述：建立与远程服务器的连接。
- 参数：int connect(int sockfd, const struct sockaddr *addr, socklen_t addrlen)
- sockfd：套接字描述符。
- addr：指向目标服务器地址的指针，通常是struct sockaddr_in（IPv4）或struct sockaddr_in6（IPv6）。
- addrlen：地址结构的长度。
- listen()函数：
- 描述：将套接字设置为监听模式，准备接受连接请求。
- 参数：int listen(int sockfd, int backlog)
- sockfd：套接字描述符。
- backlog：请求队列的最大长度，即等待接受连接的连接数。
- accept()函数：
- 描述：接受连接请求，创建一个新的套接字用于与客户端通信。
- 参数：int accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen)
- sockfd：监听套接字描述符。
- addr：指向客户端地址的指针，用于存储客户端的信息。
- addrlen：地址结构的长度。
- send()函数：
- 描述：发送数据。
- 参数：ssize_t send(int sockfd, const void *buf, size_t len, int flags)
- sockfd：套接字描述符。
- buf：要发送的数据缓冲区。
- len：要发送的数据长度。
- flags：发送标志，通常为0。
- recv()函数：
- 描述：接收数据。
- 参数：ssize_t recv(int sockfd, void *buf, size_t len, int flags)
- sockfd：套接字描述符。
- buf：接收数据的缓冲区。
- len：要接收的数据长度。
- flags：接收标志，通常为0。
- close()函数：
- 描述：关闭套接字。
- 参数：int close(int sockfd)
- sockfd：套接字描述符。
使用Socket API时，通常的流程是创建一个套接字、绑定到一个地址和端口（可选）、监听连接请求（可选）、接受连接请求、发送和接收数据，最后关闭套接字。 服务器端和客户端使用不同的套接字操作，服务器端用于监听连接请求和处理客户端请求，而客户端用于建立连接和发送请求给服务器端。
🦂sockaddr结构
sockaddr 是一个通用的套接字地址结构，在Socket编程中经常用于存储网络地址信息。由于不同的协议族（IPv4、IPv6等）具有不同的地址结构，因此 sockaddr 用作地址结构的基类，而实际使用时通常会使用具体的子结构 sockaddr_in（IPv4）或 sockaddr_in6（IPv6）。
struct sockaddr {
sa_family_t sa_family; // 地址族，通常为 AF_INET 或 AF_INET6
char sa_data[14]; // 存放地址信息的缓冲区，不同协议族具有不同的结构
};
在实际使用时，通常会将 sockaddr 结构转换为适合当前协议族的具体地址结构。例如，在IPv4协议中，使用 sockaddr_in 结构，其定义如下：
struct sockaddr_in {
sa_family_t sin_family; // 地址族，固定为 AF_INET
in_port_t sin_port; // 16位端口号，使用网络字节序
struct in_addr sin_addr; // 32位IPv4地址，使用网络字节序
char sin_zero[8]; // 不使用，填充字段
};
在IPv6协议中，使用 sockaddr_in6 结构，其定义如下：
struct sockaddr_in6 {
sa_family_t sin6_family; // 地址族，固定为 AF_INET6
in_port_t sin6_port; // 16位端口号，使用网络字节序
uint32_t sin6_flowinfo; // 流标识，通常为0
struct in6_addr sin6_addr; // 128位IPv6地址，使用网络字节序
uint32_t sin6_scope_id; // 接口范围标识
};
在使用 结构时，通常需要进行类型转换，将其转换为适用于当前协议族的地址结构，并根据需要填充具体的地址信息，然后传递给套接字相关的函数使用。
🐢 sockaddr_in结构
sockaddr_in 是用于存储IPv4地址的套接字地址结构，是在网络编程中非常常用的结构。它用于在IPv4协议族中表示网络地址和端口号。下面是 sockaddr_in 结构的定义：
struct sockaddr_in {
sa_family_t sin_family; // 地址族，固定为 AF_INET
in_port_t sin_port; // 16位端口号，使用网络字节序
struct in_addr sin_addr; // 32位IPv4地址，使用网络字节序
char sin_zero[8]; // 不使用，填充字段
};
其中，各字段的含义如下：
sin_family：地址族，固定为 AF_INET，表示IPv4地址族。
sin_port：16位端口号，使用网络字节序，需要使用 htons 函数进行字节序转换。
sin_addr：32位IPv4地址，使用网络字节序，需要使用 inet_pton 函数将点分十进制形式的IPv4地址转换为网络字节序。
sin_zero：不使用，填充字段，通常设置为0。
使用 结构时，通常先将IPv4地址和端口号填充到该结构中，然后将其转换为通用的 sockaddr_insockaddr 结构，在套接字相关的函数中使用。
例如，在服务器端绑定一个IPv4地址和端口号，可以这样做：
#include <arpa/inet.h>
#include <netinet/in.h>
#include <sys/socket.h>
int main() {
int sockfd = socket(AF_INET, SOCK_STREAM, 0);
if (sockfd < 0) {
perror("socket");
return -1;
}
struct sockaddr_in server_addr;
server_addr.sin_family = AF_INET;
server_addr.sin_port = htons(8080); // 将端口号转换为网络字节序
inet_pton(AF_INET, "127.0.0.1", &server_addr.sin_addr); // 将IPv4地址转换为网络字节序
memset(server_addr.sin_zero, 0, sizeof(server_addr.sin_zero));
if (bind(sockfd, (struct sockaddr*)&server_addr, sizeof(server_addr)) < 0) {
perror("bind");
close(sockfd);
return -1;
}
// 其他操作...
close(sockfd);
return 0;
}
注意，在使用 sockaddr_in 结构时，需要包含 <netinet/in.h> 头文件，并且要进行网络字节序的转换。
🐍 简单的UDP网络程序
🦎log.hpp 日志文件
#pragma once
#include <cstdio>
#include <ctime>
#include <cstdarg>
#include <cassert>
#include <cstring>
#include <cerrno>
#include <stdlib.h>
#define DEBUG 0
#define NOTICE 1
#define WARINING 2
#define FATAL 3
const char *log_level[]={"DEBUG", "NOTICE", "WARINING", "FATAL"};
// logMessage(DEBUG, "%d", 10);
void logMessage(int level, const char *format, ...)
{
assert(level >= DEBUG);
assert(level <= FATAL);
char *name = getenv("USER");
char logInfo[1024];
va_list ap; // ap -> char*
va_start(ap, format);
vsnprintf(logInfo, sizeof(logInfo)-1, format, ap);
va_end(ap); // ap = NULL
FILE *out = (level == FATAL) ? stderr:stdout;
fprintf(out, "%s | %u | %s | %s\n", \
log_level[level], \
(unsigned int)time(nullptr),\
name == nullptr ? "unknow":name,\
logInfo);
// char *s = format;
// while(s){
// case '%':
// if(*(s+1) == 'd') int x = va_arg(ap, int);
// break;
// }
}
🦖 udpClient.cc 客户端
#include <iostream>
#include <string>
#include <cstdlib>
#include <cassert>
#include <unistd.h>
#include <strings.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <pthread.h>
struct sockaddr_in server;
static void Usage(std::string name)
{
std::cout << "Usage:\n\t" << name << " server_ip server_port" << std::endl;
}
void *recverAndPrint(void *args)
{
while (true)
{
int sockfd = *(int *)args;
char buffer[1024];
struct sockaddr_in temp;
socklen_t len = sizeof(temp);
ssize_t s = recvfrom(sockfd, buffer, sizeof(buffer), 0, (struct sockaddr *)&temp, &len);
if (s > 0)
{
buffer[s] = 0;
std::cout << "server echo# " << buffer << std::endl;
}
}
}
// ./udpClient server_ip server_port
// 如果一个客户端要连接server必须知道server对应的ip和port
int main(int argc, char *argv[])
{
if (argc != 3)
{
Usage(argv[0]);
exit(1);
}
// 1. 根据命令行，设置要访问的服务器IP
std::string server_ip = argv[1];
uint16_t server_port = atoi(argv[2]);
// 2. 创建客户端
// 2.1 创建socket
int sockfd = socket(AF_INET, SOCK_DGRAM, 0);
assert(sockfd > 0);
// 2.2 client 需不需要bind??? 需要bind，但是不需要用户自己bind，而是os自动给你bind
// 所谓的"不需要"，指的是: 不需要用户自己bind端口信息！因为OS会自动给你绑定，你也最好这么做！
// 如果我非要自己bind呢？可以！严重不推荐！
// 所有的客户端软件 <-> 服务器 通信的时候，必须得有 client[ip:port] <-> server[ip:port]
// 为什么呢？？client很多，不能给客户端bind指定的port，port可能被别的client使用了，你的client就无法启动了
// 那么server凭什么要bind呢？？server提供的服务，必须被所有人知道！server不能随便改变！
// 2.2 填写服务器对应的信息
bzero(&server, sizeof server);
server.sin_family = AF_INET;
server.sin_port = htons(server_port);
server.sin_addr.s_addr = inet_addr(server_ip.c_str());
pthread_t t;
pthread_create(&t, nullptr, recverAndPrint, (void *)&sockfd);
// 3. 通讯过程
std::string buffer;
while (true)
{
std::cerr << "Please Enter# ";
std::getline(std::cin, buffer);
// 发送消息给server
sendto(sockfd, buffer.c_str(), buffer.size(), 0,
(const struct sockaddr *)&server, sizeof(server)); // 首次调用sendto函数的时候，我们的client会自动bind自己的ip和port
}
close(sockfd);
return 0;
}
🦕 udpServer.cc 服务器
#include <iostream>
#include <string>
#include <cstring>
#include <unistd.h>
#include <stdlib.h>
#include <ctype.h>
#include <unordered_map>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include "log.hpp"
static void Usage(const std::string porc)
{
std::cout << "Usage:\n\t" << porc << " port [ip]" << std::endl;
}
class udpServer
{
public:
udpServer(int port, std::string ip = "") : port_((uint16_t)port), ip_(ip), sockfd_(-1)
{
}
~udpServer()
{
}
void init()//初始化函数
{
//1.创建套接字
sockfd_=socket(AF_INET,SOCK_DGRAM,0);
// 参数1：套接字的协议族 `AF_INET`: IPv4协议族，用于Internet地址。
//参数2：套接字类型 `SOCK_DGRAM`: 面向消息的套接字，用于不可靠的、固定长度的数据传输（如UDP）。
//参数3：套接字的协议 0，让系统自动选择合适的协议。
if(sockfd_<0) //创建失败 打印日志信息
{
logMessage(FATAL, "socket:%s:%d", strerror(errno), sockfd_);
exit(1);
}
//到这说明 创建成功
logMessage(DEBUG, "socket create success: %d", sockfd_);
struct sockaddr_in local; // local在哪里开辟的空间? 用户栈 -> 临时变量 -> 写入内核中
bzero(&local, sizeof(local)); // memset
// 填充协议家族，域
local.sin_family = AF_INET;
// 填充服务器对应的端口号信息，一定是会发给对方的，port_一定会到网络中
local.sin_port = htons(port_);
// 服务器都必须具有IP地址,"xx.yy.zz.aaa",字符串风格点分十进制 -> 4字节IP -> uint32_t ip
// INADDR_ANY(0): 程序员不关心会bind到哪一个ip， 任意地址bind，强烈推荐的做法，所有服务器一般的做法
// inet_addr: 指定填充确定的IP，特殊用途，或者测试时使用，除了做转化，还会自动给我们进行 h—>n
local.sin_addr.s_addr = ip_.empty() ? htonl(INADDR_ANY) : inet_addr(ip_.c_str());
// 2.2 bind 网络信息
if (bind(sockfd_, (const struct sockaddr *)&local, sizeof(local)) == -1)
{
logMessage(FATAL, "bind: %s:%d", strerror(errno), sockfd_);
exit(2);
}
logMessage(DEBUG, "socket bind success: %d", sockfd_);
// done
}
void start()
{
// 服务器设计的时候，服务器都是死循环
char inbuffer[1024]; //将来读取到的数据，都放在这里
char outbuffer[1024]; //将来发送的数据，都放在这里
while (true)
{
struct sockaddr_in peer; //输出型参数
socklen_t len = sizeof(peer); //输入输出型参数
// demo2
// UDP无连接的
// 对方给你发了消息，你想不想给对方回消息？要的！后面的两个参数是输出型参数
ssize_t s = recvfrom(sockfd_, inbuffer, sizeof(inbuffer) - 1, 0,
(struct sockaddr *)&peer, &len);
if (s > 0)
{
inbuffer[s] = 0; //当做字符串
}
else if (s == -1)
{
logMessage(WARINING, "recvfrom: %s:%d", strerror(errno), sockfd_);
continue;
}
// 读取成功的,除了读取到对方的数据，你还要读取到对方的网络地址[ip:port]
std::string peerIp = inet_ntoa(peer.sin_addr); //拿到了对方的IP
uint32_t peerPort = ntohs(peer.sin_port); // 拿到了对方的port
checkOnlineUser(peerIp, peerPort, peer); //如果存在，什么都不做，如果不存在，就添加
// 打印出来客户端给服务器发送过来的消息
logMessage(NOTICE, "[%s:%d]# %s", peerIp.c_str(), peerPort, inbuffer);
// for(int i = 0; i < strlen(inbuffer); i++)
// {
// if(isalpha(inbuffer[i]) && islower(inbuffer[i])) outbuffer[i] = toupper(inbuffer[i]);
// else outbuffer[i] = toupper(inbuffer[i]);
// }
messageRoute(peerIp, peerPort,inbuffer); //消息路由
// 线程池！
// sendto(sockfd_, outbuffer, strlen(outbuffer), 0, (struct sockaddr*)&peer, len);
// demo1
// logMessage(NOTICE, "server 提供 service 中....");
// sleep(1);
}
}
void checkOnlineUser(std::string &ip, uint32_t port, struct sockaddr_in &peer)
{
std::string key = ip;
key += ":";
key += std::to_string(port);
auto iter = users.find(key);
if(iter == users.end())
{
users.insert({key, peer});
}
else
{
// iter->first, iter->second->
// do nothing
}
}
void messageRoute(std::string ip, uint32_t port, std::string info)
{
std::string message = "[";
message += ip;
message += ":";
message += std::to_string(port);
message += "]# ";
message += info;
for(auto &user : users)
{
sendto(sockfd_, message.c_str(), message.size(), 0, (struct sockaddr*)&(user.second), sizeof(user.second));
}
}
private:
// 服务器必须得有端口号信息
uint16_t port_;
// 服务器必须得有ip地址
std::string ip_;
// 服务器的socket fd信息
int sockfd_;
// onlineuser
std::unordered_map<std::string, struct sockaddr_in> users;
};
int main(int argc, char *argv[])
{
if (argc != 2 && argc != 3) //反面：argc == 2 || argc == 3
{
Usage(argv[0]);
exit(3);
}
uint16_t port = atoi(argv[1]);
std::string ip;
if (argc == 3)
{
ip = argv[2];
}
udpServer svr(port, ip);
svr.init();
svr.start();
return 0;
}
🐙 makefile文件
.PHONY:all
all:udpClient udpServer
udpClient: UCPClient.cc
g++ -o $@ $^ -std=c++11 -lpthread
udpServer:UDPServer.cc
g++ -o $@ $^ -std=c++11
.PHONY:clean
clean:
rm -f udpClient udpServer
运行:
设置对对应的端口号就行
🦑 🦐 🦞 🦀 🐡 🐠 🐟 🐬 🐳 🐋 🦈 🐊 🐅 🐆 🦓 🦍 🦧 🦣 🐘 🦛
