UNP——TCP分析

最新推荐文章于 2023-06-02 16:25:40 发布
最新推荐文章于 2023-06-02 16:25:40 发布
阅读量943 收藏 1
点赞数 1
分类专栏： UNP socket
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44537992/article/details/106772982
版权

1.TCP流程

2.TCP详细分析

2.1 TCP缓冲区

首先复习下标准IO与系统调用IO的工作流程，配图为网上摘取
buffer是从
在这里插入图片描述

在这里插入图片描述
在这里插入图片描述

3.1 传递时间示例代码

tcpserver.c

#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <unistd.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <time.h>
#include <arpa/inet.h>
#include "proto.h"

#define bakc_log 50
#define praddr_size 50
#define buffer_size 1024
static void server_job(int sockfd)
{
    int len;
    char buffer[buffer_size];
    len = sprintf(buffer,FMT_STAMP, (long long)time(NULL));

    if(send(sockfd, buffer, len, 0)<0)
    {
        perror("send");
        exit(1);
    }
}

int main()
{
    int sd,std;
    int flag;
    pid_t pid;
    char p_raddr[praddr_size];
    struct sockaddr_in laddr,raddr;
    laddr.sin_family = AF_INET;
    laddr.sin_port = htons(LOCALPORT);
    inet_pton(AF_INET,"0.0.0.0",&laddr.sin_addr);

    socklen_t laddrsize = sizeof(laddr);
    socklen_t raddrsize = sizeof(raddr);
    sd = socket(AF_INET,SOCK_STREAM,0);
    if(sd<0)
    {
        perror("socket");
        exit(1);
    }

    if(setsockopt(sd,SOL_SOCKET,SO_REUSEADDR,&flag,sizeof(flag))<0)
    {
        perror("setsocket");
        exit(1);
    }

    if(bind(sd, (void*)&laddr, laddrsize)<0)
    {
        perror("bind");
        exit(1);
    }

    if(listen(sd,bakc_log)<0)
    {
        perror("listen");
        exit(1);
    }

    while(1)
    {
            //accept返回三个值，std即可能是已连接套接字或错误信息，对端地址，对端地址大小
        std = accept(sd, (void*)&raddr,&raddrsize);  //返回值为全新文件描述符，代表与tcp对端连接，已连接描述符
        if(std < 0)
        {
            perror("accept");
            exit(1);
        }
        pid = fork();  //并发的时候，应该注意：fork之后，子进程和父进程均有已连接描述符和监听描述符，父进程中需close已连接描述符
                        //，将引用计数减为0
        if(pid == 0)
        {
            close(sd);
            inet_ntop(AF_INET,&raddr.sin_addr,p_raddr,praddr_size);
            fprintf(stderr,"Client addr is %s , port is %d\n",p_raddr,ntohs(raddr.sin_port));

            server_job(std);
            close(std);
            exit(0); //子进程结束必须exit0，否则会继续执行
        }
        close(std); //此处必须有，计数减为0，然后才会发送FIN，四次分手
    }

    close(sd);
    exit(0);
}

tcpclient.c

#include <stdlib.h>
#include <stdio.h>
#include <sys/types.h>          /* See NOTES */
#include <sys/socket.h>
#include <arpa/inet.h>
#include <stdio.h>
#include "proto.h"
#define raddr_size 40
int main(int argc, char* argv[])
{

    FILE* fp;
    long long stamp;
    struct sockaddr_in laddr,raddr;
    char raddr_ip[raddr_size];
    if(argc < 2)
    {
        fprintf(stderr,"argc");
        exit(1);
    }

    int sd = socket(AF_INET,SOCK_STREAM,0);
    if(sd<0)
    {
        perror("socket");
        exit(1);
    }
    raddr.sin_family = AF_INET;
    raddr.sin_port = htons(LOCALPORT);
    inet_pton(AF_INET,argv[1],&raddr.sin_addr);
    fprintf(stderr,"let's go");
    if(connect(sd,(void*)&raddr,sizeof(raddr))<0)  //conncet开始三次握手，可能出现三种情况1、FIN无ACK，75s后ETIMEOUT
    {
        perror("connect");
        exit(1);
    }

    //一切皆文件
    fp = fdopen(sd,"r+"); //将文件描述符转换成FILE指针打开,这里不能用w，w+，因无需创建fd
	// fileno(fp)与之相反，是FILE*转成fd
    if(fp==NULL)
    {
        perror("fdopen");
        exit(1);
    }

    if(fscanf(fp,FMT_STAMP,&stamp)<1) //返回成功读取的个数，这里只有一个item，正确为1
    {

        fprintf(stderr,"error FMT_STAMP");
    }
    else
    {
        fprintf(stderr,"stamp = %lld\n",stamp);
    }

    fclose(fp); //这里需要关闭fp，因为fdopen已经转成fp

    exit(0);
}

