mcs/class/referencesource/System.Web/Configuration/HttpCapabilitiesEvaluator.cs

   1 //------------------------------------------------------------------------------
   2 // <copyright file="HttpCapabilitiesEvaluator.cs" company="Microsoft">
   3 //     Copyright (c) Microsoft Corporation.  All rights reserved.
   4 // </copyright>
   5 //------------------------------------------------------------------------------
   6
   7 namespace System.Web.Configuration {
   8
   9     using System.Collections;
  10     using System.Collections.Specialized;
  11     using System.Diagnostics;
  12     using System.Globalization;
  13     using System.Reflection;
  14     using System.Security;
  15     using System.Text;
  16     using System.Text.RegularExpressions;
  17     using System.Threading;
  18     using System.Web.Caching;
  19     using System.Web.Compilation;
  20     using System.Web.Hosting;
  21     using System.Security.Permissions;
  22
  23     public abstract class HttpCapabilitiesProvider {
  24         public abstract HttpBrowserCapabilities GetBrowserCapabilities(HttpRequest request);
  25     }
  26
  27     //
  28     // CapabilitiesEvaluator encapabilitiesulates a set of rules for deducing
  29     // a capabilities object from an HttpRequest
  30     //
  31     public class HttpCapabilitiesDefaultProvider : HttpCapabilitiesProvider {
  32
  33         internal CapabilitiesRule _rule;
  34         internal Hashtable _variables;
  35         internal Type _resultType;
  36         internal TimeSpan _cachetime;
  37         internal string _cacheKeyPrefix;
  38
  39         private int _userAgentCacheKeyLength;
  40         private static int _idCounter;
  41         private const string _isMobileDeviceCapKey = "isMobileDevice";
  42         private static object _disableOptimisticCachingSingleton = new object();
  43         private const int _defaultUserAgentCacheKeyLength = 64;
  44         private string _browserCapabilitiesProviderType = null;
  45         private HttpCapabilitiesProvider _browserCapabilitiesProvider = null;
  46
  47         public int UserAgentCacheKeyLength {
  48             get {
  49                 return _userAgentCacheKeyLength;
  50             }
  51             set {
  52                 _userAgentCacheKeyLength = value;
  53             }
  54         }
  55
  56         public Type ResultType {
  57             get {
  58                 return _resultType;
  59             }
  60             set {
  61                 _resultType = value;
  62             }
  63         }
  64
  65         public TimeSpan CacheTime {
  66             get {
  67                 return _cachetime;
  68             }
  69             set {
  70                 _cachetime = value;
  71             }
  72         }
  73
  74         internal string BrowserCapabilitiesProviderType {
  75             get {
  76                 return _browserCapabilitiesProviderType;
  77             }
  78             set {
  79                 _browserCapabilitiesProviderType = value;
  80             }
  81         }
  82
  83         internal HttpCapabilitiesProvider BrowserCapabilitiesProvider {
  84             get {
  85                 if (_browserCapabilitiesProvider == null) {
  86                     if (BrowserCapabilitiesProviderType != null) {
  87                         Type t = System.Type.GetType(BrowserCapabilitiesProviderType, true, true);
  88                         _browserCapabilitiesProvider = (HttpCapabilitiesProvider)Activator.CreateInstance(t);
  89                     }
  90                 }
  91                 return _browserCapabilitiesProvider;
  92             }
  93             set {
  94                 _browserCapabilitiesProvider = value;
  95             }
  96         }
  97
  98         public HttpCapabilitiesDefaultProvider() : this(RuntimeConfig.GetAppConfig().BrowserCaps){
  99             if (RuntimeConfig.GetAppConfig().BrowserCaps != null) {
 100                 _userAgentCacheKeyLength = RuntimeConfig.GetAppConfig().BrowserCaps.UserAgentCacheKeyLength;
 101             }
 102             if (_userAgentCacheKeyLength == 0) {
 103                 _userAgentCacheKeyLength = _defaultUserAgentCacheKeyLength;
 104             }
 105         }
 106
 107         //
 108         // internal constructor; inherit from parent
 109         //
 110         public HttpCapabilitiesDefaultProvider(HttpCapabilitiesDefaultProvider parent) {
 111             int id = Interlocked.Increment(ref _idCounter);
 112             // don't do id.ToString() on every request, do it here
 113             _cacheKeyPrefix = CacheInternal.PrefixHttpCapabilities + id.ToString(CultureInfo.InvariantCulture);
 114
 115             if (parent == null) {
 116                 ClearParent();
 117             }
 118             else {
 119                 _rule = parent._rule;
 120
 121                 if (parent._variables == null)
 122                     _variables = null;
 123                 else
 124                     _variables = new Hashtable(parent._variables);
 125
 126                 _cachetime = parent._cachetime;
 127                 _resultType = parent._resultType;
 128             }
 129             //
 130             AddDependency(String.Empty);
 131         }
 132
 133         internal BrowserCapabilitiesFactoryBase BrowserCapFactory {
 134             get {
 135                 return BrowserCapabilitiesCompiler.BrowserCapabilitiesFactory;
 136             }
 137         }
 138
 139         //
 140         // remove inheritance for <result inherit="false" />
 141         //
 142         internal void ClearParent() {
 143             _rule = null;
 144             _cachetime = TimeSpan.FromSeconds(60); // one minute default expiry
 145             _variables = new Hashtable();
 146             _resultType = typeof(HttpCapabilitiesBase);
 147         }
 148
 149         //
 150         // add a dependency when we encounter a <use var="HTTP_ACCEPT_LANGUAGE" as="lang" />
 151         //
 152         public void AddDependency(String variable) {
 153             if (variable.Equals("HTTP_USER_AGENT"))
 154                 variable = String.Empty;
 155
 156             _variables[variable] = true;
 157         }
 158
 159         //
 160         // sets the set of rules
 161         //
 162         public virtual void AddRuleList(ArrayList ruleList) {
 163             if (ruleList.Count == 0)
 164                 return;
 165
 166             if (_rule != null)
 167                 ruleList.Insert(0, _rule);
 168
 169             _rule = new CapabilitiesSection(CapabilitiesRule.Filter, null, null, ruleList);
 170         }
 171
 172         internal static string GetUserAgent(HttpRequest request) {
 173             string userAgent;
 174
 175             if (request.ClientTarget.Length > 0) {
 176                 userAgent = GetUserAgentFromClientTarget(
 177                     request.Context.ConfigurationPath, request.ClientTarget);
 178             }
 179             else {
 180                 userAgent = request.UserAgent;
 181             }
 182
 183             // Protect against attacks with long User-Agent headers
 184             if (userAgent != null && userAgent.Length > 512) {
 185                 userAgent = userAgent.Substring(0, 512);
 186             }
 187
 188             return userAgent;
 189         }
 190
 191         internal static string GetUserAgentFromClientTarget(VirtualPath configPath, string clientTarget) {
 192
 193             // Lookup ClientTarget section in config.
 194             ClientTargetSection clientTargetConfig = RuntimeConfig.GetConfig(configPath).ClientTarget;
 195
 196             string userAgent = null;
 197
 198             if ( clientTargetConfig.ClientTargets[ clientTarget ] != null )
 199             {
 200                 userAgent = clientTargetConfig.ClientTargets[ clientTarget ].UserAgent;
 201             }
 202
 203             if ( userAgent == null )
 204             {
 205                 throw new HttpException(SR.GetString(SR.Invalid_client_target, clientTarget));
 206             }
 207
 208             return userAgent;
 209         }
 210
 211         private void CacheBrowserCapResult(ref HttpCapabilitiesBase result) {
 212             // Use the previously cached browserCap object if an identical
 213             // browserCap is found.
 214             CacheStoreProvider cacheInternal = System.Web.HttpRuntime.Cache.InternalCache;
 215
 216             if (result.Capabilities == null) {
 217                 return;
 218             }
 219
 220             string hashKey = CacheInternal.PrefixBrowserCapsHash;
 221             StringBuilder builder = new StringBuilder();
 222             foreach (string attribute in result.Capabilities.Keys) {
 223                 // Ignore useragent that is stored with empty key.
 224                 if (String.IsNullOrEmpty(attribute)) {
 225                     continue;
 226                 }
 227
 228                 string value = (String)result.Capabilities[attribute];
 229                 if (value != null) {
 230                     builder.Append(attribute);
 231                     builder.Append("$");
 232                     builder.Append(value);
 233                     builder.Append("$");
 234                 }
 235             }
 236             hashKey += builder.ToString().GetHashCode().ToString(CultureInfo.InvariantCulture);
 237
 238             HttpCapabilitiesBase newResult = cacheInternal.Get(hashKey) as HttpCapabilitiesBase;
 239             if (newResult != null) {
 240                 result = newResult;
 241             }
 242             else {
 243                 // cache it and respect cachetime
 244                 cacheInternal.Insert(hashKey, result, new CacheInsertOptions() { SlidingExpiration = _cachetime });
 245             }
 246         }
 247
 248         public override HttpBrowserCapabilities GetBrowserCapabilities(HttpRequest request) {
 249             return (HttpBrowserCapabilities)Evaluate(request);
 250         }
 251
 252         //
 253         // Actually computes the browser capabilities
 254         //
 255         internal HttpCapabilitiesBase Evaluate(HttpRequest request) {
 256
 257             HttpCapabilitiesBase result;
 258             CacheStoreProvider cacheInternal = System.Web.HttpRuntime.Cache.InternalCache;
 259
 260             //
 261             // 1) grab UA and do optimistic cache lookup (if UA is in dependency list)
 262             //
 263             string userAgent = GetUserAgent(request);
 264             string userAgentCacheKey = userAgent;
 265
 266             // Use the shorten userAgent as the cache key.
 267             Debug.Assert(UserAgentCacheKeyLength != 0);
 268             // Trim the useragent string based on <browserCaps> config
 269             if (userAgentCacheKey != null && userAgentCacheKey.Length > UserAgentCacheKeyLength) {
 270                 userAgentCacheKey = userAgentCacheKey.Substring(0, UserAgentCacheKeyLength);
 271             }
 272
 273             bool doFullCacheKeyLookup = false;
 274             string optimisticCacheKey = _cacheKeyPrefix + userAgentCacheKey;
 275             object optimisticCacheResult = cacheInternal.Get(optimisticCacheKey);
 276
 277             // optimize for common case (desktop browser)
 278             result = optimisticCacheResult as HttpCapabilitiesBase;
 279             if (result != null) {
 280                 return result;
 281             }
 282
 283             //
 284             // 1.1) optimistic cache entry could tell us to do full cache lookup
 285             //
 286             if (optimisticCacheResult == _disableOptimisticCachingSingleton) {
 287                 doFullCacheKeyLookup = true;
 288             }
 289             else {
 290                 // cache it and respect _cachetime
 291                 result = EvaluateFinal(request, true);
 292
 293                 // Optimized cache key is disabled if the request matches any headers defined within identifications.
 294                 if (result.UseOptimizedCacheKey) {
 295
 296                     // Use the same browserCap result if one with the same capabilities can be found in the cache.
 297                     // This is to reduce the number of identical browserCap instances being cached.
 298                     CacheBrowserCapResult(ref result);
 299
 300                     // Cache the result using the optimisicCacheKey
 301                     cacheInternal.Insert(optimisticCacheKey, result, new CacheInsertOptions() { SlidingExpiration = _cachetime });
 302
 303                     return result;
 304                 }
 305             }
 306
 307             //
 308             // 2) either:
 309             //
 310             //      We've never seen the UA before (parse all headers to
 311             //          determine if the new UA also carries modile device
 312             //          httpheaders).
 313             //
 314             //      It's a mobile UA (so parse all headers) and do full
 315             //          cache lookup
 316             //
 317             //      UA isn't in dependency list (customer custom caps section)
 318             //
 319
 320             IDictionaryEnumerator de = _variables.GetEnumerator();
 321             StringBuilder sb = new StringBuilder(_cacheKeyPrefix);
 322
 323             InternalSecurityPermissions.AspNetHostingPermissionLevelLow.Assert();
 324
 325             while (de.MoveNext()) {
 326                 string key = (string)de.Key;
 327                 string value;
 328
 329                 if (key.Length == 0) {
 330                     value = userAgent;
 331                 }
 332                 else {
 333                     value = request.ServerVariables[key];
 334                 }
 335
 336                 if (value != null) {
 337                     sb.Append(value);
 338                 }
 339             }
 340
 341             CodeAccessPermission.RevertAssert();
 342
 343             sb.Append(BrowserCapabilitiesFactoryBase.GetBrowserCapKey(BrowserCapFactory.InternalGetMatchedHeaders(), request));
 344             string fullCacheKey = sb.ToString();
 345
 346             //
 347             // Only do full cache lookup if the optimistic cache
 348             // result was _disableOptimisticCachingSingleton or
 349             // if UserAgent wasn't in the cap var list.
 350             //
 351             if (userAgent == null || doFullCacheKeyLookup) {
 352
 353                 result = cacheInternal.Get(fullCacheKey) as HttpCapabilitiesBase;
 354
 355                 if (result != null)
 356                     return result;
 357             }
 358
 359             result = EvaluateFinal(request, false);
 360
 361             // Use the same browserCap result if one with the same matched nodes can be found in the cache.
 362             // This is to reduce the number of identical browserCap instances being cached.
 363             CacheBrowserCapResult(ref result);
 364
 365              // cache it and respect _cachetime
 366             cacheInternal.Insert(fullCacheKey, result, new CacheInsertOptions() { SlidingExpiration = _cachetime });
 367             if(optimisticCacheKey != null) {
 368                 cacheInternal.Insert(optimisticCacheKey, _disableOptimisticCachingSingleton, new CacheInsertOptions() { SlidingExpiration = _cachetime });
 369             }
 370
 371             return result;
 372         }
 373
 374         internal HttpCapabilitiesBase EvaluateFinal(HttpRequest request, bool onlyEvaluateUserAgent) {
 375             HttpBrowserCapabilities browserCaps = BrowserCapFactory.GetHttpBrowserCapabilities(request);
 376             CapabilitiesState state = new CapabilitiesState(request, browserCaps.Capabilities);
 377             if (onlyEvaluateUserAgent) {
 378                 state.EvaluateOnlyUserAgent = true;
 379             }
 380
 381             if(_rule != null) {
 382                 string oldIsMobileDevice = browserCaps[_isMobileDeviceCapKey];
 383                 browserCaps.Capabilities[_isMobileDeviceCapKey] = null;
 384
 385                 _rule.Evaluate(state);
 386
 387                 string newIsMobileDevice = browserCaps[_isMobileDeviceCapKey];
 388                 if (newIsMobileDevice == null) {
 389                     browserCaps.Capabilities[_isMobileDeviceCapKey] = oldIsMobileDevice;
 390                 }
 391                 else if (newIsMobileDevice.Equals("true")) {
 392                     browserCaps.DisableOptimizedCacheKey();
 393                 }
 394             }
 395
 396             // create the new type
 397             //
 398             HttpCapabilitiesBase result = (HttpCapabilitiesBase)HttpRuntime.CreateNonPublicInstance(_resultType);
 399             result.InitInternal(browserCaps);
 400
 401             return result;
 402         }
 403
 404     }
 405 }