Synnefo » snf-ganeti

    (pid, uid, gid) = utils.GetSocketCredentials(request)

    logging.info("Accepted connection from pid=%s, uid=%s, gid=%s",

                 pid, uid, gid)

  def handle_error(self, request, client_address):

    logging.exception("Error while handling request")

import struct

import IN

# Structure definition for getsockopt(SOL_SOCKET, SO_PEERCRED, ...):

# struct ucred { pid_t pid; uid_t uid; gid_t gid; };

#

# The GNU C Library defines gid_t and uid_t to be "unsigned int" and

# pid_t to "int".

#

# IEEE Std 1003.1-2008:

# "nlink_t, uid_t, gid_t, and id_t shall be integer types"

# "blksize_t, pid_t, and ssize_t shall be signed integer types"

_STRUCT_UCRED = "iII"

_STRUCT_UCRED_SIZE = struct.calcsize(_STRUCT_UCRED)

def GetSocketCredentials(sock):

  """Returns the credentials of the foreign process connected to a socket.

  @param sock: Unix socket

  @rtype: tuple; (number, number, number)

  @return: The PID, UID and GID of the connected foreign process.

  """

  peercred = sock.getsockopt(socket.SOL_SOCKET, IN.SO_PEERCRED,

                             _STRUCT_UCRED_SIZE)

  return struct.unpack(_STRUCT_UCRED, peercred)

from ganeti import serializer

def _GetSocketCredentials(path):

  """Connect to a Unix socket and return remote credentials.

  """

  sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)

  try:

    sock.settimeout(10)

    sock.connect(path)

    return utils.GetSocketCredentials(sock)

  finally:

    sock.close()

class TestGetSocketCredentials(unittest.TestCase):

  def setUp(self):

    self.tmpdir = tempfile.mkdtemp()

    self.sockpath = utils.PathJoin(self.tmpdir, "sock")

    self.listener = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)

    self.listener.settimeout(10)

    self.listener.bind(self.sockpath)

    self.listener.listen(1)

  def tearDown(self):

    self.listener.shutdown(socket.SHUT_RDWR)

    self.listener.close()

    shutil.rmtree(self.tmpdir)

  def test(self):

    (c2pr, c2pw) = os.pipe()

    # Start child process

    child = os.fork()

    if child == 0:

      try:

        data = serializer.DumpJson(_GetSocketCredentials(self.sockpath))

        os.write(c2pw, data)

        os.close(c2pw)

        os._exit(0)

      finally:

        os._exit(1)

    os.close(c2pw)

    # Wait for one connection

    (conn, _) = self.listener.accept()

    conn.recv(1)

    conn.close()

    # Wait for result

    result = os.read(c2pr, 4096)

    os.close(c2pr)

    # Check child's exit code

    (_, status) = os.waitpid(child, 0)

    self.assertFalse(os.WIFSIGNALED(status))

    self.assertEqual(os.WEXITSTATUS(status), 0)

    # Check result

    (pid, uid, gid) = serializer.LoadJson(result)

    self.assertEqual(pid, os.getpid())

    self.assertEqual(uid, os.getuid())

    self.assertEqual(gid, os.getgid())