TCP多进程并发编程-回射服务/客户程序

最新推荐文章于 2023-02-15 21:21:44 发布
最新推荐文章于 2023-02-15 21:21:44 发布
阅读量1.8k 收藏
点赞数
分类专栏： Linux 计算机网络 文章标签： 服务器 网络编程 tcp
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u013011841/article/details/40787481
版权

TCP学习之建立一个简单的客户/服务器系统--回射系统

相关的资料可以参考Unix网络编程，这个只是修改版，不需要依赖任何文件,可以独立编译通过,而且是在两台不同的主机上进行的。


fggets和fputs这两个函数来自标准I/O函数库,writen和readline见my_unp.h头文件

//my_unp.h
#include<stdarg.h>
#include<syslog.h>
#include<stdio.h>
#include<netinet/in.h>//网络地址结构表示库
#include<sys/socket.h>//TCP套接口库(socket connet bind listen accept)
#include<unistd.h>//Unix标准库(fork exec close)
#include<stdlib.h>//标准库
#include<memory.h>//内存管理
#include<errno.h>//错误号头文件
#include<string.h>//字符串处理
#include<arpa/inet.h>//(inet_pton inet_ntop)

#define MAXLINE 2048
#define SERV_PORT 9877
#define LISTENQ 5

#define bzero(ptr,n)  memset(ptr,0,n)

int daemon_proc;

static void err_doit(int, int, const char*, va_list);

void err_sys(const char *fmt, ...)
{
    va_list ap;
    va_start(ap,fmt);
    err_doit(1,LOG_ERR,fmt,ap);
    va_end(ap);
    exit(1);
}

static void err_doit(int errnoflag, int level, const char *fmt, va_list ap)
{
    int errno_save,n;
    char buf[MAXLINE+1];

    errno_save=errno;

    vsnprintf(buf,MAXLINE,fmt,ap);

    n=strlen(buf);
    
    if(errnoflag)
        snprintf(buf+n,MAXLINE-n,":%s",strerror(errno_save));
    
    strcat(buf,"\n");

    if(daemon_proc)
    {
        syslog(level,buf);
    }
    else
    {
        fflush(stdout);
        fputs(buf,stderr);
        fflush(stderr);
    }
    return;
}

ssize_t writen(int fd, const void *vptr, size_t n)
{
    size_t nleft;
    ssize_t nwriten;
    const char *ptr;

    ptr=(const char*)vptr;
    nleft=n;
    while(nleft>0)
    {
        if((nwriten=write(fd,ptr,nleft))<0)
        {
            if(nwriten<0 && errno==EINTR)
                nwriten=0;
            else
                return(-1);
        }
        nleft-=nwriten;
        ptr+=nwriten;
    }
    return(n);
}

ssize_t readline(int fd,void *vptr,size_t maxlen)
{
    ssize_t n,rc;
    char c,*ptr;

    ptr=(char*)vptr;
    for(n=1;n<maxlen;n++)
    {
        again:
        if((rc=read(fd,&c,1))==1)
        {
            *ptr++=c;
            if(c=='\n')
                break;
        }
        else if(rc==0)
        {
            *ptr=0;
            return(n-1);
        }
        else
        {
            if(errno==EINTR)
                goto again;
            return(-1);
        }
    }
    *ptr=0;
    return(n);
}


void err_quit(const char *fmt, ...)
{
    va_list ap;
    va_start(ap,fmt);
    err_doit(0,LOG_ERR,fmt,ap);
    va_end(ap);
    exit(1);
}


TCP回射服务程序的主程序


#include"my_unp.h"

void str_echo(int sockfd)
{
    ssize_t n;
    char buf[MAXLINE];

    again:
    while((n=read(sockfd,buf,MAXLINE))>0)
        writen(sockfd,buf,n);

    if( n<0 && errno==EINTR )
        goto again;

    else if(n<0)
        err_sys("str_echo:read error");
}


