Inheritance: AProtocolHeader
Example #1
0
        /// <summary>
        /// Compute checksum of UDP header.
        /// </summary>
        public static ushort SumHeader(UdpHeader udpHeader)
        {
            // Do not include existing checksum.
            int x = udpHeader.srcPort + udpHeader.dstPort + udpHeader.length;

            return((ushort)((x >> 16) + x));
        }
Example #2
0
        internal void SendCommand(UdpCommandType cmd)
        {
            if (CheckCanSend(true) == UdpSendFailReason.None)
            {
                UdpStream stream = socket.GetWriteStream(mtu << 3, UdpSocket.HeaderBitSize);
                stream.WriteByte((byte)cmd, 8);

                UdpHeader header = MakeHeader(false);
                header.Pack(stream, socket);

                UdpHandle handle = MakeHandle(ref header);
                handle.Object = null;

                if (SendStream(stream, handle, false))
                {
                    // track stats
                    stats.PacketSent((uint)stream.Ptr >> 3);
                    socket.Statistics.PacketSent((uint)stream.Ptr >> 3);
                }
                else
                {
                    // should we do something here?????
                }
            }
        }
Example #3
0
        // set the checksum field, totalSize covers all the fields for
        // which the checksum is calculated
        // offset is points to the beginning of the IP header (!!!)
        // Should be called after the UDP header + data have been written
        public static void SetUdpChecksum(byte[] !packet,
                                          int ipOffset,
                                          ref UdpHeader udpHeader)
        {
            // sum IP pseudo
            ushort ipPayloadSize = 0;
            ushort headerSum     = IPFormat.SumPseudoHeader(packet, ipOffset,
                                                            ref ipPayloadSize);

            Debug.Assert(((ushort)udpHeader.length) == ipPayloadSize);

            // now add it to the udp header + data
            int ipHeaderSize = (packet[ipOffset] & 0xf) * 4;
            int udpOffset    = ipOffset + ipHeaderSize;

            Debug.Assert(packet[udpOffset + 6] == 0);
            Debug.Assert(packet[udpOffset + 7] == 0);

            ushort payloadSum = IPFormat.SumShortValues(packet, udpOffset,
                                                        ipPayloadSize);

            udpHeader.checksum = IPFormat.ComplementAndFixZeroChecksum(
                IPFormat.SumShortValues(headerSum, payloadSum));

            packet[udpOffset + 6] = (byte)(udpHeader.checksum >> 8);
            packet[udpOffset + 7] = (byte)(udpHeader.checksum & 0xff);
        }
Example #4
0
        private static bool readNetworkHeaders(BinaryReader binaryReader)
        {
            EthernetHeader ethernetHeader = EthernetHeader.read(binaryReader);

            // Skip non-IP packets
            if (ethernetHeader.proto != 8)
            {
                throw new InvalidDataException();
            }

            IpHeader ipHeader = IpHeader.read(binaryReader);

            // Skip non-UDP packets
            if (ipHeader.proto != 17)
            {
                throw new InvalidDataException();
            }

            UdpHeader udpHeader = UdpHeader.read(binaryReader);

            bool isSend = (udpHeader.dPort >= 9000 && udpHeader.dPort <= 9013);
            bool isRecv = (udpHeader.sPort >= 9000 && udpHeader.sPort <= 9013);

            // Skip non-AC-port packets
            if (!isSend && !isRecv)
            {
                throw new InvalidDataException();
            }

            return(isSend);
        }
        public UDPDisplayPacket(IpV4Header ipHeader, UdpHeader udpHeader)
        {
            Destination     = ipHeader.DestinationAddress;
            DestinationPort = string.Format("{0} {1}", udpHeader.DestinationPort, UDPPortLookup.GetPortName(udpHeader.DestinationPort));
            Source          = ipHeader.SourceAddress;
            SourcePort      = string.Format("{0} {1}", udpHeader.SourcePort, UDPPortLookup.GetPortName(udpHeader.SourcePort));
            Type            = ipHeader.ProtocolType;
            StringBuilder retVal = new StringBuilder();

            if (udpHeader.SourcePort == 520 || udpHeader.DestinationPort == 520)
            {
                //RIP Protocol
            }
            else if (udpHeader.SourcePort == 161 || udpHeader.DestinationPort == 161 ||
                     udpHeader.SourcePort == 162 || udpHeader.DestinationPort == 162 ||
                     udpHeader.SourcePort == 10161 || udpHeader.DestinationPort == 10161 ||
                     udpHeader.SourcePort == 10162 || udpHeader.DestinationPort == 10162)
            {
                //SNMP Protocol
            }
            else if (udpHeader.SourcePort == 67 || udpHeader.DestinationPort == 67 ||
                     udpHeader.SourcePort == 68 || udpHeader.DestinationPort == 68)
            {
                //DHCP Protocol
            }
            else if (udpHeader.DestinationPort == 53 || udpHeader.SourcePort == 53)
            {
                AppendDNSInfo(udpHeader.Data, retVal);
            }
            AppendUDPInfo(udpHeader, retVal);
            AppendIPInfo(ipHeader, retVal);
            AppendData(udpHeader.Data, retVal);
            Data = retVal.ToString();
        }
Example #6
0
        // writes a UDP header to a packet
        // return the next place to write to
        // the checksum must be later calculated
        // (over all the octets of the pseudo header, UDP header and data)
        public static int WriteUdpHeader(byte[] !buffer,
                                         int offset,
                                         ref UdpHeader header)
        {
            // check we have enough packet space
            if (buffer.Length - offset < Size)
            {
                return(offset);
            }

            int o = offset;

            buffer[o++] = (byte)(((ushort)header.srcPort) >> 8);
            buffer[o++] = (byte)(((ushort)header.srcPort) & 0xff);

            buffer[o++] = (byte)(((ushort)header.dstPort) >> 8);
            buffer[o++] = (byte)(((ushort)header.dstPort) & 0xff);

            buffer[o++] = (byte)(((ushort)header.length) >> 8);
            buffer[o++] = (byte)(((ushort)header.length) & 0xff);

            // checksum
            buffer[o++] = 0;
            buffer[o++] = 0;

            return(o);
        }
