嵌入式Linux学习笔记（7）-Socket网络编程

一、什么是Socket网络编程

Socket是一种抽象的编程接口，可以用于在不同主机之间进行数据通信。Socket API提供了一系列函数来创建、连接、发送和接收数据等操作。嵌入式 Linux 系统中的 Socket 网络编程是指在嵌入式系统中使用 Socket API 进行网络通信。

Socket 网络编程可以实现各种网络通信功能，如 TCP/IP 通信和 UDP 通信。

二、TCP 与 UDP

TCP是一种面向连接的协议，它提供可靠的数据传输。它通过建立一个连接，将数据分为多个小的数据包，并保证它们按顺序传输到目标节点。如果有数据包丢失或损坏，TCP会进行重传，确保所有数据包都被传输，并且按顺序重新组装。TCP还提供了流量控制和拥塞控制的机制，以确保网络稳定和高效。 TCP适用于需要可靠传输、顺序传输和流量控制的应用程序，如网页浏览、文件传输和电子邮件等。

UDP是一种无连接的协议，它提供不可靠的数据传输。UDP将数据分成小的数据包，并将它们发送到目标节点，但不保证它们按顺序送达。UDP不进行重传，也不提供流量控制和拥塞控制。因此，UDP的传输速度相对较快，但在不可靠的网络环境下可能会有数据丢失或乱序。UDP适用于对实时性要求较高，但对数据可靠性要求不高的应用程序，如视频流传输、语音通话和在线游戏等。

TCP/IP通信流程：

        TCP/IP通信通过三次握手建立连接，四次挥手关闭连接。

    1. 客户端向服务器发起连接请求，使用传输控制协议(TCP)的三次握手握手建立连接。

    2. 服务器接收到连接请求后，回复一个确认信息给客户端，进行第二次握手。

    3. 客户端接收到确认信息后，再次向服务器发送一个确认信息，进行第三次握手。

    4. 服务器接收到确认信息后，连接建立成功，开始进行数据传输。

    5. 客户端将需要传输的数据分成较小的数据包，并为每个数据包分配一个序列号，并将数据包传输给服务器。

    6. 服务器接收到数据包后，发送一个确认信息给客户端，表示已经接收到数据。

    7. 客户端接收到确认信息后，再次向服务器发送下一个数据包。

    8. 服务器不断接收和发送数据包，直到所有数据传输完成。

    9. 数据传输完成后，客户端发送一个连接释放请求给服务器，并等待服务器回复，进行第一次挥手。

    10. 服务器接收到连接释放请求后，发送一个确认信息给客户端，表示同意释放连接，进行第二次挥手。

    11. 客户端接收到确认信息后，不可以再向服务端发送消息，但仍可以接收服务端发送的消息。

    12. 服务端如果没有要发送的消息，此时发送一个连接释放请求给客户端，并等待客户端回复，进行第三次挥手。

    13. 客户端接收到连接释放请求后，发送一个确认信息给服务端，表示同意释放连接，进行第四次挥手。此时客户端关闭。

    14. 服务端接收到确认信息后关闭。

UDP通信流程：

        UDP通信不需要建立连接和释放连接。

    1. 客户端将需要传输的数据打包成数据报，并指定目标主机的IP地址和端口号。

    2. 客户端将数据报发送给目标主机。

    3. 服务器接收到数据报后，根据目标端口号对数据进行处理。

    4. 服务器根据需要向客户端发送响应数据报。

    5. 客户端接收到服务器的响应数据报后，进行相应的处理。

    6. 数据传输完成后，连接自动关闭，不需要进行连接释放。

三、相关函数

在C语言中提供了一系列的函数来创建、连接、发送和接收网络数据。下面是一些常见的Socket网络编程相关函数和它们的用法：

1、TCP 相关函数

socket()函数：创建一个新的Socket，并返回一个文件描述符。它接受三个参数：地址域（AF_INET表示IPv4）、类型（SOCK_STREAM表示TCP）和协议（0表示根据类型自动选择协议）。示例用法：

int sockfd;
sockfd = socket(AF_INET, SOCK_STREAM, 0);

bind()函数：将Socket绑定到一个特定的本地地址和端口。它接受三个参数：Socket文件描述符、指向本地地址结构的指针和本地地址结构的大小。示例用法：

