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段

使用UDP进行数据传输

在使用的时候accept以及connect函数不再使用

实际接收的时候不能使用recv/send以及read/write函数, 需要使用函数recvfrom以及sendto函数

recvfrom获取数据
ssize_t recvfrom(int sockfd, void *buf, size_t len, int flags,struct sockaddr *src_addr, socklen_t *addrlen);

socket: socket返回的lfd

buf: 数据

len: 缓冲区大小

flags: 0

src_addr: 接收的地址, 这一个是一个传出参数

addrlen :这一个结构体的大小

返回值: 成功获取的数据的个数, -1失败, 0对端关闭

sendto发送数据
ssize_t sendto(int sockfd, const void *buf, size_t len, int flags,const struct sockaddr *dest_addr, socklen_t addrlen);

socket: socket返回的lfd

buf: 数据

len: 缓冲区大小

flags: 0

dest_addr: 发送的目标地址

addrlen :这一个结构体的大小

返回值: 实际发送的字节数, 失败的时候返回-1

  • server

lfd = socket(AF_INET, SOCK_DGRAM, 0);

bind();

listen(); – 不需要连接, 所以这一个函数可有可无

while(1){

​ recvfrom

​ 处理

​ sendto

}

  • client

lfd = socket(AF_INET, SOCK_DGRAM, 0);

sendto

recvfrom

处理获取的数据

实际实现
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <errno.h>
#include <string.h>
#include <ctype.h>
#include <arpa/inet.h>
#include <sys/socket.h>int main(void){struct sockaddr_in serveraddr, clientaddr;socklen_t addrlen = sizeof(struct sockaddr_in);char buf[BUFSIZ];char str[INET_ADDRSTRLEN]; // #define INET_ADDRSTRLEN 16int i, n;int sockfd;int ret;//获取套接字sockfd = socket(AF_INET, SOCK_DGRAM, 0);if(sockfd < 0){perror("socket");exit(-1);}printf("sockfd = %d\n", sockfd);bzero(&serveraddr, sizeof(serveraddr));serveraddr.sin_family = AF_INET;serveraddr.sin_port = htons(8000);serveraddr.sin_addr.s_addr = htonl(INADDR_ANY);bind(sockfd, (struct sockaddr *)&serveraddr, addrlen);while(1){n = recvfrom(sockfd, buf, BUFSIZ, 0, (struct sockaddr *)&clientaddr, &addrlen);if(n == -1){perror("recvfrom");exit(-1);}printf("received from %s at PORT %d\n", inet_ntop(AF_INET, &clientaddr.sin_addr, str, sizeof(str)),ntohs(clientaddr.sin_port));for(i = 0; i < n; i++){buf[i] = toupper(buf[i]);}n = sendto(sockfd, buf, n, 0, (struct sockaddr *)&clientaddr, addrlen);if(n == -1){perror("sendto");exit(-1);}}close(sockfd);return 0;
}

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <errno.h>
#include <string.h>
#include <arpa/inet.h>
#include <sys/socket.h>
int main(void){struct sockaddr_in server_addr;int sockfd, n;char buf[1024];sockfd = socket(AF_INET, SOCK_DGRAM, 0);if(sockfd < 0){perror("socket");exit(1);}server_addr.sin_family = AF_INET;server_addr.sin_port = htons(8000);inet_pton(AF_INET, "127.0.0.1", &server_addr.sin_addr);while(fgets(buf, sizeof(buf), stdin) != NULL){n = sendto(sockfd, buf, strlen(buf), 0, (struct sockaddr *)&server_addr, sizeof(server_addr));if(n < 0){perror("sendto");exit(1);}n = recvfrom(sockfd, buf, sizeof(buf), 0, NULL, NULL);write(STDOUT_FILENO, buf, n);}close(sockfd);return 0;
}

出错处理封装函数

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

为使错误处理的代码不影响主程序的可读性，我们把与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.rhkb.cn/news/306333.html

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

相关文章

【算法】求{1，2，3}序列的全排列，邻里交换法（Java）

【算法】求{1，2，3}序列的全排列，邻里交换法（Java）