Example #7
0
 /// <summary>
 /// ACK报文构造
 /// </summary>
 /// <param name="conv">会话ID</param>
 /// <param name="sn">msgID</param>
 /// <param name="cmd">协议</param>
 /// <param name="headerCode">前后端消息ID</param>
 public UdpNetMessage(long conv, uint sn, ushort cmd, UdpHeader headerCode)
 {
     Conv       = conv;
     SN         = sn;
     Cmd        = cmd;
     HeaderCode = headerCode;
 }
Example #8
0
        internal void SendObject(object o)
        {
            serializer.SendNext(o);

            while (serializer.HasQueuedObjects)
            {
                UdpSendFailReason reason = CheckCanSend(false);

                if (reason != UdpSendFailReason.None)
                {
                    while (serializer.HasQueuedObjects)
                    {
                        socket.Raise(UdpEvent.PUBLIC_OBJECT_SEND_FAILED, this, serializer.NextObject(), reason);
                    }

                    break;
                }

                UdpStream stream     = socket.GetWriteStream(mtu << 3, UdpSocket.HeaderBitSize);
                var       initialPtr = stream.Ptr; // Erhune: added info
                object    obj        = serializer.NextObject();

                if (serializer.Pack(stream, ref obj))
                {
                    if (stream.Overflowing && (socket.Config.AllowPacketOverflow == false))
                    {
                        UdpLog.Error("Stream to {0} is overflowing (InitialPtr={1} Ptr={2} Len={3}), not sending {4}",
                                     endpoint.ToString(), initialPtr, stream.Ptr, stream.Length, obj); // Erhune: added info
                        socket.Raise(UdpEvent.PUBLIC_OBJECT_SEND_FAILED, this, obj, UdpSendFailReason.StreamOverflow);
                        return;
                    }

                    UdpHeader header = MakeHeader(true);
                    header.Pack(stream, socket, shouldSendClock);

                    UdpHandle handle = MakeHandle(ref header);
                    handle.Object = obj;

                    if (SendStream(stream, handle, alwaysSendMtu))
                    {
                        // track stats
                        stats.PacketSent((uint)stream.Ptr >> 3);
                        socket.Statistics.PacketSent((uint)stream.Ptr >> 3);

                        // push object to user thread
                        socket.Raise(UdpEvent.PUBLIC_OBJECT_SENT, this, obj);
                    }
                    else
                    {
                        socket.Raise(UdpEvent.PUBLIC_OBJECT_SEND_FAILED, this, obj, UdpSendFailReason.SocketError);
                    }
                }
                else
                {
                    socket.Raise(UdpEvent.PUBLIC_OBJECT_SEND_FAILED, this, obj, UdpSendFailReason.SerializerReturnedFalse);
                }
            }
        }
        public static byte[] AddUdpIpHeader(IPEndPoint srcAdr, IPEndPoint dstAdr, byte[] packet)
        {
            srcAdr = new IPEndPoint(IPAddress.Parse("25.175.152.176"), 9959);
            dstAdr = new IPEndPoint(IPAddress.Parse("25.175.152.176"), 9958);

            byte[] builtPacket = new byte[packet.Length];

            ArrayList headerList = new ArrayList();

            UdpHeader udpPacket = new UdpHeader();

            udpPacket.SourcePort      = (ushort)srcAdr.Port;
            udpPacket.DestinationPort = (ushort)dstAdr.Port;
            udpPacket.Length          = (ushort)(UdpHeader.UdpHeaderLength + packet.Length);
            udpPacket.Checksum        = 0;

            if (srcAdr.AddressFamily == AddressFamily.InterNetwork)
            {
                Ipv4Header ipv4Packet = new Ipv4Header();
                ipv4Packet.Version     = 4;
                ipv4Packet.Protocol    = (byte)ProtocolType.Udp;
                ipv4Packet.Ttl         = 2;
                ipv4Packet.Offset      = 0;
                ipv4Packet.Length      = (byte)Ipv4Header.Ipv4HeaderLength;
                ipv4Packet.TotalLength =
                    Convert.ToUInt16(Ipv4Header.Ipv4HeaderLength + UdpHeader.UdpHeaderLength + packet.Length);
                ipv4Packet.SourceAddress      = srcAdr.Address;
                ipv4Packet.DestinationAddress = dstAdr.Address;

                udpPacket.Ipv4PacketHeader = ipv4Packet;

                headerList.Add(ipv4Packet);
            }
            else if (srcAdr.AddressFamily == AddressFamily.InterNetworkV6)
            {
                Ipv6Header ipv6Packet = new Ipv6Header();

                ipv6Packet.Version            = 6;
                ipv6Packet.TrafficClass       = 1;
                ipv6Packet.Flow               = 2;
                ipv6Packet.HopLimit           = 2;
                ipv6Packet.NextHeader         = (byte)ProtocolType.Udp;
                ipv6Packet.PayloadLength      = (ushort)(UdpHeader.UdpHeaderLength + packet.Length);
                ipv6Packet.SourceAddress      = srcAdr.Address;
                ipv6Packet.DestinationAddress = dstAdr.Address;

                udpPacket.Ipv6PacketHeader = ipv6Packet;

                headerList.Add(ipv6Packet);
            }

            headerList.Add(udpPacket);

            builtPacket = udpPacket.BuildPacket(headerList, packet);

            return(builtPacket);
        }
Example #10
0
        UdpHandle MakeHandle(ref UdpHeader header)
        {
            UdpHandle handle = new UdpHandle();

            handle.IsObject    = header.IsObject;
            handle.ObjSequence = header.ObjSequence;
            handle.SendTime    = header.Now;
            return(handle);
        }
