网络通信（下）

最新推荐文章于 2024-09-14 17:25:56 发布
最新推荐文章于 2024-09-14 17:25:56 发布
阅读量152 收藏
点赞数
分类专栏： Linux环境C语言编程 文章标签： tcp/ip udp http 网络通信 网络协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/STX19980909/article/details/120399765
版权

3.基于并发的TCP客户机/服务器模型
1)TCP协议的基本特征
A.面向连接：参与通信的双发在正式通信之前需要先建立连接，以形成一条虚拟电路，所有的后续通信都在这条虚电路上完成。类似于电话通信业务。正式通话之前要先拨号，拨通了才能讲话。拨号的过程就是一个建立连接的过程。
三次握手：
    客户机                                                  服务器
发起连接请求 --------SYN(n)--------> 被动侦听
   等待应答     <-ACK(n+1)+SYN(m)- 可以接受
   反向确认     ------ACK(m+1)------> 连接成功

一旦三路握手完成，客户机和服务器的网络协议栈中就会保存有关连接的信息，此后的通信内容全部基于此连接实现数据传输。通信过程中任何原因导致的连接中断，都无法再继续通信，除非重新建立连接。
B.可靠传输：超时重传。每次发送一个数据包，对方都需要在一个给定的时间窗口内予以应答，如果超过时间没有收到对方的应答，发送方就会重发该数据包，只有重试过足够多的次数依然失败才会最终放弃。
C.保证顺序：发送端为每一个数据包编制序列号，接收端会根据序列号对所接收到的数据包进行重排，避免重复和乱序。
D.流量控制：协议栈底层在从另一端接收数据时，会不断告知对方它能够接收多少字节的数据，即所谓通告窗口。任何时候，这个窗口都反映了接收缓冲区可用空间的大小，从而确保不会因为发送方发送数据过快或过慢导致接收缓冲区出现上溢出或下溢出。
E.流式传输：以字节流形式传输数据，数据包在传输过程中没有记录边界。应用程序需要根据自己的规则来划分出数据包的记录边界。
a)定长记录
b)不定长记录加分隔符
c)定长长度加不定长记录
F.全双工：在给定的连接上，应用程序在任何时候都既可以发送数据也可以接收数据。因此TCP必须跟踪每个方向上数据流的状态信息，如序列号和通告窗口大小等。

2)TCP连接的生命周期
被动打开：通过侦听套接字感知其它主机发起的连接请求。
三路握手：TCP连接的建立过程。
| TCP包头 | TCP包体 |
包头部分总共20字节，含有6个标志位：SYN/ACK/FIN/RST/...，发送序列号和应答序列号...
数据传输：超时重传、流量控制、面向字节流、全双工

四次挥手：
  客户机                                            服务器
主动关闭 ---------FIN(n)-------> 被动关闭
等待应答 <-----ACK(n+1)------   关闭应答
确定关闭 <--------FIN(m)-------  已经关闭
关闭应答 ------ACK(m+1)----->  等待应答

3)常用函数
在指定套接字上启动对连接请求的侦听，即将该套接字置为被动模式，因为套接字都缺省为主动模式。
int listen(int sockfd, int backlog);
成功返回0，失败返回-1。
sockfd - 套接字描述符
backlog - 未决连接请求队列的最大长度
在指定的侦听套接字上等待并接受连接请求
int accept(int sockfd, struct sockaddr* addr,size_t* addrlen);
成功返回连接套接字描述符用于后续通信，失败返回-1。
sockfd - 侦听套接字描述符
addr - 输出连接请求发起者的地址信息
addrlen - 输入输出连接请求发起者地址信息的字节数
该函数由TCP服务器调用，返回排在已决连接队列首部的连接套接字对象的描述符，若已决连接队列为空，该函数会阻塞。
                                                                                                                                                                        ^^^^^^^^
