Linux系统编程-网络编程

最新推荐文章于 2025-10-21 11:52:03 发布

原创最新推荐文章于 2025-10-21 11:52:03 发布 · 575 阅读

1 ·

本内容遵循CC 4.0 BY-SA版权协议

收录于

Linux

本文介绍了网络编程中的Socket概念，包括其起源、作用以及在Unix/Linux系统中的实现方式。详细讲解了套接字描述符、字节序的重要性，并提供了Socket服务器和客户端的开发步骤，包括创建、绑定、监听、接受、读写等关键API的使用。此外，还讨论了TCP/UDP的区别和端口号的作用。

网络编程（Socket）概述

前面几篇文章的进程间通讯均基于同一台Linux内核实现的，因此无法实现多机（和手机、单片机、X86架构等）通讯，因此引入网络通讯，入门先学习Socket（又叫做套接字）网络编程。

网络编程通识扫盲

TCP/UDP 对比

端口号作用

socket套接字

socket起源于Unix，而Unix/Linux基本哲学之一就是“一切皆文件”，都可以用“打开open –> 读写write/read –> 关闭close”模式来操作。Socket就是该模式的一个实现， socket即是一种特殊的文件，一些socket函数就是对其进行的操作（读/写IO、打开、关闭）。

Socket是应用层与TCP/IP协议族通信的中间软件抽象层，它是一组接口。在设计模式中，Socket其实就是一个门面模式，它把复杂的TCP/IP协议族隐藏在Socket接口后面，对用户来说，一组简单的接口就是全部，让Socket去组织数据，以符合指定的协议。

套接字描述符

其实就是一个整数，我们最熟悉的句柄是0、1、2三个，0是标准输入，1是标准输出，2是标准错误输出。0、1、2是整数表示的，对应的FILE *结构的表示就是stdin、stdout、stderr。当应用程序要创建一个套接字时，操作系统就返回一个小整数作为描述符，应用程序则使用这个描述符来引用该套接字需要I/O请求的应用程序请求操作系统打开一个文件。操作系统就创建一个文件描述符提供给应用程序访问文件。从应用程序的角度看，文件描述符是一个整数，应用程序可以用它来读写文件。

字节序

字节序就是字节存储的顺序（从高地址开始存储还是从低地址开始存储），在网络编程中要注意相关协议使用的字节序，防止数据传输出错。具体使用的是字节序转换api，配合端口号使用

字节序
字节序指多字节数据在计算机内存中存储或者网络传输时各字节的存储顺序

常见的字节序
1、Little endian:将低字节存储在起始位置

2、Big endian:将高字节存储在起始位置

例子：内存中双字0x01020304(DWORD)

4000&4001&4002&4003

LE 04 03 02 01小

BE 01 02 03 04大

网络字节序=大端字节序

字节序API

#include <narpa/inet.h>

unit16_t htons(unit16_t host16bitvalue);//返回网络字节序的值
unit32_t htonl(unit32_t host32bitvalue);//返回网络字节序的值
unit16_t ntohs(unit16_t net16bitvalue);//返回主机字节序的值
unit32_t ntohll(unit32_t net32bitvalue);//返回主机字节序的值

h代表host(主机)，n代表net(网络)，s代表short(两个字节)，l代表long(4个字节)，通过上面4个函数可以实现主机字节序和网络字节序的相互转换。有时可以用INADDR_ANY,指定地址让操作系统自己获取

socket编程步骤

步骤介绍

Socket服务器开发步骤
1、创建套接字socket();
2、为套接字添加信息（IP地址、端口号）bind();

3、监听网络连接listen();

4、监听到有客户接入，接受一个连接accept();

5、数据交互 write()\read();

6、关闭套接字，关闭连接close();

Socket客户端开发步骤
1、创建套接字socket();
2、连接connect();

3、数据交互write()/read()
4、闭套接字，关闭连接close();

Socket 服务器API

#include <sys/types.h>
#include <sys/socket.h>

