Exemplo n.º 1
0
 public void Normalize_OnInvalidUrlPath_ThrowsArgumentException(bool isBasePath)
 => Assert.Throws <ArgumentException>(() => UrlPath.Normalize("does/not/start/with/slash", isBasePath));
        public void IsEqualOrSubDirectory_UnixPath(string dir, string subdir, bool expected)
        {
            bool actual = UrlPath.IsEqualOrSubdirectory(dir, subdir);

            Assert.Equal(expected, actual);
        }
        public void IsEqualOrSubDirectory_NullSubDir()
        {
            bool test = UrlPath.IsEqualOrSubdirectory("Hello", null);

            Assert.False(test);
        }
        public void IsEqualOrSubDirectory_True_DirBackslash()
        {
            bool test = UrlPath.IsEqualOrSubdirectory("C:\\Directory\\", "C:\\Directory\\SubDirectory");

            Assert.True(test);
        }
        public void IsEqualOrSubDirectory_Equal_BothBackslashes()
        {
            bool test = UrlPath.IsEqualOrSubdirectory("C:\\Directory\\", "C:\\Directory\\");

            Assert.True(test);
        }
Exemplo n.º 6
0
        public void IsEqualOrSubDirectory_EmptyDir()
        {
            bool test = UrlPath.IsEqualOrSubdirectory("", null);

            Assert.True(test);
        }
Exemplo n.º 7
0
        public void IsEqualOrSubDirectory_SubDirAndDirAreReversed_NoTrailingBackslash()
        {
            bool test = UrlPath.IsEqualOrSubdirectory("C:\\Directory\\SubDirectory", "C:\\Directory");

            Assert.False(test);
        }
Exemplo n.º 8
0
 public void Split_OnEmptyUrlPath_ThrowsArgumentException()
 => Assert.Throws <ArgumentException>(() => UrlPath.Split(""));