Example #11
0
    public static UdpHeader read(BinaryReader binaryReader)
    {
        UdpHeader newObj = new UdpHeader();

        newObj.sPort = Util.byteSwapped(binaryReader.ReadUInt16());
        newObj.dPort = Util.byteSwapped(binaryReader.ReadUInt16());
        newObj.len   = Util.byteSwapped(binaryReader.ReadUInt16());
        newObj.crc   = Util.byteSwapped(binaryReader.ReadUInt16());
        return(newObj);
    }
Example #12
0
 private List<byte> GetPseudoHeaderBytes(UdpHeader udpHeader, uint length)
 {
     var currentData = new List<byte>();
     currentData.AddRange(udpHeader.PseudoSourcePort.GetBytes());
     currentData.AddRange(udpHeader.PseudoDestinationPort1.GetBytes());
     currentData.Add(0);
     currentData.Add(17);
     currentData.AddRange(GetBytes(length));
     return currentData;
 }
Example #13
0
        /// <summary>
        /// 编码默认消息
        /// </summary>
        /// <param name="headerCode">操作码</param>
        /// <param name="message">二进制业务报文</param>
        /// <returns>编码成功后的数据</returns>
        public static UdpNetMessage EncodeMessage(UdpHeader headerCode, byte[] message)
        {
            var udpNetMsg = CosmosEntry.ReferencePoolManager.Spawn <UdpNetMessage>();

            udpNetMsg.Cmd         = UdpProtocol.MSG;
            udpNetMsg.Len         = 0;
            udpNetMsg.HeaderCode  = headerCode;
            udpNetMsg.ServiceData = message;
            udpNetMsg.EncodeMessage();
            return(udpNetMsg);
        }
Example #14
0
    /// <summary>
    ///
    /// </summary>
    /// <param name="udpData"></param>
    /// <param name="bytesCopied"></param>
    /// <returns></returns>
    static public UdpHeader Create(byte[] udpData, ref int bytesCopied)
    {
        UdpHeader udpPacketHeader = new UdpHeader();

        udpPacketHeader.srcPort     = BitConverter.ToUInt16(udpData, 0);
        udpPacketHeader.destPort    = BitConverter.ToUInt16(udpData, 2);
        udpPacketHeader.udpLength   = BitConverter.ToUInt16(udpData, 4);
        udpPacketHeader.udpChecksum = BitConverter.ToUInt16(udpData, 6);

        return(udpPacketHeader);
    }
Example #15
0
        void AckHandles(UdpHeader header, bool updateRtt)
        {
            while (!sendWindow.Empty)
            {
                UdpHandle handle = sendWindow.Peek();

                int seqDistance = UdpMath.SeqDistance(handle.ObjSequence, header.AckSequence, UdpHeader.SEQ_PADD);
                if (seqDistance > 0)
                {
                    break;
                }

                if (handle.IsObject)
                {
                    if (seqDistance <= -UdpSocket.AckRedundancy)
                    {
                        // track stats
                        stats.PacketLost();
                        socket.Statistics.PacketLost();

                        // handle lost
                        ObjectLost(handle.Object);
                    }
                    else
                    {
                        if ((header.AckHistory & (1UL << -seqDistance)) != 0UL)
                        {
                            // track stats
                            stats.PacketDelivered();
                            socket.Statistics.PacketDelivered();

                            // handle delivered objects
                            ObjectDelivered(handle.Object);
                        }
                        else
                        {
                            // track stats
                            stats.PacketLost();
                            socket.Statistics.PacketLost();

                            // handle
                            ObjectLost(handle.Object);
                        }
                    }
                }

                if (seqDistance == 0 && header.AckTime > 0)
                {
                    UpdatePing(recvTime, handle.SendTime, header.AckTime);
                }

                sendWindow.Dequeue();
            }
        }
Example #16
0
 public static bool ReadUdpHeader(IBuffer !buf,
                                  out UdpHeader udpHeader)
 {
     udpHeader = new UdpHeader();
     if (buf.ReadNet16(out udpHeader.srcPort) &&
         buf.ReadNet16(out udpHeader.dstPort) &&
         buf.ReadNet16(out udpHeader.length) &&
         buf.ReadNet16(out udpHeader.checksum))
     {
         return(true);
     }
     return(false);
 }
Example #17
0
        public override Handler Parse()
        {
            var header = new UdpHeader();
            header.SourcePort = LoadUInt16ReversingEndian();
            header.DestinationPort = LoadUInt16ReversingEndian();
            header.Len = LoadUInt16ReversingEndian();
            header.Crc = LoadUInt16ReversingEndian();

            SetValue(UdpHeaderProperty, header);

            return GetNextHandler();
            //return GetNextHandler(header);
        }
        void FrmMain_Receive(object sender, byte[] e)
        {
            byte[] newBytes = new byte[e.Length - 20];
            Buffer.BlockCopy(builtPacket, 20, newBytes, 0, newBytes.Length);
            e = newBytes;

            int x         = 0;
            var udpHeader = UdpHeader.Create(e, ref x);

            newBytes = new byte[e.Length - 8];
            Buffer.BlockCopy(e, 8, newBytes, 0, newBytes.Length);
            e = newBytes;

            if (udpHeader.SourcePort != 9959)
            {
                return;
            }

            lbTamanho.Invoke(new Action(() =>
            {
                txtConteudo.Clear();

                lbTamanho.Text = e.Length.ToString();
                lbCrc.Text     = udpHeader.Checksum.ToString();

                txtConteudo.Text += "Valor recebido: ";
                txtConteudo.Text += Encoding.Default.GetString(e, 1, e.Length - 1 - e[0]);
                txtConteudo.Text += Environment.NewLine;

                byte ecBytes      = e[0];
                txtConteudo.Text += "Bytes de correção: " + ecBytes;
                txtConteudo.Text += Environment.NewLine;

                int[] realPayloadInt       = e.Select(d => (int)d).ToArray();
                ReedSolomonDecoder decoder = new ReedSolomonDecoder(GenericGf.QrCodeField256);
                if (decoder.Decode(realPayloadInt, ecBytes))
                {
                    byte[] data    = realPayloadInt.Select(d => (byte)d).ToArray();
                    byte[] message = new byte[data.Length - 1 - ecBytes];
                    Buffer.BlockCopy(data, 1, message, 0, message.Length);
                    txtConteudo.Text += "Mensagem decodificada: ";
                    txtConteudo.Text += Encoding.Default.GetString(message);
                }
                else
                {
                    txtConteudo.Text += "Não foi possivel recuperar a mensagem original";
                }
            }));
        }
