gh-96290: support partial/invalid UNC drives in normpath() and splitdrive()

This brings the Python implementation of `ntpath.normpath()` in line with
the C implementation added in 99fcf15

Co-authored-by: Eryk Sun <eryksun@gmail.com>

Author: barneygale

Lib/ntpath.py

@@ -87,16 +87,20 @@ def normcase(s):
 def isabs(s):
     """Test whether a path is absolute"""
     s = os.fspath(s)
-    # Paths beginning with \\?\ are always absolute, but do not
-    # necessarily contain a drive.
     if isinstance(s, bytes):
-        if s.replace(b'/', b'\\').startswith(b'\\\\?\\'):
-            return True
+        sep = b'\\'
+        altsep = b'/'
+        colon_sep = b':\\'
     else:
-        if s.replace('/', '\\').startswith('\\\\?\\'):
-            return True
-    s = splitdrive(s)[1]
-    return len(s) > 0 and s[0] and s[0] in _get_bothseps(s)
+        sep = '\\'
+        altsep = '/'
+        colon_sep = ':\\'
+    s = s[:3].replace(altsep, sep)
+    # Absolute: UNC, device, and paths with a drive and root.
+    # LEGACY BUG: isabs("/x") should be false since the path has no drive.
+    if s.startswith(sep) or s.startswith(colon_sep, 1):
+        return True
+    return False
 
 
 # Join two (or more) paths.