Exemplo n.º 9
0
        internal static string GetWebResourceUrlInternal(Assembly assembly, string resourceName,
                                                         bool htmlEncoded, bool forSubstitution, IScriptManager scriptManager, bool enableCdn)
        {
            // When this url is being inserted as a substitution in another resource,
            // it should just be "WebResource.axd?d=..." since the resource is already coming
            // from the app root (i.e. no need for a full absolute /app/WebResource.axd).
            // Otherwise we must return a path that is absolute (starts with '/') or
            // a full absolute uri (http://..) as in the case of a CDN Path.

            EnsureHandlerExistenceChecked();
            if (!_handlerExists)
            {
                throw new InvalidOperationException(SR.GetString(SR.AssemblyResourceLoader_HandlerNotRegistered));
            }
            Assembly effectiveAssembly     = assembly;
            string   effectiveResourceName = resourceName;

            bool debuggingEnabled = false;
            bool secureConnection;

            if (scriptManager != null)
            {
                debuggingEnabled = scriptManager.IsDebuggingEnabled;
                secureConnection = scriptManager.IsSecureConnection;
            }
            else
            {
                secureConnection = ((HttpContext.Current != null) && (HttpContext.Current.Request != null) &&
                                    HttpContext.Current.Request.IsSecureConnection);
                debuggingEnabled = (HttpContext.Current != null) && HttpContext.Current.IsDebuggingEnabled;
            }
            int urlCacheKey = CreateWebResourceUrlCacheKey(assembly, resourceName, htmlEncoded,
                                                           forSubstitution, enableCdn, debuggingEnabled, secureConnection);

            string url = (string)_urlCache[urlCacheKey];

            if (url == null)
            {
                IScriptResourceDefinition definition = null;
                if (ClientScriptManager._scriptResourceMapping != null)
                {
                    definition = ClientScriptManager._scriptResourceMapping.GetDefinition(resourceName, assembly);
                    if (definition != null)
                    {
                        if (!String.IsNullOrEmpty(definition.ResourceName))
                        {
                            effectiveResourceName = definition.ResourceName;
                        }
                        if (definition.ResourceAssembly != null)
                        {
                            effectiveAssembly = definition.ResourceAssembly;
                        }
                    }
                }
                string path = null;
                // if a resource mapping exists, take it's settings into consideration
                // it might supply a path or a cdnpath.
                if (definition != null)
                {
                    if (enableCdn)
                    {
                        // Winner is first path defined, falling back on the effectiveResourceName/Assembly
                        // Debug Mode  : d.CdnDebugPath, d.DebugPath, *wra.CdnPath, d.Path
                        // Release Mode: d.CdnPath                  , *wra.CdnPath, d.Path
                        // * the WebResourceAttribute corresponding to the resource defined in the definition, not the
                        //  the original resource.
                        // Also, if the definition has a CdnPath but it cannot be converted to a secure one during https,
                        // the WRA's CdnPath is not considered.
                        if (debuggingEnabled)
                        {
                            path = secureConnection ? definition.CdnDebugPathSecureConnection : definition.CdnDebugPath;
                            if (String.IsNullOrEmpty(path))
                            {
                                path = definition.DebugPath;
                                if (String.IsNullOrEmpty(path))
                                {
                                    // Get CDN Path from the redirected resource name/assembly, not the original one,
                                    // but not if this is a secure connection and the only reason we didn't use the definition
                                    // cdn path is because it doesnt support secure connections.
                                    if (!secureConnection || String.IsNullOrEmpty(definition.CdnDebugPath))
                                    {
                                        path = GetCdnPath(effectiveResourceName, effectiveAssembly, secureConnection);
                                    }
                                    if (String.IsNullOrEmpty(path))
                                    {
                                        path = definition.Path;
                                    }
                                }
                            }
                        }
                        else
                        {
                            path = secureConnection ? definition.CdnPathSecureConnection : definition.CdnPath;
                            if (String.IsNullOrEmpty(path))
                            {
                                // Get CDN Path from the redirected resource name/assembly, not the original one
                                // but not if this is a secure connection and the only reason we didn't use the definition
                                // cdn path is because it doesnt support secure connections.
                                if (!secureConnection || String.IsNullOrEmpty(definition.CdnPath))
                                {
                                    path = GetCdnPath(effectiveResourceName, effectiveAssembly, secureConnection);
                                }
                                if (String.IsNullOrEmpty(path))
                                {
                                    path = definition.Path;
                                }
                            }
                        }
                    } // cdn
                    else
                    {
                        // Winner is first path defined, falling back on the effectiveResourceName/Assembly
                        // Debug Mode  : d.DebugPath, d.Path
                        // Release Mode: d.Path
                        if (debuggingEnabled)
                        {
                            path = definition.DebugPath;
                            if (String.IsNullOrEmpty(path))
                            {
                                path = definition.Path;
                            }
                        }
                        else
                        {
                            path = definition.Path;
                        }
                    }
                } // does not have definition
                else if (enableCdn)
                {
                    path = GetCdnPath(effectiveResourceName, effectiveAssembly, secureConnection);
                }

                if (!String.IsNullOrEmpty(path))
                {
                    // assembly based resource has been overridden by a path,
                    // whether that be a CDN Path or a definition.Path or DebugPath.
                    // We must return a path that is absolute (starts with '/') or
                    // a full absolute uri (http://..) as in the case of a CDN Path.
                    // An overridden Path that is not a CDN Path is required to be absolute
                    // or app relative.
                    if (UrlPath.IsAppRelativePath(path))
                    {
                        // expand ~/. If it is rooted (/) or an absolute uri, no conversion needed
                        if (_applicationRootPath == null)
                        {
                            url = VirtualPathUtility.ToAbsolute(path);
                        }
                        else
                        {
                            url = VirtualPathUtility.ToAbsolute(path, _applicationRootPath);
                        }
                    }
                    else
                    {
                        // must be a full uri or already rooted.
                        url = path;
                    }
                    if (htmlEncoded)
                    {
                        url = HttpUtility.HtmlEncode(url);
                    }
                }
                else
                {
                    string       urlAssemblyName;
                    Pair         assemblyInfo    = GetAssemblyInfo(effectiveAssembly);
                    AssemblyName assemblyName    = (AssemblyName)assemblyInfo.First;
                    long         assemblyDate    = (long)assemblyInfo.Second;
                    string       assemblyVersion = assemblyName.Version.ToString();

                    if (effectiveAssembly.GlobalAssemblyCache)
                    {
                        // If the assembly is in the GAC, we need to store a full name to load the assembly later
                        if (effectiveAssembly == HttpContext.SystemWebAssembly)
                        {
                            urlAssemblyName = "s";
                        }
                        else
                        {
                            // Pack the necessary values into a more compact format than FullName
                            StringBuilder builder = new StringBuilder();
                            builder.Append('f');
                            builder.Append(assemblyName.Name);
                            builder.Append(',');
                            builder.Append(assemblyVersion);
                            builder.Append(',');
                            if (assemblyName.CultureInfo != null)
                            {
                                builder.Append(assemblyName.CultureInfo.ToString());
                            }
                            builder.Append(',');
                            byte[] token = assemblyName.GetPublicKeyToken();
                            for (int i = 0; i < token.Length; i++)
                            {
                                builder.Append(token[i].ToString("x2", CultureInfo.InvariantCulture));
                            }
                            urlAssemblyName = builder.ToString();
                        }
                    }
                    else
                    {
                        // Otherwise, we can just use a partial name
                        urlAssemblyName = "p" + assemblyName.Name;
                    }
                    url = FormatWebResourceUrl(urlAssemblyName, effectiveResourceName, assemblyDate, htmlEncoded);
                    if (!forSubstitution && (HttpRuntime.AppDomainAppVirtualPathString != null))
                    {
                        // When this url is being inserted as a substitution in another resource,
                        // it should just be "WebResource.axd?d=..." since the resource is already coming
                        // from the app root (i.e. no need for a full absolute /app/WebResource.axd).
                        url = UrlPath.Combine(HttpRuntime.AppDomainAppVirtualPathString, url);
                    }
                }
                _urlCache[urlCacheKey] = url;
            }
            return(url);
        }