Example #19
0
        static MemoryStream GetPayloadAndUpdateHeader(MemoryStream ms, long length, UdpHeader header)
        {
            if (length > MAX_PAYLOAD)
            {
                throw new ArgumentException("Payload length exceeds 0x4DC maximum");
            }

            byte[] buf = new byte[length];
            ms.Read(buf, 0, buf.Length);

            var payload = new MemoryStream(buf);

            header.PayloadSize = ( ushort )payload.Length;
            header.MsgSize     = ( uint )payload.Length;
            return(payload);
        }
Example #20
0
 /// <summary>
 /// MSG报文构造
 /// </summary>
 /// <param name="conv">会话ID</param>
 /// <param name="sn">msg序号</param>
 /// <param name="cmd">协议ID</param>
 /// <param name="headerCode">操作码</param>
 /// <param name="message">消息内容</param>
 public UdpNetMessage(long conv, uint sn, byte cmd, UdpHeader headerCode, byte[] message)
 {
     if (message == null)
     {
         Len = 0;
     }
     else
     {
         Len = (ushort)message.Length;
     }
     Conv        = conv;
     SN          = sn;
     Cmd         = cmd;
     ServiceData = message;
     HeaderCode  = headerCode;
 }
Example #21
0
        bool ParseHeader(UdpStream stream)
        {
            // we should always start at ptr 0
            UdpAssert.Assert(stream.Ptr == 0);

            UdpHeader header = new UdpHeader();

            header.Unpack(stream, socket);

            // after unpacking the header, the pointer should be at the header size
            UdpAssert.Assert(stream.Ptr == UdpSocket.HeaderBitSize);

            int seqDistance = UdpMath.SeqDistance(header.ObjSequence, recvSequence, UdpHeader.SEQ_PADD);

            // we have to be within window size
            if (seqDistance > socket.Config.PacketWindow || seqDistance < -socket.Config.PacketWindow)
            {
                ConnectionError(UdpConnectionError.SequenceOutOfBounds, string.Format("seqDistance: {0}, socket.Config.PacketWindow: {1}, header.ObjSequence: {2}, recvSequence: {3}", seqDistance, socket.Config.PacketWindow, header.ObjSequence, recvSequence));
                return(false);
            }

            // this is an old packet
            if (seqDistance <= 0)
            {
                return(false);
            }

            // update receive history
            if (seqDistance >= UdpSocket.AckRedundancy)
            {
                recvHistory = 1UL;
            }
            else
            {
                recvHistory = (recvHistory << seqDistance) | 1UL;
            }

            // update our receive stats
            recvSequence       = header.ObjSequence;
            recvSinceLastSend += 1;

            // ack sent objects
            AckHandles(header, true);

            return(true);
        }
Example #22
0
        UdpHeader MakeHeader(bool isObject)
        {
            UdpHeader header = new UdpHeader();

            header.IsObject    = isObject;
            header.AckHistory  = recvHistory;
            header.AckSequence = recvSequence;
            header.ObjSequence = UdpMath.SeqNext(sendSequence, UdpHeader.SEQ_MASK);
            header.Now         = socket.GetCurrentTime();

            if (recvTime > 0)
            {
                header.AckTime = (ushort)UdpMath.Clamp(header.Now - recvTime, 0, socket.Config.MaxPing);
            }

            return(header);
        }
Example #23
0
        /// <summary>
        /// Write IP and UDP headers and payload data into a
        /// byte array.
        /// </summary>
        /// <param name="pkt">Array of bytes representing
        /// packet to be sent.</param>
        /// <param name="offset">Offset of IP Header within
        /// packet.</param>
        /// <param name="ipHeader">IP header to be written
        /// to packet.</param>
        /// <param name="udpHeader">UDP header to be written
        /// to packet.</param>
        /// <param name="payload">Payload of UDP Packet.</param>
        /// <param name="payloadOffset">The offset of start
        /// of the payload data within the payload
        /// array.</param>

        /// <param name="payloadLength">The size of the payload data.</param>
        public static void WriteUdpPacket(byte[] !pkt,
                                          int offset,
                                          IPFormat.IPHeader !ipHeader,
                                          ref UdpHeader udpHeader,
                                          byte[] payload,
                                          int payloadOffset,
                                          int payloadLength)
        {
            int udpStart = IPFormat.WriteIPHeader(pkt, offset, ipHeader);
            int udpEnd   = WriteUdpHeader(pkt, udpStart, ref udpHeader);

            if (pkt != payload || udpEnd != payloadOffset)
            {
                Array.Copy(payload, payloadOffset,
                           pkt, udpEnd, payloadLength);
            }
            SetUdpChecksum(pkt, offset, ref udpHeader);
        }
Example #24
0
 // construct a UDP header from a packet
 // if something is wrong, return the same start value
 public static int ReadUdpHeader(byte[] !packet,
                                 int udpOffset,
                                 out UdpHeader udpHeader)
 {
     // initialize an UdpHeader struct
     udpHeader         = new UdpHeader();
     udpHeader.srcPort =
         (ushort)((int)(packet[udpOffset + 0] << 8) |
                  (int)(packet[udpOffset + 1]));
     udpHeader.dstPort =
         (ushort)((int)(packet[udpOffset + 2] << 8) |
                  (int)(packet[udpOffset + 3]));
     udpHeader.length =
         (ushort)((int)(packet[udpOffset + 4] << 8) |
                  (int)(packet[udpOffset + 5]));
     udpHeader.checksum =
         (ushort)((int)(packet[udpOffset + 6] << 8) |
                  (int)(packet[udpOffset + 7]));;
     return(udpOffset + Size);
 }
