linux：套接字编程 （单连接/多进程版本/多线程版本） TCP代码的实现 netstat -anp|grep xxx 命令

其他 2018-05-23 22:23:41 阅读次数: 2

一、TCP单连接版本

1.实现服务器与客户端之间的通信，客户端给服务器发送消息，服务器的作用是把客户端发给自己的消息再给客户端发送回去

服务器端

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<arpa/inet.h>
#include<sys/types.h>
#include<sys/socket.h>
#include<unistd.h>
#include<netinet/in.h>
typedef struct sockaddr sockaddr;
typedef struct sockaddr_in sockaddr_in;
#define ERR_EXIT(m)\
    do\
{\
    perror(m);\
    exit(EXIT_FAILURE);\
}while(0)

void Usage(){
    printf("Usage: ./server [ip] [port]\n");
    return;
}
int main(int argc,char*argv[])
{
    if(3!=argc){
        Usage();
        return 1;
    }
    //1.创建socket
    int sockfd=socket(AF_INET,SOCK_STREAM,0);
    if(sockfd<0)
        ERR_EXIT("socket");
    sockaddr_in local;
    local.sin_family=AF_INET;
    local.sin_addr.s_addr=inet_addr(argv[1]);
    local.sin_port=htons(atoi(argv[2]));
    //2.将文件描述符（sockfd）和服务器的地址（ip+port）关联到一起
    int ret=bind(sockfd,(sockaddr*)&local,sizeof(local));
    if(ret<0)
        ERR_EXIT("bind");
    //3.监听，是服务器处于一种被动可以接受客户端请求的状态
    if(listen(sockfd,5)<0)
        ERR_EXIT("listen");
    printf("bind and listen success,please accept......\n");
    //4.循环的接受客户端的一个连接
    while(1){
        sockaddr_in client;
        socklen_t len=sizeof(client);
        int client_fd=accept(sockfd,(sockaddr*)&client,&len);
        if(client_fd<0){
            close(sockfd);
            break;
        }
        printf("accept success!\n");
        //5.循环的接收客户端发送消息，和给客户端发送消息
        while(1){
            char buf[1024]={0};
            //读取客户端发送的消息
            ssize_t read_size =read(client_fd,buf,sizeof(buf)-1);
            if(read_size<0){
                ERR_EXIT("read");
                break;
            }
            if(read_size==0){
                printf("client [%s:%d] quit!\n",\
                        inet_ntoa(client.sin_addr),\
                        ntohs(client.sin_port));
                break;
            }
            buf[read_size]=0;
            //输出客户端发送的消息
            printf("client [%s:%d] say:>  %s\n",
                    inet_ntoa(client.sin_addr),\
                    ntohs(client.sin_port),buf);
            //给客户端回复消息,从键盘读入要发送的消息
            printf("please enter:>  ");
            fflush(stdout);
            memset(buf,0,sizeof(buf));
            ssize_t s=read(0,buf,sizeof(buf)-1);
            if(s<0){
             ERR_EXIT("read");
             break;
             }
             printf("please wait......\n");
            write(client_fd,buf,strlen(buf));
        }
        close(client_fd);
    }
    close(sockfd);
    return 0;
}

客户机端

#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<arpa/inet.h>
#include<netinet/in.h>
#include<sys/types.h>
#include<sys/socket.h>
#include<string.h>
#define ERR_EXIT(m)\
    do\
{\
    perror(m);\
    exit(EXIT_FAILURE);\
}while(0)
typedef struct sockaddr sockaddr;
typedef struct sockaddr_in sockaddr_in;

