sys/lib/python/plat-os2emx/pwd.py

   1 # this module is an OS/2 oriented replacement for the pwd standard
   2 # extension module.
   3
   4 # written by Andrew MacIntyre, April 2001.
   5 # updated July 2003, adding field accessor support
   6
   7 # note that this implementation checks whether ":" or ";" as used as
   8 # the field separator character.  Path conversions are are applied when
   9 # the database uses ":" as the field separator character.
  10
  11 """Replacement for pwd standard extension module, intended for use on
  12 OS/2 and similar systems which don't normally have an /etc/passwd file.
  13
  14 The standard Unix password database is an ASCII text file with 7 fields
  15 per record (line), separated by a colon:
  16   - user name (string)
  17   - password (encrypted string, or "*" or "")
  18   - user id (integer)
  19   - group id (integer)
  20   - description (usually user's name)
  21   - home directory (path to user's home directory)
  22   - shell (path to the user's login shell)
  23
  24 (see the section 8.1 of the Python Library Reference)
  25
  26 This implementation differs from the standard Unix implementation by
  27 allowing use of the platform's native path separator character - ';' on OS/2,
  28 DOS and MS-Windows - as the field separator in addition to the Unix
  29 standard ":".  Additionally, when ":" is the separator path conversions
  30 are applied to deal with any munging of the drive letter reference.
  31
  32 The module looks for the password database at the following locations
  33 (in order first to last):
  34   - ${ETC_PASSWD}             (or %ETC_PASSWD%)
  35   - ${ETC}/passwd             (or %ETC%/passwd)
  36   - ${PYTHONHOME}/Etc/passwd  (or %PYTHONHOME%/Etc/passwd)
  37
  38 Classes
  39 -------
  40
  41 None
  42
  43 Functions
  44 ---------
  45
  46 getpwuid(uid) -  return the record for user-id uid as a 7-tuple
  47
  48 getpwnam(name) - return the record for user 'name' as a 7-tuple
  49
  50 getpwall() -     return a list of 7-tuples, each tuple being one record
  51                  (NOTE: the order is arbitrary)
  52
  53 Attributes
  54 ----------
  55
  56 passwd_file -    the path of the password database file
  57
  58 """
  59
  60 import os
  61
  62 # try and find the passwd file
  63 __passwd_path = []
  64 if os.environ.has_key('ETC_PASSWD'):
  65     __passwd_path.append(os.environ['ETC_PASSWD'])
  66 if os.environ.has_key('ETC'):
  67     __passwd_path.append('%s/passwd' % os.environ['ETC'])
  68 if os.environ.has_key('PYTHONHOME'):
  69     __passwd_path.append('%s/Etc/passwd' % os.environ['PYTHONHOME'])
  70
  71 passwd_file = None
  72 for __i in __passwd_path:
  73     try:
  74         __f = open(__i, 'r')
  75         __f.close()
  76         passwd_file = __i
  77         break
  78     except:
  79         pass
  80
  81 # path conversion handlers
  82 def __nullpathconv(path):
  83     return path.replace(os.altsep, os.sep)
  84
  85 def __unixpathconv(path):
  86     # two known drive letter variations: "x;" and "$x"
  87     if path[0] == '$':
  88         conv = path[1] + ':' + path[2:]
  89     elif path[1] == ';':
  90         conv = path[0] + ':' + path[2:]
  91     else:
  92         conv = path
  93     return conv.replace(os.altsep, os.sep)
  94
  95 # decide what field separator we can try to use - Unix standard, with
  96 # the platform's path separator as an option.  No special field conversion
  97 # handler is required when using the platform's path separator as field
  98 # separator, but are required for the home directory and shell fields when
  99 # using the standard Unix (":") field separator.
 100 __field_sep = {':': __unixpathconv}
 101 if os.pathsep:
 102     if os.pathsep != ':':
 103         __field_sep[os.pathsep] = __nullpathconv
 104
 105 # helper routine to identify which separator character is in use
 106 def __get_field_sep(record):
 107     fs = None
 108     for c in __field_sep.keys():
 109         # there should be 6 delimiter characters (for 7 fields)
 110         if record.count(c) == 6:
 111             fs = c
 112             break
 113     if fs:
 114         return fs
 115     else:
 116         raise KeyError, '>> passwd database fields not delimited <<'
 117
 118 # class to match the new record field name accessors.
 119 # the resulting object is intended to behave like a read-only tuple,
 120 # with each member also accessible by a field name.
 121 class Passwd:
 122     def __init__(self, name, passwd, uid, gid, gecos, dir, shell):
 123         self.__dict__['pw_name'] = name
 124         self.__dict__['pw_passwd'] = passwd
 125         self.__dict__['pw_uid'] = uid
 126         self.__dict__['pw_gid'] = gid
 127         self.__dict__['pw_gecos'] = gecos
 128         self.__dict__['pw_dir'] = dir
 129         self.__dict__['pw_shell'] = shell
 130         self.__dict__['_record'] = (self.pw_name, self.pw_passwd,
 131                                     self.pw_uid, self.pw_gid,
 132                                     self.pw_gecos, self.pw_dir,
 133                                     self.pw_shell)
 134
 135     def __len__(self):
 136         return 7
 137
 138     def __getitem__(self, key):
 139         return self._record[key]
 140
 141     def __setattr__(self, name, value):
 142         raise AttributeError('attribute read-only: %s' % name)
 143
 144     def __repr__(self):
 145         return str(self._record)
 146
 147     def __cmp__(self, other):
 148         this = str(self._record)
 149         if this == other:
 150             return 0
 151         elif this < other:
 152             return -1
 153         else:
 154             return 1
 155
 156
 157 # read the whole file, parsing each entry into tuple form
 158 # with dictionaries to speed recall by UID or passwd name
 159 def __read_passwd_file():
 160     if passwd_file:
 161         passwd = open(passwd_file, 'r')
 162     else:
 163         raise KeyError, '>> no password database <<'
 164     uidx = {}
 165     namx = {}
 166     sep = None
 167     while 1:
 168         entry = passwd.readline().strip()
 169         if len(entry) > 6:
 170             if sep == None:
 171                 sep = __get_field_sep(entry)
 172             fields = entry.split(sep)
 173             for i in (2, 3):
 174                 fields[i] = int(fields[i])
 175             for i in (5, 6):
 176                 fields[i] = __field_sep[sep](fields[i])
 177             record = Passwd(*fields)
 178             if not uidx.has_key(fields[2]):
 179                 uidx[fields[2]] = record
 180             if not namx.has_key(fields[0]):
 181                 namx[fields[0]] = record
 182         elif len(entry) > 0:
 183             pass                         # skip empty or malformed records
 184         else:
 185             break
 186     passwd.close()
 187     if len(uidx) == 0:
 188         raise KeyError
 189     return (uidx, namx)
 190
 191 # return the passwd database entry by UID
 192 def getpwuid(uid):
 193     u, n = __read_passwd_file()
 194     return u[uid]
 195
 196 # return the passwd database entry by passwd name
 197 def getpwnam(name):
 198     u, n = __read_passwd_file()
 199     return n[name]
 200
 201 # return all the passwd database entries
 202 def getpwall():
 203     u, n = __read_passwd_file()
 204     return n.values()
 205
 206 # test harness
 207 if __name__ == '__main__':
 208     getpwall()