Example #25
0
        /// <summary>
        /// Initializes a new instance of the <see cref="UdpPacket"/> class with
        /// information from the memory stream.
        ///
        /// Header is populated from the MemoryStream
        /// </summary>
        /// <param name="ms">The stream containing the packet and it's payload data.</param>
        public UdpPacket(MemoryStream ms)
        {
            Header = new UdpHeader();

            try
            {
                Header.Deserialize(ms);
            }
            catch (Exception)
            {
                return;
            }

            if (this.Header.Magic != UdpHeader.MAGIC)
            {
                return;
            }

            SetPayload(ms, Header.PayloadSize);
        }
Example #26
0
        /// <summary>
        /// Initializes a new instance of the <see cref="UdpPacket"/> class with
        /// information from the memory stream.
        ///
        /// Header is populated from the MemoryStream
        /// </summary>
        /// <param name="ms">The stream containing the packet and it's payload data.</param>
        public UdpPacket(MemoryStream ms)
        {
            Header = new UdpHeader();

            try
            {
                Header.Deserialize(ms);
            }
            catch (Exception)
            {
                Payload = new MemoryStream();
                return;
            }

            if (this.Header.Magic != UdpHeader.MAGIC)
            {
                Payload = new MemoryStream();
                return;
            }

            Payload = GetPayloadAndUpdateHeader(ms, Header.PayloadSize, Header);
        }
Example #27
0
        public static bool IsChecksumValid(IPFormat.IPHeader !ipHeader,
                                           UdpHeader udpHeader,
                                           NetPacket !payload)
        {
            // Compute partial checksums of headers
            ushort checksum = IPFormat.SumPseudoHeader(ipHeader);

            checksum = IPFormat.SumShortValues(checksum,
                                               UdpFormat.SumHeader(udpHeader));

            // Checksum payload
            int length = payload.Available;
            int end    = length & ~1;
            int i      = 0;

            while (i != end)
            {
                int x = ((((int)payload.PeekAvailable(i++)) << 8) +
                         (int)payload.PeekAvailable(i++));

                checksum = IPFormat.SumShortValues(checksum, (ushort)x);
            }

            if (i != length)
            {
                int x = (((int)payload.PeekAvailable(i++)) << 8);
                checksum = IPFormat.SumShortValues(checksum, (ushort)x);
            }

            checksum = IPFormat.ComplementAndFixZeroChecksum(checksum);

            if (udpHeader.checksum != checksum)
            {
                DebugStub.WriteLine("Bad UDP checksum {0:x4} != {1:x4}",
                                    __arglist(udpHeader.checksum, checksum));
            }
            return(udpHeader.checksum == checksum);
        }
Example #28
0
        public void Execute()
        {
            Packet         packet;
            EthernetHeader eth;
            IPHeader       ip;

            Flow      key = new Flow();
            FlowStats stats;

            try {
                //BinaryReader log = new BinaryReader(new FileStream(@"c:\users\gavin\desktop\20081006.dat", FileMode.Open, FileAccess.Read));
                while (!terminated)
                {
                    try {
                        /*packet = new Packet();
                         * packet.Time = log.ReadInt64();
                         * packet.Length = log.ReadInt32();
                         * packet.Data = log.ReadBytes(log.ReadInt32());*/
                        packet = pcap.Next();
                    } catch (Exception e) {
                        packet = null;
                        throw;
                    }
                    if (packet != null)
                    {
                        if (dump != null)
                        {
                            dump.Write(packet.Time);
                            dump.Write(packet.Length);
                            int i = Math.Min(packet.Data.Length, 64);
                            dump.Write(i);
                            dump.Write(packet.Data, 0, i);
                            dump.Flush();
                        }

                        eth = new EthernetHeader(packet.Data);

                        if (eth.Protocol == (int)EthernetProtocol.IP)
                        {
                            ip = new IPHeader(eth);
                            if (ip.Protocol == IPProtocol.Tcp)
                            {
                                TcpHeader tcp = new TcpHeader(ip);
                                key = new Flow(ip, tcp);

                                stats = tracker.Resolve(key, packet.Time);

                                stats.Last = packet.Time;
                                stats.Packets++;
                                // Bytes at IP, including IP header
                                stats.Bytes += ip.Length;

                                #region debugging

                                /*
                                 * // TODO: Verify sorted order of queue - should be right now
                                 * FlowStats check = queue.Head;
                                 * while (check != null) {
                                 * if (check.Next != null) Debug.Assert(check.Last >= check.Next.Last);
                                 * check = check.Next;
                                 * }
                                 */
                                #endregion
                            }
                            else if (ip.Protocol == IPProtocol.Udp)
                            {
                                try {
                                    UdpHeader udp = new UdpHeader(ip);
                                    key = new Flow(ip, udp);

                                    stats = tracker.Resolve(key, packet.Time);

                                    stats.Last = packet.Time;
                                    stats.Packets++;
                                    // Bytes at IP, including IP header
                                    stats.Bytes += ip.Length;
                                } catch (IndexOutOfRangeException e) {
                                    using (StreamWriter errorLog = new StreamWriter(Path.Combine(LogFolder, "error.log"), true)) {
                                        errorLog.WriteLine(DateTime.Now);
                                        errorLog.WriteLine(e.Message);
                                        errorLog.WriteLine(e.StackTrace);
                                        errorLog.WriteLine();
                                    }

                                    if (dump != null)
                                    {
                                        dump.Write(packet.Time);
                                        dump.Write(packet.Length);
                                        dump.Write(packet.Data.Length);
                                        dump.Write(packet.Data, 0, packet.Data.Length);
                                        dump.Flush();
                                    }
                                } catch (Exception ex) {
                                }
                            }
                            else if (ip.Protocol == IPProtocol.Icmp)
                            {
                                // TODO: Deal with ICMP
                            }
                            else if (ip.Protocol == IPProtocol.Gre)
                            {
                                // TODO: Deal with GRE
                            }
                        }
                        else
                        {
                            // TODO: deal with non-IP
                        }

                        #region Age flows
                        /**/
                        while (tracker.Count > 0 && tracker.Tail.Last < packet.Time - ExpiryInterval)
                        {
                            stats = tracker.Tail;
                            Dump(stats);
                            tracker.Remove(stats);
                        }
                        writer.Flush();
                        /**/
                        #endregion
                    }
                    packets++;
                }
            } catch (EndOfStreamException e) {
                // TODO: nothing
            } catch (Exception e) {
                //debug.WriteLine("ERROR: " + e.Message);
                //debug.Flush();
                throw e;
            }
        }