int socket(int domain , int type , int protocol);
函数作用：创建套接字，得到一个socket描述符

domain（领域）:指明使用的协议族，通常为AF_INET,表示互联网协议族（TCP/IP协议族）
AF_INET IPv4因特网域

AF_INET6 IPv6因特网域

AF_UNIX Unix域

AF_ROUTE 路由套接字

AF_KEY 密钥套接字

AF_UNSPEC 未指定

type:指定socket的类型：

SOCK_STREAM:

流式套接字提供可靠的、面向连接的通信流，它使用TCP协议，从而保证了数据传输的正确性和顺序性

SOCK_DGRAM:

数据报套接字定义了一种无连接的服务，数据通过相互独立的报文进行传输，是无序的，并且不保证是可靠的，无差错的，它使用UDP协议

SOCK_RAM:

运行程序使用底层协议，原始套接字允许对底层协议和IP或ICMP进行直接访问，功能强大但使用较为不便，主要用于一些协议的开发

protocol（协议）:通常赋值为0

0：选择type类型对应的默认协议
IPPROTO_TCP TCP传输协议

IPPROTO_UDP UDP传输协议

IPPROTO_SCTP SCTP传输协议

IPPROTO_TIPC TICP传输协议

返回值：成功返回socket描述符，失败返回-1，并且errno会被赋予相对应的值

-------------------------------------------------------------------------------------------------------------------------
int bind(int sockfd , const struct sockaddr *addr , socklen_t addrlen);
函数作用：为套接字添加IP,PORT等信息

sockfd:是一个socket描述符，由socket()函数获得

addr:是一个指向包含有本机IP地址及端口号等信息的socketaddr类型指针，指定要绑定给sockfd的协议地址结构，这个地址结构根据地址创建socket时的地址协议族不同而不同
如IPV4，addr结构体如下：
struct sockaddr {
sa_family_t sa_family; //协议族
char sa_data[14]; //IP+端口
}
等同于下面的结构体，下面结构体比较常用：
struct sockaddr_in {
sa_family_t sin_family; //协议族
in_port_t sin_port; //端口号

struct in_addr sin_addr; //IP地址结构体

unsigned char sin_zero[8]; //没有实际意义，只为跟sockaddr结构在内存中对齐，两者才能互相转换
}

addrlen:结构体的长度，使用sizeof来获得

返回值：成功返回0，失败返回-1，并且errno会被赋予相对应的值

-------------------------------------------------------------------------------------------------------------------------
#include <sys/types.h>
#include <sys/socket.h>

int listen(int sockfd, int backlog);

函数作用：监听网络连接，设置最大连接数量

sockfd:是一个socket描述符，由socket()函数获得

backlog:最大连接数量（包括连接成功和正在连接的）

返回值：成功返回0，失败返回-1，并且errno会被赋予相对应的值

-------------------------------------------------------------------------------------------------------------------------
#include <sys/types.h>
#include <sys/socket.h>

int accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen);

函数作用：调用该函数会使线程阻塞，直到有客户端接入

sockfd:是一个socket描述符，由socket()函数获得

addr：用来返回已经连接的对端（客户端）的协议地址

如IPV4，addr结构体如下：
struct sockaddr {
sa_family_t sa_family; //协议族
char sa_data[14]; //IP+端口
}
等同于下面的结构体，下面结构体比较常用：
struct sockaddr_in {
sa_family_t sin_family; //协议族
in_port_t sin_port; //端口号

struct in_addr sin_addr; //IP地址结构体

unsigned char sin_zero[8]; //没有实际意义，只为跟sockaddr结构在内存中对齐，两者才能互相转换
}

addrled:客户端地址长度，使用sizeof来获得

返回值：成功返回新的被连接socket描述符，失败返回-1，并且errno会被赋予相对应的值

-------------------------------------------------------------------------------------------------------------------------
int close(int fd);

函数作用：关闭套接字描述符

返回值：成功返回0，失败返回-1，并且errno会被赋予相对应的值
————————————————

字节流读写API

