private async void _conn_OnRequest(IRemoteMessage message)
{
if (message is TunnelRequest)
{
TunnelRequest req = message as TunnelRequest;
if (req.ConnId != 0 && req.ConnId != _connId)
{
return;
}
switch (req.Type)
{
case TunnelTypes.Tunnel:
IMessage msg = (IMessage)JsonConvert.DeserializeObject(Encoding.UTF8.GetString(req.Data), new JsonSerializerSettings()
{
TypeNameHandling = TypeNameHandling.Auto
});
Debug.WriteLine("Tunnel: " + msg);
byte seq = await _knxConn.Send(msg);
TunnelResponse req2 = new TunnelResponse(new byte[] { seq });
req2.Type = TunnelTypes.Response;
req2.ConnId = req.ConnId;
req2.SequenceNumber = req.SequenceNumber;
_ = _conn.Send(req2, false);
break;
}
}
}
public async Task Connect()
{
Debug.WriteLine(DateTime.Now);
TunnelRequest req = new TunnelRequest(Encoding.UTF8.GetBytes(Hash));
req.Type = TunnelTypes.Connect;
IRemoteMessage resp = await _conn.Send(req);
if (resp == null)
{
throw new Exception("Keine Antwort vom Remote Server");
}
TunnelResponse response = resp as TunnelResponse;
if (response == null)
{
throw new Exception("Unerwartete Antwort vom Remote Server: " + response.ToString());
}
IsConnected = true;
_connId = response.ConnId;
Debug.WriteLine(DateTime.Now);
Debug.WriteLine("Verbunden");
}
public async Task <int> ConnectToInterface(TunnelRequest req)
{
try
{
_connId = new Random().Next(1, 255);
await _knxConn.Connect();
TunnelResponse res = new TunnelResponse();
res.Type = TunnelTypes.Connect;
res.SequenceNumber = req.SequenceNumber;
res.Group = req.Group;
res.ChannelId = req.ChannelId;
res.ConnId = _connId;
Group = req.Group;
ChannelId = req.ChannelId;
_ = _conn.Send(res, false);
}
catch (Exception ex)
{
TunnelResponse res = new TunnelResponse();
res.Group = req.Group;
res.ChannelId = req.ChannelId;
res.ConnId = 0;
res.Data = Encoding.UTF8.GetBytes(ex.Message);
_ = _conn.Send(res, false);
}
return(_connId);
}
public byte[] GetBytesCemi()
{
if (IsExtended && Length > 256)
{
throw new Exception("Bei cEmi kann maximal 256 Bytes ausgelesen werden. (Angefordert waren " + Length + " bytes)[ExtendedFrame]");
}
if (!IsExtended && Length > 13)
{
throw new Exception("Bei cEmi kann maximal 13 Bytes ausgelesen werden. (Angefordert waren " + Length + " bytes)[StandardFrame]");
}
List <byte> data = new List <byte> {
BitConverter.GetBytes(Length)[0]
};
byte[] addr = BitConverter.GetBytes(Address);
data.Add(addr[1]);
data.Add(addr[0]);
Builders.TunnelRequest builder = new TunnelRequest();
if (IsExtended)
{
builder.SetIsExtended();
}
builder.Build(UnicastAddress.FromString("0.0.0"), DestinationAddress, ApciTypes.MemoryRead, SequenceNumber, data.ToArray());
data = new List <byte>()
{
0x11, 0x00
};
data.AddRange(builder.GetBytes());
return(data.ToArray());
}
public async Task <byte> Send(IMessage message, bool ignoreConnected = false)
{
if (!ignoreConnected && !IsConnected)
{
throw new Exception("Roflkopter 2");
}
Debug.WriteLine("Sende nun einen normalen Request");
Debug.WriteLine("------------------------------------------------------------------------------------");
TunnelRequest req = new TunnelRequest();
req.Type = TunnelTypes.Tunnel;
req.ConnId = _connId;
req.Data = Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(message, new JsonSerializerSettings()
{
TypeNameHandling = TypeNameHandling.All
}));
IRemoteMessage resp = await _conn.Send(req);
if (resp is TunnelResponse)
{
return((resp as TunnelResponse).Data[0]);
}
return(0);
}
public byte[] GetBytesCemi()
{
List <byte> data = new List <byte>()
{
0x11, 0x00
};
TunnelRequest builder = new TunnelRequest();
builder.Build(SourceAddress, DestinationAddress, ApciTypes.GroupValueWrite, 255, _data);
data.AddRange(builder.GetBytes());
return(data.ToArray());
}
public byte[] GetBytesEmi1()
{
List <byte> data = new List <byte>()
{
0x11, 0x00
};
TunnelRequest builder = new TunnelRequest();
builder.Build(UnicastAddress.FromString("0.0.0"), MulticastAddress.FromString("0/0/0"), ApciTypes.IndividualAddressRead);
data.AddRange(builder.GetBytes());
return(data.ToArray());
}
public byte[] GetBytesCemi()
{
List <byte> data = new List <byte>()
{
0x11, 0x00
};
TunnelRequest builder = new TunnelRequest();
builder.Build(UnicastAddress.FromString("0.0.0"), DestinationAddress, ApciTypes.Connect, 255);
data.AddRange(builder.GetBytes());
return(data.ToArray());
}
private ConnectionInfo Virtualize(string connectionString, string sshTunnelInfo)
{
lock (Mutex)
{
if (Clients.ContainsKey(connectionString))
{
return(Clients[connectionString]);
}
var virtualizedConnectionString = connectionString;
var url = MongoUrl.Create(connectionString);
IMongoClient client = null;
if (!TunnelClient.GetInstance()
.ForwardedPortInfoExists(url.Server.Host, Convert.ToUInt32(url.Server.Port)))
{
client = new MongoClient(connectionString);
if (!Ping(client))
{
client = null;
}
}
if (client == null)
{
var tunnelRequest = new TunnelRequest
{
RemoteHost = url.Server.Host,
RemotePort = Convert.ToUInt32(url.Server.Port), SshTunnelInfo = sshTunnelInfo
};
var portInfo = TunnelClient.GetInstance().GetForwardedPortInfo(tunnelRequest);
var newConnectionString = string.Format("mongodb://{2}{3}:{0}/{1}", portInfo.BoundPort,
url.DatabaseName,
string.IsNullOrWhiteSpace(url.Username)
? string.Empty
: string.Concat(url.Username, ":", url.Password, "@"), portInfo.BoundHost);
virtualizedConnectionString = newConnectionString;
client = new MongoClient(newConnectionString);
if (!Ping(client))
{
throw new Exception("Can't connect to MongoDb");
}
}
var connectionInfo =
new ConnectionInfo
{
VirtualizedConnectionString = virtualizedConnectionString,
Client = client
};
Clients[connectionString] = connectionInfo;
return(connectionInfo);
}
}
public byte[] GetBytesCemi()
{
List <byte> data = new List <byte>()
{
0x11, 0x00
};
TunnelRequest builder = new TunnelRequest();
builder.Build(MulticastAddress.FromString("0/0/0"), MulticastAddress.FromString("0/0/0"), ApciTypes.IndividualAddressWrite, 255, _address.GetBytes());
builder.SetPriority(Prios.System);
data.AddRange(builder.GetBytes());
return(data.ToArray());
}
public byte[] GetBytesCemi()
{
TunnelRequest builder = new TunnelRequest();
List <byte> data = new List <byte>()
{
ObjectIndex, PropertyId, PropertyIndex
};
builder.Build(UnicastAddress.FromString("0.0.0"), DestinationAddress, ApciType, SequenceNumber, data.ToArray());
data = new List <byte>()
{
0x11, 0x00
};
data.AddRange(builder.GetBytes());
return(data.ToArray());
}
public async Task <IRemoteMessage> Send(IRemoteMessage message, bool waitForResponse = true)
{
if (socket == null || socket.State != WebSocketState.Open)
{
return(null);
}
IRemoteMessage mesg = null;
try
{
if (message.SequenceNumber == -1)
{
message.SequenceNumber = SequenceNumber++;
}
if (message is TunnelRequest)
{
TunnelRequest req = message as TunnelRequest;
if (req.ChannelId == 0)
{
req.ChannelId = Remotes[req.ConnId].ChannelId;
}
if (req.Group == "")
{
req.Group = Remotes[req.ConnId].Group;
}
}
if (message is TunnelResponse)
{
TunnelResponse res = message as TunnelResponse;
if (res.ChannelId == 0)
{
res.ChannelId = Remotes[res.ConnId].ChannelId;
}
if (res.Group == "")
{
res.Group = Remotes[res.ConnId].Group;
}
}
await socket.SendAsync(message.GetBytes(), WebSocketMessageType.Binary, true, source.Token);
mesg = await WaitForResponse(message.SequenceNumber);
}catch (Exception ex)
{
}
return(mesg);
}
public byte[] GetBytesCemi()
{
TunnelRequest builder = new TunnelRequest();
List <byte> data = new List <byte>();
data.AddRange(Serial);
data.AddRange(NewAddress.GetBytes());
data.AddRange(new byte[] { 0, 0, 0, 0 });
builder.Build(UnicastAddress.FromString("0.0.0"), MulticastAddress.FromString("0/0/0"), ApciTypes.IndividualAddressSerialNumberWrite, 255, data.ToArray());
builder.SetPriority(Prios.System);
data = new List <byte>()
{
0x11, 0x00
};
data.AddRange(builder.GetBytes());
return(data.ToArray());
}
public byte[] GetBytesCemi()
{
byte[] send_data = new byte[Data.Length + 4];
send_data[0] = ObjectIndex;
send_data[1] = PropertyId;
send_data[2] = 0x10; //TODO check if it must be set to data.length
send_data[3] = 0x01;
for (int i = 0; i < Data.Length; i++)
{
send_data[i + 4] = Data[i];
}
List <byte> data = new List <byte>()
{
0x11, 0x00
};
TunnelRequest builder = new TunnelRequest();
builder.Build(UnicastAddress.FromString("0.0.0"), DestinationAddress, ApciTypes.PropertyValueWrite, SequenceNumber, send_data);
data.AddRange(builder.GetBytes());
return(data.ToArray());
}
public byte[] GetBytesCemi()
{
TunnelRequest builder = new TunnelRequest();
List <byte> data = new List <byte>()
{
};
data.Add(0x00);
data.Add((byte)(Key >> 24));
data.Add((byte)(Key >> 16));
data.Add((byte)(Key >> 8));
data.Add((byte)Key);
builder.Build(UnicastAddress.FromString("0.0.0"), DestinationAddress, ApciType, SequenceNumber, data.ToArray());
data = new List <byte>()
{
0x11, 0x00
};
data.AddRange(builder.GetBytes());
return(data.ToArray());
}
public byte[] GetBytesCemi()
{
TunnelRequest builder = new TunnelRequest();
List <byte> data = new List <byte> {
Convert.ToByte(Data.Length)
};
byte[] addr = BitConverter.GetBytes(Convert.ToInt16(Address));
Array.Reverse(addr);
data.AddRange(addr);
data.AddRange(Data);
if (IsExtended)
{
builder.SetIsExtended();
}
builder.Build(UnicastAddress.FromString("0.0.0"), DestinationAddress, ApciTypes.MemoryWrite, SequenceNumber, data.ToArray());
data = new List <byte>()
{
0x11, 0x00
};
data.AddRange(builder.GetBytes());
return(data.ToArray());
}
private void ProcessReceivingMessages()
{
Task.Run(async() =>
{
while (socket.State == WebSocketState.Open)
{
ArraySegment <byte> buffer;
WebSocketReceiveResult result = null;
try
{
buffer = new ArraySegment <byte>(new byte[1024]);
result = await socket.ReceiveAsync(buffer, ReceiveTokenSource.Token);
}
catch (Exception ex)
{
socket = null;
IsActive = false;
IsConnected = false;
return;
}
if (result == null || result.Count == 0)
{
continue;
}
Kaenx.Konnect.Remote.MessageCodes code = (Konnect.Remote.MessageCodes)buffer.Array[0];
Debug.WriteLine("Got Remote Message: " + code);
//Check if assemby from this genügt
var q = from t in Assembly.LoadFrom("Kaenx.Konnect.dll").GetTypes()
where t.IsClass && t.IsNested == false && t.Namespace == "Kaenx.Konnect.Remote"
select t;
IRemoteMessage message = null;
foreach (Type t in q.ToList())
{
IRemoteMessage down = (IRemoteMessage)Activator.CreateInstance(t);
if (down != null && code == down.MessageCode)
{
message = down;
break;
}
}
if (message == null)
{
Debug.WriteLine("Unbekannte Nachricht: " + code);
}
try
{
message.Parse(buffer.Array.Take(result.Count).ToArray());
}
catch (Exception ex)
{
}
if (message is TunnelRequest && (message as TunnelRequest).Type == TunnelTypes.Connect)
{
TunnelRequest req = message as TunnelRequest;
KnxRemote rem = new KnxRemote(Encoding.UTF8.GetString(req.Data), this);
await rem.Init(getUsbHandler);
int connId = await rem.ConnectToInterface(req);
Remotes.Add(connId, rem);
continue;
}
if (message.ToString().EndsWith("Response"))
{
Responses[message.SequenceNumber] = message;
OnResponse?.Invoke(message);
}
else
{
OnRequest?.Invoke(message);
}
}
Debug.WriteLine("Verbindung abgebrochen");
});
}
private void ProcessReceivingMessages(UdpClient _udpClient)
{
Debug.WriteLine("Höre jetzt auf: " + (_udpClient.Client.LocalEndPoint as IPEndPoint).Port);
Task.Run(async() =>
{
int rofl = 0;
try
{
while (!StopProcessing)
{
rofl++;
var result = await _udpClient.ReceiveAsync();
var knxResponse = _receiveParserDispatcher.Build(result.Buffer);
//if(!(knxResponse is SearchResponse))
// Debug.WriteLine("Telegram angekommen: " + knxResponse?.ToString());
switch (knxResponse)
{
case ConnectStateResponse connectStateResponse:
Debug.WriteLine("Connection State Response: " + connectStateResponse.Status.ToString());
switch (connectStateResponse.Status)
{
case 0x00:
IsConnected = true;
ConnectionChanged?.Invoke(IsConnected);
break;
default:
Debug.WriteLine("Connection State: Fehler: " + connectStateResponse.Status.ToString());
LastError = ConnectionErrors.NotConnectedToBus;
IsConnected = false;
ConnectionChanged?.Invoke(IsConnected);
break;
}
break;
case ConnectResponse connectResponse:
_flagCRRecieved = true;
switch (connectResponse.Status)
{
case 0x00:
_sequenceCounter = 0;
_communicationChannel = connectResponse.CommunicationChannel;
IsConnected = true;
ConnectionChanged?.Invoke(IsConnected);
PhysicalAddress = connectResponse.ConnectionResponseDataBlock.KnxAddress;
Debug.WriteLine("Connected: Eigene Adresse: " + PhysicalAddress.ToString());
break;
default:
Debug.WriteLine("Connected: Fehler: " + connectResponse.Status.ToString());
LastError = ConnectionErrors.Undefined;
IsConnected = false;
ConnectionChanged?.Invoke(IsConnected);
break;
}
break;
case Builders.TunnelResponse tunnelResponse:
if (tunnelResponse.IsRequest && tunnelResponse.DestinationAddress != PhysicalAddress)
{
Debug.WriteLine("Telegram erhalten das nicht mit der Adresse selbst zu tun hat!");
Debug.WriteLine("Typ: " + tunnelResponse.APCI);
Debug.WriteLine("Eigene Adresse: " + PhysicalAddress.ToString());
break;
}
_sendMessages.Add(new Responses.TunnelResponse(0x06, 0x10, 0x0A, 0x04, _communicationChannel, tunnelResponse.SequenceCounter, 0x00).GetBytes());
//Debug.WriteLine("Telegram APCI: " + tunnelResponse.APCI.ToString());
if (tunnelResponse.APCI.ToString().EndsWith("Response"))
{
List <byte> data = new List <byte>()
{
0x11, 0x00
};
TunnelRequest builder = new TunnelRequest();
builder.Build(UnicastAddress.FromString("0.0.0"), tunnelResponse.SourceAddress, ApciTypes.Ack, tunnelResponse.SequenceNumber);
data.AddRange(builder.GetBytes());
_ = Send(data.ToArray(), _sequenceCounter);
_sequenceCounter++;
//Debug.WriteLine("Got Response " + tunnelResponse.SequenceCounter + " . " + tunnelResponse.SequenceNumber);
}
else if (tunnelResponse.APCI == ApciTypes.Ack)
{
OnTunnelAck?.Invoke(new MsgAckRes()
{
ChannelId = tunnelResponse.CommunicationChannel,
SequenceCounter = tunnelResponse.SequenceCounter,
SequenceNumber = tunnelResponse.SequenceNumber,
SourceAddress = tunnelResponse.SourceAddress,
DestinationAddress = tunnelResponse.DestinationAddress
});
break;
}
List <string> temp = new List <string>();
var q = from t in Assembly.GetExecutingAssembly().GetTypes()
where t.IsClass && t.IsNested == false && (t.Namespace == "Kaenx.Konnect.Messages.Response" || t.Namespace == "Kaenx.Konnect.Messages.Request")
select t;
IMessage message = null;
foreach (Type t in q.ToList())
{
IMessage resp = (IMessage)Activator.CreateInstance(t);
if (resp.ApciType == tunnelResponse.APCI)
{
message = resp;
break;
}
}
if (message == null)
{
//throw new Exception("Kein MessageParser für den APCI " + tunnelResponse.APCI);
message = new MsgDefaultRes()
{
ApciType = tunnelResponse.APCI
};
Debug.WriteLine("Kein MessageParser für den APCI " + tunnelResponse.APCI);
}
message.Raw = tunnelResponse.Data;
message.ChannelId = tunnelResponse.CommunicationChannel;
message.SequenceCounter = tunnelResponse.SequenceCounter;
message.SequenceNumber = tunnelResponse.SequenceNumber;
message.SourceAddress = tunnelResponse.SourceAddress;
message.DestinationAddress = tunnelResponse.DestinationAddress;
switch (CurrentType)
{
case ProtocolTypes.cEmi:
message.ParseDataCemi();
break;
case ProtocolTypes.Emi1:
message.ParseDataEmi1();
break;
case ProtocolTypes.Emi2:
message.ParseDataEmi2();
break;
default:
throw new NotImplementedException("Unbekanntes Protokoll - TunnelResponse KnxIpTunneling");
}
if (tunnelResponse.APCI.ToString().EndsWith("Response"))
{
OnTunnelResponse?.Invoke(message as IMessageResponse);
}
else
{
OnTunnelRequest?.Invoke(message as IMessageRequest);
}
break;
case SearchResponse searchResponse:
MsgSearchRes msg = new MsgSearchRes(searchResponse.responseBytes);
switch (CurrentType)
{
case ProtocolTypes.cEmi:
msg.ParseDataCemi();
break;
case ProtocolTypes.Emi1:
msg.ParseDataEmi1();
break;
case ProtocolTypes.Emi2:
msg.ParseDataEmi2();
break;
default:
throw new NotImplementedException("Unbekanntes Protokoll - SearchResponse KnxIpTunneling");
}
OnSearchResponse?.Invoke(msg);
break;
case TunnelAckResponse tunnelAck:
//Do nothing
break;
case DisconnectResponse disconnectResponse:
IsConnected = false;
_communicationChannel = 0;
ConnectionChanged?.Invoke(IsConnected);
break;
}
}
Debug.WriteLine("Stopped Processing Messages " + _udpClient.Client.LocalEndPoint.ToString());
_udpClient.Close();
_udpClient.Dispose();
}
catch
{
}
});
}
