网络编程之客户端、服务器 - C_客户端服务器端网络编程-CSDN博客

本文链接：https://blog.csdn.net/m0_49540285/article/details/146606882

网络编程是基础中的核心，长时间不用就会忘了，抽时间温习总结一下。这里将实现一个简单的客户端，以及一个“一请求一线程”的回射服务器，客户端发什么就回什么。

一、流程图

二、套接字函数

IPV4套接字地址结构

struct in_addr {
    in_addr_t   s_addr;                /* 32-bit IPV4 address */
};                                     /* network byte ordered */

struct sockaddr_in {
    uint8_t         sin_len;           /* length of structure */
    sin_family_t    sin_family;        /* AF_INET */
    in_port_t       sin_port;          /* 16-bit TCP or UDP port number */
                                       /* network byte ordered */
    struct in_addr  sin_addr;          /* 32-bit IPV4 address */
                                       /* network byte ordered */
    char            sin_zero[8];       /* unused */

};

socket 函数

不管是客户端还是服务器，网络编程的第一个步骤是调用socket()函数创建套接字描述符(sockfd)。

#include <sys/socket.h>
int socket(int domain, int type, int protocol);
                                 //返回：若成功则为非负套接字描述符，若失败则为-1

int domain:指定协议族，常用常用AF_INET(ipv4)
int type：指定套接字类型,常用SOCK_STREAM(字节流套接字tcp) 和 SOCK_DGRAM(数据报套接字udp)
int protocol：指定协议类型，通常设置为0，系统由前两个参数决定协议类型

connect 函数

TCP客户端用connect 函数来建立与TCP服务器的连接，发起TCP三次握手流程。

#include <sys/socket.h>
int connect(int sockfd, const struct sockaddr *addr,
                   socklen_t addrlen);
                                   //返回：若成功则为0，若出错则为-1

int sockfd：主动套接字 sockfd
const struct sockaddr *addr：套接字地址结构体指针，携带服务器端ip地址和端口信息
socklen_t addrlen：套接字地址结构体长度

bind 函数

bind() 函数是在创建服务器时，用来绑定指定的服务器IP地址和端口的，便于客户端通过IP地址和端口进行连接。

#include <sys/socket.h>
int bind(int sockfd, const struct sockaddr *addr,
                socklen_t addrlen);
                                           //返回：若成功则为0，若失败则为-1

int sockfd：套接字描述符(sockfd)
const struct sockaddr *addr：带有服务器IP地址和端口的结构体对象，由(struct sockaddr_in *) 类型强转为(struct sockaddr *)
socklen_t addrlen：地址结构 (struct sockaddr)的长度

listen 函数

listen 函数仅由TCP服务器调用，用socket 函数创建的套接字被假设为主动套接字，调用listen 函数把未连接的套接字转为被动套接字，指示内核应接收指向该套接字的连接请求。调用listen 函数使套接字从 CLOSED状态转为 LISTEN状态。

#include <sys/socket.h>
int listen(int sockfd, int backlog);
                                  //返回：若成功则为0，若失败则为-1

int sockfd：需要监听的套接字
int backlog：backlog 的作用在于指定操作系统可以挂起的最大未完成连接数（即处于 SYN_RECV 状态的连接），以及已完成三次握手但尚未被 accept()接收的连接数。如果新到达的连接超过了允许的最大值，则后续的连接请求会被丢弃或重试超时后失败。

accept 函数

accept 函数由TCP服务器调用，用于从内核已完成连接队列队头接收下一个已完成的连接，在阻塞模式时若已完成队列为空则进入睡眠等待。

#include <sys/socket.h>
int accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen);
                                     //返回：若成功则为非负描述符，若失败则为-1

int sockfd：监听描述符(listenfd)
struct sockaddr *addr：地址结构体对象，用于接收客户端地址信息
socklen_t *addrlen：地址结构体长度，用于接收客户端信息字节长度

当不关注客户端地址信息时，可将 addr 和 addrlen 置为NULL。

send 函数

