pts-error-message-cleanup-20011031
[openafs.git] / src / ptserver / pts.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 #include <afsconfig.h>
11 #include <afs/param.h>
12
13 RCSID("$Header$");
14
15 #include <stdio.h>
16 #include <string.h>
17 #ifdef  AFS_AIX32_ENV
18 #include <signal.h>
19 #endif
20 #include <ctype.h>
21 #include <sys/types.h>
22 #include <errno.h>
23 #include <afs/cmd.h>
24 #ifdef AFS_NT40_ENV
25 #include <winsock2.h>
26 #include <WINNT/afsevent.h>
27 #else
28 #include <netinet/in.h>
29 #endif
30 #include <afs/cellconfig.h>
31 #include <rx/rx.h>
32 #include <rx/xdr.h>
33 #include "ptclient.h"
34 #include "pterror.h"
35 #include <afs/afsutil.h>
36
37 #undef FOREIGN
38
39 char *whoami;
40 int force = 0;
41
42
43 int osi_audit()
44 {
45 /* OK, this REALLY sucks bigtime, but I can't tell who is calling
46  * afsconf_CheckAuth easily, and only *SERVERS* should be calling osi_audit
47  * anyway.  It's gonna give somebody fits to debug, I know, I know.
48  */
49 return 0;
50 }
51
52 int GetGlobals (as)
53   register struct cmd_syndesc *as;
54 {
55     register afs_int32 code;
56     char *cell;
57     afs_int32 sec = 1;
58
59     whoami = as->a0name;
60
61     if (!strcmp(as->name,"help")) return 0;
62     if (as->parms[16].items) 
63         cell = as->parms[16].items->data;
64     else cell = 0;
65     if (as->parms[17].items)
66         sec = 0;
67     
68     if (as->parms[18].items) {          /* testing? */
69         code = pr_Initialize(sec, AFSDIR_SERVER_ETC_DIRPATH, cell);
70     }
71     else {
72         code = pr_Initialize(sec, AFSDIR_CLIENT_ETC_DIRPATH, cell);
73     }
74     if (code) {
75         com_err (whoami, code, "while initializing");
76         return code;
77     }
78     if (as->parms[19].items)
79         force = 1;
80     return code;
81 }
82
83 int CleanUp (as)
84   register struct cmd_syndesc *as;
85 {
86     if (!strcmp(as->name,"help")) return;
87     /* Need to shutdown the ubik_client & other connections */
88     pr_End();
89     rx_Finalize();
90
91     return 0;
92 }
93
94 CreateGroup (as)
95   register struct cmd_syndesc *as;
96 {
97     register afs_int32 code;
98     afs_int32 id;
99     char *owner;
100     struct cmd_item *namei;
101     struct cmd_item *idi;
102
103     namei = as->parms[0].items;
104     idi = as->parms[2].items;
105     if (as->parms[1].items)
106         owner = as->parms[1].items->data;
107     else owner = NULL;
108
109     while (namei) {
110         if (idi) {
111             code = util_GetInt32 (idi->data, &id);
112             if (code) {
113                 com_err (whoami, code,
114                          "because group id was: '%s'", idi->data);
115                 return code;
116             }
117             if (id >= 0) {
118                 code = PRBADARG;
119                 com_err (whoami, code,
120                          "because group id %d was not negative", id);
121                 return code;
122             }
123             idi = idi->next;
124         } else id = 0;
125
126         code = pr_CreateGroup (namei->data, owner, &id);
127         if (code) {
128             if (owner || id) 
129                 com_err (whoami, code,
130                          "; unable to create group %s with id %d%s%s%s%s",
131                          namei->data, id, owner ? " owned by '" : "",
132                          owner ? owner : "",
133                          owner ? "'" : "",
134                          (force ? " (ignored)" : ""));
135             else com_err (whoami, code,
136                          "; unable to create group %s %s", namei->data, (force?"(ignored)":""));
137             if (!force)
138                 return code;
139         }
140         printf ("group %s has id %d\n", namei->data, id);
141         namei = namei->next;
142     }
143     return 0;
144 }
145
146 CreateUser (as)
147   register struct cmd_syndesc *as;
148 {
149     register afs_int32 code;
150     afs_int32 id;
151     struct cmd_item *namei;
152     struct cmd_item *idi;
153
154     namei = as->parms[0].items;
155     idi = as->parms[1].items;
156
157     while (namei) {
158         if (idi) {
159             code = util_GetInt32 (idi->data, &id);
160             if (code) {
161                 com_err (whoami, code, "because id was: '%s'", idi->data);
162                 return code;
163             }
164             if (id == 0) {
165                 printf ("0 isn't a valid user id; aborting\n");
166                 return EINVAL;
167             }
168             idi = idi->next;
169         } else id = 0;
170
171         code = pr_CreateUser (namei->data, &id);
172         if (code) {
173             if (id) com_err (whoami, code,
174                              "; unable to create user %s with id %d %s",
175                              namei->data, id, (force?"(ignored)":""));
176             else com_err (whoami, code,
177                           "; unable to create user %s %s", namei->data, (force?"(ignored)":""));
178             if (!force)
179                 return code;
180         }
181         printf ("User %s has id %d\n", namei->data, id);
182         namei = namei->next;
183     }
184     return 0;
185 }
186
187
188 #ifdef notdef
189 int GetNameOrId (as, lids, lnames)
190   register struct cmd_syndesc *as;
191   struct idlist *lids;
192   struct namelist *lnames;
193 {
194     register afs_int32 code = 0;
195     int n = 0;
196     struct cmd_item *i;
197     int goodCount;
198
199     if (!(as->parms[0].items || as->parms[1].items)) {
200         com_err (whoami, 0, "must specify either a name or an id.");
201         return -1;
202     }
203     if (as->parms[0].items && as->parms[1].items) {
204         com_err (whoami, 0, "can't specify both a name and id.");
205         return -1;
206     }
207
208     goodCount = 0;
209     lids->idlist_len = 0;
210     lids->idlist_val = 0;
211
212     if (as->parms[0].items) {           /* name */
213         struct namelist names;          /* local copy, if not ret. names */
214         struct namelist *nl;
215
216         names.namelist_val = 0;         /* so it gets freed later if needed */
217         if (lnames) nl = lnames;
218         else nl = &names;
219
220         n = 0;                          /* count names */
221         for (i=as->parms[0].items; i; i=i->next) n++;
222         nl->namelist_val = (prname *)malloc(n*PR_MAXNAMELEN);
223         nl->namelist_len = n;
224         n = 0;
225         for (i=as->parms[0].items; i; i=i->next)
226             strncpy (nl->namelist_val[n++], i->data, PR_MAXNAMELEN);
227
228         code = pr_NameToId (nl, lids);
229         if (code) com_err (whoami, code, "so couldn't look up names");
230         else {
231             for (n=0; n<lids->idlist_len; n++) {
232                 if ((lids->idlist_val[n] == ANONYMOUSID)) {
233                     com_err (whoami, PRNOENT,
234                              "so couldn't look up id for %s", nl->namelist_val[n]);
235                 }
236                 else goodCount++;
237             }
238             /* treat things as working if any of the lookups worked */
239             if (goodCount==0) code = PRNOENT;
240         }
241         
242         if (names.namelist_val) free (names.namelist_val);
243     }
244     else if (as->parms[1].items) {      /* id */
245         n = 0;
246         for (i=as->parms[1].items; i; i=i->next) n++;
247         lids->idlist_val = (afs_int32 *)malloc(n*sizeof(afs_int32));
248         lids->idlist_len = n;
249         n = 0;
250         for (i=as->parms[1].items; i; i=i->next) {
251             code = util_GetInt32 (i->data, &lids->idlist_val[n]);
252             if (code)
253                 com_err (whoami, code=PRNOENT,
254                          "because a bogus id '%s' was specified", i->data);
255             n++;
256         }
257         if (!code && lnames) {
258             lnames->namelist_val = 0;
259             lnames->namelist_len = 0;
260             code = pr_IdToName (lids, lnames);
261             if (code) com_err (whoami, code, "translating ids");
262         }
263     }
264     if (code) {
265         if (lids->idlist_val) free (lids->idlist_val);
266         return -1;
267     }
268     return 0;
269 }
270 #endif
271
272
273 int GetNameOrId (as, lids, lnames)
274   register struct cmd_syndesc *as;
275   struct idlist *lids;
276   struct namelist *lnames;
277 {
278     register afs_int32 code = 0;
279     int n = 0, nd = 0, nm = 0, id, x;
280     struct cmd_item *i;
281     struct namelist names, tnames;      /* local copy, if not ret. names */
282     struct idlist ids, tids;            /* local copy, if not ret. ids */
283     int goodCount = 0;
284
285     for (i = as->parms[0].items; i; i = i->next) n++;
286     lids->idlist_val = (afs_int32 *)malloc(n*sizeof(afs_int32));
287     lids->idlist_len = n;
288     ids.idlist_val = (afs_int32 *)malloc(n*sizeof(afs_int32));
289     ids.idlist_len = n;
290     names.namelist_val = (prname *)malloc(n*PR_MAXNAMELEN);
291     names.namelist_len = n;
292     if (lnames) {
293         lnames->namelist_val = (prname *)malloc(n*PR_MAXNAMELEN);
294         lnames->namelist_len = 0;
295     }
296     for (i=as->parms[0].items; i; i=i->next) {
297         tnames.namelist_val = (prname *)malloc(PR_MAXNAMELEN);
298         strncpy (tnames.namelist_val[0], i->data, PR_MAXNAMELEN);           
299         tnames.namelist_len = 1;
300         tids.idlist_len =  0;
301         tids.idlist_val = 0;
302         code = pr_NameToId(&tnames, &tids);
303         if ((!code && (tids.idlist_val[0] != 32766)) || (code = util_GetInt32 (i->data, &id))) {
304             /* Assume it's a name instead */
305             strncpy (names.namelist_val[nm++], i->data, PR_MAXNAMELEN);     
306         } else {
307             ids.idlist_val[nd++] = id;
308         }
309         free(tnames.namelist_val);
310     }
311     names.namelist_len = nm;
312     ids.idlist_len = nd;
313     tids.idlist_len = nd = nm = 0;
314     tids.idlist_val = 0;
315     code = pr_NameToId (&names, &tids);
316     if (code) com_err (whoami, code, "so couldn't look up names");
317     else {
318         for (n=0; n < tids.idlist_len; n++) {
319             if ((tids.idlist_val[n] == ANONYMOUSID)) {
320                 com_err (whoami, PRNOENT,
321                          "so couldn't look up id for %s", names.namelist_val[n]);
322             } else 
323                 goodCount++;
324             lids->idlist_val[nd] = tids.idlist_val[n];
325             if (lnames)
326                 strcpy(lnames->namelist_val[nd], names.namelist_val[n]);            
327             nd++;
328         }
329     }
330     for (x=0; x < ids.idlist_len; x++) {
331         lids->idlist_val[nd+x] = ids.idlist_val[x];
332     }
333     lids->idlist_len = nd+x;    
334     if (!code && lnames) {
335         tnames.namelist_val = 0;
336         tnames.namelist_len = 0;
337         code = pr_IdToName (&ids, &tnames);
338         if (code) com_err (whoami, code, "translating ids");
339         else goodCount++;
340         if (lnames) {
341             for (x=0; x < ids.idlist_len; x++)
342                 strcpy(lnames->namelist_val[nd+x], tnames.namelist_val[x]);         
343             lnames->namelist_len = nd+x;
344         }
345     }
346     /* treat things as working if any of the lookups worked */
347     if (goodCount==0) code = PRNOENT;
348     if (code) {
349         if (lids->idlist_val) free (lids->idlist_val);
350         return -1;
351     }
352     return 0;
353 }
354
355
356 AddToGroup(as)
357   register struct cmd_syndesc *as;
358 {
359     register afs_int32 code;
360     struct cmd_item *u, *g;
361
362     for (u=as->parms[0].items; u; u=u->next) {
363         for (g=as->parms[1].items; g; g=g->next) {
364             code = pr_AddToGroup (u->data, g->data);
365             if (code) {
366                 com_err (whoami, code,
367                          "; unable to add user %s to group %s %s",
368                          u->data, g->data, (force?"(ignored)":""));
369                 if (!force)
370                     return code;
371             }
372         }
373     }
374     return 0;
375 }
376
377 RemoveFromGroup (as)
378   register struct cmd_syndesc *as;
379 {
380     register afs_int32 code;
381     struct cmd_item *u, *g;
382
383     for (u=as->parms[0].items; u; u=u->next) {
384         for (g=as->parms[1].items; g; g=g->next) {
385             code = pr_RemoveUserFromGroup (u->data, g->data);
386             if (code) {
387                 com_err (whoami, code,
388                          "; unable to remove user %s from group %s %s",
389                          u->data, g->data, (force?"(ignored)":""));
390                 if (!force)
391                     return code;
392             }
393         }
394     }
395     return 0;
396 }
397
398 ListMembership (as)
399   register struct cmd_syndesc *as;
400 {
401     register afs_int32 code;
402     idlist ids;
403     namelist names;
404     int i;
405     namelist list;
406     int j;
407
408     if (GetNameOrId(as, &ids, &names)) return PRBADARG;
409
410     for (i=0; i<ids.idlist_len; i++) {
411         afs_int32 id = ids.idlist_val[i];
412         char *name = names.namelist_val[i];
413
414         if (id == ANONYMOUSID) continue;        /* bad entry */
415
416         list.namelist_val = 0;
417         list.namelist_len = 0;
418         code = pr_IDListMembers(ids.idlist_val[i],&list);
419         if (code) {
420             com_err (whoami, code,
421                      "; unable to get membership of %s (id: %d)", name, id);
422             continue;
423         }
424         if (id < 0) printf ("Members of %s (id: %d) are:\n", name, id);
425         else printf ("Groups %s (id: %d) is a member of:\n", name, id);
426
427         for (j=0; j<list.namelist_len; j++)
428             printf("  %s\n", list.namelist_val[j]);
429         if (list.namelist_val) free (list.namelist_val);
430     }
431     if (ids.idlist_val) free (ids.idlist_val);
432     if (names.namelist_val) free (names.namelist_val);
433     return 0;
434 }
435
436 Delete (as)
437   register struct cmd_syndesc *as;
438 {
439     register afs_int32 code;
440     idlist ids;
441     namelist names;
442     int i;
443
444     if (GetNameOrId (as, &ids, &names)) return PRBADARG;
445
446     for (i=0; i<ids.idlist_len; i++) {
447         afs_int32 id = ids.idlist_val[i];
448         char *name = names.namelist_val[i];
449
450         if (id == ANONYMOUSID) continue;
451
452         code = pr_DeleteByID (id);
453         if (code) {
454             com_err (whoami, code, "deleting %s (id: %d) %s", name, id, (force?"(ignored)":""));
455             if (!force)
456                 return code;
457         }
458     }
459     if (ids.idlist_val) free (ids.idlist_val);
460     if (names.namelist_val) free (names.namelist_val);
461     return 0;
462 }
463
464 /* access bit translation info */
465
466 char *flags_upcase = "SOMA ";           /* legal all access values */
467 char *flags_dncase = "s mar";           /* legal member acces values */
468 int   flags_shift[5] = {2,1,2,2,1};     /* bits for each */
469
470 CheckEntry (as)
471   register struct cmd_syndesc *as;
472 {
473     register afs_int32 code;
474     afs_int32 rcode = 1;
475     int i, flag = 0, admin = 0;
476     namelist lnames, names;
477     idlist ids;
478     idlist lids;
479     struct prcheckentry aentry;
480
481     if (GetNameOrId (as, &ids, &names)) return PRBADARG;
482
483     lids.idlist_len = 2;
484     lids.idlist_val = (afs_int32 *)malloc(sizeof(afs_int32)*2);
485     lnames.namelist_len = 0;
486     lnames.namelist_val = 0;
487
488     for (i=0; i<ids.idlist_len; i++) {
489         afs_int32 id = ids.idlist_val[i];
490
491         if (id == ANONYMOUSID) continue;
492
493         rcode = 0;
494         code = pr_ListEntry (id, &aentry);
495         if (code) {
496             rcode = code;
497             com_err (whoami, code, "; unable to find entry for (id: %d)", id);
498             continue;
499         }
500
501         lids.idlist_val[0] = aentry.owner;
502         lids.idlist_val[1] = aentry.creator;
503         code = pr_IdToName (&lids, &lnames);
504         if (code) {
505             rcode = code;
506             com_err (whoami, code,
507                      "translating owner (%d) and creator (%d) ids",
508                      aentry.owner, aentry.creator);
509             continue;
510         }
511         printf("Name: %s, id: %d, owner: %s, creator: %s,\n",
512                aentry.name, aentry.id,
513                lnames.namelist_val[0], lnames.namelist_val[1]);
514         printf ("  membership: %d", aentry.count);
515         {   char access[6];
516             afs_int32 flags = aentry.flags;
517             int  j, s, new;
518             char c;
519             access[5] = 0;      /* null-terminate the string */
520             for (j=4; j>=0; j--) {
521                 s = flags_shift[j];
522                 if (s == 1) new = flags & 1;
523                 else new = flags & 3;
524                 if (new == 0) c = '-';
525                 else if (new == 1) {
526                     c = flags_dncase[j];
527                     if (c == ' ') c = flags_upcase[j];
528                 } else if (new == 2) c = flags_upcase[j];
529                 else c = 'X';
530                 access[j] = c;
531                 flags >>= s;
532             }
533             printf(", flags: %s", access);
534         }
535         if (aentry.id == SYSADMINID) 
536             admin = 1;
537         else if (!pr_IsAMemberOf (aentry.name, "system:administrators", &flag)) {
538             if (flag)
539                 admin = 1;
540         }
541         if (admin)
542             printf (", group quota: unlimited");                    
543         else
544             printf (", group quota: %d", aentry.ngroups);
545 #if FOREIGN
546         printf (", foreign user quota=%d", aentry.nusers);
547 #endif
548         printf (".\n");
549     }
550
551   done:
552     if (lnames.namelist_val) free(lnames.namelist_val);
553     if (lids.idlist_val) free(lids.idlist_val);
554     if (ids.idlist_val) free(ids.idlist_val);
555
556     return(rcode);
557 }
558
559 ListEntries (as)
560   struct cmd_syndesc *as;
561 {
562   afs_int32 code=0;
563   afs_int32 flag, startindex, nentries, nextstartindex;
564   struct prlistentries *entriesp=0, *e;
565   afs_int32 i;
566
567   flag = PRUSERS;
568   if (as->parms[1].items) flag  = PRGROUPS;
569   if (as->parms[0].items) flag |= PRUSERS;
570   
571   printf("Name                          ID  Owner Creator\n");
572   for (startindex = 0; startindex!=-1; startindex=nextstartindex) {
573      code = pr_ListEntries(flag, startindex, &nentries, &entriesp, &nextstartindex);
574      if (code) {
575         com_err (whoami, code, "; unable to list entries\n");
576         if (entriesp) free(entriesp);
577         break;
578      }
579
580      /* Now display each of the entries we read */
581      for (i=0,e=entriesp; i<nentries; i++,e++) {
582         printf("%-25s %6d %6d %7d \n", e->name, e->id, e->owner, e->creator);
583      }
584      if (entriesp) free(entriesp);
585   }
586   return code;
587 }
588
589 ChownGroup (as)
590   register struct cmd_syndesc *as;
591 {
592     register afs_int32 code;
593     char *name;
594     char *owner;
595
596     name = as->parms[0].items->data;
597     owner = as->parms[1].items->data;
598     code = pr_ChangeEntry (name, "", 0, owner);
599     if (code) com_err (whoami, code,
600                        "; unable to change owner of %s to %s", name, owner);
601     return code;
602 }
603
604 ChangeName (as)
605   register struct cmd_syndesc *as;
606 {
607     register afs_int32 code;
608     char *oldname;
609     char *newname;
610
611     oldname = as->parms[0].items->data;
612     newname = as->parms[1].items->data;
613     code = pr_ChangeEntry (oldname, newname, 0, "");
614     if (code) com_err (whoami, code,
615                        "; unable to change name of %s to %s",
616                        oldname, newname);
617     return code;
618 }
619
620 ListMax (as)
621   register struct cmd_syndesc *as;
622 {
623     register afs_int32 code;
624     afs_int32 maxUser, maxGroup;
625
626     code = pr_ListMaxUserId (&maxUser);
627     if (code) 
628         com_err (whoami, code, "getting maximum user id");
629     else {
630         code = pr_ListMaxGroupId (&maxGroup);
631         if (code) com_err (whoami, code, "getting maximum group id");
632         else {
633             printf("Max user id is %d and max group id is %d.\n",
634                    maxUser, maxGroup);      
635         }
636     }
637     return code;
638 }
639
640 SetMax (as)
641   register struct cmd_syndesc *as;
642 {
643     register afs_int32 code;
644     afs_int32 maxid;
645
646     code = 0;
647     if (as->parms[1].items) {
648         /* set user max */
649         code = util_GetInt32 (as->parms[1].items->data, &maxid);
650         if (code) {
651             com_err (whoami, code,
652                      "because id was: '%s'", as->parms[1].items->data);
653         }
654         else {
655             code = pr_SetMaxUserId (maxid);
656             if (code)
657                 com_err (whoami, code,
658                          "so couldn't set Max User Id to %d", maxid);
659         }
660     }
661     if (as->parms[0].items) {
662         /* set group max */
663         code = util_GetInt32 (as->parms[0].items->data, &maxid);
664         if (code) {
665             com_err (whoami, code,
666                      "because id was: '%s'", as->parms[0].items->data);
667         }
668         else {
669             code = pr_SetMaxGroupId (maxid);
670             if (code)
671                 com_err (whoami, code,
672                          "so couldn't set Max Group Id to %d", maxid);
673         }
674     }
675     if (!as->parms[0].items && !as->parms[1].items) {
676         code = PRBADARG;
677         printf("Must specify at least one of group or user.\n");
678     }
679     return code;
680 }
681
682 SetFields (as)
683   register struct cmd_syndesc *as;
684 {
685     register afs_int32 code;
686     idlist ids;
687     namelist names;
688     int i;
689     afs_int32 mask, flags, ngroups, nusers;
690
691     if (GetNameOrId (as, &ids, &names)) return PRBADARG;
692
693     mask = 0;
694     nusers = 0;
695     if (as->parms[1].items) {           /* privacy bits */
696         char *access = as->parms[1].items->data;
697         int   new;
698
699         if (strpbrk (access, "76543210") != 0) { /* all octal digits */
700             sscanf (access, "%lo", &flags);
701         } else {                        /* interpret flag bit names */
702             if (strlen(access) != 5) {
703               form_error:
704                 printf ("Access bits must be of the form 'somar', not %s\n", access);
705                 return PRBADARG;
706             }
707             if (strpbrk(access, "somar-") == 0) goto form_error;
708             flags = 0;
709             for (i=0; i<5; i++) {
710                 if (access[i] == flags_upcase[i]) new = 2;
711                 else if (access[i] == flags_dncase[i]) new = 1;
712                 else if (access[i] == '-') new = 0;
713                 else {
714                     printf ("Access bits out of order or illegal:\n  must be a combination of letters from '%s' or '%s' or hyphen, not %s\n", flags_upcase, flags_dncase, access);
715                     return PRBADARG;
716                 }
717                 flags <<= flags_shift[i];
718                 if (flags_shift[i] == 1) {
719                     if (new) flags |= 1;
720                 }
721                 else flags |= new;
722             }
723         }
724         mask |= PR_SF_ALLBITS;
725     }
726     if (as->parms[2].items) {           /* limitgroups */
727         code = util_GetInt32 (as->parms[2].items->data, &ngroups);
728         if (code) {
729             com_err (whoami, code, "because ngroups was: '%s'",
730                      as->parms[2].items->data);
731             return code;
732         }
733         mask |= PR_SF_NGROUPS;
734     }
735 #if FOREIGN
736     if (as->parms[3].items) {           /* limitgroups */
737         code = util_GetInt32 (as->parms[3].items->data, &nusers);
738         if (code) {
739             com_err (whoami, code, "because nusers was: '%s'",
740                      as->parms[3].items->data);
741             return code;
742         }
743         mask |= PR_SF_NUSERS;
744     }
745 #endif
746
747     for (i=0; i<ids.idlist_len; i++) {
748         afs_int32 id = ids.idlist_val[i];
749         char *name = names.namelist_val[i];
750         if (id == ANONYMOUSID) continue;
751         code = pr_SetFieldsEntry (id, mask, flags, ngroups, nusers);
752         if (code) {
753             com_err (whoami, code,
754                      "; unable to set fields for %s (id: %d)", name, id);
755             return code;
756         }
757     }
758     if (ids.idlist_val) free (ids.idlist_val);
759     if (names.namelist_val) free (names.namelist_val);
760     return 0;
761 }           
762
763 ListOwned (as)
764   register struct cmd_syndesc *as;
765 {   register afs_int32 code;
766     idlist ids;
767     namelist names;
768     namelist list;
769     int i,j;
770     afs_int32 more;
771
772     if (GetNameOrId (as, &ids, &names)) return PRBADARG;
773
774     for (i=0; i<ids.idlist_len; i++) {
775         afs_int32 oid = ids.idlist_val[i];
776         char *name = names.namelist_val[i];
777
778         if (oid == ANONYMOUSID) continue;
779
780         if (oid) printf("Groups owned by %s (id: %d) are:\n", name, oid);
781         else printf ("Orphaned groups are:\n");
782         more = 0;
783         do {
784            list.namelist_val = 0;
785            list.namelist_len = 0;
786            code = pr_ListOwned(oid, &list, &more);
787            if (code) {
788               com_err (whoami, code,
789                        "; unable to get owner list for %s (id: %d)",
790                        name, oid);
791               break;
792            }
793
794            for (j=0; j<list.namelist_len; j++)
795               printf ("  %s\n", list.namelist_val[j]);
796            if (list.namelist_val) free(list.namelist_val);
797         } while (more);
798     }
799
800     if (ids.idlist_val) free (ids.idlist_val);
801     if (names.namelist_val) free (names.namelist_val);
802     return 0;
803 }
804
805 static void add_std_args (ts)
806   register struct cmd_syndesc *ts;
807 {
808     char test_help[AFSDIR_PATH_MAX];
809
810     sprintf(test_help, "use config file in %s", AFSDIR_SERVER_ETC_DIRPATH);
811
812     cmd_Seek(ts,16);
813     cmd_AddParm(ts,"-cell",CMD_SINGLE,CMD_OPTIONAL,"cell name");
814     cmd_AddParm(ts,"-noauth",CMD_FLAG,CMD_OPTIONAL,"run unauthenticated");
815     cmd_AddParm(ts,"-test", CMD_FLAG,CMD_OPTIONAL|CMD_HIDE, test_help);
816     cmd_AddParm(ts,"-force",CMD_FLAG,CMD_OPTIONAL,"Continue oper despite reasonable errors");
817 }
818
819 /*
820 static void add_NameOrId_args (ts)
821   register struct cmd_syndesc *ts;
822 {
823     cmd_AddParm(ts,"-name",CMD_LIST,CMD_OPTIONAL,"user or group name");
824     cmd_AddParm(ts,"-id",CMD_LIST,CMD_OPTIONAL,"user or group id");
825 }
826 */
827
828 #include "AFS_component_version_number.c"
829
830 int main (argc, argv)
831   int argc;
832   char **argv;
833 {
834     register afs_int32 code;
835     register struct cmd_syndesc *ts;
836 #ifdef WIN32
837     WSADATA WSAjunk;
838 #endif
839
840 #ifdef WIN32
841     WSAStartup(0x0101, &WSAjunk);
842 #endif
843     
844 #ifdef  AFS_AIX32_ENV
845     /*
846      * The following signal action for AIX is necessary so that in case of a 
847      * crash (i.e. core is generated) we can include the user's data section 
848      * in the core dump. Unfortunately, by default, only a partial core is
849      * generated which, in many cases, isn't too useful.
850      */
851     struct sigaction nsa;
852     
853     sigemptyset(&nsa.sa_mask);
854     nsa.sa_handler = SIG_DFL;
855     nsa.sa_flags = SA_FULLDUMP;
856     sigaction(SIGSEGV, &nsa, NULL);
857 #endif
858
859     ts = cmd_CreateSyntax("creategroup",CreateGroup,0,"create a new group");
860     cmd_AddParm(ts,"-name",CMD_LIST,0,"group name");
861     cmd_AddParm(ts,"-owner",CMD_SINGLE,CMD_OPTIONAL,"owner of the group");
862     cmd_AddParm(ts,"-id",CMD_LIST,CMD_OPTIONAL,"id (negated) for the group");
863     add_std_args (ts);
864     cmd_CreateAlias(ts,"cg");
865
866     ts = cmd_CreateSyntax("createuser",CreateUser,0,"create a new user");
867     cmd_AddParm(ts,"-name",CMD_LIST,0,"user name");
868     cmd_AddParm(ts,"-id",CMD_LIST,CMD_OPTIONAL,"user id");
869     add_std_args (ts);
870     cmd_CreateAlias(ts,"cu");
871
872     ts = cmd_CreateSyntax("adduser",AddToGroup,0,"add a user to a group");
873     cmd_AddParm(ts, "-user",CMD_LIST,0,"user name");
874     cmd_AddParm(ts, "-group",CMD_LIST,0,"group name");
875     add_std_args (ts);
876
877     ts = cmd_CreateSyntax("removeuser",RemoveFromGroup,0,
878                           "remove a user from a group");
879     cmd_AddParm(ts,"-user",CMD_LIST,0,"user name");
880     cmd_AddParm(ts,"-group",CMD_LIST,0,"group name");
881     add_std_args (ts);
882
883     ts = cmd_CreateSyntax ("membership",ListMembership, 0,
884                            "list membership of a user or group");
885     cmd_AddParm(ts,"-nameorid",CMD_LIST,0,"user or group name or id");
886     add_std_args (ts);
887     cmd_CreateAlias(ts,"groups");
888
889     ts = cmd_CreateSyntax ("delete", Delete, 0,
890                            "delete a user or group from database");
891     cmd_AddParm(ts,"-nameorid",CMD_LIST,0,"user or group name or id");
892     add_std_args (ts);
893
894     ts = cmd_CreateSyntax ("examine", CheckEntry, 0, "examine an entry");
895     cmd_AddParm(ts,"-nameorid",CMD_LIST,0,"user or group name or id");
896     add_std_args (ts);
897     cmd_CreateAlias (ts, "check");
898
899     ts = cmd_CreateSyntax("chown",ChownGroup,0,"change ownership of a group");
900     cmd_AddParm(ts,"-name",CMD_SINGLE,0,"group name");
901     cmd_AddParm(ts,"-owner",CMD_SINGLE,0,"new owner");
902     add_std_args (ts);
903
904     ts = cmd_CreateSyntax("rename",ChangeName,0,"rename user or group");
905     cmd_AddParm(ts,"-oldname",CMD_SINGLE,0,"old name");
906     cmd_AddParm(ts,"-newname",CMD_SINGLE,0,"new name");
907     add_std_args (ts);
908     cmd_CreateAlias(ts, "chname");
909
910     ts = cmd_CreateSyntax("listmax",ListMax,0,"list max id");
911     add_std_args (ts);
912
913     ts = cmd_CreateSyntax("setmax",SetMax,0,"set max id");
914     cmd_AddParm(ts,"-group",CMD_SINGLE,CMD_OPTIONAL,"group max");
915     cmd_AddParm(ts,"-user",CMD_SINGLE,CMD_OPTIONAL,"user max");
916     add_std_args (ts);
917
918     ts = cmd_CreateSyntax("setfields",SetFields,0,"set fields for an entry");
919     cmd_AddParm(ts,"-nameorid",CMD_LIST,0,"user or group name or id");
920     cmd_AddParm (ts, "-access", CMD_SINGLE, CMD_OPTIONAL,
921                  "set privacy flags"); 
922     cmd_AddParm (ts, "-groupquota", CMD_SINGLE, CMD_OPTIONAL,
923                  "set limit on group creation"); 
924 #if FOREIGN
925     cmd_AddParm (ts, "-userquota", CMD_SINGLE, CMD_OPTIONAL,
926                  "set limit on foreign user creation"); 
927 #endif
928     add_std_args (ts);
929
930     ts = cmd_CreateSyntax
931         ("listowned", ListOwned, 0,
932          "list groups owned by an entry or zero id gets orphaned groups");
933     cmd_AddParm(ts,"-nameorid",CMD_LIST,0,"user or group name or id");
934     add_std_args (ts);
935     
936     ts = cmd_CreateSyntax
937         ("listentries", ListEntries, 0,
938          "list users/groups in the protection database");
939     cmd_AddParm(ts, "-users",  CMD_FLAG, CMD_OPTIONAL, "list user entries");
940     cmd_AddParm(ts, "-groups", CMD_FLAG, CMD_OPTIONAL, "list group entries");
941     add_std_args (ts);
942     
943     cmd_SetBeforeProc(GetGlobals,0);
944     cmd_SetAfterProc(CleanUp,0);
945     code = cmd_Dispatch(argc,argv);
946     exit (code != 0);
947 }
948