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