【算法】求{1&#xff0c;2&#xff0c;3}序列的全排列&#xff0c;邻里交换法&#xff08;Java&#xff09; 代码如下&#xff1a; public class Main{static int count;static int a[] {1,2,3};public static void main(String[] args) {f(a,0);System.out.println(count);}p…
阅读更多...
MAC苹果电脑如何使用Homebrew安装iperf3

MAC苹果电脑如何使用Homebrew安装iperf3

一、打开mac终端 找到这个终端打开 二、终端输入安装Homebrew命令 Homebrew官网地址&#xff1a;https://brew.sh/ 复制这个命令粘贴到mac的终端窗口&#xff0c;然后按回车键 /bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/in…
阅读更多...
未来汽车硬件安全的需求(1)

未来汽车硬件安全的需求(1)

目录 1.概述 2.EVITA 2.1 EVITA HSM 2.2 EVITA保护范围 3.市场变化对车载网络安全的影响 3.1 非侵入式攻击的风险 3.2 量子计算机的蛮力攻击 3.3 整车E/E架构的变化 3.4 网络安全标准和认证 3.5 汽车工业的网络安全措施 4.汽车安全控制器 4.1 TPM2.0 4.2 安全控…
阅读更多...
数据分析案例（一）：地区收入的PCA主成分分析

数据分析案例（一）：地区收入的PCA主成分分析

练习1 地区收入的PCA主成分分析 0.变量说明 1.导包操作 核心思路&#xff1a;导入基础数据操作库包&#xff0c;PCA、k-means 库包&#xff0c;数据可视化库包 import pandas as pd import numpy as np from sklearn.decomposition import PCA from sklearn.preprocessing i…
阅读更多...
Go语言中channel和互斥锁的应用场景

Go语言中channel和互斥锁的应用场景

面对一个并发问题，我们的解决方案是使用channel还是互斥锁来实现并不总是很清晰。因为Go提倡使用通信来共享内存，所以一个常见的错误就是总是强制使用channel,不管实际情况如何。但是我们应该把这两种选择作为互补手段。 首先，简单回顾一下Go语言中的channel:channel是一种交…
阅读更多...
软件设计师-基础知识科目-算法设计与分析8

软件设计师-基础知识科目-算法设计与分析8

八、算法设计与分析&#xff1a; 常见算法&#xff1a; 回溯方法&#xff1a; 用深度优先的探索问题的解空间。应用场景&#xff1a;N皇后问题。&#xff08;背&#xff09; 分支界限法&#xff1a; 用广度优先的探索问题的解空间&#xff0c;采用的是分支界限法算法设计策…
阅读更多...
小程序开发SSL证书下载和安装

小程序开发SSL证书下载和安装

在开发小程序时&#xff0c;确保数据的安全传输至关重要&#xff0c;而实现这一目标的关键在于正确获取与安装SSL证书。以下详细介绍了从获取到安装SSL证书的完整流程&#xff0c;以助您为小程序构建可靠的加密通信环境。 一、小程序SSL证书类型选择&#xff1a; 域名验证型D…
阅读更多...
互联网轻量级框架整合之设计模式

互联网轻量级框架整合之设计模式

反射技术 Java的反射技术能够通过配置类的全限定名、方法和参数完成对象的初始化&#xff0c;甚至反射某些方法&#xff0c;大大的增强了Java的可配置型&#xff0c;这也是Spring IoC的底层原理&#xff0c;Java的反射技术覆盖面很广&#xff0c;包括对象构建、反射方法、注解、…
阅读更多...
备战蓝桥杯---刷杂题2

备战蓝桥杯---刷杂题2

显然我们直接看前一半&#xff0c;然后我们按照斜行看&#xff0c;我们发现斜行是递增的&#xff0c;而同一行从左向右也是递增的&#xff0c;因此我们可以直接二分&#xff0c;同时我们发现对称轴的数为Ck,2k. 我们从16斜行枚举即可 #include<bits/stdc.h> using name…
阅读更多...
YOLOV5训练KITTI数据集实践

YOLOV5训练KITTI数据集实践

目录 一、YOLOV5下载安装二、KITTI数据集三、标签格式转换四、修改配置文件五、训练六、测试 一、YOLOV5下载安装 git clone https://github.com/ultralytics/yolov5.git conda create -n yolov5 python3.8 -y conda activate yolov5 cd yolov5 pip install -r requirements.t…
阅读更多...
一文了解ERC404协议

一文了解ERC404协议

一、ERC404基础讲解 1、什么是ERC404协议 ERC404协议是一种实验性的、混合的ERC20/ERC721实现的&#xff0c;具有原生流动性和碎片化的协议。即该协议可让NFT像代币一样进行拆分交易。是一个图币的互换协议。具有原生流动性和碎片化的协议。 这意味着通过 ERC404 协议&#xf…
阅读更多...
gitlab、jenkins安装及使用文档一

gitlab、jenkins安装及使用文档一

gitlab-jenkins安装文档 IP地址操作系统服务版本192.168.75.137Rocky9.2jenkins 2.450-1.1 jdk 11.0.22 git 2.39.3192.168.75.138Rocky9.2gitlab-ce 16.10.0 gitlab安装 前期准备: 关闭防火墙及 SELinuxsystemctl disable --now firewalld sed -i s/^SELINUXenforcing$…
阅读更多...
谷歌seo自然搜索排名怎么提升快？

谷歌seo自然搜索排名怎么提升快？

要想在谷歌上排名快速上升&#xff0c;关键在于运用GPC爬虫池跟高低搭配的外链组合 首先你要做的&#xff0c;就是让谷歌的蜘蛛频繁来你的网站&#xff0c;网站需要被谷歌蜘蛛频繁抓取和索引&#xff0c;那这时候GPC爬虫池就能派上用场了&#xff0c;GPC爬虫池能够帮你大幅度提…
阅读更多...
短剧小程序系统开发，让短剧观看与创作更加便捷。短剧系统源码搭建

短剧小程序系统开发，让短剧观看与创作更加便捷。短剧系统源码搭建

一、目前短剧发展趋势 1. 市场规模&#xff1a;根据数据来看&#xff0c;2023年中国微短剧市场规模达到了373.9亿元&#xff0c;同比上升了267.65%。预计2024年市场规模将超过500亿元。这一市场规模的增长速度非常显著&#xff0c;显示出短剧行业的巨大潜力和发展前景。 2. 投…
阅读更多...
RabbitMQ消息模型之Fanout消息模型

RabbitMQ消息模型之Fanout消息模型

Fanout消息模型 * 广播模型&#xff1a;* 一个交换机绑定多个队列* 每个队列都有一个消费者* 每个消费者消费自己队列中的消息&#xff0c;每个队列的信息是一样的生产者 package com.example.demo02.mq.fanout;import com.example.demo02.mq.util.ConnectionUtils; impor…
阅读更多...
Python异常处理try与except跳过报错使得程序继续运行的方法

Python异常处理try与except跳过报错使得程序继续运行的方法

本文介绍基于Python语言的异常处理模块try与except&#xff0c;对代码中出现的报错加以跳过&#xff0c;从而使得程序继续运行的方法。 在Python语言中&#xff0c;try语句块用于包含可能引发异常的代码&#xff0c;而except语句块则用于定义在出现异常时要执行的代码。其基本结…
阅读更多...
Windows下编译boost库

Windows下编译boost库

官网&#xff1a;https://www.boost.org/ 下载地址&#xff1a;https://github.com/boostorg/boost 这里使用github下载 使用git bash运行bootstrap.sh 运行b2.exe,会生成bin.v2和stage文件夹 Cmake引入
阅读更多...
03-JAVA设计模式-适配器模式

03-JAVA设计模式-适配器模式

适配器模式 设么是适配器模式 它属于结构型模式&#xff0c;主要用于将一个类的接口转换成客户端所期望的另一种接口&#xff0c;从而使得原本由于接口不兼容而无法协同工作的类能够一起工作。 适配器模式主要解决的是不兼容接口的问题。在软件开发中&#xff0c;经常会有这…
阅读更多...
前端对接fastGPT流式数据+打字机效果

前端对接fastGPT流式数据+打字机效果

首先在对接api时 参数要设置stream: true, const data {chatId: abc,stream: true,//这里true返回流式数据detail: false,variables: {uid: sfdsdf,name: zhaoyunyao,},messages: [{ content: text, role: user }]}; 不要用axios发请求 不然处理不了流式数据 我这里使用fetch …
阅读更多...
通过Transform与Animation，来探索CSS中的动态视觉效果

通过Transform与Animation，来探索CSS中的动态视觉效果

在 transform 和 animation 出现之前&#xff0c;前端开发者通常需要编写大量的 JavaScript 代码来实现动态效果。然而&#xff0c;这两个 CSS 属性的引入极大地简化了丰富动效和过渡效果的实现&#xff0c;从而让用户界面更加引人入胜&#xff0c;交互体验更为流畅。本文将深入…
阅读更多...
最新文章
推荐文章

Copyright @ 2022~2023