精华内容
下载资源
问答
  • 类似于ireport的报表开发技术,不过cognos比ireport强大很多,利用cognos配置数据源可以将数据库的表加载到cognos中,操作表中的列可以绘制普通列表,交叉报表,,图表等。
  • 我们还为每种类型的数据包创建了类。 这些类能够使用原始数据进行初始化,并包含将它们转换为原始数据的方法。 这种解析对于读取和设置属性很有用,而无需每次都进行手动位操作。 首先,我们创建了 HTTP 文件,...
  • 创建DBF数据包

    2012-12-02 23:52:43
    创建DBF数据包,通过HTTP协议开发API接口上传文件
  • PacketBuilder 数据包创建器,用于辅助创建数据包。 程序把Tcp连接上收到的二进制数据暂时存储在 packetBuilder中,如果收到的数据足够多,程序会把数据包包头解析出来,并根据数据包包头中的数据,解析出数据包...

    本文基于networkcomms2.3.1开源版本  gplv3协议

    PacketBuilder 数据包创建器,用于辅助创建数据包。

    程序把Tcp连接上收到的二进制数据暂时存储在 packetBuilder中,如果收到的数据足够多,程序会把数据包包头解析出来,并根据数据包包头中的数据,解析出数据包大小,根据数据包大小,从PacketBuilder中截取相应的二进制数据,把这部分数据以内存流(MemoryStream)的形式,加上数据包包头一起交给NetworkComms.CompleteIncomingItemTask()方法进行处理。 

    PacketBuilder 中的数据被提取过的数据,会被删除。Tcp连接上进入的数据,又会加入进来,好似一个流动的容器。

    复制代码
     /// <summary>
        /// Packet data is generally broken into multiple variable sized byte chunks or 'partial packets'. This class provides features to effortlessly rebuild whole packets.
        /// 数据包创建器,用来临时存储接收到的二进制数据,如果收到的二级制数据足够合成一个数据包,主程序会介入处理这个部分数据,处理完成后,会从PacketBuilder中删除已经处理的数据
        /// </summary>
        public class PacketBuilder
        {
            //存储的二级制数据
            List<byte[]> packets = new List<byte[]>();
            //存放二进制数据对应的大小
            List<int> packetActualBytes = new List<int>();
    
            /// <summary>
            /// Locker object used for performing thread safe operations over this packet builder
            /// </summary>
            public object Locker { get; private set; }
    
            int totalBytesCached = 0;
            int totalBytesExpected = 0;
    
            /// <summary>
            /// Create a new instance of the ConnectionPacketBuilder class
            /// </summary>
            public PacketBuilder()
            {
                Locker = new object();
            }
    
            /// <summary>
            /// The total number of cached bytes. This is the sum of all bytes across all cached partial packets. See <see cref="TotalPartialPacketCount"/>.
            /// 已经存储的数据的带下
            /// </summary>
            public int TotalBytesCached
            {
                get { return totalBytesCached; }
            }
    
            /// <summary>
            /// The total number of cached partial packets. This is different from <see cref="TotalBytesCached"/> because each partial packet may contain a variable number of bytes.
           /// </summary>
            public int TotalPartialPacketCount
            {
                get { lock (Locker) return packets.Count; }
            }
    
            /// <summary>
            /// The total number of bytes required to rebuild the next whole packet.
            /// 期待的数据大小,也就是根据数据包包头解析出的数据包大小
            /// </summary>
            public int TotalBytesExpected
            {
                get { lock (Locker) return totalBytesExpected; }
                set { lock (Locker) totalBytesExpected = value; }
            }
    
            /// <summary>
            /// Clear N bytes from cache, starting with oldest bytes first.
            /// 此方法用于,当此部分数据被主程序处理完成后,删除此部分数据
            /// </summary>
            /// <param name="numBytesToRemove">The total number of bytes to be removed.</param>
            public void ClearNTopBytes(int numBytesToRemove)
            {
                lock (Locker)
                {
                    if (numBytesToRemove > 0)
                    {
                        if (numBytesToRemove > totalBytesCached)
                            throw new CommunicationException("Attempting to remove " + numBytesToRemove.ToString() + " bytes when ConnectionPacketBuilder only contains " + totalBytesCached.ToString());
    
                        int bytesRemoved = 0;
    
                        //We will always remove bytes in order of the entries
                        for (int i = 0; i < packets.Count; i++)
                        {
                            if (packetActualBytes[i] > numBytesToRemove - bytesRemoved)
                            {
                                //Remove the necessary bytes from this packet and rebuild
                                //New array length is the original length minus the amount we need to remove
                                byte[] newPacketByteArray = new byte[packetActualBytes[i] - (numBytesToRemove - bytesRemoved)];
                                Buffer.BlockCopy(packets[i], numBytesToRemove - bytesRemoved, newPacketByteArray, 0, newPacketByteArray.Length);
    
                                bytesRemoved += packetActualBytes[i] - newPacketByteArray.Length;
                                packets[i] = newPacketByteArray;
                                packetActualBytes[i] = newPacketByteArray.Length;
    
                                //Stop removing data here
                                break;
                            }
                            else if (i > packets.Count - 1)
                            {
                                //When i == (packet.Count - 1) I would expect the above if condition to always be true
                                throw new CommunicationException("This should be impossible.");
                            }
                            else
                            {
                                //If we want to remove this entire packet we can just set the list reference to null
                                bytesRemoved += packetActualBytes[i];
                                packets[i] = null;
                                packetActualBytes[i] = -1;
                            }
                        }
    
                        if (bytesRemoved != numBytesToRemove)
                            throw new CommunicationException("bytesRemoved should really equal the requested numBytesToRemove");
    
                        //Reset the totalBytesRead
                        totalBytesCached -= bytesRemoved;
                        
                        //Get rid of any null packets
                        List<byte[]> newPackets = new List<byte[]>(packets.Count);
                        for (int i = 0; i < packets.Count; i++)
                        {
                            if (packets[i] != null)
                                newPackets.Add(packets[i]);
                        }
                        packets = newPackets;
    
                        //Remove any -1 entries
                        List<int> newPacketActualBytes = new List<int>(packetActualBytes.Count);
                        for (int i = 0; i < packetActualBytes.Count; i++)
                        {
                            if (packetActualBytes[i] > -1)
                                newPacketActualBytes.Add(packetActualBytes[i]);
                        }
                        packetActualBytes = newPacketActualBytes;
    
                        //This is a really bad place to put a garbage collection as it hammers the CPU
                        //GC.Collect();
                    }
                }
            }
    
            /// <summary>
            /// Add a partial packet to the end of the cache by reference.
            /// 添加接收的数据
            /// </summary>
            /// <param name="packetBytes">The number of valid bytes in the provided partial packet</param>
            /// <param name="partialPacket">A buffer which may or may not be full with valid bytes</param>
            public void AddPartialPacket(int packetBytes, byte[] partialPacket)
            {
                lock (Locker)
                {
                    totalBytesCached += packetBytes;
    
                    packets.Add(partialPacket);
                    packetActualBytes.Add(packetBytes);
    
                    if (NetworkComms.LoggingEnabled)
                    {
                        if (TotalBytesExpected == 0 && totalBytesCached > (10 * 1024 * 1024))
                            NetworkComms.Logger.Warn("Packet builder cache contains " + (totalBytesCached / 1024.0).ToString("0.0") + "KB when 0KB are currently expected.");
                        else if (TotalBytesExpected > 0 && totalBytesCached > totalBytesExpected * 2)
                            NetworkComms.Logger.Warn("Packet builder cache contains " + (totalBytesCached / 1024.0).ToString("0.0") + "KB when only " + (TotalBytesExpected / 1024.0).ToString("0.0") + "KB were expected.");
                    }
                }
            }
    
            /// <summary>
            /// Returns the most recently cached partial packet and removes it from the cache.
            /// Used to more efficiently utilise allocated memory space.
            /// </summary>
            /// <param name="lastPacketBytesRead">The number of valid bytes in the last partial packet added</param>
            /// <returns>A byte[] corresponding with the last added partial packet</returns>
            public byte[] RemoveMostRecentPartialPacket(ref int lastPacketBytesRead)
            {
                lock (Locker)
                {
                    if (packets.Count > 0)
                    {
                        int lastPacketIndex = packets.Count - 1;
    
                        lastPacketBytesRead = packetActualBytes[lastPacketIndex];
                        byte[] returnArray = packets[lastPacketIndex];
    
                        totalBytesCached -= packetActualBytes[lastPacketIndex];
    
                        packets.RemoveAt(lastPacketIndex);
                        packetActualBytes.RemoveAt(lastPacketIndex);
    
                        return returnArray;
                    }
                    else
                        throw new Exception("Unable to remove most recent packet as packet list is empty.");
                }
            }
    
            /// <summary>
            /// Returns the number of unused bytes in the most recently cached partial packet.
            /// </summary>
            /// <returns>The number of unused bytes in the most recently cached partial packet.</returns>
            public int NumUnusedBytesMostRecentPartialPacket()
            {
                lock (Locker)
                {
                    if (packets.Count > 0)
                    {
                        int lastPacketIndex = packets.Count - 1;
                        return packets[lastPacketIndex].Length - packetActualBytes[lastPacketIndex];
                    }
                    else
                        throw new Exception("Unable to return requested size as packet list is empty.");
                }
            }
    
            /// <summary>
            /// Returns the value of the first cached byte.
            /// 获取第一个字节中的数据
            /// </summary>
            /// <returns>The value of the first cached byte.</returns>
            public byte FirstByte()
            {
                lock (Locker)
                    return packets[0][0];
            }
    
            /// <summary>
            /// Copies all cached bytes into a single array and returns. Original data is left unchanged.
            /// </summary>
            /// <returns>All cached data as a single byte[]</returns>
            public byte[] GetAllData()
            {
                lock (Locker)
                {
                    byte[] returnArray = new byte[totalBytesCached];
    
                    int currentStart = 0;
                    for (int i = 0; i < packets.Count; i++)
                    {
                        Buffer.BlockCopy(packets[i], 0, returnArray, currentStart, packetActualBytes[i]);
                        currentStart += packetActualBytes[i];
                    }
    
                    return returnArray;
                }
            }
    
            /// <summary>
            /// Copies the requested cached bytes into a single array and returns. Original data is left unchanged.
            /// 拷贝需要的数据到一个字节数组中,并以内存流的形式返回给主程序,主程序会把“数据包包头”和此部分数据一起交给NetworkComms.CompleteIncomingItemTask()方法进行处理
            /// 
            /// </summary>
            /// <param name="startIndex">The inclusive byte index to use as the starting position.</param>
            /// <param name="length">The total number of desired bytes.</param>
            /// <returns>The requested bytes as a single array.</returns>
            public MemoryStream ReadDataSection(int startIndex, int length)
            {
                lock (Locker)
                {
                    byte[] returnArray = new byte[length];
                    int runningTotal = 0, writeTotal = 0;
                    int startingPacketIndex;
    
                    int firstPacketStartIndex = 0;
                    //First find the correct starting packet
                    for (startingPacketIndex = 0; startingPacketIndex < packets.Count; startingPacketIndex++)
                    {
                        if (startIndex - runningTotal <= packetActualBytes[startingPacketIndex])
                        {
                            firstPacketStartIndex = startIndex - runningTotal;
                            break;
                        }
                        else
                            runningTotal += packetActualBytes[startingPacketIndex];
                    }
    
                    //Copy the bytes of interest
                    for (int i = startingPacketIndex; i < packets.Count; i++)
                    {
                        if (i == startingPacketIndex)
                        {
                            if (length > packetActualBytes[i] - firstPacketStartIndex)
                                //If we want from some starting point to the end of the packet
                                Buffer.BlockCopy(packets[i], firstPacketStartIndex, returnArray, writeTotal, packetActualBytes[i] - firstPacketStartIndex);
                            else
                            {
                                //We only want part of the packet
                                Buffer.BlockCopy(packets[i], firstPacketStartIndex, returnArray, writeTotal, length);
                                writeTotal += length;
                                break;
                            }
    
                            writeTotal = packetActualBytes[i] - firstPacketStartIndex;
                        }
                        else
                        {
                            //We are no longer on the first packet
                            if (packetActualBytes[i] + writeTotal >= length)
                            {
                                //We have reached the last packet of interest
                                Buffer.BlockCopy(packets[i], 0, returnArray, writeTotal, length - writeTotal);
                                writeTotal += length - writeTotal;
                                break;
                            }
                            else
                            {
                                Buffer.BlockCopy(packets[i], 0, returnArray, writeTotal, packetActualBytes[i]);
                                writeTotal += packetActualBytes[i];
                            }
                        }
                    }
    
                    if (writeTotal != length) throw new Exception("Not enough data available in packetBuilder to complete request. Requested " + length.ToString() + " bytes but only " + writeTotal.ToString() + " bytes were copied.");
    
                    return new MemoryStream(returnArray, 0, returnArray.Length, false, true);
                }
            }
        }
    复制代码

     

    www.cnblogs.com/networkcomms

    www.networkcomms.cn

    展开全文
  • npyck:从python源文件创建可运行的数据包
  • 创建数据包 可以使用datapackage函数创建数据datapackage ,它需要一个名称以及可选的标题和描述: examples <- datapackage( name = " r_examples " , title = " Some example data sets from R " , ...
  • 它使您可以通过定义所有标头数据的各个方面来手动创建数据包,通过解析原始数据包字节,在不同层上发送/接收数据包以及截取数据包来解剖数据包。 Pypacker可以做什么 创建提供特定值的数据包或采用默认值: from ...
  • goshark - 使用tshark对IP包进行解码并创建数据结构分析数据包
  • 数据包在不同网段上的传输流程

    千次阅读 2014-09-26 14:51:46
    PC1、R1、R2、WebServer PC1 为网络A中的一台主机,WebServer为网络B中的Web服务器,路由器R1、R2...1)PC1创建数据包,欲发送到不同网络中的WebServer,由于无法取得WebServer的MAC地址,于是使用ARP协议通过主机PC1

    对于数据包在不同网段上传输这一问题,LZ参考一些资料,觉得用数据包源目标地址状态的变化能更直观的表示这一流程的进行,以下LZ用一个例子描述这一过程。



    PC1、R1、R2、WebServer

    PC1 为网络A中的一台主机,WebServer为网络B中的Web服务器,路由器R1、R2分别为网络A、B的网关,且路由器R1、R2的WAN口相连。

     

    PC1 ---> WebServer的数据包传输流程如下:

    1)PC1创建数据包,欲发送到不同网络中的WebServer,由于无法取得WebServer的MAC地址,于是使用ARP协议通过主机PC1所设置的网关(即R1的局域网IP)来获得R1的LAN接口的MAC地址,并将数据包目标MAC地址设为R1的LAN接口的MAC地址,此时数据包状态如下:

    源IP

    源MAC

    目标IP

    目标MAC

    PC1

    PC1

    WebServer

    R1(LAN)

     

    2)R1接受到数据包,将源IP地址通过NAT转换成R1的公网IP,并将源MAC地址转换成R1的WAN接口MAC地址,然后,查找路由表,发现需要经过R2才能到达WebServer(目标IP),于是将目标MAC地址转换成R2的WAN接口MAC地址,此时数据包状态如下:

    源IP

    源MAC

    目标IP

    目标MAC

    R1(WAN)

    R1(WAN)

    WebServer

    R2(WAN)

     

    3)R2接受到数据包,发现WebServer(目标IP)就在本网络(B网络)中,于是将源MAC地址改为R2的LAN接口地址,再使用ARP协议通过数据包中的目标IP地址获得WebServer的MAC地址,此时数据包状态如下:

    源IP

    源MAC

    目标IP

    目标MAC

    R1(WAN)

    R2(LAN)

    WebServer

    WebServer

     

    经过以上三步,完成PC1到WebServer的通信。

     

    问题:WebServer回传数据的时候,只知道R1的公网IP,即只能发送到R1上,却不知道PC1的子网IP,如何能够到达PC1上?

    答:通过路由器的端口映射功能。在流程2)中,R1将源IP地址转换成R1的公网IP时,R1会分配一个未记录的端口号,同时,R1会把PC1的IP和当前数据包的发送端口号(就该例子来说是80端口)与R1公网IP和刚才分配的未记录的端口号之间的映射关系记录下来。比如,PC1的IP为192.168.1.12,通过80端口发出数据包,R1的公网IP为201.12.12.12,分配的端口号为12,那么该映射关系为  :

    子网(PC1)

    公网(R1)

    192.168.1.12:80

    201.12.12.12:12

     

    当WebServer回传数据到达R1上,就会通过该映射,将数据包传给子网里的PC1。


    LZ水平有限,大家如果有疑问或者觉得哪里表述有误,希望一定提出,大家一起讨论。

    展开全文
  • 实用程序 一个简单的 Java API 扩展,用于手动创建和处理 HTTP 数据包
  • 数据包解析

    2020-04-06 20:32:33
    数据包解析数据包理解七层协议详解OSI七层协议中每一层的特征数据包解析如何改变文本的样式TCP数据包结构: 数据包理解 从专业的角度来说,(网络协议)OSI就是一个开放的通信系统互联参考模型,也是一个定义的很好的...

    数据包理解

    从专业的角度来说,(网络协议)OSI就是一个开放的通信系统互联参考模型,也是一个定义的很好的协议规范。OSI模型有7层结构,每层都可以有几个子层。OSI的7层从下到上分别是7-应用层、6-表示层、5-会话层、4-传输层、3-网络层、2-数据链路层、1-物理层。

    七层协议详解

    物理层:是参考模型的最低层。该层是网络通信的数据传输介质,由连接不同结点的电缆与设备共同构成。主要跟功能是:利用传输介质为数据链路层提供物理连接,负责处理数据传输并监控数据出错率,以便数据流的透明传输。
    数据链路层:四参考模型的第二层。主要功能是:在物理层提供的服务基础上,在通信的实体间建立数据链路连接,传输以“帧”为单位的数据包,并采用差错控制与流量控制方法,使有差错的物理线路变成无差错的数据链路。
    网络层:是参考模型的第三层。主要功能是:为数据在节点之间传输创建逻辑链路,通过路由选择算法为分组通过通信子网选择最适当的路径,以及实现拥塞控制、网络互连等功能。
    传输层:是参考模型的第四层。主要功能是:向用户提供可靠地端到端服务,处理数据包错误、数据包次序,以及其他一些关键传输问题。传输层向高层屏蔽了下层数据通信的细节。因此,它是计算机通信体系结构中关键的一层。
    会话层:是参考模型的第五层。主要功能是:负责维扩两个结点之间的传输连接,以便确保点到点传输不中断,以及管理数据交换等功能。
    表示层:是参考模型的第六层。主要功能是:用于处理在两个通信系统中交换信息的表示方法,主要包括数据格式变换、数据加密与解密、数据压缩与恢复等功能。
    应用层:是参考模型的最高层。主要功能是:为应用软件提供了很多服务,比如文件服务器、数据库服务、电子邮件与其他网络软件服务。

    OSI七层协议中每一层的特征

    第一层:物理层
    机械性能:接口的形状,尺寸的大小,引脚的数目和排列方式等;
    电气性能:接口规定信号的电压、电流、阻抗、波形、速率好平衡特性等;
    工程规范:接口引脚的意义、特性、标准。
    工作方式:确定数据位流的传输方式,如:半双工、全双工等。
    物理层协议:美国电子工业协会(EIA)的RS232/RS422/RS423等;
    国际电报电话咨询委员会(CCITT)的X.25/X.21等;
    物理层的数据单位是位(BIT),典型设备时集线器HUB。
    这主要是和硬件有关,与软件关系不大。
    第二层:链路层
    链路层屏蔽传输介质的物理特征,使数据可靠传送。
    内容包括介质访问控制、连接控制、顺序控制、流量控制、差错控制和仲裁协议等。
    链路层协议有:协议有面向字符的通讯协议(PPP)和面向位的通讯协议(HDLC)。
    仲裁协议:CSMA/CD(Carrier Sense Multiple Access with Collision Detection)、Token Bus、Token Ring
    链路层数据单位是帧,实现对MAC地址的访问,典型设备是交换机SWITCH。
    第三层:网络层
    网络层管理连接方式和路由选择。
    连接方式:虚电路和数据报服务。
    虚电路是面向连接的,数据通讯一次路由,通过会话建立的一条通路。数据报是非连接的,每个数据报都有路由能力。网络层的数据单位是包,使用的是IP地址,典型设备时路由器Router。
    这一层可以进行流量控制,但流量控制更多的是使用第二层或第四层。
    第四层:传输层
    提供端到端的服务,可以实现流量控制、负载均衡。
    传输层信息包括端口、控制字和校验和。
    传输层协议主要是TCP和UDP。
    传输层位于OSI的第四层,这层使用的设备时主机本身。
    第五层:会话层
    会话层主要内容时通过 绘画进行身份验证、绘画管理和确定通讯方式。一旦建立连接,会话层的任务就是管理会话。
    第六层:表示层
    表示层主要是解释通讯数据的意义,如代码转换、格式变换等,使不同的终端可以表示。
    还包括加密与解密、压缩与解压等。
    第七层:应用层
    应用层应该是直接面向用户的程序或服务,包括系统程序和用户程序,比如www、FTP、DNS、POP3和SMTP等都是应用层服务。
    数据再发送时是数据从应用层至物理层的一个大包的过程,接收时是数据从物理层至应用层的一个解包过程。
    从功能角度可以分为三组:1/2层解决网络通信问题,3/4层解决传输问题,5/6/7层处理对应用进程的访问。
    从控制角度可分为二组:1/2/3层是通信子网,4/5/6/7是主机控制层。

    数据包解析

    在这里插入图片描述

    如何改变文本的样式

    如图,一个刻度表示1个二进制位(比特)。

    1-1.版本号4位,表示版本号号,眼下最广泛的是4=B1000,即常说的IPv4;相信IPv6以后会广泛应用,它能给世界上每一个纽扣都分配

       一个IP地址。
    

    1-2.头长4位,数据包头部长度。它表示数据包头部包含多少个32位长整型,也就是多少个4字节的数据。无选项则为5(红色部分)。

    1-3.服务类型,包含8个二进制位,每一个位的意义例如以下:

       过程字段:3位,设置了数据包的重要性,取值越大数据越重要,取值范围为:0(正常)~ 7(网络控制)
    
       延迟字段:1位,取值:0(正常)、1(期特低的延迟)
    
       流量字段:1位,取值:0(正常)、1(期特高的流量)
    
       可靠性字段:1位,取值:0(正常)、1(期特高的可靠性)
    
       成本字段:1位,取值:0(正常)、1(期特最小成本)
    
       保留字段:1位 ,未使用
    

    1-4.包裹总长16位,当前数据包的总长度,单位是字节。当然最大仅仅能是65535,及64KB。

    2-1.重组标识16位,发送主机赋予的标识,以便接收方进行分片重组。

    2-2.标志3位,他们各自的意义例如以下:

       保留段位(2):1位,未使用
    
       不分段位(1):1位,取值:0(同意数据报分段)、1(数据报不能分段)
    
       很多其它段位(0):1位,取值:0(数据包后面没有包,该包为最后的包)、1(数据包后面有很多其它的包)
    

    2-3.段偏移量13位,与很多其它段位组合,帮助接收方组合分段的报文,以字节为单位。

    3-1.生存时间8位,常常ping命令看到的TTL(Time To Live)就是这个,每经过一个路由器,该值就减一,到零丢弃。

    3-2.协议代码8位,表明使用该包裹的上层协议,如TCP=6,ICMP=1,UDP=17等。

    3-3.头检验和16位,是IPv4数据包头部的校验和。

    4-1.源始地址,32位4字节,我们常看到的IP是将每一个字节用点(.)分开,如此而已。

    5-1.目的地址,32位,同上。

    6-1.可选选项,主要是给一些特殊的情况使用,往往安全路由会当作攻击而过滤掉,普联(TP_LINK)的TL-ER5110路由就能这么做。

    7-1.用户数据。
    强调文本 强调文本

    TCP数据包结构:

    在这里插入图片描述

    1-1.源始port16位,范围当然是0-65535啦。

    1-2.目的port,同上。

    2-1.数据序号32位,TCP为发送的每一个字节都编一个号码,这里存储当前数据包数据第一个字节的序号。

    3-1.确认序号32位,为了安全,TCP告诉接受者希望他下次接到数据包的第一个字节的序号。

    4-1.偏移4位,类似IP,表明数据距包头有多少个32位。

    4-2.保留6位,未使用,应置零。

    4-3.紧急比特URG—当URG=1时,表明紧急指针字段有效。它告诉系统此报文段中有紧急数据,应尽快传送(相当于高优先级的数据)。

    4-3.确认比特ACK—仅仅有当ACK=1时确认号字段才有效。当ACK=0时,确认号无效。參考TCP三次握手

    4-4.复位比特RST(Reset) —当RST=1时,表明TCP连接中出现严重差错(如因为主机崩溃或其它原因),必须释放连接,然后再又一次

       建立运输连接。參考TCP三次握手
    

    4-5.同步比特SYN—同步比特SYN置为1,就表示这是一个连接请求或连接接受报文。參考TCP三次握手

    4-6.终止比特FIN(FINal)—用来释放一个连接。当FIN=1时,表明此报文段的发送端的数据已发送完成,并要求释放运输连接。

    4-7.窗体字段16位,窗体字段用来控制对方发送的数据量,单位为字节。TCP连接的一端依据设置的缓存空间大小确定自己的接收窗体

       大小,然后通知对方以确定对方的发送窗体的上限。
    

    5-1.包校验和16位,包含首部和数据这两部分。在计算检验和时,要在TCP报文段的前面加上12字节的伪首部。

    5-2.紧急指针16位,紧急指针指出在本报文段中的紧急数据的最后一个字节的序号。

    6-1.可选选项24位,类似IP,是可选选项。

    6-2.填充8位,使选项凑足32位。

    7-1.用户数据……

    能够看出,每一个IP包至少要20字节的头部长度,这些与下载内容无关,加上眼下多数传输,包含http协议(就是IE直接下载),都是基于

    TCP协议的,所以IP包裹还要从用户数据中扣除20字节的TCP包头,这里已经是40字节,加上其它程序的连接,状态确认等等包裹,因

    而算出来要比理论值要小。

    另外网络环境(包含稳定因素和传输节点的转发率)也是影响下载速度的重要原因……

    python链接:https://www.cnblogs.com/baihualin/p/10730513.html
    转自:https://baijiahao.baidu.com/s?id=1623342279899809678&wfr=spider&for=pc
    转自:https://blog.csdn.net/qq_36607836/article/details/88627956

    展开全文
  • sql数据包

    2008-07-10 15:11:54
    sql数据包,包括创建表,及各表数据
  • 碎片是一种功能强大的语言和编译器,旨在使创建数据包的过程更加轻松快捷。 对于可用的Python原型,请看 。 状态 该语言处于非常早期的状态。 该项目的文档可以在找到 版本0.1的目标:与mcscript原型的功能均等 ...
  • 包含使用Mininet,iControll和LINC创建光学和数据包拓扑的脚本。 正确的教程顺序 我建议按照以下顺序进行教程:0.确保您可以使用Mininet python API创建数据包网络。 网上有一些类似的内容: 和 LINCoe_and_i...
  • 发送数据包

    千次阅读 2016-01-07 10:40:30
    提起发送数据包大家可能会想到使用SOCKET编程来实现,但其实WinPcap也提供了发送数据包的API,尽管从名字上来看它应该是用来数据捕捉的。值得注意的是,libpcap不支持发送数据包的功能,因此下面提到的函数都是...

      提起发送数据包大家可能会想到使用SOCKET编程来实现,但其实WinPcap也提供了发送数据包的API,尽管从名字上来看它应该是用来数据捕捉的。值得注意的是,libpcap不支持发送数据包的功能,因此下面提到的函数都是WinPcap的扩展,在UNIX平台下是不支持的。下面这个实例程序正是利用了WinPcap中的pcap_sendpacket()来发送单个数据包。

    复制代码
    #include <stdlib.h>
    #include <stdio.h>
    #define HAVE_REMOTE
    #include <pcap.h>


    int main(int argc, char **argv)
    {
    pcap_t *fp;
    char errbuf[PCAP_ERRBUF_SIZE];
    u_char packet[100];
    int i;

    /* 检查命令行参数的合法性 */
    if (argc != 2)
    {
    printf("usage: %s interface (e.g. 'rpcap://eth0')", argv[0]);
    return -1;
    }

    /* 打开输出设备 */
    if ( (fp= pcap_open(argv[1], // 设备名
    100, // 要捕获的部分 (只捕获前100个字节)
    PCAP_OPENFLAG_PROMISCUOUS, // 混杂模式
    1000, // 读超时时间
    NULL, // 远程机器验证
    errbuf // 错误缓冲
    ) ) == NULL)
    {
    fprintf(stderr,"\nUnable to open the adapter. %s is not supported by WinPcap\n", argv[1]);
    return -1;
    }

    /* 假设在以太网上,设置MAC的目的地址为 1:1:1:1:1:1 */
    packet[0]=1;
    packet[1]=1;
    packet[2]=1;
    packet[3]=1;
    packet[4]=1;
    packet[5]=1;

    /* 设置MAC源地址为 2:2:2:2:2:2 */
    packet[6]=2;
    packet[7]=2;
    packet[8]=2;
    packet[9]=2;
    packet[10]=2;
    packet[11]=2;

    /* 填充剩下的内容 */
    for(i=12; i<100; i++)
    {
    packet[i]=i%256;
    }

    /* 发送数据包 */
    if (pcap_sendpacket(fp, packet, 100 /* size */) != 0)
    {
    fprintf(stderr,"\nError sending the packet: %s\n", pcap_geterr(fp));
    return -1;
    }

    return 0;
    }
    复制代码

          下面是pcap_sendpacket()函数的声明:

          int pcap_sendpacket(pcap_t *, const u_char *, int);

          这三个参数的含义分别是发送数据包的适配器、要发送的数据和缓冲的长度。需要注意的是,缓冲直接发送至网络,不会有任何的控制和加工。这就意味着程序需要构造正确的协议头,使得数据包更有意义。该函数的返回值为0表示发送成功,-1表示发送失败。

          但是我们知道,在真正的应用程序中我们往往需要发送多个数据包,事实上WinPcap也支持发送多个数据包,而且WinPcap的这种方式会更高级、更强大,结构会更优。它支持发送队列的方法,即利用队列作为将要发送至网络的数据包的容器。我们来看看下面这个例子。

    复制代码
    #include <stdlib.h>
    #include <stdio.h>

    #define HAVE_REMOTE
    #define WPCAP
    #include <pcap.h>

    void usage();

    int main(int argc, char **argv)
    {
    pcap_t *indesc,*outdesc;
    char errbuf[PCAP_ERRBUF_SIZE];
    char source[PCAP_BUF_SIZE];
    FILE *capfile;
    int caplen, sync;
    u_int res;
    pcap_send_queue *squeue;
    struct pcap_pkthdr *pktheader;
    const u_char *pktdata;
    float cpu_time;
    u_int npacks = 0;

    /* 检查命令行参数的合法性 */
    if (argc <= 2 || argc >= 5)
    {
    usage();
    return -1;
    }

    /* 获取捕获文件长度 */
    capfile=fopen(argv[1],"rb");
    if(!capfile)
    {
    printf("Capture file not found!\n");
    return -1;
    }

    fseek(capfile , 0, SEEK_END);
    caplen= ftell(capfile)- sizeof(struct pcap_file_header);
    fclose(capfile);

    /* 检查时间戳是否合法 */
    if(argc == 4 && argv[3][0] == 's')
    sync = TRUE;
    else
    sync = FALSE;

    /* 开始捕获 */
    /* 根据WinPcap的新语法创建一个源字符串 */
    if ( pcap_createsrcstr( source, // 源字符串
    PCAP_SRC_FILE, // 我们要打开的文件
    NULL, // 远程主机
    NULL, // 远程主机的端口
    argv[1], // 我们要打开的文件名
    errbuf // 错误缓冲
    ) != 0)
    {
    fprintf(stderr,"\nError creating a source string\n");
    return -1;
    }

    /* 打开捕获文件 */
    if ( (indesc= pcap_open(source, 65536, PCAP_OPENFLAG_PROMISCUOUS, 1000, NULL, errbuf) ) == NULL)
    {
    fprintf(stderr,"\nUnable to open the file %s.\n", source);
    return -1;
    }

    /* 打开要输出的适配器 */
    if ( (outdesc= pcap_open(argv[2], 100, PCAP_OPENFLAG_PROMISCUOUS, 1000, NULL, errbuf) ) == NULL)
    {
    fprintf(stderr,"\nUnable to open adapter %s.\n", source);
    return -1;
    }

    /* 检查MAC的类型 */
    if (pcap_datalink(indesc) != pcap_datalink(outdesc))
    {
    printf("Warning: the datalink of the capture differs from the one of the selected interface.\n");
    printf("Press a key to continue, or CTRL+C to stop.\n");
    getchar();
    }

    /* 分配发送队列 */
    squeue = pcap_sendqueue_alloc(caplen);

    /* 从文件中将数据包填充到发送队列 */
    while ((res = pcap_next_ex( indesc, &pktheader, &pktdata)) == 1)
    {
    if (pcap_sendqueue_queue(squeue, pktheader, pktdata) == -1)
    {
    printf("Warning: packet buffer too small, not all the packets will be sent.\n");
    break;
    }

    npacks++;
    }

    if (res == -1)
    {
    printf("Corrupted input file.\n");
    pcap_sendqueue_destroy(squeue);
    return -1;
    }

    /* 发送队列 */

    cpu_time = (float)clock ();

    if ((res = pcap_sendqueue_transmit(outdesc, squeue, sync)) < squeue->len)
    {
    printf("An error occurred sending the packets: %s. Only %d bytes were sent\n", pcap_geterr(outdesc), res);
    }

    cpu_time = (clock() - cpu_time)/CLK_TCK;

    printf ("\n\nElapsed time: %5.3f\n", cpu_time);
    printf ("\nTotal packets generated = %d", npacks);
    printf ("\nAverage packets per second = %d", (int)((double)npacks/cpu_time));
    printf ("\n");

    /* 释放发送队列 */
    pcap_sendqueue_destroy(squeue);

    /* 关闭输入文件 */
    pcap_close(indesc);

    /*
    * 释放输出适配器
    * IMPORTANT: 记得一定要关闭适配器,不然就不能保证
    * 所有的数据包都回被发送出去
    */
    pcap_close(outdesc);


    return 0;
    }


    void usage()
    {

    printf("\nSendcap, sends a libpcap/tcpdump capture file to the net. Copyright (C) 2002 Loris Degioanni.\n");
    printf("\nUsage:\n");
    printf("\t sendcap file_name adapter [s]\n");
    printf("\nParameters:\n");
    printf("\nfile_name: the name of the dump file that will be sent to the network\n");
    printf("\nadapter: the device to use. Use \"WinDump -D\" for a list of valid devices\n");
    printf("\ns: if present, forces the packets to be sent synchronously, i.e. respecting the timestamps in the dump file. This option will work only under Windows NTx.\n\n");

    exit(0);
    }
    复制代码

          介绍一个新的数据类型,pcap_send_queue结构体,下面是该结构体的定义。

    复制代码
    /*!
    \brief A queue of raw packets that will be sent to the network with pcap_sendqueue_transmit().
    */
    struct pcap_send_queue
    {
    u_int maxlen; ///< Maximum size of the the queue, in bytes. This variable contains the size of the buffer field.
    u_int len; ///< Current size of the queue, in bytes.
    char *buffer; ///< Buffer containing the packets to be sent.
    };

    typedef struct pcap_send_queue pcap_send_queue;
    复制代码

          pcap_send_queue结构体正如其名,它是发送数据队列,具体字段的含义源码中已有说明。
          我们再来看看这个发送队列的生命周期~~

          1. 创建发送队列。通过调用pcap_sendqueue_alloc()函数:

              pcap_send_queue* pcap_sendqueue_alloc(u_int memsize);
             其中memsize表示申请队列的大小,返回的是队列结构体指针。

          2. 向队列加入要发送的数据包。通过调用pcap_sendqueue_queue()函数:

               int pcap_sendqueue_queue(pcap_send_queue* queue, const struct pcap_pkthdr *pkt_header, const u_char *pkt_data);

              queue表示指向发送队列的指针;pkt_header表示指向pcap_pkthdr结构体(dump文件中数据包的首部)的指针;pkt_data即为将要发送的数据。

              本例中是从文件中读取pkt_header和pkt_data后再将数据包添加至队列中的。

          3. 发送数据队列。通过调用pcap_sendqueue_transmit()函数:

               u_int pcap_sendqueue_transmit(pcap_t *p, pcap_send_queue* queue, int sync);

              这里只需要注意第三个参数sync。如果非0,则发送是同步进行的,也就是说,时间戳相符的数据包才会被处理。当然这样会消耗大量的CPU资源,因为同步操作由内核驱动中“忙等”循环实现。尽管这个操作对CPU要求很高,但它对数据包的处理结果通常是很精确的。(通常在数微秒左右,或更少)

              需要注意的是利用pcap_sendqueue_transmit()发送数据队列比通过send_packet()发送一系列数据包要高效得多,这是因为发送队列保存在内核级的缓冲区,减少了上下文交换的次数。

          4. 释放数据队列。通过调用pcap_sendqueue_destroy()函数:

               void pcap_sendqueue_destroy(pcap_send_queue* queue);

          另外需要注意到的一点是,程序中比较了dump文件的链路层和发送数据包的适配器的链路层,如果不同则会打印warning,因为这样发送将毫无意义可言。

          最后看一下第二个程序在本机上运行的结果:

    作者:黑剑 
    出处:http://www.cnblogs.com/blacksword/ 
    本文版权归作者和博客园共有,欢迎转载,但未经作者同意必须保留此段声明,且在文章页面明显位置给出原文连接,否则保留追究法律责任的权利。

    展开全文
  • 创建一个监听器继承ServletContextListener类 自动重写ServletContextListener中的contextInitialized(),contextDestroyed()两个方法。 contextInitialized()启动时的方法内容。 contextDestroyed()关闭服务时的...
  • 被动代理守护程序(pproxyd)已移至GitHub(https://github.com/rondilley/pproxyd)。此工具可读取pcap格式的文件或直接从网络读取数据包,组合基于Web的流量并生成鱿鱼代理样式日志。
  • 同时还可以按照游戏数据包结构创建数据包,再模拟客户端发送给游戏服务器,这个过程其实就是一个封包的过程。 封包的技术是实现第二类游戏外挂的最核心的技术。封包技术涉及的知识很广泛,实现方法也很多,如挡截...
  • 创建了一个网络模拟器,其中节点网络生成多个数据包并传输有效负载。 节点和数据包 节点由节点结构实现,并维护在链表中。 每个节点维护所有已生成的数据包,并一次传输一个数据包数据包数据包结构实现,并...
  • Angry Analyzer是一个wifi数据包分析工具,可以从捕获的数据包字段中创建图表。 可以使用Aircrack-ng工具将wifi捕获的数据包导出到csv文件中,而愤怒的分析器可以从该csv文件中绘制图形。 特别感谢Pentester ...
  • 过滤数据包

    2012-04-23 23:34:14
    过滤数据包   WinPcap和Libpcap的最强大的特性之一,是拥有过滤数据包的引擎。 它提供了有效的方法去获取网络中的某些数据包,这也是WinPcap捕获机制中的一个组成部分。 用来过滤数据包的函数是 ...
  • http 数据包

    千次阅读 2018-03-26 14:49:25
    一、访问网站发送的数据包 二、发送HTTP请求 通过连接,客户端写一个ASCII文本请求行,后跟0或多个HTTP头标,一个空行和实现请求的任意数据。 一个请求由四个部分组成:请求行、请求头标、空行和请求数据 1....
  • 数据包使用 data() #显示R语言自带的数据包 datasets library(datasets) #加载datasets数据包 data(package="mtcars") #加载完成后才可以调用,调用mtcars数据包 矩阵的运算 x1 <- c(1:20) #创建一个向量,无...
  • LWIP网络数据包

    千次阅读 2018-04-16 16:32:12
    数据包的种类和大小五花八门:首先是网卡上接收的原始数据包,它可以是包含TCP报文的长达数百字节的数据包,也可以是仅有几十字节的ARP数据包;然后是要发送的数据包,上层应用可能是各种各样的数据交给LWIP内核发送...
  • 路由器一旦建立了相邻关系,即可创建链路状态数据包,其中包含与该链路相关的链路状态信息,包含链路类型、IP地址、子网掩码、开销,本篇为大家介绍阿尔法路由器在创建链路时数据包的传输特点,有兴趣了解的网友可以...
  • JMemoryPacket(int id, java.lang.String hexdump) Creates a new fully decoded packet from the hexdump data provided

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 176,909
精华内容 70,763
关键字:

如何创建数据包