예제 #1
0
        public override void reciever(IPEndPoint from, byte[] data)
        {
            Dahua1Section1 section1;
            int            section1Len;
            byte           section2Len;
            UInt16         section3Len;

            int deviceMacSize;

            UInt32 deviceIPv4;

            string deviceModel, deviceSerial, deviceIPv6;

            byte[] deviceTypeArray, deviceMacArray;
            byte[] section3Array;

            int index;

            section1Len = Marshal.SizeOf(typeof(Dahua1Section1));

            deviceMacSize = 17; // "00:11:22:33:44:55".Length()

            // section 1:
            if (data.Length < Marshal.SizeOf(typeof(Dahua1Section1)))
            {
                Logger.getInstance().WriteLine(Logger.DebugLevel.Warn, String.Format("Warning: Dahua1.reciever(): Invalid packet size (less than section1) from {0}", from.ToString()));
                return;
            }

            section1 = data.GetStruct <Dahua1Section1>();

            if (section1.headerMagic != answerMagic)
            {
                Logger.getInstance().WriteLine(Logger.DebugLevel.Warn, String.Format("Warning: Dahua1.reciever(): Wrong header magic recieved from {0}", from.ToString()));
                return;
            }

            // IP Address
            deviceIPv4 = NetworkUtils.littleEndian32(section1.ip);

            // device type
            deviceModel = Encoding.UTF8.GetString(section1.deviceType);

            section2Len = section1.section2Len;
            section3Len = NetworkUtils.littleEndian16(section1.section3Len);

            if (section1Len + section2Len + section3Len != data.Length)
            {
                Logger.getInstance().WriteLine(Logger.DebugLevel.Warn, String.Format("Warning: Dahua1.reciever(): Packet has wrong size = {0} (expected was {1})", data.Length, section1Len + section2Len + section3Len));
                return;
            }

            // section 2:
            // mac Address
            deviceMacSize  = Math.Min(deviceMacSize, section2Len);
            deviceMacArray = new byte[deviceMacSize];
            index          = typeof(Dahua1Section1).StructLayoutAttribute.Size;
            Array.Copy(data, index, deviceMacArray, 0, deviceMacSize);
            index       += deviceMacArray.Length;
            deviceSerial = Encoding.UTF8.GetString(deviceMacArray);

            // we still have more data in section 2
            if (section2Len > deviceMacSize)
            {
                // if deviceType from section2, replace deviceType with this one
                deviceTypeArray = new byte[section2Len - deviceMacSize];
                Array.Copy(data, index, deviceTypeArray, 0, deviceTypeArray.Length);
                index      += deviceTypeArray.Length;
                deviceModel = Encoding.UTF8.GetString(deviceTypeArray);
            }

            // section 3:
            deviceIPv6 = null;
            if (section3Len > 0)
            {
                Dictionary <string, string> values;

                section3Array = new byte[section3Len];
                Array.Copy(data, index, section3Array, 0, section3Array.Length);
                index += section3Array.Length;

                values = parseSection3(section3Array);
                if (values.ContainsKey("SerialNo"))
                {
                    deviceSerial = values["SerialNo"];
                }
                if (values.ContainsKey("IPv6Addr"))
                {
                    deviceIPv6 = values["IPv6Addr"];
                    if (deviceIPv6.Contains(';'))
                    {
                        var IPv6Split = deviceIPv6.Split(';');
                        deviceIPv6 = IPv6Split[0];
                    }
                    if (deviceIPv6.Contains('/'))
                    {
                        var IPv6Split = deviceIPv6.Split('/');
                        deviceIPv6 = IPv6Split[0];
                    }
                }
            }

            if (deviceIPv4 != 0)
            {
                viewer.deviceFound(name, 1, new IPAddress(deviceIPv4), deviceModel, deviceSerial);
            }
            else
            {
                viewer.deviceFound(name, 1, from.Address, deviceModel, deviceSerial);
                Logger.getInstance().WriteLine(Logger.DebugLevel.Warn, String.Format("Warning: Dahua1.reciever(): Recieved ipv4 is null (from: {0})", from.Address.ToString()));
            }

            if (deviceIPv6 != null)
            {
                IPAddress ip;
                if (IPAddress.TryParse(deviceIPv6, out ip))
                {
                    viewer.deviceFound(name, 2, ip, deviceModel, deviceSerial);
                }
                else
                {
                    Logger.getInstance().WriteLine(Logger.DebugLevel.Warn, String.Format("Warning: Dahua1.reciever(): Invalid ipv6 format: {0}", deviceIPv6));
                }
            }
        }