void Usage(){
    printf("Usage: ./client [ip] [port]\n");
    return ;
}
int main(int argc,char*argv[])
{
    if(3!=argc){
        Usage();
        return 1;
    }
    //1.创建socket
    int sockfd=socket(AF_INET,SOCK_STREAM,0);
    if(sockfd<0)
        ERR_EXIT("socket");
    sockaddr_in server;
    server.sin_family=AF_INET;
    server.sin_addr.s_addr=inet_addr(argv[1]);
    server.sin_port=htons(atoi(argv[2]));
    //2.给服务器发送连接请求
    int ret=connect(sockfd,(sockaddr*)&server,sizeof(server));
    if(ret<0)
        ERR_EXIT("connect");
    printf("connect success!\n");
    //3.循环的给服务器发送消息，和接收服务器发来的消息
    socklen_t len=sizeof(server);
    while(1){
        char buf[1024]={0};
        //从键盘读要发给服务器的消息
        printf("please enter:>  ");
        fflush(stdout);
        ssize_t s=read(0,buf,sizeof(buf)-1);
        printf("please wait......\n");
        if(s>0){
            buf[s-1]=0;
            //把读到的消息发给服务器
            ssize_t write_size=write(sockfd,buf,strlen(buf));
            //输出服务器发的消息
            memset(buf,0,sizeof(buf));
            ssize_t read_size=read(sockfd,buf,sizeof(buf)-1);
            if(read_size>0)
            {
                buf[read_size]=0;
                printf("server echo:>   %s\n",buf);
            }
        }
    }
    close(sockfd);
    return 0;
}

运行结果：
这里写图片描述

上面的程序有一个缺陷，那就是不能接受多个客户端的请求连接，因为服务器执行完accept之后，服务器就一直在while循环尝试read了，没有在继续调用accept了，从而导致服务器不能接受别的连接了

二、TCP的多个连接版本

为了解决上面所说的问题，那我们采用多个执行流把accept和read分开不就好了吗，一个执行流负责accept，另一个执行流负责read，这样就可以同时处理多个连接了，因为这两个执行流是并发执行的，负责执行accept的执行流它接受完一个客户端的连接之后，此时也可以去接受别的客户端的请求，而那个负责执行读写操作的执行流，不停的对多个客户端进行读写

2.使用多进程实现TCP通信

父进程负责不停地接受客户端的连接，即就是服务器执行accept，使用父进程在创建一个子进程，子进程负责执行读写操作

ps：因为子进程在退出时，会发送SIGCHLD信号，父进程需要把子进程的资源回收掉，否则会导致僵尸进程，现在回收子进程的资源有三种方式：

（1）使用wait函数，等待子进程执行完，wait是阻塞式的等待，父进程在等待子进程的时候，什么事也做不了，只能一直等待，那此时使用wait函数的话，还是实现不了多个客户端的连接，因为父进程执行accept接受一个请求之后，子进程在while循环中，一直在尝试读写，就不会再调用到accept函数了，此种方法不能处理多个客户端的连接请求
（2）使用waitpid函数，设置选项WNOHANG,此时的话waitpid函数就是非阻塞式的等待了，但是会出现子进程还没执行完，父进程就已经执行结束了，还是会出现僵尸进程，如果采用轮询的方式，不停的去查看子进程的存在状态，一会看一下子进程有没有结束，从而回收子进程的资源，这样就会导致父进程可能不能及时的accept了，一心两用，不能保证质量哦！
（3）捕捉信号：捕捉子进程结束后发送给父进程的SIGCHLD信号，把此信号给忽略掉，就不会出现僵尸进程了,也可以实现把accept和read分离开

服务器端

