转载自：https://www.cnblogs.com/skynet/archive/2010/12/12/1903949.html

“一切皆Socket！”

话虽些许夸张，但是事实也是，现在的网络编程几乎都是用的socket——有感于实际编程和开源项目研究。

我们深谙信息交流的价值，那网络中进程之间如何通信，如我们每天打开浏览器浏览网页时，浏览器的进程怎么与web服务器通信的？当你用QQ聊天时，QQ进程怎么与服务器或你好友所在的QQ进程通信？这些都得靠socket？那什么是socket？socket的类型有哪些？还有socket的基本函数，这些都是本文想介绍的。本文的主要内容如下：

一、网络中进程之间如何通信？

本地的进程间通信（IPC）有很多种方式，但可以总结为下面4类：

• 消息传递（管道、FIFO、消息队列）
• 同步（互斥量、条件变量、读写锁、文件和写记录锁、信号量）
• 共享内存（匿名的和具名的）
• 远程过程调用（Solaris门和Sun RPC）

但这些都不是本文的主题！我们要讨论的是网络中进程之间如何通信？首要解决的问题是如何唯一标识一个进程，否则通信无从谈起！在本地可以通过进程PID来唯一标识一个进程，但是在网络中这是行不通的。其实TCP/IP协议族已经帮我们解决了这个问题，网络层的“ip地址”可以唯一标识网络中的主机，而传输层的“协议+端口”可以唯一标识主机中的应用程序（进程）。这样利用三元组（ip地址，协议，端口）就可以标识网络的进程了，网络中的进程通信就可以利用这个标志与其它进程进行交互。

使用TCP/IP协议的应用程序通常采用应用编程接口：UNIX BSD的套接字（socket）和UNIX System V的TLI（已经被淘汰），来实现网络进程之间的通信。就目前而言，几乎所有的应用程序都是采用socket，而现在又是网络时代，网络中进程通信是无处不在，这就是我为什么说“一切皆socket”。

二、什么是Socket？

上面我们已经知道网络中的进程是通过socket来通信的，那什么是socket呢？socket起源于Unix，而Unix/Linux基本哲学之一就是“一切皆文件”，都可以用“打开open –> 读写write/read –> 关闭close”模式来操作。我的理解就是Socket就是该模式的一个实现，socket即是一种特殊的文件，一些socket函数就是对其进行的操作（读/写IO、打开、关闭），这些函数我们在后面进行介绍。

socket一词的起源

在组网领域的首次使用是在1970年2月12日发布的文献IETF RFC33中发现的，撰写者为Stephen Carr、Steve Crocker和Vint Cerf。根据美国计算机历史博物馆的记载，Croker写道：“命名空间的元素都可称为套接字接口。一个套接字接口构成一个连接的一端，而一个连接可完全由一对套接字接口规定。”计算机历史博物馆补充道：“这比BSD的套接字接口定义早了大约12年。”

三、socket的基本操作

既然socket是“open—write/read—close”模式的一种实现，那么socket就提供了这些操作对应的函数接口。下面以TCP为例，介绍几个基本的socket接口函数。

3.1 socket()函数

//成功返回文件（套接字）描述符；出错返回-1
int socket(int domain, int type, int protocol);

socket()函数对应于普通文件的open操作。普通文件的open操作返回一个文件描述符，而socket()返回一个套接字描述符。套接字描述符在UNIX系统中被当做是一种文件描述符，因此很多处理文件描述符的函数（如read、write）可以用于处理套接字描述符。

socket有很多不同的种类，可以通过参数的组合来进行选择，其3个参数分别是：

• domain：协议族（family），确定通信的特征，包括地址格式。常用的协议族有：AF_INET、AF_INET6、AF_UNIX、AF_UPSPEC等。协议族决定了socket的地址类型，如AF_INET决定了要用ipv4地址（32位）与端口号（16位）的组合、AF_UNIX决定了要用一个绝对路径作为地址。
• type：指定socket类型，进一步确定通信特征。常用的类型有：SOCK_STREAM、SOCK_DGRAM、SOCK_RAW、SOCK_PACKET、SOCK_SEQPACKET等。
• protocol：通信协议，常用的协议有：IPPROTO_TCP、IPPROTO_UDP、IPPROTO_IP、IPPROTO_IPV6、IPPROTO_ICMP、IPPROTO_ROW等。

