void ReadCallback(IAsyncResult ar)
{
serverThreadPause.Set();
// Retrieve the state object and the handler socket
// from the asynchronous state object.
StateObject state = (StateObject)ar.AsyncState;
Socket handler = state.workSocket;
try
{
// Read data from the client socket.
int bytesRead = handler.EndReceive(ar);
if (bytesRead > 0)
{
// Use a Wrapper constructor that extracts header bytes into fields
BinaryWrapper receivedMsg = new BinaryWrapper(state.buffer.ToArray(), true);
//Log.WriteLine("[RX] Receive on interface {0}", receivedMsg.interfaceId);
packetHandlingCallback(receivedMsg, receivedMsg.interfaceId);
}
//handler.BeginReceive(state.buffer, 0, StateObject.BufferSize, 0, new AsyncCallback(ReadCallback), state);
}
catch (SocketException)
{
Log.WriteLine("[RX] Lost incoming connection.");
handler.Shutdown(SocketShutdown.Both);
handler.Close();
}
}
public DDD_spcom_File(List <byte> byteFile)
{
counts = new ObservableCollection <DDD_spcom_Count>();
entriesA = new ObservableCollection <DDD_spcom_CombinationA>();
entriesB = new ObservableCollection <DDD_spcom_CombinationB>();
header = BinaryWrapper.toObject <DDD_spcom_Header>(byteFile.GetRange(0, DDD_spcom_Header.SIZE));
// COUNTS
int countsCount = header.spiritCount + 1; // + padding?
for (int i = 0; i < countsCount; i++)
{
counts.Add(BinaryWrapper.toObject <DDD_spcom_Count>(byteFile.GetRange(header.countsOffset + i * DDD_spcom_Count.SIZE, DDD_spcom_Count.SIZE)));
}
//TABLE A
for (int i = 0; i < header.tableACount; i++)
{
entriesA.Add(BinaryWrapper.toObject <DDD_spcom_CombinationA>(byteFile.GetRange(header.tableAOffset + i * DDD_spcom_CombinationA.SIZE, DDD_spcom_CombinationA.SIZE)));
}
// TABLE B
for (int i = 0; i < header.tableBCount; i++)
{
entriesB.Add(BinaryWrapper.toObject <DDD_spcom_CombinationB>(byteFile.GetRange(header.tableBOffset + i * DDD_spcom_CombinationB.SIZE, DDD_spcom_CombinationB.SIZE)));
}
}
private int loadStackCategory(List <byte> byteFile, int currentOffset, byte category)
{
int count = 0;
switch (category)
{
case (int)DDD_ItemCategories.DREAM_PIECE:
count = COUNT_DREAM_PIECES;
break;
case (int)DDD_ItemCategories.TREAT:
count = COUNT_TREATS;
break;
case (int)DDD_ItemCategories.TRAINING_TOY:
count = COUNT_TRAINING_TOYS;
break;
default:
break;
}
for (int i = 0; i < count; i++)
{
List <byte> byteEntry = byteFile.GetRange(currentOffset, ENTRY_SIZE_STACK);
DDD_inventory_EntryStack entry = BinaryWrapper.toObject <DDD_inventory_EntryStack>(byteEntry);
entry.categoryId = category;
entry.typeId = (byte)i;
entriesStack.Add(entry);
currentOffset += ENTRY_SIZE_STACK;
}
return(currentOffset);
}
// FUNCTIONS
public List<byte> toBytes()
{
List<byte> byteFile = new List<byte>();
foreach (DDD_inventory_Command entry in entries)
{
byteFile.AddRange(BinaryWrapper.toBytes(entry));
}
return byteFile;
}
public void readAction(ProcessHandler processHandler)
{
try
{
DDD_spcom_Header byteFileHeader = BinaryWrapper.toObject <DDD_spcom_Header>(processHandler.readBytesFromProcessModule((long)DDD_Pointers.SPCOM_MOD_EGS, DDD_spcom_Header.SIZE));
loadFile(processHandler.readBytesFromProcessModule((long)DDD_Pointers.SPCOM_MOD_EGS, byteFileHeader.getFileSize()));
}
catch { writeInfoLabel("Error reading"); }
}
public DDD_spirit_File(List <byte> byteFile)
{
entries = new ObservableCollection <DDD_spirit_Entry>();
for (int i = 0; i < ENTRY_COUNT; i++)
{
List <byte> byteEntry = byteFile.GetRange(i * ENTRY_SIZE, ENTRY_SIZE);
DDD_spirit_Entry entry = BinaryWrapper.toObject <DDD_spirit_Entry>(byteEntry);
entries.Add(entry);
}
}
// FUNCTIONS
public List <byte> toBytes()
{
List <byte> byteFile = new List <byte>();
foreach (DDD_spirit_Entry entry in entries)
{
byteFile.AddRange(BinaryWrapper.toBytes(entry));
}
return(byteFile);
}
public DDD_techprm_File(List <byte> byteFile)
{
entries = new ObservableCollection <DDD_techprm_Entry>();
for (int i = 0; i < (byteFile.Count / DDD_techprm_Entry.SIZE); i++)
{
List <byte> byteEntry = byteFile.GetRange(i * DDD_techprm_Entry.SIZE, DDD_techprm_Entry.SIZE);
DDD_techprm_Entry entry = BinaryWrapper.toObject <DDD_techprm_Entry>(byteEntry);
entries.Add(entry);
}
}
// FUNCTIONS
public List <byte> toBytes()
{
List <byte> byteFile = new List <byte>();
foreach (DDD_lboard_Entry entry in entries)
{
byteFile.AddRange(BinaryWrapper.toBytes(entry));
}
//byteFile.AddRange(BinaryHelper.hexStringAsBytes(HEX_EOF));
return(byteFile);
}
private void construct(List <byte> byteFile)
{
entries = new ObservableCollection <DDD_lboard_Entry>();
int entryCount = byteFile.Count / DDD_lboard_Entry.SIZE;
for (int i = 0; i < entryCount; i++)
{
List <byte> byteEntry = byteFile.GetRange(i * DDD_lboard_Entry.SIZE, DDD_lboard_Entry.SIZE);
DDD_lboard_Entry entry = BinaryWrapper.toObject <DDD_lboard_Entry>(byteEntry);
entries.Add(entry);
}
}
public DDD_btlparam_File(List <byte> byteFile)
{
entries = new ObservableCollection <DDD_btlparam_Entry>();
int entryCount = byteFile.Count / ENTRY_SIZE;
for (int i = 0; i < entryCount; i++)
{
List <byte> byteEntry = byteFile.GetRange(i * ENTRY_SIZE, ENTRY_SIZE);
DDD_btlparam_Entry entry = BinaryWrapper.toObject <DDD_btlparam_Entry>(byteEntry);
entries.Add(entry);
}
}
// FUNCTIONS
public List <byte> toBytes()
{
List <byte> byteFile = new List <byte>();
recalcCounts();
byteFile.AddRange(BinaryWrapper.toBytes(header));
foreach (DDD_tboxdt_Entry entry in entries)
{
byteFile.AddRange(BinaryWrapper.toBytes(entry));
}
return(byteFile);
}
public void SendData(BinaryWrapper wrappedPacket, byte interfaceId)
{
if (!outSocketConnected)
{
throw new Exception("Router is not connected with wirecloud's receiving end!");
}
wrappedPacket.interfaceId = interfaceId; // Header byte 1: interface identifier number
wrappedPacket.randomNumber = (byte)((new Random()).Next() % 255); // Header byte 2: Random byte-sized ID generated based on the current timestamp
byte[] rawData = wrappedPacket.HeaderPlusData();
clientSocket.BeginSend(rawData, 0, rawData.Length, 0, new AsyncCallback(SendCallback), clientSocket); // Begin sending the data to the remote device.
}
public void SendPeerMessage(byte snppId, GenericMessage genmsg)
{
//Log.WriteLine("[TX] PeerMessage: {0}, SNPP {1}", genmsg.messageType, snppId);
MPLSPacket packet = new MPLSPacket(new int[] { 0 }, "");
packet.managementObject = genmsg;
AggregatePacket aggregatePacket = new AggregatePacket(new MPLSPacket[] { packet });
BinaryWrapper wrappedPacket = MPLSMethods.Serialize(aggregatePacket);
MAC.SendData(wrappedPacket, snppId);
//Log.WriteLine("[TX {0}] => {1}, iface {2}", snppId, genmsg.messageType, snppId);
}
// FUNCTIONS
public List <byte> toBytes()
{
List <byte> byteFile = new List <byte>();
foreach (DDD_inventory_Entry entry in entries)
{
byteFile.AddRange(BinaryWrapper.toBytes(entry));
}
foreach (DDD_inventory_EntryStack entry in entriesStack)
{
byteFile.AddRange(BinaryWrapper.toBytes(entry));
}
return(byteFile);
}
// FUNCTIONS
public List <byte> toBytes()
{
List <byte> byteFile = new List <byte>();
recalcCounts();
byteFile.AddRange(BinaryWrapper.toBytes(header));
foreach (DDD_lbtList_Board board in boards)
{
byteFile.AddRange(board.toBytes());
}
byteFile.AddRange(filePadding);
return(byteFile);
}
// FUNCTIONS
public List <byte> toBytes()
{
List <byte> byteFile = new List <byte>();
recalcCounts();
byteFile.AddRange(BinaryWrapper.toBytes(header));
foreach (DDD_itemdata_Entry entry in entries)
{
byteFile.AddRange(BinaryWrapper.toBytes(entry));
}
byteFile.AddRange(BinaryHelper.hexStringAsBytes(HEX_EOF));
return(byteFile);
}
public DDD_tboxdt_File(List <byte> byteFile)
{
// Header
header = BinaryWrapper.toObject <DDD_tboxdt_FileHeader>(byteFile.GetRange(0, HEADER_SIZE));
// Entries
entries = new ObservableCollection <DDD_tboxdt_Entry>();
for (int i = 0; i < header.totalCount; i++)
{
List <byte> byteEntry = byteFile.GetRange(HEADER_SIZE + (i * ENTRY_SIZE), ENTRY_SIZE);
DDD_tboxdt_Entry entry = BinaryWrapper.toObject <DDD_tboxdt_Entry>(byteEntry);
entries.Add(entry);
}
}
// FUNCTIONS
public List <byte> toBytes()
{
recalcCounts();
List <byte> byteFile = new List <byte>();
byteFile.AddRange(BinaryWrapper.toBytes(header));
foreach (DDD_lboard_Board board in boards)
{
byteFile.AddRange(board.toBytes());
}
byteFile.AddRange(BinaryHelper.hexStringAsBytes(HEX_EOF));
return(byteFile);
}
void SendPacketsCallback(object state)
{
foreach (TELinkEnd iface in routerInterfaces)
{
MPLSPacket[] queuedPackets = iface.GetPacketsAndEmptyQueue(); // Loads all packets stored in a queue and clears that interface's queue
if (queuedPackets.Length > 0)
{
AggregatePacket finalPacket = new AggregatePacket(queuedPackets);
BinaryWrapper wrappedPacket = MPLSMethods.Serialize(finalPacket);
MAC.SendData(wrappedPacket, iface.Id);
Log.WriteLine("[TX {0}] => {1} MPLS packet(s)", iface.Id, queuedPackets.Length);
}
}
}
public DDD_lbtList_File(List <byte> byteFile)
{
// Header
header = BinaryWrapper.toObject <DDD_lbtList_FileHeader>(byteFile.GetRange(0, HEADER_SIZE));
// Boards
boards = new ObservableCollection <DDD_lbtList_Board>();
for (int i = 0; i < header.boardCount; i++)
{
List <byte> byteBoard = byteFile.GetRange(HEADER_SIZE + (i * DDD_lbtList_Board.SIZE), DDD_lbtList_Board.SIZE);
DDD_lbtList_Board board = new DDD_lbtList_Board(byteBoard, i);
boards.Add(board);
}
// EOF padding
filePadding = byteFile.GetRange(byteFile.Count - EOFPADDING_SIZE, EOFPADDING_SIZE);
}
private int loadCategory(List <byte> byteFile, int currentOffset, byte category)
{
int count = 0;
switch (category)
{
case (int)DDD_ItemCategories.KEYBLADE:
count = COUNT_KEYBLADES;
break;
case (int)DDD_ItemCategories.RECIPE:
count = COUNT_RECIPES;
break;
case (int)DDD_ItemCategories.KEY_ITEM:
count = COUNT_KEY_ITEMS;
break;
case (int)DDD_ItemCategories.GLOSSARY:
count = COUNT_GLOSSARY;
break;
case (int)DDD_ItemCategories.MEMENTO:
count = COUNT_MEMENTO;
break;
case (int)DDD_ItemCategories.UNKNOWN:
count = COUNT_UNKNOWN;
break;
default:
break;
}
for (int i = 0; i < count; i++)
{
List <byte> byteEntry = byteFile.GetRange(currentOffset, ENTRY_SIZE);
DDD_inventory_Entry entry = BinaryWrapper.toObject <DDD_inventory_Entry>(byteEntry);
entry.categoryId = category;
entry.typeId = (byte)i;
entries.Add(entry);
currentOffset += ENTRY_SIZE;
}
return(currentOffset);
}
// FUNCTIONS
public List <byte> toBytes()
{
List <byte> byteFile = new List <byte>();
byteFile.AddRange(BinaryWrapper.toBytes(header));
foreach (DDD_spcom_Count count in counts)
{
byteFile.AddRange(BinaryWrapper.toBytes(count)); Console.WriteLine("count");
}
foreach (DDD_spcom_CombinationA entry in entriesA)
{
byteFile.AddRange(BinaryWrapper.toBytes(entry)); Console.WriteLine("entryA");
}
foreach (DDD_spcom_CombinationB entry in entriesB)
{
byteFile.AddRange(BinaryWrapper.toBytes(entry)); Console.WriteLine("entryB");
}
return(byteFile);
}
void PacketHandler(BinaryWrapper packet, byte interfaceId)
{
AggregatePacket receivedPacket = MPLSMethods.Deserialize(packet);
//Log.WriteLine("[RX {0}] \t {1} packet(s)", interfaceId, receivedPacket.packets.Length);
foreach (MPLSPacket mplspacket in receivedPacket.packets)
{
if (mplspacket.managementObject != null)
{
GenericMessage genmsg = (GenericMessage)mplspacket.managementObject;
//Log.WriteLine("[RX {0}] \t {1}", interfaceId, genmsg.messageType);
handleMgmtPackets(interfaceId, genmsg);
}
else
{
Log.WriteLine("[RX] Packet on interface {0}", interfaceId);
Route(mplspacket, interfaceId);
}
}
}
public DDD_lboard_File(List <byte> byteFile)
{
header = BinaryWrapper.toObject <DDD_lboard_Header>(byteFile.GetRange(0, DDD_lboard_Header.SIZE));
boards = new ObservableCollection <DDD_lboard_Board>();
for (int i = 0; i < header.boardCount; i++)
{
int boardOffset = header.boardOffsets[i];
int nextOffset;
if (i == header.boardCount - 1)
{
nextOffset = byteFile.Count - DDD_lboard_Entry.SIZE;
}
else
{
nextOffset = header.boardOffsets[i + 1];
}
int boardSize = nextOffset - boardOffset;
List <byte> byteEntry = byteFile.GetRange(boardOffset, boardSize);
DDD_lboard_Board entry = new DDD_lboard_Board(byteEntry, i);
boards.Add(entry);
}
}
public static void Save(IValueSink sink, BinaryWrapper value)
{
Value<BinaryPV>.Save(sink, value.Item);
}
public static void Save(IValueSink sink, BinaryWrapper value)
{
Value <BinaryPV> .Save(sink, value.Item);
}