#include<stdio.h>
#include<stdlib.h>
#include<arpa/inet.h>
#include<netinet/in.h>
#include<unistd.h>
#include<string.h>
#include<sys/types.h>
#include<sys/socket.h>
#include<signal.h>
#define ERR_EXIT(m)\
    do\
{\
    perror(m);\
    exit(EXIT_FAILURE);\
}while(0)
typedef struct sockaddr sockaddr;
typedef struct sockaddr_in sockaddr_in;
void Usage(){
    printf("Usage: ./server [ip] [port]\n");
    return;
}
void ProcessConnect(int client_fd,sockaddr_in client)
{
    int pid=fork();
    if(pid<0)
        ERR_EXIT("fork");
    else if(pid>0){
        close(client_fd);
        return;
    }
    else{
        printf("\n");
        //子进程进行循环的读写
        while(1){
            char buf[1024]={0};
            ssize_t read_size=read(client_fd,buf,sizeof(buf)-1);
            if(read_size<0){
                perror("read");
                close(client_fd);
                break;
            }
            if(read_size==0){
                printf("client[%s:%d] quit!\n",inet_ntoa(client.sin_addr),\
                        ntohs(client.sin_port));
                close(client_fd);
                exit(0);
            }
            buf[read_size]=0;
            printf("client[%s:%d]say:>  %s\n",inet_ntoa(client.sin_addr),\
                    ntohs(client.sin_port),buf);
            printf("please enter:>  ");
            fflush(stdout);
            ssize_t s=read(0,buf,sizeof(buf));
            if(s<0)
                ERR_EXIT("read");
            if(s>0){
                buf[s-1]=0;
                write(client_fd,buf,strlen(buf));
            }
            printf("please wait......\n");
        }
    }
}
int main(int argc,char*argv[])
{
    if(3!=argc){
        Usage();
        return 1;
    }
    signal(SIGCHLD,SIG_IGN);
    int sockfd=socket(AF_INET,SOCK_STREAM,0);
    if(sockfd<0)
        ERR_EXIT("socket");
    sockaddr_in local;
    local.sin_family=AF_INET;
    local.sin_addr.s_addr=inet_addr(argv[1]);
    local.sin_port=htons(atoi(argv[2]));
    int ret=bind(sockfd,(sockaddr*)&local,sizeof(local));
    if(ret<0)
        ERR_EXIT("bind");
    if(listen(sockfd,5)<0)
        ERR_EXIT("listen");
    printf("bind and listen success,please accept......\n");
    sockaddr_in client;
    socklen_t len=sizeof(client);
    while(1){
        int client_fd=accept(sockfd,(sockaddr*)&client,&len);
        if(client_fd<0){
            perror("accept");
            break;//跳出if，开始下一次的while
        }
        printf("accept succcess!\n");
        ProcessConnect(client_fd,client);
    }
    close(sockfd);
    return 0;
}

客户机端

#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<arpa/inet.h>
#include<netinet/in.h>
#include<sys/types.h>
#include<sys/socket.h>
#include<string.h>
#define ERR_EXIT(m)\
    do\
{\
    perror(m);\
    exit(EXIT_FAILURE);\
}while(0)
typedef struct sockaddr sockaddr;
typedef struct sockaddr_in sockaddr_in;

void Usage(){
    printf("Usage: ./client [ip] [port]\n");
    return ;
}
int main(int argc,char*argv[])
{
    if(3!=argc){
        Usage();
        return 1;
    }
    //1.创建socket
    int sockfd=socket(AF_INET,SOCK_STREAM,0);
    if(sockfd<0)
        ERR_EXIT("socket");
    sockaddr_in server;
    server.sin_family=AF_INET;
    server.sin_addr.s_addr=inet_addr(argv[1]);
    server.sin_port=htons(atoi(argv[2]));
    //2.给服务器发送连接请求
    int ret=connect(sockfd,(sockaddr*)&server,sizeof(server));
    if(ret<0)
        ERR_EXIT("connect");
    printf("connect success!\n");
    //3.循环的给服务器发送消息，和接收服务器发来的消息
    socklen_t len=sizeof(server);
    while(1){
        char buf[1024]={0};
        //从键盘读要发给服务器的消息
        printf("please enter:>  ");
        fflush(stdout);
        ssize_t s=read(0,buf,sizeof(buf)-1);
        printf("please wait......\n");
        if(s>0){
            buf[s-1]=0;
            //把读到的消息发给服务器
            ssize_t write_size=write(sockfd,buf,strlen(buf));
            //输出服务器发的消息
            memset(buf,0,sizeof(buf));
            ssize_t read_size=read(sockfd,buf,sizeof(buf)-1);
            if(read_size>0)
            {
                buf[read_size]=0;
                printf("server say:>   %s\n",buf);
            }
        }
    }
    close(sockfd);
    return 0;
}

