linux【网络编程】TCP协议通信模拟实现、日志函数模拟、守护进程化、TCP协议通信流程、三次握手与四次挥手

已于 2023-08-20 20:09:20 修改
阅读量763 收藏 24
点赞数 28
分类专栏： linux网络编程 文章标签： linux 网络 tcp/ip 服务器
于 2023-05-21 22:45:33 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_54469145/article/details/130672222
版权

linux【网络编程】TCP协议通信模拟实现、日志函数模拟、守护进程化、TCP协议通信流程

一、TCP通信简单模拟实现

Tcp通信模拟实现与Udp通信模拟实现的区别不大，一个是面向字节流，一个是面向数据报；udp协议下拿到的数据可以直接发送，tcp协议下需要创建链接，用文件描述符完成数据的读写

1.1 服务端实现

1.1.1 接口认识

1.1.1.1 listen：监听socket
#include <sys/types.h>          /* See NOTES */
#include <sys/socket.h>
int listen(int sockfd, int backlog);
sockfd：创建的套接字
backlog：新连接队列的长度限制
1.1.1.2 accept：获取连接
#include <sys/types.h>          /* See NOTES */
#include <sys/socket.h>
int accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen);
sockfd:创健的套接字，仅用于监听新链接
addr：结构体，这里说网络通信，用sockaddr_in
addrlen:结构体大小
返回值：一个新的文件描述符（套接字），这个才是和客户端通信的文件描述符

通信就用accept返回的文件描述符，面向字节流，后续都是文件操作

1.1.2 tcpServer.hpp

#pragma once
#include "logMessage.hpp"
#include <iostream>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <cstring>
#include <unistd.h>
namespace Server
{
    enum
    {
        USAGE_ERR = 1,
        SOCKET_ERR,
        BIND_ERR,
        LISTEN_ERR
    };

    using namespace std;

    static const uint16_t gport = 8080;
    static const uint16_t gbacklog = 5;
    class tcpServer
    {
    public:
        tcpServer(const uint16_t &port = gport)
            : listen_sockfd_(-1), port_(port)
        {
        }

        void InitServer()
        {
            // 1.创建socket
            listen_sockfd_ = socket(AF_INET, SOCK_STREAM, 0);
            if (listen_sockfd_ < 0)
            {
                logMessage(FATAL, "create socket error");
                exit(SOCKET_ERR);
            }
            logMessage(NORMAL, "create socket success");

            // 2.bind网络信息
            struct sockaddr_in local;
            memset(&local,0,sizeof(local));
            local.sin_family=AF_INET;
            local.sin_port=htons(port_);
            local.sin_addr.s_addr=INADDR_ANY;
            if(bind(listen_sockfd_,(struct sockaddr*)&local,sizeof(local))<0)
            {
                logMessage(FATAL,"bind socket error");
                exit(BIND_ERR);
            }

            logMessage(NORMAL,"bind socket success");
            
            //3.设置socket为监听状态
            if(listen(listen_sockfd_,gbacklog)<0)
            {
                logMessage(FATAL,"listen socket error");
                exit(LISTEN_ERR);
            }
            logMessage(NORMAL,"listen socket success");

        }
        void start()
        {
            for(; ;)
            {
                //4.server获取新链接
                struct sockaddr_in peer;
                socklen_t len=sizeof(peer);
                //sock:和客户端通信的文件描述符
                int sock=accept(listen_sockfd_,(struct sockaddr*)&peer,&len);
                if(sock<0)//没有获取新链接成功就执行下一次循环
                {
                    logMessage(FATAL,"accpect sock error");
                    continue;
                }
                logMessage(NORMAL,"accept sock success");
                std::cout<<"sock"<<sock<<endl;

                //5.通信就用sock文件描述符，面向字节流，后续都是文件操作
                /*version1*/
                serverIO(sock);
                close(sock);
            }
        }
        void serverIO(int sock)
        {
            char buffer[1024];
            while (true)
            {
                ssize_t n=read(sock,buffer,sizeof(buffer)-1);
                if(n>0)
                {
                    buffer[n]=0;
                    std::cout<<"recv message "<<buffer<<endl;
                    string outbuffer=buffer;
                    outbuffer+="server[echo]";
                    write(sock,outbuffer.c_str(),outbuffer.size());
                }
                else if(n==0)
                {
                    //客户端退出
                    logMessage(NORMAL,"client quit ,me too!!");
                    break;
                }
            }
            
        }
        ~tcpServer()
        {
        }

