osutil: implement pure version of recvfds() for PyPy

This is less portable than the C version, but PyPy can't load CPython
extensions. So for now, this will be used on PyPy.

I've tested it on Linux amd64 and Mac OS X.

mercurial/pure/osutil.py

@@ -1,173 +1,256 b''
 # osutil.py - pure Python version of osutil.c
 #
 #  Copyright 2009 Matt Mackall <[e-mail]> and others
 #
 # This software may be used and distributed according to the terms of the
 # GNU General Public License version 2 or any later version.
 
 from __future__ import absolute_import
 
+import ctypes
+import ctypes.util
 import os
+import socket
 import stat as statmod
+import sys
 
 def _mode_to_kind(mode):
     if statmod.S_ISREG(mode):
         return statmod.S_IFREG
     if statmod.S_ISDIR(mode):
         return statmod.S_IFDIR
     if statmod.S_ISLNK(mode):
         return statmod.S_IFLNK
     if statmod.S_ISBLK(mode):
         return statmod.S_IFBLK
     if statmod.S_ISCHR(mode):
         return statmod.S_IFCHR
     if statmod.S_ISFIFO(mode):
         return statmod.S_IFIFO
     if statmod.S_ISSOCK(mode):
         return statmod.S_IFSOCK
     return mode
 
 def listdir(path, stat=False, skip=None):
     '''listdir(path, stat=False) -> list_of_tuples
 
     Return a sorted list containing information about the entries
     in the directory.
 
     If stat is True, each element is a 3-tuple:
 
       (name, type, stat object)
 
     Otherwise, each element is a 2-tuple:
 
       (name, type)
     '''
     result = []
     prefix = path
     if not prefix.endswith(os.sep):
         prefix += os.sep
     names = os.listdir(path)
     names.sort()
     for fn in names:
         st = os.lstat(prefix + fn)
         if fn == skip and statmod.S_ISDIR(st.st_mode):
             return []
         if stat:
             result.append((fn, _mode_to_kind(st.st_mode), st))
         else:
             result.append((fn, _mode_to_kind(st.st_mode)))
     return result
 
 if os.name != 'nt':
     posixfile = open
+
+    _SCM_RIGHTS = 0x01
+    _socklen_t = ctypes.c_uint
+
+    if sys.platform == 'linux2':
+        # socket.h says "the type should be socklen_t but the definition of
+        # the kernel is incompatible with this."
+        _cmsg_len_t = ctypes.c_size_t
+        _msg_controllen_t = ctypes.c_size_t
+        _msg_iovlen_t = ctypes.c_size_t
 else:
