# This contains basics that can be used for creating either
# an NFS server or a client.

from xdrlib2 import *
from sunrpc import RPCProgramDef, initializeProgram
from nfscommon import *

# The size in bytes of the opaque file handle.
FHSIZE = 32

# The maximum number of bytes of data in a READ or WRITE
# request.
MAXDATA = 8192
 
# The maximum number of bytes in a pathname argument.
MAXPATHLEN = 1024
 
# The maximum number of bytes in a file name argument.
MAXNAMLEN = 255
 
# The size in bytes of the opaque "cookie" passed by READDIR.
# COOKIESIZE  = 4
 

class NFSStatResult (XDRBase):
    __xdr_fields__ = (
        NFSStat('status'),
        )

    def __init__(self, status):
        self.status = status


class NFSFH (XDRBase):
    'A file handle.'
    __xdr_fields__ = (
        XDR_fopaque('data', FHSIZE),
        )

    def __init__(self, data):
        self.data = data

NFSFHField = XDRFieldFactory(NFSFH)

class FType (XDR_enum):
    NFNON    = 0
    NFREG    = 1
    NFDIR    = 2
    NFBLK    = 3
    NFCHR    = 4
    NFLNK    = 5

class Mode (XDR_uint32):
    pass

class Filename (XDR_string):
    max = MAXNAMLEN

class NFSPath (XDR_string):
    max = MAXPATHLEN

class FileId (XDR_uint32):
    pass

#class Cookie (XDR_fopaque):
#    size = COOKIESIZE

# The above is technically correct, but the definition below is more useful.
class Cookie (XDR_uint32):
    pass

class UID (XDR_uint32):
    pass

class GID (XDR_uint32):
    pass

class Size (XDR_uint32):
    pass

class Offset (XDR_uint32):
    pass

class Mode (XDR_uint32):
##      0040000 This is a directory; "type" field should be NFDIR.
##      0020000 This is a character special file; "type" field should
##              be NFCHR.
##      0060000 This is a block special file; "type" field should be
##              NFBLK.
##      0100000 This is a regular file; "type" field should be NFREG.
##      0120000 This is a symbolic link file;  "type" field should be
##              NFLNK.
##      0140000 This is a named socket; "type" field should be NFNON.
##      0004000 Set user id on execution.
##      0002000 Set group id on execution.
##      0001000 Save swapped text even after use.
##      0000400 Read permission for owner.
##      0000200 Write permission for owner.
##      0000100 Execute and search permission for owner.
##      0000040 Read permission for group.
##      0000020 Write permission for group.
##      0000010 Execute and search permission for group.
##      0000004 Read permission for others.
##      0000002 Write permission for others.
##      0000001 Execute and search permission for others.
    pass

class Count (XDR_uint32):
    pass


class TimeVal (XDRBase):
    __xdr_fields__ = (
        XDR_uint32('seconds'),
        XDR_uint32('useconds'),
        )

    def __init__(self, t):
        v = long(t)
        self.seconds = v
        self.useconds = int((t - v) * 1000000)

TimeValField = XDRFieldFactory(TimeVal)

class FAttr (XDRBase):
    __xdr_fields__ = (
        FType('type'),
        Mode('mode'),
        XDR_uint('nlink'),
        UID('uid'),
        GID('gid'),
        Size('size'),
        Size('blocksize'),
        XDR_uint32('rdev'),
        XDR_uint32('blocks'),
        XDR_uint32('fsid'),
        FileId('fileid'),
        TimeValField('atime'),
        TimeValField('mtime'),
        TimeValField('ctime'),
        )

    nlink = 1
    blocksize = 512
    rdev = 0

    def __init__(self, isDir, access_bits, uid, gid, size, fsid, fileid,
                 atime, mtime, ctime):
        self.type = isDir and FType.NFDIR or FType.NFREG
        # Note the octal notation.
        self.mode = (isDir and 0040000 or 0100000) | access_bits
        self.uid = uid
        self.gid = gid
        self.size = size
        self.blocks = (size + self.blocksize - 1) / self.blocksize
        self.fsid = fsid
        self.fileid = fileid
        self.atime = TimeVal(atime)
        self.mtime = TimeVal(mtime)
        self.ctime = TimeVal(ctime)
                 

FAttrField = XDRFieldFactory(FAttr)

class AttrStat (XDRBase):
    __xdr_fields__ = (
        XDR_explicit_union('status',
                           {NFSStat.NFS_OK: FAttrField('attributes')}
                           ),
        )

AttrStatField = XDRFieldFactory(AttrStat)



##class TimeHow (XDR_enum):
##    DONT_CHANGE        = 0
##    SET_TO_SERVER_TIME = 1
##    SET_TO_CLIENT_TIME = 2

class SetMode (XDRBase):
    set_it = 1
    __xdr_fields__ = (
        Mode('mode'),
        )

class SetUID (XDRBase):
    set_it = 1
    __xdr_fields__ = (
        UID('uid'),
        )

class SetGID (XDRBase):
    set_it = 1
    __xdr_fields__ = (
        GID('gid'),
        )

class SetSize (XDRBase):
    set_it = 1
    __xdr_fields__ = (
        Size('size'),
        )

class SetATime (XDRBase):
    set_it = 1
    __xdr_fields__ = (
        TimeValField('atime'),
        )

class SetMTime (XDRBase):
    set_it = 1
    __xdr_fields__ = (
        TimeValField('mtime'),
        )