非并发的TCP服务器
创建套接字(socket)
绑定地址(bind)
启动侦听(listen)
等待连接(accept)<--+
接收请求(read)<-+   |
业务处理(...)          |    |
发送响应(write)--+--+

并发的TCP服务器
创建套接字(socket)
绑定地址(bind)
启动侦听(listen)
等待连接(accept)<---+
                                    |
产生客户子进程(fork)-+
    接收请求(read)<-+
    业务处理(...)          |
    发送响应(write)--+

接收数据
ssize_t recv(int sockfd, void* buf, size_t len, int flags);
返回0表示客户机或服务器已关闭，失败返回-1
flags - 接收标志，取0等价于read
    MSG_DONTWAIT: 非阻塞接收。对于阻塞模式，当接收缓冲区为空时，该函数会阻塞，直到接收缓冲区不空为止。如果使用了此标志位，当接收缓冲区为空时，该函数会返回-1，并置errno为EAGAIN或EWOULDBLOCK。
    MSG_OOB: 接收带外数据。
    MSG_PEEK: 瞄一眼数据，只将接收缓冲区中的数据复制到buf缓冲区中，但并不将其从接收缓冲区中删除。
    MSG_WAITALL: 接收到所有期望接收的数据才返回，如果接收缓冲区中的数据不到 len 个字节，该函数会阻塞，直到可接收到len个字节为止。

发送数据
ssize_t send(int sockfd, const void* buf, size_t len, int flags);
flags - 接收标志，取0等价于write
     MSG_DONTWAIT: 非阻塞发送。对于阻塞模式，当发送缓冲区的空余空间不足以容纳期望发送的字节数时，该函数会阻塞，直到发送缓冲区的空余空间足以容纳期望发送的字节数为止。如果使用了此标志位，能发送多少字节就发送多少字节，不会阻塞，甚至可能返回0表示发送缓冲区满，无法发送数据。
     MSG_OOB: 发送带外数据。
     MSG_DONTROUT: 不查路由表，直接在本地网中寻找目的主机。
代码：tcpsvr.c、tcpcli.c

/* tcpsvr.c */
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <signal.h>
#include <wait.h>
#include <errno.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
void sigchld(int signum) {
    for (;;) {
        pid_t pid = waitpid(-1, NULL, WNOHANG);
        if (pid == -1) {
            if (errno != ECHILD) {
                perror("waitpid");
                exit(-1);
            }
            printf("服务器：全部子进程都已退出\n");
            break;
        }
        if (pid)
            printf("服务器：发现%d子进程退出\n", pid);
        else {
            printf("服务器：暂时没有子进程退出\n");
            break;
        }
    }
}
int client(int connfd) {
    for (;;) {
        printf("%d：接收请求\n", getpid());
        char buf[1024];
        ssize_t rb = recv(connfd, buf, sizeof(buf), 0);
        if (rb == -1) {
            perror("recv");
            return -1;
        }
        if (rb == 0) {
            printf("%d：客户机已关闭\n", getpid());
            break;
        }
        printf("%d：发送响应\n", getpid());
        if (send(connfd, buf, rb, 0) == -1) {
            perror("send");
            return -1;
        }
    }
    return 0;
}
int main(int argc, char* argv[]) {
    if (argc < 2) {
        fprintf(stderr, "用法：%s <端口号>\n", argv[0]);
        return -1;
    }
    if (signal(SIGCHLD, sigchld) == SIG_ERR) {
        perror("signal");
        return -1;
    }
    printf("服务器：创建网络套接字\n");
    int sockfd = socket(PF_INET, SOCK_STREAM, 0);
    if (sockfd == -1) {
        perror("socket");
        return -1;
    }
    printf("服务器：准备地址并绑定\n");
    struct sockaddr_in addr;
    addr.sin_family = AF_INET;
    addr.sin_port = htons(atoi(argv[1]));
    addr.sin_addr.s_addr = INADDR_ANY;
    if (bind(sockfd, (struct sockaddr*)&addr, sizeof(addr)) == -1) {
        perror("bind");
        return -1;
    }
    printf("服务器：侦听套接字\n");
    if (listen(sockfd, 1024) == -1) {
        perror("listen");
        return -1;
    }
    for (;;) {
        printf("服务器：等待连接\n");
        struct sockaddr_in addrcli = {};
        socklen_t addrlen = sizeof(addrcli);
        int connfd = accept(sockfd, (struct sockaddr*)&addrcli, &addrlen);
        if (connfd == -1) {
            perror("accept");
            return -1;
        }
        printf("服务器：客户机%s:%u\n", inet_ntoa(addrcli.sin_addr), 
 ntohs(addrcli.sin_port));
        pid_t pid = fork();
        if (pid == -1) {
            perror("fork");
            return -1;
        }
        if (pid == 0) {
            if (close(sockfd) == -1) {
                perror("close");
                return -1;
            }
            if (client(connfd) == -1)
                return -1;
            if (close(connfd) == -1) {
                perror("close");
                return -1;
            }
            printf("%d：完成\n", getpid());
            return 0;
        }
        if (close(connfd) == -1) {
            perror("close");
            return -1;
        }
    }
    return 0;
}


