mcs/class/referencesource/mscorlib/system/runtime/remoting/crossappdomainchannel.cs

   1 // ==++==
   2 //
   3 //   Copyright (c) Microsoft Corporation.  All rights reserved.
   4 //
   5 // ==--==
   6 //
   7 // Remoting Infrastructure Sink for making calls across context
   8 // boundaries.
   9 //
  10 namespace System.Runtime.Remoting.Channels {
  11     using System;
  12     using System.Collections;
  13     using System.IO;
  14     using System.Runtime.InteropServices;
  15     using System.Runtime.Remoting;
  16     using System.Runtime.Remoting.Messaging;
  17     using System.Runtime.Remoting.Contexts;
  18     using System.Runtime.Serialization;
  19     using System.Runtime.Serialization.Formatters.Binary;
  20     using System.Security;
  21     using System.Security.Permissions;
  22     using System.Security.Policy;
  23     using System.Security.Principal;
  24     using System.Text;
  25     using System.Threading;
  26     using System.Runtime.ConstrainedExecution;
  27
  28
  29
  30     [Serializable]
  31     internal class CrossAppDomainChannel : IChannel, IChannelSender, IChannelReceiver
  32     {
  33         private const String _channelName = "XAPPDMN";
  34         private const String _channelURI = "XAPPDMN_URI";
  35
  36
  37         private static CrossAppDomainChannel gAppDomainChannel
  38         {
  39             get { return Thread.GetDomain().RemotingData.ChannelServicesData.xadmessageSink; }
  40             set { Thread.GetDomain().RemotingData.ChannelServicesData.xadmessageSink = value; }
  41         }
  42         private static Object staticSyncObject = new Object();
  43         private static PermissionSet s_fullTrust = new PermissionSet(PermissionState.Unrestricted);
  44
  45         internal static CrossAppDomainChannel AppDomainChannel
  46         {
  47             get
  48             {
  49                 if (gAppDomainChannel == null)
  50                 {
  51                     CrossAppDomainChannel tmpChnl = new CrossAppDomainChannel();
  52
  53                     lock (staticSyncObject)
  54                     {
  55                         if (gAppDomainChannel == null)
  56                         {
  57                             gAppDomainChannel = tmpChnl;
  58                         }
  59                     }
  60                 }
  61                 return gAppDomainChannel;
  62
  63             }
  64         }
  65
  66         [System.Security.SecurityCritical]  // auto-generated
  67         internal static void RegisterChannel()
  68         {
  69             CrossAppDomainChannel adc = CrossAppDomainChannel.AppDomainChannel;
  70             ChannelServices.RegisterChannelInternal((IChannel)adc, false /*ensureSecurity*/);
  71         }
  72
  73         //
  74         // IChannel Methods
  75         //
  76         public virtual String ChannelName
  77         {
  78             [System.Security.SecurityCritical]  // auto-generated
  79             get{ return _channelName; }
  80         }
  81
  82         public virtual String ChannelURI
  83         {
  84             get{ return _channelURI; }
  85         }
  86
  87         public virtual int ChannelPriority
  88         {
  89             [System.Security.SecurityCritical]  // auto-generated
  90             get{ return 100;}
  91         }
  92
  93         [System.Security.SecurityCritical]  // auto-generated
  94         public String Parse(String url, out String objectURI)
  95         {
  96             objectURI = url;
  97             return null;
  98         }
  99
 100         public virtual Object ChannelData
 101         {
 102             [System.Security.SecurityCritical]  // auto-generated
 103             get
 104             {
 105                 return new CrossAppDomainData(
 106                                     Context.DefaultContext.InternalContextID,
 107                                     Thread.GetDomain().GetId(),
 108                                     Identity.ProcessGuid);
 109             }
 110         }
 111
 112
 113         [System.Security.SecurityCritical]  // auto-generated
 114         public virtual IMessageSink CreateMessageSink(String url, Object data,
 115                                                       out String objectURI)
 116         {
 117             // Set the out parameters
 118             objectURI = null;
 119             IMessageSink sink = null;
 120
 121             // <
 122
 123
 124             if ((null != url) && (data == null))
 125             {
 126                 if(url.StartsWith(_channelName, StringComparison.Ordinal))
 127                 {
 128                     throw new RemotingException(
 129                         Environment.GetResourceString(
 130                             "Remoting_AppDomains_NYI"));
 131                 }
 132             }
 133             else
 134             {
 135                 Message.DebugOut("XAPPDOMAIN::Creating sink for data \n");
 136                 CrossAppDomainData xadData = data as CrossAppDomainData;
 137                 if (null != xadData)
 138                 {
 139                     if (xadData.ProcessGuid.Equals(Identity.ProcessGuid))
 140                     {
 141                         sink = CrossAppDomainSink.FindOrCreateSink(xadData);
 142                     }
 143                 }
 144             }
 145             return sink;
 146         }
 147
 148         [System.Security.SecurityCritical]  // auto-generated
 149         public virtual String[] GetUrlsForUri(String objectURI)
 150         {
 151             throw new NotSupportedException(
 152                 Environment.GetResourceString(
 153                     "NotSupported_Method"));
 154             //<
 155
 156
 157         }
 158
 159         [System.Security.SecurityCritical]  // auto-generated
 160         public virtual void StartListening(Object data)
 161         {
 162
 163         }
 164
 165         [System.Security.SecurityCritical]  // auto-generated
 166         public virtual void StopListening(Object data)
 167         {
 168
 169         }
 170     }
 171
 172     [Serializable]
 173     internal class CrossAppDomainData
 174     {
 175         Object _ContextID = 0;      // This is for backward compatibility
 176         int _DomainID;  // server appDomain ID
 177         String _processGuid;    // idGuid for the process (shared static)
 178
 179         internal virtual IntPtr ContextID {
 180             get {
 181 #if WIN32
 182                     return new IntPtr((int)_ContextID);
 183 #else
 184                     return new IntPtr((long)_ContextID);
 185 #endif
 186             }
 187         }
 188         internal virtual int DomainID {
 189             [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
 190             get {return _DomainID;}
 191         }
 192
 193         internal virtual String ProcessGuid { get {return _processGuid;}}
 194
 195         internal CrossAppDomainData(IntPtr ctxId, int domainID, String processGuid)
 196         {
 197             _DomainID = domainID;
 198             _processGuid = processGuid;
 199 #if WIN32
 200             _ContextID = ctxId.ToInt32();
 201 #else
 202             _ContextID = ctxId.ToInt64();  // This would have never worked anyway
 203 #endif
 204         }
 205
 206         internal bool IsFromThisProcess()
 207         {
 208             return Identity.ProcessGuid.Equals(_processGuid);
 209         }
 210
 211         [System.Security.SecurityCritical]  // auto-generated
 212         internal bool IsFromThisAppDomain()
 213         {
 214             return  IsFromThisProcess()
 215                     &&
 216                     (Thread.GetDomain().GetId() == _DomainID);
 217         }
 218     }
 219    //    Implements the Message Sink provided by the X-AppDomain channel.
 220    //    We try to use one instance of the sink to make calls to all remote
 221    //    objects in another AppDomain from one AppDomain.
 222
 223     internal class CrossAppDomainSink
 224         : InternalSink, IMessageSink
 225     {
 226         internal const int GROW_BY = 0x8;
 227         internal static volatile int[] _sinkKeys;
 228         internal static volatile CrossAppDomainSink[] _sinks;
 229
 230         internal const string LCC_DATA_KEY = "__xADCall";
 231
 232         private static Object staticSyncObject = new Object();
 233         private static InternalCrossContextDelegate s_xctxDel = new InternalCrossContextDelegate(DoTransitionDispatchCallback);
 234
 235         // each sink stores the default ContextID of the server side domain
 236         // and the domain ID for the domain
 237         internal CrossAppDomainData _xadData;
 238
 239         [System.Security.SecuritySafeCritical]  // auto-generated
 240         static CrossAppDomainSink()
 241         {
 242         }
 243
 244         internal CrossAppDomainSink(CrossAppDomainData xadData)
 245         {
 246             //
 247             // WARNING: xadData.ContextID may not be valid at this point.  Because
 248             //          CrossAppDomainData._ContextID is an IntPtr and IntPtrs are
 249             //          value types, the deserializer has to wait until the very
 250             //          end of deserialization to fixup value types.  However, when
 251             //          we unmarshal objects, we need to setup the x-AD sink and
 252             //          initialize it with this data.  Fortunately, that data won't
 253             //          be consumed until deserialization is complete, so we just
 254             //          need to take care not to read _ContextID in the constructor.
 255             //          The xadData object ref will be finalized by the time we need
 256             //          to consume its contents and everything should work properly.
 257             //
 258             _xadData = xadData;
 259         }
 260
 261         // Note: this should be called from within a synch-block
 262         internal static void GrowArrays(int oldSize)
 263         {
 264             if (_sinks == null)
 265             {
 266                 _sinks = new CrossAppDomainSink[GROW_BY];
 267                 _sinkKeys = new int[GROW_BY];
 268             }
 269             else
 270             {
 271                 CrossAppDomainSink[] tmpSinks = new CrossAppDomainSink[_sinks.Length + GROW_BY];
 272                 int[] tmpKeys = new int[_sinkKeys.Length + GROW_BY];
 273                 Array.Copy(_sinks, tmpSinks, _sinks.Length);
 274                 Array.Copy(_sinkKeys, tmpKeys, _sinkKeys.Length);
 275                 _sinks = tmpSinks;
 276                 _sinkKeys = tmpKeys;
 277             }
 278         }
 279         internal static CrossAppDomainSink FindOrCreateSink(CrossAppDomainData xadData)
 280         {
 281             //
 282             // WARNING: Do not read any value type member of xadData in this method!!
 283             //          xadData is not completely deserialized at this point.  See
 284             //          warning in CrossAppDomainSink::.ctor above
 285             //
 286             lock(staticSyncObject) {
 287                 // Note: keep this in sync with DomainUnloaded below
 288                 int key = xadData.DomainID;
 289                 if (_sinks == null)
 290                 {
 291                     GrowArrays(0);
 292                 }
 293                 int i=0;
 294                 while (_sinks[i] != null)
 295                 {
 296                     if (_sinkKeys[i] == key)
 297                     {
 298                         return _sinks[i];
 299                     }
 300                     i++;
 301                     if (i == _sinks.Length)
 302                     {
 303                         // could not find a sink, also need to Grow the array.
 304                         GrowArrays(i);
 305                         break;
 306                     }
 307                 }
 308                 // At this point we need to create a new sink and cache
 309                 // it at location "i"
 310                 _sinks[i] = new CrossAppDomainSink(xadData);
 311                 _sinkKeys[i] = key;
 312                 return _sinks[i];
 313             }
 314         }
 315
 316         internal static void DomainUnloaded(Int32 domainID)
 317         {
 318             int key = domainID;
 319             lock(staticSyncObject) {
 320                 if (_sinks == null)
 321                 {
 322                     return;
 323                 }
 324                 // Note: keep this in sync with FindOrCreateSink
 325                 int i = 0;
 326                 int remove = -1;
 327                 while (_sinks[i] != null)
 328                 {
 329                     if (_sinkKeys[i] == key)
 330                     {
 331                         BCLDebug.Assert(remove == -1, "multiple sinks?");
 332                         remove = i;
 333                     }
 334                     i++;
 335                     if (i == _sinks.Length)
 336                     {
 337                         break;
 338                     }
 339                 }
 340
 341                 if (remove ==-1) //hasn't been initialized yet
 342                     return;
 343
 344                 // The sink to remove is at index 'remove'
 345                 // We will move the last non-null entry to this location
 346
 347                 BCLDebug.Assert(remove != -1, "Bad domainId for unload?");
 348                 _sinkKeys[remove] = _sinkKeys[i-1];
 349                 _sinks[remove] = _sinks[i-1];
 350                 _sinkKeys[i-1] = 0;
 351                 _sinks[i-1] = null;
 352             }
 353
 354         }
 355
 356
 357         [System.Security.SecurityCritical]  // auto-generated
 358         internal static byte[] DoDispatch(byte[] reqStmBuff,
 359                                           SmuggledMethodCallMessage smuggledMcm,
 360                                           out SmuggledMethodReturnMessage smuggledMrm)
 361         {
 362             //*********************** DE-SERIALIZE REQ-MSG ********************
 363
 364             IMessage desReqMsg = null;
 365
 366             if (smuggledMcm != null)
 367             {
 368                 ArrayList deserializedArgs = smuggledMcm.FixupForNewAppDomain();
 369                 desReqMsg = new MethodCall(smuggledMcm, deserializedArgs);
 370             }
 371             else
 372             {
 373                 MemoryStream reqStm = new MemoryStream(reqStmBuff);
 374                 desReqMsg = CrossAppDomainSerializer.DeserializeMessage(reqStm);
 375             }
 376
 377             LogicalCallContext lcc = Thread.CurrentThread.GetMutableExecutionContext().LogicalCallContext;
 378             lcc.SetData(LCC_DATA_KEY, true);
 379             // now we can delegate to the DispatchMessage to do the rest
 380
 381             IMessage retMsg = ChannelServices.SyncDispatchMessage(desReqMsg);
 382             lcc.FreeNamedDataSlot(LCC_DATA_KEY);
 383
 384             smuggledMrm = SmuggledMethodReturnMessage.SmuggleIfPossible(retMsg);
 385             if (smuggledMrm != null)
 386             {
 387                 return null;
 388             }
 389             else
 390             {
 391                 if (retMsg != null)
 392                 {
 393                     // Null out the principal since we won't use it on the other side.
 394                     // This is handled inside of SmuggleIfPossible for method call
 395                     // messages.
 396                     LogicalCallContext callCtx = (LogicalCallContext)
 397                         retMsg.Properties[Message.CallContextKey];
 398                     if (callCtx != null)
 399                     {
 400                         if (callCtx.Principal != null)
 401                             callCtx.Principal = null;
 402                     }
 403
 404                     return CrossAppDomainSerializer.SerializeMessage(retMsg).GetBuffer();
 405                 }
 406
 407                 //*********************** SERIALIZE RET-MSG ********************
 408                 return null;
 409             }
 410         } // DoDispatch
 411
 412         [System.Security.SecurityCritical]  // auto-generated
 413         internal static Object DoTransitionDispatchCallback(Object[] args)
 414         {
 415             byte[]                       reqStmBuff     = (byte[])args[0];
 416             SmuggledMethodCallMessage    smuggledMcm    = (SmuggledMethodCallMessage)args[1];
 417             SmuggledMethodReturnMessage  smuggledMrm    = null;
 418             byte[]                       retBuff        = null;
 419
 420             try
 421             {
 422 #if !FEATURE_CORECLR
 423                 Message.DebugOut("#### : changed to Server Domain :: "+ (Thread.CurrentContext.InternalContextID).ToString("X") );
 424 #endif
 425                 retBuff = DoDispatch(reqStmBuff, smuggledMcm, out smuggledMrm);
 426             }
 427             catch (Exception e)
 428             {
 429                 // This will catch exceptions thrown by the infrastructure,
 430                 // Serialization/Deserialization etc
 431                 // Those thrown by the server are already taken care of
 432                 // and encoded in the retMsg .. so we don't come here for
 433                 // that case.
 434
 435                 // We are in another appDomain, so we can't simply throw
 436                 // the exception object across. The following marshals it
 437                 // into a serialized return message.
 438                 IMessage retMsg =
 439                     new ReturnMessage(e, new ErrorMessage());
 440                 //*********************** SERIALIZE RET-MSG ******************
 441                 retBuff = CrossAppDomainSerializer.SerializeMessage(retMsg).GetBuffer();
 442                 retMsg = null;
 443             }
 444
 445             args[2] = smuggledMrm;
 446
 447             return retBuff;
 448         }
 449
 450         [System.Security.SecurityCritical]  // auto-generated
 451         internal byte[] DoTransitionDispatch(
 452             byte[] reqStmBuff,
 453             SmuggledMethodCallMessage smuggledMcm,
 454             out SmuggledMethodReturnMessage smuggledMrm)
 455         {
 456             byte[] retBuff = null;
 457
 458             Object[] args = new Object[] { reqStmBuff, smuggledMcm, null };
 459
 460             retBuff = (byte[]) Thread.CurrentThread.InternalCrossContextCallback(null,
 461                                                               _xadData.ContextID,
 462                                                               _xadData.DomainID,
 463                                                               s_xctxDel,
 464                                                               args);
 465
 466 #if !FEATURE_CORECLR
 467             Message.DebugOut("#### : changed back to Client Domain " + (Thread.CurrentContext.InternalContextID).ToString("X"));
 468 #endif
 469
 470             smuggledMrm = (SmuggledMethodReturnMessage) args[2];
 471
 472             // System.Diagnostics.Debugger.Break();
 473             return retBuff;
 474         } // DoTransitionDispatch
 475
 476         [System.Security.SecurityCritical]  // auto-generated
 477         public virtual IMessage SyncProcessMessage(IMessage reqMsg)
 478         {
 479             Message.DebugOut("\n::::::::::::::::::::::::: CrossAppDomain Channel: Sync call starting");
 480             IMessage errMsg = InternalSink.ValidateMessage(reqMsg);
 481             if (errMsg != null)
 482             {
 483                 return errMsg;
 484             }
 485
 486
 487             // currentPrincipal is used to save the current principal. It should be
 488             //   restored on the reply message.
 489             IPrincipal currentPrincipal = null;
 490
 491
 492             IMessage desRetMsg = null;
 493
 494             try
 495             {
 496                 IMethodCallMessage mcmReqMsg = reqMsg as IMethodCallMessage;
 497                 if (mcmReqMsg != null)
 498                 {
 499                     LogicalCallContext lcc = mcmReqMsg.LogicalCallContext;
 500                     if (lcc != null)
 501                     {
 502                         // Special case Principal since if might not be serializable
 503                         currentPrincipal = lcc.RemovePrincipalIfNotSerializable();
 504                     }
 505                 }
 506
 507                 MemoryStream reqStm = null;
 508                 SmuggledMethodCallMessage smuggledMcm = SmuggledMethodCallMessage.SmuggleIfPossible(reqMsg);
 509
 510                 if (smuggledMcm == null)
 511                 {
 512
 513                     //*********************** SERIALIZE REQ-MSG ****************
 514                     // Deserialization of objects requires permissions that users
 515                     // of remoting are not guaranteed to possess. Since remoting
 516                     // can guarantee that it's users can't abuse deserialization
 517                     // (since it won't allow them to pass in raw blobs of
 518                     // serialized data), it should assert the permissions
 519                     // necessary before calling the deserialization code. This
 520                     // will terminate the security stackwalk caused when
 521                     // serialization checks for the correct permissions at the
 522                     // remoting stack frame so the check won't continue on to
 523                     // the user and fail. <EMAIL>[from Microsoft]</EMAIL>
 524                     // We will hold off from doing this for x-process channels
 525                     // until the big picture of distributed security is finalized.
 526
 527                     reqStm = CrossAppDomainSerializer.SerializeMessage(reqMsg);
 528                 }
 529
 530                 // Retrieve calling caller context here, where it is safe from the view
 531                 // of app domain checking code
 532                 LogicalCallContext oldCallCtx = CallContext.SetLogicalCallContext(null);
 533
 534                 // Call helper method here, to avoid confusion with stack frames & app domains
 535                 MemoryStream retStm = null;
 536                 byte[] responseBytes = null;
 537                 SmuggledMethodReturnMessage smuggledMrm;
 538
 539                 try
 540                 {
 541                     if (smuggledMcm != null)
 542                         responseBytes = DoTransitionDispatch(null, smuggledMcm, out smuggledMrm);
 543                     else
 544                         responseBytes = DoTransitionDispatch(reqStm.GetBuffer(), null, out smuggledMrm);
 545                 }
 546                 finally
 547                 {
 548                     CallContext.SetLogicalCallContext(oldCallCtx);
 549                 }
 550
 551                 if (smuggledMrm != null)
 552                 {
 553                     ArrayList deserializedArgs = smuggledMrm.FixupForNewAppDomain();
 554                     desRetMsg = new MethodResponse((IMethodCallMessage)reqMsg,
 555                                                    smuggledMrm,
 556                                                    deserializedArgs);
 557                 }
 558                 else
 559                 {
 560                     if (responseBytes != null) {
 561                         retStm = new MemoryStream(responseBytes);
 562
 563                         Message.DebugOut("::::::::::::::::::::::::::: CrossAppDomain Channel: Sync call returning!!\n");
 564                         //*********************** DESERIALIZE RET-MSG **************
 565                         desRetMsg = CrossAppDomainSerializer.DeserializeMessage(retStm, reqMsg as IMethodCallMessage);
 566                     }
 567                 }
 568             }
 569             catch(Exception e)
 570             {
 571                 Message.DebugOut("Arrgh.. XAppDomainSink::throwing exception " + e + "\n");
 572                 try
 573                 {
 574                     desRetMsg = new ReturnMessage(e, (reqMsg as IMethodCallMessage));
 575                 }
 576                 catch(Exception )
 577                 {
 578                     // Fatal Error .. can't do much here
 579                 }
 580             }
 581
 582             // restore the principal if necessary.
 583             if (currentPrincipal != null)
 584             {
 585                 IMethodReturnMessage mrmRetMsg = desRetMsg as IMethodReturnMessage;
 586                 if (mrmRetMsg != null)
 587                 {
 588                     LogicalCallContext lcc = mrmRetMsg.LogicalCallContext;
 589                     lcc.Principal = currentPrincipal;
 590                 }
 591             }
 592
 593             return desRetMsg;
 594         }
 595
 596         [System.Security.SecurityCritical]  // auto-generated
 597         public virtual IMessageCtrl AsyncProcessMessage(IMessage reqMsg, IMessageSink replySink)
 598         {
 599             // This is the case where we take care of returning the calling
 600             // thread asap by using the ThreadPool for completing the call.
 601
 602             // we use a more elaborate WorkItem and delegate the work to the thread pool
 603             ADAsyncWorkItem workItem = new ADAsyncWorkItem(reqMsg,
 604                                         (IMessageSink)this, /* nextSink */
 605                                         replySink);
 606
 607             WaitCallback threadFunc = new WaitCallback(workItem.FinishAsyncWork);
 608             ThreadPool.QueueUserWorkItem(threadFunc);
 609
 610             return null;
 611         }
 612
 613         public IMessageSink NextSink
 614         {
 615             [System.Security.SecurityCritical]  // auto-generated
 616             get
 617             {
 618                 // We are a terminating sink for this chain
 619                 return null;
 620             }
 621         }
 622
 623     }
 624
 625     /* package */
 626     internal class ADAsyncWorkItem
 627     {
 628         // the replySink passed in to us in AsyncProcessMsg
 629         private IMessageSink _replySink;
 630
 631         // the nextSink we have to call
 632         private IMessageSink _nextSink;
 633
 634         [System.Security.SecurityCritical] // auto-generated
 635         private LogicalCallContext _callCtx;
 636
 637         // the request msg passed in
 638         private IMessage _reqMsg;
 639
 640         [System.Security.SecurityCritical]  // auto-generated
 641         internal ADAsyncWorkItem(IMessage reqMsg, IMessageSink nextSink, IMessageSink replySink)
 642         {
 643             _reqMsg = reqMsg;
 644             _nextSink = nextSink;
 645             _replySink = replySink;
 646             _callCtx = Thread.CurrentThread.GetMutableExecutionContext().LogicalCallContext;
 647         }
 648
 649         /* package */
 650         [System.Security.SecurityCritical]  // auto-generated
 651         internal virtual void FinishAsyncWork(Object stateIgnored)
 652         {
 653             // install the call context that the calling thread actually had onto
 654             // the threadPool thread.
 655             LogicalCallContext threadPoolCallCtx = CallContext.SetLogicalCallContext(_callCtx);
 656
 657             IMessage retMsg = _nextSink.SyncProcessMessage(_reqMsg);
 658
 659             // send the reply back to the replySink we were provided with
 660             // note: replySink may be null for one-way calls.
 661             if (_replySink != null)
 662             {
 663                 _replySink.SyncProcessMessage(retMsg);
 664             }
 665             CallContext.SetLogicalCallContext(threadPoolCallCtx);
 666         }
 667     }
 668
 669
 670     internal static class CrossAppDomainSerializer
 671     {
 672         [System.Security.SecurityCritical]  // auto-generated
 673         internal static MemoryStream SerializeMessage(IMessage msg)
 674         {
 675             MemoryStream stm = new MemoryStream();
 676             RemotingSurrogateSelector ss = new RemotingSurrogateSelector();
 677             BinaryFormatter fmt = new BinaryFormatter();
 678             fmt.SurrogateSelector = ss;
 679             fmt.Context = new StreamingContext(StreamingContextStates.CrossAppDomain);
 680             fmt.Serialize(stm, msg, null, false /* No Security check */);
 681
 682             // Reset the stream so that Deserialize happens correctly
 683             stm.Position = 0;
 684
 685             return stm;
 686         }
 687
 688 #if false
 689         // called from MessageSmuggler classes
 690         internal static MemoryStream SerializeMessageParts(ArrayList argsToSerialize, out Object[] smuggledArgs)
 691         {
 692             MemoryStream stm = new MemoryStream();
 693
 694             BinaryFormatter fmt = new BinaryFormatter();
 695             RemotingSurrogateSelector ss = new RemotingSurrogateSelector();
 696             fmt.SurrogateSelector = ss;
 697             fmt.Context = new StreamingContext(StreamingContextStates.CrossAppDomain);
 698             fmt.Serialize(stm, argsToSerialize, null, false ); // No Security check
 699
 700             smuggledArgs = fmt.CrossAppDomainArray;
 701             stm.Position = 0;
 702             return stm;
 703         } // SerializeMessageParts
 704 #endif
 705
 706         [System.Security.SecurityCritical]  // auto-generated
 707         internal static MemoryStream SerializeMessageParts(ArrayList argsToSerialize)
 708         {
 709             MemoryStream stm = new MemoryStream();
 710
 711             BinaryFormatter fmt = new BinaryFormatter();
 712             RemotingSurrogateSelector ss = new RemotingSurrogateSelector();
 713             fmt.SurrogateSelector = ss;
 714             fmt.Context = new StreamingContext(StreamingContextStates.CrossAppDomain);
 715             fmt.Serialize(stm, argsToSerialize, null, false /* No Security check */);
 716
 717             stm.Position = 0;
 718             return stm;
 719         } // SerializeMessageParts
 720
 721         // called from MessageSmuggler classes
 722         [System.Security.SecurityCritical]  // auto-generated
 723         internal static void SerializeObject(Object obj, MemoryStream stm)
 724         {
 725             BinaryFormatter fmt = new BinaryFormatter();
 726             RemotingSurrogateSelector ss = new RemotingSurrogateSelector();
 727             fmt.SurrogateSelector = ss;
 728             fmt.Context = new StreamingContext(StreamingContextStates.CrossAppDomain);
 729             fmt.Serialize(stm, obj, null, false /* No Security check */);
 730         } // SerializeMessageParts
 731
 732         // called from MessageSmuggler classes
 733         [System.Security.SecurityCritical]  // auto-generated
 734         internal static MemoryStream SerializeObject(Object obj)
 735         {
 736             MemoryStream stm = new MemoryStream();
 737
 738             SerializeObject( obj, stm );
 739
 740             stm.Position = 0;
 741             return stm;
 742         } // SerializeMessageParts
 743
 744
 745         [System.Security.SecurityCritical]  // auto-generated
 746         internal static IMessage DeserializeMessage(MemoryStream stm)
 747         {
 748             return DeserializeMessage(stm, null);
 749         }
 750
 751         [System.Security.SecurityCritical]  // auto-generated
 752         internal static IMessage DeserializeMessage(
 753             MemoryStream stm, IMethodCallMessage reqMsg)
 754         {
 755             if (stm == null)
 756                 throw new ArgumentNullException("stm");
 757
 758             stm.Position = 0;
 759             BinaryFormatter fmt = new BinaryFormatter();
 760             fmt.SurrogateSelector = null;
 761             fmt.Context = new StreamingContext(StreamingContextStates.CrossAppDomain);
 762
 763             return (IMessage) fmt.Deserialize(stm, null, false /* No Security check */, true/*isCrossAppDomain*/, reqMsg);
 764         }
 765
 766 #if false
 767         // called from MessageSmuggler classes
 768         internal static ArrayList DeserializeMessageParts(MemoryStream stm, Object[] args)
 769         {
 770             stm.Position = 0;
 771
 772             BinaryFormatter fmt = new BinaryFormatter();
 773             fmt.CrossAppDomainArray = args;
 774             fmt.Context = new StreamingContext(StreamingContextStates.CrossAppDomain);
 775             return (ArrayList) fmt.Deserialize(stm, null, false/*checkSEcurity*/, true/*isCrossAppDomain*/, null);
 776         } // DeserializeMessageParts
 777 #endif
 778
 779         [System.Security.SecurityCritical]  // auto-generated
 780         internal static ArrayList DeserializeMessageParts(MemoryStream stm)
 781         {
 782             return (ArrayList) DeserializeObject(stm);
 783
 784         } // DeserializeMessageParts
 785
 786
 787         [System.Security.SecurityCritical]  // auto-generated
 788         internal static Object DeserializeObject(MemoryStream stm)
 789         {
 790             stm.Position = 0;
 791
 792             BinaryFormatter fmt = new BinaryFormatter();
 793             fmt.Context = new StreamingContext(StreamingContextStates.CrossAppDomain);
 794             return fmt.Deserialize(stm, null, false /* No Security check */, true/*isCrossAppDomain*/, null);
 795         } // DeserializeMessageParts
 796     }
 797
 798 }