private void UpdatePendingRequests(IPv4 ipAddress,
EthernetAddress macAddress)
{
using (pendingRequestsLock.Lock()) {
//Sigh...we're missing a linked list in the current Singularity C# runtime
foreach (PendingArpRequest pendingRequest in pendingRequests)
{
VTable.Assert(pendingRequest != null);
if (pendingRequest.address == ipAddress)
{
pendingRequest.active = false;
DebugStub.WriteLine("found waiting arp request...sending on out");
VectorQueueByte txBuffer = pendingRequest.txContainer.Acquire();
Bytes header = txBuffer.ExtractHead();
Bytes buffer = txBuffer.ExtractHead();
VTable.Assert(header != null);
VTable.Assert(buffer != null);
pendingRequest.txContainer.Release(txBuffer);
//Format ethernet header
EthernetHeader.Write(header, pendingRequest.localMac, macAddress, EthernetHeader.PROTOCOL_IP);
//send it!
VTable.Assert(pendingRequest.adapter != null);
pendingRequest.adapter.PopulateTxRing(header, buffer);
continue;
}
}
}
}
// create a new entry
public ArpEntry(IPv4 ipAddress, EthernetAddress mac, bool dynamic)
{
this.ipAddress = ipAddress;
this.mac = mac;
this.dynamic = dynamic;
this.entryAge = ArpTable.MaxAge;
}
public void ArpRequest(IPv4 sourceIP,
IPv4 targetIP,
EthernetAddress localMac,
Bytes header,
Bytes buffer,
IAdapter adapter)
{
// AutoResetEvent requestComplete =
AddPendingRequest(targetIP, TimeSpan.FromSeconds(3), localMac, header, buffer, adapter);
// initiate an arp request...
DebugPrint("Initiating request " +
"({0},{1}) --> ({2},{3})\n",
sourceIP, localMac, targetIP, EthernetAddress.Zero);
//eventially we'll want to follow Orion's conservation of
//packets philosophy
Bytes arpHeader = new Bytes(new byte [EthernetHeader.Size]);
Bytes arpMsg = new Bytes(new byte [ArpHeader.Size]);
//xxx I'd like to get rid of EthernetHeader eventually...
EthernetHeader.Write(arpHeader,
localMac,
EthernetAddress.Broadcast,
EthernetHeader.PROTOCOL_ARP);
ArpHeader.Write(arpMsg, localMac, sourceIP,
ArpHeader.ARP_REQUEST, EthernetAddress.Zero,
targetIP);
adapter.PopulateTxRing(arpHeader, arpMsg);
// DebugPrint("ArpRequest: waiting for reply\n");
//requestComplete.WaitOne();
// DebugPrint("ArpRequest: reply received!\n");
}
// methods:
public static int Write(byte [] !pkt,
int offset,
EthernetAddress srchw,
IPv4 srcip,
Type operation,
EthernetAddress targethw,
IPv4 targetip)
{
int o = offset;
pkt[o++] = 0x00; pkt[o++] = 0x01; // hardware type = 0x0001
pkt[o++] = 0x08; pkt[o++] = 0x00; // protocol type = 0x0800
pkt[o++] = 0x06; // hardware addr len (bytes)
pkt[o++] = 0x04; // protocol address len (bytes)
pkt[o++] = (byte)(((ushort)operation) >> 8);
pkt[o++] = (byte)(((ushort)operation) & 0xff);
srchw.CopyOut(pkt, o);
o += EthernetAddress.Length;
srcip.CopyOut(pkt, o);
o += IPv4.Length;
targethw.CopyOut(pkt, o);
o += EthernetAddress.Length;
targetip.CopyOut(pkt, o);
o += IPv4.Length;
return(o);
}
public void SetHardwareAddress(EthernetAddress ea)
{
hlen = 6;
htype = (byte)HType.Ethernet;
chaddr = new byte[HardwareAddressLength];
ea.CopyOut(chaddr, 0);
}
public Ethernet(byte[] _source, byte[] _destination)
{
source = new EthernetAddress();
source.byte0 = macManufacturer[0];
source.byte1 = macManufacturer[1];
source.byte2 = macManufacturer[2];
if (_source != null)
{
if (_source.Length == 3)
{
source.byte3 = _source[0];
source.byte4 = _source[1];
source.byte5 = _source[2];
}
}
destination = new EthernetAddress();
destination.byte0 = macManufacturer[0];
destination.byte1 = macManufacturer[1];
destination.byte2 = macManufacturer[2];
if (_destination != null)
{
if (_destination.Length == 3)
{
destination.byte3 = _destination[0];
destination.byte4 = _destination[1];
destination.byte5 = _destination[2];
}
}
type = htons(0x0800);
}
public static int Write(Bytes pkt,
EthernetAddress srchw,
IPv4 srcip,
ushort operation,
EthernetAddress targethw,
IPv4 targetip)
{
int o = 0;
pkt[o++] = 0x00; pkt[o++] = 0x01; // hardware type = 0x0001
pkt[o++] = 0x08; pkt[o++] = 0x00; // protocol type = 0x0800
pkt[o++] = 0x06; // hardware addr len (bytes)
pkt[o++] = 0x04; // protocol address len (bytes)
pkt[o++] = (byte)(operation >> 8);
pkt[o++] = (byte)(operation & 0xff);
srchw.CopyOut(pkt.Array, pkt.Start + o);
o += EthernetAddress.Length;
srcip.CopyOut(pkt.Array, pkt.Start + o);
o += IPv4.Length;
targethw.CopyOut(pkt.Array, pkt.Start + o);
o += EthernetAddress.Length;
targetip.CopyOut(pkt.Array, pkt.Start + o);
o += IPv4.Length;
return(o);
}
private NetStatus SendResolved(NetPacket !packet,
Multiplexer !targetMux,
EthernetAddress localMac,
EthernetAddress remoteMac)
{
// set the ethernet data
// TBC: make the ARPModule setup the packet
{
Session session = packet.SessionContext as Session;
if (session != null)
{
DebugPrint("Sending packet for {0}/{1} ({2}-->{3})\n",
session.RemoteAddress, session.RemotePort,
localMac, remoteMac);
}
else
{
DebugPrint("Sending packet to {0}\n", remoteMac);
}
}
Debug.Assert(packet.IsOneChunk);
EthernetFormat.Write((byte[] !)packet.GetRawData(), 0,
localMac, remoteMac,
EthernetFormat.PROTOCOL_IP);
targetMux.SendBuffered(packet);
return(NetStatus.Code.PROTOCOL_OK);
}
internal override void EnterEvent()
{
client.StartNewTransaction();
DhcpFormat dhcp =
new DhcpFormat(DhcpFormat.MessageType.Discover);
dhcp.TransactionID = client.TransactionID;
dhcp.SetHardwareAddress(client.MacAddress);
#if ADVERTISE_CLIENT_ID
// Add Client Identifier for self
//
// [2006-02-03 ohodson] This is disabled because the Windows
// DHCP server allocates us a different address with the
// client id present if we networked booted. Thus having the
// identifier breaks static DHCP entries which we use
// for test machines.
EthernetAddress macAddress = client.MacAddress;
dhcp.AddOption(DhcpClientID.Create(macAddress.GetAddressBytes()));
#endif
// Add parameters we'd like to know about
dhcp.AddOption(DhcpParameterRequest.Create(
DhcpClient.StandardRequestParameters
)
);
// dhcp.AddOption(DhcpAutoConfigure.Create(0));
client.Send(EthernetAddress.Broadcast, dhcp);
client.ChangeState(new DhcpClientStateSelecting(client));
}
private void Respond(DhcpFormat request, DhcpFormat.MessageType m)
{
DhcpFormat response = new DhcpFormat(m);
response.TransactionID = request.TransactionID;
EthernetAddress hwAddress = request.GetHardwareAddress();
response.SetHardwareAddress(hwAddress);
switch (m)
{
case DhcpFormat.MessageType.Offer:
response.NextServerIPAddress = ServerAddress;
response.AddOption(
DhcpIPAddressLeaseTime.Create(RebindingTime)
);
goto case DhcpFormat.MessageType.Ack;
case DhcpFormat.MessageType.Ack:
response.YourIPAddress = HostAddress;
assignedAddress = HostAddress;
FillOptions(request, response);
break;
case DhcpFormat.MessageType.Nak:
// Nothing to do
break;
default:
return;
}
SendResponsePacket(response);
}
public void ArpRequest(IPv4 sourceIP,
IPv4 targetIP,
Multiplexer !targetMux,
ArpRequestCallback callback,
object cookie,
TimeSpan timeout)
{
//
//XXXX Check pending request does not already exist!
//
EthernetAddress localMac = targetMux.Adapter.HardwareAddress;
AddPendingRequest(targetIP, callback, cookie, timeout);
// initiate an arp request...
DebugPrint("Initiating request " +
"({0},{1}) --> ({2},{3})\n",
sourceIP, localMac, targetIP, EthernetAddress.Zero);
byte[] data = new byte[ArpFormat.Size + EthernetFormat.Size];
int pos = EthernetFormat.Write(data, 0, localMac,
EthernetAddress.Broadcast,
EthernetFormat.PROTOCOL_ARP);
ArpFormat.Write(data, pos, localMac, sourceIP,
ArpFormat.Type.ARP_REQUEST, EthernetAddress.Zero,
targetIP);
NetPacket pkt = new NetPacket(data);
pkt.Mux = targetMux;
OnProtocolSend(pkt);
}
public EthernetAddress GetHardwareAddress()
{
if (htype != (byte)HType.Ethernet)
{
// XXX Throw some nasty exception
}
return(EthernetAddress.ParseBytes(chaddr, 0));
}
public FrameHeader(EthernetAddress origin,
EthernetAddress target,
ushort protocol)
{
this.origin = origin;
this.target = target;
this.protocol = protocol;
}
public Nic(NicDeviceContract /*.Imp*/ nicImp,
NicDeviceProperties np,
string nicName)
{
this.nicChannel = new TRef(nicImp);
//assume np.DriverName != null;
//assume np.MacAddress != null;
this.driverName = np.DriverName;
this.driverVersion = np.DriverName;
this.macAddress = np.MacAddress;
this.nicName = nicName;
this.mtu = np.MtuBytes;
this.maxTxPacketsInDevice = np.MaxTxPacketsInDevice;
this.maxRxPacketsInDevice = np.MaxRxPacketsInDevice;
this.maxTxFragmentsPerPacket = np.MaxTxFragmentsPerPacket;
this.maxRxFragmentsPerPacket = np.MaxRxFragmentsPerPacket;
this.muxEvent = new AutoResetEvent(false);
// The following attributes are both integers yet
// sgc is complaining it doesn't know to use
// Math.Min(sbyte, sbyte) or Math.Min(byte, byte).
int rxFifoSize = Math.Min(np.MaxRxPacketsInDevice,
(int)Nic.MaxRxPacketsInDevice);
this.rxFifo =
new ExRefPacketFifo(
new PacketFifo(rxFifoSize),
false
);
// The following attributes are both integers yet
// sgc is complaining it doesn't know to use
// Math.Min(sbyte, sbyte) or Math.Min(byte, byte).
int txFifoSize = Math.Min(np.MaxTxPacketsInDevice,
(int)Nic.MaxTxPacketsInDevice);
this.txFifo =
new ExRefPacketFifo(
new PacketFifo(txFifoSize),
true
);
this.txFreeFifo =
new ExRefPacketFifo(
new PacketFifo(txFifoSize),
true
);
this.txCoalesceFifo =
new ExRefPacketFifo(
new PacketFifo(txFifoSize),
true
);
TxProvision();
RxProvision();
}
private void SetupMac()
{
uint ral, rah;
// Setup our Ethernet address
macAddress = GetMacFromEeprom();
DebugStub.Print("Setting Ethernet Mac Address to " + macAddress + ". ");
GetMacHiLow(out ral, out rah, macAddress);
rah = rah | RahRegister.ADDRESS_VALID;
Write32(Register.RAL0, ral);
Write32(Register.RAH0, rah);
// Clear the mutlicast table array
for (uint i = 0; i < MtaRegister.MTA_LENGTH; i++)
{
Write32(Register.MTA_START + (4 * i), 0);
}
// Setup Descriptor buffers for rx
ResetRxRingBuffer();
// Setup Receiever Control flags
Write32(Register.RECV_CTRL, (RecvCtrlBits.BROADCAST_ACCEPT |
RecvCtrlBits.STRIP_CRC |
RecvCtrlBits.LOOPBACK_MODE_DISABLE |
RecvCtrlBits.MULTICAST_OFFSET_47_36 |
RecvCtrlBits.BUFFER_SIZE_2KB |
RecvCtrlBits.RECV_DESC_THRESHOLD_QUARTER));
// Note: If MTU ever changes (e.g. for jumbo frames), the
// recv buffer size will need to be increased.
// Setup the rx interrupt delay
Write32(Register.RECV_DELAY_TIMER, RxDelayTimers.RECV_DELAY_TIMER);
Write32(Register.RECV_INT_ABS_TIMER, RxDelayTimers.RECV_ABSOLUTE_TIMER);
// Enable IP and TCP checksum calculation offloading
Write32(Register.RECV_CHECKSUM, (RecvChecksumBits.IP_CHECKSUM_ENABLE |
RecvChecksumBits.TCP_CHECKSUM_ENABLE |
RecvChecksumBits.IP6_CHECKSUM_ENABLE));
// Setup Descriptor buffers for tx
ResetTxRingBuffer();
// Setup Transmit Control flags
Write32(Register.TSMT_CTRL,
TsmtCtrlBits.PAD_SHORT_PACKETS |
TsmtCtrlBits.COLL_THRESHOLD_DEFAULT |
TsmtCtrlBits.COLL_DISTANCE_DEFAULT);
// Setup Transmit Inter Frame Gap
Write32(Register.TSMT_IPG, TsmtIpg.DEFAULT_IPG);
// TODO enable transmit checksum offloading
}
// Write an Ethernet header assuming that the header begins at offset 0
public static void Write(Bytes header,
EthernetAddress src,
EthernetAddress dst,
ushort type)
{
dst.CopyOut(header.Array, header.Start);
src.CopyOut(header.Array, header.Start + EthernetAddress.Length);
header[12] = (byte)(type >> 8);
header[13] = (byte)(type & 0xff);
}
// parse "pkt" from "start" bytes in, and return the
// "src" and "dst" Ethernet addresses, and the protocol
// "type" Returns the byte offset of the next layer's
// header.
public static int Read(byte [] !pkt,
int start,
out EthernetAddress src,
out EthernetAddress dst,
out ushort type)
{
dst = EthernetAddress.ParseBytes(pkt, start);
src = EthernetAddress.ParseBytes(pkt, start + 6);
type = (ushort)((pkt[start + 12] << 8) | (pkt[start + 13]));
return(start + 14);
}
public static bool Read(IBuffer !buf,
out EthernetAddress src,
out EthernetAddress dst,
out ushort type)
{
bool b;
b = buf.ReadEthernetAddress(out dst);
b &= buf.ReadEthernetAddress(out src);
b &= buf.ReadNet16(out type);
return(b);
}
public bool ReadEthernetAddress(out EthernetAddress address)
{
try {
address = EthernetAddress.ParseBytes(data, position);
position += EthernetAddress.Length;
}
catch (ArgumentException) {
address = EthernetAddress.Zero;
return(false);
}
return(true);
}
///////////////////////////////////////////////////////////////////////
//
// Helper functions
//
internal void GetMacHiLow(out uint addr_low,
out uint addr_hi,
EthernetAddress mac)
{
byte[] macBytes = mac.GetAddressBytes();
addr_hi = (uint)((macBytes[5] << 8) |
(macBytes[4]));
addr_low = (uint)((macBytes[3] << 24) |
(macBytes[2] << 16) |
(macBytes[1] << 8) |
(macBytes[0]));
}
// an upper layer interface to get the mac
// to a target IP. The upper protocol must
// provide the Mux for the target IP.
// if we have it then we return true + macAddress
// and refresh the age to create a LRU list
public bool Lookup(IPv4 targetIP, out EthernetAddress macAddress)
{
ArpEntry e = arpEntries[targetIP] as ArpEntry;
if (e != null)
{
e.EntryAge = Age;
macAddress = e.MacAddress;
return(true);
}
macAddress = EthernetAddress.Zero;
return(false);
}
// Write an Ethernet header to "pkt", starting at position "start".
public static int Write(byte[] !pkt,
int start,
EthernetAddress src,
EthernetAddress dst,
ushort type)
{
dst.CopyOut(pkt, start);
src.CopyOut(pkt, start + EthernetAddress.Length);
pkt[start + 12] = (byte)(type >> 8);
pkt[start + 13] = (byte)(type & 0xff);
return(start + 14);
}
public ArpHeader(Bytes packet, ushort index)
{
//since this is already known to be an arp request
//we skip the sanity checks...
VTable.Assert(packet.Length - index >= 96);
// check hardware type == 0x0001 (Ethernet)
htype = NetworkBitConverter.ToUInt16(packet, index);
DebugStub.Assert(htype == 0x001);
index += 2;
// check protocol type == 0x0800 (IP)
ptype = NetworkBitConverter.ToUInt16(packet, index);
DebugStub.Assert(ptype == 0x0800);
index += 2;
// check hardware address len is 6 bytes
hlen = packet[index++];
DebugStub.Assert(hlen == 6);
// check IP address len is 4 bytes
plen = packet[index++];
DebugStub.Assert(plen == 4);
op = NetworkBitConverter.ToUInt16(packet, index);
index += 2;
senderEthernetAddr = EthernetAddress.ParseBytes(packet.Array, packet.Start + index);
index += EthernetAddress.Length;
uint addr = NetworkBitConverter.ToUInt32(packet, index);
index += 4;
senderIPAddr = new IPv4(addr);
destEthernetAddr = EthernetAddress.ParseBytes(packet.Array, packet.Start + index);
index += EthernetAddress.Length;
addr = NetworkBitConverter.ToUInt32(packet, index);
index += 4;
destIPAddr = new IPv4(addr);
//sgc complains
pad0 = 0;
pad1 = 0;
}
private void UpdatePendingRequests(IPv4 ipAddress,
EthernetAddress macAddress)
{
int i = 0;
while (i != pendingRequests.Count)
{
PendingRequest request = (PendingRequest !)pendingRequests[i];
if (request.address == ipAddress)
{
request.callback(ipAddress, macAddress, request.cookie);
pendingRequests.RemoveAt(i);
continue;
}
i++;
}
}
internal bool Send(EthernetAddress dstAddr, DhcpFormat dhcp)
{
int packetSize = dhcp.Size;
int headerSize = EthernetHeader.Size + UDPHeader.Size + IpHeader.Size;
Bytes packet = new Bytes(new byte [packetSize]);
Bytes header = new Bytes(new byte [headerSize]);
// Write out DHCP packet
dhcp.Write(packet, 0);
//the correct ports/addresses should already be bound up in instance of the UDP object
udp.WriteCompleteUDPHeader(header, packet, dhcp.Size);
// Add Ethernet Header
EthernetHeader.Write(header, adapter.HardwareAddress,
dstAddr, EthernetHeader.PROTOCOL_IP);
adapter.PopulateTxRing(header, packet);
return(true);
}
internal bool Send(EthernetAddress dstAddr, DhcpFormat !dhcp)
{
int packetSize = dhcp.Size + UdpFormat.Size +
IPFormat.Size + EthernetFormat.Size;
byte [] packet = new byte [packetSize];
// Write out DHCP packet
int dhcpSize = dhcp.Size;
int dhcpOffset = packet.Length - dhcpSize;
dhcp.Write(packet, dhcpOffset);
// Create UDP Header
UdpFormat.UdpHeader udpHeader = new UdpFormat.UdpHeader();
udpHeader.srcPort = DhcpFormat.ClientPort;
udpHeader.dstPort = DhcpFormat.ServerPort;
udpHeader.length = (ushort)(UdpFormat.Size + dhcpSize);
// Create IP Header
IPFormat.IPHeader ipHeader = new NetStack.Protocols.IPFormat.IPHeader();
ipHeader.SetDefaults(IPFormat.Protocol.UDP);
IPFormat.SetDontFragBit(ipHeader);
ipHeader.Source = IPv4.Any;
ipHeader.Destination = IPv4.Broadcast;
ipHeader.totalLength = (ushort)(IPFormat.Size + UdpFormat.Size + dhcpSize);
// Write out IP and Header
int udpOffset = packet.Length - dhcp.Size - UdpFormat.Size;
int ipOffset = udpOffset - IPFormat.Size;
UdpFormat.WriteUdpPacket(packet, ipOffset,
ipHeader, ref udpHeader,
packet, dhcpOffset, dhcpSize);
// Add Ethernet Header
EthernetFormat.Write(packet, 0, adapter.HardwareAddress,
dstAddr, EthernetFormat.PROTOCOL_IP);
NetPacket np = new NetPacket(packet);
return(udpSession.WritePacket(np));
}
private void ArpResponse(IPv4 address,
EthernetAddress answer,
object cookie)
{
NetPacket !packet = (NetPacket !)cookie;
DebugPrint("Got ARP response for {0} -> {1}", address, answer);
UnblockAssociatedSession(packet);
if (answer != EthernetAddress.Zero)
{
Multiplexer mux = (Multiplexer !)packet.Mux;
SendResolved(packet, mux, mux.Adapter.HardwareAddress, answer);
Core.Instance().SignalOutboundPackets();
}
else
{
DebugPrint("ARP timed out for {0}", address);
}
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void testMultithreaded() throws InterruptedException
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
public virtual void testMultithreaded()
{
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final java.util.List<Thread> threads = new java.util.ArrayList<Thread>();
IList <Thread> threads = new List <Thread>();
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final com.fasterxml.uuid.impl.TimeBasedGenerator timeBasedGenerator = com.fasterxml.uuid.Generators.timeBasedGenerator(com.fasterxml.uuid.EthernetAddress.fromInterface());
TimeBasedGenerator timeBasedGenerator = Generators.timeBasedGenerator(EthernetAddress.fromInterface());
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final java.util.concurrent.ConcurrentSkipListSet<String> generatedIds = new java.util.concurrent.ConcurrentSkipListSet<String>();
ConcurrentSkipListSet <string> generatedIds = new ConcurrentSkipListSet <string>();
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final java.util.concurrent.ConcurrentSkipListSet<String> duplicatedIds = new java.util.concurrent.ConcurrentSkipListSet<String>();
ConcurrentSkipListSet <string> duplicatedIds = new ConcurrentSkipListSet <string>();
for (int i = 0; i < THREAD_COUNT; i++)
{
Thread thread = new Thread(() =>
{
for (int j = 0; j < LOOP_COUNT; j++)
{
string id = timeBasedGenerator.generate().ToString();
bool wasAdded = generatedIds.add(id);
if (!wasAdded)
{
duplicatedIds.add(id);
}
}
});
threads.Add(thread);
thread.Start();
}
foreach (Thread thread in threads)
{
thread.Join();
}
Assert.assertEquals(THREAD_COUNT * LOOP_COUNT, generatedIds.size());
Assert.assertTrue(duplicatedIds.Empty);
}
public LoopbackAdapter()
{
LoopbackAdapter.instantiations++;
//
// Microsoft OUI 00:50:F2:xx:xx:xx
// It doesn't really matter, but something other
// than zero is preferable for testing purposes.
//
int x = 0xFFFFFF - instantiations;
address = new EthernetAddress(0x00, 0x50, 0xF2,
(byte)((x >> 16) & 0xFF),
(byte)((x >> 8) & 0xFF),
(byte)((x >> 0) & 0xFF));
writeEvent = new AutoResetEvent(false);
readEvent = new AutoResetEvent(false);
rxBuffer = new Queue(LoopbackAdapter.RingSize);
txDeliveryComplete = 0;
rxAvailable = 0;
}
private AutoResetEvent AddPendingRequest(IPv4 address,
TimeSpan timeout,
EthernetAddress localMac,
Bytes header,
Bytes buffer,
IAdapter adapter
)
{
PendingArpRequest pendingRequest = (PendingArpRequest)pendingRequestsFreelist.Dequeue();
VTable.Assert(pendingRequest != null);
pendingRequest.address = address;
pendingRequest.active = true;
pendingRequest.localMac = localMac;
pendingRequest.adapter = adapter;
VectorQueueByte txBuffer = pendingRequest.txContainer.Acquire();
txBuffer.AddTail(header);
txBuffer.AddTail(buffer);
pendingRequest.txContainer.Release(txBuffer);
using (pendingRequestsLock.Lock()) {
pendingRequests.Enqueue(pendingRequest);
}
SchedulerTime expiration = SchedulerTime.Now;
expiration = expiration.Add(timeout);
pendingRequest.requestExpiration = expiration;
//poke the wait thread
if (pendingRequests.Count == 1)
{
arpHandle.Set();
}
return(pendingRequest.requestEvent);
}