示例#1
0
        /// <include file='doc\ProcessModelInfo.uex' path='docs/doc[@for="ProcessModelInfo.GetCurrentProcessInfo"]/*' />
        static public ProcessInfo    GetCurrentProcessInfo()
        {
            InternalSecurityPermissions.AspNetHostingPermissionLevelHigh.Demand();

            HttpContext context = HttpContext.Current;

            if (context == null || context.WorkerRequest == null ||
                !(context.WorkerRequest is System.Web.Hosting.ISAPIWorkerRequestOutOfProc))
            {
                throw new HttpException(HttpRuntime.FormatResourceString(SR.Process_information_not_available));
            }

            int  dwReqExecuted  = 0;
            int  dwReqExecuting = 0;
            long tmCreateTime   = 0;
            int  pid            = 0;
            int  mem            = 0;

            int iRet = UnsafeNativeMethods.PMGetCurrentProcessInfo(
                ref dwReqExecuted, ref dwReqExecuting, ref mem,
                ref tmCreateTime, ref pid);

            if (iRet < 0)
            {
                throw new HttpException(HttpRuntime.FormatResourceString(SR.Process_information_not_available));
            }

            DateTime startTime = DateTime.FromFileTime(tmCreateTime);
            TimeSpan age       = DateTime.Now.Subtract(startTime);

            return(new ProcessInfo(startTime, age, pid, dwReqExecuted,
                                   ProcessStatus.Alive, ProcessShutdownReason.None, mem));
        }
示例#2
0
            internal bool Start(bool forGlobalCode, bool throwOnError, bool fromAnotherThread)
            {
                if (!fromAnotherThread)
                {
                    Debug.Assert(!_inProgress);
                }

                IntPtr token = GetImpersonationToken(forGlobalCode, throwOnError);

                if (token == IntPtr.Zero)
                {
                    return(false);
                }

                // Do the impersonation
                int rc = UnsafeNativeMethods.SetThreadToken(IntPtr.Zero, token);

                if (rc == 0)
                {
                    throw new HttpException(HttpRuntime.FormatResourceString(SR.Cannot_impersonate));
                }
                if (!fromAnotherThread)
                {
                    _inProgress = true;
                }
                return(true);
            }
示例#3
0
        /*internal String MachineConfigPath {
         *  get {
         *      if (_wr == null)
         *          throw new HttpException(HttpRuntime.FormatResourceString(SR.Cannot_get_config_dir));
         *
         *      return _wr.MachineConfigPath;
         *  }
         * }*/

        /*
         * Called by the URL rewrite module to modify the path for downstream modules
         */
        /// <include file='doc\HttpContext.uex' path='docs/doc[@for="HttpContext.RewritePath"]/*' />
        /// <devdoc>
        ///    <para>[To be supplied.]</para>
        /// </devdoc>
        public void RewritePath(String path)
        {
            // extract query string
            String qs  = null;
            int    iqs = path.IndexOf('?');

            if (iqs >= 0)
            {
                qs   = (iqs < path.Length - 1) ? path.Substring(iqs + 1) : String.Empty;
                path = path.Substring(0, iqs);
            }

            // resolve relative path
            path = UrlPath.Combine(Request.BaseDir, path);

            // disallow paths outside of app
            if (!HttpRuntime.IsPathWithinAppRoot(path))
            {
                throw new HttpException(HttpRuntime.FormatResourceString(SR.Cross_app_not_allowed, path));
            }

            // clear things that depend on path
            ConfigPath = null;

            // rewrite path on request
            Request.InternalRewritePath(path, qs);
        }
示例#4
0
        /// <include file='doc\MyWeb.uex' path='docs/doc[@for="MyWebManifest.Install1"]/*' />
        /// <devdoc>
        ///    <para>Marked internal for Beta 1 per ErikOls.</para>
        /// </devdoc>
        public MyWebApplication Install(String strLocation)
        {
            if (Installed)
            {
                return(null);
            }

            if (!MyWeb.IsAdminApp())
            {
                return(null);
            }

            if (strLocation != null)
            {
                _Properties[_InstalledLocation] = strLocation;
            }

            StringBuilder strError = new StringBuilder(1024);

            if (NativeMethods.MyWebInstallApp(CabFile,
                                              ApplicationUrl,
                                              InstalledLocation,
                                              ManifestFile,
                                              strError,
                                              1024) != 0)
            {
                throw new HttpException(HttpRuntime.FormatResourceString(SR.Literal, strError.ToString()));
                //return null;
            }
            else
            {
                _Installed = true;
                return(new MyWebApplication(this));
            }
        }
示例#5
0
        /// <include file='doc\MyWeb.uex' path='docs/doc[@for="MyWebApplication.Update"]/*' />
        /// <devdoc>
        ///    <para>Marked internal for Beta 1 per ErikOls.</para>
        /// </devdoc>
        public int Update()
        {
            if (!MyWeb.IsAdminApp())
            {
                throw new HttpException(HttpRuntime.FormatResourceString(SR.Operation_requires_url_to_be_myweb_home));
            }

            MyWebManifest manifest = MyWeb.GetManifest(Manifest.ApplicationUrl);

            if (manifest == null)
            {
                return(0);
            }

            StringBuilder strError = new StringBuilder(1024);
            int           iReturn  = 0;

            iReturn = NativeMethods.MyWebReInstallApp(manifest.CabFile,
                                                      manifest.ApplicationUrl,
                                                      manifest.InstalledLocation,
                                                      manifest.ManifestFile,
                                                      strError,
                                                      1024);

            if (iReturn != 0 && iReturn != 1)
            {
                throw new HttpException(HttpRuntime.FormatResourceString(SR.Literal, strError.ToString()));
            }

            _Manifest = manifest;
            return(iReturn);
        }
