internal static String GetDirectory(String path)
{
if (path == null || path.Length == 0)
{
throw new ArgumentException(HttpRuntime.FormatResourceString(SR.Empty_path_has_no_directory));
}
if (path[0] != '/')
{
throw new ArgumentException(HttpRuntime.FormatResourceString(SR.Path_must_be_rooted));
}
// Make sure there is a filename after the last '/'
Debug.Assert(path[path.Length - 1] != '/', "Path should not end with a /");
string dir = path.Substring(0, path.LastIndexOf('/'));
// If it's the root dir, we would end up with "". Return "/" instead
if (dir.Length == 0)
{
return("/");
}
return(dir);
}
internal /*public*/ void WaitOne()
{
if (_mutexHandle.Handle == IntPtr.Zero)
{
throw new InvalidOperationException(HttpRuntime.FormatResourceString(SR.CompilationMutex_Null));
}
// check the lock status
for (;;)
{
int lockStatus = _lockStatus;
if (lockStatus == -1 || _draining)
{
throw new InvalidOperationException(HttpRuntime.FormatResourceString(SR.CompilationMutex_Drained));
}
if (Interlocked.CompareExchange(ref _lockStatus, lockStatus + 1, lockStatus) == lockStatus)
{
break; // got the lock
}
}
Debug.Trace("Mutex", "Waiting for mutex " + MutexDebugName);
if (UnsafeNativeMethods.InstrumentedMutexGetLock(_mutexHandle, -1) == -1)
{
// failed to get the lock
Interlocked.Decrement(ref _lockStatus);
throw new InvalidOperationException(HttpRuntime.FormatResourceString(SR.CompilationMutex_Failed));
}
Debug.Trace("Mutex", "Got mutex " + MutexDebugName);
}
/////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////
// Helper functions: Hash a password
/// <include file='doc\FormsAuthentication.uex' path='docs/doc[@for="FormsAuthentication.HashPasswordForStoringInConfigFile"]/*' />
/// <devdoc>
/// Initializes FormsAuthentication by reading
/// configuration and getting the cookie values and encryption keys for the given
/// application.
/// </devdoc>
public static String HashPasswordForStoringInConfigFile(String password, String passwordFormat)
{
if (password == null)
{
throw new ArgumentNullException("password");
}
if (passwordFormat == null)
{
throw new ArgumentNullException("passwordFormat");
}
byte [] bBlob;
if (String.Compare(passwordFormat, "sha1", true, CultureInfo.InvariantCulture) == 0)
{
bBlob = GetMacFromBlob(Encoding.UTF8.GetBytes(password));
}
else if (String.Compare(passwordFormat, "md5", true, CultureInfo.InvariantCulture) == 0)
{
bBlob = GetMD5FromBlob(Encoding.UTF8.GetBytes(password));
}
else
{
throw new ArgumentException(HttpRuntime.FormatResourceString(SR.InvalidArgumentValue, "passwordFormat"));
}
return(MachineKey.ByteArrayToHexString(bBlob, 0));
}
private void SendResponseFromFileStream(FileStream f, long offset, long length)
{
long fileSize = f.Length;
if (length == -1)
{
length = fileSize - offset;
}
if (offset < 0 || length > fileSize - offset)
{
throw new HttpException(HttpRuntime.FormatResourceString(SR.Invalid_range));
}
if (length > 0)
{
if (offset > 0)
{
f.Seek(offset, SeekOrigin.Begin);
}
byte[] fileBytes = new byte[(int)length];
f.Read(fileBytes, 0, (int)length);
WriteBytes(fileBytes, (int)length);
}
}
/// <include file='doc\HTTPNotFoundHandler.uex' path='docs/doc[@for="HttpForbiddenHandler.ProcessRequest"]/*' />
/// <devdoc>
/// <para>Drives web processing execution.</para>
/// </devdoc>
public void ProcessRequest(HttpContext context)
{
PerfCounters.IncrementCounter(AppPerfCounter.REQUESTS_NOT_FOUND);
throw new HttpException(403,
HttpRuntime.FormatResourceString(SR.Path_forbidden, context.Request.Path));
}
/// <include file='doc\DropDownList.uex' path='docs/doc[@for="DropDownList.RenderContents"]/*' />
/// <internalonly/>
/// <devdoc>
/// <para>Displays the <see cref='System.Web.UI.WebControls.DropDownList'/> control on the client.</para>
/// </devdoc>
protected override void RenderContents(HtmlTextWriter writer)
{
ListItemCollection liCollection = Items;
int n = Items.Count;
bool selected = false;
if (n > 0)
{
for (int i = 0; i < n; i++)
{
ListItem li = liCollection[i];
writer.WriteBeginTag("option");
if (li.Selected)
{
if (selected)
{
throw new HttpException(HttpRuntime.FormatResourceString(SR.Cant_Multiselect_In_DropDownList));
}
selected = true;
writer.WriteAttribute("selected", "selected", false);
}
writer.WriteAttribute("value", li.Value, true /*fEncode*/);
writer.Write(HtmlTextWriter.TagRightChar);
HttpUtility.HtmlEncode(li.Text, writer);
writer.WriteEndTag("option");
writer.WriteLine();
}
}
}
/*
* Return a CompilerInfo that a language maps to.
*/
internal CompilerInfo GetCompilerInfoFromLanguage(string language)
{
CompilerInfo compilerInfo = (CompilerInfo)CompilerLanguages[language];
if (compilerInfo == null)
{
// Unsupported language: throw an exception
throw new HttpException(HttpRuntime.FormatResourceString(SR.Invalid_lang, language));
}
// Only allow the use of compilerOptions when we have UnmanagedCode access (ASURT 73678)
if (compilerInfo.CompilParams.CompilerOptions != null)
{
if (!HttpRuntime.HasUnmanagedPermission())
{
throw new ConfigurationException(
HttpRuntime.FormatResourceString(SR.Insufficient_trust_for_attribute, "compilerOptions"),
compilerInfo.ConfigFileName, compilerInfo.ConfigFileLineNumber);
}
}
// Clone it so the original is not modified
compilerInfo = compilerInfo.Clone();
// Set the value of the debug flag in the copy
compilerInfo.CompilParams.IncludeDebugInformation = _debug;
return(compilerInfo);
}
/*
* Process the contents of the <%@ OutputCache ... %> directive
*/
internal virtual void ProcessOutputCacheDirective(string directiveName, IDictionary directive)
{
bool fHasDuration = Util.GetAndRemovePositiveIntegerAttribute(directive, "duration", ref _duration);
if (!fHasDuration && FDurationRequiredOnOutputCache)
{
throw new HttpException(HttpRuntime.FormatResourceString(SR.Missing_attr, "duration"));
}
_varyByCustom = Util.GetAndRemoveNonEmptyAttribute(directive, "varybycustom");
_varyByParams = Util.GetAndRemoveNonEmptyAttribute(directive, "varybyparam");
// VaryByParams is required (ASURT 76763)
if (_varyByParams == null && FVaryByParamsRequiredOnOutputCache)
{
throw new HttpException(HttpRuntime.FormatResourceString(SR.Missing_varybyparam_attr));
}
// If it's "none", set it to null
if (string.Compare(_varyByParams, "none", true, CultureInfo.InvariantCulture) == 0)
{
_varyByParams = null;
}
// If there are some attributes left, fail
Util.CheckUnknownDirectiveAttributes(directiveName, directive);
}
public virtual object Create(Object parent, Object configContextObj, XmlNode section)
{
// if called through client config don't even load HttpRuntime
if (!HandlerBase.IsServerConfiguration(configContextObj))
{
return(null);
}
HttpConfigurationContext configContext = configContextObj as HttpConfigurationContext;
// section handlers can run in client mode with ConfigurationSettings.GetConfig("sectionName")
// detect this case and return null to be ensure no exploits from secure client scenarios
// see ASURT 123738
if (configContext == null)
{
return(null);
}
if (HandlerBase.IsPathAtAppLevel(configContext.VirtualPath) == PathLevel.BelowApp)
{
throw new ConfigurationException(
HttpRuntime.FormatResourceString(SR.Cannot_specify_below_app_level, section.Name),
section);
}
return(new SecurityPolicyConfig((SecurityPolicyConfig)parent, section, ConfigurationException.GetXmlNodeFilename(section)));
}
internal static string GetUserAgent(HttpRequest request)
{
if (request.ClientTarget.Length > 0)
{
// Lookup ClientTarget section in config.
ClientTargetConfiguration clientTargetConfig = (ClientTargetConfiguration)request.Context.GetConfig("system.web/clientTarget");
NameValueCollection clientTargetDictionary = null;
if (clientTargetConfig != null)
{
clientTargetDictionary = clientTargetConfig.Configuration;
}
if (clientTargetDictionary != null)
{
// Found it
// Try to map the alias
string useUserAgent = clientTargetDictionary[request.ClientTarget];
if (useUserAgent != null)
{
return(useUserAgent);
}
}
throw new HttpException(HttpRuntime.FormatResourceString(SR.Invalid_client_target, request.ClientTarget));
}
// Protect against attacks with long User-Agent headers
String userAgent = request.UserAgent;
if (userAgent != null && userAgent.Length > 256)
{
userAgent = String.Empty;
}
return(userAgent);
}
/// <include file='doc\CompareValidator.uex' path='docs/doc[@for="CompareValidator.ControlPropertiesValid"]/*' />
/// <internalonly/>
/// <devdoc>
/// <para> Checks the properties of a the control for valid values.</para>
/// </devdoc>
protected override bool ControlPropertiesValid()
{
// Check the control id references
if (ControlToCompare.Length > 0)
{
CheckControlValidationProperty(ControlToCompare, "ControlToCompare");
if (string.Compare(ControlToValidate, ControlToCompare, true, CultureInfo.InvariantCulture) == 0)
{
throw new HttpException(HttpRuntime.FormatResourceString(SR.Validator_bad_compare_control,
ID,
ControlToCompare));
}
}
else
{
// Check Values
if (Operator != ValidationCompareOperator.DataTypeCheck &&
!CanConvert(ValueToCompare, Type))
{
throw new HttpException(
HttpRuntime.FormatResourceString(
SR.Validator_value_bad_type,
new string [] {
ValueToCompare,
"ValueToCompare",
ID,
PropertyConverter.EnumToString(typeof(ValidationDataType), Type),
}));
}
}
return(base.ControlPropertiesValid());
}
ReadWriteSpinLock _lockTargets; /* lock for targets */
/*
* ctor.
*/
internal CacheEntry(
String key,
Object value,
CacheDependency dependency,
CacheItemRemovedCallback onRemovedHandler,
DateTime utcAbsoluteExpiration,
TimeSpan slidingExpiration,
CacheItemPriority priority,
bool isPublic) :
base(key, isPublic)
{
if (value == null)
{
throw new ArgumentNullException("value");
}
if (slidingExpiration < TimeSpan.Zero || OneYear < slidingExpiration)
{
throw new ArgumentOutOfRangeException("slidingExpiration");
}
if (utcAbsoluteExpiration != Cache.NoAbsoluteExpiration && slidingExpiration != Cache.NoSlidingExpiration)
{
throw new ArgumentException(HttpRuntime.FormatResourceString(SR.Invalid_expiration_combination));
}
if (priority < CacheItemPriorityMin || CacheItemPriorityMax < priority)
{
throw new ArgumentOutOfRangeException("priority");
}
_value = value;
_dependency = dependency;
_onRemovedTargets = onRemovedHandler;
_utcCreated = DateTime.UtcNow;
_slidingExpiration = slidingExpiration;
if (_slidingExpiration > TimeSpan.Zero)
{
_utcExpires = _utcCreated + _slidingExpiration;
}
else
{
_utcExpires = utcAbsoluteExpiration;
}
_expiresIndex = -1;
_expiresBucket = 0xff;
_usageIndex = -1;
if (priority == CacheItemPriority.NotRemovable)
{
_usageBucket = 0xff;
}
else
{
_usageBucket = (byte)(priority - 1);
}
}
/*public*/ void IStateClientManager.ConfigInit(SessionStateSectionHandler.Config config, SessionOnEndTarget onEndTarget)
{
/*
* Parse the connection string for errors. We want to ensure
* that the user's connection string doesn't contain an
* Initial Catalog entry, so we must first create a dummy connection.
*/
SqlConnection dummyConnection;
try {
dummyConnection = new SqlConnection(config._sqlConnectionString);
}
catch (Exception e) {
throw new ConfigurationException(e.Message, e, config._configFileName, config._sqlLine);
}
string database = dummyConnection.Database;
if (database != null && database.Length > 0)
{
throw new ConfigurationException(
HttpRuntime.FormatResourceString(SR.No_database_allowed_in_sqlConnectionString),
config._configFileName, config._sqlLine);
}
s_useIntegratedSecurity = DetectIntegratedSecurity(config._sqlConnectionString);
s_sqlConnectionString = config._sqlConnectionString + ";Initial Catalog=ASPState";
s_rpool = new ResourcePool(new TimeSpan(0, 0, 5), int.MaxValue);
}
/// <include file='doc\DataBinder.uex' path='docs/doc[@for="DataBinder.GetPropertyValue"]/*' />
/// <devdoc>
/// </devdoc>
public static object GetPropertyValue(object container, string propName)
{
if (container == null)
{
throw new ArgumentNullException("container");
}
if ((propName == null) || (propName.Length == 0))
{
throw new ArgumentNullException("propName");
}
object prop = null;
// get a PropertyDescriptor using case-insensitive lookup
PropertyDescriptor pd = TypeDescriptor.GetProperties(container).Find(propName, true);
if (pd != null)
{
prop = pd.GetValue(container);
}
else
{
throw new HttpException(HttpRuntime.FormatResourceString(SR.DataBinder_Prop_Not_Found, container.GetType().FullName, propName));
}
return(prop);
}
static internal Table CreateTable(DataTable datatable)
{
if (datatable.Rows.Count == 0)
{
return(null);
}
IEnumerator en;
bool isAlt = false;
Object[] cells;
Table table = new Table();
TableRow trow;
TableCell tcell;
table.Width = Unit.Percentage(100);
table.CellPadding = 0;
table.CellSpacing = 0;
// add a title for the table - same as table name
trow = AddRow(table);
tcell = AddHeaderCell(trow, "<h3><b>" + HttpRuntime.FormatResourceString(datatable.TableName) + "</b></h3>");
tcell.CssClass = "alt";
tcell.ColumnSpan = 10;
tcell.HorizontalAlign = HorizontalAlign.Left;
// add the header information - same as column names
trow = AddRow(table);
trow.CssClass = "subhead";
trow.HorizontalAlign = HorizontalAlign.Left;
en = datatable.Columns.GetEnumerator();
while (en.MoveNext())
{
AddHeaderCell(trow, HttpRuntime.FormatResourceString(((DataColumn)en.Current).ColumnName));
}
// now fill in the values, but don't display null values
en = datatable.Rows.GetEnumerator();
while (en.MoveNext())
{
cells = ((DataRow)en.Current).ItemArray;
trow = AddRow(table);
for (int i = 0; i < cells.Length; i++)
{
string temp = HttpUtility.HtmlEncode(cells[i].ToString());
AddCell(trow, (temp.Length != 0) ? temp : " ");
}
// alternate colors
if (isAlt)
{
trow.CssClass = "alt";
}
isAlt = !isAlt;
}
return(table);
}
private static XmlNode GetAndRemoveIntegerAttributeInternal(XmlNode node, string attrib, bool fRequired, ref int val)
{
XmlNode a = GetAndRemoveAttribute(node, attrib, fRequired);
if (a != null)
{
if (a.Value.Trim() != a.Value)
{
throw new ConfigurationException(
HttpRuntime.FormatResourceString(SR.Invalid_integer_attribute, a.Name),
a);
}
try {
val = int.Parse(a.Value, CultureInfo.InvariantCulture);
}
catch (Exception e) {
throw new ConfigurationException(
HttpRuntime.FormatResourceString(SR.Invalid_integer_attribute, a.Name),
e, a);
}
}
return(a);
}
internal Object Create()
{
// HACKHACK: for now, let uncreatable types through and error later (for .soap factory)
// This design should change - developers will want to know immediately
// when they misspell a type
if (_type == null)
{
Type t = Type.GetType(_typename, true);
// throw for bad types in deferred case
if (!IsTypeHandlerOrFactory(t))
{
throw new HttpException(HttpRuntime.FormatResourceString(SR.Type_not_factory_or_handler, _typename));
}
if (!HttpRuntime.HasAspNetHostingPermission(AspNetHostingPermissionLevel.Unrestricted))
{
if (!IsTypeFromAssemblyWithAPTCA(t) && IsTypeFromAssemblyWithStrongName(t))
{
throw new HttpException(HttpRuntime.FormatResourceString(SR.Type_from_untrusted_assembly, _typename));
}
}
_type = t;
}
return(HttpRuntime.CreateNonPublicInstance(_type));
}
internal static bool GetAndRemovePositiveIntegerAttribute(IDictionary directives,
string key, ref int val)
{
string s = Util.GetAndRemove(directives, key);
if (s == null)
{
return(false);
}
try {
val = int.Parse(s);
}
catch (Exception) {
throw new HttpException(
HttpRuntime.FormatResourceString(SR.Invalid_positive_integer_attribute, key));
}
// Make sure it's positive
if (val <= 0)
{
throw new HttpException(
HttpRuntime.FormatResourceString(SR.Invalid_positive_integer_attribute, key));
}
return(true);
}
internal static string GetScriptLocation(HttpContext context)
{
// prepare script include
string location = null;
IDictionary webControlsConfig = (IDictionary)context.GetConfig("system.web/webControls");
if (webControlsConfig != null)
{
location = (string)webControlsConfig["clientScriptsLocation"];
}
if (location == null)
{
throw new HttpException(HttpRuntime.FormatResourceString(SR.Missing_clientScriptsLocation));
}
// If there is a formatter, as there will be for the default machine.config, insert the assembly name and version.
if (location.IndexOf("{0}") >= 0)
{
string assembly = "system_web";
string version = VersionInfo.IsapiVersion.Substring(0, VersionInfo.IsapiVersion.LastIndexOf('.')).Replace('.', '_');
location = String.Format(location, assembly, version);
}
return(location);
}
private void CompileSourceCode()
{
// Return if there is nothing to compile
if (_sourceString == null)
{
return;
}
// Put in some context so that the file can be debugged.
CodeLinePragma linePragma = new CodeLinePragma(_inputFile, _lineNumber);
try {
// Compile the string, and get a type
_compiledType = _sourceCompiler.CompileSourceStringIntoType(_sourceString,
_className, linePragma, _linkedAssemblies, _compilerType, _compilParams);
}
catch {
// Throw a specific error if the type was not found
if (_sourceCompiler.TypeNotFoundInAssembly)
{
throw new HttpParseException(
HttpRuntime.FormatResourceString(SR.Type_not_found_in_src, _className),
null, _inputFile, _sourceString, _lineNumber);
}
else
{
// Just rethrow
throw;
}
}
}
// Async patern
internal /*public*/ IAsyncResult BeginAspCompatExecution(AsyncCallback cb, object extraData)
{
InternalSecurityPermissions.UnmanagedCode.Demand();
if (IsInAspCompatMode)
{
// already in AspCompatMode -- execute synchronously
bool sync = true;
Exception error = _app.ExecuteStep(this, ref sync);
_ar = new HttpAsyncResult(cb, extraData, true, null, error);
_syncCaller = true;
}
else
{
_ar = new HttpAsyncResult(cb, extraData);
_syncCaller = (cb == null);
_rootedThis = GCHandle.Alloc(this);
if (UnsafeNativeMethods.AspCompatProcessRequest(_execCallback, this) != 1)
{
// failed to queue up the execution in ASP compat mode
_rootedThis.Free();
_ar.Complete(true, null, new HttpException(HttpRuntime.FormatResourceString(SR.Cannot_access_AspCompat)));
}
}
return(_ar);
}
/*
* Add a new StateItem or update an existing StateItem in the bag.
*/
/// <include file='doc\StateBag.uex' path='docs/doc[@for="StateBag.Add"]/*' />
/// <devdoc>
/// <para>[To be supplied.]</para>
/// </devdoc>
public StateItem Add(string key, object value)
{
if (key == null || key.Length == 0)
{
throw new ArgumentException(HttpRuntime.FormatResourceString(SR.Key_Cannot_Be_Null));
}
StateItem item = bag[key] as StateItem;
if (item == null)
{
if (value != null || marked)
{
item = new StateItem(value);
bag.Add(key, item);
}
}
else
{
if (value == null && !marked)
{
bag.Remove(key);
}
else
{
item.Value = value;
}
}
if (item != null && marked)
{
item.IsDirty = true;
}
return(item);
}
/*
* Compile a web handler file into a Type.
*/
private Type GetCompiledTypeInternal()
{
DateTime utcStart = DateTime.UtcNow;
// Add all the assemblies specified in the config files
AppendConfigAssemblies();
ParseReader();
// Compile the inline source code in the file, if any
CompileSourceCode();
if (_compiledType == null)
{
_compiledType = GetType(_className);
// Even though we didn't compile anything, cache the type to avoid
// having to reparse the file every time (ASURT 67802)
_sourceCompiler.CacheType(_compiledType, utcStart);
}
if (_compiledType == null)
{
throw new HttpException(
HttpRuntime.FormatResourceString(SR.Could_not_create_type, _className));
}
return(_compiledType);
}
static XmlNode GetAndRemoveIntegerOrInfiniteAttribute(XmlNode node, string attrib, ref int val)
{
string sValue = null;
XmlNode a = HandlerBase.GetAndRemoveStringAttribute(node, attrib, ref sValue);
if (a != null)
{
if (sValue == "Infinite")
{
val = int.MaxValue;
}
else
{
try {
val = int.Parse(sValue, NumberStyles.None, CultureInfo.InvariantCulture);
}
catch (Exception e) {
throw new ConfigurationException(
HttpRuntime.FormatResourceString(SR.Invalid_integer_attribute, a.Name),
e, a);
}
}
}
return(a);
}
internal void CheckAndUpdate(XmlNode section, string [] lockableAttrList)
{
// verify the attributes at this level have not been locked
CheckForLocked(section);
string stringlockList = null;
XmlNode attr = HandlerBase.GetAndRemoveStringAttribute(section, "lockAttributes", ref stringlockList);
if (stringlockList == null)
{
return;
}
// comma-delimited list of attributes
string [] attributesToLock = stringlockList.Split(new char [] { ',', ';' });
foreach (string s in attributesToLock)
{
string attributeToLock = s.Trim(' ');
if (HandlerBase.IndexOfCultureInvariant(lockableAttrList, attributeToLock) == -1)
{
throw new ConfigurationException(
HttpRuntime.FormatResourceString(SR.Invalid_lockAttributes, attributeToLock, HandlerBase.CombineStrings(lockableAttrList)),
attr);
}
_lockedAttributes[attributeToLock] = "";
}
}
internal static void ThrowUnrecognizedElement(XmlNode node)
{
CheckBreakOnUnrecognizedElement();
throw new ConfigurationException(
HttpRuntime.FormatResourceString(SR.Config_base_unrecognized_element),
node);
}
private static XmlNode GetAndRemoveEnumAttributeInternal(XmlNode node, string attrib, bool isRequired, string [] values, ref int val)
{
XmlNode a = GetAndRemoveAttribute(node, attrib, isRequired);
if (a == null)
{
return(null);
}
for (int i = 0; i < values.Length; ++i)
{
if (values[i] == a.Value) // case sensitive
//if (string.Compare(values[i], a.Value, false, CultureInfo.InvariantCulture) == 0) { // ignore case
{
val = i;
return(a);
}
}
string names = null;
foreach (string name in values)
{
if (names == null)
{
names = name;
}
else
{
names += ", " + name;
}
}
throw new ConfigurationException(HttpRuntime.FormatResourceString(SR.Invalid_enum_attribute, attrib, names), a);
}
/// <include file='doc\HyperLinkColumn.uex' path='docs/doc[@for="HyperLinkColumn.OnDataBindColumn"]/*' />
/// <devdoc>
/// </devdoc>
private void OnDataBindColumn(object sender, EventArgs e)
{
Debug.Assert((DataTextField.Length != 0) || (DataNavigateUrlField.Length != 0),
"Shouldn't be DataBinding without a DataTextField and DataNavigateUrlField");
HyperLink boundControl = (HyperLink)sender;
DataGridItem item = (DataGridItem)boundControl.NamingContainer;
object dataItem = item.DataItem;
if ((textFieldDesc == null) && (urlFieldDesc == null))
{
PropertyDescriptorCollection props = TypeDescriptor.GetProperties(dataItem);
string fieldName;
fieldName = DataTextField;
if (fieldName.Length != 0)
{
textFieldDesc = props.Find(fieldName, true);
if ((textFieldDesc == null) && !DesignMode)
{
throw new HttpException(HttpRuntime.FormatResourceString(SR.Field_Not_Found, fieldName));
}
}
fieldName = DataNavigateUrlField;
if (fieldName.Length != 0)
{
urlFieldDesc = props.Find(fieldName, true);
if ((urlFieldDesc == null) && !DesignMode)
{
throw new HttpException(HttpRuntime.FormatResourceString(SR.Field_Not_Found, fieldName));
}
}
}
if (textFieldDesc != null)
{
object data = textFieldDesc.GetValue(dataItem);
string dataValue = FormatDataTextValue(data);
boundControl.Text = dataValue;
}
else if (DesignMode && (DataTextField.Length != 0))
{
boundControl.Text = SR.GetString(SR.Sample_Databound_Text);
}
if (urlFieldDesc != null)
{
object data = urlFieldDesc.GetValue(dataItem);
string dataValue = FormatDataNavigateUrlValue(data);
boundControl.NavigateUrl = dataValue;
}
else if (DesignMode && (DataNavigateUrlField.Length != 0))
{
boundControl.NavigateUrl = "url";
}
}
//
// Create a rulelist from an element's children
//
static ArrayList RuleListFromElement(ParseState parseState, XmlNode node, bool top)
{
ArrayList result = new ArrayList();
foreach (XmlNode child in node.ChildNodes)
{
switch (child.NodeType)
{
case XmlNodeType.Text:
case XmlNodeType.CDATA:
top = false;
AppendLines(result, child.Value, node);
break;
case XmlNodeType.Element:
switch (child.Name)
{
case "result":
if (top)
{
ProcessResult(parseState.Evaluator, child);
}
else
{
throw new ConfigurationException(
HttpRuntime.FormatResourceString(SR.Result_must_be_at_the_top_browser_section),
child);
}
break;
case "file":
if (parseState.IsExternalFile)
{
throw new ConfigurationException(
HttpRuntime.FormatResourceString(SR.File_element_only_valid_in_config),
child);
}
ProcessFile(parseState.FileList, child);
break;
default:
result.Add(RuleFromElement(parseState, child));
break;
}
top = false;
break;
case XmlNodeType.Comment:
case XmlNodeType.Whitespace:
break;
default:
HandlerBase.ThrowUnrecognizedElement(child);
break;
}
}
return(result);
}
internal static void CheckAssignableType(Type baseType, Type type)
{
if (!baseType.IsAssignableFrom(type))
{
throw new HttpException(
HttpRuntime.FormatResourceString(SR.Type_doesnt_inherit_from_type,
type.FullName, baseType.FullName));
}
}