/* tcpcli.c */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <errno.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
int main(int argc, char* argv[]) {
    if (argc < 3) {
        fprintf(stderr, "用法：%s <IP地址> <端口号>\n", argv[0]);
        return -1;
    }
    printf("客户机：创建网络套接字\n");
    int sockfd = socket(PF_INET, SOCK_STREAM, 0);
    if (sockfd == -1) {
        perror("socket");
        return -1;
    }
    printf("客户机：准备地址并连接\n");
    struct sockaddr_in addr;
    addr.sin_family = AF_INET;
    addr.sin_port = htons(atoi(argv[2]));
    addr.sin_addr.s_addr = inet_addr(argv[1]);
    if (connect(sockfd, (struct sockaddr*)&addr, sizeof(addr)) == -1) {
        perror("connect");
        return -1;
    }
    for (;;) {
        printf("> ");
        char buf[1024];
        fgets(buf, sizeof(buf) / sizeof(buf[0]), stdin);
        if (!strcmp(buf, "!\n"))
            break;
        printf("客户机：发送请求\n");
        if (send(sockfd, buf, strlen(buf) * sizeof(buf[0]), 0) == -1) {
            perror("send");
            return -1;
        }
        printf("客户机：接收响应\n");
        ssize_t rb = recv(sockfd, buf, sizeof(buf) - sizeof(buf[0]), 0);
        if (rb == 0) {
            printf("客户机：服务器已关闭\n");
            break;
        }
        buf[rb / sizeof(buf[0])] = '\0';
        printf("< %s", buf);
    }
    printf("客户机：关闭套接字\n");
    if (close(sockfd) == -1) {
        perror("close");
        return -1;
    }
    printf("完成\n");
    return 0;
}

4.基于迭代的UDP客户机/服务器模型
1)UDP协议的基本特征
A.面向无连接：参与通信的主机之间不需要专门建立和维护逻辑的连接通道。一个UDP套接字可以和任意其它UDP套接字通信，而不必受连接的限制。
B.不可靠传输：没有超时重传机制。可能导致数据丢失。
C.不保证顺序：没有序列号，也不进行序列重组。可能产生数据包重复和乱序。
D.无流量控制：没有通告窗口，通信参与者完全不知道对方的接受能力。可能造成数据溢出。
E.记录式传输：以消息报文的形式传输数据，数据包在传输过程中有记录边界。应用程序无需划分数据包边界。
F.全双工
通过在可靠性方面的部分牺牲换取高速度，在子网以及局域网内部可以不经过服务器点对点通信，还有广播机制。
例如：QQ，微信，在线电影