struct sockaddr_in addr;
addr.sin_family = AF_INET;
addr.sin_port = htons(PORT);
addr.sin_addr.s_addr = INADDR_ANY;
bind(sockfd, (struct sockaddr *)&addr, sizeof(addr));

listen()函数：将Socket设置为监听状态，等待连接请求。它接受两个参数：Socket文件描述符和最大连接数。示例用法：

listen(sockfd, BACKLOG);

accept()函数：接受客户端的连接请求，并返回一个新的Socket文件描述符，用于后续的数据传输。它接受三个参数：Socket文件描述符、指向客户端地址结构的指针和客户端地址结构的大小。示例用法：

int new_sockfd;
new_sockfd = accept(sockfd, (struct sockaddr *)&client_addr, &addrlen);

connect()函数：与远程服务器建立连接。它接受三个参数：Socket文件描述符、指向远程地址结构的指针和远程地址结构的大小。示例用法：

struct sockaddr_in serv_addr;
serv_addr.sin_family = AF_INET;
serv_addr.sin_port = htons(PORT);
inet_pton(AF_INET, "127.0.0.1", &(serv_addr.sin_addr));
connect(sockfd, (struct sockaddr *)&serv_addr, sizeof(serv_addr));

send()函数：发送数据到连接的Socket。它接受四个参数：Socket文件描述符、指向数据的指针、数据的大小和附加参数。示例用法：

char message[] = "Hello, World!";
send(sockfd, message, strlen(message), 0);

recv()函数：从连接的Socket接收数据。它接受四个参数：Socket文件描述符、指向接收缓冲区的指针、缓冲区的大小和附加参数。示例用法：

char buffer[MAX_BUFFER_SIZE];
int bytes_received = recv(sockfd, buffer, MAX_BUFFER_SIZE - 1, 0);

close()函数：关闭Socket连接。它接受一个参数：Socket文件描述符。示例用法：

close(sockfd);

2、UDP相关函数

UDP 其余函数与 TCP 相同，只是发送和接收函数略有不同。

sendto()函数：向指定的目标地址发送数据。它接受六个参数：套接字文件描述符、数据缓冲区、数据大小、附加参数（通常为0）、目标地址结构的指针和目标地址结构的大小。

char message[] = "Hello, World!";
struct sockaddr_in client_addr;
client_addr.sin_family = AF_INET;
client_addr.sin_addr.s_addr = inet_addr("127.0.0.1");
client_addr.sin_port = htons(PORT);

sendto(sockfd, message, strlen(message), 0, (struct sockaddr*)&client_addr, sizeof(client_addr));

recvfrom()函数：从指定的源地址接收数据。它接受六个参数：套接字文件描述符、接收缓冲区、缓冲区大小、附加参数（通常为0）、源地址结构的指针和源地址结构的大小。

char buffer[1024];
struct sockaddr_in client_addr;
int addr_len = sizeof(client_addr);

recvfrom(sockfd, buffer, sizeof(buffer), 0, (struct sockaddr*)&client_addr, &addr_len);

注意：UDP是无连接的，所以在发送数据时不需要先建立连接。发送数据时，可以指定目标地址，也可以不指定（这时可以直接使用send()函数）。接收数据时，可以获取到数据的源地址。

四、基于TCP的Socket通信

1、通信流程

服务器端（server）的流程大致如下：

创建Socket：使用socket()函数创建一个Socket，并指定协议族和Socket类型。
绑定Socket：使用bind()函数将Socket与特定的IP地址和端口号绑定。
监听连接：使用listen()函数将Socket设置为监听状态。
接受连接：使用accept()函数接受客户端的连接请求，并创建一个新的Socket用于与客户端通信。
与客户端通信：使用send()函数向客户端发送数据，使用recv()函数从客户端接收数据。
关闭连接：使用close()函数关闭Socket连接。

客户端（client）的流程大致如下：

创建Socket：使用socket()函数创建一个Socket，并指定协议族和Socket类型。
连接服务器：使用connect()函数与服务器建立连接。
与服务器通信：使用send()函数向服务器发送数据，使用recv()函数从服务器接收数据。
关闭连接：使用close()函数关闭Socket连接。

2、编写实例

server.c

#include <sys/socket.h>
#include <sys/types.h>
#include <netinet/in.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <arpa/inet.h>
#include <pthread.h>