proto.h

#ifndef PROTO_H__
#define PROTO_H__

#define LOCALPORT 1990
#define FMT_STAMP "%lld\r\n"


#endif

3.2 传递图片代码

tcpserver.c

#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <unistd.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <time.h>
#include <arpa/inet.h>
#include "proto.h"

#define bakc_log 50
#define praddr_size 50
#define buffer_size 1024
static void server_job(int sockfd)
{
    int len;
    char buffer[buffer_size];
    size_t num;
    FILE* fp;
    //len = sprintf(buffer,FMT_STAMP, (long long)time(NULL));
    fp = fopen("/home/qianchen/Pictures/muniao.jpg","r");
    if(fp == NULL)
    {
        perror("fopen error");
        exit(1);
    }
    while(1)
    {
        num = fread(buffer,1,buffer_size,fp);
        if(num == 0)
        {
            perror("fread error");
            break;
        }
        if(send(sockfd, buffer, num, 0)<0) //输出重定向./tcpclient 127.0.0.1 > /home/qianchen/Videos/tcp/1.jpg
        {
            perror("send");
            exit(1);
        }
    }

    fclose(fp);
}

int main()
{
    int sd,std;
    int flag;
    pid_t pid;
    char p_raddr[praddr_size];
    struct sockaddr_in laddr,raddr;
    laddr.sin_family = AF_INET;
    laddr.sin_port = htons(LOCALPORT);
    inet_pton(AF_INET,"0.0.0.0",&laddr.sin_addr);

    socklen_t laddrsize = sizeof(laddr);
    socklen_t raddrsize = sizeof(raddr);
    sd = socket(AF_INET,SOCK_STREAM,0);
    if(sd<0)
    {
        perror("socket");
        exit(1);
    }

    if(setsockopt(sd,SOL_SOCKET,SO_REUSEADDR,&flag,sizeof(flag))<0)
    {
        perror("setsocket");
        exit(1);
    }

    if(bind(sd, (void*)&laddr, laddrsize)<0)
    {
        perror("bind");
        exit(1);
    }

    if(listen(sd,bakc_log)<0)
    {
        perror("listen");
        exit(1);
    }

    while(1)
    {
            //accept返回三个值，std即可能是已连接套接字或错误信息，对端地址，对端地址大小
        std = accept(sd, (void*)&raddr,&raddrsize);  //返回值为全新文件描述符，代表与tcp对端连接，已连接描述符
        if(std < 0)
        {
            perror("accept");
            exit(1);
        }
        pid = fork();  //并发的时候，应该注意：fork之后，子进程和父进程均有已连接描述符和监听描述符，父进程中需close已连接描述符
                        //，将引用计数减为0
        if(pid == 0)
        {
            close(sd);
            inet_ntop(AF_INET,&raddr.sin_addr,p_raddr,praddr_size);
            fprintf(stderr,"Client addr is %s , port is %d\n",p_raddr,ntohs(raddr.sin_port));

            server_job(std);
            close(std);
            exit(0); //子进程结束必须exit0，否则会继续执行
        }
        close(std); //此处必须有，计数减为0，然后才会发送FIN，四次分手
    }

    close(sd);
    exit(0);
}

tcpclient.c

