学习笔记----linux下scoket

文章有点长，可以直接跳到 3.代码实现

1.预备知识

1.TCP/IP协议

TCP/IP网络协议栈分为应用层（Application）、传输层（Transport）、网络层（Network）和链路层（Link）四层，由原本的OSI七层模型转变而来，如图所示。

但是，不要认为TCP/IP模型四层都是使用tcp/udp协议，仅仅只是传输层使用tcp/udp协议

应用层：TFTP，HTTP，SNMP，FTP，SMTP，DNS，Telnet 等等

传输层：TCP，UDP

网络层：IP，ICMP，OSPF，EIGRP，IGMP

数据链路层：SLIP，CSLIP，PPP，MTU

2.Scoket概念

 　　Socket本身有“插座”的意思，在Linux环境下，用于表示进程间网络通信的特殊文件类型。本质为内核借助缓冲区形成的伪文件。
 　　既然是文件，那么理所当然的，我们可以使用文件描述符引用套接字。与管道类似的，Linux系统将其封装成文件的目的是为了统一接口，使得读写套接字和读写文件的操作一致。区别是管道主要应用于本地进程间通信，而套接字多应用于网络进程间数据的传递。
 　 　在TCP/IP协议中，“IP地址+TCP或UDP端口号”唯一标识网络通讯中的一个进程。“IP地址+端口号”就对应一个socket。欲建立连接的两个进程各自有一个socket来标识，那么这两个socket组成的socket pair就唯一标识一个连接。因此可以用Socket来描述网络连接的一对一关系。
 　　套接字通信原理如下图所示：

 　 　在网络通信中，套接字一定是成对出现的。　一端的发送缓冲区对应对端的接收缓冲区。我们使用同一个文件描述符索发送缓冲区和接收缓冲区。
Scoket是一套编程接口，是为TCP/IP协议设计的应用层编程接口，称为socket API；

3.网络字节序

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

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

4.IP地址转换函数

早期：

#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
int inet_aton(const char *cp, struct in_addr *inp);  把ip地址转化为用于网络传输的二进制数值
in_addr_t inet_addr(const char *cp);
char *inet_ntoa(struct in_addr in);	将网络传输的二进制数值转化为成点分十进制的ip地址

只能处理IPv4的ip地址
注意参数是struct in_addr
inet_aton() 转换网络主机地址ip(如192.168.1.10)为二进制数值，并存储在struct in_addr结构中，即第二个参数*inp,函数返回非0表示cp主机有地有效，返回0表示主机地址无效。（这个转换完后不能用于网络传输，还需要调用htons或htonl函数才能将主机字节顺序转化为网络字节顺序）

inet_addr()函数转换网络主机地址（如192.168.1.10)为网络字节序二进制值，如果参数char *cp无效，函数返回-1(INADDR_NONE),这个函数在处理地址为255.255.255.255时也返回－1,255.255.255.255是一个有效的地址，不过inet_addr无法处理;

inet_ntoa() 函数转换网络字节排序的地址为标准的ASCII以点分开的地址,该函数返回指向点分开的字符串地址（如192.168.1.10)的指针，该字符串的空间为静态分配的，这意味着在第二次调用该函数时，上一次调用将会被重写（复盖），所以如果需要保存该串最后复制出来自己管理！

现在：

#include <arpa/inet.h>
int inet_pton(int af, const char *src, void *dst);
	将点分十进制的ip地址转化为用于网络传输的数值格式
	返回值：若成功则为1，若输入不是有效的表达式则为0，若出错则为-1
 
const char *inet_ntop(int af, const void *src, char *dst, socklen_t size);
	将数值格式转化为点分十进制的ip地址格式
    返回值：若成功则为指向结构的指针，若出错则为NULL

支持IPv4和IPv6
其中inet_pton和inet_ntop不仅可以转换IPv4的in_addr，还可以转换IPv6的in6_addr。
因此函数接口是void *addrptr。

5.sockaddr数据结构

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

1.struct sockaddr

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

2.struct sockaddr_in

 　 　IPv4和IPv6的地址格式定义在 /usr/include/netinet/in.h或/usr/include/linux/in.h ，IPv4地址用sockaddr_in结构体表示，包括16位端口号和32位IP地址.

struct sockaddr_in {
	__kernel_sa_family_t sin_family; 			/* Address family */  	地址结构类型
	__be16 sin_port;					 		/* Port number */		端口号
	struct in_addr sin_addr;					/* Internet address */	IP地址
	/* Pad to size of `struct sockaddr'. */
	unsigned char __pad[__SOCK_SIZE__ - 
						sizeof(short int) -
						sizeof(unsigned short int) - 
						sizeof(struct in_addr)];
};