Example #29
0
    public static byte[] Construct(IPAddress sourceAddress, ushort sourcePort, IPAddress destinationAddress, ushort destinationPort, byte[] payload)
    {
        var bindAddress = IPAddress.Any;

        // Make sure parameters are consistent
        //if ((sourceAddress.AddressFamily != destinationAddress.AddressFamily) || (sourceAddress.AddressFamily != bindAddress.AddressFamily))
        //{
        //    throw new Exception("Source and destination address families don't match!");
        //}

        // Start building the headers
        byte[]    builtPacket;
        UdpHeader udpPacket  = new UdpHeader();
        ArrayList headerList = new ArrayList();

        //Socket rawSocket = null;
        //SocketOptionLevel socketLevel = SocketOptionLevel.IP;

        // Fill out the UDP header first
        Console.WriteLine("Filling out the UDP header...");
        udpPacket.SourcePort      = sourcePort;
        udpPacket.DestinationPort = destinationPort;
        udpPacket.Length          = (ushort)(UdpHeader.UdpHeaderLength + payload.Length);
        udpPacket.Checksum        = 0;

        if (sourceAddress.AddressFamily == AddressFamily.InterNetwork)
        {
            Ipv4Header ipv4Packet = new Ipv4Header();

            // Build the IPv4 header
            Console.WriteLine("Building the IPv4 header...");
            ipv4Packet.Version            = 4;
            ipv4Packet.Protocol           = (byte)ProtocolType.Udp;
            ipv4Packet.Ttl                = 2;
            ipv4Packet.Offset             = 0;
            ipv4Packet.Length             = (byte)Ipv4Header.Ipv4HeaderLength;
            ipv4Packet.TotalLength        = (ushort)System.Convert.ToUInt16(Ipv4Header.Ipv4HeaderLength + UdpHeader.UdpHeaderLength + payload.Length);
            ipv4Packet.SourceAddress      = sourceAddress;
            ipv4Packet.DestinationAddress = destinationAddress;

            // Set the IPv4 header in the UDP header since it is required to calculate the
            //    pseudo header checksum
            Console.WriteLine("Setting the IPv4 header for pseudo header checksum...");
            udpPacket.ipv4PacketHeader = ipv4Packet;

            // Add IPv4 header to list of headers -- headers should be added in th order
            //    they appear in the packet (i.e. IP first then UDP)
            Console.WriteLine("Adding the IPv4 header to the list of header, encapsulating packet...");
            headerList.Add(ipv4Packet);
            //socketLevel = SocketOptionLevel.IP;
        }
        else if (sourceAddress.AddressFamily == AddressFamily.InterNetworkV6)
        {
            Ipv6Header ipv6Packet = new Ipv6Header();

            // Build the IPv6 header
            Console.WriteLine("Building the IPv6 header...");
            ipv6Packet.Version            = 6;
            ipv6Packet.TrafficClass       = 1;
            ipv6Packet.Flow               = 2;
            ipv6Packet.HopLimit           = 2;
            ipv6Packet.NextHeader         = (byte)ProtocolType.Udp;
            ipv6Packet.PayloadLength      = (ushort)(UdpHeader.UdpHeaderLength + payload.Length);
            ipv6Packet.SourceAddress      = sourceAddress;
            ipv6Packet.DestinationAddress = destinationAddress;

            // Set the IPv6 header in the UDP header since it is required to calculate the
            //    pseudo header checksum
            Console.WriteLine("Setting the IPv6 header for pseudo header checksum...");
            udpPacket.ipv6PacketHeader = ipv6Packet;

            // Add the IPv6 header to the list of headers - headers should be added in the order
            //    they appear in the packet (i.e. IP first then UDP)
            Console.WriteLine("Adding the IPv6 header to the list of header, encapsulating packet...");
            headerList.Add(ipv6Packet);
            //socketLevel = SocketOptionLevel.IPv6;
        }

        // Add the UDP header to list of headers after the IP header has been added
        Console.WriteLine("Adding the UDP header to the list of header, after IP header...");
        headerList.Add(udpPacket);

        // Convert the header classes into the binary on-the-wire representation
        Console.WriteLine("Converting the header classes into the binary...");
        builtPacket = udpPacket.BuildPacket(headerList, payload);

        /*
         * // Create the raw socket for this packet
         * Console.WriteLine("Creating the raw socket using Socket()...");
         * rawSocket = new Socket(sourceAddress.AddressFamily, SocketType.Raw, ProtocolType.Udp);
         *
         * // Bind the socket to the interface specified
         * Console.WriteLine("Binding the socket to the specified interface using Bind()...");
         * rawSocket.Bind(new IPEndPoint(bindAddress, 0));
         *
         * // Set the HeaderIncluded option since we include the IP header
         * Console.WriteLine("Setting the HeaderIncluded option for IP header...");
         * rawSocket.SetSocketOption(socketLevel, SocketOptionName.HeaderIncluded, 1);
         *
         * try
         * {
         *  // Send the packet!
         *  Console.WriteLine("Sending the packet...");
         *  int rc = rawSocket.SendTo(builtPacket, new IPEndPoint(destinationAddress, destinationPort));
         *  Console.WriteLine("send {0} bytes to {1}", rc, destinationAddress.ToString());
         * }
         * catch (SocketException err)
         * {
         *  Console.WriteLine("Socket error occurred: {0}", err.Message);
         *  // http://msdn.microsoft.com/en-us/library/ms740668.aspx
         * }
         * finally
         * {
         *  // Close the socket
         *  Console.WriteLine("Closing the socket...");
         *  rawSocket.Close();
         * }
         */

        return(builtPacket);
    }
