Linux使用C语言实现Socket编程

Socket编程

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

网络套接字

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

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

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

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

网络字节序

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

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

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

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模型创建流程图

sockaddr数据结构

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

可参看 man 7 ip

从左向右依次进化

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 108

  struct 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模型创建流程图

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

这一个监听的客户端设置完成以后, 使用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				9078

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;				//使用IPV4
	serv_addr.sin_port = htons(SERV_PORT);		//设置端口
	serv_addr.sin_addr.s_addr = htonl(INADDR_ANY);//设置检测本地的所有ip
	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);
	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;
}

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;
}

可以使用信号机制回收子进程, 如果使用的线程, 可以使用一个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协议的对应

服务器调用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 16
	int 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;//这一个系统调研被一个中断打断
     else
       perr_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;
     else
       return -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;
     else
       return -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;
       else
         return -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;
       else
         return -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;
     } else
       return -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/