int main(int argc, char **argv)
{
    int listenfd,connfd;
    pid_t childpid;
    socklen_t clilen;
    struct sockaddr_in cliaddr,servaddr;

    listenfd=socket(AF_INET,SOCK_STREAM,0);

    bzero(&servaddr,sizeof(servaddr));

    servaddr.sin_family=AF_INET;
    servaddr.sin_addr.s_addr=htonl(INADDR_ANY);
    servaddr.sin_port=htons(SERV_PORT);

    bind(listenfd,(struct sockaddr*)&servaddr,sizeof(servaddr));

    listen(listenfd,LISTENQ);

    for(;;)
    {
        clilen=sizeof(cliaddr);
        connfd=accept(listenfd,(struct sockaddr*)&cliaddr,&clilen);
        if((childpid=fork())==0)
        {
            close(listenfd);
            str_echo(connfd);
            exit(0);
        }
        close(connfd);
    }

}

并发服务器的调用流程如右图所示


TCP回射客户程序


#include"my_unp.h"

void str_cli(FILE *fp, int sockfd)
{
    char sendline[MAXLINE],recvline[MAXLINE];
    while(fgets(sendline,MAXLINE,fp)!=NULL)
    {

        writen(sockfd,sendline,strlen(sendline));

        if(readline(sockfd,(void*)recvline,MAXLINE)==0)            
            err_quit("str_cli:server terminated prematurely");

        fputs(recvline,stdout);
    }
}

int main(int argc,char **argv)
{

    int sockfd;
    struct sockaddr_in servaddr;
    if(argc!=2)
        err_quit("usage : tcpcli<IPaddress>");
    sockfd=socket(AF_INET,SOCK_STREAM,0);

    bzero(&servaddr,sizeof(servaddr));
    servaddr.sin_family=AF_INET;
    servaddr.sin_port=htons(SERV_PORT);

    inet_pton(AF_INET,argv[1],&servaddr.sin_addr);

    connect(sockfd,(struct sockaddr*)&servaddr,sizeof(servaddr));

    str_cli(stdin,sockfd);

    exit(0);
}


正常启动过程


我们首先在一台Linux主机上启动服务器，先用g++编译，然后./serv运行服务器





我们可以查询一下网卡的IP地址,发现服务器的IP为192.168.255.129




我们这里是用VMware装了两个LINUX的虚拟机




网络的连接方式全是





检查一下服务器监听端口的状态


     打开另一个LINUX主机，并指定IP地址为192.168.255.129，如上图ifconfig查询所示

编译客户端程序



运行客户端并开始测试


断开之前,再检查一下服务器的监听套结口连接状态


可以看到0.0.0.0:9877为监听套接口，状态为LISTEN

192.168.288.129:9877 到192.168.255.130:35635为已连接套接口，状态为ESTABLISHED，关闭时会变成TIME_WAIT，大概等待1~4分钟之后会完全断开 

 

抓包分析结果

第一段为三次握手

第二段为hello,world发送过程

第三段为good bye

第四段为断开连接






服务器子进程终止的时候，给父进程发送了一个SIGCHLD信号。但是我们并没有在代码中捕获该信号，而该信号的默认行为是被忽略的。既然父进程没有处理该信号，子进程就处于僵尸状态。我们可以使用ps命令验证这一点。



-t选项是选择终端，我们这里运行的是UBUNTU的虚拟终端的第一个，所以打pts/0，类似的第一个打开的终端可以输入pts/0. -o选项是自定义输出,pid是进程ID，PPID是父进程ID
Z+就是表示子进程现在就处于僵尸状态.


下面给出服务器程序的最终版本。它能正确的处理accept返回的EINTR,并建立一个给所有已终止子进程调用waitpid的信号处理函数
多进程并发服务器编程应注意一下三个方面
  1. 当fork子进程时，必须捕获SIGCHLD信号;
  2. 当捕获信号时，必须处理被中断的系统调用
  3. SIGCHLD的信号处理函数必须正确编写，应使用waitpid函数以免留下僵尸进程
#include<stdarg.h>
#include<syslog.h>
#include<stdio.h>
#include<netinet/in.h>
#include<sys/socket.h>//TCP套接口库(socket connet bind listen accept)
#include<unistd.h>//Unix标准库(fork exec close)
#include<stdlib.h>
#include<memory.h>
#include<errno.h>
#include<string.h>
#include<arpa/inet.h>//(inet_pton inet_ntop)

#include<signal.h>//信号处理库

#include<sys/types.h>//使用wait和waitpid
#include<sys/wait.h>

#define MAXLINE 2048
#define SERV_PORT 9877
#define LISTENQ 5