예제 #2
0
        public override void reciever(IPEndPoint from, byte[] data)
        {
            GigEVisionAckn answer;
            UInt32         version;
            string         macAddress;
            IPAddress      ipv4;

            string model;
            string vendor;
            string serial;

            if (data.Length != typeof(GigEVisionAckn).StructLayoutAttribute.Size)
            {
                Logger.getInstance().WriteLine(Logger.DebugLevel.Warn, String.Format("Warning: GigEVision.reciever(): Invalid size packet recieved from {0}", from.ToString()));
                return;
            }

            answer = data.GetStruct <GigEVisionAckn>();

            if (NetworkUtils.NetworkToHostOrder16(answer.payloadLen) != data.Length - 8)
            {
                Logger.getInstance().WriteLine(Logger.DebugLevel.Warn, String.Format("Warning: GigEVision.reciever(): Invalid size payload length value (got value {0} while value {1} was expected) recieved from {2}",
                                                                                     NetworkUtils.NetworkToHostOrder16(answer.payloadLen), data.Length - 8, from.ToString()));
                return;
            }

            version = ((UInt32)NetworkUtils.NetworkToHostOrder16(answer.plMajorVersion)) << 16 |
                      ((UInt32)NetworkUtils.NetworkToHostOrder16(answer.plMinorVersion));

            if (version != 0x00010002)
            {
                Logger.getInstance().WriteLine(Logger.DebugLevel.Warn, String.Format("Warning: GigEVision.reciever(): Invalid packet version (got value 0x{0:X8} while value 0x{1:X8} was expected) recieved from {2}",
                                                                                     version, 0x00010002, from.ToString()));
            }


            if (answer.plIPCurrentAddr != 0)
            {
                ipv4 = new IPAddress((long)answer.plIPCurrentAddr);
            }
            else
            {
                ipv4 = from.Address;
            }

            macAddress = String.Format("{0:X2}:{1:X2}:{2:X2}:{3:X2}:{4:X2}:{5:X2}",
                                       answer.plMacAddress.byte00, answer.plMacAddress.byte01, answer.plMacAddress.byte02,
                                       answer.plMacAddress.byte03, answer.plMacAddress.byte04, answer.plMacAddress.byte05);
            serial = Encoding.UTF8.GetString(answer.plSerialNumber);
            if (serial == "")
            {
                serial = macAddress;
            }

            vendor = Encoding.UTF8.GetString(answer.plManufacturer);
            if (vendor == "")
            {
                vendor = name;
            }

            model = Encoding.UTF8.GetString(answer.plModel);
            if (model == "")
            {
                model = Encoding.UTF8.GetString(answer.plUsername);
            }

            viewer.deviceFound(vendor, 0, ipv4, model, serial);
        }
예제 #3
0
 public VivotekHeader(byte sessionId)
 {
     session = sessionId;
     magic   = NetworkUtils.bigEndian32(Vivotek.magic);
 }