ssize_t write(int fd , const void *buf , size_t nbytes);
ssize_t read(int fd , const void *buf , size_t nbytes);
函数作用：对字节流进行读写操作，read()函数会使线程阻塞，直到读到数据或错误

返回值：成功返回读写的字节个数，失败返回-1

-------------------------------------------------------------------------------------------------------------------------
#include <sys/types.h>
#include <sys/socket.h>

ssize_t send(int sockfd, const void *buf, size_t len, int flags);
ssize_t recv(int sockfd, void *buf, size_t len, int flags);
flags:控制选项，一般设置为0

-------------------------------------------------------------------------------------------------------------------------
recvmsg()/snedmsg(),recvfrom()/sendto() API用于UDP通信
————————————————

地址转换API

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

int inet_aton(const char *straddr,struct in_addr *addrp);
把字符串形式的“192.168.1.1”转换为网络能识别的格式

char *inet_ntoa(struct in_addr inaddr);
把网络格式的IP转换为字符串格式

typedef uint32_t in_addr_t;

struct in_addr {
in_addr_t s_addr;
};

Socket客户端API

#include <sys/types.h>
#include <sys/socket.h>

int socket(int domain , int type , int protocol);
函数作用：创建套接字，得到一个socket描述符

domain（领域）:指明使用的协议族，通常为AF_INET,表示互联网协议族（TCP/IP协议族）
AF_INET IPv4因特网域

AF_INET6 IPv6因特网域

AF_UNIX Unix域

AF_ROUTE 路由套接字

AF_KEY 密钥套接字

AF_UNSPEC 未指定

type:指定socket的类型：

SOCK_STREAM:

流式套接字提供可靠的、面向连接的通信流，它使用TCP协议，从而保证了数据传输的正确性和顺序性

SOCK_DGRAM:

数据报套接字定义了一种无连接的服务，数据通过相互独立的报文进行传输，是无序的，并且不保证是可靠的，无差错的，它使用UDP协议

SOCK_RAM:

运行程序使用底层协议，原始套接字允许对底层协议和IP或ICMP进行直接访问，功能强大但使用较为不便，主要用于一些协议的开发

protocol（协议）:通常赋值为0

0：选择type类型对应的默认协议
IPPROTO_TCP TCP传输协议

IPPROTO_UDP UDP传输协议

IPPROTO_SCTP SCTP传输协议

IPPROTO_TIPC TICP传输协议

返回值：成功返回socket描述符，失败返回-1，并且errno会被赋予相对应的值

-------------------------------------------------------------------------------------------------------------------------

int connect(int sockfd, const struct sockaddr *addr,socklen_t addrlen);
函数作用：

sockfd:是一个socket描述符，由socket()函数获得

addr：服务器的IP地址和端口号结构体指针

如IPV4，addr结构体如下：
struct sockaddr {
sa_family_t sa_family; //协议族
char sa_data[14]; //IP+端口
}
等同于下面的结构体，下面结构体比较常用：
struct sockaddr_in {
sa_family_t sin_family; //协议族
in_port_t sin_port; //端口号

struct in_addr sin_addr; //IP地址结构体

unsigned char sin_zero[8]; //没有实际意义，只为跟sockaddr结构在内存中对齐，两者才能互相转换
}

addrlen:地址长度通常设置为sizeof(struct sockaddr)

返回值：成功返回0，失败返回-1，并且errno会被赋予相对应的值

-------------------------------------------------------------------------------------------------------------------------
int close(int fd);
函数作用：关闭套接字描述符

返回值：成功返回0，失败返回-1，并且errno会被赋予相对应的值
————————————————

socket服务端代码实现

server.c

#include <stdio.h>
#include <sys/types.h>      
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>

      