#define bzero(ptr,n)  memset(ptr,0,n)

typedef void Sigfunc(int);

int daemon_proc;

static void err_doit(int, int, const char*, va_list);

void err_sys(const char *fmt, ...)
{
    va_list ap;
    va_start(ap,fmt);
    err_doit(1,LOG_ERR,fmt,ap);
    va_end(ap);
    exit(1);
}

static void err_doit(int errnoflag, int level, const char *fmt, va_list ap)
{
    int errno_save,n;
    char buf[MAXLINE+1];

    errno_save=errno;

    vsnprintf(buf,MAXLINE,fmt,ap);

    n=strlen(buf);
    if(errnoflag)
        snprintf(buf+n,MAXLINE-n,":%s",strerror(errno_save));
    strcat(buf,"\n");

    if(daemon_proc)
    {
        syslog(level,buf);
    }
    else
    {
        fflush(stdout);
        fputs(buf,stderr);
        fflush(stderr);
    }
    return;
}

ssize_t writen(int fd, const void *vptr, size_t n)
{
    size_t nleft;
    ssize_t nwriten;
    const char *ptr;

    ptr=(const char*)vptr;
    nleft=n;
    while(nleft>0)
    {
        if((nwriten=write(fd,ptr,nleft))<0)
        {
            if(nwriten<0 && errno==EINTR)
                nwriten=0;
            else
                return(-1);
        }
        nleft-=nwriten;
        ptr+=nwriten;
    }
    return(n);
}

ssize_t readline(int fd,void *vptr,size_t maxlen)
{
    ssize_t n,rc;
    char c,*ptr;

    ptr=(char*)vptr;
    for(n=1;n<maxlen;n++)
    {
        again:
        if((rc=read(fd,&c,1))==1)
        {
            *ptr++=c;
            if(c=='\n')
                break;
        }
        else if(rc==0)
        {
            *ptr=0;
            return(n-1);
        }
        else
        {
            if(errno==EINTR)
                goto again;
            return(-1);
        }
    }
    *ptr=0;
    return(n);
}


void err_quit(const char *fmt, ...)
{
    va_list ap;
    va_start(ap,fmt);
    err_doit(0,LOG_ERR,fmt,ap);
    va_end(ap);
    exit(1);
}

//包裹函数
char *Fgets(char *ptr, int n, FILE *stream)
{
 char *rptr = fgets(ptr, n, stream);
 if ( rptr == NULL && ferror(stream) )
  err_quit("fgets error");
 return rptr;
}

void Fputs(const char *ptr, FILE *stream)
{
 if (fputs(ptr, stream) == EOF)
  err_quit("fputs error");
}

ssize_t Readline(int fd, void *ptr, size_t maxlen)
{
 ssize_t n = readline(fd, ptr, maxlen);
 if ( n < 0)
  err_quit("readline error");
 return n;
}

void Writen(int fd, void *ptr, size_t nbytes)
{
 if ( writen(fd, ptr, nbytes) != nbytes )
  err_quit("writen error");
}


服务器程序 
#include"my_unp.h"

//服务器程序


//回射程序
void str_echo(int sockfd)
{
    ssize_t n;
    char buf[MAXLINE];

    again:
    while((n=readline(sockfd,buf,MAXLINE))>0)
        writen(sockfd,buf,n);

    if( n<0 && errno==EINTR )
        goto again;

    else if(n<0)
        err_sys("str_echo:read error");
}

//定义自己的signal函数
Sigfunc *signal(int signo,Sigfunc *func)
{
    struct sigaction act,oact;
    act.sa_handler=func;
    sigemptyset(&act.sa_mask);
    if(sigaction(signo,&act,&oact)<0)
        return(SIG_ERR);
    return(oact.sa_handler);
}

//信号处理函数
void sig_chld(int signo)
{
    pid_t pid;
    int stat;

    while((pid=waitpid(-1,&stat,WNOHANG))>0){}
    return;
}