예제 #4
0
        public override void reciever(IPEndPoint from, byte[] data)
        {
            mDNSHeader header;
            int        headerSize;
            int        expectedQueries, expectedAnwers;
            int        position;

            headerSize = typeof(mDNSHeader).StructLayoutAttribute.Size;

            if (data.Length <= headerSize)
            {
                Logger.getInstance().WriteLine(Logger.DebugLevel.Warn, "Warning: mDNS.reciever(): invalid packet size.");
                Logger.getInstance().WriteData(Logger.DebugLevel.Warn, data);
                return;
            }

            header = data.GetStruct <mDNSHeader>();

            expectedQueries = NetworkUtils.NetworkToHostOrder16(header.questions);
            expectedAnwers  = NetworkUtils.NetworkToHostOrder16(header.authorityRRs) + NetworkUtils.NetworkToHostOrder16(header.answerRRs) + NetworkUtils.NetworkToHostOrder16(header.additionalRRs);
            if (expectedAnwers > 0)
            {
                position = headerSize;
                try
                {
                    readQueries(data, ref position, expectedQueries);
                    readAnswers(data, ref position, expectedAnwers);
                }
                catch (OverflowException ex)
                {
                    Logger.getInstance().WriteLine(Logger.DebugLevel.Warn, String.Format("Warning: mDNS.reciever(): packet parsing overflow at position 0x{0:X}!", position));
                    Logger.getInstance().WriteLine(Logger.DebugLevel.Warn, ex.ToString());
                    Logger.getInstance().WriteData(Logger.DebugLevel.Warn, data);
                }
            }
        }
예제 #5
0
        public override void reciever(IPEndPoint from, byte[] data)
        {
            Dahua2Header header;
            string       bodyStr;

            byte[]    body;
            int       headerSize, packetSize;
            string    method;
            IPAddress ip;

            headerSize = typeof(Dahua2Header).StructLayoutAttribute.Size;

            header = data.GetStruct <Dahua2Header>();

            if (NetworkUtils.littleEndian32(header.headerSize) != headerSize)
            {
                Logger.getInstance().WriteLine(Logger.DebugLevel.Warn, String.Format("Warning: Dahua2.reciever(): recieved invalid frame (headerSize={0}, expected {1})!", header.headerSize, headerSize));
                return;
            }
            packetSize = data.Length - headerSize;
            if (NetworkUtils.littleEndian32(header.packetSize1) != packetSize)
            {
                Logger.getInstance().WriteLine(Logger.DebugLevel.Warn, String.Format("Warning: Dahua2.reciever(): recieved invalid frame (packetSize={0}, expected {1})!", NetworkUtils.littleEndian32(header.packetSize1), packetSize));
                return;
            }

            body = new byte[packetSize];
            for (int i = 0; i < packetSize; i++)
            {
                body[i] = data[headerSize + i];
            }

            bodyStr = Encoding.UTF8.GetString(body);

            method = extractJsonString("method", bodyStr);
            if (method == "client.notifyDevInfo")
            {
                string deviceModel, deviceIPv4, deviceIPv6, deviceSerial;
                string IPv4Section, IPv6Section;

                deviceModel = extractJsonString("DeviceType", bodyStr);
                if (deviceModel == null)
                {
                    deviceModel = "Dahua";
                }

                IPv4Section = extractJsonSection("IPv4Address", bodyStr);
                deviceIPv4  = extractJsonString("IPAddress", IPv4Section);
                if (deviceIPv4 == null)
                {
                    deviceIPv4 = from.Address.ToString();
                }

                deviceIPv6  = null;
                IPv6Section = extractJsonSection("IPv6Address", bodyStr);
                if (IPv6Section != null)
                {
                    deviceIPv6 = extractJsonString("IPAddress", IPv6Section);
                    if (deviceIPv6 != null)
                    {
                        int sub = deviceIPv6.IndexOfAny(new char[] { '/', '\\' });
                        if (sub > 0)
                        {
                            deviceIPv6 = deviceIPv6.Substring(0, sub - 1);
                        }
                    }
                }

                deviceSerial = extractJsonString("SerialNo", bodyStr);
                if (deviceSerial == null)
                {
                    deviceSerial = extractJsonString("mac", bodyStr);
                }
                if (deviceSerial == null)
                {
                    deviceSerial = "Dahua device";
                }


                if (!IPAddress.TryParse(deviceIPv4, out ip))
                {
                    ip = from.Address;
                    Logger.getInstance().WriteLine(Logger.DebugLevel.Warn, String.Format("Warning: Dahua2.reciever(): Invalid ipv4 format: {0}", deviceIPv4));
                }
                viewer.deviceFound(name, 2, ip, deviceModel, deviceSerial);

                if (deviceIPv6 != null)
                {
                    if (IPAddress.TryParse(deviceIPv6, out ip))
                    {
                        viewer.deviceFound(name, 2, ip, deviceModel, deviceSerial);
                    }
                    else
                    {
                        Logger.getInstance().WriteLine(Logger.DebugLevel.Warn, String.Format("Warning: Dahua2.reciever(): Invalid ipv6 format: {0}", deviceIPv6));
                    }
                }
            }
        }
