Imported Upstream version 4.6.0.125

Former-commit-id: a2155e9bd80020e49e72e86c44da02a8ac0e57a4

mcs/class/referencesource/System.Web.Mobile/Mobile/UrlPath.cs

@@ -0,0 +1,263 @@
+//------------------------------------------------------------------------------
+// <copyright file="UrlPath.cs" company="Microsoft">
+//     Copyright (c) Microsoft Corporation.  All rights reserved.
+// </copyright>                                                                
+//------------------------------------------------------------------------------
+
+/*
+ * UrlPath class.
+ * 
+ * Copyright (c) 1999 Microsoft Corporation
+ */
+
+using System.Text;
+using System.Runtime.Serialization.Formatters;
+using System.Runtime.InteropServices;
+using System.Collections;
+using System.Diagnostics;
+
+namespace System.Web.Mobile
+{
+    /*
+     * URL Path library.
+     */
+    [Obsolete("The System.Web.Mobile.dll assembly has been deprecated and should no longer be used. For information about how to develop ASP.NET mobile applications, see http://go.microsoft.com/fwlink/?LinkId=157231.")]
+    internal static class UrlPath
+    {
+        private const char appRelativeCharacter = '~';
+
+        internal static bool IsRooted(String basepath)
+        {
+            return(basepath == null || basepath.Length == 0 || basepath[0] == '/' || basepath[0] == '\\');
+        }
+
+        internal static bool IsRelativeUrl(string url)
+        {
+            // If it has a protocol, it's not relative
+            if (url.IndexOf(":", StringComparison.Ordinal) != -1)
+            {
+                return false;
+            }
+
+            return !IsRooted(url);
+        }
+
+        internal static String GetDirectory(String path)
+        {
+            if (path == null || path.Length == 0)
+            {
+                throw new ArgumentException(SR.GetString(SR.UrlPath_EmptyPathHasNoDirectory));
+            }
+
+            if (path[0] != '/' && path[0] != appRelativeCharacter)
+            {
+                throw new ArgumentException(SR.GetString(SR.UrlPath_PathMustBeRooted));
+            }
+
+            // 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;
+        }
+
+        private static void FailIfPhysicalPath(string path)
+        {
+            if (path == null || path.Length < 4)
+            {
+                return;
+            }
+
+            if (path[1] == ':' || (path[0] == '\\' && path[1] == '\\'))
+            {
+                throw new Exception(SR.GetString(SR.UrlPath_PhysicalPathNotAllowed, path));
+            }
+        }
+
+        internal static String Combine(String basepath, String relative)
+        {
+            String path;
+
+            // Make sure the relative path is not a physical path (bug 73641)
+            FailIfPhysicalPath(relative);
+
+            if (IsRooted(relative))
+            {
+                path = relative;
+                if (path == null || path.Length == 0)
+                {
+                    return String.Empty;
+                }
+            }
+            else
+            {
+                // If the relative path starts with "~/" or "~\", treat it as app root
+                // relative (bug 68628)
+                if (relative.Length >=3 && relative[0] == appRelativeCharacter && (relative[1] == '/' || relative[1] == '\\'))
+                {
+                    String appPath = HttpRuntime.AppDomainAppVirtualPath;
+                    if (appPath.Length > 1)
+                    {
+                        path = appPath + "/" + relative.Substring(2);
+                    }
+                    else
+                    {
+                        path = "/" + relative.Substring(2);
+                    }
+                }
+                else
+                {
+                    if (basepath == null || (basepath.Length == 1 && basepath[0] == '/'))
+                    {
+                        basepath = String.Empty;
+                    }
+
+                    path = basepath + "/" + relative;
+                }
+            }
+
+            return Reduce(path);
+        }
+
+        internal static String Reduce(String path)
+        {
+            // ignore query string
+            String queryString = null;
+            if (path != null)
+            {
+                int iqs = path.IndexOf('?');
+                if (iqs >= 0)
+                {
+                    queryString = path.Substring(iqs);
+                    path = path.Substring(0, iqs);
+                }
+            }
+
+            int length = path.Length;
+            int examine;
+
+            // Make sure we don't have any back slashes
+            path = path.Replace('\\', '/');
+
+            // quickly rule out situations in which there are no . or ..
+
+            for (examine = 0; ; examine++)
+            {
+                examine = path.IndexOf('.', examine);
+                if (examine < 0)
+                {
+                    return (queryString != null) ? (path + queryString) : path;
+                }
+
+                if ((examine == 0 || path[examine - 1] == '/')
+                    && (examine + 1 == length || path[examine + 1] == '/' ||
+                        (path[examine + 1] == '.' && (examine + 2 == length || path[examine + 2] == '/'))))
+                {
+                    break;
+                }
+            }
+
+            // OK, we found a . or .. so process it:
+
+            ArrayList list = new ArrayList();
+            StringBuilder sb = new StringBuilder();
+            int start;
+            examine = 0;
+
+            for (;;)
+            {
+                start = examine;
+                examine = path.IndexOf('/', start + 1);
+
+                if (examine < 0)
+                {
+                    examine = length;
+                }
+
+                if (examine - start <= 3 &&
+                    (examine < 1 || path[examine - 1] == '.') &&
+                    (start + 1 >= length || path[start + 1] == '.'))
+                {
+                    if (examine - start == 3)
+                    {
+                        if (list.Count == 0)
+                        {
+                            throw new Exception(SR.GetString(SR.UrlPath_CannotExitUpTopDirectory));
+                        }
+
+                        sb.Length = (int)list[list.Count - 1];
+                        list.RemoveRange(list.Count - 1, 1);
+                    }
+                }
+                else
+                {
+                    list.Add(sb.Length);
+
+                    sb.Append(path, start, examine - start);
+                }
+
+                if (examine == length)
+                {
+                    break;
+                }
+            }
+
+            return sb.ToString() + queryString;
+        }
+
+        private const string dummyProtocolAndServer = "http://foo";
+
+        // Return the relative vpath path from one rooted vpath to another
+        internal static string MakeRelative(string from, string to)
+        {
+            // If either path is app relative (~/...), make it absolute, since the Uri
+            // class wouldn't know how to deal with it.
+            from = MakeVirtualPathAppAbsolute(from);
+            to = MakeVirtualPathAppAbsolute(to);
+
+            // Make sure both virtual paths are rooted
+            Debug.Assert(IsRooted(from));
+            Debug.Assert(IsRooted(to));
+
+            // Uri's need full url's so, we use a dummy root
+            Uri fromUri = new Uri(dummyProtocolAndServer + from);
+            Uri toUri = new Uri(dummyProtocolAndServer + to);
+            return fromUri.MakeRelative(toUri);
+        }
+
+        // If a virtual path is app relative (i.e. starts with ~/), change it to
+        // start with the actuall app path.
+        // E.g. ~/Sub/foo.aspx --> /MyApp/Sub/foo.aspx
+        internal static string MakeVirtualPathAppAbsolute(string virtualPath) {
+
+            // If the path is exactly "~", just return the app root path
+            if (virtualPath.Length == 1 && virtualPath[0] == appRelativeCharacter)
+                return HttpRuntime.AppDomainAppVirtualPath;
+
+            // If the virtual path starts with "~/" or "~\", replace with the app path
+            // relative (ASURT 68628)
+            if (virtualPath.Length >=2 && virtualPath[0] == appRelativeCharacter &&
+                (virtualPath[1] == '/' || virtualPath[1] == '\\')) {
+
+                string appPath = HttpRuntime.AppDomainAppVirtualPath;
+
+                if (appPath.Length > 1)
+                    return appPath + "/" + virtualPath.Substring(2);
+                else
+                    return "/" + virtualPath.Substring(2);
+            }
+
+            // Return it unchanged
+            return virtualPath;
+        }
+    }
+}
+
+