1.socket介绍

socket（套接字）是对网络中不同主机上的应用进程之间进行双向通信的端点的抽象。
一个套接字就是网络上进程通信的一端，提供了应用层进程利用网络协议交换数据的机制。从所处的地位来讲，套接字上联应用进程，下联网络协议栈，是应用程序通过网络协议进行通信的接口，是应用程序与网络协议根进行交互的接口。

socket 可以看成是两个网络应用程序进行通信时，各自通信连接中的端点，这是一个逻辑上的概念。它是网络环境中进程间通信的 API，也是可以被命名和寻址的通信端点，使用中的每一个套接字都有其类型和一个与之相连进程。通信时其中一个网络应用程序将要传输的一段信息写入它所在主机的 socket 中，该 socket 通过与网络接口卡（NIC）相连的传输介质将这段信息送到另外一台主机的 socket 中，使对方能够接收到这段信息。socket 是由 IP 地址和端口结合的，提供向应用层进程传送数据包的机制。

socket 本身有“插座”的意思，在 Linux 环境下，用于表示进程间网络通信的特殊文件类型。本质为内核借助缓冲区形成的伪文件。既然是文件，那么理所当然的，我们可以使用文件描述符引用套接字。与管道类似的，Linux 系统将其封装成文件的目的是为了统一接口，使得读写套接字和读写文件的操作一致。区别是管道主要应用于本地进程间通信，而套接字多应用于网络进程间数据的传递。

//套接字通信分为两部分：
-服务器端：被动接受连接，一般不会主动发起连接
-客户端：主动向服务器发起连接
1
2
3

2.字节序

现代 CPU 的累加器一次都能装载（至少）4 字节（32 位机），即一个整数。那么这4字节在内存中排列的顺序将影响它被累加器装载成的整数的值，这就是字节序问题。

字节序，顾名思义字节的顺序，就是大于一个字节类型的数据在内存中的存放顺序。

字节序分为大端字节序（Big-Endian） 和小端字节序（Little-Endian）：
大端字节序是指一个整数的最高位字节（23 ~ 31 bit）存储在内存的低地址处，低位字节（0 ~ 7 bit）存储在内存的高地址处；
小端字节序则是指整数的高位字节存储在内存的高地址处，而低位字节则存储在内存的低地址处。

字节序举例

小段字节序：

大端字节序：

字节序转换函数

当格式化的数据在两台使用不同字节序的主机之间直接传递时，接收端必然错误的解释之。解决问题的方法是：发送端总是把要发送的数据转换成大端字节序数据后再发送，而接收端知道对方传送过来的数据总是采用大端字节序，所以接收端可以根据自身采用的字节序决定是否对接收到的数据进行转换（小端机转换，大端机不转换）。

BSD Socket提供了封装好的转换接口：
从主机字节序到网络字节序的转换函数：htons、htonl；
从网络字节序到主机字节序的转换函数：ntohs、ntohl。

h - host 主机，主机字节序 
to - 转换成什么 
n - network 网络字节序 
s - short unsigned short 
l - long unsigned int
1
2
3
4
5

网络通信时，需要将主机字节序转换成网络字节序（大端），
另外一端获取到数据以后根据情况将网络字节序转换成主机字节序。
// 用来转换端口
uint16_t htons(uint16_t hostshort);		// 主机字节序 - 网络字节序
uint16_t ntohs(uint16_t netshort);		// 网络字节序 - 主机字节序

// 用来转换IP
uint32_t htonl(uint32_t hostlong);		// 主机字节序 - 网络字节序
uint32_t ntohl(uint32_t netlong);		// 网络字节序 - 主机字节序
1
2
3
4
5
6
7
8
9

示例：

