socket之三次握手和四次挥手 wireshark解析

最新推荐文章于 2021-12-28 14:25:34 发布
最新推荐文章于 2021-12-28 14:25:34 发布
阅读量436 收藏
点赞数
分类专栏： linux网络编程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u014338577/article/details/52877683
版权

  先过滤抓包

sudo tcpdump -i eth0 "host 192.168.1.205 and host 192.168.1.201" -w socket

然后用wireshark打开抓到的socket包



server.c

#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <signal.h>
#include <sys/wait.h>

#include <stdlib.h>
#include <stdio.h>
#include <errno.h>
#include <string.h>

#define ERR_EXIT(m) \
        do \
        { \
                perror(m); \
                exit(EXIT_FAILURE); \
        } while(0)

ssize_t readn(int fd, void *buf, size_t count)
{
        size_t nleft = count;
        ssize_t nread;
        char *bufp = (char*)buf;

        while (nleft > 0)
        {
                if ((nread = read(fd, bufp, nleft)) < 0)
                {
                        if (errno == EINTR)
                                continue;
                        return -1;
                }
                else if (nread == 0)
                        return count - nleft;

                bufp += nread;
                nleft -= nread;
        }

        return count;
}

ssize_t writen(int fd, const void *buf, size_t count)
{
        size_t nleft = count;
        ssize_t nwritten;
        char *bufp = (char*)buf;

        while (nleft > 0)
        {
                if ((nwritten = write(fd, bufp, nleft)) < 0)
                {
                        if (errno == EINTR)
                                continue;
                        return -1;
                }
                else if (nwritten == 0)
                        continue;

                bufp += nwritten;
                nleft -= nwritten;
        }

        return count;
}

ssize_t recv_peek(int sockfd, void *buf, size_t len)
{
        while (1)
        {
                int ret = recv(sockfd, buf, len, MSG_PEEK);
                if (ret == -1 && errno == EINTR)
                        continue;
                return ret;
        }
}

ssize_t readline(int sockfd, void *buf, size_t maxline)
{
        int ret;
        int nread;
        char *bufp = buf;
        int nleft = maxline;
        while (1)
        {
                ret = recv_peek(sockfd, bufp, nleft);
                if (ret < 0)
                        return ret;
                else if (ret == 0)
                        return ret;

                nread = ret;
                int i;
                for (i=0; i<nread; i++)
                {
                        if (bufp[i] == '\n')
                        {
                                ret = readn(sockfd, bufp, i+1);
                                if (ret != i+1)
                                        exit(EXIT_FAILURE);

                                return ret;
                        }
                }

                if (nread > nleft)
                        exit(EXIT_FAILURE);

                nleft -= nread;
                ret = readn(sockfd, bufp, nread);
                if (ret != nread)
                        exit(EXIT_FAILURE);

                bufp += nread;
        }

        return -1;
}

void echo_srv(int conn)
{
        char recvbuf[1024];
        memset(recvbuf, 0, sizeof(recvbuf));
        int ret = readline(conn, recvbuf, 1024);
        if (ret == -1)
                ERR_EXIT("readline");
        if (ret == 0)
        {
                printf("client close\n");
                return;
        }

        fputs(recvbuf, stdout);
        writen(conn, recvbuf, strlen(recvbuf));

}


int main(void)
{

        int listenfd;
        if ((listenfd = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0)
                ERR_EXIT("socket");

        struct sockaddr_in servaddr;
        memset(&servaddr, 0, sizeof(servaddr));
        servaddr.sin_family = AF_INET;
        servaddr.sin_port = htons(8001);
        servaddr.sin_addr.s_addr = htonl(INADDR_ANY);

        int on = 1;
        if (setsockopt(listenfd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on)) < 0)
                ERR_EXIT("setsockopt");

        if (bind(listenfd, (struct sockaddr*)&servaddr, sizeof(servaddr)) < 0)
                ERR_EXIT("bind");

        if (listen(listenfd, SOMAXCONN) < 0)
                ERR_EXIT("listen");

        struct sockaddr_in peeraddr;
        socklen_t peerlen = sizeof(peeraddr);
        int conn;

        pid_t pid;
        if(1)
        {
                if ((conn = accept(listenfd, (struct sockaddr*)&peeraddr, &peerlen)) < 0)
                        ERR_EXIT("accept");

                printf("ip=%s port=%d\n", inet_ntoa(peeraddr.sin_addr), ntohs(peeraddr.sin_port));

                echo_srv(conn);
                close(conn);
                close(listenfd);
        }


        return 0;
}

client.c 

#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>

#include <stdlib.h>
#include <stdio.h>
#include <errno.h>
#include <string.h>

#define ERR_EXIT(m) \
        do \
        { \
                        perror(m); \
                        exit(EXIT_FAILURE); \
        } while(0)

