mcs/class/corlib/System.Runtime.Remoting.Channels/CrossAppDomainChannel.cs

   1 //
   2 // System.Runtime.Remoting.Channels.CrossAppDomainChannel.cs
   3 //
   4 // Author: Patrik Torstensson (totte_mono@yahoo.com)
   5 //         Lluis Sanchez Gual (lluis@ximian.com)
   6 //
   7 // 2003 (C) Copyright, Ximian, Inc.
   8 //
   9
  10 //
  11 // Copyright (C) 2004 Novell, Inc (http://www.novell.com)
  12 //
  13 // Permission is hereby granted, free of charge, to any person obtaining
  14 // a copy of this software and associated documentation files (the
  15 // "Software"), to deal in the Software without restriction, including
  16 // without limitation the rights to use, copy, modify, merge, publish,
  17 // distribute, sublicense, and/or sell copies of the Software, and to
  18 // permit persons to whom the Software is furnished to do so, subject to
  19 // the following conditions:
  20 //
  21 // The above copyright notice and this permission notice shall be
  22 // included in all copies or substantial portions of the Software.
  23 //
  24 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  25 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  26 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  27 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  28 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  29 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  30 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  31 //
  32
  33 using System.Collections;
  34 using System.IO;
  35 using System.Threading;
  36 using System.Runtime.Remoting;
  37 using System.Runtime.Remoting.Messaging;
  38 using System.Runtime.Remoting.Channels;
  39 using System.Runtime.Remoting.Contexts;
  40 using System.Runtime.Serialization;
  41 using System.Runtime.Serialization.Formatters.Binary;
  42 using System.Reflection;
  43
  44 namespace System.Runtime.Remoting.Channels
  45 {
  46
  47         // Holds the cross appdomain channel data (used to get/create the correct sink)
  48         [Serializable]
  49         internal class CrossAppDomainData
  50         {
  51                 // TODO: Add context support
  52                 private int _ContextID;
  53                 private int _DomainID;
  54                 private string _processGuid;
  55
  56                 internal CrossAppDomainData(int domainId)
  57                 {
  58                         _DomainID = domainId;
  59                         _processGuid = RemotingConfiguration.ProcessId;
  60                 }
  61
  62                 internal int DomainID
  63                 {
  64                         get { return _DomainID; }
  65                 }
  66
  67                 internal string ProcessID
  68                 {
  69                         get { return _processGuid; }
  70                 }
  71         }
  72
  73         // Responsible for marshalling objects between appdomains
  74         [Serializable]
  75         internal class CrossAppDomainChannel : IChannel, IChannelSender, IChannelReceiver
  76         {
  77                 private const String _strName = "MONOCAD";
  78                 private const String _strBaseURI = "MONOCADURI";
  79
  80                 private static Object s_lock = new Object();
  81
  82                 internal static void RegisterCrossAppDomainChannel()
  83                 {
  84                         lock (s_lock)
  85                         {
  86                                 // todo: make singleton
  87                                 CrossAppDomainChannel monocad = new CrossAppDomainChannel();
  88                                 ChannelServices.RegisterChannel ((IChannel) monocad);
  89                         }
  90                 }
  91
  92                 // IChannel implementation
  93                 public virtual String ChannelName
  94                 {
  95                         get { return _strName; }
  96                 }
  97
  98                 public virtual int ChannelPriority
  99                 {
 100                         get { return 100; }
 101                 }
 102
 103                 public String Parse(String url, out String objectURI)
 104                 {
 105                         objectURI = url;
 106                         return null;
 107                 }
 108
 109                 // IChannelReceiver
 110                 public virtual Object ChannelData
 111                 {
 112                         get { return new CrossAppDomainData(Thread.GetDomainID()); }
 113                 }
 114
 115                 public virtual String[] GetUrlsForUri(String objectURI)
 116                 {
 117                         throw new NotSupportedException("CrossAppdomain channel dont support UrlsForUri");
 118                 }
 119
 120                 // Dummies
 121                 public virtual void StartListening(Object data) {}
 122                 public virtual void StopListening(Object data) {}
 123
 124                 // IChannelSender
 125                 public virtual IMessageSink CreateMessageSink(String url, Object data, out String uri)
 126                 {
 127                         uri = null;
 128
 129                         if (data != null)
 130                         {
 131                                 // Get the data and then get the sink
 132                                 CrossAppDomainData cadData = data as CrossAppDomainData;
 133                                 if (cadData != null && cadData.ProcessID == RemotingConfiguration.ProcessId)
 134                                         // GetSink creates a new sink if we don't have any (use contexts here later)
 135                                         return CrossAppDomainSink.GetSink(cadData.DomainID);
 136                         }
 137                         if (url != null && url.StartsWith(_strName))
 138                                 throw new NotSupportedException("Can't create a named channel via crossappdomain");
 139
 140                         return null;
 141                 }
 142         }
 143
 144         [MonoTODO("Handle domain unloading?")]
 145         internal class CrossAppDomainSink : IMessageSink
 146         {
 147                 private static Hashtable s_sinks = new Hashtable();
 148
 149                 private static MethodInfo processMessageMethod =
 150                         typeof (CrossAppDomainSink).GetMethod ("ProcessMessageInDomain", BindingFlags.NonPublic|BindingFlags.Static);
 151
 152
 153                 private int _domainID;
 154
 155                 internal CrossAppDomainSink(int domainID)
 156                 {
 157                         _domainID = domainID;
 158                 }
 159
 160                 internal static CrossAppDomainSink GetSink(int domainID)
 161                 {
 162                         // Check if we have a sink for the current domainID
 163                         // note, locking is not to bad here, very few class to GetSink
 164                         lock (s_sinks.SyncRoot)
 165                         {
 166                                 if (s_sinks.ContainsKey(domainID))
 167                                         return (CrossAppDomainSink) s_sinks[domainID];
 168                                 else
 169                                 {
 170                                         CrossAppDomainSink sink = new CrossAppDomainSink(domainID);
 171                                         s_sinks[domainID] = sink;
 172
 173                                         return sink;
 174                                 }
 175                         }
 176                 }
 177
 178                 private struct ProcessMessageRes {
 179                         public byte[] arrResponse;
 180                         public CADMethodReturnMessage cadMrm;
 181                 }
 182
 183                 private static ProcessMessageRes ProcessMessageInDomain (
 184                         byte[] arrRequest,
 185                         CADMethodCallMessage cadMsg)
 186             {
 187                         ProcessMessageRes res = new ProcessMessageRes ();
 188
 189                         try
 190                         {
 191                                 AppDomain.CurrentDomain.ProcessMessageInDomain (arrRequest, cadMsg, out res.arrResponse, out res.cadMrm);
 192                         }
 193                         catch (Exception e)
 194                         {
 195                                 IMessage errorMsg = new MethodResponse (e, new ErrorMessage());
 196                                 res.arrResponse = CADSerializer.SerializeMessage (errorMsg).GetBuffer();
 197                         }
 198                         return res;
 199                 }
 200
 201                 public virtual IMessage SyncProcessMessage(IMessage msgRequest)
 202                 {
 203                         IMessage retMessage = null;
 204
 205                         try
 206                         {
 207                                 // Time to transit into the "our" domain
 208                                 byte [] arrResponse = null;
 209                                 byte [] arrRequest = null;
 210
 211                                 CADMethodReturnMessage cadMrm = null;
 212                                 CADMethodCallMessage cadMsg;
 213
 214                                 cadMsg = CADMethodCallMessage.Create (msgRequest);
 215                                 if (null == cadMsg) {
 216                                         // Serialize the request message
 217                                         MemoryStream reqMsgStream = CADSerializer.SerializeMessage(msgRequest);
 218                                         arrRequest = reqMsgStream.GetBuffer();
 219                                 }
 220
 221                                 object threadStatus = Thread.ResetDataStoreStatus ();
 222                                 Context currentContext = Thread.CurrentContext;
 223
 224                                 try {
 225                                         // InternalInvoke can't handle out arguments, this is why
 226                                         // we return the results in a structure
 227                                         ProcessMessageRes res = (ProcessMessageRes)AppDomain.InvokeInDomainByID (_domainID, processMessageMethod, null, new object [] { arrRequest, cadMsg });
 228                                         arrResponse = res.arrResponse;
 229                                         cadMrm = res.cadMrm;
 230                                 }
 231                                 finally {
 232                                         AppDomain.InternalSetContext (currentContext);
 233                                         Thread.RestoreDataStoreStatus (threadStatus);
 234                                 }
 235
 236
 237                                 if (null != arrResponse) {
 238                                         // Time to deserialize the message
 239                                         MemoryStream respMsgStream = new MemoryStream(arrResponse);
 240
 241                                         // Deserialize the response message
 242                                         retMessage = CADSerializer.DeserializeMessage(respMsgStream, msgRequest as IMethodCallMessage);
 243                                 } else
 244                                         retMessage = new MethodResponse (msgRequest as IMethodCallMessage, cadMrm);
 245                         }
 246                         catch (Exception e)
 247                         {
 248                                 try
 249                                 {
 250                                         retMessage = new ReturnMessage (e, msgRequest as IMethodCallMessage);
 251                                 }
 252                                 catch (Exception)
 253                                 {
 254                                         // this is just to be sure
 255                                 }
 256                         }
 257
 258                 return retMessage;
 259                 }
 260
 261                 public virtual IMessageCtrl AsyncProcessMessage (IMessage reqMsg, IMessageSink replySink)
 262                 {
 263                         AsyncRequest req = new AsyncRequest (reqMsg, replySink);
 264                         ThreadPool.QueueUserWorkItem (new WaitCallback (SendAsyncMessage), req);
 265                         return null;
 266                 }
 267
 268                 public void SendAsyncMessage (object data)
 269                 {
 270                         AsyncRequest req = (AsyncRequest)data;
 271                         IMessage response = SyncProcessMessage (req.MsgRequest);
 272                         req.ReplySink.SyncProcessMessage (response);
 273                 }
 274
 275                 public IMessageSink NextSink { get { return null; } }
 276         }
 277
 278         internal class CADSerializer
 279         {
 280                 internal static IMessage DeserializeMessage(MemoryStream mem, IMethodCallMessage msg)
 281                 {
 282                         BinaryFormatter serializer = new BinaryFormatter();
 283
 284                         serializer.SurrogateSelector = null;
 285                         mem.Position = 0;
 286
 287                         if (msg == null)
 288                                 return (IMessage) serializer.Deserialize(mem, null);
 289                         else
 290                                 return (IMessage) serializer.DeserializeMethodResponse(mem, null, msg);
 291                 }
 292
 293                 internal static MemoryStream SerializeMessage(IMessage msg)
 294                 {
 295                         MemoryStream mem = new MemoryStream ();
 296                         BinaryFormatter serializer = new BinaryFormatter ();
 297
 298                         serializer.SurrogateSelector = new RemotingSurrogateSelector ();
 299                         serializer.Serialize (mem, msg);
 300
 301                         mem.Position = 0;
 302
 303                         return mem;
 304                 }
 305
 306                 internal static MemoryStream SerializeObject(object obj)
 307                 {
 308                         MemoryStream mem = new MemoryStream ();
 309                         BinaryFormatter serializer = new BinaryFormatter ();
 310
 311                         serializer.SurrogateSelector = new RemotingSurrogateSelector ();
 312                         serializer.Serialize (mem, obj);
 313
 314                         mem.Position = 0;
 315
 316                         return mem;
 317                 }
 318
 319                 internal static object DeserializeObject(MemoryStream mem)
 320                 {
 321                         BinaryFormatter serializer = new BinaryFormatter();
 322
 323                         serializer.SurrogateSelector = null;
 324                         mem.Position = 0;
 325
 326                         return serializer.Deserialize (mem);
 327                 }
 328         }
 329
 330         internal class AsyncRequest
 331         {
 332                 internal IMessageSink ReplySink;
 333                 internal IMessage MsgRequest;
 334
 335                 public AsyncRequest (IMessage msgRequest, IMessageSink replySink)
 336                 {
 337                         ReplySink = replySink;
 338                         MsgRequest = msgRequest;
 339                 }
 340         }
 341
 342 }