Ejemplo n.º 1
0
        } // StopListening

        //
        // end of IChannelReceiver implementation
        //

        // Thread for listening
        void Listen()
        {
            InternalRemotingServices.RemotingTrace("Waiting to Accept a Connection on Port: " + _portName);

            //
            // Wait for an incoming client connection
            //
            IntPtr handle = IntPtr.Zero;

            bool connected = false;
            CommonSecurityDescriptor descriptor = _securityDescriptor;

            // Connect with exlusive flag the first time
            try{
                // If the descriptor is not explicitly set through code use the _authorizedGroup config
                if (descriptor == null && _authorizedGroup != null)
                {
                    NTAccount ntAccount = new NTAccount(_authorizedGroup);
                    descriptor = IpcPort.CreateSecurityDescriptor((SecurityIdentifier)ntAccount.Translate(typeof(SecurityIdentifier)));
                }

                _port = IpcPort.Create(_portName, descriptor, _bExclusiveAddressUse);
            }
            catch (Exception e) {
                _startListeningException = e;
            }
            finally {
                _bListening = (_startListeningException == null);
                _waitForStartListening.Set(); // allow main thread to continue now that we have tried to start the socket
            }

            if (_port != null)
            {
                connected = _port.WaitForConnect();
            }

            while (_bListening)
            {
                InternalRemotingServices.RemotingTrace("IpcChannel::Listen");

                // For DevDiv#220882, we need to create new IpcPort before handling the current message
                // to avoid race condition in case the message is handled and finished before
                // the new IpcPort is created.  The client will intermittently fail with Port not found.
                IpcPort port = IpcPort.Create(_portName, descriptor, false);

                if (connected)
                {
                    // Initialize the server handler and perform an async read
                    IpcServerHandler serverHandler = new IpcServerHandler(_port, CoreChannel.RequestQueue, new PipeStream(_port));
                    serverHandler.DataArrivedCallback = new WaitCallback(_transportSink.ServiceRequest);
                    serverHandler.BeginReadMessage();
                }
                _port     = port;
                connected = _port.WaitForConnect();
            }
        }
Ejemplo n.º 2
0
        public void AsyncProcessResponse(IServerResponseChannelSinkStack sinkStack, Object state,
                                         IMessage msg, ITransportHeaders headers, Stream stream)
        {
            IpcServerHandler ipcServerHandler = null;

            ipcServerHandler = (IpcServerHandler)state;

            // send the response
            ipcServerHandler.SendResponse(headers, stream);

            //if (streamManager.CanServiceAnotherRequest())
            //    streamManager.BeginReadMessage();
            //else
            //    streamManager.Close();
        } // AsyncProcessResponse
        internal void ServiceRequest(object state)
        {
            IpcServerHandler  handler        = (IpcServerHandler)state;
            ITransportHeaders requestHeaders = handler.ReadHeaders();
            Stream            requestStream  = handler.GetRequestStream();

            requestHeaders["__CustomErrorsEnabled"] = false;
            ServerChannelSinkStack sinkStack = new ServerChannelSinkStack();

            sinkStack.Push(this, handler);
            IMessage          responseMsg      = null;
            ITransportHeaders responseHeaders  = null;
            Stream            responseStream   = null;
            WindowsIdentity   current          = null;
            IPrincipal        currentPrincipal = null;
            bool             flag     = false;
            bool             flag2    = false;
            ServerProcessing complete = ServerProcessing.Complete;

            try
            {
                if (this._secure)
                {
                    handler.Port.ImpersonateClient();
                    currentPrincipal = Thread.CurrentPrincipal;
                    flag2            = true;
                    flag             = true;
                    current          = WindowsIdentity.GetCurrent();
                    if (!this._impersonate)
                    {
                        NativePipe.RevertToSelf();
                        Thread.CurrentPrincipal = new GenericPrincipal(current, null);
                        flag = false;
                    }
                    else
                    {
                        if ((current.ImpersonationLevel != TokenImpersonationLevel.Impersonation) && (current.ImpersonationLevel != TokenImpersonationLevel.Delegation))
                        {
                            throw new RemotingException(CoreChannel.GetResourceString("Remoting_Ipc_TokenImpersonationFailure"));
                        }
                        Thread.CurrentPrincipal = new WindowsPrincipal(current);
                    }
                }
                complete = this._nextSink.ProcessMessage(sinkStack, null, requestHeaders, requestStream, out responseMsg, out responseHeaders, out responseStream);
            }
            catch (Exception exception)
            {
                handler.CloseOnFatalError(exception);
            }
            finally
            {
                if (flag2)
                {
                    Thread.CurrentPrincipal = currentPrincipal;
                }
                if (flag)
                {
                    NativePipe.RevertToSelf();
                    flag = false;
                }
            }
            switch (complete)
            {
            case ServerProcessing.Complete:
                sinkStack.Pop(this);
                handler.SendResponse(responseHeaders, responseStream);
                break;

            case ServerProcessing.OneWay:
                handler.SendResponse(responseHeaders, responseStream);
                break;

            case ServerProcessing.Async:
                sinkStack.StoreAndDispatch(this, handler);
                break;
            }
            if (complete != ServerProcessing.Async)
            {
                handler.BeginReadMessage();
            }
        }
        } // StopListening
 
        // 
        // end of IChannelReceiver implementation
        // 

        // Thread for listening
        void Listen()
        { 
            bool bOkToListen = true;
 
 
            InternalRemotingServices.RemotingTrace( "Waiting to Accept a Connection on Port: " + _portName);
 
            //
            // Wait for an incoming client connection
            //
            IntPtr handle = IntPtr.Zero; 

            bool connected = false; 
            CommonSecurityDescriptor descriptor = _securityDescriptor; 

            // Connect with exlusive flag the first time 
            if (bOkToListen)
            {
                try{
                    // If the descriptor is not explicitly set through code use the _authorizedGroup config 
                    if (descriptor == null && _authorizedGroup != null)
                    { 
                        NTAccount ntAccount = new NTAccount(_authorizedGroup); 
                        descriptor = IpcPort.CreateSecurityDescriptor((SecurityIdentifier)ntAccount.Translate(typeof(SecurityIdentifier)));
                    } 

                    _port = IpcPort.Create(_portName, descriptor, _bExclusiveAddressUse);
                }
                catch (Exception e) { 
                    _startListeningException = e;
                } 
                finally { 
                    _waitForStartListening.Set(); // allow main thread to continue now that we have tried to start the socket
                } 
                if (_port != null){
                    connected = _port.WaitForConnect();
                    bOkToListen = _bListening;
                } 
            }
 
            while (bOkToListen && _startListeningException == null) 
            {
                InternalRemotingServices.RemotingTrace("IpcChannel::Listen"); 

                // For DevDiv#220882, we need to create new IpcPort before handling the current message
                // to avoid race condition in case the message is handled and finished before
                // the new IpcPort is created.  The client will intermittently fail with Port not found. 
                IpcPort port = IpcPort.Create(_portName, descriptor, false);
 
                if (connected) 
                {
                    // Initialize the server handler and perform an async read 
                    IpcServerHandler serverHandler = new IpcServerHandler(_port, CoreChannel.RequestQueue, new PipeStream(_port));
                    serverHandler.DataArrivedCallback = new WaitCallback(_transportSink.ServiceRequest);
                    serverHandler.BeginReadMessage();
                } 
                _port = port;
                connected = _port.WaitForConnect(); 
                bOkToListen = _bListening; 
            }
       } 
