Socket编程篇一

Posted 2020-07-07 mick_seu

参考自：http://www.cnblogs.com/skynet/archive/2010/12/12/1903949.html(吴秦)

1、Socket 简介

本地的进程间通信（IPC）有多种方法：

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

在本地可以通过进程 PID 来标识一个进程，但是在网络中这是行不通的。其实 TCP/IP 协议族已经帮我们解决了这个问题，网络层的 “ip地址” 可以唯一标识网络中的主机，而传输层的 “协议+端口” 可以唯一标识主机中的应用程序（进程）。这样利用三元组（ip地址，协议，端口）就可以标识网络的进程了，网络中的进程通信就可以利用这个标志与其它进程进行交互。

就目前而言，几乎所有的应用程序都是采用 socket 进行网络编程。

自学的过程中发现这个在线课堂，还不错～

http://www.hubwiz.com/course/56f9ee765fd193d76fcc6c17/（汇智网《Linux网络编程入门》）

2、Socket基本操作 

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

2.1  socket()

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

socket() 函数对应于普通文件的打开操作。普通文件的打开操作返回一个文件描述符，而 socket() 用于创建一个 socket 描述符（socket descriptor），它唯一标识一个socket。socket 函数的三个参数分别为：

1）domain：即协议域，又称为协议族（Address Family）。常用的协议族有，AF_INET、AF_INET6、AF_LOCAL（或称AF_UNIX，Unix域socket）、AF_ROUTE等等。协议族决定了socket的地址类型，在通信中必须采用对应的地址，如 AF_INET 决定了要用 ipv4 地址（32位的）与端口号（16位的）的组合、AF_UNIX 决定了要用一个绝对路径名作为地址。

2）type：指定socket类型。常用的socket类型有：SOCK_STREAM(流服务，适用TCP协议)、SOCK_DGRAM(数据包服务，使用UDP协议)、SOCK_RAW、SOCK_PACKET、SOCK_SEQPACKET 等等。

3）protocol：故名思意，就是指定协议。常用的协议有，IPPROTO_TCP、IPPROTO_UDP、IPPROTO_SCTP、IPPROTO_TIPC等，它们分别对应 TCP传输协议、UDP传输协议、SCTP传输协议、TIPC传输协议。

注意：并不是上面的 type 和 protocol 可以随意组合的，如 SOCK_STREAM 不可以跟 IPPROTO_UDP 组合。当protocol为0时，会自动选择type类型对应的默认协议。函数执行成功返回一个socket文件描述符，失败返回-1

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

2.2  bind()

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

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

函数的三个参数分别为：

1）sockfd：即socket描述符，它通过socket()函数创建，标识唯一的socket。bind()函数就是给这个描述符绑定一个地址。

2)   addr：一个const struct sockaddr *指针，指向要绑定给 sockfd 的协议地址。这个地址结构根据地址创建socket时的地址协议族的不同而不同。

ipv4对应的是： 

struct sockaddr_in {
    sa_family_t    sin_family; /* address family: AF_INET */
    in_port_t      sin_port;   /* port in network byte order */
    struct in_addr sin_addr;   /* internet address */
};

/* Internet address. */
struct in_addr {
    uint32_t       s_addr;     /* address in network byte order */
};

ipv6对应的是：

struct sockaddr_in6 { 
    sa_family_t     sin6_family;   /* AF_INET6 */ 
    in_port_t       sin6_port;     /* port number */ 
    uint32_t        sin6_flowinfo; /* IPv6 flow information */ 
    struct in6_addr sin6_addr;     /* IPv6 address */ 
    uint32_t        sin6_scope_id; /* Scope ID (new in 2.4) */ 
};

struct in6_addr { 
    unsigned char   s6_addr[16];   /* IPv6 address */ 
};

Unix域对应的是： 

#define UNIX_PATH_MAX    108

struct sockaddr_un { 
    sa_family_t sun_family;               /* AF_UNIX */ 
    char        sun_path[UNIX_PATH_MAX];  /* pathname */ 
};

3）addrlen：对应的是地址的长度。

函数执行成功返回0，失败返回-1。

通常服务器在启动的时候都会绑定一个众所周知的地址（如ip地址+端口号），用于提供服务，客户就可以通过它来接连服务器；而客户端就不用指定，由系统自动分配一个端口号和自身的ip地址组合。这就是为什么通常服务器端在listen之前会调用bind()，而客户端就不会调用，而是在connect()时由系统随机生成一个。

2.3  listen()、connect()

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

int listen(int sockfd, int backlog);

int connect(int sockfd, const struct sockaddr *addr, socklen_t addrlen);

listen() 函数的第一个参数即为要监听的 socket 描述符，第二个参数为相应 socket 监听队列的最大长度。socket()函数创建的socket默认是一个主动类型的，listen() 函数将socket变为被动类型的，等待客户的连接请求。listen() 函数创建一个监听队列以存放待处理的客户连接，将套接字sockfd指定为被监听的socket，其中backlog一般取值为5。

connect() 函数的第一个参数即为客户端的 socket 描述符，第二参数为服务器的socket地址，第三个参数为socket地址的长度。客户端通过调用 connect() 函数来建立与 TCP 服务器的连接，如果连接成功后，其第一个参数sockfd就唯一标示这个连接。函数执行成功返回0，失败返回-1。

2.4  accept()

