1 // ==++== 2 // 3 // Copyright (c) Microsoft Corporation. All rights reserved. 4 // 5 // ==--== 6 /*============================================================ 7 ** 8 ** File: Message.cs 9 ** 10 ** 11 ** Purpose: Defines the message object created by the transparent 12 ** proxy and used by the message sinks 13 ** 14 ** 15 ===========================================================*/ 16 namespace System.Runtime.Remoting.Messaging { 17 using System; 18 using System.Collections; 19 using System.Threading; 20 using System.Runtime.InteropServices; 21 using System.Runtime.Remoting; 22 using System.Runtime.Remoting.Activation; 23 using System.Runtime.Remoting.Contexts; 24 using System.Runtime.Remoting.Channels; 25 using System.Runtime.Remoting.Metadata; 26 using System.Runtime.Remoting.Metadata.W3cXsd2001; 27 using System.Runtime.Remoting.Proxies; 28 using System.Runtime.Serialization; 29 using System.Runtime.Serialization.Formatters; 30 using System.Runtime.Serialization.Formatters.Binary; 31 using System.Runtime.Versioning; 32 using System.Reflection; 33 using System.Text; 34 using System.Runtime.CompilerServices; 35 using System.Security.Permissions; 36 using System.Globalization; 37 using System.Diagnostics.Contracts; 38 using System.Security; 39 40 //+======================================================================= 41 // 42 // Synopsis: Message is used to represent call and is created by the 43 // Transparent proxy 44 // 45 //-======================================================================= 46 [Serializable] 47 internal class Message : IMethodCallMessage, IInternalMessage, ISerializable 48 { 49 50 // *** NOTE *** 51 // Keep these in sync with the flags in Message.h 52 // flags 53 internal const int Sync = 0; // Synchronous call 54 internal const int BeginAsync = 1; // Async Begin call 55 internal const int EndAsync = 2; // Async End call 56 internal const int Ctor = 4; // The call is a .Ctor 57 internal const int OneWay = 8; // One way call 58 internal const int CallMask = 15; // Mask for call type bits 59 60 internal const int FixedArgs = 16; // Fixed number of arguments call 61 internal const int VarArgs = 32; // Variable number of arguments call 62 63 // 64 // Changing the type or position of these fields requires making changes 65 // to the corresponding unmanaged class and to mscorlib.h 66 // 67 68 // Private data members 69 private String _MethodName; // Method name 70 private Type[] _MethodSignature; // Array of parameter types 71 private MethodBase _MethodBase; // Reflection method object 72 private Object _properties; // hash table for properities 73 private String _URI; // target object URI 74 private String _typeName; 75 private Exception _Fault; // null if no fault 76 77 private Identity _ID; // identity cached during Invoke 78 private ServerIdentity _srvID; // server Identity cached during Invoke 79 private ArgMapper _argMapper; 80 [System.Security.SecurityCritical] // auto-generated 81 private LogicalCallContext _callContext; 82 83 private IntPtr _frame; // ptr to the call frame 84 private IntPtr _methodDesc; // ptr to the internal method descriptor 85 private IntPtr _metaSigHolder; // Pointer to the MetaSig structure 86 private IntPtr _delegateMD; // ptr to the internal method descriptor for the delegate 87 private IntPtr _governingType; // ptr to the internal type handle for the type calling the method 88 89 private int _flags; // internal flags 90 private bool _initDone; // called the native init routine 91 92 93 internal static String CallContextKey = "__CallContext"; 94 internal static String UriKey = "__Uri"; 95 96 GetFault()97 public virtual Exception GetFault() {return _Fault;} SetFault(Exception e)98 public virtual void SetFault(Exception e) {_Fault = e;} 99 SetOneWay()100 internal virtual void SetOneWay() { _flags |= Message.OneWay;} GetCallType()101 public virtual int GetCallType() 102 { 103 // We should call init only if neccessary 104 InitIfNecessary(); 105 return _flags; 106 } 107 GetFramePtr()108 internal IntPtr GetFramePtr() { return _frame;} 109 110 111 112 [System.Security.SecurityCritical] // auto-generated 113 [ResourceExposure(ResourceScope.None)] 114 [MethodImplAttribute(MethodImplOptions.InternalCall)] GetAsyncBeginInfo(out AsyncCallback acbd, out Object state)115 public extern void GetAsyncBeginInfo(out AsyncCallback acbd, 116 out Object state); 117 118 [System.Security.SecurityCritical] // auto-generated 119 [ResourceExposure(ResourceScope.None)] 120 [MethodImplAttribute(MethodImplOptions.InternalCall)] GetThisPtr()121 public extern Object GetThisPtr(); 122 [System.Security.SecurityCritical] // auto-generated 123 [ResourceExposure(ResourceScope.None)] 124 [MethodImplAttribute(MethodImplOptions.InternalCall)] GetAsyncResult()125 public extern IAsyncResult GetAsyncResult(); 126 Init()127 public void Init() 128 { 129 // This method no longer does any meaninfull work, however it is 130 // publicly exposed so we cannot get rid of it. 131 } 132 133 [System.Security.SecurityCritical] // auto-generated 134 [ResourceExposure(ResourceScope.None)] 135 [MethodImplAttribute(MethodImplOptions.InternalCall)] GetReturnValue()136 public extern Object GetReturnValue(); 137 // 138 // Constructor 139 // This should be internal. The message object is 140 // allocated and deallocated via a pool to enable 141 // reuse. 142 // Message()143 internal Message() 144 { 145 } 146 147 // NOTE: This method is called multiple times as we reuse the 148 // message object. Make sure that you reset any fields that you 149 // add to the message object to the default values. This will 150 // ensure that the reused message object starts with the correct 151 // values. 152 [System.Security.SecurityCritical] // auto-generated InitFields(MessageData msgData)153 internal void InitFields(MessageData msgData) 154 { 155 _frame = msgData.pFrame; 156 _delegateMD = msgData.pDelegateMD; 157 _methodDesc = msgData.pMethodDesc; 158 _flags = msgData.iFlags; 159 _initDone = true; 160 _metaSigHolder = msgData.pSig; 161 _governingType = msgData.thGoverningType; 162 163 _MethodName = null; 164 _MethodSignature = null; 165 _MethodBase = null; 166 _URI = null; 167 _Fault = null; 168 _ID = null; 169 _srvID = null; 170 _callContext = null; 171 172 if (_properties != null) 173 { 174 // A dictionary object already exists. This case occurs 175 // when we reuse the message object. Just remove all the 176 // entries from the dictionary object and reuse it. 177 ((IDictionary)_properties).Clear(); 178 } 179 180 } 181 InitIfNecessary()182 private void InitIfNecessary() 183 { 184 if (!_initDone) 185 { 186 // We assume that Init is an idempotent operation 187 Init(); 188 _initDone = true; 189 } 190 } 191 192 193 //------------------------------------------------------------------- 194 // IInternalMessage 195 //------------------------------------------------------------------- 196 ServerIdentity IInternalMessage.ServerIdentityObject 197 { 198 [System.Security.SecurityCritical] 199 get { return _srvID; } 200 [System.Security.SecurityCritical] 201 set {_srvID = value;} 202 } 203 204 Identity IInternalMessage.IdentityObject 205 { 206 [System.Security.SecurityCritical] 207 get { return _ID; } 208 [System.Security.SecurityCritical] 209 set { _ID = value;} 210 } 211 212 [System.Security.SecurityCritical] IInternalMessage.SetURI(String URI)213 void IInternalMessage.SetURI(String URI) 214 { 215 _URI = URI; 216 } 217 218 [System.Security.SecurityCritical] IInternalMessage.SetCallContext(LogicalCallContext callContext)219 void IInternalMessage.SetCallContext(LogicalCallContext callContext) 220 { 221 _callContext = callContext; 222 } 223 224 [System.Security.SecurityCritical] IInternalMessage.HasProperties()225 bool IInternalMessage.HasProperties() 226 { 227 return _properties != null; 228 } 229 230 //------------------------------------------------------------------- 231 // IMessage 232 //------------------------------------------------------------------- 233 public IDictionary Properties 234 { 235 [System.Security.SecurityCritical] // auto-generated 236 get 237 { 238 if (_properties == null) 239 { 240 Interlocked.CompareExchange(ref _properties, 241 new MCMDictionary(this, null), 242 null); 243 } 244 return (IDictionary)_properties; 245 } 246 } 247 248 //------------------------------------------------------------------- 249 // IMethodCallMessage 250 //------------------------------------------------------------------- 251 252 public String Uri 253 { 254 [System.Security.SecurityCritical] // auto-generated 255 get { return _URI;} 256 257 set { _URI = value; } 258 } 259 260 public bool HasVarArgs 261 { 262 [System.Security.SecurityCritical] // auto-generated 263 get 264 { 265 // When this method is called for the first time, we 266 // obtain the answer from a native call and set the flags 267 if((0 == (_flags & Message.FixedArgs)) && 268 (0 == (_flags & Message.VarArgs))) 269 { 270 if(!InternalHasVarArgs()) 271 { 272 _flags |= Message.FixedArgs; 273 } 274 else 275 { 276 _flags |= Message.VarArgs; 277 } 278 } 279 return (1 == (_flags & Message.VarArgs)); 280 } 281 282 } 283 284 public int ArgCount 285 { 286 [System.Security.SecurityCritical] // auto-generated 287 get { return InternalGetArgCount();} 288 } 289 290 [System.Security.SecurityCritical] // auto-generated GetArg(int argNum)291 public Object GetArg(int argNum) 292 { 293 return InternalGetArg(argNum); 294 } 295 296 [System.Security.SecurityCritical] // auto-generated GetArgName(int index)297 public String GetArgName(int index) 298 { 299 if (index >= ArgCount) 300 { 301 throw new ArgumentOutOfRangeException("index"); 302 } 303 Contract.EndContractBlock(); 304 305 RemotingMethodCachedData methodCache = 306 InternalRemotingServices.GetReflectionCachedData(GetMethodBase()); 307 308 ParameterInfo[] pi = methodCache.Parameters; 309 310 if (index < pi.Length) 311 { 312 return pi[index].Name; 313 } 314 else 315 { 316 return "VarArg" + (index - pi.Length); 317 } 318 } 319 320 public Object[] Args 321 { 322 [System.Security.SecurityCritical] // auto-generated 323 get 324 { 325 return InternalGetArgs(); 326 } 327 } 328 329 public int InArgCount 330 { 331 [System.Security.SecurityCritical] // auto-generated 332 get 333 { 334 if (_argMapper == null) _argMapper = new ArgMapper(this, false); 335 return _argMapper.ArgCount; 336 } 337 } 338 339 [System.Security.SecurityCritical] // auto-generated GetInArg(int argNum)340 public Object GetInArg(int argNum) 341 { 342 if (_argMapper == null) _argMapper = new ArgMapper(this, false); 343 return _argMapper.GetArg(argNum); 344 } 345 346 [System.Security.SecurityCritical] // auto-generated GetInArgName(int index)347 public String GetInArgName(int index) 348 { 349 if (_argMapper == null) _argMapper = new ArgMapper(this, false); 350 return _argMapper.GetArgName(index); 351 } 352 353 public Object[] InArgs 354 { 355 [System.Security.SecurityCritical] // auto-generated 356 get 357 { 358 if (_argMapper == null) _argMapper = new ArgMapper(this, false); 359 return _argMapper.Args; 360 } 361 } 362 363 [System.Security.SecurityCritical] // auto-generated UpdateNames()364 private void UpdateNames() 365 { 366 RemotingMethodCachedData methCache = 367 InternalRemotingServices.GetReflectionCachedData(GetMethodBase()); 368 _typeName = methCache.TypeAndAssemblyName; 369 _MethodName = methCache.MethodName; 370 } 371 372 public String MethodName 373 { 374 [System.Security.SecurityCritical] // auto-generated 375 get 376 { 377 if(null == _MethodName) 378 UpdateNames(); 379 return _MethodName; 380 } 381 } 382 383 public String TypeName 384 { 385 [System.Security.SecurityCritical] // auto-generated 386 get 387 { 388 if (_typeName == null) 389 UpdateNames(); 390 return _typeName; 391 } 392 } 393 394 public Object MethodSignature 395 { 396 [System.Security.SecurityCritical] // auto-generated 397 get 398 { 399 if(null == _MethodSignature) 400 _MethodSignature = GenerateMethodSignature(GetMethodBase()); 401 402 return _MethodSignature; 403 } 404 } 405 406 public LogicalCallContext LogicalCallContext 407 { 408 [System.Security.SecurityCritical] // auto-generated 409 get 410 { 411 return GetLogicalCallContext(); 412 } 413 } 414 415 public MethodBase MethodBase 416 { 417 [System.Security.SecurityCritical] // auto-generated 418 get 419 { 420 return GetMethodBase(); 421 } 422 } 423 424 425 // 426 // ISerializable 427 // 428 [System.Security.SecurityCritical] // auto-generated_required GetObjectData(SerializationInfo info, StreamingContext context)429 public void GetObjectData(SerializationInfo info, StreamingContext context) 430 { 431 throw new NotSupportedException( 432 Environment.GetResourceString("NotSupported_Method")); 433 } 434 435 [System.Security.SecurityCritical] // auto-generated GetMethodBase()436 internal MethodBase GetMethodBase() 437 { 438 if(null == _MethodBase) 439 { 440 unsafe 441 { 442 IRuntimeMethodInfo mh = new RuntimeMethodInfoStub(_methodDesc, null); 443 _MethodBase = RuntimeType.GetMethodBase(Type.GetTypeFromHandleUnsafe(_governingType), mh); 444 } 445 } 446 return _MethodBase; 447 } 448 449 [System.Security.SecurityCritical] // auto-generated SetLogicalCallContext( LogicalCallContext callCtx)450 internal LogicalCallContext SetLogicalCallContext( 451 LogicalCallContext callCtx) 452 { 453 LogicalCallContext oldCtx = _callContext; 454 _callContext = callCtx; 455 456 return oldCtx; 457 } 458 459 [System.Security.SecurityCritical] // auto-generated GetLogicalCallContext()460 internal LogicalCallContext GetLogicalCallContext() 461 { 462 if (_callContext == null) 463 _callContext = new LogicalCallContext(); 464 return _callContext; 465 } 466 467 468 // Internal helper to create method signature 469 [System.Security.SecurityCritical] // auto-generated GenerateMethodSignature(MethodBase mb)470 internal static Type[] GenerateMethodSignature(MethodBase mb) 471 { 472 RemotingMethodCachedData methodCache = 473 InternalRemotingServices.GetReflectionCachedData(mb); 474 475 ParameterInfo[] paramArray = methodCache.Parameters; 476 Type[] methodSig = new Type[paramArray.Length]; 477 for(int i = 0; i < paramArray.Length; i++) 478 { 479 methodSig[i] = paramArray[i].ParameterType; 480 } 481 482 return methodSig; 483 } // GenerateMethodSignature 484 485 // 486 // The following two routines are used by StackBuilderSink to check 487 // the consistency of arguments. 488 // 489 // Check that all the arguments are of the type 490 // specified by the parameter list. 491 // 492 [System.Security.SecurityCritical] // auto-generated CoerceArgs(IMethodMessage m)493 internal static Object[] CoerceArgs(IMethodMessage m) 494 { 495 MethodBase mb = m.MethodBase; 496 Contract.Assert(mb != null, "null method base passed to CoerceArgs"); 497 498 RemotingMethodCachedData methodCache = InternalRemotingServices.GetReflectionCachedData(mb); 499 500 return CoerceArgs(m, methodCache.Parameters); 501 } // CoerceArgs 502 503 [System.Security.SecurityCritical] // auto-generated CoerceArgs(IMethodMessage m, ParameterInfo[] pi)504 internal static Object[] CoerceArgs(IMethodMessage m, ParameterInfo[] pi) 505 { 506 return CoerceArgs(m.MethodBase, m.Args, pi); 507 } // CoerceArgs 508 509 [System.Security.SecurityCritical] // auto-generated CoerceArgs(MethodBase mb, Object[] args, ParameterInfo[] pi)510 internal static Object[] CoerceArgs(MethodBase mb, Object[] args, ParameterInfo[] pi) 511 { 512 if (pi == null) 513 { 514 throw new ArgumentNullException("pi"); 515 } 516 Contract.EndContractBlock(); 517 518 if (pi.Length != args.Length) 519 { 520 throw new RemotingException( 521 String.Format( 522 CultureInfo.CurrentCulture, Environment.GetResourceString( 523 "Remoting_Message_ArgMismatch"), 524 mb.DeclaringType.FullName, mb.Name, 525 args.Length, pi.Length)); 526 } 527 528 for (int i=0; i < pi.Length; i++) 529 { 530 ParameterInfo currentPi = pi[i]; 531 Type pt = currentPi.ParameterType; 532 Object oArg = args[i]; 533 if (oArg != null) 534 { 535 args[i] = CoerceArg(oArg, pt); 536 } 537 else 538 { 539 if (pt.IsByRef) 540 { 541 Type paramType = pt.GetElementType(); 542 if (paramType.IsValueType) 543 { 544 // nullables can be null, 545 if (currentPi.IsOut) 546 { 547 // we need to fill in the blanks for value types if they are null 548 args[i] = Activator.CreateInstance(paramType, true); 549 } 550 else 551 { 552 if (!(paramType.IsGenericType && paramType.GetGenericTypeDefinition() == typeof(Nullable<>))) 553 { 554 throw new RemotingException( 555 String.Format( 556 CultureInfo.CurrentCulture, Environment.GetResourceString("Remoting_Message_MissingArgValue"), 557 paramType.FullName, i)); 558 } 559 } 560 } 561 } 562 else 563 { 564 if (pt.IsValueType) 565 { 566 // nullables can be null, 567 if (!(pt.IsGenericType && pt.GetGenericTypeDefinition() == typeof(Nullable<>))) 568 { 569 // A null value was passed as a value type parameter. 570 throw new RemotingException( 571 String.Format( 572 CultureInfo.CurrentCulture, Environment.GetResourceString("Remoting_Message_MissingArgValue"), 573 pt.FullName, i)); 574 } 575 } 576 } 577 } 578 } 579 580 return args; 581 } // CoerceArgs 582 583 584 [System.Security.SecurityCritical] // auto-generated CoerceArg(Object value, Type pt)585 internal static Object CoerceArg(Object value, Type pt) 586 { 587 Object ret = null; 588 589 if(null != value) 590 { 591 Exception inner = null; 592 try 593 { 594 if (pt.IsByRef) 595 { 596 pt = pt.GetElementType(); 597 } 598 599 if (pt.IsInstanceOfType(value)) 600 { 601 ret = value; 602 } 603 else 604 { 605 ret = Convert.ChangeType(value, pt, CultureInfo.InvariantCulture); 606 } 607 } 608 catch(Exception e) 609 { 610 // Quietly ignore all exceptions. We will throw 611 // a more meaningful exception below. 612 inner = e; 613 } 614 615 // If the coercion failed then throw an exception 616 if(null == ret) 617 { 618 // NOTE: Do not call value.ToString() on proxies as 619 // it results in loading the type and loss of refinement 620 // optimization or denial of service attacks by loading 621 // a lot of types in the server. 622 String valueName = null; 623 if(RemotingServices.IsTransparentProxy(value)) 624 { 625 valueName = typeof(MarshalByRefObject).ToString(); 626 } 627 else 628 { 629 valueName = value.ToString(); 630 } 631 632 throw new RemotingException( 633 String.Format( 634 CultureInfo.CurrentCulture, Environment.GetResourceString( 635 "Remoting_Message_CoercionFailed"), valueName, pt), inner); 636 } 637 } 638 639 return ret; 640 } //end of CoerceArg 641 642 [System.Security.SecurityCritical] // auto-generated SoapCoerceArg(Object value, Type pt, Hashtable keyToNamespaceTable)643 internal static Object SoapCoerceArg(Object value, Type pt, Hashtable keyToNamespaceTable) 644 { 645 Object ret = null; 646 647 if (value != null) 648 { 649 try 650 { 651 if (pt.IsByRef) 652 { 653 pt = pt.GetElementType(); 654 } 655 656 if (pt.IsInstanceOfType(value)) 657 { 658 ret = value; 659 } 660 else 661 { 662 String strValue = value as String; 663 if (strValue != null) 664 { 665 if (pt == typeof(Double)) 666 { 667 if (strValue == "INF") 668 ret = Double.PositiveInfinity; 669 else if (strValue == "-INF") 670 ret = Double.NegativeInfinity; 671 else 672 ret = Double.Parse(strValue, CultureInfo.InvariantCulture); 673 } 674 else if (pt == typeof(Single)) 675 { 676 if (strValue == "INF") 677 ret = Single.PositiveInfinity; 678 else if (strValue == "-INF") 679 ret = Single.NegativeInfinity; 680 else 681 ret = Single.Parse(strValue, CultureInfo.InvariantCulture); 682 } 683 else if (SoapType.typeofISoapXsd.IsAssignableFrom(pt)) 684 { 685 if (pt == SoapType.typeofSoapTime) 686 ret = SoapTime.Parse(strValue); 687 else if (pt == SoapType.typeofSoapDate) 688 ret = SoapDate.Parse(strValue); 689 else if (pt == SoapType.typeofSoapYearMonth) 690 ret = SoapYearMonth.Parse(strValue); 691 else if (pt == SoapType.typeofSoapYear) 692 ret = SoapYear.Parse(strValue); 693 else if (pt == SoapType.typeofSoapMonthDay) 694 ret = SoapMonthDay.Parse(strValue); 695 else if (pt == SoapType.typeofSoapDay) 696 ret = SoapDay.Parse(strValue); 697 else if (pt == SoapType.typeofSoapMonth) 698 ret = SoapMonth.Parse(strValue); 699 else if (pt == SoapType.typeofSoapHexBinary) 700 ret = SoapHexBinary.Parse(strValue); 701 else if (pt == SoapType.typeofSoapBase64Binary) 702 ret = SoapBase64Binary.Parse(strValue); 703 else if (pt == SoapType.typeofSoapInteger) 704 ret = SoapInteger.Parse(strValue); 705 else if (pt == SoapType.typeofSoapPositiveInteger) 706 ret = SoapPositiveInteger.Parse(strValue); 707 else if (pt == SoapType.typeofSoapNonPositiveInteger) 708 ret = SoapNonPositiveInteger.Parse(strValue); 709 else if (pt == SoapType.typeofSoapNonNegativeInteger) 710 ret = SoapNonNegativeInteger.Parse(strValue); 711 else if (pt == SoapType.typeofSoapNegativeInteger) 712 ret = SoapNegativeInteger.Parse(strValue); 713 else if (pt == SoapType.typeofSoapAnyUri) 714 ret = SoapAnyUri.Parse(strValue); 715 else if (pt == SoapType.typeofSoapQName) 716 { 717 ret = SoapQName.Parse(strValue); 718 SoapQName soapQName = (SoapQName)ret; 719 if (soapQName.Key.Length == 0) 720 soapQName.Namespace = (String)keyToNamespaceTable["xmlns"]; 721 else 722 soapQName.Namespace = (String)keyToNamespaceTable["xmlns"+":"+soapQName.Key]; 723 } 724 else if (pt == SoapType.typeofSoapNotation) 725 ret = SoapNotation.Parse(strValue); 726 else if (pt == SoapType.typeofSoapNormalizedString) 727 ret = SoapNormalizedString.Parse(strValue); 728 else if (pt == SoapType.typeofSoapToken) 729 ret = SoapToken.Parse(strValue); 730 else if (pt == SoapType.typeofSoapLanguage) 731 ret = SoapLanguage.Parse(strValue); 732 else if (pt == SoapType.typeofSoapName) 733 ret = SoapName.Parse(strValue); 734 else if (pt == SoapType.typeofSoapIdrefs) 735 ret = SoapIdrefs.Parse(strValue); 736 else if (pt == SoapType.typeofSoapEntities) 737 ret = SoapEntities.Parse(strValue); 738 else if (pt == SoapType.typeofSoapNmtoken) 739 ret = SoapNmtoken.Parse(strValue); 740 else if (pt == SoapType.typeofSoapNmtokens) 741 ret = SoapNmtokens.Parse(strValue); 742 else if (pt == SoapType.typeofSoapNcName) 743 ret = SoapNcName.Parse(strValue); 744 else if (pt == SoapType.typeofSoapId) 745 ret = SoapId.Parse(strValue); 746 else if (pt == SoapType.typeofSoapIdref) 747 ret = SoapIdref.Parse(strValue); 748 else if (pt == SoapType.typeofSoapEntity) 749 ret = SoapEntity.Parse(strValue); 750 } 751 else if (pt == typeof(Boolean)) 752 { 753 if (strValue == "1" || strValue == "true") 754 ret = (bool)true; 755 else if (strValue == "0" || strValue =="false") 756 ret = (bool)false; 757 else 758 { 759 throw new RemotingException( 760 String.Format( 761 CultureInfo.CurrentCulture, Environment.GetResourceString( 762 "Remoting_Message_CoercionFailed"), strValue, pt)); 763 } 764 } 765 else if (pt == typeof(DateTime)) 766 ret = SoapDateTime.Parse(strValue); 767 else if (pt.IsPrimitive) 768 ret = Convert.ChangeType(value, pt, CultureInfo.InvariantCulture); 769 else if (pt == typeof(TimeSpan)) 770 ret = SoapDuration.Parse(strValue); 771 else if (pt == typeof(Char)) 772 ret = strValue[0]; 773 774 else 775 ret = Convert.ChangeType(value, pt, CultureInfo.InvariantCulture); //Should this just throw an exception 776 } 777 else 778 ret = Convert.ChangeType(value, pt, CultureInfo.InvariantCulture); 779 } 780 } 781 catch(Exception ) 782 { 783 // Quietly ignore all exceptions. We will throw 784 // a more meaningful exception below. 785 } 786 787 // If the coercion failed then throw an exception 788 if(null == ret) 789 { 790 // NOTE: Do not call value.ToString() on proxies as 791 // it results in loading the type and loss of refinement 792 // optimization or denial of service attacks by loading 793 // a lot of types in the server. 794 String valueName = null; 795 if(RemotingServices.IsTransparentProxy(value)) 796 { 797 valueName = typeof(MarshalByRefObject).ToString(); 798 } 799 else 800 { 801 valueName = value.ToString(); 802 } 803 804 throw new RemotingException( 805 String.Format( 806 CultureInfo.CurrentCulture, Environment.GetResourceString( 807 "Remoting_Message_CoercionFailed"), valueName, pt)); 808 } 809 } 810 811 return ret; 812 }//end of SoapCoerceArg 813 814 815 [System.Security.SecurityCritical] // auto-generated 816 [ResourceExposure(ResourceScope.None)] 817 [MethodImplAttribute(MethodImplOptions.InternalCall)] InternalHasVarArgs()818 internal extern bool InternalHasVarArgs(); 819 820 [System.Security.SecurityCritical] // auto-generated 821 [ResourceExposure(ResourceScope.None)] 822 [MethodImplAttribute(MethodImplOptions.InternalCall)] InternalGetArgCount()823 internal extern int InternalGetArgCount(); 824 825 [System.Security.SecurityCritical] // auto-generated 826 [ResourceExposure(ResourceScope.None)] 827 [MethodImplAttribute(MethodImplOptions.InternalCall)] InternalGetArg(int argNum)828 private extern Object InternalGetArg(int argNum); 829 830 [System.Security.SecurityCritical] // auto-generated 831 [ResourceExposure(ResourceScope.None)] 832 [MethodImplAttribute(MethodImplOptions.InternalCall)] InternalGetArgs()833 private extern Object[] InternalGetArgs(); 834 835 [System.Security.SecurityCritical] // auto-generated 836 [ResourceExposure(ResourceScope.None)] 837 [MethodImplAttribute(MethodImplOptions.InternalCall)] PropagateOutParameters(Object[] OutArgs, Object retVal)838 public extern void PropagateOutParameters(Object[] OutArgs, Object retVal); 839 840 [System.Security.SecurityCritical] // auto-generated 841 [ResourceExposure(ResourceScope.None)] 842 [MethodImplAttribute(MethodImplOptions.InternalCall)] Dispatch(Object target)843 public extern bool Dispatch(Object target); 844 845 // 846 // < 847 848 [System.Security.SecurityCritical] // auto-generated 849 [System.Diagnostics.Conditional("_REMOTING_DEBUG")] DebugOut(String s)850 public static void DebugOut(String s) 851 { 852 BCLDebug.Trace( 853 "REMOTE", "RMTING: Thrd " 854 + Thread.CurrentThread.GetHashCode() 855 + " : " + s); 856 OutToUnmanagedDebugger( 857 "\nRMTING: Thrd " 858 + Thread.CurrentThread.GetHashCode() 859 + " : " + s); 860 } 861 862 [System.Security.SecurityCritical] // auto-generated 863 [ResourceExposure(ResourceScope.None)] 864 [MethodImplAttribute(MethodImplOptions.InternalCall)] OutToUnmanagedDebugger(String s)865 internal extern static void OutToUnmanagedDebugger(String s); 866 867 [System.Security.SecurityCritical] // auto-generated PropagateCallContextFromMessageToThread(IMessage msg)868 internal static LogicalCallContext PropagateCallContextFromMessageToThread(IMessage msg) 869 { 870 return CallContext.SetLogicalCallContext( 871 (LogicalCallContext) msg.Properties[Message.CallContextKey]); 872 } 873 874 [System.Security.SecurityCritical] // auto-generated PropagateCallContextFromThreadToMessage(IMessage msg)875 internal static void PropagateCallContextFromThreadToMessage(IMessage msg) 876 { 877 LogicalCallContext callCtx = Thread.CurrentThread.GetMutableExecutionContext().LogicalCallContext; 878 879 msg.Properties[Message.CallContextKey] = callCtx; 880 } 881 882 [System.Security.SecurityCritical] // auto-generated PropagateCallContextFromThreadToMessage(IMessage msg, LogicalCallContext oldcctx)883 internal static void PropagateCallContextFromThreadToMessage(IMessage msg, LogicalCallContext oldcctx) 884 { 885 // First do the common work 886 PropagateCallContextFromThreadToMessage(msg); 887 888 // restore the old call context on the thread 889 CallContext.SetLogicalCallContext(oldcctx); 890 } 891 } 892 893 //+================================================================================ 894 // 895 // Synopsis: Return message for constructors 896 // 897 //-================================================================================ 898 [System.Security.SecurityCritical] // auto-generated 899 internal class ConstructorReturnMessage : ReturnMessage, IConstructionReturnMessage 900 { 901 902 private const int Intercept = 0x1; 903 904 private MarshalByRefObject _o; 905 private int _iFlags; 906 907 ConstructorReturnMessage(MarshalByRefObject o, Object[] outArgs, int outArgsCount, LogicalCallContext callCtx, IConstructionCallMessage ccm)908 public ConstructorReturnMessage(MarshalByRefObject o, Object[] outArgs, int outArgsCount, 909 LogicalCallContext callCtx, IConstructionCallMessage ccm) 910 : base(o, outArgs, outArgsCount, callCtx, ccm) 911 { 912 _o = o; 913 _iFlags = Intercept; 914 } 915 ConstructorReturnMessage(Exception e, IConstructionCallMessage ccm)916 public ConstructorReturnMessage(Exception e, IConstructionCallMessage ccm) 917 : base(e, ccm) 918 { 919 } 920 921 public override Object ReturnValue 922 { 923 [System.Security.SecurityCritical] 924 get 925 { 926 if (_iFlags == Intercept) 927 { 928 return RemotingServices.MarshalInternal(_o,null,null); 929 } 930 else 931 { 932 return base.ReturnValue; 933 } 934 } 935 } 936 937 938 public override IDictionary Properties 939 { 940 [System.Security.SecurityCritical] 941 get 942 { 943 if (_properties == null) 944 { 945 Object properties = new CRMDictionary(this, new Hashtable()); 946 Interlocked.CompareExchange(ref _properties, properties, null); 947 } 948 return(IDictionary) _properties; 949 } 950 } 951 GetObject()952 internal Object GetObject() 953 { 954 return _o; 955 } 956 } 957 958 //+======================================================================== 959 // 960 // Synopsis: client side implementation of activation message 961 // 962 //-======================================================================== 963 internal class ConstructorCallMessage : IConstructionCallMessage 964 { 965 966 // data 967 968 private Object[] _callSiteActivationAttributes; 969 private Object[] _womGlobalAttributes; 970 private Object[] _typeAttributes; 971 972 // The activation type isn't serialized because we want to 973 // re-resolve the activation type name on the other side 974 // based on _activationTypeName. 975 [NonSerialized] 976 private RuntimeType _activationType; 977 978 private String _activationTypeName; 979 980 private IList _contextProperties; 981 private int _iFlags; 982 private Message _message; 983 private Object _properties; 984 private ArgMapper _argMapper; 985 private IActivator _activator; 986 987 // flags 988 private const int CCM_ACTIVATEINCONTEXT = 0x01; 989 ConstructorCallMessage()990 private ConstructorCallMessage() 991 { 992 // Default constructor 993 } 994 995 [System.Security.SecurityCritical] // auto-generated ConstructorCallMessage(Object[] callSiteActivationAttributes, Object[]womAttr, Object[] typeAttr, RuntimeType serverType)996 internal ConstructorCallMessage(Object[] callSiteActivationAttributes, 997 Object[]womAttr, Object[] typeAttr, RuntimeType serverType) 998 { 999 _activationType = serverType; 1000 _activationTypeName = RemotingServices.GetDefaultQualifiedTypeName(_activationType); 1001 _callSiteActivationAttributes = callSiteActivationAttributes; 1002 _womGlobalAttributes = womAttr; 1003 _typeAttributes = typeAttr; 1004 } 1005 1006 [System.Security.SecurityCritical] // auto-generated GetThisPtr()1007 public Object GetThisPtr() 1008 { 1009 if (_message != null) 1010 { 1011 return _message.GetThisPtr(); 1012 } 1013 else 1014 { 1015 throw new InvalidOperationException( 1016 Environment.GetResourceString( 1017 "InvalidOperation_InternalState")); 1018 } 1019 } 1020 1021 public Object[] CallSiteActivationAttributes 1022 { 1023 [System.Security.SecurityCritical] // auto-generated 1024 get 1025 { 1026 return _callSiteActivationAttributes; 1027 } 1028 1029 } 1030 GetWOMAttributes()1031 internal Object[] GetWOMAttributes() 1032 { 1033 return _womGlobalAttributes; 1034 } 1035 GetTypeAttributes()1036 internal Object[] GetTypeAttributes() 1037 { 1038 return _typeAttributes; 1039 } 1040 1041 public Type ActivationType 1042 { 1043 [System.Security.SecurityCritical] // auto-generated 1044 get 1045 { 1046 if ((_activationType == null) && (_activationTypeName != null)) 1047 _activationType = RemotingServices.InternalGetTypeFromQualifiedTypeName(_activationTypeName, false); 1048 1049 return _activationType; 1050 } 1051 } 1052 1053 public String ActivationTypeName 1054 { 1055 [System.Security.SecurityCritical] // auto-generated 1056 get 1057 { 1058 return _activationTypeName; 1059 } 1060 } 1061 1062 public IList ContextProperties 1063 { 1064 [System.Security.SecurityCritical] // auto-generated 1065 get 1066 { 1067 if (_contextProperties == null) 1068 { 1069 _contextProperties = new ArrayList(); 1070 } 1071 return _contextProperties; 1072 } 1073 } 1074 1075 public String Uri 1076 { 1077 [System.Security.SecurityCritical] // auto-generated 1078 get 1079 { 1080 if (_message != null) 1081 { 1082 return _message.Uri; 1083 } 1084 else 1085 { 1086 throw new InvalidOperationException( 1087 Environment.GetResourceString( 1088 "InvalidOperation_InternalState")); 1089 } 1090 } 1091 1092 set 1093 { 1094 if (_message != null) 1095 { 1096 _message.Uri = value; 1097 } 1098 else 1099 { 1100 throw new InvalidOperationException( 1101 Environment.GetResourceString( 1102 "InvalidOperation_InternalState")); 1103 } 1104 } 1105 1106 } 1107 1108 public String MethodName 1109 { 1110 [System.Security.SecurityCritical] // auto-generated 1111 get 1112 { 1113 if (_message != null) 1114 { 1115 return _message.MethodName; 1116 } 1117 else 1118 { 1119 throw new InvalidOperationException( 1120 Environment.GetResourceString( 1121 "InvalidOperation_InternalState")); 1122 } 1123 } 1124 } 1125 1126 public String TypeName 1127 { 1128 [System.Security.SecurityCritical] // auto-generated 1129 get 1130 { 1131 if (_message != null) 1132 { 1133 return _message.TypeName; 1134 } 1135 else 1136 { 1137 throw new InvalidOperationException( 1138 Environment.GetResourceString( 1139 "InvalidOperation_InternalState")); 1140 } 1141 } 1142 } 1143 1144 public Object MethodSignature 1145 { 1146 [System.Security.SecurityCritical] // auto-generated 1147 get 1148 { 1149 if (_message != null) 1150 { 1151 return _message.MethodSignature; 1152 } 1153 else 1154 { 1155 throw new InvalidOperationException( 1156 Environment.GetResourceString( 1157 "InvalidOperation_InternalState")); 1158 } 1159 } 1160 } // MethodSignature 1161 1162 public MethodBase MethodBase 1163 { 1164 [System.Security.SecurityCritical] // auto-generated 1165 get 1166 { 1167 if (_message != null) 1168 { 1169 return _message.MethodBase; 1170 } 1171 else 1172 { 1173 throw new InvalidOperationException( 1174 Environment.GetResourceString( 1175 "InvalidOperation_InternalState")); 1176 } 1177 } 1178 } // MethodBase 1179 1180 1181 /// <internalonly/> 1182 public int InArgCount 1183 { 1184 [System.Security.SecurityCritical] // auto-generated 1185 get 1186 { 1187 if (_argMapper == null) 1188 _argMapper = new ArgMapper(this, false); 1189 return _argMapper.ArgCount; 1190 } 1191 } 1192 1193 [System.Security.SecurityCritical] // auto-generated GetInArg(int argNum)1194 public Object GetInArg(int argNum) 1195 { 1196 if (_argMapper == null) 1197 _argMapper = new ArgMapper(this, false); 1198 return _argMapper.GetArg(argNum); 1199 } 1200 1201 /// <internalonly/> 1202 [System.Security.SecurityCritical] // auto-generated GetInArgName(int index)1203 public String GetInArgName(int index) 1204 { 1205 if (_argMapper == null) 1206 _argMapper = new ArgMapper(this, false); 1207 return _argMapper.GetArgName(index); 1208 } 1209 public Object[] InArgs 1210 { 1211 [System.Security.SecurityCritical] // auto-generated 1212 get 1213 { 1214 if (_argMapper == null) 1215 _argMapper = new ArgMapper(this, false); 1216 return _argMapper.Args; 1217 } 1218 } 1219 1220 public int ArgCount 1221 { 1222 [System.Security.SecurityCritical] // auto-generated 1223 get 1224 { 1225 if (_message != null) 1226 { 1227 return _message.ArgCount; 1228 } 1229 else 1230 { 1231 throw new InvalidOperationException( 1232 Environment.GetResourceString( 1233 "InvalidOperation_InternalState")); 1234 } 1235 } 1236 } 1237 1238 [System.Security.SecurityCritical] // auto-generated GetArg(int argNum)1239 public Object GetArg(int argNum) 1240 { 1241 if (_message != null) 1242 { 1243 return _message.GetArg(argNum); 1244 } 1245 else 1246 { 1247 throw new InvalidOperationException( 1248 Environment.GetResourceString( 1249 "InvalidOperation_InternalState")); 1250 } 1251 } 1252 1253 [System.Security.SecurityCritical] // auto-generated GetArgName(int index)1254 public String GetArgName(int index) 1255 { 1256 if (_message != null) 1257 { 1258 return _message.GetArgName(index); 1259 } 1260 else 1261 { 1262 throw new InvalidOperationException( 1263 Environment.GetResourceString( 1264 "InvalidOperation_InternalState")); 1265 } 1266 } 1267 1268 public bool HasVarArgs 1269 { 1270 [System.Security.SecurityCritical] // auto-generated 1271 get 1272 { 1273 if (_message != null) 1274 { 1275 return _message.HasVarArgs; 1276 } 1277 else 1278 { 1279 throw new InvalidOperationException( 1280 Environment.GetResourceString( 1281 "InvalidOperation_InternalState")); 1282 } 1283 } 1284 } 1285 1286 public Object[] Args 1287 { 1288 [System.Security.SecurityCritical] // auto-generated 1289 get 1290 { 1291 if (_message != null) 1292 { 1293 return _message.Args; 1294 } 1295 else 1296 { 1297 throw new InvalidOperationException( 1298 Environment.GetResourceString( 1299 "InvalidOperation_InternalState")); 1300 } 1301 } 1302 } 1303 1304 public IDictionary Properties 1305 { 1306 [System.Security.SecurityCritical] // auto-generated 1307 get 1308 { 1309 if (_properties == null) 1310 { 1311 Object properties = new CCMDictionary(this, new Hashtable()); 1312 Interlocked.CompareExchange(ref _properties, properties, null); 1313 } 1314 return(IDictionary) _properties; 1315 } 1316 } 1317 1318 public IActivator Activator 1319 { 1320 [System.Security.SecurityCritical] // auto-generated 1321 get { return _activator; } 1322 [System.Security.SecurityCritical] // auto-generated 1323 set { _activator = value; } 1324 } 1325 1326 public LogicalCallContext LogicalCallContext 1327 { 1328 [System.Security.SecurityCritical] // auto-generated 1329 get 1330 { 1331 return GetLogicalCallContext(); 1332 } 1333 } 1334 1335 1336 internal bool ActivateInContext 1337 { 1338 get { return((_iFlags & CCM_ACTIVATEINCONTEXT) != 0);} 1339 set { _iFlags = value ? (_iFlags | CCM_ACTIVATEINCONTEXT) : (_iFlags & ~CCM_ACTIVATEINCONTEXT);} 1340 } 1341 1342 [System.Security.SecurityCritical] // auto-generated SetFrame(MessageData msgData)1343 internal void SetFrame(MessageData msgData) 1344 { 1345 Contract.Assert(_message == null, "Can't set frame twice on ConstructorCallMessage"); 1346 _message = new Message(); 1347 _message.InitFields(msgData); 1348 } 1349 1350 [System.Security.SecurityCritical] // auto-generated GetLogicalCallContext()1351 internal LogicalCallContext GetLogicalCallContext() 1352 { 1353 if (_message != null) 1354 { 1355 return _message.GetLogicalCallContext(); 1356 } 1357 else 1358 { 1359 throw new InvalidOperationException( 1360 Environment.GetResourceString( 1361 "InvalidOperation_InternalState")); 1362 } 1363 } 1364 1365 [System.Security.SecurityCritical] // auto-generated SetLogicalCallContext(LogicalCallContext ctx)1366 internal LogicalCallContext SetLogicalCallContext(LogicalCallContext ctx) 1367 { 1368 if (_message != null) 1369 { 1370 return _message.SetLogicalCallContext(ctx); 1371 } 1372 else 1373 { 1374 throw new InvalidOperationException( 1375 Environment.GetResourceString( 1376 "InvalidOperation_InternalState")); 1377 } 1378 1379 } 1380 GetMessage()1381 internal Message GetMessage() 1382 { 1383 return _message; 1384 } 1385 } 1386 1387 //+======================================================================== 1388 // 1389 // Synopsis: Specialization of MessageDictionary for 1390 // ConstructorCallMessage objects 1391 // 1392 //-======================================================================== 1393 1394 internal class CCMDictionary : MessageDictionary 1395 { 1396 public static String[] CCMkeys = { 1397 "__Uri", //0 1398 "__MethodName", //1 1399 "__MethodSignature", //2 1400 "__TypeName", //3 1401 "__Args", //4 1402 "__CallContext", //5 1403 "__CallSiteActivationAttributes", //6 1404 "__ActivationType", //7 1405 "__ContextProperties", //8 1406 "__Activator", //9 1407 "__ActivationTypeName"}; //10 1408 1409 internal IConstructionCallMessage _ccmsg; // back pointer to message object 1410 1411 CCMDictionary(IConstructionCallMessage msg, IDictionary idict)1412 public CCMDictionary(IConstructionCallMessage msg, IDictionary idict) 1413 : base(CCMkeys, idict) 1414 { 1415 _ccmsg = msg; 1416 } 1417 1418 [System.Security.SecuritySafeCritical] // auto-generated GetMessageValue(int i)1419 internal override Object GetMessageValue(int i) 1420 { 1421 switch (i) 1422 { 1423 case 0: 1424 return _ccmsg.Uri; 1425 case 1: 1426 return _ccmsg.MethodName; 1427 case 2: 1428 return _ccmsg.MethodSignature; 1429 case 3: 1430 return _ccmsg.TypeName; 1431 case 4: 1432 return _ccmsg.Args; 1433 case 5: 1434 return FetchLogicalCallContext(); 1435 case 6: 1436 return _ccmsg.CallSiteActivationAttributes; 1437 case 7: 1438 // This it to keep us from serializing the requested server type 1439 return null; 1440 case 8: 1441 return _ccmsg.ContextProperties; 1442 case 9: 1443 return _ccmsg.Activator; 1444 case 10: 1445 return _ccmsg.ActivationTypeName; 1446 } 1447 // We should not get here! 1448 throw new RemotingException( 1449 Environment.GetResourceString( 1450 "Remoting_Default")); 1451 } 1452 1453 [System.Security.SecurityCritical] // auto-generated FetchLogicalCallContext()1454 private LogicalCallContext FetchLogicalCallContext() 1455 { 1456 ConstructorCallMessage ccm = _ccmsg as ConstructorCallMessage; 1457 if (null != ccm) 1458 { 1459 return ccm.GetLogicalCallContext(); 1460 } 1461 else if (_ccmsg is ConstructionCall) 1462 { 1463 // This is the case where the message got serialized 1464 // and deserialized 1465 return((MethodCall)_ccmsg).GetLogicalCallContext(); 1466 } 1467 else 1468 { 1469 throw new RemotingException( 1470 Environment.GetResourceString( 1471 "Remoting_Message_BadType")); 1472 } 1473 } 1474 1475 [System.Security.SecurityCritical] SetSpecialKey(int keyNum, Object value)1476 internal override void SetSpecialKey(int keyNum, Object value) 1477 { 1478 switch (keyNum) 1479 { 1480 case 0: 1481 ((ConstructorCallMessage)_ccmsg).Uri = (String)value; 1482 break; 1483 case 1: 1484 ((ConstructorCallMessage)_ccmsg).SetLogicalCallContext( 1485 (LogicalCallContext)value); 1486 break; 1487 default: 1488 // We should not get here! 1489 throw new RemotingException( 1490 Environment.GetResourceString( 1491 "Remoting_Default")); 1492 } 1493 } 1494 } 1495 1496 1497 //+======================================================================== 1498 // 1499 // Synopsis: Specialization of MessageDictionary for ConstructorCallMessage objects 1500 // 1501 //-======================================================================== 1502 1503 internal class CRMDictionary : MessageDictionary 1504 { 1505 public static String[] CRMkeysFault = { 1506 "__Uri", 1507 "__MethodName", 1508 "__MethodSignature", 1509 "__TypeName", 1510 "__CallContext"}; 1511 public static String[] CRMkeysNoFault = { 1512 "__Uri", 1513 "__MethodName", 1514 "__MethodSignature", 1515 "__TypeName", 1516 "__Return", 1517 "__OutArgs", 1518 "__CallContext"}; 1519 internal IConstructionReturnMessage _crmsg; 1520 internal bool fault; 1521 1522 [System.Security.SecurityCritical] // auto-generated CRMDictionary(IConstructionReturnMessage msg, IDictionary idict)1523 public CRMDictionary(IConstructionReturnMessage msg, IDictionary idict) 1524 : base( (msg.Exception!=null)? CRMkeysFault : CRMkeysNoFault, idict) 1525 { 1526 fault = (msg.Exception != null) ; 1527 _crmsg = msg; 1528 } 1529 1530 [System.Security.SecuritySafeCritical] // auto-generated GetMessageValue(int i)1531 internal override Object GetMessageValue(int i) 1532 { 1533 switch (i) 1534 { 1535 case 0: 1536 return _crmsg.Uri; 1537 case 1: 1538 return _crmsg.MethodName; 1539 case 2: 1540 return _crmsg.MethodSignature; 1541 case 3: 1542 return _crmsg.TypeName; 1543 case 4: 1544 return fault ? FetchLogicalCallContext() : _crmsg.ReturnValue; 1545 case 5: 1546 return _crmsg.Args; 1547 case 6: 1548 return FetchLogicalCallContext(); 1549 } 1550 throw new RemotingException( 1551 Environment.GetResourceString( 1552 "Remoting_Default")); 1553 } 1554 1555 [System.Security.SecurityCritical] // auto-generated FetchLogicalCallContext()1556 private LogicalCallContext FetchLogicalCallContext() 1557 { 1558 ReturnMessage retMsg = _crmsg as ReturnMessage; 1559 if (null != retMsg) 1560 { 1561 return retMsg.GetLogicalCallContext(); 1562 } 1563 else 1564 { 1565 MethodResponse mr = _crmsg as MethodResponse; 1566 if (null != mr) 1567 { 1568 return mr.GetLogicalCallContext(); 1569 } 1570 else 1571 { 1572 throw new RemotingException( 1573 Environment.GetResourceString( 1574 "Remoting_Message_BadType")); 1575 } 1576 } 1577 } 1578 1579 [System.Security.SecurityCritical] SetSpecialKey(int keyNum, Object value)1580 internal override void SetSpecialKey(int keyNum, Object value) 1581 { 1582 // NOTE: we use this for Uri & CallContext only ... 1583 1584 ReturnMessage rm = _crmsg as ReturnMessage; 1585 MethodResponse mr = _crmsg as MethodResponse; 1586 switch(keyNum) 1587 { 1588 case 0: 1589 if (null != rm) 1590 { 1591 rm.Uri = (String)value; 1592 } 1593 else 1594 { 1595 1596 if (null != mr) 1597 { 1598 mr.Uri = (String)value; 1599 } 1600 else 1601 { 1602 throw new RemotingException( 1603 Environment.GetResourceString( 1604 "Remoting_Message_BadType")); 1605 } 1606 } 1607 break; 1608 case 1: 1609 if (null != rm) 1610 { 1611 rm.SetLogicalCallContext((LogicalCallContext)value); 1612 } 1613 else 1614 { 1615 1616 if (null != mr) 1617 { 1618 mr.SetLogicalCallContext((LogicalCallContext)value); 1619 } 1620 else 1621 { 1622 throw new RemotingException( 1623 Environment.GetResourceString( 1624 "Remoting_Message_BadType")); 1625 } 1626 } 1627 break; 1628 default: 1629 throw new RemotingException( 1630 Environment.GetResourceString( 1631 "Remoting_Default")); 1632 } 1633 } 1634 } 1635 1636 //+================================================================================ 1637 // 1638 // Synopsis: Specialization of MessageDictionary for MethodCallMessage 1639 // 1640 //-======================================================================== 1641 1642 internal class MCMDictionary : MessageDictionary 1643 { 1644 public static String[] MCMkeys = { 1645 "__Uri", 1646 "__MethodName", 1647 "__MethodSignature", 1648 "__TypeName", 1649 "__Args", 1650 "__CallContext"}; 1651 1652 internal IMethodCallMessage _mcmsg; // back pointer to message object 1653 1654 MCMDictionary(IMethodCallMessage msg, IDictionary idict)1655 public MCMDictionary(IMethodCallMessage msg, IDictionary idict) 1656 : base(MCMkeys, idict) 1657 { 1658 _mcmsg = msg; 1659 } 1660 1661 [System.Security.SecuritySafeCritical] // auto-generated GetMessageValue(int i)1662 internal override Object GetMessageValue(int i) 1663 { 1664 switch (i) 1665 { 1666 case 0: 1667 return _mcmsg.Uri; 1668 case 1: 1669 return _mcmsg.MethodName; 1670 case 2: 1671 return _mcmsg.MethodSignature; 1672 case 3: 1673 return _mcmsg.TypeName; 1674 case 4: 1675 return _mcmsg.Args; 1676 case 5: 1677 return FetchLogicalCallContext(); 1678 } 1679 1680 // Shouldn't get here. 1681 throw new RemotingException( 1682 Environment.GetResourceString( 1683 "Remoting_Default")); 1684 } 1685 1686 [System.Security.SecurityCritical] // auto-generated FetchLogicalCallContext()1687 private LogicalCallContext FetchLogicalCallContext() 1688 { 1689 Message msg = _mcmsg as Message; 1690 if (null != msg) 1691 { 1692 return msg.GetLogicalCallContext(); 1693 } 1694 else 1695 { 1696 MethodCall mc = _mcmsg as MethodCall; 1697 if (null != mc) 1698 { 1699 return mc.GetLogicalCallContext(); 1700 } 1701 else 1702 { 1703 throw new RemotingException( 1704 Environment.GetResourceString( 1705 "Remoting_Message_BadType")); 1706 } 1707 } 1708 } 1709 1710 [System.Security.SecurityCritical] SetSpecialKey(int keyNum, Object value)1711 internal override void SetSpecialKey(int keyNum, Object value) 1712 { 1713 Message msg = _mcmsg as Message; 1714 MethodCall mc = _mcmsg as MethodCall; 1715 switch (keyNum) 1716 { 1717 case 0: 1718 if(null != msg) 1719 { 1720 msg.Uri = (String)value; 1721 } 1722 else if (null != mc) 1723 { 1724 mc.Uri = (String)value; 1725 } 1726 else 1727 { 1728 throw new RemotingException( 1729 Environment.GetResourceString( 1730 "Remoting_Message_BadType")); 1731 } 1732 break; 1733 1734 case 1: 1735 if(null != msg) 1736 { 1737 msg.SetLogicalCallContext((LogicalCallContext)value); 1738 } 1739 else 1740 { 1741 throw new RemotingException( 1742 Environment.GetResourceString( 1743 "Remoting_Message_BadType")); 1744 } 1745 break; 1746 default: 1747 // Shouldn't get here. 1748 throw new RemotingException( 1749 Environment.GetResourceString( 1750 "Remoting_Default")); 1751 } 1752 } 1753 } 1754 1755 //+================================================================================ 1756 // 1757 // Synopsis: Specialization of MessageDictionary for MethodReturnMessage objects 1758 // 1759 //-================================================================================ 1760 internal class MRMDictionary : MessageDictionary 1761 { 1762 public static String[] MCMkeysFault = {"__CallContext"}; 1763 public static String[] MCMkeysNoFault = { 1764 "__Uri", 1765 "__MethodName", 1766 "__MethodSignature", 1767 "__TypeName", 1768 "__Return", 1769 "__OutArgs", 1770 "__CallContext"}; 1771 1772 internal IMethodReturnMessage _mrmsg; 1773 internal bool fault; 1774 1775 [System.Security.SecurityCritical] // auto-generated MRMDictionary(IMethodReturnMessage msg, IDictionary idict)1776 public MRMDictionary(IMethodReturnMessage msg, IDictionary idict) 1777 : base((msg.Exception != null) ? MCMkeysFault : MCMkeysNoFault, idict) 1778 { 1779 fault = (msg.Exception != null) ; 1780 _mrmsg = msg; 1781 } 1782 1783 [System.Security.SecuritySafeCritical] GetMessageValue(int i)1784 internal override Object GetMessageValue(int i) 1785 { 1786 switch (i) 1787 { 1788 case 0: 1789 if (fault) 1790 return FetchLogicalCallContext(); 1791 else 1792 return _mrmsg.Uri; 1793 case 1: 1794 return _mrmsg.MethodName; 1795 case 2: 1796 return _mrmsg.MethodSignature; 1797 case 3: 1798 return _mrmsg.TypeName; 1799 case 4: 1800 if (fault) 1801 { 1802 return _mrmsg.Exception; 1803 } 1804 else 1805 { 1806 return _mrmsg.ReturnValue; 1807 } 1808 case 5: 1809 return _mrmsg.Args; 1810 case 6: 1811 return FetchLogicalCallContext(); 1812 } 1813 // Shouldn't get here. 1814 throw new RemotingException( 1815 Environment.GetResourceString( 1816 "Remoting_Default")); 1817 } 1818 1819 [System.Security.SecurityCritical] // auto-generated FetchLogicalCallContext()1820 private LogicalCallContext FetchLogicalCallContext() 1821 { 1822 ReturnMessage rm = _mrmsg as ReturnMessage; 1823 if (null != rm) 1824 { 1825 return rm.GetLogicalCallContext(); 1826 } 1827 else 1828 { 1829 MethodResponse mr = _mrmsg as MethodResponse; 1830 if (null != mr) 1831 { 1832 return mr.GetLogicalCallContext(); 1833 } 1834 else 1835 { 1836 StackBasedReturnMessage srm = _mrmsg as StackBasedReturnMessage; 1837 if (null != srm) 1838 { 1839 return srm.GetLogicalCallContext(); 1840 } 1841 else 1842 { 1843 throw new RemotingException( 1844 Environment.GetResourceString( 1845 "Remoting_Message_BadType")); 1846 } 1847 } 1848 } 1849 } 1850 1851 [System.Security.SecurityCritical] SetSpecialKey(int keyNum, Object value)1852 internal override void SetSpecialKey(int keyNum, Object value) 1853 { 1854 // 0 == Uri 1855 // 1 == CallContext 1856 // NOTE : we use this for Uri & CallContext only ... 1857 ReturnMessage rm = _mrmsg as ReturnMessage; 1858 MethodResponse mr = _mrmsg as MethodResponse; 1859 1860 switch (keyNum) 1861 { 1862 case 0: 1863 if (null != rm) 1864 { 1865 rm.Uri = (String)value; 1866 } 1867 else 1868 { 1869 if (null != mr) 1870 { 1871 mr.Uri = (String)value; 1872 } 1873 else 1874 { 1875 throw new RemotingException( 1876 Environment.GetResourceString( 1877 "Remoting_Message_BadType")); 1878 } 1879 } 1880 break; 1881 case 1: 1882 if (null != rm) 1883 { 1884 rm.SetLogicalCallContext((LogicalCallContext)value); 1885 } 1886 else 1887 { 1888 1889 if (null != mr) 1890 { 1891 mr.SetLogicalCallContext((LogicalCallContext)value); 1892 } 1893 else 1894 { 1895 throw new RemotingException( 1896 Environment.GetResourceString( 1897 "Remoting_Message_BadType")); 1898 } 1899 } 1900 break; 1901 default: 1902 // Shouldn't get here. 1903 throw new RemotingException( 1904 Environment.GetResourceString( 1905 "Remoting_Default")); 1906 } 1907 } 1908 1909 } 1910 1911 //+================================================================================ 1912 // 1913 // Synopsis: Abstract class to help present a dictionary view of an object 1914 // 1915 //-================================================================================ 1916 internal abstract class MessageDictionary : IDictionary 1917 { 1918 internal String[] _keys; 1919 internal IDictionary _dict; 1920 MessageDictionary(String[] keys, IDictionary idict)1921 internal MessageDictionary(String[] keys, IDictionary idict) 1922 { 1923 _keys = keys; 1924 _dict = idict; 1925 } 1926 HasUserData()1927 internal bool HasUserData() 1928 { 1929 // used by message smuggler to determine if there is any custom user 1930 // data in the dictionary 1931 if ((_dict != null) && (_dict.Count > 0)) 1932 return true; 1933 else 1934 return false; 1935 } 1936 1937 // used by message smuggler, so that it doesn't have to iterate 1938 // through special keys 1939 internal IDictionary InternalDictionary 1940 { 1941 get { return _dict; } 1942 } 1943 1944 GetMessageValue(int i)1945 internal abstract Object GetMessageValue(int i); 1946 1947 [System.Security.SecurityCritical] SetSpecialKey(int keyNum, Object value)1948 internal abstract void SetSpecialKey(int keyNum, Object value); 1949 1950 public virtual bool IsReadOnly { get { return false; } } 1951 public virtual bool IsSynchronized { get { return false; } } 1952 public virtual bool IsFixedSize { get { return false; } } 1953 1954 public virtual Object SyncRoot { get { return this; } } 1955 1956 Contains(Object key)1957 public virtual bool Contains(Object key) 1958 { 1959 if (ContainsSpecialKey(key)) 1960 { 1961 return true; 1962 } 1963 else if (_dict != null) 1964 { 1965 return _dict.Contains(key); 1966 } 1967 return false; 1968 } 1969 ContainsSpecialKey(Object key)1970 protected virtual bool ContainsSpecialKey(Object key) 1971 { 1972 if (!(key is System.String)) 1973 { 1974 return false; 1975 } 1976 String skey = (String) key; 1977 for (int i = 0 ; i < _keys.Length; i++) 1978 { 1979 if (skey.Equals(_keys[i])) 1980 { 1981 return true; 1982 } 1983 } 1984 return false; 1985 } 1986 CopyTo(Array array, int index)1987 public virtual void CopyTo(Array array, int index) 1988 { 1989 for (int i=0; i<_keys.Length; i++) 1990 { 1991 array.SetValue(GetMessageValue(i), index+i); 1992 } 1993 1994 if (_dict != null) 1995 { 1996 _dict.CopyTo(array, index+_keys.Length); 1997 } 1998 } 1999 2000 public virtual Object this[Object key] 2001 { 2002 get 2003 { 2004 System.String skey = key as System.String; 2005 if (null != skey) 2006 { 2007 for (int i=0; i<_keys.Length; i++) 2008 { 2009 if (skey.Equals(_keys[i])) 2010 { 2011 return GetMessageValue(i); 2012 } 2013 } 2014 if (_dict != null) 2015 { 2016 return _dict[key]; 2017 } 2018 } 2019 return null; 2020 } 2021 [System.Security.SecuritySafeCritical] // 2022 set 2023 { 2024 if (ContainsSpecialKey(key)) 2025 { 2026 if (key.Equals(Message.UriKey)) 2027 { 2028 SetSpecialKey(0,value); 2029 } 2030 else if (key.Equals(Message.CallContextKey)) 2031 { 2032 SetSpecialKey(1,value); 2033 } 2034 else 2035 { 2036 throw new ArgumentException( 2037 Environment.GetResourceString( 2038 "Argument_InvalidKey")); 2039 } 2040 } 2041 else 2042 { 2043 if (_dict == null) 2044 { 2045 _dict = new Hashtable(); 2046 } 2047 _dict[key] = value; 2048 } 2049 2050 } 2051 } 2052 IDictionary.GetEnumerator()2053 IDictionaryEnumerator IDictionary.GetEnumerator() 2054 { 2055 return new MessageDictionaryEnumerator(this, _dict); 2056 } 2057 IEnumerable.GetEnumerator()2058 IEnumerator IEnumerable.GetEnumerator() 2059 { 2060 throw new NotSupportedException(); 2061 } 2062 2063 Add(Object key, Object value)2064 public virtual void Add(Object key, Object value) 2065 { 2066 if (ContainsSpecialKey(key)) 2067 { 2068 throw new ArgumentException( 2069 Environment.GetResourceString( 2070 "Argument_InvalidKey")); 2071 } 2072 else 2073 { 2074 if (_dict == null) 2075 { 2076 // no need to interlock, message object not guaranteed to 2077 // be thread-safe. 2078 _dict = new Hashtable(); 2079 } 2080 _dict.Add(key, value); 2081 } 2082 } 2083 Clear()2084 public virtual void Clear() 2085 { 2086 // Remove all the entries from the hash table 2087 if (null != _dict) 2088 { 2089 _dict.Clear(); 2090 } 2091 } 2092 Remove(Object key)2093 public virtual void Remove(Object key) 2094 { 2095 if (ContainsSpecialKey(key) || (_dict == null)) 2096 { 2097 throw new ArgumentException( 2098 Environment.GetResourceString( 2099 "Argument_InvalidKey")); 2100 } 2101 else 2102 { 2103 _dict.Remove(key); 2104 } 2105 } 2106 2107 public virtual ICollection Keys 2108 { 2109 get 2110 { 2111 2112 int len = _keys.Length; 2113 ICollection c = (_dict != null) ? _dict.Keys : null; 2114 if (c != null) 2115 { 2116 len += c.Count; 2117 } 2118 2119 ArrayList l = new ArrayList(len); 2120 for (int i = 0; i<_keys.Length; i++) 2121 { 2122 l.Add(_keys[i]); 2123 } 2124 2125 if (c != null) 2126 { 2127 l.AddRange(c); 2128 } 2129 2130 return l; 2131 } 2132 } 2133 2134 public virtual ICollection Values 2135 { 2136 get 2137 { 2138 int len = _keys.Length; 2139 ICollection c = (_dict != null) ? _dict.Keys : null; 2140 if (c != null) 2141 { 2142 len += c.Count; 2143 } 2144 2145 ArrayList l = new ArrayList(len); 2146 2147 for (int i = 0; i<_keys.Length; i++) 2148 { 2149 l.Add(GetMessageValue(i)); 2150 } 2151 2152 if (c != null) 2153 { 2154 l.AddRange(c); 2155 } 2156 return l; 2157 } 2158 } 2159 2160 public virtual int Count 2161 { 2162 get 2163 { 2164 if (_dict != null) 2165 { 2166 return _dict.Count+_keys.Length; 2167 } 2168 else 2169 { 2170 return _keys.Length; 2171 } 2172 } 2173 } 2174 2175 } 2176 2177 //+================================================================================ 2178 // 2179 // Synopsis: Dictionary enumerator for helper class 2180 // 2181 //-================================================================================ 2182 internal class MessageDictionaryEnumerator : IDictionaryEnumerator 2183 { 2184 private int i=-1; 2185 private IDictionaryEnumerator _enumHash; 2186 private MessageDictionary _md; 2187 2188 MessageDictionaryEnumerator(MessageDictionary md, IDictionary hashtable)2189 public MessageDictionaryEnumerator(MessageDictionary md, IDictionary hashtable) 2190 { 2191 _md = md; 2192 if (hashtable != null) 2193 { 2194 _enumHash = hashtable.GetEnumerator(); 2195 } 2196 else 2197 { 2198 _enumHash = null; 2199 } 2200 } 2201 // Returns the key of the current element of the enumeration. The returned 2202 // value is undefined before the first call to GetNext and following 2203 // a call to GetNext that returned false. Multiple calls to 2204 // GetKey with no intervening calls to GetNext will return 2205 // the same object. 2206 // 2207 public Object Key { 2208 get { 2209 Message.DebugOut("MessageDE::GetKey i = " + i + "\n"); 2210 if (i < 0) 2211 { 2212 throw new InvalidOperationException( 2213 Environment.GetResourceString( 2214 "InvalidOperation_InternalState")); 2215 } 2216 if (i < _md._keys.Length) 2217 { 2218 return _md._keys[i]; 2219 } 2220 else 2221 { 2222 Contract.Assert(_enumHash != null,"_enumHash != null"); 2223 return _enumHash.Key; 2224 } 2225 } 2226 } 2227 2228 // Returns the value of the current element of the enumeration. The 2229 // returned value is undefined before the first call to GetNext and 2230 // following a call to GetNext that returned false. Multiple calls 2231 // to GetValue with no intervening calls to GetNext will 2232 // return the same object. 2233 // 2234 public Object Value { 2235 get { 2236 if (i < 0) 2237 { 2238 throw new InvalidOperationException( 2239 Environment.GetResourceString( 2240 "InvalidOperation_InternalState")); 2241 } 2242 2243 if (i < _md._keys.Length) 2244 { 2245 return _md.GetMessageValue(i); 2246 } 2247 else 2248 { 2249 Contract.Assert(_enumHash != null,"_enumHash != null"); 2250 return _enumHash.Value; 2251 } 2252 } 2253 } 2254 2255 // Advances the enumerator to the next element of the enumeration and 2256 // returns a boolean indicating whether an element is available. Upon 2257 // creation, an enumerator is conceptually positioned before the first 2258 // element of the enumeration, and the first call to GetNext brings 2259 // the first element of the enumeration into view. 2260 // MoveNext()2261 public bool MoveNext() 2262 { 2263 if (i == -2) 2264 { 2265 throw new InvalidOperationException( 2266 Environment.GetResourceString( 2267 "InvalidOperation_InternalState")); 2268 } 2269 i++; 2270 if (i < _md._keys.Length) 2271 { 2272 return true; 2273 } 2274 else 2275 { 2276 if (_enumHash != null && _enumHash.MoveNext()) 2277 { 2278 return true; 2279 } 2280 else 2281 { 2282 i = -2; 2283 return false; 2284 } 2285 } 2286 } 2287 2288 // Returns the current element of the enumeration. The returned value is 2289 // undefined before the first call to MoveNext and following a call 2290 // to MoveNext that returned false. Multiple calls to 2291 // Current with no intervening calls to MoveNext will return 2292 // the same object. 2293 // 2294 public Object Current { 2295 get { 2296 return Entry; 2297 } 2298 } 2299 2300 public DictionaryEntry Entry { 2301 get { 2302 return new DictionaryEntry(Key, Value); 2303 } 2304 } 2305 2306 // Resets the enumerator, positioning it before the first element. If an 2307 // Enumerator doesn't support Reset, a NotSupportedException is 2308 // thrown. Reset()2309 public void Reset() 2310 { 2311 i = -1; 2312 if (_enumHash != null) 2313 { 2314 _enumHash.Reset(); 2315 } 2316 } 2317 } 2318 2319 //+================================================================================ 2320 // 2321 // Synopsis: Message for return from a stack blit call 2322 // 2323 //-================================================================================ 2324 internal class StackBasedReturnMessage : IMethodReturnMessage, IInternalMessage 2325 { 2326 Message _m; 2327 Hashtable _h; 2328 MRMDictionary _d; 2329 ArgMapper _argMapper; 2330 StackBasedReturnMessage()2331 internal StackBasedReturnMessage() {} 2332 2333 // NOTE: This method is called multiple times as we reuse the 2334 // message object. Make sure that you reset any fields that you 2335 // add to the message object to the default values. This will 2336 // ensure that the reused message object starts with the correct 2337 // values. InitFields(Message m)2338 internal void InitFields(Message m) 2339 { 2340 _m = m; 2341 if (null != _h) 2342 { 2343 // Remove all the hashtable entries 2344 _h.Clear(); 2345 } 2346 if (null != _d) 2347 { 2348 // Remove all the dictionary entries 2349 _d.Clear(); 2350 } 2351 } 2352 2353 public String Uri 2354 { 2355 [System.Security.SecurityCritical] // auto-generated 2356 get {return _m.Uri;} 2357 } 2358 2359 public String MethodName 2360 { 2361 [System.Security.SecurityCritical] // auto-generated 2362 get {return _m.MethodName;} 2363 } 2364 2365 public String TypeName 2366 { 2367 [System.Security.SecurityCritical] // auto-generated 2368 get {return _m.TypeName;} 2369 } 2370 2371 public Object MethodSignature 2372 { 2373 [System.Security.SecurityCritical] // auto-generated 2374 get {return _m.MethodSignature;} 2375 } 2376 2377 public MethodBase MethodBase 2378 { 2379 [System.Security.SecurityCritical] // auto-generated 2380 get {return _m.MethodBase;} 2381 } 2382 2383 public bool HasVarArgs 2384 { 2385 [System.Security.SecurityCritical] // auto-generated 2386 get {return _m.HasVarArgs;} 2387 } 2388 2389 public int ArgCount 2390 { 2391 [System.Security.SecurityCritical] // auto-generated 2392 get {return _m.ArgCount;} 2393 } 2394 2395 [System.Security.SecurityCritical] // auto-generated GetArg(int argNum)2396 public Object GetArg(int argNum) {return _m.GetArg(argNum);} 2397 [System.Security.SecurityCritical] // auto-generated GetArgName(int index)2398 public String GetArgName(int index) {return _m.GetArgName(index);} 2399 public Object[] Args 2400 { 2401 [System.Security.SecurityCritical] // auto-generated 2402 get {return _m.Args;} 2403 } 2404 public LogicalCallContext LogicalCallContext 2405 { 2406 [System.Security.SecurityCritical] // auto-generated 2407 get { return _m.GetLogicalCallContext(); } 2408 } 2409 2410 [System.Security.SecurityCritical] // auto-generated GetLogicalCallContext()2411 internal LogicalCallContext GetLogicalCallContext() {return _m.GetLogicalCallContext();} 2412 [System.Security.SecurityCritical] // auto-generated SetLogicalCallContext(LogicalCallContext callCtx)2413 internal LogicalCallContext SetLogicalCallContext(LogicalCallContext callCtx) 2414 { 2415 return _m.SetLogicalCallContext(callCtx); 2416 } 2417 2418 public int OutArgCount 2419 { 2420 [System.Security.SecurityCritical] // auto-generated 2421 get 2422 { 2423 if (_argMapper == null) _argMapper = new ArgMapper(this, true); 2424 return _argMapper.ArgCount; 2425 } 2426 } 2427 2428 [System.Security.SecurityCritical] // auto-generated GetOutArg(int argNum)2429 public Object GetOutArg(int argNum) 2430 { 2431 if (_argMapper == null) _argMapper = new ArgMapper(this, true); 2432 return _argMapper.GetArg(argNum); 2433 } 2434 2435 [System.Security.SecurityCritical] // auto-generated GetOutArgName(int index)2436 public String GetOutArgName(int index) 2437 { 2438 if (_argMapper == null) _argMapper = new ArgMapper(this, true); 2439 return _argMapper.GetArgName(index); 2440 } 2441 public Object[] OutArgs 2442 { 2443 [System.Security.SecurityCritical] // auto-generated 2444 get 2445 { 2446 if (_argMapper == null) _argMapper = new ArgMapper(this, true); 2447 return _argMapper.Args; 2448 } 2449 } 2450 2451 public Exception Exception 2452 { 2453 [System.Security.SecurityCritical] // auto-generated 2454 get {return null;} 2455 } 2456 2457 public Object ReturnValue 2458 { 2459 [System.Security.SecurityCritical] // auto-generated 2460 get {return _m.GetReturnValue();} 2461 } 2462 2463 public IDictionary Properties 2464 { 2465 [System.Security.SecurityCritical] // auto-generated 2466 get 2467 { 2468 lock(this) 2469 { 2470 if (_h == null) 2471 { 2472 _h = new Hashtable(); 2473 } 2474 if (_d == null) 2475 { 2476 _d = new MRMDictionary(this, _h); 2477 } 2478 return _d; 2479 } 2480 } 2481 } 2482 2483 // 2484 // IInternalMessage 2485 // 2486 2487 ServerIdentity IInternalMessage.ServerIdentityObject 2488 { 2489 [System.Security.SecurityCritical] 2490 get { return null; } 2491 [System.Security.SecurityCritical] 2492 set {} 2493 } 2494 2495 Identity IInternalMessage.IdentityObject 2496 { 2497 [System.Security.SecurityCritical] 2498 get { return null; } 2499 [System.Security.SecurityCritical] 2500 set {} 2501 } 2502 2503 [System.Security.SecurityCritical] IInternalMessage.SetURI(String val)2504 void IInternalMessage.SetURI(String val) 2505 { 2506 _m.Uri = val; 2507 } 2508 2509 [System.Security.SecurityCritical] IInternalMessage.SetCallContext(LogicalCallContext newCallContext)2510 void IInternalMessage.SetCallContext(LogicalCallContext newCallContext) 2511 { 2512 _m.SetLogicalCallContext(newCallContext); 2513 } 2514 2515 [System.Security.SecurityCritical] IInternalMessage.HasProperties()2516 bool IInternalMessage.HasProperties() 2517 { 2518 return _h != null; 2519 } 2520 } // class StackBasedReturnMessage 2521 2522 2523 //+================================================================================ 2524 // 2525 // Synopsis: Message for return from a stack builder sink call 2526 // 2527 //-================================================================================ 2528 [System.Security.SecurityCritical] // auto-generated_required 2529 [SecurityPermissionAttribute(SecurityAction.InheritanceDemand, Flags=SecurityPermissionFlag.Infrastructure)] 2530 [System.Runtime.InteropServices.ComVisible(true)] 2531 public class ReturnMessage : IMethodReturnMessage 2532 { 2533 internal Object _ret; 2534 internal Object _properties; 2535 internal String _URI; 2536 internal Exception _e; 2537 internal Object[] _outArgs; 2538 internal int _outArgsCount; 2539 internal String _methodName; 2540 internal String _typeName; 2541 internal Type[] _methodSignature; 2542 internal bool _hasVarArgs; 2543 internal LogicalCallContext _callContext; 2544 internal ArgMapper _argMapper; 2545 internal MethodBase _methodBase; 2546 2547 [System.Security.SecurityCritical] // auto-generated ReturnMessage(Object ret, Object[] outArgs, int outArgsCount, LogicalCallContext callCtx, IMethodCallMessage mcm)2548 public ReturnMessage(Object ret, Object[] outArgs, int outArgsCount, LogicalCallContext callCtx, 2549 IMethodCallMessage mcm) 2550 { 2551 _ret = ret; 2552 _outArgs = outArgs; 2553 _outArgsCount = outArgsCount; 2554 2555 if (callCtx != null) 2556 _callContext = callCtx; 2557 else 2558 _callContext = Thread.CurrentThread.GetMutableExecutionContext().LogicalCallContext; 2559 2560 if (mcm != null) 2561 { 2562 _URI = mcm.Uri; 2563 _methodName = mcm.MethodName; 2564 _methodSignature = null; 2565 _typeName = mcm.TypeName; 2566 _hasVarArgs = mcm.HasVarArgs; 2567 _methodBase = mcm.MethodBase; 2568 } 2569 } 2570 2571 [System.Security.SecurityCritical] // auto-generated ReturnMessage(Exception e, IMethodCallMessage mcm)2572 public ReturnMessage(Exception e, IMethodCallMessage mcm) 2573 { 2574 _e = IsCustomErrorEnabled()? new RemotingException(Environment.GetResourceString("Remoting_InternalError")):e; 2575 _callContext = Thread.CurrentThread.GetMutableExecutionContext().LogicalCallContext; 2576 if (mcm != null) 2577 { 2578 _URI = mcm.Uri; 2579 _methodName = mcm.MethodName; 2580 _methodSignature = null; 2581 _typeName = mcm.TypeName; 2582 _hasVarArgs = mcm.HasVarArgs; 2583 _methodBase = mcm.MethodBase; 2584 } 2585 } 2586 2587 public String Uri 2588 { 2589 [System.Security.SecurityCritical] 2590 get { return _URI; } 2591 set { _URI = value; } 2592 } 2593 public String MethodName 2594 { 2595 [System.Security.SecurityCritical] 2596 get { return _methodName; } 2597 } 2598 public String TypeName 2599 { 2600 [System.Security.SecurityCritical] 2601 get { return _typeName; } 2602 } 2603 public Object MethodSignature 2604 { 2605 [System.Security.SecurityCritical] 2606 get 2607 { 2608 if ((_methodSignature == null) && (_methodBase != null)) 2609 _methodSignature = Message.GenerateMethodSignature(_methodBase); 2610 2611 return _methodSignature; 2612 } 2613 } 2614 2615 public MethodBase MethodBase 2616 { 2617 [System.Security.SecurityCritical] 2618 get { return _methodBase; } 2619 } 2620 2621 public bool HasVarArgs 2622 { 2623 [System.Security.SecurityCritical] 2624 get 2625 { 2626 return _hasVarArgs; 2627 } 2628 2629 } 2630 2631 public int ArgCount 2632 { 2633 [System.Security.SecurityCritical] 2634 get 2635 { 2636 if (_outArgs == null) 2637 { 2638 return _outArgsCount; 2639 } 2640 else 2641 { 2642 return _outArgs.Length; 2643 } 2644 } 2645 } 2646 2647 [System.Security.SecurityCritical] GetArg(int argNum)2648 public Object GetArg(int argNum) 2649 { 2650 if (_outArgs == null) 2651 { 2652 if ((argNum<0) || (argNum>=_outArgsCount)) 2653 { 2654 throw new ArgumentOutOfRangeException("argNum"); 2655 } 2656 return null; 2657 } 2658 else 2659 { 2660 if ((argNum<0) || (argNum>=_outArgs.Length)) 2661 { 2662 throw new ArgumentOutOfRangeException("argNum"); 2663 } 2664 return _outArgs[argNum]; 2665 } 2666 2667 } 2668 2669 [System.Security.SecurityCritical] // auto-generated GetArgName(int index)2670 public String GetArgName(int index) 2671 { 2672 2673 if (_outArgs == null) 2674 { 2675 if ((index < 0) || (index>=_outArgsCount)) 2676 { 2677 throw new ArgumentOutOfRangeException("index"); 2678 } 2679 } 2680 else 2681 { 2682 if ((index < 0) || (index>=_outArgs.Length)) 2683 { 2684 throw new ArgumentOutOfRangeException("index"); 2685 } 2686 } 2687 2688 if (_methodBase != null) 2689 { 2690 RemotingMethodCachedData methodCache = InternalRemotingServices.GetReflectionCachedData(_methodBase); 2691 return methodCache.Parameters[index].Name; 2692 } 2693 else 2694 return "__param" + index; 2695 } 2696 2697 public Object[] Args 2698 { 2699 [System.Security.SecurityCritical] 2700 get 2701 { 2702 if (_outArgs == null) 2703 { 2704 return new Object[_outArgsCount]; 2705 } 2706 return _outArgs; 2707 } 2708 } 2709 2710 public int OutArgCount 2711 { 2712 [System.Security.SecurityCritical] 2713 get 2714 { 2715 if (_argMapper == null) _argMapper = new ArgMapper(this, true); 2716 return _argMapper.ArgCount; 2717 } 2718 } 2719 2720 [System.Security.SecurityCritical] GetOutArg(int argNum)2721 public Object GetOutArg(int argNum) 2722 { 2723 if (_argMapper == null) _argMapper = new ArgMapper(this, true); 2724 return _argMapper.GetArg(argNum); 2725 } 2726 2727 [System.Security.SecurityCritical] GetOutArgName(int index)2728 public String GetOutArgName(int index) 2729 { 2730 if (_argMapper == null) _argMapper = new ArgMapper(this, true); 2731 return _argMapper.GetArgName(index); 2732 } 2733 public Object[] OutArgs 2734 { 2735 [System.Security.SecurityCritical] 2736 get 2737 { 2738 if (_argMapper == null) _argMapper = new ArgMapper(this, true); 2739 return _argMapper.Args; 2740 } 2741 } 2742 2743 public Exception Exception 2744 { 2745 [System.Security.SecurityCritical] 2746 get { return _e; } 2747 } 2748 public virtual Object ReturnValue 2749 { 2750 [System.Security.SecurityCritical] 2751 get { return _ret; } 2752 } 2753 2754 public virtual IDictionary Properties 2755 { 2756 [System.Security.SecurityCritical] 2757 get 2758 { 2759 if (_properties == null) 2760 { 2761 _properties = new MRMDictionary(this, null); 2762 } 2763 return(MRMDictionary) _properties; 2764 } 2765 } 2766 2767 public LogicalCallContext LogicalCallContext 2768 { 2769 [System.Security.SecurityCritical] // auto-generated 2770 get { return GetLogicalCallContext();} 2771 } 2772 2773 2774 [System.Security.SecurityCritical] // auto-generated GetLogicalCallContext()2775 internal LogicalCallContext GetLogicalCallContext() 2776 { 2777 if (_callContext == null) 2778 _callContext = new LogicalCallContext(); 2779 return _callContext; 2780 } 2781 SetLogicalCallContext(LogicalCallContext ctx)2782 internal LogicalCallContext SetLogicalCallContext(LogicalCallContext ctx) 2783 { 2784 LogicalCallContext old = _callContext; 2785 _callContext=ctx; 2786 return old; 2787 } 2788 2789 // used to determine if the properties dictionary has already been created HasProperties()2790 internal bool HasProperties() 2791 { 2792 return _properties != null; 2793 } 2794 [System.Security.SecurityCritical] // auto-generated IsCustomErrorEnabled()2795 static internal bool IsCustomErrorEnabled(){ 2796 Object oIsCustomErrorEnabled = CallContext.GetData("__CustomErrorsEnabled"); 2797 // The server side will always have this CallContext item set. If it is not set then 2798 // it means this is the client side. In that case customError is false. 2799 return (oIsCustomErrorEnabled == null) ? false:(bool)oIsCustomErrorEnabled; 2800 } 2801 2802 } // class ReturnMessage 2803 2804 //+================================================================================ 2805 // 2806 // Synopsis: Message used for deserialization of a method call 2807 // 2808 //-================================================================================ 2809 /// <internalonly/> 2810 [System.Security.SecurityCritical] // auto-generated_required 2811 [Serializable] 2812 [CLSCompliant(false)] 2813 [SecurityPermissionAttribute(SecurityAction.InheritanceDemand, Flags=SecurityPermissionFlag.Infrastructure)] 2814 [System.Runtime.InteropServices.ComVisible(true)] 2815 public class MethodCall : IMethodCallMessage, ISerializable, IInternalMessage, ISerializationRootObject 2816 { 2817 2818 private const BindingFlags LookupAll = BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic; 2819 private const BindingFlags LookupPublic = BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public; 2820 2821 // data 2822 private String uri; 2823 private String methodName; 2824 private MethodBase MI; 2825 private String typeName; 2826 private Object[] args; 2827 private Type[] instArgs; 2828 private LogicalCallContext callContext; 2829 private Type[] methodSignature; 2830 /// <internalonly/> 2831 protected IDictionary ExternalProperties = null; 2832 /// <internalonly/> 2833 protected IDictionary InternalProperties = null; 2834 2835 private ServerIdentity srvID; 2836 private Identity identity; 2837 private bool fSoap; 2838 private bool fVarArgs = false; 2839 private ArgMapper argMapper; 2840 2841 // 2842 // MethodCall -- SOAP uses this constructor 2843 // 2844 2845 /// <internalonly/> 2846 [System.Security.SecurityCritical] // auto-generated MethodCall(Header[] h1)2847 public MethodCall(Header[] h1) 2848 { 2849 Message.DebugOut("MethodCall ctor IN headers: " + (h1 == null ? "<null>" : h1.ToString()) + "\n"); 2850 2851 Init(); 2852 2853 fSoap = true; 2854 FillHeaders(h1); 2855 2856 ResolveMethod(); 2857 2858 Message.DebugOut("MethodCall ctor OUT\n"); 2859 } 2860 2861 // 2862 // MethodCall -- this constructor is used for copying an existing message 2863 // 2864 2865 [System.Security.SecurityCritical] // auto-generated MethodCall(IMessage msg)2866 public MethodCall(IMessage msg) 2867 { 2868 if (msg == null) 2869 throw new ArgumentNullException("msg"); 2870 Contract.EndContractBlock(); 2871 2872 Init(); 2873 2874 IDictionaryEnumerator de = msg.Properties.GetEnumerator(); 2875 while (de.MoveNext()) 2876 { 2877 FillHeader(de.Key.ToString(), de.Value); 2878 } 2879 2880 IMethodCallMessage mcm = msg as IMethodCallMessage; 2881 if (mcm != null) 2882 2883 MI = mcm.MethodBase; 2884 2885 ResolveMethod(); 2886 } 2887 2888 [System.Security.SecurityCritical] // auto-generated MethodCall(SerializationInfo info, StreamingContext context)2889 internal MethodCall(SerializationInfo info, StreamingContext context) 2890 { 2891 if (info == null) 2892 throw new ArgumentNullException("info"); 2893 Contract.EndContractBlock(); 2894 Init(); 2895 2896 SetObjectData(info, context); 2897 } 2898 2899 2900 [System.Security.SecurityCritical] // auto-generated MethodCall(SmuggledMethodCallMessage smuggledMsg, ArrayList deserializedArgs)2901 internal MethodCall(SmuggledMethodCallMessage smuggledMsg, ArrayList deserializedArgs) 2902 { 2903 uri = smuggledMsg.Uri; 2904 typeName = smuggledMsg.TypeName; 2905 methodName = smuggledMsg.MethodName; 2906 methodSignature = (Type[])smuggledMsg.GetMethodSignature(deserializedArgs); 2907 args = smuggledMsg.GetArgs(deserializedArgs); 2908 instArgs = smuggledMsg.GetInstantiation(deserializedArgs); 2909 callContext = smuggledMsg.GetCallContext(deserializedArgs); 2910 2911 ResolveMethod(); 2912 2913 if (smuggledMsg.MessagePropertyCount > 0) 2914 smuggledMsg.PopulateMessageProperties(Properties, deserializedArgs); 2915 } 2916 2917 [System.Security.SecurityCritical] // auto-generated MethodCall(Object handlerObject, BinaryMethodCallMessage smuggledMsg)2918 internal MethodCall(Object handlerObject, BinaryMethodCallMessage smuggledMsg) 2919 { 2920 if (handlerObject != null) 2921 { 2922 uri = handlerObject as String; 2923 if (uri == null) 2924 { 2925 // This must be the tranparent proxy 2926 MarshalByRefObject mbr = handlerObject as MarshalByRefObject; 2927 if (mbr != null) 2928 { 2929 bool fServer; 2930 srvID = MarshalByRefObject.GetIdentity(mbr, out fServer) as ServerIdentity; 2931 uri = srvID.URI; 2932 } 2933 } 2934 } 2935 2936 typeName = smuggledMsg.TypeName; 2937 methodName = smuggledMsg.MethodName; 2938 methodSignature = (Type[])smuggledMsg.MethodSignature; 2939 args = smuggledMsg.Args; 2940 instArgs = smuggledMsg.InstantiationArgs; 2941 callContext = smuggledMsg.LogicalCallContext; 2942 2943 ResolveMethod(); 2944 2945 if (smuggledMsg.HasProperties) 2946 smuggledMsg.PopulateMessageProperties(Properties); 2947 } 2948 2949 2950 2951 // 2952 // ISerializationRootObject 2953 // 2954 /// <internalonly/> 2955 [System.Security.SecurityCritical] // auto-generated RootSetObjectData(SerializationInfo info, StreamingContext ctx)2956 public void RootSetObjectData(SerializationInfo info, StreamingContext ctx) 2957 { 2958 SetObjectData(info, ctx); 2959 } 2960 2961 // 2962 // SetObjectData -- the class can also be initialized in part or in whole by serialization 2963 // in the SOAP case, both the constructor and SetObjectData init the object, in the non-SOAP 2964 // case, just SetObjectData is called 2965 // 2966 2967 [System.Security.SecurityCritical] // auto-generated SetObjectData(SerializationInfo info, StreamingContext context)2968 internal void SetObjectData(SerializationInfo info, StreamingContext context) 2969 { 2970 if (info == null) 2971 throw new ArgumentNullException("info"); 2972 Contract.EndContractBlock(); 2973 2974 if (fSoap) 2975 { 2976 SetObjectFromSoapData(info); 2977 } 2978 else 2979 { 2980 SerializationInfoEnumerator siEnum = info.GetEnumerator(); 2981 while (siEnum.MoveNext()) 2982 { 2983 FillHeader(siEnum.Name, siEnum.Value); 2984 } 2985 if ((context.State == StreamingContextStates.Remoting) && 2986 (context.Context != null)) 2987 { 2988 Header[] h = context.Context as Header[]; 2989 if(null != h) 2990 { 2991 for (int i=0; i<h.Length; i++) 2992 FillHeader(h[i].Name, h[i].Value); 2993 } 2994 } 2995 } 2996 } // SetObjectData 2997 2998 // 2999 // ResolveMethod 3000 // 3001 3002 #if FEATURE_REMOTING 3003 // This is used by Remoting ResolveTypeRelativeTo(String typeName, int offset, int count, Type serverType)3004 private static Type ResolveTypeRelativeTo(String typeName, int offset, int count, Type serverType) 3005 { 3006 Type type = ResolveTypeRelativeToBaseTypes(typeName, offset, count, serverType); 3007 if (type == null) 3008 { 3009 // compare against the interface list 3010 // GetInterfaces() returns a complete list of interfaces this type supports 3011 Type[] interfaces = serverType.GetInterfaces(); 3012 foreach (Type iface in interfaces) 3013 { 3014 String ifaceTypeName = iface.FullName; 3015 if (ifaceTypeName.Length == count) 3016 { 3017 if (String.CompareOrdinal(typeName, offset, ifaceTypeName, 0, count) == 0) 3018 { 3019 return iface; 3020 } 3021 } 3022 } 3023 } 3024 3025 return type; 3026 } // ResolveTypeRelativeTo 3027 3028 // This is used by Remoting ResolveTypeRelativeToBaseTypes(String typeName, int offset, int count, Type serverType)3029 private static Type ResolveTypeRelativeToBaseTypes(String typeName, int offset, int count, Type serverType) 3030 { 3031 // typeName is excepted to contain the full type name 3032 // offset is the start of the full type name within typeName 3033 // count us the number of characters in the full type name 3034 // serverType is the type of the server object 3035 3036 if ((typeName == null) || (serverType == null)) 3037 return null; 3038 3039 String serverTypeName = serverType.FullName; 3040 if (serverTypeName.Length == count) 3041 { 3042 if (String.CompareOrdinal(typeName, offset, serverTypeName, 0, count) == 0) 3043 { 3044 return serverType; 3045 } 3046 } 3047 3048 return ResolveTypeRelativeToBaseTypes(typeName, offset, count, serverType.BaseType); 3049 } // ResolveTypeRelativeTo 3050 #endif // FEATURE_REMOTING 3051 ResolveType()3052 internal Type ResolveType() 3053 { 3054 // resolve type 3055 Type t = null; 3056 3057 if (srvID == null) 3058 srvID = IdentityHolder.CasualResolveIdentity(uri) as ServerIdentity; 3059 3060 if (srvID != null) 3061 { 3062 Type serverType = srvID.GetLastCalledType(typeName); 3063 if (serverType != null) 3064 return serverType; 3065 int startIndex = 0; // start of type name 3066 3067 // check to see if type name starts with "clr:" 3068 if (String.CompareOrdinal(typeName, 0, "clr:", 0, 4) == 0) 3069 { 3070 // type starts just past "clr:" 3071 startIndex = 4; 3072 } 3073 3074 // find end of full type name 3075 int index = typeName.IndexOf(',', startIndex); 3076 if (index == -1) 3077 index = typeName.Length; 3078 3079 serverType = srvID.ServerType; 3080 t = ResolveTypeRelativeTo(typeName, startIndex, index - startIndex, serverType); 3081 } 3082 3083 if (t == null) 3084 { 3085 // fall back to Type.GetType() in case someone isn't using 3086 // our convention for the TypeName 3087 t = RemotingServices.InternalGetTypeFromQualifiedTypeName(typeName); 3088 } 3089 if (srvID != null) 3090 srvID.SetLastCalledType(typeName, t); 3091 return t; 3092 } // ResolveType 3093 3094 3095 /// <internalonly/> 3096 [System.Security.SecurityCritical] // auto-generated ResolveMethod()3097 public void ResolveMethod() 3098 { 3099 ResolveMethod(true); 3100 } 3101 3102 [System.Security.SecurityCritical] // auto-generated ResolveMethod(bool bThrowIfNotResolved)3103 internal void ResolveMethod(bool bThrowIfNotResolved) 3104 { 3105 if ((MI == null) && (methodName != null)) 3106 { 3107 BCLDebug.Trace("REMOTE", "TypeName: " + (typeName == null ? "<null>" : typeName) + "\n"); 3108 3109 // resolve type 3110 RuntimeType t = ResolveType() as RuntimeType; 3111 3112 BCLDebug.Trace("REMOTE", "Type: " + (t == null ? "<null>" : t.ToString()) + "\n"); 3113 if (methodName.Equals(".ctor")) 3114 return; 3115 if (t == null) 3116 { 3117 throw new RemotingException( 3118 String.Format( 3119 CultureInfo.CurrentCulture, Environment.GetResourceString( 3120 "Remoting_BadType"), 3121 typeName)); 3122 } 3123 3124 // Note: we reflect on non-public members here .. we do 3125 // block incoming remote calls and allow only specific methods 3126 // that we use for implementation of certain features (eg. 3127 // for remote field access) 3128 3129 // *********************************************************** 3130 // Note: For the common (non-overloaded method, urt-to-urt) case 3131 // methodSignature is null. 3132 // If the call is from a urt client to an overloaded method, 3133 // methodSignature is non-null. We could have a non-null 3134 // methodSignature if the call is from a non-urt client for 3135 // which we have to do special work if the method is overloaded 3136 // (in the try-catch below). 3137 // *********************************************************** 3138 if (null != methodSignature) 3139 { 3140 bool found = false; 3141 3142 int arity = instArgs == null ? 0 : instArgs.Length; 3143 3144 // Handle the common case efficiently, using GetMethod. 3145 // Note that GetMethod doesn't match methods with uninstantiated 3146 // generic arguments, so we can only use the fast case for 3147 // non-generic methods. 3148 if (arity == 0) 3149 { 3150 try 3151 { 3152 MI = t.GetMethod(methodName, 3153 MethodCall.LookupAll, 3154 null, 3155 CallingConventions.Any, 3156 methodSignature, 3157 null); 3158 found = true; 3159 } 3160 catch (AmbiguousMatchException) 3161 { 3162 // There is more than one match, so we'll have to do 3163 // a full search. 3164 } 3165 } 3166 3167 // Do a more thorough search if the fast case didn't succeed. 3168 if(!found) 3169 { 3170 // Make a list of all the methods with the right name. 3171 MemberInfo [] methods = t.FindMembers(MemberTypes.Method, MethodCall.LookupAll, Type.FilterName, methodName); 3172 3173 // Filter out all the methods with the wrong arity. 3174 // (Compress them into the start of the array then copy 3175 // them into a new array of exactly the right length). 3176 int candidates = 0; 3177 for (int i = 0; i < methods.Length; i++) 3178 { 3179 // MakeGenericMethod might throw if the generic arguments 3180 // can't be applied to the method in a type-safe way. 3181 // In that case, continue with the next method. 3182 try 3183 { 3184 MethodInfo mi = (MethodInfo)methods[i]; 3185 int miArity = mi.IsGenericMethod ? mi.GetGenericArguments().Length : 0; 3186 if (miArity == arity) 3187 { 3188 // Fill in generic arguments. 3189 if (arity > 0) 3190 { 3191 mi = mi.MakeGenericMethod(instArgs); 3192 } 3193 // Got a candidate, compress it back to the 3194 // start of the array. 3195 methods[candidates] = mi; 3196 candidates++; 3197 } 3198 } 3199 catch (ArgumentException) { } 3200 catch (VerificationException) { } 3201 } 3202 3203 MethodInfo[] matches = new MethodInfo[candidates]; 3204 for (int i = 0; i < candidates; i++) 3205 matches[i] = (MethodInfo)methods[i]; 3206 3207 // Use the default binder to select the right overload 3208 // based on signature. 3209 MI = Type.DefaultBinder.SelectMethod(MethodCall.LookupAll, 3210 matches, 3211 methodSignature, 3212 null); 3213 } 3214 3215 BCLDebug.Trace("REMOTE", "Method resolved w/sig ", MI == null ? "<null>" : "<not null>"); 3216 } 3217 else 3218 { 3219 3220 // Check the cache to see if you find the methodbase (unless 3221 // the method has an instantiation, in which case the method 3222 // name is not a unique key). 3223 RemotingTypeCachedData typeCache = null; 3224 if (instArgs == null) 3225 { 3226 typeCache = InternalRemotingServices.GetReflectionCachedData(t); 3227 MI = typeCache.GetLastCalledMethod(methodName); 3228 if (MI != null) 3229 return; 3230 } 3231 3232 // This could give us the wrong MethodBase because 3233 // the server and the client types could be of different 3234 // versions. The mismatch is caught either when the server has 3235 // more than one method defined with the same name or when we 3236 // coerce the args and the incoming argument types do not match 3237 // the method signature. 3238 3239 Contract.Assert( 3240 !methodName.Equals(".ctor"), 3241 "unexpected method type"); 3242 3243 bool bOverloaded = false; 3244 3245 try 3246 { 3247 MI = t.GetMethod(methodName, 3248 MethodCall.LookupAll); 3249 3250 if (instArgs != null && instArgs.Length > 0) 3251 MI = ((MethodInfo)MI).MakeGenericMethod(instArgs); 3252 3253 BCLDebug.Trace("REMOTE", "Method resolved w/name ", MI == null ? "<null>" : methodName); 3254 BCLDebug.Trace("REMOTE", "sig not filled in!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!"); 3255 } 3256 catch (AmbiguousMatchException) 3257 { 3258 // This is the case when no methodSignature was found 3259 // but the method is overloaded .. 3260 // (possibly because a non-URT client called us) 3261 bOverloaded = true; 3262 ResolveOverloadedMethod(t); 3263 } //catch 3264 3265 // In the non-URT call, overloaded case, don't cache the MI 3266 // Avoid caching generic methods -- their names aren't a unique key. 3267 if (MI != null && !bOverloaded && typeCache != null) 3268 typeCache.SetLastCalledMethod(methodName, MI); 3269 } 3270 3271 if (MI == null && bThrowIfNotResolved) 3272 { 3273 throw new RemotingException( 3274 String.Format( 3275 CultureInfo.CurrentCulture, Environment.GetResourceString( 3276 "Remoting_Message_MethodMissing"), 3277 methodName, 3278 typeName)); 3279 } 3280 } 3281 } 3282 3283 // Helper that gets called when we attempt to resolve a method 3284 // without an accompanying methodSignature ... current thinking is 3285 // that we should make a good faith attempt by matching argument 3286 // counts 3287 ResolveOverloadedMethod(RuntimeType t)3288 void ResolveOverloadedMethod(RuntimeType t) 3289 { 3290 // args is null the first call from soap because we havem't passed the arguments yet. 3291 if (args == null) 3292 return; 3293 3294 MemberInfo[] canidates = t.GetMember(methodName, MemberTypes.Method, MethodCall.LookupPublic); 3295 3296 int canidatesCount = canidates.Length; 3297 3298 if (canidatesCount == 1) 3299 { 3300 MI = canidates[0] as MethodBase; 3301 return; 3302 } 3303 3304 if (canidatesCount == 0) 3305 return; 3306 3307 int argCount = args.Length; 3308 MethodBase match = null; 3309 3310 // We will let resolve succeed if exactly one of the overloaded methods matches in terms of argCount 3311 for (int i = 0; i < canidatesCount; i++) 3312 { 3313 MethodBase canidate = canidates[i] as MethodBase; 3314 if (canidate.GetParameters().Length == argCount) 3315 { 3316 if (match != null) 3317 throw new RemotingException(Environment.GetResourceString("Remoting_AmbiguousMethod")); 3318 3319 match = canidate; 3320 } 3321 } 3322 3323 if (match != null) 3324 MI = match; 3325 } 3326 3327 // This will find the right overloaded method if the argValues from soap have type information, 3328 // By default parameters will be of type string, this could lead to a wrong choice of methodbase. ResolveOverloadedMethod(RuntimeType t, String methodName, ArrayList argNames, ArrayList argValues)3329 void ResolveOverloadedMethod(RuntimeType t, String methodName, ArrayList argNames, ArrayList argValues) 3330 { 3331 MemberInfo[] canidates = t.GetMember(methodName, MemberTypes.Method, MethodCall.LookupPublic); 3332 3333 int canidatesCount = canidates.Length; 3334 3335 if (canidatesCount == 1) 3336 { 3337 MI = canidates[0] as MethodBase; 3338 return; 3339 } 3340 3341 3342 if (canidatesCount == 0) 3343 return; 3344 3345 MethodBase match = null; 3346 3347 for (int i = 0; i < canidatesCount; i++) 3348 { 3349 MethodBase canidate = canidates[i] as MethodBase; 3350 3351 ParameterInfo[] parameters = canidate.GetParameters(); 3352 3353 if (parameters.Length == argValues.Count) 3354 { 3355 bool isMatch = true; 3356 for (int j = 0; j < parameters.Length; j++) 3357 { 3358 Type parameterType = parameters[j].ParameterType; 3359 3360 if (parameterType.IsByRef) 3361 parameterType = parameterType.GetElementType(); 3362 3363 if (parameterType != argValues[j].GetType()) 3364 { 3365 isMatch = false; 3366 break; 3367 } 3368 3369 } 3370 if (isMatch) 3371 { 3372 match = canidate; 3373 break; 3374 } 3375 } 3376 } 3377 if (match == null) 3378 throw new RemotingException(Environment.GetResourceString("Remoting_AmbiguousMethod")); 3379 MI = match; 3380 } 3381 3382 // 3383 // GetObjectData -- not implemented 3384 // 3385 3386 /// <internalonly/> 3387 [System.Security.SecurityCritical] // auto-generated_required GetObjectData(SerializationInfo info, StreamingContext context)3388 public void GetObjectData(SerializationInfo info, StreamingContext context) 3389 { 3390 throw new NotSupportedException( 3391 Environment.GetResourceString("NotSupported_Method")); 3392 } 3393 3394 // 3395 // SetObjectFromSoapData -- parses soap format for serialization data 3396 // 3397 3398 [System.Security.SecurityCritical] // auto-generated SetObjectFromSoapData(SerializationInfo info)3399 internal void SetObjectFromSoapData(SerializationInfo info) 3400 { 3401 // resolve method 3402 methodName = info.GetString("__methodName"); 3403 ArrayList paramNames = (ArrayList)info.GetValue("__paramNameList", typeof(ArrayList)); 3404 3405 Hashtable keyToNamespaceTable = (Hashtable)info.GetValue("__keyToNamespaceTable", typeof(Hashtable)); 3406 3407 if (MI == null) 3408 { 3409 // This is the case where 3410 // 1) there is no signature in the header, 3411 // 2) there is an overloaded method which can not be resolved by a difference in the number of parameters. 3412 // 3413 // The methodbase can be found only if the parameters from soap have type information 3414 ArrayList argValues = new ArrayList(); 3415 ArrayList argNames = paramNames; 3416 // SerializationInfoEnumerator siEnum1 = info.GetEnumerator(); 3417 for (int i=0; i<argNames.Count; i++) 3418 { 3419 argValues.Add(info.GetValue((String)argNames[i], typeof(Object))); 3420 } 3421 3422 //ambiguous member, try to find methodBase using actual argment types (if available) 3423 RuntimeType t = ResolveType() as RuntimeType; 3424 if (t == null) 3425 { 3426 throw new RemotingException( 3427 String.Format( 3428 CultureInfo.CurrentCulture, Environment.GetResourceString( 3429 "Remoting_BadType"), 3430 typeName)); 3431 } 3432 3433 ResolveOverloadedMethod(t, methodName, argNames, argValues); 3434 3435 if (MI == null) 3436 { 3437 throw new RemotingException( 3438 String.Format( 3439 CultureInfo.CurrentCulture, Environment.GetResourceString( 3440 "Remoting_Message_MethodMissing"), 3441 methodName, 3442 typeName)); 3443 } 3444 } 3445 //ResolveMethod(); 3446 3447 3448 //Contract.Assert(null != MI, "null != MI"); 3449 3450 // get method parameters and parameter maps 3451 RemotingMethodCachedData methodCache = InternalRemotingServices.GetReflectionCachedData(MI); 3452 ParameterInfo[] pinfos = methodCache.Parameters; 3453 int[] marshalRequestArgMap = methodCache.MarshalRequestArgMap; 3454 3455 // check to see if parameters are in-order 3456 Object fUnordered = (null == InternalProperties ? null : InternalProperties["__UnorderedParams"]); 3457 3458 // Create an array for arguments 3459 args = new Object[pinfos.Length]; 3460 3461 //SerializationInfoEnumerator siEnum = info.GetEnumerator(); 3462 3463 // Fill up the argument array 3464 if (fUnordered != null && 3465 (fUnordered is System.Boolean) && 3466 (true == (bool)fUnordered)) 3467 { 3468 String memberName; 3469 3470 for (int i=0; i<paramNames.Count; i++) 3471 { 3472 memberName = (String)paramNames[i]; 3473 Message.DebugOut( 3474 "MethodCall::PopulateData members[i].Name: " 3475 + memberName + " substring:>>" 3476 + memberName.Substring(7) + "<<\n"); 3477 3478 int position = -1; 3479 for (int j=0; j<pinfos.Length; j++) 3480 { 3481 if (memberName.Equals(pinfos[j].Name)) 3482 { 3483 position = pinfos[j].Position; 3484 break; 3485 } 3486 } 3487 3488 if (position == -1) 3489 { 3490 if (!memberName.StartsWith("__param", StringComparison.Ordinal)) 3491 { 3492 throw new RemotingException( 3493 Environment.GetResourceString( 3494 "Remoting_Message_BadSerialization")); 3495 } 3496 position = Int32.Parse(memberName.Substring(7), CultureInfo.InvariantCulture); 3497 } 3498 if (position >= args.Length) 3499 { 3500 throw new RemotingException( 3501 Environment.GetResourceString( 3502 "Remoting_Message_BadSerialization")); 3503 } 3504 args[position] = Message.SoapCoerceArg(info.GetValue(memberName, typeof(Object)), pinfos[position].ParameterType, keyToNamespaceTable); 3505 } 3506 } 3507 else 3508 { 3509 for (int i=0; i<paramNames.Count; i++) 3510 { 3511 String memberName = (String)paramNames[i]; 3512 args[marshalRequestArgMap[i]] = 3513 Message.SoapCoerceArg(info.GetValue(memberName, typeof(Object)), pinfos[marshalRequestArgMap[i]].ParameterType, keyToNamespaceTable); 3514 } 3515 3516 PopulateOutArguments(methodCache); 3517 } 3518 } // SetObjectFromSoapData 3519 3520 [SecurityCritical] 3521 [PermissionSet(SecurityAction.Assert, Unrestricted = true)] PopulateOutArguments(RemotingMethodCachedData methodCache)3522 void PopulateOutArguments(RemotingMethodCachedData methodCache) 3523 { 3524 ParameterInfo[] parameterInfos = methodCache.Parameters; 3525 // We need to have a dummy object in the array for out parameters 3526 // that have value types. 3527 foreach (int outArg in methodCache.OutOnlyArgMap) 3528 { 3529 Type type = parameterInfos[outArg].ParameterType.GetElementType(); 3530 if (type.IsValueType) 3531 args[outArg] = Activator.CreateInstance(type, true); 3532 } 3533 } 3534 3535 3536 // 3537 // Init -- constructor helper for for default behavior 3538 // 3539 3540 /// <internalonly/> Init()3541 public virtual void Init() 3542 { 3543 } 3544 3545 // 3546 // IMethodCallMessage 3547 // 3548 3549 /// <internalonly/> 3550 public int ArgCount 3551 { 3552 [System.Security.SecurityCritical] 3553 get 3554 { 3555 return(args == null) ? 0 : args.Length; 3556 } 3557 } 3558 3559 /// <internalonly/> 3560 [System.Security.SecurityCritical] GetArg(int argNum)3561 public Object GetArg(int argNum) 3562 { 3563 return args[argNum]; 3564 } 3565 3566 /// <internalonly/> 3567 [System.Security.SecurityCritical] // auto-generated GetArgName(int index)3568 public String GetArgName(int index) 3569 { 3570 ResolveMethod(); 3571 3572 RemotingMethodCachedData methodCache = InternalRemotingServices.GetReflectionCachedData(MI); 3573 return methodCache.Parameters[index].Name; 3574 } 3575 3576 /// <internalonly/> 3577 public Object[] Args 3578 { 3579 [System.Security.SecurityCritical] 3580 get 3581 { 3582 return args; 3583 } 3584 } 3585 3586 3587 /// <internalonly/> 3588 public int InArgCount 3589 { 3590 [System.Security.SecurityCritical] 3591 get 3592 { 3593 if (argMapper == null) argMapper = new ArgMapper(this, false); 3594 return argMapper.ArgCount; 3595 } 3596 } 3597 3598 /// <internalonly/> 3599 [System.Security.SecurityCritical] GetInArg(int argNum)3600 public Object GetInArg(int argNum) 3601 { 3602 if (argMapper == null) argMapper = new ArgMapper(this, false); 3603 return argMapper.GetArg(argNum); 3604 } 3605 3606 /// <internalonly/> 3607 [System.Security.SecurityCritical] GetInArgName(int index)3608 public String GetInArgName(int index) 3609 { 3610 if (argMapper == null) argMapper = new ArgMapper(this, false); 3611 return argMapper.GetArgName(index); 3612 } 3613 /// <internalonly/> 3614 public Object[] InArgs 3615 { 3616 [System.Security.SecurityCritical] 3617 get 3618 { 3619 if (argMapper == null) argMapper = new ArgMapper(this, false); 3620 return argMapper.Args; 3621 } 3622 } 3623 3624 /// <internalonly/> 3625 public String MethodName 3626 { 3627 [System.Security.SecurityCritical] 3628 get { return methodName; } 3629 } 3630 /// <internalonly/> 3631 public String TypeName 3632 { 3633 [System.Security.SecurityCritical] 3634 get { return typeName; } 3635 } 3636 /// <internalonly/> 3637 public Object MethodSignature 3638 { 3639 [System.Security.SecurityCritical] // auto-generated 3640 get 3641 { 3642 if (methodSignature != null) 3643 return methodSignature; 3644 else if (MI != null) 3645 methodSignature = Message.GenerateMethodSignature(this.MethodBase); 3646 3647 return null; 3648 } 3649 } 3650 3651 /// <internalonly/> 3652 public MethodBase MethodBase 3653 { 3654 [System.Security.SecurityCritical] 3655 get 3656 { 3657 if (MI == null) 3658 MI = RemotingServices.InternalGetMethodBaseFromMethodMessage(this); 3659 return MI; 3660 } 3661 } 3662 3663 /// <internalonly/> 3664 public String Uri 3665 { 3666 [System.Security.SecurityCritical] 3667 get { return uri; } 3668 set { uri = value; } 3669 } 3670 3671 /// <internalonly/> 3672 public bool HasVarArgs 3673 { 3674 [System.Security.SecurityCritical] 3675 get { return fVarArgs; } 3676 } 3677 3678 /// <internalonly/> 3679 public virtual IDictionary Properties 3680 { 3681 [System.Security.SecurityCritical] 3682 get 3683 { 3684 lock(this) { 3685 if (InternalProperties == null) 3686 { 3687 InternalProperties = new Hashtable(); 3688 } 3689 if (ExternalProperties == null) 3690 { 3691 ExternalProperties = new MCMDictionary(this, InternalProperties); 3692 } 3693 return ExternalProperties; 3694 } 3695 } 3696 } 3697 3698 /// <internalonly/> 3699 public LogicalCallContext LogicalCallContext 3700 { 3701 [System.Security.SecurityCritical] // auto-generated 3702 get { return GetLogicalCallContext(); } 3703 } 3704 3705 [System.Security.SecurityCritical] // auto-generated GetLogicalCallContext()3706 internal LogicalCallContext GetLogicalCallContext() 3707 { 3708 if (callContext == null) 3709 callContext = new LogicalCallContext(); 3710 return callContext; 3711 } 3712 SetLogicalCallContext(LogicalCallContext ctx)3713 internal LogicalCallContext SetLogicalCallContext(LogicalCallContext ctx) 3714 { 3715 LogicalCallContext old=callContext; 3716 callContext=ctx; 3717 return old; 3718 } 3719 3720 // 3721 // IInternalMessage 3722 // 3723 3724 /// <internalonly/> 3725 ServerIdentity IInternalMessage.ServerIdentityObject 3726 { 3727 [System.Security.SecurityCritical] 3728 get { return srvID; } 3729 [System.Security.SecurityCritical] 3730 set { srvID = value; } 3731 } 3732 3733 /// <internalonly/> 3734 Identity IInternalMessage.IdentityObject 3735 { 3736 [System.Security.SecurityCritical] 3737 get { return identity; } 3738 [System.Security.SecurityCritical] 3739 set { identity = value; } 3740 } 3741 3742 /// <internalonly/> 3743 [System.Security.SecurityCritical] IInternalMessage.SetURI(String val)3744 void IInternalMessage.SetURI(String val) 3745 { 3746 uri = val; 3747 } 3748 3749 /// <internalonly/> 3750 [System.Security.SecurityCritical] IInternalMessage.SetCallContext(LogicalCallContext newCallContext)3751 void IInternalMessage.SetCallContext(LogicalCallContext newCallContext) 3752 { 3753 callContext = newCallContext; 3754 } 3755 3756 /// <internalonly/> 3757 [System.Security.SecurityCritical] IInternalMessage.HasProperties()3758 bool IInternalMessage.HasProperties() 3759 { 3760 return (ExternalProperties != null) || (InternalProperties != null); 3761 } 3762 3763 // 3764 // helper functions 3765 // 3766 3767 [System.Security.SecurityCritical] // auto-generated FillHeaders(Header[] h)3768 internal void FillHeaders(Header[] h) 3769 { 3770 FillHeaders(h, false); 3771 } 3772 3773 [System.Security.SecurityCritical] // auto-generated FillHeaders(Header[] h, bool bFromHeaderHandler)3774 private void FillHeaders(Header[] h, bool bFromHeaderHandler) 3775 { 3776 if (h == null) 3777 return; 3778 3779 if (bFromHeaderHandler && fSoap) 3780 { 3781 // Handle the case of headers coming off the wire in SOAP. 3782 3783 // look for message properties 3784 int co; 3785 for (co = 0; co < h.Length; co++) 3786 { 3787 Header header = h[co]; 3788 if (header.HeaderNamespace == "http://schemas.microsoft.com/clr/soap/messageProperties") 3789 { 3790 // add property to the message 3791 FillHeader(header.Name, header.Value); 3792 } 3793 else 3794 { 3795 // add header to the message as a header 3796 String name = LogicalCallContext.GetPropertyKeyForHeader(header); 3797 FillHeader(name, header); 3798 } 3799 } 3800 } 3801 else 3802 { 3803 int i; 3804 for (i=0; i<h.Length; i++) 3805 { 3806 FillHeader(h[i].Name, h[i].Value); 3807 } 3808 } 3809 } 3810 3811 [System.Security.SecurityCritical] // auto-generated FillSpecialHeader(String key, Object value)3812 internal virtual bool FillSpecialHeader(String key, Object value) 3813 { 3814 if (key == null) 3815 { 3816 //skip 3817 } 3818 else if (key.Equals("__Uri")) 3819 { 3820 uri = (String) value; 3821 } 3822 else if (key.Equals("__MethodName")) 3823 { 3824 methodName = (String) value; 3825 } 3826 else if (key.Equals("__MethodSignature")) 3827 { 3828 methodSignature = (Type[]) value; 3829 } 3830 else if (key.Equals("__TypeName")) 3831 { 3832 typeName = (String) value; 3833 } 3834 else if (key.Equals("__Args")) 3835 { 3836 args = (Object[]) value; 3837 } 3838 else if (key.Equals("__CallContext")) 3839 { 3840 // if the value is a string, then its the LogicalCallId 3841 if (value is String) 3842 { 3843 callContext = new LogicalCallContext(); 3844 callContext.RemotingData.LogicalCallID = (String) value; 3845 } 3846 else 3847 callContext = (LogicalCallContext) value; 3848 } 3849 else 3850 { 3851 return false; 3852 } 3853 return true; 3854 } 3855 [System.Security.SecurityCritical] // auto-generated FillHeader(String key, Object value)3856 internal void FillHeader(String key, Object value) 3857 { 3858 Message.DebugOut("MethodCall::FillHeader: key:" + key + "\n"); 3859 3860 if (!FillSpecialHeader(key,value)) 3861 { 3862 if (InternalProperties == null) 3863 { 3864 InternalProperties = new Hashtable(); 3865 } 3866 InternalProperties[key] = value; 3867 } 3868 3869 } 3870 3871 /// <internalonly/> 3872 [System.Security.SecurityCritical] // auto-generated HeaderHandler(Header[] h)3873 public virtual Object HeaderHandler(Header[] h) 3874 { 3875 SerializationMonkey m = (SerializationMonkey) FormatterServices.GetUninitializedObject(typeof(SerializationMonkey)); 3876 Header[] newHeaders = null; 3877 if (h != null && h.Length > 0 && h[0].Name == "__methodName") 3878 { 3879 methodName = (String)h[0].Value; 3880 if (h.Length > 1) 3881 { 3882 newHeaders = new Header[h.Length -1]; 3883 Array.Copy(h, 1, newHeaders, 0, h.Length-1); 3884 } 3885 else 3886 newHeaders = null; 3887 } 3888 else 3889 newHeaders = h; 3890 3891 FillHeaders(newHeaders, true); 3892 ResolveMethod(false); 3893 m._obj = this; 3894 if (MI != null) 3895 { 3896 ArgMapper argm = new ArgMapper(MI, false); 3897 m.fieldNames = argm.ArgNames; 3898 m.fieldTypes = argm.ArgTypes; 3899 } 3900 return m; 3901 } 3902 } 3903 3904 3905 //+================================================================================ 3906 // 3907 // Synopsis: Message used for deserialization of a construction call 3908 // 3909 //-================================================================================ 3910 /// <internalonly/> 3911 [System.Security.SecurityCritical] // auto-generated_required 3912 [Serializable] 3913 [CLSCompliant(false)] 3914 [System.Runtime.InteropServices.ComVisible(true)] 3915 public class ConstructionCall : MethodCall, IConstructionCallMessage 3916 { 3917 3918 // 3919 // data 3920 // 3921 3922 internal Type _activationType; 3923 internal String _activationTypeName; 3924 internal IList _contextProperties; 3925 internal Object[] _callSiteActivationAttributes; 3926 internal IActivator _activator; 3927 3928 /* 3929 [NonSerialized] 3930 internal Object _fakeThisPtr; // used for proxyattribute::CI 3931 */ 3932 3933 // 3934 // construction 3935 // 3936 3937 /// <internalonly/> ConstructionCall(Header[] headers)3938 public ConstructionCall(Header[] headers) : base(headers) {} 3939 3940 /// <internalonly/> ConstructionCall(IMessage m)3941 public ConstructionCall(IMessage m) : base(m) {} ConstructionCall(SerializationInfo info, StreamingContext context)3942 internal ConstructionCall(SerializationInfo info, StreamingContext context) : base(info, context) 3943 { 3944 } 3945 3946 #if false GetThisPtr()3947 internal Object GetThisPtr() 3948 { 3949 return _fakeThisPtr; 3950 } SetThisPtr(Object obj)3951 internal void SetThisPtr(Object obj) 3952 { 3953 _fakeThisPtr = obj; 3954 } 3955 #endif 3956 3957 // 3958 // Function: FillSpecialHeader 3959 // 3960 // Synopsis: this is the only specialization we need to 3961 // make things go in the right place 3962 // 3963 // 3964 [System.Security.SecurityCritical] FillSpecialHeader(String key, Object value)3965 internal override bool FillSpecialHeader(String key, Object value) 3966 { 3967 if (key == null) 3968 { 3969 //skip 3970 } 3971 else if (key.Equals("__ActivationType")) 3972 { 3973 Contract.Assert(value==null, "Phoney type in CCM"); 3974 _activationType = null; 3975 } 3976 else if (key.Equals("__ContextProperties")) 3977 { 3978 _contextProperties = (IList) value; 3979 } 3980 else if (key.Equals("__CallSiteActivationAttributes")) 3981 { 3982 _callSiteActivationAttributes = (Object[]) value; 3983 } 3984 else if (key.Equals("__Activator")) 3985 { 3986 _activator = (IActivator) value; 3987 } 3988 else if (key.Equals("__ActivationTypeName")) 3989 { 3990 _activationTypeName = (String) value; 3991 } 3992 else 3993 { 3994 return base.FillSpecialHeader(key, value); 3995 } 3996 return true; 3997 3998 } 3999 4000 4001 // 4002 // IConstructionCallMessage 4003 // 4004 4005 /// <internalonly/> 4006 public Object[] CallSiteActivationAttributes 4007 { 4008 [System.Security.SecurityCritical] 4009 get 4010 { 4011 return _callSiteActivationAttributes; 4012 } 4013 4014 } 4015 4016 /// <internalonly/> 4017 public Type ActivationType 4018 { 4019 [System.Security.SecurityCritical] 4020 get 4021 { 4022 if ((_activationType == null) && (_activationTypeName != null)) 4023 _activationType = RemotingServices.InternalGetTypeFromQualifiedTypeName(_activationTypeName, false); 4024 4025 return _activationType; 4026 } 4027 } 4028 4029 /// <internalonly/> 4030 public String ActivationTypeName 4031 { 4032 [System.Security.SecurityCritical] 4033 get 4034 { 4035 return _activationTypeName; 4036 } 4037 } 4038 4039 /// <internalonly/> 4040 public IList ContextProperties 4041 { 4042 [System.Security.SecurityCritical] 4043 get 4044 { 4045 if (_contextProperties == null) 4046 { 4047 _contextProperties = new ArrayList(); 4048 } 4049 return _contextProperties; 4050 } 4051 } 4052 4053 /// <internalonly/> 4054 public override IDictionary Properties 4055 { 4056 [System.Security.SecurityCritical] 4057 get 4058 { 4059 lock(this) 4060 { 4061 if (InternalProperties == null) 4062 { 4063 InternalProperties = new Hashtable(); 4064 } 4065 if (ExternalProperties == null) 4066 { 4067 ExternalProperties = new CCMDictionary(this, InternalProperties); 4068 } 4069 return ExternalProperties; 4070 } 4071 } 4072 } 4073 4074 4075 // IConstructionCallMessage::Activator 4076 /// <internalonly/> 4077 public IActivator Activator 4078 { 4079 [System.Security.SecurityCritical] 4080 get { return _activator; } 4081 [System.Security.SecurityCritical] 4082 set { _activator = value; } 4083 } 4084 4085 } 4086 //+================================================================================ 4087 // 4088 // Synopsis: Message used for deserialization of a method response 4089 // 4090 //-================================================================================ 4091 /// <internalonly/> 4092 [System.Security.SecurityCritical] // auto-generated_required 4093 [Serializable] 4094 [CLSCompliant(false)] 4095 [SecurityPermissionAttribute(SecurityAction.InheritanceDemand, Flags=SecurityPermissionFlag.Infrastructure)] 4096 [System.Runtime.InteropServices.ComVisible(true)] 4097 public class MethodResponse : IMethodReturnMessage, ISerializable, ISerializationRootObject, IInternalMessage 4098 { 4099 private MethodBase MI; 4100 private String methodName; 4101 private Type[] methodSignature; 4102 private String uri; 4103 private String typeName; 4104 private Object retVal; 4105 private Exception fault; 4106 private Object[] outArgs; 4107 private LogicalCallContext callContext; 4108 /// <internalonly/> 4109 protected IDictionary InternalProperties; 4110 /// <internalonly/> 4111 protected IDictionary ExternalProperties; 4112 4113 private int argCount; 4114 private bool fSoap; 4115 private ArgMapper argMapper; 4116 private RemotingMethodCachedData _methodCache; 4117 4118 // Constructor -- this constructor is called only in the SOAP Scenario 4119 4120 4121 /// <internalonly/> 4122 [System.Security.SecurityCritical] // auto-generated MethodResponse(Header[] h1, IMethodCallMessage mcm)4123 public MethodResponse(Header[] h1, IMethodCallMessage mcm) 4124 { 4125 if (mcm == null) 4126 throw new ArgumentNullException("mcm"); 4127 Contract.EndContractBlock(); 4128 4129 Message msg = mcm as Message; 4130 if (null != msg) 4131 { 4132 MI = (MethodBase)msg.GetMethodBase(); 4133 } 4134 else 4135 { 4136 MI = (MethodBase)mcm.MethodBase; 4137 } 4138 if (MI == null) 4139 { 4140 throw new RemotingException( 4141 String.Format( 4142 CultureInfo.CurrentCulture, Environment.GetResourceString( 4143 "Remoting_Message_MethodMissing"), 4144 mcm.MethodName, 4145 mcm.TypeName)); 4146 } 4147 4148 _methodCache = InternalRemotingServices.GetReflectionCachedData(MI); 4149 4150 argCount = _methodCache.Parameters.Length; 4151 fSoap = true; 4152 FillHeaders(h1); 4153 } 4154 4155 4156 [System.Security.SecurityCritical] // auto-generated MethodResponse(IMethodCallMessage msg, SmuggledMethodReturnMessage smuggledMrm, ArrayList deserializedArgs)4157 internal MethodResponse(IMethodCallMessage msg, 4158 SmuggledMethodReturnMessage smuggledMrm, 4159 ArrayList deserializedArgs) 4160 { 4161 MI = (MethodBase)msg.MethodBase; 4162 _methodCache = InternalRemotingServices.GetReflectionCachedData(MI); 4163 4164 methodName = msg.MethodName; 4165 uri = msg.Uri; 4166 typeName = msg.TypeName; 4167 4168 if (_methodCache.IsOverloaded()) 4169 methodSignature = (Type[])msg.MethodSignature; 4170 4171 retVal = smuggledMrm.GetReturnValue(deserializedArgs); 4172 outArgs = smuggledMrm.GetArgs(deserializedArgs); 4173 fault = smuggledMrm.GetException(deserializedArgs); 4174 4175 callContext = smuggledMrm.GetCallContext(deserializedArgs); 4176 4177 if (smuggledMrm.MessagePropertyCount > 0) 4178 smuggledMrm.PopulateMessageProperties(Properties, deserializedArgs); 4179 4180 argCount = _methodCache.Parameters.Length; 4181 fSoap = false; 4182 } 4183 4184 [System.Security.SecurityCritical] // auto-generated MethodResponse(IMethodCallMessage msg, Object handlerObject, BinaryMethodReturnMessage smuggledMrm)4185 internal MethodResponse(IMethodCallMessage msg, 4186 Object handlerObject, 4187 BinaryMethodReturnMessage smuggledMrm) 4188 { 4189 4190 if (msg != null) 4191 { 4192 MI = (MethodBase)msg.MethodBase; 4193 _methodCache = InternalRemotingServices.GetReflectionCachedData(MI); 4194 4195 methodName = msg.MethodName; 4196 uri = msg.Uri; 4197 typeName = msg.TypeName; 4198 4199 if (_methodCache.IsOverloaded()) 4200 methodSignature = (Type[])msg.MethodSignature; 4201 4202 argCount = _methodCache.Parameters.Length; 4203 4204 } 4205 4206 retVal = smuggledMrm.ReturnValue; 4207 outArgs = smuggledMrm.Args; 4208 fault = smuggledMrm.Exception; 4209 4210 callContext = smuggledMrm.LogicalCallContext; 4211 4212 if (smuggledMrm.HasProperties) 4213 smuggledMrm.PopulateMessageProperties(Properties); 4214 4215 fSoap = false; 4216 } 4217 4218 4219 4220 // 4221 // SetObjectData -- this can be called with the object in two possible states. 1. the object 4222 // is servicing a SOAP response in which it will have been half initialized by the constructor, 4223 // or 2. the object is uninitailized and serialization is passing in the contents. 4224 // 4225 [System.Security.SecurityCritical] // auto-generated MethodResponse(SerializationInfo info, StreamingContext context)4226 internal MethodResponse(SerializationInfo info, StreamingContext context) 4227 { 4228 if (info == null) 4229 throw new ArgumentNullException("info"); 4230 Contract.EndContractBlock(); 4231 SetObjectData(info, context); 4232 } 4233 4234 4235 /// <internalonly/> 4236 [System.Security.SecurityCritical] // auto-generated HeaderHandler(Header[] h)4237 public virtual Object HeaderHandler(Header[] h) 4238 { 4239 SerializationMonkey m = (SerializationMonkey) FormatterServices.GetUninitializedObject(typeof(SerializationMonkey)); 4240 4241 Header[] newHeaders = null; 4242 if (h != null && h.Length > 0 && h[0].Name == "__methodName") 4243 { 4244 if (h.Length > 1) 4245 { 4246 newHeaders = new Header[h.Length -1]; 4247 Array.Copy(h, 1, newHeaders, 0, h.Length-1); 4248 } 4249 else 4250 newHeaders = null; 4251 } 4252 else 4253 newHeaders = h; 4254 4255 Type retType = null; 4256 MethodInfo mi = MI as MethodInfo; 4257 if (mi != null) 4258 { 4259 retType = mi.ReturnType; 4260 } 4261 4262 ParameterInfo[] pinfos = _methodCache.Parameters; 4263 4264 // Calculate length 4265 int outParamsCount = _methodCache.MarshalResponseArgMap.Length; 4266 if (!((retType == null) || (retType == typeof(void)))) 4267 outParamsCount++; 4268 4269 Type[] paramTypes = new Type[outParamsCount]; 4270 String[] paramNames = new String[outParamsCount]; 4271 int paramTypesIndex = 0; 4272 if (!((retType == null) || (retType == typeof(void)))) 4273 { 4274 paramTypes[paramTypesIndex++] = retType; 4275 } 4276 4277 foreach (int i in _methodCache.MarshalResponseArgMap) 4278 { 4279 paramNames[paramTypesIndex] = pinfos[i].Name; 4280 if (pinfos[i].ParameterType.IsByRef) 4281 paramTypes[paramTypesIndex++] = pinfos[i].ParameterType.GetElementType(); 4282 else 4283 paramTypes[paramTypesIndex++] = pinfos[i].ParameterType; 4284 } 4285 4286 ((IFieldInfo)m).FieldTypes = paramTypes; 4287 ((IFieldInfo)m).FieldNames = paramNames; 4288 FillHeaders(newHeaders, true); 4289 m._obj = this; 4290 return m; 4291 } 4292 4293 // 4294 // ISerializationRootObject 4295 // 4296 /// <internalonly/> 4297 [System.Security.SecurityCritical] // auto-generated RootSetObjectData(SerializationInfo info, StreamingContext ctx)4298 public void RootSetObjectData(SerializationInfo info, StreamingContext ctx) 4299 { 4300 SetObjectData(info, ctx); 4301 } 4302 4303 [System.Security.SecurityCritical] // auto-generated SetObjectData(SerializationInfo info, StreamingContext ctx)4304 internal void SetObjectData(SerializationInfo info, StreamingContext ctx) 4305 { 4306 if (info == null) 4307 throw new ArgumentNullException("info"); 4308 Contract.EndContractBlock(); 4309 4310 if (fSoap) 4311 { 4312 SetObjectFromSoapData(info); 4313 } 4314 else 4315 { 4316 SerializationInfoEnumerator e = info.GetEnumerator(); 4317 bool ret = false; 4318 bool excep = false; 4319 4320 while (e.MoveNext()) 4321 { 4322 if (e.Name.Equals("__return")) 4323 { 4324 ret = true; 4325 break; 4326 } 4327 if (e.Name.Equals("__fault")) 4328 { 4329 excep = true; 4330 fault = (Exception)e.Value; 4331 break; 4332 } 4333 4334 FillHeader(e.Name, e.Value); 4335 } 4336 if ((excep) && (ret)) 4337 { 4338 throw new RemotingException( 4339 Environment.GetResourceString( 4340 "Remoting_Message_BadSerialization")); 4341 } 4342 } 4343 } 4344 // 4345 // ISerializable 4346 // 4347 4348 // 4349 // GetObjectData -- not implemented 4350 // 4351 4352 /// <internalonly/> 4353 [System.Security.SecurityCritical] // auto-generated_required GetObjectData(SerializationInfo info, StreamingContext context)4354 public virtual void GetObjectData(SerializationInfo info, StreamingContext context) 4355 { 4356 throw new NotSupportedException( 4357 Environment.GetResourceString("NotSupported_Method")); 4358 } 4359 4360 // 4361 // SetObjectFromSoapData -- assumes SOAP format and populates the arguments array 4362 // 4363 SetObjectFromSoapData(SerializationInfo info)4364 internal void SetObjectFromSoapData(SerializationInfo info) 4365 { 4366 //SerializationInfoEnumerator e = info.GetEnumerator(); 4367 4368 Hashtable keyToNamespaceTable = (Hashtable)info.GetValue("__keyToNamespaceTable", typeof(Hashtable)); 4369 ArrayList paramNames = (ArrayList)info.GetValue("__paramNameList", typeof(ArrayList)); 4370 SoapFault soapFault = (SoapFault)info.GetValue("__fault", typeof(SoapFault)); 4371 4372 if (soapFault != null) 4373 { 4374 ServerFault serverFault = soapFault.Detail as ServerFault; 4375 if (null != serverFault) 4376 { 4377 // Server Fault information 4378 if (serverFault.Exception != null) 4379 fault = serverFault.Exception; 4380 else 4381 { 4382 Type exceptionType = Type.GetType(serverFault.ExceptionType, false, false); 4383 if (exceptionType == null) 4384 { 4385 // Exception type cannot be resolved, use a ServerException 4386 StringBuilder sb = new StringBuilder(); 4387 sb.Append("\nException Type: "); 4388 sb.Append(serverFault.ExceptionType); 4389 sb.Append("\n"); 4390 sb.Append("Exception Message: "); 4391 sb.Append(serverFault.ExceptionMessage); 4392 sb.Append("\n"); 4393 sb.Append(serverFault.StackTrace); 4394 fault = new ServerException(sb.ToString()); 4395 } 4396 else 4397 { 4398 // Exception type can be resolved, throw the exception 4399 Object[] args = {serverFault.ExceptionMessage}; 4400 fault = (Exception)Activator.CreateInstance( 4401 exceptionType, 4402 BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.CreateInstance, 4403 null, 4404 args, 4405 null, 4406 null); 4407 } 4408 } 4409 } 4410 else if ((soapFault.Detail != null) && (soapFault.Detail.GetType() == typeof(String)) && (!(((String)soapFault.Detail).Length == 0))) 4411 { 4412 fault = new ServerException((String)soapFault.Detail); 4413 } 4414 else 4415 { 4416 fault = new ServerException(soapFault.FaultString); 4417 } 4418 4419 return; 4420 } 4421 4422 MethodInfo mi = MI as MethodInfo; 4423 int paramNameIndex = 0; 4424 if (mi != null) 4425 { 4426 Type retType = mi.ReturnType; 4427 if (retType != typeof(void)) 4428 { 4429 paramNameIndex++; 4430 Object returnValue = info.GetValue((String)paramNames[0], typeof(Object)); 4431 if (returnValue is String) 4432 retVal = Message.SoapCoerceArg(returnValue, retType, keyToNamespaceTable); 4433 else 4434 retVal = returnValue; 4435 } 4436 } 4437 4438 // populate the args array 4439 ParameterInfo[] pinfos = _methodCache.Parameters; 4440 4441 Object fUnordered = (InternalProperties == null) ? null : InternalProperties["__UnorderedParams"]; 4442 if (fUnordered != null && 4443 (fUnordered is System.Boolean) && 4444 (true == (bool)fUnordered)) 4445 { 4446 // Unordered 4447 for (int i=paramNameIndex; i<paramNames.Count; i++) 4448 { 4449 String memberName = (String)paramNames[i]; 4450 4451 // check for the parameter name 4452 4453 int position = -1; 4454 for (int j=0; j<pinfos.Length; j++) 4455 { 4456 if (memberName.Equals(pinfos[j].Name)) 4457 { 4458 position = pinfos[j].Position; 4459 } 4460 } 4461 4462 // no name so check for well known name 4463 4464 if (position == -1) 4465 { 4466 if (!memberName.StartsWith("__param", StringComparison.Ordinal)) 4467 { 4468 throw new RemotingException( 4469 Environment.GetResourceString( 4470 "Remoting_Message_BadSerialization")); 4471 } 4472 position = Int32.Parse(memberName.Substring(7), CultureInfo.InvariantCulture); 4473 } 4474 4475 // if still not resolved then throw 4476 4477 if (position >= argCount) 4478 { 4479 throw new RemotingException( 4480 Environment.GetResourceString( 4481 "Remoting_Message_BadSerialization")); 4482 } 4483 4484 // store the arg in the parameter array 4485 4486 if (outArgs == null) 4487 { 4488 outArgs = new Object[argCount]; 4489 } 4490 outArgs[position]= Message.SoapCoerceArg(info.GetValue(memberName, typeof(Object)), pinfos[position].ParameterType, keyToNamespaceTable); 4491 } 4492 } 4493 else 4494 { 4495 // ordered 4496 if (argMapper == null) argMapper = new ArgMapper(this, true); 4497 for (int j=paramNameIndex; j<paramNames.Count; j++) 4498 { 4499 String memberName = (String)paramNames[j]; 4500 if (outArgs == null) 4501 { 4502 outArgs = new Object[argCount]; 4503 } 4504 4505 int position = argMapper.Map[j-paramNameIndex]; 4506 outArgs[position] = Message.SoapCoerceArg(info.GetValue(memberName, typeof(Object)), pinfos[position].ParameterType, keyToNamespaceTable); 4507 } 4508 } 4509 } // SetObjectFromSoapData 4510 4511 4512 4513 [System.Security.SecurityCritical] // auto-generated GetLogicalCallContext()4514 internal LogicalCallContext GetLogicalCallContext() 4515 { 4516 if (callContext == null) 4517 callContext = new LogicalCallContext(); 4518 return callContext; 4519 } 4520 SetLogicalCallContext(LogicalCallContext ctx)4521 internal LogicalCallContext SetLogicalCallContext(LogicalCallContext ctx) 4522 { 4523 LogicalCallContext old=callContext; 4524 callContext=ctx; 4525 return old; 4526 } 4527 4528 // 4529 // IMethodReturnMessage 4530 // 4531 4532 /// <internalonly/> 4533 public String Uri 4534 { 4535 [System.Security.SecurityCritical] 4536 get { return uri; } 4537 set { uri = value; } 4538 } 4539 /// <internalonly/> 4540 public String MethodName 4541 { 4542 [System.Security.SecurityCritical] 4543 get { return methodName; } 4544 } 4545 /// <internalonly/> 4546 public String TypeName 4547 { 4548 [System.Security.SecurityCritical] 4549 get { return typeName; } 4550 } 4551 /// <internalonly/> 4552 public Object MethodSignature 4553 { 4554 [System.Security.SecurityCritical] 4555 get { return methodSignature; } 4556 } 4557 /// <internalonly/> 4558 public MethodBase MethodBase 4559 { 4560 [System.Security.SecurityCritical] 4561 get { return MI; } 4562 } 4563 4564 4565 /// <internalonly/> 4566 public bool HasVarArgs 4567 { 4568 [System.Security.SecurityCritical] 4569 get 4570 { 4571 // Var args nyi.. 4572 return false; 4573 } 4574 } 4575 4576 /// <internalonly/> 4577 public int ArgCount 4578 { 4579 [System.Security.SecurityCritical] 4580 get 4581 { 4582 if (outArgs == null) 4583 return 0; 4584 else 4585 return outArgs.Length; 4586 } 4587 } 4588 /// <internalonly/> 4589 [System.Security.SecurityCritical] GetArg(int argNum)4590 public Object GetArg(int argNum) { return outArgs[argNum]; } 4591 /// <internalonly/> 4592 [System.Security.SecurityCritical] // auto-generated GetArgName(int index)4593 public String GetArgName(int index) 4594 { 4595 if (MI != null) 4596 { 4597 RemotingMethodCachedData methodCache = InternalRemotingServices.GetReflectionCachedData(MI); 4598 ParameterInfo[] paramInfo = methodCache.Parameters; 4599 if (index < 0 || index >= paramInfo.Length) 4600 throw new ArgumentOutOfRangeException("index"); 4601 4602 return methodCache.Parameters[index].Name; 4603 } 4604 else 4605 return "__param" + index; 4606 } 4607 /// <internalonly/> 4608 public Object[] Args 4609 { 4610 [System.Security.SecurityCritical] 4611 get { return outArgs; } 4612 } 4613 4614 /// <internalonly/> 4615 public int OutArgCount 4616 { 4617 [System.Security.SecurityCritical] 4618 get 4619 { 4620 if (argMapper == null) argMapper = new ArgMapper(this, true); 4621 return argMapper.ArgCount; 4622 } 4623 } 4624 4625 /// <internalonly/> 4626 [System.Security.SecurityCritical] GetOutArg(int argNum)4627 public Object GetOutArg(int argNum) 4628 { 4629 if (argMapper == null) argMapper = new ArgMapper(this, true); 4630 return argMapper.GetArg(argNum); 4631 } 4632 4633 /// <internalonly/> 4634 [System.Security.SecurityCritical] GetOutArgName(int index)4635 public String GetOutArgName(int index) 4636 { 4637 if (argMapper == null) argMapper = new ArgMapper(this, true); 4638 return argMapper.GetArgName(index); 4639 } 4640 /// <internalonly/> 4641 public Object[] OutArgs 4642 { 4643 [System.Security.SecurityCritical] 4644 get 4645 { 4646 if (argMapper == null) argMapper = new ArgMapper(this, true); 4647 return argMapper.Args; 4648 } 4649 } 4650 4651 /// <internalonly/> 4652 public Exception Exception 4653 { 4654 [System.Security.SecurityCritical] 4655 get { return fault; } 4656 } 4657 /// <internalonly/> 4658 public Object ReturnValue 4659 { 4660 [System.Security.SecurityCritical] 4661 get { return retVal; } 4662 } 4663 4664 4665 /// <internalonly/> 4666 public virtual IDictionary Properties 4667 { 4668 [System.Security.SecurityCritical] 4669 get 4670 { 4671 lock(this) 4672 { 4673 if (InternalProperties == null) 4674 { 4675 InternalProperties = new Hashtable(); 4676 } 4677 if (ExternalProperties == null) 4678 { 4679 ExternalProperties = new MRMDictionary(this, InternalProperties); 4680 } 4681 return ExternalProperties; 4682 } 4683 } 4684 } 4685 4686 /// <internalonly/> 4687 public LogicalCallContext LogicalCallContext 4688 { 4689 [System.Security.SecurityCritical] // auto-generated 4690 get { return GetLogicalCallContext();} 4691 } 4692 4693 // 4694 // helpers 4695 // 4696 [System.Security.SecurityCritical] // auto-generated FillHeaders(Header[] h)4697 internal void FillHeaders(Header[] h) 4698 { 4699 FillHeaders(h, false); 4700 } // FillHeaders 4701 4702 4703 [System.Security.SecurityCritical] // auto-generated FillHeaders(Header[] h, bool bFromHeaderHandler)4704 private void FillHeaders(Header[] h, bool bFromHeaderHandler) 4705 { 4706 if (h == null) 4707 return; 4708 4709 if (bFromHeaderHandler && fSoap) 4710 { 4711 // Handle the case of headers coming off the wire in SOAP. 4712 4713 // look for message properties 4714 int co; 4715 for (co = 0; co < h.Length; co++) 4716 { 4717 Header header = h[co]; 4718 if (header.HeaderNamespace == "http://schemas.microsoft.com/clr/soap/messageProperties") 4719 { 4720 // add property to the message 4721 FillHeader(header.Name, header.Value); 4722 } 4723 else 4724 { 4725 // add header to the message as a header 4726 String name = LogicalCallContext.GetPropertyKeyForHeader(header); 4727 FillHeader(name, header); 4728 } 4729 } 4730 } 4731 else 4732 { 4733 for (int i=0; i<h.Length; i++) 4734 { 4735 FillHeader(h[i].Name, h[i].Value); 4736 } 4737 } 4738 } // FillHeaders 4739 4740 4741 [System.Security.SecurityCritical] // auto-generated FillHeader(String name, Object value)4742 internal void FillHeader(String name, Object value) 4743 { 4744 Message.DebugOut("MethodCall::FillHeaders: name: " + (name == null ? "NULL" : name) + "\n"); 4745 Message.DebugOut("MethodCall::FillHeaders: Value.GetClass: " + (value == null ? "NULL" : value.GetType().FullName) + "\n"); 4746 Message.DebugOut("MethodCall::FillHeaders: Value.ToString: " + (value == null ? "NULL" : value.ToString()) + "\n"); 4747 4748 if (name.Equals("__MethodName")) 4749 { 4750 methodName = (String) value; 4751 } 4752 else if (name.Equals("__Uri")) 4753 { 4754 uri = (String) value; 4755 } 4756 else if (name.Equals("__MethodSignature")) 4757 { 4758 methodSignature = (Type[]) value; 4759 } 4760 else if (name.Equals("__TypeName")) 4761 { 4762 typeName = (String) value; 4763 } 4764 else if (name.Equals("__OutArgs")) 4765 { 4766 outArgs = (Object[]) value; 4767 } 4768 else if (name.Equals("__CallContext")) 4769 { 4770 // if the value is a string, then its the LogicalCallId 4771 if (value is String) 4772 { 4773 callContext = new LogicalCallContext(); 4774 callContext.RemotingData.LogicalCallID = (String) value; 4775 } 4776 else 4777 callContext = (LogicalCallContext) value; 4778 } 4779 else if (name.Equals("__Return")) 4780 { 4781 retVal = value; 4782 } 4783 else 4784 { 4785 if (InternalProperties == null) 4786 { 4787 InternalProperties = new Hashtable(); 4788 } 4789 InternalProperties[name] = value; 4790 } 4791 } 4792 4793 // 4794 // IInternalMessage 4795 // 4796 4797 /// <internalonly/> 4798 ServerIdentity IInternalMessage.ServerIdentityObject 4799 { 4800 [System.Security.SecurityCritical] 4801 get { return null; } 4802 [System.Security.SecurityCritical] 4803 set { } 4804 } 4805 4806 /// <internalonly/> 4807 Identity IInternalMessage.IdentityObject 4808 { 4809 [System.Security.SecurityCritical] 4810 get { return null; } 4811 [System.Security.SecurityCritical] 4812 set { } 4813 } 4814 4815 /// <internalonly/> 4816 [System.Security.SecurityCritical] IInternalMessage.SetURI(String val)4817 void IInternalMessage.SetURI(String val) 4818 { 4819 uri = val; 4820 } 4821 4822 /// <internalonly/> 4823 4824 [System.Security.SecurityCritical] IInternalMessage.SetCallContext(LogicalCallContext newCallContext)4825 void IInternalMessage.SetCallContext(LogicalCallContext newCallContext) 4826 { 4827 callContext = newCallContext; 4828 } 4829 4830 /// <internalonly/> 4831 [System.Security.SecurityCritical] IInternalMessage.HasProperties()4832 bool IInternalMessage.HasProperties() 4833 { 4834 return (ExternalProperties != null) || (InternalProperties != null); 4835 } 4836 4837 } // class MethodResponse 4838 4839 internal interface ISerializationRootObject 4840 { 4841 [System.Security.SecurityCritical] // auto-generated_required RootSetObjectData(SerializationInfo info, StreamingContext ctx)4842 void RootSetObjectData(SerializationInfo info, StreamingContext ctx); 4843 } 4844 4845 [Serializable] 4846 internal class SerializationMonkey : ISerializable, IFieldInfo 4847 { 4848 internal ISerializationRootObject _obj; 4849 internal String[] fieldNames = null; 4850 internal Type[] fieldTypes = null; 4851 4852 [System.Security.SecurityCritical] // auto-generated SerializationMonkey(SerializationInfo info, StreamingContext ctx)4853 internal SerializationMonkey(SerializationInfo info, StreamingContext ctx) 4854 { 4855 Contract.Assert(_obj != null, "SerializationMonkey's _obj field should have been initialized elsewhere with a special hack."); 4856 _obj.RootSetObjectData(info, ctx); 4857 } 4858 4859 [System.Security.SecurityCritical] // auto-generated_required GetObjectData(SerializationInfo info, StreamingContext context)4860 public void GetObjectData(SerializationInfo info, StreamingContext context) 4861 { 4862 throw new NotSupportedException( 4863 Environment.GetResourceString( 4864 "NotSupported_Method")); 4865 } 4866 4867 public String[] FieldNames 4868 { 4869 [System.Security.SecurityCritical] // auto-generated 4870 get {return fieldNames;} 4871 [System.Security.SecurityCritical] // auto-generated 4872 set {fieldNames = value;} 4873 } 4874 4875 public Type[] FieldTypes 4876 { 4877 [System.Security.SecurityCritical] // auto-generated 4878 get {return fieldTypes;} 4879 [System.Security.SecurityCritical] // auto-generated 4880 set {fieldTypes = value;} 4881 } 4882 4883 4884 } 4885 4886 //+================================================================================ 4887 // 4888 // Synopsis: Message used for deserialization of a method construction 4889 // 4890 //-================================================================================ 4891 /// <internalonly/> 4892 [System.Security.SecurityCritical] // auto-generated_required 4893 [Serializable] 4894 [CLSCompliant(false)] 4895 [SecurityPermissionAttribute(SecurityAction.InheritanceDemand, Flags=SecurityPermissionFlag.Infrastructure)] 4896 [System.Runtime.InteropServices.ComVisible(true)] 4897 public class ConstructionResponse : MethodResponse, IConstructionReturnMessage 4898 { 4899 /// <internalonly/> ConstructionResponse(Header[] h, IMethodCallMessage mcm)4900 public ConstructionResponse(Header[] h, IMethodCallMessage mcm) : base(h, mcm) {} ConstructionResponse(SerializationInfo info, StreamingContext context)4901 internal ConstructionResponse(SerializationInfo info, StreamingContext context) : base (info, context) {} 4902 4903 /// <internalonly/> 4904 public override IDictionary Properties 4905 { 4906 [System.Security.SecurityCritical] 4907 get 4908 { 4909 lock(this) 4910 { 4911 if (InternalProperties == null) 4912 { 4913 InternalProperties = new Hashtable(); 4914 } 4915 if (ExternalProperties == null) 4916 { 4917 ExternalProperties = new CRMDictionary(this, InternalProperties); 4918 } 4919 return ExternalProperties; 4920 } 4921 } 4922 } 4923 } 4924 4925 // This is a special message used for helping someone make a transition 4926 // into a Context (or AppDomain) and back out. This is intended as a replacement 4927 // of the callBack object mechanism which is expensive since it involves 4928 // 2 round trips (one to get the callback object) and one to make the call 4929 // on it. Furthermore the callBack object scheme in cross domain cases would 4930 // involve unnecessary marshal/unmarshal-s of vari'ous callBack objects. 4931 // 4932 // We implement IInternalMessage and do our own magic when various 4933 // infrastructure sinks ask for serverID etc. Bottomline intent is to make 4934 // everything look like a complete remote call with all the entailing transitions 4935 // and executing some delegate in another context (or appdomain) without 4936 // actually having a proxy to call "Invoke" on or a server object to "Dispatch" 4937 // on. 4938 [Serializable] 4939 internal class TransitionCall 4940 :IMessage, IInternalMessage, IMessageSink, ISerializable 4941 { 4942 IDictionary _props; // For IMessage::GetDictionary 4943 IntPtr _sourceCtxID; // Where the request emerged 4944 IntPtr _targetCtxID; // Where the request should execute 4945 int _targetDomainID; // Non zero if we are going to another domain 4946 ServerIdentity _srvID; // Created serverID 4947 Identity _ID; // Created ID 4948 4949 CrossContextDelegate _delegate; // The delegate to execute for the cross context case 4950 IntPtr _eeData; // Used for DoCallbackInEE 4951 4952 // The _delegate should really be on an agile object otherwise 4953 // the whole point of doing a callBack is moot. However, even if it 4954 // is not, remoting and serialization together will ensure that 4955 // everything happens as expected and there is no smuggling. 4956 4957 [System.Security.SecurityCritical] // auto-generated TransitionCall( IntPtr targetCtxID, CrossContextDelegate deleg)4958 internal TransitionCall( 4959 IntPtr targetCtxID, 4960 CrossContextDelegate deleg) 4961 { 4962 Contract.Assert(targetCtxID!=IntPtr.Zero, "bad target ctx for call back"); 4963 _sourceCtxID = Thread.CurrentContext.InternalContextID; 4964 _targetCtxID = targetCtxID; 4965 _delegate = deleg; 4966 _targetDomainID = 0; 4967 _eeData = IntPtr.Zero; 4968 4969 // We are going to another context in the same app domain 4970 _srvID = new ServerIdentity( 4971 null, 4972 Thread.GetContextInternal(_targetCtxID)); 4973 _ID = _srvID; 4974 _ID.RaceSetChannelSink(CrossContextChannel.MessageSink); 4975 _srvID.RaceSetServerObjectChain(this); 4976 4977 //DBG Console.WriteLine("### TransitionCall ctor: " + Int32.Format(_sourceCtxID,"x") + ":" + Int32.Format(_targetCtxID,"x")); 4978 } // TransitionCall 4979 4980 4981 // This constructor should be used for cross appdomain case. 4982 [System.Security.SecurityCritical] // auto-generated TransitionCall(IntPtr targetCtxID, IntPtr eeData, int targetDomainID)4983 internal TransitionCall(IntPtr targetCtxID, IntPtr eeData, int targetDomainID) 4984 { 4985 Contract.Assert(targetCtxID != IntPtr.Zero, "bad target ctx for call back"); 4986 Contract.Assert(targetDomainID !=0, "bad target ctx for call back"); 4987 4988 _sourceCtxID = Thread.CurrentContext.InternalContextID; 4989 _targetCtxID = targetCtxID; 4990 _delegate = null; 4991 _targetDomainID = targetDomainID; 4992 _eeData = eeData; 4993 4994 4995 // In the cross domain case, the client side just has a base Identity 4996 // and the server domain has the Server identity. We fault in the latter 4997 // when requested later. 4998 4999 // We are going to a context in another app domain 5000 _srvID = null; 5001 _ID = new Identity("TransitionCallURI", null); 5002 5003 // Create the data needed for the channel sink creation 5004 CrossAppDomainData data = 5005 new CrossAppDomainData(_targetCtxID, 5006 _targetDomainID, 5007 Identity.ProcessGuid); 5008 String unUsed; 5009 IMessageSink channelSink = 5010 CrossAppDomainChannel.AppDomainChannel.CreateMessageSink( 5011 null, //uri 5012 data, //channelData 5013 out unUsed);//out objURI 5014 5015 Contract.Assert(channelSink != null, "X-domain transition failure"); 5016 _ID.RaceSetChannelSink(channelSink); 5017 } // TransitionCall 5018 5019 TransitionCall(SerializationInfo info, StreamingContext context)5020 internal TransitionCall(SerializationInfo info, StreamingContext context) 5021 { 5022 if (info == null || (context.State != StreamingContextStates.CrossAppDomain)) 5023 { 5024 throw new ArgumentNullException("info"); 5025 } 5026 Contract.EndContractBlock(); 5027 5028 _props = (IDictionary)info.GetValue("props", typeof(IDictionary)); 5029 _delegate = (CrossContextDelegate) info.GetValue("delegate", typeof(CrossContextDelegate)); 5030 _sourceCtxID = (IntPtr) info.GetValue("sourceCtxID", typeof(IntPtr)); 5031 _targetCtxID = (IntPtr) info.GetValue("targetCtxID", typeof(IntPtr)); 5032 _eeData = (IntPtr) info.GetValue("eeData", typeof(IntPtr)); 5033 5034 _targetDomainID = info.GetInt32("targetDomainID"); 5035 Contract.Assert(_targetDomainID != 0, "target domain should be non-zero"); 5036 } 5037 5038 //IMessage::GetProperties 5039 public IDictionary Properties 5040 { 5041 [System.Security.SecurityCritical] // auto-generated 5042 get 5043 { 5044 if (_props == null) 5045 { 5046 lock(this) 5047 { 5048 if (_props == null) 5049 { 5050 _props = new Hashtable(); 5051 } 5052 } 5053 } 5054 return _props; 5055 } 5056 } 5057 5058 //IInternalMessage::ServerIdentityObject 5059 ServerIdentity IInternalMessage.ServerIdentityObject 5060 { 5061 [System.Security.SecurityCritical] 5062 get 5063 { 5064 if ( (_targetDomainID!=0) && _srvID == null) 5065 { 5066 // We should now be in the target context! (We should not be 5067 // attempting to get the server identity in the client domain). 5068 Contract.Assert(Thread.CurrentContext.InternalContextID 5069 == _targetCtxID, 5070 "ServerID requested in wrong appDomain!"); 5071 lock(this) 5072 { 5073 /*DBG Console.WriteLine("### Get SrvID: thrdCtxID== " + Int32.Format(Thread.CurrentContext.InternalContextID,"x")); 5074 Console.WriteLine("### Get SrvID: _targetCtxID" + Int32.Format(_targetCtxID,"x")); DBG*/ 5075 5076 // NOTE: if we don't have a managed context object 5077 // corresponding to the targetCtxID ... we just use 5078 // the default context for the AppDomain. This could 5079 // be a problem if by some means we could have 5080 // a non-default target VM context without a managed 5081 // context object associated with it. 5082 Context ctx = Thread.GetContextInternal(_targetCtxID); 5083 if (ctx == null) 5084 { 5085 ctx = Context.DefaultContext; 5086 } 5087 Contract.Assert(ctx != null, "Null target context unexpected!"); 5088 _srvID = new ServerIdentity( 5089 null, 5090 Thread.GetContextInternal(_targetCtxID)); 5091 5092 _srvID.RaceSetServerObjectChain(this); 5093 } 5094 } 5095 return _srvID; 5096 } 5097 [System.Security.SecurityCritical] 5098 set 5099 { 5100 throw new RemotingException( 5101 Environment.GetResourceString( 5102 "Remoting_Default")); 5103 } 5104 } 5105 5106 //IInternalMessage::IdentityObject 5107 Identity IInternalMessage.IdentityObject 5108 { 5109 [System.Security.SecurityCritical] 5110 get 5111 { 5112 return _ID; 5113 } 5114 [System.Security.SecurityCritical] 5115 set 5116 { 5117 throw new RemotingException( 5118 Environment.GetResourceString( 5119 "Remoting_Default")); 5120 } 5121 } 5122 5123 //IInternalMessage::SetURI 5124 [System.Security.SecurityCritical] IInternalMessage.SetURI(String uri)5125 void IInternalMessage.SetURI(String uri) 5126 { 5127 throw new RemotingException( 5128 Environment.GetResourceString( 5129 "Remoting_Default")); 5130 } 5131 5132 [System.Security.SecurityCritical] IInternalMessage.SetCallContext(LogicalCallContext callContext)5133 void IInternalMessage.SetCallContext(LogicalCallContext callContext) 5134 { 5135 throw new RemotingException( 5136 Environment.GetResourceString( 5137 "Remoting_Default")); 5138 } 5139 5140 [System.Security.SecurityCritical] IInternalMessage.HasProperties()5141 bool IInternalMessage.HasProperties() 5142 { 5143 throw new RemotingException( 5144 Environment.GetResourceString( 5145 "Remoting_Default")); 5146 } 5147 5148 5149 //IMessage::SyncProcessMessage 5150 [System.Security.SecurityCritical] // auto-generated SyncProcessMessage(IMessage msg)5151 public IMessage SyncProcessMessage(IMessage msg) 5152 { 5153 Contract.Assert( 5154 Thread.CurrentContext.InternalContextID == _targetCtxID, 5155 "Transition message routed to wrong context"); 5156 5157 try 5158 { 5159 LogicalCallContext oldcctx = Message.PropagateCallContextFromMessageToThread(msg); 5160 if (_delegate != null) 5161 { 5162 _delegate(); 5163 } 5164 else 5165 { 5166 // This is the cross appdomain case, so we need to construct 5167 // the delegate and call on it. 5168 CallBackHelper cb = new CallBackHelper( 5169 _eeData, 5170 true /*fromEE*/, 5171 _targetDomainID); 5172 CrossContextDelegate ctxDel = new CrossContextDelegate(cb.Func); 5173 ctxDel(); 5174 } 5175 Message.PropagateCallContextFromThreadToMessage(msg, oldcctx); 5176 } 5177 5178 catch (Exception e) 5179 { 5180 ReturnMessage retMsg = new ReturnMessage(e, new ErrorMessage()); 5181 retMsg.SetLogicalCallContext( 5182 (LogicalCallContext) msg.Properties[Message.CallContextKey]); 5183 return retMsg; 5184 } 5185 5186 return this; 5187 } 5188 5189 //IMessage::AsyncProcessMessage 5190 [System.Security.SecurityCritical] // auto-generated AsyncProcessMessage(IMessage msg, IMessageSink replySink)5191 public IMessageCtrl AsyncProcessMessage(IMessage msg, IMessageSink replySink) 5192 { 5193 IMessage retMsg = SyncProcessMessage(msg); 5194 replySink.SyncProcessMessage(retMsg); 5195 return null; 5196 } 5197 5198 //IMessage::GetNextSink() 5199 public IMessageSink NextSink 5200 { 5201 [System.Security.SecurityCritical] // auto-generated 5202 get{return null;} 5203 } 5204 5205 //ISerializable::GetObjectData 5206 [System.Security.SecurityCritical] // auto-generated_required GetObjectData(SerializationInfo info, StreamingContext context)5207 public void GetObjectData(SerializationInfo info, StreamingContext context) 5208 { 5209 if (info == null || (context.State != StreamingContextStates.CrossAppDomain)) 5210 { 5211 throw new ArgumentNullException("info"); 5212 } 5213 Contract.EndContractBlock(); 5214 info.AddValue("props", _props, typeof(IDictionary)); 5215 info.AddValue("delegate", _delegate, typeof(CrossContextDelegate)); 5216 info.AddValue("sourceCtxID", _sourceCtxID); 5217 info.AddValue("targetCtxID", _targetCtxID); 5218 info.AddValue("targetDomainID", _targetDomainID); 5219 info.AddValue("eeData", _eeData); 5220 } 5221 5222 }// class TransitionCall 5223 5224 internal class ArgMapper 5225 { 5226 int[] _map; 5227 IMethodMessage _mm; 5228 RemotingMethodCachedData _methodCachedData; 5229 5230 [System.Security.SecurityCritical] // auto-generated ArgMapper(IMethodMessage mm, bool fOut)5231 internal ArgMapper(IMethodMessage mm, bool fOut) 5232 { 5233 _mm = mm; 5234 MethodBase mb = (MethodBase)_mm.MethodBase; 5235 _methodCachedData = 5236 InternalRemotingServices.GetReflectionCachedData(mb); 5237 5238 if (fOut) 5239 _map = _methodCachedData.MarshalResponseArgMap; 5240 else 5241 _map = _methodCachedData.MarshalRequestArgMap; 5242 } // ArgMapper 5243 5244 [System.Security.SecurityCritical] // auto-generated ArgMapper(MethodBase mb, bool fOut)5245 internal ArgMapper(MethodBase mb, bool fOut) 5246 { 5247 _methodCachedData = 5248 InternalRemotingServices.GetReflectionCachedData(mb); 5249 5250 if (fOut) 5251 _map = _methodCachedData.MarshalResponseArgMap; 5252 else 5253 _map = _methodCachedData.MarshalRequestArgMap; 5254 } // ArgMapper 5255 5256 5257 internal int[] Map 5258 { 5259 get { return _map; } 5260 } 5261 5262 internal int ArgCount 5263 { 5264 get 5265 { 5266 if (_map == null) 5267 { 5268 return 0; 5269 } 5270 else 5271 { 5272 return _map.Length; 5273 } 5274 } 5275 } 5276 5277 [System.Security.SecurityCritical] // auto-generated GetArg(int argNum)5278 internal Object GetArg(int argNum) 5279 { 5280 5281 if (_map == null || argNum < 0 || argNum >= _map.Length) 5282 { 5283 throw new InvalidOperationException( 5284 Environment.GetResourceString( 5285 "InvalidOperation_InternalState")); 5286 } 5287 else 5288 { 5289 return _mm.GetArg(_map[argNum]); 5290 } 5291 } 5292 5293 [System.Security.SecurityCritical] // auto-generated GetArgName(int argNum)5294 internal String GetArgName(int argNum) 5295 { 5296 if (_map == null || argNum < 0 || argNum >= _map.Length) 5297 { 5298 throw new InvalidOperationException( 5299 Environment.GetResourceString( 5300 "InvalidOperation_InternalState")); 5301 } 5302 else 5303 { 5304 return _mm.GetArgName(_map[argNum]); 5305 } 5306 } 5307 5308 internal Object[] Args 5309 { 5310 [System.Security.SecurityCritical] // auto-generated 5311 get 5312 { 5313 if (_map == null) 5314 { 5315 return null; 5316 } 5317 else 5318 { 5319 Object[] ret = new Object[_map.Length]; 5320 for(int i=0; i<_map.Length; i++) 5321 { 5322 ret[i] = _mm.GetArg(_map[i]); 5323 } 5324 return ret; 5325 } 5326 } 5327 } 5328 5329 internal Type[] ArgTypes 5330 { 5331 get 5332 { 5333 Type[] ret = null; 5334 if (_map != null) 5335 { 5336 ParameterInfo[] pi = _methodCachedData.Parameters; 5337 ret = new Type[_map.Length]; 5338 for (int i=0; i<_map.Length; i++) 5339 { 5340 ret[i] = pi[_map[i]].ParameterType; 5341 } 5342 } 5343 return ret; 5344 } 5345 } 5346 5347 internal String[] ArgNames 5348 { 5349 get 5350 { 5351 String[] ret = null; 5352 if (_map != null) 5353 { 5354 ParameterInfo[] pi = _methodCachedData.Parameters; 5355 ret = new String[_map.Length]; 5356 for (int i=0; i<_map.Length; i++) 5357 { 5358 ret[i] = pi[_map[i]].Name; 5359 } 5360 } 5361 return ret; 5362 } 5363 } 5364 5365 5366 // 5367 // Helper functions for getting argument maps 5368 // 5369 GetParameterMaps(ParameterInfo[] parameters, out int[] inRefArgMap, out int[] outRefArgMap, out int[] outOnlyArgMap, out int[] nonRefOutArgMap, out int[] marshalRequestMap, out int[] marshalResponseMap)5370 internal static void GetParameterMaps(ParameterInfo[] parameters, 5371 out int[] inRefArgMap, 5372 out int[] outRefArgMap, 5373 out int[] outOnlyArgMap, 5374 out int[] nonRefOutArgMap, 5375 out int[] marshalRequestMap, 5376 out int[] marshalResponseMap) 5377 { 5378 int co; 5379 5380 int inRefCount = 0; 5381 int outRefCount = 0; 5382 int outOnlyCount = 0; 5383 int nonRefOutCount = 0; 5384 5385 int marshalRequestCount = 0; 5386 int marshalResponseCount = 0; 5387 int[] tempMarshalRequestMap = new int[parameters.Length]; 5388 int[] tempMarshalResponseMap = new int[parameters.Length]; 5389 5390 // count instances of each type of parameter 5391 co = 0; 5392 foreach (ParameterInfo param in parameters) 5393 { 5394 bool bIsIn = param.IsIn; // [In] 5395 bool bIsOut = param.IsOut; // [Out] note: out int a === [Out] ref int b 5396 5397 bool bIsByRef = param.ParameterType.IsByRef; // (ref or normal) 5398 5399 if (!bIsByRef) 5400 { 5401 // it's a normal parameter (always passed in) 5402 inRefCount++; 5403 if (bIsOut) 5404 nonRefOutCount++; 5405 } 5406 else 5407 if (bIsOut) 5408 { 5409 outRefCount++; 5410 outOnlyCount++; 5411 } 5412 else 5413 { 5414 inRefCount++; 5415 5416 outRefCount++; 5417 } 5418 5419 // create maps for marshaling 5420 bool bMarshalIn = false; 5421 bool bMarshalOut = false; 5422 if (bIsByRef) 5423 { 5424 if (bIsIn == bIsOut) 5425 { 5426 // "ref int a" or "[In, Out] ref int a" 5427 bMarshalIn = true; 5428 bMarshalOut = true; 5429 } 5430 else 5431 { 5432 // "[In] ref int a" or "out int a" 5433 bMarshalIn = bIsIn; 5434 bMarshalOut = bIsOut; 5435 } 5436 } 5437 else 5438 { 5439 // "int a" or "[In, Out] a" 5440 bMarshalIn = true; 5441 bMarshalOut = bIsOut; 5442 } 5443 5444 5445 if (bMarshalIn) 5446 tempMarshalRequestMap[marshalRequestCount++] = co; 5447 5448 if (bMarshalOut) 5449 tempMarshalResponseMap[marshalResponseCount++] = co; 5450 5451 co++; // parameter index 5452 } // foreach (ParameterInfo param in parameters) 5453 5454 inRefArgMap = new int[inRefCount]; 5455 outRefArgMap = new int[outRefCount]; 5456 outOnlyArgMap = new int[outOnlyCount]; 5457 nonRefOutArgMap = new int[nonRefOutCount]; 5458 5459 inRefCount = 0; 5460 outRefCount = 0; 5461 outOnlyCount = 0; 5462 nonRefOutCount = 0; 5463 5464 // build up parameter maps 5465 for (co = 0; co < parameters.Length; co++) 5466 { 5467 ParameterInfo param = parameters[co]; 5468 5469 bool bIsOut = param.IsOut; // [Out] note: out int a === [Out] ref int b 5470 5471 bool bIsByRef = param.ParameterType.IsByRef; // (ref or normal) 5472 5473 if (!bIsByRef) 5474 { 5475 // it's an in parameter 5476 inRefArgMap[inRefCount++] = co; 5477 if (bIsOut) 5478 nonRefOutArgMap[nonRefOutCount++] = co; 5479 } 5480 else 5481 if (bIsOut) 5482 { 5483 outRefArgMap[outRefCount++] = co; 5484 outOnlyArgMap[outOnlyCount++] = co; 5485 } 5486 else 5487 { 5488 inRefArgMap[inRefCount++] = co; 5489 5490 outRefArgMap[outRefCount++] = co; 5491 } 5492 } 5493 5494 // copy over marshal maps 5495 marshalRequestMap = new int[marshalRequestCount]; 5496 Array.Copy(tempMarshalRequestMap, marshalRequestMap, marshalRequestCount); 5497 5498 marshalResponseMap = new int[marshalResponseCount]; 5499 Array.Copy(tempMarshalResponseMap, marshalResponseMap, marshalResponseCount); 5500 5501 } // GetParameterMaps 5502 5503 // 5504 // Helper methods for expanding and contracting argument lists 5505 // when translating from async methods to sync methods and back. 5506 // 5507 ExpandAsyncEndArgsToSyncArgs(RemotingMethodCachedData syncMethod, Object[] asyncEndArgs)5508 internal static Object[] ExpandAsyncEndArgsToSyncArgs(RemotingMethodCachedData syncMethod, 5509 Object[] asyncEndArgs) 5510 { 5511 // This is when we have a list of args associated with EndFoo(), and 5512 // we want to size it to a list of args associated with Foo(); 5513 5514 Object[] args = new Object[syncMethod.Parameters.Length]; 5515 5516 int[] outRefArgMap = syncMethod.OutRefArgMap; 5517 5518 for (int co = 0; co < outRefArgMap.Length; co++) 5519 { 5520 args[outRefArgMap[co]] = asyncEndArgs[co]; 5521 } 5522 5523 return args; 5524 } // ExpandAsyncEndArgsToSyncArgs 5525 5526 } // class ArgMapper 5527 5528 internal class ErrorMessage: IMethodCallMessage 5529 { 5530 5531 // IMessage 5532 public IDictionary Properties 5533 { 5534 [System.Security.SecurityCritical] // auto-generated 5535 get{ return null;} 5536 } 5537 5538 // IMethodMessage 5539 public String Uri 5540 { 5541 [System.Security.SecurityCritical] // auto-generated 5542 get{ return m_URI; } 5543 } 5544 5545 public String MethodName 5546 { 5547 [System.Security.SecurityCritical] // auto-generated 5548 get{ return m_MethodName; } 5549 } 5550 5551 public String TypeName 5552 { 5553 [System.Security.SecurityCritical] // auto-generated 5554 get{ return m_TypeName; } 5555 } 5556 5557 public Object MethodSignature 5558 { 5559 [System.Security.SecurityCritical] // auto-generated 5560 get { return m_MethodSignature; } 5561 } 5562 5563 public MethodBase MethodBase 5564 { 5565 [System.Security.SecurityCritical] // auto-generated 5566 get { return null; } 5567 } 5568 5569 public int ArgCount 5570 { 5571 [System.Security.SecurityCritical] // auto-generated 5572 get { return m_ArgCount;} 5573 } 5574 5575 [System.Security.SecurityCritical] // auto-generated GetArgName(int index)5576 public String GetArgName(int index) { return m_ArgName; } 5577 [System.Security.SecurityCritical] // auto-generated GetArg(int argNum)5578 public Object GetArg(int argNum) { return null;} 5579 public Object[] Args 5580 { 5581 [System.Security.SecurityCritical] // auto-generated 5582 get { return null;} 5583 } 5584 5585 public bool HasVarArgs 5586 { 5587 [System.Security.SecurityCritical] // auto-generated 5588 get { return false;} 5589 } 5590 5591 5592 // IMethodCallMessage 5593 public int InArgCount 5594 { 5595 [System.Security.SecurityCritical] // auto-generated 5596 get { return m_ArgCount;} 5597 } 5598 [System.Security.SecurityCritical] // auto-generated GetInArgName(int index)5599 public String GetInArgName(int index) { return null; } 5600 [System.Security.SecurityCritical] // auto-generated GetInArg(int argNum)5601 public Object GetInArg(int argNum) { return null;} 5602 public Object[] InArgs 5603 { 5604 [System.Security.SecurityCritical] // auto-generated 5605 get { return null; } 5606 } 5607 public LogicalCallContext LogicalCallContext 5608 { 5609 [System.Security.SecurityCritical] // auto-generated 5610 get { return null; } 5611 } 5612 5613 String m_URI = "Exception"; 5614 String m_MethodName = "Unknown"; 5615 String m_TypeName = "Unknown"; 5616 Object m_MethodSignature = null; 5617 int m_ArgCount = 0; 5618 String m_ArgName = "Unknown"; 5619 } 5620 5621 5622 5623 //+================================================================================ 5624 // 5625 // Synopsis: Message wrapper used as base class for all exposed message wrappers. 5626 // This is needed so that we can extract the identity object from a custom message. 5627 // 5628 //-================================================================================ 5629 /// <internalonly/> 5630 [System.Security.SecurityCritical] // auto-generated 5631 [System.Runtime.InteropServices.ComVisible(true)] 5632 public class InternalMessageWrapper 5633 { 5634 /// <internalonly/> 5635 protected IMessage WrappedMessage; 5636 5637 /// <internalonly/> InternalMessageWrapper(IMessage msg)5638 public InternalMessageWrapper(IMessage msg) 5639 { 5640 WrappedMessage = msg; 5641 } // InternalMessageWrapper 5642 5643 [System.Security.SecurityCritical] // auto-generated GetIdentityObject()5644 internal Object GetIdentityObject() 5645 { 5646 IInternalMessage iim = WrappedMessage as IInternalMessage; 5647 if (null != iim) 5648 { 5649 return iim.IdentityObject; 5650 } 5651 else 5652 { 5653 InternalMessageWrapper imw = WrappedMessage as InternalMessageWrapper; 5654 if(null != imw) 5655 { 5656 return imw.GetIdentityObject(); 5657 } 5658 else 5659 { 5660 return null; 5661 } 5662 } 5663 } // GetIdentityObject 5664 5665 [System.Security.SecurityCritical] // auto-generated GetServerIdentityObject()5666 internal Object GetServerIdentityObject() 5667 { 5668 IInternalMessage iim = WrappedMessage as IInternalMessage; 5669 if (null != iim) 5670 { 5671 return iim.ServerIdentityObject; 5672 } 5673 else 5674 { 5675 InternalMessageWrapper imw = WrappedMessage as InternalMessageWrapper; 5676 if (null != imw) 5677 { 5678 return imw.GetServerIdentityObject(); 5679 } 5680 else 5681 { 5682 return null; 5683 } 5684 } 5685 } // GetServerIdentityObject 5686 5687 } // class InternalMessageWrapper 5688 5689 5690 5691 //+================================================================================ 5692 // 5693 // Synopsis: Message wrapper used for creating custom method call messages. 5694 // 5695 //-================================================================================ 5696 /// <internalonly/> 5697 [System.Security.SecurityCritical] // auto-generated_required 5698 [SecurityPermissionAttribute(SecurityAction.InheritanceDemand, Flags=SecurityPermissionFlag.Infrastructure)] 5699 [System.Runtime.InteropServices.ComVisible(true)] 5700 public class MethodCallMessageWrapper : InternalMessageWrapper, IMethodCallMessage 5701 { 5702 // we need to overload the dictionary to delegate special values to this class 5703 private class MCMWrapperDictionary : Hashtable 5704 { 5705 private IMethodCallMessage _mcmsg; // pointer to this message object 5706 private IDictionary _idict; // point to contained message's dictionary 5707 MCMWrapperDictionary(IMethodCallMessage msg, IDictionary idict)5708 public MCMWrapperDictionary(IMethodCallMessage msg, IDictionary idict) 5709 { 5710 _mcmsg = msg; 5711 _idict = idict; 5712 } 5713 5714 public override Object this[Object key] 5715 { 5716 [System.Security.SecuritySafeCritical] // overrides transparent public member 5717 get 5718 { 5719 System.String strKey = key as System.String; 5720 if (null != strKey) 5721 { 5722 switch (strKey) 5723 { 5724 case "__Uri": return _mcmsg.Uri; 5725 case "__MethodName": return _mcmsg.MethodName; 5726 case "__MethodSignature": return _mcmsg.MethodSignature; 5727 case "__TypeName": return _mcmsg.TypeName; 5728 case "__Args": return _mcmsg.Args; 5729 } 5730 } 5731 return _idict[key]; 5732 } 5733 [System.Security.SecuritySafeCritical] // overrides transparent public member 5734 set 5735 { 5736 System.String strKey = key as System.String; 5737 if (null != strKey) 5738 { 5739 switch (strKey) 5740 { 5741 case "__MethodName": 5742 case "__MethodSignature": 5743 case "__TypeName": 5744 case "__Args": 5745 throw new RemotingException( 5746 Environment.GetResourceString("Remoting_Default")); 5747 } 5748 _idict[key] = value; 5749 } 5750 } 5751 } 5752 } // class MCMWrapperDictionary 5753 5754 5755 IMethodCallMessage _msg; 5756 IDictionary _properties; 5757 ArgMapper _argMapper = null; 5758 Object[] _args; 5759 5760 5761 /// <internalonly/> MethodCallMessageWrapper(IMethodCallMessage msg)5762 public MethodCallMessageWrapper(IMethodCallMessage msg) : base(msg) 5763 { 5764 _msg = msg; 5765 _args = _msg.Args; 5766 } // MethodCallMessageWrapper 5767 5768 5769 // IMethodMessage implementation 5770 5771 /// <internalonly/> 5772 public virtual String Uri 5773 { 5774 [System.Security.SecurityCritical] 5775 get 5776 { 5777 return _msg.Uri; 5778 } 5779 set 5780 { 5781 _msg.Properties[Message.UriKey] = value; 5782 } 5783 } 5784 5785 /// <internalonly/> 5786 public virtual String MethodName 5787 { 5788 [System.Security.SecurityCritical] 5789 get { return _msg.MethodName; } 5790 } 5791 /// <internalonly/> 5792 public virtual String TypeName 5793 { 5794 [System.Security.SecurityCritical] 5795 get { return _msg.TypeName; } 5796 } 5797 /// <internalonly/> 5798 public virtual Object MethodSignature 5799 { 5800 [System.Security.SecurityCritical] 5801 get { return _msg.MethodSignature; } 5802 } 5803 /// <internalonly/> 5804 public virtual LogicalCallContext LogicalCallContext 5805 { 5806 [System.Security.SecurityCritical] 5807 get { return _msg.LogicalCallContext; } 5808 } 5809 /// <internalonly/> 5810 public virtual MethodBase MethodBase 5811 { 5812 [System.Security.SecurityCritical] 5813 get { return _msg.MethodBase; } 5814 } 5815 5816 /// <internalonly/> 5817 public virtual int ArgCount 5818 { 5819 [System.Security.SecurityCritical] 5820 get 5821 { 5822 if (_args != null) 5823 return _args.Length; 5824 else 5825 return 0; 5826 } 5827 } 5828 /// <internalonly/> 5829 [System.Security.SecurityCritical] GetArgName(int index)5830 public virtual String GetArgName(int index) { return _msg.GetArgName(index); } 5831 /// <internalonly/> 5832 [System.Security.SecurityCritical] GetArg(int argNum)5833 public virtual Object GetArg(int argNum) { return _args[argNum]; } 5834 /// <internalonly/> 5835 public virtual Object[] Args 5836 { 5837 [System.Security.SecurityCritical] 5838 get { return _args; } 5839 set { _args = value; } 5840 } 5841 5842 /// <internalonly/> 5843 public virtual bool HasVarArgs 5844 { 5845 [System.Security.SecurityCritical] 5846 get { return _msg.HasVarArgs; } 5847 } 5848 5849 // end of IMethodMessage implementation 5850 5851 5852 // IMethodCallMessage implementation 5853 // (We cannot simply delegate to the internal message 5854 // since we override the definition of Args and create our own array 5855 // which can be modified.) 5856 /// <internalonly/> 5857 public virtual int InArgCount 5858 { 5859 [System.Security.SecurityCritical] 5860 get 5861 { 5862 if (_argMapper == null) _argMapper = new ArgMapper(this, false); 5863 return _argMapper.ArgCount; 5864 } 5865 } // InArgCount 5866 5867 /// <internalonly/> 5868 [System.Security.SecurityCritical] GetInArg(int argNum)5869 public virtual Object GetInArg(int argNum) 5870 { 5871 if (_argMapper == null) _argMapper = new ArgMapper(this, false); 5872 return _argMapper.GetArg(argNum); 5873 } // GetInArg 5874 5875 /// <internalonly/> 5876 [System.Security.SecurityCritical] GetInArgName(int index)5877 public virtual String GetInArgName(int index) 5878 { 5879 if (_argMapper == null) _argMapper = new ArgMapper(this, false); 5880 return _argMapper.GetArgName(index); 5881 } // GetInArgName 5882 5883 /// <internalonly/> 5884 public virtual Object[] InArgs 5885 { 5886 [System.Security.SecurityCritical] 5887 get 5888 { 5889 if (_argMapper == null) _argMapper = new ArgMapper(this, false); 5890 return _argMapper.Args; 5891 } 5892 } // InArgs 5893 5894 // end of IMethodCallMessage implementation 5895 5896 5897 /// <internalonly/> 5898 public virtual IDictionary Properties 5899 { 5900 [System.Security.SecurityCritical] 5901 get 5902 { 5903 if (_properties == null) 5904 _properties = new MCMWrapperDictionary(this, _msg.Properties); 5905 return _properties; 5906 } 5907 } 5908 5909 } // class MethodCallMessageWrapper 5910 5911 5912 5913 //+================================================================================ 5914 // 5915 // Synopsis: Message wrapper used for creating custom method return messages. 5916 // 5917 //-================================================================================ 5918 /// <internalonly/> 5919 [System.Security.SecurityCritical] // auto-generated_required 5920 [SecurityPermissionAttribute(SecurityAction.InheritanceDemand, Flags=SecurityPermissionFlag.Infrastructure)] 5921 [System.Runtime.InteropServices.ComVisible(true)] 5922 public class MethodReturnMessageWrapper : InternalMessageWrapper, IMethodReturnMessage 5923 { 5924 // we need to overload the dictionary to delegate special values to this class 5925 private class MRMWrapperDictionary : Hashtable 5926 { 5927 private IMethodReturnMessage _mrmsg; // pointer to this message object 5928 private IDictionary _idict; // point to contained message's dictionary 5929 MRMWrapperDictionary(IMethodReturnMessage msg, IDictionary idict)5930 public MRMWrapperDictionary(IMethodReturnMessage msg, IDictionary idict) 5931 { 5932 _mrmsg = msg; 5933 _idict = idict; 5934 } 5935 5936 public override Object this[Object key] 5937 { 5938 [System.Security.SecuritySafeCritical] // overrides transparent public member 5939 get 5940 { 5941 System.String strKey = key as System.String; 5942 if (null != strKey) 5943 { 5944 switch (strKey) 5945 { 5946 case "__Uri": return _mrmsg.Uri; 5947 case "__MethodName": return _mrmsg.MethodName; 5948 case "__MethodSignature": return _mrmsg.MethodSignature; 5949 case "__TypeName": return _mrmsg.TypeName; 5950 case "__Return": return _mrmsg.ReturnValue; 5951 case "__OutArgs": return _mrmsg.OutArgs; 5952 } 5953 } 5954 return _idict[key]; 5955 } 5956 [System.Security.SecuritySafeCritical] // overrides transparent public member 5957 set 5958 { 5959 System.String strKey = key as System.String; 5960 if (null != strKey) 5961 { 5962 switch (strKey) 5963 { 5964 case "__MethodName": 5965 case "__MethodSignature": 5966 case "__TypeName": 5967 case "__Return": 5968 case "__OutArgs": 5969 throw new RemotingException( 5970 Environment.GetResourceString("Remoting_Default")); 5971 } 5972 _idict[key] = value; 5973 } 5974 } 5975 } 5976 } // class MCMWrapperDictionary 5977 5978 5979 IMethodReturnMessage _msg; 5980 IDictionary _properties; 5981 ArgMapper _argMapper = null; 5982 Object[] _args = null; 5983 Object _returnValue = null; 5984 Exception _exception = null; 5985 5986 5987 /// <internalonly/> MethodReturnMessageWrapper(IMethodReturnMessage msg)5988 public MethodReturnMessageWrapper(IMethodReturnMessage msg) : base(msg) 5989 { 5990 _msg = msg; 5991 _args = _msg.Args; 5992 _returnValue = _msg.ReturnValue; // be careful if you decide to lazily assign _returnValue 5993 // since the return value might actually be null 5994 _exception = _msg.Exception; // (same thing as above goes for _exception) 5995 } // MethodReturnMessageWrapper 5996 5997 5998 // IMethodMessage implementation 5999 6000 /// <internalonly/> 6001 public String Uri 6002 { 6003 [System.Security.SecurityCritical] 6004 get 6005 { 6006 return _msg.Uri; 6007 } 6008 6009 set 6010 { 6011 _msg.Properties[Message.UriKey] = value; 6012 } 6013 } 6014 6015 /// <internalonly/> 6016 public virtual String MethodName 6017 { 6018 [System.Security.SecurityCritical] 6019 get { return _msg.MethodName; } 6020 } 6021 /// <internalonly/> 6022 public virtual String TypeName 6023 { 6024 [System.Security.SecurityCritical] 6025 get { return _msg.TypeName; } 6026 } 6027 /// <internalonly/> 6028 public virtual Object MethodSignature 6029 { 6030 [System.Security.SecurityCritical] 6031 get { return _msg.MethodSignature; } 6032 } 6033 /// <internalonly/> 6034 public virtual LogicalCallContext LogicalCallContext 6035 { 6036 [System.Security.SecurityCritical] 6037 get { return _msg.LogicalCallContext; } 6038 } 6039 /// <internalonly/> 6040 public virtual MethodBase MethodBase 6041 { 6042 [System.Security.SecurityCritical] 6043 get { return _msg.MethodBase; } 6044 } 6045 6046 /// <internalonly/> 6047 public virtual int ArgCount 6048 { 6049 [System.Security.SecurityCritical] 6050 get 6051 { 6052 if (_args != null) 6053 return _args.Length; 6054 else 6055 return 0; 6056 } 6057 } 6058 6059 /// <internalonly/> 6060 [System.Security.SecurityCritical] GetArgName(int index)6061 public virtual String GetArgName(int index) { return _msg.GetArgName(index); } 6062 /// <internalonly/> 6063 [System.Security.SecurityCritical] GetArg(int argNum)6064 public virtual Object GetArg(int argNum) { return _args[argNum]; } 6065 /// <internalonly/> 6066 public virtual Object[] Args 6067 { 6068 [System.Security.SecurityCritical] 6069 get { return _args; } 6070 set { _args = value; } 6071 } 6072 6073 /// <internalonly/> 6074 public virtual bool HasVarArgs 6075 { 6076 [System.Security.SecurityCritical] 6077 get { return _msg.HasVarArgs; } 6078 } 6079 6080 // end of IMethodMessage implementation 6081 6082 6083 // IMethodReturnMessage implementation 6084 // (We cannot simply delegate to the internal message 6085 // since we override the definition of Args and create our own array 6086 // which can be modified.) 6087 /// <internalonly/> 6088 public virtual int OutArgCount 6089 { 6090 [System.Security.SecurityCritical] 6091 get 6092 { 6093 if (_argMapper == null) _argMapper = new ArgMapper(this, true); 6094 return _argMapper.ArgCount; 6095 } 6096 } 6097 6098 /// <internalonly/> 6099 [System.Security.SecurityCritical] GetOutArg(int argNum)6100 public virtual Object GetOutArg(int argNum) 6101 { 6102 if (_argMapper == null) _argMapper = new ArgMapper(this, true); 6103 return _argMapper.GetArg(argNum); 6104 } 6105 6106 /// <internalonly/> 6107 [System.Security.SecurityCritical] GetOutArgName(int index)6108 public virtual String GetOutArgName(int index) 6109 { 6110 if (_argMapper == null) _argMapper = new ArgMapper(this, true); 6111 return _argMapper.GetArgName(index); 6112 } 6113 6114 /// <internalonly/> 6115 public virtual Object[] OutArgs 6116 { 6117 [System.Security.SecurityCritical] 6118 get 6119 { 6120 if (_argMapper == null) _argMapper = new ArgMapper(this, true); 6121 return _argMapper.Args; 6122 } 6123 } 6124 6125 /// <internalonly/> 6126 public virtual Exception Exception 6127 { 6128 [System.Security.SecurityCritical] 6129 get { return _exception; } 6130 set { _exception = value; } 6131 } 6132 6133 /// <internalonly/> 6134 public virtual Object ReturnValue 6135 { 6136 [System.Security.SecurityCritical] 6137 get { return _returnValue; } 6138 set { _returnValue = value; } 6139 } 6140 6141 // end of IMethodReturnMessage implementation 6142 6143 // IMessage 6144 /// <internalonly/> 6145 public virtual IDictionary Properties 6146 { 6147 [System.Security.SecurityCritical] 6148 get 6149 { 6150 if (_properties == null) 6151 _properties = new MRMWrapperDictionary(this, _msg.Properties); 6152 return _properties; 6153 } 6154 } 6155 6156 6157 } // class MethodReturnMessageWrapper 6158 6159 } // namespace Remoting 6160 6161 6162