?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
**** Merged from MCS ****
[mono-project.git] / mcs / class / corlib / System.Runtime.Remoting / RemotingConfiguration.cs
blob2cbe62dff510798b71531f5886ed449ad343dcbe
1 //
2 // System.Runtime.Remoting.RemotingConfiguration.cs
3 //
4 // Author: Jaime Anguiano Olarra (jaime@gnome.org)
5 // Lluis Sanchez Gual (lluis@ideary.com)
6 //
7 // (C) 2002, Jaime Anguiano Olarra
8 //
9
10 //
11 // Copyright (C) 2004 Novell, Inc (http://www.novell.com)
12 //
13 // Permission is hereby granted, free of charge, to any person obtaining
14 // a copy of this software and associated documentation files (the
15 // "Software"), to deal in the Software without restriction, including
16 // without limitation the rights to use, copy, modify, merge, publish,
17 // distribute, sublicense, and/or sell copies of the Software, and to
18 // permit persons to whom the Software is furnished to do so, subject to
19 // the following conditions:
20 //
21 // The above copyright notice and this permission notice shall be
22 // included in all copies or substantial portions of the Software.
23 //
24 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
25 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
26 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
27 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
28 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
29 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
30 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
31 //
32
33 using System;
34 using System.IO;
35 using System.Reflection;
36 using System.Collections;
37 using System.Runtime.Remoting.Activation;
38 using System.Runtime.Remoting.Channels;
39 using System.Runtime.Remoting.Lifetime;
40 using Mono.Xml;
41
42 namespace System.Runtime.Remoting
43 {
44 public class RemotingConfiguration
45 {
46 //
47 // Private constructor: nobody instantiates this.
48 //
49 private RemotingConfiguration ()
50 {
51 }
52
53 static string applicationID = null;
54 static string applicationName = null;
55 static string configFile = "";
56 static MiniParser parser = null;
57 static string processGuid = null;
58 static bool defaultConfigRead = false;
59 static bool defaultDelayedConfigRead = false;
60 static string _errorMode;
61
62 static Hashtable wellKnownClientEntries = new Hashtable();
63 static Hashtable activatedClientEntries = new Hashtable();
64 static Hashtable wellKnownServiceEntries = new Hashtable();
65 static Hashtable activatedServiceEntries = new Hashtable();
66
67 static Hashtable channelTemplates = new Hashtable ();
68 static Hashtable clientProviderTemplates = new Hashtable ();
69 static Hashtable serverProviderTemplates = new Hashtable ();
70
71 // public properties
72 // At this time the ID will be the application name
73 public static string ApplicationId
74 {
75 get
76 {
77 applicationID = AppDomain.CurrentDomain.SetupInformation.ApplicationName;
78 return applicationID;
79 }
80 }
81
82 public static string ApplicationName
83 {
84 get {
85 try {
86 applicationName = AppDomain.CurrentDomain.SetupInformation.ApplicationName;
87 }
88 catch (Exception e) {
89 throw e;
90 }
91 // We return null if the application name has not been set.
92 return null;
93 }
94 set { applicationName = value; }
95 }
96
97 public static string ProcessId
98 {
99 get {
100 if (processGuid == null)
101 processGuid = AppDomain.GetProcessGuid ();
102
103 return processGuid;
104 }
105 }
106
107
108 // public methods
109
110 public static void Configure (string filename)
111 {
112 lock (channelTemplates)
113 {
114 if (!defaultConfigRead)
115 {
116 ReadConfigFile (Environment.GetMachineConfigPath ());
117 defaultConfigRead = true;
118 }
119
120 if (filename != null)
121 ReadConfigFile (filename);
122 }
123 }
124
125 private static void ReadConfigFile (string filename)
126 {
127 try
128 {
129 MiniParser parser = new MiniParser ();
130 RReader rreader = new RReader (filename);
131 ConfigHandler handler = new ConfigHandler (false);
132 parser.Parse (rreader, handler);
133 }
134 catch (Exception ex)
135 {
136 throw new RemotingException ("Configuration file '" + filename + "' could not be loaded: " + ex.Message);
137 }
138 }
139
140 internal static void LoadDefaultDelayedChannels ()
141 {
142 lock (channelTemplates)
143 {
144 if (defaultDelayedConfigRead || defaultConfigRead) return;
145
146 MiniParser parser = new MiniParser ();
147 RReader rreader = new RReader (Environment.GetMachineConfigPath ());
148 ConfigHandler handler = new ConfigHandler (true);
149 parser.Parse (rreader, handler);
150 defaultDelayedConfigRead = true;
151 }
152 }
153
154 public static ActivatedClientTypeEntry[] GetRegisteredActivatedClientTypes ()
155 {
156 lock (channelTemplates)
157 {
158 ActivatedClientTypeEntry[] entries = new ActivatedClientTypeEntry[activatedClientEntries.Count];
159 activatedClientEntries.Values.CopyTo (entries,0);
160 return entries;
161 }
162 }
163
164 public static ActivatedServiceTypeEntry[] GetRegisteredActivatedServiceTypes ()
165 {
166 lock (channelTemplates)
167 {
168 ActivatedServiceTypeEntry[] entries = new ActivatedServiceTypeEntry[activatedServiceEntries.Count];
169 activatedServiceEntries.Values.CopyTo (entries,0);
170 return entries;
171 }
172 }
173
174 public static WellKnownClientTypeEntry[] GetRegisteredWellKnownClientTypes ()
175 {
176 lock (channelTemplates)
177 {
178 WellKnownClientTypeEntry[] entries = new WellKnownClientTypeEntry[wellKnownClientEntries.Count];
179 wellKnownClientEntries.Values.CopyTo (entries,0);
180 return entries;
181 }
182 }
183
184 public static WellKnownServiceTypeEntry[] GetRegisteredWellKnownServiceTypes ()
185 {
186 lock (channelTemplates)
187 {
188 WellKnownServiceTypeEntry[] entries = new WellKnownServiceTypeEntry[wellKnownServiceEntries.Count];
189 wellKnownServiceEntries.Values.CopyTo (entries,0);
190 return entries;
191 }
192 }
193
194 public static bool IsActivationAllowed (Type serverType)
195 {
196 lock (channelTemplates)
197 {
198 return activatedServiceEntries.ContainsKey (serverType);
199 }
200 }
201
202 public static ActivatedClientTypeEntry IsRemotelyActivatedClientType (Type serviceType)
203 {
204 lock (channelTemplates)
205 {
206 return activatedClientEntries [serviceType] as ActivatedClientTypeEntry;
207 }
208 }
209
210 public static ActivatedClientTypeEntry IsRemotelyActivatedClientType (string typeName, string assemblyName)
211 {
212 return IsRemotelyActivatedClientType (Assembly.Load(assemblyName).GetType (typeName));
213 }
214
215 public static WellKnownClientTypeEntry IsWellKnownClientType (Type serviceType)
216 {
217 lock (channelTemplates)
218 {
219 return wellKnownClientEntries [serviceType] as WellKnownClientTypeEntry;
220 }
221 }
222
223 public static WellKnownClientTypeEntry IsWellKnownClientType (string typeName, string assemblyName)
224 {
225 return IsWellKnownClientType (Assembly.Load(assemblyName).GetType (typeName));
226 }
227
228 public static void RegisterActivatedClientType (ActivatedClientTypeEntry entry)
229 {
230 lock (channelTemplates)
231 {
232 if (wellKnownClientEntries.ContainsKey (entry.ObjectType) || activatedClientEntries.ContainsKey (entry.ObjectType))
233 throw new RemotingException ("Attempt to redirect activation of type '" + entry.ObjectType.FullName + "' which is already redirected.");
234
235 activatedClientEntries[entry.ObjectType] = entry;
236 ActivationServices.EnableProxyActivation (entry.ObjectType, true);
237 }
238 }
239
240 public static void RegisterActivatedClientType (Type type, string appUrl)
241 {
242 if (type == null) throw new ArgumentNullException ("type");
243 if (appUrl == null) throw new ArgumentNullException ("appUrl");
244
245 RegisterActivatedClientType (new ActivatedClientTypeEntry (type, appUrl));
246 }
247
248 public static void RegisterActivatedServiceType (ActivatedServiceTypeEntry entry)
249 {
250 lock (channelTemplates)
251 {
252 activatedServiceEntries.Add (entry.ObjectType, entry);
253 }
254 }
255
256 public static void RegisterActivatedServiceType (Type type)
257 {
258 RegisterActivatedServiceType (new ActivatedServiceTypeEntry (type));
259 }
260
261 public static void RegisterWellKnownClientType (Type type, string objectUrl)
262 {
263 if (type == null) throw new ArgumentNullException ("type");
264 if (objectUrl == null) throw new ArgumentNullException ("objectUrl");
265
266 RegisterWellKnownClientType (new WellKnownClientTypeEntry (type, objectUrl));
267 }
268
269 public static void RegisterWellKnownClientType (WellKnownClientTypeEntry entry)
270 {
271 lock (channelTemplates)
272 {
273 if (wellKnownClientEntries.ContainsKey (entry.ObjectType) || activatedClientEntries.ContainsKey (entry.ObjectType))
274 throw new RemotingException ("Attempt to redirect activation of type '" + entry.ObjectType.FullName + "' which is already redirected.");
275
276 wellKnownClientEntries[entry.ObjectType] = entry;
277 ActivationServices.EnableProxyActivation (entry.ObjectType, true);
278 }
279 }
280
281 public static void RegisterWellKnownServiceType (Type type, string objectUrl, WellKnownObjectMode mode)
282 {
283 RegisterWellKnownServiceType (new WellKnownServiceTypeEntry (type, objectUrl, mode));
284 }
285
286 public static void RegisterWellKnownServiceType (WellKnownServiceTypeEntry entry)
287 {
288 lock (channelTemplates)
289 {
290 wellKnownServiceEntries [entry.ObjectUri] = entry;
291 RemotingServices.CreateWellKnownServerIdentity (entry.ObjectType, entry.ObjectUri, entry.Mode);
292 }
293 }
294
295 internal static void RegisterChannelTemplate (ChannelData channel)
296 {
297 channelTemplates [channel.Id] = channel;
298 }
299
300 internal static void RegisterClientProviderTemplate (ProviderData prov)
301 {
302 clientProviderTemplates [prov.Id] = prov;
303 }
304
305 internal static void RegisterServerProviderTemplate (ProviderData prov)
306 {
307 serverProviderTemplates [prov.Id] = prov;
308 }
309
310 internal static void RegisterChannels (ArrayList channels, bool onlyDelayed)
311 {
312 foreach (ChannelData channel in channels)
313 {
314 if (onlyDelayed && channel.DelayLoadAsClientChannel != "true")
315 continue;
316
317 if (defaultDelayedConfigRead && channel.DelayLoadAsClientChannel == "true")
318 continue;
319
320 if (channel.Ref != null)
321 {
322 ChannelData template = (ChannelData) channelTemplates [channel.Ref];
323 if (template == null) throw new RemotingException ("Channel template '" + channel.Ref + "' not found");
324 channel.CopyFrom (template);
325 }
326
327 foreach (ProviderData prov in channel.ServerProviders)
328 {
329 if (prov.Ref != null)
330 {
331 ProviderData template = (ProviderData) serverProviderTemplates [prov.Ref];
332 if (template == null) throw new RemotingException ("Provider template '" + prov.Ref + "' not found");
333 prov.CopyFrom (template);
334 }
335 }
336
337 foreach (ProviderData prov in channel.ClientProviders)
338 {
339 if (prov.Ref != null)
340 {
341 ProviderData template = (ProviderData) clientProviderTemplates [prov.Ref];
342 if (template == null) throw new RemotingException ("Provider template '" + prov.Ref + "' not found");
343 prov.CopyFrom (template);
344 }
345 }
346
347 ChannelServices.RegisterChannelConfig (channel);
348 }
349 }
350
351 internal static void RegisterTypes (ArrayList types)
352 {
353 foreach (TypeEntry type in types)
354 {
355 if (type is ActivatedClientTypeEntry)
356 RegisterActivatedClientType ((ActivatedClientTypeEntry)type);
357 else if (type is ActivatedServiceTypeEntry)
358 RegisterActivatedServiceType ((ActivatedServiceTypeEntry)type);
359 else if (type is WellKnownClientTypeEntry)
360 RegisterWellKnownClientType ((WellKnownClientTypeEntry)type);
361 else if (type is WellKnownServiceTypeEntry)
362 RegisterWellKnownServiceType ((WellKnownServiceTypeEntry)type);
363 }
364 }
365
366 #if NET_1_1
367 public static bool CustomErrorsEnabled (bool isLocalRequest)
368 {
369 if (_errorMode == "off") return false;
370 if (_errorMode == "on") return true;
371 return !isLocalRequest;
372 }
373 #endif
374
375 internal static void SetCustomErrorsMode (string mode)
376 {
377 if (mode != "on" && mode != "off" && mode != "remoteOnly")
378 throw new RemotingException ("Invalid custom error mode: " + mode);
379
380 _errorMode = mode;
381 }
382 }
383
384 /***************************************************************
385 * Internal classes used by RemotingConfiguration.Configure () *
386 ***************************************************************/
387
388 internal class RReader : MiniParser.IReader {
389 private string xml; // custom remoting config file
390 private int pos;
391
392 public RReader (string filename)
393 {
394 try {
395 StreamReader sr = new StreamReader (filename);
396 xml = sr.ReadToEnd ();
397 sr.Close ();
398 }
399 catch {
400 xml = null;
401 }
402 }
403
404 public int Read () {
405 try {
406 return (int) xml[pos++];
407 }
408 catch {
409 return -1;
410 }
411 }
412 }
413
414 internal class ConfigHandler : MiniParser.IHandler
415 {
416 ArrayList typeEntries = new ArrayList ();
417 ArrayList channelInstances = new ArrayList ();
418
419 ChannelData currentChannel = null;
420 Stack currentProviderData = null;
421
422 string currentClientUrl = null;
423 string appName;
424
425 string currentXmlPath = "";
426 bool onlyDelayedChannels;
427
428 public ConfigHandler (bool onlyDelayedChannels)
429 {
430 this.onlyDelayedChannels = onlyDelayedChannels;
431 }
432
433 void ValidatePath (string element, params string[] paths)
434 {
435 foreach (string path in paths)
436 if (CheckPath (path)) return;
437
438 throw new RemotingException ("Element " + element + " not allowed in this context");
439 }
440
441 bool CheckPath (string path)
442 {
443 if (path.StartsWith ("/"))
444 return path == currentXmlPath;
445 else
446 return currentXmlPath.EndsWith (path);
447 }
448
449 public void OnStartParsing (MiniParser parser) {}
450
451 public void OnStartElement (string name, MiniParser.IAttrList attrs)
452 {
453 try
454 {
455 if (currentXmlPath.StartsWith ("/configuration/system.runtime.remoting"))
456 ParseElement (name, attrs);
457
458 currentXmlPath += "/" + name;
459 }
460 catch (Exception ex)
461 {
462 throw new RemotingException ("Error in element " + name + ": " + ex.Message);
463 }
464 }
465
466 public void ParseElement (string name, MiniParser.IAttrList attrs)
467 {
468 if (currentProviderData != null)
469 {
470 ReadCustomProviderData (name, attrs);
471 return;
472 }
473
474 switch (name)
475 {
476 case "application":
477 ValidatePath (name, "system.runtime.remoting");
478 if (attrs.Names.Length > 0)
479 appName = attrs.Values[0];
480 break;
481
482 case "lifetime":
483 ValidatePath (name, "application");
484 ReadLifetine (attrs);
485 break;
486
487 case "channels":
488 ValidatePath (name, "system.runtime.remoting", "application");
489 break;
490
491 case "channel":
492 ValidatePath (name, "channels");
493 if (currentXmlPath.IndexOf ("application") != -1)
494 ReadChannel (attrs, false);
495 else
496 ReadChannel (attrs, true);
497 break;
498
499 case "serverProviders":
500 ValidatePath (name, "channelSinkProviders", "channel");
501 break;
502
503 case "clientProviders":
504 ValidatePath (name, "channelSinkProviders", "channel");
505 break;
506
507 case "provider":
508 case "formatter":
509 ProviderData prov;
510
511 if (CheckPath ("application/channels/channel/serverProviders") ||
512 CheckPath ("channels/channel/serverProviders"))
513 {
514 prov = ReadProvider (name, attrs, false);
515 currentChannel.ServerProviders.Add (prov);
516 }
517 else if (CheckPath ("application/channels/channel/clientProviders") ||
518 CheckPath ("channels/channel/clientProviders"))
519 {
520 prov = ReadProvider (name, attrs, false);
521 currentChannel.ClientProviders.Add (prov);
522 }
523 else if (CheckPath ("channelSinkProviders/serverProviders"))
524 {
525 prov = ReadProvider (name, attrs, true);
526 RemotingConfiguration.RegisterServerProviderTemplate (prov);
527 }
528 else if (CheckPath ("channelSinkProviders/clientProviders"))
529 {
530 prov = ReadProvider (name, attrs, true);
531 RemotingConfiguration.RegisterClientProviderTemplate (prov);
532 }
533 else
534 ValidatePath (name);
535 break;
536
537 case "client":
538 ValidatePath (name, "application");
539 currentClientUrl = attrs.GetValue ("url");
540 break;
541
542 case "service":
543 ValidatePath (name, "application");
544 break;
545
546 case "wellknown":
547 ValidatePath (name, "client", "service");
548 if (CheckPath ("client"))
549 ReadClientWellKnown (attrs);
550 else
551 ReadServiceWellKnown (attrs);
552 break;
553
554 case "activated":
555 ValidatePath (name, "client", "service");
556 if (CheckPath ("client"))
557 ReadClientActivated (attrs);
558 else
559 ReadServiceActivated (attrs);
560 break;
561
562 case "soapInterop":
563 ValidatePath (name, "application");
564 break;
565
566 case "interopXmlType":
567 ValidatePath (name, "soapInterop");
568 ReadInteropXml (attrs, false);
569 break;
570
571 case "interopXmlElement":
572 ValidatePath (name, "soapInterop");
573 ReadInteropXml (attrs, false);
574 break;
575
576 case "preLoad":
577 ValidatePath (name, "soapInterop");
578 ReadPreload (attrs);
579 break;
580
581 case "debug":
582 ValidatePath (name, "system.runtime.remoting");
583 break;
584
585 case "channelSinkProviders":
586 ValidatePath (name, "system.runtime.remoting");
587 break;
588
589 case "customErrors":
590 ValidatePath (name, "system.runtime.remoting");
591 RemotingConfiguration.SetCustomErrorsMode (attrs.GetValue ("mode"));
592 break;
593
594 default:
595 throw new RemotingException ("Element '" + name + "' is not valid in system.remoting.configuration section");
596 }
597 }
598
599 public void OnEndElement (string name)
600 {
601 if (currentProviderData != null)
602 {
603 currentProviderData.Pop ();
604 if (currentProviderData.Count > 0) return;
605 currentProviderData = null;
606 }
607
608 currentXmlPath = currentXmlPath.Substring (0, currentXmlPath.Length - name.Length - 1);
609 }
610
611 void ReadCustomProviderData (string name, MiniParser.IAttrList attrs)
612 {
613 SinkProviderData parent = (SinkProviderData) currentProviderData.Peek ();
614
615 SinkProviderData data = new SinkProviderData (name);
616 for (int i=0; i < attrs.Names.Length; ++i)
617 data.Properties [attrs.Names[i]] = attrs.GetValue (i);
618
619 parent.Children.Add (data);
620 currentProviderData.Push (data);
621 }
622
623 void ReadLifetine (MiniParser.IAttrList attrs)
624 {
625 for (int i=0; i < attrs.Names.Length; ++i) {
626 switch (attrs.Names[i]) {
627 case "leaseTime":
628 LifetimeServices.LeaseTime = ParseTime (attrs.GetValue(i));
629 break;
630 case "sponsorshipTimeout":
631 LifetimeServices.SponsorshipTimeout = ParseTime (attrs.GetValue(i));
632 break;
633 case "renewOnCallTime":
634 LifetimeServices.RenewOnCallTime = ParseTime (attrs.GetValue(i));
635 break;
636 case "leaseManagerPollTime":
637 LifetimeServices.LeaseManagerPollTime = ParseTime (attrs.GetValue(i));
638 break;
639 default:
640 throw new RemotingException ("Invalid attribute: " + attrs.Names[i]);
641 }
642 }
643 }
644
645 TimeSpan ParseTime (string s)
646 {
647 if (s == "" || s == null) throw new RemotingException ("Invalid time value");
648
649 int i = s.IndexOfAny (new char[] { 'D','H','M','S' });
650
651 string unit;
652 if (i == -1)
653 unit = "S";
654 else {
655 unit = s.Substring (i);
656 s = s.Substring (0,i);
657 }
658 double val;
659
660 try {
661 val = double.Parse (s);
662 }
663 catch {
664 throw new RemotingException ("Invalid time value: " + s);
665 }
666
667 if (unit == "D") return TimeSpan.FromDays (val);
668 if (unit == "H") return TimeSpan.FromHours (val);
669 if (unit == "M") return TimeSpan.FromMinutes (val);
670 if (unit == "S") return TimeSpan.FromSeconds (val);
671 if (unit == "MS") return TimeSpan.FromMilliseconds (val);
672 throw new RemotingException ("Invalid time unit: " + unit);
673 }
674
675 void ReadChannel (MiniParser.IAttrList attrs, bool isTemplate)
676 {
677 ChannelData channel = new ChannelData ();
678
679 for (int i=0; i < attrs.Names.Length; ++i)
680 {
681 string at = attrs.Names[i];
682 string val = attrs.Values[i];
683
684 if (at == "ref" && !isTemplate)
685 channel.Ref = val;
686 else if (at == "delayLoadAsClientChannel")
687 channel.DelayLoadAsClientChannel = val;
688 else if (at == "id" && isTemplate)
689 channel.Id = val;
690 else if (at == "type")
691 channel.Type = val;
692 else
693 channel.CustomProperties.Add (at, val);
694 }
695
696 if (isTemplate)
697 {
698 if (channel.Id == null) throw new RemotingException ("id attribute is required");
699 if (channel.Type == null) throw new RemotingException ("id attribute is required");
700 RemotingConfiguration.RegisterChannelTemplate (channel);
701 }
702 else
703 channelInstances.Add (channel);
704
705 currentChannel = channel;
706 }
707
708 ProviderData ReadProvider (string name, MiniParser.IAttrList attrs, bool isTemplate)
709 {
710 ProviderData prov = (name == "provider") ? new ProviderData () : new FormatterData ();
711 SinkProviderData data = new SinkProviderData ("root");
712 prov.CustomData = data.Children;
713
714 currentProviderData = new Stack ();
715 currentProviderData.Push (data);
716
717 for (int i=0; i < attrs.Names.Length; ++i)
718 {
719 string at = attrs.Names[i];
720 string val = attrs.Values[i];
721
722 if (at == "id" && isTemplate)
723 prov.Id = val;
724 else if (at == "type")
725 prov.Type = val;
726 else if (at == "ref" && !isTemplate)
727 prov.Ref = val;
728 else
729 prov.CustomProperties.Add (at, val);
730 }
731
732 if (prov.Id == null && isTemplate) throw new RemotingException ("id attribute is required");
733 return prov;
734 }
735
736 void ReadClientActivated (MiniParser.IAttrList attrs)
737 {
738 string type = GetNotNull (attrs, "type");
739 string assm = ExtractAssembly (ref type);
740
741 if (currentClientUrl == null || currentClientUrl == "")
742 throw new RemotingException ("url attribute is required in client element when it contains activated entries");
743
744 typeEntries.Add (new ActivatedClientTypeEntry (type, assm, currentClientUrl));
745 }
746
747 void ReadServiceActivated (MiniParser.IAttrList attrs)
748 {
749 string type = GetNotNull (attrs, "type");
750 string assm = ExtractAssembly (ref type);
751
752 typeEntries.Add (new ActivatedServiceTypeEntry (type, assm));
753 }
754
755 void ReadClientWellKnown (MiniParser.IAttrList attrs)
756 {
757 string url = GetNotNull (attrs, "url");
758 string type = GetNotNull (attrs, "type");
759 string assm = ExtractAssembly (ref type);
760
761 typeEntries.Add (new WellKnownClientTypeEntry (type, assm, url));
762 }
763
764 void ReadServiceWellKnown (MiniParser.IAttrList attrs)
765 {
766 string objectUri = GetNotNull (attrs, "objectUri");
767 string smode = GetNotNull (attrs, "mode");
768 string type = GetNotNull (attrs, "type");
769 string assm = ExtractAssembly (ref type);
770
771 WellKnownObjectMode mode;
772 if (smode == "SingleCall") mode = WellKnownObjectMode.SingleCall;
773 else if (smode == "Singleton") mode = WellKnownObjectMode.Singleton;
774 else throw new RemotingException ("wellknown object mode '" + smode + "' is invalid");
775
776 typeEntries.Add (new WellKnownServiceTypeEntry (type, assm, objectUri, mode));
777 }
778
779 void ReadInteropXml (MiniParser.IAttrList attrs, bool isElement)
780 {
781 Type t = Type.GetType (GetNotNull (attrs, "clr"));
782 string[] xmlName = GetNotNull (attrs, "xml").Split (',');
783 string localName = xmlName [0].Trim ();
784 string ns = xmlName.Length > 0 ? xmlName[1].Trim() : null;
785
786 if (isElement) SoapServices.RegisterInteropXmlElement (localName, ns, t);
787 else SoapServices.RegisterInteropXmlType (localName, ns, t);
788 }
789
790 void ReadPreload (MiniParser.IAttrList attrs)
791 {
792 string type = attrs.GetValue ("type");
793 string assm = attrs.GetValue ("assembly");
794
795 if (type != null && assm != null)
796 throw new RemotingException ("Type and assembly attributes cannot be specified together");
797
798 if (type != null)
799 SoapServices.PreLoad (Type.GetType (type));
800 else if (assm != null)
801 SoapServices.PreLoad (Assembly.Load (assm));
802 else
803 throw new RemotingException ("Either type or assembly attributes must be specified");
804 }
805
806 string GetNotNull (MiniParser.IAttrList attrs, string name)
807 {
808 string value = attrs.GetValue (name);
809 if (value == null || value == "")
810 throw new RemotingException (name + " attribute is required");
811 return value;
812 }
813
814 string ExtractAssembly (ref string type)
815 {
816 int i = type.IndexOf (',');
817 if (i == -1) return "";
818
819 string asm = type.Substring (i+1).Trim();
820 type = type.Substring (0, i).Trim();
821 return asm;
822 }
823
824 public void OnChars (string ch) {}
825
826 public void OnEndParsing (MiniParser parser)
827 {
828 RemotingConfiguration.RegisterChannels (channelInstances, onlyDelayedChannels);
829 if (appName != null) RemotingConfiguration.ApplicationName = appName;
830
831 if (!onlyDelayedChannels)
832 RemotingConfiguration.RegisterTypes (typeEntries);
833 }
834 }
835
836
837 /*******************************************************************
838 * Internal data structures used by ConfigHandler, to store *
839 * machine.config's remoting related data. *
840 * If having them implemented this way, makes configuration too *
841 * slow, we can use string arrays. *
842 *******************************************************************/
843
844 internal class ChannelData {
845 internal string Ref;
846 internal string Type;
847 internal string Id;
848 internal string DelayLoadAsClientChannel;
849
850 ArrayList _serverProviders = new ArrayList ();
851 ArrayList _clientProviders = new ArrayList ();
852 Hashtable _customProperties = new Hashtable ();
853
854 internal ArrayList ServerProviders {
855 get {
856 if (_serverProviders == null) _serverProviders = new ArrayList ();
857 return _serverProviders;
858 }
859 }
860
861 public ArrayList ClientProviders {
862 get {
863 if (_clientProviders == null) _clientProviders = new ArrayList ();
864 return _clientProviders;
865 }
866 }
867
868 public Hashtable CustomProperties {
869 get {
870 if (_customProperties == null) _customProperties = new Hashtable ();
871 return _customProperties;
872 }
873 }
874
875 public void CopyFrom (ChannelData other)
876 {
877 if (Ref == null) Ref = other.Ref;
878 if (Id == null) Id = other.Id;
879 if (Type == null) Type = other.Type;
880 if (DelayLoadAsClientChannel == null) DelayLoadAsClientChannel = other.DelayLoadAsClientChannel;
881
882 if (other._customProperties != null)
883 {
884 foreach (DictionaryEntry entry in other._customProperties)
885 if (!CustomProperties.ContainsKey (entry.Key))
886 CustomProperties [entry.Key] = entry.Value;
887 }
888
889 if (_serverProviders == null && other._serverProviders != null)
890 {
891 foreach (ProviderData prov in other._serverProviders)
892 {
893 ProviderData np = new ProviderData();
894 np.CopyFrom (prov);
895 ServerProviders.Add (np);
896 }
897 }
898
899 if (_clientProviders == null && other._clientProviders != null)
900 {
901 foreach (ProviderData prov in other._clientProviders)
902 {
903 ProviderData np = new ProviderData();
904 np.CopyFrom (prov);
905 ClientProviders.Add (np);
906 }
907 }
908 }
909 }
910
911 internal class ProviderData {
912 internal string Ref;
913 internal string Type;
914 internal string Id;
915
916 internal Hashtable CustomProperties = new Hashtable ();
917 internal IList CustomData;
918
919 public void CopyFrom (ProviderData other)
920 {
921 if (Ref == null) Ref = other.Ref;
922 if (Id == null) Id = other.Id;
923 if (Type == null) Type = other.Type;
924
925 foreach (DictionaryEntry entry in other.CustomProperties)
926 if (!CustomProperties.ContainsKey (entry.Key))
927 CustomProperties [entry.Key] = entry.Value;
928
929 if (other.CustomData != null)
930 {
931 if (CustomData == null) CustomData = new ArrayList ();
932 foreach (SinkProviderData data in other.CustomData)
933 CustomData.Add (data);
934 }
935 }
936 }
937
938 internal class FormatterData: ProviderData {
939 }
940 }
Mirror of the official Mono project git repository