示例#6
0
        internal void AddNewControl(string id, string parentId, string type, int viewStateSize)
        {
            VerifyStart();

            DataRow row = NewRow(_requestData, SR.Trace_Control_Tree);

            if (id == null)
            {
                id = PAGEKEYNAME;
            }
            row[SR.Trace_Control_Id] = id;

            if (parentId == null)
            {
                parentId = PAGEKEYNAME;
            }
            row[SR.Trace_Parent_Id] = parentId;

            row[SR.Trace_Type]           = type;
            row[SR.Trace_Viewstate_Size] = viewStateSize;
            row[SR.Trace_Render_Size]    = 0;
            try {
                AddRow(_requestData, SR.Trace_Control_Tree, row);
            }
            catch (ConstraintException) {
                throw new HttpException(HttpRuntime.FormatResourceString(SR.Duplicate_id_used, id, "Trace"));
            }
        }
示例#7
0
        internal void InstallFilter(Stream filter)
        {
            if (_filterSink == null)  // have to redirect to the sink -- null means sink wasn't ever asked for
            {
                throw new HttpException(HttpRuntime.FormatResourceString(SR.Invalid_response_filter));
            }

            _installedFilter = filter;
        }
示例#8
0
        private void VerifyState()
        {
            // throw exception on unexpected filter writes

            if (!_filtering)
            {
                throw new HttpException(HttpRuntime.FormatResourceString(SR.Invalid_use_of_response_filter));
            }
        }
示例#9
0
        internal int CallISAPI(UnsafeNativeMethods.CallISAPIFunc iFunction, byte [] bufIn, byte [] bufOut)
        {
            if (_wr == null || !(_wr is System.Web.Hosting.ISAPIWorkerRequest))
            {
                throw new HttpException(HttpRuntime.FormatResourceString(SR.Cannot_call_ISAPI_functions));
            }

            return(((System.Web.Hosting.ISAPIWorkerRequest)_wr).CallISAPI(iFunction, bufIn, bufOut));
        }
示例#10
0
        internal static SafeStringResource ReadSafeStringResource(Type t)
        {
            // Module.FullyQualifiedName was changed to check for FileIOPermission regardless of the name being an existing file or not.
            // we need to Assert in order to succeed the Demand() (ASURT 121603)
            (InternalSecurityPermissions.PathDiscovery(HttpRuntime.CodegenDirInternal)).Assert();

            string dllPath = t.Module.FullyQualifiedName;

            IntPtr hModule = UnsafeNativeMethods.GetModuleHandle(dllPath);

            if (hModule == (IntPtr)0)
            {
                throw new HttpException(HttpRuntime.FormatResourceString(SR.Resource_problem,
                                                                         "GetModuleHandle", HttpException.HResultFromLastError(Marshal.GetLastWin32Error()).ToString()));
            }

            IntPtr hrsrc = UnsafeNativeMethods.FindResource(hModule, (IntPtr)RESOURCE_ID, (IntPtr)RESOURCE_TYPE);

            if (hrsrc == (IntPtr)0)
            {
                throw new HttpException(HttpRuntime.FormatResourceString(SR.Resource_problem,
                                                                         "FindResource", HttpException.HResultFromLastError(Marshal.GetLastWin32Error()).ToString()));
            }

            int resSize = UnsafeNativeMethods.SizeofResource(hModule, hrsrc);

            IntPtr hglob = UnsafeNativeMethods.LoadResource(hModule, hrsrc);

            if (hglob == (IntPtr)0)
            {
                throw new HttpException(HttpRuntime.FormatResourceString(SR.Resource_problem,
                                                                         "LoadResource", HttpException.HResultFromLastError(Marshal.GetLastWin32Error()).ToString()));
            }

            IntPtr pv = UnsafeNativeMethods.LockResource(hglob);

            if (pv == (IntPtr)0)
            {
                throw new HttpException(HttpRuntime.FormatResourceString(SR.Resource_problem,
                                                                         "LockResource", HttpException.HResultFromLastError(Marshal.GetLastWin32Error()).ToString()));
            }

            // Make sure the end of the resource lies within the module.  this can be an issue
            // if the resource has been hacked with an invalid length (ASURT 145040)
            if (!UnsafeNativeMethods.IsValidResource(hModule, pv, resSize))
            {
                throw new InvalidOperationException();
            }

            return(new SafeStringResource(pv, resSize));
        }
示例#11
0
 internal void ReimpersonateIfSuspended()
 {
     if (_mode == ImpersonationMode.Client)
     {
         if (!ImpersonationSuspendContext.IsImpersonating())
         {
             int rc = UnsafeNativeMethods.SetThreadToken((IntPtr)0, _token);
             if (rc == 0)
             {
                 throw new HttpException(HttpRuntime.FormatResourceString(SR.Cannot_impersonate));
             }
             _reimpersonating = true;
         }
     }
 }
示例#12
0
        /*
         * Get bytes (for filtering)
         */
        /*public*/ byte[] IHttpResponseElement.GetBytes()
        {
            if (_size == 0)
            {
                return(new byte[0]);
            }

            byte[]     data = null;
            FileStream f    = null;

            try {
                if (_filename == null)
                {
                    f = new FileStream(_fileHandle, FileAccess.Read, false);
                }
                else
                {
                    f = new FileStream(_filename, FileMode.Open, FileAccess.Read, FileShare.Read);
                }

                long fileSize = f.Length;

                if (_offset < 0 || _size > fileSize - _offset)
                {
                    throw new HttpException(HttpRuntime.FormatResourceString(SR.Invalid_range));
                }

                if (_offset > 0)
                {
                    f.Seek(_offset, SeekOrigin.Begin);
                }

                data = new byte[(int)_size];
                f.Read(data, 0, (int)_size);
            }
            finally {
                if (f != null)
                {
                    f.Close();
                }
            }

            return(data);
        }