    private:
        int listen_sockfd_;//不负责通信，只负责监听链接，获取新链接
        uint16_t port_;
    };
}

1.1.3 tcpServer.cc

#include "tcpServer.hpp"
#include <memory>

using namespace std;
using namespace Server;
static void Usage(string proc)
{
    cout << "\nUsage:\n\t" << proc << " local_port\n\n";
}


int main(int argc,char* argv[])
{
    if(argc!=2)
    {
        Usage(argv[0]);
        exit(USAGE_ERR);
    }
    uint16_t serverport=atoi(argv[1]);
    unique_ptr<tcpServer> tsvr(new tcpServer(serverport));
    tsvr->InitServer();
    tsvr->start();
    return 0;

}

1.2 客户端实现

1.2.1 接口认识

1.2.1.1 connect：发起连接
#include <sys/types.h>          /* See NOTES */
#include <sys/socket.h>
int connect(int sockfd, const struct sockaddr *addr,socklen_t addrlen);
参数与accept一样，代表的含义也一样
返回值：成功0，失败-1

1.2.2 tcpClient.hpp

#pragma once
#include <iostream>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <cstring>
#include <string>
#include <unistd.h>

namespace Client
{
    enum
    {
        USAGE_ERR = 1,
        SOCKET_ERR,
        BIND_ERR,
        LISTEN_ERR
    };
    using namespace std;
    class tcpClient
    {
    public:
        tcpClient(const string &clientip, const uint16_t &clientport)
            : clientip_(clientip), clientport_(clientport), sockfd_(-1)
        {
        }
        void InitCient()
        {
            // 1.创建socket
            sockfd_ = socket(AF_INET, SOCK_STREAM, 0);
            if (sockfd_ < 0)
            {
                std::cerr << "socket create error" << endl;
                exit(2);
            }
        }
        void run()
        {
            struct sockaddr_in server;
            memset(&server, 0, sizeof(server));
            server.sin_family = AF_INET;
            server.sin_port = htons(clientport_);
            server.sin_addr.s_addr = inet_addr(clientip_.c_str());

            // 发起链接
            if (connect(sockfd_, (struct sockaddr *)&server, sizeof(server)) != 0)
            {
                std::cerr << "connect create error" << endl;
            }
            else
            {
                string msg;
                while (true)
                {
                    cout << "Enter# ";
                    getline(cin, msg);
                    write(sockfd_, msg.c_str(), msg.size());

                    char buffer [1024];
                    ssize_t n=read(sockfd_,buffer,sizeof(buffer)-1);
                    if (n>0)
                    {
                        buffer[n]=0;
                        cout<<"Server处理后为# "<<buffer<<endl;

                    }
                    else
                    {
                        break;
                    }
                    

                }
            }
        }
        ~tcpClient() {
            if(sockfd_>=0) close(sockfd_);
        }

    private:
        int sockfd_;
        uint16_t clientport_;
        string clientip_;
    };
}

1.2.3 tcpClient.cc

#include "tcpClient.hpp"
#include <memory>
using namespace std;
using namespace Client;
static void Usage(string proc)
{
    cout << "\nUsage:\n\t" << proc << " server_ip server_port\n\n";
}


int main(int argc,char* argv[])
{
    if(argc!=3)
    {
        Usage(argv[0]);
        exit(USAGE_ERR);
    }
    uint16_t clientport=atoi(argv[2]);
    string clientip=argv[1];

    unique_ptr<tcpClient> ucli(new tcpClient(clientip,clientport));
    ucli->InitCient();
    ucli->run();
    return 0;
}