运行结果：
这里写图片描述
ps：服务器的IP地址设为0，表示这服务器可以关联任一个地址
127.0.0.1是环回地址，是留给用户自己使用的，故客户端可以使用该地址

3.实现多线程版本的TCP通信，主线程负责accept（接受客户端发来的连接请求），新创建的线程负责循环的执行读写操作

服务器端

扫描二维码关注公众号，回复： 998246 查看本文章 
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<pthread.h>
#include<unistd.h>
#include<sys/types.h>
#include<sys/socket.h>
#include<arpa/inet.h>
#include<netinet/in.h>
#define ERR_EXIT(m)\
    do\
{\
    perror(m);\
    exit(EXIT_FAILURE);\
}while(0)
typedef struct sockaddr sockaddr;
typedef struct sockaddr_in sockaddr_in;
//封装消息
typedef struct Arg
{ 
    int fd;
    sockaddr_in addr;
}Arg;
void*ThreadEntry(void*ptr)
{
    Arg*arg=(Arg*)ptr;
    while(1){
        char buf[1024]={0};
        ssize_t read_size=read(arg->fd,buf,sizeof(buf)-1);
        if(read_size<0){
            close(arg->fd);
            perror("read");
            break;
        }
        if(read_size==0){
            printf("client [%s:%d] quit!\n",inet_ntoa(arg->addr.sin_addr),\
                    ntohs(arg->addr.sin_port));
            close(arg->fd);
            free(arg);
            return NULL;

        }
        printf("client [%s:%d]:>  %s\n",inet_ntoa(arg->addr.sin_addr),\
                ntohs(arg->addr.sin_port),buf);
        memset(buf,0,sizeof(buf));
        printf("please enter:>  ");
        fflush(stdout);
        ssize_t s=read(0,buf,sizeof(buf)-1);
        if(s>0){
            buf[s-1]=0;
            write(arg->fd,buf,strlen(buf));
        }
        printf("please wait......\n");
    }
    return NULL;
}
void ProcessConnect(int client_fd,sockaddr_in client)
{
    Arg* arg=(Arg*)malloc(sizeof(Arg));
    arg->fd=client_fd;
    arg->addr=client;
    pthread_t tid;
    pthread_create(&tid,NULL,ThreadEntry,(void*)arg);
    pthread_detach(tid);
}
void Usage(){
    printf("Usage: ./server [ip] [port]\n");
    return;
}
int main(int argc,char*argv[])
{
    if(3!=argc){
        Usage();
        return 1;
    }
    int sockfd=socket(AF_INET,SOCK_STREAM,0);
    if(sockfd<0)
        ERR_EXIT("socket");
    sockaddr_in local;
    local.sin_family=AF_INET;
    local.sin_addr.s_addr=inet_addr(argv[1]);
    local.sin_port=htons(atoi(argv[2]));
    int ret=bind(sockfd,(sockaddr*)&local,sizeof(local));
    if(ret<0)
        ERR_EXIT("bind");
    if(listen(sockfd,5)<0)
        ERR_EXIT("listen");
    printf("bind and listen success,please accept......\n");
    sockaddr_in client;
    socklen_t len=sizeof(client);
    while(1){
        int client_fd=accept(sockfd,(sockaddr*)&client,&len);
        if(client_fd<0)
        {
            perror("accept");
            break;
        }
        printf("accept success!\n");
        ProcessConnect(client_fd,client);
    }
    close(sockfd);
    return 0;
}

客户机端

#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<arpa/inet.h>
#include<netinet/in.h>
#include<sys/types.h>
#include<sys/socket.h>
#include<string.h>
#define ERR_EXIT(m)\
    do\
{\
    perror(m);\
    exit(EXIT_FAILURE);\
}while(0)
typedef struct sockaddr sockaddr;
typedef struct sockaddr_in sockaddr_in;