#include <stdlib.h>
#include <stdio.h>
#include <sys/types.h>          /* See NOTES */
#include <sys/socket.h>
#include <arpa/inet.h>
#include <stdio.h>
#include "proto.h"
#define raddr_size 40
#define JPGBUFFERSIZE 1024



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

    FILE* fp;
    size_t num;
    long long stamp;
    char jpgbuffer[JPGBUFFERSIZE];
    struct sockaddr_in laddr,raddr;
    char raddr_ip[raddr_size];
    if(argc < 2)
    {
        fprintf(stderr，"argc error\n");
        exit(1);
    }

    int sd = socket(AF_INET,SOCK_STREAM,0);
    if(sd<0)
    {
        perror("socket");
        exit(1);
    }
    raddr.sin_family = AF_INET;
    raddr.sin_port = htons(LOCALPORT);
    inet_pton(AF_INET,argv[1],&raddr.sin_addr);
    fprintf(stderr,"let's go");
    if(connect(sd,(void*)&raddr,sizeof(raddr))<0)  //conncet开始三次握手，可能出现三种情况1、FIN无ACK，75s后ETIMEOUT
    {
        perror("connect");
        exit(1);
    }

    //一切皆文件
    fp = fdopen(sd,"r+"); //将文件描述符转换成FILE指针打开,这里不能用w，w+，因无需创建fd

    if(fp==NULL)
    {
        perror("fdopen");
        exit(1);
    }
    fprintf(stderr,"Let's go!\n");
    while(1)
    {
        num = fread(jpgbuffer,1,JPGBUFFERSIZE,fp);
        if(num==0)
        {
            fprintf(stderr,"fread");
            break;
        }    
        fwrite(jpgbuffer,1,num,stdout);
        fprintf(stderr,"end\n");
    }

    fclose(fp); //这里需要关闭fp，因为fdopen已经转成fp

    exit(0);
}

proto.h

#ifndef PROTO_H__
#define PROTO_H__

#define LOCALPORT 1990
#define FMT_STAMP "%lld\r\n"


#endif

3.3 静态进程池tcp连接

tcppoolserver.c

#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <unistd.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <time.h>
#include <arpa/inet.h>
#include <sys/wait.h>
#include "proto.h"

#define POOL_SIZE 3
#define BAKC_LOG 50
#define PRADDER_SIZE 50
#define BUFFER_SIZE 1024
int sd;
int flag;
pid_t pid;
char p_raddr[PRADDER_SIZE];
struct sockaddr_in laddr,raddr;
socklen_t laddrsize = sizeof(laddr);
socklen_t raddrsize = sizeof(raddr);


static void do_it(int sockfd);

static void server_job(int sockfd)
{
    int len;
    char buffer[BUFFER_SIZE];
    size_t num;
    len = sprintf(buffer,FMT_STAMP, (long long)time(NULL));
    if(send(sockfd,buffer,len,0)<0)
    {
        perror("send");
        exit(1);
    }
}

int main()
{

    laddr.sin_family = AF_INET;
    laddr.sin_port = htons(LOCALPORT);
    inet_pton(AF_INET,"0.0.0.0",&laddr.sin_addr);


    sd = socket(AF_INET,SOCK_STREAM,0);
    if(sd<0)
    {
        perror("socket");
        exit(1);
    }

    if(setsockopt(sd,SOL_SOCKET,SO_REUSEADDR,&flag,sizeof(flag))<0)
    {
        perror("setsocket");
        exit(1);
    }

    if(bind(sd, (void*)&laddr, laddrsize)<0)
    {
        perror("bind");
        exit(1);
    }

    if(listen(sd,BAKC_LOG)<0)  //多个c端握手，内核保证BAKC_LOG大小的两个队列，进行握手
    {
        perror("listen");
        exit(1);
    }
    for(int i=0; i<POOL_SIZE; i++)  //产生静态进程池，用这三个进程处理
    {

        pid = fork();
        if(pid<0)
        {
            perror("fork");
            exit(1);
        }
        if(pid == 0)
        {  
            do_it(sd);
            exit(0);
        } 
    }
    for(int i=0; i<POOL_SIZE; i++)
    {
        wait(NULL);
    }



    close(sd);
    exit(0);
}


