public void ReadData(AcnBinaryReader data, bool tcpTransport) { //Read Preamble if (!tcpTransport) { PreambleSize = data.ReadOctet2(); PostambleSize = data.ReadOctet2(); } string packetId = data.ReadUtf8String(12); if (packetId != PacketId) { throw new InvalidPacketException("The packet ID is not a valid ACN packet Id"); } if (tcpTransport) { BlockSize = data.ReadOctet4(); } //Read PDU Header Length = data.ReadOctet2(); Flags = (byte)((Length & 0xF000) >> 12); Length &= 0xFFF; ProtocolId = data.ReadOctet4(); //Read CID SenderId = new Guid(data.ReadBytes(16)); }
protected override void ReadData(AcnBinaryReader data) { SourceName = data.ReadUtf8String(64); SequenceNumber = data.ReadOctet4(); EndpointID = data.ReadOctet2(); data.BaseStream.Seek(1, SeekOrigin.Current); }
public static AcnPacket ReadTcpPacket(AcnBinaryReader data) { AcnRootLayer rootLayer = new AcnRootLayer(); rootLayer.ReadData(data, true); return(ReadPacket(rootLayer, data));; }
/// <summary> /// Creates the specified root layer. /// </summary> /// <param name="rootLayer">The root layer.</param> /// <param name="reader">The reader.</param> /// <returns></returns> public AcnPacket Create(AcnRootLayer rootLayer, AcnBinaryReader reader) { AcnPacket packet = (AcnPacket)Activator.CreateInstance(typeof(TPacketType)); packet.Root = rootLayer; packet.ReadData(reader); return(packet); }
protected override void ReadData(AcnBinaryReader data) { LeaderId = new Guid(data.ReadBytes(16)); ChannelNumber = data.ReadOctet2(); MemberId = data.ReadOctet2(); ReliableSequenceNumber = data.ReadOctet4(); RefuseCode = (ReasonCodes)data.ReadByte(); }
protected override void ReadData(AcnBinaryReader data) { LeaderId = new Guid(data.ReadBytes(16)); ChannelNumber = data.ReadOctet2(); MemberId = data.ReadOctet2(); ReliableSequenceNumber = data.ReadOctet4(); ReciprocalChannel = data.ReadOctet2(); }
protected override void ReadData(AcnBinaryReader data) { SourceName = data.ReadUtf8String(64); Priority = data.ReadByte(); SyncPacketAddress = data.ReadOctet2(); SequenceNumber = data.ReadByte(); Options = data.ReadByte(); Universe = data.ReadOctet2(); }
public void ProcessPacket(IPEndPoint source, AcnRootLayer header, AcnBinaryReader data) { StreamingAcnDmxPacket newPacket = AcnPacket.ReadPacket(header, data) as StreamingAcnDmxPacket; if (newPacket != null) { RaiseNewPacket(source, newPacket); } }
/// <summary> /// Reads the PDU information from the recieved packet data. /// </summary> /// <param name="data">The recieved packet data.</param> protected override void ReadData(AcnBinaryReader data) { Page = data.ReadByte(); TotalPages = data.ReadByte(); for (int n = 2; n < Length; n += 2) { Universes.Add(data.ReadOctet2()); } }
protected override void ReadData(AcnBinaryReader data) { AddressType = data.ReadByte(); FirstPropertyAddress = data.ReadOctet2(); AddressIncrement = data.ReadOctet2(); int propertyLength = data.ReadOctet2(); PropertyData = data.ReadBytes(propertyLength); }
protected override void ReadData(AcnBinaryReader data) { ChannelNumber = data.ReadOctet2(); TotalSequenceNumber = data.ReadOctet4(); ReliableSequenceNumber = data.ReadOctet4(); OldestAvailableWrapper = data.ReadOctet4(); FirstMemberToAck = data.ReadOctet2(); LastMemberToAck = data.ReadOctet2(); MAKThreshold = data.ReadOctet2(); throw new NotImplementedException(); }
public static AcnPacket Build(AcnRootLayer header, AcnBinaryReader data) { IPacketBuilder packetType; if (factory.TryGetBuilder(new PacketKey(header.ProtocolId), out packetType)) { AcnPacket packet = packetType.Create(header, data); return(packet); } return(null); }
protected override void ReadData(AcnBinaryReader data) { ComponentId = new Guid(data.ReadBytes(16)); MemberId = data.ReadOctet2(); ChannelNumber = data.ReadOctet2(); ReciprocalChannel = data.ReadOctet2(); TotalSequenceNumber = data.ReadOctet4(); ReliableSequenceNumber = data.ReadOctet4(); DestinationAddress = SdtAddress.ReadData(data); ChannelParameterBlock = ChannelParameterBlock.ReadData(data); AdHocExpiry = data.ReadByte(); }
public static AcnPacket ReadPacket(AcnRootLayer header, AcnBinaryReader data) { AcnPacket packet = AcnPacket.Create(header); if (packet != null) { packet.Root = header; packet.ReadData(data); } return(packet); }
private void ProcessAcnPacket(IPEndPoint source, AcnBinaryReader data) { AcnRootLayer rootLayer = GetRootLayer(); rootLayer.ReadData(data, TcpTraffic); IProtocolFilter filter; if (filters.TryGetValue(rootLayer.ProtocolId, out filter)) { filter.ProcessPacket(source, rootLayer, data); } }
private void OnRecieve(IAsyncResult state) { if (PortOpen) { Tuple <Socket, MemoryStream> recieveState = (Tuple <Socket, MemoryStream>)(state.AsyncState); try { if (recieveState != null) { EndPoint remoteEndPoint = new IPEndPoint(IPAddress.Any, 0); int dataSize = recieveState.Item1.EndReceiveFrom(state, ref remoteEndPoint); //Protect against UDP loopback where we recieve our own packets. //Ensure we have actually recieved data. if (LocalEndPoint != remoteEndPoint && dataSize > 0) { LastPacket = DateTime.Now; IPEndPoint ipEndPoint = (IPEndPoint)remoteEndPoint; //If this is a TCP connection then the returned enpoint will be empty and we must use the connection endpoint. if (ipEndPoint.Port == 0) { ipEndPoint = (IPEndPoint)recieveState.Item1.RemoteEndPoint; } AcnBinaryReader packetReader = new AcnBinaryReader(recieveState.Item2); ProcessAcnPacket(ipEndPoint, packetReader); } } } catch (SocketException) { Close(); } catch (Exception ex) { RaiseUnhandledException(ex); } finally { //Attempt to recieve another packet. if (PortOpen) { StartRecieve(recieveState.Item1, recieveState.Item2); } } } }
/// <summary> /// Processes the packet that have been recieved and allocated to this filter. /// </summary> /// <param name="source">The source IP address of the packet.</param> /// <param name="header">The header information for the ACN packet.</param> /// <param name="data">The data reader for the remaining packet data.</param> /// <remarks> /// Only packets that have supported protocol ID's will be sent to this function. /// </remarks> void IProtocolFilter.ProcessPacket(IPEndPoint source, AcnRootLayer header, AcnBinaryReader data) { RdmNetPacket newPacket = AcnPacket.ReadPacket(header, data) as RdmNetPacket; if (newPacket != null) { RdmBinaryReader dmxReader = new RdmBinaryReader(new MemoryStream(newPacket.RdmNet.RdmData)); //Skip Start Code and sub-start code dmxReader.BaseStream.Seek(1, SeekOrigin.Begin); RdmPacket rdmPacket = RdmPacket.ReadPacket(dmxReader); RaiseNewRdmPacket(new RdmEndPoint(source, newPacket.Framing.EndpointID), rdmPacket); } }
/// <summary> /// Processes the packet that have been recieved and allocated to this filter. /// </summary> /// <param name="source">The source IP address of the packet.</param> /// <param name="header">The header information for the ACN packet.</param> /// <param name="data">The data reader for the remaining packet data.</param> /// <remarks> /// Only packets that have supported protocol ID's will be sent to this function. /// </remarks> public void ProcessPacket(IPEndPoint source, AcnRootLayer header, AcnBinaryReader data) { AcnPacket packet = AcnPacket.ReadPacket(header, data); if (packet is StreamingAcnDmxPacket) { RaiseNewPacket(source, (StreamingAcnDmxPacket)packet); } if (packet is StreamingAcnSynchronizationPacket) { RaiseNewSynchronize(source, (StreamingAcnSynchronizationPacket)packet); } if (packet is StreamingAcnDiscoveryPacket) { RaiseNewDiscovery(source, (StreamingAcnDiscoveryPacket)packet); } }
public static SdtAddress ReadData(AcnBinaryReader data) { switch ((SdtAddressTypes)data.ReadByte()) { case SdtAddressTypes.Null: return(new NullAddress()); case SdtAddressTypes.IPv4: return(new IPv4Address()); case SdtAddressTypes.IPv6: return(new IPv6Address()); default: throw new InvalidOperationException("Unknown address STD type."); } }
/// <summary> /// Creates the specified root layer. /// </summary> /// <param name="rootLayer">The root layer.</param> /// <param name="reader">The reader.</param> /// <returns></returns> public AcnPacket Create(AcnRootLayer rootLayer, AcnBinaryReader reader) { long startPosition = reader.BaseStream.Position; PduHeader pduHeader = new PduHeader(); pduHeader.ReadPdu(reader); IPacketBuilder builder; if (TryGetBuilder(new PacketKey(pduHeader.Vector), out builder)) { reader.BaseStream.Seek(startPosition, System.IO.SeekOrigin.Begin); return(builder.Create(rootLayer, reader)); } return(null); }
public virtual void ReadPdu(AcnBinaryReader data) { //Read PDU Header Length = data.ReadOctet2(); Flags = (PduFlags)((Length & 0xF000) >> 12); Length &= 0xFFF; switch (vectorLength) { case 1: Vector = data.ReadByte(); break; case 4: Vector = data.ReadOctet4(); break; } ReadData(data); }
protected abstract void ReadData(AcnBinaryReader data);
protected override void ReadData(AcnBinaryReader data) { base.ReadData(data); }
void IProtocolFilter.ProcessPacket(IPEndPoint source, AcnRootLayer header, AcnBinaryReader data) { parent.LastContact = DateTime.Now; }
protected override void ReadData(AcnBinaryReader data) { ProtocolId = data.ReadOctet4(); }
protected override void ReadData(AcnBinaryReader data) { Framing.ReadPdu(data); }
protected override void ReadData(AcnBinaryReader data) { RdmData = data.ReadBytes(Length - 3); }
/// <summary> /// Reads the PDU information from the recieved packet data. /// </summary> /// <param name="data">The recieved packet data.</param> protected override void ReadData(AcnBinaryReader data) { SourceName = data.ReadUtf8String(64); data.BaseStream.Seek(4, SeekOrigin.Current); }
protected override void ReadData(AcnBinaryReader data) { AddressType = data.ReadByte(); }
protected override void ReadData(AcnBinaryReader data) { ProtocolId = data.ReadOctet4(); Reason = (ReasonCodes)data.ReadByte(); }