//主函数
int main(int argc, char **argv)
{
    int listenfd,connfd;
    pid_t childpid;
    socklen_t clilen;
    struct sockaddr_in cliaddr,servaddr;
    
    void sig_chld(int);

    listenfd=socket(AF_INET,SOCK_STREAM,0);

    bzero(&servaddr,sizeof(servaddr));

    servaddr.sin_family=AF_INET;
    servaddr.sin_addr.s_addr=htonl(INADDR_ANY);
    servaddr.sin_port=htons(SERV_PORT);

    bind(listenfd,(struct sockaddr*)&servaddr,sizeof(servaddr));

    listen(listenfd,LISTENQ);

    signal(SIGCHLD,sig_chld);//捕捉SIGCHLD信号的信号处理函数

    for(;;)
    {
        clilen=sizeof(cliaddr);
        connfd=accept(listenfd,(struct sockaddr*)&cliaddr,&clilen);
        
        if((connfd=accept(listenfd,(struct sockaddr*)&cliaddr,&clilen))<0)
        {
            if(errno==EINTR)
                continue;
            else
                err_sys("accept error");
        }
        
        
        if((childpid=fork())==0)
        {
            close(listenfd);
            str_echo(connfd);
            exit(0);
        }
        close(connfd);
    }

}


再次连接并断开，再运行ps检查一下是否会还残留僵尸进程


