mcs/class/referencesource/System.Web/Util/SecUtil.cs

   1 //------------------------------------------------------------------------------
   2 // <copyright file="SecurityUtil.cs" company="Microsoft">
   3 //     Copyright (c) Microsoft Corporation.  All rights reserved.
   4 // </copyright>
   5 //------------------------------------------------------------------------------
   6
   7 /*
   8  * SecurityUtil class
   9  *
  10  * Copyright (c) 1999 Microsoft Corporation
  11  */
  12
  13 namespace System.Web.Util {
  14     using System.Globalization;
  15     using System.Web.Hosting;
  16     using System.Collections;
  17     using System.Collections.Specialized;
  18     using System.Data;
  19     using System.Data.SqlClient;
  20     using System.Data.SqlTypes;
  21     using System.Configuration.Provider;
  22     using System.Configuration;
  23     using System.Text.RegularExpressions;
  24     using System.Web.DataAccess;
  25
  26     internal static class SecUtility {
  27
  28         internal static string GetDefaultAppName() {
  29             try {
  30                 string appName = HostingEnvironment.ApplicationVirtualPath;
  31                 if (String.IsNullOrEmpty(appName)) {
  32 #if !FEATURE_PAL
  33                     // ROTORTODO: enable Process.MainModule or support an alternative
  34                     // naming scheme for (HttpRuntime.AppDomainAppVirtualPath == null)
  35
  36                     appName = System.Diagnostics.Process.GetCurrentProcess().
  37                                      MainModule.ModuleName;
  38
  39                     int indexOfDot = appName.IndexOf('.');
  40                     if (indexOfDot != -1) {
  41                         appName = appName.Remove(indexOfDot);
  42                     }
  43 #endif // !FEATURE_PAL
  44                 }
  45
  46                 if (String.IsNullOrEmpty(appName)) {
  47                     return "/";
  48                 }
  49                 else {
  50                     return appName;
  51                 }
  52             }
  53             catch {
  54                 return "/";
  55             }
  56         }
  57
  58         internal static string GetConnectionString(NameValueCollection config) {
  59             Debug.Assert(config != null);
  60
  61             string connectionString = config["connectionString"];
  62             if (!String.IsNullOrEmpty(connectionString)) {
  63                 return connectionString;
  64             }
  65             else {
  66                 string connectionStringName = config["connectionStringName"];
  67                 if (String.IsNullOrEmpty(connectionStringName))
  68                     throw new ProviderException(SR.GetString(SR.Connection_name_not_specified));
  69
  70                 connectionString = SqlConnectionHelper.GetConnectionString(connectionStringName, lookupConnectionString: true, appLevel: true);
  71                 if (String.IsNullOrEmpty(connectionString)) {
  72                     throw new ProviderException(SR.GetString(SR.Connection_string_not_found, connectionStringName));
  73                 }
  74                 else {
  75                     return connectionString;
  76                 }
  77             }
  78         }
  79
  80         // We don't trim the param before checking with password parameters
  81         internal static bool ValidatePasswordParameter(ref string param, int maxSize) {
  82             if (param == null) {
  83                 return false;
  84             }
  85
  86             if (param.Length < 1) {
  87                 return false;
  88             }
  89
  90             if (maxSize > 0 && (param.Length > maxSize) ) {
  91                 return false;
  92             }
  93
  94             return true;
  95         }
  96
  97         internal static bool ValidateParameter(ref string param, bool checkForNull, bool checkIfEmpty, bool checkForCommas, int maxSize) {
  98             if (param == null) {
  99                 return !checkForNull;
 100             }
 101
 102             param = param.Trim();
 103             if ((checkIfEmpty && param.Length < 1) ||
 104                  (maxSize > 0 && param.Length > maxSize) ||
 105                  (checkForCommas && param.Contains(","))) {
 106                 return false;
 107             }
 108
 109             return true;
 110         }
 111
 112         // We don't trim the param before checking with password parameters
 113         internal static void CheckPasswordParameter(ref string param, int maxSize, string paramName) {
 114             if (param == null) {
 115                 throw new ArgumentNullException(paramName);
 116             }
 117
 118             if (param.Length < 1) {
 119                 throw new ArgumentException(SR.GetString(SR.Parameter_can_not_be_empty, paramName), paramName);
 120             }
 121
 122             if (maxSize > 0 && param.Length > maxSize) {
 123                 throw new ArgumentException(SR.GetString(SR.Parameter_too_long, paramName, maxSize.ToString(CultureInfo.InvariantCulture)), paramName);
 124             }
 125         }
 126
 127         internal static void CheckParameter(ref string param, bool checkForNull, bool checkIfEmpty, bool checkForCommas, int maxSize, string paramName) {
 128             if (param == null) {
 129                 if (checkForNull) {
 130                     throw new ArgumentNullException(paramName);
 131                 }
 132
 133                 return;
 134             }
 135
 136             param = param.Trim();
 137             if (checkIfEmpty && param.Length < 1) {
 138                 throw new ArgumentException(SR.GetString(SR.Parameter_can_not_be_empty, paramName), paramName);
 139             }
 140
 141             if (maxSize > 0 && param.Length > maxSize) {
 142                 throw new ArgumentException(SR.GetString(SR.Parameter_too_long, paramName, maxSize.ToString(CultureInfo.InvariantCulture)), paramName);
 143             }
 144
 145             if (checkForCommas && param.Contains(",")) {
 146                 throw new ArgumentException(SR.GetString(SR.Parameter_can_not_contain_comma, paramName), paramName);
 147             }
 148         }
 149
 150         internal static void CheckArrayParameter(ref string[] param, bool checkForNull, bool checkIfEmpty, bool checkForCommas, int maxSize, string paramName) {
 151             if (param == null) {
 152                 throw new ArgumentNullException(paramName);
 153             }
 154
 155             if (param.Length < 1) {
 156                 throw new ArgumentException(SR.GetString(SR.Parameter_array_empty, paramName), paramName);
 157             }
 158
 159             Hashtable values = new Hashtable(param.Length);
 160             for (int i = param.Length - 1; i >= 0; i--) {
 161                 SecUtility.CheckParameter(ref param[i], checkForNull, checkIfEmpty, checkForCommas, maxSize,
 162                     paramName + "[ " + i.ToString(CultureInfo.InvariantCulture) + " ]");
 163                 if (values.Contains(param[i])) {
 164                     throw new ArgumentException(SR.GetString(SR.Parameter_duplicate_array_element, paramName), paramName);
 165                 }
 166                 else {
 167                     values.Add(param[i], param[i]);
 168                 }
 169             }
 170         }
 171
 172         internal static bool GetBooleanValue(NameValueCollection config, string valueName, bool defaultValue) {
 173             string sValue = config[valueName];
 174             if (sValue == null) {
 175                 return defaultValue;
 176             }
 177
 178             bool result;
 179             if (bool.TryParse(sValue, out result)) {
 180                 return result;
 181             }
 182             else {
 183                 throw new ProviderException(SR.GetString(SR.Value_must_be_boolean, valueName));
 184             }
 185         }
 186
 187         internal static int GetIntValue(NameValueCollection config, string valueName, int defaultValue, bool zeroAllowed, int maxValueAllowed) {
 188             string sValue = config[valueName];
 189
 190             if (sValue == null) {
 191                 return defaultValue;
 192             }
 193
 194             int iValue;
 195             if (!Int32.TryParse(sValue, out iValue)) {
 196                 if (zeroAllowed) {
 197                     throw new ProviderException(SR.GetString(SR.Value_must_be_non_negative_integer, valueName));
 198                 }
 199
 200                 throw new ProviderException(SR.GetString(SR.Value_must_be_positive_integer, valueName));
 201             }
 202
 203             if (zeroAllowed && iValue < 0) {
 204                 throw new ProviderException(SR.GetString(SR.Value_must_be_non_negative_integer, valueName));
 205             }
 206
 207             if (!zeroAllowed && iValue <= 0) {
 208                 throw new ProviderException(SR.GetString(SR.Value_must_be_positive_integer, valueName));
 209             }
 210
 211             if (maxValueAllowed > 0 && iValue > maxValueAllowed) {
 212                 throw new ProviderException(SR.GetString(SR.Value_too_big, valueName, maxValueAllowed.ToString(CultureInfo.InvariantCulture)));
 213             }
 214
 215             return iValue;
 216         }
 217
 218         internal static TimeUnit GetTimeoutUnit(NameValueCollection config, string valueName, TimeUnit defaultValue) {
 219             TimeUnit unit;
 220             string sValue = config[valueName];
 221
 222             if (sValue == null || !Enum.TryParse(sValue, out unit)) {
 223                 return defaultValue;
 224             }
 225
 226             return unit;
 227         }
 228
 229         internal static int? GetNullableIntValue(NameValueCollection config, string valueName) {
 230             int iValue;
 231             string sValue = config[valueName];
 232
 233             if (sValue == null || !Int32.TryParse(sValue, out iValue)) {
 234                 return null;
 235             }
 236
 237             return iValue;
 238         }
 239
 240 #if !FEATURE_PAL //
 241         internal static void CheckSchemaVersion(ProviderBase provider, SqlConnection connection, string[] features, string version, ref int schemaVersionCheck) {
 242             if (connection == null) {
 243                 throw new ArgumentNullException("connection");
 244             }
 245
 246             if (features == null) {
 247                 throw new ArgumentNullException("features");
 248             }
 249
 250             if (version == null) {
 251                 throw new ArgumentNullException("version");
 252             }
 253
 254             if (schemaVersionCheck == -1) {
 255                 throw new ProviderException(SR.GetString(SR.Provider_Schema_Version_Not_Match, provider.ToString(), version));
 256             }
 257             else if (schemaVersionCheck == 0) {
 258                 lock (provider) {
 259                     if (schemaVersionCheck == -1) {
 260                         throw new ProviderException(SR.GetString(SR.Provider_Schema_Version_Not_Match, provider.ToString(), version));
 261                     }
 262                     else if (schemaVersionCheck == 0) {
 263                         int iStatus = 0;
 264                         SqlCommand cmd = null;
 265                         SqlParameter p = null;
 266
 267                         foreach (string feature in features) {
 268                             cmd = new SqlCommand("dbo.aspnet_CheckSchemaVersion", connection);
 269
 270                             cmd.CommandType = CommandType.StoredProcedure;
 271
 272                             p = new SqlParameter("@Feature", feature);
 273                             cmd.Parameters.Add(p);
 274
 275                             p = new SqlParameter("@CompatibleSchemaVersion", version);
 276                             cmd.Parameters.Add(p);
 277
 278                             p = new SqlParameter("@ReturnValue", SqlDbType.Int);
 279                             p.Direction = ParameterDirection.ReturnValue;
 280                             cmd.Parameters.Add(p);
 281
 282                             cmd.ExecuteNonQuery();
 283
 284                             iStatus = ((p.Value != null) ? ((int)p.Value) : -1);
 285                             if (iStatus != 0) {
 286                                 schemaVersionCheck = -1;
 287
 288                                 throw new ProviderException(SR.GetString(SR.Provider_Schema_Version_Not_Match, provider.ToString(), version));
 289                             }
 290                         }
 291
 292                         schemaVersionCheck = 1;
 293                     }
 294                 }
 295             }
 296         }
 297 #endif // !FEATURE_PAL
 298     }
 299 }