Use a bool instead of an int for the follow argument to
[invirt/packages/python-afs.git] / afs / _pts.pyx
1 from afs cimport *
2 from afs import pyafs_error
3
4 cdef import from "afs/ptuser.h":
5     enum:
6         PR_MAXNAMELEN
7         PRGRP
8         PRUSERS
9         PRGROUPS
10         ANONYMOUSID
11         PR_SF_ALLBITS
12         PR_SF_NGROUPS
13         PR_SF_NUSERS
14
15     ctypedef char prname[PR_MAXNAMELEN]
16
17     struct namelist:
18         unsigned int namelist_len
19         prname *namelist_val
20
21     struct prlist:
22         unsigned int prlist_len
23         afs_int32 *prlist_val
24
25     struct idlist:
26         unsigned int idlist_len
27         afs_int32 *idlist_val
28
29     struct prcheckentry:
30         afs_int32 flags
31         afs_int32 id
32         afs_int32 owner
33         afs_int32 creator
34         afs_int32 ngroups
35         afs_int32 nusers
36         afs_int32 count
37         char name[PR_MAXNAMELEN]
38
39     struct prlistentries:
40         afs_int32 flags
41         afs_int32 id
42         afs_int32 owner
43         afs_int32 creator
44         afs_int32 ngroups
45         afs_int32 nusers
46         afs_int32 count
47         char name[PR_MAXNAMELEN]
48
49     struct prentries:
50         unsigned int prentries_len
51         prlistentries *prentries_val
52
53     int ubik_PR_NameToID(ubik_client *, afs_int32, namelist *, idlist *)
54     int ubik_PR_IDToName(ubik_client *, afs_int32, idlist *, namelist *)
55     int ubik_PR_INewEntry(ubik_client *, afs_int32, char *, afs_int32, afs_int32)
56     int ubik_PR_NewEntry(ubik_client *, afs_int32, char *, afs_int32, afs_int32, afs_int32 *)
57     int ubik_PR_Delete(ubik_client *, afs_int32, afs_int32)
58     int ubik_PR_AddToGroup(ubik_client *, afs_int32, afs_int32, afs_int32)
59     int ubik_PR_RemoveFromGroup(ubik_client *, afs_int32, afs_int32, afs_int32)
60     int ubik_PR_ListElements(ubik_client *, afs_int32, afs_int32, prlist *, afs_int32 *)
61     int ubik_PR_ListOwned(ubik_client *, afs_int32, afs_int32, prlist *, afs_int32 *)
62     int ubik_PR_ListEntry(ubik_client *, afs_int32, afs_int32, prcheckentry *)
63     int ubik_PR_ChangeEntry(ubik_client *, afs_int32, afs_int32, char *, afs_int32, afs_int32)
64     int ubik_PR_IsAMemberOf(ubik_client *, afs_int32, afs_int32, afs_int32, afs_int32 *)
65     int ubik_PR_ListMax(ubik_client *, afs_int32, afs_int32 *, afs_int32 *)
66     int ubik_PR_SetMax(ubik_client *, afs_int32, afs_int32, afs_int32)
67     int ubik_PR_ListEntries(ubik_client *, afs_int32, afs_int32, afs_int32, prentries *, afs_int32 *)
68     int ubik_PR_SetFieldsEntry(ubik_client *, afs_int32, afs_int32, afs_int32, afs_int32, afs_int32, afs_int32, afs_int32, afs_int32)
69
70 cdef import from "afs/pterror.h":
71     enum:
72         PRNOENT
73
74 cdef class PTEntry:
75     cdef public afs_int32 flags
76     cdef public afs_int32 id
77     cdef public afs_int32 owner
78     cdef public afs_int32 creator
79     cdef public afs_int32 ngroups
80     cdef public afs_int32 nusers
81     cdef public afs_int32 count
82     cdef public object name
83
84     def __repr__(self):
85         if self.name != '':
86             return '<PTEntry: %s>' % self.name
87         else:
88             return '<PTEntry: PTS ID %s>' % self.id
89
90 cdef int _ptentry_from_c(PTEntry p_entry, prcheckentry * c_entry) except -1:
91     if p_entry is None:
92         raise TypeError
93         return -1
94
95     p_entry.flags = c_entry.flags
96     p_entry.id = c_entry.id
97     p_entry.owner = c_entry.owner
98     p_entry.creator = c_entry.creator
99     p_entry.ngroups = c_entry.ngroups
100     p_entry.nusers = c_entry.nusers
101     p_entry.count = c_entry.count
102     p_entry.name = c_entry.name
103     return 0
104
105 cdef int _ptentry_to_c(prcheckentry * c_entry, PTEntry p_entry) except -1:
106     if p_entry is None:
107         raise TypeError
108         return -1
109
110     c_entry.flags = p_entry.flags
111     c_entry.id = p_entry.id
112     c_entry.owner = p_entry.owner
113     c_entry.creator = p_entry.creator
114     c_entry.ngroups = p_entry.ngroups
115     c_entry.nusers = p_entry.nusers
116     c_entry.count = p_entry.count
117     strncpy(c_entry.name, p_entry.name, sizeof(c_entry.name))
118     return 0
119
120 cdef class PTS:
121     """
122     A PTS object is essentially a handle to talk to the server in a
123     given cell.
124
125     cell defaults to None. If no argument is passed for cell, PTS
126     connects to the home cell.
127
128     sec is the security level, an integer from 0 to 3:
129       - 0: unauthenticated connection
130       - 1: try authenticated, then fall back to unauthenticated
131       - 2: fail if an authenticated connection can't be established
132       - 3: same as 2, plus encrypt all traffic to the protection
133         server
134     """
135     cdef ubik_client * client
136     cdef readonly object cell
137
138     def __cinit__(self, cell=None, sec=1):
139         cdef afs_int32 code
140         cdef afsconf_dir *cdir
141         cdef afsconf_cell info
142         cdef char * c_cell
143         cdef ktc_principal prin
144         cdef ktc_token token
145         cdef rx_securityClass *sc
146         cdef rx_connection *serverconns[MAXSERVERS]
147         cdef int i
148
149         initialize_PT_error_table()
150
151         if cell is None:
152             c_cell = NULL
153         else:
154             c_cell = cell
155
156         self.client = NULL
157
158         code = rx_Init(0)
159         if code != 0:
160             raise Exception(code, "Error initializing Rx")
161
162         cdir = afsconf_Open(AFSDIR_CLIENT_ETC_DIRPATH)
163         if cdir is NULL:
164             raise OSError(errno,
165                           "Error opening configuration directory (%s): %s" % \
166                               (AFSDIR_CLIENT_ETC_DIRPATH, strerror(errno)))
167         code = afsconf_GetCellInfo(cdir, c_cell, "afsprot", &info)
168         pyafs_error(code)
169
170         self.cell = info.name
171
172         if sec > 0:
173             strncpy(prin.cell, info.name, sizeof(prin.cell))
174             prin.instance[0] = 0
175             strncpy(prin.name, "afs", sizeof(prin.name))
176
177             code = ktc_GetToken(&prin, &token, sizeof(token), NULL);
178             if code != 0:
179                 if sec >= 2:
180                     # No really - we wanted authentication
181                     pyafs_error(code)
182                 sec = 0
183             else:
184                 if sec == 3:
185                     level = rxkad_crypt
186                 else:
187                     level = rxkad_clear
188                 sc = rxkad_NewClientSecurityObject(level, &token.sessionKey,
189                                                    token.kvno, token.ticketLen,
190                                                    token.ticket)
191
192         if sec == 0:
193             sc = rxnull_NewClientSecurityObject()
194         else:
195             sec = 2
196
197         memset(serverconns, 0, sizeof(serverconns))
198         for 0 <= i < info.numServers:
199             serverconns[i] = rx_NewConnection(info.hostAddr[i].sin_addr.s_addr,
200                                               info.hostAddr[i].sin_port,
201                                               PRSRV,
202                                               sc,
203                                               sec)
204
205         code = ubik_ClientInit(serverconns, &self.client)
206         pyafs_error(code)
207
208         code = rxs_Release(sc)
209
210     def __dealloc__(self):
211         ubik_ClientDestroy(self.client)
212         rx_Finalize()
213
214     def _NameOrId(self, ident):
215         """
216         Given an identifier, convert it to a PTS ID by looking up the
217         name if it's a string, or otherwise just converting it to an
218         integer.
219         """
220         if isinstance(ident, basestring):
221             return self._NameToId(ident)
222         else:
223             return int(ident)
224
225     def _NameToId(self, name):
226         """
227         Converts a user or group to an AFS ID.
228         """
229         cdef namelist lnames
230         cdef idlist lids
231         cdef afs_int32 code, id = ANONYMOUSID
232         name = name.lower()
233
234         lids.idlist_len = 0
235         lids.idlist_val = NULL
236         lnames.namelist_len = 1
237         lnames.namelist_val = <prname *>malloc(PR_MAXNAMELEN)
238         strncpy(lnames.namelist_val[0], name, PR_MAXNAMELEN)
239         code = ubik_PR_NameToID(self.client, 0, &lnames, &lids)
240         if lids.idlist_val is not NULL:
241             id = lids.idlist_val[0]
242             free(lids.idlist_val)
243         if id == ANONYMOUSID:
244             code = PRNOENT
245         pyafs_error(code)
246         return id
247
248     def _IdToName(self, id):
249         """
250         Convert an AFS ID to the name of a user or group.
251         """
252         cdef namelist lnames
253         cdef idlist lids
254         cdef afs_int32 code
255         cdef char name[PR_MAXNAMELEN]
256
257         lids.idlist_len = 1
258         lids.idlist_val = <afs_int32 *>malloc(sizeof(afs_int32))
259         lids.idlist_val[0] = id
260         lnames.namelist_len = 0
261         lnames.namelist_val = NULL
262         code = ubik_PR_IDToName(self.client, 0, &lids, &lnames)
263         if lnames.namelist_val is not NULL:
264             strncpy(name, lnames.namelist_val[0], sizeof(name))
265             free(lnames.namelist_val)
266         if lids.idlist_val is not NULL:
267             free(lids.idlist_val)
268         if name == str(id):
269             code = PRNOENT
270         pyafs_error(code)
271         return name
272
273     def _CreateUser(self, name, id=None):
274         """
275         Create a new user in the protection database. If an ID is
276         provided, that one will be used.
277         """
278         cdef afs_int32 code
279         cdef afs_int32 cid
280         name = name[:PR_MAXNAMELEN].lower()
281
282         if id is not None:
283             cid = id
284
285         if id is not None:
286             code = ubik_PR_INewEntry(self.client, 0, name, cid, 0)
287         else:
288             code = ubik_PR_NewEntry(self.client, 0, name, 0, 0, &cid)
289
290         pyafs_error(code)
291         return cid
292
293     def _CreateGroup(self, name, owner, id=None):
294         """
295         Create a new group in the protection database. If an ID is
296         provided, that one will be used.
297         """
298         cdef afs_int32 code, cid
299
300         name = name[:PR_MAXNAMELEN].lower()
301         oid = self._NameOrId(owner)
302
303         if id is not None:
304             cid = id
305             code = ubik_PR_INewEntry(self.client, 0, name, cid, oid)
306         else:
307             code = ubik_PR_NewEntry(self.client, 0, name, PRGRP, oid, &cid)
308
309         pyafs_error(code)
310         return cid
311
312     def _Delete(self, ident):
313         """
314         Delete the protection database entry with the provided
315         identifier.
316         """
317         cdef afs_int32 code
318         cdef afs_int32 id = self._NameOrId(ident)
319
320         code = ubik_PR_Delete(self.client, 0, id)
321         pyafs_error(code)
322
323     def _AddToGroup(self, user, group):
324         """
325         Add the given user to the given group.
326         """
327         cdef afs_int32 code
328         cdef afs_int32 uid = self._NameOrId(user), gid = self._NameOrId(group)
329
330         code = ubik_PR_AddToGroup(self.client, 0, uid, gid)
331         pyafs_error(code)
332
333     def _RemoveFromGroup(self, user, group):
334         """
335         Remove the given user from the given group.
336         """
337         cdef afs_int32 code
338         cdef afs_int32 uid = self._NameOrId(user), gid = self._NameOrId(group)
339
340         code = ubik_PR_RemoveFromGroup(self.client, 0, uid, gid)
341         pyafs_error(code)
342
343     def _ListMembers(self, ident):
344         """
345         Get the membership of an entity.
346
347         If id is a group, this returns the users that are in that
348         group.
349
350         If id is a user, this returns the list of groups that user is
351         on.
352
353         This returns a list of PTS IDs.
354         """
355         cdef afs_int32 code, over
356         cdef prlist alist
357         cdef int i
358         cdef object members = []
359
360         cdef afs_int32 id = self._NameOrId(ident)
361
362         alist.prlist_len = 0
363         alist.prlist_val = NULL
364
365         code = ubik_PR_ListElements(self.client, 0, id, &alist, &over)
366
367         if alist.prlist_val is not NULL:
368             for i in range(alist.prlist_len):
369                 members.append(alist.prlist_val[i])
370             free(alist.prlist_val)
371
372         pyafs_error(code)
373
374         return members
375
376     def _ListOwned(self, owner):
377         """
378         Get all groups owned by an entity.
379         """
380         cdef afs_int32 code, over
381         cdef prlist alist
382         cdef int i
383         cdef object owned = []
384
385         cdef afs_int32 oid = self._NameOrId(owner)
386
387         alist.prlist_len = 0
388         alist.prlist_val = NULL
389
390         code = ubik_PR_ListOwned(self.client, 0, oid, &alist, &over)
391
392         if alist.prlist_val is not NULL:
393             for i in range(alist.prlist_len):
394                 owned.append(alist.prlist_val[i])
395             free(alist.prlist_val)
396
397         pyafs_error(code)
398
399         return owned
400
401     def _ListEntry(self, ident):
402         """
403         Load a PTEntry instance with information about the provided
404         entity.
405         """
406         cdef afs_int32 code
407         cdef prcheckentry centry
408         cdef object entry = PTEntry()
409
410         cdef afs_int32 id = self._NameOrId(ident)
411
412         code = ubik_PR_ListEntry(self.client, 0, id, &centry)
413         pyafs_error(code)
414
415         _ptentry_from_c(entry, &centry)
416         return entry
417
418     def _ChangeEntry(self, ident, newname=None, newid=None, newoid=None):
419         """
420         Change the name, ID, and/or owner of a PTS entity.
421
422         For any of newname, newid, and newoid which aren't specified
423         or ar None, the value isn't changed.
424         """
425         cdef afs_int32 code
426         cdef afs_int32 c_newid = 0, c_newoid = 0
427         cdef char * c_newname
428
429         cdef afs_int32 id = self._NameOrId(ident)
430
431         if newname is None:
432             newname = self._IdToName(id)
433         c_newname = newname
434         if newid is not None:
435             c_newid = newid
436         if newoid is not None:
437             c_newoid = newoid
438
439         code = ubik_PR_ChangeEntry(self.client, 0, id, c_newname, c_newoid, c_newid)
440         pyafs_error(code)
441
442     def _IsAMemberOf(self, user, group):
443         """
444         Return True if the given user is a member of the given group.
445         """
446         cdef afs_int32 code
447         cdef afs_int32 flag
448
449         cdef afs_int32 uid = self._NameOrId(user), gid = self._NameOrId(group)
450
451         code = ubik_PR_IsAMemberOf(self.client, 0, uid, gid, &flag)
452         pyafs_error(code)
453
454         return bool(flag)
455
456     def _ListMax(self):
457         """
458         Return a tuple of the maximum user ID and the maximum group
459         ID currently assigned.
460         """
461         cdef afs_int32 code, uid, gid
462
463         code = ubik_PR_ListMax(self.client, 0, &uid, &gid)
464         pyafs_error(code)
465
466         return (uid, gid)
467
468     def _SetMaxUserId(self, id):
469         """
470         Set the maximum currently assigned user ID (the next
471         automatically assigned UID will be id + 1)
472         """
473         cdef afs_int32 code
474
475         code = ubik_PR_SetMax(self.client, 0, id, 0)
476         pyafs_error(code)
477
478     def _SetMaxGroupId(self, id):
479         """
480         Set the maximum currently assigned user ID (the next
481         automatically assigned UID will be id + 1)
482         """
483         cdef afs_int32 code
484
485         code = ubik_PR_SetMax(self.client, 0, id, PRGRP)
486         pyafs_error(code)
487
488     def _ListEntries(self, users=None, groups=None):
489         """
490         Return a list of PTEntry instances representing all entries in
491         the PRDB.
492
493         Returns just users by default, but can return just users, just
494         groups, or both.
495         """
496         cdef afs_int32 code
497         cdef afs_int32 flag = 0, startindex = 0, nentries, nextstartindex
498         cdef prentries centries
499         cdef unsigned int i
500
501         cdef object entries = []
502
503         if groups is None or users is True:
504             flag |= PRUSERS
505         if groups:
506             flag |= PRGROUPS
507
508         while startindex != -1:
509             centries.prentries_val = NULL
510             centries.prentries_len = 0
511             nextstartindex = -1
512
513             code = ubik_PR_ListEntries(self.client, 0, flag, startindex, &centries, &nextstartindex)
514             if centries.prentries_val is not NULL:
515                 for i in range(centries.prentries_len):
516                     e = PTEntry()
517                     _ptentry_from_c(e, <prcheckentry *>&centries.prentries_val[i])
518                     entries.append(e)
519                 free(centries.prentries_val)
520             pyafs_error(code)
521
522             startindex = nextstartindex
523
524         return entries
525
526     def _SetFields(self, ident, access=None, groups=None, users=None):
527         """
528         Update the fields for an entry.
529
530         Valid fields are the privacy flags (access), the group quota
531         (groups), or the "foreign user quota" (users), which doesn't
532         actually seem to do anything, but is included for
533         completeness.
534         """
535         cdef afs_int32 code
536         cdef afs_int32 mask = 0, flags = 0, nusers = 0, ngroups = 0
537
538         cdef afs_int32 id = self._NameOrId(ident)
539
540         if access is not None:
541             flags = access
542             mask |= PR_SF_ALLBITS
543         if groups is not None:
544             ngroups = groups
545             mask |= PR_SF_NGROUPS
546         if users is not None:
547             nusers = users
548             mask |= PR_SF_NGROUPS
549
550         code = ubik_PR_SetFieldsEntry(self.client, 0, id, mask, flags, ngroups, nusers, 0, 0)
551         pyafs_error(code)