精华内容
下载资源
问答
  • windows下模拟客户端和服务端通信TCP/UDP
  • 使用C(或C++)等语言编写网络通信模拟程序,它由 client 和 server 两部分组成, client 和 server 之间的通信基于 TCP 或者UDP协议,要求能够实现客户和服务器端的交互对话
  • TCP/UDP协议模拟软件

    2015-09-16 11:10:45
    该工具包含TCP Server、TCP Client、UDP功能。
  • c# UDP模拟TCP实现可靠传输

    千次阅读 2014-01-21 12:00:59
    在网上搜集的使用UDP模拟实现TCP的可靠传输 using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading; using System.Net; using System.Net.Sockets; using...

    在网上搜集的使用UDP模拟实现TCP的可靠传输

    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    using System.Threading;
    using System.Net;
    using System.Net.Sockets;
    using System.IO;
     
    namespace Transfer
    {
        /********************************************************************************
        Secured UDP Transfer Class -- UDP安全传输类
        采用TCP滑动窗口原理在应用层解决UDP协议传输的丢包,乱序等问题,实现UDP可靠传输;
        要求传入的UdpClient实例为已连接的实例,即调用此类的方法前请先执行初始化实例并连接;
        发送接收的数据类采用Stream,可应用到其子类FileStream,MemoryStream等
        ********************************************************************************/
        public class SUdpTransfer
        {
            private const int defaultPacketSize = 513, defaultGroupSize = 7;//默认UDP包数据内容大小、组(窗口)大小
            private const int confirmTimeOut = 1000;//确认超时时间
            private const int maxResendCount = 4;//最大重发次数(超出则认为连接断开)
            private const int receiveTimeOut = 4000;//接收超时时间
     
            private UdpClient client;//已连接的UdpClient实例
            private AutoResetEvent confirmEvent = new AutoResetEvent(false);//等待确认回复用的事件
            private int groupSeq;//当前传送的组序号
            private Thread thListen;//发送端确认包接收线程
            private bool error;//出错标志
     
            public SUdpTransfer(UdpClient client)
            {
                this.client = client;
            }
     
            //数据发送函数,返回值0:发送成功,-1:发送失败
            public int Send(Stream stream)
            {
                return Send(stream, defaultPacketSize, defaultGroupSize);
            }
     
            public int Send(Stream stream, int packetSize, int groupSize)
            {
                error = false;
     
                int dataSize = packetSize - 1;
     
                int i, read, readSum;
                byte flag = 0;//UDP包中的标志字节,包含组序号,包序号(即组内序号),发送结束标志
                int resendCount = 0;//重发次数标记
     
                try
                {
                    //启动确认包接收线程
                    thListen = new Thread(new ThreadStart(Listen));
                    thListen.IsBackground = true;
                    thListen.Start();
     
                    groupSeq = 0;
                    stream.Seek(0, SeekOrigin.Begin);
                    confirmEvent.Reset();
                    while (true)
                    {
                        if (error)
                            return -1;
     
                        readSum = 0;//记录读取字节数以便重发时Stream的回退
     
                        for (i = 0; i < groupSize; i++)
                        {
                            flag = (byte)(((byte)groupSeq) << 4 | (((byte)i) << 1));
                            byte[] buffer = new byte[packetSize];
                            read = stream.Read(buffer, 0, dataSize);
     
                            readSum += read;
     
                            if (read == dataSize)
                            {
                                if (stream.Position == stream.Length)//已经读完
                                {
                                    flag |= 0x01;//结束标记位置1
                                    buffer[read] = flag;//数据包标志字节放于每个包的最后
                                    client.Send(buffer, read + 1);
     
                                    break;
                                }
     
                                buffer[read] = flag;
                                client.Send(buffer, read + 1);
                            }
                            else if (read > 0)//已经读完
                            {
                                flag |= 0x01;//结束标记位置1
                                buffer[read] = flag;//数据包标志字节放于每个包的最后
                                client.Send(buffer, read + 1);
     
                                break;
                            }
                            else
                            {
                                break;
                            }
                        }
     
                        if (error)
                            return -1;
     
                        if (confirmEvent.WaitOne(confirmTimeOut))//收到确认
                        {
                            if ((int)(flag & 0x01) == 1)//发送完毕
                                break;
     
                            groupSeq = (groupSeq + 1) % 16;
                            resendCount = 0;
                        }
                        else//未收到确认
                        {
                            if (resendCount >= maxResendCount)//超出最大重发次数
                            {
                                thListen.Abort();
                                return -1;
                            }
     
                            //重发
                            stream.Seek(-1 * readSum, SeekOrigin.Current);
                            resendCount++;
                        }
                    }
     
                    //发送完毕,关闭确认包接收线程
                    thListen.Abort();
                }
                catch//异常
                {
                    thListen.Abort();
                    return -1;
                }
     
                return 0;
            }
     
            //确认包接收线程函数
            private void Listen()
            {
                IPEndPoint ipep = new IPEndPoint(IPAddress.Any, 0);
                try
                {
                    while (true)
                    {
                        byte[] confirm = client.Receive(ref ipep);
     
                        if ((int)confirm[0] == groupSeq)//收到确认
                        {
                            confirmEvent.Set();//激活接收确认事件
                        }
                        else if (confirm[0] == 0xFF)//传输中断命令
                        {
                            error = true;
                            break;
                        }
                    }
                }
                catch//异常
                {
                    error = true;
                }
            }
     
            //数据接收函数,返回值0:接收成功,-1:接收失败
            public int Receive(ref Stream stream)
            {
                return Receive(ref stream, defaultPacketSize, defaultGroupSize);
            }
     
            public int Receive(ref Stream stream, int packetSize, int groupSize)
            {
                IPEndPoint ipep = new IPEndPoint(IPAddress.Any, 0);
     
                int[] groupFlag = new int[groupSize];
                byte[][] groupData = new byte[groupSize][];
                byte flag;//UDP包中的标志字节,包含组序号,包序号(即组内序号),发送结束标志
                int groupSeq, packetSeq, myGroupSeq;
                int dataSize = packetSize - 1;
                int i, endFlag, currentGroupSize;
                int socketRecieveTimeOut = client.Client.ReceiveTimeout;//保存原来的接收超时时间
     
                try
                {
                    client.Client.ReceiveTimeout = receiveTimeOut;//设置接收超时时间
                    currentGroupSize = groupSize;
                    myGroupSeq = 0;
     
                    while (true)
                    {
                        byte[] data = client.Receive(ref ipep);
                        {
                            if (data.Length < 2)//最小数据长度为2字节
                            {
                                if (data.Length == 1 && data[0] == 0xFF)//传输中断命令
                                {
                                    client.Client.ReceiveTimeout = socketRecieveTimeOut;//恢复原来的接收超时时间
                                    return -1;
                                }
                                continue;
                            }
     
                            flag = data[data.Length - 1];//数据包标志字节在每个数据包的最后
                            groupSeq = flag >> 4;//前四位:组序号
                            packetSeq = (flag & 0x0F) >> 1;//中间三位:包序号
                            endFlag = flag & 0x01;//最后一位:发送结束标记
     
                            if (groupSeq != myGroupSeq)//不属于希望接受的数据包组
                            {
                                if ((groupSeq + 1) % 16 == myGroupSeq)//上一组回复的确认未收到
                                {
                                    byte[] confirmData = new byte[] { (byte)groupSeq };
                                    client.Send(confirmData, confirmData.Length);//回复确认
                                }
                                continue;
                            }
     
                            if (groupFlag[packetSeq] == 1)//已接收该包则丢弃
                            {
                                continue;
                            }
     
                            groupFlag[packetSeq] = 1;//记录
                            groupData[packetSeq] = data;//暂存数据
                            if (endFlag == 1)//收到含结束标记的包
                            {
                                currentGroupSize = packetSeq + 1;//改变当前组的窗口大小
                            }
     
                            //检测是否该组包已全部接收
                            for (i = 0; i < currentGroupSize; i++)
                            {
                                if (groupFlag[i] == 0)
                                    break;
                            }
                            if (i == currentGroupSize)//已全部接收
                            {
                                //写入数据
                                for (i = 0; i < currentGroupSize; i++)
                                {
                                    stream.Write(groupData[i], 0, groupData[i].Length - 1);
                                }
                                byte[] confirmData = new byte[] { (byte)groupSeq };
     
                                client.Send(confirmData, confirmData.Length);//回复确认
                                client.Send(confirmData, confirmData.Length);//回复两次,确保收到
     
                                if (endFlag == 1)//已收到结束包则退出
                                {
                                    break;
                                }
     
                                myGroupSeq = (myGroupSeq + 1) % 16;
                                currentGroupSize = groupSize;
                                Array.Clear(groupFlag, 0, groupData.Length);
                            }
                        }
                    }
                }
                catch//异常
                {
                    client.Client.ReceiveTimeout = socketRecieveTimeOut;//恢复原来的接收超时时间
                    return -1;
                }
     
                client.Client.ReceiveTimeout = socketRecieveTimeOut;
                return 0;
            }
        }
    }/r/n/n本文来自CSDN博客,转载请标明出处:http://www.flatws.cn/article/program/delphi/2011-04-10/19986.html


     

    展开全文
  • UDP模拟TCP c#

    2013-12-30 02:58:15
    可是UDP存在一些可靠性上的问题,主要是UDP是面向无连接的协议,传输中数据包丢失时没有重传,而且由于网络环境因素可能会出现数据包的乱序的情况。UDP的特点导致其不能方便的应用于需要保证数据可靠性的场合,比如...
  • UDP模仿TCP

    千次阅读 2018-11-28 20:59:55
    模拟TCP的功能 三次握手 四次挥手 发送端要带有计时器,要实现RTT估计和RTO(重传计时器)估计。RTT如下 SampleRTT某报文段被发出到对该报文段的确认被收到之间的时间量 EstimatedRTT=(1-α)* EstimatedRTT+α*...

    udp模仿tcp类似于socket实现tcp的功能(单方向),比如三次握手,四次挥手,超时重传快速重传等等。

    模拟TCP的功能

    • 三次握手
    • 四次挥手
    • 发送端要带有计时器,要实现RTT估计和RTO(重传计时器)估计。RTT如下

    SampleRTT某报文段被发出到对该报文段的确认被收到之间的时间量
    EstimatedRTT=(1-α)* EstimatedRTT+α*SampleRTT(α=0.125?)
    DevRTT=(1-β)DevRTT+β|SampleRTT-EstimatedRTT| (β=0.25?)
    TimeoutInterval = EstimatedRTT + 4 *DevRTT(初始值:EstimatedRTT = 500 milliseconds, DevRTT = 250 milliseconds)
    TimeoutInterval = EstimatedRTT + gamma * DevRTT

    • 可靠数据传输:发送端维护最早未被确认的字节序号(sendbase), 下一个要发送的字节的序号(nextSeqNum), 通过单一计时器来实现超时重传,通过冗余ACK来实现快速重传。
    • 流量控制:有一个在任何时刻能保持的最大的未确认的 《字节数》(最大窗口数),包能够有的最多字节数。
    • 因为是在环回网络上测试,所以要模拟数据包出现TCP中的意外–丢失,延迟,损坏,乱序
    • 接收端收到后立刻返回ACK。不对ACK包进行操作

    设计参考《计算机网络自顶向下方法》

    设计思路之包头设计

    三次握手需要syn,ack两个标志位,四次挥手需要fin的标志位,校验错误需要crc码,传输数据需要ackNo码跟seqNo码。因为java中datagramSocket.receive收到的packet大小是固定的。比如

    byte[] receBuf = new byte[1024];
    DatagramPacket datagramPacket = new DatagramPacket(receBuf, receBuf.length);
    

    则无论实际数据是多少datagramPacket.getData().length()都会是1024, 所以java还需要一个len来记录一个包中数据的长度(udp不会粘包)。tcp粘包,udp不会原因
    而python没发现这种情况,所以不需要也可以。
    所以包头设计为

    //fin:四次挥手用,表示要断开连接
    //syn:三次握手用,表示要连接接收端
    //ack:数据传输用,表示收到包了
    //crc_code: 校验用
    //len:包体长度
    //seqNo:序号(具体意思百度一下TCP, seq_num就有)
    //ackNo:确认号(同上)
    private int fin, syn, ack, seqNo, ackNo, crc_code, len;
    
    

    因为发送时是发送字节数组。所以包头需要一个将Header转换为byte[] 的方法。通过位操作将3个标志位放在1个字节中。其他各为4个字节python使用pack,java使用ByteBuffer

        public static byte[] getIntBytes(int data) {
            ByteBuffer buffer = ByteBuffer.allocate(4);
            buffer.order(ByteOrder.BIG_ENDIAN);
            buffer.putInt(data);
            byte[] bytes = buffer.array();
            return bytes;
        }
    
    
        public static int getInt(byte[] bytes) {
            ByteBuffer buffer = ByteBuffer.allocate(bytes.length);
            buffer.order(ByteOrder.BIG_ENDIAN);
            buffer.put(bytes);
            int result = buffer.getInt(0);
            return result;
        }
    
    

    设计思路之状态

    两边都需要使用状态值来记录当前处于哪种状态。因为收到ack=1的的确认包,那是处于接收数据状态还是四次挥手状态。所以有如下状态:
    class States(Enum):
    CLOSE = 0
    LAST_ACK = 1
    SYN_RCVD = 2
    SYN_SENT = 3
    CLOSE_WAIT = 4
    ESTABLISHED = 5
    FIN_WAIT = 6

    发送端发送第一次握手后进入SYN_SENT, 接收端接收后进入SYN_RCVD, 回复第二次握手, 发送端接收后回复第三次握手,进入ESTABLISHED, 准备发送数据。接收端接收后进入ESTABLISHED等待数据。

    快速重传

    收到乱序包时,回复等待接收的正确顺序的那个ACK包。发送端收到3个同样的冗余ACK后就可以重传了。因此发送端需要维护一个缓冲区。里面存着已发送但还未确认的包。该缓冲区大小 小于最大窗口数。

    接受端

    接收数据,要区分一下情况:

    1. 包丢失,即包的seq_num比last_ack_num大(last_ack_num:最后一个收到并确认的数据包的seq_num)
    2. 包重复,丢弃即可
    3. 包损坏,丢弃,当作没收到
    4. 包延时:先存后面的包,使用快速重传,回复冗余ACK
    5. 包乱序:同包延时处理
    展开全文
  • TCP&UDP;模拟测试工具

    2018-07-05 22:12:41
    此工具可用于模拟TCP/IP和UDP的通讯,对于socket通讯,可以起到模拟的作用,快捷方便易操作。
  • 模拟ip tcp udp协议

    2018-01-30 17:47:46
    手工模拟底层 ip tcp udp协议,代码是多年前学习底层通行时做的,测试过可以使用,但是不能编译。用于学习还是不错的
  • tcp/udp数据模拟发送

    热门讨论 2012-09-29 10:02:40
    1,tcp udp 数据发送 2,支持16进制数据 3,支持创建tcp/udp服务器
  • 怎么用 UDP 实现 TCP

    千次阅读 2020-12-07 22:03:12
    其实面试官主要是想让我说出 UDPTCP 的原理上的区别,怎么给 UDP 加些功能实现 TCP。 下面我会以大白话的方式来解答上面的问题。 UDP 的特点 UDP 让我想起了刚毕业参加工作那会,一名毕业菜鸟。 沟通简单 领导...

    背景

    本题是我在面试中,技术总监问我的一道真题,当时答得不太好,所以把它揪出来总结了下。

    其实面试官主要是想让我说出 UDP 和 TCP 的原理上的区别,怎么给 UDP 加些功能实现 TCP。

    看好去很容易就能说出一两个 TCP 和 UDP 的区别,但如果能用女朋友都能听懂的方式该怎么说呢?

    女朋友:我不想听课本上讲的!我听不懂呀~

    下面我会以大白话的方式来解答上面的问题。

    UDP 的特点

    UDP 让我想起了刚毕业参加工作那会,一名毕业菜鸟。

    • 沟通简单

    领导安排的任务,直接干就完了。

    UDP 也是,相信网络世界永远是美好的,我发送的包是很容易送到的,接收方也是很容易组装的。数据结构也很简单,不需要大量的数据结构、处理逻辑、包头字段。

    • 轻信他人

    测试人员报的 bug 我也不会和她争论什么,永远相信测试人员是对的,测试人员说啥就是啥,我改就是。

    UDP 也是,不会建立连接,有个端口号,谁都可以监听这个端口号往上面发数据。也可以从这个端口号传给任何人数据。反正我只管发就是。

    • 不会讨价还价

    产品经理昨天说手机壳需要根据心情变色,测试人员说这个 bug 要把关联的两个 bug 一起修掉。那就按照他们说的做吧!

    UDP 也是,不懂坚持和退让。也就是根据网络情况进行拥塞控制。无论网络丢包多严重,我还是照样发~

    UDP 使用场景

    针对像我那时候毕业菜鸟的情况,领导给我安排了三种工作环境让我选。

    • 内部系统,任务简单,模块单一,不需要考虑代码的关联影响,即使失败了也没有关系。

    UDP 也是,需要资源少,网络情况比较好的内网,或者对于丢包不敏感的应用。

    • 有一个强力的团队支持,都是中高级开发、测试人员,团队成员打过很多年交道,互相信任。有什么问题,吼一嗓子就可以了!

    UDP 也是,不需要一对一沟通来建立连接,可以广播的应用。

    • 一个新项目,需要有激情,对于刚毕业的菜鸟,都是有很强的自主能动性的,也不会耍滑头,躲在厕所玩手机,带薪拉shi ?即时项目不忙,我也抓紧时间干。项目忙,还是一样干!

    UDP 也是,猛着发包就是,主要应用在需要处理速度快,时延低,可以容忍少数丢包的情况。即使网络情况不佳,发包就是~

    针对上面的三大场景,UDP 常用在实时竞技游戏,IoT 物联网,移动通信领域。

    TCP 的特点?

    • 面向连接

    TCP 和 UDP 是传输层里面比较重要的两个协议。大部分面试的时候都会问到两者的区别。而大部分都会两句,比如 TCP 是面先连接的,UDP 是面向无连接。

    那什么是面向连接?

    TCP 三次握手是我们常常念叨和背诵的。而在这三次握手成功后,就是建立连接成功。

    那什么又叫面向 呢?

    我们也常听到面向对象编程、面向切面编程、面向服务编程。那到底什么是面向?

    在我看来 面向 就是遵循一定的协议、规范、数据结构等来做一系列事情。

    比如面向连接 ,就是为了在客户端和服务端维护连接,而建立一定的数据结构来维护双方交互的状态,用这样的数据来保证所谓的面向连接的特性。

    知道了 TCP 的是用三次握手来建立连接,那我们是否可以让 UDP 也发三个包来模拟 TCP 建立连接了?可以是可以,但是如果只是建立,而不是面向连接,其实意义不大。

    那 TCP 面向连接做了哪些事情?

    TCP 提供可靠交付,通过 TCP 连接传输的数据,可以无差错、不丢失、不重复、并且按序到达。而 UDP 继承了 IP 包的特性,不保证不丢失,不保证按顺序到达。

    • 面向字节流

    TCP 是面向字节流,所谓字节流,就是发的是一个流,没头没尾。TCP 自己维护流状态。

    UDP 基于 IP 数据报,一个一个地发,一个一个地收。

    • 拥塞控制

    TCP 拥有拥塞控制,如果包丢弃了或者网络环境不好了,就会根据网络情况自行控制自己的行为,看下是发快点还是发慢点。

    UDP 则没有这么智能了, 你让我发,我就发呗,反正是你让我发的,其他的一概不管~

    • 有状态服务

    TCP 是一个有状态的服务,有状态可以理解为:我记录了哪些发送了,哪些没有发送,哪些接收到了,哪些没接收到,应该接收哪个了,一点差错都不行。TCP 干的事情可真多!

    而 UDP 则不是有状态的服务,我只管发,其他的就交给接收端吧,有点任性是吧?

    如何让 UDP 实现 TCP 功能?

    建立连接上面已经讲到了,三次握手和四次握手,UDP 也可以模拟去做。

    那下面还有几个问题:

    • 顺序问题
    • 丢包问题
    • 流量控制
    • 拥塞控制

    TCP 的数据结构长这样:
    在这里插入图片描述

    其实如果你能把这些结构讲清楚,就已经理解了 TCP 的核心功能。

    下面我还是用大白话的方式来讲解上面的四个问题。

    顺序问题丢包问题可以利用确认与重发的机制。

    假如包收到了,可以做一个确认,发送一个 ACK 给发送端,告诉他我收到了。假如有的包提前到了,就缓存着。假如有包丢失了,就可以超时重试。超时重试不宜过短,时间必须大于往返时间 RTT,否则会引起不必要的重传。也不宜过长,如果超时时间过长,访问就变慢了。那怎么确定这个时间,可以通过采样 RTT 的时间,进行加权平均。还需要根据网络状况,动态变化。可以了解下自适应重传算法。

    流量控制就是根据网络情况调整发包的速率。利用的是滑动窗口。在对于包的确认中,同事会携带一个窗口的大小,只要利用好这个窗口大小,就能很好地调整发包速率,发的报文段不要超过窗口的大小就 OK。

    TCP 的拥塞控制主要用来避免包丢失和超时重传,如果出现了这两种现象,就说明发的速率太快了。那最开始怎么知道发送速率呢?其实开始时只发送一个报文段数据,如果收到一个确认,则倍增报文段,依次类推。当发现超时重传时,就又回到只发送一个报文段的情况,这个就是慢启动,这种方式不合适。其实还有一种快速重传算法,简单来说就是拥塞窗口减半,后续线性增速。针对于算法怎么实现的,这里就不展开讲述了。
    在这里插入图片描述
    在这里插入图片描述

    至此,我用大白话的方式讲解了 UDP 和 TCP 的区别,以及 UDP 缺什么功能,需要怎么去弥补才能实现 TCP 的功能。相信这样回答的思路可以让面试官觉得还是有点东西的。

    巨人的肩膀:

    《趣谈网络协议》

    《计算机网络》

    展开全文
  • UDPTCP 的区别是什么呢? 主要的区别是 : UDP 是非面向连接, 优点是快, 但是不稳定。 TCP 是面向连接,优点是慢,但是稳定, 具体自己查下,不是本节的重点。 在介绍这个知识 我们要下载个网络助手,...

    前面在学习多进程 之间通信用到 QUEQUE, 那也只是在同一台电脑,进行通信,

    那如何在不同的电脑传输数据呢, 就用到了网络传输,以后的章节我都写网络编程的知识。

    首先我们要了解 IP 和 端口 两个概念,

    当我们把一个消息发送到电脑 qq 里, 为什么他能找到你的电脑呢, 就是用 IP 协议 , 为什么找到你的电脑也能找你的qq呢,为什么不发到微信里, 说明用到了端口号。 端口是分辨电脑里进程的编号。

    UDP 和 TCP 的区别是什么呢?

    主要的区别是 :

    UDP 是非面向连接, 优点是快, 但是不稳定。
    TCP 是面向连接,优点是慢,但是稳定, 具体自己查下,不是本节的重点。

    在介绍这个知识 我们要下载个网络助手,百度下载安装就行, 如图:

    网络调试助手

    模拟UDP 发送

    1. 设置网络助手
      设置内容 有, 协议类型 选择UDP, ip 和端口,然后点击连接。

    在这里插入图片描述
    2. 编辑代码 然后发送

    from socket import *
    udpsocket=socket(AF_INET,SOCK_DGRAM)  #  这个是固定的写法 ,返回一个socket 对象
    senddata=b"hello ,  i love you "   #  这个保存你要发的内容
    sendaddr=('192.168.43.224',8080)  # 保存发送地址, 是个元祖 第一个是IP、寻找哪台电脑, 第二个是端口代表发给哪个程序
    udpsocket.sendto(senddata,sendaddr) # 调用sendto 方法 ,发送你想要的内容
    

    在网络助手 显示就是要发送的内容,如图:

    在这里插入图片描述

    模拟 TCP 发送

    1. 设置 TCP服务端
      在这里插入图片描述
    from socket import *
    addr  = ('192.168.43.224',8080)
    sendData = ("i am tcp ")
    Socket_TCP = socket()    # socket 对象
    Socket_TCP.connect(addr) # 连接 tcp 服务器
    data = sendData  
    data = bytes(data, encoding='utf-8')  # 因为input返回的是字符串类型的数据,data需要字节类型的数据
    Socket_TCP.sendall(data)  # 发送数据
    

    执行的结果为:

    在这里插入图片描述

    总结:

    我写的只是了解 socket 基本概念, 并熟悉的基本流程, 后边我具体介绍 socket 包含的方法, 并写一个基本的聊天系统。

    展开全文
  • 知道了 TCP 的是用三次握手来建立连接,那我们是否可以让 UDP 也发三个包来模拟 TCP 建立连接?可以是可以,但是如果只是建立,而不是面向连接,其实意义不大。 那 TCP 面向连接做了哪些事情? TCP 提供可靠交付,...
  • 编写一个udp服务端的C语言程序 1. 创建套接字 2. 为套接字绑定地址信息 3. 接收数据 4. 发送数据 5. 关闭套接字 #include <stdio.h> #include <stdlib.h> #include <unistd.h> #include <...
  • UDP实现TCP可靠传输

    千次阅读 2018-10-22 11:30:12
    udptcp的区别 TCP(TransmissionControl Protocol 传输控制协议)是一种面向连接的、可靠的、基于字节流的传输层通信协议。 使用超时重传、数据确认、滑动窗口等方式确保数据包被正确地发送至目的端 UDP是(User ...
  • TCP/UDP模拟服务端

    2019-03-14 09:29:55
    TCP/UDP模拟服务端
  • TCP(传输控制协议): 1)提供IP环境下的数据可靠传输(一台计算机发出的字节流会无差错的发往网络上的其他计算机,而且计算机A接收数据包的时候,也会向计算机B回发数据包,这也会产生部分通信量),有效流控,全双工...
  • 如何利用UDP实现TCP的可靠传输

    千次阅读 2019-03-06 23:38:41
    报告:https://github.com/c980129/TCP/blob/master/%E5%AE%9E%E9%AA%8C%E6%8A%A5%E5%91%8A.pdf 代码:https://github.com/c980129/TCP
  • TCP客户端和服务器模拟UDP客户端和服务器模拟。对于你新人来说,你可以做完客户端之后选择这个工具模拟服务器,然后尝试连接确认自己客户端写的正确,反之亦然。
  • (转)UDP模拟TCP滑动窗口实现数据安全可靠传输(C#) <br />最近需要实现P2P也就是需要做NAT穿透,原来写的TCP传输就出现问题了,因为TCP不能很好的实现内网的穿透,因此最好用UDP来实现传输。 可是...
  • 文章目录一、前言二、代码2.1 代码1——模拟TCP通信2.2 代码2——模拟UDP通信三、尾声 一、前言 Java的网络编程(java.net包)提供和计算机网络操作相关的API,本文演示Java代码模拟tcp通信和udp通信,且见代码1、...
  • Windows系统下的TCP/UDP调试工具,功能如其名。支持TCP/UDP的收发、TCP的服务端和客户端模式、UDP的组播
  • 这是一款串口+UDP+TCP通信三合一调试工具,很不错的轻量级软件,推荐给大家
  • VC WinSock API实现的聊天程序,消息部份可穿越内网,传输文件部分(TCP部分)暂且只能接收,其实与UDP类似,把TCP socket改为允许端口复用即可(WSAEADDRINUSE)
  • TCP/UDP测试工具,建立服务器和客户端,便可实现模拟通信
  • TCP&UDP;测试工具

    2017-10-20 17:08:21
    TCP&UDP;测试工具,很好的模拟测试网络TCPUDP通讯协议的电脑客户端工具。
  • TCP(传输控制协议): 1)提供IP环境下的数据可靠传输(一台计算机发出的字节流会无差错的发往网络上的其他计算机,而且计算机A接收数据包的时候,也会向计算机B回发数据包,这也会产生部分通信量),有效流控,全双工...
  • 两个小工具用来debug tcp/udp 链接和测试tcp/udp server的压力 http://www.cnblogs.com/smark/p/4496660.html?utm_source=tuicool 和 sokit TCP/UDP 数据包收发测试
  • 该Demo基于TCP用于模拟UDP广播的Socket服务端程序,能够实时监听基于TCP协议的socket客户端的连接和断开,可以用于简单的实现服务端向多客户端发送信息,进行交互
  • Socket简单模拟tcpUdp客户端服务端

    千次阅读 2019-05-07 09:08:39
    网络模型图:应用层,传输层,网络层,链路层 什么是Socket? Socket就是为网络服务提供的一种机制。...TCPUDP在概念上的区别: udp: a、是面向无连接, 将数据及源的封装成数据包中,不需要建立...
  • 时隔半年,对网络调试助手工具进行所有代码重写,这次目录结果整齐的一逼,代码整齐的一逼,非常完善了,打死也不再改版了。这次真的打死也不再改版了。...9:四种模式,tcp服务器、tcp客户端、udp服务器、udp客户端。

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 34,765
精华内容 13,906
关键字:

udp模拟tcp