示例#13
0
            private static IntPtr GetCurrentToken()
            {
                IntPtr token = IntPtr.Zero;

                if (UnsafeNativeMethods.OpenThreadToken(
                        UnsafeNativeMethods.GetCurrentThread(),
                        UnsafeNativeMethods.TOKEN_READ | UnsafeNativeMethods.TOKEN_IMPERSONATE,
                        true,
                        ref token) == 0)
                {
                    // if the last error is ERROR_NO_TOKEN it is ok, otherwise throw
                    if (Marshal.GetLastWin32Error() != UnsafeNativeMethods.ERROR_NO_TOKEN)
                    {
                        throw new HttpException(HttpRuntime.FormatResourceString(SR.Cannot_impersonate));
                    }
                }

                return(token);
            }
示例#14
0
        //////////////////////////////////////////////////////////////////////
        // Move an app
        /// <include file='doc\MyWeb.uex' path='docs/doc[@for="MyWebManifest.Move"]/*' />
        /// <devdoc>
        ///    <para>Marked internal for Beta 1 per ErikOls.</para>
        /// </devdoc>
        public int Move(String strNewLocation)
        {
            if (!MyWeb.IsAdminApp())
            {
                return(0);
            }

            int           iReturn  = 0;
            StringBuilder strError = new StringBuilder(1024);

            iReturn = NativeMethods.MyWebMoveApp(ApplicationUrl,
                                                 strNewLocation,
                                                 strError,
                                                 1024);
            if (iReturn != 0 && iReturn != 1)
            {
                throw new HttpException(HttpRuntime.FormatResourceString(SR.Literal, strError.ToString()));
            }

            _Properties[_InstalledLocation] = strNewLocation;
            return(iReturn);
        }
示例#15
0
        ////////////////////////////////////////////////////////////////////////
        // CTor: Create from an installed app
        internal MyWebApplication(int iIndex)
        {
            if (!MyWeb.IsAdminApp())
            {
                throw new HttpException(HttpRuntime.FormatResourceString(SR.Operation_requires_url_to_be_myweb_home));
            }

            StringBuilder strBFile = new StringBuilder(300);
            StringBuilder strBUrl  = new StringBuilder(1024);

            long [] pLongs = new long[3];

            if (NativeMethods.MyWebGetApplicationDetails(iIndex, strBFile, 300, strBUrl, 1024, pLongs) != 0)
            {
                throw new HttpException(HttpRuntime.FormatResourceString(SR.Unable_to_create_app_object));
            }

            _Manifest         = MyWebManifest.CreateFromFile(strBFile.ToString() + "\\myweb.osd", strBUrl.ToString(), true, true);
            _InstalledDate    = DateTime.FromFileTime(pLongs[0]);
            _LastAccessDate   = DateTime.FromFileTime(pLongs[1]);
            _LocalApplication = (pLongs[2] != 0);
        }
示例#16
0
            internal void Resume()
            {
                if (_token != IntPtr.Zero)
                {
                    bool impersonationFailed = false;

                    if (_revertSucceeded)
                    {
                        if (UnsafeNativeMethods.SetThreadToken(IntPtr.Zero, _token) == 0)
                        {
                            impersonationFailed = true;
                        }
                    }

                    UnsafeNativeMethods.CloseHandle(_token);

                    if (impersonationFailed)
                    {
                        throw new HttpException(HttpRuntime.FormatResourceString(SR.Cannot_impersonate));
                    }
                }
            }
