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