2)常用函数
ssize_t sendto(int sockfd, const void* buf, size_t len, int flags, const struct sockaddr* dest_addr,socklen_t addrlen);
dest_addr - 数据包接收者地址结构
addrlen - 数据包接收者地址结构字节数
ssize_t recvfrom(int sockfd, void* buf, size_t len, int flags, struct sockaddr* src_addr, socklen_t* addrlen);
src_addr - 输出数据包发送者地址结构
addrlen - 输出数据包发送者地址结构字节数
代码：udpsvr.c、udpcli.c

/* udpsvr.c */
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
int main(int argc, char* argv[]) {
    if (argc < 2) {
        fprintf(stderr, "用法：%s <端口号>\n", argv[0]);
        return -1;
    }
    printf("服务器：创建网络套接字\n");
    int sockfd = socket(PF_INET, SOCK_DGRAM, 0);
    if (sockfd == -1) {
        perror("socket");
        return -1;
    }
    printf("服务器：准备地址并绑定\n");
    struct sockaddr_in addr;
    addr.sin_family = AF_INET;
    addr.sin_port = htons(atoi(argv[1]));
    addr.sin_addr.s_addr = INADDR_ANY;
    if (bind(sockfd, (struct sockaddr*)&addr, sizeof(addr)) == -1) {
        perror("bind");
        return -1;
    }
    for (;;) {
        printf("服务器：接收请求\n");
        char buf[1024];
        struct sockaddr_in addrcli = {};
        socklen_t addrlen = sizeof(addrcli);
        ssize_t rb = recvfrom(sockfd, buf, sizeof(buf), 0, (struct sockaddr*)&addrcli, &addrlen);
        if (rb == -1) {
            perror("recvfrom");
            return -1;
        }
        printf("服务器：向%s:%u发送响应\n", inet_ntoa(addrcli.sin_addr), ntohs(addrcli.sin_port));
        if (sendto(sockfd, buf, rb, 0, (struct sockaddr*)&addrcli, addrlen) == -1) {
            perror("sendto");
            return -1;
        }
    }
    return 0;
}


/* udpcli.c */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
int main(int argc, char* argv[]) {
    if (argc < 3) {
        fprintf(stderr, "用法：%s <IP地址> <端口号>\n", argv[0]);
        return -1;
    }
    printf("客户机：创建网络套接字\n");
    int sockfd = socket(PF_INET, SOCK_DGRAM, 0);
    if (sockfd == -1) {
        perror("socket");
        return -1;
    }
    printf("客户机：准备地址\n");
    struct sockaddr_in addr;
    addr.sin_family = AF_INET;
    addr.sin_port = htons(atoi(argv[2]));
    addr.sin_addr.s_addr = inet_addr(argv[1]);
    for (;;) {
        printf("> ");
        char buf[1024];
        fgets(buf, sizeof(buf) / sizeof(buf[0]), stdin);
        if (!strcmp(buf, "!\n"))
            break;
        printf("客户机：向%s:%u发送请求\n", inet_ntoa(addr.sin_addr), ntohs(addr.sin_port));
        if (sendto(sockfd, buf, strlen(buf) * sizeof(buf[0]), 0, (struct sockaddr*)&addr, sizeof(addr)) == -1) {
            perror("sendto");
            return -1;
        }
        printf("客户机：接收响应\n");
        ssize_t rb = recv(sockfd, buf, sizeof(buf) - sizeof(buf[0]), 0);
        if (rb == -1) {
            perror("recv");
            return -1;
        }
        buf[rb / sizeof(buf[0])] = '\0';
        printf("< %s", buf);
    }
    printf("客户机：关闭套接字\n");
    if (close(sockfd) == -1) {
        perror("close");
        return -1;
    }
    printf("客户机：完成\n");
    return 0;
}

针对UDP套接字的connect函数并不象TCP套接字的connect函数一样通过三路握手过程建立所谓的虚电路连接，而仅仅是将传递给该函数的对方地址结构缓存在套接字对象中。此后通过该套接字发送数据时，可以不使用sendto函数，而直接调用send函数，有关接收方的地址信息从套接字对象的地址缓存中提取即可。

