class/System.Runtime.Remoting/System.Runtime.Remoting.Channels.Simple/SimpleServerTransportSink.cs

   1 //
   2 // System.Runtime.Remoting.Channels.Simple.SimpleServerTransportSink.cs
   3 //
   4 // Author: Dietmar Maurer (dietmar@ximian.com)
   5 //
   6 // 2002 (C) Copyright, Ximian, Inc.
   7 //
   8
   9 //
  10 // Permission is hereby granted, free of charge, to any person obtaining
  11 // a copy of this software and associated documentation files (the
  12 // "Software"), to deal in the Software without restriction, including
  13 // without limitation the rights to use, copy, modify, merge, publish,
  14 // distribute, sublicense, and/or sell copies of the Software, and to
  15 // permit persons to whom the Software is furnished to do so, subject to
  16 // the following conditions:
  17 //
  18 // The above copyright notice and this permission notice shall be
  19 // included in all copies or substantial portions of the Software.
  20 //
  21 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  22 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  23 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  24 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  25 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  26 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  27 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  28 //
  29
  30 using System.Collections;
  31 using System.Runtime.Remoting.Messaging;
  32 using System.Text.RegularExpressions;
  33 using System.Net.Sockets;
  34 using System.Net;
  35 using System.Threading;
  36 using System.IO;
  37
  38 namespace System.Runtime.Remoting.Channels.Simple
  39 {
  40         internal class SimpleServerTransportSink : IServerChannelSink, IChannelSinkBase
  41         {
  42                 IServerChannelSink next_sink;
  43
  44                 public SimpleServerTransportSink (IServerChannelSink next)
  45                 {
  46                         next_sink = next;
  47                 }
  48
  49                 public IServerChannelSink NextChannelSink {
  50                         get {
  51                                 return next_sink;
  52                         }
  53                 }
  54
  55                 [MonoTODO]
  56                 public IDictionary Properties {
  57                         get {
  58                                 throw new NotImplementedException ();
  59                         }
  60                 }
  61
  62                 [MonoTODO]
  63                 public void AsyncProcessResponse (IServerResponseChannelSinkStack sinkStack, object state,
  64                                                   IMessage msg, ITransportHeaders headers, Stream stream)
  65                 {
  66                         throw new NotImplementedException ();
  67                 }
  68
  69                 [MonoTODO]
  70                 public Stream GetResponseStream (IServerResponseChannelSinkStack sinkStack, object state,
  71                                                 IMessage msg, ITransportHeaders headers)
  72                 {
  73                         throw new NotImplementedException ();
  74                 }
  75
  76                 public ServerProcessing ProcessMessage (IServerChannelSinkStack sinkStack,
  77                                                         IMessage requestMsg,
  78                                                         ITransportHeaders requestHeaders,
  79                                                         Stream requestStream,
  80                                                         out IMessage responseMsg,
  81                                                         out ITransportHeaders responseHeaders,
  82                                                         out Stream responseStream)
  83                 {
  84                         // this is the first sink, and SimpleServerChannel does not call it.
  85                         throw new NotSupportedException ();
  86                 }
  87
  88                 internal void InternalProcessMessage (Stream network_stream)
  89                 {
  90                         try {
  91                                 string uri;
  92                                 SimpleMessageFormat.MessageType msg_type;
  93                                 MemoryStream msg_stream;
  94
  95                                 msg_stream = SimpleMessageFormat.ReceiveMessageStream (network_stream,
  96                                                                                        out msg_type, out uri);
  97                                 if (msg_type != SimpleMessageFormat.MessageType.Request)
  98                                         throw new RemotingException ("received wrong message type");
  99
 100                                 TransportHeaders headers = new TransportHeaders ();
 101                                 headers ["_requestUri"] = uri;
 102
 103                                 IMessage resp_message;
 104                                 ITransportHeaders resp_headers;
 105                                 Stream resp_stream;
 106                                 ServerProcessing res = next_sink.ProcessMessage (null, null, headers, msg_stream,
 107                                                                                  out resp_message, out resp_headers,
 108                                                                                  out resp_stream);
 109
 110                                 switch (res) {
 111                                 case ServerProcessing.Complete:
 112
 113                                         Exception e = ((IMethodReturnMessage)resp_message).Exception;
 114                                         if (e != null) {
 115                                                 // we handle exceptions in the transport channel
 116                                                 SimpleMessageFormat.SendExceptionMessage (network_stream, e.ToString ());
 117                                         } else {
 118                                                 // send the response
 119                                                 SimpleMessageFormat.SendMessageStream (network_stream,
 120                                                                                        (MemoryStream)resp_stream,
 121                                                                                        SimpleMessageFormat.MessageType.Response,
 122                                                                                        null);
 123                                         }
 124                                         break;
 125                                 case ServerProcessing.Async:
 126                                 case ServerProcessing.OneWay:
 127                                         throw new NotImplementedException ();
 128                                 }
 129
 130                         } catch (Exception e) {
 131                                 SimpleMessageFormat.SendExceptionMessage (network_stream, e.ToString ());
 132                         }
 133                 }
 134         }
 135 }