#include <unistd.h>
#define handle_error(cmd, result) \
    if (result < 0)               \
    {                             \
        perror(cmd);              \
        return -1;                \
    }

void *read_from_client(void *argv){
    // 使用recv接收客户端发送的数据打印到控制台
    char *read_buf = NULL;
    int client_fd = *(int *)argv;
    read_buf = malloc(sizeof(char*) * 1024);
    ssize_t count = 0;

    if (!read_buf)
    {
        perror("malloc server read_buf");
        return NULL;
    }
    //接收数据  只要能接收到数据 一直挂起
    while(count = recv(client_fd,read_buf,1024,0))
    {
        if (count < 0)
        {
            perror("malloc server read_buf");
            return NULL;
        }

        fputs(read_buf,stdout);
    }
    
    printf("客户端请求关闭\n");
    free(read_buf);

    return NULL;

}

void *write_from_client(void *argv){
    // 接受控制台输入的消息 发送出去
    char *write_buf = NULL;
    int client_fd = *(int *)argv;
    write_buf = malloc(sizeof(char*) * 1024);
    ssize_t count = 0;

    if (!write_buf)
    {
        perror("malloc server write_buf");
        return NULL;
    }

    while(fgets(write_buf,1024,stdin) != NULL)
    {
        //发送数据
        count = send(client_fd,write_buf,1024,0);

        if (count < 0)
        {
            perror("send");
            return NULL;
        }

    }
    
    printf("接收到关闭请求，不再写入，关闭连接\n");
    // 可以具体关闭某一端
    shutdown(client_fd,SHUT_WR);
    free(write_buf);

    return NULL;

}

int main(int argc, char const *argv[])
{
    int sockfd,clientfd,temp_result;
    pthread_t pid_read,pid_write;
    // 创建服务器地址和客户端地址
    struct sockaddr_in server_addr,client_addr;
    // 清空
    memset(&server_addr,0,sizeof(server_addr));
    memset(&client_addr,0,sizeof(client_addr));

    // 填写服务端地址
    server_addr.sin_family = AF_INET;//协议
    // 填写ip地址 0.0.0.0
    server_addr.sin_addr.s_addr = htonl(INADDR_ANY);
    // inet_pton(AF_INET,"0.0.0.0",&server_addr.sin_addr);
    // 填写端口号
    server_addr.sin_port = htons(6666);

    // 网络编程流程
    // 1. socket
    sockfd = socket(AF_INET,SOCK_STREAM,0);//IPV4,TCP
    handle_error("socket",sockfd);
    
    // 2. 绑定地址
    temp_result = bind(sockfd,(struct sockaddr *)&server_addr,sizeof(server_addr));
    handle_error("bind",temp_result);

    // 3. 进入监听状态
    temp_result = listen(sockfd,128);
    handle_error("listen",temp_result);

    // 4. 获取客户端连接
    socklen_t client_addr_len = sizeof(client_addr);
    // 返回的 clienfd 才是能够和客户端收发消息的文件描述符
    clientfd = accept(sockfd,(struct sockaddr *)&client_addr,&client_addr_len);// 如果没有客户端连接会挂起等待
    handle_error("accpet",clientfd);

    printf("与客户端%s %d 建立连接，文件描述符是 %d\n",inet_ntoa(client_addr.sin_addr),ntohs(client_addr.sin_port),clientfd);

    // 创建线程用于收消息
    pthread_create(&pid_read,NULL,read_from_client,(void *)&clientfd);

    // 创建线程用于发消息
    pthread_create(&pid_write,NULL,write_from_client,(void *)&clientfd);

    // 阻塞主线程
    pthread_join(pid_read,NULL);
    pthread_join(pid_write,NULL);

    // 释放资源
    printf("释放资源\n");
    close(clientfd);
    close(sockfd);

    return 0;
}

client.c

#include <sys/socket.h>
#include <sys/types.h>
#include <netinet/in.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <arpa/inet.h>
#include <pthread.h>

#include <unistd.h>
#define handle_error(cmd, result) \
    if (result < 0)               \
    {                             \
        perror(cmd);              \
        return -1;                \
    }