int main(int argc, char const *argv[])
{
	int s_fd;
	int c_fd;
	int n_read;
	int n_write;
	char readBuf[128];
	char *returnMsg="我收到了你的信息";//发送给客户端的消息 尽量不使用数组
	
	struct sockaddr_in c_addr;
	struct sockaddr_in s_addr;
	memset(&c_addr,0,sizeof(struct sockaddr_in));
	memset(&s_addr,0,sizeof(struct sockaddr_in));//数据清空 再配置

	//1.socket  int socket(int domain, int type, int protocol);
	s_fd=socket(AF_INET,SOCK_STREAM,0);
				//ipv4   tcp协议
	if(s_fd == -1){
		printf("创建socket失败");
		perror("socket:");
		exit(-1);

	}
	
	//2.bind  int bind(int sockfd, const struct sockaddr *addr, socklen_t addrlen);

	s_addr.sin_family=AF_INET;//ipv4
	s_addr.sin_port=htons(8687);//端口号，选择5000以上(有些端口被系统调用)。honts返回网络字节序
	//int inet_aton(const char *cp, struct in_addr *inp)
	
	inet_aton("192.168.103.49",&s_addr.sin_addr)
	//inet_aton("127.0.0.1",&s_addr.sin_addr);//sin_addr是结构体sockaddr_in里面的结构体 存放IP（下面有查找到原型）   然后转换为网络能识别的格式
	//或者使用ifconfig命令查到实际本机的IP也可以
	bind(s_fd,(struct sockaddr *)&s_addr,sizeof(struct sockaddr_in));
               //结构体类型转换，因为用的同等替换的结构体sockaddr_in
               
	//3.listen int listen(int sockfd, int backlog);
	listen(s_fd,10);//监听10个连接


	//4.accept int accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen);
	int client=sizeof(struct sockaddr_in);       //要求用指针（存放长度）
	c_fd=accept(s_fd,(struct sockaddr *)&c_addr,&client);
	                    //sockaddr_in进行类型强转 存放客户端信息
	if(c_fd == -1){
		printf("连接失败\n");
		perror("accept:");
		exit(-1);

	}
	                                  //客户端
	printf("客户端的ip：%s\n",inet_ntoa(c_addr.sin_addr)); //把网络格式的ip地址打印成字符串格式
	
	
	//5.read  ssize_t read(int fd, void *buf, size_t count);
	n_read=read(c_fd,readBuf,128);  //c_fd客户端
	if(n_read == -1){
		perror("read:");
	}else{
		printf("得到的消息:%d,%s\n",n_read,readBuf);
	}
	
	//6.write ssize_t write(int fd, const void *buf, size_t count);
	n_write=write(c_fd,returnMsg,strlen(returnMsg));
	return 0;
}

利用telnet的方式进行通信

Tips：在user/include目录下查找头文件。查找结构体sockaddr_in的定义原型、使用了哪个头文件时，我们可以用grep xx* -nir 来实现（n:显示行号；i：不区分大小写；r：递归）。

实现双方（多方）一直聊天

本质就是上面的代码加入while循环，实现不断的消息收发

第一次是在accept后（即三次握手成功后）创建进程，实现和多个客户端的通信；
第二次fork()创建进程应用在和客户端通信“写”的过程，而“读”放在while循环中，这样就实现了读和写并行运行

客户端仅用fork创建了一个进程，同样应用在“写”，“读”放在while循环中，这样就实现了读和写并行运行。

服务端代码：

#include <stdio.h>
#include <sys/types.h>      
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
     

