Linux使用C语言实现Socket编程

Socket编程

这一个课程的笔记
相关文章
协议
Socket编程
高并发服务器实现
线程池

网络套接字

socket: （电源）插座（电器上的）插口，插孔，管座

在通信过程中, 套接字是成对存在的, 一个客户端的套接字, 一个服务器的套接字

img

**在网络通信中，套接字一定是成对出现的。**一端的发送缓冲区对应对端的接收缓冲区。我们使用同一个文件描述符索发送缓冲区和接收缓冲区。

为TCP/IP协议设计的应用层编程接口称为socket API。

img

网络字节序

我们已经知道，内存中的多字节数据相对于内存地址有大端和小端之分，磁盘文件中的多字节数据相对于文件中的偏移地址也有大端小端之分。网络数据流同样有大端小端之分，那么如何定义网络数据流的地址呢？发送主机通常将发送缓冲区中的数据按内存地址从低到高的顺序发出，接收主机把从网络上接到的字节依次保存在接收缓冲区中，也是按内存地址从低到高的顺序保存，因此，网络数据流的地址应这样规定：先发出的数据是低地址，后发出的数据是高地址。

小段法: 高位的数据在高地址, 低位的数据在低地址(计算机本地使用)

大端法: 高位在地地址, 低位在高地址(网络使用)

TCP/IP协议规定，网络数据流应采用大端字节序，即低地址高字节。例如上一节的UDP段格式，地址0-1是16位的源端口号，如果这个端口号是1000（0x3e8），则地址0是0x03，地址1是0xe8，也就是先发0x03，再发0xe8，这16位在发送主机的缓冲区中也应该是低地址存0x03，高地址存0xe8。但是，如果发送主机是小端字节序的，这16位被解释成0xe803，而不是1000。因此，发送主机把1000填到发送缓冲区之前需要做字节序的转换。同样地，接收主机如果是小端字节序的，接到16位的源端口号也要做字节序的转换。如果主机是大端字节序的，发送和接收都不需要做转换。同理，32位的IP地址也要考虑网络字节序和主机字节序的问题。

为使网络程序具有可移植性，使同样的C代码在大端和小端计算机上编译后都能正常运行，可以调用以下库函数做网络字节序和主机字节序的转换。

#include <arpa/inet.h>uint32_t htonl(uint32_t hostlong); //本地到网络, 主要是IP
uint16_t htons(uint16_t hostshort);//本地到网络, 这一个主要是端口
uint32_t ntohl(uint32_t netlong);
uint16_t ntohs(uint16_t netshort);

h表示host，n表示network，l表示32位长整数，s表示16位短整数。

如果主机是小端字节序，这些函数将参数做相应的大小端转换然后返回，如果主机是大端字节序，这些函数不做转换，将参数原封不动地返回。

IP地址转换函数

#include <arpa/inet.h>
int inet_pton(int af, const char *src, void *dst);
const char *inet_ntop(int af, const void *src, char *dst, socklen_t size);

支持IPv4和IPv6\

This function converts the character string src into a network address structure in the af address family, then copies the network address struc‐ture to dst. The af argument must be either AF_INET or AF_INET6. dst is written in network byte order.

af : 使用的协议, 可以使用两个宏定义

AF_INET: IPV4

AF_INET6: IPV6

src: 源字符串

dst: 获取到的转换后的网络字节序的IP地址

返回值: 1成功, 0:这一个src不是一个有效的ip地址

网络套接字函数

socket模型创建流程图

img

sockaddr数据结构

strcut sockaddr 很多网络编程函数诞生早于IPv4协议，那时候都使用的是sockaddr结构体,为了向前兼容，现在sockaddr退化成了（void *）的作用，传递一个地址给函数，至于这个函数是sockaddr_in还是sockaddr_in6，由地址族确定，然后函数内部再强制类型转化为所需的地址类型。

可参看 man 7 ip

img

从左向右依次进化

sockaddr数据结构

struct sockaddr {sa_family_t sa_family;   /* address family, AF_xxx */char sa_data[14];     /* 14 bytes of protocol address */};