上述代码是一个单进程的版本，一个链接过来会去死循环执行serverIO，也就是说同一时间只能有一个链接过来通信，其他的链接必须阻塞等待上一个链接退出

1.3 优化方案

1.3.1 TCP网络通信----多进程版

更该tcpServer.hpp中的start函数即可，其他文件和单进程版一致

void start()
{
    logMessage(NORMAL, "Thread init success");
    for (;;)
    {
        // 4.server获取新链接
        struct sockaddr_in peer;
        socklen_t len = sizeof(peer);
        // sock:和客户端通信的文件描述符
        int sock = accept(listen_sockfd_, (struct sockaddr *)&peer, &len);
        if (sock < 0) // 没有获取新链接成功就执行下一次循环
        {
            logMessage(FATAL, "accpect sock error");
            continue;
        }
        logMessage(NORMAL, "accept sock success,get new sock:%d", sock);

        /*******************************************version2多进程版*/

        pid_t id = fork();
        if (id == 0) // 子进程
        {
            // 关闭子进程不需要的文件描述符
            close(listen_sockfd_);

            // 子进程退出，父进程回收资源，孙子进程去执行任务
            // 孙子进程成为孤儿进程，1号进程托管并回收其退出资源
            if (fork() > 0)
                exit(0); 

            // 孙子进程
            serverIO(sock);
            close(sock);//任务完成关闭文件描述符
            exit(0); 
        }
        
        // 细节：父进程必须关闭子进程的sock，避免一直被占用
        // 这里的关闭并不是完全关闭，只是引用计数减一，并不影响孙子进程
        close(sock); // 获取之后立马关闭，多次链接出现sock都一样，也可能不一样

        // 父进程,阻塞等待子进程退出
        pid_t ret = waitpid(id, nullptr, 0);
        if (ret > 0)
        {
            std::cout << "waitsuccess" << ret << endl;
        }
    }
}
  1. 父进程必须关闭子进程的sock，避免一直被占用
    这里的关闭并不是完全关闭，只是引用计数减一，并不影响孙子进程
  2. waitpid这里不能单纯用非阻塞等待，当有多个连接到来的时候，并且有一个进程退出，父进程非阻塞等待，去执行accept，但是如果后续没有连接来了，就一直阻塞在accept，剩下的子进程就没法回收了

前面【信号】中曾说道子进程退出时会发送SIGCHLD信号，我们可以对其设置捕捉，忽略掉其行为，父进程就不需要阻塞等待了

void start()
{
    logMessage(NORMAL, "Thread init success");
   	signal(SIGCHLD,SIG_IGN);//设置信号忽略行为
    for (;;)
    {
        // 4.server获取新链接
        struct sockaddr_in peer;
        socklen_t len = sizeof(peer);
        // sock:和客户端通信的文件描述符
        int sock = accept(listen_sockfd_, (struct sockaddr *)&peer, &len);
        if (sock < 0) // 没有获取新链接成功就执行下一次循环
        {
            logMessage(FATAL, "accpect sock error");
            continue;
        }
        logMessage(NORMAL, "accept sock success,get new sock:%d", sock);

        /*******************************************version2多进程版*/

        pid_t id = fork();
        if (id == 0) // 子进程
        {
            // 关闭子进程不需要的文件描述符
            close(listen_sockfd_);
            // 子进程
            serverIO(sock);
            close(sock);//任务完成关闭文件描述符
            exit(0); 
        }
        
        // 细节：父进程必须关闭子进程的sock，避免一直被占用
        // 这里的关闭并不是完全关闭，只是引用计数减一，并不影响孙子进程
        close(sock); // 获取之后立马关闭，多次链接出现sock都一样，也可能不一样

       
    }
}

1.3.2 TCP网络通信----多线程版

在tcpServer类外添加ThreadData类，类内修改start函数，添加threadRoutinue函数其余不变

    class tcpServer;
    class ThreadData
    {
    public:
        ThreadData(tcpServer *self, int sockfd)
            : self_(self), sockfd_(sockfd)
        {
        }

    public:
        tcpServer *self_;
        int sockfd_;
    };
    
