static void Main (string [] args)
{
IpcServerChannel channel = new IpcServerChannel ("Foo");
ChannelServices.RegisterChannel (channel, false);
RemotingConfiguration.RegisterWellKnownServiceType (typeof (Fooo), "Foo", WellKnownObjectMode.Singleton);
Console.ReadLine ();
}
public HookProcess(Process process, OverlayConfig overlayConfig, OverlayInterface overlayInterface)
{
if (HookManager.IsHooked(process.Id))
{
throw new ProcessAlreadyHookedException();
}
overlayInterface.ProcessID = process.Id;
OverlayInterface = overlayInterface;
Server = RemoteHooking.IpcCreateServer<OverlayInterface>(ref ChannelName, WellKnownObjectMode.Singleton, OverlayInterface);
try
{
var libraryName = typeof (OverlayInterface).Assembly.GetName()
.Name + ".dll";
var location = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, libraryName);
RemoteHooking.Inject(process.Id, InjectionOptions.NoService | InjectionOptions.DoNotRequireStrongName, location, location, ChannelName, overlayConfig);
}
catch (Exception ex)
{
throw new InjectionFailedException(ex);
}
HookManager.AddHookedProcess(process.Id);
InjectedProcess = process;
}
static void Main(string[] args)
{
if ((args.Length == 2) && (args[0].Equals("-iphonepackager")))
{
// We were run as a 'child' process, quit when our 'parent' process exits
// There is no parent-child relationship WRT windows, it's self-imposed.
int ParentPID = int.Parse(args[1]);
IpcServerChannel Channel = new IpcServerChannel("iPhonePackager");
ChannelServices.RegisterChannel(Channel, false);
RemotingConfiguration.RegisterWellKnownServiceType(typeof(DeploymentImplementation), "DeploymentServer_PID" + ParentPID.ToString(), WellKnownObjectMode.Singleton);
Process ParentProcess = Process.GetProcessById(ParentPID);
while (!ParentProcess.HasExited)
{
System.Threading.Thread.Sleep(1000);
}
}
else
{
// Run directly by some intrepid explorer
Console.WriteLine("Note: This program should only be started by iPhonePackager");
Console.WriteLine(" This program cannot be used on it's own.");
DeploymentImplementation Deployer = new DeploymentImplementation();
var DeviceList = Deployer.EnumerateConnectedDevices();
foreach (var Device in DeviceList)
{
Console.WriteLine(" - Found device named {0} of type {1} with UDID {2}", Device.DeviceName, Device.DeviceType, Device.UDID);
}
Console.WriteLine("Exiting.");
}
}
public EntryPoint(
EasyHook.RemoteHooking.IContext context,
String channelName,
CaptureConfig config)
{
// Get reference to IPC to host application
// Note: any methods called or events triggered against _interface will execute in the host process.
_interface = EasyHook.RemoteHooking.IpcConnectClient<CaptureInterface>(channelName);
// We try to ping immediately, if it fails then injection fails
_interface.Ping();
#region Allow client event handlers (bi-directional IPC)
// Attempt to create a IpcServerChannel so that any event handlers on the client will function correctly
System.Collections.IDictionary properties = new System.Collections.Hashtable();
properties["name"] = channelName;
properties["portName"] = channelName + Guid.NewGuid().ToString("N"); // random portName so no conflict with existing channels of channelName
System.Runtime.Remoting.Channels.BinaryServerFormatterSinkProvider binaryProv = new System.Runtime.Remoting.Channels.BinaryServerFormatterSinkProvider();
binaryProv.TypeFilterLevel = System.Runtime.Serialization.Formatters.TypeFilterLevel.Full;
System.Runtime.Remoting.Channels.Ipc.IpcServerChannel _clientServerChannel = new System.Runtime.Remoting.Channels.Ipc.IpcServerChannel(properties, binaryProv);
System.Runtime.Remoting.Channels.ChannelServices.RegisterChannel(_clientServerChannel, false);
#endregion
}
public EntryPoint(
EasyHook.RemoteHooking.IContext context,
String channelName,
CaptureConfig config)
{
// Get reference to IPC to host application
// Note: any methods called or events triggered against _interface will execute in the host process.
_interface = EasyHook.RemoteHooking.IpcConnectClient <CaptureInterface>(channelName);
// We try to ping immediately, if it fails then injection fails
_interface.Ping();
#region Allow client event handlers (bi-directional IPC)
// Attempt to create a IpcServerChannel so that any event handlers on the client will function correctly
System.Collections.IDictionary properties = new System.Collections.Hashtable();
properties["name"] = channelName;
properties["portName"] = channelName + Guid.NewGuid().ToString("N"); // random portName so no conflict with existing channels of channelName
System.Runtime.Remoting.Channels.BinaryServerFormatterSinkProvider binaryProv = new System.Runtime.Remoting.Channels.BinaryServerFormatterSinkProvider();
binaryProv.TypeFilterLevel = System.Runtime.Serialization.Formatters.TypeFilterLevel.Full;
System.Runtime.Remoting.Channels.Ipc.IpcServerChannel _clientServerChannel = new System.Runtime.Remoting.Channels.Ipc.IpcServerChannel(properties, binaryProv);
System.Runtime.Remoting.Channels.ChannelServices.RegisterChannel(_clientServerChannel, false);
#endregion
}
private void FormMain_Load(object sender, EventArgs e)
{
channel = RemoteHooking.IpcCreateServer(
ref channelName,
WellKnownObjectMode.Singleton,
IpcInterface,
WellKnownSidType.WorldSid);
}
public PtAccServer()
{
// Create and register an IPC channel
serverChannel = new IpcServerChannel("remote");
ChannelServices.RegisterChannel(serverChannel, true);
// Expose an object
RemotingConfiguration.RegisterWellKnownServiceType(typeof(PtAccRemoteType), "PtAcc", WellKnownObjectMode.Singleton);
}
public static void Setup()
{
// Reset the channel name.
ChannelName = null;
// Start an Ipc server for the DLL to connect to.
InjectionServer = RemoteHooking.IpcCreateServer<ChatInterface>(ref ChannelName, WellKnownObjectMode.Singleton);
}
public static void RegisterIpcChannel(EventHandler<NewInstanceDetectedEventArgs> handler)
{
IChannel ipcChannel = new IpcServerChannel(String.Format(CultureInfo.InvariantCulture, "hfm-{0}-{1}", Environment.UserName, AssemblyGuid));
ChannelServices.RegisterChannel(ipcChannel, false);
var obj = new IpcObject(handler);
RemotingServices.Marshal(obj, ObjectName);
}
protected EyesarServer(EyesarSharedObject sharedObject)
{
if (ChannelServices.RegisteredChannels.Any(channel => channel.ChannelName == "Eyesar"))
throw new InvalidOperationException();
_channel = new IpcServerChannel("Eyesar", "eyesar");
ChannelServices.RegisterChannel(_channel, false);
RemotingServices.Marshal(SharedObject = sharedObject, "shared", typeof (EyesarSharedObject));
}
public static Server Start(ApplicationCore applicationCore)
{
var serverChannel = new IpcServerChannel("SassTray");
ChannelServices.RegisterChannel(serverChannel, true);
var server = new Server(applicationCore);
RemotingServices.Marshal(server, "Server", typeof(Server));
return server;
}
static void StartServer(AssemblyService service, string name, string uri) {
var props = new Hashtable();
props["portName"] = name;
var provider = new BinaryServerFormatterSinkProvider();
provider.TypeFilterLevel = System.Runtime.Serialization.Formatters.TypeFilterLevel.Full;
var channel = new IpcServerChannel(props, provider);
ChannelServices.RegisterChannel(channel, false);
RemotingServices.Marshal(service, uri);
}
private void Form1_Load(object sender, EventArgs e)
{
// Initialise the IPC server
ScreenshotServer = RemoteHooking.IpcCreateServer<ScreenshotInterface.ScreenshotInterface>(
ref ChannelName,
WellKnownObjectMode.Singleton);
ScreenshotManager.OnScreenshotDebugMessage += new ScreenshotDebugMessage(ScreenshotManager_OnScreenshotDebugMessage);
}
/// <summary>
/// Prepares capturing in the target process. Note that the process must not already be hooked, and must have a <see cref="Process.MainWindowHandle"/>.
/// </summary>
/// <param name="process">The process to inject into</param>
/// <exception cref="ProcessHasNoWindowHandleException">Thrown if the <paramref name="process"/> does not have a window handle. This could mean that the process does not have a UI, or that the process has not yet finished starting.</exception>
/// <exception cref="ProcessAlreadyHookedException">Thrown if the <paramref name="process"/> is already hooked</exception>
/// <exception cref="InjectionFailedException">Thrown if the injection failed - see the InnerException for more details.</exception>
/// <remarks>The target process will have its main window brought to the foreground after successful injection.</remarks>
public CaptureProcess(Process process, CaptureConfig config, CaptureInterface captureInterface)
{
// If the process doesn't have a mainwindowhandle yet, skip it (we need to be able to get the hwnd to set foreground etc)
//if (process.MainWindowHandle == IntPtr.Zero)
//{
// throw new ProcessHasNoWindowHandleException();
//}
// Skip if the process is already hooked (and we want to hook multiple applications)
if (HookManager.IsHooked(process.Id))
{
throw new ProcessAlreadyHookedException();
}
captureInterface.ProcessId = process.Id;
this._serverInterface = captureInterface;
//_serverInterface = new CaptureInterface() { ProcessId = process.Id };
// Initialise the IPC server (with our instance of _serverInterface)
this._screenshotServer = RemoteHooking.IpcCreateServer<CaptureInterface>(
ref this._channelName,
WellKnownObjectMode.Singleton,
this._serverInterface);
try
{
var location = typeof(CaptureInterface).Assembly.Location;
if (String.IsNullOrEmpty(location))
{
var dllName = typeof(CaptureInterface).Assembly.GetName().Name + ".dll";
location = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, dllName);
}
// Inject DLL into target process
RemoteHooking.Inject(
process.Id,
InjectionOptions.Default,
location,
//"Capture.dll", // 32-bit version (the same because AnyCPU) could use different assembly that links to 32-bit C++ helper dll
location,
//"Capture.dll", // 64-bit version (the same because AnyCPU) could use different assembly that links to 64-bit C++ helper dll
// the optional parameter list...
this._channelName,
// The name of the IPC channel for the injected assembly to connect to
config
);
}
catch (Exception e)
{
throw new InjectionFailedException(e);
}
HookManager.AddHookedProcess(process.Id);
this.Process = process;
}
static void Main(string[] args)
{
if (args == null)
throw new ArgumentNullException("args");
if (args.Length != 1)
throw new ArgumentException("Arguments number doesn't match!", "args");
var name = args[0];
if (string.IsNullOrEmpty(name))
throw new Exception("Name cannot be null or empty.");
name = name.Trim('"');
var channelPort = string.Format(ProcessAppConst.PortNameTemplate, name, Process.GetCurrentProcess().Id);
var currentDomain = AppDomain.CurrentDomain;
var root = Path.Combine(Path.Combine(currentDomain.BaseDirectory, ProcessAppConst.WorkingDir), name);
//Hack to change the default AppDomain's root
if (NDockEnv.IsMono) //for Mono
{
var pro = typeof(AppDomain).GetProperty("SetupInformationNoCopy", BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.GetProperty);
var setupInfo = (AppDomainSetup)pro.GetValue(currentDomain, null);
setupInfo.ApplicationBase = root;
}
else // for .NET
{
currentDomain.SetData("APPBASE", root);
}
currentDomain.SetData(typeof(IsolationMode).Name, IsolationMode.Process);
try
{
var serverChannel = new IpcServerChannel("IpcAgent", channelPort, new BinaryServerFormatterSinkProvider { TypeFilterLevel = TypeFilterLevel.Full });
var clientChannel = new IpcClientChannel();
ChannelServices.RegisterChannel(serverChannel, false);
ChannelServices.RegisterChannel(clientChannel, false);
RemotingConfiguration.RegisterWellKnownServiceType(typeof(ManagedAppWorker), ProcessAppConst.WorkerRemoteName, WellKnownObjectMode.Singleton);
Console.WriteLine("Ok");
var line = Console.ReadLine();
while (!"quit".Equals(line, StringComparison.OrdinalIgnoreCase))
{
line = Console.ReadLine();
}
}
catch
{
Console.Write("Failed");
}
}
/// <summary>
/// Prepares capturing in the target process. Note that the process must not already be hooked, and must have a
/// <see cref="Process.MainWindowHandle" />.
/// </summary>
/// <param name="process">The process to inject into</param>
/// <exception cref="ProcessHasNoWindowHandleException">
/// Thrown if the <paramref name="process" /> does not have a window
/// handle. This could mean that the process does not have a UI, or that the process has not yet finished starting.
/// </exception>
/// <exception cref="ProcessAlreadyHookedException">Thrown if the <paramref name="process" /> is already hooked</exception>
/// <exception cref="InjectionFailedException">Thrown if the injection failed - see the InnerException for more details.</exception>
/// <remarks>The target process will have its main window brought to the foreground after successful injection.</remarks>
public CaptureProcess(Process process, CaptureConfig config, CaptureInterface captureInterface)
{
// If the process doesn't have a mainwindowhandle yet, skip it (we need to be able to get the hwnd to set foreground etc)
if (process.MainWindowHandle == IntPtr.Zero)
{
throw new ProcessHasNoWindowHandleException();
}
// Skip if the process is already hooked (and we want to hook multiple applications)
if (HookManager.IsHooked(process.Id))
{
throw new ProcessAlreadyHookedException();
}
captureInterface.ProcessId = process.Id;
CaptureInterface = captureInterface;
//_serverInterface = new CaptureInterface() { ProcessId = process.Id };
// Initialise the IPC server (with our instance of _serverInterface)
_screenshotServer = RemoteHooking.IpcCreateServer(
ref _channelName,
WellKnownObjectMode.Singleton,
CaptureInterface);
try
{
// Inject DLL into target process
RemoteHooking.Inject(
process.Id,
InjectionOptions.Default,
typeof (CaptureInterface).Assembly.Location,
//"Capture.dll", // 32-bit version (the same because AnyCPU) could use different assembly that links to 32-bit C++ helper dll
typeof (CaptureInterface).Assembly.Location,
//"Capture.dll", // 64-bit version (the same because AnyCPU) could use different assembly that links to 64-bit C++ helper dll
// the optional parameter list...
_channelName, // The name of the IPC channel for the injected assembly to connect to
config
);
}
catch (Exception e)
{
throw new InjectionFailedException(e);
}
HookManager.AddHookedProcess(process.Id);
Process = process;
// Ensure the target process is in the foreground,
// this prevents an issue where the target app appears to be in
// the foreground but does not receive any user inputs.
// Note: the first Alt+Tab out of the target application after injection
// may still be an issue - switching between windowed and
// fullscreen fixes the issue however (see ScreenshotInjection.cs for another option)
BringProcessWindowToFront();
}
/// <summary>
/// Cleanup unneeded resources upon disposal.
/// </summary>
protected override void OnCleanup()
{
if (channel != null)
{
ChannelServices.UnregisterChannel(channel);
channel = null;
}
base.OnCleanup();
}
public ScreenCapturer(ScreenshotRequestResponseNotification notify)
{
// Initialise the IPC server
ScreenshotServer = RemoteHooking.IpcCreateServer<ScreenshotInterface.ScreenshotInterface>(
ref ChannelName,
WellKnownObjectMode.Singleton);
Trace.TraceInformation("IPC server started, channel ref: {0}", ChannelName);
this.notify = notify;
}
public static void Cleanup()
{
_singleInstanceMutex.Dispose();
if (_channel != null)
{
ChannelServices.UnregisterChannel(_channel);
_channel = null;
}
}
public void ListenForLaunches()
{
if (!IsFirstInstance)
{
throw new InvalidOperationException();
}
IpcServerChannel channel = new IpcServerChannel(ApplicationId);
ChannelServices.RegisterChannel(channel, true);
RemotingServices.Marshal(this, ApplicationId, typeof (IFirstInstanceServer));
}
static ProcessBootstrap()
{
// Create the channel.
var clientChannel = new IpcClientChannel();
// Register the channel.
System.Runtime.Remoting.Channels.ChannelServices.RegisterChannel(clientChannel, false);
var serverChannel = new IpcServerChannel("Bootstrap", BootstrapIpcPort);
System.Runtime.Remoting.Channels.ChannelServices.RegisterChannel(serverChannel, false);
RemotingConfiguration.RegisterWellKnownServiceType(typeof(ProcessBootstrapProxy), "Bootstrap.rem", WellKnownObjectMode.Singleton);
}
/// <summary>
/// Mains the specified args.
/// </summary>
/// <param name="args">The args.</param>
static void Main(string[] args)
{
if (args == null)
throw new ArgumentNullException("args");
if(args.Length != 3)
throw new ArgumentException("Arguments number doesn't match!", "args");
var name = args[0];
if(string.IsNullOrEmpty(name))
throw new Exception("Name cannot be null or empty.");
name = name.Trim('"');
var channelPort = args[1];
if (string.IsNullOrEmpty(channelPort))
throw new Exception("Channel port cannot be null or empty.");
channelPort = channelPort.Trim('"');
channelPort = string.Format(channelPort, Process.GetCurrentProcess().Id);
var root = args[2];
if (string.IsNullOrEmpty(root))
throw new Exception("Root cannot be null or empty.");
AppDomain.CurrentDomain.SetData("APPBASE", root);
AppDomain.CurrentDomain.SetData(typeof(IsolationMode).Name, IsolationMode.Process);
try
{
var serverChannel = new IpcServerChannel("IpcAgent", channelPort);
var clientChannel = new IpcClientChannel();
ChannelServices.RegisterChannel(serverChannel, false);
ChannelServices.RegisterChannel(clientChannel, false);
RemotingConfiguration.RegisterWellKnownServiceType(typeof(WorkItemAgent), "WorkItemAgent.rem", WellKnownObjectMode.Singleton);
Console.WriteLine("Ok");
var line = Console.ReadLine();
while (!"quit".Equals(line, StringComparison.OrdinalIgnoreCase))
{
line = Console.ReadLine();
}
}
catch
{
Console.WriteLine("Failed");
}
}
/// <summary>
/// Register the Service Property as IPC Server
/// </summary>
private void RegisterServer()
{
Repeater = new DataEventRepeator();
IpcServerChannel channel = new IpcServerChannel("NetOffice.SampleChannel");
ChannelServices.RegisterChannel(channel, true);
RemotingConfiguration.RegisterWellKnownServiceType(
typeof(WebTranslationService),
"NetOffice.WebTranslationService.DataService",
WellKnownObjectMode.Singleton);
Service = new WebTranslationService();
Repeater.Translation += new TranslationEventHandler(ServiceOnTranslation);
Service.AddEventRepeater(Repeater);
}
/// <summary>
/// Registers the remote type.
/// </summary>
/// <param name="uri">The URI.</param>
private static void RegisterRemoteType(string uri)
{
// register remote channel (net-pipes)
var serverChannel = new IpcServerChannel(Environment.MachineName + uri);
ChannelServices.RegisterChannel(serverChannel, true);
// register shared type
RemotingConfiguration.RegisterWellKnownServiceType(
typeof(InstanceProxy), uri, WellKnownObjectMode.Singleton);
// close channel, on process exit
Process process = Process.GetCurrentProcess();
process.Exited += delegate { ChannelServices.UnregisterChannel(serverChannel); };
}
static int Main(string[] args)
{
if ((args.Length == 2) && (args[0].Equals("-iphonepackager")))
{
try
{
// We were run as a 'child' process, quit when our 'parent' process exits
// There is no parent-child relationship WRT windows, it's self-imposed.
int ParentPID = int.Parse(args[1]);
DeploymentProxy.Deployer = new DeploymentImplementation();
IpcServerChannel Channel = new IpcServerChannel("iPhonePackager");
ChannelServices.RegisterChannel(Channel, false);
RemotingConfiguration.RegisterWellKnownServiceType(typeof(DeploymentProxy), "DeploymentServer_PID" + ParentPID.ToString(), WellKnownObjectMode.Singleton);
Process ParentProcess = Process.GetProcessById(ParentPID);
while (!ParentProcess.HasExited)
{
CoreFoundationRunLoop.RunLoopRunInMode(CoreFoundationRunLoop.kCFRunLoopDefaultMode(), 1.0, 0);
}
}
catch (System.Exception Ex)
{
Console.WriteLine(Ex.Message);
}
}
else
{
// Parse the command
if (ParseCommand(args))
{
Deployer = new DeploymentImplementation();
bool bCommandComplete = false;
System.Threading.Thread enumerateLoop = new System.Threading.Thread(delegate()
{
RunCommand();
bCommandComplete = true;
});
enumerateLoop.Start();
while (!bCommandComplete)
{
CoreFoundationRunLoop.RunLoopRunInMode(CoreFoundationRunLoop.kCFRunLoopDefaultMode(), 1.0, 0);
}
}
Console.WriteLine("Exiting.");
}
Environment.ExitCode = Program.ExitCode;
return Program.ExitCode;
}
public MainWindow()
{
InitializeComponent();
try
{
server = RemoteHooking.IpcCreateServer<InjectInterface>(
ref channelName,
WellKnownObjectMode.Singleton);
}
catch (Exception ex)
{
Console.WriteLine(ex.ToString());
}
}
private static void _CreateRemoteService(string channelName)
{
_channel = new IpcServerChannel(
new Dictionary<string, string>
{
{ "name", channelName },
{ "portName", channelName },
{ "exclusiveAddressUse", "false" },
},
new BinaryServerFormatterSinkProvider { TypeFilterLevel = TypeFilterLevel.Full });
ChannelServices.RegisterChannel(_channel, true);
RemotingServices.Marshal(new _IpcRemoteService(), _RemoteServiceName);
}
protected override void StartImpl()
{
this._channel = new IpcServerChannel(new Dictionary<Object, Object>()
{
{"name", ""},
{"secure", true},
{"portName", this._portName},
}, new BinaryServerFormatterSinkProvider()
{
TypeFilterLevel = TypeFilterLevel.Full,
});
ChannelServices.RegisterChannel(this._channel, false);
RemotingServices.Marshal((MarshalByRefObject) this.Host, "", typeof(IServerCore));
}
public IpcChannel(IDictionary properties, IClientChannelSinkProvider clientSinkProvider, IServerChannelSinkProvider serverSinkProvider, CommonSecurityDescriptor securityDescriptor)
{
this._channelPriority = 20;
this._channelName = "ipc";
Hashtable hashtable = new Hashtable();
Hashtable hashtable2 = new Hashtable();
bool flag = false;
if (properties != null)
{
foreach (DictionaryEntry entry in properties)
{
string key = (string)entry.Key;
if (key == null)
{
goto Label_00CC;
}
if (!(key == "name"))
{
if (key == "priority")
{
goto Label_0098;
}
if (key == "portName")
{
goto Label_00B6;
}
goto Label_00CC;
}
this._channelName = (string)entry.Value;
continue;
Label_0098:
this._channelPriority = Convert.ToInt32((string)entry.Value, CultureInfo.InvariantCulture);
continue;
Label_00B6:
hashtable2["portName"] = entry.Value;
flag = true;
continue;
Label_00CC:
hashtable[entry.Key] = entry.Value;
hashtable2[entry.Key] = entry.Value;
}
}
this._clientChannel = new IpcClientChannel(hashtable, clientSinkProvider);
if (flag)
{
this._serverChannel = new IpcServerChannel(hashtable2, serverSinkProvider, securityDescriptor);
}
}
public EntryPoint(RemoteHooking.IContext InContext, string InChannelName)
{
_interface = RemoteHooking.IpcConnectClient<OverlayInterface>(InChannelName);
_interface.Ping();
IDictionary properties = new Hashtable();
properties["name"] = InChannelName;
properties["portName"] = InChannelName + Guid.NewGuid().ToString("N");
BinaryServerFormatterSinkProvider provider = new BinaryServerFormatterSinkProvider();
provider.TypeFilterLevel = System.Runtime.Serialization.Formatters.TypeFilterLevel.Full;
_serverChannel = new IpcServerChannel(properties, provider);
ChannelServices.RegisterChannel(_serverChannel, false);
}
public IpcChannel(IDictionary properties, IClientChannelSinkProvider clientSinkProvider, IServerChannelSinkProvider serverSinkProvider, CommonSecurityDescriptor securityDescriptor)
{
this._channelPriority = 20;
this._channelName = "ipc";
Hashtable hashtable = new Hashtable();
Hashtable hashtable2 = new Hashtable();
bool flag = false;
if (properties != null)
{
foreach (DictionaryEntry entry in properties)
{
string key = (string) entry.Key;
if (key == null)
{
goto Label_00CC;
}
if (!(key == "name"))
{
if (key == "priority")
{
goto Label_0098;
}
if (key == "portName")
{
goto Label_00B6;
}
goto Label_00CC;
}
this._channelName = (string) entry.Value;
continue;
Label_0098:
this._channelPriority = Convert.ToInt32((string) entry.Value, CultureInfo.InvariantCulture);
continue;
Label_00B6:
hashtable2["portName"] = entry.Value;
flag = true;
continue;
Label_00CC:
hashtable[entry.Key] = entry.Value;
hashtable2[entry.Key] = entry.Value;
}
}
this._clientChannel = new IpcClientChannel(hashtable, clientSinkProvider);
if (flag)
{
this._serverChannel = new IpcServerChannel(hashtable2, serverSinkProvider, securityDescriptor);
}
}
public static void InitializeServer(string objectUri, string portName, System.Type type)
{
if (_serverChannel != null) {
Logger.Info("IpcHelper.InitializeServer chiude il canale aperto ...");
ChannelServices.UnregisterChannel(_serverChannel);
}
Hashtable props = new Hashtable();
props.Add("authorizedGroup", "Everyone");
props.Add("portName", portName);
props.Add("exclusiveAddressUse", "false");
_serverChannel = new IpcServerChannel(props, null, null);
ChannelServices.RegisterChannel(_serverChannel, false);
RemotingConfiguration.RegisterWellKnownServiceType(type, objectUri, WellKnownObjectMode.SingleCall);
Logger.Info("CacheService inizializzato");
}
public IpcChannel(IDictionary properties,
IClientChannelSinkProvider clientSinkProvider,
IServerChannelSinkProvider serverSinkProvider,
CommonSecurityDescriptor securityDescriptor)
{
Hashtable clientData = new Hashtable();
Hashtable serverData = new Hashtable();
bool portFound = false;
// divide properties up for respective channels
if (properties != null)
{
foreach (DictionaryEntry entry in properties)
{
switch ((String)entry.Key)
{
// general channel properties
case "name": _channelName = (String)entry.Value; break;
case "priority": _channelPriority = Convert.ToInt32((String)entry.Value, CultureInfo.InvariantCulture); break;
case "portName":
{
serverData["portName"] = entry.Value;
portFound = true;
break;
}
default:
clientData[entry.Key] = entry.Value;
serverData[entry.Key] = entry.Value;
break;
}
}
}
_clientChannel = new IpcClientChannel(clientData, clientSinkProvider);
if (portFound)
{
_serverChannel = new IpcServerChannel(serverData, serverSinkProvider, securityDescriptor);
}
} // IpcChannel
} // IpcChannel
public IpcChannel(String portName) : this()
{
_serverChannel = new IpcServerChannel(portName);
} // IpcChannel
public IpcChannel(string portName) : this()
{
this._serverChannel = new IpcServerChannel(portName);
}
