private static Npdu decapAcknowledge(PACKET currentPacket)
{
Npdu currentNpdu = new Npdu();
BitArray type = new BitArray(new byte[] { currentPacket.target });
if (type[0])
{
if (type[3])
{
currentNpdu.type = "NACK";
}
else
{
currentNpdu.type = "ACK";
}
BitArray pr = new BitArray(3);
pr.Set(0, type.Get(5));
pr.Set(1, type.Get(6));
pr.Set(2, type.Get(7));
int[] next = new int[1];
pr.CopyTo(next, 0);
currentNpdu.pr = next[0];
currentNpdu.connection = currentPacket.connectionNumber.ToString();
}
else
{
currentNpdu.type = "WrongPacketFormat";
}
return(currentNpdu);
}
private static Npdu decapRelease(PACKET currentPacket)
{
Npdu currentNpdu = new Npdu();
currentNpdu.type = "N_DISCONNECT.ind";
currentNpdu.sourceAddr = currentPacket.sourceAddr.ToString();
currentNpdu.destAddr = currentPacket.destAddr.ToString();
currentNpdu.connection = currentPacket.connectionNumber.ToString();
BitArray target = new BitArray(new byte[] { currentPacket.target });
if (target[0])
{
currentNpdu.target = "Closed by Client";
}
else if (target[1])
{
currentNpdu.target = "Closed by Provider";
}
else
{
currentNpdu.target = "Unknown";
}
return(currentNpdu);
}
private static Npdu decapData(PACKET currentPacket)
{
Npdu currentNpdu = new Npdu();
currentNpdu.type = "N_DATA.ind";
currentNpdu.connection = currentPacket.connectionNumber.ToString();
BitArray type = new BitArray(new byte[] { currentPacket.packetType });
BitArray prps = new BitArray(3);
prps.Set(0, type.Get(5));
prps.Set(1, type.Get(6));
prps.Set(2, type.Get(7));
int[] num = new int[1];
prps.CopyTo(num, 0);
currentNpdu.pr = num[0];
prps.Set(0, type.Get(1));
prps.Set(1, type.Get(2));
prps.Set(2, type.Get(3));
prps.CopyTo(num, 0);
currentNpdu.ps = num[0];
if (currentPacket.dataArray != null)
{
currentNpdu.data = GetString(currentPacket.dataArray);
}
currentNpdu.flag = type[4];
return(currentNpdu);
}
public static PACKET encapsulateData(byte connectionNumber, byte pr, byte ps, bool m, byte[] dataArray)
{
PACKET currentPacket = new PACKET();
BitArray type = new BitArray(8);
type.SetAll(false);
BitArray temp = new BitArray(new byte[] { pr });
type.Set(5, temp.Get(0));
type.Set(6, temp.Get(1));
type.Set(7, temp.Get(2));
temp = new BitArray(new byte[] { ps });
type.Set(1, temp.Get(0));
type.Set(2, temp.Get(1));
type.Set(3, temp.Get(2));
type.Set(4, m);
byte[] result = new byte[1];
type.CopyTo(result, 0);
currentPacket.connectionNumber = connectionNumber;
currentPacket.packetType = result[0];
currentPacket.dataArray = dataArray;
return(currentPacket);
}
public static byte[] encapsulateDataBytes(PACKET currentPacket)
{
byte[] send = new byte[2 + currentPacket.dataArray.Length];
send[0] = currentPacket.connectionNumber;
send[1] = currentPacket.packetType;
Buffer.BlockCopy(currentPacket.dataArray, 0, send, 2, currentPacket.dataArray.Length);
return(send);
}
private static Npdu decapRequest(PACKET currentPacket)
{
Npdu currentNpdu = new Npdu();
currentNpdu.type = "N_CONNECT.ind";
currentNpdu.sourceAddr = currentPacket.sourceAddr.ToString();
currentNpdu.destAddr = currentPacket.destAddr.ToString();
currentNpdu.connection = currentPacket.connectionNumber.ToString();
return(currentNpdu);
}
public static Npdu decapPacket(PACKET currentPacket)
{
Npdu _4Transport = new Npdu();
BitArray type = new BitArray(new byte[] { currentPacket.packetType });
BitArray connectionInit, connectionEstablished, releasing;
bool[] boolArray = new bool[8] {
true, true, false, true, false, false, false, false
};
connectionInit = new BitArray(boolArray);
boolArray = new bool[8] {
true, true, true, true, false, false, false, false
};
connectionEstablished = new BitArray(boolArray);
boolArray = new bool[8] {
true, true, false, false, true, false, false, false
};
releasing = new BitArray(boolArray);
if (currentPacket.packetType == 255)
{
return(decapAcknowledge(currentPacket));
}
else if (isEqualBitArrays(type, releasing))
{
return(decapRelease(currentPacket));
}
else if (isEqualBitArrays(type, connectionEstablished))
{
return(decapConnectionEstablished(currentPacket));
}
else if (isEqualBitArrays(type, connectionInit))
{
return(decapRequest(currentPacket));
}
else if (!type[0])
{
return(decapData(currentPacket));
}
_4Transport.type = "WrongPacketFormat";
return(_4Transport);
}
public static PACKET encapsulateConnectionEstablished(byte connectionNumber, byte sourceAddr, byte destAddr)
{
PACKET currentPacket = new PACKET();
currentPacket.connectionNumber = connectionNumber;
bool[] currentType = new bool[8] {
true, true, true, true, false, false, false, false
};
BitArray type = new BitArray(currentType);
byte[] temp = new byte[1];
type.CopyTo(temp, 0);
currentPacket.packetType = temp[0];
currentPacket.sourceAddr = sourceAddr;
currentPacket.destAddr = destAddr;
return(currentPacket);
}
public static PACKET decapBytes(byte[] received)
{
PACKET currentPacket = new PACKET();
if (received.Length == 2)
{
currentPacket.connectionNumber = received[0];
currentPacket.target = received[1];
currentPacket.packetType = 255;
}
else if (received.Length == 4)
{
currentPacket.connectionNumber = received[0];
currentPacket.packetType = received[1];
currentPacket.sourceAddr = received[2];
currentPacket.destAddr = received[3];
}
else if (received.Length == 5)
{
currentPacket.connectionNumber = received[0];
currentPacket.packetType = received[1];
currentPacket.sourceAddr = received[2];
currentPacket.destAddr = received[3];
currentPacket.target = received[4];
}
else if (received.Length == 0)
{
;
}
else
{
currentPacket.connectionNumber = received[0];
currentPacket.packetType = received[1];
byte[] temp = new byte[received.Length - 2];
Buffer.BlockCopy(received, 2, temp, 0, received.Length - 2);
currentPacket.dataArray = temp;
}
return(currentPacket);
}
public static byte[] encapsulateBytes(PACKET currentPacket, string type)
{
byte[] sending;
switch (type)
{
case "request":
case "established":
sending = new byte[4];
sending[0] = currentPacket.connectionNumber;
sending[1] = currentPacket.packetType;
sending[2] = currentPacket.sourceAddr;
sending[3] = currentPacket.destAddr;
break;
case "release":
sending = new byte[5];
sending[0] = currentPacket.connectionNumber;
sending[1] = currentPacket.packetType;
sending[2] = currentPacket.sourceAddr;
sending[3] = currentPacket.destAddr;
sending[4] = currentPacket.target;
break;
case "acknowledge":
sending = new byte[2];
sending[0] = currentPacket.connectionNumber;
sending[1] = currentPacket.target;
break;
case "NACK":
sending = new byte[2];
sending[0] = currentPacket.connectionNumber;
sending[1] = currentPacket.target;
break;
default:
sending = new byte[0];
break;
}
return(sending);
}
public static PACKET[] encapsulateFullData(string lesdonnees, byte connectionNumber, byte pr)
{
PACKET[] currentPackets;
byte[] convertedData = GetBytes(lesdonnees);
int nbBytes = convertedData.Length;
int nbpackets = (nbBytes / 128) + 1;
currentPackets = new PACKET[nbpackets];
byte ps = 0;
for (int i = 0; i < nbpackets; i++)
{
int size = 128;
if (i * 128 + size > nbBytes)
{
size = nbBytes - i * 128;
}
byte[] temp = new byte[size];
int k = 0;
for (int j = i * 128; j < i * 128 + size; j++)
{
temp[k] = convertedData[j];
k++;
}
bool m = true;
if (size < 128 && i * 128 + size + 1 > nbBytes)
{
m = false;
}
int l = i % 8;
ps = (byte)l;
currentPackets[i] = encapsulateData(connectionNumber, pr, ps, m, temp);
}
return(currentPackets);
}
public static PACKET encapsulateRelease(byte connectionNumber, byte sourceAddr, byte destAddr, bool target)
{
PACKET currentPacket = new PACKET();
currentPacket.connectionNumber = connectionNumber;
bool[] currentType = new bool[8] {
true, true, false, false, true, false, false, false
};
BitArray type = new BitArray(currentType);
byte[] temp = new byte[1];
type.CopyTo(temp, 0);
currentPacket.packetType = temp[0];
currentPacket.sourceAddr = sourceAddr;
currentPacket.destAddr = destAddr;
BitArray currentTarget = new BitArray(8);
if (target)
{
currentTarget.SetAll(false);
currentTarget.Set(0, true);
}
else
{
currentTarget.SetAll(false);
currentTarget.Set(1, true);
}
byte[] result = new byte[1];
currentTarget.CopyTo(result, 0);
currentPacket.target = result[0];
return(currentPacket);
}
public static PACKET encapsulateAcknowledge(byte connectionNumber, byte prochain, bool acquitte)
{
PACKET currentPacket = new PACKET();
currentPacket.connectionNumber = connectionNumber;
BitArray temp = new BitArray(new byte[] { prochain });
BitArray next = new BitArray(8);
next.SetAll(false);
next.Set(5, temp.Get(0));
next.Set(6, temp.Get(1));
next.Set(7, temp.Get(2));
next.Set(0, true);
if (!acquitte)
{
next.Set(3, true);
}
byte[] result = new byte[1];
next.CopyTo(result, 0);
currentPacket.target = result[0];
return(currentPacket);
}
public void networkRead()
{
if (network2PacketProcessing.Peek().GetType() == typeof(byte[]))
{
byte[] packetFromNetwork = (byte[])network2PacketProcessing.Dequeue();
BitArray type = new BitArray(new byte[] { packetFromNetwork[1] });
PACKET returnPacket;
byte[] packet2Network;
if (!type[0])
{
IEnumerator enumerateur = packets.GetEnumerator();
PACKET packet;
bool found = false;
BitArray ps = new BitArray(3);
BitArray pr = new BitArray(3);
packet.sourceAddr = 0;
ps.Set(0, type.Get(1));
ps.Set(1, type.Get(2));
ps.Set(2, type.Get(3));
pr.Set(0, type.Get(5));
pr.Set(1, type.Get(6));
pr.Set(2, type.Get(7));
while (enumerateur.MoveNext())
{
PACKET currentPacket = (PACKET)enumerateur.Current;
if (currentPacket.connectionNumber == packetFromNetwork[0])
{
packet = currentPacket;
found = true;
break;
}
}
if (found)
{
if (packet.sourceAddr % 15 != 0)
{
Random rnd = new Random();
byte defect = (byte)rnd.Next(0, 7);
BitArray defectBits = new BitArray(new byte[] { defect });
byte temp = Packet.ConvertToByte(ps);
BitArray current = new BitArray(new byte[] { temp });
if (Packet.isEqualBitArrays(defectBits, current))
{
returnPacket = Packet.encapsulateAcknowledge(packetFromNetwork[0], Packet.ConvertToByte(pr), false);
packet2Network = Packet.encapsulateBytes(returnPacket, "NACK");
}
else
{
returnPacket = Packet.encapsulateAcknowledge(packetFromNetwork[0], Packet.ConvertToByte(pr), true);
packet2Network = Packet.encapsulateBytes(returnPacket, "ACK");
}
packetProcessing2Network.Enqueue(packet2Network);
}
}
else
{
returnPacket = Packet.encapsulateAcknowledge(packetFromNetwork[0], Packet.ConvertToByte(pr), false);
packet2Network = Packet.encapsulateBytes(returnPacket, "release");
packetProcessing2Network.Enqueue(packet2Network);
}
}
else if (packetFromNetwork.Length == 4)
{
if (packetFromNetwork[2] % 19 != 0)
{
if (packetFromNetwork[2] % 13 == 0)
{
returnPacket = Packet.encapsulateRelease(packetFromNetwork[0], packetFromNetwork[2], packetFromNetwork[3], true);
packet2Network = Packet.encapsulateBytes(returnPacket, "release");
}
else
{
returnPacket = Packet.encapsulateConnectionEstablished(packetFromNetwork[0], packetFromNetwork[2], packetFromNetwork[3]);
packet2Network = Packet.encapsulateBytes(returnPacket, "established");
packets.Add(returnPacket);
}
packetProcessing2Network.Enqueue(packet2Network);
}
else
{
returnPacket = Packet.encapsulateRelease(packetFromNetwork[0], packetFromNetwork[2], packetFromNetwork[3], true);
packet2Network = Packet.encapsulateBytes(returnPacket, "release");
packetProcessing2Network.Enqueue(packet2Network);
}
}
else if (packetFromNetwork.Length == 5)
{
returnPacket = Packet.encapsulateRelease(packetFromNetwork[0], packetFromNetwork[2], packetFromNetwork[3], true);
packet2Network = Packet.encapsulateBytes(returnPacket, "release");
packetProcessing2Network.Enqueue(packet2Network);
packets.Remove(returnPacket);
}
}
}
public void transportWrite()
{
while (true)
{
try
{
if (!disconnected)
{
if (packetProcessing2Network.Count > 0)
{
if (packetProcessing2Network.Peek().GetType() == typeof(byte[]))
{
string msg = "";
byte[] received = (byte[])packetProcessing2Network.Dequeue();
PACKET receivedPacket = Packet.decapBytes(received);
Npdu _4Transport = Packet.decapPacket(receivedPacket);
switch (_4Transport.type)
{
case "WrongPacketFormat":
msg = "Wrong Packet Format";
break;
case "release":
msg = "released packet: " + receivedPacket.packetType.ToString();
rejected = true;
break;
case "N_DISCONNECT.ind":
msg = "N_DISCONNECT " + _4Transport.target;
network2Transport.Enqueue(_4Transport);
accepted = true;
disconnected = true;
break;
case "N_CONNECT.ind":
msg = "N_CONNECT dest Address :" + _4Transport.destAddr + " source Address: " + _4Transport.sourceAddr;
network2Transport.Enqueue(_4Transport);
accepted = true;
break;
case "N_DATA.ind":
msg = "N_DATA transferring network data";
receivedData += _4Transport.data;
if (!_4Transport.flag)
{
_4Transport.data = receivedData;
network2Transport.Enqueue(_4Transport);
}
break;
default:
break;
}
write2Transport.WriteLine(msg);
Form1._UI.write2L_ecr(msg);
}
}
}
}
catch (ThreadAbortException)
{
}
}
}
