• 如何进行网络编程和套接字操作？

    网络编程是计算机编程中重要的领域之一，它使程序能够在网络上进行数据传输和通信。C语言是一种强大的编程语言，也可以用于网络编程。网络编程通常涉及套接字（Socket）操作，套接字是一种用于网络通信的抽象接口。本文将详细讨论如何进行C语言网络编程和套接字操作。

    第一部分：网络编程基础

    在开始学习C语言网络编程之前，首先需要理解一些基本的概念和术语。

    1.1 IP地址和端口号

    • IP地址：IP地址是用于标识计算机或设备在网络上的唯一地址。IPv4和IPv6是两种常用的IP地址协议，它们用于不同的网络环境。IPv4地址通常表示为四个十进制数，如192.168.1.1，而IPv6地址更长，以冒号分隔，如2001:0db8:85a3:0000:0000:8a2e:0370:7334。

    • 端口号：端口号用于标识正在运行的应用程序或服务。它是一个16位的整数，范围从0到65535。常见的端口号已被分配给特定的应用程序，例如HTTP通常使用端口80，HTTPS使用端口443。

    1.2 客户端和服务器

    在网络编程中，有两个主要的角色：客户端和服务器。

    • 客户端：客户端是发送请求并接收服务器响应的程序或设备。它通常主动发起连接，并向服务器请求数据或服务。

    • 服务器：服务器是接受客户端请求并提供相应服务的程序或设备。它通常监听一个特定的端口，并等待客户端连接。

    1.3 套接字（Socket）

    套接字是网络编程中的核心概念。套接字允许程序通过网络进行通信，可以是TCP套接字或UDP套接字。

    • TCP套接字：TCP（传输控制协议）提供可靠的、面向连接的通信。TCP套接字用于建立可靠的双向通信通道，数据按顺序传输，且不丢失。

    • UDP套接字：UDP（用户数据报协议）提供不可靠的、面向数据包的通信。UDP套接字用于快速数据传输，但不能保证数据的顺序和可靠性。

    第二部分：套接字编程步骤

    进行网络编程和套接字操作通常涉及以下步骤：

    2.1 包含头文件

    要进行套接字编程，需要包含C语言的相关头文件。最常用的头文件是、和。这些头文件包含了套接字函数和网络地址结构的定义。

    1. #include 
    2. #include 
    3. #include

    2.2 创建套接字

    创建套接字是网络编程的第一步。使用socket函数来创建套接字，该函数的原型如下

    int socket(int domain, int type, int protocol);

    • domain参数指定套接字的协议族，常用的是AF_INET（IPv4）和AF_INET6（IPv6）。

    • type参数指定套接字的类型，常用的有SOCK_STREAM（用于TCP）和SOCK_DGRAM（用于UDP）。

    • protocol参数通常设置为0，以便根据domain和type自动选择协议。

    以下是创建TCP套接字的示例：

    1. int sockfd = socket(AF_INET, SOCK_STREAM, 0);
    2. if (sockfd == -1) {
    3.     perror("Socket creation failed");
    4.     // 处理错误
    5. }

    2.3 定义服务器和客户端地址

    在网络通信中，服务器和客户端都需要定义自己的地址信息。这些信息包括IP地址和端口号。

    定义服务器地址
    1. struct sockaddr_in server_addr;
    2. server_addr.sin_family = AF_INET;            // 使用IPv4
    3. server_addr.sin_port = htons(PORT_NUMBER);   // 设置端口号（需要使用htons函数进行字节序转换）
    4. server_addr.sin_addr.s_addr = INADDR_ANY;    // 监听所有可用的网络接口
    定义客户端地址
    1. struct sockaddr_in client_addr;
    2. client_addr.sin_family = AF_INET;            // 使用IPv4
    3. client_addr.sin_port = htons(PORT_NUMBER);   // 设置服务器端口号
    4. client_addr.sin_addr.s_addr = inet_addr(SERVER_IP); // 设置服务器IP地址

    2.4 绑定套接字（服务器端）

    在服务器端，需要将套接字绑定到一个特定的IP地址和端口号上，以便监听客户端连接。使用bind函数来执行绑定操作：

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

    • sockfd是套接字描述符，即要绑定的套接字。

    • addr是一个指向sockaddr结构的指针，其中包含要绑定的地址信息。

    • addrlen是addr结构的长度。

    以下是服务器端绑定套接字的示例：

    1. if (bind(sockfd, (struct sockaddr *)&server_addr, sizeof(server_addr)) == -1) {
    2.     perror("Bind failed");
    3.     // 处理错误
    4. }

    2.5 监听连接请求（服务器端）

    在服务器端，需要使用listen函数开始监听客户端的连接请求：

    int listen(int sockfd, int backlog);

    • sockfd是套接字描述符，即要监听的套接字。

    • backlog是等待连接队列的最大长度，通常设置为5或更大。

    以下是服务器端监听连接请求的示例：

     

    1. if (listen(sockfd, 5) == -1) {
    2.     perror("Listen failed");
    3.     // 处理错误
    4. }
     

    2.6 接受连接（服务器端）
     

    当客户端尝试连接到服务器时，服务器需要使用accept函数接受连接请求并创建新的套接字用于通信：
     

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

     

    •  
      sockfd是监听套接字的描述符。
       
    •  
      addr是一个指向sockaddr结构的指针，用于存储客户端的地址信息。
       
    •  
      addrlen是addr结构的长度。
       
     

    accept函数将返回一个新的套接字描述符，用于与客户端通信。服务器可以使用此套接字与客户端进行数据交换。
     

    以下是服务器端接受连接的示例：
     

    1. int new_socket;
    2. socklen_t addr_len = sizeof(client_addr);
    3. new_socket = accept(sockfd, (struct sockaddr *)&client_addr, &addr_len);
    4. if (new_socket == -1) {
    5.     perror("Accept failed");
    6.     // 处理错误
    7. }
     

    2.7 连接到服务器（客户端）
     

    在客户端，需要使用connect函数连接到服务器：
     

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

     

    •  
      sockfd是客户端套接字的描述符。
       
    •  
      addr是一个指向服务器地址的指针。
       
    •  
      addrlen是服务器地址结构的长度。
       
     

    以下是客户端连接到服务器的示例：
     

     

    1. if (connect(sockfd, (struct sockaddr *)&server_addr, sizeof(server_addr)) == -1) {
    2.     perror("Connection failed");
    3.     // 处理错误
    4. }
     

    2.8 发送和接收数据
     

    一旦连接建立，服务器和客户端可以使用send和recv函数来发送和接收数据。
     

    发送数据
     

     

    ssize_t send(int sockfd, const void *buf, size_t len, int flags);

     

    •  
      sockfd是套接字描述符。
       
    •  
      buf是包含要发送数据的缓冲区的指针。
       
    •  
      len是要发送的数据的字节数。
       
    •  
      flags通常设置为0。
       
     

    以下是发送数据的示例：
     

    1. char message[] = "Hello, Server!";
    2. send(new_socket, message, strlen(message), 0);
     

    接收数据
     

     

    ssize_t recv(int sockfd, void *buf, size_t len, int flags);

     

    •  
      sockfd是套接字描述符。
       
    •  
      buf是用于存储接收数据的缓冲区的指针。
       
    •  
      len是缓冲区的大小，表示最多可以接收多少字节的数据。
       
    •  
      flags通常设置为0。
       
     

    以下是接收数据的示例：
     

     

    1. char buffer[1024];
    2. ssize_t bytes_received = recv(new_socket, buffer, sizeof(buffer), 0);
    3. if (bytes_received == -1) {
    4.     perror("Receive failed");
    5.     // 处理错误
    6. } else {
    7.     buffer[bytes_received] = '\0'; // 添加字符串结束符
    8.     printf("Received: %s\n", buffer);
    9. }
     

    2.9 关闭套接字
     

    在完成通信后，服务器和客户端应使用close函数关闭套接字以释放资源：
     

    int close(int sockfd);

     

    • sockfd是要关闭的套接字描述符。
     

    以下是关闭套接字的示例：
     

    1. close(new_socket); // 关闭与客户端的套接字
    2. close(sockfd);     // 关闭服务器监听套接字
     

    第三部分：完整的示例
     

    以下是一个简单的C语言网络编程示例，其中包括了创建服务器和客户端的代码。
     

    服务器端示例
     

    1. #include 
    2. #include 
    3. #include 
    4. #include 
    5. #include 
    6. #include 
    7.  
    8. #define PORT_NUMBER 8080
    9.  
    10. int main() {
    11.     int sockfd, new_socket;
    12.     struct sockaddr_in server_addr, client_addr;
    13.     socklen_t addr_len = sizeof(client_addr);
    14.  
    15.     // 创建套接字
    16.     sockfd = socket(AF_INET, SOCK_STREAM, 0);
    17.     if (sockfd == -1) {
    18.         perror("Socket creation failed");
    19.         exit(1);
    20.     }
    21.  
    22.     // 定义服务器地址
    23.     server_addr.sin_family = AF_INET;
    24.     server_addr.sin_port = htons(PORT_NUMBER);
    25.     server_addr.sin_addr.s_addr = INADDR_ANY;
    26.  
    27.     // 绑定套接字到地址
    28.     if (bind(sockfd, (struct sockaddr *)&server_addr, sizeof(server_addr)) == -1) {
    29.         perror("Bind failed");
    30.         exit(1);
    31.     }
    32.  
    33.     // 监听连接请求
    34.     if (listen(sockfd, 5) == -1) {
    35.         perror("Listen failed");
    36.         exit(1);
    37.     }
    38.  
    39.     // 接受连接
    40.     new_socket = accept(sockfd, (struct sockaddr *)&client_addr, &addr_len);
    41.     if (new_socket == -1) {
    42.         perror("Accept failed");
    43.         exit(1);
    44.     }
    45.  
    46.     // 接收数据
    47.     char buffer[1024];
    48.     ssize_t bytes_received = recv(new_socket, buffer, sizeof(buffer), 0);
    49.     if (bytes_received == -1) {
    50.         perror("Receive failed");
    51.         exit(1);
    52.     }
    53.     buffer[bytes_received] = '\0'; // 添加字符串结束符
    54.     printf("Received: %s\n", buffer);
    55.  
    56.     // 发送响应
    57.     const char *response = "Hello, Client!";
    58.     send(new_socket, response, strlen(response), 0);
    59.  
    60.     // 关闭套接字
    61.     close(new_socket);
    62.     close(sockfd);
    63.  
    64.     return 0;
    65. }
     

    客户端示例
     

    1. #include 
    2. #include 
    3. #include 
    4. #include 
    5. #include 
    6. #include 
    7.  
    8. #define SERVER_IP "127.0.0.1"
    9. #define PORT_NUMBER 8080
    10.  
    11. int main() {
    12.     int sockfd;
    13.     struct sockaddr_in server_addr;
    14.  
    15.     // 创建套接字
    16.     sockfd = socket(AF_INET, SOCK_STREAM, 0);
    17.     if (sockfd == -1) {
    18.         perror("Socket creation failed");
    19.         exit(1);
    20.     }
    21.  
    22.     // 定义服务器地址
    23.     server_addr.sin_family = AF_INET;
    24.     server_addr.sin_port = htons(PORT_NUMBER);
    25.     server_addr.sin_addr.s_addr = inet_addr(SERVER_IP);
    26.  
    27.     // 连接到服务器
    28.     if (connect(sockfd, (struct sockaddr *)&server_addr, sizeof(server_addr)) == -1) {
    29.         perror("Connection failed");
    30.         exit(1);
    31.     }
    32.  
    33.     // 发送数据
    34.     const char *message = "Hello, Server!";
    35.     send(sockfd, message, strlen(message), 0);
    36.  
    37.     // 接收响应
    38.     char buffer[1024];
    39.     ssize_t bytes_received = recv(sockfd, buffer, sizeof(buffer), 0);
    40.     if (bytes_received == -1) {
    41.         perror("Receive failed");
    42.         exit(1);
    43.     }
    44.     buffer[bytes_received] = '\0'; // 添加字符串结束符
    45.     printf("Received: %s\n", buffer);
    46.  
    47.     // 关闭套接字
    48.     close(sockfd);
    49.  
    50.     return 0;
    51. }
     

    第四部分：网络编程进阶
     

    以上示例介绍了基本的套接字编程步骤，但网络编程还涉及到更多高级概念和技术，例如多线程服务器、非阻塞套接字、套接字选项、数据序列化和安全性等。要深入学习网络编程，建议查阅相关文档和书籍，并尝试构建更复杂的网络应用程序。
     

    此外，网络编程也需要考虑安全性和性能方面的问题。在实际应用中，您需要谨慎处理输入数据，防止网络攻击，并优化网络通信以提高性能。
     

    总之，C语言网络编程是一个广阔而有趣的领域，它允许您构建各种网络应用程序，从简单的聊天客户端到复杂的服务器应用程序。通过深入学习套接字编程和网络协议，您将能够更好地理解和掌握网络编程的原理和实践。
    
                
    
                    
    
                
    • 

                
  • 

                    相关阅读:
    
                    
含文档+PPT+源码等]精品微信小程序班级打卡系统+后台管理系统|前后分离VUE[包运行成功]微信小程序项目源码Java毕业设计                            
    
浅谈Python异常处理                            
    
软件的生命周期和软件测试的生命周期                            
    
[算法】查找元素                            
    
Linux 内核（Kernel）组成分析                            
    
调试 webview 通知Notification                            
    
【python海洋专题八】Cartopy画地形水深图的contourf填充间隔数调整                            
    
[附源码]计算机毕业设计JAVA高校创新创业项目管理系统                            
    
数据库系统概论第六章（关系数据理论）知识点总结（1）—— 函数依赖概念总结                            
    
MAC 安装minikube 记录及排错                            
    
                        
                
    • 
                
  • 
                    原文地址：https://blog.csdn.net/weixin_68551689/article/details/133443429
                
    •