5.域名解析（Domain Name Service, DNS）
字符串形式的域名
(www.tmooc.cn)
              |
              v
      DNS服务器 
              |
              v
整数形式的IP地址
(202.141.55.23)-->套接字编程
根据主机域名获取信息
#include <netdb.h>
struct hostent* gethostbyname(const char* name);
成功返回主机信息条目指针，失败返回NULL。
name - 主机域名(字符串)
hostent
    h_name -> xxx\0 - 主机官方名
    h_aliases -> * * * ... NULL - 别名表
    h_addrtype -> AF_INET - 地址类型
    h_length -> 4 - 地址字节数
    h_addr_list -> * * * ... NULL - 地址表
                             |
                             v
                   struct in_addr
                       s_addr - 网络字节序32位无符号整数
代码：dns.c

/* dns.c */
#include <stdio.h>
#include <stdlib.h>
#include <arpa/inet.h>
#include <netdb.h>
int main(int argc, char* argv[]) {
    if (argc < 2) {
        fprintf(stderr, "用法：%s <主机域名>\n", argv[0]);
        return -1;
    }
    struct hostent* host = gethostbyname(argv[1]);
    if (!host) {
        perror("gethostbyname");
        return -1;
    }
    if (host->h_addrtype != AF_INET) {
        fprintf(stderr, "非IPv4地址！\n");
        return -1;
    }
    printf("主机官方名：\n");
    printf("\t%s\n", host->h_name);
    printf("主机别名表：\n");
    for (char** pp = host->h_aliases; *pp; ++pp)
        printf("\t%s\n", *pp);
    printf("主机地址表：\n");
    for (struct in_addr** pp = (struct in_addr**)host->h_addr_list; *pp; ++pp)
        printf("\t%s\n", inet_ntoa(**pp));
    return 0;
}

6.获取HTTP服务器上的页面内容
HTTP, Hyper Text Transform Protocol，超文本传输协议
www服务器通过http协议提供页面服务。
HTTP - 应用层协议：| HTTP包头 | HTTP包体 |
    |
 TCP - 传输层协议：| TCP包头 | HTTP包头 | HTTP包体 |
    |
   IP - 网络层协议：...
    |
   ...
HTTP请求包头：
方法                资源路径                 协议及
   |        (URI，统一资源定位符)     其版本
   |                         |                             |
GET  /user/project/main.html  HTTP/1.1

   键         值（主机域名）
    |            |
Host: www.tmooc.cn\r\n
Accept: text/html\r\n
Connection: Keep-Alive\r\n
User-Agent: Mozilla/5.0\r\n
Referer: www.tmooc.cn\r\n
...
最后一行\r\n\r\n
代码：http.c

/* http.c */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
int main(int argc, char* argv[]) {
    // 解析命令行
    if (argc < 3) {
        fprintf(stderr, "用法：%s <主机IP地址> <主机域名> [<资源路径>]\n",
            argv[0]);
        return -1;
    }
    const char* ip = argv[1];
    const char* domain = argv[2];
    const char* path = argc < 4 ? "/" : argv[3];
    // 创建套接字
    int sockfd = socket(PF_INET, SOCK_STREAM, 0);
    if (sockfd == -1) {
        perror("socket");
        return -1;
    }
    // 服务器地址
    struct sockaddr_in addr;
    addr.sin_family = AF_INET;
    addr.sin_port = htons(80);
    if (!inet_aton(ip, &addr.sin_addr)) {
        perror("inet_aton");
        return -1;
    }
    // 连接服务器
    if (connect(sockfd, (struct sockaddr*)&addr, sizeof(addr)) == -1) {
        perror("connect");
        return -1;
    }
    // 格式化请求
    char request[1024];
    sprintf(request,
        "GET %s HTTP/1.0\r\n"
        "Host: %s\r\n"
        "Accept: */*\r\n"
        "Connection: Close\r\n"
        "User-Agent: Mozilla/5.0\r\n"
        "Referer: %s\r\n\r\n",
        path, domain, domain);
    printf("%s", request);
    // 发送请求
    if (send(sockfd, request, strlen(request) * sizeof(request[0]), 0) == -1) {
        perror("send");
        return -1;
    }
    // 接收响应
    for (;;) {
        char respond[1024] = {};
        ssize_t rlen = recv(sockfd, respond, sizeof(respond) - sizeof(respond[0]), 0);
        if (rlen == -1) {
            perror("recv");
            return -1;
        }
        if (!rlen)
            break;
        printf("%s", respond);
    }
    printf("\n");
    close(sockfd);
    return 0;
}

