19
+ − 1 "A an RPC module, with optimizations for VXI-11 rpc calls"
+ − 2 _rcsid="$Id: rpc.py 323 2011-04-06 19:10:03Z marcus $"
+ − 3
+ − 4 #this module is 99% from the python distribution, Demo/rpc/rpc.py, with a few modifications
+ − 5 #by Marcus Mendenhall to improve timeout handling, etc. It probably should follow any licensing
+ − 6 #intent of whoever originated it.
+ − 7
+ − 8 # Sun RPC version 2 -- RFC1057.
+ − 9
+ − 10 # XXX There should be separate exceptions for the various reasons why
+ − 11 # XXX an RPC can fail, rather than using RuntimeError for everything
+ − 12
+ − 13 # XXX The UDP version of the protocol resends requests when it does
+ − 14 # XXX not receive a timely reply -- use only for idempotent calls!
+ − 15
+ − 16 # XXX There is no provision for call timeout on TCP connections
+ − 17 # Now there is, on receives. 2003.02.20 Marcus Mendenhall, Vanderbilt University marcus.h.mendenhall@vanderbilt.edu
+ − 18
+ − 19 import xdrlib as xdr
+ − 20 import socket
+ − 21 import os
+ − 22 from exceptions import *
+ − 23
+ − 24 RPCVERSION = 2
+ − 25
+ − 26 CALL = 0
+ − 27 REPLY = 1
+ − 28
+ − 29 AUTH_NULL = 0
+ − 30 AUTH_UNIX = 1
+ − 31 AUTH_SHORT = 2
+ − 32 AUTH_DES = 3
+ − 33
+ − 34 MSG_ACCEPTED = 0
+ − 35 MSG_DENIED = 1
+ − 36
+ − 37 SUCCESS = 0 # RPC executed successfully
+ − 38 PROG_UNAVAIL = 1 # remote hasn't exported program
+ − 39 PROG_MISMATCH = 2 # remote can't support version #
+ − 40 PROC_UNAVAIL = 3 # program can't support procedure
+ − 41 GARBAGE_ARGS = 4 # procedure can't decode params
+ − 42
+ − 43 RPC_MISMATCH = 0 # RPC version number != 2
+ − 44 AUTH_ERROR = 1 # remote can't authenticate caller
+ − 45
+ − 46 AUTH_BADCRED = 1 # bad credentials (seal broken)
+ − 47 AUTH_REJECTEDCRED = 2 # client must begin new session
+ − 48 AUTH_BADVERF = 3 # bad verifier (seal broken)
+ − 49 AUTH_REJECTEDVERF = 4 # verifier expired or replayed
+ − 50 AUTH_TOOWEAK = 5 # rejected for security reasons
+ − 51
+ − 52
+ − 53 class Packer(xdr.Packer):
+ − 54
+ − 55 def pack_auth(self, auth):
+ − 56 flavor, stuff = auth
+ − 57 self.pack_enum(flavor)
+ − 58 self.pack_opaque(stuff)
+ − 59
+ − 60 def pack_auth_unix(self, stamp, machinename, uid, gid, gids):
+ − 61 self.pack_uint(stamp)
+ − 62 self.pack_string(machinename)
+ − 63 self.pack_uint(uid)
+ − 64 self.pack_uint(gid)
+ − 65 self.pack_uint(len(gids))
+ − 66 for i in gids:
+ − 67 self.pack_uint(i)
+ − 68
+ − 69 def pack_callheader(self, xid, prog, vers, proc, cred, verf):
+ − 70 self.pack_uint(xid)
+ − 71 self.pack_enum(CALL)
+ − 72 self.pack_uint(RPCVERSION)
+ − 73 self.pack_uint(prog)
+ − 74 self.pack_uint(vers)
+ − 75 self.pack_uint(proc)
+ − 76 self.pack_auth(cred)
+ − 77 self.pack_auth(verf)
+ − 78 # Caller must add procedure-specific part of call
+ − 79
+ − 80 def pack_replyheader(self, xid, verf):
+ − 81 self.pack_uint(xid)
+ − 82 self.pack_enum(REPLY)
+ − 83 self.pack_uint(MSG_ACCEPTED)
+ − 84 self.pack_auth(verf)
+ − 85 self.pack_enum(SUCCESS)
+ − 86 # Caller must add procedure-specific part of reply
+ − 87
+ − 88
+ − 89 # Exceptions
+ − 90 BadRPCFormat = 'rpc.BadRPCFormat'
+ − 91 BadRPCVersion = 'rpc.BadRPCVersion'
+ − 92 GarbageArgs = 'rpc.GarbageArgs'
+ − 93
+ − 94 class Unpacker(xdr.Unpacker):
+ − 95
+ − 96 def unpack_auth(self):
+ − 97 flavor = self.unpack_enum()
+ − 98 stuff = self.unpack_opaque()
+ − 99 return (flavor, stuff)
+ − 100
+ − 101 def unpack_callheader(self):
+ − 102 xid = self.unpack_uint(xid)
+ − 103 temp = self.unpack_enum()
+ − 104 if temp <> CALL:
+ − 105 raise BadRPCFormat, 'no CALL but ' + `temp`
+ − 106 temp = self.unpack_uint()
+ − 107 if temp <> RPCVERSION:
+ − 108 raise BadRPCVerspion, 'bad RPC version ' + `temp`
+ − 109 prog = self.unpack_uint()
+ − 110 vers = self.unpack_uint()
+ − 111 proc = self.unpack_uint()
+ − 112 cred = self.unpack_auth()
+ − 113 verf = self.unpack_auth()
+ − 114 return xid, prog, vers, proc, cred, verf
+ − 115 # Caller must add procedure-specific part of call
+ − 116
+ − 117 def unpack_replyheader(self):
+ − 118 xid = self.unpack_uint()
+ − 119 mtype = self.unpack_enum()
+ − 120 if mtype <> REPLY:
+ − 121 raise RuntimeError, 'no REPLY but ' + `mtype`
+ − 122 stat = self.unpack_enum()
+ − 123 if stat == MSG_DENIED:
+ − 124 stat = self.unpack_enum()
+ − 125 if stat == RPC_MISMATCH:
+ − 126 low = self.unpack_uint()
+ − 127 high = self.unpack_uint()
+ − 128 raise RuntimeError, \
+ − 129 'MSG_DENIED: RPC_MISMATCH: ' + `low, high`
+ − 130 if stat == AUTH_ERROR:
+ − 131 stat = self.unpack_uint()
+ − 132 raise RuntimeError, \
+ − 133 'MSG_DENIED: AUTH_ERROR: ' + `stat`
+ − 134 raise RuntimeError, 'MSG_DENIED: ' + `stat`
+ − 135 if stat <> MSG_ACCEPTED:
+ − 136 raise RuntimeError, \
+ − 137 'Neither MSG_DENIED nor MSG_ACCEPTED: ' + `stat`
+ − 138 verf = self.unpack_auth()
+ − 139 stat = self.unpack_enum()
+ − 140 if stat == PROG_UNAVAIL:
+ − 141 raise RuntimeError, 'call failed: PROG_UNAVAIL'
+ − 142 if stat == PROG_MISMATCH:
+ − 143 low = self.unpack_uint()
+ − 144 high = self.unpack_uint()
+ − 145 raise RuntimeError, \
+ − 146 'call failed: PROG_MISMATCH: ' + `low, high`
+ − 147 if stat == PROC_UNAVAIL:
+ − 148 raise RuntimeError, 'call failed: PROC_UNAVAIL'
+ − 149 if stat == GARBAGE_ARGS:
+ − 150 raise RuntimeError, 'call failed: GARBAGE_ARGS'
+ − 151 if stat <> SUCCESS:
+ − 152 raise RuntimeError, 'call failed: ' + `stat`
+ − 153 return xid, verf
+ − 154 # Caller must get procedure-specific part of reply
+ − 155
+ − 156
+ − 157 # Subroutines to create opaque authentication objects
+ − 158
+ − 159 def make_auth_null():
+ − 160 return ''
+ − 161
+ − 162 def make_auth_unix(seed, host, uid, gid, groups):
+ − 163 p = Packer()
+ − 164 p.pack_auth_unix(seed, host, uid, gid, groups)
+ − 165 return p.get_buf()
+ − 166
+ − 167 def make_auth_unix_default():
+ − 168 try:
+ − 169 from os import getuid, getgid
+ − 170 uid = getuid()
+ − 171 gid = getgid()
+ − 172 except ImportError:
+ − 173 uid = gid = 0
+ − 174 import time
+ − 175 return make_auth_unix(int(time.time()-unix_epoch()), \
+ − 176 socket.gethostname(), uid, gid, [])
+ − 177
+ − 178 _unix_epoch = -1
+ − 179 def unix_epoch():
+ − 180 """Very painful calculation of when the Unix Epoch is.
+ − 181
+ − 182 This is defined as the return value of time.time() on Jan 1st,
+ − 183 1970, 00:00:00 GMT.
+ − 184
+ − 185 On a Unix system, this should always return 0.0. On a Mac, the
+ − 186 calculations are needed -- and hard because of integer overflow
+ − 187 and other limitations.
+ − 188
+ − 189 """
+ − 190 global _unix_epoch
+ − 191 if _unix_epoch >= 0: return _unix_epoch
+ − 192 import time
+ − 193 now = time.time()
+ − 194 localt = time.localtime(now) # (y, m, d, hh, mm, ss, ..., ..., ...)
+ − 195 gmt = time.gmtime(now)
+ − 196 offset = time.mktime(localt) - time.mktime(gmt)
+ − 197 y, m, d, hh, mm, ss = 1970, 1, 1, 0, 0, 0
+ − 198 offset, ss = divmod(ss + offset, 60)
+ − 199 offset, mm = divmod(mm + offset, 60)
+ − 200 offset, hh = divmod(hh + offset, 24)
+ − 201 d = d + offset
+ − 202 _unix_epoch = time.mktime((y, m, d, hh, mm, ss, 0, 0, 0))
+ − 203 print "Unix epoch:", time.ctime(_unix_epoch)
+ − 204 return _unix_epoch
+ − 205
+ − 206
+ − 207 # Common base class for clients
+ − 208
+ − 209 class Client:
+ − 210
+ − 211 def __init__(self, host, prog, vers, port):
+ − 212 self.host = host
+ − 213 self.prog = prog
+ − 214 self.vers = vers
+ − 215 self.port = port
+ − 216 self.makesocket() # Assigns to self.sock
+ − 217 self.bindsocket()
+ − 218 self.connsocket()
+ − 219 self.lastxid = 0 # XXX should be more random?
+ − 220 self.addpackers()
+ − 221 self.cred = None
+ − 222 self.verf = None
+ − 223
+ − 224 def close(self):
+ − 225 self.sock.close()
+ − 226
+ − 227 def makesocket(self):
+ − 228 # This MUST be overridden
+ − 229 raise RuntimeError, 'makesocket not defined'
+ − 230
+ − 231 def connsocket(self):
+ − 232 # Override this if you don't want/need a connection
+ − 233 self.sock.connect((self.host, self.port))
+ − 234
+ − 235 def bindsocket(self):
+ − 236 # Override this to bind to a different port (e.g. reserved)
+ − 237 self.sock.bind(('', 0))
+ − 238
+ − 239 def addpackers(self):
+ − 240 # Override this to use derived classes from Packer/Unpacker
+ − 241 self.packer = Packer()
+ − 242 self.unpacker = Unpacker('')
+ − 243
+ − 244 def make_call(self, proc, args, pack_func, unpack_func):
+ − 245 #print "make_call() args = " + str(args)
+ − 246 # Don't normally override this (but see Broadcast)
+ − 247 if pack_func is None and args is not None:
+ − 248 raise TypeError, 'non-null args with null pack_func'
+ − 249 #print "packed args"
+ − 250 self.start_call(proc)
+ − 251 if pack_func:
+ − 252 pack_func(args)
+ − 253 self.do_call()
+ − 254 if unpack_func:
+ − 255 result = unpack_func()
+ − 256 else:
+ − 257 result = None
+ − 258 #print "result = " + str(result)
+ − 259 self.unpacker.done()
+ − 260 return result
+ − 261
+ − 262 def start_call(self, proc):
+ − 263 # Don't override this
+ − 264 self.lastxid = xid = self.lastxid + 1
+ − 265 cred = self.mkcred()
+ − 266 verf = self.mkverf()
+ − 267 p = self.packer
+ − 268 p.reset()
+ − 269 p.pack_callheader(xid, self.prog, self.vers, proc, cred, verf)
+ − 270
+ − 271 def do_call(self):
+ − 272 # This MUST be overridden
+ − 273 raise RuntimeError, 'do_call not defined'
+ − 274
+ − 275 def mkcred(self):
+ − 276 # Override this to use more powerful credentials
+ − 277 if self.cred == None:
+ − 278 self.cred = (AUTH_NULL, make_auth_null())
+ − 279 return self.cred
+ − 280
+ − 281 def mkverf(self):
+ − 282 # Override this to use a more powerful verifier
+ − 283 if self.verf == None:
+ − 284 self.verf = (AUTH_NULL, make_auth_null())
+ − 285 return self.verf
+ − 286
+ − 287 def call_0(self): # Procedure 0 is always like this
+ − 288 return self.make_call(0, None, None, None)
+ − 289
+ − 290
+ − 291 # Record-Marking standard support
+ − 292
+ − 293 try:
+ − 294 from select import select as _select
+ − 295 except:
+ − 296 _select=None
+ − 297
+ − 298 def sendfrag_with_timeout(sock, last, frag, timeout_seconds=None):
+ − 299 x = len(frag)
+ − 300 if last: x = x | 0x80000000L
+ − 301 header = (chr(int(x>>24 & 0xff)) + chr(int(x>>16 & 0xff)) + \
+ − 302 chr(int(x>>8 & 0xff)) + chr(int(x & 0xff)))
+ − 303 block=header+frag
+ − 304 n=len(block)
+ − 305 nsent=0
+ − 306 while(nsent<n):
+ − 307 if _select and timeout_seconds:
+ − 308 rlist, wlist, xlist=_select([],[sock],[], timeout_seconds)
+ − 309 if not wlist:
+ − 310 raise EOFError, "Blocked write in sendfrag()"
+ − 311 nsent+=sock.send(block[nsent:])
+ − 312
+ − 313 def recvfrag_with_timeout(sock, timeout_seconds=None):
+ − 314 #print "receiving from ", sock
+ − 315 if _select and timeout_seconds:
+ − 316 #print "Selecting with timeout...", timeout_seconds
+ − 317 rlist, wlist, xlist=_select([sock],[],[], timeout_seconds)
+ − 318 if not rlist:
+ − 319 raise EOFError, "No header at all in recvfrag()"
+ − 320
+ − 321 header = sock.recv(4)
+ − 322 if len(header) < 4:
+ − 323 raise EOFError
+ − 324 x = long(ord(header[0]))<<24 | ord(header[1])<<16 | \
+ − 325 ord(header[2])<<8 | ord(header[3])
+ − 326 last = ((x & 0x80000000L) != 0)
+ − 327 n = int(x & 0x7fffffff)
+ − 328
+ − 329 frag=''
+ − 330
+ − 331 while(len(frag) < n):
+ − 332 if _select and timeout_seconds:
+ − 333 #print "Selecting with timeout...", timeout_seconds
+ − 334 rlist, wlist, xlist=_select([sock],[],[], timeout_seconds)
+ − 335 if not rlist:
+ − 336 raise EOFError, "No data after header in recvfrag()"
+ − 337 frag += sock.recv(n-len(frag))
+ − 338
+ − 339 return last, frag
+ − 340
+ − 341
+ − 342 def recvrecord(sock, timeout_seconds=None):
+ − 343 record = ''
+ − 344 last = 0
+ − 345 while not last:
+ − 346 last, frag = recvfrag_with_timeout(sock, timeout_seconds)
+ − 347 record = record + frag
+ − 348 return record
+ − 349
+ − 350 def sendrecord(sock, record, timeout_seconds=None):
+ − 351 sendfrag_with_timeout(sock, 1, record, timeout_seconds)
+ − 352
+ − 353
+ − 354
+ − 355 # Try to bind to a reserved port (must be root)
+ − 356
+ − 357 last_resv_port_tried = None
+ − 358 def bindresvport(sock, host):
+ − 359 global last_resv_port_tried
+ − 360 FIRST, LAST = 600, 1024 # Range of ports to try
+ − 361 if last_resv_port_tried == None:
+ − 362 import os
+ − 363 last_resv_port_tried = FIRST + os.getpid() % (LAST-FIRST)
+ − 364 for i in range(last_resv_port_tried, LAST) + \
+ − 365 range(FIRST, last_resv_port_tried):
+ − 366 last_resv_port_tried = i
+ − 367 try:
+ − 368 sock.bind((host, i))
+ − 369 return last_resv_port_tried
+ − 370 except socket.error, (errno, msg):
+ − 371 if errno <> 114:
+ − 372 raise socket.error, (errno, msg)
+ − 373 raise RuntimeError, 'can\'t assign reserved port'
+ − 374
+ − 375
+ − 376 # Client using TCP to a specific port
+ − 377
+ − 378 class RawTCPClient(Client):
+ − 379
+ − 380 select_timeout_seconds=None
+ − 381
+ − 382 def makesocket(self):
+ − 383 self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+ − 384
+ − 385 def do_call(self):
+ − 386 call = self.packer.get_buf()
+ − 387 sendrecord(self.sock, call, self.select_timeout_seconds)
+ − 388 reply = recvrecord(self.sock, self.select_timeout_seconds)
+ − 389 u = self.unpacker
+ − 390 u.reset(reply)
+ − 391 xid, verf = u.unpack_replyheader()
+ − 392 if xid <> self.lastxid:
+ − 393 # Can't really happen since this is TCP...
+ − 394 raise RuntimeError, 'wrong xid in reply ' + `xid` + \
+ − 395 ' instead of ' + `self.lastxid`
+ − 396
+ − 397
+ − 398 # Client using UDP to a specific port
+ − 399
+ − 400 class RawUDPClient(Client):
+ − 401
+ − 402 def makesocket(self):
+ − 403 self.sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+ − 404
+ − 405 def do_call(self):
+ − 406 call = self.packer.get_buf()
+ − 407 self.sock.send(call)
+ − 408 try:
+ − 409 from select import select
+ − 410 except ImportError:
+ − 411 print 'WARNING: select not found, RPC may hang'
+ − 412 select = None
+ − 413 BUFSIZE = 8192 # Max UDP buffer size
+ − 414 timeout = 1
+ − 415 count = 5
+ − 416 while 1:
+ − 417 r, w, x = [self.sock], [], []
+ − 418 if select:
+ − 419 r, w, x = select(r, w, x, timeout)
+ − 420 if self.sock not in r:
+ − 421 count = count - 1
+ − 422 if count < 0: raise RuntimeError, 'timeout'
+ − 423 if timeout < 25: timeout = timeout *2
+ − 424 ## print 'RESEND', timeout, count
+ − 425 self.sock.send(call)
+ − 426 continue
+ − 427 reply = self.sock.recv(BUFSIZE)
+ − 428 u = self.unpacker
+ − 429 u.reset(reply)
+ − 430 xid, verf = u.unpack_replyheader()
+ − 431 if xid <> self.lastxid:
+ − 432 ## print 'BAD xid'
+ − 433 continue
+ − 434 break
+ − 435
+ − 436
+ − 437 # Client using UDP broadcast to a specific port
+ − 438
+ − 439 class RawBroadcastUDPClient(RawUDPClient):
+ − 440
+ − 441 def __init__(self, bcastaddr, prog, vers, port):
+ − 442 RawUDPClient.__init__(self, bcastaddr, prog, vers, port)
+ − 443 self.reply_handler = None
+ − 444 self.timeout = 30
+ − 445
+ − 446 def connsocket(self):
+ − 447 # Don't connect -- use sendto
+ − 448 self.sock.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, 1)
+ − 449
+ − 450 def set_reply_handler(self, reply_handler):
+ − 451 self.reply_handler = reply_handler
+ − 452
+ − 453 def set_timeout(self, timeout):
+ − 454 self.timeout = timeout # Use None for infinite timeout
+ − 455
+ − 456 def make_call(self, proc, args, pack_func, unpack_func):
+ − 457 if pack_func is None and args is not None:
+ − 458 raise TypeError, 'non-null args with null pack_func'
+ − 459 self.start_call(proc)
+ − 460 if pack_func:
+ − 461 pack_func(args)
+ − 462 call = self.packer.get_buf()
+ − 463 self.sock.sendto(call, (self.host, self.port))
+ − 464 try:
+ − 465 from select import select
+ − 466 except ImportError:
+ − 467 print 'WARNING: select not found, broadcast will hang'
+ − 468 select = None
+ − 469 BUFSIZE = 8192 # Max UDP buffer size (for reply)
+ − 470 replies = []
+ − 471 if unpack_func is None:
+ − 472 def dummy(): pass
+ − 473 unpack_func = dummy
+ − 474 while 1:
+ − 475 r, w, x = [self.sock], [], []
+ − 476 if select:
+ − 477 if self.timeout is None:
+ − 478 r, w, x = select(r, w, x)
+ − 479 else:
+ − 480 r, w, x = select(r, w, x, self.timeout)
+ − 481 if self.sock not in r:
+ − 482 break
+ − 483 reply, fromaddr = self.sock.recvfrom(BUFSIZE)
+ − 484 u = self.unpacker
+ − 485 u.reset(reply)
+ − 486 xid, verf = u.unpack_replyheader()
+ − 487 if xid <> self.lastxid:
+ − 488 ## print 'BAD xid'
+ − 489 continue
+ − 490 reply = unpack_func()
+ − 491 self.unpacker.done()
+ − 492 replies.append((reply, fromaddr))
+ − 493 if self.reply_handler:
+ − 494 self.reply_handler(reply, fromaddr)
+ − 495 return replies
+ − 496
+ − 497
+ − 498 # Port mapper interface
+ − 499
+ − 500 # Program number, version and (fixed!) port number
+ − 501 PMAP_PROG = 100000
+ − 502 PMAP_VERS = 2
+ − 503 PMAP_PORT = 111
+ − 504
+ − 505 # Procedure numbers
+ − 506 PMAPPROC_NULL = 0 # (void) -> void
+ − 507 PMAPPROC_SET = 1 # (mapping) -> bool
+ − 508 PMAPPROC_UNSET = 2 # (mapping) -> bool
+ − 509 PMAPPROC_GETPORT = 3 # (mapping) -> unsigned int
+ − 510 PMAPPROC_DUMP = 4 # (void) -> pmaplist
+ − 511 PMAPPROC_CALLIT = 5 # (call_args) -> call_result
+ − 512
+ − 513 # A mapping is (prog, vers, prot, port) and prot is one of:
+ − 514
+ − 515 IPPROTO_TCP = 6
+ − 516 IPPROTO_UDP = 17
+ − 517
+ − 518 # A pmaplist is a variable-length list of mappings, as follows:
+ − 519 # either (1, mapping, pmaplist) or (0).
+ − 520
+ − 521 # A call_args is (prog, vers, proc, args) where args is opaque;
+ − 522 # a call_result is (port, res) where res is opaque.
+ − 523
+ − 524
+ − 525 class PortMapperPacker(Packer):
+ − 526
+ − 527 def pack_mapping(self, mapping):
+ − 528 prog, vers, prot, port = mapping
+ − 529 self.pack_uint(prog)
+ − 530 self.pack_uint(vers)
+ − 531 self.pack_uint(prot)
+ − 532 self.pack_uint(port)
+ − 533
+ − 534 def pack_pmaplist(self, list):
+ − 535 self.pack_list(list, self.pack_mapping)
+ − 536
+ − 537 def pack_call_args(self, ca):
+ − 538 prog, vers, proc, args = ca
+ − 539 self.pack_uint(prog)
+ − 540 self.pack_uint(vers)
+ − 541 self.pack_uint(proc)
+ − 542 self.pack_opaque(args)
+ − 543
+ − 544
+ − 545 class PortMapperUnpacker(Unpacker):
+ − 546
+ − 547 def unpack_mapping(self):
+ − 548 prog = self.unpack_uint()
+ − 549 vers = self.unpack_uint()
+ − 550 prot = self.unpack_uint()
+ − 551 port = self.unpack_uint()
+ − 552 return prog, vers, prot, port
+ − 553
+ − 554 def unpack_pmaplist(self):
+ − 555 return self.unpack_list(self.unpack_mapping)
+ − 556
+ − 557 def unpack_call_result(self):
+ − 558 port = self.unpack_uint()
+ − 559 res = self.unpack_opaque()
+ − 560 return port, res
+ − 561
+ − 562
+ − 563 class PartialPortMapperClient:
+ − 564
+ − 565 def addpackers(self):
+ − 566 self.packer = PortMapperPacker()
+ − 567 self.unpacker = PortMapperUnpacker('')
+ − 568
+ − 569 def Set(self, mapping):
+ − 570 return self.make_call(PMAPPROC_SET, mapping, \
+ − 571 self.packer.pack_mapping, \
+ − 572 self.unpacker.unpack_uint)
+ − 573
+ − 574 def Unset(self, mapping):
+ − 575 return self.make_call(PMAPPROC_UNSET, mapping, \
+ − 576 self.packer.pack_mapping, \
+ − 577 self.unpacker.unpack_uint)
+ − 578
+ − 579 def Getport(self, mapping):
+ − 580 return self.make_call(PMAPPROC_GETPORT, mapping, \
+ − 581 self.packer.pack_mapping, \
+ − 582 self.unpacker.unpack_uint)
+ − 583
+ − 584 def Dump(self):
+ − 585 return self.make_call(PMAPPROC_DUMP, None, \
+ − 586 None, \
+ − 587 self.unpacker.unpack_pmaplist)
+ − 588
+ − 589 def Callit(self, ca):
+ − 590 return self.make_call(PMAPPROC_CALLIT, ca, \
+ − 591 self.packer.pack_call_args, \
+ − 592 self.unpacker.unpack_call_result)
+ − 593
+ − 594
+ − 595 class TCPPortMapperClient(PartialPortMapperClient, RawTCPClient):
+ − 596
+ − 597 def __init__(self, host, port=PMAP_PORT, timeout_seconds=None):
+ − 598 RawTCPClient.__init__(self, \
+ − 599 host, PMAP_PROG, PMAP_VERS, port)
+ − 600 self.select_timeout_seconds=timeout_seconds
+ − 601
+ − 602
+ − 603 class UDPPortMapperClient(PartialPortMapperClient, RawUDPClient):
+ − 604
+ − 605 def __init__(self, host, port=PMAP_PORT):
+ − 606 RawUDPClient.__init__(self, \
+ − 607 host, PMAP_PROG, PMAP_VERS, port)
+ − 608
+ − 609 class BroadcastUDPPortMapperClient(PartialPortMapperClient, \
+ − 610 RawBroadcastUDPClient):
+ − 611
+ − 612 def __init__(self, bcastaddr):
+ − 613 RawBroadcastUDPClient.__init__(self, \
+ − 614 bcastaddr, PMAP_PROG, PMAP_VERS, PMAP_PORT)
+ − 615
+ − 616
+ − 617 # Generic clients that find their server through the Port mapper
+ − 618
+ − 619 class TCPClient(RawTCPClient):
+ − 620
+ − 621 def __init__(self, host, prog, vers, portmap_proxy_host=None, portmap_proxy_port=PMAP_PORT, timeout_seconds=None):
+ − 622
+ − 623 self.select_timeout_seconds=timeout_seconds
+ − 624 if portmap_proxy_host is None:
+ − 625 portmap_proxy_host=host #use a proxy to get around firewalled portmappers
+ − 626 pmap = TCPPortMapperClient(portmap_proxy_host, portmap_proxy_port,timeout_seconds)
+ − 627 port = pmap.Getport((prog, vers, IPPROTO_TCP, 0))
+ − 628 pmap.close()
+ − 629 if port == 0:
+ − 630 raise RuntimeError, 'program not registered'
+ − 631 RawTCPClient.__init__(self, host, prog, vers, port)
+ − 632
+ − 633
+ − 634 class UDPClient(RawUDPClient):
+ − 635
+ − 636 def __init__(self, host, prog, vers, portmap_proxy_host=None, portmap_proxy_port=PMAP_PORT):
+ − 637 if portmap_proxy_host is None:
+ − 638 portmap_proxy_host=host #use a proxy to get around firewalled portmappers
+ − 639 pmap = UDPPortMapperClient(portmap_proxy_host, portmap_proxy_port)
+ − 640 port = pmap.Getport((prog, vers, IPPROTO_UDP, 0))
+ − 641 pmap.close()
+ − 642 if port == 0:
+ − 643 raise RuntimeError, 'program not registered'
+ − 644 RawUDPClient.__init__(self, host, prog, vers, port)
+ − 645
+ − 646
+ − 647 class BroadcastUDPClient(Client):
+ − 648
+ − 649 def __init__(self, bcastaddr, prog, vers):
+ − 650 self.pmap = BroadcastUDPPortMapperClient(bcastaddr)
+ − 651 self.pmap.set_reply_handler(self.my_reply_handler)
+ − 652 self.prog = prog
+ − 653 self.vers = vers
+ − 654 self.user_reply_handler = None
+ − 655 self.addpackers()
+ − 656
+ − 657 def close(self):
+ − 658 self.pmap.close()
+ − 659
+ − 660 def set_reply_handler(self, reply_handler):
+ − 661 self.user_reply_handler = reply_handler
+ − 662
+ − 663 def set_timeout(self, timeout):
+ − 664 self.pmap.set_timeout(timeout)
+ − 665
+ − 666 def my_reply_handler(self, reply, fromaddr):
+ − 667 port, res = reply
+ − 668 self.unpacker.reset(res)
+ − 669 result = self.unpack_func()
+ − 670 self.unpacker.done()
+ − 671 self.replies.append((result, fromaddr))
+ − 672 if self.user_reply_handler is not None:
+ − 673 self.user_reply_handler(result, fromaddr)
+ − 674
+ − 675 def make_call(self, proc, args, pack_func, unpack_func):
+ − 676 self.packer.reset()
+ − 677 if pack_func:
+ − 678 pack_func(args)
+ − 679 if unpack_func is None:
+ − 680 def dummy(): pass
+ − 681 self.unpack_func = dummy
+ − 682 else:
+ − 683 self.unpack_func = unpack_func
+ − 684 self.replies = []
+ − 685 packed_args = self.packer.get_buf()
+ − 686 dummy_replies = self.pmap.Callit( \
+ − 687 (self.prog, self.vers, proc, packed_args))
+ − 688 return self.replies
+ − 689
+ − 690
+ − 691 # Server classes
+ − 692
+ − 693 # These are not symmetric to the Client classes
+ − 694 # XXX No attempt is made to provide authorization hooks yet
+ − 695
+ − 696 class Server:
+ − 697
+ − 698 def __init__(self, host, prog, vers, port):
+ − 699 self.host = host # Should normally be '' for default interface
+ − 700 self.prog = prog
+ − 701 self.vers = vers
+ − 702 self.port = port # Should normally be 0 for random port
+ − 703 self.makesocket() # Assigns to self.sock and self.prot
+ − 704 self.bindsocket()
+ − 705 self.host, self.port = self.sock.getsockname()
+ − 706 self.addpackers()
+ − 707
+ − 708 def handle(self, call):
+ − 709 # Don't use unpack_header but parse the header piecewise
+ − 710 # XXX I have no idea if I am using the right error responses!
+ − 711 self.unpacker.reset(call)
+ − 712 self.packer.reset()
+ − 713 xid = self.unpacker.unpack_uint()
+ − 714 self.packer.pack_uint(xid)
+ − 715 temp = self.unpacker.unpack_enum()
+ − 716 if temp <> CALL:
+ − 717 return None # Not worthy of a reply
+ − 718 self.packer.pack_uint(REPLY)
+ − 719 temp = self.unpacker.unpack_uint()
+ − 720 if temp <> RPCVERSION:
+ − 721 self.packer.pack_uint(MSG_DENIED)
+ − 722 self.packer.pack_uint(RPC_MISMATCH)
+ − 723 self.packer.pack_uint(RPCVERSION)
+ − 724 self.packer.pack_uint(RPCVERSION)
+ − 725 return self.packer.get_buf()
+ − 726 self.packer.pack_uint(MSG_ACCEPTED)
+ − 727 self.packer.pack_auth((AUTH_NULL, make_auth_null()))
+ − 728 prog = self.unpacker.unpack_uint()
+ − 729 if prog <> self.prog:
+ − 730 self.packer.pack_uint(PROG_UNAVAIL)
+ − 731 return self.packer.get_buf()
+ − 732 vers = self.unpacker.unpack_uint()
+ − 733 if vers <> self.vers:
+ − 734 self.packer.pack_uint(PROG_MISMATCH)
+ − 735 self.packer.pack_uint(self.vers)
+ − 736 self.packer.pack_uint(self.vers)
+ − 737 return self.packer.get_buf()
+ − 738 proc = self.unpacker.unpack_uint()
+ − 739 methname = 'handle_' + `proc`
+ − 740 try:
+ − 741 meth = getattr(self, methname)
+ − 742 except AttributeError:
+ − 743 self.packer.pack_uint(PROC_UNAVAIL)
+ − 744 return self.packer.get_buf()
+ − 745 cred = self.unpacker.unpack_auth()
+ − 746 verf = self.unpacker.unpack_auth()
+ − 747 try:
+ − 748 meth() # Unpack args, call turn_around(), pack reply
+ − 749 except (EOFError, GarbageArgs):
+ − 750 # Too few or too many arguments
+ − 751 self.packer.reset()
+ − 752 self.packer.pack_uint(xid)
+ − 753 self.packer.pack_uint(REPLY)
+ − 754 self.packer.pack_uint(MSG_ACCEPTED)
+ − 755 self.packer.pack_auth((AUTH_NULL, make_auth_null()))
+ − 756 self.packer.pack_uint(GARBAGE_ARGS)
+ − 757 return self.packer.get_buf()
+ − 758
+ − 759 def turn_around(self):
+ − 760 try:
+ − 761 self.unpacker.done()
+ − 762 except RuntimeError:
+ − 763 raise GarbageArgs
+ − 764 self.packer.pack_uint(SUCCESS)
+ − 765
+ − 766 def handle_0(self): # Handle NULL message
+ − 767 self.turn_around()
+ − 768
+ − 769 def makesocket(self):
+ − 770 # This MUST be overridden
+ − 771 raise RuntimeError, 'makesocket not defined'
+ − 772
+ − 773 def bindsocket(self):
+ − 774 # Override this to bind to a different port (e.g. reserved)
+ − 775 self.sock.bind((self.host, self.port))
+ − 776
+ − 777 def addpackers(self):
+ − 778 # Override this to use derived classes from Packer/Unpacker
+ − 779 self.packer = Packer()
+ − 780 self.unpacker = Unpacker('')
+ − 781
+ − 782
+ − 783 class TCPServer(Server):
+ − 784
+ − 785 def register(self):
+ − 786 mapping = self.prog, self.vers, self.prot, self.port
+ − 787 p = TCPPortMapperClient(self.host)
+ − 788 if not p.Set(mapping):
+ − 789 raise RuntimeError, 'register failed'
+ − 790
+ − 791 def unregister(self):
+ − 792 mapping = self.prog, self.vers, self.prot, self.port
+ − 793 p = TCPPortMapperClient(self.host)
+ − 794 if not p.Unset(mapping):
+ − 795 raise RuntimeError, 'unregister failed'
+ − 796
+ − 797 def makesocket(self):
+ − 798 self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+ − 799 self.prot = IPPROTO_TCP
+ − 800
+ − 801 def loop(self):
+ − 802 self.sock.listen(0)
+ − 803 while 1:
+ − 804 self.session(self.sock.accept())
+ − 805
+ − 806 def session(self, connection):
+ − 807 sock, (host, port) = connection
+ − 808 while 1:
+ − 809 try:
+ − 810 call = recvrecord(sock)
+ − 811 except EOFError:
+ − 812 break
+ − 813 except socket.error, msg:
+ − 814 print 'socket error:', msg
+ − 815 break
+ − 816 reply = self.handle(call)
+ − 817 if reply is not None:
+ − 818 sendrecord(sock, reply)
+ − 819
+ − 820 def forkingloop(self):
+ − 821 # Like loop but uses forksession()
+ − 822 self.sock.listen(0)
+ − 823 while 1:
+ − 824 self.forksession(self.sock.accept())
+ − 825
+ − 826 def forksession(self, connection):
+ − 827 # Like session but forks off a subprocess
+ − 828 import os
+ − 829 # Wait for deceased children
+ − 830 try:
+ − 831 while 1:
+ − 832 pid, sts = os.waitpid(0, 1)
+ − 833 except os.error:
+ − 834 pass
+ − 835 pid = None
+ − 836 try:
+ − 837 pid = os.fork()
+ − 838 if pid: # Parent
+ − 839 connection[0].close()
+ − 840 return
+ − 841 # Child
+ − 842 self.session(connection)
+ − 843 finally:
+ − 844 # Make sure we don't fall through in the parent
+ − 845 if pid == 0:
+ − 846 os._exit(0)
+ − 847
+ − 848
+ − 849 class UDPServer(Server):
+ − 850
+ − 851 def register(self):
+ − 852 mapping = self.prog, self.vers, self.prot, self.port
+ − 853 p = UDPPortMapperClient(self.host)
+ − 854 if not p.Set(mapping):
+ − 855 raise RuntimeError, 'register failed'
+ − 856
+ − 857 def unregister(self):
+ − 858 mapping = self.prog, self.vers, self.prot, self.port
+ − 859 p = UDPPortMapperClient(self.host)
+ − 860 if not p.Unset(mapping):
+ − 861 raise RuntimeError, 'unregister failed'
+ − 862
+ − 863 def makesocket(self):
+ − 864 self.sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+ − 865 self.prot = IPPROTO_UDP
+ − 866
+ − 867 def loop(self):
+ − 868 while 1:
+ − 869 self.session()
+ − 870
+ − 871 def session(self):
+ − 872 call, host_port = self.sock.recvfrom(8192)
+ − 873 reply = self.handle(call)
+ − 874 if reply <> None:
+ − 875 self.sock.sendto(reply, host_port)
+ − 876
+ − 877
+ − 878 # Simple test program -- dump local portmapper status
+ − 879
+ − 880 def test():
+ − 881 pmap = UDPPortMapperClient('')
+ − 882 list = pmap.Dump()
+ − 883 list.sort()
+ − 884 for prog, vers, prot, port in list:
+ − 885 print prog, vers,
+ − 886 if prot == IPPROTO_TCP: print 'tcp',
+ − 887 elif prot == IPPROTO_UDP: print 'udp',
+ − 888 else: print prot,
+ − 889 print port
+ − 890
+ − 891
+ − 892 # Test program for broadcast operation -- dump everybody's portmapper status
+ − 893
+ − 894 def testbcast():
+ − 895 import sys
+ − 896 if sys.argv[1:]:
+ − 897 bcastaddr = sys.argv[1]
+ − 898 else:
+ − 899 bcastaddr = '<broadcast>'
+ − 900 def rh(reply, fromaddr):
+ − 901 host, port = fromaddr
+ − 902 print host + '\t' + `reply`
+ − 903 pmap = BroadcastUDPPortMapperClient(bcastaddr)
+ − 904 pmap.set_reply_handler(rh)
+ − 905 pmap.set_timeout(5)
+ − 906 replies = pmap.Getport((100002, 1, IPPROTO_UDP, 0))
+ − 907
+ − 908
+ − 909 # Test program for server, with corresponding client
+ − 910 # On machine A: python -c 'import rpc; rpc.testsvr()'
+ − 911 # On machine B: python -c 'import rpc; rpc.testclt()' A
+ − 912 # (A may be == B)
+ − 913
+ − 914 def testsvr():
+ − 915 # Simple test class -- proc 1 doubles its string argument as reply
+ − 916 class S(UDPServer):
+ − 917 def handle_1(self):
+ − 918 arg = self.unpacker.unpack_string()
+ − 919 self.turn_around()
+ − 920 print 'RPC function 1 called, arg', `arg`
+ − 921 self.packer.pack_string(arg + arg)
+ − 922 #
+ − 923 s = S('', 0x20000000, 1, 0)
+ − 924 try:
+ − 925 s.unregister()
+ − 926 except RuntimeError, msg:
+ − 927 print 'RuntimeError:', msg, '(ignored)'
+ − 928 s.register()
+ − 929 print 'Service started...'
+ − 930 try:
+ − 931 s.loop()
+ − 932 finally:
+ − 933 s.unregister()
+ − 934 print 'Service interrupted.'
+ − 935
+ − 936
+ − 937 def testclt():
+ − 938 import sys
+ − 939 if sys.argv[1:]: host = sys.argv[1]
+ − 940 else: host = ''
+ − 941 # Client for above server
+ − 942 class C(UDPClient):
+ − 943 def call_1(self, arg):
+ − 944 return self.make_call(1, arg, \
+ − 945 self.packer.pack_string, \
+ − 946 self.unpacker.unpack_string)
+ − 947 c = C(host, 0x20000000, 1)
+ − 948 print 'making call...'
+ − 949 reply = c.call_1('hello, world, ')
+ − 950 print 'call returned', `reply`
+ − 951
+ − 952 def testclt2():
+ − 953 import sys
+ − 954 host = '127.0.0.1'
+ − 955 # Client for above server
+ − 956 class C(UDPClient):
+ − 957 def call_1(self, arg):
+ − 958 return self.make_call(1, arg, \
+ − 959 self.packer.pack_string, \
+ − 960 self.unpacker.unpack_string)
+ − 961 c = C(host, 0x20000000, 1)
+ − 962 print 'making call...'
+ − 963 reply = c.call_1('hello, world, ')
+ − 964 print 'call returned', `reply`
+ − 965