Ejemplo n.º 5
0
        internal void ServiceRequest(Object state)
        {
            IpcServerHandler ipcServerHandler = (IpcServerHandler)state;

            // Read the headers from the stream, using the header size in the message
            ITransportHeaders headers = ipcServerHandler.ReadHeaders();

            // Get the request Stream
            Stream requestStream = ipcServerHandler.GetRequestStream();

            // customErrors should be disabled, since we are on the same machine
            headers["__CustomErrorsEnabled"] = false;

            // process request
            ServerChannelSinkStack sinkStack = new ServerChannelSinkStack();

            sinkStack.Push(this, ipcServerHandler);

            IMessage          responseMessage = null;
            ITransportHeaders responseHeaders = null;
            Stream            responseStream  = null;
            WindowsIdentity   identity        = null;
            IPrincipal        oldPrincipal    = null;
            bool             impersonated     = false;
            bool             principalChanged = false;
            ServerProcessing processing       = ServerProcessing.Complete;

            try{
                if (_secure)
                {
                    IpcPort port = ipcServerHandler.Port;
                    port.ImpersonateClient();
                    oldPrincipal     = Thread.CurrentPrincipal;
                    principalChanged = true;
                    impersonated     = true;
                    identity         = WindowsIdentity.GetCurrent();
                    // If the authentication mode is to identify callers only revert the impersonation immediately
                    if (!_impersonate)
                    {
                        NativePipe.RevertToSelf();
                        Thread.CurrentPrincipal = new GenericPrincipal(identity, null);
                        impersonated            = false;
                    }
                    else
                    {
                        if (identity.ImpersonationLevel == TokenImpersonationLevel.Impersonation ||
                            identity.ImpersonationLevel == TokenImpersonationLevel.Delegation)
                        {
                            // Set the current principal
                            Thread.CurrentPrincipal = new WindowsPrincipal(identity);
                        }
                        else
                        {
                            throw new RemotingException(CoreChannel.GetResourceString(
                                                            "Remoting_Ipc_TokenImpersonationFailure"));
                        }
                    }
                }

                processing =
                    _nextSink.ProcessMessage(sinkStack, null, headers, requestStream,
                                             out responseMessage,
                                             out responseHeaders, out responseStream);
            }
            catch (Exception e) {
                ipcServerHandler.CloseOnFatalError(e);
            }
            finally{
                // Revert the principal if we had changed the principal
                if (principalChanged)
                {
                    Thread.CurrentPrincipal = oldPrincipal;
                }
                // Revert the impersonation if we had impersonated
                if (impersonated)
                {
                    NativePipe.RevertToSelf();
                    impersonated = false;
                }
            }

            // handle response
            switch (processing)
            {
            case ServerProcessing.Complete:
            {
                // Send the response. Call completed synchronously.
                sinkStack.Pop(this);
                // Send the response back to the client
                ipcServerHandler.SendResponse(responseHeaders, responseStream);
                break;
            } // case ServerProcessing.Complete

            case ServerProcessing.OneWay:
            {
                // No response needed, but the following method will make sure that
                //   we send at least a skeleton reply if the incoming request was
                //   not marked OneWayRequest (client/server metadata could be out of
                //   [....]).
                ipcServerHandler.SendResponse(responseHeaders, responseStream);
                break;
            } // case ServerProcessing.OneWay

            case ServerProcessing.Async:
            {
                sinkStack.StoreAndDispatch(this, ipcServerHandler);
                break;
            } // case ServerProcessing.Async
            } // switch (processing)

            // Start waiting for the next request
            if (processing != ServerProcessing.Async)
            {
                ipcServerHandler.BeginReadMessage();
            }
        } // ServiceRequest