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();
}