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