class SAttr (XDRBase):
    __xdr_fields__ = (
        XDR_struct('mode', SetMode),
        XDR_struct('uid', SetUID),
        XDR_struct('gid', SetGID),
        XDR_struct('size', SetSize),
        XDR_struct('atime', SetATime),
        XDR_struct('mtime', SetMTime),
        )        

SAttrField = XDRFieldFactory(SAttr)


class DirOpArgs (XDRBase):
    __xdr_fields__ = (
        NFSFHField('dir'),
        Filename('name'),
        )

DirOpArgsField = XDRFieldFactory(DirOpArgs)


class DirOpRes (XDRBase):
    __xdr_fields__ = (
        XDR_explicit_union('status', {NFSStat.NFS_OK:
                                      (NFSFHField('handle'),
                                       FAttrField('attributes'))
                                      }),
        )

DirOpResField = XDRFieldFactory(DirOpRes)


class NFS_V2_Program (RPCProgramDef):
    program = 100003
    version = 2

    procnames = {
        0: 'null',
        1: 'getattr',
        2: 'setattr',
        3: 'root',
        4: 'lookup',
        5: 'readlink',
        6: 'read',
        7: 'writecache',
        8: 'write',
        9: 'create',
        10: 'remove',
        11: 'rename',
        12: 'hardlink',
        13: 'symlink',
        14: 'mkdir',
        15: 'rmdir',
        16: 'readdir',
        17: 'statfs',
        }




null_need_auth = 0
null_args = None
null_res = None




class getattr_args (XDRBase):
    __xdr_fields__ = (
        NFSFHField('handle'),
        )

getattr_res = AttrStat




class setattr_args (XDRBase):
    __xdr_fields__ = (
        NFSFHField('handle'),
        SAttrField('attributes'),
        )

setattr_res = AttrStat






root_args = None
root_res = None





class lookup_args (XDRBase):
    __xdr_fields__ = (
        DirOpArgsField('what'),
        )

lookup_res = DirOpRes









class readlink_args (XDRBase):
    __xdr_fields__ = (
        NFSFHField('handle'),
        )

class readlink_res (XDRBase):
    __xdr_fields__ = (
        XDR_explicit_union('status', {NFSStat.NFS_OK:
                                      (NFSPath('data'),)
                                      }),
        )






class read_args (XDRBase):
    __xdr_fields__ = (
        NFSFHField('handle'),
        Offset('offset'),
        Count('count'),
        Count('totalcount'),
        )

class read_res (XDRBase):
    __xdr_fields__ = (
        XDR_explicit_union('status', {NFSStat.NFS_OK:
                                      (FAttrField('attributes'),
                                       XDR_opaque('data'),)
                                      }),
        )




writecache_args = None
writecache_res = None




class write_args (XDRBase):
    __xdr_fields__ = (
        NFSFHField('handle'),
        Offset('beginoffset'),
        Offset('offset'),
        Count('totalcount'),
        XDR_opaque('data'),
        )

write_res = AttrStat





class create_args (XDRBase):
    __xdr_fields__ = (
        DirOpArgsField('where'),
        SAttrField('attributes'),
        )

create_res = DirOpRes





class remove_args (XDRBase):
    __xdr_fields__ = (
        DirOpArgsField('object'),
        )

class remove_res (XDRBase):
    __xdr_fields__ = (
        NFSStat('status'),
        )





class rename_args (XDRBase):
    __xdr_fields__ = (
        DirOpArgsField('rename_from'),
        DirOpArgsField('rename_to'),
        )

class rename_res (XDRBase):
    __xdr_fields__ = (
        NFSStat('status'),
        )





class hardlink_args (XDRBase):
    __xdr_fields__ = (
        NFSFHField('handle'),
        DirOpArgsField('where'),
        )

class hardlink_res (XDRBase):
    __xdr_fields__ = (
        NFSStat('status'),
        )





class symlink_args (XDRBase):
    __xdr_fields__ = (
        DirOpArgsField('where'),
        NFSPath('path'),
        SAttrField('attributes'),
        )

class symlink_res (XDRBase):
    __xdr_fields__ = (
        NFSStat('status'),
        )






class mkdir_args (XDRBase):
    __xdr_fields__ = (
        DirOpArgsField('where'),
        SAttrField('attributes'),
        )

mkdir_res = DirOpRes






rmdir_args = remove_args
rmdir_res = remove_res





class readdir_args (XDRBase):
    __xdr_fields__ = (
        NFSFHField('handle'),
        Cookie('cookie'),
        Count('count'),
        )

class Entry (XDRBase):
    __xdr_fields__ = (
        FileId('fileid'),
        Filename('name'),
        Cookie('cookie'),
        )

class DirList (XDRBase):
    __xdr_fields__ = (
        XDR_list('entries', Entry),
        XDR_bool('eof'),
        )

class readdir_res (XDRBase):
    __xdr_fields__ = (
        XDR_explicit_union('status', {NFSStat.NFS_OK:
                                      (XDR_struct('reply', DirList),)
                                      }),
        )





class statfs_args (XDRBase):
    __xdr_fields__ = (
        NFSFHField('root_handle'),
        )

class statfs_resok (XDRBase):
    __xdr_fields__ = (
        Size('tsize'),
        Size('bsize'),
        Size('blocks'),
        Size('bfree'),
        Size('bavail'),
        )

class statfs_res (XDRBase):
    __xdr_fields__ = (
        XDR_explicit_union('status', {NFSStat.NFS_OK:
                                      (XDR_struct('info', statfs_resok),)
                                      }),
        )




initializeProgram(NFS_V2_Program, globals())


if __name__ == '__main__':
    l = list(NFS_V2_Program.procs.items())
    l.sort()
    for item in l:
        print item