示例#17
0
        /// <include file='doc\HttpContext.uex' path='docs/doc[@for="HttpContext.RewritePath1"]/*' />
        /// <devdoc>
        ///    <para>[To be supplied.]</para>
        /// </devdoc>
        public void RewritePath(String filePath, String pathInfo, String queryString)
        {
            // resolve relative path
            filePath = UrlPath.Combine(Request.BaseDir, filePath);

            // disallow paths outside of app
            if (!HttpRuntime.IsPathWithinAppRoot(filePath))
            {
                throw new HttpException(HttpRuntime.FormatResourceString(SR.Cross_app_not_allowed, filePath));
            }

            // patch pathInfo
            if (pathInfo == null)
            {
                pathInfo = String.Empty;
            }

            // clear things that depend on path
            ConfigPath = null;

            // rewrite path on request
            Request.InternalRewritePath(filePath, pathInfo, queryString);
        }
        /// <include file='doc\HttpDebugHandler.uex' path='docs/doc[@for="HttpDebugHandler.ProcessRequest"]/*' />
        /// <devdoc>
        ///    <para>Drives web processing execution.</para>
        /// </devdoc>
        public void ProcessRequest(HttpContext context)
        {
            // Debugging must be enabled

            try {
                HttpDebugHandlerTimeLog.PrintTickDelta("Entered HttpDebugHandler");

                if (!HttpRuntime.DebuggingEnabled)
                {
                    context.Response.Write(HttpRuntime.FormatResourceString(SR.Debugging_forbidden, context.Request.Path));
                    context.Response.StatusCode = 403;
                    return;
                }

                // Check to see if it's a valid debug command.
                string command = context.Request.Headers["Command"];

                if (command == null)
                {
                    Debug.Trace("AutoAttach", "No debug command!!");
                    context.Response.Write(HttpRuntime.FormatResourceString(SR.Invalid_Debug_Request));
                    context.Response.StatusCode = 500;
                    return;
                }

                Debug.Trace("AutoAttach", "Debug command: " + command);

                if (string.Compare(command, "stop-debug", true, CultureInfo.InvariantCulture) == 0)
                {
                    context.Response.Write("OK");
                    return;
                }

                if (string.Compare(command, "start-debug", true, CultureInfo.InvariantCulture) != 0)
                {
                    context.Response.Write(HttpRuntime.FormatResourceString(SR.Invalid_Debug_Request));
                    context.Response.StatusCode = 500;
                    return;
                }

                // Request must be NTLM authenticated
                string authType  = context.WorkerRequest.GetServerVariable("AUTH_TYPE"); // go the metal
                string logonUser = context.WorkerRequest.GetServerVariable("LOGON_USER");

                Debug.Trace("AutoAttach", "Authentication type string: " + ((authType != null) ? authType : "NULL"));
                Debug.Trace("AutoAttach", "Logon user string: " + ((logonUser != null) ? logonUser : "******"));

                if (logonUser == null || logonUser.Length == 0 || authType == null || authType.Length == 0 || String.Compare(authType, "basic", true, CultureInfo.InvariantCulture) == 0)
                {
                    Debug.Trace("AutoAttach", "Invalid logon_user or auth_type string.");
                    context.Response.Write(HttpRuntime.FormatResourceString(SR.Debug_Access_Denied, context.Request.Path));
                    context.Response.StatusCode = 401;
                    return;
                }

                // Get the session ID
                String sessId = context.Request.Form["DebugSessionID"];

                Debug.Trace("AutoAttach", "DebugSessionID: " + ((sessId != null) ? sessId : "NULL"));

                if (sessId == null || sessId.Length == 0)
                {
                    context.Response.Write(HttpRuntime.FormatResourceString(SR.Invalid_Debug_ID));
                    context.Response.StatusCode = 500;
                    return;
                }

                string s = sessId.Replace(';', '&');

                HttpValueCollection valCol = new HttpValueCollection(s, true, true, Encoding.UTF8);
                string clsId = (string)valCol["autoattachclsid"];

                // Verify clsId
                bool isClsIdOk = false;
                if (clsId != null)
                {
                    for (int i = 0; i < validClsIds.Length; i++)
                    {
                        if (clsId.ToLower(System.Globalization.CultureInfo.InvariantCulture) == validClsIds[i])
                        {
                            isClsIdOk = true;
                            break;
                        }
                    }
                }
                if (isClsIdOk == false)
                {
                    context.Response.Write(HttpRuntime.FormatResourceString(SR.Debug_Access_Denied, context.Request.Path));
                    context.Response.StatusCode = 401;
                    Debug.Trace("AutoAttach", "Debug attach not attempted because of invalid CLSID.");
                    return;
                }

                // Attach the debugger
                HttpDebugHandlerTimeLog.PrintTickDelta("About to call into MDM");

                int rc = UnsafeNativeMethods.AttachDebugger(clsId, sessId, context.WorkerRequest.GetUserToken());

                HttpDebugHandlerTimeLog.PrintTickDelta("Returned from call to MDM");

                // If it's not S_OK, then we got a problem
                if (rc != 0)
                {
                    Debug.Trace("AutoAttach", "Debug attach failed! Return code: " + rc);
                    context.Response.Write(HttpRuntime.FormatResourceString(SR.Error_Attaching_with_MDM, "0x" + rc.ToString("X8")));
                    context.Response.StatusCode = 500;
                    return;
                }

                Debug.Trace("AutoAttach", "Debug attach successful!");

                // Everything ok -- increment counter, return something (not 204)
                PerfCounters.IncrementCounter(AppPerfCounter.DEBUGGING_REQUESTS);
                context.Response.Write("OK");

                // Set global flag for us
                HttpRuntime.VSDebugAttach = true;
            }
            finally {
                Debug.Trace("AutoAttach", "Http Debug attach done!");

                HttpDebugHandlerTimeLog.PrintTickDelta("Leaving HttpDebugHandler");
                HttpDebugHandlerTimeLog.Close();
            }
        }
        /////////////////////////////////////////////////////////////////////////////
        /////////////////////////////////////////////////////////////////////////////
        public void ProcessRequest(HttpContext context)
        {
            FileInfo     file;
            HttpRequest  request  = context.Request;
            HttpResponse response = context.Response;
            string       FileName = request.PhysicalPath;

            Util.Debug.Trace("GET", "Path = " + request.Path);
            Util.Debug.Trace("GET", "File Name = " + FileName);

            //
            // Check whether the file exists
            //

            if (!FileUtil.FileExists(FileName))
            {
                throw new HttpException(HttpStatus.NotFound,
                                        HttpRuntime.FormatResourceString(SR.File_does_not_exist));
            }

            try {
                file = new FileInfo(FileName);
            }
            catch (IOException ioEx) {
                if (!HttpRuntime.HasFilePermission(FileName))
                {
                    throw new HttpException(HttpStatus.NotFound,
                                            HttpRuntime.FormatResourceString(SR.Error_trying_to_enumerate_files));
                }
                else
                {
                    throw new HttpException(HttpStatus.NotFound,
                                            HttpRuntime.FormatResourceString(SR.Error_trying_to_enumerate_files),
                                            ioEx);
                }
            }
            catch (SecurityException secEx) {
                if (!HttpRuntime.HasFilePermission(FileName))
                {
                    throw new HttpException(HttpStatus.Unauthorized,
                                            HttpRuntime.FormatResourceString(SR.File_enumerator_access_denied));
                }
                else
                {
                    throw new HttpException(HttpStatus.Unauthorized,
                                            HttpRuntime.FormatResourceString(SR.File_enumerator_access_denied),
                                            secEx);
                }
            }

            //
            // To be consistent with IIS, we won't serve out hidden files
            //

            if ((((int)file.Attributes) & ((int)FileAttributes.Hidden)) != 0)
            {
                throw new HttpException(HttpStatus.NotFound,
                                        HttpRuntime.FormatResourceString(SR.File_is_hidden));
            }

            //
            // To prevent the trailing dot problem, error out all file names with trailing dot.
            //

            if (FileName[FileName.Length - 1] == '.')
            {
                throw new HttpException(HttpStatus.NotFound,
                                        HttpRuntime.FormatResourceString(SR.File_does_not_exist));
            }

            //
            // If the file is a directory, then it must not have a slash in
            // end of it (if it does have a slash suffix, then the config file
            // mappings are missing and we will just return 403.  Otherwise,
            // we will redirect the client to the URL with this slash.
            //

            if ((((int)file.Attributes) & ((int)FileAttributes.Directory)) != 0)
            {
                if (request.Path.EndsWith("/"))
                {
                    //
                    // Just return 403
                    //

                    throw new HttpException(HttpStatus.Forbidden,
                                            HttpRuntime.FormatResourceString(SR.Missing_star_mapping));
                }
                else
                {
                    //
                    // Redirect to a slash suffixed URL which will be
                    // handled by the */ handler mapper
                    //
                    response.Redirect(request.Path + "/");
                }
            }
            else
            {
                DateTime lastModified;
                string   strETag;

                //
                // Determine Last Modified Time.  We might need it soon
                // if we encounter a Range: and If-Range header
                //

                lastModified = new DateTime(file.LastWriteTime.Year,
                                            file.LastWriteTime.Month,
                                            file.LastWriteTime.Day,
                                            file.LastWriteTime.Hour,
                                            file.LastWriteTime.Minute,
                                            file.LastWriteTime.Second,
                                            0);
                //
                // Generate ETag
                //

                strETag = GenerateETag(context, lastModified);

                //
                // OK.  Send the static file out either
                // entirely or send out the requested ranges
                //

                try {
                    BuildFileItemResponse(context,
                                          FileName,
                                          file.Length,
                                          lastModified,
                                          strETag);
                }
                catch (Exception e) {
                    //
                    // Check for ERROR_ACCESS_DENIED and set the HTTP
                    // status such that the auth modules do their thing
                    //

                    if ((e is ExternalException) && IsSecurityError(((ExternalException)e).ErrorCode))
                    {
                        throw new HttpException(HttpStatus.Unauthorized,
                                                HttpRuntime.FormatResourceString(SR.Resource_access_forbidden));
                    }
                }

                context.Response.Cache.SetLastModified(lastModified);

                context.Response.Cache.SetETag(strETag);

                //
                // We will always set Cache-Control to public
                //

                context.Response.Cache.SetCacheability(HttpCacheability.Public);
            }
        }
 public override void Remove(String name)
 {
     throw new HttpException(HttpRuntime.FormatResourceString(SR.Cannot_modify_server_vars));
 }