-    import ctypes
+        _cmsg_len_t = _socklen_t
+        _msg_controllen_t = _socklen_t
+        _msg_iovlen_t = ctypes.c_int
+
+    class _iovec(ctypes.Structure):
+        _fields_ = [
+            ('iov_base', ctypes.c_void_p),
+            ('iov_len', ctypes.c_size_t),
+        ]
+
+    class _msghdr(ctypes.Structure):
+        _fields_ = [
+            ('msg_name', ctypes.c_void_p),
+            ('msg_namelen', _socklen_t),
+            ('msg_iov', ctypes.POINTER(_iovec)),
+            ('msg_iovlen', _msg_iovlen_t),
+            ('msg_control', ctypes.c_void_p),
+            ('msg_controllen', _msg_controllen_t),
+            ('msg_flags', ctypes.c_int),
+        ]
+
+    class _cmsghdr(ctypes.Structure):
+        _fields_ = [
+            ('cmsg_len', _cmsg_len_t),
+            ('cmsg_level', ctypes.c_int),
+            ('cmsg_type', ctypes.c_int),
+            ('cmsg_data', ctypes.c_ubyte * 0),
+        ]
+
+    _libc = ctypes.CDLL(ctypes.util.find_library('c'), use_errno=True)
+    _recvmsg = _libc.recvmsg
+    _recvmsg.restype = ctypes.c_ssize_t
+    _recvmsg.argtypes = (ctypes.c_int, ctypes.POINTER(_msghdr), ctypes.c_int)
+
+    def _CMSG_FIRSTHDR(msgh):
+        if msgh.msg_controllen < ctypes.sizeof(_cmsghdr):
+            return
+        cmsgptr = ctypes.cast(msgh.msg_control, ctypes.POINTER(_cmsghdr))
+        return cmsgptr.contents
+
+    # The pure version is less portable than the native version because the
+    # handling of socket ancillary data heavily depends on C preprocessor.
+    # Also, some length fields are wrongly typed in Linux kernel.
+    def recvfds(sockfd):
+        """receive list of file descriptors via socket"""
+        dummy = (ctypes.c_ubyte * 1)()
+        iov = _iovec(ctypes.cast(dummy, ctypes.c_void_p), ctypes.sizeof(dummy))
+        cbuf = ctypes.create_string_buffer(256)
+        msgh = _msghdr(None, 0,
+                       ctypes.pointer(iov), 1,
+                       ctypes.cast(cbuf, ctypes.c_void_p), ctypes.sizeof(cbuf),
+                       0)
+        r = _recvmsg(sockfd, ctypes.byref(msgh), 0)
+        if r < 0:
+            e = ctypes.get_errno()
+            raise OSError(e, os.strerror(e))
+        # assumes that the first cmsg has fds because it isn't easy to write
+        # portable CMSG_NXTHDR() with ctypes.
+        cmsg = _CMSG_FIRSTHDR(msgh)
+        if not cmsg:
+            return []
+        if (cmsg.cmsg_level != socket.SOL_SOCKET or
+            cmsg.cmsg_type != _SCM_RIGHTS):
+            return []
+        rfds = ctypes.cast(cmsg.cmsg_data, ctypes.POINTER(ctypes.c_int))
+        rfdscount = ((cmsg.cmsg_len - _cmsghdr.cmsg_data.offset) /
+                     ctypes.sizeof(ctypes.c_int))
+        return [rfds[i] for i in xrange(rfdscount)]
+
+else:
     import msvcrt
 
     _kernel32 = ctypes.windll.kernel32
 
     _DWORD = ctypes.c_ulong
     _LPCSTR = _LPSTR = ctypes.c_char_p
     _HANDLE = ctypes.c_void_p
 
     _INVALID_HANDLE_VALUE = _HANDLE(-1).value
 
     # CreateFile
     _FILE_SHARE_READ = 0x00000001
     _FILE_SHARE_WRITE = 0x00000002
     _FILE_SHARE_DELETE = 0x00000004
 
     _CREATE_ALWAYS = 2
     _OPEN_EXISTING = 3
     _OPEN_ALWAYS = 4
 
     _GENERIC_READ = 0x80000000
     _GENERIC_WRITE = 0x40000000
 
     _FILE_ATTRIBUTE_NORMAL = 0x80
 
     # open_osfhandle flags
     _O_RDONLY = 0x0000
     _O_RDWR = 0x0002
     _O_APPEND = 0x0008
 
     _O_TEXT = 0x4000
     _O_BINARY = 0x8000
 
     # types of parameters of C functions used (required by pypy)
 
     _kernel32.CreateFileA.argtypes = [_LPCSTR, _DWORD, _DWORD, ctypes.c_void_p,
         _DWORD, _DWORD, _HANDLE]
     _kernel32.CreateFileA.restype = _HANDLE
 
     def _raiseioerror(name):
         err = ctypes.WinError()
         raise IOError(err.errno, '%s: %s' % (name, err.strerror))
 
     class posixfile(object):
         '''a file object aiming for POSIX-like semantics
 
         CPython's open() returns a file that was opened *without* setting the
         _FILE_SHARE_DELETE flag, which causes rename and unlink to abort.
         This even happens if any hardlinked copy of the file is in open state.
         We set _FILE_SHARE_DELETE here, so files opened with posixfile can be
         renamed and deleted while they are held open.
         Note that if a file opened with posixfile is unlinked, the file
         remains but cannot be opened again or be recreated under the same name,
         until all reading processes have closed the file.'''
 
         def __init__(self, name, mode='r', bufsize=-1):
             if 'b' in mode:
                 flags = _O_BINARY
             else:
                 flags = _O_TEXT
 
             m0 = mode[0]
             if m0 == 'r' and '+' not in mode:
                 flags |= _O_RDONLY
                 access = _GENERIC_READ
             else:
                 # work around http://support.microsoft.com/kb/899149 and
                 # set _O_RDWR for 'w' and 'a', even if mode has no '+'
                 flags |= _O_RDWR
                 access = _GENERIC_READ | _GENERIC_WRITE
 
             if m0 == 'r':
                 creation = _OPEN_EXISTING
             elif m0 == 'w':
                 creation = _CREATE_ALWAYS
             elif m0 == 'a':
                 creation = _OPEN_ALWAYS
                 flags |= _O_APPEND
             else:
                 raise ValueError("invalid mode: %s" % mode)
 
             fh = _kernel32.CreateFileA(name, access,
                     _FILE_SHARE_READ | _FILE_SHARE_WRITE | _FILE_SHARE_DELETE,
                     None, creation, _FILE_ATTRIBUTE_NORMAL, None)
             if fh == _INVALID_HANDLE_VALUE:
                 _raiseioerror(name)
 
             fd = msvcrt.open_osfhandle(fh, flags)
             if fd == -1:
                 _kernel32.CloseHandle(fh)
                 _raiseioerror(name)
 
             f = os.fdopen(fd, mode, bufsize)
             # unfortunately, f.name is '<fdopen>' at this point -- so we store
             # the name on this wrapper. We cannot just assign to f.name,
             # because that attribute is read-only.
             object.__setattr__(self, 'name', name)
             object.__setattr__(self, '_file', f)
 
         def __iter__(self):
             return self._file
 
         def __getattr__(self, name):
             return getattr(self._file, name)
 
         def __setattr__(self, name, value):
             '''mimics the read-only attributes of Python file objects
             by raising 'TypeError: readonly attribute' if someone tries:
               f = posixfile('foo.txt')
               f.name = 'bla'  '''
             return self._file.__setattr__(name, value)