mono/mcs/class/System.Runtime.Remoting/System.Runtime.Remoting.Channels.Ipc.Win32/IpcClientChannel.cs

//
// System.Runtime.Remoting.Channels.Ipc.Win32.IpcClientChannel.cs
//
// Author: Robert Jordan ([email protected])
//
// Copyright (C) 2005 Novell, Inc (http://www.novell.com)
//
//
// Permission is hereby granted, free of charge, to any person obtaining
// a copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to
// permit persons to whom the Software is furnished to do so, subject to
// the following conditions:
// 
// The above copyright notice and this permission notice shall be
// included in all copies or substantial portions of the Software.
// 
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
//

#if NET_2_0

using System;
using System.Collections;
using System.IO;
using System.Runtime.Remoting;
using System.Runtime.Remoting.Channels;
using System.Runtime.Remoting.Messaging;

namespace System.Runtime.Remoting.Channels.Ipc.Win32
{
    internal class IpcClientChannel : IChannelSender, IChannel
    {
        readonly string channelName = IpcChannelHelper.Scheme;
        readonly int channelPriority = 1;
        readonly IClientChannelSinkProvider clientProvider;

        /// <summary>
        /// Creates a default client channel.
        /// </summary>
        public IpcClientChannel()
            : this ((IDictionary)null, null)
        {
        }

        /// <summary>
        /// Creates a default client channel.
        /// </summary>
        /// <param name="name">The channel name.</param>
        /// <param name="sinkProvider">The provider</param>
        public IpcClientChannel(string name, IClientChannelSinkProvider provider)
            : this (IpcServerChannel.BuildDefaultProperties (name), provider)
        {
        }

        /// <summary>
        /// Creates a client channel.
        /// </summary>
        /// <param name="properties">The properties.</param>
        /// <param name="sinkProvider">The provider</param>
        public IpcClientChannel(IDictionary properties, IClientChannelSinkProvider provider)
        {
            if (properties != null) 
            {
                foreach (DictionaryEntry e in properties) 
                {
                    switch ((string)e.Key) 
                    {
                        case "name":
                            channelName = (string)e.Value;
                            break;
                        case "priority":
                            channelPriority = Convert.ToInt32(e.Value);
                            break;
                    }
                }
            }

            if (provider == null) 
            {
                clientProvider = new BinaryClientFormatterSinkProvider();
                clientProvider.Next = new IpcClientChannelSinkProvider();
            }
            else 
            {
                // add us to the sink chain.
                clientProvider = provider;
                IClientChannelSinkProvider p;
                for (p = clientProvider; p.Next != null; p = p.Next) {}
                p.Next = new IpcClientChannelSinkProvider();
            }
                                        
        }

        #region IChannelSender Members

        public IMessageSink CreateMessageSink(string url, object remoteChannelData, out string objectURI)
        {
            objectURI = null;
            string channelUri = null;

            if (url != null) 
            {
                channelUri = Parse(url, out objectURI);
            }

            if (channelUri == null) 
            {
                // get url from the channel data
                IChannelDataStore ds = remoteChannelData as IChannelDataStore;
                if (ds != null) 
                {
                    channelUri = Parse(ds.ChannelUris[0], out objectURI);
                    if (channelUri != null)
                        url = ds.ChannelUris[0];
                }
            }

            if (channelUri != null) 
            {
                return (IMessageSink) clientProvider.CreateSink(this, url, remoteChannelData);
            }
            else 
            {
                return null;
            }
        }

        #endregion

        #region IChannel Members

        public string ChannelName
        {
            get
            {
                return channelName;
            }
        }

        public int ChannelPriority
        {
            get
            {
                return channelPriority;
            }
        }

        public string Parse(string url, out string objectURI)
        {
            return IpcChannelHelper.Parse(url, out objectURI);
        }

        #endregion
    }

    internal class IpcClientChannelSinkProvider : IClientChannelSinkProvider
    {
        #region IClientChannelSinkProvider Members

        public IClientChannelSink CreateSink(IChannelSender channel, string url, object remoteChannelData)
        {
            return new IpcClientChannelSink(url);
        }

        public IClientChannelSinkProvider Next
        {
            get
            {
                return null;
            }
            set
            {
                throw new NotSupportedException();
            }
        }

        #endregion
    }

    internal class IpcClientChannelSink : IClientChannelSink
    {
        readonly string pipeName;

        public IpcClientChannelSink(string url) 
        {
            string unused;
            IpcChannelHelper.Parse(url, out pipeName, out unused);
        }

        #region IClientChannelSink Members

        delegate void AsyncResponse(IClientChannelSinkStack sinkStack, IpcTransport transport);

        public void AsyncProcessRequest(IClientChannelSinkStack sinkStack, IMessage msg, ITransportHeaders headers, Stream stream)
        {
            headers[CommonTransportKeys.RequestUri] = ((IMethodCallMessage)msg).Uri;

            // connect
            NamedPipeClient client = new NamedPipeClient(pipeName);
            NamedPipeSocket socket = client.Connect();
            IpcTransport t = new IpcTransport(socket);
            t.Write(headers, stream);

            // schedule an async call
            if (!RemotingServices.IsOneWay(((IMethodCallMessage)msg).MethodBase)) 
            {
                new AsyncResponse(AsyncHandler).BeginInvoke(sinkStack, t, null, null);
            }
        }

        void AsyncHandler(IClientChannelSinkStack sinkStack, IpcTransport transport) 
        {
            try 
            {
                // get the response headers and the response stream from the server
                ITransportHeaders responseHeaders;
                Stream responseStream;
                transport.Read(out responseHeaders, out responseStream);
                transport.Close();
                sinkStack.AsyncProcessResponse(responseHeaders, responseStream);
            }
            catch (Exception ex) 
            {
                sinkStack.DispatchException(ex);
            }
        }

        public void ProcessMessage(IMessage msg, ITransportHeaders requestHeaders, Stream requestStream, out ITransportHeaders responseHeaders, out Stream responseStream)
        {
            responseHeaders = null;
            responseStream = null;

            requestHeaders[CommonTransportKeys.RequestUri] = ((IMethodCallMessage)msg).Uri;

            // connect
            NamedPipeClient client = new NamedPipeClient(pipeName);
            NamedPipeSocket socket = client.Connect();
            IpcTransport t = new IpcTransport(socket);
            t.Write(requestHeaders, requestStream);
            t.Read(out responseHeaders, out responseStream);
            t.Close();
        }

        public void AsyncProcessResponse(IClientResponseChannelSinkStack sinkStack, object state, ITransportHeaders headers, Stream stream)
        {
            throw new NotSupportedException();
        }

        public Stream GetRequestStream(IMessage msg, ITransportHeaders headers)
        {
            return null;
        }

        public IClientChannelSink NextChannelSink
        {
            get { return null; }
        }

        #endregion

        #region IChannelSinkBase Members

        public IDictionary Properties
        {
            get { return null; }
        }

        #endregion

    }

}

#endif