暗里い着迷
关注
专栏目录
socket之无连接编程（UDP）
github_33736971的博客
06-01 1696
UDP是无连接不可靠的数据报协议，UDP的常见应用程序是DNS（域名解析系统），NFS（网络文件系统），SNMP（简单网络管理协议）；在使用UDP的客户服务器程序中，客户不与服务器建立连接，而是只管使用sendto函数给服务器发送数据报，其中必须指出目标服务器的地址；同样，服务器不接受来自客户的连接，而只是用recvfrom等待指定用户的数据到达，recvfrom将与所接收的数据报一起返回客户的协议
网络通信与协议理解
王聚涛的专栏
06-04 2635
一、通信协议是什么？ 1、网络通信协议，是一种网络通信语言，为了连接不同操作系统和硬件体系结构提供通信支持。目的是实现通讯双方（发送方和接收方）能正确无障碍的理解要通信的内容。好比一个广东人和一个山西人打招呼，同样说你好，用方言说的话双方都不懂，那么这时候大家就约定都是用普通话，那么广东人说话山西人懂，山西人说话广东人也能懂，这么就可以愉快的聊天了。同理，计算机之间也需要有一定的约定才能实现正确的发送和接收信息。 2、网络通信协议三要素，语义（表达的意思），语法（表达的形式，接收，格式），时序（事件发生
第14章 网络编程
yuanboshuai的博客
08-29 166
基于TCP协议的SOCKET通信 服务器代码 #include&lt;WinSock2.h&gt;//使用WinSocket库中的函数 #include&lt;stdio.h&gt;//使用C语言标准输入输出函数 #pragma comment(lib,"ws2_32.lib")//需要加上这个链接库不然WSAStartup报错 void main() { WORD wVersionReq...
基于TCPIP的网络编程（C++语言编程）
m0_54866636的博客
08-28 590
基于TCP/IP的通信基本上都是利用SOCKET套接字进行数据通讯，程序一般分为服务器端和用户端两部分。二、服务器套接字进行信息绑定（bind），并开始监听连接（listen）。二、与远程服务器进行连接（connect），如被接受则创建接收进程。三、接受来自用户端的连接请求（accept）。四、开始数据传输(send/receive)。五、关闭套接字（closesocket）。四、关闭套接字（closesocket）。一、创建服务器套接字（create）。一、创建客户套接字（create）。...
网络通信基本原理
随风浅入画
11-25 3910
网络通信基本原理
容器网络通信原理
m0_37732829的博客
04-14 1747
容器网络通信 多机器容器网络通信，如下图所示
网络通信原理及流程
ymj321的专栏
07-19 9489
网络通信原理 1.1 互联网的本质就是一系列的网络协议 一台硬设有了操作系统，然后装上软件你就可以正常使用了，然而你也只能自己使用像这样，每个人都拥有一台自己的机器，然而彼此孤立吗，如何能大家一起玩耍 其实两台计算机之间通信与两个人打电话之间通信的原理是一样的（中国有很多地区...
网络通信基础
xHai的博客
09-15 2116
网络通信一、网络通信基本概念二、网络编程要解决的问题三、通信要素四、OSI7层模型3.1数据链路层3.2网络层3.3 传输层五、TCP/IP协议5.1 历史背景5.2 特点 一、网络通信基本概念 网络就是用物理链路将各个孤立的主机连接在一起，组成数据链路，从而达到资源共享和通信的目的。 网络通信是通过网络将各个孤立的设备进行连接，通过信息交换实现人与人，人与计算机，计算机与计算机之间的通信。 网络通信中最重要的就是网络通信协议。 二、网络编程要解决的问题 网络编程要解决的2个问题： （1）如何准确定位网络上
C++网络通信
Gin_ger的博客
06-19 3638
一、TCP/IP协议 1、OSI参考模型： OSI参考模型的建立不仅创建了通信设备之间的物理通道，还规划了各层之间的功能，为标准化组合和生产厂家定制协议提供了基本原则。 OSI参考模型采用分层的划分原则，将网络中的数据传输划分为7层，每一层使用下层的服务，并向上层提供服务。 应用层（第7层）—— 表示层——会话层——传输层——网络层——数据链路层——物理层（第1层） 2.TCP/IP参考模型： TCP/IP通信协议采用了4层的层级结构，每一层都呼叫它的下一层所提供的网络来完成自己的需求，这4层分别为： 应用
Python中的网络通信
热门推荐
Ulrich蚊子Blog
01-22 2万+
概述 在我们平时生活工作中，常常会接触到网络通信的内容，不管你是普通的用户，还是通信行业内的开发人员，都无法避免与网络通信打交道。我在初步学习python的过程中，对python的网络通信问题做了总结，所以写下这篇文章作为记录，也希望能给其他初学者一些引导和启发。这篇文章的主要内容如下： 1. 在深入讲解之前，我们先介绍一些背景信息； 2. 介绍套
C#语言网络通信程序
11-22
一个简单而又实用的C#网络通信小例子，包含全部代码和笔记。
西门子工业网络通信指南下册(崔坚).pdf
08-20
西门子工业网络通信指南下册(崔坚).pdf
网络通信的过程
weixin_42065178的博客
05-09 4384
网络通讯的过程
网络通信学习笔记之 ———Socket网络通信
m0_62480610的博客
11-01 4882
简单介绍了基于TCP协议的Socket网络通信和基于UDP协议的Socket网路通信
车载以太网之SOME/IP
码农的历程
09-10 673
SOME/IP概述
如何搭建一个ip池用来做数据抓取用
最新发布
KookeeyLena4的博客
09-14 234
在当今的数据驱动时代，数据抓取成为了获取网络信息的重要手段。然而，频繁的数据抓取活动可能会触发网站的安全机制，导致IP被封禁。为了维持数据抓取的持续性和稳定性，构建一个有效的IP池变得至关重要。本文将详细介绍如何搭建一个用于数据抓取的IP池，以及相关的策略和最佳实践。
端口大全说明,HTTP,TCP,UDP常见端口对照表
云博客_资源宝分享
09-10 2007
端口大全说明,HTTP,TCP,UDP常见端口对照表
详解TCP的三次握手
m0_57330725的博客
09-09 1159
第一次握手**：客户端发送 SYN，表示想建立连接，并发送自己的序列号。第二次握手**：服务器发送 SYN + ACK，确认收到客户端请求，并发送自己的序列号和对客户端的确认号。第三次握手**：客户端发送 ACK，确认收到服务器的序列号，并对连接的建立做最终确认。这样，通过三次握手，TCP 连接才能可靠地建立，接下来才能进行数据传输。
SOME/IP通信协议在汽车业务具体示例
achirandliu的专栏
09-11 795
SOME/IP通信协议在汽车业务具体示例
网络通信流程详解：从客户端到服务端
"这篇博客主要介绍了网络通信的基本流程，适合初学者理解网络通信的基本概念。内容涵盖客户端与服务端架构、DNS服务器、交换机、路由器和网关的作用，以及DHCP的相关知识。" 网络通信是现代信息技术的重要组成部分...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

暗里い着迷

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值