Exemplo n.º 10
0
 public void StripPrefix_ReturnsCorrectValue(string urlPath, string baseUrlPath, string expectedResult)
 => Assert.AreEqual(expectedResult, UrlPath.StripPrefix(urlPath, baseUrlPath));
Exemplo n.º 11
0
 public void Split_OnNullUrlPath_ThrowsArgumentNullException()
 => Assert.Throws <ArgumentNullException>(() => UrlPath.Split(null));
Exemplo n.º 12
0
 public void StripPrefix_OnInvalidParameter_ThrowsArgumentException(string urlPath, string baseUrlPath)
 => Assert.Throws <ArgumentException>(() => UrlPath.StripPrefix(urlPath, baseUrlPath));
Exemplo n.º 13
0
 public void HasPrefix_OnEmptyParameter_ThrowsArgumentException(string urlPath, string baseUrlPath)
 => Assert.Throws <ArgumentException>(() => UrlPath.HasPrefix(urlPath, baseUrlPath));
Exemplo n.º 14
0
 public void Normalize_ReturnsCorrectValue(string urlPath, bool isBasePath, string expectedResult)
 => Assert.AreEqual(expectedResult, UrlPath.Normalize(urlPath, isBasePath));
Exemplo n.º 15
0
 private static string FileUploadUrl(string fileId, NameValueCollection values)
 {
     return(Uri.UriBuilder(Url.UPLOAD, UrlPath.Create(Path.File).Append(fileId).ToString(),
                           values));
 }