Example #30
0
        /// <summary>
        /// 抓包
        /// </summary>
        /// <param name="s"></param>
        private void CatchPacket(Object s)
        {
            Socket ss = s as Socket;//参数转换
            byte[] buffer = new byte[2400];//接收数据的缓冲区
            while (true)
            {
                if (count > 80000)
                    break;
                int j = ss.Receive(buffer);//接收数据
                if (j > 0)//若接收到数据包
                {
                    IPHeader ipheader = new IPHeader(buffer, j);
                    ListViewItem lv = new ListViewItem();//定义一个视图项
                    count += j;//count用于统计接收的总字节数

                    lv.Text = ipheader.srcAddr.ToString();//往视图项添加源IP
                    lv.SubItems.Add(ipheader.destAddr.ToString());//往视图项添加目的IP
                    if (ipheader.protocol == 6)//6代表TCP
                    {
                            byte[] tcp = new byte[ipheader.length - ipheader.IPlength];
                            Array.Copy(buffer, ipheader.IPlength, tcp, 0, j - ipheader.IPlength);
                            TcpHeader tcpHeader = new TcpHeader(tcp, j);//解析TCP报文
                            lv.SubItems.Add(tcpHeader.sourcePort.ToString());
                            lv.SubItems.Add(tcpHeader.destinationPort.ToString());
                            lv.SubItems.Add("TCP");

                            ListViewItem tcpListView = new ListViewItem();
                            tcpListView.Text = tcpHeader.sourcePort.ToString();
                            tcpListView.SubItems.Add(tcpHeader.destinationPort.ToString());
                            tcpListView.SubItems.Add(tcpHeader.seq.ToString());
                            tcpListView.SubItems.Add(tcpHeader.ack.ToString());
                            tcpListView.SubItems.Add(tcpHeader.dataOffset.ToString());
                            tcpListView.SubItems.Add(tcpHeader.win.ToString());
                            this.listView2.Items.Add(tcpListView);
                       // if (tcpHeader.destinationPort == 80)
                       // {
                            string str = Encoding.UTF8.GetString(buffer,40,j-40);
                            this.richTextBox1.AppendText("\r\n" + str);
                      //  }
                    }
                    else if (ipheader.protocol == 17)
                    {//17代表UDP报文
                            byte[] udp = new byte[ipheader.length - ipheader.IPlength];
                            Array.Copy(buffer, ipheader.IPlength, udp, 0, j - ipheader.IPlength);
                            UdpHeader udpHeader = new UdpHeader(udp, j);//解析UDP报文
                            lv.SubItems.Add(udpHeader.sourcePort.ToString());
                            lv.SubItems.Add(udpHeader.destinationPort.ToString());
                            lv.SubItems.Add("UDP");
                    }
                    else
                    {//其他协议
                        lv.SubItems.Add(" ");
                        lv.SubItems.Add(" ");
                        lv.SubItems.Add("Others");
                    }
                    lv.SubItems.Add((ipheader.length).ToString());
                    lv.SubItems.Add(count.ToString());
                    this.listView1.Items.Add(lv);
                }
            }
        }
Example #31
0
    /// <summary>
    ///
    /// </summary>
    /// <param name="udpData"></param>
    /// <param name="bytesCopied"></param>
    /// <returns></returns>
    public static UdpHeader Create(byte[] udpData, ref int bytesCopied)
    {
        UdpHeader udpPacketHeader = new UdpHeader();

        udpPacketHeader.srcPort = BitConverter.ToUInt16(udpData, 0);
        udpPacketHeader.destPort = BitConverter.ToUInt16(udpData, 2);
        udpPacketHeader.udpLength = BitConverter.ToUInt16(udpData, 4);
        udpPacketHeader.udpChecksum = BitConverter.ToUInt16(udpData, 6);

        return udpPacketHeader;
    }
Example #32
0
 public void Assign(IPHeader ip, UdpHeader udp)
 {
     Source      = new IPEndPoint(ip.SourceIp, udp.SourcePort);
     Destination = new IPEndPoint(ip.DestinationIp, udp.DestinationPort);
     Protocol    = ip.Protocol;
 }
Example #33
0
 public Flow(IPHeader ip, UdpHeader udp)
 {
     Assign(ip, udp);
 }
