windows-cm_ioctl_query_opts-20080115
[openafs.git] / src / WINNT / afsd / fs.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 <afs/param.h>
11 #include <afs/stds.h>
12
13 #include <windows.h>
14 #include <stdlib.h>
15 #include <malloc.h>
16 #include <string.h>
17 #include <stdio.h>
18 #include <time.h>
19 #include <winsock2.h>
20 #include <errno.h>
21 #include <assert.h>
22 #include <rx/rx_globals.h>
23
24 #include <osi.h>
25 #include <afsint.h>
26 #include <afs/cellconfig.h>
27 #include <afs/ptserver.h>
28 #include <afs/ptuser.h>
29 #include <afs/volser.h>
30 #include <WINNT\afsreg.h>
31
32 #include "fs.h"
33 #include "fs_utils.h"
34 #include "cmd.h"
35 #include "afsd.h"
36 #include "cm_ioctl.h"
37
38 #define MAXHOSTS 13
39 #define OMAXHOSTS 8
40 #define MAXCELLHOSTS 8
41 #define MAXNAME 100
42 #define MAXSIZE 2048
43 #define MAXINSIZE 1300    /* pioctl complains if data is larger than this */
44 #define VMSGSIZE 128      /* size of msg buf in volume hdr */
45 #define MAXCELLCHARS            64
46 #define MAXHOSTCHARS            64
47
48 static char space[MAXSIZE];
49 static char tspace[1024];
50
51 static struct ubik_client *uclient;
52
53 static int GetClientAddrsCmd(struct cmd_syndesc *asp, void *arock);
54 static int SetClientAddrsCmd(struct cmd_syndesc *asp, void *arock);
55 static int FlushMountCmd(struct cmd_syndesc *asp, void *arock);
56 static int RxStatProcCmd(struct cmd_syndesc *asp, void *arock);
57 static int RxStatPeerCmd(struct cmd_syndesc *asp, void *arock);
58
59 extern struct cmd_syndesc *cmd_CreateSyntax();
60
61 static int MemDumpCmd(struct cmd_syndesc *asp, void *arock);
62 static int CSCPolicyCmd(struct cmd_syndesc *asp, void *arock);
63 static int MiniDumpCmd(struct cmd_syndesc *asp, void *arock);
64
65 static char pn[] = "fs";
66 static int rxInitDone = 0;
67
68 /*
69  * Character to use between name and rights in printed representation for
70  * DFS ACL's.
71  */
72 #define DFS_SEPARATOR   ' '
73
74 typedef char sec_rgy_name_t[1025];      /* A DCE definition */
75
76 struct Acl {
77     int dfs;            /* Originally true if a dfs acl; now also the type
78                          * of the acl (1, 2, or 3, corresponding to object,
79                          * initial dir, or initial object). */
80     sec_rgy_name_t cell; /* DFS cell name */
81     int nplus;
82     int nminus;
83     struct AclEntry *pluslist;
84     struct AclEntry *minuslist;
85 };
86
87 struct AclEntry {
88     struct AclEntry *next;
89     char name[MAXNAME];
90     afs_int32 rights;
91 };
92
93 static void 
94 ZapAcl (struct Acl *acl)
95 {
96     if (!acl)
97         return;
98
99     ZapList(acl->pluslist);
100     ZapList(acl->minuslist);
101     free(acl);
102 }
103
104 /*
105  * Mods for the AFS/DFS protocol translator.
106  *
107  * DFS rights. It's ugly to put these definitions here, but they 
108  * *cannot* change, because they're part of the wire protocol.
109  * In any event, the protocol translator will guarantee these
110  * assignments for AFS cache managers.
111  */
112 #define DFS_READ          0x01
113 #define DFS_WRITE         0x02
114 #define DFS_EXECUTE       0x04
115 #define DFS_CONTROL       0x08
116 #define DFS_INSERT        0x10
117 #define DFS_DELETE        0x20
118
119 /* the application definable ones (backwards from AFS) */
120 #define DFS_USR0 0x80000000      /* "A" bit */
121 #define DFS_USR1 0x40000000      /* "B" bit */
122 #define DFS_USR2 0x20000000      /* "C" bit */
123 #define DFS_USR3 0x10000000      /* "D" bit */
124 #define DFS_USR4 0x08000000      /* "E" bit */
125 #define DFS_USR5 0x04000000      /* "F" bit */
126 #define DFS_USR6 0x02000000      /* "G" bit */
127 #define DFS_USR7 0x01000000      /* "H" bit */
128 #define DFS_USRALL      (DFS_USR0 | DFS_USR1 | DFS_USR2 | DFS_USR3 |\
129                          DFS_USR4 | DFS_USR5 | DFS_USR6 | DFS_USR7)
130
131 /*
132  * Offset of -id switch in command structure for various commands.
133  * The -if switch is the next switch always.
134  */
135 static int parm_setacl_id, parm_copyacl_id, parm_listacl_id;
136
137 /*
138  * Determine whether either the -id or -if switches are present, and
139  * return 0, 1 or 2, as appropriate. Abort if both switches are present.
140  */
141 /* int id; Offset of -id switch; -if is next switch */
142 static int 
143 getidf(struct cmd_syndesc *as, int id)
144 {
145     int idf = 0;
146
147     if (as->parms[id].items) {
148         idf |= 1;
149     }
150     if (as->parms[id + 1].items) {
151         idf |= 2;
152     }
153     if (idf == 3) {
154         fprintf(stderr,
155              "%s: you may specify either -id or -if, but not both switches\n",
156              pn);
157         exit(1);
158     }
159     return idf;
160 }
161
162 static int
163 PRights(afs_int32 arights, int dfs)
164 {
165     if (!dfs) {
166         if (arights & PRSFS_READ) 
167             printf("r");
168         if (arights & PRSFS_LOOKUP) 
169             printf("l");
170         if (arights & PRSFS_INSERT) 
171             printf("i");
172         if (arights & PRSFS_DELETE) 
173             printf("d");
174         if (arights & PRSFS_WRITE) 
175             printf("w");
176         if (arights & PRSFS_LOCK) 
177             printf("k");
178         if (arights & PRSFS_ADMINISTER) 
179             printf("a");
180         if (arights & PRSFS_USR0) 
181             printf("A");
182         if (arights & PRSFS_USR1) 
183             printf("B");
184         if (arights & PRSFS_USR2) 
185             printf("C");
186         if (arights & PRSFS_USR3) 
187             printf("D");
188         if (arights & PRSFS_USR4) 
189             printf("E");
190         if (arights & PRSFS_USR5) 
191             printf("F");
192         if (arights & PRSFS_USR6) 
193             printf("G");
194         if (arights & PRSFS_USR7) 
195             printf("H");
196     } else {
197         if (arights & DFS_READ) 
198             printf("r");
199         else 
200             printf("-");
201         if (arights & DFS_WRITE) 
202             printf("w"); 
203         else 
204             printf("-");
205         if (arights & DFS_EXECUTE) 
206             printf("x"); 
207         else 
208             printf("-");
209         if (arights & DFS_CONTROL) 
210             printf("c"); 
211         else 
212             printf("-");
213         if (arights & DFS_INSERT) 
214             printf("i"); 
215         else 
216             printf("-");
217         if (arights & DFS_DELETE) 
218             printf("d"); 
219         else 
220             printf("-");
221         if (arights & (DFS_USRALL)) 
222             printf("+");
223         if (arights & DFS_USR0) 
224             printf("A");
225         if (arights & DFS_USR1) 
226             printf("B");
227         if (arights & DFS_USR2) 
228             printf("C");
229         if (arights & DFS_USR3) 
230             printf("D");
231         if (arights & DFS_USR4) 
232             printf("E");
233         if (arights & DFS_USR5) 
234             printf("F");
235         if (arights & DFS_USR6) 
236             printf("G");
237         if (arights & DFS_USR7) 
238             printf("H");
239     }   
240     return 0;
241 }
242
243 /* this function returns TRUE (1) if the file is in AFS, otherwise false (0) */
244 static int 
245 InAFS(char *apath)
246 {
247     struct ViceIoctl blob;
248     afs_int32 code;
249
250     blob.in_size = 0;
251     blob.out_size = MAXSIZE;
252     blob.out = space;
253
254     code = pioctl(apath, VIOC_FILE_CELL_NAME, &blob, 1);
255     if (code) {
256         if ((errno == EINVAL) || (errno == ENOENT)) 
257             return 0;
258     }
259     return 1;
260 }
261
262 static int 
263 IsFreelanceRoot(char *apath)
264 {
265     struct ViceIoctl blob;
266     afs_int32 code;
267
268     blob.in_size = 0;
269     blob.out_size = MAXSIZE;
270     blob.out = space;
271
272     code = pioctl(apath, VIOC_FILE_CELL_NAME, &blob, 1);
273     if (code == 0)
274         return !stricmp("Freelance.Local.Root",space);
275     return 1;   /* assume it is because it is more restrictive that way */
276 }
277
278 /* return a static pointer to a buffer */
279 static char *
280 Parent(char *apath)
281 {
282     char *tp;
283     strcpy(tspace, apath);
284     tp = strrchr(tspace, '\\');
285     if (tp) {
286         *(tp+1) = 0;    /* lv trailing slash so Parent("k:\foo") is "k:\" not "k:" */
287     }
288     else {
289         fs_ExtractDriveLetter(apath, tspace);
290         strcat(tspace, ".");
291     }
292     return tspace;
293 }
294
295 enum rtype {add, destroy, deny};
296
297 static afs_int32 
298 Convert(char *arights, int dfs, enum rtype *rtypep)
299 {
300     int i, len;
301     afs_int32 mode;
302     char tc;
303
304     *rtypep = add;      /* add rights, by default */
305
306     if (dfs) {
307         if (!strcmp(arights, "null")) {
308             *rtypep = deny;
309             return 0;
310         }
311         if (!strcmp(arights,"read")) 
312             return DFS_READ | DFS_EXECUTE;
313         if (!strcmp(arights, "write")) 
314             return DFS_READ | DFS_EXECUTE | DFS_INSERT | DFS_DELETE | 
315                 DFS_WRITE;
316         if (!strcmp(arights, "all")) 
317             return DFS_READ | DFS_EXECUTE | DFS_INSERT | DFS_DELETE | 
318                 DFS_WRITE | DFS_CONTROL;
319     } else {
320         if (!strcmp(arights,"read")) 
321             return PRSFS_READ | PRSFS_LOOKUP;
322         if (!strcmp(arights, "write")) 
323             return PRSFS_READ | PRSFS_LOOKUP | PRSFS_INSERT | PRSFS_DELETE | 
324                 PRSFS_WRITE | PRSFS_LOCK;
325         if (!strcmp(arights, "mail")) 
326             return PRSFS_INSERT | PRSFS_LOCK | PRSFS_LOOKUP;
327         if (!strcmp(arights, "all")) 
328             return PRSFS_READ | PRSFS_LOOKUP | PRSFS_INSERT | PRSFS_DELETE | 
329                 PRSFS_WRITE | PRSFS_LOCK | PRSFS_ADMINISTER;
330     }
331     if (!strcmp(arights, "none")) {
332         *rtypep = destroy; /* Remove entire entry */
333         return 0;
334     }
335     len = (int)strlen(arights);
336     mode = 0;
337     for(i=0;i<len;i++) {
338         tc = *arights++;
339         if (dfs) {
340             if (tc == '-') 
341                 continue;
342             else if (tc == 'r') 
343                 mode |= DFS_READ;
344             else if (tc == 'w') 
345                 mode |= DFS_WRITE;
346             else if (tc == 'x') 
347                 mode |= DFS_EXECUTE;
348             else if (tc == 'c') 
349                 mode |= DFS_CONTROL;
350             else if (tc == 'i') 
351                 mode |= DFS_INSERT;
352             else if (tc == 'd') 
353                 mode |= DFS_DELETE;
354             else if (tc == 'A') 
355                 mode |= DFS_USR0;
356             else if (tc == 'B') 
357                 mode |= DFS_USR1;
358             else if (tc == 'C') 
359                 mode |= DFS_USR2;
360             else if (tc == 'D') 
361                 mode |= DFS_USR3;
362             else if (tc == 'E') 
363                 mode |= DFS_USR4;
364             else if (tc == 'F') 
365                 mode |= DFS_USR5;
366             else if (tc == 'G') 
367                 mode |= DFS_USR6;
368             else if (tc == 'H') 
369                 mode |= DFS_USR7;
370             else {
371                 fprintf(stderr, "%s: illegal DFS rights character '%c'.\n", 
372                          pn, tc);
373                 exit(1);
374             }
375         } else {
376             if (tc == 'r') 
377                 mode |= PRSFS_READ;
378             else if (tc == 'l') 
379                 mode |= PRSFS_LOOKUP;
380             else if (tc == 'i') 
381                 mode |= PRSFS_INSERT;
382             else if (tc == 'd') 
383                 mode |= PRSFS_DELETE;
384             else if (tc == 'w') 
385                 mode |= PRSFS_WRITE;
386             else if (tc == 'k') 
387                 mode |= PRSFS_LOCK;
388             else if (tc == 'a') 
389                 mode |= PRSFS_ADMINISTER;
390             else if (tc == 'A') 
391                 mode |= PRSFS_USR0;
392             else if (tc == 'B') 
393                 mode |= PRSFS_USR1;
394             else if (tc == 'C') 
395                 mode |= PRSFS_USR2;
396             else if (tc == 'D') 
397                 mode |= PRSFS_USR3;
398             else if (tc == 'E') 
399                 mode |= PRSFS_USR4;
400             else if (tc == 'F') 
401                 mode |= PRSFS_USR5;
402             else if (tc == 'G') 
403                 mode |= PRSFS_USR6;
404             else if (tc == 'H') 
405                 mode |= PRSFS_USR7;
406             else {
407                 fprintf(stderr, "%s: illegal rights character '%c'.\n", pn, 
408                          tc);
409                 exit(1);
410             }
411         }
412     }
413     return mode;
414 }
415
416 static struct AclEntry *
417 FindList (struct AclEntry *alist, char *aname)
418 {
419     while (alist) {
420         if (!strcasecmp(alist->name, aname)) 
421             return alist;
422         alist = alist->next;
423     }
424     return 0;
425 }
426
427 /* if no parm specified in a particular slot, set parm to be "." instead */
428 static void 
429 SetDotDefault(struct cmd_item **aitemp)
430 {
431     struct cmd_item *ti;
432     if (*aitemp) 
433         return;                 /* already has value */
434     /* otherwise, allocate an item representing "." */
435     ti = (struct cmd_item *) malloc(sizeof(struct cmd_item));
436     assert(ti);
437     ti->next = (struct cmd_item *) 0;
438     ti->data = (char *) malloc(2);
439     assert(ti->data);
440     strcpy(ti->data, ".");
441     *aitemp = ti;
442 }
443
444 static void 
445 ChangeList (struct Acl *al, afs_int32 plus, char *aname, afs_int32 arights)
446 {
447     struct AclEntry *tlist;
448     tlist = (plus ? al->pluslist : al->minuslist);
449     tlist = FindList (tlist, aname);
450     if (tlist) {
451         /* Found the item already in the list. */
452         tlist->rights = arights;
453         if (plus)
454             al->nplus -= PruneList(&al->pluslist, al->dfs);
455         else
456             al->nminus -= PruneList(&al->minuslist, al->dfs);
457         return;
458     }
459     /* Otherwise we make a new item and plug in the new data. */
460     tlist = (struct AclEntry *) malloc(sizeof (struct AclEntry));
461     assert(tlist);
462     strcpy(tlist->name, aname);
463     tlist->rights = arights;
464     if (plus) {
465         tlist->next = al->pluslist;
466         al->pluslist = tlist;
467         al->nplus++;
468         if (arights == 0 || arights == -1)
469             al->nplus -= PruneList(&al->pluslist, al->dfs);
470     } else {
471         tlist->next = al->minuslist;
472         al->minuslist = tlist;
473         al->nminus++;
474         if (arights == 0) 
475             al->nminus -= PruneList(&al->minuslist, al->dfs);
476     }
477 }
478
479 static void 
480 ZapList (struct AclEntry *alist)
481 {
482     struct AclEntry *tp, *np;
483     for (tp = alist; tp; tp = np) {
484         np = tp->next;
485         free(tp);
486     }
487 }
488
489 static int 
490 PruneList (struct AclEntry **ae, int dfs)
491 {
492     struct AclEntry **lp;
493     struct AclEntry *te, *ne;
494     afs_int32 ctr;
495     ctr = 0;
496     lp = ae;
497     for(te = *ae;te;te=ne) {
498         if ((!dfs && te->rights == 0) || te->rights == -1) {
499             *lp = te->next;
500             ne = te->next;
501             free(te);
502             ctr++;
503         } else {
504             ne = te->next;
505             lp = &te->next;
506         }
507     }
508     return ctr;
509 }
510
511 static char *
512 SkipLine (char *astr)
513 {
514     while (*astr !='\n') 
515         astr++;
516     astr++;
517     return astr;
518 }
519
520 /*
521  * Create an empty acl, taking into account whether the acl pointed
522  * to by astr is an AFS or DFS acl. Only parse this minimally, so we
523  * can recover from problems caused by bogus ACL's (in that case, always
524  * assume that the acl is AFS: for DFS, the user can always resort to
525  * acl_edit, but for AFS there may be no other way out).
526  */
527 static struct Acl *
528 EmptyAcl(char *astr)
529 {
530     struct Acl *tp;
531     int junk;
532
533     tp = (struct Acl *)malloc(sizeof (struct Acl));
534     assert(tp);
535     tp->nplus = tp->nminus = 0;
536     tp->pluslist = tp->minuslist = 0;
537     tp->dfs = 0;
538     sscanf(astr, "%d dfs:%d %s", &junk, &tp->dfs, tp->cell);
539     return tp;
540 }
541
542 static struct Acl *
543 ParseAcl (char *astr)
544 {
545     int nplus, nminus, i, trights;
546     char tname[MAXNAME];
547     struct AclEntry *first, *last, *tl;
548     struct Acl *ta;
549
550     ta = (struct Acl *) malloc (sizeof (struct Acl));
551     assert(ta);
552     ta->dfs = 0;
553     sscanf(astr, "%d dfs:%d %s", &ta->nplus, &ta->dfs, ta->cell);
554     astr = SkipLine(astr);
555     sscanf(astr, "%d", &ta->nminus);
556     astr = SkipLine(astr);
557
558     nplus = ta->nplus;
559     nminus = ta->nminus;
560
561     last = 0;
562     first = 0;
563     for(i=0;i<nplus;i++) {
564         sscanf(astr, "%100s %d", tname, &trights);
565         astr = SkipLine(astr);
566         tl = (struct AclEntry *) malloc(sizeof (struct AclEntry));
567         assert(tl);
568         if (!first) 
569             first = tl;
570         strcpy(tl->name, tname);
571         tl->rights = trights;
572         tl->next = 0;
573         if (last) 
574             last->next = tl;
575         last = tl;
576     }
577     ta->pluslist = first;
578
579     last = 0;
580     first = 0;
581     for(i=0;i<nminus;i++) {
582         sscanf(astr, "%100s %d", tname, &trights);
583         astr = SkipLine(astr);
584         tl = (struct AclEntry *) malloc(sizeof (struct AclEntry));
585         assert(tl);
586         if (!first) 
587             first = tl;
588         strcpy(tl->name, tname);
589         tl->rights = trights;
590         tl->next = 0;
591         if (last) 
592             last->next = tl;
593         last = tl;
594     }
595     ta->minuslist = first;
596
597     return ta;
598 }
599
600 static int
601 PrintStatus(VolumeStatus *status, char *name, char *motd, char *offmsg)
602 {
603     printf("Volume status for vid = %u named %s is\n",status->Vid, name);
604     if (*offmsg != 0)
605         printf("Current offline message is %s\n",offmsg);
606     if (*motd != 0)
607         printf("Current message of the day is %s\n",motd);
608     printf("Current disk quota is ");
609     if (status->MaxQuota != 0) 
610         printf("%d\n", status->MaxQuota);
611     else 
612         printf("unlimited\n");
613     printf("Current blocks used are %d\n",status->BlocksInUse);
614     printf("The partition has %d blocks available out of %d\n",
615             status->PartBlocksAvail, status->PartMaxBlocks);
616     return 0;
617 }
618
619 static int
620 QuickPrintStatus(VolumeStatus *status, char *name)
621 {
622     double QuotaUsed =0.0;
623     double PartUsed =0.0;
624     int WARN = 0;
625     printf("%-25.25s",name);
626
627     if (status->MaxQuota != 0) {
628         printf("%10d%10d", status->MaxQuota, status->BlocksInUse);
629         QuotaUsed = ((((double)status->BlocksInUse)/status->MaxQuota) * 100.0);
630     } else {
631         printf("no limit%10d", status->BlocksInUse);
632     }
633     if (QuotaUsed > 90.0){
634         printf(" %5.0f%%<<", QuotaUsed);
635         WARN = 1;
636     } else 
637         printf(" %5.0f%%  ", QuotaUsed);
638     PartUsed = (100.0 - ((((double)status->PartBlocksAvail)/status->PartMaxBlocks) * 100.0));
639     if (PartUsed > 97.0){
640         printf(" %9.0f%%<<", PartUsed);
641         WARN = 1;
642     } else 
643         printf(" %9.0f%%  ", PartUsed);
644     if (WARN){
645         printf("  <<WARNING\n");
646     } else 
647         printf("\n");
648     return 0;
649 }
650
651 static int
652 QuickPrintSpace(VolumeStatus *status, char *name)
653 {
654     double PartUsed =0.0;
655     int WARN = 0;
656     printf("%-25.25s",name);
657
658     printf("%10d%10d%10d", status->PartMaxBlocks, status->PartMaxBlocks - status->PartBlocksAvail, status->PartBlocksAvail);
659         
660     PartUsed = (100.0 - ((((double)status->PartBlocksAvail)/status->PartMaxBlocks) * 100.0));
661     if (PartUsed > 90.0){
662         printf(" %4.0f%%<<", PartUsed);
663         WARN = 1;
664     } else 
665         printf(" %4.0f%%  ", PartUsed);
666     if (WARN){
667         printf("  <<WARNING\n");
668     } else 
669         printf("\n");
670     return 0;
671 }
672
673 static char *
674 AclToString(struct Acl *acl)
675 {
676     static char mydata[MAXSIZE];
677     char tstring[MAXSIZE];
678     char dfsstring[30];
679     struct AclEntry *tp;
680     
681     if (acl->dfs) 
682         sprintf(dfsstring, " dfs:%d %s", acl->dfs, acl->cell);
683     else 
684         dfsstring[0] = '\0';
685     sprintf(mydata, "%d%s\n%d\n", acl->nplus, dfsstring, acl->nminus);
686     for (tp = acl->pluslist;tp;tp=tp->next) {
687         sprintf(tstring, "%s %d\n", tp->name, tp->rights);
688         strcat(mydata, tstring);
689     }
690     for (tp = acl->minuslist;tp;tp=tp->next) {
691         sprintf(tstring, "%s %d\n", tp->name, tp->rights);
692         strcat(mydata, tstring);
693     }
694     return mydata;
695 }
696
697 static DWORD IsFreelance(void)
698 {
699     HKEY  parmKey;
700     DWORD code;
701     DWORD dummyLen;
702     DWORD enabled = 0;
703
704     code = RegOpenKeyEx(HKEY_LOCAL_MACHINE, AFSREG_CLT_SVC_PARAM_SUBKEY,
705                          0, KEY_QUERY_VALUE, &parmKey);
706     if (code == ERROR_SUCCESS) {
707         dummyLen = sizeof(cm_freelanceEnabled);
708         code = RegQueryValueEx(parmKey, "FreelanceClient", NULL, NULL,
709                             (BYTE *) &enabled, &dummyLen);
710         RegCloseKey (parmKey);
711     }
712     return enabled;
713 }
714
715 static const char * NetbiosName(void)
716 {
717     static char buffer[1024] = "AFS";
718     HKEY  parmKey;
719     DWORD code;
720     DWORD dummyLen;
721     DWORD enabled = 0;
722
723     code = RegOpenKeyEx(HKEY_LOCAL_MACHINE, AFSREG_CLT_SVC_PARAM_SUBKEY,
724                          0, KEY_QUERY_VALUE, &parmKey);
725     if (code == ERROR_SUCCESS) {
726         dummyLen = sizeof(buffer);
727         code = RegQueryValueEx(parmKey, "NetbiosName", NULL, NULL,
728                                buffer, &dummyLen);
729         RegCloseKey (parmKey);
730     } else {
731         strcpy(buffer, "AFS");
732     }
733     return buffer;
734 }
735
736 #define AFSCLIENT_ADMIN_GROUPNAME "AFS Client Admins"
737
738 static BOOL IsAdmin (void)
739 {
740     static BOOL fAdmin = FALSE;
741     static BOOL fTested = FALSE;
742
743     if (!fTested)
744     {
745         /* Obtain the SID for the AFS client admin group.  If the group does
746          * not exist, then assume we have AFS client admin privileges.
747          */
748         PSID psidAdmin = NULL;
749         DWORD dwSize, dwSize2;
750         char pszAdminGroup[ MAX_COMPUTERNAME_LENGTH + sizeof(AFSCLIENT_ADMIN_GROUPNAME) + 2 ];
751         char *pszRefDomain = NULL;
752         SID_NAME_USE snu = SidTypeGroup;
753
754         dwSize = sizeof(pszAdminGroup);
755
756         if (!GetComputerName(pszAdminGroup, &dwSize)) {
757             /* Can't get computer name.  We return false in this case.
758                Retain fAdmin and fTested. This shouldn't happen.*/
759             return FALSE;
760         }
761
762         dwSize = 0;
763         dwSize2 = 0;
764
765         strcat(pszAdminGroup,"\\");
766         strcat(pszAdminGroup, AFSCLIENT_ADMIN_GROUPNAME);
767
768         LookupAccountName(NULL, pszAdminGroup, NULL, &dwSize, NULL, &dwSize2, &snu);
769         /* that should always fail. */
770
771         if (GetLastError() != ERROR_INSUFFICIENT_BUFFER) {
772             /* if we can't find the group, then we allow the operation */
773             fAdmin = TRUE;
774             return TRUE;
775         }
776
777         if (dwSize == 0 || dwSize2 == 0) {
778             /* Paranoia */
779             fAdmin = TRUE;
780             return TRUE;
781         }
782
783         psidAdmin = (PSID)malloc(dwSize); memset(psidAdmin,0,dwSize);
784         assert(psidAdmin);
785         pszRefDomain = (char *)malloc(dwSize2);
786         assert(pszRefDomain);
787
788         if (!LookupAccountName(NULL, pszAdminGroup, psidAdmin, &dwSize, pszRefDomain, &dwSize2, &snu)) {
789             /* We can't lookup the group now even though we looked it up earlier.  
790                Could this happen? */
791             fAdmin = TRUE;
792         } else {
793             /* Then open our current ProcessToken */
794             HANDLE hToken;
795
796             if (OpenProcessToken (GetCurrentProcess(), TOKEN_QUERY, &hToken))
797             {
798
799                 if (!CheckTokenMembership(hToken, psidAdmin, &fAdmin)) {
800                     /* We'll have to allocate a chunk of memory to store the list of
801                      * groups to which this user belongs; find out how much memory
802                      * we'll need.
803                      */
804                     DWORD dwSize = 0;
805                     PTOKEN_GROUPS pGroups;
806
807                     GetTokenInformation (hToken, TokenGroups, NULL, dwSize, &dwSize);
808
809                     pGroups = (PTOKEN_GROUPS)malloc(dwSize);
810                     assert(pGroups);
811
812                     /* Allocate that buffer, and read in the list of groups. */
813                     if (GetTokenInformation (hToken, TokenGroups, pGroups, dwSize, &dwSize))
814                     {
815                         /* Look through the list of group SIDs and see if any of them
816                          * matches the AFS Client Admin group SID.
817                          */
818                         size_t iGroup = 0;
819                         for (; (!fAdmin) && (iGroup < pGroups->GroupCount); ++iGroup)
820                         {
821                             if (EqualSid (psidAdmin, pGroups->Groups[ iGroup ].Sid)) {
822                                 fAdmin = TRUE;
823                             }
824                         }
825                     }
826
827                     if (pGroups)
828                         free(pGroups);
829                 }
830
831                 /* if do not have permission because we were not explicitly listed
832                  * in the Admin Client Group let's see if we are the SYSTEM account
833                  */
834                 if (!fAdmin) {
835                     PTOKEN_USER pTokenUser;
836                     SID_IDENTIFIER_AUTHORITY SIDAuth = SECURITY_NT_AUTHORITY;
837                     PSID pSidLocalSystem = 0;
838                     DWORD gle;
839
840                     GetTokenInformation(hToken, TokenUser, NULL, 0, &dwSize);
841
842                     pTokenUser = (PTOKEN_USER)malloc(dwSize);
843                     assert(pTokenUser);
844
845                     if (!GetTokenInformation(hToken, TokenUser, pTokenUser, dwSize, &dwSize))
846                         gle = GetLastError();
847
848                     if (AllocateAndInitializeSid( &SIDAuth, 1,
849                                                   SECURITY_LOCAL_SYSTEM_RID,
850                                                   0, 0, 0, 0, 0, 0, 0,
851                                                   &pSidLocalSystem))
852                     {
853                         if (EqualSid(pTokenUser->User.Sid, pSidLocalSystem)) {
854                             fAdmin = TRUE;
855                         }
856
857                         FreeSid(pSidLocalSystem);
858                     }
859
860                     if ( pTokenUser )
861                         free(pTokenUser);
862                 }
863             }
864         }
865
866         free(psidAdmin);
867         free(pszRefDomain);
868
869         fTested = TRUE;
870     }
871
872     return fAdmin;
873 }
874
875 static int
876 SetACLCmd(struct cmd_syndesc *as, void *arock)
877 {
878     afs_int32 code;
879     struct ViceIoctl blob;
880     struct Acl *ta = 0;
881     struct cmd_item *ti, *ui;
882     int plusp;
883     afs_int32 rights;
884     int clear;
885     int idf = getidf(as, parm_setacl_id);
886
887     int error = 0;
888
889     if (as->parms[2].items)
890         clear = 1;
891     else
892         clear = 0;
893     plusp = !(as->parms[3].items);
894     for(ti=as->parms[0].items; ti;ti=ti->next) {
895         blob.out_size = MAXSIZE;
896         blob.in_size = idf;
897         blob.in = blob.out = space;
898         code = pioctl(ti->data, VIOCGETAL, &blob, 1);
899         if (code) {
900             Die(errno, ti->data);
901             error = 1;
902             continue;
903         }
904         if (ta)
905             ZapAcl(ta);
906         ta = ParseAcl(space);
907         if (!plusp && ta->dfs) {
908             fprintf(stderr,
909                     "fs: %s: you may not use the -negative switch with DFS acl's.\n%s",
910                     ti->data,
911                     "(you may specify \"null\" to revoke all rights, however)\n");
912             error = 1;
913             continue;
914         }
915         if (ta)
916             ZapAcl(ta);
917         if (clear) 
918             ta = EmptyAcl(space);
919         else 
920             ta = ParseAcl(space);
921         CleanAcl(ta, ti->data);
922         for(ui=as->parms[1].items; ui; ui=ui->next->next) {
923             enum rtype rtype;
924             if (!ui->next) {
925                 fprintf(stderr,
926                         "%s: Missing second half of user/access pair.\n", pn);
927                 ZapAcl(ta);
928                 return 1;
929             }
930             rights = Convert(ui->next->data, ta->dfs, &rtype);
931             if (rtype == destroy && !ta->dfs) {
932                 struct AclEntry *tlist;
933
934                 tlist = (plusp ? ta->pluslist : ta->minuslist);
935                 if (!FindList(tlist, ui->data))
936                     continue;
937             }
938             if (rtype == deny && !ta->dfs) 
939                 plusp = 0;
940             if (rtype == destroy && ta->dfs) 
941                 rights = -1;
942             ChangeList(ta, plusp, ui->data, rights);
943         }
944         blob.in = AclToString(ta);
945         blob.out_size=0;
946         blob.in_size = 1+(long)strlen(blob.in);
947         code = pioctl(ti->data, VIOCSETAL, &blob, 1);
948         if (code) {
949             if (errno == EINVAL) {
950                 if (ta->dfs) {
951                     static char *fsenv = 0;
952                     if (!fsenv) {
953                         fsenv = (char *)getenv("FS_EXPERT");
954                     }
955                     fprintf(stderr, "fs: \"Invalid argument\" was returned when you tried to store a DFS access list.\n");
956                     if (!fsenv) {
957                         fprintf(stderr,
958     "%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s",
959     "\nPossible reasons for this include:\n\n",                     
960     " -You may have specified an inappropriate combination of rights.\n",
961     "  For example, some DFS-supported filesystems may not allow you to\n",
962     "  drop the \"c\" right from \"user_obj\".\n\n",
963     " -A mask_obj may be required (it is likely required by the underlying\n",
964     "  filesystem if you try to set anything other than the basic \"user_obj\"\n",
965     "  \"mask_obj\", or \"group_obj\" entries). Unlike acl_edit, the fs command\n",
966     "  does not automatically create or update the mask_obj. Try setting\n",
967     "  the rights \"mask_obj all\" with \"fs sa\" before adding any explicit\n",
968     "  users or groups. You can do this with a single command, such as\n",
969     "  \"fs sa mask_obj all user:somename read\"\n\n",
970     " -A specified user or group may not exist.\n\n",
971     " -You may have tried to delete \"user_obj\", \"group_obj\", or \"other_obj\".\n",
972     "  This is probably not allowed by the underlying file system.\n\n",
973     " -If you add a user or group to a DFS ACL, remember that it must be\n",
974     "  fully specified as \"user:username\" or \"group:groupname\". In addition, there\n",
975     "  may be local requirements on the format of the user or group name.\n",
976     "  Check with your cell administrator.\n\n",                            
977     " -Or numerous other possibilities. It would be great if we could be more\n",
978     "  precise about the actual problem, but for various reasons, this is\n",
979     "  impractical via this interface.  If you can't figure it out, you\n",
980     "  might try logging into a DCE-equipped machine and use acl_edit (or\n",
981     "  whatever is provided). You may get better results. Good luck!\n\n",
982     " (You may inhibit this message by setting \"FS_EXPERT\" in your environment)\n");
983                     }
984                 } else {
985                     fprintf(stderr,
986                             "%s: Invalid argument, possible reasons include:\n", 
987                              pn);
988                     fprintf(stderr,"\t-File not in AFS\n");
989                     fprintf(stderr,
990                             "\t-Too many users on access control list\n");
991                     fprintf(stderr,
992                             "\t-Tried to add non-existent user to access control list\n");
993                 }
994             } else {
995                 Die(errno, ti->data);
996             }
997             error = 1;
998         }
999     }
1000     if (ta)
1001         ZapAcl(ta);
1002     return error;
1003 }
1004
1005 static int 
1006 CopyACLCmd(struct cmd_syndesc *as, void *arock)
1007 {
1008     afs_int32 code;
1009     struct ViceIoctl blob;
1010     struct Acl *fa, *ta = 0;
1011     struct AclEntry *tp;
1012     struct cmd_item *ti;
1013     int clear;
1014     int idf = getidf(as, parm_copyacl_id);
1015     int error = 0;
1016
1017     if (as->parms[2].items) 
1018         clear=1;
1019     else 
1020         clear=0;
1021     blob.out_size = MAXSIZE;
1022     blob.in_size = idf;
1023     blob.in = blob.out = space;
1024     code = pioctl(as->parms[0].items->data, VIOCGETAL, &blob, 1);
1025     if (code) {
1026         Die(errno, as->parms[0].items->data);
1027         return 1;
1028     }
1029     fa = ParseAcl(space);
1030     CleanAcl(fa, as->parms[0].items->data);
1031     for (ti=as->parms[1].items; ti;ti=ti->next) {
1032         blob.out_size = MAXSIZE;
1033         blob.in_size = idf;
1034         blob.in = blob.out = space;
1035         code = pioctl(ti->data, VIOCGETAL, &blob, 1);
1036         if (code) {
1037             Die(errno, ti->data);
1038             error = 1;
1039             continue;
1040         }
1041         if (ta)
1042             ZapAcl(ta);
1043         if (clear) 
1044             ta = EmptyAcl(space);
1045         else 
1046             ta = ParseAcl(space);
1047         CleanAcl(ta, ti->data);
1048         if (ta->dfs != fa->dfs) {
1049             fprintf(stderr, 
1050                     "%s: incompatible file system types: acl not copied to %s; aborted\n", 
1051                     pn, ti->data);
1052             error = 1;
1053             continue;
1054         }
1055         if (ta->dfs) {
1056             if (! clear && strcmp(ta->cell, fa->cell) != 0) {
1057                 fprintf(stderr, 
1058                         "%s: default DCE cell differs for file %s: use \"-clear\" switch; acl not merged\n", 
1059                         pn, ti->data);
1060                 error = 1;
1061                 continue;
1062             }
1063             strcpy(ta->cell, fa->cell);
1064         }
1065         for (tp = fa->pluslist;tp;tp=tp->next) 
1066             ChangeList(ta, 1, tp->name, tp->rights);
1067         for (tp = fa->minuslist;tp;tp=tp->next) 
1068             ChangeList(ta, 0, tp->name, tp->rights);
1069         blob.in = AclToString(ta);
1070         blob.out_size=0;
1071         blob.in_size = 1+(long)strlen(blob.in);
1072         code = pioctl(ti->data, VIOCSETAL, &blob, 1);
1073         if (code) {
1074             if (errno == EINVAL) {
1075                 fprintf(stderr,
1076                         "%s: Invalid argument, possible reasons include:\n", pn);
1077                 fprintf(stderr,"\t-File not in AFS\n");
1078             } else {
1079                 Die(errno, ti->data);
1080             }
1081             error = 1;
1082         }
1083     } 
1084     if (ta)
1085         ZapAcl(ta);
1086     ZapAcl(fa);
1087     return error;
1088 }
1089
1090 /* pioctl() call to get the cellname of a pathname */
1091 static afs_int32
1092 GetCell(char *fname, char *cellname)
1093 {
1094     afs_int32 code;
1095     struct ViceIoctl blob;
1096
1097     blob.in_size = 0;
1098     blob.out_size = MAXCELLCHARS;
1099     blob.out = cellname;
1100
1101     code = pioctl(fname, VIOC_FILE_CELL_NAME, &blob, 1);
1102     return code;
1103 }
1104
1105 /* Check if a username is valid: If it contains only digits (or a
1106  * negative sign), then it might be bad.  We then query the ptserver
1107  * to see.
1108  */
1109 static int
1110 BadName(char *aname, char *fname)
1111 {
1112     afs_int32 tc, code, id;
1113     char *nm;
1114     char cell[MAXCELLCHARS];
1115
1116     for ( nm = aname; tc = *nm; nm++) {
1117         /* all must be '-' or digit to be bad */
1118         if (tc != '-' && (tc < '0' || tc > '9'))
1119             return 0;
1120     }
1121
1122     /* Go to the PRDB and see if this all number username is valid */
1123     code = GetCell(fname, cell);
1124     if (code)
1125         return 0;
1126
1127     pr_Initialize(1, AFSDIR_CLIENT_ETC_DIRPATH, cell);
1128     code = pr_SNameToId(aname, &id);
1129     pr_End();
1130
1131     /* 1=>Not-valid; 0=>Valid */
1132     return ((!code && (id == ANONYMOUSID)) ? 1 : 0);
1133 }
1134
1135
1136 /* clean up an access control list of its bad entries; return 1 if we made
1137    any changes to the list, and 0 otherwise */
1138 static int 
1139 CleanAcl(struct Acl *aa, char *fname)
1140 {
1141     struct AclEntry *te, **le, *ne;
1142     int changes;
1143
1144     /* Don't correct DFS ACL's for now */
1145     if (aa->dfs)
1146         return 0;
1147
1148     /* prune out bad entries */
1149     changes = 0;            /* count deleted entries */
1150     le = &aa->pluslist;
1151     for(te = aa->pluslist; te; te=ne) {
1152         ne = te->next;
1153         if (BadName(te->name, fname)) {
1154             /* zap this dude */
1155             *le = te->next;
1156             aa->nplus--;
1157             free(te);
1158             changes++;
1159         } else {
1160             le = &te->next;
1161         }
1162     }
1163     le = &aa->minuslist;
1164     for(te = aa->minuslist; te; te=ne) {
1165         ne = te->next;
1166         if (BadName(te->name, fname)) {
1167             /* zap this dude */
1168             *le = te->next;
1169             aa->nminus--;
1170             free(te);
1171             changes++;
1172         } else {
1173             le = &te->next;
1174         }
1175     }
1176     return changes;
1177 }
1178
1179
1180 /* clean up an acl to not have bogus entries */
1181 static int 
1182 CleanACLCmd(struct cmd_syndesc *as, void *arock)
1183 {
1184     afs_int32 code;
1185     struct Acl *ta = 0;
1186     struct ViceIoctl blob;
1187     int changes;
1188     struct cmd_item *ti;
1189     struct AclEntry *te;
1190     int error = 0;
1191
1192     SetDotDefault(&as->parms[0].items);
1193     for(ti=as->parms[0].items; ti; ti=ti->next) {
1194         blob.out_size = MAXSIZE;
1195         blob.in_size = 0;
1196         blob.out = space;
1197         code = pioctl(ti->data, VIOCGETAL, &blob, 1);
1198         if (code) {
1199             Die(errno, ti->data);
1200             error = 1;
1201             continue;
1202         }
1203         if (ta)
1204             ZapAcl(ta);
1205         ta = ParseAcl(space);
1206
1207         if (ta->dfs) {
1208             fprintf(stderr,
1209                     "%s: cleanacl is not supported for DFS access lists.\n",
1210                     pn);
1211             error = 1;
1212             continue;
1213         }
1214
1215         changes = CleanAcl(ta, ti->data);
1216
1217         if (changes) {
1218             /* now set the acl */
1219             blob.in=AclToString(ta);
1220             blob.in_size = (long)strlen(blob.in)+1;
1221             blob.out_size = 0;
1222             code = pioctl(ti->data, VIOCSETAL, &blob, 1);
1223             if (code) {
1224                 if (errno == EINVAL) {
1225                     fprintf(stderr,
1226                             "%s: Invalid argument, possible reasons include\n", 
1227                              pn);
1228                     fprintf(stderr,"%s: File not in vice or\n", pn);
1229                     fprintf(stderr,
1230                             "%s: Too many users on access control list or\n", 
1231                             pn);
1232                 } else {
1233                     Die(errno, ti->data);
1234                 }
1235                 error = 1;
1236                 continue;
1237             }
1238
1239             /* now list the updated acl */
1240             printf("Access list for %s is now\n", ti->data);
1241             if (ta->nplus > 0) {
1242                 if (!ta->dfs) 
1243                     printf("Normal rights:\n");
1244                 for(te = ta->pluslist;te;te=te->next) {
1245                     printf("  %s ", te->name);
1246                     PRights(te->rights, ta->dfs);
1247                     printf("\n");
1248                 }
1249             }
1250             if (ta->nminus > 0) {
1251                 printf("Negative rights:\n");
1252                 for(te = ta->minuslist;te;te=te->next) {
1253                     printf("  %s ", te->name);
1254                     PRights(te->rights, ta->dfs);
1255                     printf("\n");
1256                 }
1257             }
1258             if (ti->next) 
1259                 printf("\n");
1260         } else
1261             printf("Access list for %s is fine.\n", ti->data);
1262     }
1263     if (ta)
1264         ZapAcl(ta);
1265     return error;
1266 }
1267
1268 static int 
1269 ListACLCmd(struct cmd_syndesc *as, void *arock) 
1270 {
1271     afs_int32 code;
1272     struct Acl *ta = 0;
1273     struct ViceIoctl blob;
1274     struct AclEntry *te;
1275     struct cmd_item *ti;
1276     int idf = getidf(as, parm_listacl_id);
1277     int error = 0;
1278
1279     SetDotDefault(&as->parms[0].items);
1280     for(ti=as->parms[0].items; ti; ti=ti->next) {
1281         char separator;
1282         blob.out_size = MAXSIZE;
1283         blob.in_size = idf;
1284         blob.in = blob.out = space;
1285         code = pioctl(ti->data, VIOCGETAL, &blob, 1);
1286         if (code) {
1287             Die(errno, ti->data);
1288             error = 1;
1289             continue;
1290         }
1291         ta = ParseAcl(space);
1292         switch (ta->dfs) {
1293           case 0:
1294             printf("Access list for %s is\n", ti->data);
1295             break;
1296           case 1:
1297             printf("DFS access list for %s is\n", ti->data);
1298             break;
1299           case 2:
1300             printf("DFS initial directory access list of %s is\n", ti->data);
1301             break;
1302           case 3:
1303             printf("DFS initial file access list of %s is\n", ti->data);
1304             break;
1305         }
1306         if (ta->dfs) {
1307             printf("  Default cell = %s\n", ta->cell);
1308         }
1309         separator = ta->dfs? DFS_SEPARATOR : ' ';
1310         if (ta->nplus > 0) {
1311             if (!ta->dfs) 
1312                 printf("Normal rights:\n");
1313             for(te = ta->pluslist;te;te=te->next) {
1314                 printf("  %s%c", te->name, separator);
1315                 PRights(te->rights, ta->dfs);
1316                 printf("\n");
1317             }
1318         }
1319         if (ta->nminus > 0) {
1320             printf("Negative rights:\n");
1321             for(te = ta->minuslist;te;te=te->next) {
1322                 printf("  %s ", te->name);
1323                 PRights(te->rights, ta->dfs);
1324                 printf("\n");
1325             }
1326         }
1327         if (ti->next) 
1328             printf("\n");
1329         ZapAcl(ta);
1330     }
1331     return error;
1332 }
1333
1334 static int
1335 FlushAllCmd(struct cmd_syndesc *as, void *arock)
1336 {
1337     afs_int32 code;
1338     struct ViceIoctl blob;
1339
1340     blob.in_size = blob.out_size = 0;
1341     code = pioctl(NULL, VIOC_FLUSHALL, &blob, 0);
1342     if (code) {
1343         fprintf(stderr, "Error flushing all ");
1344         return 1;
1345     }
1346     return 0;
1347 }
1348
1349 static int
1350 FlushVolumeCmd(struct cmd_syndesc *as, void *arock)
1351 {
1352     afs_int32 code;
1353     struct ViceIoctl blob;
1354     struct cmd_item *ti;
1355     int error = 0;
1356
1357     SetDotDefault(&as->parms[0].items);
1358     for(ti=as->parms[0].items; ti; ti=ti->next) {
1359         blob.in_size = blob.out_size = 0;
1360         code = pioctl(ti->data, VIOC_FLUSHVOLUME, &blob, 0);
1361         if (code) {
1362             fprintf(stderr, "Error flushing volume ");
1363             perror(ti->data);
1364             error = 1;
1365             continue;
1366         }
1367     }
1368     return error;
1369 }
1370
1371 static int 
1372 FlushCmd(struct cmd_syndesc *as, void *arock) 
1373 {
1374     afs_int32 code;
1375     struct ViceIoctl blob;
1376     struct cmd_item *ti;
1377     int error = 0;
1378     int literal = 0;
1379     cm_ioctlQueryOptions_t options;
1380
1381     if (as->parms[1].items)
1382         literal = 1;
1383     
1384     for(ti=as->parms[0].items; ti; ti=ti->next) {
1385         /* once per file */
1386         memset(&options, 0, sizeof(options));
1387         options.size = sizeof(options);
1388         options.field_flags |= CM_IOCTL_QOPTS_FIELD_LITERAL;
1389         options.literal = literal;
1390         blob.in_size = options.size;    /* no variable length data */
1391         blob.in = &options;
1392
1393         blob.out_size = 0;
1394         code = pioctl(ti->data, VIOCFLUSH, &blob, 0);
1395         if (code) {
1396             if (errno == EMFILE) {
1397                 fprintf(stderr, "%s: Can't flush active file %s\n", pn, 
1398                         ti->data);
1399             } else {
1400                 fprintf(stderr, "%s: Error flushing file ", pn);
1401                 perror(ti->data);
1402             }
1403             error = 1;
1404             continue;
1405         }
1406     }
1407     return error;
1408 }
1409
1410 /* all this command does is repackage its args and call SetVolCmd */
1411 static int
1412 SetQuotaCmd(struct cmd_syndesc *as, void *arock) {
1413     struct cmd_syndesc ts;
1414
1415     /* copy useful stuff from our command slot; we may later have to reorder */
1416     memcpy(&ts, as, sizeof(ts));        /* copy whole thing */
1417     return SetVolCmd(&ts, arock);
1418 }
1419
1420 static int
1421 SetVolCmd(struct cmd_syndesc *as, void *arock) {
1422     afs_int32 code;
1423     struct ViceIoctl blob;
1424     struct cmd_item *ti;
1425     struct VolumeStatus *status;
1426     char *motd, *offmsg, *input;
1427     int error = 0;
1428
1429     SetDotDefault(&as->parms[0].items);
1430     for(ti=as->parms[0].items; ti; ti=ti->next) {
1431         /* once per file */
1432         blob.out_size = MAXSIZE;
1433         blob.in_size = sizeof(*status) + 3;     /* for the three terminating nulls */
1434         blob.out = space;
1435         blob.in = space;
1436         status = (VolumeStatus *)space;
1437         status->MinQuota = status->MaxQuota = -1;
1438         motd = offmsg = NULL;
1439         if (as->parms[1].items) {
1440             code = util_GetInt32(as->parms[1].items->data, &status->MaxQuota);
1441             if (code) {
1442                 fprintf(stderr,"%s: bad integer specified for quota.\n", pn);
1443                 error = 1;
1444                 continue;
1445             }
1446         }
1447         if (as->parms[2].items) 
1448             motd = as->parms[2].items->data;
1449         if (as->parms[3].items) 
1450             offmsg = as->parms[3].items->data;
1451         input = (char *)status + sizeof(*status);
1452         *(input++) = '\0';      /* never set name: this call doesn't change vldb */
1453         if(offmsg) {
1454             if (strlen(offmsg) >= VMSGSIZE) {
1455                 fprintf(stderr,"%s: message must be shorter than %d characters\n",
1456                          pn, VMSGSIZE);
1457                 error = 1;
1458                 continue;
1459             }
1460             strcpy(input,offmsg);
1461             blob.in_size += (long)strlen(offmsg);
1462             input += strlen(offmsg) + 1;
1463         } else 
1464             *(input++) = '\0';
1465         if(motd) {
1466             if (strlen(motd) >= VMSGSIZE) {
1467                 fprintf(stderr,"%s: message must be shorter than %d characters\n",
1468                          pn, VMSGSIZE);
1469                 return code;
1470             }
1471             strcpy(input,motd);
1472             blob.in_size += (long)strlen(motd);
1473             input += strlen(motd) + 1;
1474         } else 
1475             *(input++) = '\0';
1476         code = pioctl(ti->data,VIOCSETVOLSTAT, &blob, 1);
1477         if (code) {
1478             Die(errno, ti->data);
1479             error = 1;
1480         }
1481     }
1482     return error;
1483 }
1484
1485 /* values match cache manager File Types */
1486 static char *
1487 filetypestr(afs_uint32 type)
1488 {
1489     char * s = "Object";
1490
1491     switch (type) {
1492     case 1:     /* file */
1493         s = "File";
1494         break;
1495     case 2:
1496         s = "Directory";
1497         break;
1498     case 3:
1499         s = "Symlink";
1500         break;
1501     case 4:
1502         s = "Mountpoint";
1503         break;
1504     case 5:
1505         s = "DfsLink";
1506         break;
1507     }
1508     return s;
1509 }
1510
1511 static int 
1512 ExamineCmd(struct cmd_syndesc *as, void *arock)
1513 {
1514     afs_int32 code;
1515     struct ViceIoctl blob;
1516     struct cmd_item *ti;
1517     struct VolumeStatus *status;
1518     char *name, *offmsg, *motd;
1519     int error = 0;
1520     int literal = 0;
1521     cm_ioctlQueryOptions_t options;
1522
1523     if (as->parms[1].items)
1524         literal = 1;
1525
1526     SetDotDefault(&as->parms[0].items);
1527     for(ti=as->parms[0].items; ti; ti=ti->next) {
1528         cm_fid_t fid;
1529         afs_uint32 filetype;
1530         afs_uint32 owner[2];
1531         char cell[MAXCELLCHARS];
1532
1533         /* once per file */
1534         memset(&fid, 0, sizeof(fid));
1535         memset(&options, 0, sizeof(options));
1536         filetype = 0;
1537         options.size = sizeof(options);
1538         options.field_flags |= CM_IOCTL_QOPTS_FIELD_LITERAL;
1539         options.literal = literal;
1540         blob.in_size = options.size;    /* no variable length data */
1541         blob.in = &options;
1542
1543         blob.out_size = sizeof(cm_fid_t);
1544         blob.out = (char *) &fid;
1545         if (0 == pioctl(ti->data, VIOCGETFID, &blob, 1)) {
1546             options.field_flags |= CM_IOCTL_QOPTS_FIELD_FID;
1547             options.fid = fid;
1548         } else {
1549             Die(errno, ti->data);
1550             error = 1;
1551             continue;
1552         }
1553
1554         blob.out_size = sizeof(filetype);
1555         blob.out = &filetype;
1556
1557         code = pioctl(ti->data, VIOC_GETFILETYPE, &blob, 1);
1558
1559         blob.out_size = MAXCELLCHARS;
1560         blob.out = cell;
1561
1562         code = pioctl(ti->data, VIOC_FILE_CELL_NAME, &blob, 1);
1563         printf("%s %s (%u.%u.%u) contained in cell %s\n",
1564                 filetypestr(filetype),
1565                 ti->data, fid.volume, fid.vnode, fid.unique,
1566                 code ? "unknown-cell" : cell);
1567
1568         blob.out_size = 2 * sizeof(afs_uint32);
1569         blob.out = (char *) &owner;
1570         if (0 == pioctl(ti->data, VIOCGETOWNER, &blob, 1)) {
1571             char oname[PR_MAXNAMELEN] = "(unknown)";
1572
1573             /* Go to the PRDB and see if this all number username is valid */
1574             pr_Initialize(1, AFSDIR_CLIENT_ETC_DIRPATH, cell);
1575             pr_SIdToName(owner[0], oname);
1576             printf("Owner %s (%u) Group %u\n", oname, owner[0], owner[1]);
1577         }
1578
1579         blob.out = space;
1580         blob.out_size = MAXSIZE;
1581         code = pioctl(ti->data, VIOCGETVOLSTAT, &blob, 1);
1582         if (code == 0) {
1583             status = (VolumeStatus *)space;
1584             name = (char *)status + sizeof(*status);
1585             offmsg = name + strlen(name) + 1;
1586             motd = offmsg + strlen(offmsg) + 1;
1587
1588             PrintStatus(status, name, motd, offmsg);
1589         } else {
1590             Die(errno, ti->data);
1591         }
1592
1593         errno = 0;
1594         code = pioctl(ti->data, VIOC_PATH_AVAILABILITY, &blob, 1);
1595         switch (errno) {
1596         case 0:
1597             printf("Volume is online\n");
1598             break;
1599         case ENXIO:
1600             printf("Volume is offline\n");
1601             break;
1602         case ENOSYS:
1603             printf("All Volume servers are down\n");
1604             break;
1605         case EBUSY:
1606             printf("All volume servers are busy\n");
1607             break;
1608         default:
1609             printf("Unknown volume state\n");
1610             Die(errno, ti->data);
1611         }
1612         printf("\n");
1613     }
1614     return error;
1615 }
1616
1617 static int
1618 ListQuotaCmd(struct cmd_syndesc *as, void *arock) 
1619 {
1620     afs_int32 code;
1621     struct ViceIoctl blob;
1622     struct cmd_item *ti;
1623     struct VolumeStatus *status;
1624     char *name;
1625
1626     int error = 0;
1627     
1628     printf("%-25s%-10s%-10s%-7s%-13s\n", 
1629            "Volume Name", "     Quota", "      Used", "  %Used", "    Partition");
1630     SetDotDefault(&as->parms[0].items);
1631     for(ti=as->parms[0].items; ti; ti=ti->next) {
1632         /* once per file */
1633         blob.out_size = MAXSIZE;
1634         blob.in_size = 0;
1635         blob.out = space;
1636         code = pioctl(ti->data, VIOCGETVOLSTAT, &blob, 1);
1637         if (code) {
1638             Die(errno, ti->data);
1639             error = 1;
1640             continue;
1641         }
1642         status = (VolumeStatus *)space;
1643         name = (char *)status + sizeof(*status);
1644         QuickPrintStatus(status, name);
1645     }
1646     return error;
1647 }
1648
1649 static int
1650 WhereIsCmd(struct cmd_syndesc *as, void *arock)
1651 {
1652     afs_int32 code;
1653     struct ViceIoctl blob;
1654     struct cmd_item *ti;
1655     int j;
1656     afs_int32 *hosts;
1657     char *tp;
1658     int error = 0;
1659     int literal = 0;
1660     cm_ioctlQueryOptions_t options;
1661
1662     if (as->parms[1].items)
1663         literal = 1;
1664     
1665     SetDotDefault(&as->parms[0].items);
1666     for(ti=as->parms[0].items; ti; ti=ti->next) {
1667         cm_fid_t fid;
1668         afs_uint32 filetype;
1669
1670         /* once per file */
1671         memset(&fid, 0, sizeof(fid));
1672         memset(&options, 0, sizeof(options));
1673         filetype = 0;
1674         options.size = sizeof(options);
1675         options.field_flags |= CM_IOCTL_QOPTS_FIELD_LITERAL;
1676         options.literal = literal;
1677         blob.in_size = options.size;    /* no variable length data */
1678         blob.in = &options;
1679         
1680         blob.out_size = sizeof(cm_fid_t);
1681         blob.out = (char *) &fid;
1682         if (0 == pioctl(ti->data, VIOCGETFID, &blob, 1)) {
1683             options.field_flags |= CM_IOCTL_QOPTS_FIELD_FID;
1684             options.fid = fid;
1685         } else {
1686             Die(errno, ti->data);
1687             error = 1;
1688             continue;
1689         }
1690
1691         blob.out_size = sizeof(filetype);
1692         blob.out = &filetype;
1693
1694         code = pioctl(ti->data, VIOC_GETFILETYPE, &blob, 1);
1695
1696         blob.out_size = MAXSIZE;
1697         blob.out = space;
1698         memset(space, 0, sizeof(space));
1699         code = pioctl(ti->data, VIOCWHEREIS, &blob, 1);
1700         if (code) {
1701             Die(errno, ti->data);
1702             error = 1;
1703             continue;
1704         }
1705         hosts = (afs_int32 *) space;
1706         printf("%s %s is on host%s ", 
1707                 filetypestr(filetype),
1708                 ti->data,
1709                 (hosts[0] && !hosts[1]) ? "": "s");
1710         for(j=0; j<MAXHOSTS; j++) {
1711             if (hosts[j] == 0) 
1712                 break;
1713             tp = hostutil_GetNameByINet(hosts[j]);
1714             printf("%s ", tp);
1715         }
1716         printf("\n");
1717     }
1718     return error;
1719 }
1720
1721
1722 static int
1723 DiskFreeCmd(struct cmd_syndesc *as, void *arock)
1724 {
1725     afs_int32 code;
1726     struct ViceIoctl blob;
1727     struct cmd_item *ti;
1728     char *name;
1729     struct VolumeStatus *status;
1730     int error = 0;
1731     
1732     printf("%-25s%-10s%-10s%-10s%-6s\n", "Volume Name", "    kbytes",
1733            "      used", "     avail", " %used");
1734     SetDotDefault(&as->parms[0].items);
1735     for(ti=as->parms[0].items; ti; ti=ti->next) {
1736         /* once per file */
1737         blob.out_size = MAXSIZE;
1738         blob.in_size = 0;
1739         blob.out = space;
1740         code = pioctl(ti->data, VIOCGETVOLSTAT, &blob, 1);
1741         if (code) {
1742             Die(errno, ti->data);
1743             error = 1;
1744             continue;
1745         }
1746         status = (VolumeStatus *)space;
1747         name = (char *)status + sizeof(*status);
1748         QuickPrintSpace(status, name);
1749     }
1750     return error;
1751 }
1752
1753 static int
1754 QuotaCmd(struct cmd_syndesc *as, void *arock)
1755 {
1756     afs_int32 code;
1757     struct ViceIoctl blob;
1758     struct cmd_item *ti;
1759     double quotaPct;
1760     struct VolumeStatus *status;
1761     int error = 0;
1762     
1763     SetDotDefault(&as->parms[0].items);
1764     for(ti=as->parms[0].items; ti; ti=ti->next) {
1765         /* once per file */
1766         blob.out_size = MAXSIZE;
1767         blob.in_size = 0;
1768         blob.out = space;
1769         code = pioctl(ti->data, VIOCGETVOLSTAT, &blob, 1);
1770         if (code) {
1771             Die(errno, ti->data);
1772             error = 1;
1773             continue;
1774         }
1775         status = (VolumeStatus *)space;
1776         if (status->MaxQuota) 
1777             quotaPct = ((((double)status->BlocksInUse)/status->MaxQuota) * 100.0);
1778         else 
1779             quotaPct = 0.0;
1780         printf("%2.0f%% of quota used.\n", quotaPct);
1781     }
1782     return error;
1783 }
1784
1785 static int
1786 ListMountCmd(struct cmd_syndesc *as, void *arock)
1787 {
1788     afs_int32 code;
1789     struct ViceIoctl blob;
1790     struct cmd_item *ti;
1791     char orig_name[1024];               /*Original name, may be modified*/
1792     char true_name[1024];               /*``True'' dirname (e.g., symlink target)*/
1793     char parent_dir[1024];              /*Parent directory of true name*/
1794     char *last_component;       /*Last component of true name*/
1795 #ifndef WIN32
1796     struct stat statbuff;               /*Buffer for status info*/
1797 #endif /* not WIN32 */
1798 #ifndef WIN32
1799     int link_chars_read;                /*Num chars read in readlink()*/
1800 #endif /* not WIN32 */
1801     int thru_symlink;                   /*Did we get to a mount point via a symlink?*/
1802     
1803     int error = 0;
1804     for(ti=as->parms[0].items; ti; ti=ti->next) {
1805         /* once per file */
1806         thru_symlink = 0;
1807 #ifdef WIN32
1808         strcpy(orig_name, ti->data);
1809 #else /* not WIN32 */
1810         sprintf(orig_name, "%s%s",
1811                 (ti->data[0] == '/') ? "" : "./",
1812                 ti->data);
1813 #endif /* not WIN32 */
1814
1815 #ifndef WIN32
1816         if (lstat(orig_name, &statbuff) < 0) {
1817             /* if lstat fails, we should still try the pioctl, since it
1818              * may work (for example, lstat will fail, but pioctl will
1819              * work if the volume of offline (returning ENODEV). */
1820             statbuff.st_mode = S_IFDIR; /* lie like pros */
1821         }
1822
1823         /*
1824          * The lstat succeeded.  If the given file is a symlink, substitute
1825          * the file name with the link name.
1826          */
1827         if ((statbuff.st_mode & S_IFMT) == S_IFLNK) {
1828             thru_symlink = 1;
1829             /*
1830              * Read name of resolved file.
1831              */
1832             link_chars_read = readlink(orig_name, true_name, 1024);
1833             if (link_chars_read <= 0) {
1834                 fprintf(stderr,
1835                         "%s: Can't read target name for '%s' symbolic link!\n",
1836                        pn, orig_name);
1837                 error = 1;
1838                 continue;
1839             }
1840
1841             /*
1842              * Add a trailing null to what was read, bump the length.
1843              */
1844             true_name[link_chars_read++] = 0;
1845
1846             /*
1847              * If the symlink is an absolute pathname, we're fine.  Otherwise, we
1848              * have to create a full pathname using the original name and the
1849              * relative symlink name.  Find the rightmost slash in the original
1850              * name (we know there is one) and splice in the symlink value.
1851              */
1852             if (true_name[0] != '\\') {
1853                 last_component = (char *) strrchr(orig_name, '\\');
1854                 strcpy(++last_component, true_name);
1855                 strcpy(true_name, orig_name);
1856             }
1857         } else
1858             strcpy(true_name, orig_name);
1859 #else   /* WIN32 */
1860         strcpy(true_name, orig_name);
1861 #endif /* WIN32 */
1862
1863         /*
1864          * Find rightmost slash, if any.
1865          */
1866 #ifdef WIN32
1867         last_component = (char *) strrchr(true_name, '\\');
1868         if (!last_component)
1869 #endif /* WIN32 */
1870             last_component = (char *) strrchr(true_name, '/');
1871         if (last_component) {
1872             /*
1873              * Found it.  Designate everything before it as the parent directory,
1874              * everything after it as the final component.
1875              */
1876             strncpy(parent_dir, true_name, last_component - true_name + 1);
1877             parent_dir[last_component - true_name + 1] = 0;
1878             last_component++;   /*Skip the slash*/
1879 #ifdef WIN32
1880             if (!InAFS(parent_dir)) {
1881                 const char * nbname = NetbiosName();
1882                 int len = (int)strlen(nbname);
1883
1884                 if (parent_dir[0] == '\\' && parent_dir[1] == '\\' &&
1885                     parent_dir[len+2] == '\\' &&
1886                     parent_dir[len+3] == '\0' &&
1887                     !strnicmp(nbname,&parent_dir[2],len))
1888                 {
1889                     sprintf(parent_dir,"\\\\%s\\all\\", nbname);
1890                 }
1891             }
1892 #endif
1893         } else {
1894             /*
1895              * No slash appears in the given file name.  Set parent_dir to the current
1896              * directory, and the last component as the given name.
1897              */
1898             fs_ExtractDriveLetter(true_name, parent_dir);
1899             strcat(parent_dir, ".");
1900             last_component = true_name;
1901             fs_StripDriveLetter(true_name, true_name, sizeof(true_name));
1902         }
1903
1904         if (strcmp(last_component, ".") == 0 || strcmp(last_component, "..") == 0) {
1905             fprintf(stderr,"%s: you may not use '.' or '..' as the last component\n",pn);
1906             fprintf(stderr,"%s: of a name in the 'fs lsmount' command.\n",pn);
1907             error = 1;
1908             continue;
1909         }
1910
1911         blob.in = last_component;
1912         blob.in_size = (long)strlen(last_component)+1;
1913         blob.out_size = MAXSIZE;
1914         blob.out = space;
1915         memset(space, 0, MAXSIZE);
1916
1917         code = pioctl(parent_dir, VIOC_AFS_STAT_MT_PT, &blob, 1);
1918
1919         if (code == 0) {
1920             printf("'%s' is a %smount point for volume '%s'\n",
1921                    ti->data,
1922                    (thru_symlink ? "symbolic link, leading to a " : ""),
1923                    space);
1924
1925         } else {
1926             if (errno == EINVAL) {
1927                 fprintf(stderr,"'%s' is not a mount point.\n", ti->data);
1928             } else {
1929                 Die(errno, (ti->data ? ti->data : parent_dir));
1930             }
1931             error = 1;
1932         }
1933     }
1934     return error;
1935 }
1936
1937 static int
1938 MakeMountCmd(struct cmd_syndesc *as, void *arock)
1939 {
1940     afs_int32 code;
1941     char *cellName, *volName, *tmpName;
1942 #ifdef WIN32
1943     char localCellName[128];
1944 #endif
1945     char path[1024] = "";
1946     struct afsconf_cell info;
1947     struct vldbentry vldbEntry;
1948     struct ViceIoctl blob;
1949     char * parent;
1950
1951     if (as->parms[2].items)     /* cell name specified */
1952         cellName = as->parms[2].items->data;
1953     else
1954         cellName = NULL;
1955     volName = as->parms[1].items->data;
1956
1957     if (strlen(volName) >= 64) {
1958         fprintf(stderr,"%s: volume name too long (length must be < 64 characters)\n", pn);
1959         return 1;
1960     }
1961
1962     /* Check for a cellname in the volume specification, and complain
1963      * if it doesn't match what was specified with -cell */
1964     if (tmpName = strchr(volName, ':')) {
1965         *tmpName = '\0';
1966         if (cellName) {
1967             if (strcasecmp(cellName,volName)) {
1968                 fprintf(stderr,"fs: cellnames do not match.\n");
1969                 return 1;
1970             }
1971         }
1972         cellName = volName;
1973         volName = ++tmpName;
1974     }
1975
1976     parent = Parent(as->parms[0].items->data);
1977     if (!InAFS(parent)) {
1978 #ifdef WIN32
1979         const char * nbname = NetbiosName();
1980         int len = (int)strlen(nbname);
1981
1982         if (parent[0] == '\\' && parent[1] == '\\' &&
1983             parent[len+2] == '\\' &&
1984             parent[len+3] == '\0' &&
1985             !strnicmp(nbname,&parent[2],len))
1986         {
1987             sprintf(path,"%sall\\%s", parent, &as->parms[0].items->data[strlen(parent)]);
1988             parent = Parent(path);
1989             if (!InAFS(parent)) {
1990                 fprintf(stderr,"%s: mount points must be created within the AFS file system\n", pn);
1991                 return 1;
1992             }
1993         } else 
1994 #endif
1995         {
1996             fprintf(stderr,"%s: mount points must be created within the AFS file system\n", pn);
1997             return 1;
1998         }
1999     }
2000
2001     if ( strlen(path) == 0 )
2002         strcpy(path, as->parms[0].items->data);
2003
2004     if ( IsFreelanceRoot(parent) ) {
2005         if ( !IsAdmin() ) {
2006             fprintf(stderr,"%s: Only AFS Client Administrators may alter the root.afs volume\n", pn);
2007             return 1;
2008         }
2009
2010         if (!cellName) {
2011             blob.in_size = 0;
2012             blob.out_size = sizeof(localCellName);
2013             blob.out = localCellName;
2014             code = pioctl(parent, VIOC_GET_WS_CELL, &blob, 1);
2015             if (!code)
2016                 cellName = localCellName;
2017         }
2018     } else {
2019         if (!cellName) {
2020             code = GetCell(parent,space);
2021             if (code)
2022                 return 1;
2023         }
2024     }
2025
2026     code = GetCellName(cellName?cellName:space, &info);
2027     if (code) {
2028         return 1;
2029     }
2030     if (!(as->parms[4].items)) {
2031       /* not fast, check which cell the mountpoint is being created in */
2032       code = 0;
2033         /* not fast, check name with VLDB */
2034       if (!code)
2035         code = VLDBInit(1, &info);
2036       if (code == 0) {
2037           /* make the check.  Don't complain if there are problems with init */
2038           code = ubik_VL_GetEntryByNameO(uclient, 0, volName, &vldbEntry);
2039           if (code == VL_NOENT) {
2040               fprintf(stderr,"%s: warning, volume %s does not exist in cell %s.\n",
2041                       pn, volName, cellName ? cellName : space);
2042           }
2043       }
2044     }
2045
2046     if (as->parms[3].items)     /* if -rw specified */
2047         strcpy(space, "%");
2048     else
2049         strcpy(space, "#");
2050     if (cellName) {
2051         /* cellular mount point, prepend cell prefix */
2052         strcat(space, info.name);
2053         strcat(space, ":");
2054     }
2055     strcat(space, volName);     /* append volume name */
2056     strcat(space, ".");         /* stupid convention; these end with a period */
2057 #ifdef WIN32
2058     /* create symlink with a special pioctl for Windows NT, since it doesn't
2059      * have a symlink system call.
2060      */
2061     blob.out_size = 0;
2062     blob.in_size = 1 + (long)strlen(space);
2063     blob.in = space;
2064     blob.out = NULL;
2065     code = pioctl(path, VIOC_AFS_CREATE_MT_PT, &blob, 0);
2066 #else /* not WIN32 */
2067     code = symlink(space, path);
2068 #endif /* not WIN32 */
2069     if (code) {
2070         Die(errno, path);
2071         return 1;
2072     }
2073     return 0;
2074 }
2075
2076 /*
2077  * Delete AFS mount points.  Variables are used as follows:
2078  *       tbuffer: Set to point to the null-terminated directory name of the mount point
2079  *          (or ``.'' if none is provided)
2080  *      tp: Set to point to the actual name of the mount point to nuke.
2081  */
2082 static int
2083 RemoveMountCmd(struct cmd_syndesc *as, void *arock) {
2084     afs_int32 code=0;
2085     struct ViceIoctl blob;
2086     struct cmd_item *ti;
2087     char tbuffer[1024];
2088     char lsbuffer[1024];
2089     char *tp;
2090     int error = 0;
2091     
2092     for(ti=as->parms[0].items; ti; ti=ti->next) {
2093         /* once per file */
2094         tp = (char *) strrchr(ti->data, '\\');
2095         if (!tp)
2096             tp = (char *) strrchr(ti->data, '/');
2097         if (tp) {
2098             strncpy(tbuffer, ti->data, code=(afs_int32)(tp-ti->data+1));  /* the dir name */
2099             tbuffer[code] = 0;
2100             tp++;   /* skip the slash */
2101
2102 #ifdef WIN32
2103             if (!InAFS(tbuffer)) {
2104                 const char * nbname = NetbiosName();
2105                 int len = (int)strlen(nbname);
2106
2107                 if (tbuffer[0] == '\\' && tbuffer[1] == '\\' &&
2108                     tbuffer[len+2] == '\\' &&
2109                     tbuffer[len+3] == '\0' &&
2110                     !strnicmp(nbname,&tbuffer[2],len))
2111                 {
2112                     sprintf(tbuffer,"\\\\%s\\all\\", nbname);
2113                 }
2114             }
2115 #endif
2116         } else {
2117             fs_ExtractDriveLetter(ti->data, tbuffer);
2118             strcat(tbuffer, ".");
2119             tp = ti->data;
2120             fs_StripDriveLetter(tp, tp, 0);
2121         }
2122         blob.in = tp;
2123         blob.in_size = (long)strlen(tp)+1;
2124         blob.out = lsbuffer;
2125         blob.out_size = sizeof(lsbuffer);
2126         code = pioctl(tbuffer, VIOC_AFS_STAT_MT_PT, &blob, 0);
2127         if (code) {
2128             if (errno == EINVAL) {
2129                 fprintf(stderr,"%s: '%s' is not a mount point.\n", pn, ti->data);
2130             } else {
2131                 Die(errno, ti->data);
2132             }
2133             error = 1;
2134             continue;   /* don't bother trying */
2135         }
2136
2137         if ( IsFreelanceRoot(tbuffer) && !IsAdmin() ) {
2138             fprintf(stderr,"%s: Only AFS Client Administrators may alter the root.afs volume\n", pn);
2139             error = 1;
2140             continue;   /* skip */
2141         }
2142
2143         blob.out_size = 0;
2144         blob.in = tp;
2145         blob.in_size = (long)strlen(tp)+1;
2146         code = pioctl(tbuffer, VIOC_AFS_DELETE_MT_PT, &blob, 0);
2147         if (code) {
2148             Die(errno, ti->data);
2149             error = 1;
2150         }
2151     }
2152     return error;
2153 }
2154
2155 /*
2156 */
2157
2158 static int
2159 CheckServersCmd(struct cmd_syndesc *as, void *arock)
2160 {
2161     afs_int32 code;
2162     struct ViceIoctl blob;
2163     afs_int32 j;
2164     afs_int32 temp;
2165     char *tp;
2166     struct afsconf_cell info;
2167     struct chservinfo checkserv;
2168
2169     memset(&checkserv, 0, sizeof(struct chservinfo));
2170     blob.in_size=sizeof(struct chservinfo);
2171     blob.in=(caddr_t)&checkserv;
2172
2173     blob.out_size = MAXSIZE;
2174     blob.out = space;
2175     memset(space, 0, sizeof(afs_int32));        /* so we assure zero when nothing is copied back */
2176
2177     /* prepare flags for checkservers command */
2178     temp = 2;   /* default to checking local cell only */
2179     if (as->parms[2].items) 
2180         temp |= 1;      /* set fast flag */
2181     if (as->parms[1].items) 
2182         temp &= ~2;     /* turn off local cell check */
2183     
2184     checkserv.magic = 0x12345678;       /* XXX */
2185     checkserv.tflags=temp;
2186
2187     /* now copy in optional cell name, if specified */
2188     if (as->parms[0].items) {
2189         code = GetCellName(as->parms[0].items->data, &info);
2190         if (code) {
2191             return 1;
2192         }
2193         strcpy(checkserv.tbuffer,info.name);
2194         checkserv.tsize=(int)strlen(info.name)+1;
2195     } else {
2196         strcpy(checkserv.tbuffer,"\0");
2197         checkserv.tsize=0;
2198     }
2199
2200     if(as->parms[3].items) {
2201         checkserv.tinterval=atol(as->parms[3].items->data);
2202
2203         /* sanity check */
2204         if(checkserv.tinterval<0) {
2205             printf("Warning: The negative -interval is ignored; treated as an inquiry\n");
2206             checkserv.tinterval=-1;
2207         } else if(checkserv.tinterval> 600) {
2208             printf("Warning: The maximum -interval value is 10 mins (600 secs)\n");
2209             checkserv.tinterval=600;    /* 10 min max interval */
2210         }       
2211     } else {
2212         checkserv.tinterval = -1;       /* don't change current interval */
2213     }
2214
2215     if ( checkserv.tinterval >= 0 ) {
2216 #ifdef WIN32
2217         if ( !IsAdmin() ) {
2218             fprintf (stderr,"Permission denied: requires AFS Client Administrator access.\n");
2219             return EACCES;
2220         }
2221 #else /* WIN32 */
2222         if (geteuid()) {
2223             fprintf (stderr,"Permission denied: requires root access.\n");
2224             return EACCES;
2225         }
2226 #endif /* WIN32 */
2227     }
2228
2229     code = pioctl(0, VIOCCKSERV, &blob, 1);
2230     if (code) {
2231         if ((errno == EACCES) && (checkserv.tinterval > 0)) {
2232             printf("Must be root to change -interval\n");
2233             return code;
2234         }
2235         Die(errno, 0);
2236         return 1;
2237     }
2238     memcpy(&temp, space, sizeof(afs_int32));
2239     if (checkserv.tinterval >= 0) {
2240         if (checkserv.tinterval > 0) 
2241             printf("The new down server probe interval (%d secs) is now in effect (old interval was %d secs)\n", 
2242                    checkserv.tinterval, temp);
2243         else 
2244             printf("The current down server probe interval is %d secs\n", temp);
2245         return 0;
2246     }
2247     if (temp == 0) {
2248         printf("All servers are running.\n");
2249     } else {
2250         printf("These servers unavailable due to network or server problems: ");
2251         for(j=0; j < MAXHOSTS; j++) {
2252             memcpy(&temp, space + j*sizeof(afs_int32), sizeof(afs_int32));
2253             if (temp == 0) 
2254                 break;
2255             tp = hostutil_GetNameByINet(temp);
2256             printf(" %s", tp);
2257         }
2258         printf(".\n");
2259         code = 1;       /* XXX */
2260     }
2261     return code;
2262 }
2263
2264 static int
2265 MessagesCmd(struct cmd_syndesc *as, void *arock)
2266 {
2267     afs_int32 code=0;
2268     struct ViceIoctl blob;
2269     struct gaginfo gagflags;
2270     struct cmd_item *show;
2271     
2272     memset(&gagflags, 0, sizeof(struct gaginfo));
2273     blob.in_size = sizeof(struct gaginfo);
2274     blob.in = (caddr_t ) &gagflags;
2275     blob.out_size = MAXSIZE;
2276     blob.out = space;
2277     memset(space, 0, sizeof(afs_int32));        /* so we assure zero when nothing is copied back */
2278
2279     if (show = as->parms[0].items) {
2280         if (!strcasecmp (show->data, "user"))
2281             gagflags.showflags |= GAGUSER;
2282         else if (!strcasecmp (show->data, "console"))
2283             gagflags.showflags |= GAGCONSOLE;
2284         else if (!strcasecmp (show->data, "all"))
2285             gagflags.showflags |= GAGCONSOLE | GAGUSER;
2286         else if (!strcasecmp (show->data, "none"))
2287             /* do nothing */ ;
2288         else {
2289             fprintf(stderr, 
2290                      "unrecognized flag %s: must be in {user,console,all,none}\n", 
2291                      show->data);
2292             code = EINVAL;
2293         }
2294     }
2295  
2296     if (code)
2297         return 1;
2298
2299     code = pioctl(0, VIOC_GAG, &blob, 1);
2300     if (code) {
2301         Die(errno, 0);
2302         return 1;
2303     }
2304     return 0;
2305 }
2306
2307 static int
2308 CheckVolumesCmd(struct cmd_syndesc *as, void *arock)
2309 {
2310     afs_int32 code;
2311     struct ViceIoctl blob;
2312     
2313     blob.in_size = 0;
2314     blob.out_size = 0;
2315     code = pioctl(0, VIOCCKBACK, &blob, 1);
2316     if (code) {
2317         Die(errno, 0);
2318         return 1;
2319     }
2320     printf("All volumeID/name mappings checked.\n");
2321     
2322     return 0;
2323 }
2324
2325 static int
2326 SetCacheSizeCmd(struct cmd_syndesc *as, void *arock)
2327 {
2328     afs_int32 code;
2329     struct ViceIoctl blob;
2330     afs_int32 temp;
2331     
2332 #ifdef WIN32
2333     if ( !IsAdmin() ) {
2334         fprintf (stderr,"Permission denied: requires AFS Client Administrator access.\n");
2335         return EACCES;
2336     }
2337 #else /* WIN32 */
2338     if (geteuid()) {
2339         fprintf (stderr,"Permission denied: requires root access.\n");
2340         return EACCES;
2341     }
2342 #endif /* WIN32 */
2343
2344     if (!as->parms[0].items && !as->parms[1].items) {
2345         fprintf(stderr,"%s: syntax error in set cache size cmd.\n", pn);
2346         return 1;
2347     }
2348     if (as->parms[0].items) {
2349         code = util_GetInt32(as->parms[0].items->data, &temp);
2350         if (code) {
2351             fprintf(stderr,"%s: bad integer specified for cache size.\n", pn);
2352             return 1;
2353         }
2354     } else
2355         temp = 0;
2356     blob.in = (char *) &temp;
2357     blob.in_size = sizeof(afs_int32);
2358     blob.out_size = 0;
2359     code = pioctl(0, VIOCSETCACHESIZE, &blob, 1);
2360     if (code) {
2361         Die(errno, (char *) 0);
2362         return 1;
2363     } 
2364       
2365     printf("New cache size set.\n");
2366     return 0;
2367 }
2368
2369 static int
2370 GetCacheParmsCmd(struct cmd_syndesc *as, void *arock)
2371 {
2372     afs_int32 code;
2373     struct ViceIoctl blob;
2374     cm_cacheParms_t parms;
2375
2376     memset(&parms, 0, sizeof(parms));
2377     blob.in = NULL;
2378     blob.in_size = 0;
2379     blob.out_size = sizeof(parms);
2380     blob.out = (char *) &parms;
2381     code = pioctl(0, VIOCGETCACHEPARMS, &blob, 1);
2382     if (code) {
2383         Die(errno, NULL);
2384         return 1;
2385     }
2386      
2387     printf("AFS using %I64u of the cache's available %I64u 1K byte blocks.\n",
2388            parms.parms[1], parms.parms[0]);
2389     if (parms.parms[1] > parms.parms[0])
2390         printf("[Cache guideline temporarily deliberately exceeded; it will be adjusted down but you may wish to increase the cache size.]\n");
2391     return 0;
2392 }
2393
2394 static int
2395 ListCellsCmd(struct cmd_syndesc *as, void *arock)
2396 {
2397     afs_int32 code;
2398     afs_int32 i, j, *lp, magic, size;
2399     char *tp;
2400     afs_int32 addr, maxa = OMAXHOSTS;
2401     struct ViceIoctl blob;
2402     int resolve;
2403
2404     resolve = !(as->parms[0].items);    /* -numeric */
2405     
2406     for(i=0;i<1000;i++) {
2407         tp = space;
2408         memcpy(tp, &i, sizeof(afs_int32));
2409         tp = (char *)(space + sizeof(afs_int32));
2410         lp = (afs_int32 *)tp;
2411         *lp++ = 0x12345678;
2412         size = sizeof(afs_int32) + sizeof(afs_int32);
2413         blob.out_size = MAXSIZE;
2414         blob.in_size = sizeof(afs_int32);
2415         blob.in = space;
2416         blob.out = space;
2417         code = pioctl(0, VIOCGETCELL, &blob, 1);
2418         if (code < 0) {
2419             if (errno == EDOM) 
2420                 break;  /* done with the list */
2421             Die(errno, 0);
2422             return 1;
2423         }       
2424         tp = space;
2425         memcpy(&magic, tp, sizeof(afs_int32));  
2426         if (magic == 0x12345678) {
2427             maxa = MAXHOSTS;
2428             tp += sizeof(afs_int32);
2429         }
2430         printf("Cell %s on hosts", tp+maxa*sizeof(afs_int32));
2431         for(j=0; j < maxa; j++) {
2432             char *name, tbuffer[20];
2433
2434             memcpy(&addr, tp + j*sizeof(afs_int32), sizeof(afs_int32));
2435             if (addr == 0) 
2436                 break;
2437
2438             if (resolve) {
2439                 name = hostutil_GetNameByINet(addr);
2440             } else {
2441                 addr = ntohl(addr);
2442                 sprintf(tbuffer, "%d.%d.%d.%d", (addr >> 24) & 0xff,
2443                          (addr >> 16) & 0xff, (addr >> 8) & 0xff, addr & 0xff);
2444                 name = tbuffer;
2445             }
2446             printf(" %s", name);
2447         }
2448         printf(".\n");
2449     }
2450     return 0;
2451 }
2452
2453 #ifndef WIN32
2454 static int
2455 ListAliasesCmd(struct cmd_syndesc *as, void *arock)
2456 {
2457     afs_int32 code, i;
2458     char *tp, *aliasName, *realName;
2459     struct ViceIoctl blob;
2460
2461     for (i = 0;; i++) {
2462         tp = space;
2463         memcpy(tp, &i, sizeof(afs_int32));
2464         blob.out_size = MAXSIZE;
2465         blob.in_size = sizeof(afs_int32);
2466         blob.in = space;
2467         blob.out = space;
2468         code = pioctl(0, VIOC_GETALIAS, &blob, 1);
2469         if (code < 0) {
2470             if (errno == EDOM)
2471                 break;          /* done with the list */
2472             Die(errno, 0);
2473             return 1;
2474         }
2475         tp = space;
2476         aliasName = tp;
2477         tp += strlen(aliasName) + 1;
2478         realName = tp;
2479         printf("Alias %s for cell %s\n", aliasName, realName);
2480     }
2481     return 0;
2482 }
2483
2484 static int
2485 CallBackRxConnCmd(struct cmd_syndesc *as, void *arock)
2486 {
2487     afs_int32 code;
2488     struct ViceIoctl blob;
2489     struct cmd_item *ti;
2490     afs_int32 hostAddr;
2491     struct hostent *thp;
2492     char *tp;
2493     int setp;
2494     
2495     ti = as->parms[0].items;
2496     setp = 1;
2497     if (ti) {
2498         thp = hostutil_GetHostByName(ti->data);
2499         if (!thp) {
2500             fprintf(stderr, "host %s not found in host table.\n", ti->data);
2501             return 1;
2502         }
2503         else memcpy(&hostAddr, thp->h_addr, sizeof(afs_int32));
2504     } else {
2505         hostAddr = 0;   /* means don't set host */
2506         setp = 0;       /* aren't setting host */
2507     }
2508     
2509     /* now do operation */
2510     blob.in_size = sizeof(afs_int32);
2511     blob.out_size = sizeof(afs_int32);
2512     blob.in = (char *) &hostAddr;
2513     blob.out = (char *) &hostAddr;
2514     
2515     code = pioctl(0, VIOC_CBADDR, &blob, 1);
2516     if (code < 0) {
2517         Die(errno, 0);
2518         return 1;
2519     }
2520     return 0;
2521 }
2522 #endif /* WIN32 */
2523
2524 static int
2525 NewCellCmd(struct cmd_syndesc *as, void *arock)
2526 {
2527 #ifndef WIN32
2528     afs_int32 code, linkedstate=0, size=0, *lp;
2529     struct ViceIoctl blob;
2530     struct cmd_item *ti;
2531     char *tp, *cellname=0;
2532     struct hostent *thp;
2533     afs_int32 fsport = 0, vlport = 0;
2534
2535     memset(space, 0, MAXHOSTS * sizeof(afs_int32));
2536     tp = space;
2537     lp = (afs_int32 *)tp;
2538     *lp++ = 0x12345678;
2539     tp += sizeof(afs_int32);
2540     for(ti=as->parms[1].items; ti; ti=ti->next) {
2541         thp = hostutil_GetHostByName(ti->data);
2542         if (!thp) {
2543             fprintf(stderr,"%s: Host %s not found in host table, skipping it.\n",
2544                    pn, ti->data);
2545         }
2546         else {
2547             memcpy(tp, thp->h_addr, sizeof(afs_int32));
2548             tp += sizeof(afs_int32);
2549         }
2550     }
2551     if (as->parms[2].items) {
2552         /*
2553          * Link the cell, for the purposes of volume location, to the specified
2554          * cell.
2555          */
2556         cellname = as->parms[2].items->data;
2557         linkedstate = 1;
2558     }
2559 #ifdef FS_ENABLE_SERVER_DEBUG_PORTS
2560     if (as->parms[3].items) {
2561         code = util_GetInt32(as->parms[3].items->data, &vlport);
2562         if (code) {
2563             fprintf(stderr,"fs: bad integer specified for the fileserver port.\n");
2564             return code;
2565         }
2566     }
2567     if (as->parms[4].items) {
2568         code = util_GetInt32(as->parms[4].items->data, &fsport);
2569         if (code) {
2570             fprintf(stderr,"fs: bad integer specified for the vldb server port.\n");
2571             return code;
2572         }
2573     }
2574 #endif
2575     tp = (char *)(space + (MAXHOSTS+1) *sizeof(afs_int32));
2576     lp = (afs_int32 *)tp;    
2577     *lp++ = fsport;
2578     *lp++ = vlport;
2579     *lp = linkedstate;
2580     strcpy(space +  ((MAXHOSTS+4) * sizeof(afs_int32)), as->parms[0].items->data);
2581     size = ((MAXHOSTS+4) * sizeof(afs_int32)) + strlen(as->parms[0].items->data) + 1 /* for null */;
2582     tp = (char *)(space + size);
2583     if (linkedstate) {
2584         strcpy(tp, cellname);
2585         size += strlen(cellname) + 1;
2586     }
2587     blob.in_size = size;
2588     blob.in = space;
2589     blob.out_size = 0;
2590     code = pioctl(0, VIOCNEWCELL, &blob, 1);
2591     if (code < 0)
2592         Die(errno, 0);
2593     return 0;
2594 #else /* WIN32 */
2595     afs_int32 code;
2596     struct ViceIoctl blob;
2597     
2598     if ( !IsAdmin() ) {
2599         fprintf (stderr,"Permission denied: requires AFS Client Administrator access.\n");
2600         return EACCES;
2601     }
2602
2603     blob.in_size = 0;
2604     blob.in = (char *) 0;
2605     blob.out_size = MAXSIZE;
2606     blob.out = space;
2607
2608     code = pioctl((char *) 0, VIOCNEWCELL, &blob, 1);
2609
2610     if (code) {
2611         Die(errno, (char *) 0);
2612         return 1;
2613     }
2614     
2615     printf("Cell servers information refreshed\n");
2616     return 0;
2617 #endif /* WIN32 */
2618 }
2619
2620 #ifndef WIN32
2621 static int
2622 NewAliasCmd(struct cmd_syndesc *as, void *arock)
2623 {
2624     afs_int32 code;
2625     struct ViceIoctl blob;
2626     char *tp;
2627     char *aliasName, *realName;
2628
2629     /* Setup and do the NEWALIAS pioctl call */
2630     aliasName = as->parms[0].items->data;
2631     realName = as->parms[1].items->data;
2632     tp = space;
2633     strcpy(tp, aliasName);
2634     tp += strlen(aliasName) + 1;
2635     strcpy(tp, realName);
2636     tp += strlen(realName) + 1;
2637
2638     blob.in_size = tp - space;
2639     blob.in = space;
2640     blob.out_size = 0;
2641     blob.out = space;
2642     code = pioctl(0, VIOC_NEWALIAS, &blob, 1);
2643     if (code < 0) {
2644         if (errno == EEXIST) {
2645             fprintf(stderr,
2646                     "%s: cell name `%s' in use by an existing cell.\n", pn,
2647                     aliasName);
2648         } else {
2649             Die(errno, 0);
2650         }
2651         return 1;
2652     }
2653     return 0;
2654 }
2655 #endif /* WIN32 */
2656
2657 static int
2658 WhichCellCmd(struct cmd_syndesc *as, void *arock)
2659 {
2660     afs_int32 code;
2661     struct cmd_item *ti;
2662     struct ViceIoctl blob;
2663     int error = 0;
2664     int literal = 0;
2665     cm_ioctlQueryOptions_t options;
2666
2667     if (as->parms[1].items)
2668         literal = 1;
2669     
2670     SetDotDefault(&as->parms[0].items);
2671     for(ti=as->parms[0].items; ti; ti=ti->next) {
2672         cm_fid_t fid;
2673         afs_uint32 filetype;
2674         char cell[MAXCELLCHARS];
2675
2676         /* once per file */
2677         memset(&fid, 0, sizeof(fid));
2678         memset(&options, 0, sizeof(options));
2679         filetype = 0;
2680         options.size = sizeof(options);
2681         options.field_flags |= CM_IOCTL_QOPTS_FIELD_LITERAL;
2682         options.literal = literal;
2683         blob.in_size = options.size;    /* no variable length data */
2684         blob.in = &options;
2685
2686         blob.out_size = sizeof(cm_fid_t);
2687         blob.out = (char *) &fid;
2688         if (0 == pioctl(ti->data, VIOCGETFID, &blob, 1)) {
2689             options.field_flags |= CM_IOCTL_QOPTS_FIELD_FID;
2690             options.fid = fid;
2691         } else {
2692             Die(errno, ti->data);
2693             error = 1;
2694             continue;
2695         }
2696
2697         blob.out_size = sizeof(filetype);
2698         blob.out = &filetype;
2699
2700         code = pioctl(ti->data, VIOC_GETFILETYPE, &blob, 1);
2701
2702         blob.out_size = MAXCELLCHARS;
2703         blob.out = cell;
2704
2705         code = pioctl(ti->data, VIOC_FILE_CELL_NAME, &blob, 1);
2706         if (code) {
2707             if (errno == ENOENT)
2708                 fprintf(stderr,"%s: no such cell as '%s'\n", pn, ti->data);
2709             else
2710                 Die(errno, ti->data);
2711             error = 1;
2712             continue;
2713         }
2714         printf("%s %s lives in cell '%s'\n",
2715                 filetypestr(filetype),
2716                 ti->data, cell);
2717     }
2718     return error;
2719 }
2720
2721 static int
2722 WSCellCmd(struct cmd_syndesc *as, void *arock)
2723 {
2724     afs_int32 code;
2725     struct ViceIoctl blob;
2726     
2727     blob.in_size = 0;
2728     blob.in = NULL;
2729     blob.out_size = MAXSIZE;
2730     blob.out = space;
2731
2732     code = pioctl(NULL, VIOC_GET_WS_CELL, &blob, 1);
2733
2734     if (code) {
2735         Die(errno, NULL);
2736         return 1;
2737     }
2738
2739     printf("This workstation belongs to cell '%s'\n", space);
2740     return 0;
2741 }
2742
2743 /*
2744 static int
2745 PrimaryCellCmd(struct cmd_syndesc *as, void *arock)
2746 {
2747     fprintf(stderr,"This command is obsolete, as is the concept of a primary token.\n");
2748     return 0;
2749 }
2750 */
2751
2752 #ifndef AFS_NT40_ENV
2753 static int
2754 MonitorCmd(struct cmd_syndesc *as, void *arock)
2755 {
2756     afs_int32 code;
2757     struct ViceIoctl blob;
2758     struct cmd_item *ti;
2759     afs_int32 hostAddr;
2760     struct hostent *thp;
2761     char *tp;
2762     int setp;
2763     
2764     ti = as->parms[0].items;
2765     setp = 1;
2766     if (ti) {
2767         /* set the host */
2768         if (!strcmp(ti->data, "off")) {
2769             hostAddr = 0xffffffff;
2770         } else {
2771             thp = hostutil_GetHostByName(ti->data);
2772             if (!thp) {
2773                 if (!strcmp(ti->data, "localhost")) {
2774                     fprintf(stderr,"localhost not in host table, assuming 127.0.0.1\n");
2775                     hostAddr = htonl(0x7f000001);
2776                 } else {
2777                     fprintf(stderr,"host %s not found in host table.\n", ti->data);
2778                     return 1;
2779                 }
2780             } else {
2781                 memcpy(&hostAddr, thp->h_addr, sizeof(afs_int32));
2782             }
2783         }
2784     } else {
2785         hostAddr = 0;   /* means don't set host */
2786         setp = 0;       /* aren't setting host */
2787     }
2788
2789     /* now do operation */
2790     blob.in_size = sizeof(afs_int32);
2791     blob.out_size = sizeof(afs_int32);
2792     blob.in = (char *) &hostAddr;
2793     blob.out = (char *) &hostAddr;
2794     code = pioctl(0, VIOC_AFS_MARINER_HOST, &blob, 1);
2795     if (code) {
2796         Die(errno, 0);
2797         return 1;
2798     }
2799     if (setp) {
2800         printf("%s: new monitor host set.\n", pn);
2801     } else {
2802         /* now decode old address */
2803         if (hostAddr == 0xffffffff) {
2804             printf("Cache monitoring is currently disabled.\n");
2805         } else {
2806             tp = hostutil_GetNameByINet(hostAddr);
2807             printf("Using host %s for monitor services.\n", tp);
2808         }
2809     }
2810     return 0;
2811 }
2812 #endif /* AFS_NT40_ENV */
2813
2814 static int
2815 SysNameCmd(struct cmd_syndesc *as, void *arock)
2816 {
2817     afs_int32 code;
2818     struct ViceIoctl blob;
2819     struct cmd_item *ti;
2820     char *input = space;
2821     afs_int32 setp = 0;
2822     
2823     ti = as->parms[0].items;
2824     if (ti) {
2825 #ifdef WIN32
2826     if ( !IsAdmin() ) {
2827         fprintf (stderr,"Permission denied: requires AFS Client Administrator access.\n");
2828         return EACCES;
2829     }
2830 #else /* WIN32 */
2831     if (geteuid()) {
2832         fprintf (stderr,"Permission denied: requires root access.\n");
2833         return EACCES;
2834     }
2835 #endif /* WIN32 */
2836     }
2837
2838     blob.in = space;
2839     blob.out = space;
2840     blob.out_size = MAXSIZE;
2841     blob.in_size = sizeof(afs_int32);
2842     memcpy(input, &setp, sizeof(afs_int32));
2843     input += sizeof(afs_int32);
2844     for (; ti; ti = ti->next) {
2845         setp++;
2846         blob.in_size += (long)strlen(ti->data) + 1;
2847         if (blob.in_size > MAXSIZE) {
2848             fprintf(stderr, "%s: sysname%s too long.\n", pn,
2849                      setp > 1 ? "s" : "");
2850             return 1;
2851         }
2852         strcpy(input, ti->data);
2853         input += strlen(ti->data);
2854         *(input++) = '\0';
2855     }
2856     memcpy(space, &setp, sizeof(afs_int32));
2857     code = pioctl(0, VIOC_AFS_SYSNAME, &blob, 1);
2858     if (code) {
2859         Die(errno, 0);
2860         return 1;
2861     }    
2862     if (setp) {
2863         printf("%s: new sysname%s set.\n", pn, setp > 1 ? " list" : "");
2864         return 0;
2865     }
2866
2867     input = space;
2868     memcpy(&setp, input, sizeof(afs_int32));
2869     input += sizeof(afs_int32);
2870     if (!setp) {
2871         fprintf(stderr,"No sysname name value was found\n");
2872         return 1;
2873     } 
2874     
2875     printf("Current sysname%s is", setp > 1 ? " list" : "");
2876     for (; setp > 0; --setp ) {
2877         printf(" \'%s\'", input);
2878         input += strlen(input) + 1;
2879     }
2880     printf("\n");
2881     return 0;
2882 }
2883
2884 #ifndef AFS_NT40_ENV
2885 static char *exported_types[] = {"null", "nfs", ""};
2886 static int ExportAfsCmd(struct cmd_syndesc *as, void *arock)
2887 {
2888     afs_int32 code;
2889     struct ViceIoctl blob;
2890     struct cmd_item *ti;
2891     int export = 0, type = 0, mode = 0, exp = 0, gstat = 0;
2892     int exportcall, pwsync = 0, smounts = 0;
2893     
2894 #ifdef WIN32
2895     if ( !IsAdmin() ) {
2896         fprintf (stderr,"Permission denied: requires AFS Client Administrator access.\n");
2897         return EACCES;
2898     }
2899 #else /* WIN32 */
2900     if (geteuid()) {
2901         fprintf (stderr,"Permission denied: requires root access.\n");
2902         return EACCES;
2903     }
2904 #endif /* WIN32 */
2905
2906     ti = as->parms[0].items;
2907     if (strcmp(ti->data, "nfs") == 0) 
2908         type = 0x71; /* NFS */
2909     else {
2910         fprintf(stderr,
2911                 "Invalid exporter type, '%s', Only the 'nfs' exporter is currently supported\n", ti->data);
2912         return 1;
2913     }
2914     ti = as->parms[1].items;
2915     if (ti) {
2916         if (strcmp(ti->data, "on") == 0) 
2917             export = 3;
2918         else if (strcmp(ti->data, "off") == 0) 
2919             export = 2;
2920         else {
2921             fprintf(stderr, "Illegal argument %s\n", ti->data);
2922             return 1;
2923         }
2924         exp = 1;
2925     }
2926     if (ti = as->parms[2].items) {      /* -noconvert */
2927         if (strcmp(ti->data, "on") == 0) 
2928             mode = 2;
2929         else if (strcmp(ti->data, "off") == 0) 
2930             mode = 3;
2931         else {
2932             fprintf(stderr, "Illegal argument %s\n", ti->data);
2933             return 1;
2934         }
2935     }
2936     if (ti = as->parms[3].items) {      /* -uidcheck */
2937         if (strcmp(ti->data, "on") == 0) 
2938             pwsync = 3;
2939         else if (strcmp(ti->data, "off") == 0) 
2940             pwsync = 2;
2941         else {
2942             fprintf(stderr, "Illegal argument %s\n", ti->data);
2943             return 1;
2944         }
2945     }
2946     if (ti = as->parms[4].items) {      /* -submounts */
2947         if (strcmp(ti->data, "on") == 0) 
2948             smounts = 3;
2949         else if (strcmp(ti->data, "off") == 0) 
2950             smounts = 2;
2951         else {
2952             fprintf(stderr, "Illegal argument %s\n", ti->data);
2953             return 1;
2954         }
2955     }
2956     exportcall =  (type << 24) | (mode << 6) | (pwsync << 4) | (smounts << 2) | export;
2957     type &= ~0x70;
2958     /* make the call */
2959     blob.in = (char *) &exportcall;
2960     blob.in_size = sizeof(afs_int32);
2961     blob.out = (char *) &exportcall;
2962     blob.out_size = sizeof(afs_int32);
2963     code = pioctl(0, VIOC_EXPORTAFS, &blob, 1);
2964     if (code) {
2965         if (errno == ENODEV) {
2966             fprintf(stderr,
2967                     "Sorry, the %s-exporter type is currently not supported on this AFS client\n", exported_types[type]);
2968         } else {
2969             Die(errno, 0);
2970         }
2971         return 1;
2972     } else {
2973         if (!gstat) {
2974             if (exportcall & 1) {
2975                 printf("'%s' translator is enabled with the following options:\n\tRunning in %s mode\n\tRunning in %s mode\n\t%s\n", 
2976                        exported_types[type], (exportcall & 2 ? "strict unix" : "convert owner mode bits to world/other"),
2977                        (exportcall & 4 ? "strict 'passwd sync'" : "no 'passwd sync'"),
2978                        (exportcall & 8 ? "Allow mounts of /afs/.. subdirs" : "Only mounts to /afs allowed"));
2979             } else {
2980                 printf("'%s' translator is disabled\n", exported_types[type]);
2981             }
2982         }
2983     }
2984     return 0;
2985 }
2986 #endif
2987
2988 static int
2989 GetCellCmd(struct cmd_syndesc *as, void *arock)
2990 {
2991     afs_int32 code;
2992     struct ViceIoctl blob;
2993     struct afsconf_cell info;
2994     struct cmd_item *ti;
2995     struct a {
2996         afs_int32 stat;
2997         afs_int32 junk;
2998     } args;
2999     int error = 0;
3000
3001     memset(&args, 0, sizeof(args));      /* avoid Purify UMR error */
3002     for(ti=as->parms[0].items; ti; ti=ti->next) {
3003         /* once per cell */
3004         blob.out_size = sizeof(args);
3005         blob.out = (caddr_t) &args;
3006         code = GetCellName(ti->data, &info);
3007         if (code) {
3008             error = 1;
3009             continue;
3010         }
3011         blob.in_size = 1+(long)strlen(info.name);
3012         blob.in = info.name;
3013         code = pioctl(0, VIOC_GETCELLSTATUS, &blob, 1);
3014         if (code) {
3015             if (errno == ENOENT)
3016                 fprintf(stderr,"%s: the cell named '%s' does not exist\n", pn, info.name);
3017             else
3018                 Die(errno, info.name);
3019             error = 1;
3020             continue;
3021         }
3022         printf("Cell %s status: ", info.name);
3023 #ifdef notdef
3024         if (args.stat & 1) 
3025             printf("primary ");
3026 #endif
3027         if (args.stat & 2) 
3028             printf("no setuid allowed");
3029         else 
3030             printf("setuid allowed");
3031         if (args.stat & 4) 
3032             printf(", using old VLDB");
3033         printf("\n");
3034     }
3035     return error;
3036 }
3037
3038 static int SetCellCmd(struct cmd_syndesc *as, void *arock)
3039 {
3040     afs_int32 code;
3041     struct ViceIoctl blob;
3042     struct afsconf_cell info;
3043     struct cmd_item *ti;
3044     struct a {
3045         afs_int32 stat;
3046         afs_int32 junk;
3047         char cname[64];
3048     } args;
3049     int error = 0;
3050
3051     /* Check arguments. */
3052     if (as->parms[1].items && as->parms[2].items) {
3053         fprintf(stderr, "Cannot specify both -suid and -nosuid.\n");
3054         return 1;
3055     }
3056
3057     /* figure stuff to set */
3058     args.stat = 0;
3059     args.junk = 0;
3060
3061 #ifdef WIN32
3062     if ( !IsAdmin() ) {
3063         fprintf (stderr,"Permission denied: requires AFS Client Administrator access.\n");
3064         return EACCES;
3065     }
3066 #else /* WIN32 */
3067     if (geteuid()) {
3068         fprintf (stderr,"Permission denied: requires root access.\n");
3069         return EACCES;
3070     }
3071 #endif /* WIN32 */
3072
3073     if (! as->parms[1].items) 
3074         args.stat |= CM_SETCELLFLAG_SUID; /* default to -nosuid */
3075
3076     /* set stat for all listed cells */
3077     for(ti=as->parms[0].items; ti; ti=ti->next) {
3078         /* once per cell */
3079         code = GetCellName(ti->data, &info);
3080         if (code) {
3081             error = 1;
3082             continue;
3083         }
3084         strcpy(args.cname, info.name);
3085         blob.in_size = sizeof(args);
3086         blob.in = (caddr_t) &args;
3087         blob.out_size = 0;
3088         blob.out = (caddr_t) 0;
3089         code = pioctl(0, VIOC_SETCELLSTATUS, &blob, 1);
3090         if (code) {
3091             Die(errno, info.name);      /* XXX added cell name to Die() call */
3092             error = 1;
3093         }
3094     }
3095     return error;
3096 }
3097
3098 #ifdef WIN32
3099 static int
3100 GetCellName(char *cellNamep, struct afsconf_cell *infop)
3101 {
3102     strcpy(infop->name, cellNamep);
3103     return 0;
3104 }
3105 #else
3106 static int
3107 GetCellName(char *cellName, struct afsconf_cell *info)
3108 {
3109     struct afsconf_dir *tdir;
3110     int code;
3111
3112     tdir = afsconf_Open(AFSDIR_CLIENT_ETC_CLIENTNAME);
3113     if (!tdir) {
3114         fprintf(stderr,
3115                 "Could not process files in configuration directory (%s).\n",
3116                  AFSDIR_CLIENT_ETC_CLIENTNAME);
3117         return -1;
3118     }
3119
3120     code = afsconf_GetCellInfo(tdir, cellName, AFSCONF_VLDBSERVICE, info);
3121     if (code) {
3122         fprintf(stderr,"fs: cell %s not in %s/CellServDB\n", cellName, 
3123                 AFSDIR_CLIENT_ETC_CLIENTNAME);
3124         return code;
3125     }
3126
3127     return 0;
3128 }
3129 #endif /* not WIN32 */
3130
3131 static int
3132 VLDBInit(int noAuthFlag, struct afsconf_cell *info)
3133 {
3134     afs_int32 code;
3135
3136     code = ugen_ClientInit(noAuthFlag, (char *)AFSDIR_CLIENT_ETC_DIRPATH, 
3137                            info->name, 0, &uclient, 
3138                            NULL, pn, rxkad_clear,
3139                            VLDB_MAXSERVERS, AFSCONF_VLDBSERVICE, 50,
3140                            0, 0, USER_SERVICE_ID);
3141     rxInitDone = 1;
3142     return code;
3143 }
3144
3145 static struct ViceIoctl gblob;
3146 static int debug = 0;
3147 /* 
3148  * here follow some routines in suport of the setserverprefs and
3149  * getserverprefs commands.  They are:
3150  * SetPrefCmd  "top-level" routine
3151  * addServer   adds a server to the list of servers to be poked into the
3152  *             kernel.  Will poke the list into the kernel if it threatens
3153  *             to get too large.
3154  * pokeServers pokes the existing list of servers and ranks into the kernel
3155  * GetPrefCmd  reads the Cache Manager's current list of server ranks
3156  */
3157
3158 #ifdef WIN32
3159 static int 
3160 pokeServers(void)
3161 {
3162     int code;
3163     cm_SSetPref_t *ssp;
3164     code = pioctl(0, VIOC_SETSPREFS, &gblob, 1);
3165
3166     ssp = (cm_SSetPref_t *)space;
3167     gblob.in_size = (long)(((char *)&(ssp->servers[0])) - (char *)ssp);
3168     gblob.in = space;
3169     return code;
3170 }
3171 #else
3172 /*
3173  * returns -1 if error message printed,
3174  * 0 on success,
3175  * errno value if error and no error message printed
3176  */
3177 static int
3178 pokeServers(void)
3179 {
3180     int code;
3181
3182     code = pioctl(0, VIOC_SETSPREFS, &gblob, 1);
3183     if (code && (errno == EINVAL)) {
3184         struct setspref *ssp;
3185         ssp = (struct setspref *)gblob.in;
3186         if (!(ssp->flags & DBservers)) {
3187             gblob.in = (void *)&(ssp->servers[0]);
3188             gblob.in_size -= ((char *)&(ssp->servers[0])) - (char *)ssp;
3189             code = pioctl(0, VIOC_SETSPREFS33, &gblob, 1);
3190             return code ? errno : 0;
3191         }
3192         fprintf(stderr,
3193                 "This cache manager does not support VL server preferences.\n");
3194         return -1;
3195     }
3196
3197     return code ? errno : 0;
3198 }
3199 #endif /* WIN32 */
3200
3201 #ifdef WIN32
3202 static int
3203 addServer(char *name, unsigned short rank)
3204 {  
3205     int code;
3206     cm_SSetPref_t *ssp;
3207     cm_SPref_t *sp;
3208     struct hostent *thostent;
3209
3210 #ifndef MAXUSHORT
3211 #ifdef MAXSHORT
3212 #define MAXUSHORT ((unsigned short) 2*MAXSHORT+1)  /* assumes two's complement binary system */
3213 #else
3214 #define MAXUSHORT ((unsigned short) ~0)
3215 #endif
3216 #endif
3217
3218     code = 0;
3219     thostent = hostutil_GetHostByName(name);
3220     if (!thostent) {
3221         fprintf (stderr, "%s: couldn't resolve name.\n", name);
3222         return EINVAL;
3223     }
3224
3225     ssp = (cm_SSetPref_t *)(gblob.in);
3226
3227     if (gblob.in_size > MAXINSIZE - sizeof(cm_SPref_t)) {
3228         code = pokeServers();
3229         ssp->num_servers = 0;
3230     }
3231
3232     sp = (cm_SPref_t *)((char*)gblob.in + gblob.in_size);
3233     memcpy (&(sp->host.s_addr), thostent->h_addr, sizeof(afs_uint32));
3234     sp->rank = (rank > MAXUSHORT ? MAXUSHORT : rank);
3235     gblob.in_size += sizeof(cm_SPref_t);
3236     ssp->num_servers++;
3237
3238     if (debug) fprintf(stderr, "adding server %s, rank %d, ip addr 0x%lx\n",name,sp->rank,sp->host.s_addr);
3239
3240     return code;
3241 }
3242 #else
3243 /*
3244  * returns -1 if error message printed,
3245  * 0 on success,
3246  * errno value if error and no error message printed
3247  */
3248 static int
3249 addServer(char *name, afs_int32 rank)
3250 {
3251     int t, code;
3252     struct setspref *ssp;
3253     struct spref *sp;
3254     struct hostent *thostent;
3255     afs_uint32 addr;
3256     int error = 0;
3257
3258 #ifndef MAXUSHORT
3259 #ifdef MAXSHORT
3260 #define MAXUSHORT ((unsigned short) 2*MAXSHORT+1)       /* assumes two's complement binary system */
3261 #else
3262 #define MAXUSHORT ((unsigned short) ~0)
3263 #endif
3264 #endif
3265
3266     thostent = hostutil_GetHostByName(name);
3267     if (!thostent) {
3268         fprintf(stderr, "%s: couldn't resolve name.\n", name);
3269         return -1;
3270     }
3271
3272     ssp = (struct setspref *)(gblob.in);
3273
3274     for (t = 0; thostent->h_addr_list[t]; t++) {
3275         if (gblob.in_size > MAXINSIZE - sizeof(struct spref)) {
3276             code = pokeServers();
3277             if (code)
3278                 error = code;
3279             ssp->num_servers = 0;
3280         }
3281
3282         sp = (struct spref *)(gblob.in + gblob.in_size);
3283         memcpy(&(sp->server.s_addr), thostent->h_addr_list[t],
3284                sizeof(afs_uint32));
3285         sp->rank = (rank > MAXUSHORT ? MAXUSHORT : rank);
3286         gblob.in_size += sizeof(struct spref);
3287         ssp->num_servers++;
3288
3289         if (debug)
3290             fprintf(stderr, "adding server %s, rank %d, ip addr 0x%lx\n",
3291                     name, sp->rank, sp->server.s_addr);
3292     }
3293
3294     return error;
3295 }
3296 #endif /* WIN32 */
3297
3298 #ifdef WIN32
3299 static BOOL IsWindowsNT (void)
3300 {
3301     static BOOL fChecked = FALSE;
3302     static BOOL fIsWinNT = FALSE;
3303
3304     if (!fChecked)
3305     {
3306         OSVERSIONINFO Version;
3307
3308         fChecked = TRUE;
3309
3310         memset (&Version, 0x00, sizeof(Version));
3311         Version.dwOSVersionInfoSize = sizeof(Version);
3312
3313         if (GetVersionEx (&Version))
3314         {
3315             if (Version.dwPlatformId == VER_PLATFORM_WIN32_NT)
3316                 fIsWinNT = TRUE;
3317         }
3318     }
3319     return fIsWinNT;
3320 }
3321 #endif /* WIN32 */
3322
3323 #ifdef WIN32
3324 static int
3325 SetPrefCmd(struct cmd_syndesc *as, void * arock)
3326 {
3327     FILE *infd;
3328     afs_int32 code;
3329     struct cmd_item *ti;
3330     char name[80];
3331     afs_int32 rank;
3332     cm_SSetPref_t *ssp;
3333     
3334     ssp = (cm_SSetPref_t *)space;
3335     ssp->flags = 0;
3336     ssp->num_servers = 0;
3337     gblob.in_size = (long)(((char*)&(ssp->servers[0])) - (char *)ssp);
3338     gblob.in = space;
3339     gblob.out = space;
3340     gblob.out_size = MAXSIZE;
3341
3342     if ( !IsAdmin() ) {
3343         fprintf (stderr,"Permission denied: requires AFS Client Administrator access.\n");
3344         return EACCES;
3345     }
3346
3347     code = 0;
3348
3349     ti = as->parms[2].items;  /* -file */
3350     if (ti) {
3351         if (debug) fprintf(stderr,"opening file %s\n",ti->data);
3352         if (!(infd = fopen(ti->data,"r" ))) {
3353             code = errno;
3354             Die(errno,ti->data);
3355         }
3356         else
3357             while ( fscanf(infd, "%79s%ld", name, &rank) != EOF) {
3358                 code = addServer (name, (unsigned short) rank);
3359             }
3360     }
3361
3362     ti = as->parms[3].items;  /* -stdin */
3363     if (ti) {
3364         while ( scanf("%79s%ld", name, &rank) != EOF) {
3365             code = addServer (name, (unsigned short) rank);
3366         }
3367     }
3368
3369     for (ti = as->parms[0].items;ti;ti=ti->next) {/*list of servers, ranks */
3370         if (ti) {
3371             if (!ti->next) {
3372                 break;
3373             }
3374             code = addServer (ti->data, (unsigned short) atol(ti->next->data));
3375             if (debug)
3376                 printf("set fs prefs %s %s\n", ti->data, ti->next->data);
3377             ti=ti->next;
3378         }
3379     }
3380     code = pokeServers();
3381     if (debug) 
3382         printf("now working on vlservers, code=%d, errno=%d\n",code,errno);
3383
3384     ssp = (cm_SSetPref_t *)space;
3385     gblob.in_size = (long)(((char*)&(ssp->servers[0])) - (char *)ssp);
3386     gblob.in = space;
3387     ssp->flags = CM_SPREF_VLONLY;
3388     ssp->num_servers = 0;
3389
3390     for (ti = as->parms[1].items;ti;ti=ti->next) { /* list of dbservers, ranks */
3391         if (ti) {
3392             if (!ti->next) {
3393                 break;
3394             }
3395             code = addServer (ti->data, (unsigned short) atol(ti->next->data));
3396             if (debug) 
3397                 printf("set vl prefs %s %s\n", ti->data, ti->next->data);
3398             ti=ti->next;
3399         }
3400     }
3401
3402     if (as->parms[1].items) {
3403         if (debug) 
3404             printf("now poking vlservers\n");
3405         code = pokeServers();
3406     }
3407
3408     if (code) 
3409         Die(errno,0);
3410
3411     return code;
3412 }
3413 #else
3414 static int
3415 SetPrefCmd(struct cmd_syndesc *as, void *arock)
3416 {
3417     FILE *infd;
3418     afs_int32 code;
3419     struct cmd_item *ti;
3420     char name[80];
3421     afs_int32 rank;
3422     struct setspref *ssp;
3423     int error = 0;              /* -1 means error message printed,
3424                                  * >0 means errno value for unprinted message */
3425
3426     ssp = (struct setspref *)space;
3427     ssp->flags = 0;
3428     ssp->num_servers = 0;
3429     gblob.in_size = ((char *)&(ssp->servers[0])) - (char *)ssp;
3430     gblob.in = space;
3431     gblob.out = space;
3432     gblob.out_size = MAXSIZE;
3433
3434
3435     if (geteuid()) {
3436         fprintf(stderr, "Permission denied: requires root access.\n");
3437         return 1;
3438     }
3439
3440     ti = as->parms[2].items;    /* -file */
3441     if (ti) {
3442         if (debug)
3443             fprintf(stderr, "opening file %s\n", ti->data);
3444         if (!(infd = fopen(ti->data, "r"))) {
3445             perror(ti->data);
3446             error = -1;
3447         } else {
3448             while (fscanf(infd, "%79s%ld", name, &rank) != EOF) {
3449                 code = addServer(name, (unsigned short)rank);
3450                 if (code)
3451                     error = code;
3452             }
3453         }
3454     }
3455
3456     ti = as->parms[3].items;    /* -stdin */
3457     if (ti) {
3458         while (scanf("%79s%ld", name, &rank) != EOF) {
3459             code = addServer(name, (unsigned short)rank);
3460             if (code)
3461                 error = code;
3462         }
3463     }
3464
3465     for (ti = as->parms[0].items; ti; ti = ti->next) {  /* list of servers, ranks */
3466         if (ti) {
3467             if (!ti->next) {
3468                 break;
3469             }
3470             code = addServer(ti->data, (unsigned short)atol(ti->next->data));
3471             if (code)
3472                 error = code;
3473             if (debug)
3474                 printf("set fs prefs %s %s\n", ti->data, ti->next->data);
3475             ti = ti->next;
3476         }
3477     }
3478     code = pokeServers();
3479     if (code)
3480         error = code;
3481     if (debug)
3482         printf("now working on vlservers, code=%d\n", code);
3483
3484     ssp = (struct setspref *)space;
3485     ssp->flags = DBservers;
3486     ssp->num_servers = 0;
3487     gblob.in_size = ((char *)&(ssp->servers[0])) - (char *)ssp;
3488     gblob.in = space;
3489
3490     for (ti = as->parms[1].items; ti; ti = ti->next) {  /* list of dbservers, ranks */
3491         if (ti) {
3492             if (!ti->next) {
3493                 break;
3494             }
3495             code = addServer(ti->data, (unsigned short)atol(ti->next->data));
3496             if (code)
3497                 error = code;
3498             if (debug)
3499                 printf("set vl prefs %s %s\n", ti->data, ti->next->data);
3500             ti = ti->next;
3501         }
3502     }
3503
3504     if (as->parms[1].items) {
3505         if (debug)
3506             printf("now poking vlservers\n");
3507         code = pokeServers();
3508         if (code)
3509             error = code;
3510     }
3511
3512     if (error > 0)
3513         Die(error, 0);
3514
3515     return error ? 1 : 0;
3516 }
3517 #endif /* WIN32 */
3518
3519 #ifdef WIN32
3520 static int 
3521 GetPrefCmd(struct cmd_syndesc *as, void *arock)
3522 {
3523     afs_int32 code;
3524     struct cmd_item *ti;
3525     char *name, tbuffer[20];
3526     afs_int32 addr;
3527     FILE * outfd;
3528     int resolve;
3529     int vlservers;
3530     struct ViceIoctl blob;
3531     struct cm_SPrefRequest *in;
3532     struct cm_SPrefInfo *out;
3533     int i;
3534     
3535     code = 0;
3536     ti = as->parms[0].items;  /* -file */
3537     if (ti) {
3538         if (debug) fprintf(stderr,"opening file %s\n",ti->data);
3539         if (!(outfd = freopen(ti->data,"w",stdout))) {
3540             Die(errno,ti->data);
3541             return errno;
3542         }
3543     }
3544
3545     ti = as->parms[1].items;  /* -numeric */
3546     resolve = !(ti);
3547     ti = as->parms[2].items;  /* -vlservers */
3548     vlservers = (ti ? CM_SPREF_VLONLY : 0);
3549     /*  ti = as->parms[3].items;   -cell */
3550
3551     in = (struct cm_SPrefRequest *)space;
3552     in->offset = 0;
3553
3554     do {
3555         blob.in_size=sizeof(struct cm_SPrefRequest);
3556         blob.in = (char *)in;
3557         blob.out = space;
3558         blob.out_size = MAXSIZE;
3559
3560         in->num_servers = (MAXSIZE - 2*sizeof(short))/sizeof(struct cm_SPref);
3561         in->flags = vlservers; 
3562
3563         code = pioctl(0, VIOC_GETSPREFS, &blob, 1);
3564         if (code){
3565             perror("getserverprefs pioctl");
3566             Die (errno,0);
3567         }
3568         else {
3569             out = (struct cm_SPrefInfo *) blob.out;
3570
3571             for (i=0;i<out->num_servers;i++) {
3572                 if (resolve) {
3573                     name = hostutil_GetNameByINet(out->servers[i].host.s_addr);
3574                 }
3575                 else {
3576                     addr = ntohl(out->servers[i].host.s_addr);
3577                     sprintf(tbuffer, "%d.%d.%d.%d", (addr>>24) & 0xff, (addr>>16) & 0xff,
3578                              (addr>>8) & 0xff, addr & 0xff);
3579                     name=tbuffer;
3580                 }
3581                 printf ("%-50s %5u\n",name,out->servers[i].rank);      
3582             }
3583
3584             in->offset = out->next_offset;
3585         }
3586     } while (!code && out->next_offset > 0);
3587
3588     return code;
3589 }
3590 #else
3591 static int
3592 GetPrefCmd(struct cmd_syndesc *as, void *arock)
3593 {
3594     afs_int32 code;
3595     struct cmd_item *ti;
3596     char *name, tbuffer[20];
3597     afs_int32 rank, addr;
3598     FILE *outfd;
3599     int resolve;
3600     int vlservers = 0;
3601     struct ViceIoctl blob;
3602     struct sprefrequest *in;
3603     struct sprefinfo *out;
3604     int i;
3605
3606     ti = as->parms[0].items;    /* -file */
3607     if (ti) {
3608         if (debug)
3609             fprintf(stderr, "opening file %s\n", ti->data);
3610         if (!(outfd = freopen(ti->data, "w", stdout))) {
3611             perror(ti->data);
3612             return 1;
3613         }
3614     }
3615
3616     ti = as->parms[1].items;    /* -numeric */
3617     resolve = !(ti);
3618     ti = as->parms[2].items;    /* -vlservers */
3619     vlservers |= (ti ? DBservers : 0);
3620     /*  ti = as->parms[3].items;   -cell */
3621
3622     in = (struct sprefrequest *)space;
3623     in->offset = 0;
3624
3625     do {
3626         blob.in_size = sizeof(struct sprefrequest);
3627         blob.in = (char *)in;
3628         blob.out = space;
3629         blob.out_size = MAXSIZE;
3630
3631         in->num_servers =
3632             (MAXSIZE - 2 * sizeof(short)) / sizeof(struct spref);
3633         in->flags = vlservers;
3634
3635         code = pioctl(0, VIOC_GETSPREFS, &blob, 1);
3636         if (code) {
3637             perror("getserverprefs pioctl");
3638             return 1;
3639         }
3640
3641         out = (struct sprefinfo *)blob.out;
3642
3643         for (i = 0; i < out->num_servers; i++) {
3644             if (resolve) {
3645                 name = hostutil_GetNameByINet(out->servers[i].server.s_addr);
3646             } else {
3647                 addr = ntohl(out->servers[i].server.s_addr);
3648                 sprintf(tbuffer, "%d.%d.%d.%d", (addr >> 24) & 0xff,
3649                         (addr >> 16) & 0xff, (addr >> 8) & 0xff, addr & 0xff);
3650                 name = tbuffer;
3651             }
3652             printf("%-50s %5u\n", name, out->servers[i].rank);
3653         }
3654
3655         in->offset = out->next_offset;
3656     } while (out->next_offset > 0);
3657
3658     return 0;
3659 }
3660 #endif /* WIN32 */
3661
3662 static int
3663 UuidCmd(struct cmd_syndesc *asp, void *arock)
3664 {
3665     long code;
3666     long inValue;
3667     afsUUID outValue;
3668     struct ViceIoctl blob;
3669     char * uuidstring = NULL;
3670
3671     if (asp->parms[0].items) {
3672 #ifdef WIN32
3673         if ( !IsAdmin() ) {
3674             fprintf (stderr,"Permission denied: requires AFS Client Administrator access.\n");
3675             return EACCES;
3676         }
3677 #else
3678         if (geteuid()) {
3679             fprintf (stderr, "Permission denied: requires root access.\n");
3680             return EACCES;
3681         }
3682 #endif
3683         inValue = 1;            /* generate new UUID */
3684     } else {
3685         inValue = 0;            /* just show the current UUID */
3686     }
3687
3688     blob.in_size = sizeof(inValue);
3689     blob.in = (char *) &inValue;
3690     blob.out_size = sizeof(outValue);
3691     blob.out = (char *) &outValue;
3692
3693     code = pioctl(NULL, VIOC_UUIDCTL, &blob, 1);
3694     if (code) {
3695         Die(errno, NULL);
3696         return code;
3697     }
3698
3699     UuidToString((UUID *) &outValue, &uuidstring);
3700
3701     printf("%sUUID: %s",
3702            ((inValue == 1)?"New ":""),
3703            uuidstring);
3704
3705     if (uuidstring)
3706         RpcStringFree(&uuidstring);
3707
3708     return 0;