public static void RegistRemotingObj(string channelName, int port, string typeName, string assembly, string url) { //Port IChannel chnl = ChannelServices.GetChannel(channelName); if (channel == null || chnl == null) { if (channel != null) ChannelServices.UnregisterChannel(channel); if (chnl != null) ChannelServices.UnregisterChannel(chnl); channel = new TcpServerChannel(channelName, port); ChannelServices.RegisterChannel(channel, false); } //Object Regist WellKnownServiceTypeEntry registerType = new WellKnownServiceTypeEntry(typeName, assembly, url, WellKnownObjectMode.Singleton); RemotingConfiguration.RegisterWellKnownServiceType(registerType); RemotingConfiguration.CustomErrorsMode = CustomErrorsModes.Off; RemotingConfiguration.CustomErrorsEnabled(false); }
/// <summary> /// when big boring button is clicked start to listen on port 9000 /// </summary> /// <param name="sender"></param> /// <param name="e"></param> private void start_Click(object sender, EventArgs e) { TcpServerChannel channel = new TcpServerChannel(9000); ChannelServices.RegisterChannel(channel, false); WellKnownServiceTypeEntry remObj = new WellKnownServiceTypeEntry ( typeof(RemoteApp.RemoteApp), "remoteapp", WellKnownObjectMode.Singleton ); RemotingConfiguration.RegisterWellKnownServiceType(remObj); }
static void Main(string[] args) { TcpChannel remotingChannel = new TcpChannel(8888); ChannelServices.RegisterChannel(remotingChannel, false); WellKnownServiceTypeEntry remoteObject = new WellKnownServiceTypeEntry(typeof(RemoteMathExpanded), "rMath", WellKnownObjectMode.SingleCall); RemotingConfiguration.RegisterWellKnownServiceType(remoteObject); Console.WriteLine("Registered service"); Console.WriteLine("Press any key to exit"); Console.ReadLine(); }
private void registerChannel() { // set typefilterlevel to higher security SoapServerFormatterSinkProvider serverFormatter = new SoapServerFormatterSinkProvider(); serverFormatter.TypeFilterLevel = System.Runtime.Serialization.Formatters.TypeFilterLevel.Full; // setup dictionary with values Hashtable ht = new Hashtable(); ht["name"] = "ServerChannel"; ht["port"] = 9000; // create and register the channel HttpChannel channel = new HttpChannel(ht, null, serverFormatter); ChannelServices.RegisterChannel(channel, false); // register a wellknown type in singleton mode string identifier = "commBuffer"; WellKnownObjectMode mode = WellKnownObjectMode.Singleton; WellKnownServiceTypeEntry entry = new WellKnownServiceTypeEntry(typeof(osgCommBuffer), identifier, mode); RemotingConfiguration.RegisterWellKnownServiceType(entry); }
static void Main(string[] args) { // create a TCP channel and bind it to port 8888 TcpChannel remotingChannel = new TcpChannel(8888); // register the channel, the second parameter is ensureSecurity // I have set it to false to disable encryption and signing // for more information see section Remarks in https://msdn.microsoft.com/en-us/library/ms223155(v=vs.90).aspx ChannelServices.RegisterChannel(remotingChannel, false); // create a new servicetype of type RemoteMath named "rMath" and of type SingleCall // SingleCall: a new object will be created for each call // as opposed to WellKnownObjectMode.Singleton where there is one object for all calls (and clients) WellKnownServiceTypeEntry remoteObject = new WellKnownServiceTypeEntry(typeof(RemoteMath), "rMath", WellKnownObjectMode.SingleCall); // register the remoteObject servicetype RemotingConfiguration.RegisterWellKnownServiceType(remoteObject); Console.WriteLine("Registered service"); Console.WriteLine("Press any key to exit"); Console.ReadLine(); }
private bool CheckForWellKnownServiceEntryWithType(string typeName, string asmName) { foreach (DictionaryEntry entry in this._wellKnownExportInfo) { WellKnownServiceTypeEntry entry2 = (WellKnownServiceTypeEntry)entry.Value; if (typeName == entry2.TypeName) { bool flag = false; if (asmName == entry2.AssemblyName) { flag = true; } else if ((string.Compare(entry2.AssemblyName, 0, asmName, 0, asmName.Length, StringComparison.OrdinalIgnoreCase) == 0) && (entry2.AssemblyName[asmName.Length] == ',')) { flag = true; } if (flag) { return(true); } } } return(false); }
public static void RegisterWellKnownServiceType(WellKnownServiceTypeEntry entry) { Contract.Requires(entry != null); Contract.Requires(entry.AssemblyName != null); Contract.Requires(entry.ObjectUri != null); }
/// <summary> /// Publishes this object for remoting. /// </summary> /// <param name="objectUri">The remoting uri of the object.</param> /// <param name="createDefaultChannels"> /// Determinates if the default channels should be created or not. /// <seealso cref="RemotingConstants"/> /// </param> public void Start(string objectUri, bool createDefaultChannels) { if (createDefaultChannels) { // Register default channel for remote access Hashtable properties = new Hashtable(); properties["name"] = RemotingConstants.DefaultServiceChannelName; properties["port"] = RemotingConstants.DefaultServicePort; IChannel currentChannel = RemotingConstants.GetDefaultChannel(properties); ChannelServices.RegisterChannel(currentChannel, false); } WellKnownServiceTypeEntry serviceTypeEntry = new WellKnownServiceTypeEntry( GetType(), objectUri, WellKnownObjectMode.Singleton); RegisterService(InnerHandler); RemotingConfiguration.RegisterWellKnownServiceType(serviceTypeEntry); }
[System.Security.SecurityCritical] // auto-generated internal void AddWellKnownEntry(WellKnownServiceTypeEntry entry, bool fReplace) { if (CheckForRedirectedClientType(entry.TypeName, entry.AssemblyName)) { throw new RemotingException( String.Format( CultureInfo.CurrentCulture, Environment.GetResourceString( "Remoting_Config_CantUseRedirectedTypeForWellKnownService"), entry.TypeName, entry.AssemblyName)); } String key = entry.ObjectUri.ToLower(CultureInfo.InvariantCulture); if (fReplace) { // Registering a well known object twice replaces the old one, so // we null out the old entry in the identity table after adding // this one. The identity will be recreated the next time someone // asks for this object. _wellKnownExportInfo[key] = entry; IdentityHolder.RemoveIdentity(entry.ObjectUri); } else { _wellKnownExportInfo.Add(key, entry); } }
public static void RegisterWellKnownServiceType(Type type, string objectUri, WellKnownObjectMode mode) { WellKnownServiceTypeEntry entry = new WellKnownServiceTypeEntry(type, objectUri, mode); RemotingConfiguration.RegisterWellKnownServiceType(entry); }
//解析WellKnown对象 void ParseWellKnownServerObjectSection(XmlNode root) { foreach (XmlNode node in root.ChildNodes) { if (node.NodeType == XmlNodeType.Comment) continue; if (node.Name != "add") continue; string objectUri = base.GetStringAttribute(node, "objectUri"); if (string.IsNullOrEmpty(objectUri)) continue; string fullTypeName = base.GetStringAttribute(node, "type"); if (string.IsNullOrEmpty(fullTypeName)) continue; string mode = base.GetStringAttribute(node, "mode").ToLower(); string typeName = fullTypeName.Split(',')[0]; string assemblyName = string.Empty; if (fullTypeName.IndexOf(',') != -1) { assemblyName = fullTypeName.Split(',')[1]; } else { Assembly assembly = ReflectUtil.FindAssemblyFromAppDirectory(typeName); if (assembly != null) assemblyName = assembly.FullName; } WellKnownObjectMode objectMode = WellKnownObjectMode.Singleton; if (mode == "singlecall") objectMode = WellKnownObjectMode.SingleCall; WellKnownServiceTypeEntry wse = new WellKnownServiceTypeEntry(typeName, assemblyName, objectUri, objectMode); si.AddWellKnownObject(wse); } }
public int Run(string[] args) { bool bouncingRequest = false; var options = args.Switches(); var parameters = args.Parameters(); foreach (var arg in options.Keys) { var argumentParameters = options[arg]; switch (arg) { case "load-config": // all ready done, but don't get too picky. break; case "nologo": this.Assembly().SetLogo(string.Empty); break; case "help": return Help(); case "output-file": _traceFile = Path.GetFullPath(argumentParameters.LastOrDefault()); break; case "bounce": // whoa there, this is an internal bounce request bouncingRequest = true; _ticket = int.Parse(argumentParameters.LastOrDefault()); break; default: return Fail("Unknown parameter [--{0}]", arg); } } if (parameters.Count() < 1 && !bouncingRequest) { return Fail("Missing Command. \r\n\r\n Use --help for command line help."); } // // Get the rest of the command line // var application = string.Empty; var cmdline = string.Empty; if (!bouncingRequest) { application = Helpers.FindInPath(parameters.First()); if( !File.Exists(application)) { return Fail("Unable to start given command line. \r\n\r\n Can not find executable [{0}]", application); } cmdline = parameters.Skip(1).Aggregate("\"" + application + "\" ", (current, i) => current + (i.Contains(" ") ? "\"" + i + "\" " : i + " ")).Trim(); Logo(); } // // Register our .NET remoting "scribe" and related comm channel // if (!bouncingRequest) { _channel = new IpcChannel("CoAppTraceIpc"); WellKnownServiceTypeEntry wkst = new WellKnownServiceTypeEntry(typeof(Scribe), "Scribe", WellKnownObjectMode.Singleton); RemotingConfiguration.RegisterWellKnownServiceType(wkst); ChannelServices.RegisterChannel(_channel, false); } // // Create the first instance // var scribe = (IScribe)Activator.GetObject(typeof(IScribe), "ipc://CoAppTraceIpc/Scribe"); scribe.Ping(); // // Detour and launch the target process. // // If we're bouncing a request, we need to ensure we restore all the // original parameters before continuing. // IntPtr ppi = Marshal.AllocHGlobal(Constants.SizeOfProcessInformation); Helpers.RtlZeroMemory(ppi, Constants.SizeOfProcessInformation); IntPtr psi = Marshal.AllocHGlobal(Constants.SizeOfStartupInformation); Helpers.RtlZeroMemory(psi, Constants.SizeOfStartupInformation); Marshal.WriteInt32(psi, 0, Constants.SizeOfStartupInformation); Scribe.State state = new Scribe.State(); if (bouncingRequest) { state = scribe.RetrieveState(_ticket); application = state.ApplicationName; cmdline = state.CommandLine; var processInfo = state.ProcessInformation; var startupInfo = state.StartupInformation; IntPtr lpDesktop = string.IsNullOrEmpty(state.Desktop) ? IntPtr.Zero : Marshal.StringToHGlobalUni(state.Desktop); IntPtr lpTitle = string.IsNullOrEmpty(state.Title) ? IntPtr.Zero : Marshal.StringToHGlobalUni(state.Title); startupInfo.lpDesktop = lpDesktop; startupInfo.lpTitle = lpTitle; // Leaky. But not really a problem. Marshal.StructureToPtr(processInfo, ppi, false); Marshal.StructureToPtr(startupInfo, psi, false); // // The bounce process has a console of its own (console subsystem). // We need to destroy it and latch onto our parent's existing one. // // Kernel32.FreeConsole(); // Kernel32.AttachConsole(-1); } IntPtr lpApplication = Marshal.StringToHGlobalUni(application); IntPtr lpCmdLine = Marshal.StringToHGlobalUni(cmdline); bool bounced; Detours.DetourCreateProcessWithDll(lpApplication, lpCmdLine, IntPtr.Zero, IntPtr.Zero, Constants.DetoursDllName, Constants.DetouredDllName,Constants.CoAppTraceHost, 1, 0, IntPtr.Zero, IntPtr.Zero, psi, ppi, out bounced); var pi = (PROCESS_INFORMATION)Marshal.PtrToStructure(ppi, typeof(PROCESS_INFORMATION)); Debug.Assert(pi.dwProcessId != 0, "Process ID 0 detected."); if (bouncingRequest) { scribe.DocumentNewProcess(state.OriginalParentProcessId, (int)pi.dwProcessId, cmdline, application, Environment.CurrentDirectory); // we need to give the child app time enough to get going before doing anything... // Thread.Sleep(1000); if (state.IsConsole) { try { Scribe.GetStartedProcessById((int) pi.dwProcessId).WaitForExit(); } catch (Exception e) { /// meh. it dies, it dies. // Console.WriteLine("Exception'd. {0}", e.Message); } } } else { if (!bounced) { scribe.DocumentNewProcess((int) pi.dwProcessId, cmdline, application, Environment.CurrentDirectory); } // // Wait for the spawned process (and its children) to terminate completely. // scribe.Finished.WaitOne(); // // Save the trace output to disk. // scribe.Write(_traceFile.format((int) pi.dwProcessId)); using (new ConsoleColors(ConsoleColor.White, ConsoleColor.Black)) { Console.WriteLine("TRACE COMPLETE"); Console.WriteLine("TRACE File: {0} ", _traceFile.format((int) pi.dwProcessId).GetFullPath()); } } return 0; }
internal void AddWellKnownEntry(WellKnownServiceTypeEntry entry, bool fReplace) { if (this.CheckForRedirectedClientType(entry.TypeName, entry.AssemblyName)) { throw new RemotingException(string.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("Remoting_Config_CantUseRedirectedTypeForWellKnownService"), new object[] { entry.TypeName, entry.AssemblyName })); } string key = entry.ObjectUri.ToLower(CultureInfo.InvariantCulture); if (fReplace) { this._wellKnownExportInfo[key] = entry; IdentityHolder.RemoveIdentity(entry.ObjectUri); } else { this._wellKnownExportInfo.Add(key, entry); } }
internal WellKnownServiceTypeEntry[] GetRegisteredWellKnownServiceTypes() { WellKnownServiceTypeEntry[] entryArray = new WellKnownServiceTypeEntry[this._wellKnownExportInfo.Count]; int num = 0; foreach (DictionaryEntry entry in this._wellKnownExportInfo) { WellKnownServiceTypeEntry entry2 = (WellKnownServiceTypeEntry) entry.Value; WellKnownServiceTypeEntry entry3 = new WellKnownServiceTypeEntry(entry2.TypeName, entry2.AssemblyName, entry2.ObjectUri, entry2.Mode) { ContextAttributes = entry2.ContextAttributes }; entryArray[num++] = entry3; } return entryArray; }
internal static void RegisterWellKnownServiceType(WellKnownServiceTypeEntry entry) { string typeName = entry.TypeName; string assemblyName = entry.AssemblyName; string objectUri = entry.ObjectUri; WellKnownObjectMode mode = entry.Mode; lock (Info) { Info.AddWellKnownEntry(entry); } }
internal void StoreWellKnownExports(RemotingXmlConfigFileData configData) { foreach (RemotingXmlConfigFileData.ServerWellKnownEntry entry in configData.ServerWellKnownEntries) { WellKnownServiceTypeEntry entry2 = new WellKnownServiceTypeEntry(entry.TypeName, entry.AssemblyName, entry.ObjectURI, entry.ObjectMode) { ContextAttributes = null }; RemotingConfigHandler.RegisterWellKnownServiceType(entry2); } }
// Register a well known service type entry. public static void RegisterWellKnownServiceType (WellKnownServiceTypeEntry entry) { if(entry == null) { throw new ArgumentNullException("entry"); } lock(typeof(RemotingConfiguration)) { EnsureLoaded(); if(registeredServiceTypes == null) { registeredServiceTypes = new Hashtable(); } registeredServiceTypes[entry.ObjectType] = entry; } }
public static WellKnownServiceTypeEntry[] GetRegisteredWellKnownServiceTypes () { lock (channelTemplates) { WellKnownServiceTypeEntry[] entries = new WellKnownServiceTypeEntry[wellKnownServiceEntries.Count]; wellKnownServiceEntries.Values.CopyTo (entries,0); return entries; } }
public static void RegisterWellKnownServiceType(WellKnownServiceTypeEntry entry) { RemotingConfigHandler.RegisterWellKnownServiceType(entry); } // RegisterWellKnownServiceType
public static void RegisterWellKnownServiceType (WellKnownServiceTypeEntry entry) { lock (channelTemplates) { wellKnownServiceEntries [entry.ObjectUri] = entry; RemotingServices.CreateWellKnownServerIdentity (entry.ObjectType, entry.ObjectUri, entry.Mode); } }
} // GetRegisteredActivatedServiceTypes internal WellKnownServiceTypeEntry[] GetRegisteredWellKnownServiceTypes() { WellKnownServiceTypeEntry[] entries = new WellKnownServiceTypeEntry[_wellKnownExportInfo.Count]; int co = 0; foreach (DictionaryEntry dictEntry in _wellKnownExportInfo) { WellKnownServiceTypeEntry entry = (WellKnownServiceTypeEntry)dictEntry.Value; WellKnownServiceTypeEntry wkste = new WellKnownServiceTypeEntry( entry.TypeName, entry.AssemblyName, entry.ObjectUri, entry.Mode); wkste.ContextAttributes = entry.ContextAttributes; entries[co++] = wkste; } return entries; } // GetRegisteredWellKnownServiceTypes
public static void RegisterWellKnownServiceType(WellKnownServiceTypeEntry entry) { RemotingConfigHandler.RegisterWellKnownServiceType(entry); }
public static void RegisterWellKnownServiceType(Type type, string objectUri, WellKnownObjectMode mode) { WellKnownServiceTypeEntry entry = new WellKnownServiceTypeEntry(type, objectUri, mode); RegisterWellKnownServiceType(entry); }
public static void RegisterWellKnownServiceType( Type type, String objectUri, WellKnownObjectMode mode) { WellKnownServiceTypeEntry wke = new WellKnownServiceTypeEntry(type, objectUri, mode); RemotingConfiguration.RegisterWellKnownServiceType(wke); } // RegisterWellKnownServiceType
/// <summary> /// 加入一个WellKnown对象实体 /// </summary> /// <param name="entry"></param> public void AddWellKnownObject(WellKnownServiceTypeEntry entry) { if (_WellKnownObjectCollection.ContainsKey(entry.ObjectUri)) return; _WellKnownObjectCollection.Add(entry.ObjectUri, entry); }
[System.Security.SecurityCritical] // auto-generated internal void StoreWellKnownExports(RemotingXmlConfigFileData configData) { // < foreach (RemotingXmlConfigFileData.ServerWellKnownEntry entry in configData.ServerWellKnownEntries) { WellKnownServiceTypeEntry wke = new WellKnownServiceTypeEntry( entry.TypeName, entry.AssemblyName, entry.ObjectURI, entry.ObjectMode); wke.ContextAttributes = null; // Register the well known entry but do not startup the object RemotingConfigHandler.RegisterWellKnownServiceType(wke); } } // StoreWellKnownExports
public static void RegisterWellKnownServiceType(WellKnownServiceTypeEntry entry) { throw new NotImplementedException(); }
[System.Security.SecurityCritical] // auto-generated internal void AddWellKnownEntry(WellKnownServiceTypeEntry entry) { AddWellKnownEntry(entry, true); }
public static void init() { if (instance == null) { instance = new WebBackEnd(); if (tch1 == null) { tch1 = new TcpChannel(8347); //Register TCP Channel Listener ChannelServices.RegisterChannel(tch1); WellKnownServiceTypeEntry WKSTE = new WellKnownServiceTypeEntry(typeof(WebBackEnd), "WebBackEnd.rem", WellKnownObjectMode.Singleton); RemotingConfiguration.ApplicationName="beagled"; RemotingConfiguration.RegisterWellKnownServiceType(WKSTE); } } }
[System.Security.SecurityCritical] // auto-generated internal static void RegisterWellKnownServiceType(WellKnownServiceTypeEntry entry) { BCLDebug.Trace("REMOTE", "Adding well known service type for " + entry.ObjectUri); // < String serverType = entry.TypeName; String asmName = entry.AssemblyName; String URI = entry.ObjectUri; WellKnownObjectMode mode = entry.Mode; lock (Info) { // We make an entry in our config tables so as to keep // both the file-based and programmatic config in [....]. Info.AddWellKnownEntry(entry); } } // RegisterWellKnownServiceType
internal void AddWellKnownEntry(WellKnownServiceTypeEntry entry) { this.AddWellKnownEntry(entry, true); }