[pathlib] Prevent Path.copy() from processing special files

Previously, `pathlib.Path.copy()` would indiscriminately attempt to open and read from the source path if it wasn't a directory or symlink. This caused severe issues with special files:
1. Blocking indefinitely when reading from a FIFO (named pipe).
2. Entering an infinite loop when reading from zero-generators like `/dev/zero`.

This commit modifies the copy logic to explicitly verify that the source is a regular file using `is_file()` before attempting to copy its content. If the source exists but is a special file, `io.UnsupportedOperation` is now raised. This change aligns `pathlib`'s behavior with safety expectations and prevents resource exhaustion or hanging processes.

Existing behavior for dangling symlinks (raising FileNotFoundError) is preserved.

Tests added:
- `test_copy_fifo`: Ensures copying a FIFO raises UnsupportedOperation.
- `test_copy_char_device`: Ensures copying a character device (e.g. /dev/null) raises UnsupportedOperation.

Author: tonghuaroot

Lib/pathlib/__init__.py

@@ -1328,8 +1328,13 @@ def _copy_from(self, source, follow_symlinks=True, preserve_metadata=False):
                     child, follow_symlinks, preserve_metadata)
             if preserve_metadata:
                 _copy_info(source.info, self)
-        else:
+        elif source.info.is_file():
+            self._copy_from_file(source, preserve_metadata)
+        elif not source.info.exists(follow_symlinks=follow_symlinks):
             self._copy_from_file(source, preserve_metadata)
+        else:
+            raise io.UnsupportedOperation(
+                f"{source!r} is a special file and cannot be copied")
 
     def _copy_from_file(self, source, preserve_metadata=False):
         ensure_different_files(source, self)

Lib/test/test_pathlib/test_copy.py

@@ -169,6 +169,36 @@ class LocalToLocalPathCopyTest(CopyTestBase, unittest.TestCase):
         source_ground = LocalPathGround(Path)
         target_ground = LocalPathGround(Path)
 
+        def test_copy_fifo(self):
+            import io
+            import os
+            if not hasattr(os, 'mkfifo'):
+                self.skipTest('os.mkfifo() required')
+            
+            source = self.source_root / 'test.fifo'
+            try:
+                os.mkfifo(source)
+            except OSError:
+                self.skipTest("cannot create fifo")
+                
+            target = self.target_root / 'copy_fifo'
+            with self.assertRaises(io.UnsupportedOperation): 
+                source.copy(target)
+
+        def test_copy_char_device(self):
+            import io
+            import os
+            # /dev/null is a character device on POSIX
+            source = Path('/dev/null')
+            if not source.exists() or not source.is_char_device():
+                self.skipTest('/dev/null required')
+            
+            target = self.target_root / 'copy_null'
+            # This should fail immediately with UnsupportedOperation
+            # If it were buggy, it might loop infinitely or copy empty file depending on implementation
+            with self.assertRaises(io.UnsupportedOperation):
+                source.copy(target)
+
 
 if __name__ == "__main__":
     unittest.main()