void Usage(){
    printf("Usage: ./client [ip] [port]\n");
    return ;
}
int main(int argc,char*argv[])
{
    if(3!=argc){
        Usage();
        return 1;
    }
    //1.创建socket
    int sockfd=socket(AF_INET,SOCK_STREAM,0);
    if(sockfd<0)
        ERR_EXIT("socket");
    sockaddr_in server;
    server.sin_family=AF_INET;
    server.sin_addr.s_addr=inet_addr(argv[1]);
    server.sin_port=htons(atoi(argv[2]));
    //2.给服务器发送连接请求
    int ret=connect(sockfd,(sockaddr*)&server,sizeof(server));
    if(ret<0)
        ERR_EXIT("connect");
    printf("connect success!\n");
    //3.循环的给服务器发送消息，和接收服务器发来的消息
    socklen_t len=sizeof(server);
    while(1){
        char buf[1024]={0};
        //从键盘读要发给服务器的消息
        printf("please enter:>  ");
        fflush(stdout);
        ssize_t s=read(0,buf,sizeof(buf)-1);
        printf("please wait......\n");
        if(s>0){
            buf[s-1]=0;
            //把读到的消息发给服务器
            ssize_t write_size=write(sockfd,buf,strlen(buf));
            //输出服务器发的消息
            memset(buf,0,sizeof(buf));
            ssize_t read_size=read(sockfd,buf,sizeof(buf)-1);
            if(read_size>0)
            {
                buf[read_size]=0;
                printf("server say:>   %s\n",buf);
            }
        }
    }
    close(sockfd);
    return 0;
}

运行结果：
这里写图片描述

相关命令

1.netsat -anp|grep +服务器的端口号//查看该服务器的信息
2.netstat -anp|grep -n2//显示查询出来的信息的格式

这里写图片描述

Local Address    本地IP和端口
Foreign Address  对端IP和端口
State:是当前进程的状态，LISTEN表示此进程处于监听状态，ESTABLISHED表示此进程已经建立连接
Recv-Q和Send-Q表示流量
0.0.0.0:*//是任何IP和端口，此种使用方法表示对任何IP和端口，都可以处理该IP和端口定义的套接字的通信

netstat -nt|grep 服务器的端口号//显示服务器中监听队列中的内容

这里写图片描述

相关函数的用法请参考博客：
https://blog.csdn.net/dangzhangjing97/article/details/80280770
IP地址和端口请参考博客：
https://blog.csdn.net/dangzhangjing97/article/details/80280254
关于网络字节序与主机字节序之间转换的相关函数：
https://blog.csdn.net/dangzhangjing97/article/details/80303625

三.使用TCP实现一个加法器

服务器负责计算客户端发送的数据，客户端再把结果输出到屏幕上

#include "proto.h"
void Usage(){
    printf("Usage:./server [ip] [port]\n");
    return;
}
int main(int argc,char*argv[])
{ 
    if(argc!=3){
        Usage();
        return 1;
    }
    //创建一个socket文件描述符
    int sockfd=socket(AF_INET,SOCK_STREAM,0);
    //if(sockfd<0)
    //  ERR_EXIT("socket");
    sockaddr_in local;
    local.sin_family=AF_INET;
    local.sin_addr.s_addr=inet_addr(argv[1]);
    local.sin_port=htons(atoi(argv[2]));
    Response response;
    Request request;
    //将文件描述符和服务器的地址（ip+port）关联到一起
    if(bind(sockfd,(sockaddr*)&local,sizeof(local))<0)
        ERR_EXIT("bind");
    //将服务器转换成被动状态，以便于接受客户端发送的请求连接
    if(listen(sockfd,5)<0)
        ERR_EXIT("listen");
    printf("bind and listen success,wait accept......\n");
     sockaddr_in client;
    socklen_t len=sizeof(client);
    //循环的接受客户端的连接请求，完成客户端的需求
    while(1){
        int client_fd=accept(sockfd,(sockaddr*)&client,&len);
        if(client_fd<0){
            close(client_fd);
            break;//重新开始下一次的接收来自客户端的连接
        }
        //此时已经和客户端建立连接，循环的与客户端发送消息
        while(1){
            //读客户端需要求和的数字
            ssize_t read_size=read(client_fd,&request,sizeof(request));
            if(read_size>0){
                response.sum=request.a+request.b;
            }
            //把计算好的结果发给客户端
            write(client_fd,&response,sizeof(response));
        }
    }
    close(sockfd);
    return 0;
}