ssize_t readn(int fd, void *buf, size_t count)
{
        size_t nleft = count;
        ssize_t nread;
        char *bufp = (char*)buf;

        while (nleft > 0)
        {
                if ((nread = read(fd, bufp, nleft)) < 0)
                {
                        if (errno == EINTR)
                                continue;
                        return -1;
                }
                else if (nread == 0)
                        return count - nleft;

                bufp += nread;
                nleft -= nread;
        }

        return count;
}

ssize_t writen(int fd, const void *buf, size_t count)
{
        size_t nleft = count;
        ssize_t nwritten;
        char *bufp = (char*)buf;

        while (nleft > 0)
        {
                if ((nwritten = write(fd, bufp, nleft)) < 0)
                {
                        if (errno == EINTR)
                                continue;
                        return -1;
                }
                else if (nwritten == 0)
                        continue;

                bufp += nwritten;
                nleft -= nwritten;
        }

        return count;
}

ssize_t recv_peek(int sockfd, void *buf, size_t len)
{
        while (1)
        {
                int ret = recv(sockfd, buf, len, MSG_PEEK);
                if (ret == -1 && errno == EINTR)
                        continue;
                return ret;
        }
}


ssize_t readline(int sockfd, void *buf, size_t maxline)
{
        int ret;
        int nread;
        char *bufp = buf;
        int nleft = maxline;
        while (1)
        {
                ret = recv_peek(sockfd, bufp, nleft);
                if (ret < 0)
                        return ret;
                else if (ret == 0)
                        return ret;

                nread = ret;
                int i;
                for (i=0; i<nread; i++)
                {
                        if (bufp[i] == '\n')
                        {
                                ret = readn(sockfd, bufp, i+1);
                                if (ret != i+1)
                                        exit(EXIT_FAILURE);

                                return ret;
                        }
                }

                if (nread > nleft)
                                exit(EXIT_FAILURE);

                nleft -= nread;
                ret = readn(sockfd, bufp, nread);
                if (ret != nread)
                        exit(EXIT_FAILURE);

                bufp += nread;
        }

        return -1;
}

void echo_cli(int sock)
{
        char sendbuf[1024] = {0};
        char recvbuf[1024] = {0};
        fd_set rfds;

        int retval;
        int fd_stdin = fileno(stdin);
        int maxfd;
        if (fd_stdin > sock)
                maxfd = fd_stdin;
        else
                maxfd = sock;
        FD_ZERO(&rfds);


        while(1)
        {
                FD_SET(fd_stdin, &rfds);
                FD_SET(sock, &rfds);

                retval = select(maxfd+1, &rfds, NULL, NULL, NULL);
                if (retval == -1)
                        perror("select()");
                else if (retval == 0)
                        continue;

                if(FD_ISSET(sock,&rfds))
                {
                        int ret = readline(sock, recvbuf, sizeof(recvbuf));
                        if (ret == -1)
                                ERR_EXIT("readline");
                        else if (ret == 0)
                        {
                                printf("server close\n");
                                break;
                        }

                        fputs(recvbuf, stdout);
                        memset(recvbuf, 0, sizeof(recvbuf));
                }

                if(FD_ISSET(fd_stdin,&rfds))
                {
                        if(fgets(sendbuf, sizeof(sendbuf), stdin) != NULL)
                        {
                                writen(sock, sendbuf, strlen(sendbuf));
                                memset(sendbuf, 0, sizeof(sendbuf));
                        }
                }
        }//while(1)

}