void *read_from_server(void *argv){
    // 使用recv接收客户端发送的数据打印到控制台
    char *read_buf = NULL;
    int client_fd = *(int *)argv;
    read_buf = malloc(sizeof(char*) * 1024);
    ssize_t count = 0;

    if (!read_buf)
    {
        perror("malloc server read_buf");
        return NULL;
    }
    //接收数据  只要能接收到数据 一直挂起
    while(count = recv(client_fd,read_buf,1024,0))
    {
        if (count < 0)
        {
            perror("malloc server read_buf");
            return NULL;
        }

        fputs(read_buf,stdout);
    }
    
    printf("服务端请求关闭\n");
    free(read_buf);

    return NULL;

}

void *write_from_server(void *argv){
    // 接受控制台输入的消息 发送出去
    char *write_buf = NULL;
    int client_fd = *(int *)argv;
    write_buf = malloc(sizeof(char*) * 1024);
    ssize_t count = 0;

    if (!write_buf)
    {
        perror("malloc server write_buf");
        return NULL;
    }

    while(fgets(write_buf,1024,stdin) != NULL)
    {
        //发送数据
        count = send(client_fd,write_buf,1024,0);

        if (count < 0)
        {
            perror("send");
            return NULL;
        }

    }
    
    printf("接收到关闭请求，不再写入，关闭连接\n");
    // 可以具体关闭某一端
    shutdown(client_fd,SHUT_WR);
    free(write_buf);

    return NULL;

}

int main(int argc, char const *argv[])
{
    int sockfd,temp_result;
    pthread_t pid_read,pid_write;
    // 创建服务器地址和客户端地址
    struct sockaddr_in server_addr,client_addr;
    // 清空
    memset(&server_addr,0,sizeof(server_addr));
    memset(&client_addr,0,sizeof(client_addr));

    // 填写客户端地址
    client_addr.sin_family = AF_INET;//协议
    // 填写ip地址 192.168.1.195
    inet_pton(AF_INET,"192.168.1.195",&client_addr.sin_addr);
    // 填写端口号
    client_addr.sin_port = htons(8888);

    // 填写服务端地址
    server_addr.sin_family = AF_INET;//协议
    // 填写ip地址 0.0.0.0/127.0.0.1
    inet_pton(AF_INET,"0.0.0.0",&server_addr.sin_addr);
    // 填写端口号
    server_addr.sin_port = htons(6666);


    // 客户端网络编程流程
    // 1. 创建socket
    sockfd = socket(AF_INET,SOCK_STREAM,0);
    handle_error("socket",sockfd);

    // 2. 绑定
    temp_result = bind(sockfd,(struct sockaddr *)&client_addr,sizeof(client_addr));
    handle_error("bind",temp_result);

    // 3. 主动连接服务端
    temp_result = connect(sockfd,(struct sockaddr *)&server_addr,sizeof(server_addr));
    handle_error("connect",temp_result);

    printf("连接上服务器%s %d\n",inet_ntoa(server_addr.sin_addr),ntohs(server_addr.sin_port));


    // 创建线程用于收消息
    pthread_create(&pid_read,NULL,read_from_server,(void *)&sockfd);

    // 创建线程用于发消息
    pthread_create(&pid_write,NULL,write_from_server,(void *)&sockfd);

    // 阻塞主线程
    pthread_join(pid_read,NULL);
    pthread_join(pid_write,NULL);

    // 释放资源
    printf("释放资源\n");
    close(sockfd);

    return 0;
}

五、基于UDP的Socket通信

1、通信流程

客户端（client）的流程大致如下：

创建Socket：使用socket()函数创建一个Socket，并指定协议族和Socket类型。

发送数据：使用sendto()函数将要发送的数据以及服务器的IP地址和端口号发送给服务器。

接收数据：使用recvfrom()函数从服务器接收数据。

关闭Socket：使用close()函数关闭Socket连接。

服务器端（server）的流程大致如下：

创建Socket：使用socket()函数创建一个Socket，并指定协议族和Socket类型。

绑定Socket：使用bind()函数将Socket与特定的IP地址和端口号绑定。

接收数据：使用recvfrom()函数从客户端接收数据。

处理数据：服务器对接收到的数据进行处理，可以根据需要进行相应的操作。

发送数据：使用sendto()函数将处理后的数据发送给客户端。

关闭Socket：使用close()函数关闭Socket连接。

2、编写实例

server.c

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

#define handle_error(cmd, result) \
    if (result < 0)               \
    {                             \
        perror(cmd);              \
        return -1;                \
    }

