/// <summary> /// Converts the string representation of an IPv4 address (1.2.3.4) to its IPv4 address equivalent. /// A return value indicates whether the conversion succeeded. /// </summary> /// <param name="value">A string containing the IPv4 address to convert (1.2.3.4).</param> /// <param name="result"> /// When this method returns, contains the IPv4 address value equivalent of the IPv4 address contained in s, if the conversion succeeded, /// or zero IPv4 address if the conversion failed. /// The conversion fails if the s parameter is null or String.Empty or is not of the correct format. This parameter is passed uninitialized. /// </param> /// <returns>True iff parsing was successful.</returns> public static bool TryParse(string value, out IpV4Address result) { if (value == null) { result = Zero; return false; } string[] valuesStrings = value.Split('.'); if (valuesStrings.Length != 4) { result = Zero; return false; } byte[] values = new byte[4]; for (int i = 0; i != 4; ++i) { if (!byte.TryParse(valuesStrings[i], NumberStyles.None, CultureInfo.InvariantCulture, out values[i])) { result = Zero; return false; } } result = new IpV4Address(BitSequence.Merge(values[0], values[1], values[2], values[3])); return true; }
public ConnId(ushort lPort, IpV4Address rIp, ushort rPort, IpV4Protocol protocol) { this.lPort = lPort; this.rIp = rIp; this.rPort = rPort; this.protocol = protocol; }
private Packet BuildArpPacketRequest(IpV4Address targetIp) { EthernetLayer ethernetLayer = new EthernetLayer { Source = _ownMacAddr, Destination = _macBroadcastAddr, //broadcast EtherType = EthernetType.None, // Will be filled automatically. }; ArpLayer arpLayer = new ArpLayer { ProtocolType = EthernetType.IpV4, Operation = ArpOperation.Request, SenderHardwareAddress = Array.AsReadOnly(_ownMacAddrByte), // self mac-address SenderProtocolAddress = Array.AsReadOnly(_ownIpAddrByte), // self ip-address TargetHardwareAddress = Array.AsReadOnly(_targetMacAddr), // Not Yet known TargetProtocolAddress = Helper.IpAddressToBytes(targetIp) // ip we want to get the mac for }; PacketBuilder builder = new PacketBuilder(ethernetLayer, arpLayer); return builder.Build(DateTime.Now); }
private IpV6MobilityOptionLocalMobilityAnchorAddress(IpV6LocalMobilityAnchorAddressCode code, IpV4Address? localMobilityAnchorAddressIpV4, IpV6Address? localMobilityAnchorAddressIpV6) : base(IpV6MobilityOptionType.LocalMobilityAnchorAddress) { Code = code; LocalMobilityAnchorAddressIpV6 = localMobilityAnchorAddressIpV6; LocalMobilityAnchorAddressIpV4 = localMobilityAnchorAddressIpV4; }
/// <summary> /// Creates an instance from Prefix Length and Home Address. /// </summary> /// <param name="prefixLength"> /// Indicates the prefix length of the mobile node's IPv4 home network corresponding to the IPv4 home address contained in the option. /// </param> /// <param name="homeAddress"> /// Contains the IPv4 home address that is being requested. /// The value of 0.0.0.0 is used to request that the local mobility anchor perform the address allocation. /// </param> public IpV6MobilityOptionIpV4HomeAddressRequest(byte prefixLength, IpV4Address homeAddress) : base(IpV6MobilityOptionType.IpV4HomeAddressRequest) { if (prefixLength > MaxPrefixLength) throw new ArgumentOutOfRangeException("prefixLength", prefixLength, string.Format(CultureInfo.InvariantCulture, "Max prefix length is {0}", MaxPrefixLength)); PrefixLength = prefixLength; HomeAddress = homeAddress; }
/// <summary> /// Creates an instance from Prefix Length, Request Prefix and Home Address. /// </summary> /// <param name="prefixLength"> /// The length of the prefix allocated to the mobile node. /// If only a single address is allocated, this field must be set to 32. /// In the first binding update requesting a prefix, the field contains the prefix length requested. /// However, in the following binding updates, this field must contain the length of the prefix allocated. /// A value of zero is invalid and must be considered an error. /// </param> /// <param name="requestPrefix"> /// When true, indicates that the mobile node requests a mobile network prefix. /// This flag is only relevant for new requests, and must be ignored for binding refreshes. /// </param> /// <param name="homeAddress"> /// The mobile node's IPv4 home address that should be defended by the home agent. /// This field could contain any unicast IPv4 address (public or private) that was assigned to the mobile node. /// The value 0.0.0.0 is used to request an IPv4 home address from the home agent. /// A mobile node may choose to use this option to request a prefix by setting the address to All Zeroes and setting the RequestPrefix flag. /// The mobile node could then form an IPv4 home address based on the allocated prefix. /// Alternatively, the mobile node may use two different options, one for requesting an address (static or dynamic) and another for requesting a /// </param> public IpV6MobilityOptionIpV4HomeAddress(byte prefixLength, bool requestPrefix, IpV4Address homeAddress) : base(IpV6MobilityOptionType.IpV4HomeAddress) { if (prefixLength > MaxPrefixLength) throw new ArgumentOutOfRangeException("prefixLength", prefixLength, string.Format(CultureInfo.InvariantCulture, "Exceeded maximum value {0}", MaxPrefixLength)); PrefixLength = prefixLength; RequestPrefix = requestPrefix; HomeAddress = homeAddress; }
internal static bool Read(DataSegment data, out IpV4Address address) { if (data.Length != OptionDataLength) { address = IpV4Address.Zero; return false; } address = data.ReadIpV4Address(Offset.Address, Endianity.Big); return true; }
/// <summary> /// Creates an instance from status, Prefix Length and Home Address. /// </summary> /// <param name="status"> /// Indicates success or failure for the IPv4 home address binding. /// Values from 0 to 127 indicate success. /// Higher values indicate failure. /// </param> /// <param name="prefixLength"> /// The prefix length of the address allocated. /// This field is only valid in case of success and must be set to zero and ignored in case of failure. /// This field overrides what the mobile node requested (if not equal to the requested length). /// </param> /// <param name="homeAddress"> /// The IPv4 home address that the home agent will use in the binding cache entry. /// This could be a public or private address. /// This field must contain the mobile node's IPv4 home address. /// If the address were dynamically allocated, the home agent will add the address to inform the mobile node. /// Otherwise, if the address is statically allocated to the mobile node, the home agent will copy it from the binding update message. /// </param> public IpV6MobilityOptionIpV4AddressAcknowledgement(IpV6AddressAcknowledgementStatus status, byte prefixLength, IpV4Address homeAddress) : base(IpV6MobilityOptionType.IpV4AddressAcknowledgement) { if (prefixLength > MaxPrefixLength) throw new ArgumentOutOfRangeException("prefixLength", prefixLength, string.Format(CultureInfo.InvariantCulture, "Exceeded maximum value {0}", MaxPrefixLength)); Status = status; PrefixLength = prefixLength; HomeAddress = homeAddress; }
/// <summary> /// Tries to read the option from a buffer starting from the option value (after the type and length). /// </summary> /// <param name="buffer">The buffer to read the option from.</param> /// <param name="offset">The offset to the first byte to read the buffer. Will be incremented by the number of bytes read.</param> /// <param name="valueLength">The number of bytes the option value should take according to the length field that was already read.</param> /// <returns>On success - the complex option read. On failure - null.</returns> Option IOptionComplexFactory.CreateInstance(byte[] buffer, ref int offset, byte valueLength) { if (valueLength != OptionValueLength) { return(null); } ushort identification = buffer.ReadUShort(ref offset, Endianity.Big); ushort outboundHopCount = buffer.ReadUShort(ref offset, Endianity.Big); ushort returnHopCount = buffer.ReadUShort(ref offset, Endianity.Big); IpV4Address originatorIpAddress = buffer.ReadIpV4Address(ref offset, Endianity.Big); return(new IpV4OptionTraceRoute(identification, outboundHopCount, returnHopCount, originatorIpAddress)); }
public TapWorker(Guid guid, string name, string mac, string ip, string gateway) { Guid = guid; Name = name; ifHardwareAddressString = mac; ifProtocolAddressString = ip; ownProtocolAddressString = gateway; ifHardwareAddress = new MacAddress(ifHardwareAddressString); ifProtocolAddress = new IpV4Address(ifProtocolAddressString); ownProtocolAddress = new IpV4Address(ownProtocolAddressString); ifHardwareAddressByte = ifHardwareAddressString.Split(':').Select(s => Convert.ToByte(s, 16)).ToArray(); ifProtocolAddressByte = ifProtocolAddressString.Split('.').Select(byte.Parse).ToArray(); ownProtocolAddressByte = ownProtocolAddressString.Split('.').Select(byte.Parse).ToArray(); }
/// <summary> /// Creates an address from an address string ("2001:0db8:0::22:1.2.3.4"). /// </summary> public IpV6Address(string value) { if (value == null) throw new ArgumentNullException("value"); string cannonizedValue = value; // Handle ...:1.2.3.4 int lastColonIndex = cannonizedValue.LastIndexOf(':'); if (lastColonIndex == -1) throw new ArgumentException("Invalid IPv6 address format " + value); string lastPart = value.Substring(lastColonIndex + 1, cannonizedValue.Length - lastColonIndex - 1); if (lastPart.IndexOf('.') != -1) { uint lastPartValue = new IpV4Address(lastPart).ToValue(); cannonizedValue = cannonizedValue.Substring(0, lastColonIndex + 1) + (lastPartValue >> 16).ToString("x", CultureInfo.InvariantCulture) + ":" + (lastPartValue & 0x0000FFFF).ToString("x", CultureInfo.InvariantCulture); } // Handle ...::... int doubleColonIndex = cannonizedValue.IndexOf("::", StringComparison.Ordinal); if (doubleColonIndex != -1) { int numMissingColons = 7 - cannonizedValue.Count(':'); if (numMissingColons < 0) throw new ArgumentException("Invalid IPv6 address format " + value); cannonizedValue = cannonizedValue.Substring(0, doubleColonIndex + 2) + new string(':', numMissingColons) + cannonizedValue.Substring(doubleColonIndex + 2); } IEnumerable<ushort> values = cannonizedValue.Split(':').Select(part => string.IsNullOrEmpty(part) ? (ushort)0 : ushort.Parse(part, NumberStyles.HexNumber, CultureInfo.InvariantCulture)); ulong mostSignificant = values.Take(4).Aggregate((ulong)0, (sum, element) => (sum << 16) + element); ulong leastSignificant = values.Skip(4).Take(4).Aggregate((ulong)0, (sum, element) => (sum << 16) + element); _value = new UInt128(mostSignificant, leastSignificant); }
internal static IpV4Address CalculateDestination(IpV4Address currentDestination, IpV4Options options) { if (options == null) { return(currentDestination); } IpV4OptionRoute destinationControllerRouteOption = (IpV4OptionRoute)options.OptionsCollection.FirstOrDefault(option => option.OptionType == IpV4OptionType.LooseSourceRouting || option.OptionType == IpV4OptionType.StrictSourceRouting); if (destinationControllerRouteOption != null) { ReadOnlyCollection <IpV4Address> route = destinationControllerRouteOption.Route; if (destinationControllerRouteOption.PointedAddressIndex < route.Count) { return(route[route.Count - 1]); } } return(currentDestination); }
internal static bool TryRead(out IpV4Address[] addresses, out byte pointedAddressIndex, byte[] buffer, ref int offset, byte valueLength) { addresses = (IpV4Address[])null; pointedAddressIndex = (byte)0; if ((int)valueLength < 1 || (int)valueLength % 4 != 1) { return(false); } byte num = buffer[offset++]; if ((int)num % 4 != 0 || (int)num < 4) { return(false); } pointedAddressIndex = (byte)((int)num / 4 - 1); int length = (int)valueLength / 4; addresses = new IpV4Address[length]; for (int index = 0; index != length; ++index) { addresses[index] = ByteArrayExtensions.ReadIpV4Address(buffer, ref offset, Endianity.Big); } return(true); }
internal IpV6MobilityOptionIpV4Address(IpV6MobilityOptionType type, IpV4Address address) : base(type) { Address = address; }
public bool Equals(IpV4Address other) { return((int)this.ToValue() == (int)other.ToValue()); }
/// <summary> /// Creates an instance from a care-of address. /// </summary> /// <param name="careOfAddress"> /// Contains the mobile node's IPv4 care-of address. /// The IPv4 care-of address is used when the mobile node is located in an IPv4-only network. /// </param> public IpV6MobilityOptionIpV4CareOfAddress(IpV4Address careOfAddress) : base(IpV6MobilityOptionType.IpV4CareOfAddress, careOfAddress) { }
/// <summary> /// Creates an instance from binding id, status, simulatneous home and foreign binding, priority and IPv4 care of address. /// </summary> /// <param name="bindingId"> /// The BID that is assigned to the binding indicated by the care-of address in the Binding Update or the Binding Identifier mobility option. /// The value of zero is reserved and should not be used. /// </param> /// <param name="status"> /// When the Binding Identifier mobility option is included in a Binding Acknowledgement, /// this field overwrites the Status field in the Binding Acknowledgement only for this BID. /// If this field is set to zero, the receiver ignores this field and uses the registration status stored in the Binding Acknowledgement message. /// The receiver must ignore this field if the Binding Identifier mobility option is not carried within either the Binding Acknowledgement /// or the Care-of Test messages. /// The possible status codes are the same as the status codes of the Binding Acknowledgement. /// This Status field is also used to carry error information related to the care-of address test in the Care-of Test message. /// </param> /// <param name="simultaneousHomeAndForeignBinding"> /// Indicates that the mobile node registers multiple bindings to the home agent while it is attached to the home link. /// This flag is valid only for a Binding Update sent to the home agent. /// </param> /// <param name="priority"> /// Places each BID to a relative priority (PRI) with other registered BIDs. /// Value '0' is reserved and must not be used. /// A lower number in this field indicates a higher priority, while BIDs with the same BID-PRI value have equal priority meaning that, /// the BID used is an implementation issue. /// This is consistent with current practice in packet classifiers. /// </param> /// <param name="careOfAddress"> /// The IPv4 care-of address for the corresponding BID. /// </param> public IpV6MobilityOptionBindingIdentifier(ushort bindingId, IpV6BindingAcknowledgementStatus status, bool simultaneousHomeAndForeignBinding, byte priority, IpV4Address careOfAddress) : this(bindingId, status, simultaneousHomeAndForeignBinding, priority, careOfAddress, null) { }
private IpV6MobilityOptionRedirect(IpV4Address? localMobilityAddressIpV4, IpV6Address? localMobilityAddressIpV6) : base(IpV6MobilityOptionType.Redirect) { LocalMobilityAddressIpV4 = localMobilityAddressIpV4; LocalMobilityAddressIpV6 = localMobilityAddressIpV6; }
void EventButtonStartClick(object sender, RoutedEventArgs e) { if (comboAdapter.SelectedIndex < 0) { MessageBox.Show("Adapter not selected"); return; } if (iEndpoint == null) { MessageBox.Show("Endpoint not specified"); return; } iMutex.WaitOne(); iRunningDevice = iDevices[comboAdapter.SelectedIndex]; iRunningEndpoint = iEndpoint; iRunningAddress = new IpV4Address(iRunningEndpoint.Address.ToString()); ResetStats(); buttonStart.IsEnabled = false; buttonStop.IsEnabled = true; iMutex.ReleaseMutex(); iStart.Release(); }
internal GreSourceRouteEntryIp(IpV4Address[] addresses, int nextAddressIndex) :this(addresses.AsReadOnly(), nextAddressIndex) { }
internal static void WriteVersion0Header(byte[] buffer, int offset, IgmpMessageType igmpMessageType, byte code, uint identifier, IpV4Address groupAddress, ulong accessKey) { buffer.Write(offset + Offset.MessageType, (byte)igmpMessageType); buffer.Write(offset + Offset.Code, code); buffer.Write(offset + Offset.Version0GroupAddress, groupAddress, Endianity.Big); buffer.Write(offset + Offset.Identifier, identifier, Endianity.Big); buffer.Write(offset + Offset.AccessKey, accessKey, Endianity.Big); WriteChecksum(buffer, offset, Version0HeaderLength); }
public IpV4OptionTraceRoute(ushort identification, ushort outboundHopCount, ushort returnHopCount, IpV4Address originatorIpAddress) : base(IpV4OptionType.TraceRoute) { this._identification = identification; this._outboundHopCount = outboundHopCount; this._returnHopCount = returnHopCount; this._originatorIpAddress = originatorIpAddress; }
private static ushort CalculateTransportChecksum(byte[] buffer, int offset, int headerLength, ushort transportLength, int transportChecksumOffset, bool isChecksumOptional, IpV4Address destination) { int offsetAfterChecksum = offset + headerLength + transportChecksumOffset + 2; uint sum = Sum16Bits(buffer, offset + Offset.Source, IpV4Address.SizeOf) + Sum16Bits(destination) + buffer[offset + Offset.Protocol] + transportLength + Sum16Bits(buffer, offset + headerLength, transportChecksumOffset) + Sum16Bits(buffer, offsetAfterChecksum, transportLength - transportChecksumOffset - 2); ushort checksumResult = Sum16BitsToChecksum(sum); if (checksumResult == 0 && isChecksumOptional) { return(0xFFFF); } return(checksumResult); }
internal static void WriteTransportChecksum(byte[] buffer, int offset, int headerLength, ushort transportLength, int transportChecksumOffset, bool isChecksumOptional, ushort?checksum, IpV4Address destination) { ushort checksumValue = checksum == null ? CalculateTransportChecksum(buffer, offset, headerLength, transportLength, transportChecksumOffset, isChecksumOptional, destination) : checksum.Value; buffer.Write(offset + headerLength + transportChecksumOffset, checksumValue, Endianity.Big); }
internal static void WriteTransportChecksum(byte[] buffer, int offset, int headerLength, ushort transportLength, int transportChecksumOffset, bool isChecksumOptional, ushort?checksum, IpV4Address destination) { ushort?nullable = checksum; ushort num = !(nullable.HasValue ? new int?((int)nullable.GetValueOrDefault()) : new int?()).HasValue ? IpV4Datagram.CalculateTransportChecksum(buffer, offset, headerLength, transportLength, transportChecksumOffset, isChecksumOptional, destination) : checksum.Value; ByteArrayExtensions.Write(buffer, offset + headerLength + transportChecksumOffset, num, Endianity.Big); }
private static ushort CalculateTransportChecksum(byte[] buffer, int offset, int headerLength, ushort transportLength, int transportChecksumOffset, bool isChecksumOptional, IpV4Address destination) { int offset1 = offset + headerLength + transportChecksumOffset + 2; ushort num = DataSegment.Sum16BitsToChecksum(DataSegment.Sum16Bits(buffer, offset + 12, 4) + DataSegment.Sum16Bits(destination) + (uint)buffer[offset + 9] + (uint)transportLength + DataSegment.Sum16Bits(buffer, offset + headerLength, transportChecksumOffset) + DataSegment.Sum16Bits(buffer, offset1, (int)transportLength - transportChecksumOffset - 2)); if ((int)num == 0 && isChecksumOptional) { return(ushort.MaxValue); } return(num); }
/// <summary> /// Create a timed address accroding to the given values. /// </summary> /// <param name="address">The address in the pair.</param> /// <param name="timeOfDay">The time passed since midnight UT.</param> public IpV4OptionTimedAddress(IpV4Address address, IpV4TimeOfDay timeOfDay) { _address = address; _timeOfDay = timeOfDay; }
internal static void WriteQueryVersion3(byte[] buffer, int offset, TimeSpan maxResponseTime, IpV4Address groupAddress, bool isSuppressRouterSideProcessing, byte queryRobustnessVariable, TimeSpan queryInterval, IEnumerable<IpV4Address> sourceAddresses) { // MessageType buffer.Write(offset + Offset.MessageType, (byte)IgmpMessageType.MembershipQuery); // MaxResponseCode if (maxResponseTime < TimeSpan.Zero || maxResponseTime > MaxVersion3MaxResponseTime) throw new ArgumentOutOfRangeException("maxResponseTime", maxResponseTime, "must be in the range [" + TimeSpan.Zero + ", " + MaxVersion3MaxResponseTime + "]"); double maxResponseTimeTenthOfASecond = maxResponseTime.TotalSeconds * 10; byte maxResponseCode = (byte)(maxResponseTimeTenthOfASecond < 128 ? maxResponseTimeTenthOfASecond : ValueToCode((int)maxResponseTimeTenthOfASecond)); buffer.Write(offset + Offset.MaxResponseCode, maxResponseCode); // GroupAddress buffer.Write(offset + Offset.GroupAddress, groupAddress, Endianity.Big); // IsSuppressRouterSideProcessing and QueryRobustnessVariable if (queryRobustnessVariable > MaxQueryRobustnessVariable) throw new ArgumentOutOfRangeException("queryRobustnessVariable", queryRobustnessVariable, "must be in range [0, 7]"); buffer.Write(offset + Offset.QueryRobustnessVariable, (byte)(queryRobustnessVariable | (isSuppressRouterSideProcessing ? 0x08 : 0x00))); // QueryIntervalCode if (queryInterval < TimeSpan.Zero || queryInterval > MaxQueryInterval) throw new ArgumentOutOfRangeException("queryInterval", maxResponseTime, "must be in the range [" + TimeSpan.Zero + ", " + MaxQueryInterval + "]"); double queryIntervalTenthOfASecond = queryInterval.TotalSeconds; byte queryIntervalCode = (byte)(queryIntervalTenthOfASecond < 128 ? queryIntervalTenthOfASecond : ValueToCode((int)queryIntervalTenthOfASecond)); buffer.Write(offset + Offset.QueryIntervalCode, queryIntervalCode); // SourceAddresses int numSourceAddresses = 0; foreach (IpV4Address sourceAddress in sourceAddresses) { buffer.Write(offset + Offset.SourceAddresses + IpV4Address.SizeOf * numSourceAddresses, sourceAddress, Endianity.Big); ++numSourceAddresses; } // NumberOfSources buffer.Write(offset + Offset.NumberOfSources, (ushort)numSourceAddresses, Endianity.Big); // Checksum WriteChecksum(buffer, offset, QueryVersion3HeaderLength + IpV4Address.SizeOf * numSourceAddresses); }
/// <summary> /// Two addresses are equal if the have the exact same value. /// </summary> public bool Equals(IpV4Address other) { return(ToValue() == other.ToValue()); }
internal static void WriteHeader(byte[] buffer, int offset, byte typeOfService, ushort identification, IpV4Fragmentation fragmentation, byte ttl, IpV4Protocol protocol, ushort?headerChecksum, IpV4Address source, IpV4Address destination, IpV4Options options, int payloadLength) { int length = 20 + options.BytesLength; buffer[offset] = (byte)(64 + length / 4); buffer[offset + 1] = typeOfService; ByteArrayExtensions.Write(buffer, offset + 2, (ushort)(length + payloadLength), Endianity.Big); ByteArrayExtensions.Write(buffer, offset + 4, identification, Endianity.Big); fragmentation.Write(buffer, offset + 6); buffer[offset + 8] = ttl; buffer[offset + 9] = (byte)protocol; ByteArrayExtensions.Write(buffer, offset + 12, source, Endianity.Big); ByteArrayExtensions.Write(buffer, offset + 16, destination, Endianity.Big); options.Write(buffer, offset + 20); ushort?nullable = headerChecksum; ushort num = !(nullable.HasValue ? new int?((int)nullable.GetValueOrDefault()) : new int?()).HasValue ? DataSegment.Sum16BitsToChecksum(DataSegment.Sum16Bits(buffer, offset, length)) : headerChecksum.Value; ByteArrayExtensions.Write(buffer, offset + 10, num, Endianity.Big); }
/// <summary> /// Creates an instance from tagger id and identifier. /// </summary> /// <param name="taggerId"> /// Used to differentiate multiple ingressing border gateways that may commonly apply the SMF_DPD option header to packets from a particular source. /// </param> /// <param name="identifier"> /// DPD packet Identifier. /// When the TaggerId field is present, the Identifier can be considered a unique packet identifier /// in the context of the TaggerId:srcAddr:dstAddr tuple. /// When the TaggerId field is not present, then it is assumed that the source applied the SMF_DPD option /// and the Identifier can be considered unique in the context of the IPv6 packet header srcAddr:dstAddr tuple. /// </param> public IpV6OptionSimplifiedMulticastForwardingDuplicatePacketDetectionIpV4(IpV4Address taggerId, DataSegment identifier) : base(identifier) { TaggerId = taggerId; }
internal static void Write(byte[] buffer, ref int offset, IgmpRecordType recordType, Datagram auxiliaryData, IpV4Address multicastAddress, ReadOnlyCollection<IpV4Address> sourceAddresses) { buffer.Write(offset + Offset.RecordType, (byte)recordType); buffer.Write(offset + Offset.AuxiliaryDataLength, (byte)(auxiliaryData.Length / 4)); int numSourceAddresses = sourceAddresses.Count; buffer.Write(offset + Offset.NumberOfSources, (ushort)numSourceAddresses, Endianity.Big); buffer.Write(offset + Offset.MulticastAddress, multicastAddress, Endianity.Big); for (int i = 0; i != numSourceAddresses; ++i) buffer.Write(offset + Offset.SourceAddresses + IpV4Address.SizeOf * i, sourceAddresses[i], Endianity.Big); offset += HeaderLength + numSourceAddresses * IpV4Address.SizeOf; buffer.Write(ref offset, auxiliaryData); }
/// <summary> /// Creates an instance from an IPv4 local mobility address. /// </summary> /// <param name="localMobilityAddress">The IPv4 address of the r2LMA.</param> public IpV6MobilityOptionRedirect(IpV4Address localMobilityAddress) : this(localMobilityAddress, null) { }
private IpV6MobilityOptionBindingIdentifier(ushort bindingId, IpV6BindingAcknowledgementStatus status, bool simultaneousHomeAndForeignBinding, byte priority, IpV4Address? ipV4CareOfAddress, IpV6Address? ipV6CareOfAddress) : base(IpV6MobilityOptionType.BindingIdentifier) { if (priority > MaxPriority) throw new ArgumentOutOfRangeException("priority", priority, string.Format(CultureInfo.InvariantCulture, "Must not exceed {0}", MaxPriority)); BindingId = bindingId; Status = status; SimultaneousHomeAndForeignBinding = simultaneousHomeAndForeignBinding; Priority = priority; IpV4CareOfAddress = ipV4CareOfAddress; IpV6CareOfAddress = ipV6CareOfAddress; }
/// <summary> /// Writes the given value to the buffer using the given endianity and increments the offset by the number of bytes written. /// </summary> /// <param name="buffer">The buffer to write the value to.</param> /// <param name="offset">The offset in the buffer to start writing.</param> /// <param name="value">The value to write.</param> /// <param name="endianity">The endianity to use when converting the value to bytes.</param> public static void Write(this byte[] buffer, ref int offset, IpV4Address value, Endianity endianity) { buffer.Write(ref offset, value.ToValue(), endianity); }
internal static IpV4Address CalculateDestination(IpV4Address currentDestination, IpV4Options options) { if (options == null) return currentDestination; IpV4OptionRoute destinationControllerRouteOption = (IpV4OptionRoute)options.OptionsCollection.FirstOrDefault(option => option.OptionType == IpV4OptionType.LooseSourceRouting || option.OptionType == IpV4OptionType.StrictSourceRouting); if (destinationControllerRouteOption != null) { ReadOnlyCollection<IpV4Address> route = destinationControllerRouteOption.Route; if (destinationControllerRouteOption.PointedAddressIndex < route.Count) return route[route.Count - 1]; } return currentDestination; }
private static Packet BuildIcmpPacket(MacAddress SourceMac, MacAddress DestinationMac, IpV4Address SourceIp, IpV4Address CurrentDestination, string packetType) { EthernetLayer ethernetLayer = new EthernetLayer { Source = SourceMac, Destination = DestinationMac, EtherType = EthernetType.None, // Will be filled automatically. }; IpV4Layer ipV4Layer = new IpV4Layer { //Source = new IpV4Address("1.2.3.4"), //CurrentDestination = new IpV4Address("11.22.33.44"), Source = SourceIp, CurrentDestination = CurrentDestination, Fragmentation = IpV4Fragmentation.None, HeaderChecksum = null, // Will be filled automatically. Identification = 123, Options = IpV4Options.None, Protocol = null, // Will be filled automatically. Ttl = 100, TypeOfService = 0, }; IcmpEchoLayer icmpLayer = null; IcmpEchoReplyLayer icmpRLayer = null; PacketBuilder builder = null; if (packetType.Equals("REQUEST")) { Console.WriteLine("Request"); icmpLayer = new IcmpEchoLayer { Checksum = null, // Will be filled automatically. Identifier = 456, SequenceNumber = 800, }; builder = new PacketBuilder(ethernetLayer, ipV4Layer, icmpLayer); } else { Console.WriteLine("Reply"); icmpRLayer = new IcmpEchoReplyLayer { Checksum = null, // Will be filled automatically. Identifier = 456, SequenceNumber = 800, }; builder = new PacketBuilder(ethernetLayer, ipV4Layer, icmpRLayer); } return builder.Build(DateTime.Now); }
internal static void WriteHeader(byte[] buffer, int offset, byte typeOfService, ushort identification, IpV4Fragmentation fragmentation, byte ttl, IpV4Protocol protocol, ushort? headerChecksum, IpV4Address source, IpV4Address destination, IpV4Options options, int payloadLength) { int headerLength = HeaderMinimumLength + options.BytesLength; buffer[offset + Offset.VersionAndHeaderLength] = (byte)((DefaultVersion << 4) + headerLength / 4); buffer[offset + Offset.TypeOfService] = typeOfService; buffer.Write(offset + Offset.TotalLength, (ushort)(headerLength + payloadLength), Endianity.Big); buffer.Write(offset + Offset.Identification, identification, Endianity.Big); fragmentation.Write(buffer, offset + Offset.Fragmentation); buffer[offset + Offset.Ttl] = ttl; buffer[offset + Offset.Protocol] = (byte)protocol; buffer.Write(offset + Offset.Source, source, Endianity.Big); buffer.Write(offset + Offset.Destination, destination, Endianity.Big); options.Write(buffer, offset + Offset.Options); ushort headerChecksumValue = headerChecksum == null ? Sum16BitsToChecksum(Sum16Bits(buffer, offset, headerLength)) : headerChecksum.Value; buffer.Write(offset + Offset.HeaderChecksum, headerChecksumValue, Endianity.Big); }
internal static void WriteHeader(byte[] buffer, int offset, IgmpMessageType igmpMessageType, TimeSpan maxResponseTime, IpV4Address groupAddress) { buffer.Write(offset + Offset.MessageType, (byte)igmpMessageType); double numTenthOfASecond = (maxResponseTime.TotalSeconds * 10); if (numTenthOfASecond >= 256 || numTenthOfASecond < 0) throw new ArgumentOutOfRangeException("maxResponseTime", maxResponseTime, "must be in the range [" + TimeSpan.Zero + ", " + TimeSpan.FromSeconds(255 * 0.1) + "]"); buffer.Write(offset + Offset.MaxResponseCode, (byte)numTenthOfASecond); buffer.Write(offset + Offset.GroupAddress, groupAddress, Endianity.Big); WriteChecksum(buffer, offset, HeaderLength); }
internal static void WriteTransportChecksum(byte[] buffer, int offset, int headerLength, ushort transportLength, int transportChecksumOffset, bool isChecksumOptional, ushort? checksum, IpV4Address destination) { ushort checksumValue = checksum == null ? CalculateTransportChecksum(buffer, offset, headerLength, transportLength, transportChecksumOffset, isChecksumOptional, destination) : checksum.Value; buffer.Write(offset + headerLength + transportChecksumOffset, checksumValue, Endianity.Big); }
internal static void WriteHeaderAdditional(byte[] buffer, int offset, IpV4Address addressMask) { buffer.Write(offset, addressMask, Endianity.Big); }
private static ushort CalculateTransportChecksum(byte[] buffer, int offset, int headerLength, ushort transportLength, int transportChecksumOffset, bool isChecksumOptional, IpV4Address destination) { int offsetAfterChecksum = offset + headerLength + transportChecksumOffset + sizeof(ushort); uint sum = Sum16Bits(buffer, offset + Offset.Source, IpV4Address.SizeOf) + Sum16Bits(destination) + buffer[offset + Offset.Protocol] + transportLength + Sum16Bits(buffer, offset + headerLength, transportChecksumOffset) + Sum16Bits(buffer, offsetAfterChecksum, transportLength - transportChecksumOffset - sizeof(ushort)); ushort checksumResult = Sum16BitsToChecksum(sum); if (checksumResult == 0 && isChecksumOptional) return 0xFFFF; return checksumResult; }