--- /dev/null
+
+# rpc.py - RFC1057/RFC1831
+#
+# Copyright (C) 2001 Cendio Systems AB (http://www.cendio.se)
+# All rights reserved.
+#
+# Copyright (c) 2001 Python Software Foundation.
+# All rights reserved.
+#
+# Copyright (c) 2000 BeOpen.com.
+# All rights reserved.
+#
+# Copyright (c) 1995-2001 Corporation for National Research Initiatives.
+# All rights reserved.
+#
+# Copyright (c) 1991-1995 Stichting Mathematisch Centrum.
+# All rights reserved.
+#
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; version 2 of the License.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+
+# XXX The UDP version of the protocol resends requests when it does
+# XXX not receive a timely reply -- use only for idempotent calls!
+
+# XXX There is no provision for call timeout on TCP connections
+
+__pychecker__ = 'no-callinit'
+
+import xdrlib
+import socket
+import os
+import time
+
+RPCVERSION = 2
+
+CALL = 0
+REPLY = 1
+
+AUTH_NULL = 0
+AUTH_UNIX = 1
+AUTH_SHORT = 2
+AUTH_DES = 3
+
+MSG_ACCEPTED = 0
+MSG_DENIED = 1
+
+SUCCESS = 0 # RPC executed successfully
+PROG_UNAVAIL = 1 # remote hasn't exported program
+PROG_MISMATCH = 2 # remote can't support version #
+PROC_UNAVAIL = 3 # program can't support procedure
+GARBAGE_ARGS = 4 # procedure can't decode params
+
+RPC_MISMATCH = 0 # RPC version number != 2
+AUTH_ERROR = 1 # remote can't authenticate caller
+
+AUTH_BADCRED = 1 # bad credentials (seal broken)
+AUTH_REJECTEDCRED = 2 # client must begin new session
+AUTH_BADVERF = 3 # bad verifier (seal broken)
+AUTH_REJECTEDVERF = 4 # verifier expired or replayed
+AUTH_TOOWEAK = 5 # rejected for security reasons
+
+# All RPC errors are subclasses of RPCException
+class RPCException(Exception):
+ def __str__(self):
+ return "RPCException"
+
+class BadRPCMsgType(RPCException):
+ def __init__(self, msg_type):
+ self.msg_type = msg_type
+
+ def __str__(self):
+ return "BadRPCMsgType %d" % self.msg_type
+
+class BadRPCVersion(RPCException):
+ def __init__(self, version):
+ self.version = version
+
+ def __str__(self):
+ return "BadRPCVersion %d" % self.version
+
+class RPCMsgDenied(RPCException):
+ # MSG_DENIED
+ def __init__(self, stat):
+ self.stat = stat
+
+ def __str__(self):
+ return "RPCMsgDenied %d" % self.stat
+
+class RPCMisMatch(RPCException):
+ # MSG_DENIED: RPC_MISMATCH
+ def __init__(self, low, high):
+ self.low = low
+ self.high = high
+
+ def __str__(self):
+ return "RPCMisMatch %d,%d" % (self.low, self.high)
+
+class RPCAuthError(RPCException):
+ # MSG_DENIED: AUTH_ERROR
+ def __init__(self, stat):
+ self.stat = stat
+
+ def __str__(self):
+ return "RPCAuthError %d" % self.stat
+
+class BadRPCReplyType(RPCException):
+ # Neither MSG_DENIED nor MSG_ACCEPTED
+ def __init__(self, msg_type):
+ self.msg_type = msg_type
+
+ def __str__(self):
+ return "BadRPCReplyType %d" % self.msg_type
+
+class RPCProgUnavail(RPCException):
+ # PROG_UNAVAIL
+ def __str__(self):
+ return "RPCProgUnavail"
+
+class RPCProgMismatch(RPCException):
+ # PROG_MISMATCH
+ def __init__(self, low, high):
+ self.low = low
+ self.high = high
+
+ def __str__(self):
+ return "RPCProgMismatch %d,%d" % (self.low, self.high)
+
+class RPCProcUnavail(RPCException):
+ # PROC_UNAVAIL
+ def __str__(self):
+ return "RPCProcUnavail"
+
+class RPCGarbageArgs(RPCException):
+ # GARBAGE_ARGS
+ def __str__(self):
+ return "RPCGarbageArgs"
+
+class RPCUnextractedData(RPCException):
+ # xdrlib raised exception because unextracted data remained
+ def __str__(self):
+ return "RPCUnextractedData"
+
+class RPCBadAcceptStats(RPCException):
+ # Unknown accept_stat
+ def __init__(self, stat):
+ self.stat = stat
+
+ def __str__(self):
+ return "RPCBadAcceptStats %d" % self.stat
+
+class XidMismatch(RPCException):
+ # Got wrong XID in reply, got "xid" instead of "expected"
+ def __init__(self, xid, expected):
+ self.xid = xid
+ self.expected = expected
+
+ def __str__(self):
+ return "XidMismatch %d,%d" % (self.xid, self.expected)
+
+class TimeoutError(RPCException):
+ pass
+
+class PortMapError(RPCException):
+ pass
+
+
+class Packer(xdrlib.Packer):
+
+ def pack_auth(self, auth):
+ flavor, stuff = auth
+ self.pack_enum(flavor)
+ self.pack_opaque(stuff)
+
+ def pack_auth_unix(self, stamp, machinename, uid, gid, gids):
+ self.pack_uint(stamp)
+ self.pack_string(machinename)
+ self.pack_uint(uid)
+ self.pack_uint(gid)
+ self.pack_uint(len(gids))
+ for i in gids:
+ self.pack_uint(i)
+
+ def pack_callheader(self, xid, prog, vers, proc, cred, verf):
+ self.pack_uint(xid)
+ self.pack_enum(CALL)
+ self.pack_uint(RPCVERSION)
+ self.pack_uint(prog)
+ self.pack_uint(vers)
+ self.pack_uint(proc)
+ self.pack_auth(cred)
+ self.pack_auth(verf)
+ # Caller must add procedure-specific part of call
+
+ def pack_replyheader(self, xid, verf):
+ self.pack_uint(xid)
+ self.pack_enum(REPLY)
+ self.pack_uint(MSG_ACCEPTED)
+ self.pack_auth(verf)
+ self.pack_enum(SUCCESS)
+ # Caller must add procedure-specific part of reply
+
+
+class Unpacker(xdrlib.Unpacker):
+
+ def unpack_auth(self):
+ flavor = self.unpack_enum()
+ stuff = self.unpack_opaque()
+ if flavor == AUTH_UNIX:
+ p = Unpacker(stuff)
+ stuff = p.unpack_auth_unix()
+ return (flavor, stuff)
+
+ def unpack_auth_unix(self):
+ stamp=self.unpack_uint()
+ machinename=self.unpack_string()
+ print "machinename: %s" % machinename
+ uid=self.unpack_uint()
+ gid=self.unpack_uint()
+ n_gids=self.unpack_uint()
+ gids = []
+ print "n_gids: %d" % n_gids
+ for i in range(n_gids):
+ gids.append(self.unpack_uint())
+ return stamp, machinename, uid, gid, gids
+
+
+ def unpack_callheader(self):
+ xid = self.unpack_uint()
+ msg_type = self.unpack_enum()
+ if msg_type <> CALL:
+ raise BadRPCMsgType(msg_type)
+ rpcvers = self.unpack_uint()
+ if rpcvers <> RPCVERSION:
+ raise BadRPCVersion(rpcvers)
+ prog = self.unpack_uint()
+ vers = self.unpack_uint()
+ proc = self.unpack_uint()
+ cred = self.unpack_auth()
+ verf = self.unpack_auth()
+ return xid, prog, vers, proc, cred, verf
+ # Caller must add procedure-specific part of call
+
+ def unpack_replyheader(self):
+ xid = self.unpack_uint()
+ msg_type = self.unpack_enum()
+ if msg_type <> REPLY:
+ raise BadRPCMsgType(msg_type)
+ stat = self.unpack_enum()
+ if stat == MSG_DENIED:
+ stat = self.unpack_enum()
+ if stat == RPC_MISMATCH:
+ low = self.unpack_uint()
+ high = self.unpack_uint()
+ raise RPCMisMatch(low, high)
+ if stat == AUTH_ERROR:
+ stat = self.unpack_uint()
+ raise RPCAuthError(stat)
+ raise RPCMsgDenied(stat)
+ if stat <> MSG_ACCEPTED:
+ raise BadRPCReplyType(stat)
+ verf = self.unpack_auth()
+ stat = self.unpack_enum()
+ if stat == PROG_UNAVAIL:
+ raise RPCProgUnavail()
+ if stat == PROG_MISMATCH:
+ low = self.unpack_uint()
+ high = self.unpack_uint()
+ raise RPCProgMismatch(low, high)
+ if stat == PROC_UNAVAIL:
+ raise RPCProcUnavail()
+ if stat == GARBAGE_ARGS:
+ raise RPCGarbageArgs()
+ if stat <> SUCCESS:
+ raise RPCBadAcceptStats(stat)
+ return xid, verf
+ # Caller must get procedure-specific part of reply
+
+
+# Subroutines to create opaque authentication objects
+
+def make_auth_null():
+ return ''
+
+def make_auth_unix(seed, host, uid, gid, groups):
+ p = Packer()
+ p.pack_auth_unix(seed, host, uid, gid, groups)
+ return p.get_buffer()
+
+def make_auth_unix_default():
+ try:
+ uid = os.getuid()
+ gid = os.getgid()
+ except AttributeError:
+ uid = gid = 0
+ return make_auth_unix(int(time.time()-unix_epoch()), \
+ socket.gethostname(), uid, gid, [])
+
+_unix_epoch = -1
+def unix_epoch():
+ """Very painful calculation of when the Unix Epoch is.
+
+ This is defined as the return value of time.time() on Jan 1st,
+ 1970, 00:00:00 GMT.
+
+ On a Unix system, this should always return 0.0. On a Mac, the
+ calculations are needed -- and hard because of integer overflow
+ and other limitations.
+
+ """
+ global _unix_epoch
+ if _unix_epoch >= 0: return _unix_epoch
+ now = time.time()
+ localt = time.localtime(now) # (y, m, d, hh, mm, ss, ..., ..., ...)
+ gmt = time.gmtime(now)
+ offset = time.mktime(localt) - time.mktime(gmt)
+ y, m, d, hh, mm, ss = 1970, 1, 1, 0, 0, 0
+ offset, ss = divmod(ss + offset, 60)
+ offset, mm = divmod(mm + offset, 60)
+ offset, hh = divmod(hh + offset, 24)
+ d = d + offset
+ _unix_epoch = time.mktime((y, m, d, hh, mm, ss, 0, 0, 0))
+ print "Unix epoch:", time.ctime(_unix_epoch)
+ return _unix_epoch
+
+
+# Common base class for clients
+
+class Client:
+
+ def __init__(self, host, prog, vers, port):
+ self.host = host
+ self.prog = prog
+ self.vers = vers
+ self.port = port
+ self.sock = None
+ self.makesocket() # Assigns to self.sock
+ self.bindsocket()
+ self.connsocket()
+ # Servers may do XID caching, so try to come up with something
+ # unique to start with. XIDs are 32 bits. Python integers are always
+ # at least 32 bits.
+ self.lastxid = int(long(time.time() * 1E6) & 0xfffffff)
+ self.addpackers()
+ self.cred = None
+ self.verf = None
+
+ def close(self):
+ self.sock.close()
+
+ def makesocket(self):
+ # This MUST be overridden
+ raise RuntimeError("makesocket not defined")
+
+ def connsocket(self):
+ # Override this if you don't want/need a connection
+ self.sock.connect((self.host, self.port))
+
+ def bindsocket(self):
+ # Override this to bind to a different port (e.g. reserved)
+ self.sock.bind(('', 0))
+
+ def addpackers(self):
+ # Override this to use derived classes from Packer/Unpacker
+ self.packer = Packer()
+ self.unpacker = Unpacker('')
+
+ def make_call(self, proc, args, pack_func, unpack_func):
+ # Don't normally override this (but see Broadcast)
+ if pack_func is None and args is not None:
+ raise TypeError("non-null args with null pack_func")
+ self.start_call(proc)
+ if pack_func:
+ pack_func(args)
+ self.do_call()
+ if unpack_func:
+ result = unpack_func()
+ else:
+ result = None
+ try:
+ self.unpacker.done()
+ except xdrlib.Error:
+ raise RPCUnextractedData()
+
+ return result
+
+ def start_call(self, proc):
+ # Don't override this
+ self.lastxid = xid = self.lastxid + 1
+ cred = self.mkcred()
+ verf = self.mkverf()
+ p = self.packer
+ p.reset()
+ p.pack_callheader(xid, self.prog, self.vers, proc, cred, verf)
+
+ def do_call(self):
+ # This MUST be overridden
+ raise RuntimeError("do_call not defined")
+
+ def mkcred(self):
+ # Override this to use more powerful credentials
+ if self.cred == None:
+ self.cred = (AUTH_NULL, make_auth_null())
+ return self.cred
+
+ def mkverf(self):
+ # Override this to use a more powerful verifier
+ if self.verf == None:
+ self.verf = (AUTH_NULL, make_auth_null())
+ return self.verf
+
+ def call_0(self): # Procedure 0 is always like this
+ return self.make_call(0, None, None, None)
+
+
+# Record-Marking standard support
+
+def sendfrag(sock, last, frag):
+ x = len(frag)
+ if last: x = x | 0x80000000L
+ header = (chr(int(x>>24 & 0xff)) + chr(int(x>>16 & 0xff)) + \
+ chr(int(x>>8 & 0xff)) + chr(int(x & 0xff)))
+ sock.send(header + frag)
+
+def sendrecord(sock, record):
+ sendfrag(sock, 1, record)
+
+def recvfrag(sock):
+ header = sock.recv(4)
+ if len(header) < 4:
+ raise EOFError
+ x = long(ord(header[0]))<<24 | ord(header[1])<<16 | \
+ ord(header[2])<<8 | ord(header[3])
+ last = ((x & 0x80000000) != 0)
+ n = int(x & 0x7fffffff)
+ frag = ''
+ while n > 0:
+ buf = sock.recv(n)
+ if not buf: raise EOFError
+ n = n - len(buf)
+ frag = frag + buf
+ return last, frag
+
+def recvrecord(sock):
+ record = ''
+ last = 0
+ while not last:
+ last, frag = recvfrag(sock)
+ record = record + frag
+ return record
+
+
+# Try to bind to a reserved port (must be root)
+
+last_resv_port_tried = None
+def bindresvport(sock, host):
+ global last_resv_port_tried
+ FIRST, LAST = 600, 1024 # Range of ports to try
+ if last_resv_port_tried == None:
+ last_resv_port_tried = FIRST + os.getpid() % (LAST-FIRST)
+ for i in range(last_resv_port_tried, LAST) + \
+ range(FIRST, last_resv_port_tried):
+ last_resv_port_tried = i
+ try:
+ sock.bind((host, i))
+ return last_resv_port_tried
+ except socket.error, (errno, msg):
+ if errno <> 114:
+ raise socket.error(errno, msg)
+ raise RuntimeError("can't assign reserved port")
+
+
+# Client using TCP to a specific port
+
+class RawTCPClient(Client):
+
+ def makesocket(self):
+ self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+
+ def do_call(self):
+ call = self.packer.get_buffer()
+ sendrecord(self.sock, call)
+ reply = recvrecord(self.sock)
+ u = self.unpacker
+ u.reset(reply)
+ xid, verf = u.unpack_replyheader()
+ if xid <> self.lastxid:
+ # Can't really happen since this is TCP...
+ raise XidMismatch(xid, self.lastxid)
+
+# Client using UDP to a specific port
+
+class RawUDPClient(Client):
+
+ def makesocket(self):
+ self.sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+
+ def do_call(self):
+ call = self.packer.get_buffer()
+ self.sock.send(call)
+ try:
+ from select import select
+ except ImportError:
+ print 'WARNING: select not found, RPC may hang'
+ select = None
+ BUFSIZE = 8192 # Max UDP buffer size
+ timeout = 1
+ count = 5
+ while 1:
+ r, w, x = [self.sock], [], []
+ if select:
+ r, w, x = select(r, w, x, timeout)
+ if self.sock not in r:
+ count = count - 1
+ if count < 0: raise TimeoutError()
+ if timeout < 25: timeout = timeout *2
+## print 'RESEND', timeout, count
+ self.sock.send(call)
+ continue
+ reply = self.sock.recv(BUFSIZE)
+ u = self.unpacker
+ u.reset(reply)
+ xid, verf = u.unpack_replyheader()
+ if xid <> self.lastxid:
+## print 'BAD xid'
+ continue
+ break
+
+
+# Client using UDP broadcast to a specific port
+
+class RawBroadcastUDPClient(RawUDPClient):
+
+ def __init__(self, bcastaddr, prog, vers, port):
+ RawUDPClient.__init__(self, bcastaddr, prog, vers, port)
+ self.reply_handler = None
+ self.timeout = 30
+
+ def connsocket(self):
+ # Don't connect -- use sendto
+ self.sock.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, 1)
+
+ def set_reply_handler(self, reply_handler):
+ self.reply_handler = reply_handler
+
+ def set_timeout(self, timeout):
+ self.timeout = timeout # Use None for infinite timeout
+
+ def make_call(self, proc, args, pack_func, unpack_func):
+ if pack_func is None and args is not None:
+ raise TypeError("non-null args with null pack_func")
+ self.start_call(proc)
+ if pack_func:
+ pack_func(args)
+ call = self.packer.get_buffer()
+ self.sock.sendto(call, (self.host, self.port))
+ try:
+ from select import select
+ except ImportError:
+ print 'WARNING: select not found, broadcast will hang'
+ select = None
+ BUFSIZE = 8192 # Max UDP buffer size (for reply)
+ replies = []
+ if unpack_func is None:
+ def dummy(): pass
+ unpack_func = dummy
+ while 1:
+ r, w, x = [self.sock], [], []
+ if select:
+ if self.timeout is None:
+ r, w, x = select(r, w, x)
+ else:
+ r, w, x = select(r, w, x, self.timeout)
+ if self.sock not in r:
+ break
+ reply, fromaddr = self.sock.recvfrom(BUFSIZE)
+ u = self.unpacker
+ u.reset(reply)
+ xid, verf = u.unpack_replyheader()
+ if xid <> self.lastxid:
+## print 'BAD xid'
+ continue
+ reply = unpack_func()
+ try:
+ self.unpacker.done()
+ except xdrlib.Error:
+ raise RPCUnextractedData()
+ replies.append((reply, fromaddr))
+ if self.reply_handler:
+ self.reply_handler(reply, fromaddr)
+ return replies
+
+
+# Port mapper interface
+
+# Program number, version and (fixed!) port number
+PMAP_PROG = 100000
+PMAP_VERS = 2
+PMAP_PORT = 111
+
+# Procedure numbers
+PMAPPROC_NULL = 0 # (void) -> void
+PMAPPROC_SET = 1 # (mapping) -> bool
+PMAPPROC_UNSET = 2 # (mapping) -> bool
+PMAPPROC_GETPORT = 3 # (mapping) -> unsigned int
+PMAPPROC_DUMP = 4 # (void) -> pmaplist
+PMAPPROC_CALLIT = 5 # (call_args) -> call_result
+
+# A mapping is (prog, vers, prot, port) and prot is one of:
+
+IPPROTO_TCP = 6
+IPPROTO_UDP = 17
+
+# A pmaplist is a variable-length list of mappings, as follows:
+# either (1, mapping, pmaplist) or (0).
+
+# A call_args is (prog, vers, proc, args) where args is opaque;
+# a call_result is (port, res) where res is opaque.
+
+
+class PortMapperPacker(Packer):
+
+ def pack_mapping(self, mapping):
+ prog, vers, prot, port = mapping
+ self.pack_uint(prog)
+ self.pack_uint(vers)
+ self.pack_uint(prot)
+ self.pack_uint(port)
+
+ def pack_pmaplist(self, list):
+ self.pack_list(list, self.pack_mapping)
+
+ def pack_call_args(self, ca):
+ prog, vers, proc, args = ca
+ self.pack_uint(prog)
+ self.pack_uint(vers)
+ self.pack_uint(proc)
+ self.pack_opaque(args)
+
+
+class PortMapperUnpacker(Unpacker):
+
+ def unpack_mapping(self):
+ prog = self.unpack_uint()
+ vers = self.unpack_uint()
+ prot = self.unpack_uint()
+ port = self.unpack_uint()
+ return prog, vers, prot, port
+
+ def unpack_pmaplist(self):
+ return self.unpack_list(self.unpack_mapping)
+
+ def unpack_call_result(self):
+ port = self.unpack_uint()
+ res = self.unpack_opaque()
+ return port, res
+
+
+class PartialPortMapperClient:
+ __pychecker__ = 'no-classattr'
+ def addpackers(self):
+ self.packer = PortMapperPacker()
+ self.unpacker = PortMapperUnpacker('')
+
+ def Set(self, mapping):
+ return self.make_call(PMAPPROC_SET, mapping, \
+ self.packer.pack_mapping, \
+ self.unpacker.unpack_uint)
+
+ def Unset(self, mapping):
+ return self.make_call(PMAPPROC_UNSET, mapping, \
+ self.packer.pack_mapping, \
+ self.unpacker.unpack_uint)
+
+ def Getport(self, mapping):
+ return self.make_call(PMAPPROC_GETPORT, mapping, \
+ self.packer.pack_mapping, \
+ self.unpacker.unpack_uint)
+
+ def Dump(self):
+ return self.make_call(PMAPPROC_DUMP, None, \
+ None, \
+ self.unpacker.unpack_pmaplist)
+
+ def Callit(self, ca):
+ return self.make_call(PMAPPROC_CALLIT, ca, \
+ self.packer.pack_call_args, \
+ self.unpacker.unpack_call_result)
+
+
+class TCPPortMapperClient(PartialPortMapperClient, RawTCPClient):
+
+ def __init__(self, host):
+ RawTCPClient.__init__(self, \
+ host, PMAP_PROG, PMAP_VERS, PMAP_PORT)
+
+
+class UDPPortMapperClient(PartialPortMapperClient, RawUDPClient):
+
+ def __init__(self, host):
+ RawUDPClient.__init__(self, \
+ host, PMAP_PROG, PMAP_VERS, PMAP_PORT)
+
+
+class BroadcastUDPPortMapperClient(PartialPortMapperClient, \
+ RawBroadcastUDPClient):
+
+ def __init__(self, bcastaddr):
+ RawBroadcastUDPClient.__init__(self, \
+ bcastaddr, PMAP_PROG, PMAP_VERS, PMAP_PORT)
+
+
+# Generic clients that find their server through the Port mapper
+
+class TCPClient(RawTCPClient):
+
+ def __init__(self, host, prog, vers):
+ pmap = TCPPortMapperClient(host)
+ port = pmap.Getport((prog, vers, IPPROTO_TCP, 0))
+ pmap.close()
+ if port == 0:
+ raise PortMapError("program not registered")
+ RawTCPClient.__init__(self, host, prog, vers, port)
+
+
+class UDPClient(RawUDPClient):
+
+ def __init__(self, host, prog, vers):
+ pmap = UDPPortMapperClient(host)
+ port = pmap.Getport((prog, vers, IPPROTO_UDP, 0))
+ pmap.close()
+ if port == 0:
+ raise PortMapError("program not registered")
+ RawUDPClient.__init__(self, host, prog, vers, port)
+
+
+class BroadcastUDPClient(Client):
+
+ def __init__(self, bcastaddr, prog, vers):
+ self.pmap = BroadcastUDPPortMapperClient(bcastaddr)
+ self.pmap.set_reply_handler(self.my_reply_handler)
+ self.prog = prog
+ self.vers = vers
+ self.user_reply_handler = None
+ self.addpackers()
+
+ def close(self):
+ self.pmap.close()
+
+ def set_reply_handler(self, reply_handler):
+ self.user_reply_handler = reply_handler
+
+ def set_timeout(self, timeout):
+ self.pmap.set_timeout(timeout)
+
+ def my_reply_handler(self, reply, fromaddr):
+ port, res = reply
+ self.unpacker.reset(res)
+ result = self.unpack_func()
+ try:
+ self.unpacker.done()
+ except xdrlib.Error:
+ raise RPCUnextractedData()
+ self.replies.append((result, fromaddr))
+ if self.user_reply_handler is not None:
+ self.user_reply_handler(result, fromaddr)
+
+ def make_call(self, proc, args, pack_func, unpack_func):
+ self.packer.reset()
+ if pack_func:
+ pack_func(args)
+ if unpack_func is None:
+ def dummy(): pass
+ self.unpack_func = dummy
+ else:
+ self.unpack_func = unpack_func
+ self.replies = []
+ packed_args = self.packer.get_buffer()
+ dummy_replies = self.pmap.Callit( \
+ (self.prog, self.vers, proc, packed_args))
+ return self.replies
+
+
+# Server classes
+
+# These are not symmetric to the Client classes
+# XXX No attempt is made to provide authorization hooks yet
+
+class Server:
+
+ def __init__(self, host, prog, vers, port):
+ self.host = host # Should normally be '' for default interface
+ self.prog = prog
+ self.vers = vers
+ self.port = port # Should normally be 0 for random port
+ self.sock = None
+ self.prot = None
+ self.makesocket() # Assigns to self.sock and self.prot
+ self.bindsocket()
+ self.host, self.port = self.sock.getsockname()
+ self.addpackers()
+
+ def register(self):
+ mapping = self.prog, self.vers, self.prot, self.port
+ p = TCPPortMapperClient(self.host)
+ if not p.Set(mapping):
+ raise PortMapError("register failed")
+
+ def unregister(self):
+ mapping = self.prog, self.vers, self.prot, self.port
+ p = TCPPortMapperClient(self.host)
+ if not p.Unset(mapping):
+ raise PortMapError("unregister failed")
+
+ def handle(self, call):
+ # Don't use unpack_header but parse the header piecewise
+ # XXX I have no idea if I am using the right error responses!
+ self.unpacker.reset(call)
+ self.packer.reset()
+ xid = self.unpacker.unpack_uint()
+ self.packer.pack_uint(xid)
+ temp = self.unpacker.unpack_enum()
+ if temp <> CALL:
+ return None # Not worthy of a reply
+ self.packer.pack_uint(REPLY)
+ temp = self.unpacker.unpack_uint()
+ if temp <> RPCVERSION:
+ self.packer.pack_uint(MSG_DENIED)
+ self.packer.pack_uint(RPC_MISMATCH)
+ self.packer.pack_uint(RPCVERSION)
+ self.packer.pack_uint(RPCVERSION)
+ return self.packer.get_buffer()
+ self.packer.pack_uint(MSG_ACCEPTED)
+ self.packer.pack_auth((AUTH_NULL, make_auth_null()))
+ prog = self.unpacker.unpack_uint()
+ if prog <> self.prog:
+ self.packer.pack_uint(PROG_UNAVAIL)
+ return self.packer.get_buffer()
+ vers = self.unpacker.unpack_uint()
+ if vers <> self.vers:
+ self.packer.pack_uint(PROG_MISMATCH)
+ self.packer.pack_uint(self.vers)
+ self.packer.pack_uint(self.vers)
+ return self.packer.get_buffer()
+ proc = self.unpacker.unpack_uint()
+ methname = 'handle_' + `proc`
+ try:
+ meth = getattr(self, methname)
+ except AttributeError:
+ self.packer.pack_uint(PROC_UNAVAIL)
+ return self.packer.get_buffer()
+ self.recv_cred = self.unpacker.unpack_auth()
+ self.recv_verf = self.unpacker.unpack_auth()
+ try:
+ meth() # Unpack args, call turn_around(), pack reply
+ except (EOFError, RPCGarbageArgs):
+ # Too few or too many arguments
+ self.packer.reset()
+ self.packer.pack_uint(xid)
+ self.packer.pack_uint(REPLY)
+ self.packer.pack_uint(MSG_ACCEPTED)
+ self.packer.pack_auth((AUTH_NULL, make_auth_null()))
+ self.packer.pack_uint(GARBAGE_ARGS)
+ return self.packer.get_buffer()
+
+ def turn_around(self):
+ try:
+ self.unpacker.done()
+ except xdrlib.Error:
+ raise RPCUnextractedData()
+
+ self.packer.pack_uint(SUCCESS)
+
+ def handle_0(self): # Handle NULL message
+ self.turn_around()
+
+ def makesocket(self):
+ # This MUST be overridden
+ raise RuntimeError("makesocket not defined")
+
+ def bindsocket(self):
+ # Override this to bind to a different port (e.g. reserved)
+ self.sock.bind((self.host, self.port))
+
+ def addpackers(self):
+ # Override this to use derived classes from Packer/Unpacker
+ self.packer = Packer()
+ self.unpacker = Unpacker('')
+
+
+class TCPServer(Server):
+
+ def makesocket(self):
+ self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+ self.prot = IPPROTO_TCP
+
+ def loop(self):
+ self.sock.listen(0)
+ while 1:
+ self.session(self.sock.accept())
+
+ def session(self, connection):
+ sock, (host, port) = connection
+ while 1:
+ try:
+ call = recvrecord(sock)
+ except EOFError:
+ break
+ except socket.error, msg:
+ print 'socket error:', msg
+ break
+ reply = self.handle(call)
+ if reply is not None:
+ sendrecord(sock, reply)
+
+ def forkingloop(self):
+ # Like loop but uses forksession()
+ self.sock.listen(0)
+ while 1:
+ self.forksession(self.sock.accept())
+
+ def forksession(self, connection):
+ # Like session but forks off a subprocess
+ # Wait for deceased children
+ try:
+ while 1:
+ pid, sts = os.waitpid(0, 1)
+ except os.error:
+ pass
+ pid = None
+ try:
+ pid = os.fork()
+ if pid: # Parent
+ connection[0].close()
+ return
+ # Child
+ self.session(connection)
+ finally:
+ # Make sure we don't fall through in the parent
+ if pid == 0:
+ os._exit(0)
+
+
+class UDPServer(Server):
+
+ def makesocket(self):
+ self.sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+ self.prot = IPPROTO_UDP
+
+ def loop(self):
+ while 1:
+ self.session()
+
+ def session(self):
+ call, host_port = self.sock.recvfrom(8192)
+ self.sender_port = host_port
+ reply = self.handle(call)
+ if reply <> None:
+ self.sock.sendto(reply, host_port)
+
+
+# Simple test program -- dump local portmapper status
+
+def test():
+ pmap = UDPPortMapperClient('')
+ list = pmap.Dump()
+ list.sort()
+ for prog, vers, prot, port in list:
+ print prog, vers,
+ if prot == IPPROTO_TCP: print 'tcp',
+ elif prot == IPPROTO_UDP: print 'udp',
+ else: print prot,
+ print port
+
+
+# Test program for broadcast operation -- dump everybody's portmapper status
+
+def testbcast():
+ import sys
+ if sys.argv[1:]:
+ bcastaddr = sys.argv[1]
+ else:
+ bcastaddr = '<broadcast>'
+ def rh(reply, fromaddr):
+ host, port = fromaddr
+ print host + '\t' + `reply`
+ pmap = BroadcastUDPPortMapperClient(bcastaddr)
+ pmap.set_reply_handler(rh)
+ pmap.set_timeout(5)
+ unused_replies = pmap.Getport((100002, 1, IPPROTO_UDP, 0))
+
+
+# Test program for server, with corresponding client
+# On machine A: python -c 'import rpc; rpc.testsvr()'
+# On machine B: python -c 'import rpc; rpc.testclt()' A
+# (A may be == B)
+
+def testsvr():
+ # Simple test class -- proc 1 doubles its string argument as reply
+ class S(UDPServer):
+ def handle_1(self):
+ arg = self.unpacker.unpack_string()
+ self.turn_around()
+ print 'RPC function 1 called, arg', `arg`
+ self.packer.pack_string(arg + arg)
+ #
+ s = S('', 0x20000000, 1, 0)
+ try:
+ s.unregister()
+ except PortMapError, e:
+ print 'RuntimeError:', e.args, '(ignored)'
+ s.register()
+ print 'Service started...'
+ try:
+ s.loop()
+ finally:
+ s.unregister()
+ print 'Service interrupted.'
+
+
+def testclt():
+ import sys
+ if sys.argv[1:]: host = sys.argv[1]
+ else: host = ''
+ # Client for above server
+ class C(UDPClient):
+ def call_1(self, arg):
+ return self.make_call(1, arg, \
+ self.packer.pack_string, \
+ self.unpacker.unpack_string)
+ c = C(host, 0x20000000, 1)
+ print 'making call...'
+ reply = c.call_1('hello, world, ')
+ print 'call returned', `reply`
+
+
+# Local variables:
+# py-indent-offset: 4
+# tab-width: 8
+# End:
projects / unfs3 / blobdiff