Exemplo n.º 16
0
 /// <devdoc>
 /// Validates that the WebResource.axd handler is registered in config and actually
 /// points to the correct handler type.
 /// </devdoc>
 private static void EnsureHandlerExistenceChecked()
 {
     // First we have to check that the handler is registered:
     // <add path="WebResource.axd" verb="GET" type="System.Web.Handlers.AssemblyResourceLoader" validate="True" />
     if (!_handlerExistenceChecked)
     {
         HttpContext       context           = HttpContext.Current;
         IIS7WorkerRequest iis7WorkerRequest = (context != null) ? context.WorkerRequest as IIS7WorkerRequest : null;
         string            webResourcePath   = UrlPath.Combine(HttpRuntime.AppDomainAppVirtualPathString, _webResourceUrl);
         if (iis7WorkerRequest != null)
         {
             // check the IIS <handlers> section by mapping the handler
             string handlerTypeString = iis7WorkerRequest.MapHandlerAndGetHandlerTypeString(method: "GET",
                                                                                            path: UrlPath.Combine(HttpRuntime.AppDomainAppVirtualPathString, _webResourceUrl),
                                                                                            convertNativeStaticFileModule: false, ignoreWildcardMappings: true);
             if (!String.IsNullOrEmpty(handlerTypeString))
             {
                 _handlerExists = (typeof(AssemblyResourceLoader) == BuildManager.GetType(handlerTypeString, true /*throwOnFail*/, false /*ignoreCase*/));
             }
         }
         else
         {
             // check the <httpHandlers> section
             HttpHandlerAction httpHandler = RuntimeConfig.GetConfig(VirtualPath.Create(webResourcePath)).HttpHandlers.FindMapping("GET", VirtualPath.Create(_webResourceUrl));
             _handlerExists = (httpHandler != null) && (httpHandler.TypeInternal == typeof(AssemblyResourceLoader));
         }
         _handlerExistenceChecked = true;
     }
 }
Exemplo n.º 17
0
        public void IsEqualOrSubDirectory_NullDir()
        {
            bool test = UrlPath.IsEqualOrSubdirectory(null, "Hello");

            Assert.Equal(true, test);
        }
        public void DynamicWidgetsDesignerListSettings_VerifyUsePagingFunctionality()
        {
            var dynamicCollection = ServerOperationsFeather.DynamicModulePressArticle().RetrieveCollectionOfPressArticles();

            this.pageOperations = new PagesOperations();
            string testName        = System.Reflection.MethodInfo.GetCurrentMethod().Name;
            string pageNamePrefix  = testName + "DynamicPage";
            string pageTitlePrefix = testName + "Dynamic Page";
            string urlNamePrefix   = testName + "dynamic-page";
            int    index           = 1;
            int    itemsPerPage    = 1;
            string index2          = "/2";
            string index3          = "/3";
            string url1            = UrlPath.ResolveAbsoluteUrl("~/" + urlNamePrefix + index);
            string url2            = UrlPath.ResolveAbsoluteUrl("~/" + urlNamePrefix + index + index2);
            string url3            = UrlPath.ResolveAbsoluteUrl("~/" + urlNamePrefix + index + index3);

            try
            {
                for (int i = 0; i < this.dynamicTitles.Length; i++)
                {
                    ServerOperationsFeather.DynamicModulePressArticle().CreatePressArticleItem(this.dynamicTitles[i], this.dynamicUrls[i]);
                }

                dynamicCollection = ServerOperationsFeather.DynamicModulePressArticle().RetrieveCollectionOfPressArticles();

                var mvcProxy = new MvcWidgetProxy();
                mvcProxy.ControllerName = typeof(DynamicContentController).FullName;
                var dynamicController = new DynamicContentController();
                dynamicController.Model.ContentType  = TypeResolutionService.ResolveType(ResolveType);
                dynamicController.Model.DisplayMode  = ListDisplayMode.Paging;
                dynamicController.Model.ItemsPerPage = itemsPerPage;
                mvcProxy.Settings   = new ControllerSettings(dynamicController);
                mvcProxy.WidgetName = WidgetName;

                this.pageOperations.CreatePageWithControl(mvcProxy, pageNamePrefix, pageTitlePrefix, urlNamePrefix, index);

                string responseContent1 = PageInvoker.ExecuteWebRequest(url1);
                string responseContent2 = PageInvoker.ExecuteWebRequest(url2);
                string responseContent3 = PageInvoker.ExecuteWebRequest(url3);

                for (int i = 0; i < this.dynamicTitles.Length; i++)
                {
                    switch (i)
                    {
                    case 0:
                        Assert.IsTrue(responseContent3.Contains(this.dynamicTitles[i]), "The dynamic item with this title was not found!");
                        Assert.IsFalse(responseContent3.Contains(this.dynamicTitles[i + 1]), "The dynamic item with this title was found!");
                        Assert.IsFalse(responseContent3.Contains(this.dynamicTitles[i + 2]), "The dynamic item with this title was found!");
                        break;

                    case 1:
                        Assert.IsTrue(responseContent2.Contains(this.dynamicTitles[i]), "The dynamic item with this title was not found!");
                        Assert.IsFalse(responseContent2.Contains(this.dynamicTitles[i + 1]), "The dynamic item with this title was found!");
                        Assert.IsFalse(responseContent2.Contains(this.dynamicTitles[i - 1]), "The dynamic item with this title was found!");
                        break;

                    case 2:
                        Assert.IsTrue(responseContent1.Contains(this.dynamicTitles[i]), "The dynamic item with this title was not found!");
                        Assert.IsFalse(responseContent1.Contains(this.dynamicTitles[i - 1]), "The dynamic item with this title was found!");
                        Assert.IsFalse(responseContent1.Contains(this.dynamicTitles[i - 2]), "The dynamic item with this title was found!");
                        break;
                    }
                }
            }
            finally
            {
                this.pageOperations.DeletePages();
                ServerOperationsFeather.DynamicModulePressArticle().DeleteDynamicItems(dynamicCollection);
            }
        }