3.struct in_addr

 　 　用来表示一个32位的IPv4地址。

struct in_addr {						/* Internet address. */
	__be32 s_addr;
};
__be32 一般为 32位的unsigned int，其字节顺序为网络顺序（network byte ordered)，即该无符号整数采用大端字节序 。

4.struct sockaddr_in6

 　 　IPv4和IPv6的地址格式定义在 /usr/include/netinet/in.h 或/usr/include/linux/in.h中. IPv6地址用sockaddr_in6结构体表示，包括16位端口号、128位IP地址和一些控制字段。

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) */
};

5.struct in6_addr

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

6.struct sockaddr_un

 　 　UNIX Domain Socket的地址格式定义在 /usr/include/linux/un.h或/usr/include/linux/sys/un.h中，用sock-addr_un结构体表示。

#define UNIX_PATH_MAX 108
	struct sockaddr_un {
	__kernel_sa_family_t sun_family; 	/* AF_UNIX */
	char sun_path[UNIX_PATH_MAX]; 	/* pathname */
};

 　 　各种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 */

2.网络套接字函数

 　 　socket模型创建流程图

1.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 本地协议，使用在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 即可。

2.bind() 函数

#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地址加端口号
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)); /*清空该结构体相当于memset*/
servaddr.sin_family = AF_INET;	/*TCP/IP – IPv4*/
servaddr.sin_addr.s_addr = htonl(INADDR_ANY); /*IP地址设置成INADDR_ANY,让系统自动获取本机的IP地址。*/
servaddr.sin_port = htons(6666);

如不懂htonl()和htons(),请前往 网络字节序 该节

3.listen()函数

#include <sys/types.h> /* See NOTES */
#include <sys/socket.h>
int listen(int sockfd, int backlog);
sockfd:
	socket文件描述符
backlog:
	排队建立3次握手队列和刚刚建立3次握手队列的链接数和

查看系统默认backlog

cat /proc/sys/net/ipv4/tcp_max_syn_backlog

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

4.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。

5.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。

5.read()/recv()

ssize_t read(int fd, void *buf, size_t count);
fd:
	文件描述符
buf：
	指明一个缓冲区，该缓冲区用来存放recv函数接收到的数据
count
	指明buf的长度
返回值:
	成功：返回读出的字节数
	失败：返回-1，并设置errno，
	如果在调用read之前到达文件末尾，则这次read返回0
	
ssize_t recv(int sockfd, void *buf, size_t len, int flags);
fd:
	接收端套接字描述符
buf：
	指明一个缓冲区，该缓冲区用来存放recv函数接收到的数据
count:
	指明buf的长度
flags:
	一般置为0

6.write()/send()

ssize_t write(int fd, const void *buf, size_t count);
fd:
	文件描述符
buf:
	指明一个缓冲区，该缓冲区用来存放recv函数接收到的数据
count:
	指明buf的长度
ssize_t send(int sockfd, const void *buf, size_t len, int flags);
fd:
	接收端套接字描述符
buf：
	指明一个缓冲区，该缓冲区用来存放send函数需要发送的数据
count:
	指明buf的长度
flags:
	一般置为0

3.代码实现

接下来就是以上理论的产出了。
scoke实现一般过程，socket框架：

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

#define MAXLINE 80
//#define SERV_PORT 6666

int main(int argc, char *argv[])
{
    struct sockaddr_in servaddr, cliaddr;
    socklen_t cliaddr_len;
    int listenfd, connfd;
    char buf[MAXLINE];
    char str[INET_ADDRSTRLEN];
    int i, n, port;
	if (argc != 2) {
        fputs("usage: ./server port\n", stderr);
        exit(1);
    }
	port = atoi(argv[1]);
	/*建立Socket*/
    listenfd = Socket(AF_INET, SOCK_STREAM, 0);

	/*scoket结构体初始化*/
    bzero(&servaddr, sizeof(servaddr));
    servaddr.sin_family = AF_INET;					/*TCP/IP – IPv4*/
    servaddr.sin_addr.s_addr = htonl(INADDR_ANY);	/*IP地址设置成INADDR_ANY,让系统自动获取本机的IP地址。*/
    servaddr.sin_port = htons(port);				/*设置端口*/
       
    /*设置端口复用*/
    /*int opt = 1; 
    setsockopt(listenfd, SOL_SOCKET,
               SO_REUSEPORT,
               (const void *)&opt, 
               sizeof(opt)
               );*/
    
    Bind(listenfd, (struct sockaddr *)&servaddr, sizeof(servaddr));	/*将本地地址绑定到所创建的套接字上*/
    Listen(listenfd, 20);											/*开始监听是否有客户端连接*/

    printf("Accepting connections ...\n");
    while (1) 
    /*核心代码实现处*/
    }
    return 0;
}