注意，协议需要与type对应，例如SOCK_STREAM不可以跟IPPROTO_UDP组合。当protocol为0时，会自动选择type类型对应的默认协议。

当我们调用socket创建一个socket时，返回的socket描述符存在于协议族（address family，AF_XXX）空间中，但没有一个具体的地址。如果想要给它赋值一个地址（ip+端口），就必须调用bind()函数（服务端通常使用），或者调用connect()、listen()时系统会自动随机分配一个端口（客户端通常使用）。

3.2 bind()函数

如上所说，bind()函数把一个地址族中的特定地址赋给socket。例如对应AF_INET、AF_INET6就是把一个ipv4或ipv6地址和端口组合赋给socket。

//成功返回0；出错返回-1
int bind(int sockfd, const struct sockaddr *addr, socklen_t addrlen);

函数的3个参数分别是：

• sockfd：即socket描述符，它是通过socket()函数返回的套接字唯一标识符。bind()函数就是给这个描述符绑定一个实际地址。
• addr：一个const struct sockaddr *指针，指向要绑定的地址。这个结构根据创建socket时地址类型的不同而不同，如ipv4对应的是：

struct sockaddr_in{
    sa_family_t sin_family;  //地址族：AF_INET
    in_port_t sin_port;      //网络字节序的端口号
    struct in_addr sin_addr; //网络地址
}

struct in_addr{
    uint32_t s_addr; //网络字节序的地址
}

Unix域对应的是：

#define UNIX_PATH_MAX 108

struct sockaddr_un{
    sa_family_t sun_family;      //AF_UNIX
    char sun_path[UNIX_PATH_MAX];  //路径名
}

• addrlen：对应的是地址的长度。

通常服务器在启动时都会绑定一个地址（如127.0.0.1:80），客户可以通过改地址来连接服务器。而客户端就不用指定，有系统自动分配一个端口号和自身ip地址组合。这就是为什么通常服务端在listen之前会调用bind()，而客户端就不用，而是在connnect()时由系统随机生成一个。

网络字节序与主机字节序

主机字节序就是我们平常所说的大端和小端模式：不同的CPU有不同的字节序，这些字节序是指整数在内存中保存的顺序。小端（Little-Endian）就是低位字节排放在内存的低地址端，高位字节排放在内存的高地址端。大端（Big-Endian）就是高位字节排放在内存的低地址端，低位字节排放在内存的高地址端。
例子：在内存中双字0x01020304(DWORD)的存储方式

内存地址

4000 4001 4002 4003

LE 04 03 02 01

BE 01 02 03 04

网络字节序：网络字节顺序是TCP/IP中规定好的一种数据表示格式，它与具体的CPU类型、操作系统等无关，从而可以保证数据在不同主机之间传输时能够被正确解释。网络字节顺序采用big endian排序方式。
如4个字节的32 bit值以下面的次序传输：首先是0～7bit，其次8～15bit，然后16～23bit，最后是24~31bit。

注意，在将一个地址绑定到socket时，务必要将主机字节序的地址转换为网络字节序，否则可能会引发血案，导致很多莫名其妙的问题。

3.3 listen()、connect()函数

如果作为一个服务器，在调用socket()、bind()之后就会调用listen()来监听这个socket；如果是一个客户端，这时会调用connect()来发出连接请求。

//sockfd:需要监听的socket
//backlog:该socket可以排队的最大连接数
//成功返回0；失败返回-1
int listen(int sockfd, int backlog);

//sockfd:客户端的socket
//addr:服务器的socket地址
//addrlen:服务器地址长度
//成功返回0；失败返回-1
int connect(int sockfd, const struct sockaddr *addr, socklen_t addrlen);

socket()创建的socket默认是一个主动类型的，listen函数将socket变为被动类型的，等待客户端连接请求。