客户机端

#include"proto.h"
void Usage(){
    printf("Usage ./client [ip] [port]\n");
    return;
}
int main(int argc,char*argv[])
{
    if(3!=argc){
        Usage();
        return 1;
    }
    int sockfd=socket(AF_INET,SOCK_STREAM,0);
    if(sockfd<0)
        ERR_EXIT("socket");
     sockaddr_in server;
    server.sin_family=AF_INET;
    server.sin_addr.s_addr=inet_addr(argv[1]);
    server.sin_port=htons(atoi(argv[2]));
    Request request;
    Response response;
    socklen_t len=sizeof(server);
    if(connect(sockfd,(sockaddr*)&server,len)<0)
        ERR_EXIT("connect");
    while(1){
        char buf[1024]={0};
        printf("请输入需要求和的两个数:>  ");
        fflush(stdout);
        scanf("%d %d",&request.a,&request.b);
        //把需要求和的两个数发给服务器（服务器是计算结果的）
        write(sockfd,&request,sizeof(request));
        //读取服务器计算的结果
        ssize_t s=read(sockfd,&response,sizeof(response));
        if(s>0){
            printf("结果为:> %d\n",response.sum);
        }
    }
    close(sockfd);
    return 0;
}

运行结果：
这里写图片描述
结果解析：服务器负责计算结果，并把计算的结果发给客户机，客户机把自己想要计算的数据发给服务器就好，然后接收服务器的计算结果就OK，最后把计算的结果输出到屏幕上

猜你喜欢

转载自blog.csdn.net/dangzhangjing97/article/details/80316680
今日推荐
基于大语言模型的开源知识库问答系统 MaxKB GitHub Star 数量突破 5,000 个！
美国拟限制 AI 大模型出口中国和俄罗斯
苹果将与 OpenAI 达成协议，将 ChatGPT 应用于 iPhone
openKylin 社区生态委员会第六次会议圆满召开
阿里云正式发布通义千问 2.5
Python 3.13 发布首个 Beta：实验性自由线程模式和 JIT、改进交互式解释器
Stack Overflow 拿我的代码去训练 AI 大模型，还封了我的账号
Pop!_OS 的 COSMIC 桌面完成 App Store 上架工作
报告：Django 仍然是 74% 开发者的首选
《2024 年一季度互联网投融资运行情况》研究报告
15 年前上了“FFmpeg 耻辱柱”，今天他还得谢谢咱——腾讯QQPlayer一雪前耻？
TIOBE 5 月榜单：Fortran “复活”进入 Top 10
周排行
BPM为企业带来的实际利益
好程序员web前端分享css常用属性缩写
Java文件下载（excel）
css样式的动态添加及显示和隐藏等零碎用法
axios全局配置以及拦截器
使用Logstash来实时同步MySQL和log日志数据到ES
C++获取当前时间（年月日、时分秒、毫秒）
Odoo产品分析 (四) -- 工具板块(11) -- 网站即时聊天(1)
Java环境配置正确，但是java、javac、java -version均返回“不是内部或外部命令，也不是可运行的程序或批处理文件”？
01 官网下载各种CentOS教程（超详细版）
每日归档
更多
2024-05-14(0)
2024-05-13(18)
2024-05-12(0)
2024-05-11(38)
2024-05-10(38)
2024-05-09(35)
2024-05-08(42)
2024-05-07(14)
2024-05-06(40)
2024-05-05(0)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022