0.出错处理函数封装

我们先来把socket系列函数封装一下，进行出错处理，在使用过程中不需要再判断函数是否调用成功
封装函数和原函数使用方法一样，参数也是相同的，只是把原函数的首字母变成了大写
源码地址：https://github.com/qingyiz/client-server/tree/master/wrap

1.普通client/server

这种c/s,只能拥有一个 client和一个server，按照普通的socket流程即可完成
相应源码地址：https://github.com/qingyiz/client-server/tree/master/01%E6%99%AE%E9%80%9Ac-s

测试
gcc server.c wrap.c -o server
gcc client.c wrap.c -o client

./server 端口号
./client 端口号

2.多进程并发client/server

相应源码地址：https://github.com/qingyiz/client-server/tree/master/02_%E5%A4%9A%E8%BF%9B%E7%A8%8B%E5%B9%B6%E5%8F%91c-s
在process_server中有一段代码，是用来回收子进程的，你可以注释掉该代码，对整个程序并没有什么影响，至少从表面上是没有影响的，但是如果注释掉这段代码，子进程终止了，但是并没有被父进程回收，如果不进行处理，等父进程一结束，那变成孤儿进程了，也就是僵尸进程。所以需要使用信号使用来回收子进程。
SIGINT关联ctrl+c
SIGCHLD:子进程终止时会向父进程发送SIGCHLD信号，告知父进程回收自己，但该信号的默认处理动作为忽略，因此父进程仍然不会去回收子进程，需要捕捉处理实现子进程的回收；

/*sigaction结构体初始化，用来回收子进程pcb*/
	struct sigaction newact;
	newact.sa_handler = do_sigchild;	/*回调*/
	sigemptyset(&newact.sa_mask);
	newact.sa_flags = 0;
	sigaction(SIGCHLD, &newact, NULL);

为了有直观的体现，可以运行以下代码

/*sigaction.c*/
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <signal.h>

void do_sigchile(int num)
{
    printf("信号回收%d\n",num);
}

int main()
{
    struct sigaction newact;
    newact.sa_flags = 0;
    sigemptyset(&newact.sa_mask);
    newact.sa_handler = do_sigchile;
    sigaction(SIGINT,&newact,NULL);
    while(1);
    return 0;
}

gcc sigaction .c -o sigaction
./sigaction
执行程序后，按ctrl+c就,可以看到有现象，ctrl+c就发出了SIGINT信号，执行指定的回调函数，同理SIGCHLD也一样

3.多线程并发client/server

 　 　多线程相比如多进程就简单的多，线程有线程分离状态，不再需要手动回收线程，代码里有相应的注释
 　 　编译这段代码时，请加上线程库

gcc pthread_server.c wrap.c -o pthread_server -lpthread

相应源码地址：https://github.com/qingyiz/client-server/tree/master/03_%E5%A4%9A%E7%BA%BF%E7%A8%8B%E5%B9%B6%E5%8F%91c-s

4.多路I/O转接服务器

 　 　多线程或多进程服务器，可以实现一对多，客户端少还好，但客户端一单多了起来,但无疑会消耗大量的系统资源。系统资源是有限的，而且系统也不可能把所有的资源都分配给给你，所以多线程和多进程并发服务器是不现实的。而多路I/O转接服务器可以解决该问题，
（由于本篇篇幅过长，只能另起炉灶了）
 　 　多路IO转接服务器部分：https://blog.csdn.net/yaoyaohyl/article/details/108718735

-1.端口复用

以上代码会有一个严重的问题，就是在服务器端断开之后，如果再次使用这个窗口，就会出现如下问题

如何解决这个问题？那就是使用端口复用了，
端口复用最常用的用途：

• 防止服务器重启时之前绑定的端口还未释放
• 程序突然退出而系统没有释放端口

#include <sys/socket.h>

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

sockfd:
	需要操作的套接字描述符
level:
	协议层次
            SOL_SOCKET 套接字层次
            IPPROTO_IP ip层次
            IPPROTO_TCP TCP层次
option_name：
	选项的名称（套接字层次）
option_value：
	获取到的选项的值,一般设为一
option_len：
	value的长度

注意事项：
	在绑定之前设置该属性

只截取了套接字层次的，其他部分的暂时不关心。

端口复用一般设置方式

/*设置端口复用*/
int opt = 1; 
setsockopt(	sockfd,
			SOL_SOCKET, 
			SO_REUSEPORT,
			(const void *)&opt,
			sizeof(opt)
			);

在原先的代码中，我已经加上了端口复用，只需要把注释去掉即可
、

**---------------------------------------------

正在实现中。。。。。**