void start()
        {
            logMessage(NORMAL, "Thread init success");
            // signal(SIGCHLD,SIG_IGN);
            for (;;)
            {
                // 4.server获取新链接
                struct sockaddr_in peer;
                socklen_t len = sizeof(peer);
                // sock:和客户端通信的文件描述符
                int sock = accept(listen_sockfd_, (struct sockaddr *)&peer, &len);
                if (sock < 0) // 没有获取新链接成功就执行下一次循环
                {
                    logMessage(FATAL, "accpect sock error");
                    continue;
                }
                logMessage(NORMAL, "accept sock success,get new sock:%d", sock);

                

                /*******************************************version3：多线程版本*/
                 pthread_t tid;
                 ThreadData* td=new ThreadData(this,sock);
                 pthread_create(&tid,nullptr,threadRoutinue,td);

                
            }
        }
        //类内调用，静态方法
         static void* threadRoutinue(void* args)
         {
             pthread_detach(pthread_self());
             ThreadData* td= static_cast<ThreadData*>(args);
             td->self_->serverIO(td->sockfd_);
             //在一个进程中的所有线程都可以访问到文件描述符表，属于共享资源，
             //一个线程所对应的fd在使用完毕后需要进行关闭。
             close(td->sockfd_);
             delete td;
             return nullptr;
         }

多进程版，多线程版，线程池版，可参考我的Gitee

二、日志函数编写

在计算机中，日志文件是记录在操作系统或其他软件运行中发生的事件或在通信软件的不同用户之间的消息的文件。记录是保持日志的行为。在最简单的情况下，消息被写入单个日志文件。

我们借助可变参数列表来模拟实现日志函数
实现格式如：[日志等级][时间][pid][message]

#pragma once
#include <iostream>
#include <string>
#include <stdarg.h>
#include <ctime>
#include <unistd.h>

//把错误信息写到指定文件

#define LOG_NORMAL "log_nrl.txt"
#define LOG_ERR "log_err.txt"



#define DEBUG   0
#define NORMAL  1
#define WARNING 2
#define ERROR   3
#define FATAL   4

//typedef char* va_list

const char * to_levelstr(int level)
{
    switch(level)
    {
        case DEBUG : return "DEBUG";
        case NORMAL: return "NORMAL";
        case WARNING: return "WARNING";
        case ERROR: return "ERROR";
        case FATAL: return "FATAL";
        default : return nullptr;
    }
}

//void logMessage(DEBUG,"sss %f %d %c",2.1,6,'h')
void logMessage(int level,const char* format,...)
{
#define NUM 1024
    char logprefix[NUM];

    //前半部分[日志等级][时间][pid]
    snprintf(logprefix,sizeof(logprefix),"[%s][%ld][%d]",to_levelstr(level),(long int)time(nullptr),getpid());

    char logcontent[NUM];
    va_list arg;
    //初始化arg为参数列表中的第一个参数的地址
    va_start(arg,format);

    //后半部分，错误信息
    //vsnprintf()函数的作用是将可变参数列表arg中的数据按照指定的格式format写入缓冲区logcontent中
    vsnprintf(logcontent,sizeof(logcontent),format,arg);  

   

//这里做了简化，实际上是一个等级一个日志文件
    FILE* log=fopen(LOG_NORMAL,"a");
    FILE* err=fopen(LOG_ERR,"a");

    if(log !=nullptr && err!=nullptr)
    {
       
        if(level==DEBUG || level==NORMAL||level==WARNING)
        {
            fprintf(log,"%s%s\n",logprefix,logcontent);
        }

        if(level==ERROR || level==FATAL)
        {
            fprintf(err,"%s%s\n",logprefix,logcontent);
        }

        fclose(log);
        fclose(err);
    }

}

三、守护进程

3.1 引入:为什么需要守护进程化

守护进程又叫精灵进程—本质孤儿进程的一种有了守护进程，上述的服务端才能变成一个真正的服务端

在这里插入图片描述
1.当我们使用xsell链接远端云服务器的时候，打开的页面第一个出现的就是bash命令行，这个时候我们输入sleep 10000 | sleep 20000 |sleep 30000 &就可以添加一个后台任务。

