1 # Mount RPC client -- RFC 1094 (NFS), Appendix A

     2 

     3 # This module demonstrates how to write your own RPC client in Python.

     4 # When this example was written, there was no RPC compiler for

     5 # Python. Without such a compiler, you must first create classes

     6 # derived from Packer and Unpacker to handle the data types for the

     7 # server you want to interface to.  You then write the client class.

     8 # If you want to support both the TCP and the UDP version of a

     9 # protocol, use multiple inheritance as shown below.

    10 

    11 

    12 import rpc

    13 from rpc import Packer, Unpacker, TCPClient, UDPClient

    14 

    15 

    16 # Program number and version for the mount protocol

    17 MOUNTPROG = 100005

    18 MOUNTVERS = 1

    19 

    20 # Size of the 'fhandle' opaque structure

    21 FHSIZE = 32

    22 

    23 

    24 # Packer derived class for Mount protocol clients.

    25 # The only thing we need to pack beyond basic types is an 'fhandle'

    26 

    27 class MountPacker(Packer):

    28 

    29     def pack_fhandle(self, fhandle):

    30         self.pack_fopaque(FHSIZE, fhandle)

    31 

    32 

    33 # Unpacker derived class for Mount protocol clients.

    34 # The important types we need to unpack are fhandle, fhstatus,

    35 # mountlist and exportlist; mountstruct, exportstruct and groups are

    36 # used to unpack components of mountlist and exportlist and the

    37 # corresponding functions are passed as function argument to the

    38 # generic unpack_list function.

    39 

    40 class MountUnpacker(Unpacker):

    41 

    42     def unpack_fhandle(self):

    43         return self.unpack_fopaque(FHSIZE)

    44 

    45     def unpack_fhstatus(self):

    46         status = self.unpack_uint()

    47         if status == 0:

    48             fh = self.unpack_fhandle()

    49         else:

    50             fh = None

    51         return status, fh

    52 

    53     def unpack_mountlist(self):

    54         return self.unpack_list(self.unpack_mountstruct)

    55 

    56     def unpack_mountstruct(self):

    57         hostname = self.unpack_string()

    58         directory = self.unpack_string()

    59         return (hostname, directory)

    60 

    61     def unpack_exportlist(self):

    62         return self.unpack_list(self.unpack_exportstruct)

    63 

    64     def unpack_exportstruct(self):

    65         filesys = self.unpack_string()

    66         groups = self.unpack_groups()

    67         return (filesys, groups)

    68 

    69     def unpack_groups(self):

    70         return self.unpack_list(self.unpack_string)

    71 

    72 

    73 # These are the procedures specific to the Mount client class.

    74 # Think of this as a derived class of either TCPClient or UDPClient.

    75 

    76 class PartialMountClient:

    77 

    78     # This method is called by Client.__init__ to initialize

    79     # self.packer and self.unpacker

    80     def addpackers(self):

    81         self.packer = MountPacker()

    82         self.unpacker = MountUnpacker('')

    83 

    84     # This method is called by Client.__init__ to bind the socket

    85     # to a particular network interface and port.  We use the

    86     # default network interface, but if we're running as root,

    87     # we want to bind to a reserved port

    88     def bindsocket(self):

    89         import os

    90         try:

    91             uid = os.getuid()

    92         except AttributeError:

    93             uid = 1

    94         if uid == 0:

    95             port = rpc.bindresvport(self.sock, '')

    96             # 'port' is not used

    97         else:

    98             self.sock.bind(('', 0))

    99 

   100     # This function is called to cough up a suitable

   101     # authentication object for a call to procedure 'proc'.

   102     def mkcred(self):

   103         if self.cred is None:

   104             self.cred = rpc.AUTH_UNIX, rpc.make_auth_unix_default()

   105         return self.cred

   106 

   107     # The methods Mnt, Dump etc. each implement one Remote

   108     # Procedure Call.  This is done by calling self.make_call()

   109     # with as arguments:

   110     #

   111     # - the procedure number

   112     # - the arguments (or None)

   113     # - the "packer" function for the arguments (or None)

   114     # - the "unpacker" function for the return value (or None)

   115     #

   116     # The packer and unpacker function, if not None, *must* be

   117     # methods of self.packer and self.unpacker, respectively.

   118     # A value of None means that there are no arguments or is no

   119     # return value, respectively.

   120     #

   121     # The return value from make_call() is the return value from

   122     # the remote procedure call, as unpacked by the "unpacker"

   123     # function, or None if the unpacker function is None.

   124     #

   125     # (Even if you expect a result of None, you should still

   126     # return the return value from make_call(), since this may be

   127     # needed by a broadcasting version of the class.)

   128     #

   129     # If the call fails, make_call() raises an exception

   130     # (this includes time-outs and invalid results).

   131     #

   132     # Note that (at least with the UDP protocol) there is no

   133     # guarantee that a call is executed at most once.  When you do

   134     # get a reply, you know it has been executed at least once;

   135     # when you don't get a reply, you know nothing.

   136 

   137     def Mnt(self, directory):

   138         return self.make_call(1, directory, \

   139                 self.packer.pack_string, \

   140                 self.unpacker.unpack_fhstatus)

   141 

   142     def Dump(self):

   143         return self.make_call(2, None, \

   144                 None, self.unpacker.unpack_mountlist)

   145 

   146     def Umnt(self, directory):

   147         return self.make_call(3, directory, \

   148                 self.packer.pack_string, None)

   149 

   150     def Umntall(self):

   151         return self.make_call(4, None, None, None)

   152 

   153     def Export(self):

   154         return self.make_call(5, None, \

   155                 None, self.unpacker.unpack_exportlist)

   156 

   157 

   158 # We turn the partial Mount client into a full one for either protocol

   159 # by use of multiple inheritance.  (In general, when class C has base

   160 # classes B1...Bn, if x is an instance of class C, methods of x are

   161 # searched first in C, then in B1, then in B2, ..., finally in Bn.)

   162 

   163 class TCPMountClient(PartialMountClient, TCPClient):

   164 

   165     def __init__(self, host):

   166         TCPClient.__init__(self, host, MOUNTPROG, MOUNTVERS)

   167 

   168 

   169 class UDPMountClient(PartialMountClient, UDPClient):

   170 

   171     def __init__(self, host):

   172         UDPClient.__init__(self, host, MOUNTPROG, MOUNTVERS)

   173 

   174 

   175 # A little test program for the Mount client.  This takes a host as

   176 # command line argument (default the local machine), prints its export

   177 # list, and attempts to mount and unmount each exported files system.

   178 # An optional first argument of -t or -u specifies the protocol to use

   179 # (TCP or UDP), default is UDP.

   180 

   181 def test():

   182     import sys

   183     if sys.argv[1:] and sys.argv[1] == '-t':

   184         C = TCPMountClient

   185         del sys.argv[1]

   186     elif sys.argv[1:] and sys.argv[1] == '-u':

   187         C = UDPMountClient

   188         del sys.argv[1]

   189     else:

   190         C = UDPMountClient

   191     if sys.argv[1:]: host = sys.argv[1]

   192     else: host = ''

   193     mcl = C(host)

   194     list = mcl.Export()

   195     for item in list:

   196         print item

   197         try:

   198             mcl.Mnt(item[0])

   199         except:

   200             print 'Sorry'

   201             continue

   202         mcl.Umnt(item[0])