static void do_it(int sockfd)
{
    int std;
    while(1)
    {	
        //accept返回三个值，std即可能是已连接套接字或错误信息，对端地址，对端地址大小
    std = accept(sockfd, (void*)&raddr,&raddrsize);  //返回值为全新文件描述符，代表与tcp对端连接，已连接描述符
    if(std < 0)
    {
        perror("accept");
        exit(1);
    }

    //close(sockfd); 注意，这里不能close(sockfd),否则在while里，运行POOL_SIZE次后，fd会被close掉
    inet_ntop(AF_INET,&raddr.sin_addr,p_raddr,PRADDER_SIZE);
    fprintf(stderr,"Client addr is %s , port is %d, pid is %d\n",p_raddr,ntohs(raddr.sin_port),getpid());

    server_job(std);
    close(std);
    //exit(0); //子进程结束必须exit0，否则会继续执行
    }
//    }
//    close(std); //此处必须有，计数减为0，然后才会发送FIN，四次分手
}

tcppollclient.c

#include <stdlib.h>
#include <stdio.h>
#include <sys/types.h>          /* See NOTES */
#include <sys/socket.h>
#include <arpa/inet.h>
#include <stdio.h>
#include "proto.h"
#define raddr_size 40
int main(int argc, char* argv[])
{

    FILE* fp;
    long long stamp;
    struct sockaddr_in laddr,raddr;
    char raddr_ip[raddr_size];
    if(argc < 2)
    {
        fprintf(stderr,"argc");
        exit(1);
    }

    int sd = socket(AF_INET,SOCK_STREAM,0);
    if(sd<0)
    {
        perror("socket");
        exit(1);
    }
    raddr.sin_family = AF_INET;
    raddr.sin_port = htons(LOCALPORT);
    inet_pton(AF_INET,argv[1],&raddr.sin_addr);
    fprintf(stderr,"let's go");
    if(connect(sd,(void*)&raddr,sizeof(raddr))<0)  //conncet开始三次握手，可能出现三种情况1、FIN无ACK，75s后ETIMEOUT
    {
        perror("connect");
        exit(1);
    }

    //一切皆文件
    fp = fdopen(sd,"r+"); //将文件描述符转换成FILE指针打开,这里不能用w，w+，因无需创建fd

    if(fp==NULL)
    {
        perror("fdopen");
        exit(1);
    }

    if(fscanf(fp,FMT_STAMP,&stamp)<1) //返回成功读取的个数，这里只有一个item，正确为1
    {

        fprintf(stderr,"error FMT_STAMP");
    }
    else
    {
        fprintf(stderr,"stamp = %lld\n",stamp);
    }

    fclose(fp); //这里需要关闭fp，因为fdopen已经转成fp

    exit(0);
}


#ifndef PROTO_H__
#define PROTO_H__

#define LOCALPORT 1990
#define FMT_STAMP "%lld\r\n"


#endif

3.4 TCP动态进程池

#include <stdio.h>
#include <stdlib.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <signal.h>
#include <sys/mman.h>
#include <arpa/inet.h>
#include <errno.h>
#include <unistd.h>
#include <time.h>
#include "proto.h"

#define MINIDLENUM 5
#define MAXIDLENUM 10
#define MAXCLIENT 20
#define BUFFERSIZE 1024
#define SIG_NOTIFY SIGUSR1
#define RADDR_BUFSIZE 40
enum st_state
{
    ST_IDEL=0,
    ST_BUSY
};

struct server_st
{
    pid_t pid;
    int state;
};

static struct server_st *serverpool;
static int idle_count=0,busy_count=0;

int sd;
socklen_t raddr_len;
char linebuffer[BUFFERSIZE];
struct sockaddr_in raddr;
char raddr_buffer[RADDR_BUFSIZE];


static int addserver();
static int delserver();
static void server_jod(int a);
static void fun_notify();
static int scan_pool();