使用 sudo grep -r “struct sockaddr_in {” /usr 命令可查看到struct sockaddr_in结构体的定义。一般其默认的存储位置：/usr/include/linux/in.h 文件中。

这一个struct sockaddr_in这一个是实际使用的参数, 使用的时候需要进行一个强制转换, 这是因为这一个函数设计的时间比较早, 为了兼容早期的程序

struct sockaddr_in {__kernel_sa_family_t sin_family;      /* Address family   地址结构类型, 可以使用AF_INET表示ipv4 */__be16 sin_port;               /* Port number    端口号 使用函数htons*/struct in_addr sin_addr;          /* Internet address  IP地址, 这一个需要使用inet_pton进行转换 , 这一个可以使用宏定义INADDR_ANY获取当前的有效的IP地址, 之后使用htonl转换一下*//* Pad to size of `struct sockaddr'. */unsigned char __pad[__SOCK_SIZE__ - sizeof(short int) -sizeof(unsigned short int) - sizeof(struct in_addr)];};struct in_addr {            /* Internet address. */__be32 s_addr;};struct sockaddr_in6 {unsigned short int sin6_family;     /* AF_INET6 */__be16 sin6_port;          /* Transport layer port # */__be32 sin6_flowinfo;        /* IPv6 flow information */struct in6_addr sin6_addr;     /* IPv6 address */__u32 sin6_scope_id;        /* scope id (new in RFC2553) */};struct in6_addr {union {__u8 u6_addr8[16];__be16 u6_addr16[8];__be32 u6_addr32[4];} in6_u;#define s6_addr     in6_u.u6_addr8#define s6_addr16    in6_u.u6_addr16#define s6_addr32    in6_u.u6_addr32};#define UNIX_PATH_MAX 108struct sockaddr_un {__kernel_sa_family_t sun_family;  /* AF_UNIX */char sun_path[UNIX_PATH_MAX];  /* pathname */};

Pv4和IPv6的地址格式定义在netinet/in.h中，IPv4地址用sockaddr_in结构体表示，包括16位端口号和32位IP地址，IPv6地址用sockaddr_in6结构体表示，包括16位端口号、128位IP地址和一些控制字段。UNIX Domain Socket的地址格式定义在sys/un.h中，用sock-addr_un结构体表示。各种socket地址结构体的开头都是相同的，前16位表示整个结构体的长度（并不是所有UNIX的实现都有长度字段，如Linux就没有），后16位表示地址类型。

IPv4、IPv6和Unix Domain Socket的地址类型分别定义为常数AF_INET、AF_INET6、AF_UNIX。这样，只要取得某种sockaddr结构体的首地址，不需要知道具体是哪种类型的sockaddr结构体，就可以根据地址类型字段确定结构体中的内容。因此，socket API可以接受各种类型的sockaddr结构体指针做参数，例如bind、accept、connect等函数，这些函数的参数应该设计成void *类型以便接受各种类型的指针，但是sock API的实现早于ANSI C标准化，那时还没有void *类型，因此这些函数的参数都用struct sockaddr *类型表示，在传递参数之前要强制类型转换一下，例如：

struct sockaddr_in servaddr;
bind(listen_fd, (struct sockaddr *)&servaddr, sizeof(servaddr));   /* initialize servaddr */

网络套接字函数

socket模型创建流程图

img

实际使用的时候客户有一个套接字, 和服务器的一个套接字进行通讯, 服务器还有一个套接字用于监听

这一个监听的客户端设置完成以后, 使用accept函数获取连接, 返回一个新的socket的描述符, 实际通信使用的是这一个新的socket描述符

socket创建一个套接字

#include <sys/types.h> /* See NOTES */#include <sys/socket.h>int socket(int domain, int type, int protocol);

  • domain:

    AF_INET 这是大多数用来产生socket的协议，使用TCP或UDP来传输，用IPv4的地址

    AF_INET6 与上面类似，不过是来用IPv6的地址

    AF_UNIX, AF_LOCAL本地协议，使用在Unix和Linux系统上，一般都是当客户端和服务器在同一台及其上的时候使用

  • type:

    SOCK_STREAM 这个协议是按照顺序的、可靠的、数据完整的基于字节流的连接。这是一个使用最多的socket类型，这个socket是使用TCP来进行传输。

    SOCK_DGRAM 这个协议是无连接的、固定长度的传输调用。该协议是不可靠的，使用UDP来进行它的连接。

    SOCK_SEQPACKET该协议是双线路的、可靠的连接，发送固定长度的数据包进行传输。必须把这个包完整的接受才能进行读取。

    SOCK_RAW socket类型提供单一的网络访问，这个socket类型使用ICMP公共协议。（ping、traceroute使用该协议）

    SOCK_RDM 这个类型是很少使用的，在大部分的操作系统上没有实现，它是提供给数据链路层使用，不保证数据包的顺序

  • protocol:

    传0 表示使用默认协议。

  • 返回值：

    成功：返回指向新创建的socket的文件描述符，失败：返回-1，设置errno

socket()打开一个网络通讯端口，如果成功的话，就像open()一样返回一个文件描述符，应用程序可以像读写文件一样用read/write在网络上收发数据，如果socket()调用出错则返回-1。对于IPv4，domain参数指定为AF_INET。对于TCP协议，type参数指定为SOCK_STREAM，表示面向流的传输协议。如果是UDP协议，则type参数指定为SOCK_DGRAM，表示面向数据报的传输协议。protocol参数的介绍从略，指定为0即可。

bind绑定ip端口

#include <sys/types.h> /* See NOTES */
#include <sys/socket.h>
int bind(int sockfd, const struct sockaddr *addr, socklen_t addrlen);

sockfd：

socket文件描述符

addr:

构造出IP地址加端口号, 这一个结构体实际使用的是sockaddr_in, 里面的协议要和socket一样, 实际传参的时候需要一个类型转换

addrlen:

sizeof(addr)长度

返回值：

成功返回0，失败返回-1, 设置errno

​ 服务器程序所监听的网络地址和端口号通常是固定不变的，客户端程序得知服务器程序的地址和端口号后就可以向服务器发起连接，因此服务器需要调用bind绑定一个固定的网络地址和端口号。

bind()的作用是将参数sockfd和addr绑定在一起，使sockfd这个用于网络通讯的文件描述符监听addr所描述的地址和端口号。前面讲过，struct sockaddr *是一个通用指针类型，addr参数实际上可以接受多种协议的sockaddr结构体，而它们的长度各不相同，所以需要第三个参数addrlen指定结构体的长度。如：

struct sockaddr_in servaddr;
bzero(&servaddr, sizeof(servaddr));
servaddr.sin_family = AF_INET;
servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
servaddr.sin_port = htons(6666);

首先将整个结构体清零，然后设置地址类型为AF_INET，网络地址为INADDR_ANY，这个宏表示本地的任意IP地址，因为服务器可能有多个网卡，每个网卡也可能绑定多个IP地址，这样设置可以在所有的IP地址上监听，直到与某个客户端建立了连接时才确定下来到底用哪个IP地址，端口号为6666。

listen设置监听上限

#include <sys/types.h> /* See NOTES */
#include <sys/socket.h>
int listen(int sockfd, int backlog);

sockfd:

socket文件描述符

backlog:

排队建立3次握手队列和刚刚建立3次握手队列的链接数和, 这一个系统的默认最大值是128

查看系统默认backlog

cat /proc/sys/net/ipv4/tcp_max_syn_backlog

典型的服务器程序可以同时服务于多个客户端，当有客户端发起连接时，服务器调用的accept()返回并接受这个连接，如果有大量的客户端发起连接而服务器来不及处理，尚未accept的客户端就处于连接等待状态，listen()声明sockfd处于监听状态，并且最多允许有backlog个客户端处于连接待状态，如果接收到更多的连接请求就忽略。listen()成功返回0，失败返回-1。

accept阻塞监听客户端

#include <sys/types.h>   /* See NOTES */
#include <sys/socket.h>
int accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen);

sockdf:

socket文件描述符

addr:

传出参数，返回链接客户端地址信息，含IP地址和端口号

addrlen:

传入传出参数（值-结果）,传入sizeof(addr)大小，函数返回时返回真正接收到地址结构体的大小

返回值：

成功返回一个新的socket文件描述符，用于和客户端通信，失败返回-1，设置errno

三方握手完成后，服务器调用accept()接受连接，如果服务器调用accept()时还没有客户端的连接请求，就阻塞等待直到有客户端连接上来。addr是一个传出参数，accept()返回时传出客户端的地址和端口号。addrlen参数是一个传入传出参数（value-result argument），传入的是调用者提供的缓冲区addr的长度以避免缓冲区溢出问题，传出的是客户端地址结构体的实际长度（有可能没有占满调用者提供的缓冲区）。如果给addr参数传NULL，表示不关心客户端的地址。

我们的服务器程序结构是这样的：

while (1) {cliaddr_len = sizeof(cliaddr);connfd = accept(listenfd, (struct sockaddr *)&cliaddr, &cliaddr_len);n = read(connfd, buf, MAXLINE);......close(connfd);}

整个是一个while死循环，每次循环处理一个客户端连接。由于cliaddr_len是传入传出参数，每次调用accept()之前应该重新赋初值。accept()的参数listenfd是先前的监听文件描述符，而accept()的返回值是另外一个文件描述符connfd，之后与客户端之间就通过这个connfd通讯，最后关闭connfd断开连接，而不关闭listenfd，再次回到循环开头listenfd仍然用作accept的参数。accept()成功返回一个文件描述符，出错返回-1。

connect客户连接

#include <sys/types.h>         /* See NOTES */
#include <sys/socket.h>
int connect(int sockfd, const struct sockaddr *addr, socklen_t addrlen);

sockdf:

socket文件描述符

addr:

传入参数，指定服务器端地址信息，含IP地址和端口号

addrlen:

传入参数,传入sizeof(addr)大小

返回值：

成功返回0，失败返回-1，设置errno

客户端需要调用connect()连接服务器，connect和bind的参数形式一致，区别在于bind的参数是自己的地址，而connect的参数是对方的地址。connect()成功返回0，出错返回-1。

之后就可以使用read和write函数进行读写, 进行数据的传递

read的错误:

  1. errno = EINTR 这个被一个信号中断了, 需要再重新读取一次
  2. errno = EAGIN 或 EWOULDBLOCK 以一个非阻塞的模式进行读取, 需要再一次读取
  3. errno = ECONNRESET 连接被重置了需要close, 之后移除监听队列(这一个是服务器端三次握手只进行一般发生RET返回的情景)

如果不使用bind函数绑定客户端的ip和端口, 这一个会隐式绑定

端口复用

socket 网络编程——端口复用技术（setsockopt（））（linux下多个进程监听同一个端口）_linux端口复用怎么区分不同的客户端-CSDN博客

setsockopt函数的作用和说明-CSDN博客

在server的TCP连接没有完全断开之前不允许重新监听是不合理的。因为，TCP连接没有完全断开指的是connfd（127.0.0.1:6666）没有完全断开，而我们重新监听的是lis-tenfd（0.0.0.0:6666），虽然是占用同一个端口，但IP地址不同，connfd对应的是与某个客户端通讯的一个具体的IP地址，而listenfd对应的是wildcard address。解决这个问题的方法是使用setsockopt()设置socket描述符的选项SO_REUSEADDR为1，表示允许创建端口号相同但IP地址不同的多个socket描述符。

int setsockopt(int sockfd, int level, int optname,const void *optval, socklen_t optlen);

optval : 1设置端口复用, 0:设置端口不复用

在server代码的socket()和bind()调用之间插入如下代码：

int opt = 1;
setsockopt(listenfd, SOL_SOCKET, SO_REUSEADDR, (void *)&opt, sizeof(opt));

重用本地地址, 这一个设置需要在bind之前

SO_REUSEADDR提供如下四个功能：

  • 允许启动一个监听服务器并捆绑其众所周知端口，即使以前建立的将此端口用做他们的本地端口的连接仍存在。这通常是重启监听服务器时出现，若不设置此选项，则bind时将出错。
  • 允许在同一端口上启动同一服务器的多个实例，只要每个实例捆绑一个不同的本地IP地址即可。对于TCP，我们根本不可能启动捆绑相同IP地址和相同端口号的多个服务器。
  • 允许单个进程捆绑同一端口到多个套接口上，只要每个捆绑指定不同的本地IP地址即可。这一般不用于TCP服务器。
  • 允许完全重复的捆绑：当一个IP地址和端口绑定到某个套接口上时，还允许此IP地址和端口捆绑到另一个套接口上。一般来说，这个特性仅在支持多播的系统上才有，而且只对UDP套接口而言（TCP不支持多播）。

SO_REUSEPORT有如下语义：

  • 此选项允许完全重复捆绑，但仅在想捆绑相同IP地址和端口的套接口都指定了此套接口选项才行。
  • 如果被捆绑的IP地址是一个多播地址，则SO_REUSEADDR和SO_REUSEPORT等效。

有关setsockopt可以设置的其它选项请参考UNP第7章。

实际的使用流程

  • server

socket: 获取一个socket用于监听

bind: 绑定一下IP地址和端口号

listen: 设置监听的上限

accept: 阻塞监听客户端连接

read: 读取信息

NAME
recv, recvfrom, recvmsg - receive a message from a socket

SYNOPSIS

#include <sys/types.h>
#include <sys/socket.h>
ssize_t recv(int sockfd, void *buf, size_t len, int flags);

这一个函数和read的区别只有flags参数的不同, 使用0的时候和read一样

write:发送信息

NAME
send, sendto, sendmsg - send a message on a socket

SYNOPSIS

#include <sys/types.h>
#include <sys/socket.h>
ssize_t send(int sockfd, const void *buf, size_t len, int flags);

close

  • client

socket

connect:创建数据

write: 写入数据

read: 读取数据

close

示例

服务器
#include <ctype.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <errno.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <arpa/inet.h>#define SERV_PORT				9078int main(void){int lfd = 0, cfd;struct sockaddr_in serv_addr, clit_addr;socklen_t clit_addr_len;char buf[BUFSIZ];lfd = socket(AF_INET, SOCK_STREAM, 0);if(lfd == -1){perror("socket error\n");exit(0);}serv_addr.sin_family = AF_INET;				//使用IPV4serv_addr.sin_port = htons(SERV_PORT);		//设置端口serv_addr.sin_addr.s_addr = htonl(INADDR_ANY);//设置检测本地的所有ipint ret = bind(lfd, (struct sockaddr *)&serv_addr, sizeof(serv_addr));if(ret != 0){perror("bind error\n");exit(0);}ret = listen(lfd, 128);						//设置最大的处理个数if(ret != 0){perror("listen error\n");exit(0);}clit_addr_len = sizeof(clit_addr);cfd = accept(lfd, (struct sockaddr *)&clit_addr, &clit_addr_len);	//设置阻塞if(cfd == -1){perror("sccept error\n");exit(1);}while(1){ret = read(cfd, buf, sizeof(buf));if(ret < 0){perror("read error\n");exit(1);}else if(ret == 0){break;}write(STDOUT_FILENO , buf, ret);for(int i = 0;i<ret;i++){buf[i] = toupper(buf[i]);		//获取的数据转换为大写}write(cfd, buf, ret);}close(cfd);close(lfd);return 0;
}