int main(int argc, char const *argv[])
{
    // 使用UDP协议完成客户端与服务端的通信
    // EOF作为关闭的信号
    int sockfd,temp_result;
    char *buf = malloc(sizeof(char) * 1024);

    // 创建服务器地址和客户端地址
    struct sockaddr_in server_addr,client_addr;
    // 清空
    memset(&server_addr,0,sizeof(server_addr));
    memset(&client_addr,0,sizeof(client_addr));

    // 填写服务端地址
    server_addr.sin_family = AF_INET;//协议
    // 填写ip地址 0.0.0.0
    server_addr.sin_addr.s_addr = htonl(INADDR_ANY);
    // inet_pton(AF_INET,"0.0.0.0",&server_addr.sin_addr);
    // 填写端口号
    server_addr.sin_port = htons(6666);

    // UDP编程流程
    // 1. socket
    sockfd = socket(AF_INET,SOCK_DGRAM,0);//IPV4,TCP
    handle_error("socket",sockfd);

    // 2. 服务端绑定地址
    socklen_t server_len = sizeof(server_addr);
    socklen_t client_len = sizeof(client_addr);
    temp_result = bind(sockfd,(struct sockaddr *)&server_addr,server_len);
    handle_error("bind",temp_result);

    // 直接收发数据
    do
    {
        // 接收数据存到缓冲
        memset(buf,0,1024);
        temp_result = recvfrom(sockfd,buf,1024,0,(struct sockaddr*)&client_addr,&client_len);
        handle_error("recvfrom",temp_result);

        if (strncmp(buf,"EOF",3) != 0)
        {
            printf("接收到客户端%s %d信息: %s\n",inet_ntoa(client_addr.sin_addr),ntohs(client_addr.sin_port),buf);
            strcpy(buf,"OK");
        }else{
            printf("准备关闭\n");
        }
        
        temp_result = sendto(sockfd,buf,4,0,(struct sockaddr*)&client_addr,client_len);
        handle_error("sendto",temp_result);

    } while (strncmp(buf,"EOF",3) != 0);
    
    free(buf);
    
    return 0;
}

client.c

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

#define handle_error(cmd, result) \
    if (result < 0)               \
    {                             \
        perror(cmd);              \
        return -1;                \
    }

int main(int argc, char const *argv[])
{
    // 使用UDP协议完成客户端与服务端的通信
    // EOF作为关闭的信号
    int sockfd,temp_result;
    char *buf = malloc(sizeof(char) * 1024);

    // 创建服务器地址和客户端地址
    struct sockaddr_in server_addr,client_addr;
    // 清空
    memset(&server_addr,0,sizeof(server_addr));
    memset(&client_addr,0,sizeof(client_addr));

    // 填写服务端地址
    server_addr.sin_family = AF_INET;//协议
    // 填写ip地址 0.0.0.0
    server_addr.sin_addr.s_addr = htonl(INADDR_ANY);
    // inet_pton(AF_INET,"0.0.0.0",&server_addr.sin_addr);
    // 填写端口号
    server_addr.sin_port = htons(6666);

    // UDP编程流程
    // 1. socket
    sockfd = socket(AF_INET,SOCK_DGRAM,0);//IPV4,TCP
    handle_error("socket",sockfd);

    // 2. 客户端不需要绑定地址
    socklen_t server_len = sizeof(server_addr);
    socklen_t client_len = sizeof(client_addr);
    // temp_result = bind(sockfd,(struct sockaddr *)&server_addr,server_len);
    // handle_error("bind",temp_result);

    // 直接收发数据
    do
    {
        write(STDOUT_FILENO,"Type something you want to send: ", 34);
        // 从控制台读取信息
        int buf_len = read(STDIN_FILENO,buf,1023);
        sendto(sockfd,buf,buf_len,0,(struct sockaddr *)&server_addr,server_len);
        handle_error("sendto",buf_len);

        // 清空缓冲区
        memset(buf,0,1024);

        temp_result = recvfrom(sockfd,buf,1024,0,NULL,NULL);
        handle_error("recvfrom",temp_result);

        if (strncmp(buf,"EOF",3) != 0)
        {
            printf("接收到服务端%s %d返回的数据: %s\n",inet_ntoa(server_addr.sin_addr),ntohs(server_addr.sin_port),buf);
        }
        

    } while (strncmp(buf,"EOF",3) != 0);

    free(buf);
    
    return 0;
}