示例#21
0
 internal HttpRequestValidationException(string message)
     : base(message)
 {
     SetFormatter(new UnhandledErrorFormatter(
                      this, HttpRuntime.FormatResourceString(SR.Dangerous_input_detected_descr), null));
 }
示例#22
0
        //////////////////////////////////////////////////////////////////////
        //////////////////////////////////////////////////////////////////////
        //////////////////////////////////////////////////////////////////////
        // Private stuff

        //////////////////////////////////////////////////////////////////////
        // Create a manifest from a manifest file
        static internal MyWebManifest CreateFromFile(
            String strFile,
            String strUrl,
            bool installed,
            bool donotfail)
        {
            String []         strProperties = null;
            ConfigXmlDocument xmlDoc        = null;
            ConfigXmlCursor   cursor        = null;
            int           iter        = 0;
            int           iRet        = 0;
            StringBuilder strBuf      = new StringBuilder(1024);
            bool          fFound      = false;
            ArrayList     customUrls  = new ArrayList();
            ArrayList     customUrlDs = new ArrayList();
            String        strRandom   = System.Web.SessionState.SessionId.Create();

            ////////////////////////////////////////////////////////////
            // Step 1: Parse the file and get the other properties
            try {
                xmlDoc = new ConfigXmlDocument();
                xmlDoc.Load(strFile);
                cursor = xmlDoc.GetCursor();
                cursor.MoveToFirstChild();
            }
            catch (Exception e) {
                if (!donotfail)
                {
                    throw e;
                }
                cursor = null;
            }

            if (cursor != null)
            {
                do
                {
                    if (cursor.Type == ConfigXmlElement.Element && cursor.Name.ToLower(CultureInfo.InvariantCulture).Equals("softpkg"))
                    {
                        fFound = true;
                        break;
                    }
                }while (cursor.MoveNext());
            }

            if (!fFound && !donotfail)
            {
                return(null);
            }

            ////////////////////////////////////////////////////////////
            // Step 2: Get the non-manifest file properties
            strProperties = new String[NUM_PROPERTIES];
            for (iter = 0; iter < NUM_PROPERTIES; iter++)
            {
                strProperties[iter] = String.Empty;
            }

            strProperties[_ApplicationUrl] = strUrl.Replace('\\', '/');
            strProperties[_ManifestFile]   = strFile;

            if (!installed)
            {
                iRet = NativeMethods.MyWebGetInstallLocationForUrl(MyWeb.GetDefaultInstallLocation(),
                                                                   strUrl, strRandom, strBuf, 1024);

                if (iRet < 0)
                {
                    iRet   = -iRet + 100;
                    strBuf = new StringBuilder(iRet);
                    iRet   = NativeMethods.MyWebGetInstallLocationForUrl(MyWeb.GetDefaultInstallLocation(),
                                                                         strUrl, strRandom, strBuf, iRet);
                }
                if (iRet <= 0)
                {
                    throw new HttpException(HttpRuntime.FormatResourceString(SR.Unable_to_get_app_location));
                }

                strProperties[_InstalledLocation] = strBuf.ToString();
            }
            else
            {
                strProperties[_InstalledLocation] = strFile.Substring(0, strFile.LastIndexOf('\\'));
            }


            if (cursor == null && donotfail)
            {
                return(new MyWebManifest(strProperties, installed, new String[0], new String[0]));
            }

            strProperties[_Name]    = cursor.AttributeText("name");
            strProperties[_Version] = cursor.AttributeText("version");
            cursor.MoveToFirstChild();
            do
            {
                if (cursor.Type == ConfigXmlElement.Element)
                {
                    String strName = cursor.Name.ToLower(CultureInfo.InvariantCulture);

                    if (strName.Equals("implementation"))
                    {
                        strProperties[_CabFile] = GetCabFileNameFromCursor(cursor);
                    }
                    else if (strName.Equals("license"))
                    {
                        strProperties[_License] = cursor.AttributeText("href");
                    }
                    else if (strName.Equals("customurl"))
                    {
                        String strC = cursor.AttributeText("href");
                        String strD = cursor.AttributeText("description");
                        customUrls.Add(strC);
                        customUrlDs.Add(strD);
                    }
                    else
                    {
                        for (iter = 0; iter < _OtherProperties.Length; iter++)
                        {
                            if (strName.Equals(_OtherProperties[iter]))
                            {
                                strProperties[OTHER_PROP_START + iter] = GetCursorText(cursor);
                                break;
                            }
                        }
                    }
                }
            }while (cursor.MoveNext());

            return(new MyWebManifest(strProperties, installed, customUrls.ToArray(), customUrlDs.ToArray()));
        }