image-20240404114734669

cfd = accept(lfd, (struct sockaddr *)&clit_addr, &clit_addr_len);
if(cfd == -1){perror("sccept error\n");exit(1);
}
printf("client ip: %s port %d\n", inet_ntop(AF_INET, &clit_addr.sin_addr.s_addr, buf, sizeof(buf)), ntohs(clit_addr.sin_port));

可以使用这一个获取连接的客户端的信息

客户端
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <errno.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <arpa/inet.h>
int main(void){int cfd;	cfd = socket(AF_INET, SOCK_STREAM, 0);if(cfd == -1){perror("socket error");exit(1);}struct sockaddr_in c_sock;int ip_addr;inet_pton(AF_INET, "127.0.0.1", &ip_addr);//获取ip地址的二进制小端数据c_sock.sin_addr.s_addr = ip_addr;c_sock.sin_port = htons(9078);c_sock.sin_family = AF_INET;int ret = connect(cfd, (struct sockaddr *)&c_sock, sizeof(c_sock));//连接if(ret == -1){perror("connect error");exit(1);}char buf[1024];while(1){int len = read(STDIN_FILENO, buf, sizeof(buf));//获取输入write(cfd, buf, len);//发送信息len = read(cfd, buf, sizeof(buf));//获取返回值write(STDOUT_FILENO, buf, len);//显示}return 0;
}

