public void return_all_loggers_as_a_composite_if_no_filters_are_used()
{
var sut = new LogProvider();
sut.Add(new NullLogger());
sut.Add(new NullLogger());
var logger = sut.GetLogger(GetType());
logger.Should().BeOfType <CompositeLogger>();
}
public void only_return_one_logger_if_the_filter_is_not_ok()
{
var sut = new LogProvider();
sut.Add(new NullLogger());
sut.Add(new NullLogger(), new NamespaceFilter(revokedIncludingChildNamespaces: "Griffin"));
var logger = sut.GetLogger(GetType());
logger.Should().BeOfType <NullLogger>();
}
public void return_composite_if_filter_is_ok()
{
var sut = new LogProvider();
sut.Add(new NullLogger());
sut.Add(new NullLogger(), new NamespaceFilter(allowedIncludingChildNamespaces: "Griffin"));
var logger = sut.GetLogger(GetType());
logger.Should().BeOfType <CompositeLogger>();
}
public void return_composite_if_filter_is_ok()
{
var sut = new LogProvider();
sut.Add(new NullLogger());
sut.Add(new NullLogger(), new NamespaceFilter(allowedIncludingChildNamespaces: "MicroServer"));
var logger = sut.GetLogger(GetType());
//logger.Should().BeOfType<CompositeLogger>();
Assert.IsInstanceOfType(logger, typeof(CompositeLogger));
}
public void only_return_one_logger_if_the_filter_is_not_ok()
{
var sut = new LogProvider();
sut.Add(new NullLogger());
sut.Add(new NullLogger(), new NamespaceFilter(revokedIncludingChildNamespaces: "MicroServer"));
var logger = sut.GetLogger(GetType());
//logger.Should().BeOfType<NullLogger>();
Assert.IsInstanceOfType(logger, typeof(NullLogger));
}
public void SetDescramblerData(DescramblerParity parity, DescramblerDataType type, byte[] data)
{
if (type == DescramblerDataType.Key)
{
switch (parity)
{
case DescramblerParity.Even:
Array.Copy(data, _CwEven, _CwEven.Length);
SetEvenControlWord(_PtrKeySet, _CwEven);
break;
case DescramblerParity.Odd:
Array.Copy(data, _CwOdd, _CwOdd.Length);
SetOddControlWord(_PtrKeySet, _CwOdd);
break;
default:
LogProvider.Add(DebugLevel.Warning, cLogSection, Message.CsaUnknownParity, parity);
return;
}
}
else
{
LogProvider.Add(DebugLevel.Warning, cLogSection, Message.CsaInvalidDescrDataType, type);
}
}
private void IcCommandSetFilter(BinaryReader rdr)
{
int filter = rdr.ReadInt32();
int pid = rdr.ReadInt32();
int timeout = rdr.ReadInt32();
DemuxFilter.Flags flags = (DemuxFilter.Flags)rdr.ReadInt32();
byte[] fData = rdr.ReadBytes(16);
byte[] fMask = rdr.ReadBytes(16);
byte[] fMode = rdr.ReadBytes(16);
// falls es den schon gibt rauskicken:
DelFilter(filter, pid);
LogProvider.Add(DebugLevel.InterComClientCommand, cLogSection, Message.AdapterSetFilter, filter, pid);
LogProvider.Add(DebugLevel.InterComClientCommand | DebugLevel.HexDump, cLogSection, Message.AdapterSetFilterDump, fData, 0, fData.Length);
LogProvider.Add(DebugLevel.InterComClientCommand | DebugLevel.HexDump, cLogSection, Message.Empty, fMask, 0, fMask.Length);
LogProvider.Add(DebugLevel.InterComClientCommand | DebugLevel.HexDump, cLogSection, Message.Empty, fMode, 0, fMode.Length);
lock (_Filters)
_Filters.Add(new DemuxFilter(filter, pid, fData, fMask, fMode, timeout, flags));
// prüfen ob PMT-Filter, dann PMT direkt rausschicken:
if (pid == _PmtPid && _Pmt != null)
{
IcFilterData(filter, _Pmt.Data, _Pmt.SectionSize);
}
AddPid(pid);
}
private static void SetDcw(byte[] cw, Dvb.Crypto.DescramblerParity parity)
{
LogProvider.Add(DebugLevel.Info, cLogSection, Message.MdapiEvSetDcw);
TDvbCommand cmd = new TDvbCommand();
cmd.CommandLength = 0x0007; // nachfolgende anzahl an words.
cmd.Command1 = (ushort)MdApiMessages.DvbSetDescrCmd;
cmd.Command2 = 0x0005;
cmd.Parity = (ushort)parity;
cmd.Cw = new ushort[4];
// von byte[] in ushort[] umwandeln:
for (int i = 0; i < cmd.Cw.Length; i++)
{
int j = i << 1;
int k = j + 1;
cmd.Cw[i] = (ushort)(cw[k] | (cw[j] << 8));
}
IntPtr cmdPtr = Marshal.AllocHGlobal(Marshal.SizeOf(cmd));
Marshal.StructureToPtr(cmd, cmdPtr, false);
int res = (int)SendMessage(_MdapiWindow, (uint)WMessage.User, (UIntPtr)MdApiMessages.DvbCommand, cmdPtr);
if (res == 0)
{
uint err = Plugin.GetLastError();
LogProvider.Add(DebugLevel.Warning, cLogSection, Message.MdapiEvSetDcwFailed, err);
}
Marshal.FreeHGlobal(cmdPtr);
}
public Des()
{
// TODO: Entfernen, wenn fertig:
LogProvider.Add(DebugLevel.Warning, cLogSection, Message.DesDescramblingNotAvail);
_EvenDes = new DesBase();
_OddDes = new DesBase();
_Cluster = new IntPtr[_MaxPacketsAtOnce + 1];
_CurrentBatchIndex = 0;
}
public static void OnSendDllIdName(IntPtr name)
{
LogProvider.Add(DebugLevel.Info, cLogSection, Message.MdapiEvDllName);
if (name != IntPtr.Zero)
{
Marshal.Copy(_DllName, 0, name, _DllName.Length);
}
}
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);
}
}
public void return_the_only_added_logger()
{
var sut = new LogProvider();
sut.Add(new NullLogger());
var logger = sut.GetLogger(GetType());
logger.Should().BeOfType <NullLogger>();
}
private void CmdServerInfo(BinaryReader r)
{
int proto = IPAddress.NetworkToHostOrder(r.ReadInt16());
string info = Statics.GetStringFromC(3, _RecvBuff, _RecvBuff[2]);
LogProvider.Add(DebugLevel.Info, cLogSection, Message.DvbapiServerInfo, info, proto);
_ServerInfo = new DvbApiServerInfo(proto, info);
SendCaPmtList();
}
/// <summary>
/// Instantiiert einen neuen Adapter
/// </summary>
/// <param name="pipeName">Pipename über die der Adapter die Einstellungen zum ApiClient bezieht.</param>
/// <param name="isMdapi">Wenn der Adapter selbst keine Entschlüsselung vornehmen soll, true, anderenfalls false.</param>
public DvbApiAdapter(string pipeName, bool isMdapi)
{
_FilteredPids = new byte[0x2000]; // index = pid 0 = nicht filtern, 1 = filtern.
_DescramblePids = new byte[0x2000]; // gleiche hier, wert jedoch descrambler-Index.
_Descramblers = new Descrambler[256];
_DescramblersList = new List <Descrambler>();
_Filters = new List <DemuxFilter>();
_ServiceId = -1;
_PmtPid = -1;
_AdapterIndex = -1;
_UseMdApi = isMdapi;
_DumpStream = false;
Globals.Config.Get("debug", "streamdump", ref _DumpStream);
try
{
string srv = "";
int port = 0;
int adapterOffset = 0;
Globals.Config.Get(cConfigSection, "server", ref srv);
if (Globals.Config.Get(cConfigSection, "offset", 0, 128, ref adapterOffset) != Configuration.ConfigRes.Ok)
{
LogProvider.Add(DebugLevel.Error, cLogSection, Message.AdapterConfigInvalidOffset);
}
if (Globals.Config.Get(cConfigSection, "port", 1, 65535, ref port) != Configuration.ConfigRes.Ok)
{
LogProvider.Add(DebugLevel.Error, cLogSection, Message.AdapterConfigInvalidPort);
}
_ApiClient = new DvbApiClient(srv, port, pipeName, Globals.Info, adapterOffset);
_ApiClient.Start();
}
catch (AlreadyRunningException)
{
// ...wenn fehlgeschlagen, weil pipe schon existent,
// dann war eine andere Plugin-Instanz schneller, wird weiter nicht benötigt.
LogProvider.Add(DebugLevel.Info, cLogSection, Message.AdapterClientRunning);
}
_IcEp = new InterComClient(pipeName);
_IcEp.GotCommand += IcCommand;
_IcEp.Disconnected += IcDisconnected;
_IcEp.Start();
}
public void return_the_only_added_logger()
{
var sut = new LogProvider();
sut.Add(new NullLogger());
var logger = sut.GetLogger(GetType());
Assert.IsInstanceOfType(logger, typeof(NullLogger));
//logger.Should().BeOfType<NullLogger>();
}
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);
}
}
private void Reset()
{
try
{
_ApiSckt.Close();
}
catch { }
LogProvider.Add(DebugLevel.DvbApi, cLogSection, Message.DvbapiDisconnected);
_ServerInfo = null;
_IsConnected = false;
// Reconnect erfolgt bei nächstem Send-Message.
}
private void IcCommandDelFilter(BinaryReader rdr)
{
int num = rdr.ReadInt32();
int pid = rdr.ReadInt32();
LogProvider.Add(DebugLevel.InterComClientCommand, cLogSection, Message.AdapterDelFilter, num, pid);
DelFilter(num, pid);
// muss _nach_ Remove ausgeführt werden, prüft nämlich ob noch filter vorhanden sind.
if (pid != _PmtPid)
{
DelPid(pid);
}
}
public static void OnStart(
IntPtr MDInstance, IntPtr MDWnd, int Log_Set, int dllId,
IntPtr My_Hot_Key, IntPtr Api_Version, IntPtr keepMeRunning
)
{
LogProvider.Add(DebugLevel.Info, cLogSection, Message.MdapiEvOnStart);
_DllId = dllId;
_MdapiWindow = MDWnd;
if (keepMeRunning != IntPtr.Zero && _KeepAliveSupport)
{
Marshal.WriteInt32(keepMeRunning, 1);
}
}
public static void OnExit(IntPtr MDInstance, IntPtr MDWnd, int Log_Set)
{
LogProvider.Add(DebugLevel.Info, cLogSection, Message.MdapiUnload);
try
{
_IsStopping = true;
_DvbAdapter.Tune(-1, -1, -1, -1);
_DvbAdapter.Dispose();
}
catch (Exception ex)
{
LogProvider.Exception(cLogSection, Message.MdapiUnloadFailed, ex);
}
Globals.Dispose();
}
private void CmdCaSetPid(BinaryReader r)
{
int adapter = r.ReadByte();
int pid = IPAddress.NetworkToHostOrder(r.ReadInt32());
int idx = IPAddress.NetworkToHostOrder(r.ReadInt32());
LogProvider.Add(DebugLevel.DvbApi, cLogSection, Message.DvbapiCaSetPid, adapter, pid, idx);
ChannelSession c = _ChanSessions[adapter - _AdapterOffset];
if (c != null)
{
c.SetPid(pid, (byte)(idx + 1));
}
}
public static int EventMsg(Event ev, IntPtr data)
{
LogProvider.Add(DebugLevel.DvbViewerPluginEvent, cLogSection, Message.DvbvEvent, ev);
try
{
switch (ev)
{
case Event.InitComplete:
break;
case Event.TuneChannel:
if (data != IntPtr.Zero)
{
TChannel chan = (TChannel)Marshal.PtrToStructure(data, typeof(TChannel));
PostMessage(_DvbViewerHwnd, (uint)WMessage.DvbViewer, new UIntPtr((uint)ParamMessages.AddTsCall), _NativeTsCallback);
_DvbAdapter.Tune(chan.Sid, chan.PmtPid, chan.TransportStreamId, chan.NetworkId);
}
else if (_DvbAdapter.IsTuned) // bei einigen Versionen kommt hier null (nil in pascal)
{
PostMessage(_DvbViewerHwnd, (uint)WMessage.DvbViewer, new UIntPtr((uint)ParamMessages.DelTsCall), _NativeTsCallback);
_DvbAdapter.Tune(-1, -1, -1, -1);
}
break;
case Event.RemoveChannel: // üblicherweise DVBViewer
case Event.DisableTuner: // überlicherweise Recording-Service oder DVBViewer Media Server
if (_DvbAdapter.IsTuned)
{
PostMessage(_DvbViewerHwnd, (uint)WMessage.DvbViewer, new UIntPtr((uint)ParamMessages.DelTsCall), _NativeTsCallback);
_DvbAdapter.Tune(-1, -1, -1, -1);
}
break;
case Event.Unload:
Dispose();
break;
}
}
catch (Exception ex)
{
LogProvider.Exception(cLogSection, Message.DvbvEventFailed, ex);
}
return(0);
}
private void CmdSetCaDescrMode(BinaryReader r)
{
int adapter = r.ReadByte();
int idx = IPAddress.NetworkToHostOrder(r.ReadInt32());
DescramblerAlgo algo = (DescramblerAlgo)IPAddress.NetworkToHostOrder(r.ReadInt32());
DescramblerMode mode = (DescramblerMode)IPAddress.NetworkToHostOrder(r.ReadInt32());
LogProvider.Add(DebugLevel.DvbApi, cLogSection, Message.DvbapiSetMode, adapter, idx, algo, mode);
ChannelSession c = _ChanSessions[adapter - _AdapterOffset];
if (c != null)
{
c.SetDescramblerMode(idx, algo, mode);
}
}
private static void AddPid(DvbApiAdapter sender, ushort pid)
{
if (_IsStopping)
{
return;
}
LogProvider.Add(DebugLevel.Info, cLogSection, Message.MdapiAddPid, pid);
try
{
lock (_Filters)
{
int free = -1;
int found = -1;
for (int i = 0; i < _Filters.Length; i++)
{
if (_Filters[i] == null && free < 0)
{
free = i;
}
else if (_Filters[i] != null && _Filters[i].FilterPid == pid && found < 0)
{
found = i;
}
}
if (found >= 0)
{
_Filters[found].Dispose();
_Filters[found] = new Filter.Context(_DvbAdapter, _DllName, _MdapiWindow, _188ByteSupport, _DllId, pid, (ushort)found);
}
else if (free >= 0)
{
_Filters[free] = new Filter.Context(_DvbAdapter, _DllName, _MdapiWindow, _188ByteSupport, _DllId, pid, (ushort)free);
}
else
{
LogProvider.Add(DebugLevel.Warning, cLogSection, Message.MdapiAddPidMaxFilter, pid);
}
}
}
catch (Exception ex)
{
LogProvider.Exception(cLogSection, Message.MdapiAddPidFailed, ex);
}
}
private void CmdEcmInfo(BinaryReader rdr)
{
int adapter = rdr.ReadByte();
EcmInfo info = EcmInfo.GetFromBinaryReader(rdr);
LogProvider.Add(DebugLevel.EcmInfo, cLogSection, info);
ChannelSession c = _ChanSessions[adapter - _AdapterOffset];
if (c != null)
{
c.SetEcmInfo(info);
}
else
{
LogProvider.Add(DebugLevel.Warning, cLogSection, Message.DvbapiEcmInfoFailed, adapter);
}
}
public void Run(IBackgroundTaskInstance taskInstance)
{
// Get the deferral and save it to local variable so that the app stays alive
this.backgroundTaskDeferral = taskInstance.GetDeferral();
taskInstance.Canceled += TaskCanceled;
// Setup system logging
logProvider.Add(systemDebugLogger, new NamespaceFilter("MicroServer"));
LogManager.Provider = logProvider;
ILogger Logger = LogManager.GetLogger <StartupTask>();
try
{
// Create Http server pipeline
ModuleManager ModuleManager = new ModuleManager();
// Add the router module as the fist module to pipeline
ModuleManager.Add(new RouterModule());
// Add the storage service module to pipeline
//ModuleManager.Add(new FileModule(new StorageService("/", @"WebRoot")));
// Add the controller module to pipeline
ModuleManager.Add(new ControllerModule());
// Add the error module as the last module to pipeline
ModuleManager.Add(new ErrorModule());
// Create the http server
HttpServer webServer = new HttpServer(ModuleManager);
IAsyncAction asyncAction = ThreadPool.RunAsync(
async(workItem) =>
{
await webServer.StartAsync("80");
});
Logger.Info("Background task is running...");
}
catch (Exception ex)
{
Debug.WriteLine("Exception in Run: {0}", ex.Message);
}
}
private void Connect()
{
if (_IsConnected || !_IsRunning)
{
return;
}
_IsConnected = true;
LogProvider.Add(DebugLevel.DvbApi, cLogSection, Message.DvbapiConnect);
if (!IPAddress.TryParse(_Host, out IPAddress ip))
{
try
{
IPHostEntry ihe = Dns.GetHostEntry(_Host); // wirft Ausnahme wenn Host nicht gefunden.
if (ihe.AddressList.Length > 0)
{
ip = ihe.AddressList[0];
}
}
catch { }
}
if (ip == null)
{
_IsConnected = false;
LogProvider.Add(DebugLevel.Error, cLogSection, Message.DvbapiInvalidHost, _Host);
return;
}
EndPoint srv = new IPEndPoint(ip, _Port);
_ApiSckt = new Socket(ip.AddressFamily, SocketType.Stream, ProtocolType.Tcp);
_ApiSckt.Connect(srv);
_ApiSckt.NoDelay = true; // im Hinterkopf halten falls aussetzer
LogProvider.Add(DebugLevel.DvbApi, cLogSection, Message.DvbapiConnected);
SendMessage(_ClientInfo.GetData(), true);
_ApiSckt.BeginReceive(_RecvBuff, 0, 4, SocketFlags.None, Receive, _ApiSckt); // msgstart empfangen.
}
public void SetDescramblerMode(DescramblerMode mode)
{
switch (mode)
{
case DescramblerMode.Cbc:
_EvenAes.SetMode(CipherMode.CBC);
_OddAes.SetMode(CipherMode.CBC);
break;
case DescramblerMode.Ecb:
_EvenAes.SetMode(CipherMode.ECB);
_OddAes.SetMode(CipherMode.ECB);
break;
default:
LogProvider.Add(DebugLevel.Warning, cLogSection, Message.AesInvalidDescrMode, mode);
return;
}
}
public void Dispose()
{
if (!_Disposed)
{
// Struct zurücklesen, Host passt RunningID an zwecks identifikation. Die wird für Stopfilter benötigt.
TStartFilter str = (TStartFilter)Marshal.PtrToStructure(_StructPtr, typeof(TStartFilter));
int res = (int)Plugin.SendMessage(_MdapiWindow, (uint)WMessage.User, (UIntPtr)MdApiMessages.StopFilter, new IntPtr(str.RunningId));
LogProvider.Add(DebugLevel.Info, cLogSection, Message.MdapiCtxDelFilter, str.Pid, str.RunningId);
if (res == 0)
{
uint err = Plugin.GetLastError();
LogProvider.Add(DebugLevel.Warning, cLogSection, Message.MdapiCtxDelFilterFailed, err);
}
Marshal.FreeHGlobal(_StructPtr);
_Disposed = true;
}
}
private void IcCommandSetDescramblerMode(BinaryReader rdr)
{
int index = rdr.ReadInt32();
DescramblerAlgo algo = (DescramblerAlgo)rdr.ReadInt32();
DescramblerMode mode = (DescramblerMode)rdr.ReadInt32();
if (_UseMdApi)
{
if (algo != DescramblerAlgo.DvbCsa)
{
LogProvider.Add(DebugLevel.Warning, cLogSection, Message.AdapterMdapiMode);
}
return;
}
Descrambler descr = GetDescrambler(index);
descr.SetDescramblerMode(algo, mode);
}