00b62ab48912d53dbd85d2db216a81f1a98acd28
[openafs.git] / src / volser / vos.c
1 /*
2  * Copyright 2000, International Business Machines Corporation and others.
3  * All Rights Reserved.
4  * 
5  * This software has been released under the terms of the IBM Public
6  * License.  For details, see the LICENSE file in the top-level source
7  * directory or online at http://www.openafs.org/dl/license10.html
8  */
9
10 #include <afsconfig.h>
11 #include <afs/param.h>
12
13 RCSID("$Header$");
14
15 #include <sys/types.h>
16 #ifdef AFS_NT40_ENV
17 #include <fcntl.h>
18 #include <io.h>
19 #include <winsock2.h>
20 #else
21 #include <sys/time.h>
22 #include <sys/file.h>
23 #include <netdb.h>
24 #include <netinet/in.h>
25 #endif
26 #include <sys/stat.h>
27 #ifdef AFS_AIX_ENV
28 #include <sys/statfs.h>
29 #endif
30 #include <errno.h>
31
32 #ifdef HAVE_STRING_H
33 #include <string.h>
34 #else
35 #ifdef HAVE_STRINGS_H
36 #include <strings.h>
37 #endif
38 #endif
39
40 #include <lock.h>
41 #include <afs/stds.h>
42 #include <rx/xdr.h>
43 #include <rx/rx.h>
44 #include <rx/rx_globals.h>
45 #include <afs/nfs.h>
46 #include <afs/vlserver.h>
47 #include <afs/auth.h>
48 #include <afs/cellconfig.h>
49 #include <afs/keys.h>
50 #include <afs/afsutil.h>
51 #include <ubik.h>
52 #include <afs/afsint.h>
53 #include <afs/cmd.h>
54 #include <afs/usd.h>
55 #include <rx/rxkad.h>
56 #include "volser.h"
57 #include "volint.h"
58 #include "lockdata.h"
59 #ifdef  AFS_AIX32_ENV
60 #include <signal.h>
61 #endif
62
63 struct tqElem {
64     afs_int32 volid;
65     struct tqElem *next;
66 };
67
68 struct tqHead {
69     afs_int32 count;
70     struct tqElem *next;
71 };
72
73
74 struct hostent *hostutil_GetHostByName(register char *ahost);
75
76 #define COMMONPARMS     cmd_Seek(ts, 12);\
77 cmd_AddParm(ts, "-cell", CMD_SINGLE, CMD_OPTIONAL, "cell name");\
78 cmd_AddParm(ts, "-noauth", CMD_FLAG, CMD_OPTIONAL, "don't authenticate");\
79 cmd_AddParm(ts, "-localauth",CMD_FLAG,CMD_OPTIONAL,"use server tickets");\
80 cmd_AddParm(ts, "-verbose", CMD_FLAG, CMD_OPTIONAL, "verbose");\
81 cmd_AddParm(ts, "-encrypt", CMD_FLAG, CMD_OPTIONAL, "encrypt commands");\
82
83 #define ERROR_EXIT(code) {error=(code); goto error_exit;}
84
85 extern int verbose;
86 int rxInitDone = 0;
87 struct rx_connection *tconn;
88 afs_int32 tserver;
89 extern struct ubik_client *cstruct;
90 const char *confdir;
91 extern struct rx_connection *UV_Bind();
92 extern int UV_SetSecurity();
93 extern int UV_SetVolumeInfo();
94 extern int vsu_SetCrypt();
95 extern VL_SetLock();
96 extern VL_ReleaseLock();
97 extern VL_DeleteEntry();
98 extern VL_ListEntry();
99 extern VL_GetAddrs();
100 extern VL_GetAddrsU();
101 extern VL_ChangeAddr();
102
103 extern int vsu_ExtractName();
104 extern PrintError();
105 extern int MapPartIdIntoName();
106 extern int MapHostToNetwork();
107 extern int MapNetworkToHost();
108 extern void EnumerateEntry();
109 extern void SubEnumerateEntry();
110
111
112 static struct tqHead busyHead, notokHead;
113
114 static void qInit(ahead)
115 struct tqHead *ahead;
116 {
117     memset((char *)ahead, 0, sizeof(struct tqHead));
118     return;
119 }
120
121
122 static void qPut(ahead,volid)
123 struct tqHead *ahead;
124 afs_int32 volid;
125 {
126     struct tqElem *elem;
127
128     elem = (struct tqElem *)malloc(sizeof(struct tqElem));
129     elem->next = ahead->next;
130     elem->volid = volid;
131     ahead->next = elem;
132     ahead->count++;
133     return;
134 }
135
136 static void qGet(ahead,volid)
137 struct tqHead *ahead;
138 afs_int32 *volid;
139 {
140     struct tqElem *tmp;
141
142     if(ahead->count <= 0) return;
143     *volid = ahead->next->volid;
144     tmp = ahead->next;
145     ahead->next = tmp->next;
146     ahead->count--;
147     free(tmp);
148     return;
149 }
150
151 /* returns 1 if <filename> exists else 0 */
152 static FileExists(filename)
153 char *filename;
154 {
155     usd_handle_t ufd;
156     int code;
157     afs_hyper_t size;
158
159     code = usd_Open(filename, USD_OPEN_RDONLY, 0, &ufd);
160     if (code) {
161         return 0;
162     }
163     code = USD_IOCTL(ufd, USD_IOCTL_GETSIZE, &size);
164     USD_CLOSE(ufd);
165     if (code) {
166         return 0;
167     }
168     return 1;
169 }
170
171 /* returns 1 if <name> doesnot end in .readonly or .backup, else 0 */
172 static VolNameOK(name)
173 char *name;
174 {   
175     int total;
176
177     
178     total = strlen(name);
179     if(!strcmp(&name[total - 9],".readonly")) {
180         return 0;
181     }
182     else if(!strcmp(&name[total - 7 ],".backup")) {
183         return 0;
184     }
185     else {
186         return 1;
187     }
188 }
189
190 /* return 1 if name is a number else 0 */
191 static IsNumeric(name)
192 char *name;
193 {
194     int result, len,i;
195     char *ptr;
196
197     result = 1;
198     ptr = name;
199     len = strlen(name);
200     for(i = 0; i < len ; i++){
201         if(*ptr < '0' || *ptr > '9'){
202             result = 0;
203             break;
204         }
205         ptr++;
206         
207     }
208     return result;
209         
210
211 }
212
213
214 /*
215  * Parse a server name/address and return the address in HOST BYTE order
216  */
217 afs_int32 GetServer(aname)
218 char *aname; {
219     register struct hostent *th;
220     afs_int32 addr;
221     int b1, b2, b3, b4;
222     register afs_int32 code;
223     char hostname[MAXHOSTCHARS];
224
225     code = sscanf(aname, "%d.%d.%d.%d", &b1, &b2, &b3, &b4);
226     if (code == 4) {
227         addr = (b1<<24) | (b2<<16) | (b3<<8) | b4;
228         addr = ntohl(addr); /* convert to host order */
229     } else {
230         th = gethostbyname(aname);
231         if (!th) return 0;
232         memcpy(&addr, th->h_addr, sizeof(addr));
233     }
234
235     if (addr == htonl(0x7f000001)) {                /* local host */
236        code = gethostname(hostname, MAXHOSTCHARS);
237        if (code) return 0;
238        th = gethostbyname(hostname); /* returns host byte order */
239        if (!th) return 0;
240        memcpy(&addr, th->h_addr, sizeof(addr));
241     }
242
243     return (addr); 
244 }
245
246 afs_int32 GetVolumeType(aname)
247 char *aname;
248 {
249
250     if(!strcmp(aname,"ro"))
251         return(ROVOL);
252     else if(!strcmp(aname, "rw"))
253         return(RWVOL);
254     else if(!strcmp(aname,"bk"))
255         return(BACKVOL);
256     else return(-1);
257 }
258
259 int IsPartValid(partId, server, code)
260 afs_int32 server, partId,*code;
261
262 {   
263     struct partList dummyPartList;
264     int i,success, cnt;
265     
266
267     
268     success = 0;
269     *code = 0;
270
271     *code = UV_ListPartitions(server,&dummyPartList, &cnt);
272     if(*code) return success;
273     for(i = 0 ; i < cnt ; i++) {
274         if(dummyPartList.partFlags[i] & PARTVALID)
275             if(dummyPartList.partId[i] == partId)
276                 success = 1;
277     }
278     return success;
279 }
280
281
282
283  /*sends the contents of file associated with <fd> and <blksize>  to Rx Stream 
284 * associated  with <call> */
285 SendFile(ufd, call, blksize)
286 usd_handle_t ufd;
287 register struct rx_call *call;
288 long blksize;
289 {
290     char *buffer = (char*) 0;
291     afs_int32 error = 0;
292     int done = 0;
293     afs_uint32 nbytes;
294
295     buffer = (char *)malloc(blksize);
296     if (!buffer) {
297         fprintf(STDERR,"malloc failed\n");
298         return -1;
299     }
300
301     while (!error && !done) {
302 #ifndef AFS_NT40_ENV  /* NT csn't select on non-socket fd's */
303         fd_set in;
304         FD_ZERO(&in);
305         FD_SET((int)(ufd->handle), &in);
306         /* don't timeout if read blocks */
307         IOMGR_Select(((int)(ufd->handle))+1, &in, 0, 0, 0);
308 #endif
309         error = USD_READ(ufd, buffer, blksize, &nbytes);
310         if (error) {
311             fprintf(STDERR, "File system read failed\n");
312             break;
313         }
314         if(nbytes == 0){
315             done = 1;
316             break;
317         }
318         if (rx_Write(call, buffer, nbytes) != nbytes){
319             error = -1;
320             break;
321         }
322     }
323     if (buffer) free(buffer);
324     return error;
325 }
326
327 /* function invoked by UV_RestoreVolume, reads the data from rx_trx_stream and
328  * writes it out to the volume. */
329 afs_int32 WriteData(call,rock)
330 struct rx_call *call;
331 char *rock;
332 {
333     char *filename;
334     usd_handle_t ufd;
335     long blksize;
336     afs_int32 error,code;
337     int ufdIsOpen = 0;
338
339     error = 0;
340
341     filename = rock;
342     if(!filename || !*filename) {
343         usd_StandardInput(&ufd);
344         blksize = 4096;
345         ufdIsOpen = 1;
346     } else {
347         code = usd_Open(filename, USD_OPEN_RDONLY, 0, &ufd);
348         if (code == 0) {
349             ufdIsOpen = 1;
350             code = USD_IOCTL(ufd, USD_IOCTL_GETBLKSIZE, &blksize);
351         }
352         if (code){
353             fprintf(STDERR,"Could not access file '%s'\n", filename);
354             error = VOLSERBADOP;
355             goto wfail;
356         }
357     }
358     code = SendFile(ufd,call,blksize);
359     if(code) {
360         error = code;
361         goto wfail;
362     }
363   wfail:
364     if(ufdIsOpen) {
365         code = USD_CLOSE(ufd);
366         if(code){
367             fprintf(STDERR,"Could not close dump file %s\n",
368                     (filename && *filename)?filename:"STDOUT");
369             if(!error) error = code;
370         }
371     }
372     return error;
373 }
374
375 /* Receive data from <call> stream into file associated
376  * with <fd> <blksize>
377  */
378 int ReceiveFile(ufd, call, blksize)
379     usd_handle_t ufd;
380     struct rx_call *call;
381     long blksize;
382 {
383     char *buffer = NULL;
384     afs_int32  bytesread;
385     afs_uint32  bytesleft, w;
386     afs_int32 error = 0;
387
388     buffer = (char *)malloc(blksize);
389     if (!buffer) {
390        fprintf(STDERR,"memory allocation failed\n");
391        ERROR_EXIT(-1);
392     }
393
394     while ((bytesread=rx_Read(call,buffer,blksize)) > 0) {
395        for (bytesleft=bytesread; bytesleft; bytesleft-=w) {
396 #ifndef AFS_NT40_ENV  /* NT csn't select on non-socket fd's */
397           fd_set out;
398           FD_ZERO(&out);
399           FD_SET((int)(ufd->handle), &out);
400           /* don't timeout if write blocks */
401           IOMGR_Select(((int)(ufd->handle))+1, 0, &out, 0, 0);
402 #endif
403           error = USD_WRITE(ufd, &buffer[bytesread-bytesleft], bytesleft, &w);
404           if (error) {
405              fprintf(STDERR,"File system write failed\n");
406              ERROR_EXIT(-1);
407           }
408        }
409     }
410
411   error_exit:
412     if (buffer) free(buffer);
413     return(error);
414 }
415
416 afs_int32 DumpFunction(call, filename)
417     struct rx_call *call;
418     char *filename;
419 {
420     usd_handle_t ufd;             /* default is to stdout */
421     afs_int32 error=0, code;
422     afs_hyper_t size;
423     long blksize;
424     int ufdIsOpen = 0;
425
426     /* Open the output file */
427     if (!filename || !*filename) {
428         usd_StandardOutput(&ufd);
429         blksize = 4096;
430         ufdIsOpen = 1;
431     } else {
432         code = usd_Open(filename, USD_OPEN_CREATE|USD_OPEN_RDWR, 0666, &ufd);
433         if (code == 0) {
434             ufdIsOpen = 1;
435             hzero(size);
436             code = USD_IOCTL(ufd, USD_IOCTL_SETSIZE, &size);
437         }
438         if (code == 0) {
439             code = USD_IOCTL(ufd, USD_IOCTL_GETBLKSIZE, &blksize);
440         }
441         if (code){
442             fprintf(STDERR, "Could not create file '%s'\n", filename);
443             ERROR_EXIT(VOLSERBADOP);
444         }
445     }
446
447     code = ReceiveFile(ufd, call, blksize);
448     if (code) ERROR_EXIT(code);
449
450   error_exit:
451     /* Close the output file */
452     if (ufdIsOpen) {
453        code = USD_CLOSE(ufd);
454        if (code) {
455           fprintf(STDERR,"Could not close dump file %s\n",
456                   (filename && *filename)?filename:"STDIN");
457           if (!error) error = code;
458        }
459     }
460
461     return(error);
462 }   
463     
464 static void DisplayFormat(pntr,server,part,totalOK,totalNotOK,totalBusy,fast,longlist,disp)
465 volintInfo *pntr;
466 afs_int32 server,part;
467 int *totalOK,*totalNotOK,*totalBusy;
468 int fast,longlist, disp;
469 {
470     char pname[10];
471
472     if(fast){
473         fprintf(STDOUT,"%-10u\n",pntr->volid);
474     }
475     else if(longlist){
476         if(pntr->status == VOK){
477             fprintf(STDOUT,"%-32s ",pntr->name);
478             fprintf(STDOUT,"%10u ",pntr->volid);
479             if(pntr->type == 0) fprintf(STDOUT,"RW ");
480             if(pntr->type == 1) fprintf(STDOUT,"RO ");
481             if(pntr->type == 2) fprintf(STDOUT,"BK ");
482             fprintf(STDOUT,"%10d K  ",pntr->size);
483             if(pntr->inUse == 1) {
484                 fprintf(STDOUT,"On-line");
485                 *totalOK += 1;
486             } else {
487                 fprintf(STDOUT,"Off-line");
488                 *totalNotOK++;
489             }
490             if(pntr->needsSalvaged == 1) fprintf(STDOUT,"**needs salvage**");
491             fprintf(STDOUT,"\n");
492             MapPartIdIntoName(part,pname);
493             fprintf(STDOUT,"    %s %s \n",hostutil_GetNameByINet(server),pname);
494             fprintf(STDOUT,"    RWrite %10u ROnly %10u Backup %10u \n", pntr->parentID,pntr->cloneID, pntr->backupID);
495             fprintf(STDOUT,"    MaxQuota %10d K \n",pntr->maxquota);
496             fprintf(STDOUT,"    Creation    %s",
497                     ctime((time_t *)&pntr->creationDate));
498 #ifdef FULL_LISTVOL_SWITCH
499             fprintf(STDOUT,"    Copy        %s",
500                     ctime((time_t *)&pntr->copyDate));
501             if(!pntr->backupDate)
502               fprintf(STDOUT,"    Backup      Never\n");
503             else
504               fprintf(STDOUT,"    Backup      %s",
505                       ctime((time_t *)&pntr->backupDate));
506             if (pntr->accessDate)
507               fprintf(STDOUT,"    Last Access %s",
508                       ctime((time_t *)&pntr->accessDate));
509 #endif
510             if(pntr->updateDate < pntr->creationDate)
511                 fprintf(STDOUT,"    Last Update %s",
512                         ctime((time_t *)&pntr->creationDate));
513             else
514                 fprintf(STDOUT,"    Last Update %s",
515                         ctime((time_t *)&pntr->updateDate));
516             fprintf(STDOUT, "    %d accesses in the past day (i.e., vnode references)\n",
517                     pntr->dayUse);
518         }
519         else if (pntr->status == VBUSY) {
520             *totalBusy += 1;
521             qPut(&busyHead,pntr->volid);
522             if (disp) fprintf(STDOUT,"**** Volume %u is busy ****\n",pntr->volid);
523         }
524         else {
525             *totalNotOK += 1;
526             qPut(&notokHead,pntr->volid);
527             if (disp) fprintf(STDOUT,"**** Could not attach volume %u ****\n",pntr->volid);
528         }
529         fprintf(STDOUT,"\n");
530     }
531     else {/* default listing */
532         if(pntr->status == VOK){
533             fprintf(STDOUT,"%-32s ",pntr->name);
534             fprintf(STDOUT,"%10u ",pntr->volid);
535             if(pntr->type == 0) fprintf(STDOUT,"RW ");
536             if(pntr->type == 1) fprintf(STDOUT,"RO ");
537             if(pntr->type == 2) fprintf(STDOUT,"BK ");
538             fprintf(STDOUT,"%10d K ",pntr->size);
539             if(pntr->inUse == 1) {
540                 fprintf(STDOUT,"On-line");
541                 *totalOK += 1;
542             } else {
543                 fprintf(STDOUT,"Off-line");
544                 *totalNotOK += 1;
545             }
546             if(pntr->needsSalvaged == 1) fprintf(STDOUT,"**needs salvage**");
547             fprintf(STDOUT,"\n");
548         }
549         else if (pntr->status == VBUSY) {
550             *totalBusy += 1;
551             qPut(&busyHead,pntr->volid);
552             if (disp) fprintf(STDOUT,"**** Volume %u is busy ****\n",pntr->volid);
553         }
554         else {
555             *totalNotOK += 1;
556             qPut(&notokHead,pntr->volid);
557             if (disp) fprintf(STDOUT,"**** Could not attach volume %u ****\n",pntr->volid);
558         }
559     }
560 }
561
562 /*------------------------------------------------------------------------
563  * PRIVATE XDisplayFormat
564  *
565  * Description:
566  *      Display the contents of one extended volume info structure.
567  *
568  * Arguments:
569  *      a_xInfoP        : Ptr to extended volume info struct to print.
570  *      a_servID        : Server ID to print.
571  *      a_partID        : Partition ID to print.
572  *      a_totalOKP      : Ptr to total-OK counter.
573  *      a_totalNotOKP   : Ptr to total-screwed counter.
574  *      a_totalBusyP    : Ptr to total-busy counter.
575  *      a_fast          : Fast listing?
576  *      a_int32         : Int32 listing?
577  *      a_showProblems  : Show volume problems?
578  *
579  * Returns:
580  *      Nothing.
581  *
582  * Environment:
583  *      Nothing interesting.
584  *
585  * Side Effects:
586  *      As advertised.
587  *------------------------------------------------------------------------*/
588
589 static void XDisplayFormat(a_xInfoP, a_servID, a_partID, a_totalOKP,
590                            a_totalNotOKP, a_totalBusyP, a_fast, a_int32,
591                            a_showProblems)
592     volintXInfo *a_xInfoP;
593     afs_int32 a_servID;
594     afs_int32 a_partID;
595     int *a_totalOKP;
596     int *a_totalNotOKP;
597     int *a_totalBusyP;
598     int a_fast;
599     int a_int32;
600     int a_showProblems;
601
602 { /*XDisplayFormat*/
603
604     char pname[10];
605
606     if (a_fast) {
607         /*
608          * Short & sweet.
609          */
610         fprintf(STDOUT, "%-10u\n", a_xInfoP->volid);
611     }
612     else
613         if (a_int32) {
614             /*
615              * Fully-detailed listing.
616              */
617             if (a_xInfoP->status == VOK) {
618                 /*
619                  * Volume's status is OK - all the fields are valid.
620                  */
621                 fprintf(STDOUT, "%-32s ", a_xInfoP->name);
622                 fprintf(STDOUT, "%10u ",  a_xInfoP->volid);
623                 if (a_xInfoP->type == 0) fprintf(STDOUT,"RW ");
624                 if (a_xInfoP->type == 1) fprintf(STDOUT,"RO ");
625                 if (a_xInfoP->type == 2) fprintf(STDOUT,"BK ");
626                 fprintf(STDOUT, "%10d K used ", a_xInfoP->size);
627                 fprintf(STDOUT, "%d files ", a_xInfoP->filecount);
628                 if(a_xInfoP->inUse == 1) {
629                     fprintf(STDOUT, "On-line");
630                     (*a_totalOKP)++;
631                 }
632                 else {
633                     fprintf(STDOUT, "Off-line");
634                     (*a_totalNotOKP)++;
635                 }
636                 fprintf(STDOUT, "\n");
637                 MapPartIdIntoName(a_partID, pname);
638                 fprintf(STDOUT, "    %s %s \n",
639                         hostutil_GetNameByINet(a_servID),
640                         pname);
641                 fprintf(STDOUT, "    RWrite %10u ROnly %10u Backup %10u \n",
642                         a_xInfoP->parentID, a_xInfoP->cloneID, a_xInfoP->backupID);
643                 fprintf(STDOUT, "    MaxQuota %10d K \n",
644                         a_xInfoP->maxquota);
645                 fprintf(STDOUT, "    Creation    %s",
646                         ctime((time_t *)&a_xInfoP->creationDate));
647 #ifdef FULL_LISTVOL_SWITCH
648                 fprintf(STDOUT,"    Copy        %s",
649                         ctime((time_t *)&a_xInfoP->copyDate));
650                 if(!a_xInfoP->backupDate)
651                     fprintf(STDOUT,"    Backup      Never\n");
652                 else
653                     fprintf(STDOUT,"    Backup      %s",
654                             ctime((time_t *)&a_xInfoP->backupDate));
655                 if (a_xInfoP->accessDate)
656                     fprintf(STDOUT,"    Last Access %s",
657                             ctime((time_t *)&a_xInfoP->accessDate));
658 #endif
659                 if (a_xInfoP->updateDate < a_xInfoP->creationDate)
660                     fprintf(STDOUT, "    Last Update %s",
661                             ctime((time_t *)&a_xInfoP->creationDate));
662                 else
663                     fprintf(STDOUT, "    Last Update %s",
664                             ctime((time_t *)&a_xInfoP->updateDate));
665                 fprintf(STDOUT, "    %d accesses in the past day (i.e., vnode references)\n",
666                         a_xInfoP->dayUse);
667
668                 /*
669                  * Print all the read/write and authorship stats.
670                  */
671                 fprintf(STDOUT,
672                         "\n                      Raw Read/Write Stats\n");
673                 fprintf(STDOUT,
674                         "          |-------------------------------------------|\n");
675                 fprintf(STDOUT,
676                         "          |    Same Network     |    Diff Network     |\n");
677                 fprintf(STDOUT,
678                         "          |----------|----------|----------|----------|\n");
679                 fprintf(STDOUT,
680                         "          |  Total   |   Auth   |   Total  |   Auth   |\n");
681                 fprintf(STDOUT,
682                         "          |----------|----------|----------|----------|\n");
683                 fprintf(STDOUT,
684                         "Reads     | %8d | %8d | %8d | %8d |\n",
685                         a_xInfoP->stat_reads[VOLINT_STATS_SAME_NET],
686                         a_xInfoP->stat_reads[VOLINT_STATS_SAME_NET_AUTH],
687                         a_xInfoP->stat_reads[VOLINT_STATS_DIFF_NET],
688                         a_xInfoP->stat_reads[VOLINT_STATS_DIFF_NET_AUTH]);
689                 fprintf(STDOUT,
690                         "Writes    | %8d | %8d | %8d | %8d |\n",
691                         a_xInfoP->stat_writes[VOLINT_STATS_SAME_NET],
692                         a_xInfoP->stat_writes[VOLINT_STATS_SAME_NET_AUTH],
693                         a_xInfoP->stat_writes[VOLINT_STATS_DIFF_NET],
694                         a_xInfoP->stat_writes[VOLINT_STATS_DIFF_NET_AUTH]);
695                 fprintf(STDOUT,
696                         "          |-------------------------------------------|\n\n");
697
698                 fprintf(STDOUT,
699                         "                   Writes Affecting Authorship\n");
700                 fprintf(STDOUT,
701                         "          |-------------------------------------------|\n");
702                 fprintf(STDOUT,
703                         "          |   File Authorship   | Directory Authorship|\n");
704                 fprintf(STDOUT,
705                         "          |----------|----------|----------|----------|\n");
706                 fprintf(STDOUT,
707                         "          |   Same   |   Diff   |    Same  |   Diff   |\n");
708                 fprintf(STDOUT,
709                         "          |----------|----------|----------|----------|\n");
710                 fprintf(STDOUT,
711                         "0-60 sec  | %8d | %8d | %8d | %8d |\n",
712                         a_xInfoP->stat_fileSameAuthor[VOLINT_STATS_TIME_IDX_0],
713                         a_xInfoP->stat_fileDiffAuthor[VOLINT_STATS_TIME_IDX_0],
714                         a_xInfoP->stat_dirSameAuthor[VOLINT_STATS_TIME_IDX_0],
715                         a_xInfoP->stat_dirDiffAuthor[VOLINT_STATS_TIME_IDX_0]);
716                 fprintf(STDOUT,
717                         "1-10 min  | %8d | %8d | %8d | %8d |\n",
718                         a_xInfoP->stat_fileSameAuthor[VOLINT_STATS_TIME_IDX_1],
719                         a_xInfoP->stat_fileDiffAuthor[VOLINT_STATS_TIME_IDX_1],
720                         a_xInfoP->stat_dirSameAuthor[VOLINT_STATS_TIME_IDX_1],
721                         a_xInfoP->stat_dirDiffAuthor[VOLINT_STATS_TIME_IDX_1]);
722                 fprintf(STDOUT,
723                         "10min-1hr | %8d | %8d | %8d | %8d |\n",
724                         a_xInfoP->stat_fileSameAuthor[VOLINT_STATS_TIME_IDX_2],
725                         a_xInfoP->stat_fileDiffAuthor[VOLINT_STATS_TIME_IDX_2],
726                         a_xInfoP->stat_dirSameAuthor[VOLINT_STATS_TIME_IDX_2],
727                         a_xInfoP->stat_dirDiffAuthor[VOLINT_STATS_TIME_IDX_2]);
728                 fprintf(STDOUT,
729                         "1hr-1day  | %8d | %8d | %8d | %8d |\n",
730                         a_xInfoP->stat_fileSameAuthor[VOLINT_STATS_TIME_IDX_3],
731                         a_xInfoP->stat_fileDiffAuthor[VOLINT_STATS_TIME_IDX_3],
732                         a_xInfoP->stat_dirSameAuthor[VOLINT_STATS_TIME_IDX_3],
733                         a_xInfoP->stat_dirDiffAuthor[VOLINT_STATS_TIME_IDX_3]);
734                 fprintf(STDOUT,
735                         "1day-1wk  | %8d | %8d | %8d | %8d |\n",
736                         a_xInfoP->stat_fileSameAuthor[VOLINT_STATS_TIME_IDX_4],
737                         a_xInfoP->stat_fileDiffAuthor[VOLINT_STATS_TIME_IDX_4],
738                         a_xInfoP->stat_dirSameAuthor[VOLINT_STATS_TIME_IDX_4],
739                         a_xInfoP->stat_dirDiffAuthor[VOLINT_STATS_TIME_IDX_4]);
740                 fprintf(STDOUT,
741                         "> 1wk     | %8d | %8d | %8d | %8d |\n",
742                         a_xInfoP->stat_fileSameAuthor[VOLINT_STATS_TIME_IDX_5],
743                         a_xInfoP->stat_fileDiffAuthor[VOLINT_STATS_TIME_IDX_5],
744                         a_xInfoP->stat_dirSameAuthor[VOLINT_STATS_TIME_IDX_5],
745                         a_xInfoP->stat_dirDiffAuthor[VOLINT_STATS_TIME_IDX_5]);
746                 fprintf(STDOUT,
747                         "          |-------------------------------------------|\n");
748             } /*Volume status OK*/
749             else
750                 if (a_xInfoP->status == VBUSY) {
751                     (*a_totalBusyP)++;
752                     qPut(&busyHead, a_xInfoP->volid);
753                     if (a_showProblems)
754                         fprintf(STDOUT, "**** Volume %u is busy ****\n",
755                                 a_xInfoP->volid);
756                 } /*Busy volume*/
757                 else {
758                     (*a_totalNotOKP)++;
759                     qPut(&notokHead, a_xInfoP->volid);
760                     if (a_showProblems)
761                         fprintf(STDOUT, "**** Could not attach volume %u ****\n",
762                                 a_xInfoP->volid);
763                 } /*Screwed volume*/
764             fprintf(STDOUT,"\n");
765         } /*Long listing*/
766         else {
767             /*
768              * Default listing.
769              */
770             if (a_xInfoP->status == VOK) {
771                 fprintf(STDOUT, "%-32s ", a_xInfoP->name);
772                 fprintf(STDOUT, "%10u ", a_xInfoP->volid);
773                 if (a_xInfoP->type == 0) fprintf(STDOUT, "RW ");
774                 if (a_xInfoP->type == 1) fprintf(STDOUT, "RO ");
775                 if (a_xInfoP->type == 2) fprintf(STDOUT, "BK ");
776                 fprintf(STDOUT, "%10d K ", a_xInfoP->size);
777                 if(a_xInfoP->inUse == 1) {
778                     fprintf(STDOUT, "On-line");
779                     (*a_totalOKP)++;
780                 } else {
781                     fprintf(STDOUT, "Off-line");
782                     (*a_totalNotOKP)++;
783                 }
784                 fprintf(STDOUT, "\n");
785             } /*Volume OK*/
786             else
787                 if (a_xInfoP->status == VBUSY) {
788                     (*a_totalBusyP)++;
789                     qPut(&busyHead, a_xInfoP->volid);
790                     if (a_showProblems)
791                         fprintf(STDOUT,"**** Volume %u is busy ****\n",
792                                 a_xInfoP->volid);
793                 } /*Busy volume*/
794                 else {
795                     (*a_totalNotOKP)++;
796                     qPut(&notokHead, a_xInfoP->volid);
797                     if (a_showProblems)
798                         fprintf(STDOUT,"**** Could not attach volume %u ****\n",
799                                 a_xInfoP->volid);
800                 } /*Screwed volume*/
801         } /*Default listing*/
802 } /*XDisplayFormat*/
803
804 #ifdef FULL_LISTVOL_SWITCH
805 static void  DisplayFormat2(server, partition, pntr)
806     long    server, partition;
807     volintInfo *pntr;
808 {
809   static long server_cache = -1, partition_cache = -1;
810   static char hostname[256],
811   address[32],
812   pname[16];
813
814   if (server != server_cache) {
815     struct in_addr s;
816     
817     s.s_addr = server;
818     strcpy(hostname, hostutil_GetNameByINet(server));
819     strcpy(address, inet_ntoa(s));
820     server_cache = server;
821   }
822   if (partition != partition_cache) {
823     MapPartIdIntoName(partition, pname);
824     partition_cache = partition;
825   }
826   fprintf(STDOUT, "name\t\t%s\n", pntr->name);
827   fprintf(STDOUT, "id\t\t%lu\n", pntr->volid);
828   fprintf(STDOUT, "serv\t\t%s\t%s\n", address, hostname);
829   fprintf(STDOUT, "part\t\t%s\n", pname);
830   switch (pntr->status) {
831   case VOK:
832     fprintf(STDOUT, "status\t\tOK\n");
833     break;
834   case VBUSY:
835     fprintf(STDOUT, "status\t\tBUSY\n");
836     return;
837   default:
838     fprintf(STDOUT, "status\t\tUNATTACHABLE\n");
839     return;
840   }
841   fprintf(STDOUT, "backupID\t%lu\n", pntr->backupID);
842   fprintf(STDOUT, "parentID\t%lu\n", pntr->parentID);
843   fprintf(STDOUT, "cloneID\t\t%lu\n", pntr->cloneID);
844   fprintf(STDOUT, "inUse\t\t%s\n", pntr->inUse ? "Y" : "N");
845   fprintf(STDOUT, "needsSalvaged\t%s\n", pntr->needsSalvaged ? "Y" : "N");
846   /* 0xD3 is from afs/volume.h since I had trouble including the file */
847   fprintf(STDOUT, "destroyMe\t%s\n", pntr->destroyMe == 0xD3 ? "Y" : "N");
848   switch (pntr->type) {
849   case 0:
850     fprintf(STDOUT, "type\t\tRW\n");
851     break;
852   case 1:
853     fprintf(STDOUT, "type\t\tRO\n");
854     break;
855   case 2:
856     fprintf(STDOUT, "type\t\tBK\n");
857     break;
858   default:
859     fprintf(STDOUT, "type\t\t?\n");
860     break;
861   }
862   fprintf(STDOUT, "creationDate\t%-9lu\t%s", pntr->creationDate, ctime(&pntr->creationDate));
863   fprintf(STDOUT, "accessDate\t%-9lu\t%s", pntr->accessDate, ctime(&pntr->accessDate));
864   fprintf(STDOUT, "updateDate\t%-9lu\t%s", pntr->updateDate, ctime(&pntr->updateDate));
865   fprintf(STDOUT, "backupDate\t%-9lu\t%s", pntr->backupDate, ctime(&pntr->backupDate));
866   fprintf(STDOUT, "copyDate\t%-9lu\t%s", pntr->copyDate, ctime(&pntr->copyDate));
867   fprintf(STDOUT, "flags\t\t%#lx\t(Optional)\n", pntr->flags);
868   fprintf(STDOUT, "diskused\t%u\n", pntr->size);
869   fprintf(STDOUT, "maxquota\t%u\n", pntr->maxquota);
870   fprintf(STDOUT, "minquota\t%lu\t(Optional)\n", pntr->spare0);
871   fprintf(STDOUT, "filecount\t%u\n", pntr->filecount);
872   fprintf(STDOUT, "dayUse\t\t%u\n", pntr->dayUse);
873   fprintf(STDOUT, "weekUse\t\t%lu\t(Optional)\n", pntr->spare1);
874   fprintf(STDOUT, "spare2\t\t%lu\t(Optional)\n", pntr->spare2);
875   fprintf(STDOUT, "spare3\t\t%lu\t(Optional)\n", pntr->spare3);
876   return;
877 }
878
879 static void DisplayVolumes2(server, partition, pntr, count)
880     volintInfo *pntr;
881     long    server, partition, count;
882 {
883   long    i;
884   
885   for (i = 0; i < count; i++) {
886     fprintf(STDOUT, "BEGIN_OF_ENTRY\n");
887     DisplayFormat2(server, partition, pntr);
888     fprintf(STDOUT, "END_OF_ENTRY\n\n");
889     pntr++;
890   }
891   return;
892 }
893 #endif /* FULL_LISTVOL_SWITCH */
894
895 static void DisplayVolumes(server,part,pntr,count,longlist,fast,quiet)
896 afs_int32 server,part;
897 volintInfo *pntr;
898 afs_int32 count,longlist,fast;
899 int quiet;
900 {
901     int totalOK,totalNotOK,totalBusy, i;
902     afs_int32 volid;
903
904     totalOK = 0;
905     totalNotOK = 0;
906     totalBusy = 0;
907     qInit(&busyHead);
908     qInit(&notokHead);
909     for(i = 0; i < count; i++){
910         DisplayFormat(pntr,server,part,&totalOK,&totalNotOK,&totalBusy,fast,longlist,0);
911         pntr++;
912     }
913     if(totalBusy){
914         while(busyHead.count){
915             qGet(&busyHead,&volid);
916             fprintf(STDOUT,"**** Volume %u is busy ****\n",volid);
917         }
918     }
919     if(totalNotOK){
920         while(notokHead.count){
921             qGet(&notokHead,&volid);
922             fprintf(STDOUT,"**** Could not attach volume %u ****\n",volid);
923         }
924     }
925     if(!quiet){
926         fprintf(STDOUT,"\n");
927         if(!fast){
928             fprintf(STDOUT,"Total volumes onLine %d ; Total volumes offLine %d ; Total busy %d\n\n",totalOK,totalNotOK,totalBusy);
929         }
930     }
931 }
932
933 /*------------------------------------------------------------------------
934  * PRIVATE XDisplayVolumes
935  *
936  * Description:
937  *      Display extended volume information.
938  *
939  * Arguments:
940  *      a_servID : Pointer to the Rx call we're performing.
941  *      a_partID : Partition for which we want the extended list.
942  *      a_xInfoP : Ptr to extended volume info.
943  *      a_count  : Number of volume records contained above.
944  *      a_int32   : Int32 listing generated?
945  *      a_fast   : Fast listing generated?
946  *      a_quiet  : Quiet listing generated?
947  *
948  * Returns:
949  *      Nothing.
950  *
951  * Environment:
952  *      Nothing interesting.
953  *
954  * Side Effects:
955  *      As advertised.
956  *------------------------------------------------------------------------*/
957
958 static void XDisplayVolumes(a_servID, a_partID, a_xInfoP,
959                             a_count, a_int32, a_fast, a_quiet)
960     afs_int32 a_servID;
961     afs_int32 a_partID;
962     volintXInfo *a_xInfoP;
963     afs_int32 a_count;
964     afs_int32 a_int32;
965     afs_int32 a_fast;
966     int a_quiet;
967
968 { /*XDisplayVolumes*/
969
970     int totalOK;        /*Total OK volumes*/
971     int totalNotOK;     /*Total screwed volumes*/
972     int totalBusy;      /*Total busy volumes*/
973     int i;              /*Loop variable*/
974     afs_int32 volid;            /*Current volume ID*/
975
976     /*
977      * Initialize counters and (global!!) queues.
978      */
979     totalOK = 0;
980     totalNotOK = 0;
981     totalBusy = 0;
982     qInit(&busyHead);
983     qInit(&notokHead);
984
985     /*
986      * Display each volume in the list.
987      */
988     for(i = 0; i < a_count; i++) {
989         XDisplayFormat(a_xInfoP,
990                        a_servID,
991                        a_partID,
992                        &totalOK,
993                        &totalNotOK,
994                        &totalBusy,
995                        a_fast,
996                        a_int32,
997                        0);
998         a_xInfoP++;
999     }
1000
1001     /*
1002      * If any volumes were found to be busy or screwed, display them.
1003      */
1004     if (totalBusy) {
1005         while (busyHead.count) {
1006             qGet(&busyHead, &volid);
1007             fprintf(STDOUT, "**** Volume %u is busy ****\n", volid);
1008         }
1009     }
1010     if (totalNotOK) {
1011         while (notokHead.count) {
1012             qGet(&notokHead, &volid);
1013             fprintf(STDOUT, "**** Could not attach volume %u ****\n", volid);
1014         }
1015     }
1016
1017     if (!a_quiet) {
1018         fprintf(STDOUT, "\n");
1019         if (!a_fast) {
1020             fprintf(STDOUT,
1021                     "Total volumes: %d on-line, %d off-line, %d  busyd\n\n",
1022                     totalOK, totalNotOK, totalBusy);
1023         }
1024     }
1025
1026 } /*XDisplayVolumes*/
1027
1028 /* set <server> and <part> to the correct values depending on 
1029  * <voltype> and <entry> */
1030 static void GetServerAndPart (entry, voltype, server, part, previdx)
1031     struct nvldbentry *entry;
1032     afs_int32 *server,*part;
1033     int voltype;
1034     int *previdx;
1035 {
1036     int i, istart, vtype;
1037
1038     *server = -1;
1039     *part   = -1;
1040
1041     /* Doesn't check for non-existance of backup volume */
1042     if ((voltype == RWVOL) || (voltype == BACKVOL)) {
1043        vtype = ITSRWVOL;
1044        istart = 0;      /* seach the entire entry */
1045     } else {
1046        vtype = ITSROVOL;
1047        /* Seach from beginning of entry or pick up where we left off */
1048        istart = ((*previdx < 0) ? 0 : *previdx+1);
1049     }
1050
1051     for (i = istart; i < entry->nServers; i++) {
1052        if (entry->serverFlags[i] & vtype) {
1053           *server = entry->serverNumber[i];
1054           *part   = entry->serverPartition[i];
1055           *previdx = i;
1056           return;
1057        }
1058     }
1059
1060     /* Didn't find any, return -1 */
1061     *previdx = -1;
1062     return;
1063 }
1064
1065 static void PostVolumeStats(entry)
1066 struct nvldbentry *entry;
1067 {
1068     SubEnumerateEntry(entry);
1069     /* Check for VLOP_ALLOPERS */
1070     if (entry->flags & VLOP_ALLOPERS)
1071        fprintf(STDOUT,"    Volume is currently LOCKED  \n");
1072     return;
1073 }
1074
1075 /*------------------------------------------------------------------------
1076  * PRIVATE XVolumeStats
1077  *
1078  * Description:
1079  *      Display extended volume information.
1080  *
1081  * Arguments:
1082  *      a_xInfoP  : Ptr to extended volume info.
1083  *      a_entryP  : Ptr to the volume's VLDB entry.
1084  *      a_srvID   : Server ID.
1085  *      a_partID  : Partition ID.
1086  *      a_volType : Type of volume to print.
1087  *
1088  * Returns:
1089  *      Nothing.
1090  *
1091  * Environment:
1092  *      Nothing interesting.
1093  *
1094  * Side Effects:
1095  *      As advertised.
1096  *------------------------------------------------------------------------*/
1097
1098 static void XVolumeStats(a_xInfoP, a_entryP, a_srvID, a_partID, a_volType)
1099     volintXInfo *a_xInfoP;
1100     struct nvldbentry *a_entryP;
1101     afs_int32 a_srvID;
1102     afs_int32 a_partID;
1103     int a_volType;
1104
1105 { /*XVolumeStats*/
1106
1107     int totalOK, totalNotOK, totalBusy; /*Dummies - we don't really count here*/
1108     
1109     XDisplayFormat(a_xInfoP,            /*Ptr to extended volume info*/
1110                    a_srvID,             /*Server ID to print*/
1111                    a_partID,            /*Partition ID to print*/
1112                    &totalOK,            /*Ptr to total-OK counter*/
1113                    &totalNotOK,         /*Ptr to total-screwed counter*/
1114                    &totalBusy,          /*Ptr to total-busy counter*/
1115                    0,                   /*Don't do a fast listing*/
1116                    1,                   /*Do a long listing*/
1117                    1);                  /*Show volume problems*/
1118     return;
1119
1120 } /*XVolumeStats*/
1121
1122 static void VolumeStats(pntr,entry,server,part,voltype)
1123 volintInfo *pntr;
1124 struct nvldbentry *entry;
1125 int voltype;
1126 afs_int32 server,part;
1127 {
1128     int totalOK,totalNotOK,totalBusy;
1129     afs_int32 vcode,vcode2;
1130     
1131     DisplayFormat(pntr,server,part,&totalOK,&totalNotOK,&totalBusy,0,1,1);
1132     return;
1133 }
1134
1135 /* command to forcibly remove a volume */
1136 static NukeVolume(as)
1137 register struct cmd_syndesc *as; {
1138     register afs_int32 code;
1139     afs_int32 volID, err;
1140     afs_int32 partID;
1141     afs_int32 server;
1142     register char *tp;
1143
1144     server = GetServer(tp = as->parms[0].items->data);
1145     if (!server) {
1146         fprintf(STDERR,"vos: server '%s' not found in host table\n", tp);
1147         return 1;
1148     }
1149
1150     partID = volutil_GetPartitionID(tp = as->parms[1].items->data);
1151     if (partID == -1) {
1152         fprintf(STDERR, "vos: could not parse '%s' as a partition name", tp);
1153         return 1;
1154     }
1155
1156     volID = vsu_GetVolumeID(tp = as->parms[2].items->data, cstruct, &err);
1157     if (volID == 0) {
1158         if (err) PrintError("", err);
1159         else fprintf(STDERR, "vos: could not parse '%s' as a numeric volume ID", tp);
1160         return 1;
1161     }
1162
1163     fprintf(STDOUT, "vos: forcibly removing all traces of volume %d, please wait...", volID);
1164     fflush(STDOUT);
1165     code = UV_NukeVolume(server, partID, volID);
1166     if (code == 0)
1167         fprintf(STDOUT, "done.\n");
1168     else
1169         fprintf(STDOUT, "failed with code %d.\n", code);
1170     return code;
1171 }
1172
1173
1174 /*------------------------------------------------------------------------
1175  * PRIVATE ExamineVolume
1176  *
1177  * Description:
1178  *      Routine used to examine a single volume, contacting the VLDB as
1179  *      well as the Volume Server.
1180  *
1181  * Arguments:
1182  *      as : Ptr to parsed command line arguments.
1183  *
1184  * Returns:
1185  *      0 for a successful operation,
1186  *      Otherwise, one of the ubik or VolServer error values.
1187  *
1188  * Environment:
1189  *      Nothing interesting.
1190  *
1191  * Side Effects:
1192  *      As advertised.
1193  *------------------------------------------------------------------------
1194  */
1195 static ExamineVolume(as)
1196 register struct cmd_syndesc *as;
1197 {
1198     struct nvldbentry entry;
1199     afs_int32 vcode = 0;
1200     volintInfo *pntr = (volintInfo *)0;
1201     volintXInfo *xInfoP = (volintXInfo *)0;
1202     afs_int32 volid;
1203     afs_int32 code, err, error = 0;
1204     int voltype, foundserv = 0, foundentry = 0;
1205     afs_int32 aserver, apart;
1206     int previdx = -1;
1207     int wantExtendedInfo;               /*Do we want extended vol info?*/
1208
1209     wantExtendedInfo = (as->parms[1].items ? 1 : 0);       /* -extended */
1210
1211     volid = vsu_GetVolumeID(as->parms[0].items->data, cstruct, &err);    /* -id */
1212     if (volid == 0) {
1213         if (err) PrintError("", err);
1214         else fprintf(STDERR, "Unknown volume ID or name '%s'\n", as->parms[0].items->data);
1215         return -1;
1216     }
1217
1218     if (verbose) {
1219        fprintf(STDOUT, "Fetching VLDB entry for %u .. ", volid);
1220        fflush(STDOUT);
1221     }
1222     vcode = VLDB_GetEntryByID (volid, -1, &entry);
1223     if (vcode) {
1224         fprintf(STDERR, "Could not fetch the entry for volume number %u from VLDB \n",volid);
1225         return (vcode);
1226     }
1227     if (verbose)
1228        fprintf(STDOUT, "done\n");
1229     MapHostToNetwork(&entry);
1230
1231     if (entry.volumeId[RWVOL] == volid)
1232        voltype = RWVOL;
1233     else if (entry.volumeId[BACKVOL] == volid)
1234        voltype = BACKVOL;
1235     else                          /* (entry.volumeId[ROVOL] == volid) */
1236        voltype = ROVOL;
1237
1238     do {                     /* do {...} while (voltype == ROVOL) */
1239        /* Get the entry for the volume. If its a RW vol, get the RW entry.
1240         * It its a BK vol, get the RW entry (even if VLDB may say the BK doen't exist).
1241         * If its a RO vol, get the next RO entry.
1242         */
1243        GetServerAndPart(&entry, ((voltype == ROVOL) ? ROVOL : RWVOL), &aserver, &apart, &previdx);
1244        if (previdx == -1) { /* searched all entries */
1245           if (!foundentry) {
1246              fprintf(STDERR,"Volume %s does not exist in VLDB\n\n", as->parms[0].items->data);
1247              error = ENOENT;
1248           }
1249           break;
1250        }
1251        foundentry = 1;
1252
1253        /* Get information about the volume from the server */
1254        if (verbose) {
1255           fprintf(STDOUT,"Getting volume listing from the server %s .. ",
1256                   hostutil_GetNameByINet(aserver));
1257           fflush(STDOUT);
1258        }
1259        if (wantExtendedInfo)
1260           code = UV_XListOneVolume(aserver, apart, volid, &xInfoP);
1261        else
1262           code = UV_ListOneVolume(aserver, apart, volid, &pntr);
1263        if (verbose)
1264           fprintf(STDOUT,"done\n");
1265
1266        if (code) {
1267           error = code;
1268           if (code == ENODEV) {
1269              if ((voltype == BACKVOL) && !(entry.flags & BACK_EXISTS)) {
1270                 /* The VLDB says there is no backup volume and its not on disk */
1271                 fprintf(STDERR, "Volume %s does not exist\n", as->parms[0].items->data);
1272                 error = ENOENT;
1273              } else {
1274                 fprintf(STDERR, "Volume does not exist on server %s as indicated by the VLDB\n", 
1275                         hostutil_GetNameByINet(aserver));
1276              }
1277           } else {
1278              PrintDiagnostics("examine", code);
1279           }
1280           fprintf(STDOUT, "\n");
1281        } else {
1282           foundserv = 1;
1283           if (wantExtendedInfo)
1284              XVolumeStats(xInfoP, &entry, aserver, apart, voltype);
1285           else
1286 #ifdef FULL_LISTVOL_SWITCH
1287             if (as->parms[2].items) {
1288               DisplayFormat2(aserver, apart, pntr);
1289               EnumerateEntry(&entry);
1290             } else
1291 #endif /* FULL_LISTVOL_SWITCH */
1292              VolumeStats(pntr, &entry, aserver, apart, voltype);
1293
1294           if ((voltype == BACKVOL) && !(entry.flags & BACK_EXISTS)) {
1295              /* The VLDB says there is no backup volume yet we found one on disk */
1296              fprintf(STDERR, "Volume %s does not exist in VLDB\n", as->parms[0].items->data);
1297              error = ENOENT;
1298           }
1299        }
1300
1301        if (pntr)   free(pntr);
1302        if (xInfoP) free(xInfoP);
1303     } while (voltype == ROVOL);
1304
1305     if (!foundserv) {
1306        fprintf(STDERR,"Dump only information from VLDB\n\n");           
1307        fprintf(STDOUT,"%s \n", entry.name);    /* PostVolumeStats doesn't print name */
1308     }
1309     PostVolumeStats(&entry);
1310
1311     return (error);
1312 }
1313
1314 /*------------------------------------------------------------------------
1315  * PRIVATE SetFields
1316  *
1317  * Description:
1318  *      Routine used to change the status of a single volume.
1319  *
1320  * Arguments:
1321  *      as : Ptr to parsed command line arguments.
1322  *
1323  * Returns:
1324  *      0 for a successful operation,
1325  *      Otherwise, one of the ubik or VolServer error values.
1326  *
1327  * Environment:
1328  *      Nothing interesting.
1329  *
1330  * Side Effects:
1331  *      As advertised.
1332  *------------------------------------------------------------------------
1333  */
1334 static SetFields(as)
1335 register struct cmd_syndesc *as;
1336 {
1337     struct nvldbentry entry;
1338     afs_int32 vcode = 0;
1339     volintInfo info;
1340     afs_int32 volid;
1341     afs_int32 code, err;
1342     afs_int32 aserver, apart;
1343     int previdx = -1;
1344
1345     volid = vsu_GetVolumeID(as->parms[0].items->data, cstruct, &err);    /* -id */
1346     if (volid == 0) {
1347         if (err) PrintError("", err);
1348         else fprintf(STDERR, "Unknown volume ID or name '%s'\n", as->parms[0].items->data);
1349         return -1;
1350     }
1351
1352     code = VLDB_GetEntryByID (volid, RWVOL, &entry);
1353     if (code) {
1354         fprintf(STDERR, "Could not fetch the entry for volume number %u from VLDB \n",volid);
1355         return (code);
1356     }
1357     MapHostToNetwork(&entry);
1358
1359     GetServerAndPart(&entry, RWVOL, &aserver, &apart, &previdx);
1360     if (previdx == -1) {
1361         fprintf(STDERR,"Volume %s does not exist in VLDB\n\n", as->parms[0].items->data);
1362         return (ENOENT);
1363     }
1364
1365     memset(&info, 0, sizeof(info));
1366     info.volid    = volid;
1367     info.type     = RWVOL;
1368     info.dayUse   = -1;
1369     info.maxquota = -1;
1370     info.flags    = -1;
1371     info.spare0   = -1;
1372     info.spare1   = -1;
1373     info.spare2   = -1;
1374     info.spare3   = -1;
1375
1376     if (as->parms[1].items) {
1377         /* -max <quota> */
1378         code = util_GetInt32(as->parms[1].items->data, &info.maxquota);
1379         if (code) {
1380             fprintf(STDERR,"invalid quota value\n");
1381             return code;
1382         }
1383     }
1384     if (as->parms[2].items) {
1385         /* -clearuse */
1386         info.dayUse = 0;
1387     }
1388     code = UV_SetVolumeInfo(aserver, apart, volid, &info);
1389     if (code)
1390         fprintf(STDERR,"Could not update volume info fields for volume number %u\n",volid);
1391     return (code);
1392 }
1393
1394 /*------------------------------------------------------------------------
1395  * PRIVATE volOnline
1396  *
1397  * Description:
1398  *      Brings a volume online.
1399  *
1400  * Arguments:
1401  *      as : Ptr to parsed command line arguments.
1402  *
1403  * Returns:
1404  *      0 for a successful operation,
1405  *
1406  * Environment:
1407  *      Nothing interesting.
1408  *
1409  * Side Effects:
1410  *      As advertised.
1411  *------------------------------------------------------------------------
1412  */
1413 static volOnline(as)
1414     register struct cmd_syndesc *as;
1415 {
1416     afs_int32 server, partition, volid;
1417     afs_int32 code, err=0;
1418
1419     server = GetServer(as->parms[0].items->data);
1420     if (server == 0) {
1421         fprintf(STDERR,"vos: server '%s' not found in host table\n", as->parms[0].items->data);
1422         return -1;
1423     }
1424
1425     partition = volutil_GetPartitionID(as->parms[1].items->data);
1426     if (partition < 0) {
1427         fprintf(STDERR,"vos: could not interpret partition name '%s'\n", as->parms[1].items->data);
1428         return ENOENT;
1429     }
1430
1431     volid = vsu_GetVolumeID(as->parms[2].items->data, cstruct, &err);    /* -id */
1432     if (!volid) {
1433        if (err) PrintError("", err);
1434        else fprintf(STDERR, "Unknown volume ID or name '%s'\n", as->parms[0].items->data);
1435        return -1;
1436     }
1437
1438     code = UV_SetVolume(server, partition, volid, ITOffline, 0/*online*/, 0/*sleep*/);
1439     if (code) {
1440        fprintf(STDERR, "Failed to set volume. Code = %d\n", code);
1441        return -1;
1442     }
1443
1444     return 0;
1445 }
1446
1447 /*------------------------------------------------------------------------
1448  * PRIVATE volOffline
1449  *
1450  * Description:
1451  *      Brings a volume offline.
1452  *
1453  * Arguments:
1454  *      as : Ptr to parsed command line arguments.
1455  *
1456  * Returns:
1457  *      0 for a successful operation,
1458  *
1459  * Environment:
1460  *      Nothing interesting.
1461  *
1462  * Side Effects:
1463  *      As advertised.
1464  *------------------------------------------------------------------------
1465  */
1466 static volOffline(as)
1467     register struct cmd_syndesc *as;
1468 {
1469     afs_int32 server, partition, volid;
1470     afs_int32 code, err=0;
1471     afs_int32 transflag, sleeptime, transdone;
1472
1473     server = GetServer(as->parms[0].items->data);
1474     if (server == 0) {
1475         fprintf(STDERR,"vos: server '%s' not found in host table\n", as->parms[0].items->data);
1476         return -1;
1477     }
1478
1479     partition = volutil_GetPartitionID(as->parms[1].items->data);
1480     if (partition < 0) {
1481         fprintf(STDERR,"vos: could not interpret partition name '%s'\n", as->parms[1].items->data);
1482         return ENOENT;
1483     }
1484
1485     volid = vsu_GetVolumeID(as->parms[2].items->data, cstruct, &err); /* -id */
1486     if (!volid) {
1487        if (err) PrintError("", err);
1488        else fprintf(STDERR, "Unknown volume ID or name '%s'\n", as->parms[0].items->data);
1489        return -1;
1490     }
1491
1492     transflag = (as->parms[4].items ? ITBusy : ITOffline);
1493     sleeptime = (as->parms[3].items ? atol(as->parms[3].items->data) : 0);
1494     transdone = (sleeptime ? 0/*online*/ : VTOutOfService);
1495     if (as->parms[4].items && !as->parms[3].items) {
1496         fprintf(STDERR,"-sleep option must be used with -busy flag\n");
1497         return -1;
1498     }
1499
1500     code = UV_SetVolume(server, partition, volid, transflag, transdone, sleeptime);
1501     if (code) {
1502        fprintf(STDERR, "Failed to set volume. Code = %d\n", code);
1503        return -1;
1504     }
1505
1506     return 0;
1507 }
1508
1509 static CreateVolume(as)
1510 register struct cmd_syndesc *as;
1511 {
1512     afs_int32 pname;
1513     char part[10];
1514     afs_int32 volid,code;
1515     struct nvldbentry entry;
1516     afs_int32 vcode;
1517     afs_int32 quota;
1518
1519     quota = 5000;
1520     tserver = GetServer(as->parms[0].items->data);
1521     if (!tserver) {
1522         fprintf(STDERR,"vos: host '%s' not found in host table\n",as->parms[0].items->data );
1523         return ENOENT;
1524     }
1525     pname = volutil_GetPartitionID(as->parms[1].items->data);
1526     if (pname < 0) {
1527         fprintf(STDERR,"vos: could not interpret partition name '%s'\n",as->parms[1].items->data );
1528         return ENOENT;
1529     }
1530     if (!IsPartValid(pname,tserver,&code)){/*check for validity of the partition */
1531         if(code) PrintError("",code);
1532         else fprintf(STDERR,"vos : partition %s does not exist on the server\n",as->parms[1].items->data);
1533         return ENOENT;
1534     }
1535     if(!ISNAMEVALID(as->parms[2].items->data)) {
1536         fprintf(STDERR,"vos: the name of the root volume %s exceeds the size limit of %d\n",as->parms[2].items->data,VOLSER_OLDMAXVOLNAME - 10);
1537         return E2BIG;
1538     }
1539     if(!VolNameOK(as->parms[2].items->data)){
1540         fprintf(STDERR,"Illegal volume name %s, should not end in .readonly or .backup\n",as->parms[2].items->data);
1541         return EINVAL;
1542     }
1543     if(IsNumeric(as->parms[2].items->data)){
1544         fprintf(STDERR,"Illegal volume name %s, should not be a number\n",as->parms[2].items->data);
1545         return EINVAL;
1546     }
1547     vcode = VLDB_GetEntryByName(as->parms[2].items->data, &entry);
1548     if(!vcode) {
1549         fprintf(STDERR,"Volume %s already exists\n",as->parms[2].items->data);
1550         PrintDiagnostics("create", code);
1551         return EEXIST;
1552     }
1553
1554     if (as->parms[3].items) {
1555        if (!IsNumeric(as->parms[3].items->data)){
1556          fprintf(STDERR,"Initial quota %s should be numeric.\n", as->parms[3].items->data);
1557          return EINVAL;
1558        }
1559
1560       code = util_GetInt32(as->parms[3].items->data, &quota);
1561       if (code) {
1562         fprintf(STDERR,"vos: bad integer specified for quota.\n");
1563         return code;
1564       }
1565     }
1566
1567     code = UV_CreateVolume2(tserver, pname,as->parms[2].items->data,
1568                             quota, 0, 0, 0, 0, &volid);
1569     if (code) {
1570         PrintDiagnostics("create", code);
1571         return code;
1572     }
1573     MapPartIdIntoName(pname, part);
1574     fprintf(STDOUT,"Volume %u created on partition %s of %s\n", volid, part,as->parms[0].items->data );
1575
1576     return 0;
1577 }
1578
1579 static afs_int32 DeleteAll(entry)
1580 struct nvldbentry *entry;
1581 {
1582     int i;
1583     afs_int32 error, code, curserver, curpart, volid;
1584
1585     MapHostToNetwork(entry);
1586     error = 0;
1587     for(i=0; i < entry->nServers; i++){
1588         curserver = entry->serverNumber[i];
1589         curpart = entry->serverPartition[i];
1590         if(entry->serverFlags[i] & ITSROVOL){
1591             volid = entry->volumeId[ROVOL];
1592         }
1593         else{
1594             volid = entry->volumeId[RWVOL];
1595         }
1596         code = UV_DeleteVolume(curserver,curpart,volid);
1597         if(code && !error)
1598             error = code;
1599     }
1600     return error;
1601 }
1602
1603 static DeleteVolume(as)
1604     struct cmd_syndesc *as;
1605 {
1606     afs_int32 err, code = 0;
1607     afs_int32 server = 0, partition = -1, volid;
1608     char pname[10];
1609     afs_int32 idx, j;
1610
1611     if (as->parms[0].items) {
1612        server = GetServer(as->parms[0].items->data);
1613        if (!server) {
1614           fprintf(STDERR,"vos: server '%s' not found in host table\n",
1615                   as->parms[0].items->data);
1616           return ENOENT;
1617        }
1618     }
1619
1620     if (as->parms[1].items) {
1621        partition = volutil_GetPartitionID(as->parms[1].items->data);
1622        if (partition < 0) {
1623           fprintf(STDERR,"vos: could not interpret partition name '%s'\n",
1624                   as->parms[1].items->data );
1625           return EINVAL;
1626        }
1627
1628        /* Check for validity of the partition */
1629        if (!IsPartValid(partition, server, &code)) {
1630           if (code) {
1631              PrintError("", code);
1632           } else {
1633              fprintf(STDERR,"vos : partition %s does not exist on the server\n",
1634                      as->parms[1].items->data);
1635           }
1636           return ENOENT;
1637        }
1638     }
1639
1640     volid = vsu_GetVolumeID(as->parms[2].items->data, cstruct, &err);
1641     if (volid == 0) {
1642         fprintf(STDERR, "Can't find volume name '%s' in VLDB\n",
1643                 as->parms[2].items->data);
1644         if (err) PrintError("", err);
1645         return ENOENT;
1646     }
1647
1648     /* If the server or partition option are not complete, try to fill
1649      * them in from the VLDB entry.
1650      */
1651     if ((partition == -1) || !server) {
1652        struct nvldbentry entry;
1653
1654        code = VLDB_GetEntryByID(volid, -1, &entry);
1655        if (code) {
1656           fprintf(STDERR,"Could not fetch the entry for volume %u from VLDB\n",
1657                   volid);
1658           PrintError("",code);
1659           return (code);
1660        }
1661        
1662        if (((volid == entry.volumeId[RWVOL])   && (entry.flags & RW_EXISTS)) ||
1663            ((volid == entry.volumeId[BACKVOL]) && (entry.flags & BACK_EXISTS)) ) {
1664           idx = Lp_GetRwIndex(&entry);
1665           if ( (idx == -1) ||
1666                (server && (server != entry.serverNumber[idx])) ||
1667                ((partition != -1) && (partition != entry.serverPartition[idx])) ) {
1668              fprintf(STDERR,"VLDB: Volume '%s' no match\n", as->parms[2].items->data);
1669              return ENOENT;
1670           }
1671        } 
1672        else if ((volid == entry.volumeId[ROVOL]) && (entry.flags & RO_EXISTS)) {
1673           for (idx=-1,j=0; j<entry.nServers; j++) {
1674              if (entry.serverFlags[j] != ITSROVOL) continue;
1675
1676              if ( ((server    ==  0) || (server    == entry.serverNumber[j])) &&
1677                   ((partition == -1) || (partition == entry.serverPartition[j])) ) {
1678                 if (idx != -1) {
1679                    fprintf(STDERR,"VLDB: Volume '%s' matches more than one RO\n",
1680                            as->parms[2].items->data);
1681                    return ENOENT;
1682                 }
1683                 idx = j;
1684              }
1685           }
1686           if (idx == -1) {
1687              fprintf(STDERR,"VLDB: Volume '%s' no match\n", as->parms[2].items->data);
1688              return ENOENT;
1689           }
1690        }
1691        else {
1692           fprintf(STDERR,"VLDB: Volume '%s' no match\n", as->parms[2].items->data);
1693           return ENOENT;
1694        }
1695
1696        server    = htonl(entry.serverNumber[idx]);
1697        partition = entry.serverPartition[idx];
1698     }
1699
1700
1701     code = UV_DeleteVolume(server, partition, volid);
1702     if (code) {
1703        PrintDiagnostics("remove", code);
1704        return code;
1705     }
1706
1707     MapPartIdIntoName(partition, pname);
1708     fprintf(STDOUT,"Volume %u on partition %s server %s deleted\n",
1709             volid, pname, hostutil_GetNameByINet(server));
1710     return 0;
1711 }
1712
1713 #define TESTM   0       /* set for move space tests, clear for production */
1714 static MoveVolume(as)
1715 register struct cmd_syndesc *as;
1716 {
1717     
1718     afs_int32 volid, fromserver, toserver, frompart, topart,code, err;
1719     char fromPartName[10], toPartName[10];
1720
1721         struct diskPartition partition;         /* for space check */
1722         volintInfo *p;
1723
1724         volid = vsu_GetVolumeID(as->parms[0].items->data, cstruct, &err);
1725         if (volid == 0) {
1726         if (err) PrintError("", err);
1727         else  fprintf(STDERR, "vos: can't find volume ID or name '%s'\n",
1728                     as->parms[0].items->data);
1729             return ENOENT;
1730         }
1731         fromserver = GetServer(as->parms[1].items->data);
1732         if (fromserver == 0) {
1733             fprintf(STDERR,"vos: server '%s' not found in host table\n", as->parms[1].items->data);
1734             return ENOENT;
1735         }
1736         toserver = GetServer(as->parms[3].items->data);
1737         if (toserver == 0) {
1738             fprintf(STDERR,"vos: server '%s' not found in host table\n", as->parms[3].items->data);
1739             return ENOENT;
1740         }
1741         frompart = volutil_GetPartitionID(as->parms[2].items->data);
1742         if (frompart < 0) {
1743             fprintf(STDERR,"vos: could not interpret partition name '%s'\n", as->parms[2].items->data);
1744             return EINVAL;
1745         }
1746         if (!IsPartValid(frompart,fromserver,&code)){/*check for validity of the partition */
1747             if(code) PrintError("",code);
1748             else fprintf(STDERR,"vos : partition %s does not exist on the server\n",as->parms[2].items->data);
1749             return ENOENT;
1750         }
1751         topart = volutil_GetPartitionID(as->parms[4].items->data);
1752         if (topart < 0) {
1753             fprintf(STDERR,"vos: could not interpret partition name '%s'\n",as->parms[4].items->data);
1754             return EINVAL;
1755         }
1756         if (!IsPartValid(topart,toserver,&code)){/*check for validity of the partition */
1757             if(code) PrintError("",code);
1758             else fprintf(STDERR,"vos : partition %s does not exist on the server\n",as->parms[4].items->data);
1759             return ENOENT;
1760         }
1761
1762         /*
1763                 check source partition for space to clone volume
1764         */
1765
1766         MapPartIdIntoName(topart,toPartName);
1767         MapPartIdIntoName(frompart, fromPartName);
1768
1769         /*
1770                 check target partition for space to move volume
1771         */
1772
1773         code=UV_PartitionInfo(toserver,toPartName,&partition);
1774         if(code)
1775         {
1776                 fprintf(STDERR,"vos: cannot access partition %s\n",toPartName);
1777                 exit(1);
1778         }
1779         if(TESTM)
1780                 fprintf(STDOUT,"target partition %s free space %d\n",
1781                         toPartName,partition.free);
1782
1783         p=(volintInfo *)0;
1784         code=UV_ListOneVolume(fromserver,frompart,volid,&p);
1785         if(code)
1786         {
1787                 fprintf(STDERR,"vos:cannot access volume %u\n",volid);
1788                 free(p);
1789                 exit(1);
1790         }
1791         if(TESTM)
1792                 fprintf(STDOUT,"volume %u size %d\n",volid,p->size);
1793         if(partition.free<=p->size)
1794         {
1795                 fprintf(STDERR,"vos: no space on target partition %s to move volume %u\n",
1796                         toPartName,volid);
1797                 free(p);
1798                 exit(1);
1799         }
1800         free(p);
1801
1802         if(TESTM)
1803         {
1804                 fprintf(STDOUT,"size test - don't do move\n");
1805                 exit(0);
1806         }
1807
1808         /* successful move still not guaranteed but shoot for it */
1809
1810         code = UV_MoveVolume(volid, fromserver, frompart, toserver, topart);
1811         if (code) {
1812             PrintDiagnostics("move", code);
1813             return code;
1814         }
1815         MapPartIdIntoName(topart,toPartName);
1816         MapPartIdIntoName(frompart, fromPartName);
1817         fprintf(STDOUT,"Volume %u moved from %s %s to %s %s \n",volid,as->parms[1].items->data,fromPartName,as->parms[3].items->data,toPartName);
1818
1819     return 0;
1820 }
1821 static BackupVolume(as)
1822 register struct cmd_syndesc *as;
1823 {
1824    afs_int32 avolid, aserver, apart,vtype,code, err;
1825    struct nvldbentry entry;
1826
1827         afs_int32 buvolid,buserver,bupart,butype;
1828         struct nvldbentry buentry;
1829         struct rx_connection *conn;
1830         volEntries volInfo;
1831         struct nvldbentry store;
1832    
1833         avolid = vsu_GetVolumeID(as->parms[0].items->data, cstruct, &err);
1834         if (avolid == 0) {
1835             if (err) PrintError("", err);
1836             else fprintf(STDERR, "vos: can't find volume ID or name '%s'\n",
1837                     as->parms[0].items->data);
1838             return ENOENT;
1839         }
1840         code = GetVolumeInfo( avolid,&aserver, &apart,&vtype,&entry);
1841         if(code) exit(1);
1842
1843         /* verify this is a readwrite volume */
1844
1845         if(vtype != RWVOL)
1846         {
1847                 fprintf(STDERR,"%s not RW volume\n",as->parms[0].items->data);
1848                 exit(1);
1849         }
1850
1851         /* is there a backup volume already? */
1852
1853         if(entry.flags & BACK_EXISTS)
1854         {
1855                 /* yep, where is it? */
1856
1857                 buvolid=entry.volumeId[BACKVOL];
1858                 code=GetVolumeInfo(buvolid,&buserver,&bupart,&butype,&buentry);
1859                 if(code) exit(1);
1860
1861                 /* is it local? */
1862                 code = VLDB_IsSameAddrs(buserver, aserver, &err);
1863                 if (err) {
1864                     fprintf(STDERR,"Failed to get info about server's %d address(es) from vlserver; aborting call!\n", buserver);
1865                     exit(1);
1866                 }
1867                 if (!code)
1868                 {
1869                         fprintf(STDERR,"FATAL ERROR: backup volume %u exists on server %u\n",
1870                                 buvolid,buserver);
1871                         exit(1);
1872                 }
1873         }
1874
1875         /* nope, carry on */
1876
1877         code = UV_BackupVolume(aserver, apart, avolid);
1878
1879         if (code) {
1880             PrintDiagnostics("backup", code);
1881             return code;
1882         }
1883         fprintf(STDOUT,"Created backup volume for %s \n",as->parms[0].items->data); 
1884    return 0;
1885 }
1886 static ReleaseVolume(as)
1887 register struct cmd_syndesc *as;
1888 {
1889
1890     struct nvldbentry entry;
1891     afs_int32 avolid, aserver, apart,vtype,code, err;
1892     int force = 0;
1893
1894     if(as->parms[1].items) force = 1;
1895     avolid = vsu_GetVolumeID(as->parms[0].items->data, cstruct, &err);
1896     if (avolid == 0) {
1897         if (err) PrintError("", err);
1898         else fprintf(STDERR, "vos: can't find volume '%s'\n", as->parms[0].items->data);
1899         return ENOENT;
1900     }
1901     code = GetVolumeInfo( avolid,&aserver, &apart,&vtype,&entry);
1902     if(code) return code;
1903
1904     if (vtype != RWVOL) {
1905        fprintf(STDERR,"%s not a RW volume\n", as->parms[0].items->data);
1906        return(ENOENT);
1907     }
1908
1909     if(!ISNAMEVALID(entry.name)){
1910         fprintf(STDERR,"Volume name %s is too long, rename before releasing\n",entry.name);
1911         return E2BIG;
1912     }
1913
1914     code = UV_ReleaseVolume(avolid, aserver, apart, force);
1915     if (code) {
1916         PrintDiagnostics("release", code);
1917         return code;
1918     }
1919     fprintf(STDOUT,"Released volume %s successfully\n",as->parms[0].items->data );
1920     return 0;
1921 }
1922 static DumpVolume(as)
1923 register struct cmd_syndesc *as;
1924
1925 {    
1926         afs_int32 avolid, aserver, apart,voltype,fromdate=0,code, err, i;
1927         char filename[NameLen];
1928         struct nvldbentry entry;
1929
1930         rx_SetRxDeadTime(60 * 10);
1931         for (i = 0; i<MAXSERVERS; i++) {
1932             struct rx_connection *rxConn = ubik_GetRPCConn(cstruct,i);
1933             if (rxConn == 0) break;
1934             rx_SetConnDeadTime(rxConn, rx_connDeadTime);
1935             if (rxConn->service)  rxConn->service->connDeadTime = rx_connDeadTime;
1936         }
1937
1938         avolid = vsu_GetVolumeID(as->parms[0].items->data, cstruct, &err);
1939         if (avolid == 0) {
1940             if (err) PrintError("", err);
1941             else  fprintf(STDERR, "vos: can't find volume '%s'\n", as->parms[0].items->data);
1942             return ENOENT;
1943         }
1944
1945         if (as->parms[3].items || as->parms[4].items) {
1946            if (!as->parms[3].items || !as->parms[4].items) {
1947               fprintf(STDERR, "Must specify both -server and -partition options\n");
1948               return -1;
1949            }
1950            aserver = GetServer(as->parms[3].items->data);
1951            if (aserver == 0) {
1952               fprintf(STDERR, "Invalid server name\n");
1953               return -1;
1954            }
1955            apart = volutil_GetPartitionID(as->parms[4].items->data);
1956            if (apart < 0) {
1957               fprintf(STDERR, "Invalid partition name\n");
1958               return -1;
1959            }
1960         } else {
1961            code = GetVolumeInfo(avolid, &aserver, &apart, &voltype, &entry);
1962            if (code) return code;
1963         }
1964
1965         if (as->parms[1].items && strcmp(as->parms[1].items->data,"0")) {
1966             code = ktime_DateToInt32(as->parms[1].items->data, &fromdate);
1967             if (code) {
1968                fprintf(STDERR,"vos: failed to parse date '%s' (error=%d))\n",
1969                        as->parms[1].items->data, code);
1970                return code;
1971             }
1972         }
1973         if(as->parms[2].items){
1974             strcpy(filename,as->parms[2].items->data);
1975         }
1976         else{
1977             strcpy(filename,"");
1978         }
1979         code = UV_DumpVolume(avolid, aserver, apart, fromdate, DumpFunction, filename);
1980         if (code) {
1981             PrintDiagnostics("dump", code);
1982             return code;
1983         }
1984         if(strcmp(filename,""))
1985             fprintf(STDERR,"Dumped volume %s in file %s\n",as->parms[0].items->data, filename);
1986         else
1987             fprintf(STDERR,"Dumped volume %s in stdout \n",as->parms[0].items->data);
1988         return 0;
1989 }
1990
1991 #define ASK   0
1992 #define ABORT 1
1993 #define FULL  2
1994 #define INC   3
1995
1996 static RestoreVolume(as)
1997 register struct cmd_syndesc *as;
1998
1999 {    
2000         afs_int32 avolid, aserver, apart, code,vcode, err;
2001         afs_int32 aoverwrite = ASK;
2002         int restoreflags, readonly = 0, offline = 0, voltype = RWVOL;
2003         char prompt;
2004         char afilename[NameLen], avolname[VOLSER_MAXVOLNAME +1],apartName[10];
2005         char volname[VOLSER_MAXVOLNAME +1];
2006         struct nvldbentry entry;
2007
2008         prompt = 'n';
2009
2010         if(as->parms[4].items){
2011             avolid = vsu_GetVolumeID(as->parms[4].items->data, cstruct, &err);
2012             if (avolid == 0) {
2013                 if (err) PrintError("", err);
2014                 else fprintf(STDERR, "vos: can't find volume '%s'\n", as->parms[4].items->data);
2015                 exit(1);
2016             }
2017         }
2018         else
2019             avolid = 0;
2020
2021         if (as->parms[5].items) {
2022             if ( (strcmp(as->parms[5].items->data, "a")     == 0) ||
2023                  (strcmp(as->parms[5].items->data, "abort") == 0) ) {
2024                 aoverwrite = ABORT;
2025             }
2026             else if ( (strcmp(as->parms[5].items->data, "f")    == 0) ||
2027                       (strcmp(as->parms[5].items->data, "full") == 0) ) {
2028                 aoverwrite = FULL;
2029             }
2030             else if ( (strcmp(as->parms[5].items->data, "i")           == 0) ||
2031                       (strcmp(as->parms[5].items->data, "inc")         == 0) ||
2032                       (strcmp(as->parms[5].items->data, "increment")   == 0) ||
2033                       (strcmp(as->parms[5].items->data, "incremental") == 0) ) {
2034                 aoverwrite = INC;
2035             }
2036             else {
2037                 fprintf(STDERR, "vos: %s is not a valid argument to -overwrite\n", 
2038                         as->parms[5].items->data);
2039                 exit(1);
2040             }
2041         }
2042         if (as->parms[6].items) offline = 1;
2043         if (as->parms[7].items) {
2044             readonly = 1;
2045             voltype = ROVOL;
2046         }
2047
2048         aserver = GetServer(as->parms[0].items->data);
2049         if (aserver == 0) {
2050             fprintf(STDERR,"vos: server '%s' not found in host table\n", as->parms[0].items->data);
2051             exit(1);
2052         }
2053         apart = volutil_GetPartitionID(as->parms[1].items->data);
2054         if (apart < 0) {
2055             fprintf(STDERR,"vos: could not interpret partition name '%s'\n",as->parms[1].items->data );
2056             exit(1);
2057         }
2058         if (!IsPartValid(apart,aserver,&code)){/*check for validity of the partition */
2059             if(code) PrintError("",code);
2060             else fprintf(STDERR,"vos : partition %s does not exist on the server\n",as->parms[1].items->data);
2061             exit(1);
2062         }
2063         strcpy(avolname,as->parms[2].items->data );
2064         if(!ISNAMEVALID(avolname)) {
2065             fprintf(STDERR,"vos: the name of the volume %s exceeds the size limit\n",avolname);
2066             exit(1);
2067         }
2068         if(!VolNameOK(avolname)){
2069             fprintf(STDERR,"Illegal volume name %s, should not end in .readonly or .backup\n",avolname);
2070             exit(1);
2071         }
2072         if(as->parms[3].items){
2073             strcpy(afilename,as->parms[3].items->data );
2074             if(!FileExists(afilename)){
2075                 fprintf(STDERR,"Can't access file %s\n",afilename);
2076                 exit(1);
2077             }
2078         }
2079         else {
2080             strcpy(afilename,"");
2081         }
2082
2083         /* Check if volume exists or not */
2084
2085         vsu_ExtractName(volname,avolname);
2086         vcode = VLDB_GetEntryByName(volname, &entry);
2087         if (vcode) {              /* no volume - do a full restore */
2088             restoreflags = RV_FULLRST;
2089             if ( (aoverwrite == INC) || (aoverwrite == ABORT) )
2090                 fprintf(STDERR,"Volume does not exist; Will perform a full restore\n");
2091         }
2092
2093         else if ((!readonly && Lp_GetRwIndex(&entry) == -1)        /* RW volume does not exist - do a full */
2094              ||  (readonly && !Lp_ROMatch(0, 0, &entry))) {        /* RO volume does not exist - do a full */
2095             restoreflags = RV_FULLRST;
2096             if ( (aoverwrite == INC) || (aoverwrite == ABORT) )
2097                 fprintf(STDERR,"%s Volume does not exist; Will perform a full restore\n",
2098                         readonly ? "RO" : "RW");
2099
2100             if (avolid == 0) {
2101                 avolid = entry.volumeId[voltype];
2102             }
2103             else if (entry.volumeId[voltype] != 0  && entry.volumeId[voltype] != avolid) {
2104                 avolid = entry.volumeId[voltype];
2105             }
2106         }
2107
2108         else {                    /* volume exists - do we do a full incremental or abort */
2109             int Oserver, Opart, Otype, vol_elsewhere = 0;
2110             struct nvldbentry Oentry;
2111             int   c, dc;
2112
2113             if(avolid == 0) {
2114                 avolid = entry.volumeId[voltype];
2115             }
2116             else if(entry.volumeId[voltype] != 0  && entry.volumeId[voltype] != avolid) {
2117                 avolid = entry.volumeId[voltype];
2118             }
2119             
2120             /* A file name was specified  - check if volume is on another partition */
2121             vcode = GetVolumeInfo(avolid, &Oserver, &Opart, &Otype, &Oentry);
2122             if (vcode) exit(1);
2123
2124             vcode = VLDB_IsSameAddrs(Oserver, aserver, &err);
2125             if (err) {
2126                 fprintf(STDERR,"Failed to get info about server's %d address(es) from vlserver (err=%d); aborting call!\n", 
2127                         Oserver, err);
2128                 exit(1);
2129             }
2130             if (!vcode || (Opart != apart)) vol_elsewhere = 1;
2131
2132             if (aoverwrite == ASK) {
2133                 if (strcmp(afilename,"") == 0) {  /* The file is from standard in */
2134                     fprintf(STDERR,"Volume exists and no -overwrite option specified; Aborting restore command\n");
2135                     exit(1);
2136                 }
2137                 
2138                 /* Ask what to do */
2139                 if (vol_elsewhere) {
2140                     fprintf(STDERR,"The volume %s %u already exists on a different server/part\n",
2141                             volname, entry.volumeId[voltype]);
2142                     fprintf(STDERR, 
2143                             "Do you want to do a full restore or abort? [fa](a): ");
2144                 }
2145                 else
2146                 {
2147                     fprintf(STDERR,"The volume %s %u already exists in the VLDB\n",
2148                             volname, entry.volumeId[voltype]);
2149                     fprintf(STDERR, 
2150                             "Do you want to do a full/incremental restore or abort? [fia](a): ");
2151                 }
2152                 dc = c = getchar();
2153                 while (!(dc==EOF || dc=='\n')) dc=getchar(); /* goto end of line */
2154                 if      ((c == 'f') || (c == 'F')) aoverwrite = FULL;
2155                 else if ((c == 'i') || (c == 'I')) aoverwrite = INC;
2156                 else aoverwrite = ABORT;
2157             }
2158
2159             if (aoverwrite == ABORT) {
2160                 fprintf(STDERR,"Volume exists; Aborting restore command\n");
2161                 exit(1);
2162             }
2163             else if (aoverwrite == FULL) {
2164                 restoreflags = RV_FULLRST;
2165                 fprintf(STDERR,"Volume exists; Will delete and perform full restore\n");
2166             }
2167             else if (aoverwrite == INC) {
2168                 restoreflags = 0;
2169                 if (vol_elsewhere) {
2170                     fprintf(STDERR,
2171                             "%s volume %u already exists on a different server/part; not allowed\n",
2172                             readonly ? "RO" : "RW", avolid);
2173                     exit(1);
2174                 }
2175             }
2176         }
2177         if (offline)  restoreflags |= RV_OFFLINE;
2178         if (readonly) restoreflags |= RV_RDONLY;
2179         code = UV_RestoreVolume(aserver, apart, avolid, avolname,
2180                                 restoreflags, WriteData, afilename);
2181         if (code) {
2182             PrintDiagnostics("restore", code);
2183             exit(1);
2184         }
2185         MapPartIdIntoName(apart,apartName);
2186
2187         /*
2188                 patch typo here - originally "parms[1]", should be "parms[0]"
2189         */
2190
2191         fprintf(STDOUT,"Restored volume %s on %s %s\n",
2192                 avolname, as->parms[0].items->data, apartName);
2193         return 0;
2194 }
2195 static LockReleaseCmd(as)
2196 register struct cmd_syndesc *as;
2197
2198 {
2199     afs_int32 avolid,code, err;
2200
2201         avolid = vsu_GetVolumeID(as->parms[0].items->data, cstruct, &err);
2202         if (avolid == 0) {
2203             if (err) PrintError("", err);
2204             else fprintf(STDERR, "vos: can't find volume '%s'\n", as->parms[0].items->data);
2205             exit(1);
2206         }
2207         
2208         code = UV_LockRelease(avolid);
2209         if (code) {
2210             PrintDiagnostics("unlock", code);
2211             exit(1);
2212         }
2213         fprintf(STDOUT,"Released lock on vldb entry for volume %s\n",as->parms[0].items->data);
2214     return 0;
2215 }
2216 static AddSite(as)
2217 register struct cmd_syndesc *as;
2218 {
2219    afs_int32 avolid, aserver, apart,code, err;
2220    char apartName[10], avolname[VOLSER_MAXVOLNAME+1];
2221
2222         vsu_ExtractName(avolname, as->parms[2].items->data);;
2223         avolid = vsu_GetVolumeID(avolname, cstruct, &err);
2224         if (avolid == 0) {
2225             if (err) PrintError("", err);
2226             else fprintf(STDERR, "vos: can't find volume '%s'\n", as->parms[2].items->data);
2227             exit(1);
2228         }
2229         aserver = GetServer(as->parms[0].items->data);
2230         if (aserver == 0) {
2231             fprintf(STDERR,"vos: server '%s' not found in host table\n", as->parms[0].items->data);
2232             exit(1);
2233         }
2234         apart = volutil_GetPartitionID(as->parms[1].items->data);
2235         if (apart < 0) {
2236             fprintf(STDERR,"vos: could not interpret partition name '%s'\n",as->parms[1].items->data );
2237             exit(1);
2238         }
2239         if (!IsPartValid(apart,aserver,&code)){/*check for validity of the partition */
2240             if(code) PrintError("",code);
2241             else fprintf(STDERR,"vos : partition %s does not exist on the server\n",as->parms[1].items->data);
2242             exit(1);
2243         }
2244         code = UV_AddSite(aserver, apart, avolid);
2245         if (code) {
2246             PrintDiagnostics("addsite", code);
2247             exit(1);
2248         }
2249         MapPartIdIntoName(apart,apartName);
2250         fprintf(STDOUT,"Added replication site %s %s for volume %s\n",as->parms[0].items->data, apartName,as->parms[2].items->data);
2251    return 0;
2252 }
2253
2254 static RemoveSite(as)
2255 register struct cmd_syndesc *as;
2256
2257
2258     afs_int32 avolid, aserver, apart, code, err;
2259     char apartName[10], avolname[VOLSER_MAXVOLNAME+1];
2260
2261         vsu_ExtractName(avolname, as->parms[2].items->data);
2262         avolid = vsu_GetVolumeID(avolname, cstruct, &err);
2263         if (avolid == 0) {
2264             if (err) PrintError("", err);
2265             else fprintf(STDERR, "vos: can't find volume '%s'\n", as->parms[2].items->data);
2266             exit(1);
2267         }
2268         aserver = GetServer(as->parms[0].items->data);
2269         if (aserver == 0) {
2270             fprintf(STDERR,"vos: server '%s' not found in host table\n", as->parms[0].items->data);
2271             exit(1);
2272         }
2273         apart = volutil_GetPartitionID(as->parms[1].items->data);
2274         if (apart < 0) {
2275             fprintf(STDERR,"vos: could not interpret partition name '%s'\n",as->parms[1].items->data );
2276             exit(1);
2277         }
2278 /*
2279  *skip the partition validity check, since it is possible that the partition
2280  *has since been decomissioned.
2281  */
2282 /*
2283         if (!IsPartValid(apart,aserver,&code)){
2284             if(code) PrintError("",code);
2285             else fprintf(STDERR,"vos : partition %s does not exist on the server\n",as->parms[1].items->data);
2286             exit(1);
2287         }
2288 */
2289         code = UV_RemoveSite(aserver, apart, avolid);
2290         if (code) {
2291             PrintDiagnostics("remsite", code);
2292             exit(1);
2293         }
2294         MapPartIdIntoName(apart,apartName);
2295         fprintf(STDOUT,"Removed replication site %s %s for volume %s\n",as->parms[0].items->data,apartName,as->parms[2].items->data);
2296     return 0;
2297 }
2298 static ChangeLocation(as)
2299 register struct cmd_syndesc *as;
2300 {
2301    afs_int32 avolid, aserver, apart,code, err;
2302    char apartName[10];
2303
2304         avolid = vsu_GetVolumeID(as->parms[2].items->data, cstruct, &err);
2305         if (avolid == 0) {
2306             if (err) PrintError("", err);
2307             else fprintf(STDERR, "vos: can't find volume '%s'\n", as->parms[2].items->data);
2308             exit(1);
2309         }
2310         aserver = GetServer(as->parms[0].items->data);
2311         if (aserver == 0) {
2312             fprintf(STDERR,"vos: server '%s' not found in host table\n", as->parms[0].items->data);
2313             exit(1);
2314         }
2315         apart = volutil_GetPartitionID(as->parms[1].items->data);
2316         if (apart < 0) {
2317             fprintf(STDERR,"vos: could not interpret partition name '%s'\n",as->parms[1].items->data );
2318             exit(1);
2319         }
2320         if (!IsPartValid(apart,aserver,&code)){/*check for validity of the partition */
2321             if(code) PrintError("",code);
2322             else fprintf(STDERR,"vos : partition %s does not exist on the server\n",as->parms[1].items->data);
2323             exit(1);
2324         }
2325         code = UV_ChangeLocation(aserver, apart, avolid);
2326         if (code) {
2327             PrintDiagnostics("addsite", code);
2328             exit(1);
2329         }
2330         MapPartIdIntoName(apart,apartName);
2331         fprintf(STDOUT,"Changed location to %s %s for volume %s\n",as->parms[0].items->data, apartName,as->parms[2].items->data);
2332    return 0;
2333 }
2334
2335 static ListPartitions(as)
2336 register struct cmd_syndesc *as;
2337 {
2338     afs_int32 aserver,code;
2339     struct partList dummyPartList;
2340     int i;
2341     char pname[10];
2342     int total, cnt;
2343
2344     aserver = GetServer(as->parms[0].items->data);
2345     if (aserver == 0) {
2346         fprintf(STDERR,"vos: server '%s' not found in host table\n", as->parms[0].items->data);
2347         exit(1);
2348     }
2349
2350
2351     code = UV_ListPartitions(aserver,&dummyPartList, &cnt);
2352     if (code) {
2353         PrintDiagnostics("listpart", code);
2354         exit(1);
2355     }
2356     total = 0;
2357     fprintf(STDOUT,"The partitions on the server are:\n");
2358     for(i = 0 ; i < cnt ; i++){
2359         if(dummyPartList.partFlags[i] & PARTVALID){
2360             memset(pname, 0, sizeof(pname));
2361             MapPartIdIntoName(dummyPartList.partId[i],pname);
2362             fprintf(STDOUT," %10s ",pname);
2363             total++;
2364             if( (i % 5) == 0 && (i != 0)) fprintf(STDOUT,"\n");
2365         }
2366     }
2367     fprintf(STDOUT,"\n");
2368     fprintf(STDOUT,"Total: %d\n",total);
2369     return 0;
2370         
2371 }
2372
2373 static int CompareVolName(p1,p2)
2374 char *p1,*p2;
2375 {
2376     volintInfo *arg1,*arg2;
2377
2378     arg1 = (volintInfo *)p1;
2379     arg2 = (volintInfo *)p2;
2380     return(strcmp(arg1->name,arg2->name));
2381     
2382 }
2383
2384 /*------------------------------------------------------------------------
2385  * PRIVATE XCompareVolName
2386  *
2387  * Description:
2388  *      Comparison routine for volume names coming from an extended
2389  *      volume listing.
2390  *
2391  * Arguments:
2392  *      a_obj1P : Char ptr to first extended vol info object
2393  *      a_obj1P : Char ptr to second extended vol info object
2394  *
2395  * Returns:
2396  *      The value of strcmp() on the volume names within the passed
2397  *      objects (i,e., -1, 0, or 1).
2398  *
2399  * Environment:
2400  *      Passed to qsort() as the designated comparison routine.
2401  *
2402  * Side Effects:
2403  *      As advertised.
2404  *------------------------------------------------------------------------*/
2405
2406 static int XCompareVolName(a_obj1P, a_obj2P)
2407     char *a_obj1P, *a_obj2P;
2408
2409 { /*XCompareVolName*/
2410
2411     return(strcmp(((struct volintXInfo *)(a_obj1P))->name,
2412                   ((struct volintXInfo *)(a_obj2P))->name));
2413
2414 } /*XCompareVolName*/
2415
2416 static int CompareVolID(p1,p2)
2417 char *p1,*p2;
2418 {
2419     volintInfo *arg1,*arg2;
2420
2421     arg1 = (volintInfo *)p1;
2422     arg2 = (volintInfo *)p2;
2423     if(arg1->volid == arg2->volid) return 0;
2424     if(arg1->volid > arg2->volid) return 1;
2425     else return -1;
2426     
2427 }
2428
2429 /*------------------------------------------------------------------------
2430  * PRIVATE XCompareVolID
2431  *
2432  * Description:
2433  *      Comparison routine for volume IDs coming from an extended
2434  *      volume listing.
2435  *
2436  * Arguments:
2437  *      a_obj1P : Char ptr to first extended vol info object
2438  *      a_obj1P : Char ptr to second extended vol info object
2439  *
2440  * Returns:
2441  *      The value of strcmp() on the volume names within the passed
2442  *      objects (i,e., -1, 0, or 1).
2443  *
2444  * Environment:
2445  *      Passed to qsort() as the designated comparison routine.
2446  *
2447  * Side Effects:
2448  *      As advertised.
2449  *------------------------------------------------------------------------*/
2450
2451 static int XCompareVolID(a_obj1P, a_obj2P)
2452     char *a_obj1P, *a_obj2P;
2453
2454 { /*XCompareVolID*/
2455
2456     afs_int32 id1, id2; /*Volume IDs we're comparing*/
2457
2458     id1 = ((struct volintXInfo *)(a_obj1P))->volid;
2459     id2 = ((struct volintXInfo *)(a_obj2P))->volid;
2460     if (id1 == id2)
2461         return(0);
2462     else
2463         if (id1 > id2)
2464             return(1);
2465     else
2466        return(-1);
2467
2468 } /*XCompareVolID*/
2469
2470 /*------------------------------------------------------------------------
2471  * PRIVATE ListVolumes
2472  *
2473  * Description:
2474  *      Routine used to list volumes, contacting the Volume Server
2475  *      directly, bypassing the VLDB.
2476  *
2477  * Arguments:
2478  *      as : Ptr to parsed command line arguments.
2479  *
2480  * Returns:
2481  *      0                       Successful operation
2482  *
2483  * Environment:
2484  *      Nothing interesting.
2485  *
2486  * Side Effects:
2487  *      As advertised.
2488  *------------------------------------------------------------------------*/
2489
2490 static ListVolumes(as)
2491 register struct cmd_syndesc *as;
2492 {  
2493     afs_int32 apart,int32list,fast;
2494     afs_int32 aserver,code;
2495     volintInfo *pntr,*oldpntr;
2496     afs_int32 count;
2497     int i;
2498     char *base;
2499     volintXInfo *xInfoP, *origxInfoP;   /*Ptr to current/orig extended vol info*/
2500     int wantExtendedInfo;               /*Do we want extended vol info?*/
2501
2502     char pname[10];
2503     struct partList dummyPartList;
2504     int all;
2505     int quiet, cnt;
2506
2507     apart = -1;
2508     fast = 0;
2509     int32list = 0;
2510
2511     if(as->parms[3].items) int32list = 1;
2512     if(as->parms[4].items) quiet = 1;
2513     else quiet = 0;
2514     if(as->parms[2].items) fast = 1;
2515     if(fast) all = 0;
2516     else all = 1;
2517     if (as->parms[5].items) {
2518         /*
2519          * We can't coexist with the fast flag.
2520          */
2521         if (fast) {
2522             fprintf(STDERR,
2523                     "vos: Can't use the -fast and -extended flags together\n");
2524             exit(1);
2525         }
2526
2527         /*
2528          * We need to turn on ``long'' listings to get the full effect.
2529          */
2530         wantExtendedInfo = 1;
2531         int32list = 1;
2532     }
2533     else
2534         wantExtendedInfo = 0;
2535     if(as->parms[1].items){
2536         apart = volutil_GetPartitionID(as->parms[1].items->data);
2537         if (apart < 0) {
2538             fprintf(STDERR,"vos: could not interpret partition name '%s'\n", as->parms[1].items->data);
2539             exit(1);
2540         }
2541         dummyPartList.partId[0] = apart;
2542         dummyPartList.partFlags[0] = PARTVALID;
2543         cnt = 1;
2544     }
2545     aserver = GetServer(as->parms[0].items->data);
2546     if (aserver == 0) {
2547         fprintf(STDERR,"vos: server '%s' not found in host table\n",as->parms[0].items->data );
2548         exit(1);
2549     }
2550
2551     if(apart != -1) {
2552         if (!IsPartValid(apart,aserver,&code)){/*check for validity of the partition */
2553             if(code) PrintError("",code);
2554             else fprintf(STDERR,"vos : partition %s does not exist on the server\n",as->parms[1].items->data);
2555             exit(1);
2556         }
2557     }
2558     else {
2559         code = UV_ListPartitions(aserver,&dummyPartList, &cnt);
2560         if (code) {
2561             PrintDiagnostics("listvol", code);
2562             exit(1);
2563         }
2564     }
2565     for(i = 0 ; i < cnt ; i++){
2566         if(dummyPartList.partFlags[i] & PARTVALID){
2567             if (wantExtendedInfo)
2568                 code = UV_XListVolumes(aserver,
2569                                        dummyPartList.partId[i],
2570                                        all,
2571                                        &xInfoP,
2572                                        &count);
2573             else
2574                 code = UV_ListVolumes(aserver,
2575                                       dummyPartList.partId[i],
2576                                       all,
2577                                       &pntr,
2578                                       &count);
2579             if (code) {
2580                 PrintDiagnostics("listvol", code);
2581                 if(pntr) free(pntr);
2582                 exit(1);
2583             }
2584             if (wantExtendedInfo) {
2585                 origxInfoP = xInfoP;
2586                 base = (char *)xInfoP;
2587             } else {
2588                 oldpntr = pntr;
2589                 base = (char *)pntr;
2590             }
2591
2592             if(!fast) {
2593                 if (wantExtendedInfo) 
2594                     qsort(base, count, sizeof(volintXInfo), XCompareVolName);
2595                 else
2596                     qsort(base, count, sizeof(volintInfo), CompareVolName);
2597             } else {
2598                 if (wantExtendedInfo) 
2599                     qsort(base, count, sizeof(volintXInfo), XCompareVolID);
2600                 else
2601                     qsort(base, count, sizeof(volintInfo), CompareVolID);
2602             }
2603             MapPartIdIntoName(dummyPartList.partId[i],pname);
2604             if(!quiet)
2605                 fprintf(STDOUT,"Total number of volumes on server %s partition %s: %u \n",as->parms[0].items->data,pname,count);
2606             if (wantExtendedInfo) {
2607                 XDisplayVolumes(aserver,
2608                                 dummyPartList.partId[i],
2609                                 origxInfoP,
2610                                 count,
2611                                 int32list,
2612                                 fast,
2613                                 quiet);
2614                 if(xInfoP)
2615                     free(xInfoP);
2616                 xInfoP = (volintXInfo *)0;
2617             }
2618             else {
2619 #ifdef FULL_LISTVOL_SWITCH
2620               if (as->parms[6].items)
2621                 DisplayVolumes2(aserver, dummyPartList.partId[i], oldpntr, 
2622                                 count);
2623               else
2624 #endif /* FULL_LISTVOL_SWITCH */
2625                 DisplayVolumes(aserver,
2626                                dummyPartList.partId[i],
2627                                oldpntr,
2628                                count,
2629                                int32list,
2630                                fast,
2631                                quiet);
2632                 if (pntr)
2633                     free(pntr);
2634                 pntr = (volintInfo *)0;
2635             }
2636         }
2637     }
2638     return 0;
2639 }
2640
2641 static SyncVldb(as)
2642   register struct cmd_syndesc *as;
2643 {
2644   afs_int32 pname, code;        /* part name */
2645   char part[10];
2646   int flags = 0;
2647   char *volname = 0;
2648
2649   tserver = 0;
2650   if (as->parms[0].items) {
2651      tserver = GetServer(as->parms[0].items->data);
2652      if (!tserver) {
2653         fprintf(STDERR,"vos: host '%s' not found in host table\n",as->parms[0].items->data );
2654         exit(1);
2655      }
2656   }
2657
2658   if (as->parms[1].items) {
2659      pname = volutil_GetPartitionID(as->parms[1].items->data);
2660      if (pname < 0) {
2661         fprintf(STDERR,"vos: could not interpret partition name '%s'\n",as->parms[1].items->data );
2662         exit(1);
2663      }
2664      if (!IsPartValid(pname,tserver,&code)) { /*check for validity of the partition */
2665         if(code) PrintError("",code);
2666         else fprintf(STDERR,"vos: partition %s does not exist on the server\n",
2667                      as->parms[1].items->data);
2668         exit(1);
2669      }
2670      flags = 1;
2671      
2672      if (!tserver) {
2673         fprintf(STDERR,"The -partition option requires a -server option\n");
2674         exit(1);
2675      }
2676   }
2677
2678   if (as->parms[2].items) {
2679      /* Synchronize an individual volume */
2680      volname = as->parms[2].items->data;
2681      code = UV_SyncVolume(tserver, pname, volname, flags);
2682   } else {
2683      if (!tserver) {
2684         fprintf(STDERR,"Without a -volume option, the -server option is required\n");
2685         exit(1);
2686      }
2687      code = UV_SyncVldb(tserver, pname, flags, 0/*unused*/);
2688   }
2689
2690   if (code) {
2691      PrintDiagnostics("syncvldb", code);
2692      exit(1);
2693   }
2694
2695   /* Print a summary of what we did */
2696   if (volname) fprintf(STDOUT,"VLDB volume %s synchronized", volname);
2697   else         fprintf(STDOUT,"VLDB synchronized");
2698   if (tserver) {
2699      fprintf(STDOUT," with state of server %s", as->parms[0].items->data);
2700   }
2701   if (flags) {
2702      MapPartIdIntoName(pname,part);
2703      fprintf(STDOUT," partition %s\n", part);
2704   }
2705   fprintf(STDOUT, "\n");
2706
2707   return 0;
2708 }
2709     
2710 static SyncServer(as)
2711 register struct cmd_syndesc *as;
2712
2713 {
2714     afs_int32 pname,code;       /* part name */
2715     char part[10];
2716         
2717         int flags = 0;
2718
2719         tserver = GetServer(as->parms[0].items->data);
2720         if (!tserver) {
2721             fprintf(STDERR,"vos: host '%s' not found in host table\n",as->parms[0].items->data );
2722             exit(1);
2723         }
2724         if(as->parms[1].items){
2725             pname = volutil_GetPartitionID(as->parms[1].items->data);
2726             if (pname < 0) {
2727                 fprintf(STDERR,"vos: could not interpret partition name '%s'\n",as->parms[1].items->data);
2728                 exit(1);
2729             }
2730             if (!IsPartValid(pname,tserver,&code)){/*check for validity of the partition */
2731                 if(code) PrintError("",code);
2732                 else fprintf(STDERR,"vos : partition %s does not exist on the server\n",as->parms[1].items->data);
2733                 exit(1);
2734             }
2735             flags = 1;
2736         }
2737         
2738         code = UV_SyncServer(tserver, pname, flags, 0/*unused*/);
2739         if (code) {
2740             PrintDiagnostics("syncserv", code);
2741             exit(1);
2742         }
2743         if(flags){
2744             MapPartIdIntoName(pname,part);
2745             fprintf(STDOUT,"Server %s partition %s synchronized with VLDB\n",as->parms[0].items->data,part);
2746         }
2747         else fprintf(STDOUT,"Server %s synchronized with VLDB\n",as->parms[0].items->data);
2748     return 0;
2749         
2750 }
2751
2752 static VolumeInfoCmd(name)
2753 char *name;
2754 {  
2755     struct nvldbentry entry;
2756     afs_int32 vcode;
2757
2758     /* The vlserver will handle names with the .readonly
2759      * and .backup extension as well as volume ids.
2760      */
2761     vcode = VLDB_GetEntryByName(name, &entry);
2762     if (vcode) {
2763         PrintError("", vcode);
2764         exit(1);
2765     }
2766     MapHostToNetwork(&entry);
2767     EnumerateEntry(&entry);
2768
2769     /* Defect #3027: grubby check to handle locked volume.
2770      * If VLOP_ALLOPERS is set, the entry is locked.
2771      * Leave this routine as is, but put in correct check.
2772      */
2773     if (entry.flags & VLOP_ALLOPERS)
2774         fprintf(STDOUT,"    Volume is currently LOCKED  \n");
2775
2776     return 0;
2777 }
2778
2779 static VolumeZap(as)
2780 register struct cmd_syndesc *as;
2781
2782 {
2783     struct nvldbentry entry;
2784     afs_int32 volid,code,server,part, zapbackupid=0, backupid=0, err;
2785     
2786     if (as->parms[3].items) {
2787         /* force flag is on, use the other version */
2788         return NukeVolume(as);
2789     }
2790
2791     if (as->parms[4].items) {
2792         zapbackupid = 1;
2793     }
2794
2795     volid = vsu_GetVolumeID(as->parms[2].items->data, cstruct, &err);
2796     if(volid == 0) {
2797         if (err) PrintError("", err);
2798         else fprintf(STDERR, "vos: can't find volume '%s'\n", as->parms[2].items->data);
2799         exit(1);
2800     }
2801     part = volutil_GetPartitionID(as->parms[1].items->data);
2802     if (part < 0) {
2803         fprintf(STDERR,"vos: could not interpret partition name '%s'\n",as->parms[1].items->data );
2804         exit(1);
2805     }
2806     server = GetServer(as->parms[0].items->data);
2807     if (!server) {
2808             fprintf(STDERR,"vos: host '%s' not found in host table\n",as->parms[0].items->data );
2809             exit(1);
2810     }
2811     if (!IsPartValid(part,server,&code)){/*check for validity of the partition */
2812             if(code) PrintError("",code);
2813             else fprintf(STDERR,"vos : partition %s does not exist on the server\n",as->parms[1].items->data);
2814             exit(1);
2815         }
2816     code = VLDB_GetEntryByID(volid,-1, &entry);
2817     if (!code) {
2818         if (volid == entry.volumeId[RWVOL])
2819             backupid = entry.volumeId[BACKVOL];
2820         fprintf(STDERR,"Warning: Entry for volume number %u exists in VLDB (but we're zapping it anyway!)\n",
2821                 volid);
2822     }
2823     if (zapbackupid) {
2824         volintInfo *pntr = (volintInfo *)0;
2825
2826         if (!backupid) {
2827             code = UV_ListOneVolume(server, part, volid, &pntr);
2828             if (!code) {
2829                 if (volid == pntr->parentID)
2830                     backupid = pntr->backupID;
2831                 if (pntr) free(pntr);
2832             }
2833         }
2834         if (backupid) {
2835             code = UV_VolumeZap(server,part, backupid);
2836             if (code) {
2837                 PrintDiagnostics("zap", code);
2838                 exit(1);
2839             }
2840             fprintf(STDOUT,"Backup Volume %u deleted\n", backupid);
2841         }
2842     }
2843     code = UV_VolumeZap(server,part,volid);
2844     if (code) {
2845         PrintDiagnostics("zap", code);
2846         exit(1);
2847     }
2848     fprintf(STDOUT,"Volume %u deleted\n",volid);
2849
2850     return 0;
2851 }
2852    
2853 static VolserStatus(as)
2854 register struct cmd_syndesc *as;
2855
2856 {   
2857     afs_int32 server, code;
2858     transDebugInfo *pntr,*oldpntr;
2859     afs_int32 count;
2860     int i;
2861     char pname[10];
2862
2863     server = GetServer(as->parms[0].items->data);
2864     if (!server) {
2865             fprintf(STDERR,"vos: host '%s' not found in host table\n",as->parms[0].items->data );
2866             exit(1);
2867     }
2868     code = UV_VolserStatus(server,&pntr,&count);
2869     if(code) {
2870         PrintDiagnostics("status",code);
2871         exit(1);
2872     }
2873     oldpntr = pntr;
2874     if(count == 0) 
2875         fprintf(STDOUT,"No active transactions on %s\n",as->parms[0].items->data);
2876     else {
2877         fprintf(STDOUT,"Total transactions: %d\n",count);
2878     }
2879     for(i = 0; i < count ; i++){
2880         /*print out the relevant info */
2881         fprintf(STDOUT,"--------------------------------------\n");
2882         fprintf(STDOUT,"transaction: %u  created: %s",pntr->tid,
2883                 ctime((time_t *)&pntr->time));
2884         if(pntr->returnCode){
2885             fprintf(STDOUT,"returnCode: %u\n",pntr->returnCode);
2886         }
2887         if(pntr->iflags){
2888             fprintf(STDOUT,"attachFlags:  ");
2889             switch(pntr->iflags){
2890               case ITOffline: fprintf(STDOUT,"offline ");
2891                 break;
2892               case ITBusy: fprintf(STDOUT,"busy ");
2893                 break;
2894               case ITReadOnly: fprintf(STDOUT,"readonly ");
2895                 break;
2896               case ITCreate: fprintf(STDOUT,"create ");
2897                 break;
2898               case ITCreateVolID: fprintf(STDOUT,"create volid ");
2899                 break;
2900             }
2901             fprintf(STDOUT,"\n");
2902         }
2903         if(pntr->vflags){
2904             fprintf(STDOUT,"volumeStatus: ");
2905             switch(pntr->vflags){
2906               case VTDeleteOnSalvage: fprintf(STDOUT,"deleteOnSalvage ");
2907               case VTOutOfService: fprintf(STDOUT,"outOfService ");
2908               case VTDeleted: fprintf(STDOUT,"deleted ");
2909             }
2910             fprintf(STDOUT,"\n");
2911         }
2912         if(pntr->tflags){
2913             fprintf(STDOUT,"transactionFlags: ");
2914             fprintf(STDOUT,"delete\n");
2915         }
2916         MapPartIdIntoName(pntr->partition ,pname);
2917         fprintf(STDOUT,"volume: %u  partition: %s  procedure: %s\n",pntr->volid,pname, pntr->lastProcName);
2918         if(pntr->callValid){
2919             fprintf(STDOUT,"packetRead: %u  lastReceiveTime: %d  packetSend: %u  lastSendTime: %d\n",pntr->readNext,pntr->lastReceiveTime,pntr->transmitNext, pntr->lastSendTime);
2920         }
2921         pntr++;
2922         fprintf(STDOUT,"--------------------------------------\n");
2923         fprintf(STDOUT,"\n");
2924     }
2925     if(oldpntr) free(oldpntr);
2926     return 0;
2927 }
2928  
2929 static RenameVolume(as)
2930 register struct cmd_syndesc *as;
2931 {
2932    afs_int32 code1,code2,code;
2933    struct nvldbentry entry;
2934
2935         code1 = VLDB_GetEntryByName(as->parms[0].items->data, &entry);
2936         if(code1){
2937             fprintf(STDERR,"vos: Could not find entry for volume %s\n",as->parms[0].items->data);
2938             exit(1);
2939         }
2940         code2 = VLDB_GetEntryByName(as->parms[1].items->data, &entry);
2941         if((!code1) && (!code2)) { /*the newname already exists */
2942             fprintf(STDERR,"vos: volume %s already exists\n",as->parms[1].items->data);
2943             exit(1);
2944         }
2945
2946         if(code1 && code2){
2947             fprintf(STDERR,"vos: Could not find entry for volume %s or %s\n",as->parms[0].items->data,as->parms[1].items->data);
2948             exit(1);
2949         }
2950     if(!VolNameOK(as->parms[0].items->data)){
2951         fprintf(STDERR,"Illegal volume name %s, should not end in .readonly or .backup\n",as->parms[0].items->data);
2952         exit(1);
2953     }
2954    if(!ISNAMEVALID(as->parms[1].items->data)) {
2955         fprintf(STDERR,"vos: the new volume name %s exceeds the size limit of %d\n",as->parms[1].items->data,VOLSER_OLDMAXVOLNAME - 10);
2956         exit(1);
2957     }
2958     if(!VolNameOK(as->parms[1].items->data)){
2959         fprintf(STDERR,"Illegal volume name %s, should not end in .readonly or .backup\n",as->parms[1].items->data);
2960         exit(1);
2961     }
2962     if(IsNumeric(as->parms[1].items->data)){
2963         fprintf(STDERR,"Illegal volume name %s, should not be a number\n",as->parms[1].items->data);
2964         exit(1);
2965     }
2966         MapHostToNetwork(&entry);
2967         code = UV_RenameVolume(&entry,as->parms[0].items->data,as->parms[1].items->data);
2968         if (code) {
2969             PrintDiagnostics("rename", code);
2970             exit(1);
2971         }
2972         fprintf(STDOUT,"Renamed volume %s to %s\n",as->parms[0].items->data,as->parms[1].items->data); 
2973    return 0;
2974 }
2975
2976 GetVolumeInfo(volid, server, part, voltype,rentry)
2977 afs_int32 *server, volid, *part, *voltype;
2978 register struct nvldbentry *rentry;
2979 {
2980     afs_int32 vcode;
2981     int i,index = -1;
2982
2983     vcode = VLDB_GetEntryByID(volid, -1, rentry);
2984     if(vcode) {
2985                 fprintf(STDERR,"Could not fetch the entry for volume %u from VLDB \n",volid);
2986                 PrintError("",vcode);
2987                 return (vcode);
2988     }
2989     MapHostToNetwork(rentry);
2990     if(volid == rentry->volumeId[ROVOL]){
2991         *voltype = ROVOL;
2992         for (i = 0; i < rentry->nServers; i++) {
2993             if ( (index == -1) && (rentry->serverFlags[i] & ITSROVOL) &&
2994                 !(rentry->serverFlags[i] & RO_DONTUSE) )
2995                 index = i;
2996         }
2997         if(index == -1) {
2998             fprintf(STDERR,"RO volume is not found in VLDB entry for volume %u\n", volid);
2999             return -1;
3000         }
3001
3002         *server = rentry->serverNumber[index];
3003         *part = rentry->serverPartition[index];
3004         return 0;
3005     }
3006                 
3007     index = Lp_GetRwIndex(rentry);
3008     if(index == -1) {
3009         fprintf(STDERR,"RW Volume is not found in VLDB entry for volume %u\n", volid);
3010         return -1;
3011     }
3012     if(volid == rentry->volumeId[RWVOL]){
3013         *voltype = RWVOL;
3014         *server = rentry->serverNumber[index];
3015         *part = rentry->serverPartition[index];
3016         return 0;
3017     }
3018     if(volid == rentry->volumeId[BACKVOL]){
3019         *voltype = BACKVOL;
3020         *server = rentry->serverNumber[index];
3021         *part = rentry->serverPartition[index];
3022         return 0;
3023     }
3024 }
3025
3026 static DeleteEntry(as)
3027 register struct cmd_syndesc *as;
3028
3029 {
3030     afs_int32 apart;
3031     afs_int32 avolid;
3032     afs_int32 vcode;
3033     struct VldbListByAttributes attributes;
3034     nbulkentries arrayEntries;
3035     register struct nvldbentry *vllist;
3036     struct cmd_item *itp;
3037     afs_int32 nentries;
3038     int j;
3039     char prefix[VOLSER_MAXVOLNAME+1];
3040     int seenprefix=0;
3041     afs_int32 totalBack=0, totalFail=0, err;
3042
3043     if (as->parms[0].items) { /* -id */
3044        if (as->parms[1].items || as->parms[2].items || as->parms[3].items) {
3045           fprintf(STDERR,"You cannot use -server, -partition, or -prefix with the -id argument\n");
3046           exit(-2);
3047        }
3048        for (itp=as->parms[0].items; itp; itp=itp->next) {
3049           avolid = vsu_GetVolumeID(itp->data, cstruct, &err);
3050           if (avolid == 0) {
3051              if (err) PrintError("", err);
3052              else fprintf(STDERR, "vos: can't find volume '%s'\n", itp->data);
3053              continue;
3054           }
3055           if (as->parms[4].items) { /* -noexecute */
3056              fprintf(STDOUT,"Would have deleted VLDB entry for %s \n", itp->data);
3057              fflush(STDOUT);
3058              continue;
3059           }
3060           vcode = ubik_Call(VL_DeleteEntry,cstruct, 0, avolid, RWVOL);
3061           if (vcode) {
3062              fprintf(STDERR,"Could not delete entry for volume %s\n", itp->data);
3063              fprintf(STDERR,"You must specify a RW volume name or ID "
3064                             "(the entire VLDB entry will be deleted)\n", itp->data);
3065              PrintError("",vcode);
3066              totalFail++;
3067              continue;
3068           }
3069           totalBack++;
3070        }
3071        fprintf(STDOUT,"Deleted %d VLDB entries\n", totalBack);
3072        return(totalFail);
3073     }
3074
3075     if (!as->parms[1].items && !as->parms[2].items && !as->parms[3].items) {
3076        fprintf(STDERR,"You must specify an option\n");
3077        exit(-2);
3078     }
3079
3080     /* Zero out search attributes */
3081     memset(&attributes, 0, sizeof(struct VldbListByAttributes));
3082
3083     if (as->parms[1].items) { /* -prefix */
3084        strncpy(prefix, as->parms[1].items->data, VOLSER_MAXVOLNAME);
3085        seenprefix = 1;
3086        if (!as->parms[2].items && !as->parms[3].items) { /* a single entry only */
3087           fprintf(STDERR,"You must provide -server with the -prefix argument\n");
3088           exit(-2);
3089        }
3090     }
3091
3092     if (as->parms[2].items) { /* -server */
3093        afs_int32 aserver;
3094        aserver = GetServer(as->parms[2].items->data);
3095        if (aserver == 0) {
3096           fprintf(STDERR,"vos: server '%s' not found in host table\n",as->parms[2].items->data );
3097           exit(-1);
3098        }
3099        attributes.server = ntohl(aserver);
3100        attributes.Mask |= VLLIST_SERVER;
3101     }
3102     
3103     if (as->parms[3].items) { /* -partition */
3104        if (!as->parms[2].items) {
3105           fprintf(STDERR,"You must provide -server with the -partition argument\n");
3106           exit(-2);
3107        }
3108        apart = volutil_GetPartitionID(as->parms[3].items->data);
3109        if (apart < 0) {
3110           fprintf(STDERR,"vos: could not interpret partition name '%s'\n",
3111                   as->parms[3].items->data);
3112           exit(-1);
3113         }
3114        attributes.partition = apart;
3115        attributes.Mask |= VLLIST_PARTITION;
3116     }
3117
3118     /* Print status line of what we are doing */
3119     fprintf(STDOUT,"Deleting VLDB entries for ");
3120     if (as->parms[2].items) {
3121        fprintf(STDOUT,"server %s ", as->parms[2].items->data);
3122     }
3123     if (as->parms[3].items) {
3124        char pname[10];
3125        MapPartIdIntoName(apart, pname);
3126        fprintf(STDOUT,"partition %s ", pname);
3127     }
3128     if (seenprefix) {
3129        fprintf(STDOUT,"which are prefixed with %s ", prefix);
3130     }
3131     fprintf(STDOUT,"\n");
3132     fflush(STDOUT);
3133
3134     /* Get all the VLDB entries on a server and/or partition */
3135     memset(&arrayEntries, 0, sizeof(arrayEntries));
3136     vcode = VLDB_ListAttributes(&attributes, &nentries, &arrayEntries);
3137     if (vcode) {
3138        fprintf(STDERR,"Could not access the VLDB for attributes\n");
3139        PrintError("",vcode);
3140        exit(-1);
3141     }
3142
3143     /* Process each entry */
3144     for (j=0; j<nentries; j++) {
3145        vllist = &arrayEntries.nbulkentries_val[j];
3146        if (seenprefix) {
3147           /* It only deletes the RW volumes */
3148           if (strncmp(vllist->name, prefix, strlen(prefix))){
3149              if (verbose) {
3150                 fprintf(STDOUT,"Omitting to delete %s due to prefix %s mismatch\n",
3151                         vllist->name, prefix);
3152              }
3153              fflush(STDOUT);
3154              continue;
3155           }
3156        }
3157                 
3158        if (as->parms[4].items) { /* -noexecute */
3159           fprintf(STDOUT,"Would have deleted VLDB entry for %s \n", vllist->name);
3160           fflush(STDOUT);
3161           continue;
3162        }
3163
3164        /* Only matches the RW volume name */
3165        avolid = vllist->volumeId[RWVOL];
3166        vcode = ubik_Call(VL_DeleteEntry, cstruct, 0, avolid, RWVOL);
3167        if (vcode){
3168           fprintf(STDOUT,"Could not delete VDLB entry for  %s\n",vllist->name);
3169           totalFail++;
3170           PrintError("",vcode);
3171           continue;
3172        } else {
3173           totalBack++;
3174           if (verbose)
3175              fprintf(STDOUT,"Deleted VLDB entry for %s \n",vllist->name);
3176        }
3177        fflush(STDOUT);
3178     } /*for*/
3179
3180     fprintf(STDOUT,"----------------------\n");
3181     fprintf(STDOUT,"Total VLDB entries deleted: %u; failed to delete: %u\n",totalBack,totalFail);
3182     if (arrayEntries.nbulkentries_val) free(arrayEntries.nbulkentries_val);
3183     return 0;
3184 }
3185
3186
3187 static int CompareVldbEntryByName(p1,p2)
3188 char *p1,*p2;
3189 {
3190     struct nvldbentry *arg1,*arg2;
3191
3192     arg1 = (struct nvldbentry *)p1;
3193     arg2 = (struct nvldbentry *)p2;
3194     return(strcmp(arg1->name,arg2->name));
3195 }
3196
3197 /*
3198 static int CompareVldbEntry(p1,p2)
3199 char *p1,*p2;
3200 {
3201     struct nvldbentry *arg1,*arg2;
3202     int i;
3203     int pos1, pos2;
3204     char comp1[100],comp2[100];
3205     char temp1[20],temp2[20];
3206
3207     arg1 = (struct nvldbentry *)p1;
3208     arg2 = (struct nvldbentry *)p2;
3209     pos1 = -1;
3210     pos2 = -1;
3211
3212     for(i = 0; i < arg1->nServers; i++)
3213         if(arg1->serverFlags[i] & ITSRWVOL) pos1 = i;
3214     for(i = 0; i < arg2->nServers; i++)
3215         if(arg2->serverFlags[i] & ITSRWVOL) pos2 = i;
3216     if(pos1 == -1 || pos2 == -1){
3217         pos1 = 0;
3218         pos2 = 0;
3219     }
3220     sprintf(comp1,"%10u",arg1->serverNumber[pos1]);
3221     sprintf(comp2,"%10u",arg2->serverNumber[pos2]);
3222     sprintf(temp1,"%10u",arg1->serverPartition[pos1]);
3223     sprintf(temp2,"%10u",arg2->serverPartition[pos2]);
3224     strcat(comp1,temp1);
3225     strcat(comp2,temp2);
3226     strcat(comp1,arg1->name);
3227     strcat(comp1,arg2->name);
3228     return(strcmp(comp1,comp2));
3229
3230 }
3231
3232 */      
3233 static ListVLDB(as)
3234     struct cmd_syndesc *as;
3235 {   
3236     afs_int32 apart;
3237     afs_int32 aserver,code;
3238     afs_int32 vcode;
3239     struct VldbListByAttributes attributes;
3240     nbulkentries arrayEntries;
3241     struct nvldbentry *vllist, *tarray=0, *ttarray;
3242     afs_int32 centries, nentries = 0, tarraysize, parraysize;
3243     int j;
3244     char pname[10];
3245     int quiet, sort, lock;
3246     afs_int32 thisindex, nextindex;
3247
3248     aserver = 0;
3249     apart = 0;
3250
3251     attributes.Mask = 0;
3252     lock   = (as->parms[3].items ? 1 : 0);  /* -lock   flag */
3253     quiet  = (as->parms[4].items ? 1 : 0);  /* -quit   flag */
3254     sort   = (as->parms[5].items ? 0 : 1);  /* -nosort flag */
3255
3256     /* If the volume name is given, Use VolumeInfoCmd to look it up
3257      * and not ListAttributes.
3258      */
3259     if (as->parms[0].items) {
3260        if (lock) {
3261           fprintf(STDERR,"vos: illegal use of '-locked' switch, need to specify server and/or partition\n");
3262           exit(1);
3263        }
3264        code = VolumeInfoCmd(as->parms[0].items->data);
3265        if (code) {
3266           PrintError("",code);
3267           exit(1);
3268        }
3269        return 0;
3270     }
3271
3272     /* Server specified */
3273     if (as->parms[1].items) {
3274        aserver = GetServer(as->parms[1].items->data);
3275        if (aserver == 0) {
3276           fprintf(STDERR,"vos: server '%s' not found in host table\n",as->parms[1].items->data );
3277           exit(1);
3278        }
3279        attributes.server = ntohl(aserver);
3280        attributes.Mask |= VLLIST_SERVER;
3281     }
3282     
3283     /* Partition specified */
3284     if (as->parms[2].items) {
3285        apart = volutil_GetPartitionID(as->parms[2].items->data);
3286        if (apart < 0) {
3287           fprintf(STDERR,"vos: could not interpret partition name '%s'\n", as->parms[2].items->data);
3288           exit(1);
3289        }
3290        attributes.partition = apart;
3291        attributes.Mask |= VLLIST_PARTITION;
3292     }
3293
3294     if (lock) {
3295        attributes.Mask |= VLLIST_FLAG;
3296        attributes.flag =  VLOP_ALLOPERS;
3297     }
3298
3299     /* Print header information */
3300     if (!quiet) {
3301        MapPartIdIntoName(apart, pname);
3302        fprintf(STDOUT,"VLDB entries for %s %s%s%s %s\n",
3303                (as->parms[1].items ? "server"                 : "all"    ),
3304                (as->parms[1].items ? as->parms[1].items->data : "servers"),
3305                (as->parms[2].items ? " partition "            : ""),
3306                (as->parms[2].items ? pname                    : ""),
3307                (lock               ? "which are locked:"      : ""));
3308     }
3309
3310     for (thisindex = 0; (thisindex != -1); thisindex = nextindex) {
3311        memset(&arrayEntries, 0, sizeof(arrayEntries));
3312        centries = 0;
3313        nextindex = -1;
3314
3315        vcode = VLDB_ListAttributesN2(&attributes, 0, thisindex,
3316                                      &centries, &arrayEntries, &nextindex);
3317        if (vcode == RXGEN_OPCODE) {
3318           /* Vlserver not running with ListAttributesN2. Fall back */
3319           vcode = VLDB_ListAttributes(&attributes, &centries, &arrayEntries);
3320           nextindex = -1;
3321        }
3322        if (vcode) {
3323           fprintf(STDERR,"Could not access the VLDB for attributes\n");
3324           PrintError("",vcode);
3325           exit(1);
3326        }
3327        nentries += centries;
3328
3329        /* We don't sort, so just print the entries now */
3330        if (!sort) {
3331           for (j = 0; j < centries; j++) {                   /* process each entry */
3332              vllist = &arrayEntries.nbulkentries_val[j];
3333              MapHostToNetwork(vllist);
3334              EnumerateEntry(vllist);
3335
3336              if(vllist->flags & VLOP_ALLOPERS)
3337                 fprintf(STDOUT,"    Volume is currently LOCKED  \n");
3338           }
3339        } 
3340
3341        /* So we sort. First we must collect all the entries and keep
3342         * them in memory.
3343         */
3344        else if (centries > 0) {
3345           if (!tarray) {
3346              /* steal away the first bulk entries array */
3347              tarray = (struct nvldbentry *)arrayEntries.nbulkentries_val;
3348              tarraysize = centries * sizeof(struct nvldbentry);
3349              arrayEntries.nbulkentries_val = 0;
3350           } else {
3351              /* Grow the tarray to keep the extra entries */
3352              parraysize = (centries * sizeof(struct nvldbentry));
3353              ttarray = (struct nvldbentry *) realloc(tarray, tarraysize + parraysize);
3354              if (!ttarray) {
3355                 fprintf(STDERR,"Could not allocate enough space for  the VLDB entries\n");
3356                 goto bypass;
3357              }
3358              tarray = ttarray;
3359              
3360              /* Copy them in */
3361              memcpy(((char *)tarray)+tarraysize, (char *)arrayEntries.nbulkentries_val, parraysize);
3362              tarraysize += parraysize;
3363           }
3364        }
3365
3366        /* Free the bulk array */
3367        if (arrayEntries.nbulkentries_val) {
3368           free(arrayEntries.nbulkentries_val);
3369           arrayEntries.nbulkentries_val = 0;
3370        }
3371     }
3372
3373     /* Here is where we now sort all the entries and print them */
3374     if (sort && (nentries > 0)) {
3375        qsort((char *)tarray, nentries, sizeof(struct nvldbentry), CompareVldbEntryByName);
3376        for (vllist=tarray, j=0; j<nentries; j++, vllist++) {
3377           MapHostToNetwork(vllist);
3378           EnumerateEntry(vllist);
3379
3380           if(vllist->flags & VLOP_ALLOPERS)
3381              fprintf(STDOUT,"    Volume is currently LOCKED  \n");
3382        }
3383     }
3384
3385 bypass:
3386     if (!quiet) fprintf(STDOUT,"\nTotal entries: %u\n", nentries);
3387     if (tarray) free(tarray);
3388     return 0;
3389 }
3390
3391 static BackSys(as)
3392     register struct cmd_syndesc *as;
3393 {   
3394     afs_int32 apart=0, avolid;
3395     afs_int32 aserver=0, code, aserver1, apart1;
3396     afs_int32 vcode;
3397     struct VldbListByAttributes attributes;
3398     nbulkentries arrayEntries;
3399     register struct nvldbentry *vllist;
3400     afs_int32 nentries;
3401     int j;
3402     char pname[10];
3403     int seenprefix, seenxprefix, exclude, ex, exp, noaction;
3404     afs_int32 totalBack=0;
3405     afs_int32 totalFail=0;
3406     int previdx=-1, error, same;
3407     int comp=0;
3408     char compstr[50];
3409     struct cmd_item *ti;
3410     char *ccode;
3411     int match;
3412
3413     memset(&attributes, 0, sizeof(struct VldbListByAttributes));
3414     attributes.Mask = 0;
3415
3416     seenprefix  = (as->parms[0].items ? 1 : 0);
3417     exclude     = (as->parms[3].items ? 1 : 0);
3418     seenxprefix = (as->parms[4].items ? 1 : 0);
3419     noaction    = (as->parms[5].items ? 1 : 0);
3420
3421     if (as->parms[1].items) {                         /* -server */
3422         aserver = GetServer(as->parms[1].items->data);
3423         if (aserver == 0) {
3424             fprintf(STDERR,"vos: server '%s' not found in host table\n",as->parms[1].items->data );
3425             exit(1);
3426         }
3427         attributes.server  = ntohl(aserver);
3428         attributes.Mask   |= VLLIST_SERVER;
3429     }
3430
3431     if (as->parms[2].items) {                         /* -partition */
3432         apart = volutil_GetPartitionID(as->parms[2].items->data);
3433         if (apart < 0) {
3434             fprintf(STDERR,"vos: could not interpret partition name '%s'\n", as->parms[2].items->data);
3435             exit(1);
3436         }
3437         attributes.partition  = apart;
3438         attributes.Mask      |= VLLIST_PARTITION;
3439     }
3440
3441     /* Check to make sure the prefix and xprefix expressions compile ok */
3442     if (seenprefix) {
3443        for (ti=as->parms[0].items; ti; ti=ti->next) {
3444           if (strncmp(ti->data,"^",1) == 0) {
3445              ccode = (char *)re_comp(ti->data);
3446              if (ccode) {
3447                 fprintf(STDERR,"Unrecognizable -prefix regular expression: '%s': %s\n",
3448                         ti->data, ccode);
3449                 exit(1);        
3450              }
3451           }
3452        }
3453     }
3454     if (seenxprefix) {
3455        for (ti=as->parms[4].items; ti; ti=ti->next) {
3456           if (strncmp(ti->data,"^",1) == 0) {
3457              ccode = (char *)re_comp(ti->data);
3458              if (ccode) {
3459                 fprintf(STDERR,"Unrecognizable -xprefix regular expression: '%s': %s\n",
3460                         ti->data, ccode);
3461                 exit(1);        
3462              }
3463           }
3464        }
3465     }
3466
3467     memset(&arrayEntries, 0, sizeof(arrayEntries)); /* initialize to hint the stub to alloc space */
3468     vcode = VLDB_ListAttributes(&attributes, &nentries, &arrayEntries);
3469     if (vcode) {
3470         fprintf(STDERR,"Could not access the VLDB for attributes\n");
3471         PrintError("",vcode);
3472         exit(1);
3473     }
3474
3475     if (as->parms[1].items || as->parms[2].items || verbose) {
3476         fprintf(STDOUT,"%s up volumes", (noaction?"Would have backed":"Backing"));
3477
3478         if (as->parms[1].items) {
3479             fprintf(STDOUT," on server %s", as->parms[1].items->data);
3480         } else if (as->parms[2].items) {
3481             fprintf(STDOUT," for all servers");
3482         }
3483
3484         if (as->parms[2].items) {
3485             MapPartIdIntoName(apart, pname);
3486             fprintf(STDOUT," partition %s", pname);
3487         }
3488
3489         if (seenprefix || (!seenprefix && seenxprefix)) {
3490             ti  = (seenprefix ? as->parms[0].items : as->parms[4].items);
3491             ex  = (seenprefix ? exclude : !exclude);
3492             exp = (strncmp(ti->data,"^",1) == 0);
3493             fprintf(STDOUT," which %smatch %s '%s'", (ex ? "do not " : ""),
3494                     (exp?"expression":"prefix"), ti->data);
3495             for (ti=ti->next; ti; ti=ti->next) {
3496                exp = (strncmp(ti->data,"^",1) == 0);
3497                printf(" %sor %s '%s'", (ex ? "n" : ""),
3498                       (exp?"expression":"prefix"), ti->data);
3499             }
3500         }
3501
3502         if (seenprefix && seenxprefix) {
3503             ti  = as->parms[4].items;
3504             exp = (strncmp(ti->data,"^",1) == 0);
3505             fprintf(STDOUT," %swhich match %s '%s'",
3506                     (exclude?"adding those ":"removing those "),
3507                     (exp?"expression":"prefix"), ti->data);
3508             for (ti=ti->next; ti; ti=ti->next) {
3509                exp = (strncmp(ti->data,"^",1) == 0);
3510                printf(" or %s '%s'", (exp?"expression":"prefix"), ti->data);
3511             }
3512         }
3513         fprintf(STDOUT," .. ");
3514         if (verbose) fprintf(STDOUT,"\n");
3515         fflush(STDOUT);
3516     }
3517
3518     for (j=0; j<nentries; j++) {        /* process each vldb entry */
3519         vllist = &arrayEntries.nbulkentries_val[j];
3520
3521         if (seenprefix) {
3522            for (ti=as->parms[0].items; ti; ti=ti->next) {
3523               if (strncmp(ti->data,"^",1) == 0) {
3524                  ccode = (char *)re_comp(ti->data);
3525                  if (ccode) {
3526                     fprintf(STDERR,"Error in -prefix regular expression: '%s': %s\n",
3527                             ti->data, ccode);
3528                     exit(1);    
3529                  }
3530                  match = (re_exec(vllist->name) == 1);
3531               } else {
3532                  match = (strncmp(vllist->name,ti->data,strlen(ti->data)) == 0);
3533               }
3534               if (match) break;
3535            }
3536         } else {
3537            match = 1;
3538         }
3539         
3540         /* Without the -exclude flag: If it matches the prefix, then
3541          *    check if we want to exclude any from xprefix.
3542          * With the -exclude flag: If it matches the prefix, then
3543          *    check if we want to add any from xprefix.
3544          */
3545         if (match && seenxprefix) {
3546            for (ti=as->parms[4].items; ti; ti=ti->next) {
3547               if (strncmp(ti->data,"^",1) == 0) {
3548                  ccode = (char *)re_comp(ti->data);
3549                  if (ccode) {
3550                     fprintf(STDERR,"Error in -xprefix regular expression: '%s': %s\n",
3551                             ti->data, ccode);
3552                     exit(1);    
3553                  }
3554                  if (re_exec(vllist->name) == 1) {
3555                     match = 0;
3556                     break;
3557                  }
3558               } else {
3559                  if (strncmp(vllist->name,ti->data,strlen(ti->data)) == 0) {
3560                    match = 0;
3561                    break;
3562                  }
3563               }
3564            }
3565         }
3566
3567         if (exclude) match = !match;     /* -exclude will reverse the match */
3568         if (!match) continue;             /* Skip if no match */
3569
3570         /* Print list of volumes to backup */
3571         if (noaction) {
3572             fprintf(STDOUT,"     %s\n", vllist->name);
3573             continue;
3574         }
3575
3576         if(!(vllist->flags & RW_EXISTS)){
3577             if(verbose) {
3578                 fprintf(STDOUT,"Omitting to backup %s since RW volume does not exist \n", vllist->name);
3579                 fprintf(STDOUT,"\n");
3580             }
3581             fflush(STDOUT);
3582             continue;
3583         }
3584         
3585         avolid = vllist->volumeId[RWVOL];
3586         MapHostToNetwork(vllist);
3587         GetServerAndPart(vllist,RWVOL,&aserver1,&apart1,&previdx);
3588         if(aserver1 == -1 || apart1 == -1){
3589             fprintf(STDOUT,"could not backup %s, invalid VLDB entry\n",vllist->name);
3590             totalFail++;
3591             continue;
3592         }
3593         if (aserver) {
3594             same = VLDB_IsSameAddrs(aserver, aserver1, &error);
3595             if (error) {
3596                 fprintf(STDERR,"Failed to get info about server's %d address(es) from vlserver (err=%d); aborting call!\n", 
3597                         aserver, error);
3598                 totalFail++;
3599                 continue;
3600             }
3601         }
3602         if ((aserver && !same) || (apart && (apart != apart1))) {
3603             if(verbose) {
3604                 fprintf(STDOUT, "Omitting to backup %s since the RW is in a different location\n", vllist->name);
3605             }
3606             continue;
3607         }
3608         if(verbose){
3609             time_t now = time(0);
3610             fprintf(STDOUT,"Creating backup volume for %s on %s",vllist->name, ctime(&now));
3611             fflush(STDOUT);
3612         }
3613
3614         code = UV_BackupVolume(aserver1, apart1, avolid);
3615         if (code) {
3616            fprintf(STDOUT,"Could not backup %s\n",vllist->name);
3617            totalFail++;
3618         }
3619         else {
3620             totalBack++;
3621         }
3622         if (verbose) fprintf(STDOUT,"\n");
3623         fflush(STDOUT);
3624     } /* process each vldb entry */
3625     fprintf(STDOUT,"done\n");
3626     fprintf(STDOUT,"Total volumes backed up: %u; failed to backup: %u\n",totalBack,totalFail);
3627     fflush(STDOUT);
3628     if(arrayEntries.nbulkentries_val) free(arrayEntries.nbulkentries_val);
3629     return 0;
3630 }
3631
3632 static UnlockVLDB(as)
3633 register struct cmd_syndesc *as;
3634 {   
3635     afs_int32 apart;
3636     afs_int32 aserver,code;
3637     afs_int32 vcode;
3638     struct VldbListByAttributes attributes;
3639     nbulkentries arrayEntries;
3640     register struct nvldbentry *vllist;
3641     afs_int32 nentries;
3642     int j;
3643     afs_int32 volid;
3644     afs_int32 totalE;
3645     char pname[10];
3646
3647     apart = -1;
3648     totalE = 0;
3649     attributes.Mask = 0;
3650
3651     if(as->parms[0].items) {/* server specified */
3652         aserver = GetServer(as->parms[0].items->data);
3653         if (aserver == 0) {
3654             fprintf(STDERR,"vos: server '%s' not found in host table\n",as->parms[0].items->data );
3655             exit(1);
3656         }
3657         attributes.server = ntohl(aserver);
3658         attributes.Mask |= VLLIST_SERVER;
3659     }
3660     if(as->parms[1].items) {/* partition specified */
3661         apart = volutil_GetPartitionID(as->parms[1].items->data);
3662         if (apart < 0) {
3663             fprintf(STDERR,"vos: could not interpret partition name '%s'\n", as->parms[1].items->data);
3664             exit(1);
3665         }
3666         if (!IsPartValid(apart,aserver,&code)){/*check for validity of the partition */
3667             if(code) PrintError("",code);
3668             else fprintf(STDERR,"vos : partition %s does not exist on the server\n",as->parms[1].items->data);
3669             exit(1);
3670         }
3671         attributes.partition = apart;
3672         attributes.Mask |= VLLIST_PARTITION;
3673     }
3674     attributes.flag = VLOP_ALLOPERS;
3675     attributes.Mask |=  VLLIST_FLAG;
3676     memset(&arrayEntries, 0, sizeof(arrayEntries)); /*initialize to hint the stub  to alloc space */
3677     vcode = VLDB_ListAttributes(&attributes, &nentries, &arrayEntries);
3678     if(vcode) {
3679         fprintf(STDERR,"Could not access the VLDB for attributes\n");
3680         PrintError("",vcode);
3681         exit(1);
3682     }
3683     for(j=0;j<nentries;j++) {   /* process each entry */
3684         vllist = &arrayEntries.nbulkentries_val[j];
3685         volid = vllist->volumeId[RWVOL];
3686         vcode = ubik_Call(VL_ReleaseLock,cstruct, 0, volid,-1, LOCKREL_OPCODE | LOCKREL_AFSID | LOCKREL_TIMESTAMP);
3687         if(vcode){
3688             fprintf(STDERR,"Could not unlock entry for volume %s\n",vllist->name);
3689             PrintError("",vcode);
3690             totalE++;
3691         }
3692             
3693     }
3694     MapPartIdIntoName(apart,pname);
3695     if(totalE) fprintf(STDOUT,"Could not lock %u VLDB entries of %u locked entries\n",totalE,nentries);
3696     else {
3697         if(as->parms[0].items) {
3698             fprintf(STDOUT,"Unlocked all the VLDB entries for volumes on server %s ",as->parms[0].items->data);
3699             if(as->parms[1].items){
3700                 MapPartIdIntoName(apart,pname);
3701                 fprintf(STDOUT,"partition %s\n",pname);
3702             }
3703             else  fprintf(STDOUT,"\n");
3704
3705         }
3706         else if(as->parms[1].items){
3707             MapPartIdIntoName(apart,pname);
3708             fprintf(STDOUT,"Unlocked all the VLDB entries for volumes on partition %s on all servers\n",pname);
3709         }
3710     }
3711     
3712     if(arrayEntries.nbulkentries_val) free(arrayEntries.nbulkentries_val);
3713     return 0;
3714 }
3715
3716 static PartitionInfo(as)
3717 register struct cmd_syndesc *as;
3718 {   
3719     afs_int32 apart;
3720     afs_int32 aserver,code;
3721     char pname[10];
3722     struct diskPartition partition;
3723     struct partList dummyPartList;
3724     int i, cnt;
3725
3726     apart = -1;
3727     aserver = GetServer(as->parms[0].items->data);
3728     if (aserver == 0) {
3729         fprintf(STDERR,"vos: server '%s' not found in host table\n",as->parms[0].items->data );
3730         exit(1);
3731     }
3732     if(as->parms[1].items){
3733         apart = volutil_GetPartitionID(as->parms[1].items->data);
3734         if (apart < 0) {
3735             fprintf(STDERR,"vos: could not interpret partition name '%s'\n", as->parms[1].items->data);
3736             exit(1);
3737         }
3738         dummyPartList.partId[0] = apart;
3739         dummyPartList.partFlags[0] = PARTVALID;
3740         cnt = 1;
3741     }
3742     if(apart != -1) {
3743         if (!IsPartValid(apart,aserver,&code)){/*check for validity of the partition */
3744             if(code) PrintError("",code);
3745             else fprintf(STDERR,"vos : partition %s does not exist on the server\n",as->parms[1].items->data);
3746             exit(1);
3747         }
3748     }
3749     else {
3750         code = UV_ListPartitions(aserver,&dummyPartList, &cnt);
3751         if (code) {
3752             PrintDiagnostics("listpart", code);
3753             exit(1);
3754         }
3755     }
3756     for(i = 0 ; i < cnt ; i++){
3757         if(dummyPartList.partFlags[i] & PARTVALID){
3758             MapPartIdIntoName(dummyPartList.partId[i],pname);
3759             code = UV_PartitionInfo(aserver,pname,&partition);
3760             if(code){
3761                 fprintf(STDERR,"Could not get information on partition %s\n",pname);
3762                 PrintError("",code);
3763                 exit(1);
3764             }
3765             fprintf(STDOUT,"Free space on partition %s: %d K blocks out of total %d\n",pname,partition.free,partition.minFree);
3766         }
3767     }
3768     return 0;
3769 }
3770
3771 static ChangeAddr(as)
3772 register struct cmd_syndesc *as;
3773
3774 {
3775     afs_int32 ip1, ip2, vcode;
3776     int remove=0;
3777
3778     ip1 = GetServer(as->parms[0].items->data);
3779     if (!ip1) {
3780       fprintf(STDERR, "vos: invalid host address\n");
3781       return( EINVAL );
3782     }
3783
3784     if ( ( as->parms[1].items &&  as->parms[2].items) ||
3785          (!as->parms[1].items && !as->parms[2].items) ) {
3786        fprintf(STDERR, "vos: Must specify either '-newaddr <addr>' or '-remove' flag\n");
3787        return(EINVAL);
3788     }
3789
3790     if (as->parms[1].items) {
3791        ip2 = GetServer(as->parms[1].items->data);
3792        if (!ip2) {
3793           fprintf(STDERR, "vos: invalid host address\n");
3794           return( EINVAL );
3795        }
3796     } else {
3797        /* Play a trick here. If we are removing an address, ip1 will be -1
3798         * and ip2 will be the original address. This switch prevents an 
3799         * older revision vlserver from removing the IP address.
3800         */
3801        remove = 1;
3802        ip2 = ip1;
3803        ip1 = 0xffffffff;
3804     }
3805
3806     vcode = ubik_Call_New(VL_ChangeAddr, cstruct, 0, ntohl(ip1), ntohl(ip2) );
3807     if (vcode) {
3808         if (remove) {
3809            fprintf(STDERR,"Could not remove server %s from the VLDB\n",
3810                    as->parms[0].items->data);
3811            if (vcode == VL_NOENT) {
3812               fprintf(STDERR, "vlserver does not support the remove flag or ");
3813            }
3814         } else {
3815            fprintf(STDERR,"Could not change server %s to server %s\n", 
3816                    as->parms[0].items->data, as->parms[1].items->data);
3817         }
3818         PrintError("",vcode);
3819         return( vcode );
3820     }
3821
3822     if (remove) {
3823        fprintf(STDOUT,"Removed server %s from the VLDB\n",
3824                as->parms[0].items->data);
3825     } else {
3826        fprintf(STDOUT,"Changed server %s to server %s\n",
3827                as->parms[0].items->data, as->parms[1].items->data);
3828     }
3829     return 0;
3830 }
3831
3832 static void
3833 print_addrs(const bulkaddrs *addrs, const afsUUID *m_uuid, int nentries, int print, int noresolve)
3834 {
3835   afs_int32 vcode;
3836   afs_int32 i, j;
3837   struct VLCallBack    unused;
3838   afs_int32            *addrp;
3839   bulkaddrs            m_addrs;
3840   ListAddrByAttributes m_attrs;
3841   afs_int32            m_unique, m_nentries, *m_addrp;
3842   afs_int32            base, index;
3843   char buf[1024];
3844
3845   if (print) {
3846       afsUUID_to_string(m_uuid, buf, sizeof(buf));
3847       printf("UUID: %s\n", buf);
3848   }
3849
3850   /* print out the list of all the server */
3851   addrp = (afs_int32 *)addrs->bulkaddrs_val;
3852   for (i=0; i<nentries; i++, addrp++) {
3853      /* If it is a multihomed address, then we will need to 
3854       * get the addresses for this multihomed server from
3855       * the vlserver and print them.
3856       */
3857      if ( ((*addrp & 0xff000000) == 0xff000000) && ((*addrp)&0xffff) ) {
3858         /* Get the list of multihomed fileservers */
3859         base =  (*addrp>>16) & 0xff;
3860         index = (*addrp)     & 0xffff;
3861
3862         if ( (base  >= 0) && (base  <= VL_MAX_ADDREXTBLKS) &&
3863              (index >= 1) && (index <= VL_MHSRV_PERBLK)    ) {
3864            m_attrs.Mask  = VLADDR_INDEX;
3865            m_attrs.index = (base * VL_MHSRV_PERBLK) + index;
3866            m_nentries            = 0;
3867            m_addrs.bulkaddrs_val = 0;
3868            m_addrs.bulkaddrs_len = 0;
3869            vcode = ubik_Call(VL_GetAddrsU, cstruct, 0,
3870                              &m_attrs, &m_uuid, &m_unique, &m_nentries, &m_addrs);
3871            if (vcode) {
3872               fprintf(STDERR,"vos: could not list the multi-homed server addresses\n");
3873               PrintError("",vcode);
3874            }
3875
3876            /* Print the list */
3877            m_addrp = (afs_int32 *)m_addrs.bulkaddrs_val;
3878            for (j=0; j<m_nentries; j++, m_addrp++) {
3879               *m_addrp = htonl(*m_addrp);       
3880               if (noresolve) {
3881                   char hoststr[16];
3882                   printf("%s ", afs_inet_ntoa_r(*m_addrp,hoststr));
3883               } else {
3884                   printf("%s ", hostutil_GetNameByINet(*m_addrp));
3885               }
3886            }
3887            if (j==0) {
3888               printf("<unknown>\n");
3889            } else {
3890               printf("\n");
3891            }
3892
3893            continue;
3894         }
3895      }
3896
3897      /* Otherwise, it is a non-multihomed entry and contains
3898       * the IP address of the server - print it.
3899       */
3900      *addrp = htonl(*addrp);    
3901      if (noresolve) {
3902          char hoststr[16];
3903          printf("%s\n", afs_inet_ntoa_r(*addrp,hoststr));
3904      } else {
3905          printf("%s\n", hostutil_GetNameByINet(*addrp));
3906      }
3907   }
3908
3909   if (print) {
3910       printf("\n");
3911   }
3912   return;
3913 }
3914
3915 static ListAddrs(as)
3916 register struct cmd_syndesc *as;
3917 {
3918   afs_int32 vcode;
3919   afs_int32 i, j, noresolve=0, printuuid=0;
3920   struct VLCallBack    unused;
3921   afs_int32                nentries, *addrp;
3922   bulkaddrs            addrs, m_addrs;
3923   ListAddrByAttributes m_attrs;
3924   afsUUID              m_uuid, askuuid;
3925   afs_int32                m_unique, m_nentries, *m_addrp;
3926   afs_int32                base, index;
3927
3928   memset(&m_attrs, 0, sizeof(struct ListAddrByAttributes));
3929   m_attrs.Mask = VLADDR_INDEX;
3930
3931   memset(&m_addrs, 0, sizeof(bulkaddrs));
3932   memset(&askuuid, 0, sizeof(afsUUID));
3933   if (as->parms[0].items) {
3934       /* -uuid */
3935       afsUUID_from_string(as->parms[0].items->data, &askuuid);
3936       m_attrs.Mask = VLADDR_UUID;
3937       m_attrs.uuid = askuuid;
3938   }
3939   if (as->parms[1].items) {
3940       /* -host */
3941       struct hostent       *he; 
3942       afs_int32 saddr;
3943       he = hostutil_GetHostByName((char*)as->parms[1].items->data);
3944       if (he == NULL) {
3945           fprintf(stderr,
3946                   "Can't get host info for '%s'\n",
3947                   as->parms[1].items->data);
3948           exit(-1);
3949       }
3950       memcpy(&saddr, he->h_addr, 4);
3951       m_attrs.Mask = VLADDR_IPADDR;
3952       m_attrs.ipaddr = ntohl(saddr);
3953   }
3954   if (as->parms[2].items) {
3955       noresolve=1;
3956   }
3957   if (as->parms[3].items) {
3958       printuuid=1;
3959   }
3960
3961   m_addrs.bulkaddrs_val = 0;
3962   m_addrs.bulkaddrs_len = 0;
3963
3964   vcode = ubik_Call_New(VL_GetAddrs, cstruct, 0,
3965                         0, 0, &m_unique, &nentries, &m_addrs);
3966   if (vcode) {
3967     fprintf(STDERR,"vos: could not list the server addresses\n");
3968     PrintError("",vcode);
3969     return( vcode );
3970   }
3971
3972   m_nentries            = 0;
3973   m_addrs.bulkaddrs_val = 0;
3974   m_addrs.bulkaddrs_len = 0;
3975   i=1;
3976   while (1) {
3977       m_attrs.index = i;
3978
3979       vcode = ubik_Call_New(VL_GetAddrsU, cstruct, 0, &m_attrs, &m_uuid, 
3980                         &m_unique, &m_nentries, &m_addrs);
3981       if(vcode == VL_NOENT) {
3982           i++;
3983           nentries++;
3984           continue;
3985       }
3986
3987       if (vcode == VL_INDEXERANGE) {
3988           break;
3989       }
3990
3991       if (vcode) {
3992           fprintf(STDERR,"vos: could not list the server addresses\n");
3993           PrintError("",vcode);
3994           return( vcode );
3995       }
3996
3997       print_addrs(&m_addrs, &m_uuid, m_nentries, printuuid, noresolve);
3998       i++;
3999
4000       if ((as->parms[1].items)||(as->parms[0].items)||(i>nentries))
4001           break;
4002   }
4003     
4004   return 0;
4005 }
4006
4007 static LockEntry(as)
4008 register struct cmd_syndesc *as;
4009
4010 {
4011     afs_int32 avolid,vcode, err;
4012
4013     avolid = vsu_GetVolumeID(as->parms[0].items->data, cstruct, &err);
4014     if (avolid == 0) {
4015         if (err) PrintError("", err);
4016         else fprintf(STDERR, "vos: can't find volume '%s'\n", as->parms[0].items->data);
4017         exit(1);
4018     }
4019     vcode = ubik_Call(VL_SetLock,cstruct, 0, avolid, -1, VLOP_DELETE);
4020     if(vcode){
4021         fprintf(STDERR,"Could not lock VLDB entry for volume %s\n",as->parms[0].items->data);
4022         PrintError("",vcode);
4023         exit(1);
4024     }
4025     fprintf(STDOUT,"Locked VLDB entry for volume %s\n",as->parms[0].items->data);
4026     return 0;
4027 }
4028
4029 PrintDiagnostics(astring, acode)
4030     char *astring;
4031     afs_int32 acode;
4032 {
4033     if (acode == EACCES) {
4034         fprintf(STDERR,"You are not authorized to perform the 'vos %s' command (%d)\n",
4035                 astring, acode);
4036     }
4037     else {
4038         fprintf(STDERR,"Error in vos %s command.\n", astring);
4039         PrintError("", acode);
4040     }
4041     return 0;
4042 }
4043
4044
4045 static MyBeforeProc(as, arock)
4046 struct cmd_syndesc *as;
4047 char *arock; {
4048     register char *tcell;
4049     register afs_int32 code;
4050     register afs_int32 sauth;
4051
4052     /* Initialize the ubik_client connection */
4053     rx_SetRxDeadTime(90);
4054     cstruct = (struct ubik_client *)0;
4055
4056     sauth = 0;
4057     tcell = NULL;
4058     if (as->parms[12].items)    /* if -cell specified */
4059         tcell = as->parms[12].items->data;
4060     if(as->parms[14].items)     /* -serverauth specified */
4061         sauth = 1;
4062     if(as->parms[16].items)     /* -crypt specified */
4063         vsu_SetCrypt(1);
4064     if (code = vsu_ClientInit((as->parms[13].items != 0), confdir, tcell, sauth,
4065                               &cstruct, UV_SetSecurity)) {
4066         fprintf(STDERR,"could not initialize VLDB library (code=%u) \n",code);
4067         exit(1);
4068     }
4069     rxInitDone = 1;
4070     if(as->parms[15].items)     /* -verbose flag set */
4071         verbose = 1;
4072     else
4073         verbose = 0;
4074     return 0;
4075 }
4076
4077 int osi_audit()
4078 {
4079 /* this sucks but it works for now.
4080 */
4081 return 0;
4082 }
4083
4084 #include "AFS_component_version_number.c"
4085
4086 main(argc, argv)
4087 int argc;
4088 char **argv; {
4089   register afs_int32 code;
4090     
4091     register struct cmd_syndesc *ts;
4092
4093 #ifdef  AFS_AIX32_ENV
4094     /*
4095      * The following signal action for AIX is necessary so that in case of a 
4096      * crash (i.e. core is generated) we can include the user's data section 
4097      * in the core dump. Unfortunately, by default, only a partial core is
4098      * generated which, in many cases, isn't too useful.
4099      */
4100     struct sigaction nsa;
4101     
4102     sigemptyset(&nsa.sa_mask);
4103     nsa.sa_handler = SIG_DFL;
4104     nsa.sa_flags = SA_FULLDUMP;
4105     sigaction(SIGSEGV, &nsa, NULL);
4106 #endif
4107
4108     confdir = AFSDIR_CLIENT_ETC_DIRPATH;
4109
4110     cmd_SetBeforeProc(MyBeforeProc,  NULL);
4111
4112     ts = cmd_CreateSyntax("create", CreateVolume, 0, "create a new volume");
4113     cmd_AddParm(ts, "-server", CMD_SINGLE, 0, "machine name");
4114     cmd_AddParm(ts, "-partition", CMD_SINGLE, 0, "partition name");
4115     cmd_AddParm(ts, "-name", CMD_SINGLE, 0, "volume name");
4116     cmd_AddParm(ts, "-maxquota", CMD_SINGLE, CMD_OPTIONAL, "initial quota (KB)");
4117 #ifdef notdef
4118     cmd_AddParm(ts, "-minquota", CMD_SINGLE, CMD_OPTIONAL, "");
4119 #endif
4120     COMMONPARMS;
4121
4122     ts = cmd_CreateSyntax("remove", DeleteVolume, 0, "delete a volume");
4123     cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_OPTIONAL, "machine name");
4124     cmd_AddParm(ts, "-partition", CMD_SINGLE, CMD_OPTIONAL, "partition name");
4125     cmd_AddParm(ts, "-id", CMD_SINGLE, 0, "volume name or ID");
4126
4127     COMMONPARMS;
4128
4129     ts = cmd_CreateSyntax("move", MoveVolume, 0, "move a volume");
4130     cmd_AddParm(ts, "-id", CMD_SINGLE, 0, "volume name or ID");
4131     cmd_AddParm(ts, "-fromserver", CMD_SINGLE, 0, "machine name on source");
4132     cmd_AddParm(ts, "-frompartition", CMD_SINGLE, 0, "partition name on source");
4133     cmd_AddParm(ts, "-toserver", CMD_SINGLE, 0, "machine name on destination");
4134     cmd_AddParm(ts, "-topartition", CMD_SINGLE, 0, "partition name on destination");
4135     COMMONPARMS;
4136
4137     ts = cmd_CreateSyntax("backup", BackupVolume, 0, "make backup of a volume");
4138     cmd_AddParm(ts, "-id", CMD_SINGLE, 0, "volume name or ID");
4139     COMMONPARMS;
4140
4141     ts = cmd_CreateSyntax("release", ReleaseVolume, 0, "release a volume");
4142     cmd_AddParm(ts, "-id", CMD_SINGLE, 0, "volume name or ID");
4143     cmd_AddParm(ts, "-force", CMD_FLAG, CMD_OPTIONAL, "force a complete release");
4144     COMMONPARMS;
4145
4146     ts = cmd_CreateSyntax("dump", DumpVolume, 0, "dump a volume");
4147     cmd_AddParm(ts, "-id", CMD_SINGLE, 0, "volume name or ID");
4148     cmd_AddParm(ts, "-time", CMD_SINGLE, CMD_OPTIONAL, "dump from time");
4149     cmd_AddParm(ts, "-file", CMD_SINGLE, CMD_OPTIONAL, "dump file");
4150     cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_OPTIONAL, "server");
4151     cmd_AddParm(ts, "-partition", CMD_SINGLE, CMD_OPTIONAL, "partition");
4152     COMMONPARMS;
4153
4154     ts = cmd_CreateSyntax("restore", RestoreVolume, 0, "restore a volume");
4155     cmd_AddParm(ts, "-server", CMD_SINGLE, 0, "machine name");
4156     cmd_AddParm(ts, "-partition", CMD_SINGLE, 0, "partition name");
4157     cmd_AddParm(ts, "-name", CMD_SINGLE, 0, "name of volume to be restored");
4158     cmd_AddParm(ts, "-file", CMD_SINGLE,CMD_OPTIONAL, "dump file");
4159     cmd_AddParm(ts, "-id", CMD_SINGLE,CMD_OPTIONAL,  "volume ID");
4160     cmd_AddParm(ts, "-overwrite", CMD_SINGLE,CMD_OPTIONAL,  "abort | full | incremental");
4161     cmd_AddParm(ts, "-offline", CMD_FLAG, CMD_OPTIONAL,
4162                 "leave restored volume offline");
4163     cmd_AddParm(ts, "-readonly", CMD_FLAG, CMD_OPTIONAL,
4164                 "make restored volume read-only");
4165     COMMONPARMS;
4166
4167     ts = cmd_CreateSyntax("unlock", LockReleaseCmd, 0, "release lock on VLDB entry for a volume");
4168     cmd_AddParm(ts, "-id", CMD_SINGLE, 0, "volume name or ID");
4169     COMMONPARMS;
4170
4171     ts = cmd_CreateSyntax("changeloc", ChangeLocation, 0, "change an RW volume's location in the VLDB");
4172     cmd_AddParm(ts, "-server", CMD_SINGLE, 0, "machine name for new location");
4173     cmd_AddParm(ts, "-partition", CMD_SINGLE, 0, "partition name for new location");
4174     cmd_AddParm(ts, "-id", CMD_SINGLE, 0, "volume name or ID");
4175     COMMONPARMS;
4176
4177     ts = cmd_CreateSyntax("addsite", AddSite, 0, "add a replication site");
4178     cmd_AddParm(ts, "-server", CMD_SINGLE, 0, "machine name for new site");
4179     cmd_AddParm(ts, "-partition", CMD_SINGLE, 0, "partition name for new site");
4180     cmd_AddParm(ts, "-id", CMD_SINGLE, 0, "volume name or ID");
4181     COMMONPARMS;
4182
4183     ts = cmd_CreateSyntax("remsite", RemoveSite, 0, "remove a replication site");
4184     cmd_AddParm(ts, "-server", CMD_SINGLE, 0, "machine name");
4185     cmd_AddParm(ts, "-partition", CMD_SINGLE, 0, "partition name");
4186     cmd_AddParm(ts, "-id", CMD_SINGLE, 0, "volume name or ID");
4187     COMMONPARMS;
4188
4189     ts = cmd_CreateSyntax("listpart", ListPartitions, 0, "list partitions");
4190     cmd_AddParm(ts, "-server", CMD_SINGLE, 0, "machine name");
4191     COMMONPARMS;
4192
4193     ts = cmd_CreateSyntax("listvol", ListVolumes, 0, "list volumes on server (bypass VLDB)");
4194     cmd_AddParm(ts, "-server", CMD_SINGLE, 0, "machine name");
4195     cmd_AddParm(ts, "-partition", CMD_SINGLE,CMD_OPTIONAL, "partition name");
4196     cmd_AddParm(ts, "-fast", CMD_FLAG, CMD_OPTIONAL, "minimal listing");
4197     cmd_AddParm(ts, "-long", CMD_FLAG, CMD_OPTIONAL,
4198                 "list all normal volume fields");
4199     cmd_AddParm(ts, "-quiet", CMD_FLAG, CMD_OPTIONAL, "generate minimal information");
4200     cmd_AddParm(ts, "-extended", CMD_FLAG, CMD_OPTIONAL,
4201                 "list extended volume fields");
4202 #ifdef FULL_LISTVOL_SWITCH
4203     cmd_AddParm(ts, "-format", CMD_FLAG, CMD_OPTIONAL, 
4204               "machine readable format");
4205 #endif /* FULL_LISTVOL_SWITCH */
4206     COMMONPARMS;
4207
4208     ts = cmd_CreateSyntax("syncvldb", SyncVldb, 0, "synchronize VLDB with server");
4209     cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_OPTIONAL, "machine name");
4210     cmd_AddParm(ts, "-partition", CMD_SINGLE,CMD_OPTIONAL , "partition name");
4211     cmd_AddParm(ts, "-volume", CMD_SINGLE,CMD_OPTIONAL , "volume name or ID");
4212     COMMONPARMS;
4213
4214     ts = cmd_CreateSyntax("syncserv", SyncServer, 0, "synchronize server with VLDB");
4215     cmd_AddParm(ts, "-server", CMD_SINGLE, 0, "machine name");
4216     cmd_AddParm(ts, "-partition", CMD_SINGLE,CMD_OPTIONAL , "partition name");
4217     COMMONPARMS;
4218
4219     ts = cmd_CreateSyntax("examine", ExamineVolume, 0, "everything about the volume");
4220     cmd_AddParm(ts, "-id", CMD_SINGLE, 0, "volume name or ID");
4221     cmd_AddParm(ts, "-extended", CMD_FLAG, CMD_OPTIONAL,
4222                 "list extended volume fields");
4223 #ifdef FULL_LISTVOL_SWITCH
4224     cmd_AddParm(ts, "-format", CMD_FLAG, CMD_OPTIONAL, 
4225               "machine readable format");
4226 #endif /* FULL_LISTVOL_SWITCH */
4227     COMMONPARMS;
4228     cmd_CreateAlias (ts, "volinfo");
4229
4230     ts = cmd_CreateSyntax("setfields", SetFields, 0, "change volume info fields");
4231     cmd_AddParm(ts, "-id",        CMD_SINGLE, 0, "volume name or ID");
4232     cmd_AddParm(ts, "-maxquota", CMD_SINGLE, CMD_OPTIONAL, "quota (KB)");
4233     cmd_AddParm(ts, "-clearuse",  CMD_FLAG,   CMD_OPTIONAL, "clear dayUse");
4234     COMMONPARMS;
4235
4236     ts = cmd_CreateSyntax("offline", volOffline, 0, (char *) CMD_HIDDEN);
4237     cmd_AddParm(ts, "-server",    CMD_SINGLE, 0, "server name");
4238     cmd_AddParm(ts, "-partition", CMD_SINGLE, 0, "partition name");
4239     cmd_AddParm(ts, "-id",        CMD_SINGLE, 0, "volume name or ID");
4240     cmd_AddParm(ts, "-sleep", CMD_SINGLE, CMD_OPTIONAL, "seconds to sleep");
4241     cmd_AddParm(ts, "-busy",  CMD_FLAG,   CMD_OPTIONAL, "busy volume");
4242     COMMONPARMS;
4243
4244     ts = cmd_CreateSyntax("online", volOnline, 0, (char *) CMD_HIDDEN);
4245     cmd_AddParm(ts, "-server",    CMD_SINGLE, 0, "server name");
4246     cmd_AddParm(ts, "-partition", CMD_SINGLE, 0, "partition name");
4247     cmd_AddParm(ts, "-id",        CMD_SINGLE, 0, "volume name or ID");
4248     COMMONPARMS;
4249
4250     ts = cmd_CreateSyntax("zap", VolumeZap, 0, "delete the volume, don't bother with VLDB");
4251     cmd_AddParm(ts, "-server", CMD_SINGLE, 0, "machine name");
4252     cmd_AddParm(ts, "-partition", CMD_SINGLE, 0, "partition name");
4253     cmd_AddParm(ts, "-id", CMD_SINGLE, 0, "volume ID");
4254     cmd_AddParm(ts, "-force", CMD_FLAG, CMD_OPTIONAL, "force deletion of bad volumes");
4255     cmd_AddParm(ts, "-backup", CMD_FLAG, CMD_OPTIONAL, "also delete backup volume if one is found");
4256     COMMONPARMS;
4257
4258     ts = cmd_CreateSyntax("status", VolserStatus, 0, "report on volser status");
4259     cmd_AddParm(ts, "-server", CMD_SINGLE, 0, "machine name");
4260     COMMONPARMS;
4261
4262     ts = cmd_CreateSyntax("rename", RenameVolume, 0, "rename a volume");
4263     cmd_AddParm(ts, "-oldname", CMD_SINGLE, 0, "old volume name ");
4264     cmd_AddParm(ts, "-newname", CMD_SINGLE, 0, "new volume name ");
4265     COMMONPARMS;
4266
4267     ts = cmd_CreateSyntax("listvldb", ListVLDB, 0, "list volumes in the VLDB");
4268     cmd_AddParm(ts, "-name", CMD_SINGLE,CMD_OPTIONAL,  "volume name or ID");
4269     cmd_AddParm(ts, "-server", CMD_SINGLE,CMD_OPTIONAL,  "machine name");
4270     cmd_AddParm(ts, "-partition", CMD_SINGLE,CMD_OPTIONAL, "partition name");
4271     cmd_AddParm(ts, "-locked", CMD_FLAG, CMD_OPTIONAL, "locked volumes only");
4272     cmd_AddParm(ts, "-quiet", CMD_FLAG, CMD_OPTIONAL, "generate minimal information");
4273     cmd_AddParm(ts, "-nosort", CMD_FLAG, CMD_OPTIONAL, "do not alphabetically sort the volume names");
4274     COMMONPARMS;
4275
4276     ts = cmd_CreateSyntax("backupsys", BackSys, 0, "en masse backups");
4277     cmd_AddParm(ts, "-prefix", CMD_LIST,CMD_OPTIONAL,  "common prefix on volume(s)");
4278     cmd_AddParm(ts, "-server", CMD_SINGLE,CMD_OPTIONAL,  "machine name");
4279     cmd_AddParm(ts, "-partition", CMD_SINGLE,CMD_OPTIONAL, "partition name");
4280     cmd_AddParm(ts, "-exclude", CMD_FLAG, CMD_OPTIONAL, "exclude common prefix volumes");
4281     cmd_AddParm(ts, "-xprefix", CMD_LIST, CMD_OPTIONAL, "negative prefix on volume(s)");
4282     cmd_AddParm(ts, "-dryrun", CMD_FLAG, CMD_OPTIONAL, "no action");
4283     COMMONPARMS;
4284
4285     ts = cmd_CreateSyntax("delentry", DeleteEntry, 0, "delete VLDB entry for a volume");
4286     cmd_AddParm(ts, "-id", CMD_LIST, CMD_OPTIONAL, "volume name or ID");
4287     cmd_AddParm(ts, "-prefix", CMD_SINGLE,CMD_OPTIONAL, "prefix of the volume whose VLDB entry is to be deleted");
4288     cmd_AddParm(ts, "-server", CMD_SINGLE,CMD_OPTIONAL,  "machine name");
4289     cmd_AddParm(ts, "-partition", CMD_SINGLE,CMD_OPTIONAL, "partition name");
4290     cmd_AddParm(ts, "-noexecute", CMD_FLAG,CMD_OPTIONAL|CMD_HIDE, "no execute");
4291     COMMONPARMS;
4292
4293      ts = cmd_CreateSyntax("partinfo", PartitionInfo, 0, "list partition information");
4294     cmd_AddParm(ts, "-server", CMD_SINGLE, 0, "machine name");
4295     cmd_AddParm(ts, "-partition", CMD_SINGLE,CMD_OPTIONAL, "partition name");
4296     COMMONPARMS;
4297
4298     ts = cmd_CreateSyntax("unlockvldb", UnlockVLDB, 0, "unlock all the locked entries in the VLDB");
4299     cmd_AddParm(ts, "-server", CMD_SINGLE,CMD_OPTIONAL,  "machine name");
4300     cmd_AddParm(ts, "-partition", CMD_SINGLE,CMD_OPTIONAL, "partition name");
4301     COMMONPARMS;
4302
4303     ts = cmd_CreateSyntax("lock", LockEntry, 0, "lock VLDB entry for a volume");
4304     cmd_AddParm(ts, "-id", CMD_SINGLE, 0, "volume name or ID");
4305     COMMONPARMS;
4306
4307     ts = cmd_CreateSyntax("changeaddr", ChangeAddr, 0, "change the IP address of a file server");
4308     cmd_AddParm(ts, "-oldaddr", CMD_SINGLE, 0, "original IP address");
4309     cmd_AddParm(ts, "-newaddr", CMD_SINGLE, CMD_OPTIONAL, "new IP address");
4310     cmd_AddParm(ts, "-remove", CMD_FLAG, CMD_OPTIONAL, "remove the IP address from the VLDB");
4311     COMMONPARMS;
4312
4313     ts = cmd_CreateSyntax("listaddrs", ListAddrs, 0, "list the IP address of all file servers registered in the VLDB");
4314     cmd_AddParm(ts, "-uuid", CMD_SINGLE, CMD_OPTIONAL, "uuid of server");
4315     cmd_AddParm(ts, "-host", CMD_SINGLE, CMD_OPTIONAL, "address of host");
4316     cmd_AddParm(ts, "-noresolve", CMD_FLAG, CMD_OPTIONAL, "don't resolve addresses");
4317     cmd_AddParm(ts, "-printuuid", CMD_FLAG, CMD_OPTIONAL, "print uuid of hosts");
4318     COMMONPARMS;
4319
4320     code = cmd_Dispatch(argc, argv);
4321     if (rxInitDone) {