客户端通过调用connect()来建立与TCP服务器的连接。

3.4 accept()函数

1. 服务器依次调用socket()、bind()、listen()之后，就会监听指定的socket地址而来。
2. TCP客户端依次调用socket()、connect()之后就向服务器发送了一个连接请求。
3. 服务器监听到这个请求之后，就会调用accept()函数接收请求，这样连接就建立好了。之后就可以开始网络IO操作了。

//sockfd:监听的socket
//addr：客户端请求的socket地址会被填充到该缓冲区中
//addrlen:客户端地址的长度
//返回值：成功返回一个内核生成的新的socket描述符，该描述符与客户端请求绑定
int accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen);

accept的第一个参数为服务器的socket描述符，是服务器开始调用socket()函数生成的，称为监听socket描述符；而accept函数返回的是已连接的socket描述符。一个服务器通常只创建一个监听socket描述符，他在该服务器的生命周期内一直存在。内核为每个由服务器进程接收的客户端连接创建了一个已连接的描述符，当服务器完成对某个客户的服务，相应的socket描述符就被关闭。

3.5 read()、write()等函数

至此服务器与客户已经建立好连接，可以调用网络IO进行读写操作了。网络IO操作有下面几组：

• read()/write()
• recv()/send()
• readv()/writev()
• recvmsg()/sendmsg()
• recvfrom()/sendto()

它们的声明如下：

#include <unistd.h>

ssize_t read(int fd, void *buf, size_t count);
ssize_t write(int fd, const void *buf, size_t count);

#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);

ssize_t sendto(int sockfd, const void *buf, size_t len, int flags,
                const struct sockaddr *dest_addr, socklen_t addrlen);
ssize_t recvfrom(int sockfd, void *buf, size_t len, int flags,
                struct sockaddr *src_addr, socklen_t *addrlen);

ssize_t sendmsg(int sockfd, const struct msghdr *msg, int flags);
ssize_t recvmsg(int sockfd, struct msghdr *msg, int flags);

推荐使用recvmsg()/sendmsg()，它们使用msghdr结构来缓冲数据，能提供更精细的控制。

3.6 close()函数

在服务器与客户端建立连接后，会进行一些读写操作，完成后就需要关闭相应的socket描述符，好比操作完文件后要调用fclose关闭文件。

#include <unistd.h>
int close(int fd);

close一个TCP socket的缺省行为时把该socket标记为以关闭，然后立即返回到调用进程。该描述字不能再由调用进程使用，也就是说不能再作为read或write的第一个参数。

注意：close操作只是使相应socket描述字的引用计数-1，只有当引用计数为0的时候，才会触发TCP客户端向服务器发送终止连接请求。

四、Socket 通信方法调用全过程

以TCP和UDP两种方式来说明Socket通信的整体方法调用流程。

4.1 TCP方式

]

4.2 UDP方式

五、socket中TCP的三次握手建立连接

我们知道tcp建立连接要进行“三次握手”，即交换三个分组。大致流程如下：

• 客户端向服务器发送一个SYN J
• 服务器向客户端响应一个SYN K，并对SYN J进行确认ACK J+1
• 客户端再向服务器发一个确认ACK K+1

三次握手发生在socket的哪几个函数中呢？请看下图：

从图中可以看出：

1. 当客户端调用connect()时，触发了连接请求，向服务器发送了SYN J包，这时connect()进入阻塞状态；
2. 服务器监听到连接请求，即收到SYN J包，调用accept()函数接收请求向客户端发送SYN K，ACK J+1，这时accept进入阻塞状态；
3. 客户端收到服务器的SYN K，ACK J+1之后，connect()返回，并对SYN K进行确认；
4. 服务器收到ACK K+1时，accept返回，至此三次握手完毕，连接建立。

五、socket中TCP的四次挥手释放连接

上面介绍了socket中TCP的三次握手建立过程，及其涉及的socket函数。现在我们介绍socket中的四次握手释放连接的过程，请看下图：

图示过程如下：