int main()
{
    int flag = 1;
    struct sigaction sa_usr1,sa_ch,sa_cho;
    struct sockaddr_in laddr;
    sigset_t sig_set,sig_old;

    laddr.sin_family = AF_INET;
    laddr.sin_port =  htons(LOCALPORT);
    inet_pton(AF_INET,"0.0.0.0",(void*)&laddr.sin_addr);

    sa_usr1.sa_handler = fun_notify;
    sigemptyset(&sa_usr1.sa_mask) ;
    sa_usr1.sa_flags = 0;
    sigaction(SIG_NOTIFY,&sa_usr1,&sa_cho);

    sa_ch.sa_handler = SIG_IGN;
    sigemptyset(&sa_ch.sa_mask);
    sa_ch.sa_flags = SA_NOCLDWAIT;  // 类似于detach，子进程进入僵尸态后，系统自动回收，不用wait
    sigaction(SIGCHLD,&sa_ch,&sa_cho);

    sigemptyset(&sig_set);
    sigaddset(&sig_set,SIG_NOTIFY);
    sigprocmask(SIG_BLOCK,&sig_set,&sig_old); //进程阻塞了SIG_NOTIFY

    
    serverpool = mmap(NULL, sizeof(struct server_st)*MAXCLIENT, PROT_WRITE, MAP_SHARED|MAP_ANONYMOUS,-1,0);//申请内存
    if(serverpool == MAP_FAILED)
    {
        perror("mmap");
        exit(1);
    }
    for(int i=0; i<MAXCLIENT; i++)
    {
        serverpool[i].pid = -1;
    }


    sd = socket(AF_INET,SOCK_STREAM,0);
    if(sd<0)
    {
        perror("socket");
        exit(1);
    }

    if(setsockopt(sd,SOL_SOCKET,SO_REUSEADDR,&flag,sizeof(flag))<0)
    {
        perror("setsockopt");
        exit(1);
    }


    if(bind(sd,(void*)&laddr,sizeof(laddr))<0)
    {
        perror("bind");
        exit(1);
    }

    if(listen(sd,50)<0)
    {
        perror("listen");
        exit(1);
    }

    for(int i = 0; i<MINIDLENUM; i++)
    {
        addserver();
    }

    while(1)
    {
        sigsuspend(&sig_old);//临时改变mask，同时pause
        scan_pool();
        if(idle_count>MAXIDLENUM)
        {
            for(int i=0; i<(idle_count-MAXIDLENUM); i++)
                delserver();
        }
        else if(idle_count < MINIDLENUM)
        {
            for(int i=0; i<(MINIDLENUM-idle_count); i++)
                addserver();
        }
        for(int i=0; i<MAXCLIENT; i++)
        {
            if(serverpool[i].pid == -1)
                putchar(' ');
            else if(serverpool[i].state == ST_IDEL)
                putchar('*');
            else
                putchar('X');
        }
        putchar('\n');
    }
    sigprocmask(SIG_SETMASK,&sig_old,NULL); //恢复原来的屏蔽集

    exit(0);
}

static int addserver()
{
    pid_t spid;
    int slot;
    if(idle_count+busy_count>= MAXCLIENT)
        return -1;
    for(slot=0; slot<MAXCLIENT; slot++)
    {
        if(serverpool[slot].pid == -1)
        {
            break;
        }
    }
    serverpool[slot].state = ST_IDEL;
    spid = fork();
    if(spid < 0)
    {   perror("fork");
        exit(1);
    } 
    else if(spid == 0)
    {
        server_jod(slot);
        exit(0);
    }               //父进程负责计数和设置serverpool里元素
    idle_count++;
    serverpool[slot].pid = spid;
    
    return 0;

}

static int delserver()
{
    int i;
    if(idle_count == 0)
        return -1;
    for(i=0; i<MAXCLIENT ;i++)
    {
        if(serverpool[i].pid != -1 && serverpool[i].state == ST_IDEL)
        {
            kill(serverpool[i].pid,SIGTERM);
            serverpool[i].pid = -1;
            idle_count--;
            break;
        }
    }
    return 0;
}

static void server_jod(int a)
{
    int asd;
    int num;
    int ppid;
    ppid = getppid();
    while(1)
    {
        serverpool[a].state = ST_IDEL; //设置属性
        // idle_count++;

        kill(ppid,SIG_NOTIFY);
        asd = accept(sd,(void*)&raddr,&raddr_len);
        if(asd < 0)
        {
            if(errno != EINTR || errno != EAGAIN) //这里注意假错，EINTR和EAGAIN
            {
                perror("accept");
                exit(1);
            }
        }
        serverpool[a].state = ST_BUSY;
        // idle_count--;
        // busy_count++;
        inet_ntop(AF_INET,(void*)&raddr.sin_addr,raddr_buffer,RADDR_BUFSIZE);
     //   fprintf(stdout,"the client pid is %d, addr is %s, port is %d\n",serverpool[a].pid,raddr_buffer,ntohs(raddr.sin_port));

        kill(ppid,SIG_NOTIFY); //给父进程发送消息，让其查看状态
        num = sprintf(linebuffer,FMT_STAMP,(long long)time(NULL));
        if(send(asd,linebuffer,num,0)<0)
        {
            perror("send");
            exit(1);
        }
        sleep(5);
        close(asd);
        // busy_count--;
        // idle_count++;
    }

}