예제 #6
0
        public override void reciever(IPEndPoint from, byte[] data)
        {
            string deviceModel, deviceSerial;

            // xml is much bigger
            if (data.Length == typeof(BoschBinaryAnswer).StructLayoutAttribute.Size)
            {
                BoschBinaryAnswer binary;
                UInt32            ip;

                binary = data.GetStruct <BoschBinaryAnswer>();

                if (NetworkUtils.bigEndian32(binary.magic) != answerMagic)
                {
                    Logger.getInstance().WriteLine(Logger.DebugLevel.Warn, "Warning: Bosch.reciever(): Packet with wrong header.");
                    return;
                }

                ip = NetworkUtils.littleEndian32(binary.ipv4);

                deviceSerial = String.Format("{0:X02}:{1:X02}:{2:X02}:{3:X02}:{4:X02}:{5:X02}", binary.mac.byte00, binary.mac.byte01, binary.mac.byte02,
                                             binary.mac.byte03, binary.mac.byte04, binary.mac.byte05);

                deviceModel = name;

                viewer.deviceFound(name, 1, new IPAddress(ip), deviceModel, deviceSerial);
            }
            else
            {
                string    xml;
                string    deviceIPv4Str, deviceIPv6Str;
                Regex     type, ipv4, ipv6, mac, serial;
                Match     m;
                IPAddress ip;

                xml    = Encoding.UTF8.GetString(data);
                type   = new Regex("<friendlyName>([^<]*)</friendlyName>");
                ipv4   = new Regex("<unitIPAddress>([^<]*)</unitIPAddress>");
                ipv6   = new Regex("<unitIPv6Address>([^<]*)</unitIPv6Address>");
                mac    = new Regex("<physAddress>([^<]*)</physAddress>");
                serial = new Regex("<serialNumber>([^<]*)</serialNumber>");

                deviceIPv4Str = "";
                m             = ipv4.Match(xml);
                if (m.Success)
                {
                    deviceIPv4Str = m.Groups[1].Value;
                }

                deviceIPv6Str = "";
                m             = ipv6.Match(xml);
                if (m.Success)
                {
                    deviceIPv6Str = m.Groups[1].Value;
                }

                deviceModel = "";
                m           = type.Match(xml);
                if (m.Success)
                {
                    deviceModel = m.Groups[1].Value;
                }

                deviceSerial = "";
                m            = serial.Match(xml);
                if (m.Success)
                {
                    deviceSerial = m.Groups[1].Value;
                }
                else
                {
                    m = mac.Match(xml);
                    if (m.Success)
                    {
                        deviceSerial = m.Groups[1].Value;
                    }
                }

                if (!IPAddress.TryParse(deviceIPv4Str, out ip))
                {
                    Logger.getInstance().WriteLine(Logger.DebugLevel.Warn, String.Format("Warning: Bosch.reciever(): Invalid ipv4 format: {0}", deviceIPv4Str));
                    ip = from.Address;
                }
                viewer.deviceFound(name, 2, ip, deviceModel, deviceSerial);

                if (IPAddress.TryParse(deviceIPv6Str, out ip))
                {
                    viewer.deviceFound(name, 2, ip, deviceModel, deviceSerial);
                }
                else
                {
                    Logger.getInstance().WriteLine(Logger.DebugLevel.Warn, String.Format("Warning: Bosch.reciever(): Invalid ipv6 format: {0}", deviceIPv6Str));
                }
            }
        }