int main(int argc,char * argv[])
{
        if(argc != 2)
        {
                printf("usage ./echoclient ipaddress\n");
                return -1;
        }

        int sock;
        if ((sock = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0)
                ERR_EXIT("socket");

        struct sockaddr_in servaddr;
        memset(&servaddr, 0, sizeof(servaddr));
        servaddr.sin_family = AF_INET;
        servaddr.sin_port = htons(8001);
        servaddr.sin_addr.s_addr = inet_addr(argv[1]);

        if (connect(sock, (struct sockaddr*)&servaddr, sizeof(servaddr)) < 0)
                ERR_EXIT("connect");

        struct sockaddr_in localaddr;
        socklen_t addrlen = sizeof(localaddr);
        if (getsockname(sock, (struct sockaddr*)&localaddr, &addrlen) < 0)
                ERR_EXIT("getsockname");

        printf("ip=%s port=%d\n", inet_ntoa(localaddr.sin_addr), ntohs(localaddr.sin_port));


        echo_cli(sock);

        return 0;
}


注意四次挥手经常不能抓全，原因是对端已经退出了，导致ack包经常丢失。多次试验后总结发现的发现规律


形形色色的人
关注
专栏目录
TCP连接的建立与释放过程
ther123dd的博客
11-28 497
这里写自定义目录标题欢迎使用Markdown编辑器新的改变功能快捷键合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出导入 欢迎使用Markdown编辑器 你好！ 这是你第一次使用 Markdown编辑器 所展示的欢迎页。如果你想学习如何使用M..
Socket三次握手四次挥手
luoyoub的博客
09-03 5872
Socket 起源于 Unix，而Unix基本哲学之一就是一切皆文件，都可以用“打开open –&gt; 读写write/read –&gt; 关闭close”模式来操作。Socket就是该模式的一个实现，网络的Socket数据传输是一种特殊的I/O，Socket也是一种文件描述符 通信模型： s erver的生命周期大致如下： 创建socket。 绑定（bind）地址端口 监听网络...
socket中TCP的三次握手和四次挥手详解
ym & blog
02-26 711
socket中TCP的三次握手建立连接详解 我们知道tcp建立连接要进行“三次握手”，即交换三个分组。大致流程如下： 客户端向服务器发送一个SYN J 服务器向客户端响应一个SYN K，并对SYN J进行确认ACK J+1 客户端再想服务器发一个确认ACK K+1 只有就完了三次握手，但是这个三次握手发生在socket的那几个函数中呢？请看下图： 从图中可以看出，当客户端调用connect时...
TCP 三次握手 和 四次挥手
weixin_34406061的博客
06-26 3976
2019独角兽企业重金招聘Python工程师标准>>> ...
Socket 三次握手四次挥手
sjh_389510506的博客
03-07 416
梳理一下socket 相关老生常谈的知识点 三次握手四次挥手 先看几个概念 字段 含义 URG 紧急指针是否有效。为1，表示某一位需要被优先处理 ACK 确认号是否有效，一般置为1。 PSH 提示接收端应用程序立即从TCP缓冲区把数据读走。 RST 对方要求重新建立连接，复位。 SYN 请求建立连接，并在其序列号的字段进行序列号的初始值设定。建立连接，设置...
HTTP协议简介/数据包封装/三次握手/DNS解析
sunshine612的博客
04-28 3746
HTTP协议简介/数据包封装/三次握手/DNS解析1.浏览器背后的故事2.HTTP3.透过TCP/IP看HTTP4.数据包的封装过程5.传输层--TCP三次握手6.DNS域名解析DNS 域名解析协议的工作原理 递归式 迭代式7.HTTP事务处理过程实验---对于浏览器来说HTTP请求到底是什么样子 1.浏览器背后的故事 解释： 打给小红，由姓名的代号来记录， 小红就是域名，电话号就是IP地址，共同...
访问Web，tcp传输全过程（三次握手、请求、数据传输、四次挥手）
热门推荐
秋天的原野
12-07 2万+
从输入域名到最后呈现经历的过程： 域名解析 --> 发起TCP的3次握手 --> 建立TCP连接后发起http请求 --> 服务器响应http请求，浏览器得到html代码 --> 浏览器解析html代码，并请求html代码中的资源（如js、css、图片等） --> 浏览器对页面进行渲染呈现给用户 --> 四次挥手结束 1.域名解析 首先浏览器会解析 www.zipackage.c
TCP/IP协议是网络协议中的核心协议，含三次握手，四次分手
+W❤：bjmsb2019
09-18 3510
一、网络协议 国际标准化组织（International Standard Organization,ISO）公布了开放系统互连参考模型（OSI/RM）。OSI/RM是一种分层的体系结构，参考模型共有7层。 TCP/IP(Transmission Control Protocol/Internet Protocol)作为Internet的核心协议。它是个协议族，包含多种协议。 分层的基本想法是每一层都在它的下层提供的服务基础上提供更高级的增值服务，而最高层提供能运行分布式应用程序的服务。 发送请求
Android进程间通信之Socket使用与解析（TCP、UDP）
恬静释然的博客
12-18 1161
在使用Socket实现进程间通信前，先对网络协议相关知识进行简单回顾。
java 仿wireshark_wireshark抓包工具
weixin_35690449的博客
02-16 727
一、简介1、什么是wireshark百度：Wireshark(前称Ethereal)是一个网络封包分析软件。网络封包分析软件的功能是撷取网络封包，并尽可能显示出最为详细的网络封包资料。Wireshark使用WinPCAP作为接口，直接与网卡进行数据报文交换。在过去，网络封包分析软件是非常昂贵的，或是专门属于盈利用的软件。Ethereal的出现改变了这一切。在GNUGPL通用许可证的保障范围底下，使...
Socket的三次握手和4次挥手
blueheartstone的博客
05-12 169
socket通信，三次握手，四次挥手
aa1384656303的博客
12-25 114
服务端套接字函数 　　s.bind() 绑定(主机,端口号)到套接字　　s.listen() 开始TCP监听 　　　　半连接池就是半连接存放位置 　　　　可以设置最大半连接数来防止洪水攻击　　s.accept() 被动接受TCP客户的连接,(阻塞式)等待连接的到来 客户端套接字函数 　　s.connect() 主动初始化TCP服务器连接　　s.connect_ex()...
socket的TCP的三次握手/四次挥手
weixin_30378311的博客
08-10 83
第一次握手：客户端尝试连接服务器，向服务器发送syn包（同步序列编号Synchronize Sequence Numbers），syn=j，客户端进入SYN_SEND状态等待服务器确认 第二次握手：服务器接收客户端syn包并确认（ack=j+1），同时向客户端发送一个SYN包（syn=k），即SYN+ACK包，此时服务器进入SYN_RECV状态 第三次握手：第三次握手：客户端收到服务器的S...
socket的TCP的三次握手&&四次挥手
a787188834的专栏
12-23 232
socket中的TCP_IP的三次握手与四次挥手： （一）socket中TCP的三次握手建立连接： （1）tcp建立连接要进行“三次握手”，即交换三个分组。大致流程如下： 客户端向服务器发送一个SYN J 服务器向客户端响应一个SYN K，并对SYN J进行确认ACK J+1 客户端再想服务器发一个确认ACK K+1 只有就完了三次握手，但是这个三次握手发生在s
socket通讯与连接（三次握手四次挥手）
zpflwy1314的博客
04-02 599
套接字（socket）概念 套接字（socket）是通信的基石，是支持TCP/IP协议的网络通信的基本操作单元。它是网络通信过程中端点的抽象表示，包含进行网络通信必须的五种信息：连接使用的协议，本地主机的IP地址，本地进程的协议端口，远地主机的IP地址，远地进程的协议端口。 建立socket连接 建立Socket连接至少需要一对套接字，其中一个运行于客户端，称为Clie...
网络编程4-socket通信三次握手四次挥手
5big的博客
12-10 455
0.一些概念socket是”打开—读/写—关闭”模式的实现，以使用TCP协议通讯的socket为例，其交互流程大概是这样子的 过程介绍 服务器端先初始化Socket，然后与端口绑定(bind)，对端口进行监听(listen)，调用accept()阻塞，等待客户端连接。在这时如果有个客户端初始化一个Socket，然后连接服务器(connect)，如果连接成功，这时客户端与服务器端的连接就建立了
SOCKET套接字（二） 三次握手-四次挥手
猫爪子敲代码的博客
12-02 565
三次握手和四次挥手是TCP的连接过程和断开过程 三次握手 如下图为三次握手建立连接 可以这么理解： 第一条客户端向服务端发起建立请求； 第二条服务器告诉客户端，OK你已经连上我了，我可以连接你么？（功能1：确认收到了你的请求，功能2：发送连接请求） 第三条客户端告诉服务端，OK你向我发起的请求搞定~ 整个流程看下来像是一个确认机制，可以确认前两条消息都互相收到并确认过了，用这种机制来默认已经完成...
计算机网络③-④：TCP的socket编程（内核维护两个队列，API）、socket三次握手、socket四次挥手
weixin_44478659的博客
10-29 346
TCP的socket编程： TCP的socket就是一个文件流。 服务端和客户端初始化 socket ，得到文件描述符； 服务端调用 bind ，将绑定在 IP 地址和端口; 服务端调用 listen，进行监听； 服务端调用 accept ，等待客户端连接； 客户端调用 connect ，向服务器端的地址和端口发起连接请求； 服务端 accept 返回用于传输的 socket 的文件描述符； 客户端调用 write 写入数据；服务端调用 read 读取数据； 客户端断开连接时，会调用 close ，那么
socket网络编程以及三次握手四次挥手
Mark66890620
12-28 1179
我们深谙信息交流的价值，那网络中进程之间如何通信，如我们每天打开浏览器浏览网页时，浏览器的进程怎么与web服务器通信的？当你用QQ聊天时，QQ进程怎么与服务器或你好友所在的QQ进程通信？这些都得靠socket？那什么是socket？socket的类型有哪些？还有socket的基本函数，这些都是本文想介绍的。本文的主要内容如下： 1、网络中进程之间如何通信？ 2、Socket是什么？ 3、socket的基本操作 3.1、socket()函数 3.2、bind
TCP三次握手与四次挥手过程详解
在TCP中，为了确保两个通信端点能够准确地建立和终止连接，分别采用了三次握手和四次挥手的过程。 ### TCP三次握手 三次握手的主要目的是为了防止已失效的连接请求报文突然又传到了服务端，因而产生错误。以下是三...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值