Exemplo n.º 19
0
        public void IsEqualOrSubDirectory_NotEmptyDir_EmptySubDir()
        {
            bool test = UrlPath.IsEqualOrSubdirectory("Hello", "");

            Assert.False(test);
        }
Exemplo n.º 20
0
        public static VirtualPath Create(string virtualPath, VirtualPathOptions options)
        {
            // Trim it first, so that blank strings (e.g. "  ") get treated as empty
            if (virtualPath != null)
            {
                virtualPath = virtualPath.Trim();
            }

            // If it's empty, check whether we allow it
            if (String.IsNullOrEmpty(virtualPath))
            {
                if ((options & VirtualPathOptions.AllowNull) != 0)
                {
                    return(null);
                }

                throw new ArgumentNullException("virtualPath");
            }

            // Dev10 767308: optimize for normal paths, and scan once for
            //     i) invalid chars
            //    ii) slashes
            //   iii) '.'

            bool slashes = false;
            bool dot     = false;
            int  len     = virtualPath.Length;

            //todo check if i need this code
            //unsafe {
            //    fixed (char * p = virtualPath) {
            //        for (int i = 0; i < len; i++) {
            //            switch (p[i]) {
            //                // need to fix slashes ?
            //                case '/':
            //                    if (i > 0 && p[i-1] == '/')
            //                        slashes = true;
            //                    break;
            //                case '\\':
            //                    slashes = true;
            //                    break;
            //                // contains "." or ".."
            //                case '.':
            //                    dot = true;
            //                    break;
            //                // invalid chars
            //                case '\0':
            //                    throw new HttpException("SR.GetString(SR.Invalid_vpath, virtualPath)"); // todo
            //                default:
            //                    break;
            //            }
            //        }
            //    }
            //}

            if (slashes)
            {
                // If we're supposed to fail on malformed path, then throw
                if ((options & VirtualPathOptions.FailIfMalformed) != 0)
                {
                    throw new HttpException("SR.GetString(SR.Invalid_vpath, virtualPath)"); // todo
                }
                // Flip ----lashes, and remove duplicate slashes
                virtualPath = UrlPath.FixVirtualPathSlashes(virtualPath);
            }

            // Make sure it ends with a trailing slash if requested
            if ((options & VirtualPathOptions.EnsureTrailingSlash) != 0)
            {
                virtualPath = UrlPath.AppendSlashToPathIfNeeded(virtualPath);
            }

            VirtualPath virtualPathObject = new VirtualPath();

            if (UrlPath.IsAppRelativePath(virtualPath))
            {
                if (dot)
                {
                    virtualPath = UrlPath.ReduceVirtualPath(virtualPath);
                }

                if (virtualPath[0] == UrlPath.appRelativeCharacter)
                {
                    if ((options & VirtualPathOptions.AllowAppRelativePath) == 0)
                    {
                        throw new ArgumentException("SR.GetString(SR.VirtualPath_AllowAppRelativePath, virtualPath)"); // todo
                    }

                    virtualPathObject._appRelativeVirtualPath = virtualPath;
                }
                else
                {
                    // It's possible for the path to become absolute after calling Reduce,
                    // even though it started with "~/".  e.g. if the app is "/app" and the path is
                    // "~/../hello.aspx", it becomes "/hello.aspx", which is absolute

                    if ((options & VirtualPathOptions.AllowAbsolutePath) == 0)
                    {
                        throw new ArgumentException("SR.GetString(SR.VirtualPath_AllowAbsolutePath, virtualPath)"); // todo
                    }

                    virtualPathObject._virtualPath = virtualPath;
                }
            }
            else
            {
                if (virtualPath[0] != '/')
                {
                    if ((options & VirtualPathOptions.AllowRelativePath) == 0)
                    {
                        throw new ArgumentException("SR.GetString(SR.VirtualPath_AllowRelativePath, virtualPath)"); // todo
                    }

                    // Don't Reduce relative paths, since the Reduce method is broken (e.g. "../foo.aspx" --> "/foo.aspx!")
                    //
                    virtualPathObject._virtualPath = virtualPath;
                }
                else
                {
                    if ((options & VirtualPathOptions.AllowAbsolutePath) == 0)
                    {
                        throw new ArgumentException("SR.GetString(SR.VirtualPath_AllowAbsolutePath, virtualPath)"); // todo
                    }

                    if (dot)
                    {
                        virtualPath = UrlPath.ReduceVirtualPath(virtualPath);
                    }

                    virtualPathObject._virtualPath = virtualPath;
                }
            }
#if DBG
            virtualPathObject.ValidateState();
#endif
            return(virtualPathObject);
        }
        public void IsEqualOrSubDirectory_SubDirIsASubDirOfDir_NoTrailingBackslash()
        {
            bool test = UrlPath.IsEqualOrSubdirectory("C:\\Directory", "C:\\Directory\\SubDirectory");

            Assert.True(test);
        }
        internal FileAttributesData GetFileAttributes(string alias)
        {
            DirectoryMonitor   directoryMonitor = null;
            string             fullPath;
            string             file = null;
            FileAttributesData fad  = null;

            if (alias == null)
            {
                throw CreateFileMonitoringException(-2147024809, alias);
            }
            if (this.IsFCNDisabled)
            {
                if ((alias.Length == 0) || !UrlPath.IsAbsolutePhysicalPath(alias))
                {
                    throw CreateFileMonitoringException(-2147024809, alias);
                }
                fullPath = GetFullPath(alias);
                FindFileData data = null;
                if (FindFileData.FindFile(fullPath, out data) == 0)
                {
                    return(data.FileAttributesData);
                }
                return(null);
            }
            using (new ApplicationImpersonationContext())
            {
                this._lockDispose.AcquireReaderLock();
                try
                {
                    if (!this._disposed)
                    {
                        FileMonitor monitor = (FileMonitor)this._aliases[alias];
                        if ((monitor != null) && !monitor.IsDirectory)
                        {
                            directoryMonitor = monitor.DirectoryMonitor;
                            file             = monitor.FileNameLong;
                        }
                        else
                        {
                            if ((alias.Length == 0) || !UrlPath.IsAbsolutePhysicalPath(alias))
                            {
                                throw CreateFileMonitoringException(-2147024809, alias);
                            }
                            fullPath = GetFullPath(alias);
                            string directoryOrRootName = UrlPath.GetDirectoryOrRootName(fullPath);
                            file = Path.GetFileName(fullPath);
                            if ((file != null) || (file.Length > 0))
                            {
                                directoryMonitor = this.FindDirectoryMonitor(directoryOrRootName, false, false);
                            }
                        }
                    }
                }
                finally
                {
                    this._lockDispose.ReleaseReaderLock();
                }
                if ((directoryMonitor == null) || !directoryMonitor.GetFileAttributes(file, out fad))
                {
                    FileAttributesData.GetFileAttributes(alias, out fad);
                }
                return(fad);
            }
        }
        public void GetDirectoryOrRootName_Null()
        {
            string test = UrlPath.GetDirectoryOrRootName(null);

            Assert.Null(null);
        }
        internal DateTime StartMonitoringFile(string alias, FileChangeEventHandler callback)
        {
            string fullPath;
            bool   flag = false;

            if (alias == null)
            {
                throw CreateFileMonitoringException(-2147024809, alias);
            }
            if (this.IsFCNDisabled)
            {
                fullPath = GetFullPath(alias);
                FindFileData data = null;
                if (FindFileData.FindFile(fullPath, out data) == 0)
                {
                    return(data.FileAttributesData.UtcLastWriteTime);
                }
                return(DateTime.MinValue);
            }
            using (new ApplicationImpersonationContext())
            {
                FileMonitor        monitor;
                string             fileNameLong;
                FileAttributesData data2;
                this._lockDispose.AcquireReaderLock();
                try
                {
                    DirectoryMonitor directoryMonitor;
                    if (this._disposed)
                    {
                        return(DateTime.MinValue);
                    }
                    monitor = (FileMonitor)this._aliases[alias];
                    if (monitor != null)
                    {
                        directoryMonitor = monitor.DirectoryMonitor;
                        fileNameLong     = monitor.FileNameLong;
                    }
                    else
                    {
                        flag = true;
                        if ((alias.Length == 0) || !UrlPath.IsAbsolutePhysicalPath(alias))
                        {
                            throw CreateFileMonitoringException(-2147024809, alias);
                        }
                        fullPath = GetFullPath(alias);
                        if (this.IsBeneathAppPathInternal(fullPath))
                        {
                            directoryMonitor = this._dirMonAppPathInternal;
                            fileNameLong     = fullPath.Substring(this._appPathInternal.Length + 1);
                        }
                        else
                        {
                            string directoryOrRootName = UrlPath.GetDirectoryOrRootName(fullPath);
                            fileNameLong = Path.GetFileName(fullPath);
                            if (string.IsNullOrEmpty(fileNameLong))
                            {
                                throw CreateFileMonitoringException(-2147024809, alias);
                            }
                            directoryMonitor = this.FindDirectoryMonitor(directoryOrRootName, true, true);
                        }
                    }
                    monitor = directoryMonitor.StartMonitoringFileWithAssert(fileNameLong, callback, alias);
                    if (flag)
                    {
                        this._aliases[alias] = monitor;
                    }
                }
                finally
                {
                    this._lockDispose.ReleaseReaderLock();
                }
                monitor.DirectoryMonitor.GetFileAttributes(fileNameLong, out data2);
                if (data2 != null)
                {
                    return(data2.UtcLastWriteTime);
                }
                return(DateTime.MinValue);
            }
        }
        public void IsEqualOrSubDirectory_Equal_SecondHasBackslash()
        {
            bool test = UrlPath.IsEqualOrSubdirectory("C:\\Directory", "C:\\Directory\\");

            Assert.True(test);
        }
        internal DateTime StartMonitoringPath(string alias, FileChangeEventHandler callback, out FileAttributesData fad)
        {
            FileMonitor      monitor  = null;
            DirectoryMonitor monitor2 = null;
            string           fullPath;
            string           file = null;
            bool             flag = false;

            fad = null;
            if (alias == null)
            {
                throw new HttpException(System.Web.SR.GetString("Invalid_file_name_for_monitoring", new object[] { string.Empty }));
            }
            if (this.IsFCNDisabled)
            {
                fullPath = GetFullPath(alias);
                FindFileData data = null;
                if (FindFileData.FindFile(fullPath, out data) == 0)
                {
                    fad = data.FileAttributesData;
                    return(data.FileAttributesData.UtcLastWriteTime);
                }
                return(DateTime.MinValue);
            }
            using (new ApplicationImpersonationContext())
            {
                this._lockDispose.AcquireReaderLock();
                try
                {
                    if (this._disposed)
                    {
                        return(DateTime.MinValue);
                    }
                    monitor = (FileMonitor)this._aliases[alias];
                    if (monitor != null)
                    {
                        file    = monitor.FileNameLong;
                        monitor = monitor.DirectoryMonitor.StartMonitoringFileWithAssert(file, callback, alias);
                    }
                    else
                    {
                        flag = true;
                        if ((alias.Length == 0) || !UrlPath.IsAbsolutePhysicalPath(alias))
                        {
                            throw new HttpException(System.Web.SR.GetString("Invalid_file_name_for_monitoring", new object[] { HttpRuntime.GetSafePath(alias) }));
                        }
                        fullPath = GetFullPath(alias);
                        if (this.IsBeneathAppPathInternal(fullPath))
                        {
                            monitor2 = this._dirMonAppPathInternal;
                            file     = fullPath.Substring(this._appPathInternal.Length + 1);
                            monitor  = monitor2.StartMonitoringFileWithAssert(file, callback, alias);
                        }
                        else
                        {
                            monitor2 = this.FindDirectoryMonitor(fullPath, false, false);
                            if (monitor2 != null)
                            {
                                monitor = monitor2.StartMonitoringFileWithAssert(null, callback, alias);
                            }
                            else
                            {
                                string directoryOrRootName = UrlPath.GetDirectoryOrRootName(fullPath);
                                file = Path.GetFileName(fullPath);
                                if (!string.IsNullOrEmpty(file))
                                {
                                    monitor2 = this.FindDirectoryMonitor(directoryOrRootName, false, false);
                                    if (monitor2 != null)
                                    {
                                        try
                                        {
                                            monitor = monitor2.StartMonitoringFileWithAssert(file, callback, alias);
                                        }
                                        catch
                                        {
                                        }
                                        if (monitor != null)
                                        {
                                            goto Label_01C7;
                                        }
                                    }
                                }
                                monitor2 = this.FindDirectoryMonitor(fullPath, true, false);
                                if (monitor2 != null)
                                {
                                    file = null;
                                }
                                else
                                {
                                    if (string.IsNullOrEmpty(file))
                                    {
                                        throw CreateFileMonitoringException(-2147024809, alias);
                                    }
                                    monitor2 = this.FindDirectoryMonitor(directoryOrRootName, true, true);
                                }
                                monitor = monitor2.StartMonitoringFileWithAssert(file, callback, alias);
                            }
                        }
                    }
Label_01C7:
                    if (!monitor.IsDirectory)
                    {
                        monitor.DirectoryMonitor.GetFileAttributes(file, out fad);
                    }
                    if (flag)
                    {
                        this._aliases[alias] = monitor;
                    }
                }
                finally
                {
                    this._lockDispose.ReleaseReaderLock();
                }
                if (fad != null)
                {
                    return(fad.UtcLastWriteTime);
                }
                return(DateTime.MinValue);
            }
        }
        public void GetDirectoryOrRootName_NotDirectoryOrRoot()
        {
            string test = UrlPath.GetDirectoryOrRootName("Hello");

            Assert.Equal("", test);
        }
Exemplo n.º 28
0
 private static string FileQueryUrl(string fileId, NameValueCollection values = null)
 {
     return(Uri.UriBuilder(Url.DRIVE, UrlPath.Create(Path.File).Append(fileId).ToString(),
                           values));
 }
        public void IsEqualOrSubDirectory_NullDirAndSubDir()
        {
            bool test = UrlPath.IsEqualOrSubdirectory(null, null);

            Assert.True(test);
        }
Exemplo n.º 30
0
 public void Normalize_OnEmptyUrlPath_ThrowsArgumentException(bool isBasePath)
 => Assert.Throws <ArgumentException>(() => UrlPath.Normalize(string.Empty, isBasePath));