예제 #7
0
        public override void reciever(IPEndPoint from, byte[] data)
        {
            UbiquitiHeader header;
            int            headerSize;
            int            position;
            IPAddress      IPv4;

            byte[] mac;
            string macAddress;
            string model;

            headerSize = typeof(UbiquitiHeader).StructLayoutAttribute.Size;

            if (data.Length < headerSize)
            {
                Logger.LogWarning(String.Format("Warning: Ubiquiti.reciever(): Invalid size packet recieved from {0}", from.ToString()));
                return;
            }

            header = data.GetStruct <UbiquitiHeader>();
            if (NetworkUtils.bigEndian16(header.magic) != anwserMagic)
            {
                Logger.LogWarning(String.Format("Warning: Ubiquiti.reciever(): Invalid magic value from {0}", from.ToString()));
                /* not enougth tested Ubiquiti answer to say it is always this magic, so disabling return for now */
                // return;
            }

            if (NetworkUtils.bigEndian16(header.packetSize) != data.Length - 4)
            {
                Logger.LogWarning(String.Format("Warning: Ubiquiti.reciever(): Invalid packet size value (got value {0} while value {1} was expected) from {2}",
                                                NetworkUtils.bigEndian16(header.packetSize), data.Length - 4, from.ToString()));
                return;
            }

            position = headerSize;
            IPv4     = null;
            mac      = null;
            model    = "";

            while (position < data.Length)
            {
                UInt16 variable;
                byte[] value;

                variable = readNextValue(data, ref position, out value);
                switch (variable)
                {
                case (byte)UbiquitiValue.typeNull:
                    Logger.LogWarning("Warning: Ubiquiti.reciever(): Invalid packet, variable type null");
                    return;

                case (byte)UbiquitiValue.macAddress1:     // binary: 4 bytes
                case (byte)UbiquitiValue.macAddress2:     // binary: 4 bytes
                    if (value.Length != 6)
                    {
                        Logger.LogWarning(String.Format("Warning: Ubiquiti.reciever(): invalid size of variable 0x{0:X4} (expected={1}, found={2})",
                                                        (UInt16)variable, 6, value.Length));
                        break;
                    }
                    if (mac == null)
                    {
                        mac = value;
                    }
                    break;

                case (byte)UbiquitiValue.macIPv4:     // binary: 10 bytes
                    if (value.Length != 10)
                    {
                        Logger.LogWarning(String.Format("Warning: Ubiquiti.reciever(): invalid size of variable 0x{0:X4} (expected={1}, found={2})",
                                                        (UInt16)variable, 10, value.Length));
                        break;
                    }
                    if (mac == null)
                    {
                        mac = new byte[6];
                        Array.Copy(value, 0, mac, 0, 6);
                    }
                    if (IPv4 == null)
                    {
                        var IPv4Bytes = new byte[4];
                        Array.Copy(value, 6, IPv4Bytes, 0, 4);
                        IPv4 = new IPAddress(IPv4Bytes);
                    }
                    break;

                case (byte)UbiquitiValue.model1:     // string
                case (byte)UbiquitiValue.model2:     // string
                    if (model == "")
                    {
                        model = Encoding.UTF8.GetString(value);
                    }
                    break;
                }
            }

            if (IPv4 == null)
            {
                IPv4 = from.Address;
            }
            if (mac != null && IPv4 != null)
            {
                macAddress = String.Format("{0:X2}:{1:X2}:{2:X2}:{3:X2}:{4:X2}:{5:X2}", mac[0], mac[1], mac[2], mac[3], mac[4], mac[5]);
                if (model == "")
                {
                    model = "unknown";
                }

                viewer.deviceFound(name, 1, IPv4, model, macAddress);
            }
        }