在这里插入图片描述
2.在命令行运行sleep 40000 | sleep 50000 |sleep 60000 &后，查看进程，发现新创建的三个进程PGID一样，属于同一个组，完成一个任务，与之前的任务同属于一个会话（SID都一样）
在这里插入图片描述
3.通过查看SID进程发现，是bash：会话ID是以bash命名的
在这里插入图片描述
4.前后台任务切换
fg + 作业编号切换指定任务到前台
ctrl+z暂停任务：bash自动切换到前台
bg +作业编号指定任务stop->run
在这里插入图片描述
当我们进行网络通信的时候，如果服务器关机或注销了，任务就可能会被清理，导致客户端发送的消息无响应，这显然与真正的服务器不一样，我们需要把服务任务自成会话，自成进程组，不受终端设备影响-----守护进程

3.2 进程，守护进程化

#include <unistd.h>

pid_t setsid(void);//必须是非组长调用

setsid 用于在一个新的会话中启动一个进程。在运行 setsid 命令时，所启动的进程将会脱离当前的终端会话，并在一个新的会话中运行，这样它就不会受到终端会话关闭或挂起的影响，而可以持续运行。

#pragma once
#include <unistd.h>
#include <signal.h>
#include <cstdlib>
#include <cassert>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>

#define DEV "/dev/null"  //垃圾站，写进的内容全丢弃

//自建一个会话，组长就是自己，调用函数的不能是组长
//调用完毕之后成为组长
void daemonSelf(char* currPath=nullptr)
{
    //1.让调用进程忽略掉异常的信号
    //客户端已经退出，服务端再写会崩溃
    signal(SIGPIPE,SIG_IGN);

    //2.不是组长，调用setsid
    if(fork()>0) exit(0);
    
    //子进程---守护进程又叫精灵进程---本质孤儿进程
    pid_t n=setsid();
    assert(n!=-1);

    //3.守护进程是脱离终端的，关闭或重定向以前进程默认打开的文件

    //      /dev/null 垃圾站，写进的内容全丢弃
    int fd=open(DEV,O_RDWR);
    if(fd>=0)
    {
        dup2(fd,0);
        dup2(fd,1);
        dup2(fd,2);

        //012已经执行devil/null
        close(fd);
    }
    else
    {
        close(0);
        close(1);
        close(2);
    }

    //4.可选：进程执行路径发生更改
    //chdir：将进程的当前工作目录更改为 currpath 参数指定的目录
    if(!currPath) chdir(currPath);


}

在服务端初始化完毕之后，启动之前执行daemonSelf()函数，再启动服务端，查看进程就可以得到以下信息
在这里插入图片描述
父进程id为1证明这个进程是一个孤儿进程，而且可以发现这个进程的PID,PGID,GID都一样，这就是自成会话，自成进程组的守护进程！！！

这个时候，即便关闭终端，只要不kill掉这个进程，他就会在一直运行响应客户端

四、TCP协议通信流程

在这里插入图片描述
建立连接的过程:

  • 调用socket, 创建文件描述符;
  • 调用connect, 向服务器发起连接请求;
  • connect会发出SYN段并阻塞等待服务器应答; (第一次)
  • 服务器收到客户端的SYN, 会应答一个SYN-ACK段表示"同意建立连接"; (第二次)
  • 客户端收到SYN-ACK后会从connect()返回, 同时应答一个ACK段; (第三次)
    这个建立连接的过程, 通常称为 三次握手

断开连接的过程:

  • 如果客户端没有更多的请求了, 就调用close()关闭连接, 客户端会向服务器发送FIN段(第一次);
  • 此时服务器收到FIN后, 会回应一个ACK, 同时read会返回0 (第二次);
  • read返回之后, 服务器就知道客户端关闭了连接, 也调用close关闭连接, 这个时候服务器会向客户端发送一个FIN; (第三次)
  • 客户端收到FIN, 再返回一个ACK给服务器; (第四次)

4.1 三次握手与四次挥手感性认识

