public void SendCommand(InterComCommand cmd, byte[] data, int offset, int len)
{
if (!IsConnected)
{
return;
}
lock (this) // nur einer gleichzeitig senden!
{
_MsOut.Position = 0;
_Bw.Write(len + sizeof(int));
_Bw.Write((int)cmd);
if (len != 0)
{
_Bw.Write(data, offset, len);
}
_Bw.Flush();
try
{
_IcSckt.Send(_OutBuffer, (int)_MsOut.Position, SocketFlags.None);
}
catch
{
this.Disconnect();
}
}
}
private void IcCommand(InterComEndPoint sender, InterComCommand cmd, byte[] data)
{
LogProvider.Add(DebugLevel.InterComClientCommand, cLogSection, Message.AdapterIcCommand, cmd);
try
{
using (MemoryStream ms = new MemoryStream(data))
using (BinaryReader rdr = new BinaryReader(ms))
{
switch (cmd)
{
case InterComCommand.SetInstanceNumber:
IcCommandSetInstanceNumber(rdr);
break;
case InterComCommand.Stop:
// entfernt. Soll einfach weiterlaufen, z.b. bei oscam Restart
break;
case InterComCommand.SetFilter:
IcCommandSetFilter(rdr);
break;
case InterComCommand.DelFilter:
IcCommandDelFilter(rdr);
break;
case InterComCommand.SetPid:
SetRawPid(rdr.ReadInt32(), rdr.ReadByte());
break;
case InterComCommand.ClearFilter:
IcCommandClearFilter(rdr);
break;
case InterComCommand.SetDescramblerMode:
IcCommandSetDescramblerMode(rdr);
break;
case InterComCommand.SetDescramblerData:
IcCommandSetDescrambleData(rdr, data.Length);
break;
default:
LogProvider.Add(DebugLevel.Warning, cLogSection, Message.AdapterIcCommandUnknown, cmd);
// unbekannter befehl. Sollte nicht vorkommen.
// Da aber bereits alle Bytes gelesen, ignorieren und weiter im Programm.
break;
}
}
}
catch (Exception ex)
{
LogProvider.Exception(cLogSection, Message.AdapterIcCommandFailed, ex);
}
}
protected void OnRead(IAsyncResult iar)
{
if (!_IsRunning)
{
return;
}
if (!IsConnected || !_IcSckt.Connected)
{
return;
}
try
{
int len = _IcSckt.EndReceive(iar);
_MsIn.Position = 0;
if (len < 4)
{
Disconnect();
return;
}
int packetLen = _Br.ReadInt32();
if (!NetUtils.ReceiveAll(_InBuffer, _IcSckt, packetLen, (int)_MsIn.Position))
{
Disconnect();
return;
}
InterComCommand cmd = (InterComCommand)_Br.ReadInt32();
byte[] data = new byte[packetLen - sizeof(int)];
Array.Copy(_InBuffer, _MsIn.Position, data, 0, data.Length);
LogProvider.Add(DebugLevel.InterComEndpoint, cLogSection, Message.IntercomCmd, (int)cmd, cmd);
LogProvider.Add(DebugLevel.InterComEndpoint | DebugLevel.HexDump, cLogSection, Message.IntercomCmdData, data, 0, data.Length);
GotCommand?.Invoke(this, cmd, data);
// Nächste Daten:
Start();
}
catch (Exception ex)
{
Disconnect();
LogProvider.Exception(cLogSection, Message.IntercomEx, ex);
}
}
/// <summary>
/// Prüft ob der CLient auch wirklich der ist, der er zu sein scheint.
/// </summary>
/// <param name="iar"></param>
private void FirstCommand(IAsyncResult iar)
{
int len = _IcSckt.EndReceive(iar);
if (len != sizeof(int))
{
Disconnect();
return;
}
int packetLen = _Br.ReadInt32();
if (packetLen > _InBuffer.Length)
{
Disconnect();
return;
}
if (!NetUtils.ReceiveAll(_InBuffer, _IcSckt, packetLen, (int)_MsIn.Position))
{
Disconnect();
return;
}
InterComCommand cmd = (InterComCommand)_Br.ReadInt32();
if (cmd != InterComCommand.Initiate)
{
Disconnect();
return;
}
ulong auth = _Br.ReadUInt64();
if (auth != _AuthToken)
{
Disconnect();
return;
}
if (Authenticated == null)
{
Disconnect();
return;
}
Authenticated.Invoke(this);
}
private void CommandReceived(InterComEndPoint sender, InterComCommand cmd, byte[] data)
{
using (MemoryStream ms = new MemoryStream(data))
using (BinaryReader rdr = new BinaryReader(ms))
{
switch (cmd)
{
case InterComCommand.Stop:
Stop(false);
break;
case InterComCommand.Pmt:
// 1 int pmt pid, 1 int sid;
bool update = false;
bool add = CurrentSid == -1;
int tmp = rdr.ReadInt32(); // 4 byte nid
if (tmp != CurrentNId)
{
update = true;
CurrentNId = tmp;
}
tmp = rdr.ReadInt32(); // 4 byte tsid
if (tmp != CurrentTsId)
{
update = true;
CurrentTsId = tmp;
}
tmp = rdr.ReadInt32(); // 4 byte Pid
if (tmp != CurrentPid)
{
update = true;
CurrentPid = tmp;
}
PmtSection pmt = new PmtSection(data, (int)rdr.BaseStream.Position, CurrentPid);
if (_CurrentPmt == null || _CurrentPmt.Version != pmt.Version)
{
update = true;
_CurrentPmt = pmt;
}
if (update)
{
ChannelUpdated?.Invoke(this, add);
}
break;
case InterComCommand.FilterData:
int fltId = rdr.ReadInt32();
byte[] fData = rdr.ReadBytes(data.Length - sizeof(int));
FilterData?.Invoke(this, fltId, fData);
break;
default:
// unbekannter befehl. oder anderswo abgefangen Sollte nicht vorkommen
// Da aber bereits alle Bytes gelesen, ignorieren und weiter im Programm.
break;
}
}
}
public void SendCommand(InterComCommand cmd)
{
SendCommand(cmd, null, 0, 0);
}
public void SendCommand(InterComCommand cmd, byte[] data)
{
int len = data == null ? 0 : data.Length;
SendCommand(cmd, data, 0, len);
}
