public MITM_Service()
{
hostsIPends = new List <byte>();
packetStructs = new Queue <PacketStruct>();
packetLockObject = new object();
publisher = new Publisher();
dataLinkHandler = new DataLinkHandler();
applicationHandler = new ApplicationHandler();
}
public DNP3Handler()
{
DNP3ApplicationHandler = new ApplicationHandler();
DNP3DataLinkHandler = new DataLinkHandler();
}
/// <summary>
/// Processing answers from Simulator - Process Controller
/// </summary>
public void ProcessPCAnwers(TimeSpan timeout, CancellationToken token)
{
DataLinkHandler dataLinkHandler = new DataLinkHandler();
while (!token.IsCancellationRequested)
{
bool isSuccessful;
IORequestBlock answer = IORequests.DequeueAnswer(out isSuccessful, timeout);
if (isSuccessful)
{
bool isChange = false;
RTU rtu;
if ((rtu = dbContext.GetRTUByName(answer.ProcessControllerName)) != null)
{
switch (rtu.Protocol)
{
case IndustryProtocols.ModbusTCP:
ModbusHandler mdbHandler = new ModbusHandler();
try
{
mdbHandler.UnpackData(answer.RcvBuff, answer.RcvMsgLength);
switch (mdbHandler.Response.FunCode)
{
case FunctionCodes.ReadDiscreteInput:
{
BitReadResponse response = (BitReadResponse)mdbHandler.Response;
var responsePVCount = answer.Flags;
ushort varAddr = answer.ReqAddress;
for (int i = 0; i < responsePVCount; i++, varAddr++)
{
ProcessVariable pv;
if (rtu.GetProcessVariableByAddress(varAddr, out pv))
{
Digital target = (Digital)pv;
try
{
bool isOpened = response.BitValues[i];
if (target.State != target.ValidStates[isOpened ? 1 : 0])
{
isChange = true;
target.State = target.ValidStates[isOpened ? 1 : 0];
Console.WriteLine(" CHANGE! Digital variable {0}, state: {1}", target.Name, target.State);
dMSProxy.ChangeOnSCADADigital(target.Name, target.State);
}
}
catch
{
Console.WriteLine("Digital variable {0}, state: INVALID", target.Name);
}
}
}
if (isChange)
{
ScadaModelParser parser = new ScadaModelParser();
parser.SerializeScadaModel();
}
}
break;
// analog input
case FunctionCodes.ReadInputRegisters:
{
RegisterReadResponse response = (RegisterReadResponse)mdbHandler.Response;
var responsePVCount = answer.Flags;
ushort varAddr = answer.ReqAddress;
for (int i = 0; i < responsePVCount; i++, varAddr++)
{
ProcessVariable pv;
if (rtu.GetProcessVariableByAddress(varAddr, out pv))
{
Analog target = (Analog)pv;
try
{
ushort newRawAcqValue = response.RegValues[target.RelativeAddress];
float newAcqValue;
AnalogProcessor.RawValueToEGU(target, newRawAcqValue, out newAcqValue);
if (target.AcqValue != newAcqValue)
{
isChange = true;
target.RawAcqValue = newRawAcqValue;
target.AcqValue = newAcqValue;
Console.WriteLine(" CHANGE! Analog variable {0}, AcqValue: {1}", target.Name, target.AcqValue);
//to do: propagacija analogih promena(ako se secate Pavlica je prvo rekao da nam to ne treba da samo jednom zakucamo vrednost na pocetku) xD
dMSProxy.ChangeOnSCADAAnalog(target.Name, target.AcqValue);
}
}
catch
{
// Console.WriteLine("Digital variable {0}, state: INVALID", target.Name);
}
}
}
if (isChange)
{
ScadaModelParser parser = new ScadaModelParser();
parser.SerializeScadaModel();
}
}
break;
}
}
catch (Exception e)
{
Console.WriteLine(e.Message);
}
break;
case IndustryProtocols.DNP3TCP:
byte len = answer.RcvBuff[2];
byte actualLen = (byte)(2 + 1 + 5 + 2); // start + len + ctrl + dest + source + crc
len -= 5; // minus header
while (len > 0)
{
if (len < 16)
{
// last chunk
actualLen += (byte)(len + 2);
break;
}
actualLen += (byte)(16 + 2);
len -= 16;
}
byte[] message = new byte[actualLen];
for (int i = 0; i < actualLen; i++)
{
message[i] = answer.RcvBuff[i];
}
List <UserLevelObject> userLevelObjects = dataLinkHandler.PackUp(message);
if (userLevelObjects == null)
{
continue;
}
DNP3UserLayerHandler dNP3UserLayerHandler = new DNP3UserLayerHandler(new DNP3Handler(), dbContext);
List <Tuple <string, float> > tuples = dNP3UserLayerHandler.ReadAllAnalogInputPointsReadResponse(userLevelObjects, rtu.Name);
foreach (Tuple <string, float> tuple in tuples)
{
try
{
dMSProxy.ChangeOnSCADAAnalog(tuple.Item1, tuple.Item2);
}
catch
{
dMSProxy = new DMSSCADAProxy();
}
}
break;
}
}
}
}
Console.WriteLine("ProcessPCAnswers.shutdown=true");
return;
}
public List <byte[]> PackDown(byte[] data, bool isRequest, bool isMaster)
{
List <byte[]> segments = new List <byte[]>();
bool fir = true;
byte sequence = 0;
TransportHeader transportHeader = new TransportHeader();
TransportSegment transportSegment = new TransportSegment(transportHeader);
int dataCount = data.Count();
int dataIndex = 0;
while (dataCount > 0)
{
if (sequence == 64)
{
sequence = 0;
}
else
{
sequence++;
}
int totalLength = 1;
byte[] temp = null;
if (fir)
{
transportHeader.Header[6] = true; // FIR
fir = false;
sequence = 0;
}
else
{
transportHeader.Header[6] = false; // FIR
}
if (dataCount <= segmentMaxSize)
{
transportHeader.Header[7] = true; // FIN
temp = new byte[dataCount + 1];
for (int i = 1; i <= dataCount; i++)
{
temp[i] = data[dataIndex++];
}
totalLength += dataCount;
}
else
{
temp = new byte[segmentMaxSize + 1];
for (int i = 1; i <= dataCount; i++)
{
temp[i] = data[dataIndex++];
}
totalLength += segmentMaxSize;
}
dataCount -= segmentMaxSize;
dataIndex += segmentMaxSize;
BitArray tempSeq = new BitArray(new byte[] { sequence });
transportHeader.Header[5] = tempSeq[5]; // Sequence
transportHeader.Header[4] = tempSeq[4];
transportHeader.Header[3] = tempSeq[3];
transportHeader.Header[3] = tempSeq[2];
transportHeader.Header[2] = tempSeq[1];
transportHeader.Header[0] = tempSeq[0];
temp[0] = transportHeader.ToBytes()[0];
byte[] finalDataLinkSegment = new byte[totalLength];
for (int i = 0; i < totalLength; i++)
{
finalDataLinkSegment[i] = temp[i];
}
segments.Add(finalDataLinkSegment);
}
List <byte[]> returnValue = new List <byte[]>();
DNP3DataLinkHandler = new DataLinkHandler();
foreach (byte[] segment in segments)
{
List <byte[]> tempSegments = new List <byte[]>()
{
DNP3DataLinkHandler.PackDown(segment, isRequest, isMaster, DataLinkFunctionCodes.UNCONFIRMED_USER_DATA)
};
foreach (byte[] tempSegment in tempSegments)
{
returnValue.Add(tempSegment);
}
}
return(returnValue);
}
void ProcessRequest(TcpClient client)
{
DataLinkHandler dataLinkHandler = new DataLinkHandler();
Byte[] bytes = new Byte[1000];
NetworkStream stream = client.GetStream();
byte actualLen = 0;
int i = 0;
while ((i = stream.Read(bytes, 0, bytes.Length)) != 0)
{
byte len = bytes[2];
actualLen = (byte)(2 + 1 + 5 + 2); // start + len + ctrl + dest + source + crc
len -= 5; // minus header
while (len > 0)
{
if (len < 16)
{
// last chunk
actualLen += (byte)(len + 2);
break;
}
actualLen += (byte)(16 + 2);
len -= 16;
}
byte[] message = new byte[actualLen];
for (i = 0; i < actualLen; i++)
{
message[i] = bytes[i];
}
List <UserLevelObject> userLevelObjects = dataLinkHandler.PackUp(message);
if (userLevelObjects == null)
{
continue;
}
DNP3Handler dNP3Handler = new DNP3Handler();
DNP3UserLayerHandler userLayer = new DNP3UserLayerHandler(dNP3Handler);
List <byte[]> segments = userLayer.ReadAllAnalogInputPointsResponse(userLevelObjects);
int offset = 0;
foreach (byte[] segment in segments)
{
try
{
stream.Write(segment, offset, segment.Count());
}
catch (Exception e) { }
}
}
}
