Tidy up libacl
[openafs.git] / src / libacl / aclprocs.c
1 /*
2  * Copyright 2000, International Business Machines Corporation and others.
3  * All Rights Reserved.
4  * 
5  * This software has been released under the terms of the IBM Public
6  * License.  For details, see the LICENSE file in the top-level source
7  * directory or online at http://www.openafs.org/dl/license10.html
8  */
9
10 /*
11         Information Technology Center
12         Carnegie-Mellon University
13 */
14
15
16 #include <afsconfig.h>
17 #include <afs/param.h>
18
19
20 #include <sys/types.h>
21 #ifdef AFS_NT40_ENV
22 #include <winsock2.h>
23 #else
24 #include <netinet/in.h>
25 #endif
26 #include <string.h>
27 #include <rx/xdr.h>
28 #include <rx/rx.h>
29 #include <afs/ptclient.h>
30 #include <afs/ptuser.h>
31 #include "acl.h"
32
33 #ifdef AFS_PTHREAD_ENV
34 #include <assert.h>
35 #include <pthread.h>
36 pthread_mutex_t acl_list_mutex;
37 #endif /* AFS_PTHREAD_ENV */
38
39 struct freeListEntry {
40     struct freeListEntry *next;
41     int size;
42     char body[1];
43 };
44
45 struct freeListEntry *freeList;
46
47 static int AddToList(struct freeListEntry **, struct freeListEntry *);
48 static int GetFromList(struct freeListEntry **, struct freeListEntry **,
49                        afs_int32);
50
51 /*todo: for sorting acls - make sure they work with new groups lists 10/5*/
52 static int
53 CmpPlus(const void *arg1, const void *arg2)
54 {
55     const struct acl_accessEntry *a = (struct acl_accessEntry *) arg1;
56     const struct acl_accessEntry *b = (struct acl_accessEntry *) arg2;
57     if (a->id < b->id)
58         return (-1);
59     if (a->id == b->id)
60         return (0);
61     return (1);
62 }
63
64 static int
65 CmpMinus(const void *arg1, const void *arg2)
66 {
67     const struct acl_accessEntry *a = (struct acl_accessEntry *) arg1;
68     const struct acl_accessEntry *b = (struct acl_accessEntry *) arg2;
69                 
70     if (a->id > b->id)
71         return (-1);
72     if (a->id == b->id)
73         return (0);
74     return (1);
75 }
76
77 static int
78 CmpInt(int x, int y)
79 {
80     if (x < y)
81         return (-1);
82     if (x == y)
83         return (0);
84     return (1);
85 }
86
87
88 int
89 acl_NewACL(int nEntries, struct acl_accessList **acl)
90 {
91     /* Creates an access list capable of holding at least nEntries entries.
92      * Returns 0 on success; aborts if we run out of memory. */
93
94     int t;
95     struct freeListEntry *e;
96
97     t = sizeof(struct acl_accessList) + (nEntries -
98                                          1) * sizeof(struct acl_accessEntry);
99     if (GetFromList(&freeList, &e, t) < 0) {
100         e = (struct freeListEntry *)malloc(t + sizeof(int) +
101                                            sizeof(struct freeListEntry *));
102         if (e == NULL) {
103             perror("acl_NewACL: malloc() failed");
104             abort();
105         }
106         e->size = t;
107         *acl = (struct acl_accessList *)(e->body);
108     } else
109         *acl = (struct acl_accessList *)(e->body);
110
111     (*acl)->size = t;           /* May be less than actual size of storage */
112     (*acl)->version = ACL_ACLVERSION;
113     (*acl)->total = nEntries;
114     (*acl)->positive = (*acl)->negative = 0;
115     return (0);
116 }
117
118
119 int
120 acl_FreeACL(struct acl_accessList **acl)
121 {
122     /* Releases the access list defined by acl.  Returns 0 always. */
123     struct freeListEntry *x;
124
125     x = (struct freeListEntry *)
126         ((char *)*acl - sizeof(struct freeListEntry *) - sizeof(int));
127     *acl = NULL;
128     return (AddToList(&freeList, x));
129 }
130
131 int
132 acl_NewExternalACL(int nEntries, char **r)
133 {
134     /* Puts an external acl big enough to hold nEntries in r.  Returns 0 on success, aborts if insufficient memory. */
135
136     int t;
137     struct freeListEntry *e;
138
139     t = 20 + (nEntries) * (PR_MAXNAMELEN + 20);
140     /* Conservative estimate: enough space in each entry for longest 
141      * name plus decimal 2**32 (for largest rights mask) plus some formatting */
142
143     if (GetFromList(&freeList, &e, t)) {
144         e = (struct freeListEntry *)malloc(t + sizeof(int) +
145                                            sizeof(struct freeListEntry *));
146         if (e == NULL) {
147             perror("acl_NewExternalACL(): malloc() failed");
148             abort();
149         }
150         e->size = t;
151     }
152
153     *r = e->body;
154     sprintf(*r, "0\n0\n");
155     return (0);
156 }
157
158 int
159 acl_FreeExternalACL(char **r)
160 {
161     /* Releases the external access list defined by r.  Returns 0 always.  */
162
163     struct freeListEntry *x;
164
165     x = (struct freeListEntry *)
166         ((char *)*r - sizeof(struct freeListEntry *) - sizeof(int));
167     *r = NULL;
168     return (AddToList(&freeList, x));
169 }
170
171
172 int
173 acl_Externalize(struct acl_accessList *acl, char **elist)
174 {
175     /* Converts the access list defined by acl into the external access list 
176      * in elist.  Non-translatable id's are converted to their ASCII string 
177      * representations.  Returns 0 on success, -1 if number of entries 
178      * exceeds ACL_MAXENTRIES, or a failure code from the protection server 
179      * if the problem occured there. */
180
181     register int i;
182     register int j;
183     register int code;
184     register char *nextc;
185     idlist lids;
186     namelist lnames;
187
188     if (acl->total > ACL_MAXENTRIES)
189         return (-1);
190     acl_NewExternalACL(acl->total, elist);
191     nextc = *elist;
192     lids.idlist_val =
193         (afs_int32 *) malloc(ACL_MAXENTRIES * sizeof(afs_int32));
194     memset(lids.idlist_val, 0, ACL_MAXENTRIES * sizeof(afs_int32));
195     lids.idlist_len = acl->total;
196     lnames.namelist_len = 0;
197     lnames.namelist_val = (prname *) 0;
198     sprintf(nextc, "%d\n%d\n", acl->positive, acl->negative);
199     nextc += strlen(nextc);
200     for (i = 0; i < acl->positive; i++)
201         lids.idlist_val[i] = acl->entries[i].id;
202     j = i;
203     for (i = acl->total - 1; i >= acl->total - acl->negative; i--, j++)
204         lids.idlist_val[j] = acl->entries[i].id;
205     code = pr_IdToName(&lids, &lnames);
206     if (code != 0) {
207         if (lids.idlist_val)
208             free(lids.idlist_val);
209         if (lnames.namelist_val)
210             free(lnames.namelist_val);
211         return code;
212     }
213     for (i = 0; i < acl->positive; i++) {
214         sprintf(nextc, "%s", lnames.namelist_val[i]);
215         nextc += strlen(nextc);
216         sprintf(nextc, "\t%d\n", acl->entries[i].rights);
217         nextc += strlen(nextc);
218     }
219     j = i;
220     for (i = acl->total - 1; i >= acl->total - acl->negative; i--, j++) {
221         sprintf(nextc, "%s", lnames.namelist_val[j]);
222         nextc += strlen(nextc);
223         sprintf(nextc, "\t%d\n", acl->entries[i].rights);
224         nextc += strlen(nextc);
225     }
226     if (lids.idlist_val)
227         free(lids.idlist_val);
228     if (lnames.namelist_val)
229         free(lnames.namelist_val);
230     return (0);
231 }
232
233
234 int
235 acl_Internalize(char *elist, struct acl_accessList **acl)
236 {
237     /* Converts the external access list elist into the access list acl.  
238      * Returns 0 on success, -1 if ANY name is not translatable, or if 
239      * the number of entries exceeds al_maxExtEntries. */
240     register int i;
241     register int j;
242     register char *nextc;
243     register afs_int32 code;
244     int p, n;
245     namelist lnames;
246     idlist lids;
247
248     if (sscanf(elist, "%d\n%d\n", &p, &n) != 2)
249         return -1;
250     if (p + n > ACL_MAXENTRIES)
251         return (-1);
252     acl_NewACL(p + n, acl);
253     (*acl)->total = p + n;
254     (*acl)->positive = p;
255     (*acl)->negative = n;
256     if ((*acl)->total == 0) {
257         /* Empty acl entry; simply return success */
258         return 0;
259     }
260     lnames.namelist_len = (*acl)->total;
261     lnames.namelist_val =
262         (prname *) malloc(lnames.namelist_len * PR_MAXNAMELEN);
263     if (lnames.namelist_val == 0) {
264         return -1;
265     }
266     nextc = elist;
267     while (*nextc && *nextc != '\n')
268         nextc++;
269     nextc++;
270     while (*nextc && *nextc != '\n')
271         nextc++;
272     nextc++;                    /* now at the beginning of the entry list */
273     for (i = 0; i < (*acl)->positive; i++) {
274         int k;
275         if (sscanf(nextc, "%s\t%d\n", lnames.namelist_val[i], &k) != 2) {
276             free(lnames.namelist_val);
277             return (-1);
278         }
279         (*acl)->entries[i].rights = k;
280         nextc = strchr(nextc, '\n');
281         nextc++;                /* 1 + index can cast ptr to integer */
282     }
283     j = i;
284     for (i = (*acl)->total - 1; i >= (*acl)->total - (*acl)->negative;
285          i--, j++) {
286         if (sscanf
287             (nextc, "%s\t%d\n", lnames.namelist_val[j],
288              &((*acl)->entries[j].rights)) != 2) {
289             free(lnames.namelist_val);
290             return (-1);
291         }
292         nextc = strchr(nextc, '\n');
293         nextc++;
294     }
295     lids.idlist_len = 0;
296     lids.idlist_val = 0;
297
298     code = pr_NameToId(&lnames, &lids);
299     if (code) {
300         free(lnames.namelist_val);
301         if (lids.idlist_val)
302             free(lids.idlist_val);
303         return -1;
304     }
305     for (i = 0; i < (*acl)->positive; i++) {
306         if (lids.idlist_val[i] == ANONYMOUSID) {
307             free(lnames.namelist_val);
308             if (lids.idlist_val)
309                 free(lids.idlist_val);
310             return -1;
311         }
312         (*acl)->entries[i].id = lids.idlist_val[i];
313     }
314     j = i;
315     for (i = (*acl)->total - 1; i >= (*acl)->total - (*acl)->negative; i--) {
316         if (lids.idlist_val[i] == ANONYMOUSID) {
317             free(lnames.namelist_val);
318             if (lids.idlist_val)
319                 free(lids.idlist_val);
320             return -1;
321         }
322         (*acl)->entries[i].id = lids.idlist_val[i];
323     }
324     /* sort for easier lookup */
325     qsort(&((*acl)->entries[0]), (*acl)->positive,
326           sizeof(struct acl_accessEntry), CmpPlus);
327     qsort(&((*acl)->entries[(*acl)->total - (*acl)->negative]),
328           (*acl)->negative, sizeof(struct acl_accessEntry), CmpMinus);
329     free(lnames.namelist_val);
330     if (lids.idlist_val)
331         free(lids.idlist_val);
332     return (0);
333 }
334
335
336 int
337 acl_CheckRights(struct acl_accessList *acl, prlist *groups, int *rights)
338 {
339     /* Returns the rights given by acl to groups */
340
341     int temprights;             /* positive rights accumulated so far */
342     int negrights;              /* negative rights accumulated so far */
343     int a;                      /* index into next entry in acl */
344     int c;                      /* index into next entry in CPS */
345
346     /* more sanity checks */
347     if (acl->total > ACL_MAXENTRIES)
348         return 1;
349     if (acl->total < 0)
350         return 1;
351     if (acl->size > 192)
352         return 1;               /* 192 is the room in a 256 byte vnode reserved for the ACL */
353
354     if (acl->total <= 0 || groups->prlist_len <= 0) {
355         *rights = 0;
356         return (0);
357     }
358     if (groups->prlist_val[groups->prlist_len - 1] == SYSADMINID) {
359         *rights = -1;
360         return 0;
361     }
362
363     /* Each iteration eats up exactly one entry from either acl or groups.
364      * Duplicate Entries in access list ==> accumulated rights are obtained.
365      * Duplicate Entries in groups ==> irrelevant */
366     temprights = 0;
367     c = a = 0;
368     while ((a < acl->positive) && (c < groups->prlist_len))
369         switch (CmpInt(acl->entries[a].id, groups->prlist_val[c])) {
370         case -1:
371             a += 1;
372             break;
373
374         case 0:
375             temprights |= acl->entries[a].rights;
376             a += 1;
377             break;
378
379         case 1:
380             c += 1;
381             break;
382
383         default:
384             printf("CmpInt() returned bogus value. Aborting ...\n");
385             abort();
386         }
387     negrights = 0;
388     c = 0;
389     a = acl->total - 1;
390     while ((c < groups->prlist_len) && (a > acl->total - acl->negative - 1))
391         switch (CmpInt(acl->entries[a].id, groups->prlist_val[c])) {
392         case -1:
393             a -= 1;
394             break;
395         case 0:
396             negrights |= acl->entries[a].rights;
397             a -= 1;
398             break;
399         case 1:
400             c += 1;
401             break;
402         }
403     *rights = temprights & (~negrights);
404     return (0);
405 }
406
407 int
408 acl_Initialize(char *version)
409 {
410     /* I'm sure we need to do some initialization, I'm just not quite sure what yet! */
411     if (strcmp(version, ACL_VERSION) != 0) {
412         fprintf(stderr, "Wrong version of acl package!\n");
413         fprintf(stderr, "This is version %s, file server passed in %s.\n",
414                 ACL_VERSION, version);
415     }
416 #ifdef AFS_PTHREAD_ENV
417     assert(pthread_mutex_init(&acl_list_mutex, NULL) == 0);
418 #endif /* AFS_PTHREAD_ENV */
419     return 0;
420 }
421
422 int
423 acl_IsAMember(afs_int32 aid, prlist *cps)
424 {
425     afs_int32 i;
426
427     for (i = 0; i < cps->prlist_len; i++)
428         if (cps->prlist_val[i] == aid)
429             return 1;
430     return 0;
431 }
432
433
434 static int
435 AddToList(struct freeListEntry **pflist, struct freeListEntry *elem)
436 {
437     /* Adds elem to the freelist flist;  returns 0 */
438 #ifdef AFS_PTHREAD_ENV
439     assert(pthread_mutex_lock(&acl_list_mutex) == 0);
440 #endif /* AFS_PTHREAD_ENV */
441     elem->next = *pflist;
442     *pflist = elem;
443 #ifdef AFS_PTHREAD_ENV
444     assert(pthread_mutex_unlock(&acl_list_mutex) == 0);
445 #endif /* AFS_PTHREAD_ENV */
446     return 0;
447 }
448
449 static int
450 GetFromList(struct freeListEntry **pflist, struct freeListEntry **elem, 
451             afs_int32 minsize)
452 {
453     /* Looks for an element whose body is at least minsize bytes in the 
454      * freelist flist.  If found, unlinks it, puts its address in elem, 
455      * and returns 0, else returns -1.  A trivial first-fit algorithm is 
456      * used. */
457
458     struct freeListEntry *y, *z;
459
460 #ifdef AFS_PTHREAD_ENV
461     assert(pthread_mutex_lock(&acl_list_mutex) == 0);
462 #endif /* AFS_PTHREAD_ENV */
463     if (*pflist == NULL) {
464 #ifdef AFS_PTHREAD_ENV
465         assert(pthread_mutex_unlock(&acl_list_mutex) == 0);
466 #endif /* AFS_PTHREAD_ENV */
467         return -1;
468     }
469     for (y = *pflist, z = NULL; y != NULL; z = y, y = y->next) {
470         if (y->size >= minsize) {
471             *elem = y;
472             if (z == NULL) {    /* pulling off the head */
473                 *pflist = y->next;
474 #ifdef AFS_PTHREAD_ENV
475                 assert(pthread_mutex_unlock(&acl_list_mutex) == 0);
476 #endif /* AFS_PTHREAD_ENV */
477                 return 0;
478             }
479             z->next = y->next;
480 #ifdef AFS_PTHREAD_ENV
481             assert(pthread_mutex_unlock(&acl_list_mutex) == 0);
482 #endif /* AFS_PTHREAD_ENV */
483             return 0;
484         }
485     }
486 #ifdef AFS_PTHREAD_ENV
487     assert(pthread_mutex_unlock(&acl_list_mutex) == 0);
488 #endif /* AFS_PTHREAD_ENV */
489     return -1;
490 }