int main(int argc, char const *argv[])
{
	int s_fd;
	int c_fd;
	int n_read;
	int n_write;
	char readBuf[128];
	char returnMsg[128]={0};
	struct sockaddr_in c_addr;
	struct sockaddr_in s_addr;
	memset(&c_addr,0,sizeof(struct sockaddr_in));
	memset(&s_addr,0,sizeof(struct sockaddr_in));//数据清空
	if(argc != 3){
		printf("参数出错\n");
		exit(-1);
	}
	//1.socket  int socket(int domain, int type, int protocol);
	s_fd=socket(AF_INET,SOCK_STREAM,0);
				//ipv4   tcp协议
	if(s_fd == -1){
		printf("创建socket失败");
		perror("socket:");
		exit(-1);

	}
	//2.bind  int bind(int sockfd, const struct sockaddr *addr, socklen_t addrlen);

	s_addr.sin_family=AF_INET;//ipv4
	s_addr.sin_port=htons(atoi(argv[2]));//端口号，选择5000以上。honts返回网络字节序,atoi(argv[2])防止端口被占用
	//int inet_aton(const char *cp, struct in_addr *inp)
	inet_aton(argv[1],&s_addr.sin_addr);//转换为网络能识别的格式
	bind(s_fd,(struct sockaddr *)&s_addr,sizeof(struct sockaddr_in));

	//3.listen int listen(int sockfd, int backlog);
	listen(s_fd,10);//监听10个连接

	//4.accept int accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen);
	int client=sizeof(struct sockaddr_in);
	while(1){//不断接收客户端
		c_fd=accept(s_fd,(struct sockaddr *)&c_addr,&client);
		if(c_fd == -1){
			printf("连接失败\n");
			perror("accept:");
			exit(-1);

		}
		printf("客户端的ip：%s\n",inet_ntoa(c_addr.sin_addr)); //把网络格式的ip地址打印成字符串格式
		if(fork() == 0){
			if(fork() == 0){
				while(1){//不断写入
					memset(returnMsg,0,sizeof(returnMsg));
					printf("请输入：\n");
					gets(returnMsg);
					//6.write ssize_t write(int fd, const void *buf, size_t count);
					n_write=write(c_fd,returnMsg,strlen(returnMsg));
				}
			}
			while(1){//不断读取
				//5.read  ssize_t read(int fd, void *buf, size_t count);
				memset(readBuf,0,sizeof(readBuf));//不断清空数据防止数据重复出现
				n_read=read(c_fd,readBuf,128);
				if(n_read == -1){
					perror("read:");
				}else{
					printf("得到的消息:%d,%s\n",n_read,readBuf);
				}
			}
			
		}
	}
	return 0;
}

客户端代码:

#include <stdio.h>
#include <sys/types.h>      
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>


int main(int argc, char const *argv[])
{
	int ret;
	int c_fd;
	int n_read;
	int n_write;
	int c_connect;
	char readBuf[128];
	char returnMsg[128]={0};
	char *quit="quit";
	struct sockaddr_in c_addr;
	memset(&c_addr,0,sizeof(struct sockaddr_in));//数据清空
	if(argc != 3){
		printf("参数出错\n");
		exit(-1);
	}
	//1.socket  int socket(int domain, int type, int protocol);
	c_fd=socket(AF_INET,SOCK_STREAM,0);
				//ipv4   tcp协议
	if(c_fd == -1){
		printf("创建socket失败");
		perror("socket:");
		exit(-1);

	}
	c_addr.sin_family=AF_INET;//ipv4
	c_addr.sin_port=htons(atoi(argv[2]));//端口号，选择5000以上。honts返回网络字节序
	//int inet_aton(const char *cp, struct in_addr *inp)
	inet_aton(argv[1],&c_addr.sin_addr);//转换为网络能识别的格式
	//2.connect  int connect(int sockfd, const struct sockaddr *addr,socklen_t addrlen);
    c_connect=connect(c_fd,(struct sockaddr *)&c_addr,sizeof(struct sockaddr));
    if(c_connect == -1){
    	printf("连接失败\n");
    	perror("connect:");
    }
	while(1){
		if(fork() == 0){
			while(1){//不断写入
				memset(returnMsg,0,sizeof(returnMsg));
				printf("请输入:\n");
				gets(returnMsg);
				//3.write/send ssize_t write(int fd, const void *buf, size_t count);
				n_write=write(c_fd,returnMsg,strlen(returnMsg));
				if(strcmp(quit,returnMsg) == 0){//如果输入quit则客户端就退出
					exit(0);
				
				}
			}
		}
		while(1){//不断读取
			memset(readBuf,0,sizeof(readBuf));//不断清空数据防止数据重复出现
			//4.read  ssize_t read(int fd, void *buf, size_t count);
			n_read=read(c_fd,readBuf,128);
			if(n_read == -1){
				perror("read:");
			}else{
				printf("来自服务端的消息:%d,%s\n",n_read,readBuf);
			}
		}
		//5.close     int close(int fd);

		close(c_fd);
	}
	return 0;
}

