【Linux】网络基础--TCP编程socket编程

伍伍1GB

已于 2023-02-28 21:10:46 修改

阅读量139

点赞数 2

分类专栏： Linux 文章标签： linux 服务器 c++ c# tcp Powered by 金山文档

于 2023-02-28 15:20:05 首次发布

本文链接：https://blog.csdn.net/weixin_59824611/article/details/129261423

版权

Linux 专栏收录该内容

26 篇文章 0 订阅

订阅专栏

tcp编程流程（图解）

监听接口

int listen(int sockfd,int backlog);
//sockfd:套接字描述符，socket函数创建的侦听套接字
//backlog:TCP开发连接数（已完成连接的大小）；tcp的服务端在一瞬间并发能够处理的最大的tcp的连接数量。强调：并不是ycp服务端最多能够接受的tcp数量！
//返回值：成功返回0；失败返回-1.

未完成连接队列：还处于连接建立的连接被放在这个队列当中（可以理解为正在三次握手的连接在该队列）

已完成连接队列：连接已建立，可以正常的通信的连接放在这个队列（可以理解为三次握手完毕的连接在该队列）

可以通过修改/proc/sys/net/ipv4/tcp_max_syn_backlog当中的值，修改未完成连接队列的大小。

连接接口

int connect(int sockfd,const struct sockaddr *addr,socklen_t addrlen);
//sockfd:套接字描述符
//addr:地址信息结构，描述服务端地址信息（服务端的ip和端口）
//addelen:地址信息长度
//返回值:成功返回0；失败返回-1.
//注意:该函数不仅可以完成连接功能，如果客户端没有绑定，同时也会进行绑定客户端的地址信息。

接收（三次握手）成功的标志

服务端为该连接创建了套接字描述符。

接收新连接

int accept(int sockfd,struct sockaddr *addr,socklen_t *addrlen);
//sockfd:套接字描述符，监听套接字。
//addr:地址信息结构体，描述客户端地址信息的结构体。
//addrlen:地址信息长度。
//返回值:成功返回新连接的套接字；失败返回-1。
//注意:这个是阻塞调用的函数。如果已完成队列当中没回应已经建立连接的连接则阻塞，如果有就返回，

发送接口

ssize_t send(int sockfd,const void *buf,size_t len,int flags);
//sockfd:发送buf指向的空间的内容
//buf:发送buf指向的空间的内容
//len:数据长度
//flags:0（阻塞发送）
//返回值:成功返回发送的字节数量；失败返回-1.

接收接口

ssize_t recv(int sockfd,void *buf,size_t len,int flags);
//sockfs:套接字描述符（客户端调用recv，使用客户端调用的套接字；服务端调用recv，使用的就是新连接的套接字描述符）
//buf:将接收到的数据存在buf指定的空间、空间需要提前开辟
//len:数据长度
//flags:0（阻塞发送）
//返回值:成功返回接收的字节数量；对端关闭连接返回0；接受错误返回-1.

代码实现

服务端：

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