int main() {

    // htons 转换端口
    unsigned short a = 0x0102;
    printf("a : %x\n", a);
    unsigned short b = htons(a);
    printf("b : %x\n", b);
    printf("=======================\n");
    // htonl  转换IP
    char buf[4] = {192, 168, 1, 100};
    int num = *(int *)buf;
    int sum = htonl(num);
    unsigned char *p = (char *)∑
    printf("%d %d %d %d\n", *p, *(p+1), *(p+2), *(p+3));
    printf("=======================\n");
    // ntohl
    unsigned char buf1[4] = {1, 1, 168, 192};
    int num1 = *(int *)buf1;
    int sum1 = ntohl(num1);
    unsigned char *p1 = (unsigned char *)&sum1;
    printf("%d %d %d %d\n", *p1, *(p1+1), *(p1+2), *(p1+3));
    
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

3.socket地址

socket地址是一个结构体，封装端口号和IP等信息。

通用socket地址

socket 网络编程接口中表示 socket 地址的是结构体 sockaddr，定义为：

#include <bits/socket.h> 
struct sockaddr { 
    sa_family_t sa_family;      //sa_family成员是地址族类型（sa_family_t）的变量
    char sa_data[14];           //用于存放socket地址值
};
typedef unsigned short int sa_family_t;
1
2
3
4
5
6

地址族类型通常与协议族类型对应。常见的协议族（protocol family，也称 domain）和对应的地址族入下所示：

宏 PF_* 和 AF_* 都定义在 bits/socket.h 头文件中，且后者与前者有完全相同的值，所以二者通常混用。

sa_data 成员用于存放 socket 地址值。但是，不同的协议族的地址值具有不同的含义和长度，如下所示：

14 字节的 sa_data 根本无法容纳多数协议族的地址值。
因此，Linux 定义了新的通用的 socket 地址结构体，这个结构体不仅提供了足够大的空间用于存放地址值，而且是内存对齐的。

#include <bits/socket.h>
struct sockaddr_storage
{
    sa_family_t sa_family;
    unsigned long int __ss_align;
    char __ss_padding[ 128 - sizeof(__ss_align) ];
};
typedef unsigned short int sa_family_t;
1
2
3
4
5
6
7
8

专用socket地址

为了向前兼容，现在sockaddr 退化成了（void *）的作用，传递一个地址给函数，至于这个函数是 sockaddr_in 还是sockaddr_in6，由地址族确定，然后函数内部再强制类型转化为所需的地址类型。

UNIX 本地域协议族专用的 socket 地址结构体：

#include <sys/un.h>
struct sockaddr_un
{
    sa_family_t sin_family;
    char sun_path[108];
};
1
2
3
4
5
6

TCP/IP 协议族有sockaddr_in和sockaddr_in6两个专用的socket地址结构体，分别用于 IPv4 和IPv6：

#include <netinet/in.h> 
struct sockaddr_in 
{ 
    sa_family_t sin_family; /* __SOCKADDR_COMMON(sin_) */ 
    in_port_t sin_port; /* Port number. */ 
    struct in_addr sin_addr; /* Internet address. */ 
    /* Pad to size of `struct sockaddr'. */ 
    unsigned char sin_zero[sizeof (struct sockaddr) - __SOCKADDR_COMMON_SIZE - sizeof (in_port_t) - sizeof (struct in_addr)]; 
};

struct in_addr 
{ 
    in_addr_t s_addr; 
};

struct sockaddr_in6 
{ 
    sa_family_t sin6_family; 
    in_port_t sin6_port; /* Transport layer port # */ 
    uint32_t sin6_flowinfo; /* IPv6 flow information */ 
    struct in6_addr sin6_addr; /* IPv6 address */ 
    uint32_t sin6_scope_id; /* IPv6 scope-id */ 
}; 

typedef unsigned short uint16_t; 
typedef unsigned int uint32_t; 
typedef uint16_t in_port_t; 
typedef uint32_t in_addr_t; 
#define __SOCKADDR_COMMON_SIZE (sizeof (unsigned short int))
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

所有专用 socket 地址（以及 sockaddr_storage）类型的变量在实际使用时都需要转化为通用 socket 地址类型 sockaddr（强制转化即可），因为所有 socket 编程接口使用的地址参数类型都是sockaddr。

4.IP地址转换

通常，人们习惯用可读性好的字符串来表示 IP 地址，比如用点分十进制字符串表示 IPv4 地址，以及用十六进制字符串表示 IPv6 地址。
但编程中我们需要先把它们转化为整数（二进制数）方能使用。
而记录日志时则相反，要把整数表示的 IP 地址转化为可读的字符串。
下面 2 个函数可用于用点分十进制字符串表示的地址和用网络字节序整数表示的地址之间的转换，同时适用 IPv4 地址和 IPv6 地址：：

#include <arpa/inet.h>
// p:点分十进制的IP字符串，n:表示network，网络字节序的整数
int inet_pton(int af, const char *src, void *dst);
    af:地址族： AF_INET  AF_INET6
    src:需要转换的点分十进制的IP字符串
    dst:保存转换后的结果

// 将网络字节序的整数，转换成点分十进制的IP地址字符串
const char *inet_ntop(int af, const void *src, char *dst, socklen_t size);
    af:地址族： AF_INET  AF_INET6
    src: 要转换的ip的整数的地址
    dst: 保存转换成IP地址字符串
    size：第三个参数的大小（数组的大小）
    返回值：返回转换后的数据的地址（字符串），和 dst 是一样的
1
2
3
4
5
6
7
8
9
10
11
12
13
14

示例：

int main() {

    char buf[] = "192.168.1.4";        // 创建一个ip字符串,点分十进制的IP地址字符串
    unsigned int num = 0;              // 保存转换后的结果
    inet_pton(AF_INET, buf, &num);     // 将点分十进制的IP字符串转换成网络字节序的整数
    unsigned char * p = (unsigned char *)#
    printf("%d %d %d %d\n", *p, *(p+1), *(p+2), *(p+3));   // 逐个字节打印nums中的数据
    char ip[16] = "";                                      // 保存转换后结果的字符串
    const char * str =  inet_ntop(AF_INET, &num, ip, 16);  // 将网络字节序的IP整数转换成点分十进制的IP字符串
    printf("str : %s\n", str);        // 打印返回值
    printf("ip : %s\n", str);         // 也可以打印保存转换后结果的字符串
    printf("%d\n", ip == str);        // 两个返回值是一样的

    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

5.TCP通信流程

TCP和UDP是传输层的协议
UDP:用户数据报协议，面向无连接(通讯两端没有建立连接)，可以单播，多播，广播， 面向数据报，不可靠
TCP:传输控制协议，面向连接的，可靠的，基于字节流，仅支持单播传输

TCP通信流程

服务器端（被动接受连接）
1.创建一个用于监听的套接字
  - 监听：监听有客户端的连接 
  - 套接字：这个套接字其实就是一个文件描述符
2. 将这个监听文件描述符和本地的IP和端口绑定（IP和端口就是服务器的地址信息） 
  - 客户端连接服务器的时候使用的就是这个IP和端口 
3. 设置监听，监听的fd开始工作
4. 阻塞等待，当有客户端发起连接，解除阻塞，接受客户端的连接，会得到一个和客户端通信的套接字 （fd） 
5. 通信 - 接收数据 - 发送数据
6. 通信结束，断开连接

客户端
1. 创建一个用于通信的套接字（fd） 
2. 连接服务器，需要指定连接的服务器的 IP 和 端口 
3. 连接成功了，客户端可以直接和服务器通信 
   - 接收数据 
   - 发送数据  
4. 通信结束，断开连接
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

6.socket函数

#include <sys/types.h> 
#include <sys/socket.h> 
#include <arpa/inet.h> // 包含了这个头文件，上面两个就可以省略 
int socket(int domain, int type, int protocol); 
    功能：创建一个套接字  
    参数：
         - domain: 协议族 
                   AF_INET : ipv4 
                   AF_INET6 : ipv6 
                   AF_UNIX, AF_LOCAL : 本地套接字通信（进程间通信） 
         - type: 通信过程中使用的协议类型 
                 SOCK_STREAM : 流式协议 
                 SOCK_DGRAM : 报式协议 
         - protocol : 具体的一个协议。一般写0 
         - SOCK_STREAM : 流式协议默认使用 TCP 
         - SOCK_DGRAM : 报式协议默认使用 UDP 
    返回值： 
         - 成功：返回文件描述符，操作的就是内核缓冲区
         - 失败：返回-1 

int bind(int sockfd, const struct sockaddr *addr, socklen_t addrlen); // socket命名 
    功能：绑定，将fd 和本地的IP + 端口进行绑定 
    参数： 
         - sockfd : 通过socket函数得到的文件描述符 
         - addr : 需要绑定的socket地址，这个地址封装了ip和端口号的信息 
         - addrlen : 第二个参数结构体占的内存大小 

int listen(int sockfd, int backlog);
    功能：监听这个socket上的连接 
    参数：
         - sockfd : 通过socket()函数得到的文件描述符 
         - backlog : 未连接的和已经连接的和的最大值，一般指定5就可以 

int accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen); 
    功能：接收客户端连接，默认是一个阻塞的函数，阻塞等待客户端连接 
    参数： 
         - sockfd : 用于监听的文件描述符 
         - addr : 传出参数，记录了连接成功后客户端的地址信息（ip，port） 
         - addrlen : 指定第二个参数的对应的内存大小 
    返回值：
         - 成功 ：用于通信的文件描述符 
         - 失败 ：返回-1 

int connect(int sockfd, const struct sockaddr *addr, socklen_t addrlen);
    功能： 客户端连接服务器 
    参数： 
         - sockfd : 用于通信的文件描述符 
         - addr : 客户端要连接的服务器的地址信息 
         - addrlen : 第二个参数的内存大小 
    返回值：成功返回0， 失败返回1 

ssize_t write(int fd, const void *buf, size_t count);    // 写数据 
ssize_t read(int fd, void *buf, size_t count);           // 读数据
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53

7.TCP通信实现

服务器端

// TCP 通信的服务器端
#include <stdio.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <string.h>
#include <stdlib.h>

int main() {

    // 1.创建socket(用于监听的套接字)
    int lfd = socket(AF_INET, SOCK_STREAM, 0);
    // 2.绑定
    struct sockaddr_in saddr;            // 创建socket地址
    saddr.sin_family = AF_INET;          // 对socket地址的成员进行初始化
    saddr.sin_addr.s_addr = INADDR_ANY;  // 0.0.0.0，表示任意地址，可以让多个客户端访问
    saddr.sin_port = htons(9999);        // 将端口设置为9999，利用htons将主机字节序转换成网络字节序
    int ret = bind(lfd, (struct sockaddr *)&saddr, sizeof(saddr));  //将 fd 和本地的IP + 端口进行绑定
    // 3.监听
    ret = listen(lfd, 8);
    // 4.接收客户端连接
    struct sockaddr_in clientaddr;       // 创建socket地址，记录连接进来的客户端信息
    int len = sizeof(clientaddr);        // socket地址的长度
    int cfd = accept(lfd, (struct sockaddr *)&clientaddr, &len);   // 接收客户端连接，返回的是文件描述符
    // 输出客户端的信息
    char clientIP[16];                   // 定义IP字符串
    inet_ntop(AF_INET, &clientaddr.sin_addr.s_addr, clientIP, sizeof(clientIP)); // 将网络字节序转换成主机字节序
    unsigned short clientPort = ntohs(clientaddr.sin_port);        // 获取端口信息
    printf("client ip is %s, port is %d\n", clientIP, clientPort); // 打印客户端的信息
    // 5.通信
    char recvBuf[1024] = {0};            // 定义保存读取数据的数组
    while(1) {
        int num = read(cfd, recvBuf, sizeof(recvBuf));             // 获取客户端的数据
        if(num == -1) {                 // 调用失败
            perror("read");
            exit(-1);
        } else if(num > 0) {            // 读到数据
            printf("recv client data : %s\n", recvBuf);            // 打印获取到的数据
        } else if(num == 0) {           // 表示客户端断开连接
            printf("clinet closed...");
            break;
        }
        char * data = "hello,i am server";                         // 给客户端要发送的数据
        write(cfd, data, strlen(data));                            // 给客户端发送数据
    }
    // 关闭文件描述符
    close(cfd);
    close(lfd);

    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50

客户端

// TCP通信的客户端
#include <stdio.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <string.h>
#include <stdlib.h>

int main() {

    // 1.创建套接字
    int fd = socket(AF_INET, SOCK_STREAM, 0);
    // 2.连接服务器端
    struct sockaddr_in serveraddr;             // 创建socket地址
    serveraddr.sin_family = AF_INET;           // 对socket地址的成员进行初始化
    inet_pton(AF_INET, "192.168.141.129", &serveraddr.sin_addr.s_addr);         //指定IP
    serveraddr.sin_port = htons(9999);         // 端口设置的值要和服务器端保持一致
    int ret = connect(fd, (struct sockaddr *)&serveraddr, sizeof(serveraddr));  //客户端连接服务器
    // 3. 通信
    char recvBuf[1024] = {0};                 // 定义保存读取数据的数组
    while(1) {
        char * data = "hello,i am client";    // 要给服务器端发送的数据
        write(fd, data , strlen(data));       // 给服务器端发送数据
        sleep(1);
        int len = read(fd, recvBuf, sizeof(recvBuf));
        if(len == -1) {
            perror("read");
            exit(-1);
        } else if(len > 0) {
            printf("recv server data : %s\n", recvBuf);
        } else if(len == 0) {
            // 表示服务器端断开连接
            printf("server closed...");
            break;
        }
    }
    close(fd);                               // 关闭连接
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38