这一个实现的功能是从stdin获取信息发送给服务器, 之后打印服务器的返回值

多进程处理
#include <ctype.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <errno.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <arpa/inet.h>#define SERV_PORT				9078
void deal_one_server(struct sockaddr_in *clit_addr, int cfd){int ret;char buf[1024];printf("client ip: %s port %d\n", inet_ntop(AF_INET, &clit_addr->sin_addr.s_addr, buf, sizeof(buf)), ntohs(clit_addr->sin_port));while(1){ret = read(cfd, buf, sizeof(buf));if(ret < 0){perror("read error\n");exit(1);}else if(ret == 0){break;}write(STDOUT_FILENO , buf, ret);for(int i = 0;i<ret;i++){buf[i] = toupper(buf[i]);}write(cfd, buf, ret);}
}
int main(void){int lfd = 0, cfd;struct sockaddr_in serv_addr, clit_addr;socklen_t clit_addr_len;char buf[BUFSIZ];lfd = socket(AF_INET, SOCK_STREAM, 0);if(lfd == -1){perror("socket error\n");exit(0);}serv_addr.sin_family = AF_INET;serv_addr.sin_port = htons(SERV_PORT);serv_addr.sin_addr.s_addr = htonl(INADDR_ANY);int ret = bind(lfd, (struct sockaddr *)&serv_addr, sizeof(serv_addr));if(ret != 0){perror("bind error\n");exit(0);}ret = listen(lfd, 128);if(ret != 0){perror("listen error\n");exit(0);}clit_addr_len = sizeof(clit_addr);pid_t pid;while(1){printf("waiting connect\n");cfd = accept(lfd, (struct sockaddr *)&clit_addr, &clit_addr_len);if(cfd == -1){perror("sccept error\n");exit(1);}else{pid = fork();//创建一个子进程printf("pid = %d\n", pid);if(pid == -1){perror("fork error");exit(1);}if(pid == 0){//使用子进程处理这一个连接close(lfd);printf("deal a connect %d %d\n", getpid(), getppid());deal_one_server(&clit_addr, cfd);close(cfd);exit(1);}else{//父进程继续捕获close(cfd);}}}return 0;
}

image-20240404211134041

可以使用信号机制回收子进程, 如果使用的线程, 可以使用一个detach把这一个线程分离出去, 也可以专门使用一个线程进行回收兄弟线程

多线程
#include <ctype.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <errno.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <arpa/inet.h>
#include <pthread.h>#define SERV_PORT				9078
//子线程的处理函数
void *deal_one_server(void * arg){int ret;int cfd = (int)arg;char buf[1024];while(1){ret = read(cfd, buf, sizeof(buf));if(ret < 0){perror("read error\n");exit(1);}else if(ret == 0){break;}write(STDOUT_FILENO , buf, ret);for(int i = 0;i<ret;i++){buf[i] = toupper(buf[i]);}write(cfd, buf, ret);}close(cfd);
}
int main(void){int lfd = 0, cfd;struct sockaddr_in serv_addr, clit_addr;socklen_t clit_addr_len;char buf[BUFSIZ];lfd = socket(AF_INET, SOCK_STREAM, 0);if(lfd == -1){perror("socket error\n");exit(0);}//设置一下服务器的接收serv_addr.sin_family = AF_INET;serv_addr.sin_port = htons(SERV_PORT);serv_addr.sin_addr.s_addr = htonl(INADDR_ANY);int ret = bind(lfd, (struct sockaddr *)&serv_addr, sizeof(serv_addr));if(ret != 0){perror("bind error\n");exit(0);}ret = listen(lfd, 128);//设置可以接受的个数if(ret != 0){perror("listen error\n");exit(0);}clit_addr_len = sizeof(clit_addr);pid_t pid;while(1){printf("waiting connect\n");
sig_continue:cfd = accept(lfd, (struct sockaddr *)&clit_addr, &clit_addr_len);//开始接收if(cfd == -1){if((errno == ECONNABORTED) || (errno == EINTR)){goto sig_continue;//处理一下信号打断}perror("sccept error\n");exit(1);}else{printf("client ip: %s port %d\n", inet_ntop(AF_INET, &clit_addr.sin_addr.s_addr, buf, sizeof(buf)), ntohs(clit_addr.sin_port));pthread_t pid;pthread_create(&pid, NULL, deal_one_server, (void *)cfd);//使用一个线程接收pthread_detach(pid);//把这一个线程分离}}return 0;
}

和TCP协议的对应

img

服务器调用socket()、bind()、listen()完成初始化后，调用accept()阻塞等待，处于监听端口的状态，客户端调用socket()初始化后，调用connect()发出SYN段并阻塞等待服务器应答，服务器应答一个SYN-ACK段，客户端收到后从connect()返回，同时应答一个ACK段，服务器收到后从accept()返回。

这个时候三次握手已经完成了

建立连接后，TCP协议提供全双工的通信服务，但是一般的客户端/服务器程序的流程是由客户端主动发起请求，服务器被动处理请求，一问一答的方式。因此，服务器从accept()返回后立刻调用read()，读socket就像读管道一样，如果没有数据到达就阻塞等待，这时客户端调用write()发送请求给服务器，服务器收到后从read()返回，对客户端的请求进行处理，在此期间客户端调用read()阻塞等待服务器的应答，服务器调用write()将处理结果发回给客户端，再次调用read()阻塞等待下一条请求，客户端收到后从read()返回，发送下一条请求，如此循环下去。

如果客户端没有更多的请求了，就调用close()关闭连接，就像写端关闭的管道一样，服务器的read()返回0，这样服务器就知道客户端关闭了连接，也调用close()关闭连接。

四次挥手

注意，任何一方调用close()后，连接的两个传输方向都关闭，不能再发送数据了。如果一方调用shutdown()则连接处于半关闭状态，仍可接收对方发来的数据。

半关闭

在学习socket API时要注意应用程序和TCP协议层是如何交互的： 应用程序调用某个socket函数时TCP协议层完成什么动作，比如调用connect()会发出SYN段 应用程序如何知道TCP协议层的状态变化，比如从某个阻塞的socket函数返回就表明TCP协议收到了某些段，再比如read()返回0就表明收到了FIN段

出错处理封装函数

上面的例子不仅功能简单，而且简单到几乎没有什么错误处理，我们知道，系统调用不能保证每次都成功，必须进行出错处理，这样一方面可以保证程序逻辑正常，另一方面可以迅速得到故障信息。

为使错误处理的代码不影响主程序的可读性，我们把与socket相关的一些系统函数加上错误处理代码包装成新的函数，做成一个模块wrap.c：

这里只改变了一个字母的大小写不影响进入man手册

wrap.c

#include <stdlib.h>
#include <errno.h>
#include <sys/socket.h>
//一个错误信息打印函数
void perr_exit(const char *s)
{perror(s);exit(1);
}int Accept(int fd, struct sockaddr *sa, socklen_t *salenptr)
{int n;again:if ( (n = accept(fd, sa, salenptr)) < 0) {if ((errno == ECONNABORTED) || (errno == EINTR))goto again;//这一个系统调研被一个中断打断elseperr_exit("accept error");}return n;
}int Bind(int fd, const struct sockaddr *sa, socklen_t salen)
{int n;if ((n = bind(fd, sa, salen)) < 0)perr_exit("bind error");return n;
}int Connect(int fd, const struct sockaddr *sa, socklen_t salen)
{int n;if ((n = connect(fd, sa, salen)) < 0)perr_exit("connect error");return n;
}int Listen(int fd, int backlog)
{int n;if ((n = listen(fd, backlog)) < 0)perr_exit("listen error");return n;
}int Socket(int family, int type, int protocol)
{int n;if ( (n = socket(family, type, protocol)) < 0)perr_exit("socket error");return n;
}ssize_t Read(int fd, void *ptr, size_t nbytes)
{ssize_t n;
again:if ( (n = read(fd, ptr, nbytes)) == -1) {if (errno == EINTR)goto again;elsereturn -1;}return n;
}ssize_t Write(int fd, const void *ptr, size_t nbytes)
{ssize_t n;
again:if ( (n = write(fd, ptr, nbytes)) == -1) {if (errno == EINTR)goto again;elsereturn -1;}return n;
}int Close(int fd)
{int n;if ((n = close(fd)) == -1)perr_exit("close error");return n;
}
//在socket编程里面没有文件描述符, 所以这一个读取的时候只能使用系统调用
//在使用的时候封装一下会提高效率
ssize_t Readn(int fd, void *vptr, size_t n)
{size_t nleft;ssize_t nread;char *ptr;ptr = vptr;nleft = n;while (nleft > 0) {if ( (nread = read(fd, ptr, nleft)) < 0) {if (errno == EINTR)nread = 0;elsereturn -1;} else if (nread == 0)break;nleft -= nread;ptr += nread;}return n - nleft;}ssize_t Writen(int fd, const void *vptr, size_t n)
{size_t nleft;ssize_t nwritten;const char *ptr;ptr = vptr;nleft = n;while (nleft > 0) {if ( (nwritten = write(fd, ptr, nleft)) <= 0) {if (nwritten < 0 && errno == EINTR)nwritten = 0;elsereturn -1;}nleft -= nwritten;ptr += nwritten;}return n;
}//以此获取一个字符, 这一个只能针对一个文件
static ssize_t my_read(int fd, char *ptr)
{static int read_cnt;static char *read_ptr;static char read_buf[100];//一个静态的缓冲区if (read_cnt <= 0) {
again:if ((read_cnt = read(fd, read_buf, sizeof(read_buf))) < 0) {if (errno == EINTR)goto again;return -1; } else if (read_cnt == 0)return 0;//没有数据了read_ptr = read_buf;}read_cnt--;*ptr = *read_ptr++;//读取一个数据return 1;
}ssize_t Readline(int fd, void *vptr, size_t maxlen)
{ssize_t n, rc;char c, *ptr;ptr = vptr;for (n = 1; n < maxlen; n++) {if ( (rc = my_read(fd, &c)) == 1) {*ptr++ = c;if (c == '\n')break;} else if (rc == 0) {*ptr = 0;return n - 1;} elsereturn -1;}*ptr = 0;return n;
}

wrap.h

#ifndef __WRAP_H_
#define __WRAP_H_
void perr_exit(const char *s);
int Accept(int fd, struct sockaddr *sa, socklen_t *salenptr);
int Bind(int fd, const struct sockaddr *sa, socklen_t salen);
int Connect(int fd, const struct sockaddr *sa, socklen_t salen);
int Listen(int fd, int backlog);
int Socket(int family, int type, int protocol);
ssize_t Read(int fd, void *ptr, size_t nbytes);
ssize_t Write(int fd, const void *ptr, size_t nbytes);
int Close(int fd);
ssize_t Readn(int fd, void *vptr, size_t n);
ssize_t Writen(int fd, const void *vptr, size_t n);
ssize_t my_read(int fd, char *ptr);
ssize_t Readline(int fd, void *vptr, size_t maxlen);
#endif

补充函数(非常用)

shutdown关闭连接

当TCP链接中A发送FIN请求关闭，B端回应ACK后（A端进入FIN_WAIT_2状态），B没有立即发送FIN给A时，A方处在半链接状态，此时A可以接收B发送的数据，但是A已不能再向B发送数据。

从程序的角度，可以使用API来控制实现半连接状态。

#include <sys/socket.h>
int shutdown(int sockfd, int how);

sockfd: 需要关闭的socket的描述符

how: 允许为shutdown操作选择以下几种方式:

SHUT_RD(0)： 关闭sockfd上的读功能，此选项将不允许sockfd进行读操作。

​ 该套接字不再接收数据，任何当前在套接字接受缓冲区的数据将被无声的丢弃掉。

SHUT_WR(1): 关闭sockfd的写功能，此选项将不允许sockfd进行写操作。进程不能在对此套接字发出写操作。

SHUT_RDWR(2): 关闭sockfd的读写功能。相当于调用shutdown两次：首先是以SHUT_RD,然后以SHUT_WR。

使用close中止一个连接，但它只是减少描述符的引用计数，并不直接关闭连接，只有当描述符的引用计数为0时才关闭连接。

shutdown不考虑描述符的引用计数，直接关闭描述符。也可选择中止一个方向的连接，只中止读或只中止写。

注意:

  1. 如果有多个进程共享一个套接字，close每被调用一次，计数减1，直到计数为0时，也就是所用进程都调用了close，套接字将被释放。
  2. 在多进程中如果一个进程调用了shutdown(sfd, SHUT_RDWR)后，其它的进程将无法进行通信。但，如果一个进程close(sfd)将不会影响到其它进程。

补充

把文件上传服务器

scp -r 文件名 服务器用户名@服务器ip:目录 
scp -r ./socket.c root@110.41.39.131:/root/

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.mzph.cn/news/808756.shtml

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

PUBG绝地求生更新后无法启动/更新后卡顿？3个解决方法分享

PUBG绝地求生更新后无法启动/更新后卡顿？3个解决方法分享

在绝地求生中&#xff0c;团队协作也是非常重要的一点。咱们可以运用strong标签来着重“团队协作”。与队友紧密配合、彼此援助&#xff0c;一起拟定战术和战略&#xff0c;将会大大提高在游戏中获得成功的几率。在绝地求生中获得成功并不简单&#xff0c;但只需咱们把握了一些…
阅读更多...
linux的io的知识大全

linux的io的知识大全

C语言的io操作 写文件 #include<stdio.h> #include<string.h>#define FILE_NAME "log.txt" int main() {FILE * fp fopen(FILE_NAME, "w");if(fpNULL){printf("fopen error!\n");}const char* msg "hello zk\n";int c…
阅读更多...
北邮通报学生联名举报导师事件，导师PUA学生，学生只有压榨它

北邮通报学生联名举报导师事件，导师PUA学生，学生只有压榨它

诸葛亮为激司马懿出战&#xff0c;派使者送给他女人的衣服&#xff0c;司马懿欣然接受后问使者&#xff1a;“你们家丞相都管些什么呀&#xff1f;” 使者回答道&#xff1a;“我们丞相从行军布阵到饮食起居&#xff0c;无一不亲自过问。” 司马懿听到心中大喜&#xff0c;心想…
阅读更多...
【ARM Coresight SOC-600 -- ETF Flushin无法接收到 CTI 发出 triggerout 信号问题分析】

【ARM Coresight SOC-600 -- ETF Flushin无法接收到 CTI 发出 triggerout 信号问题分析】

请阅读【嵌入式开发必备专栏 】 文章目录 问题背景波形分析问题背景 在做验证的时候，准备通过 CTI2 给 SOC 上的 ETF 触发一个 flushin 动作，然后stop住 formatter，结果一致发现没有成功，接下来就是分析的过程了。 首先检查了代码，没有发现代码有什么问题（一般自己写的代…
阅读更多...
学习大数据，所需要的java(Maven)基础（1）

学习大数据，所需要的java(Maven)基础（1）

文章目录 使用Maven的优势第三方jar包添加第三方jar包获取jar包之间的依赖关系jar包之间的冲突处理将项目拆分成多个工程模块 实现项目的分布式部署Maven是什么自动化构建工具构建的概念构建环节自动化构建 Maven如何使用安装Maven核心程序maven联网问题Maven中的settings配置在…
阅读更多...
Linux下批量的批量操作

Linux下批量的批量操作

批量删除docker 镜像 docker images | grep ent-form-web |awk ‘{print $3}’ | xargs docker rmi docker images: 列出所有的docker 镜像 docker images | grep ent-form-web : 选取出结果带 ent-form-web的信息 docker images | grep ent-form-web |awk ‘{print $3}’ 选取…
阅读更多...
为什么在学校很难真正学好嵌入式？

为什么在学校很难真正学好嵌入式？

10几年前，我是读电气工程专业，学了很多东西，结构，电机、绘图，plc等等.. 其实，都没什么鸟用，出来还是像个废物。 后面我自学转了单片机开发，说句难听点，自己买个开发板都比在学校学得深。 可能是这个专业的问题，主攻不是嵌入式方向，老师用汇编点个流水灯，这门课就…
阅读更多...
CMake学习笔记（三）区分macro与function

CMake学习笔记（三）区分macro与function

目录 共同点--形式类似 macro的形式 function的形式 不同点 1 输入参数的替换阶段不同 macro function 2 输入参数作用域不同 macro function 共同点--形式类似 macro的形式 macro(宏名 输入参数名).... endmacro() function的形式 function(函数名 输入参数名).…
阅读更多...
20232831 2023-2024-2 《网络攻防实践》第5次作业

20232831 2023-2024-2 《网络攻防实践》第5次作业

目录 20232831 2023-2024-2 《网络攻防实践》第5次作业1.实验内容&#xff08;1&#xff09;防火墙配置&#xff08;具体IP配置参考自己的IP设置&#xff09;&#xff08;2&#xff09;动手实践&#xff1a;Snort&#xff08;3&#xff09;分析配置规则 2.实验过程3.学习中遇到…
阅读更多...
基于小程序实现的校园失物招领系统

基于小程序实现的校园失物招领系统

作者主页&#xff1a;Java码库 主营内容&#xff1a;SpringBoot、Vue、SSM、HLMT、Jsp、PHP、Nodejs、Python、爬虫、数据可视化、小程序、安卓app等设计与开发。 收藏点赞不迷路 关注作者有好处 文末获取源码 技术选型 【后端】&#xff1a;Java 【框架】&#xff1a;spring…
阅读更多...
第十二天--二维数组的彻底解刨--地址

第十二天--二维数组的彻底解刨--地址

1.二维数组我们用父子的地址来称呼二维数组的地址 比如arr[3][4] 这里的arr是二维数组的首地址&#xff0c;也是父数组的首地址&#xff0c;也是子数组的首地址 arr1父数组的地址偏移1&#xff0c;实际上是偏移了4*416个字节 arr[0]是子数组的首地址&#xff0c;arr[0]1是子数…
阅读更多...
langchain txt 文档加载，分割

langchain txt 文档加载，分割

stuff 策略 加载 arXiv 论文&#xff0c;让模型总结前 2000 字 这里采用的是 stuff 策略&#xff0c;也就是将一大段文本。按字数分割成 N 个文本块&#xff0c;又合并成一个大的文本块。 对超大规模不友好&#xff0c;没有区分文档重要性&#xff0c;适合文档量较少场景 i…
阅读更多...
安卓刷机fastboot分段传输

安卓刷机fastboot分段传输

win10 fastboot 无法识别&#xff0c;驱动下载地址GitHub - xushuan/google_latest_usb_driver_windows 把inf文件更新到设备管理器驱动更新即可 问题 archive does not contain super_empty.img Sending vbmeta_a (4 KB) OKAY [ 0.117s] Writing …
阅读更多...
Springboot项目的测试类书写（速通）

Springboot项目的测试类书写（速通）

目录 前言1. 单元测试的测试类2. 框架测试的测试类 前言 在实际开发中&#xff0c;如果只是做一个简单的单元测试&#xff08;不涉及端到端、数据库交互、API调用、消息队列处理等&#xff09;&#xff0c;我为了方便一般都是找块儿地方写一个main方法来跑一下就行了&#xff…
阅读更多...
Redis中的集群(六)

Redis中的集群(六)

集群 ASK错误 在进行重新分片期间&#xff0c;源节点向目标节点迁移一个槽的过程中&#xff0c;可能会出现这样一种情况:属于被迁移槽的一部分键值对保存在源节点里面&#xff0c;而另一部分键值对则保存在目标节点里面。当客户端向源节点发送一个与数据库有关的命令&#xf…
阅读更多...
C中自定义类型——结构体

C中自定义类型——结构体

一.前言 在C语言中&#xff0c;不仅有int、char、short、long等内置类型&#xff0c;C语言还有一种特殊的类型——自定义类型。该类型可以由使用者自己定义&#xff0c;可以解决一些复杂的个体。 二.结构体 2.1结构体的声明 我们在利用结构体的时候一般是用于描述一些有多种…
阅读更多...
javaweb配置JSTL

javaweb配置JSTL

首先配置好javaweb项目。 在网上下载好jakarta-taglibs-standard并解压。 在web/WEB-INF目录下创建lib目录。 在jakarta-taglibs-standard目录下lib目录内的两个.jar文件复制到javaweb项目lib目录下。 将这两个.jar包导入库。 在idea菜单栏找到“文件”并打开&#xff0c;点…
阅读更多...
nvm更新node版本

nvm更新node版本

1、nvm安装和管理多个 Node.js 版本&#xff1a;NVM 允许用户在计算机上同时安装多个不同版本的 Node.js。这使得开发人员可以轻松地在不同的项目中使用不同的 Node.js 版本&#xff0c;而无需手动安装或卸载。 2、nvm切换 Node.js 版本&#xff1a;通过 NVM&#xff0c;用户可…
阅读更多...
好菜每回味道不同--建造者模式

好菜每回味道不同--建造者模式

1.1 炒菜没放盐 中餐&#xff0c;老板需要每次炒菜&#xff0c;每次炒出来的味道都有可能不同。麦当劳、肯德基这些不过百年的洋快餐却能在有千年饮食文化的中国发展的那么好呢&#xff1f;是因为你不管何时何地在哪里吃味道都一样&#xff0c;而鱼香肉丝在我们中餐却可以吃出上…
阅读更多...
Langchain-Chatchat 从入门到精通（基于本地知识库的问答系统）（更新中）

Langchain-Chatchat 从入门到精通（基于本地知识库的问答系统）（更新中）

目录 前言一、Langchain-Chatchat介绍1-1、Langchain-Chatchat介绍1-2、LangChainChatGLM 工作流1-3、文档角度的工作流 二、快速上手2-0、硬件要求2-1、环境配置2-2、模型下载2-3、初始化知识库和配置文件2-4、一键启动 三、配置文件详解&#xff08;config目录下&#xff09;…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023