swffsdgasdg
关注
专栏目录
TCP 回射程序
Z374012581的博客
04-17 774
TCP回射程序回射程序步骤 客户端从标准输入读入一行文本，并发给服务器 服务器从网络输入读入这行文本，并且回射给客户 客户从网络输入读入这行回射文本，并且显示在标准输出上。 回射流程TCP 回射服务器#include <stdio.h> #include <stdlib.h> #include <string.h> #include <sys/socket.h> #include <unistd.h
计算机网络套接字编程实验-TCP多进程并发服务器程序与单进程客户端程序（简单回声）
最新发布
001
06-30 1775
学生客户端与服务器收发数据时均未进行PDU字节序转换，本地测试看起来一切正常，但究其根本，是因为学生客户端与服务器程序虽未遵循网络字节序规范，但相当于遵循了无需字节序转换的自定义协议规范，且客户端、服务器进程都运行在同一主机上，因此字节序问题并不会暴露。·若服务器启动时设定 Established Queue的长度，即listen（）第二个参数backlog为2，则最多可 以有2个客户编同时连上服务器并开展交互，此时，再启动另一个客户端连接服务器，观察体验是什么现象，并尝试分析现象背后的底层逻辑。
UNIX网络编程——TCP回射服务器/客户端程序
weixin_33847182的博客
07-23 251
下面通过最简单的客户端/服务器程序的实例来学习socket API。 serv.c 程序的功能是从客户端读取字符然后直接回射回去：#include<stdio.h> #include<sys/types.h> #include<sys/socket.h> #include<unistd.h> ...
TCP并发服务器程序，每个客户一个子进程
weixin_34167043的博客
01-23 159
TCP并发服务器程序，每个客户一个子进程 传统上并发服务器调用fork派生一个子进程来处理每个客户。这使得服务器能够同时为多个客户服务，每个进程一个客户。客户数目的唯一限制是操作系统对以其名义运行的服务器的用户ID能够同时拥有多少个子进程的限制。 转载于:https://blog.51cto.com/4817659/1124857...
tcp多进程并发服务器
xiaolz88的博客
03-23 281
1.多进程并发服务器需要注意的点就是回收子进程的资源 2.使用linux下的nc命令可以测试连接效果 #include <stdio.h> #include <stdlib.h> #include <arpa/inet.h> #include <unistd.h> #include <errno.h> #include <signal.h> #include <sys/types.h> #include <s.
tcp回射程序
Lce的专栏
11-02 789
服务器端： #include #include #include #include #include #include #define LISTENQ 1024 #define SERV_PORT 9877 #define SA struct sockaddr int main(int argc, char** argv) { int listenfd, conn
tcp/ip网络编程-进程间通信代码
02-06
本资源聚焦于“tcp/ip网络编程-进程间通信代码”，提供了几个C语言实现的示例，如echo_storeserv.c、pipe2.c、pipe3.c和pipe1.c，这些都是用于演示不同类型的进程间通信（IPC）技术。 1. **TCP/IP协议栈**：TCP/IP...
多进程并发TCP服务器模型（含客户端）（网络编程 C语言实现）
weixin_56187542的博客
08-18 2541
大家都知道不同pc间的通信需要用到套接字sockte来实现，但是服务器一次只能收到一个客户端发来的消息，所以为了能让服务器可以接收多个客户端的连接与消息的传递，我们就引入了多进程并发这样一个概念。： 每连接一个客户端，创建一个子进程，子进程负责处理connfd(客户请求)recv(), read(), recvfrom()　数据接收。send(), write(), sendto()　数据发送。close(), shutdown()　关闭套接字。父进程处理sockfd(连接请求)。...
Linux高并发服务器开发---笔记5（网络编程--＞I/O多路复用、项目实战1：阻塞/非阻塞、同步/异步、HTTP请求、响应报文、Reactor模式&Proactor模式、线程池原理）parse解析
weixin_38665351的博客
07-20 4151
Linux高并发服务器开发—笔记1这次答应我，一举拿下I/O多路复用！最基础的TCP的Socket编程，它是阻塞I/O模型，基本上只能一对一通信，那为了服务更多的客户端，我们需要改进网络I/O模型。比较传统的方式是使用多进程/线程模型，每来一个客户端连接，就分配一个进程/线程，然后后续的读写都在对应的进程/线程，这种方式处理100个客户端没问题，但是当客户端增大到10000个时，10000个进程/线程的调度、上下文切换以及它们占用的内存，都会成为瓶颈。I/O的多路复用。...................
TCP+IP高效编程--改善网络程序的44个技巧.zip
12-10
《TCP+IP高效编程--改善网络程序的44个技巧》是一本专注于网络程序优化的指导书籍，主要针对TCP/IP协议栈的运用和C++编程语言进行深入探讨。该书通过对44个实用技巧的详细讲解，帮助开发者提升网络应用程序的性能、...
基于Winsock的多客户并发程序的实现（TCP实验报告）
04-16
内有详尽讲解，有截图，有代码，是一份完整的实验报告
TCP回射程序
jike080401的博客
11-09 502
服务器端的代码如下： /************************************************************************* > File Name: tcpserv.c > Author: mhsheng > Mail:981065720@qq.com > Created Time: Wed 09 Nov 2016 09:59:55 AM
tcp多进程多线程并发服务器
m0_49415349的博客
02-15 158
signal socket setsockopt bind listen accept fork close pthread_create pthread_detach
TCP并发服务器（多进程）
augeksjsj的博客
01-05 200
每连接一个客户端就fork一个子进程去处理，子进程结束，父进程要给子进程回收资源，假如是wait阻塞回收，不满足并发服务器要求。假如是waitpid非阻塞，轮询占资源。可以在子进程结束后给父进程发信号，父进程收到信号进行捕获，给子进程回收资源。
234-Linux tcp多线程、进程并发
weixin_45964837的博客
03-08 1191
1.tcp特点：面向连接的可靠的流式服务 2.建立连接是通过三次握手完成的，是在客户端connect时开始进行三次握手，关闭连接是通过四次挥手完成的，客户端close的时候开始进行四次挥手 3.可靠性的体现： ①应答确认 ②超时重传 ③乱序重排 ④去重 ⑤滑动窗口来进行流量控制 4.流式服务 send将数据发送到客户端的发送缓冲区中，由tcp报文段发送到服务器的接收缓冲区中，服务器通过recv接收服务器端接收缓冲区的数据，这就是流式服务 注意：send()成功只能说明数据成功的到达了客户端的发送缓冲区，不能
【Linux】TCP并发网络编程
iccoke的博客
02-13 520
TCP并发编程
TCP编程（多进程版本)
Moralin_的博客
05-13 336
TCP：传输控制协议。特点：传输层协议          有连接          面向字节流          可靠传输UDP编程思想server.csocket()服务器创建套接字bind()绑定端口号listen()监听客户端发来的请求accept()接受client请求接收成功，为客户端提供服务service()代码：问题：为什么要创建孙子进程？服务器端可以创建多个子进程去处理客户端发来的...
TCP客户/服务器程序示例之简单的回射客户/服务器
weixin_45729831的博客
01-02 2271
TCP客户/服务器程序示例之简单的回射客户/服务器
vfork与多进程：理解并发服务器与进程/线程的区别
"创建进程（cont.）在程序开发中起着至关重要的作用，尤其是在多进程和多线程的并发服务器设计中。本文首先介绍了进程的基本概念，将其定义为计算的基本单元，每个进程有独立的地址空间、执行堆栈和文件描述符，确保...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值