int main(){
    /*1.创建套接字（流式套接字）*/
    int listen_sockfd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
    if(listen_sockfd < 0){
        perror("socket");
        return 0;
    }

    /*2.绑定地址信息， 服务端绑定ip和端口*/
    //int bind(int sockfd, const struct sockaddr *addr,
    //                                              socklen_t addrlen);
    struct sockaddr_in addr;
    addr.sin_family = AF_INET;
    addr.sin_port = htons(8080);
    //当前机器的私网ip地址（自己机器网卡的ip地址）， 如果说要绑定， 则绑定该ip地址： 172.28.71.17
    //当前机器的公网IP地址（云服务器厂商为我们提供的ip地址， 从公网访问公网ip地址则能放到该机器）：120.78.126.148
    //    ！！！不要绑定公网ip地址， 因为公网IP地址不是当前机器的网卡地址
    addr.sin_addr.s_addr = inet_addr("0.0.0.0");
    int ret = bind(listen_sockfd, (struct sockaddr*)&addr, sizeof(addr));
    if(ret < 0){
        perror("bind");
        return 0;
    }

    /*3.监听， 当调用了监听接口之后， 服务端就能接收客户端的连接请求了*/
    ret = listen(listen_sockfd, 2);
    if(ret < 0){
        perror("listen");
        return 0;
    }

    while(1){
    /*4.接收新连接， 这个函数是阻塞调用的函数*/
    int new_sockfd = accept(listen_sockfd, NULL, NULL);
    if(new_sockfd < 0){
        perror("accept");
        return 0;
    }

        char buf[1024] = {0};
        ssize_t r_size = recv(new_sockfd, buf, sizeof(buf) - 1, 0);
        if(r_size < 0){
            perror("recv");
            continue;
        }else if(r_size == 0){
            // peer shutdown
            printf("client shutdown connection\n");
            close(new_sockfd);
            break;
        }else{
            printf("[buf is ] : %s\n", buf);
        }

        memset(buf, '\0', sizeof(buf));
        printf("please enter msg: ");
        fflush(stdout);
        std::cin >> buf;
        send(new_sockfd, buf, strlen(buf), 0);
    }
    
    close(listen_sockfd);
    return 0;
}

客户端：

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


int main(){
    int sockfd = socket(AF_INET, SOCK_STREAM, 0);
    if(sockfd < 0){
        perror("socket");
        return 0;
    }

    //int connect(int sockfd, const struct sockaddr *addr,
    //                socklen_t addrlen);
    struct sockaddr_in addr;
    addr.sin_family = AF_INET;
    addr.sin_port = htons(8080);
    addr.sin_addr.s_addr = inet_addr("120.78.126.148");
    int ret = connect(sockfd, (struct sockaddr*)&addr, sizeof(addr));
    if(ret < 0){
        perror("connect");
        return 0;
    }

    while(1){
        printf("please enter your msg: ");
        fflush(stdout);
        char buf[1024] = {0};
        std::cin >> buf;
        send(sockfd, buf, strlen(buf), 0);


        memset(buf, '\0', sizeof(buf));
        ssize_t r_size = recv(sockfd, buf, sizeof(buf) - 1, 0);
        if(r_size < 0){
            perror("recv");
            continue;
        }else if(r_size == 0){
            // server shutdown
            break;
        }else{
            printf("%s\n", buf);
        }
    }
    close(sockfd);
    return 0;
}

进程与TCP的结合运用

代码模拟：

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

void sigcallback(int signo){
    wait(NULL);
}

int main(){
    signal(SIGCHLD, sigcallback);

    /*1.创建套接字（流式套接字）*/
    int listen_sockfd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
    if(listen_sockfd < 0){
        perror("socket");
        return 0;
    }

    /*2.绑定地址信息， 服务端绑定ip和端口*/
    //int bind(int sockfd, const struct sockaddr *addr,
    //                                              socklen_t addrlen);
    struct sockaddr_in addr;
    addr.sin_family = AF_INET;
    addr.sin_port = htons(8080);
    //当前机器的私网ip地址（自己机器网卡的ip地址）， 如果说要绑定， 则绑定该ip地址： 172.28.71.17
    //当前机器的公网IP地址（云服务器厂商为我们提供的ip地址， 从公网访问公网ip地址则能放到该机器）：120.78.126.148
    //    ！！！不要绑定公网ip地址， 因为公网IP地址不是当前机器的网卡地址
    addr.sin_addr.s_addr = inet_addr("0.0.0.0");
    int ret = bind(listen_sockfd, (struct sockaddr*)&addr, sizeof(addr));
    if(ret < 0){
        perror("bind");
        return 0;
    }

    /*3.监听， 当调用了监听接口之后， 服务端就能接收客户端的连接请求了*/
    ret = listen(listen_sockfd, 2);
    if(ret < 0){
        perror("listen");
        return 0;
    }

    while(1){
        /*4.接收新连接， 这个函数是阻塞调用的函数*/
        int new_sockfd = accept(listen_sockfd, NULL, NULL);
        if(new_sockfd < 0){
            perror("accept");
            return 0;
        }

        int pid = fork();
        if(pid < 0){
            close(new_sockfd);
            continue;
        }else if(pid == 0){
            while(1){
                char buf[1024] = {0};
                ssize_t r_size = recv(new_sockfd, buf, sizeof(buf) - 1, 0);
                if(r_size < 0){
                    perror("recv");
                    continue;
                }else if(r_size == 0){
                    // peer shutdown
                    printf("client shutdown connection\n");
                    close(new_sockfd);
                    exit(1);
                }else{
                    printf("[buf is ] : %s\n", buf);
                }

                memset(buf, '\0', sizeof(buf));
                printf("please enter msg: ");
                fflush(stdout);
                std::cin >> buf;
                send(new_sockfd, buf, strlen(buf), 0);
            }
        }else{
            //wait(NULL);
        }

    }

    close(listen_sockfd);
    return 0;
}