1. 应用进程首先调用close主动关闭连接，这时客户端向服务端发送一个FIN M
2. 服务端收到FIN M后，执行被动关闭，并对这个FIN M进行确认。同时服务端的read函数返回0，表示到达文件末尾，再也读不到数据。
3. 一段时间之后，接收到文件结束符的服务端应用进程调用close()关闭它的socket。这导致它也发送了一个FIN N
4. 接收到这个FIN的客户端对其进行确认。

这样每个方向上都有一个FIN和ACK。

六、实例

说了这么多了，动手实践一下。下面编写一个简单的服务器、客户端（使用TCP）——服务器端一直监听本机的6666号端口，如果收到连接请求，将接收请求并接收客户端发来的消息；客户端与服务器端建立连接并发送一条消息。

服务端代码：

#include <sys/socket.h>
#include <stdio.h>
#include <netinet/in.h>  //INADDR_ANY
#include <cstring>
#include <unistd.h>
#include <arpa/inet.h>

#define MAX_MSG_LEN 2048

int main()
{
    int listen_fd,client_fd;
    struct sockaddr_in addr,sa;
    struct sockaddr client_addr;
    socklen_t addrlen,len;
    char buf[MAX_MSG_LEN] = {0};

    //创建socket
    if((listen_fd = socket(AF_INET, SOCK_STREAM, 0)) == -1)
    {
        printf("create socket error!");
        return -1;
    }

    //初始化结构体
    memset(&addr,0,sizeof(addr));
    addr.sin_family = AF_INET;
    addr.sin_port = htons(6666);   //6666端口，转换为主机字节序
    addr.sin_addr.s_addr = htonl(INADDR_ANY); //0.0.0.0 表示本地的所有地址，转换为网络字节序

    //绑定地址
    if(bind(listen_fd,(struct sockaddr*)&addr,sizeof(addr)) == -1)
    {
        printf("bind socket error!");
        return -1;
    }

    //监听socket
    if(listen(listen_fd,50) == -1)
    {
        printf("listen socket error!");
        return -1;
    }

    printf("======waiting for client's request======\n");
    while(1)
    {
         //接收请求
        if((client_fd=accept(listen_fd, &client_addr, &addrlen)) == -1)
        {
            printf("accept socket error!");
            return -1;
        }
        len = sizeof(sa);
        if(!getpeername(client_fd, (struct sockaddr *)&sa, &len))
        {
            printf( "对方IP：%s ", inet_ntoa(sa.sin_addr));
            printf( "对方PORT：%d ", ntohs(sa.sin_port));
        }

        int n = recv(client_fd, buf, MAX_MSG_LEN, 0);
        printf("消息:%s\n",buf);
        close(client_fd);
    }
    close(listen_fd);

    return 0;
}

客户端代码：

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


int main()
{
	int client_fd;
	struct sockaddr_in servaddr;
	char sendline[4096] = {0};
	
	if((client_fd = socket(AF_INET,SOCK_STREAM,0)) == -1)
	{
		printf("socket fail");
		return -1;
	}

	memset(&servaddr,0,sizeof(servaddr));
	servaddr.sin_family = AF_INET;
	servaddr.sin_port = htons(6666);
	if( inet_pton(AF_INET, "10.12.62.107", &servaddr.sin_addr) <=0)
	{
		printf("inet_pton fail");
                return -1;
	}

	if(connect(client_fd,(struct sockaddr*)&servaddr,sizeof(servaddr)) == -1)
	{
		printf("connect fail");
                return -1;
	}

	printf("send msg to server:\n");
	fgets(sendline, 4096, stdin);

	if(send(client_fd, sendline, strlen(sendline),0) <0)
	{
		printf("send fail");
                return -1;
	}

	close(client_fd);
	return 0;
}

当然上面的代码很简单，也有很多缺点，这就只是简单的演示socket的基本函数使用。其实不管有多复杂的网络程序，都使用的这些基本函数。上面的服务器使用的是迭代模式的，即只有处理完一个客户端请求才会去处理下一个客户端的请求，这样的服务器处理能力是很弱的，现实中的服务器都需要有并发处理能力！为了需要并发处理，服务器需要fork()一个新的进程或者线程去处理请求等。