static void fun_notify()
{
    return ;
}

static int scan_pool()
{
    int num_idel=0, num_busy=0;
    for(int i=0; i< MAXCLIENT; i++)
    {
        if(serverpool[i].pid == -1)
            continue;
        if(kill(serverpool[i].pid,0))
        {
            serverpool[i].pid = -1;
            continue;
        }
        if(serverpool[i].state == ST_IDEL)
            num_idel++;
        else if(serverpool[i].state == ST_BUSY)
            num_busy++;  
        else 
        {    
            fprintf(stderr,"scan_pool error");
            abort();
        }
    }
    idle_count = num_idel;
    busy_count = num_busy;
    return 0;
}
liuge
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
UNP（一）：网络编程角度下的TCP、UDP协议
sweetgum2012的专栏
04-18 9064
此博文是学习UNP（UNIX Network Programming）后的读书笔记，供以后自己翻阅回顾知识。 TCP、UDP概述 在前面《计算机网络与TCP/IP》栏目下已经介绍过一些关于TCP、UDP的相关知识TCP/IP(三)：传输层TCP与UDP，这里只是简单从UNIX网络编程的角度介绍TCP、UDP协议。我们都知道UDP 缺乏可靠性、无连接的，面向数据报 的协议，如果想确保数据报到达目的地
UNP学习笔记讲义
04-29
Linux 网络编程修炼指南内功心法，这个是博主https://blog.csdn.net/q1007729991/article/details/69101159，大家可以互相学习
UNP TCP连接管理
博客
07-28 559
ARQ和重传通信媒介可能会丢失或改变被传递的消息，比如一个有损信道内传输比特流，可能会导致比特被删除或者修改，造成通信的不可靠性。目前有两种方式可以解决上述问题： 差错校正码：通过添加一些冗余的比特，使得即使某些比特被毁，真实的信息也可以被恢复过来。 ARQ（自动重传请求）：通过重新传输消息，直到信息最终被正确接收。 ARQ需要重发分组直到它被正确接受，判断机制为：（1）接受方是否已收到分组（2）
UNP总结 Chapter 2 传输层：TCP、UDP和SCTP
weixin_33755554的博客
08-11 140
注，总结中暂时忽略SCTP 1.总图 虽然称为“TCP/IP”协议族，但是本协议族还有许多其他成员，见下图 2.用户数据包协议(UDP) UDP 套接字写入一个消息，该消息接着被封装（encapsulating）进一个UDP数据报，该UDP数据报又进而被封装成一个IP数据报，然后发送到目的地。UDP不保证UDP数据报到达其最终目的地，不保证各个数据报的先后顺序跨网络保持不变，也不保证每...
Go SIGINT（终端中断信号）和 SIGTERM（终止信号）signal.Notify 通知信号函数
wgchen
06-02 1137
Go SIGINT（终端中断信号）和 SIGTERM（终止信号）signal.Notify 通知信号函数
c语言notify头文件,关于 signal.Notify 使用带缓存的 channel
weixin_42717586的博客
05-23 374
```gopackage mainimport ("fmt""os""os/signal")func main() {// Set up channel on which to send signal notifications.// We must use a buffered channel or risk missing the signal// if we're not ready to ...
unp 64bit CentOS编译
12-08
书中涵盖了大量的网络编程概念，包括套接字API、TCP/IP协议栈以及多线程编程等内容。`unp.h`是该书中的一个头文件，它提供了方便的函数定义和宏，帮助读者更好地理解和实现书中的示例代码。而`config.h`通常是用于...
UNP源码 STEVEN
05-23
全书不但介绍了基本编程内容，还涵盖了与套接字编程相关的高级主题，对于客户/服务器程序的各种设计方法也作了完整的探讨，最后还深入分析了流这种设备驱动机制。 　本书内容详尽且具权威性，几乎每章都提供精选的...
unp library
03-27
unp library and code,unp library and code,unp library and code,unp library and code,unp library and code,c
unp unix网络编程
04-06
《unp unix网络编程》是关于Unix系统下网络编程的经典之作，主要涵盖了网络通信的各种基础知识、原理和技术。这本书深入解析了TCP/IP协议栈的工作机制，提供了丰富的实例代码，旨在帮助开发者理解和实现网络应用。...
TCP与UDP的区别 用途 例子
03-18
NULL 博文链接：https://javapub.iteye.com/blog/681138
linux系统编程笔记——网络编程4 TCP
qq_44807796的博客
02-24 136
SOCKET编程 TCP 关于TCP更多细节请看 TCP 的那些事儿（上） TCP 的那些事儿（下） 步骤 Client 获取SOCKET 给SOCKET取得地址 发送连接 收/发消息 关闭 Server 获取SOCKET 给SOCKET取得地址 将SOCKET置为监听模式 接受连接 收/发消息 关闭 普通多进程版 #ifndef PROTO_H__ #define PROTO_H__ #include <stdint.h> #define NAMEMAX 512-8-8//(UDP推荐
Linux应用开发之进程与多任务(parallel)编程
铁路十六宿舍的博客
03-29 1153
本篇文章详尽的介绍了在Linux环境下开发多任务应用需要的相关技术知识，并针对关键技术点为读者提供了带有详尽中文注释的示例，能够很好的帮助嵌入式工程师上手Linux环境程序的开发工作。
golang 中 signal 包的 Notify 函数用法介绍
热门推荐
chuanglan的专栏
06-20 1万+
函数声明为： func Notify(c chan&lt;- os.Signal, sig ...os.Signal) 官方描述： Notify函数让signal包将输入信号转发到c。如果没有列出要传递的信号，会将所有输入信号传递到c；否则只传递列出的输入信号。 signal包不会为了向c发送信息而阻塞（就是说如果发送时c阻塞了，signal包会直接放弃）：调用者应该保证c有足够的缓存...
erlang对port子进程退出的处理
erlang非业余研究
12-08 206
erlang通过port来spawn外部程序 重定向外部程序的stdin, stdout到一对pipe行通信的,利用poll来检测外部程序的读写事件。但是如果外部程序退出的话，erts如何知道并且加以处理的呢？ erts运行的时候会初始化smp_sig_notify,开启一个信号处理线程，在这个线程里面做具体的信号处理。 static void init_smp_sig_notify...
静态进程池
weixin_34315189的博客
08-19 121
2019独角兽企业重金招聘Python工程师标准>>> ...
流式套接字
weixin_33736649的博客
08-18 125
2019独角兽企业重金招聘Python工程师标准>>> ...
深入理解TCP通信
我的梦
10-25 1498
这大概是自己博客上面第三次写TCP通信demo了，总是写同样的内容也不太好啊，不过每一次都比前一次进步一点。这次主要使用了VIM编辑工具、gdb调试、wireshirk、netstat查看网络状态。 参考《C++服务器视频教程》、《Unix网络编程》 一、VIM常用命令 vim server.cpp #打开一个文件 :w 写入文件 :wq 保存并退出 :q! 不保存退出 显示行号 ...
UNP卷一学习笔记：TCP状态
代码面包
02-29 450
搞linux后台开发，必须掌握Stevens的著作《UNIX网络编程》里提及的大量知识点，所以我特意从网上购买了一套（O(∩_∩)O）。 面对厚厚的卷一，不实践，不记笔记，我觉得很难有所提升，故我决定将自己看书时候觉得重要的知识点和一些总结记录下来。 今天的笔记是关于TCP状态的。 TCP状态变迁主要发生在三次握手或四次挥手的时候，而且在此期间客户端client和服务器server的TCP状
UNIX网络编程的unp.h
最新发布
07-27
unp.h是该书中提供的一个头文件，它包含了一些与网络编程相关的函数、结构体和常量的声明。这个头文件提供了一些方便的宏定义和函数原型，可以帮助开发者更方便地进行网络编程。 unp.h头文件中包含了很多内容，比如...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值