Example #34
0
        /// <summary>
        /// 抓包
        /// </summary>
        /// <param name="s"></param>
        private void CatchPacket(Object s)
        {
            Socket ss = s as Socket;        //参数转换

            byte[] buffer = new byte[2400]; //接收数据的缓冲区
            while (true)
            {
                if (count > 80000)
                {
                    break;
                }
                int j = ss.Receive(buffer); //接收数据
                if (j > 0)                  //若接收到数据包
                {
                    IPHeader     ipheader = new IPHeader(buffer, j);
                    ListViewItem lv       = new ListViewItem();    //定义一个视图项
                    count += j;                                    //count用于统计接收的总字节数

                    lv.Text = ipheader.srcAddr.ToString();         //往视图项添加源IP
                    lv.SubItems.Add(ipheader.destAddr.ToString()); //往视图项添加目的IP
                    if (ipheader.protocol == 6)                    //6代表TCP
                    {
                        byte[] tcp = new byte[ipheader.length - ipheader.IPlength];
                        Array.Copy(buffer, ipheader.IPlength, tcp, 0, j - ipheader.IPlength);
                        TcpHeader tcpHeader = new TcpHeader(tcp, j);    //解析TCP报文
                        lv.SubItems.Add(tcpHeader.sourcePort.ToString());
                        lv.SubItems.Add(tcpHeader.destinationPort.ToString());
                        lv.SubItems.Add("TCP");

                        ListViewItem tcpListView = new ListViewItem();
                        tcpListView.Text = tcpHeader.sourcePort.ToString();
                        tcpListView.SubItems.Add(tcpHeader.destinationPort.ToString());
                        tcpListView.SubItems.Add(tcpHeader.seq.ToString());
                        tcpListView.SubItems.Add(tcpHeader.ack.ToString());
                        tcpListView.SubItems.Add(tcpHeader.dataOffset.ToString());
                        tcpListView.SubItems.Add(tcpHeader.win.ToString());
                        this.listView2.Items.Add(tcpListView);
                        // if (tcpHeader.destinationPort == 80)
                        // {
                        string str = Encoding.UTF8.GetString(buffer, 40, j - 40);
                        this.richTextBox1.AppendText("\r\n" + str);
                        //  }
                    }
                    else if (ipheader.protocol == 17)
                    {//17代表UDP报文
                        byte[] udp = new byte[ipheader.length - ipheader.IPlength];
                        Array.Copy(buffer, ipheader.IPlength, udp, 0, j - ipheader.IPlength);
                        UdpHeader udpHeader = new UdpHeader(udp, j);    //解析UDP报文
                        lv.SubItems.Add(udpHeader.sourcePort.ToString());
                        lv.SubItems.Add(udpHeader.destinationPort.ToString());
                        lv.SubItems.Add("UDP");
                    }
                    else
                    {//其他协议
                        lv.SubItems.Add(" ");
                        lv.SubItems.Add(" ");
                        lv.SubItems.Add("Others");
                    }
                    lv.SubItems.Add((ipheader.length).ToString());
                    lv.SubItems.Add(count.ToString());
                    this.listView1.Items.Add(lv);
                }
            }
        }
Example #35
0
        void AckHandles(UdpHeader header, bool updateRtt)
        {
            while (!sendWindow.Empty) {
                UdpHandle handle = sendWindow.Peek();

                int seqDistance = UdpMath.SeqDistance(handle.ObjSequence, header.AckSequence, UdpHeader.SEQ_PADD);
                if (seqDistance > 0) {
                    break;
                }

                if (handle.IsObject) {
                    if (seqDistance <= -UdpSocket.AckRedundancy) {
                        // track stats
                        stats.PacketLost();
                        socket.Statistics.PacketLost();

                        // handle lost
                        ObjectLost(handle.Object);
                    } else {
                        if ((header.AckHistory & (1UL << -seqDistance)) != 0UL) {
                            // track stats
                            stats.PacketDelivered();
                            socket.Statistics.PacketDelivered();

                            // handle delivered objects
                            ObjectDelivered(handle.Object);

                        } else {
                            // track stats
                            stats.PacketLost();
                            socket.Statistics.PacketLost();

                            // handle
                            ObjectLost(handle.Object);
                        }
                    }
                }

                if (seqDistance == 0 && header.AckTime > 0) {
                    UpdatePing(recvTime, handle.SendTime, header.AckTime);
                }

                sendWindow.Dequeue();
            }
        }
Example #36
0
 UdpHandle MakeHandle(ref UdpHeader header)
 {
     UdpHandle handle = new UdpHandle();
     handle.IsObject = header.IsObject;
     handle.ObjSequence = header.ObjSequence;
     handle.SendTime = header.Now;
     return handle;
 }
Example #37
0
        UdpHeader MakeHeader(bool isObject)
        {
            UdpHeader header = new UdpHeader();
            header.IsObject = isObject;
            header.AckHistory = recvHistory;
            header.AckSequence = recvSequence;
            header.ObjSequence = UdpMath.SeqNext(sendSequence, UdpHeader.SEQ_MASK);
            header.Now = socket.GetCurrentTime();

            if (recvTime > 0) {
                header.AckTime = (ushort) UdpMath.Clamp(header.Now - recvTime, 0, socket.Config.MaxPing);
            }

            return header;
        }
Example #38
0
        bool ParseHeader(UdpStream stream)
        {
            // we should always start at ptr 0
            UdpAssert.Assert(stream.Ptr == 0);

            UdpHeader header = new UdpHeader();
            header.Unpack(stream, socket);

            // after unpacking the header, the pointer should be at the header size
            UdpAssert.Assert(stream.Ptr == UdpSocket.HeaderBitSize);

            int seqDistance = UdpMath.SeqDistance(header.ObjSequence, recvSequence, UdpHeader.SEQ_PADD);

            // we have to be within window size
            if (seqDistance > socket.Config.PacketWindow || seqDistance < -socket.Config.PacketWindow) {
                ConnectionError(UdpConnectionError.SequenceOutOfBounds, string.Format("seqDistance: {0}, socket.Config.PacketWindow: {1}, header.ObjSequence: {2}, recvSequence: {3}", seqDistance, socket.Config.PacketWindow, header.ObjSequence, recvSequence));
                return false;
            }

            // this is an old packet
            if (seqDistance <= 0)
                return false;

            // update receive history
            if (seqDistance >= UdpSocket.AckRedundancy) {
                recvHistory = 1UL;
            } else {
                recvHistory = (recvHistory << seqDistance) | 1UL;
            }

            // update our receive stats
            recvSequence = header.ObjSequence;
            recvSinceLastSend += 1;

            // ack sent objects
            AckHandles(header, true);

            return true;
        }