//private Belikov.GenuineChannels.GenuineTcp.GenuineTcpChannel channel;
        public HTTPTwoWayRemotingClient(int listenPort, int keepAliveIntervalSeconds)
            : base(keepAliveIntervalSeconds)
        {
            /*IDictionary sProps = new Hashtable();
            sProps["algorithm"] = "3DES";
            sProps["requireSecurity"] = "true";
            sProps["connectionAgeLimit"] = "120";
            sProps["sweepFrequency"] = "60";*/

            BinaryServerFormatterSinkProvider binaryServerFormatSinkProvider = new BinaryServerFormatterSinkProvider();
            binaryServerFormatSinkProvider.TypeFilterLevel = System.Runtime.Serialization.Formatters.TypeFilterLevel.Full;

            //SecureServerChannelSinkProvider secureServerSinkProvider = new SecureServerChannelSinkProvider(sProps, null);
            //secureServerSinkProvider.Next = binaryServerFormatSinkProvider;

            BinaryClientFormatterSinkProvider binaryClientFormatSinkProvider = new BinaryClientFormatterSinkProvider();
            //binaryClientFormatSinkProvider.Next = new SecureClientChannelSinkProvider(sProps, null);

            IDictionary props = new Hashtable();
            props["port"] = listenPort;
            //props["useIpAddress"] = false;
            //props["clientConnectionLimit"] = 1;
            //props["rejectRemoteRequests"] = false;
            //props["ConnectTimeout"] = 15000;
            //props["InvocationTimeout"] = 15000;
            //props["Priority"] = "100";

            //Belikov.GenuineChannels.Security.SecuritySessionServices.SetCurrentSecurityContext(new Belikov.GenuineChannels.Security.SecuritySessionParameters(Belikov.GenuineChannels.Security.SecuritySessionServices.DefaultContext.Name, Belikov.GenuineChannels.Security.SecuritySessionAttributes.ForceSync, TimeSpan.FromSeconds(15), Belikov.GenuineChannels.Connection.GenuineConnectionType.Persistent, null, TimeSpan.FromMinutes(5)));

            //channel = new System.Runtime.Remoting.Channels.Tcp.TcpChannel(props, binaryClientFormatSinkProvider, secureServerSinkProvider);
            channel = new System.Runtime.Remoting.Channels.Tcp.TcpChannel(props, binaryClientFormatSinkProvider, binaryServerFormatSinkProvider);
            //channel = new System.Runtime.Remoting.Channels.Http.HttpChannel(props, binaryClientFormatSinkProvider, secureServerSinkProvider);
            //channel = new Belikov.GenuineChannels.GenuineTcp.GenuineTcpChannel(props, binaryClientFormatSinkProvider, binaryServerFormatSinkProvider);
            System.Runtime.Remoting.Channels.ChannelServices.RegisterChannel(channel);
        }

        /// <summary>
        /// 
        /// </summary>
        /// <returns></returns>
        private RemoteObject GetRemoteObject()
        {
            if (_remoteObject == null)
            {

                IDictionary tcpProperties = new Hashtable();

                BinaryClientFormatterSinkProvider tcpClientSinkProvider =
                    new BinaryClientFormatterSinkProvider();

                BinaryServerFormatterSinkProvider tcpServerSinkProvider =
                    new BinaryServerFormatterSinkProvider();

                tcpServerSinkProvider.TypeFilterLevel =
                    System.Runtime.Serialization.Formatters.TypeFilterLevel.Full;

                tcpProperties["timeout"] = 5000;
                tcpProperties["port"] = 0;

                _tcpChannel = new TcpChannel(
                    tcpProperties,
                    tcpClientSinkProvider,
                    tcpServerSinkProvider);

                ChannelServices.RegisterChannel(_tcpChannel, false);

                _remoteObject = (RemoteObject)Activator.GetObject(
                               typeof(RemoteObject),
                               "tcp://127.0.0.1:9000/RO"
                               );
            }

            return _remoteObject;
        }

		/// <summary>
		///  Create a TcpChannel with a given name, on a given port.
		/// </summary>
		/// <param name="port"></param>
		/// <param name="name"></param>
		/// <returns></returns>
		private static TcpChannel CreateTcpChannel( string name, int port, int limit )
		{
			ListDictionary props = new ListDictionary();
			props.Add( "port", port );
			props.Add( "name", name );
			props.Add( "bindTo", "127.0.0.1" );

			BinaryServerFormatterSinkProvider serverProvider =
				new BinaryServerFormatterSinkProvider();

            // NOTE: TypeFilterLevel and "clientConnectionLimit" property don't exist in .NET 1.0.
			Type typeFilterLevelType = typeof(object).Assembly.GetType("System.Runtime.Serialization.Formatters.TypeFilterLevel");
			if (typeFilterLevelType != null)
			{
				PropertyInfo typeFilterLevelProperty = serverProvider.GetType().GetProperty("TypeFilterLevel");
				object typeFilterLevel = Enum.Parse(typeFilterLevelType, "Full");
				typeFilterLevelProperty.SetValue(serverProvider, typeFilterLevel, null);

//                props.Add("clientConnectionLimit", limit);
            }

			BinaryClientFormatterSinkProvider clientProvider =
				new BinaryClientFormatterSinkProvider();

			return new TcpChannel( props, clientProvider, serverProvider );
		}

 private void RegisterChannels()
 {
     BinaryServerFormatterSinkProvider binaryServerProv = new BinaryServerFormatterSinkProvider();
     binaryServerProv.TypeFilterLevel = TypeFilterLevel.Full;
     BinaryClientFormatterSinkProvider binaryClientProv = new BinaryClientFormatterSinkProvider();
     IDictionary props = new Hashtable();
     props["port"] = clientPort;
     props["name"] = server + ":" + serverPort;
     IPAddress[] serverIpAddresses = Dns.GetHostAddresses(server);
     IPAddress serverSelectedIP = null;
     foreach (IPAddress address in serverIpAddresses)
     {
         if (address.AddressFamily == AddressFamily.InterNetwork)
         {
             serverSelectedIP = address;
         }
     }
     if (serverSelectedIP != null)
     {
         IPAddress address = NetHelper.GetIpAddressFromTheSameNetworkAs(serverSelectedIP);
         if (address != null)
         {
             props["machineName"] = address.ToString();
         }
     }
     else
     {
         throw new Exception("Could not select an IP address for the server.");
     }
     chan = new TcpChannel(props, binaryClientProv, binaryServerProv);
     ChannelServices.RegisterChannel(chan);
 }

        /// <summary>
        /// Sets up the services remoting channel
        /// </summary>
        public void Start()
        {
            try
            {
                System.Collections.Hashtable props = new System.Collections.Hashtable();
                props["typeFilterLevel"] = "Full";

                // Both formatters only use the typeFilterLevel property
                BinaryClientFormatterSinkProvider cliFormatter = new BinaryClientFormatterSinkProvider(props, null);
                BinaryServerFormatterSinkProvider srvFormatter = new BinaryServerFormatterSinkProvider(props, null);

                // The channel requires these to be set that it can found by name by clients
                props["name"] = "SyslogConsole";
                props["portName"] = "SyslogConsole";
                props["authorizedGroup"] = "Everyone";

                // Create the channel
                channel = new IpcChannel(props, cliFormatter, srvFormatter);
                channel.IsSecured = false;

                // Register the channel in the Windows IPC list
                ChannelServices.RegisterChannel(channel, false);

                // Register the channel for remoting use
                RemotingConfiguration.RegisterWellKnownServiceType(typeof(ClientMethods), "Server", WellKnownObjectMode.Singleton);

                // Assign the event to a handler
                Listener.MessageReceived += new Listener.MessageReceivedEventHandler(Listener_MessageReceived);
            }
            catch (Exception ex)
            {
                EventLogger.LogEvent("Could not create a named pipe because: " + ex.Message + Environment.NewLine + "Communication with the GUI console will be disabled.",
                    System.Diagnostics.EventLogEntryType.Warning);
            }
        }

        public static void Main(string[] args)
        {
            short port=23456;

            Console.WriteLine("USAGE: subserver <portnumber>");

            if(args.Length>1 && Int16.TryParse(args[1],out port) && port>1024){
                //OK, got good port
            } else {
                port = 23456; //default port
            }

            try {
                BinaryServerFormatterSinkProvider serverProv = new BinaryServerFormatterSinkProvider();
                serverProv.TypeFilterLevel = System.Runtime.Serialization.Formatters.TypeFilterLevel.Full;
                BinaryClientFormatterSinkProvider clientProv = new BinaryClientFormatterSinkProvider();
                IDictionary props = new Hashtable();
                props["port"] = port;

                TcpChannel chan = new TcpChannel(props, clientProv, serverProv);	//create the tcp channel
                ChannelServices.RegisterChannel(chan,false);	//register the tcp channel
                RemotingConfiguration.RegisterWellKnownServiceType(typeof(subsharelib.subshareRemoteObject),"SUBSERVER",WellKnownObjectMode.Singleton);	//publish the remote object

                Console.WriteLine("SERVER STARTED AT PORT "+port);
            } catch (Exception ex) {
                Console.WriteLine("SERVER CAN NOT START! "+ex);
            }
            Console.Write("Press any key to exit . . . ");
            Console.ReadKey(true);
        }

        private void CreateCommunicationChannel()
        {
            BinaryServerFormatterSinkProvider binaryServerProv = new BinaryServerFormatterSinkProvider();
            binaryServerProv.TypeFilterLevel = TypeFilterLevel.Full;
            BinaryClientFormatterSinkProvider binaryClientProv = new BinaryClientFormatterSinkProvider();

            IDictionary props = new Hashtable();
            props["port"] = settings.Port;
            props["authenticationMode"] = "IdentifyCallers";


            //HttpChannel chan = new HttpChannel(props, binaryClientProv, binaryServerProv); 
            try
            {
                TcpChannel chan = new TcpChannel(props, binaryClientProv, binaryServerProv);
                ChannelServices.RegisterChannel(chan, false);
                if (chan == null)
                {
                    new WindowsServiceLog().WriteEntry(
                            string.Format("Could not start server with port {0}", settings.Port));
                    Process.GetCurrentProcess().Kill();
                }
            }
            catch (SocketException e)
            {
                new WindowsServiceLog().WriteEntry(
                        string.Format("Could not start server. Application port {1} is using by another application. Error message: {0}",
                                                    e.Message, settings.Port));
                Process.GetCurrentProcess().Kill();
            }
        }

        public frmRCleint()
        {
            InitializeComponent();

            //************************************* TCP *************************************//
            // using TCP protocol
            // running both client and server on same machines
            //TcpChannel chan = new TcpChannel();
            //˫���ŵ�
            BinaryServerFormatterSinkProvider serverProv = new BinaryServerFormatterSinkProvider();
            serverProv.TypeFilterLevel = System.Runtime.Serialization.Formatters.TypeFilterLevel.Full;
            BinaryClientFormatterSinkProvider clientProv = new BinaryClientFormatterSinkProvider();
            IDictionary props = new Hashtable();
            props["port"] = 0;//���ն˿�(���)
            TcpChannel chan = new TcpChannel(props, clientProv, serverProv);

            ChannelServices.RegisterChannel(chan,false);
            // Create an instance of the remote object
            remoteObject = (MyRemotableObject) Activator.GetObject(typeof(MyRemotableObject),"tcp://localhost:8080/HelloWorld");
            // if remote object is on another machine the name of the machine should be used instead of localhost.
            //************************************* TCP *************************************//
            wrapper = new EventWrapper();//�¼���װ������
            wrapper.LocalEvent += new ServerEventHandler(OnServerEvent);
            remoteObject.ServerEvent += new ServerEventHandler(wrapper.Response);
        }

        private void btnStart_Click(object sender, EventArgs e)
        {
            setServiceXml();
            btnStart.Enabled = false;
            
            try
            {
                Setting.Load();
                BinaryServerFormatterSinkProvider binaryServerFormatterSinkProvider = new BinaryServerFormatterSinkProvider();
                BinaryClientFormatterSinkProvider clientSinkProvider = new BinaryClientFormatterSinkProvider();
                binaryServerFormatterSinkProvider.TypeFilterLevel = TypeFilterLevel.Full;

                IDictionary dic = new Dictionary<string, int>();
                dic.Add("port", Setting.Instance.Port);

                TcpChannel channel = new TcpChannel(dic, clientSinkProvider, binaryServerFormatterSinkProvider);
                ChannelServices.RegisterChannel(channel, false);
                List<IRemoteService> list = ServicesManager.GetTypeFromAssembly<IRemoteService>();
                foreach (IRemoteService service in list)
                {
                    service.RegisterService();
                }
                btnStop.Enabled = true;
            }
            catch (Exception ex)
            {
                btnStart.Enabled = true;
                throw ex;
            }
        }

        public RemotingHostServer(Machine machine, int port, string name)
            : base(machine)
        {
            this.port = port;
            this.name = name;

            // TODO review this name, get machine name
            this.hostname = "localhost";

            // According to http://www.thinktecture.com/resourcearchive/net-remoting-faq/changes2003
            // in order to have ObjRef accessible from client code
            BinaryServerFormatterSinkProvider serverProv = new BinaryServerFormatterSinkProvider();
            serverProv.TypeFilterLevel = System.Runtime.Serialization.Formatters.TypeFilterLevel.Full;

            BinaryClientFormatterSinkProvider clientProv = new BinaryClientFormatterSinkProvider();

            IDictionary props = new Hashtable();
            props["port"] = port;

            TcpChannel channel = new TcpChannel(props, clientProv, serverProv);

            if (!registered)
            {
                ChannelServices.RegisterChannel(channel, false);
                registered = true;
            }

            // end of "according"

            // TODO review other options to publish an object
            this.objref = RemotingServices.Marshal(this, name);
        }

 private IClientChannelSinkProvider CreateDefaultClientProviderChain()
 {
     IClientChannelSinkProvider provider = new BinaryClientFormatterSinkProvider();
     IClientChannelSinkProvider provider2 = provider;
     provider2.Next = new IpcClientTransportSinkProvider(this._prop);
     return provider;
 }

        private void RegisterRemoting()
        {
            {
                try
                {
                    BinaryServerFormatterSinkProvider server_provider = new BinaryServerFormatterSinkProvider();
                    server_provider.TypeFilterLevel = System.Runtime.Serialization.Formatters.TypeFilterLevel.Full;

                    BinaryClientFormatterSinkProvider client_provider = new BinaryClientFormatterSinkProvider();
                    IDictionary properties = new Hashtable();

                    properties["port"] = "0";

                    TcpChannel channel = new TcpChannel(properties, client_provider, server_provider);
                    ChannelServices.RegisterChannel(channel, false);

                    user = (IUser)Activator.GetObject(typeof(IUser), "tcp://localhost:9998/UserHandeling");
                    portal = (IPortal)Activator.GetObject(typeof(IPortal), "tcp://localhost:9998/PortalHandeling");
                    ftserver = (IFTserver)Activator.GetObject(typeof(IFTserver), "tcp://localhost:9998/TransferHandeling");
                }
                catch (RemotingException e)
                {
                    MessageBox.Show("Connection Error");
                }
            }
        }

        public static UserWarehouse GetInstance()
        {
            var clientFormatter = new BinaryClientFormatterSinkProvider();
            HttpChannel httpChannel = new HttpChannel(null, clientFormatter, null);
            ChannelServices.RegisterChannel(httpChannel, false);

            return (UserWarehouse)Activator.GetObject(typeof(UserWarehouse), "http://localhost:5000/UserWarehouse");
        }

		private static void SetupRemoting(int port) {
			BinaryClientFormatterSinkProvider clientProvider = new BinaryClientFormatterSinkProvider();
			BinaryServerFormatterSinkProvider serverProvider = new BinaryServerFormatterSinkProvider { TypeFilterLevel = TypeFilterLevel.Full };
			IDictionary props = new Hashtable();
			props["port"] = port;
			Logger.Info("Initializing on port " + port + "...");
			TcpChannel chan = new TcpChannel(props, clientProvider, serverProvider);
			ChannelServices.RegisterChannel(chan, false);
		}

		public static void RegisterRemotingChannel ()
		{
			IDictionary dict = new Hashtable ();
			BinaryClientFormatterSinkProvider clientProvider = new BinaryClientFormatterSinkProvider();
			BinaryServerFormatterSinkProvider serverProvider = new BinaryServerFormatterSinkProvider();
			dict ["port"] = 0;
			serverProvider.TypeFilterLevel = System.Runtime.Serialization.Formatters.TypeFilterLevel.Full;
			ChannelServices.RegisterChannel (new TcpChannel (dict, clientProvider, serverProvider), false);
		}

		public static void RegisterRemotingChannel ()
		{
			IDictionary dict = new Hashtable ();
			BinaryClientFormatterSinkProvider clientProvider = new BinaryClientFormatterSinkProvider();
			BinaryServerFormatterSinkProvider serverProvider = new BinaryServerFormatterSinkProvider();
			unixRemotingFile = Path.GetTempFileName ();
			dict ["portName"] = Path.GetFileName (unixRemotingFile);
			serverProvider.TypeFilterLevel = System.Runtime.Serialization.Formatters.TypeFilterLevel.Full;
			ChannelServices.RegisterChannel (new IpcChannel (dict, clientProvider, serverProvider), false);
		}

		public static void Init(int port)
		{
			BinaryServerFormatterSinkProvider serverProv = new BinaryServerFormatterSinkProvider();
			serverProv.TypeFilterLevel = TypeFilterLevel.Full;
			BinaryClientFormatterSinkProvider clientProv = new BinaryClientFormatterSinkProvider();
			IDictionary props = new Hashtable();
			props["port"] = port;
			TcpChannel tcp_channel = new TcpChannel(props, clientProv, serverProv);
			ChannelServices.RegisterChannel(tcp_channel, false);
		}

        static void Main(string[] args)
        {
            Console.WriteLine("Starting client");

            BinaryServerFormatterSinkProvider serverProv = new BinaryServerFormatterSinkProvider();
            serverProv.TypeFilterLevel = System.Runtime.Serialization.Formatters.TypeFilterLevel.Full;
            BinaryClientFormatterSinkProvider clientProv = new BinaryClientFormatterSinkProvider();

            IDictionary props = new Hashtable();
            props["port"] = 0;
            props["name"] = "clientChannelName";

            var channel = new HttpChannel(props, clientProv, serverProv);
            ChannelServices.RegisterChannel(channel, false);

            try
            {
                var ctxServer = (IServerContext)RemotingServices.Connect(typeof(IServerContext), "http://localhost:5656" + "/ctxServer");

                var ctxClient = new ClientContext(ctxServer, new Execom.IOG.Storage.MemoryStorageUnsafe<Guid, object>());

                ConsoleKeyInfo pressedKey = new ConsoleKeyInfo();
                do
                {
                    Console.Clear();
                    Console.WriteLine("Press ESC to exit");

                    if (Console.KeyAvailable)
                    {
                        pressedKey = Console.ReadKey();
                    }

                    if (pressedKey.Key != ConsoleKey.Escape)
                    {
                        using (var ws = ctxClient.OpenWorkspace<Execom.IOG.Distributed.Model.IDataModel>(IsolationLevel.Snapshot))
                        {
                            for (int i = 0; i < 1000; i++)
                            {
                                var user = ws.New<IUser>();
                                user.Username = "New guy";

                                ws.Data.Users.Add(user);
                            }
                            ws.Commit();
                        }
                    }

                }
                while (pressedKey.Key != ConsoleKey.Escape);
            }
            finally
            {
                ChannelServices.UnregisterChannel(channel);
            }
        }

        public void Run(AgentConfig config, bool bDaemonMode)
        {
            mConfig = config;
            // init remoting
            BinaryClientFormatterSinkProvider clientProvider =
                new BinaryClientFormatterSinkProvider();
            BinaryServerFormatterSinkProvider serverProvider =
                new BinaryServerFormatterSinkProvider();
            serverProvider.TypeFilterLevel =
                System.Runtime.Serialization.Formatters.TypeFilterLevel.Full;

            IDictionary props = new Hashtable();
            props["port"] = mConfig.Port;
            string s = System.Guid.NewGuid().ToString();
            props["name"] = s;
            props["typeFilterLevel"] = TypeFilterLevel.Full;
            try
            {
                TcpChannel chan = new TcpChannel(
                    props, clientProvider, serverProvider);

                log.InfoFormat("Registering channel on port {0}", mConfig.Port);
            #if NET_2_0
                ChannelServices.RegisterChannel(chan, false);
            #else
                ChannelServices.RegisterChannel(chan);
            #endif
            }
            catch (Exception e)
            {
                log.InfoFormat("Can't register channel.\n{0}", e.Message);
                return;
            }

            // publish
            RemotingServices.Marshal(this, PNUnit.Framework.Names.PNUnitAgentServiceName);

            // otherwise in .NET 2.0 memory grows continuosly
            FreeMemory();

            if (bDaemonMode)
            {
                // wait continously
                while (true)
                {
                    Thread.Sleep(10000);
                }
            }
            else
            {
                Console.ReadLine();
            }

            //RemotingServices.Disconnect(this);
        }

        static RemotingPortalClient()
        {
            Hashtable properties = new Hashtable();
            properties["name"] = "HttpBinary";
            BinaryClientFormatterSinkProvider formatter = new BinaryClientFormatterSinkProvider();
            HttpChannel channel = new HttpChannel(properties, formatter, null);
            ChannelServices.RegisterChannel(channel, EncryptChannel);

            //HttpChannel channel = new HttpChannel();
            //ChannelServices.RegisterChannel(channel, EncryptChannel);
        }