多线程与TCP的结合运用

代码模拟：

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

struct NewSockfd{
    int new_sockfd;
};


void* worker_thread(void* arg){
    pthread_detach(pthread_self());
    struct NewSockfd* ns = (struct NewSockfd*)arg;

    while(1){
        char buf[1024] = {0};
        ssize_t r_size = recv(ns->new_sockfd, buf, sizeof(buf) - 1, 0);
        if(r_size < 0){
            perror("recv");
            continue;
        }else if(r_size == 0){
            // peer shutdown
            printf("client shutdown connection\n");
            close(ns->new_sockfd);
            break;
        }else{
            printf("[buf is ] : %s\n", buf);
        }

        memset(buf, '\0', sizeof(buf));
        printf("please enter msg: ");
        fflush(stdout);
        std::cin >> buf;
        send(ns->new_sockfd, buf, strlen(buf), 0);

    }

    delete ns;
    return NULL;
}

int main(){
    /*1.创建套接字（流式套接字）*/
    int listen_sockfd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
    if(listen_sockfd < 0){
        perror("socket");
        return 0;
    }

    /*2.绑定地址信息， 服务端绑定ip和端口*/
    //int bind(int sockfd, const struct sockaddr *addr,
    //                                              socklen_t addrlen);
    struct sockaddr_in addr;
    addr.sin_family = AF_INET;
    addr.sin_port = htons(8080);
    //当前机器的私网ip地址（自己机器网卡的ip地址）， 如果说要绑定， 则绑定该ip地址： 172.28.71.17
    //当前机器的公网IP地址（云服务器厂商为我们提供的ip地址， 从公网访问公网ip地址则能放到该机器）：120.78.126.148
    //    ！！！不要绑定公网ip地址， 因为公网IP地址不是当前机器的网卡地址
    addr.sin_addr.s_addr = inet_addr("0.0.0.0");
    int ret = bind(listen_sockfd, (struct sockaddr*)&addr, sizeof(addr));
    if(ret < 0){
        perror("bind");
        return 0;
    }

    /*3.监听， 当调用了监听接口之后， 服务端就能接收客户端的连接请求了*/
    ret = listen(listen_sockfd, 2);
    if(ret < 0){
        perror("listen");
        return 0;
    }

    while(1){
        /*4.接收新连接， 这个函数是阻塞调用的函数*/
        int new_sockfd = accept(listen_sockfd, NULL, NULL);
        if(new_sockfd < 0){
            perror("accept");
            return 0;
        }

        struct NewSockfd * ns = new struct NewSockfd;
        ns->new_sockfd = new_sockfd;
        pthread_t tid;
        int ret = pthread_create(&tid, NULL, worker_thread, (void*)ns);
        if(ret < 0){
            close(new_sockfd);
            continue;
        }
    }

    close(listen_sockfd);
    return 0;
}