示例#23
0
        /// <include file='doc\ProcessModelInfo.uex' path='docs/doc[@for="ProcessModelInfo.GetHistory"]/*' />
        static public ProcessInfo[]  GetHistory(int numRecords)
        {
            InternalSecurityPermissions.AspNetHostingPermissionLevelHigh.Demand();

            HttpContext context = HttpContext.Current;

            if (context == null || context.WorkerRequest == null ||
                !(context.WorkerRequest is System.Web.Hosting.ISAPIWorkerRequestOutOfProc))
            {
                throw new HttpException(HttpRuntime.FormatResourceString(SR.Process_information_not_available));
            }

            if (numRecords < 1)
            {
                return(null);
            }

            int []  dwPID  = new int [numRecords];
            int []  dwExed = new int [numRecords];
            int []  dwExei = new int [numRecords];
            int []  dwPend = new int [numRecords];
            int []  dwReas = new int [numRecords];
            long [] tmCrea = new long [numRecords];
            long [] tmDeat = new long [numRecords];
            int []  mem    = new int [numRecords];

            int iRows = UnsafeNativeMethods.PMGetHistoryTable(numRecords, dwPID, dwExed, dwPend, dwExei, dwReas, mem, tmCrea, tmDeat);

            if (iRows < 0)
            {
                throw new HttpException(HttpRuntime.FormatResourceString(SR.Process_information_not_available));
            }

            ProcessInfo[] ret = new ProcessInfo[iRows];
            for (int iter = 0; iter < iRows; iter++)
            {
                DateTime startTime = DateTime.FromFileTime(tmCrea[iter]);
                TimeSpan age       = DateTime.Now.Subtract(startTime);

                ProcessStatus         status = ProcessStatus.Alive;
                ProcessShutdownReason rea    = ProcessShutdownReason.None;

                if (dwReas[iter] != 0)
                {
                    if (tmDeat[iter] > 0)
                    {
                        age = DateTime.FromFileTime(tmDeat[iter]).Subtract(startTime);
                    }

                    if ((dwReas[iter] & 0x0004) != 0)
                    {
                        status = ProcessStatus.Terminated;
                    }
                    else if ((dwReas[iter] & 0x0002) != 0)
                    {
                        status = ProcessStatus.ShutDown;
                    }
                    else
                    {
                        status = ProcessStatus.ShuttingDown;
                    }

                    if ((0x0040 & dwReas[iter]) != 0)
                    {
                        rea = ProcessShutdownReason.IdleTimeout;
                    }
                    else if ((0x0080 & dwReas[iter]) != 0)
                    {
                        rea = ProcessShutdownReason.RequestsLimit;
                    }
                    else if ((0x0100 & dwReas[iter]) != 0)
                    {
                        rea = ProcessShutdownReason.RequestQueueLimit;
                    }
                    else if ((0x0020 & dwReas[iter]) != 0)
                    {
                        rea = ProcessShutdownReason.Timeout;
                    }
                    else if ((0x0200 & dwReas[iter]) != 0)
                    {
                        rea = ProcessShutdownReason.MemoryLimitExceeded;
                    }
                    else if ((0x0400 & dwReas[iter]) != 0)
                    {
                        rea = ProcessShutdownReason.PingFailed;
                    }
                    else if ((0x0800 & dwReas[iter]) != 0)
                    {
                        rea = ProcessShutdownReason.DeadlockSuspected;
                    }
                    else
                    {
                        rea = ProcessShutdownReason.Unexpected;
                    }
                }

                ret[iter] = new ProcessInfo(startTime, age, dwPID[iter], dwExed[iter], status, rea, mem[iter]);
            }

            return(ret);
        }