send 函数在需要发送数据时调用，发送和接收数据的函数有多种，可根据需求自行选择。

#include <sys/socket.h>
ssize_t send(int sockfd, const void *buf, size_t len, int flags);
                                  //返回，若成功则为写入的字节数，若失败则为-1

int sockfd：已连接套接字
const void *buf：指向存放数据地址的buffer指针
size_t len：需要发送数据的字节数
int flags：附加功能标志，通常设置为0

recv 函数

recv 函数在需要接收数据时调用，发送和接收数据的函数有多种，可根据需求自行选择。

#include <sys/socket.h>
ssize_t recv(int sockfd, void *buf, size_t len, int flags);
                       //返回，若成功则为接收的字节数，若失败则为-1，若没有连接则为0

int sockfd：已连接套接字
void *buf：指向用来存放数据的buffer指针
size_t len：buffer的空间大小
int flags：附加功能标志，通常设置为0

三、完整代码

运行代码需要自行设置ip地址和端口。

客户端代码

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

#define SER_PORT 2000
#define SER_ADDR "192.168.8.158"

#define BUFFER_SIZE 128


int main(int argc, char *argv[])
{
    if (argc != 2) return -1;

    //获取服务器端口
    int port = atoi(argv[1]);

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

    struct sockaddr_in seraddr;
    memset(seraddr, 0, sizeof(struct sockaddr_in));
    seraddr.sin_family = AF_INET;
    seraddr.sin_addr.s_addr = inet_addr(SER_ADDR);
    seraddr.sin_port = htons(port);

    //需要转为通用套接字地址结构体 struct sockaddr
    if (0 != connect(sockfd, (struct sockaddr*)&seraddr, sizeof(struct sockaddr_in))) {
        printf("connect failed\n");
        return -1;
    }

    int count =0;
    while(1) {

        count++;
        char buffer[BUFFER_SIZE] = {0};
        sprintf(buffer, "msg %d\n", count);

        int len = strlen(buffer);

        int ret = send(sockfd, buffer, len, 0);
        printf("send ret: %d\n", ret);

        ret = recv(sockfd, buffer, BUFFER_SIZE, 0);
        printf("recv ret: %d  %s\n", ret, buffer);

        sleep(2);
    }
    

    return 0;
}

服务器代码

#include <stdio.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <unistd.h>
#include <errno.h>
#include <pthread.h>

#define SER_PORT    3000

#define BUFFER_SIZE     1024


void *client_thread(void *arg)
{
    int clientfd = *(int *)arg;

    while(1) {
        
        char buffer[BUFFER_SIZE] = {0};
        int count = recv(clientfd, buffer, BUFFER_SIZE, 0);
        if(count == 0) {
            printf("client disconnect\n");
            close(clientfd);
            break;
        }

        printf("recv: %s, fd: %d\n", buffer, clientfd);

        count = send(clientfd, buffer, count, 0);
        printf("count: %d, fd: %d\n", count, clientfd);
    }
}

int init_server(int port)
{
    int sockfd = socket(AF_INET,SOCK_STREAM,0);

    struct sockaddr_in seraddr;
    memset(seraddr, 0, sizeof(struct sockaddr_in));
    seraddr.sin_family = AF_INET;
    seraddr.sin_addr.s_addr = htonl(INADDR_ANY); //0.0.0.0
    seraddr.sin_port = htons(port);

    //需要转为通用套接字地址结构体 struct sockaddr
    if(-1 == bind(sockfd, (struct sockaddr*)&seraddr, sizeof(struct sockaddr))) {
        printf("bind failed\n");
    }
    
    return sockfd;
}

int main()
{
    int sockfd = init_server(SER_PORT);

    listen(sockfd, 10);

    struct sockaddr_in cliaddr;
    socklen_t len = sizeof(cliaddr);

    while(1) {

        int clientfd = accept(sockfd, (struct sockaddr*)&cliaddr, &len);

        pthread_t thid;
        pthread_create(&thid, NULL, client_thread, &clientfd);
    }

    return 0;
}