TCP服务器端依次调用socket()、bind()、listen()之后，就会监听指定的socket地址了。TCP客户端依次调用socket()、connect()之后就想TCP服务器发送了一个连接请求。TCP服务器监听到这个请求之后，就会调用accept()函数取接收请求，这样连接就建立好了。之后就可以开始网络I/O操作了，即类同于普通文件的读写I/O操作。

int accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen);

accept() 函数的第一个参数为服务器的 socket描述符，第二个参数为指向struct sockaddr *的指针，用于返回客户端的协议地址，第三个参数为协议地址的长度。如果 accpet 成功，那么其返回值是由内核自动生成的一个全新的描述字，代表与返回客户的TCP连接。

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

2.5  read()、write()

至此服务器与客户已经建立好连接了。可以调用网络I/O进行读写操作了，即实现网络中不同进程之间的通信。网络I/O操作有下面几组：

1）read()/write()
2）recv()/send()
3）readv()/writev()
4）recvmsg()/sendmsg() 
5）recvfrom()/sendto()

2.6  close()

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

int close(int fd);

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

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

3、C/S模型

C/S模型(即client/server, 客户端/服务端模型)，是最经典的服务器模型，使用TCP连接，模型如下图所示。 TCP/IP协议在设计和实现并没有区分客户端和服务端，通信双方其实地位相同，但是因为很多数据（比如新闻、音乐、视频）均由公司集中提供，比如我们看视频的时候，服务端负责提供相关视频资源，因此有了客户端和服务端之分，很多客户端可以访问服务端以获取资源。

采用C/S模型的TCP客户端和TCP服务器工作流程，如下图所示：

服务端工作流程如下：

1）调用socket函数创建套接字(socket)。

2）调用bind函数给创建的套接字，分配IP地址和端口(bind)。

3）调用listen函数进行监听，等待客户端连接(listen)。

4）等待客户请求到来: 当请求到来后，调用accept函数接受连接请求，返回一个对应于此次连接的新的套接字，做好相互通信准备（accept）。

5）调用write/read或send/recv进行数据的读写，通过accept返回的套接字和客户端进行通信.

6）关闭socket(close)。

客户端工作流程如下：

1）调用socket函数创建套接字(socket)。

2）调用connect函数连接服务端(connect)。

3）调用write/read或send/recv进行数据的读写。

4）关闭socket(close)。

4、TCP三次握手

“三次握手”大致流程如下：

1）客户端向服务器发送一个SYN J；
2）服务器向客户端响应一个ACK J + 1，并发送一个 SYN K；
3）客户端再向服务器发一个确认ACK K+1。

如下图：

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

总结：客户端的connect在三次握手的第二个次返回，而服务器端的accept在三次握手的第三次返回。

5、TCP四次挥手

Socket中的四次握手释放连接的过程，请看下图：

某个应用进程首先调用close主动关闭连接，这时TCP发送一个FIN M；另一端接收到FIN M之后，执行被动关闭，对这个FIN进行确认。它的接收也作为文件结束符传递给应用进程，因为FIN的接收意味着应用进程在相应的连接上再也接收不到额外数据；一段时间之后，接收到文件结束符的应用进程调用close关闭它的socket。这导致它的TCP也发送一个FIN N；接收到这个FIN的源发送端TCP对它进行确认。

6、动动手

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

服务器：

#include <cstdio>
#include <unistd.h>
#include <stdlib.h>
#include <cstring>
#include <cassert>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>

const int BUFFER_SIZE = 4096;
const int SERVER_PORT = 7777;

int main()
{
	int server_socket;
	char buff[BUFFER_SIZE];
	int n;

	server_socket = socket(AF_INET, SOCK_STREAM, 0);
	assert(server_socket != -1);

	struct sockaddr_in server_addr;
	memset(&server_addr, 0, sizeof(server_addr));
	server_addr.sin_family = AF_INET;
	server_addr.sin_port = htons(SERVER_PORT);
	server_addr.sin_addr.s_addr = htonl(INADDR_ANY);

	assert(bind(server_socket, (struct sockaddr *)&server_addr, sizeof(server_addr)) != -1);
	assert(listen(server_socket, 5) != -1);
	
	struct sockaddr_in client_addr;
	socklen_t client_addr_len = sizeof(client_addr);

	while(1)
	{
		printf("waiting...\\n");
		int connfd = accept(server_socket, (struct sockaddr*)&client_addr, &client_addr_len);
		printf("here\\n");
		if(connfd == -1)
			continue;
		n = recv(connfd, buff, BUFFER_SIZE, 0);
		buff[n] = '\\n';
		printf("recv msg from client: %s\\n", buff);
		close(connfd);
	}
	close(server_socket);

	return 0;
}

客户端：

#include <cstdio>
#include <unistd.h>
#include <stdlib.h>
#include <cstring>
#include <cassert>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>

const int BUFFER_SIZE = 4096;
const int SERVER_PORT = 7777;

int main()
{
	int client_socket;
	const char *server_ip = "127.0.0.1";
	char buff[BUFFER_SIZE] = "I'm from client!\\n";

	client_socket = socket(AF_INET, SOCK_STREAM, 0);
	assert(client_socket != -1);

	struct sockaddr_in server_addr;
	memset(&server_addr, 0, sizeof(server_addr));
	server_addr.sin_family = AF_INET;
	server_addr.sin_port = htons(SERVER_PORT);
	server_addr.sin_addr.s_addr = inet_addr(server_ip);

	assert(connect(client_socket, (struct sockaddr *)&server_addr, sizeof(server_addr)) != -1);
	assert(send(client_socket, buff, strlen(buff), 0) != -1);

	close(client_socket);

	return 0;
}