示例#24
0
        internal /*public*/ string GetHtmlErrorMessage(bool dontShowSensitiveInfo)
        {
            // Give the formatter a chance to prepare its state
            PrepareFormatter();

            StringBuilder sb = new StringBuilder();

            // REVIEW: all the derived method should work directly with the string
            // builder instead of returning a string.

            sb.Append("<html>\r\n");
            sb.Append("    <head>\r\n");
            sb.Append("        <title>" + ErrorTitle + "</title>\r\n");
            sb.Append("        <style>\r\n");
            sb.Append("        	body {font-family:\"Verdana\";font-weight:normal;font-size: .7em;color:black;} \r\n");
            sb.Append("        	p {font-family:\"Verdana\";font-weight:normal;color:black;margin-top: -5px}\r\n");
            sb.Append("        	b {font-family:\"Verdana\";font-weight:bold;color:black;margin-top: -5px}\r\n");
            sb.Append("        	H1 { font-family:\"Verdana\";font-weight:normal;font-size:18pt;color:red }\r\n");
            sb.Append("        	H2 { font-family:\"Verdana\";font-weight:normal;font-size:14pt;color:maroon }\r\n");
            sb.Append("        	pre {font-family:\"Lucida Console\";font-size: .9em}\r\n");
            sb.Append("        	.marker {font-weight: bold; color: black;text-decoration: none;}\r\n");
            sb.Append("        	.version {color: gray;}\r\n");
            sb.Append("        	.error {margin-bottom: 10px;}\r\n");
            sb.Append("        	.expandable { text-decoration:underline; font-weight:bold; color:navy; cursor:hand; }\r\n");
            sb.Append("        </style>\r\n");
            sb.Append("    </head>\r\n\r\n");
            sb.Append("    <body bgcolor=\"white\">\r\n\r\n");
            sb.Append("            <span><H1>" + HttpRuntime.FormatResourceString(SR.Error_Formatter_ASPNET_Error, HttpRuntime.AppDomainAppVirtualPath) + "<hr width=100% size=1 color=silver></H1>\r\n\r\n");
            sb.Append("            <h2> <i>" + ErrorTitle + "</i> </h2></span>\r\n\r\n");
            sb.Append("            <font face=\"Arial, Helvetica, Geneva, SunSans-Regular, sans-serif \">\r\n\r\n");
            sb.Append("            <b> " + HttpRuntime.FormatResourceString(SR.Error_Formatter_Description) + " </b>" + Description + "\r\n");
            sb.Append("            <br><br>\r\n\r\n");
            if (MiscSectionTitle != null)
            {
                sb.Append("            <b> " + MiscSectionTitle + ": </b>" + MiscSectionContent + "<br><br>\r\n\r\n");
            }

            WriteColoredSquare(sb, ColoredSquareTitle, ColoredSquareDescription, ColoredSquareContent, WrapColoredSquareContentLines);

            if (ShowSourceFileInfo)
            {
                string fileName = HttpRuntime.GetSafePath(SourceFileName);
                if (fileName == null)
                {
                    fileName = HttpRuntime.FormatResourceString(SR.Error_Formatter_No_Source_File);
                }
                sb.Append("            <b> " + HttpRuntime.FormatResourceString(SR.Error_Formatter_Source_File) + " </b> " + fileName + "<b> &nbsp;&nbsp; " + HttpRuntime.FormatResourceString(SR.Error_Formatter_Line) + " </b> " + SourceFileLineNumber + "\r\n");
                sb.Append("            <br><br>\r\n\r\n");
            }

            // If it's a FileNotFoundException/FileLoadException/BadImageFormatException with a FusionLog,
            // write it out (ASURT 83587)
            if (!dontShowSensitiveInfo && Exception != null)
            {
                // (Only display the fusion log in medium or higher (ASURT 126827)
                if (HttpRuntime.HasAspNetHostingPermission(AspNetHostingPermissionLevel.Medium))
                {
                    for (Exception e = Exception; e != null; e = e.InnerException)
                    {
                        string fusionLog = null;
                        string filename  = null;
                        FileNotFoundException fnfException = e as FileNotFoundException;
                        if (fnfException != null)
                        {
                            fusionLog = fnfException.FusionLog;
                            filename  = fnfException.FileName;
                        }
                        FileLoadException flException = e as FileLoadException;
                        if (flException != null)
                        {
                            fusionLog = flException.FusionLog;
                            filename  = flException.FileName;
                        }
                        BadImageFormatException bifException = e as BadImageFormatException;
                        if (bifException != null)
                        {
                            fusionLog = bifException.FusionLog;
                            filename  = bifException.FileName;
                        }
                        if (fusionLog != null && fusionLog.Length > 0)
                        {
                            WriteColoredSquare(sb,
                                               HttpRuntime.FormatResourceString(SR.Error_Formatter_FusionLog),
                                               HttpRuntime.FormatResourceString(SR.Error_Formatter_FusionLogDesc, filename),
                                               HttpUtility.HtmlEncode(fusionLog),
                                               false /*WrapColoredSquareContentLines*/);
                            break;
                        }
                    }
                }
            }

            WriteColoredSquare(sb, ColoredSquare2Title, ColoredSquare2Description, ColoredSquare2Content, false);

            if (!dontShowSensitiveInfo)    // don't show version for security reasons
            {
                sb.Append("            <hr width=100% size=1 color=silver>\r\n\r\n");
                sb.Append("            <b>" + HttpRuntime.FormatResourceString(SR.Error_Formatter_Version) + "</b>&nbsp;" +
                          HttpRuntime.FormatResourceString(SR.Error_Formatter_CLR_Build) + VersionInfo.ClrVersion +
                          HttpRuntime.FormatResourceString(SR.Error_Formatter_ASPNET_Build) + VersionInfo.IsapiVersion + "\r\n\r\n");
                sb.Append("            </font>\r\n\r\n");
            }
            sb.Append("    </body>\r\n");
            sb.Append("</html>\r\n");

            sb.Append(PostMessage);

            return(sb.ToString());
        }