三次握手—建立连接：
女方对男方说想谈恋爱，男方答应并问到什么时候开始，女方说现在

四次挥手—断开连接：
比如女方对男方说离婚，男方回复离婚
同时男方反应一会觉得不行，凭什么你先对我说，我也得休了你，然后对女方说离婚，女方回复离婚

TCP三握四挥传送门>>>

阿浩啊z
关注
  • 28
    点赞
  • 踩
  • 24
    收藏
    觉得还不错? 一键收藏
  • 26
    评论
专栏目录
Linux之—网络通信（TCP）
best_fiends_zxh的博客
11-06 1389
TCP的上一层是应用层，TCP向应用层提供可靠的面向对象的数据流传输服务，TCP数据传输实现了从一个应用程序到另一个应用程序的数据传递。它能提供高可靠性通信(即数据无误、数据无丢失、数据无失序、数据无重复到达的通信。)，应用程序通过向TCP层提交数据接发送/收端的地址和端口号而实现应用层的数据通信。 通过IP的源/目的可以惟一地区分网络中两个设备的连接，通过socket的源/目的可以惟一地区分网
Linux Socket TCP通信
albon arith
03-31 5260
1. Server端 /*socket tcp服务器端*/ #include #include #include #include #include #include #include #include #include #include #include #include #define SERVER_PORT 5555 int main() { int ser
Linux——socket编程之tcp通信
最新发布
kkbca的博客
05-04 1191
前面我们学习，了解到了socket的概念与udp的实现方法，今天我们来学习一下面向连接的tcp通信。
linux——简单的Tcp通信
maple_zmz的博客
08-20 65
https://blog.csdn.net/u012198575/article/details/103493100?ops_request_misc=%257B%2522request%255Fid%2522%253A%2522162942256916780274183616%2522%252C%2522scm%2522%253A%252220140713.130102334..%2522%257D&request_id=162942256916780274183616&biz_id=0&
Linux下的TCP通信（二）—— 多进程模式、多线程模式
challenglistic的博客
07-19 1166
Linux下的TCP通信 —— 多进程模式、多线程模式
Linux下的TCP通信（一）—— 单进程模式
challenglistic的博客
07-17 824
Linux 下的TCP通信
我终于搞懂了TCP的三次握手和四次挥手（图片案例详解）
01-06
TCP三次握手和四次挥手不管是在开发还是面试中都是一个非常重要的知识点，它是我们优化web程序性能的基础。欢迎学习，一起进步 文章目录一.TCP简介二.TCP数据报结构三.TCP的三次握手四.TCP的四次挥手 一.TCP简介 TCP...
利用TCP协议与socket文件完成两个进程之间的网络通信
08-05
在IT领域，网络通信是核心部分之一，尤其...总的来说，TCP协议与socket文件的结合，为进程间的网络通信提供了稳定且高效的方式。理解并掌握这些知识对于开发网络应用至关重要，能够帮助我们构建出健壮、可扩展的系统。
TCP.zip_DEMO_LINUX TCP _linux 网络通信_linux 网络_linux 网络编程
09-22
2. **TCP连接过程**：TCP是面向连接的协议，遵循三次握手流程建立连接。客户端首先发送SYN（同步序列编号）报文，服务器响应SYN+ACK（同步+确认），最后客户端再次发送ACK报文确认连接建立。 3. **数据传输**：连接...
tcp.rar_TCP VC6_tcp_tcp 通信_vc6.0 socket_网络协议
09-24
1. **连接建立**：TCP通信始于三次握手（Three-Way Handshake）。客户端发送一个SYN（同步序列编号）包给服务器，服务器回应一个SYN+ACK（确认），最后客户端再发一个ACK来确认连接建立。这一过程确保了双方都有能力...
TCP.rar_MFC tcp网络通信_TCP协议mfc_mfc tcp通信_tcp 短连接_tcp短连接
09-23
TCP使用三次握手建立连接，确保双方都有能力接收和发送数据。在描述中提到的“短连接”指的是每次通信完成后立即关闭连接，而不是保持连接开放以供后续通信。这种方式适用于一次性或非持久性的通信需求，例如HTTP...
Linux tcp通讯demo
07-19
本文件中包含两个文件TCP客户端client.c和TCP服务器server.c 文件用gcc即可完成编译 先运行服务器端，在运行客户端，可从客户端向服务器端发送数据，当输入“1”，结束连接，客户端释放连接，退出程序，服务器端释放当前连接，继续进入监听状态，等待新的连接 本程序适合linux下的Socket编程新手，有助更好的理解TCP协议和socket编程
Linux网络编程之TCP通信
m0_57710138的博客
08-27 628
简单介绍TCP通信以及TCP客户端/服务端间的通信常用的函数
Linux网络编程：TCP通信
weixin_44788175的博客
04-28 1351
一、TCP流程图 二、TCP通信流程1、服务器端 2、客户端 三、套接字函数1、头文件2、socket 函数3、bind 函数4、listen函数5、accept函数6、connect函数7、write 和 read 函数
在Linux系统上实现TCP（socket）通信
m0_74055118的博客
04-07 957
TCP（传输控制协议）是一种面向连接的、可靠的、基于字节流的传输层通信协议。
TCP程序设计 听课笔记
yuyu711的博客
10-23 125
[size=x-large]步骤[/size] TCP服务器 1 创建socket, 用socket()函数 2 绑定IP地址,端口到socket上, 用bind()函数 3 设置最大连接数, 用listen()函数 4 等待来自客户端的连接请求, 用accept()函数 5 收发数据, 用send()和recv(), 或者read()和write() 6 关闭网络连接 T...
232-Linux tcp通信
weixin_45964837的博客
03-07 460
1.传输层：两台不同主机上的两个进程的通信 2.tcp/ip 应用层 传输层 网络层 数据链路层 应用层发送一个"hello"，到传输层以后会变成 tcp “hello”，当到了网络层以后会变成 ip tcp “hello”，到数据链路层以后会变成 帧头 ip tcp “hello” 帧尾 3.tcp和udp的特点 tcp特点：面向连接的、可靠的流式服务 upd特点：无连接的、不可靠的数据报服务 tcp的可靠性是有开销的，tcp为了可靠性付出了一些的代价 4.通过套接字可以进行数据的收发 5.创建套接
233-Linux tcp通信
weixin_45964837的博客
03-07 458
1.客户端connect开始执行三次握手，客户端close开始执行四次挥手 2.tcp的服务器端和客户端是面试的时候最有可能考的，必须要会 3.什么情况下会导致服务器端bind绑定的时候失败？ 答案：端口被占用或者ip地址错误 4.服务器端listen函数中的第二个参数在Linux系统中指的是已完成三次握手的队列的长度，在Unix系统中指的是未完成三次握手队列和已完成三次握手队列大小之和 5.服务器端recv的返回值等于0是唯一可以判断客户端关闭了连接的一个依据，不管是客户端close了还是说客户端的进程
10 Linux TCP简单通信
IYATT-yx的博客
01-26 128
前言 (含目录)
waitpid
05-31
`waitpid` 是一个系统调用，用于等待指定进程的状态发生变化，并返回其状态信息。它的原型为： ```c pid_t waitpid(pid_t pid, int *status, int options); ``` 其中，`pid` 参数指定要等待的进程的 PID。如果 `pid` 的值为 -1，则表示等待任意子进程。`status` 参数用于存储进程的状态信息，包括进程是否正常退出、退出状态码等。`options` 参数用于指定等待的行为，例如是否使用非阻塞模式等。 `waitpid` 函数会阻塞当前进程，直到指定进程的状态发生变化。如果指定的进程已经退出，则会立即返回其状态信息。如果指定的进程还在运行，则 `waitpid` 函数会一直等待，直到进程退出或者发生错误。 需要注意的是，如果多个子进程同时退出，`waitpid` 函数只会返回其中一个子进程的状态信息。如果需要获取所有子进程的状态，可以使用 `wait` 函数或者循环调用 `waitpid` 函数。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 26
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值