@@ -167,40 +171,31 @@ def splitdrive(p):
 
     """
     p = os.fspath(p)
-    if len(p) >= 2:
-        if isinstance(p, bytes):
-            sep = b'\\'
-            altsep = b'/'
-            colon = b':'
-            unc_prefix = b'\\\\?\\UNC'
-        else:
-            sep = '\\'
-            altsep = '/'
-            colon = ':'
-            unc_prefix = '\\\\?\\UNC'
-        normp = p.replace(altsep, sep)
-        if (normp[0:2] == sep*2) and (normp[2:3] != sep):
-            # is a UNC path:
-            # vvvvvvvvvvvvvvvvvvvv drive letter or UNC path
-            # \\machine\mountpoint\directory\etc\...
-            #           directory ^^^^^^^^^^^^^^^
-            if normp[:8].upper().rstrip(sep) == unc_prefix:
-                start = 8
-            else:
-                start = 2
-            index = normp.find(sep, start)
-            if index == -1:
-                return p[:0], p
-            index2 = normp.find(sep, index + 1)
-            # a UNC path can't have two slashes in a row
-            # (after the initial two)
-            if index2 == index + 1:
-                return p[:0], p
-            if index2 == -1:
-                index2 = len(p)
-            return p[:index2], p[index2:]
-        if normp[1:2] == colon:
-            return p[:2], p[2:]
+    if isinstance(p, bytes):
+        sep = b'\\'
+        altsep = b'/'
+        colon = b':'
+        unc_prefix = b'\\\\?\\UNC\\'
+    else:
+        sep = '\\'
+        altsep = '/'
+        colon = ':'
+        unc_prefix = '\\\\?\\UNC\\'
+    normp = p.replace(altsep, sep)
+    if normp[1:2] == colon and normp[:1] != sep:
+        # Drive-letter logical drives, e.g. X:
+        return p[:2], p[2:]
+    if normp[:2] == sep * 2:
+        # UNC drives, e.g. \\server\share or \\?\UNC\server\share
+        # Device drives, e.g. \\.\device or \\?\device
+        start = 8 if normp[:8].upper() == unc_prefix else 2
+        index = normp.find(sep, start)
+        if index == -1:
+            return p, p[:0]
+        index = normp.find(sep, index + 1)
+        if index == -1:
+            return p, p[:0]
+        return p[:index], p[index:]
     return p[:0], p
 
 
@@ -523,20 +518,11 @@ def normpath(path):
             altsep = b'/'
             curdir = b'.'
             pardir = b'..'
-            special_prefixes = (b'\\\\.\\', b'\\\\?\\')
         else:
             sep = '\\'
             altsep = '/'
             curdir = '.'
             pardir = '..'
-            special_prefixes = ('\\\\.\\', '\\\\?\\')
-        if path.startswith(special_prefixes):
-            # in the case of paths with these prefixes:
-            # \\.\ -> device names
-            # \\?\ -> literal paths
-            # do not do any normalization, but return the path
-            # unchanged apart from the call to os.fspath()
-            return path
         path = path.replace(altsep, sep)
         prefix, path = splitdrive(path)
 

Lib/test/test_ntpath.py

@@ -107,22 +107,22 @@ def test_splitdrive(self):
         tester('ntpath.splitdrive("//conky/mountpoint/foo/bar")',
                ('//conky/mountpoint', '/foo/bar'))
         tester('ntpath.splitdrive("\\\\\\conky\\mountpoint\\foo\\bar")',
-            ('', '\\\\\\conky\\mountpoint\\foo\\bar'))
+            ('\\\\\\conky', '\\mountpoint\\foo\\bar'))
         tester('ntpath.splitdrive("///conky/mountpoint/foo/bar")',
-            ('', '///conky/mountpoint/foo/bar'))
+            ('///conky', '/mountpoint/foo/bar'))
         tester('ntpath.splitdrive("\\\\conky\\\\mountpoint\\foo\\bar")',
-               ('', '\\\\conky\\\\mountpoint\\foo\\bar'))
+               ('\\\\conky\\', '\\mountpoint\\foo\\bar'))
         tester('ntpath.splitdrive("//conky//mountpoint/foo/bar")',
-               ('', '//conky//mountpoint/foo/bar'))
+               ('//conky/', '/mountpoint/foo/bar'))
         # Issue #19911: UNC part containing U+0130
         self.assertEqual(ntpath.splitdrive('//conky/MOUNTPOİNT/foo/bar'),
                          ('//conky/MOUNTPOİNT', '/foo/bar'))
         # gh-81790: support device namespace, including UNC drives.
         tester('ntpath.splitdrive("//?/c:")', ("//?/c:", ""))
         tester('ntpath.splitdrive("//?/c:/")', ("//?/c:", "/"))
         tester('ntpath.splitdrive("//?/c:/dir")', ("//?/c:", "/dir"))
-        tester('ntpath.splitdrive("//?/UNC")', ("", "//?/UNC"))
-        tester('ntpath.splitdrive("//?/UNC/")', ("", "//?/UNC/"))
+        tester('ntpath.splitdrive("//?/UNC")', ("//?/UNC", ""))
+        tester('ntpath.splitdrive("//?/UNC/")', ("//?/UNC/", ""))
         tester('ntpath.splitdrive("//?/UNC/server/")', ("//?/UNC/server/", ""))
         tester('ntpath.splitdrive("//?/UNC/server/share")', ("//?/UNC/server/share", ""))
         tester('ntpath.splitdrive("//?/UNC/server/share/dir")', ("//?/UNC/server/share", "/dir"))
@@ -133,8 +133,8 @@ def test_splitdrive(self):
         tester('ntpath.splitdrive("\\\\?\\c:")', ("\\\\?\\c:", ""))
         tester('ntpath.splitdrive("\\\\?\\c:\\")', ("\\\\?\\c:", "\\"))
         tester('ntpath.splitdrive("\\\\?\\c:\\dir")', ("\\\\?\\c:", "\\dir"))
-        tester('ntpath.splitdrive("\\\\?\\UNC")', ("", "\\\\?\\UNC"))
-        tester('ntpath.splitdrive("\\\\?\\UNC\\")', ("", "\\\\?\\UNC\\"))
+        tester('ntpath.splitdrive("\\\\?\\UNC")', ("\\\\?\\UNC", ""))
+        tester('ntpath.splitdrive("\\\\?\\UNC\\")', ("\\\\?\\UNC\\", ""))
         tester('ntpath.splitdrive("\\\\?\\UNC\\server\\")', ("\\\\?\\UNC\\server\\", ""))
         tester('ntpath.splitdrive("\\\\?\\UNC\\server\\share")', ("\\\\?\\UNC\\server\\share", ""))
         tester('ntpath.splitdrive("\\\\?\\UNC\\server\\share\\dir")',
@@ -143,6 +143,13 @@ def test_splitdrive(self):
                ('\\\\?\\VOLUME{00000000-0000-0000-0000-000000000000}', '\\spam'))
         tester('ntpath.splitdrive("\\\\?\\BootPartition\\")', ("\\\\?\\BootPartition", "\\"))
 
+        # gh-96290: support partial/invalid UNC drives
+        tester('ntpath.splitdrive("//")', ("//", ""))  # empty server & missing share
+        tester('ntpath.splitdrive("///")', ("///", ""))  # empty server & empty share
+        tester('ntpath.splitdrive("///y")', ("///y", ""))  # empty server & valid share
+        tester('ntpath.splitdrive("//x")', ("//x", ""))  # valid server & missing share
+        tester('ntpath.splitdrive("//x/")', ("//x/", ""))  # valid server & empty share
+
     def test_split(self):
         tester('ntpath.split("c:\\foo\\bar")', ('c:\\foo', 'bar'))
         tester('ntpath.split("\\\\conky\\mountpoint\\foo\\bar")',
@@ -270,6 +277,13 @@ def test_normpath(self):
         tester("ntpath.normpath('//server/share/../..')",  '\\\\server\\share\\')
         tester("ntpath.normpath('//server/share/../../')", '\\\\server\\share\\')
 
+        # gh-96290: don't normalize partial/invalid UNC drives
+        tester("ntpath.normpath('\\\\foo\\bar')", '\\\\foo\\bar')
+        tester("ntpath.normpath('\\\\foo\\\\')", '\\\\foo\\\\')
+        tester("ntpath.normpath('\\\\foo\\')", '\\\\foo\\')
+        tester("ntpath.normpath('\\\\foo')", '\\\\foo')
+        tester("ntpath.normpath('\\\\')", '\\\\')
+
     def test_realpath_curdir(self):
         expected = ntpath.normpath(os.getcwd())
         tester("ntpath.realpath('.')", expected)

Lib/test/test_pathlib.py

@@ -151,19 +151,16 @@ def test_splitroot(self):
         self.assertEqual(f('c:a\\b'), ('c:', '', 'a\\b'))
         self.assertEqual(f('c:\\a\\b'), ('c:', '\\', 'a\\b'))
         # Redundant slashes in the root are collapsed.
-        self.assertEqual(f('\\\\a'), ('', '\\', 'a'))
-        self.assertEqual(f('\\\\\\a/b'), ('', '\\', 'a/b'))
         self.assertEqual(f('c:\\\\a'), ('c:', '\\', 'a'))
         self.assertEqual(f('c:\\\\\\a/b'), ('c:', '\\', 'a/b'))
         # Valid UNC paths.
         self.assertEqual(f('\\\\a\\b'), ('\\\\a\\b', '\\', ''))
         self.assertEqual(f('\\\\a\\b\\'), ('\\\\a\\b', '\\', ''))
         self.assertEqual(f('\\\\a\\b\\c\\d'), ('\\\\a\\b', '\\', 'c\\d'))
-        # These are non-UNC paths (according to ntpath.py and test_ntpath).
-        # However, command.com says such paths are invalid, so it's
+        # Invalid or partial UNC paths. Per gh-96290, it's
         # difficult to know what the right semantics are.
-        self.assertEqual(f('\\\\\\a\\b'), ('', '\\', 'a\\b'))
-        self.assertEqual(f('\\\\a'), ('', '\\', 'a'))
+        self.assertEqual(f('\\\\\\a\\b'),  ('\\\\\\a', '\\', 'b'))
+        self.assertEqual(f('\\\\a'), ('\\\\a', '\\', ''))
 
 
 #
@@ -182,7 +179,7 @@ class _BasePurePathTest(object):
             ('', 'a', 'b'), ('a', '', 'b'), ('a', 'b', ''),
             ],
         '/b/c/d': [
-            ('a', '/b/c', 'd'), ('a', '///b//c', 'd/'),
+            ('a', '/b/c', 'd'),
             ('/a', '/b/c', 'd'),
             # Empty components get removed.
             ('/', 'b', '', 'c/d'), ('/', '', 'b/c/d'), ('', '/b/c/d'),

Lib/test/test_zipfile/test_core.py

@@ -1469,10 +1469,10 @@ def test_extract_hackers_arcnames_windows_only(self):
             (r'C:\foo\bar', 'foo/bar'),
             (r'//conky/mountpoint/foo/bar', 'foo/bar'),
             (r'\\conky\mountpoint\foo\bar', 'foo/bar'),
-            (r'///conky/mountpoint/foo/bar', 'conky/mountpoint/foo/bar'),
-            (r'\\\conky\mountpoint\foo\bar', 'conky/mountpoint/foo/bar'),
-            (r'//conky//mountpoint/foo/bar', 'conky/mountpoint/foo/bar'),
-            (r'\\conky\\mountpoint\foo\bar', 'conky/mountpoint/foo/bar'),
+            (r'///conky/mountpoint/foo/bar', 'mountpoint/foo/bar'),
+            (r'\\\conky\mountpoint\foo\bar', 'mountpoint/foo/bar'),
+            (r'//conky//mountpoint/foo/bar', 'mountpoint/foo/bar'),
+            (r'\\conky\\mountpoint\foo\bar', 'mountpoint/foo/bar'),
             (r'//?/C:/foo/bar', 'foo/bar'),
             (r'\\?\C:\foo\bar', 'foo/bar'),
             (r'C:/../C:/foo/bar', 'C_/foo/bar'),

Misc/NEWS.d/next/Library/2022-12-19-23-19-26.gh-issue-96290.qFjsi6.rst

@@ -0,0 +1,5 @@
+Fix handling of partial and invalid UNC drives in ``ntpath.splitdrive()``, and in
+``ntpath.normpath()`` on non-Windows systems. Paths such as '\\server' and '\\' are now considered
+by ``splitdrive()`` to contain only a drive, and consequently are not modified by ``normpath()`` on
+non-Windows systems. The behaviour of ``normpath()`` on Windows systems is unaffected, as native
+OS APIs are used. Patch by Eryk Sun, with contributions by Barney Gale.