mcs/class/referencesource/System.ServiceModel.Web/System/ServiceModel/Dispatcher/WebHttpDispatchOperationSelector.cs

   1 //------------------------------------------------------------
   2 // Copyright (c) Microsoft Corporation.  All rights reserved.
   3 //------------------------------------------------------------
   4 #pragma warning disable 1634, 1691
   5 namespace System.ServiceModel.Dispatcher
   6 {
   7     using System;
   8     using System.Collections.Generic;
   9     using System.Collections.ObjectModel;
  10     using System.Diagnostics;
  11     using System.Diagnostics.CodeAnalysis;
  12     using System.Runtime;
  13     using System.ServiceModel;
  14     using System.ServiceModel.Activation;
  15     using System.ServiceModel.Channels;
  16     using System.ServiceModel.Description;
  17     using System.ServiceModel.Diagnostics;
  18     using System.ServiceModel.Web;
  19     using System.Net;
  20
  21     public class WebHttpDispatchOperationSelector : IDispatchOperationSelector
  22     {
  23         public const string HttpOperationSelectorUriMatchedPropertyName = "UriMatched";
  24         internal const string HttpOperationSelectorDataPropertyName = "HttpOperationSelectorData";
  25
  26         //
  27         public const string HttpOperationNamePropertyName = "HttpOperationName";
  28         internal const string redirectOperationName = ""; // always unhandled invoker
  29         internal const string RedirectPropertyName = "WebHttpRedirect";
  30
  31         string catchAllOperationName = ""; // user UT=* Method=* operation, else unhandled invoker
  32
  33         Dictionary<string, UriTemplateTable> methodSpecificTables; // indexed by the http method name
  34         UriTemplateTable wildcardTable; // this is one of the methodSpecificTables, special-cased for faster access
  35         Dictionary<string, UriTemplate> templates;
  36
  37         UriTemplateTable helpUriTable;
  38
  39         public WebHttpDispatchOperationSelector(ServiceEndpoint endpoint)
  40         {
  41             if (endpoint == null)
  42             {
  43                 throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("endpoint");
  44             }
  45             if (endpoint.Address == null)
  46             {
  47                 throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(
  48                     SR2.GetString(SR2.EndpointAddressCannotBeNull)));
  49             }
  50 #pragma warning disable 56506 // Microsoft, endpoint.Address.Uri is never null
  51             Uri baseUri = endpoint.Address.Uri;
  52             this.methodSpecificTables = new Dictionary<string, UriTemplateTable>();
  53             this.templates = new Dictionary<string, UriTemplate>();
  54 #pragma warning restore 56506
  55
  56             WebHttpBehavior webHttpBehavior = endpoint.Behaviors.Find<WebHttpBehavior>();
  57             if (webHttpBehavior != null && webHttpBehavior.HelpEnabled)
  58             {
  59                 this.helpUriTable = new UriTemplateTable(endpoint.ListenUri, HelpPage.GetOperationTemplatePairs());
  60             }
  61
  62             Dictionary<WCFKey, string> alreadyHaves = new Dictionary<WCFKey, string>();
  63
  64 #pragma warning disable 56506 // Microsoft, endpoint.Contract is never null
  65             foreach (OperationDescription od in endpoint.Contract.Operations)
  66 #pragma warning restore 56506
  67             {
  68                 // ignore callback operations
  69                 if (od.Messages[0].Direction == MessageDirection.Input)
  70                 {
  71                     string method = WebHttpBehavior.GetWebMethod(od);
  72                     string path = UriTemplateClientFormatter.GetUTStringOrDefault(od);
  73
  74                     //
  75
  76                     if (UriTemplateHelpers.IsWildcardPath(path) && (method == WebHttpBehavior.WildcardMethod))
  77                     {
  78                         if (this.catchAllOperationName != "")
  79                         {
  80                             throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(
  81                                 new InvalidOperationException(
  82                                 SR2.GetString(SR2.MultipleOperationsInContractWithPathMethod,
  83                                 endpoint.Contract.Name, path, method)));
  84                         }
  85                         this.catchAllOperationName = od.Name;
  86                     }
  87                     UriTemplate ut = new UriTemplate(path);
  88                     WCFKey wcfKey = new WCFKey(ut, method);
  89                     if (alreadyHaves.ContainsKey(wcfKey))
  90                     {
  91                         throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(
  92                             new InvalidOperationException(
  93                             SR2.GetString(SR2.MultipleOperationsInContractWithPathMethod,
  94                             endpoint.Contract.Name, path, method)));
  95                     }
  96                     alreadyHaves.Add(wcfKey, od.Name);
  97
  98                     UriTemplateTable methodSpecificTable;
  99                     if (!methodSpecificTables.TryGetValue(method, out methodSpecificTable))
 100                     {
 101                         methodSpecificTable = new UriTemplateTable(baseUri);
 102                         methodSpecificTables.Add(method, methodSpecificTable);
 103                     }
 104
 105                     methodSpecificTable.KeyValuePairs.Add(new KeyValuePair<UriTemplate, object>(ut, od.Name));
 106                     this.templates.Add(od.Name, ut);
 107                 }
 108             }
 109
 110             if (this.methodSpecificTables.Count == 0)
 111             {
 112                 this.methodSpecificTables = null;
 113             }
 114             else
 115             {
 116                 // freeze all the tables because they should not be modified after this point
 117                 foreach (UriTemplateTable table in this.methodSpecificTables.Values)
 118                 {
 119                     table.MakeReadOnly(true /* allowDuplicateEquivalentUriTemplates */);
 120                 }
 121
 122                 if (!methodSpecificTables.TryGetValue(WebHttpBehavior.WildcardMethod, out wildcardTable))
 123                 {
 124                     wildcardTable = null;
 125                 }
 126             }
 127         }
 128
 129         protected WebHttpDispatchOperationSelector()
 130         {
 131         }
 132
 133         public virtual UriTemplate GetUriTemplate(string operationName)
 134         {
 135             if (operationName == null)
 136             {
 137                 throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("operationName");
 138             }
 139             UriTemplate result;
 140             if (!this.templates.TryGetValue(operationName, out result))
 141             {
 142                 return null;
 143             }
 144             else
 145             {
 146                 return result;
 147             }
 148         }
 149
 150         [SuppressMessage("Microsoft.Design", "CA1045:DoNotPassTypesByReference", MessageId = "0#", Justification = "This method is defined by the IDispatchOperationSelector interface")]
 151         public string SelectOperation(ref Message message)
 152         {
 153             if (message == null)
 154             {
 155                 throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("message");
 156             }
 157             bool uriMatched;
 158             string result = this.SelectOperation(ref message, out uriMatched);
 159 #pragma warning disable 56506 // Microsoft, Message.Properties is never null
 160             message.Properties.Add(HttpOperationSelectorUriMatchedPropertyName, uriMatched);
 161 #pragma warning restore 56506
 162             if (result != null)
 163             {
 164                 message.Properties.Add(HttpOperationNamePropertyName, result);
 165                 if (DiagnosticUtility.ShouldTraceInformation)
 166                 {
 167 #pragma warning disable 56506 // Microsoft, Message.Headers is never null
 168                     TraceUtility.TraceEvent(TraceEventType.Information, TraceCode.WebRequestMatchesOperation, SR2.GetString(SR2.TraceCodeWebRequestMatchesOperation, message.Headers.To, result));
 169 #pragma warning restore 56506
 170                 }
 171             }
 172             return result;
 173         }
 174
 175         [SuppressMessage("Microsoft.Design", "CA1045:DoNotPassTypesByReference", MessageId = "0#", Justification = "This method is like that defined by the IDispatchOperationSelector interface")]
 176         [SuppressMessage("Microsoft.Design", "CA1021:AvoidOutParameters", MessageId = "1#", Justification = "This API needs to return multiple things")]
 177         protected virtual string SelectOperation(ref Message message, out bool uriMatched)
 178         {
 179             if (message == null)
 180             {
 181                 throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("message");
 182             }
 183             uriMatched = false;
 184             if (this.methodSpecificTables == null)
 185             {
 186                 return this.catchAllOperationName;
 187             }
 188
 189 #pragma warning disable 56506 // Microsoft, message.Properties is never null
 190             if (!message.Properties.ContainsKey(HttpRequestMessageProperty.Name))
 191             {
 192                 return this.catchAllOperationName;
 193             }
 194             HttpRequestMessageProperty prop = message.Properties[HttpRequestMessageProperty.Name] as HttpRequestMessageProperty;
 195             if (prop == null)
 196             {
 197                 return this.catchAllOperationName;
 198             }
 199             string method = prop.Method;
 200
 201             Uri to = message.Headers.To;
 202 #pragma warning restore 56506
 203
 204             if (to == null)
 205             {
 206                 return this.catchAllOperationName;
 207             }
 208
 209             if (this.helpUriTable != null)
 210             {
 211                 UriTemplateMatch match = this.helpUriTable.MatchSingle(to);
 212                 if (match != null)
 213                 {
 214                     uriMatched = true;
 215                     AddUriTemplateMatch(match, prop, message);
 216                     if (method == WebHttpBehavior.GET)
 217                     {
 218                         return HelpOperationInvoker.OperationName;
 219                     }
 220                     message.Properties.Add(WebHttpDispatchOperationSelector.HttpOperationSelectorDataPropertyName,
 221                         new WebHttpDispatchOperationSelectorData() { AllowedMethods = new List<string>() { WebHttpBehavior.GET } });
 222                     return this.catchAllOperationName;
 223                 }
 224             }
 225
 226             UriTemplateTable methodSpecificTable;
 227             bool methodMatchesExactly = methodSpecificTables.TryGetValue(method, out methodSpecificTable);
 228             if (methodMatchesExactly)
 229             {
 230                 string operationName;
 231                 uriMatched = CanUriMatch(methodSpecificTable, to, prop, message, out operationName);
 232                 if (uriMatched)
 233                 {
 234                     return operationName;
 235                 }
 236             }
 237
 238             if (wildcardTable != null)
 239             {
 240                 string operationName;
 241                 uriMatched = CanUriMatch(wildcardTable, to, prop, message, out operationName);
 242                 if (uriMatched)
 243                 {
 244                     return operationName;
 245                 }
 246             }
 247
 248             if (ShouldRedirectToUriWithSlashAtTheEnd(methodSpecificTable, message, to))
 249             {
 250                 return redirectOperationName;
 251             }
 252
 253             // the {method, uri} pair does not match anything the service supports.
 254             // we know at this point that we'll return some kind of error code, but we
 255             // should go through all methods for the uri to see if any method is supported
 256             // so that that information could be returned to the user as well
 257
 258             List<string> allowedMethods = null;
 259             foreach (KeyValuePair<string, UriTemplateTable> pair in methodSpecificTables)
 260             {
 261                 if (pair.Key == method || pair.Key == WebHttpBehavior.WildcardMethod)
 262                 {
 263                     // the uri must not match the uri template
 264                     continue;
 265                 }
 266                 UriTemplateTable table = pair.Value;
 267                 if (table.MatchSingle(to) != null)
 268                 {
 269                     if (allowedMethods == null)
 270                     {
 271                         allowedMethods = new List<string>();
 272                     }
 273
 274                     //
 275
 276                     if (!allowedMethods.Contains(pair.Key))
 277                     {
 278                         allowedMethods.Add(pair.Key);
 279                     }
 280                 }
 281             }
 282
 283             if (allowedMethods != null)
 284             {
 285                 uriMatched = true;
 286                 message.Properties.Add(WebHttpDispatchOperationSelector.HttpOperationSelectorDataPropertyName,
 287                     new WebHttpDispatchOperationSelectorData() { AllowedMethods = allowedMethods });
 288             }
 289             return catchAllOperationName;
 290         }
 291
 292         bool CanUriMatch(UriTemplateTable methodSpecificTable, Uri to, HttpRequestMessageProperty prop, Message message, out string operationName)
 293         {
 294             operationName = null;
 295             UriTemplateMatch result = methodSpecificTable.MatchSingle(to);
 296
 297             if (result != null)
 298             {
 299                 operationName = result.Data as string;
 300                 Fx.Assert(operationName != null, "bad result");
 301                 AddUriTemplateMatch(result, prop, message);
 302                 return true;
 303             }
 304             return false;
 305         }
 306
 307         void AddUriTemplateMatch(UriTemplateMatch match, HttpRequestMessageProperty requestProp, Message message)
 308         {
 309             match.SetBaseUri(match.BaseUri, requestProp);
 310             message.Properties.Add(IncomingWebRequestContext.UriTemplateMatchResultsPropertyName, match);
 311         }
 312
 313         bool ShouldRedirectToUriWithSlashAtTheEnd(UriTemplateTable methodSpecificTable, Message message, Uri to)
 314         {
 315             UriBuilder ub = new UriBuilder(to);
 316             if (ub.Path.EndsWith("/", StringComparison.Ordinal))
 317             {
 318                 return false;
 319             }
 320
 321             ub.Path = ub.Path + "/";
 322             Uri originalPlusSlash = ub.Uri;
 323
 324             bool result = false;
 325             if (methodSpecificTable != null && methodSpecificTable.MatchSingle(originalPlusSlash) != null)
 326             {
 327                 // as an optimization, we check the table that matched the request's method
 328                 // first, as it is more probable that a hit happens there
 329                 result = true;
 330             }
 331             else
 332             {
 333                 // back-compat:
 334                 // we will redirect as long as there is any method
 335                 // - not necessary the one the user is looking for -
 336                 // that matches the uri with a slash at the end
 337
 338                 foreach (KeyValuePair<string, UriTemplateTable> pair in methodSpecificTables)
 339                 {
 340                     UriTemplateTable table = pair.Value;
 341                     if (table != methodSpecificTable && table.MatchSingle(originalPlusSlash) != null)
 342                     {
 343                         result = true;
 344                         break;
 345                     }
 346                 }
 347             }
 348
 349             if (result)
 350             {
 351                 string hostAndPort = GetAuthority(message);
 352                 originalPlusSlash = UriTemplate.RewriteUri(ub.Uri, hostAndPort);
 353                 message.Properties.Add(RedirectPropertyName, originalPlusSlash);
 354             }
 355             return result;
 356         }
 357
 358         static string GetAuthority(Message message)
 359         {
 360             HttpRequestMessageProperty requestProperty;
 361             string hostName = null;
 362             if (message.Properties.TryGetValue(HttpRequestMessageProperty.Name, out requestProperty))
 363             {
 364                 hostName = requestProperty.Headers[HttpRequestHeader.Host];
 365                 if (!string.IsNullOrEmpty(hostName))
 366                 {
 367                     return hostName;
 368                 }
 369             }
 370             IAspNetMessageProperty aspNetMessageProperty = AspNetEnvironment.Current.GetHostingProperty(message);
 371             if (aspNetMessageProperty != null)
 372             {
 373                 hostName = aspNetMessageProperty.OriginalRequestUri.Authority;
 374             }
 375             return hostName;
 376         }
 377
 378         // to enforce that no two ops have same UriTemplate & Method
 379         class WCFKey
 380         {
 381             string method;
 382             UriTemplate uriTemplate;
 383             public WCFKey(UriTemplate uriTemplate, string method)
 384             {
 385                 this.uriTemplate = uriTemplate;
 386                 this.method = method;
 387             }
 388             public override bool Equals(object obj)
 389             {
 390                 WCFKey other = obj as WCFKey;
 391                 if (other == null)
 392                 {
 393                     return false;
 394                 }
 395                 return this.uriTemplate.IsEquivalentTo(other.uriTemplate) && this.method == other.method;
 396             }
 397             public override int GetHashCode()
 398             {
 399                 return UriTemplateEquivalenceComparer.Instance.GetHashCode(this.uriTemplate);
 400             }
 401         }
 402     }
 403 }
 404