多方消息收发

上一节代码其实已经可以实现多方通信了，不过存在两个问题：

1、客户端发消息回车的那一瞬间，光标不知道被哪个进程抢到了，也就是说服务器同一时刻发送的消息，不能确定哪个客户端子进程收到消息。
2、客户端之间无法进行互相通讯。

下面的demo加入了类似心跳包的功能，用来说明服务端其实是知道哪个客户端发来的消息，并且每隔两秒给每个客户端回复

如果想要完全实现类似QQ聊天机制，思路就是将服务端作为中转站，客户端和客户端之间通过服务器完成聊天功能。当然客户端之间要提前建立“好友”关系，所谓的好友关系可以通过sqlite数据库存储每个客户端的IP、端口、账号等信息，然后服务端后台对这些进行逻辑处理，实现客户端之间的类似QQ聊天机制。

服务端代码

#include <stdio.h>
#include <sys/types.h>      
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>

      



int main(int argc, char const *argv[])
{
	int mark=0;
	int s_fd;
	int c_fd;
	int n_read;
	int n_write;
	char readBuf[128];
	char returnMsg[128]={0};
	struct sockaddr_in c_addr;
	struct sockaddr_in s_addr;
	memset(&c_addr,0,sizeof(struct sockaddr_in));
	memset(&s_addr,0,sizeof(struct sockaddr_in));//数据清空
	if(argc != 3){
		printf("参数出错\n");
		exit(-1);
	}
	//1.socket  int socket(int domain, int type, int protocol);
	s_fd=socket(AF_INET,SOCK_STREAM,0);
				//ipv4   tcp协议
	if(s_fd == -1){
		printf("创建socket失败");
		perror("socket:");
		exit(-1);

	}
	//2.bind  int bind(int sockfd, const struct sockaddr *addr, socklen_t addrlen);

	s_addr.sin_family=AF_INET;//ipv4
	s_addr.sin_port=htons(atoi(argv[2]));//端口号，选择5000以上。honts返回网络字节序,atoi(argv[2])防止端口被占用
	//int inet_aton(const char *cp, struct in_addr *inp)
	inet_aton(argv[1],&s_addr.sin_addr);//转换为网络能识别的格式
	bind(s_fd,(struct sockaddr *)&s_addr,sizeof(struct sockaddr_in));

	//3.listen int listen(int sockfd, int backlog);
	listen(s_fd,10);//监听10个连接

	//4.accept int accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen);
	int client=sizeof(struct sockaddr_in);
	while(1){//不断接收客户端
		c_fd=accept(s_fd,(struct sockaddr *)&c_addr,&client);
		if(c_fd == -1){
			printf("连接失败\n");
			perror("accept:");
			exit(-1);

		}
		printf("客户端的ip：%s\n",inet_ntoa(c_addr.sin_addr)); //把网络格式的ip地址打印成字符串格式
		mark++;
		if(fork() == 0){
			if(fork() == 0){
				while(1){
					sprintf(returnMsg,"欢迎第%d号客户端",mark);
					//6.write ssize_t write(int fd, const void *buf, size_t count);
					n_write=write(c_fd,returnMsg,strlen(returnMsg));
					sleep(20);
				}
			}
			while(1){
				//5.read  ssize_t read(int fd, void *buf, size_t count);
				memset(readBuf,0,sizeof(readBuf));
				n_read=read(c_fd,readBuf,128);
				if(n_read == -1){
					perror("read:");
				}else if(n_read == 0){
                    printf("客户端退出\n");
                    break;
                }else{
					printf("得到%d号的消息:%s\n",mark,readBuf);
				}
			}
		}
	}
	return 0;
}

客户端代