示例#25
0
        /*
         * Return the text of the error line in the source file, with a few
         * lines around it.  It is returned in HTML format.
         */
        internal static string GetSourceFileLines(string fileName, Encoding encoding, string sourceCode, int lineNumber)
        {
            // Don't show any source file if the user doesn't have access to it (ASURT 122430)
            if (fileName != null && !HttpRuntime.HasFilePermission(fileName))
            {
                return(HttpRuntime.FormatResourceString(SR.WithFile_No_Relevant_Line));
            }

            // REVIEW: write directly to the main builder
            StringBuilder sb = new StringBuilder();

            if (lineNumber <= 0)
            {
                return(HttpRuntime.FormatResourceString(SR.WithFile_No_Relevant_Line));
            }

            TextReader reader = null;

            fileName = ResolveHttpFileName(fileName);

            try {
                // Open the source file
                reader = new StreamReader(fileName, encoding, true, 4096);
            }
            catch (Exception) {
                // Can't open the file?  Use the dynamically generated content...
                reader = new StringReader(sourceCode);
            }

            try {
                bool fFoundLine = false;

                for (int i = 1; ; i++)
                {
                    // Get the current line from the source file
                    string sourceLine = reader.ReadLine();
                    if (sourceLine == null)
                    {
                        break;
                    }

                    // If it's the error line, make it red
                    if (i == lineNumber)
                    {
                        sb.Append("<font color=red>");
                    }

                    // Is it in the range we want to display
                    if (i >= lineNumber - errorRange && i <= lineNumber + errorRange)
                    {
                        fFoundLine = true;
                        String linestr = i.ToString("G");

                        sb.Append(HttpRuntime.FormatResourceString(SR.WithFile_Line_Num, linestr));
                        if (linestr.Length < 3)
                        {
                            sb.Append(' ', 3 - linestr.Length);
                        }
                        sb.Append(HttpUtility.HtmlEncode(sourceLine));

                        if (i != lineNumber + errorRange)
                        {
                            sb.Append("\r\n");
                        }
                    }

                    if (i == lineNumber)
                    {
                        sb.Append("</font>");
                    }

                    if (i > lineNumber + errorRange)
                    {
                        break;
                    }
                }

                if (!fFoundLine)
                {
                    return(HttpRuntime.FormatResourceString(SR.WithFile_No_Relevant_Line));
                }
            }
            finally {
                // Make sure we always close the reader
                reader.Close();
            }

            return(sb.ToString());
        }
示例#26
0
        //
        // constructor used by config section handler
        //
        internal CustomErrors(XmlNode node, String basePath, CustomErrors parent)
        {
            _mode = CustomErrorsMode.Off;

            // inherit parent settings

            if (parent != null)
            {
                _mode            = parent._mode;
                _defaultRedirect = parent._defaultRedirect;

                if (parent._codeRedirects != null)
                {
                    _codeRedirects = new Hashtable();
                    for (IDictionaryEnumerator e = parent._codeRedirects.GetEnumerator(); e.MoveNext();)
                    {
                        _codeRedirects.Add(e.Key, e.Value);
                    }
                }
            }

            // add current settings

            XmlNode a;
            String  redirect = null;

            // get default and mode from the main tag

            HandlerBase.GetAndRemoveStringAttribute(node, "defaultRedirect", ref redirect);

            if (redirect != null)
            {
                _defaultRedirect = GetAbsoluteRedirect(redirect, basePath);
            }

            int iMode = 0;

            a = HandlerBase.GetAndRemoveEnumAttribute(node, "mode", typeof(CustomErrorsMode), ref iMode);
            if (a != null)
            {
                _mode = (CustomErrorsMode)iMode;
            }

            // report errors on bad attribures
            HandlerBase.CheckForUnrecognizedAttributes(node);

            // child tags

            foreach (XmlNode child in node.ChildNodes)
            {
                if (HandlerBase.IsIgnorableAlsoCheckForNonElement(child))
                {
                    continue;
                }

                int status = 0; // set when req. attr. is read

                // only <error> is allowed

                if (child.Name != "error")
                {
                    HandlerBase.ThrowUnrecognizedElement(child);
                }

                // status code attribure

                a = HandlerBase.GetAndRemoveRequiredIntegerAttribute(child, "statusCode", ref status);
                if (status < 100 && status > 999)
                {
                    throw new ConfigurationException(
                              HttpRuntime.FormatResourceString(SR.Customerrors_invalid_statuscode),
                              a);
                }

                // redirect attribure
                redirect = HandlerBase.RemoveRequiredAttribute(child, "redirect");

                // errors on other attributes
                HandlerBase.CheckForUnrecognizedAttributes(child);
                // <error> tags contain no content
                HandlerBase.CheckForChildNodes(child);

                // remember

                if (_codeRedirects == null)
                {
                    _codeRedirects = new Hashtable();
                }

                _codeRedirects[status.ToString()] = GetAbsoluteRedirect(redirect, basePath);
            }
        }