1d80c9b1af401a078d8ffd693c2be3c9ba637e88
[openafs.git] / src / butc / lwps.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 #include <afs/procmgmt.h>
14 #include <roken.h>
15
16 #ifdef AFS_NT40_ENV
17 #include <conio.h>
18 #endif
19
20 #include <rx/xdr.h>
21 #include <rx/rx.h>
22 #include <lwp.h>
23 #include <lock.h>
24 #include <afs/tcdata.h>
25 #include <afs/bubasics.h>       /* PA */
26 #include <afs/budb_client.h>
27 #include <afs/bucoord_prototypes.h>
28 #include <afs/butm_prototypes.h>
29 #include <afs/volser.h>
30 #include <afs/volser_prototypes.h>
31 #include <afs/com_err.h>
32 #include <afs/afsutil.h>
33
34 #include "error_macros.h"
35 #include "butc_xbsa.h"
36 #include "butc_internal.h"
37
38 /* GLOBAL CONFIGURATION PARAMETERS */
39 extern int queryoperator;
40 extern int tapemounted;
41 extern char *opencallout;
42 extern char *closecallout;
43 extern char *whoami;
44 extern char *extractDumpName(char *);
45 extern int BufferSize;          /* Size in B stored for header info */
46 FILE *restoretofilefd;
47 #ifdef xbsa
48 extern char *restoretofile;
49 extern int forcemultiple;
50 #endif
51
52 /* XBSA Global Parameters */
53 afs_int32 xbsaType;
54 #ifdef xbsa
55 struct butx_transactionInfo butxInfo;
56 #endif
57
58 static struct TapeBlock {               /* A 16KB tapeblock */
59     char mark[BUTM_HDRSIZE];    /* Header info */
60     char data[BUTM_BLKSIZE];    /* data */
61 } *bufferBlock;
62
63 afs_int32 dataSize;             /* Size of data to read on each xbsa_ReadObjectData() call (CONF_XBSA) */
64 afs_int32 tapeblocks;           /* Number of tape datablocks in buffer (!CONF_XBSA) */
65
66 /* notes
67  *      Need to re-write to:
68  *      1) non-interactive tape handling (optional)
69  *      2) compute tape and volume sizes for the database
70  *      3) compute and use tape id's for tape tracking (put on tape label)
71  *      4) status management
72  */
73
74 /* All the relevant info shared between Restorer and restoreVolume */
75 struct restoreParams {
76     struct dumpNode *nodePtr;
77     afs_int32 frag;
78     char mntTapeName[BU_MAXTAPELEN];
79     afs_int32 tapeID;
80     struct butm_tapeInfo *tapeInfoPtr;
81 };
82
83 /* Abort checks are done after each  BIGCHUNK of data transfer */
84 #define BIGCHUNK 102400
85
86 #define HEADER_CHECKS(vhptr, header)                                    \
87 {                                                                       \
88     afs_int32 magic, versionflags;                                              \
89                                                                         \
90     versionflags = ntohl(vhptr.versionflags);                           \
91     if ( versionflags == TAPE_VERSION_0 ||                              \
92              versionflags == TAPE_VERSION_1 ||                          \
93              versionflags == TAPE_VERSION_2 ||                          \
94              versionflags == TAPE_VERSION_3 ||                          \
95              versionflags == TAPE_VERSION_4 )       {                   \
96                                                                         \
97             magic = ntohl(vhptr.magic); /* another sanity check */      \
98             if (magic == TC_VOLBEGINMAGIC ||                            \
99                 magic == TC_VOLENDMAGIC ||                              \
100                 magic == TC_VOLCONTD )                 {                \
101                                                                         \
102                 memcpy(header, &vhptr, sizeof(struct volumeHeader));    \
103                 return (0);                                             \
104             } /* magic */                                               \
105         } /* versionflags */                                            \
106 }
107
108 extern FILE *logIO;
109 extern FILE *ErrorlogIO;
110 extern FILE *centralLogIO;
111 extern FILE *lastLogIO;
112 extern afs_int32 lastPass;      /* Set true during last pass of dump */
113 extern int debugLevel;
114 extern int autoQuery;
115 extern struct tapeConfig globalTapeConfig;
116 extern struct deviceSyncNode *deviceLatch;
117 extern char globalCellName[];
118 struct timeval tp;
119
120 /* forward declaration */
121 afs_int32 readVolumeHeader(char *, afs_int32, struct volumeHeader *);
122 int FindVolTrailer(char *, afs_int32, afs_int32 *, struct volumeHeader *);
123 int FindVolTrailer2(char *, afs_int32, afs_int32 *, char *, afs_int32,
124                     afs_int32 *, struct volumeHeader *);
125 int SkipVolume(struct tc_restoreDesc *, afs_int32, afs_int32, afs_int32,
126                afs_int32);
127
128
129
130 /* The on-disk volume header or trailer can differ in size from platform to platform */
131 static struct TapeBlock tapeBlock;
132 char tapeVolumeHT[sizeof(struct volumeHeader) + 2 * sizeof(char)];
133
134 void
135 PrintLogStr(FILE *log, afs_int32 error1, afs_int32 error2, char *str)
136 {
137     char *err1, *err2;
138
139     fprintf(log, "%s", str);
140     if (error1) {
141         err2 = "vols";
142         switch (error1) {
143         case VSALVAGE:
144             err1 = "Volume needs to be salvaged";
145             break;
146         case VNOVNODE:
147             err1 = "Bad vnode number quoted";
148             break;
149         case VNOVOL:
150             err1 = "Volume not attached, does not exist, or not on line";
151             break;
152         case VVOLEXISTS:
153             err1 = "Volume already exists";
154             break;
155         case VNOSERVICE:
156             err1 = "Volume is not in service";
157             break;
158         case VOFFLINE:
159             err1 = "Volume is off line";
160             break;
161         case VONLINE:
162             err1 = "Volume is already on line";
163             break;
164         case VDISKFULL:
165             err1 = "Partition is full";
166             break;
167         case VOVERQUOTA:
168             err1 = "Volume max quota exceeded";
169             break;
170         case VBUSY:
171             err1 = "Volume temporarily unavailable";
172             break;
173         case VMOVED:
174             err1 = "Volume has moved to another server";
175             break;
176         default:
177             err1 = (char *)afs_error_message(error1);
178             err2 = (char *)afs_error_table_name(error1);
179             break;
180         }
181         if (error1 == -1)
182             fprintf(log, "     Possible communication failure");
183         else
184             fprintf(log, "     %s: %s", err2, err1);
185         if (error2)
186             fprintf(log, ": %s", afs_error_message(error2));
187         fprintf(log, "\n");
188     }
189     fflush(log);
190 }
191
192 void
193 TapeLogStr(int debug, afs_int32 task, afs_int32 error1, afs_int32 error2,
194            char *str)
195 {
196     time_t now;
197     char tbuffer[32];
198     struct tm tm;
199
200     now = time(0);
201     if (strftime(tbuffer, sizeof(tbuffer), "%a %b %d %T %Y",
202                  localtime_r(&now, &tm)) != 0)
203         fprintf(logIO, "%s: ", tbuffer);
204
205     if (task)
206         fprintf(logIO, "Task %u: ", task);
207     PrintLogStr(logIO, error1, error2, str);
208
209     if (lastPass && lastLogIO) {
210         fprintf(lastLogIO, "%s: ", tbuffer);
211         if (task)
212             fprintf(lastLogIO, "Task %u: ", task);
213         PrintLogStr(lastLogIO, error1, error2, str);
214     }
215
216     /* Now print to the screen if debug level requires */
217     if (debug <= debugLevel)
218         PrintLogStr(stdout, error1, error2, str);
219 }
220
221 void
222 TapeLog(int debug, afs_int32 task, afs_int32 error1, afs_int32 error2,
223         char *fmt, ...)
224 {
225     char tmp[1024];
226     va_list ap;
227
228     va_start(ap, fmt);
229     vsnprintf(tmp, sizeof(tmp), fmt, ap);
230     va_end(ap);
231
232     TapeLogStr(debug, task, error1, error2, tmp);
233 }
234
235 void
236 TLog(afs_int32 task, char *fmt, ...)
237 {
238     char tmp[1024];
239     va_list ap;
240
241     va_start(ap, fmt);
242     vsnprintf(tmp, sizeof(tmp), fmt, ap);
243     va_end(ap);
244
245     /* Sends message to TapeLog and stdout */
246     TapeLogStr(0, task, 0, 0, tmp);
247 }
248
249 void
250 ErrorLogStr(int debug, afs_int32 task, afs_int32 error1, afs_int32 error2,
251             char *errStr)
252 {
253     time_t now;
254     char tbuffer[32];
255     struct tm tm;
256
257     now = time(0);
258     if (strftime(tbuffer, sizeof(tbuffer), "%a %b %d %T %Y",
259                  localtime_r(&now, &tm)) != 0)
260         fprintf(ErrorlogIO, "%s: ", tbuffer);
261
262     /* Print the time and task number */
263     if (task)
264         fprintf(ErrorlogIO, "Task %u: ", task);
265
266     PrintLogStr(ErrorlogIO, error1, error2, errStr);
267     TapeLogStr(debug, task, error1, error2, errStr);
268 }
269
270 void
271 ErrorLog(int debug, afs_int32 task, afs_int32 error1, afs_int32 error2,
272          char *fmt, ...)
273 {
274     char tmp[1024];
275     va_list ap;
276
277     va_start(ap, fmt);
278     vsnprintf(tmp, sizeof(tmp), fmt, ap);
279     va_end(ap);
280
281     ErrorLogStr(debug, task, error1, error2, tmp);
282
283 }
284
285 void
286 ELog(afs_int32 task, char *fmt, ...)
287 {
288     char tmp[1024];
289     va_list ap;
290
291     va_start(ap, fmt);
292     vsnprintf(tmp, sizeof(tmp), fmt, ap);
293     va_end(ap);
294
295     /* Sends message to ErrorLog, TapeLog and stdout */
296     ErrorLog(0, task, 0, 0, "%s", tmp);
297 }
298
299 /* first proc called by anybody who intends to use the device */
300 void
301 EnterDeviceQueue(struct deviceSyncNode *devLatch)
302 {
303     ObtainWriteLock(&(devLatch->lock));
304     devLatch->flags = TC_DEVICEINUSE;
305 }
306
307 /* last proc called by anybody finishing using the device */
308 void
309 LeaveDeviceQueue(struct deviceSyncNode *devLatch)
310 {
311     devLatch->flags = 0;
312     ReleaseWriteLock(&(devLatch->lock));
313 }
314
315 #define BELLTIME 60             /* 60 seconds before a bell rings */
316 #define BELLCHAR 7              /* ascii for bell */
317
318 /*
319  * FFlushInput
320  *     flush all input
321  * notes:
322  *     only external clients are in recoverDb.c. Was static. PA
323  */
324 void
325 FFlushInput(void)
326 {
327     int w;
328
329     fflush(stdin);
330
331     while (1) {
332         w = LWP_WaitForKeystroke(0);
333         if (w) {
334 #ifdef AFS_NT40_ENV
335             getche();
336 #else
337             getchar();
338 #endif /* AFS_NT40_ENV */
339         } else {
340             return;
341         }
342     }
343 }
344
345 int
346 callOutRoutine(afs_int32 taskId, char *tapePath, int flag, char *name,
347                afs_uint32 dbDumpId, int tapecount)
348 {
349     int pid;
350
351     char StapePath[256];
352     char ScallOut[256];
353     char Scount[10];
354     char Sopcode[16];
355     char Sdumpid[16];
356     char Stape[40];
357     char *callOut;
358
359     char *CO_argv[10];
360     char *CO_envp[1];
361
362
363     callOut = opencallout;
364     switch (flag) {
365     case READOPCODE:
366         strcpy(Sopcode, "restore");
367         break;
368     case APPENDOPCODE:
369         strcpy(Sopcode, "appenddump");
370         break;
371     case WRITEOPCODE:
372         strcpy(Sopcode, "dump");
373         break;
374     case LABELOPCODE:
375         strcpy(Sopcode, "labeltape");
376         break;
377     case READLABELOPCODE:
378         strcpy(Sopcode, "readlabel");
379         break;
380     case SCANOPCODE:
381         strcpy(Sopcode, "scantape");
382         break;
383     case RESTOREDBOPCODE:
384         strcpy(Sopcode, "restoredb");
385         break;
386     case SAVEDBOPCODE:
387         strcpy(Sopcode, "savedb");
388         break;
389     case CLOSEOPCODE:
390         strcpy(Sopcode, "unmount");
391         callOut = closecallout;
392         break;
393     default:
394         strcpy(Sopcode, "unknown");
395         break;
396     }
397
398     if (!callOut)               /* no script to call */
399         return 0;
400
401     strcpy(ScallOut, callOut);
402     CO_argv[0] = ScallOut;
403
404     strcpy(StapePath, tapePath);
405     CO_argv[1] = StapePath;
406
407     CO_argv[2] = Sopcode;
408
409     if (flag == CLOSEOPCODE) {
410         CO_argv[3] = NULL;
411     } else {
412         sprintf(Scount, "%d", tapecount);
413         CO_argv[3] = Scount;
414
415         /* The tape label name - special case labeltape */
416         if (!name || (strcmp(name, "") == 0))   /* no label */
417             strcpy(Stape, "none");
418         else {                  /* labeltape */
419 #ifdef AFS_NT40_ENV
420             if (!strcmp(name, TC_NULLTAPENAME)) /* pass "<NULL>" instead of <NULL> */
421                 strcpy(Stape, TC_QUOTEDNULLTAPENAME);
422             else
423 #endif
424                 strcpy(Stape, name);
425         }
426         CO_argv[4] = Stape;
427
428         /* The tape id */
429         if (!dbDumpId)
430             strcpy(Sdumpid, "none");
431         else
432             sprintf(Sdumpid, "%u", dbDumpId);
433         CO_argv[5] = Sdumpid;
434
435         CO_argv[6] = NULL;
436     }
437
438     CO_envp[0] = NULL;
439
440     pid = spawnprocve(callOut, CO_argv, CO_envp, 2);
441     if (pid < 0) {
442         ErrorLog(0, taskId, errno, 0,
443                  "Call to %s outside routine %s failed\n", Sopcode, callOut);
444         return 0;
445     }
446
447     return (pid);
448 }
449
450 /*
451  * unmountTape
452  *     Unmounts a tape and prints a warning if it can't unmount it.
453  *     Regardless of error, the closecallout routine will be called
454  *     (unless a tape is not mounted in the first place).
455  */
456 void
457 unmountTape(afs_int32 taskId, struct butm_tapeInfo *tapeInfoPtr)
458 {
459     afs_int32 code;
460     int cpid, status, rcpid;
461
462     code = butm_Dismount(tapeInfoPtr);
463     if (code && (code != BUTM_NOMOUNT))
464         ErrorLog(0, taskId, code, (tapeInfoPtr)->error,
465                  "Warning: Can't close tape\n");
466
467     if (tapemounted && closecallout) {
468         setStatus(taskId, CALL_WAIT);
469
470         cpid =
471             callOutRoutine(taskId, globalTapeConfig.device, CLOSEOPCODE, "",
472                            0, 1);
473         while (cpid) {          /* Wait until return */
474             status = 0;
475             rcpid = waitpid(cpid, &status, WNOHANG);
476             if (rcpid > 0) {
477                 tapemounted = 0;
478                 break;
479             }
480             if (rcpid == -1 && errno != EINTR) {
481                 tapemounted = 0;
482                 afs_com_err(whoami, errno,
483                         "Error waiting for callout script to terminate.");
484                 break;
485             }
486 #ifdef AFS_PTHREAD_ENV
487             sleep(1);
488 #else
489             IOMGR_Sleep(1);
490 #endif
491
492             if (checkAbortByTaskId(taskId)) {
493                 TLog(taskId, "Callout routine has been aborted\n");
494                 if (kill(cpid, SIGKILL))        /* Cancel callout */
495                     ErrorLog(0, taskId, errno, 0,
496                              "Kill of callout process %d failed\n", cpid);
497                 break;
498             }
499         }
500     }
501     clearStatus(taskId, CALL_WAIT);
502 }
503
504 /* PrintPrompt
505  *      print out prompt to operator
506  * calledby:
507  *      PromptForTape only.
508  */
509
510 void static
511 PrintPrompt(int flag, char *name, int dumpid)
512 {
513     char tapename[BU_MAXTAPELEN + 32];
514     char *dn;
515
516     TAPENAME(tapename, name, dumpid);
517
518     printf("******* OPERATOR ATTENTION *******\n");
519     printf("Device :  %s \n", globalTapeConfig.device);
520
521     switch (flag) {
522     case READOPCODE:            /* mount for restore */
523         printf("Please put in tape %s for reading", tapename);
524         break;
525
526     case APPENDOPCODE:          /* mount for dump (appends) */
527
528         dn = extractDumpName(name);
529
530         if (!dn || !dumpid)
531             printf("Please put in last tape of dump set for appending dump");
532         else
533             printf
534                 ("Please put in last tape of dump set for appending dump %s (DumpID %u)",
535                  dn, dumpid);
536         break;
537
538     case WRITEOPCODE:           /* mount for dump */
539         if (strcmp(name, "") == 0)
540             printf("Please put in tape for writing");
541
542         /* The name is what we are going to label the tape as */
543         else
544             printf("Please put in tape %s for writing", tapename);
545         break;
546
547     case LABELOPCODE:           /* mount for labeltape */
548         printf("Please put in tape to be labelled as %s", tapename);
549         break;
550
551     case READLABELOPCODE:       /* mount for readlabel */
552         printf("Please put in tape whose label is to be read");
553         break;
554
555     case SCANOPCODE:            /* mount for scantape */
556         if (strcmp(name, "") == 0)
557             printf("Please put in tape to be scanned");
558         else
559             printf("Please put in tape %s for scanning", tapename);
560         break;
561
562     case RESTOREDBOPCODE:       /* Mount for restoredb */
563         printf("Please insert a tape %s for the database restore", tapename);
564         break;
565
566     case SAVEDBOPCODE:          /* Mount for savedb */
567         printf("Please insert a writable tape %s for the database dump",
568                tapename);
569         break;
570
571     default:
572         break;
573     }
574     printf(" and hit return when done\n");
575 }
576
577 /* PromptForTape
578  *      Prompt the operator to change the tape.
579  *      Use to be a void routine but now returns an error. Some calls
580  *      don't use the error code.
581  * notes:
582  *      only external clients are in recoverDb.c. Was static PA
583  */
584 afs_int32
585 PromptForTape(int flag, char *name, afs_uint32 dbDumpId, afs_uint32 taskId,
586               int tapecount)
587 {
588     afs_int32 code = 0;
589     afs_int32 wcode;
590     afs_int32 start = 0;
591     char inchr;
592     int CallOut;
593     int cpid, status, rcpid;
594
595     if (checkAbortByTaskId(taskId))
596         ERROR_EXIT(TC_ABORTEDBYREQUEST);
597
598     if (dbDumpId)
599         TapeLog(2, taskId, 0, 0, "Prompt for tape %s (%u)\n", name, dbDumpId);
600     else
601         TapeLog(2, taskId, 0, 0, "Prompt for tape %s\n", name);
602
603     CallOut = (opencallout ? 1 : 0);
604     if (CallOut) {
605         setStatus(taskId, CALL_WAIT);
606
607         cpid =
608             callOutRoutine(taskId, globalTapeConfig.device, flag, name,
609                            dbDumpId, tapecount);
610         if (cpid == 0)
611             CallOut = 0;        /* prompt at screen */
612
613         while (CallOut) {       /* Check if callout routine finished */
614             status = 0;
615             rcpid = waitpid(cpid, &status, WNOHANG);
616             if (rcpid > 0) {
617                 if (rcpid != cpid)
618                     wcode = -1;
619                 else if (WIFEXITED(status))
620                     wcode = WEXITSTATUS(status);
621                 else
622                     wcode = -1;
623
624                 if (wcode == 0) {
625                     break;      /* All done */
626                 } else if (wcode == 1) {
627                     ERROR_EXIT(TC_ABORTEDBYREQUEST);    /* Abort */
628                 } else if ((flag == READOPCODE) && (wcode == 3)) {
629                     ERROR_EXIT(TC_SKIPTAPE);    /* Restore: skip the tape */
630                 } else {
631                     TLog(taskId,
632                          "Callout routine has exited with code %d: will prompt\n",
633                          wcode);
634                     CallOut = 0;        /* Switch to keyboard input */
635                     break;
636                 }
637             }
638             /* if waitpid experienced an error, we prompt */
639             if (rcpid == -1 && errno != EINTR) {
640                 afs_com_err(whoami, errno,
641                         "Error waiting for callout script to terminate.");
642                 TLog(taskId,
643                      "Can't get exit status from callout script. will prompt\n");
644                 CallOut = 0;
645                 break;
646             }
647 #ifdef AFS_PTHREAD_ENV
648             sleep(1);
649 #else
650             IOMGR_Sleep(1);
651 #endif
652
653             if (checkAbortByTaskId(taskId)) {
654                 printf
655                     ("This tape operation has been aborted by the coordinator.\n");
656
657                 if (kill(cpid, SIGKILL))        /* Cancel callout */
658                     ErrorLog(0, taskId, errno, 0,
659                              "Kill of callout process %d failed\n", cpid);
660
661                 ERROR_EXIT(TC_ABORTEDBYREQUEST);
662             }
663         }
664     }
665
666     if (!CallOut) {
667         clearStatus(taskId, CALL_WAIT);
668         setStatus(taskId, OPR_WAIT);
669
670         PrintPrompt(flag, name, dbDumpId);
671
672         /* Loop until we get ok to go ahead (or abort) */
673         while (1) {
674             if (time(0) > start + BELLTIME) {
675                 start = time(0);
676                 FFlushInput();
677                 putchar(BELLCHAR);
678                 fflush(stdout);
679             }
680             wcode = LWP_GetResponseKey(5, &inchr);      /* inchr stores key read */
681             if (wcode == 1) {   /* keyboard input is available */
682
683                 if ((inchr == 'a') || (inchr == 'A')) {
684                     printf("This tape operation has been aborted.\n");
685                     ERROR_EXIT(TC_ABORTEDBYREQUEST);    /* Abort command */
686                 } else if ((flag == READOPCODE)
687                            && ((inchr == 's') || (inchr == 'S'))) {
688                     printf("This tape will be skipped.\n");
689                     ERROR_EXIT(TC_SKIPTAPE);    /* Restore: skip the tape */
690                 }
691                 break;          /* continue */
692             }
693
694             if (checkAbortByTaskId(taskId)) {
695                 printf
696                     ("This tape operation has been aborted by the coordinator.\n");
697                 ERROR_EXIT(TC_ABORTEDBYREQUEST);
698             }
699         }
700
701     }
702
703     printf("Thanks, now proceeding with tape ");
704     switch (flag) {
705     case RESTOREDBOPCODE:
706     case READOPCODE:
707         printf("reading");
708         break;
709
710     case APPENDOPCODE:
711         printf("append writing");
712         break;
713
714     case SAVEDBOPCODE:
715     case WRITEOPCODE:
716         printf("writing");
717         break;
718
719     case LABELOPCODE:
720         printf("labelling");
721         break;
722
723     case READLABELOPCODE:
724         printf("label reading");
725         break;
726
727     case SCANOPCODE:
728         printf("scanning");
729         break;
730
731     default:
732         printf("unknown");
733         break;
734     }
735
736     printf(" operation.\n");
737     if (!CallOut)
738         printf("**********************************\n");
739
740     TapeLog(2, taskId, 0, 0, "Proceeding with tape operation\n");
741     tapemounted = 1;
742
743   error_exit:
744     clearStatus(taskId, (OPR_WAIT | CALL_WAIT));
745     return (code);
746 }
747
748
749 /* VolHeaderToHost
750  *      convert the fields in the tapeVolHeader into host byte order,
751  *      placing the converted copy of the structure into the hostVolHeader
752  * entry:
753  *      tapeVolHeader - points to volume header read from tape
754  *      hostVolHeader - pointer to struct for result
755  * exit:
756  *      hostVolHeader - information in host byte order
757  */
758
759 afs_int32
760 VolHeaderToHost(struct volumeHeader *hostVolHeader,
761                 struct volumeHeader *tapeVolHeader)
762 {
763     switch (ntohl(tapeVolHeader->versionflags)) {
764     case TAPE_VERSION_0:
765         /* sizes in bytes and fields in host order */
766         memcpy(tapeVolHeader, hostVolHeader, sizeof(struct volumeHeader));
767         break;
768
769     case TAPE_VERSION_1:
770     case TAPE_VERSION_2:
771     case TAPE_VERSION_3:        /* for present */
772     case TAPE_VERSION_4:
773         /* sizes in K and fields in network order */
774         /* do the conversion field by field */
775
776         strcpy(hostVolHeader->preamble, tapeVolHeader->preamble);
777         strcpy(hostVolHeader->postamble, tapeVolHeader->postamble);
778         strcpy(hostVolHeader->volumeName, tapeVolHeader->volumeName);
779         strcpy(hostVolHeader->dumpSetName, tapeVolHeader->dumpSetName);
780         hostVolHeader->volumeID = ntohl(tapeVolHeader->volumeID);
781         hostVolHeader->server = ntohl(tapeVolHeader->server);
782         hostVolHeader->part = ntohl(tapeVolHeader->part);
783         hostVolHeader->from = ntohl(tapeVolHeader->from);
784         hostVolHeader->frag = ntohl(tapeVolHeader->frag);
785         hostVolHeader->magic = ntohl(tapeVolHeader->magic);
786         hostVolHeader->contd = ntohl(tapeVolHeader->contd);
787         hostVolHeader->dumpID = ntohl(tapeVolHeader->dumpID);
788         hostVolHeader->level = ntohl(tapeVolHeader->level);
789         hostVolHeader->parentID = ntohl(tapeVolHeader->parentID);
790         hostVolHeader->endTime = ntohl(tapeVolHeader->endTime);
791         hostVolHeader->versionflags = ntohl(tapeVolHeader->versionflags);
792         hostVolHeader->cloneDate = ntohl(tapeVolHeader->cloneDate);
793         break;
794
795     default:
796         return (TC_BADVOLHEADER);
797     }
798     return (0);
799 }
800
801 afs_int32
802 ReadVolHeader(afs_int32 taskId,
803               struct butm_tapeInfo *tapeInfoPtr,
804               struct volumeHeader *volHeaderPtr)
805 {
806     afs_int32 code = 0;
807     afs_int32 nbytes;
808     struct volumeHeader volHead;
809
810     /* Read the volume header */
811     code =
812         butm_ReadFileData(tapeInfoPtr, tapeBlock.data, sizeof(tapeVolumeHT),
813                           &nbytes);
814     if (code) {
815         ErrorLog(0, taskId, code, tapeInfoPtr->error,
816                  "Can't read volume header on tape\n");
817         ERROR_EXIT(code);
818     }
819
820     code = readVolumeHeader(tapeBlock.data, 0L, &volHead);
821     if (code) {
822         ErrorLog(0, taskId, code, 0,
823                  "Can't find volume header on tape block\n");
824         ERROR_EXIT(code);
825     }
826
827     code = VolHeaderToHost(volHeaderPtr, &volHead);
828     if (code) {
829         ErrorLog(0, taskId, code, 0, "Can't convert volume header\n");
830         ERROR_EXIT(code);
831     }
832
833   error_exit:
834     return code;
835 }
836
837 afs_int32 static
838 GetVolumeHead(afs_int32 taskId, struct butm_tapeInfo *tapeInfoPtr,
839               afs_int32 position, char *volName, afs_int32 volId)
840 {
841     afs_int32 code = 0;
842     struct volumeHeader tapeVolHeader;
843
844     /* Position directly to the volume and read the header */
845     if (position) {
846         code = butm_Seek(tapeInfoPtr, position);
847         if (code) {
848             ErrorLog(0, taskId, code, tapeInfoPtr->error,
849                      "Can't seek to position %u on tape\n", position);
850             ERROR_EXIT(code);
851         }
852
853         code = butm_ReadFileBegin(tapeInfoPtr);
854         if (code) {
855             ErrorLog(0, taskId, code, tapeInfoPtr->error,
856                      "Can't read FileBegin on tape\n");
857             ERROR_EXIT(code);
858         }
859
860         /* Read the volume header */
861         code = ReadVolHeader(taskId, tapeInfoPtr, &tapeVolHeader);
862         if (code)
863             ERROR_EXIT(code);
864
865         /* Check if volume header matches */
866         if (strcmp(tapeVolHeader.volumeName, volName))
867             ERROR_EXIT(TC_BADVOLHEADER);
868         if (volId && (tapeVolHeader.volumeID != volId))
869             ERROR_EXIT(TC_BADVOLHEADER);
870         if (tapeVolHeader.magic != TC_VOLBEGINMAGIC)
871             ERROR_EXIT(TC_BADVOLHEADER);
872     }
873
874     /* Do a sequential search for the volume */
875     else {
876         while (1) {
877             code = butm_ReadFileBegin(tapeInfoPtr);
878             if (code) {
879                 ErrorLog(0, taskId, code, tapeInfoPtr->error,
880                          "Can't read FileBegin on tape\n");
881                 ERROR_EXIT(code);
882             }
883
884             code = ReadVolHeader(taskId, tapeInfoPtr, &tapeVolHeader);
885             if (code)
886                 ERROR_EXIT(TC_VOLUMENOTONTAPE);
887
888             /* Test if we found the volume */
889             if ((strcmp(tapeVolHeader.volumeName, volName) == 0)
890                 && (!volId || (volId == tapeVolHeader.volumeID)))
891                 break;
892
893             /* skip to the next HW EOF marker */
894             code = SeekFile(tapeInfoPtr, 1);
895             if (code) {
896                 ErrorLog(0, taskId, code, tapeInfoPtr->error,
897                          "Can't seek to next EOF on tape\n");
898                 ERROR_EXIT(code);
899             }
900         }
901     }
902
903   error_exit:
904     return code;
905 }
906
907 afs_int32
908 GetRestoreTape(afs_int32 taskId, struct butm_tapeInfo *tapeInfoPtr,
909                char *tname, afs_int32 tapeID, int prompt)
910 {
911     struct butm_tapeLabel tapeLabel;
912     afs_int32 code = 0, rc;
913     int tapecount = 1;
914     struct budb_dumpEntry dumpEntry;
915
916     /* Make sure that the dump/tape is not a XBSA dump */
917     rc = bcdb_FindDumpByID(tapeID, &dumpEntry);
918     if (!rc && (dumpEntry.flags & (BUDB_DUMP_ADSM | BUDB_DUMP_BUTA))) {
919         ErrorLog(0, taskId, 0, 0,
920                  "Volumes from dump %u are XBSA dumps (skipping)\n", tapeID);
921         ERROR_EXIT(TC_SKIPTAPE);
922     }
923
924     while (1) {
925         if (prompt) {
926             code =
927                 PromptForTape(READOPCODE, tname, tapeID, taskId, tapecount);
928             if (code)
929                 ERROR_EXIT(code);
930         }
931         prompt = 1;
932         tapecount++;
933
934         code = butm_Mount(tapeInfoPtr, tname);
935         if (code) {
936             TapeLog(0, taskId, code, tapeInfoPtr->error, "Can't open tape\n");
937             goto newtape;
938         }
939
940         code = butm_ReadLabel(tapeInfoPtr, &tapeLabel, 1);
941         if (code) {
942             ErrorLog(0, taskId, code, tapeInfoPtr->error,
943                      "Can't read tape label\n");
944             goto newtape;
945         }
946
947         /* Now check the label to see if the tapename matches or tapeids match */
948         if (strcmp(TNAME(&tapeLabel), tname)
949             || ((tapeLabel.structVersion >= TAPE_VERSION_3)
950                 && (tapeLabel.dumpid != tapeID))) {
951             char expectedName[BU_MAXTAPELEN + 32],
952                 gotName[BU_MAXTAPELEN + 32];
953
954             TAPENAME(expectedName, tname, tapeID);
955             LABELNAME(gotName, &tapeLabel);
956
957             TapeLog(0, taskId, 0, 0,
958                     "Tape label expected %s, label seen %s\n", expectedName,
959                     gotName);
960             goto newtape;
961         }
962
963         break;
964
965       newtape:
966         unmountTape(taskId, tapeInfoPtr);
967     }
968
969   error_exit:
970     return code;
971 }
972
973 afs_int32
974 xbsaRestoreVolumeData(struct rx_call *call, void *rock)
975 {
976     afs_int32 code = 0;
977 #ifdef xbsa
978     struct restoreParams *rparamsPtr = (struct restoreParams *)rock;
979     afs_int32 curChunk, rc;
980     afs_uint32 totalWritten;
981     afs_int32 headBytes, tailBytes, w;
982     afs_int32 taskId;
983     struct volumeHeader volTrailer;
984     afs_int32 vtsize = 0;
985     int found;
986     struct dumpNode *nodePtr;
987     struct tc_restoreDesc *Restore;
988     afs_int32 bytesRead, tbuffersize, endData = 0;
989     char *buffer = (char *)bufferBlock, tbuffer[256];
990
991     nodePtr = rparamsPtr->nodePtr;
992     Restore = nodePtr->restores;
993     taskId = nodePtr->taskID;
994
995     /* Read the volume fragment one block at a time until
996      * find a volume trailer
997      */
998     curChunk = BIGCHUNK + 1;
999     tbuffersize = 0;
1000     totalWritten = 0;
1001
1002     while (!endData) {
1003         rc = xbsa_ReadObjectData(&butxInfo, buffer, dataSize, &bytesRead,
1004                                  &endData);
1005         if (restoretofile && (bytesRead > 0)) {
1006             fwrite(buffer, bytesRead, 1, restoretofilefd);      /* Save to a file */
1007         }
1008         if (rc != XBSA_SUCCESS) {
1009             ErrorLog(0, taskId, rc, 0,
1010                      "Unable to read volume data from the server\n");
1011             ERROR_EXIT(rc);
1012         }
1013
1014         /* Periodically update status structure and check if should abort */
1015         curChunk += bytesRead;
1016         if (curChunk > BIGCHUNK) {
1017             curChunk = 0;
1018             lock_Status();
1019             nodePtr->statusNodePtr->nKBytes = totalWritten / 1024;
1020             unlock_Status();
1021
1022             if (checkAbortByTaskId(taskId))
1023                 ERROR_EXIT(TC_ABORTEDBYREQUEST);
1024         }
1025
1026         if (!endData && (bytesRead > 0)) {
1027             /* Fill tbuffer up with data from end of buffer and write
1028              * the remainder of buffer out.
1029              */
1030             if ((tbuffersize == 0) || (bytesRead >= sizeof(tbuffer))) {
1031                 /* Write out contents of tbuffer */
1032                 if (tbuffersize) {
1033                     w = rx_Write(call, tbuffer, tbuffersize);
1034                     if (w != tbuffersize) {
1035                         ErrorLog(0, taskId, -1, 0,
1036                                  "Error in RX write: Wrote %d bytes\n", w);
1037                         ERROR_EXIT(-1);
1038                     }
1039                     totalWritten += w;
1040                 }
1041                 /* fill tbuffer with end of buffer */
1042                 bytesRead -= sizeof(tbuffer);
1043                 memcpy(tbuffer, buffer + bytesRead, sizeof(tbuffer));
1044                 tbuffersize = sizeof(tbuffer);
1045                 /* Write out whatever is left over in buffer */
1046                 if (bytesRead) {
1047                     w = rx_Write(call, buffer, bytesRead);
1048                     if (w != bytesRead) {
1049                         ErrorLog(0, taskId, -1, 0,
1050                                  "Error in RX data write: Wrote %d bytes\n",
1051                                  w);
1052                         ERROR_EXIT(-1);
1053                     }
1054                     totalWritten += w;
1055                     bytesRead = 0;
1056                 }
1057             } else if ((tbuffersize + bytesRead) <= sizeof(tbuffer)) {
1058                 /* Copy all of buffer into tbuffer (it will fit) */
1059                 memcpy(tbuffer + tbuffersize, buffer, bytesRead);
1060                 tbuffersize += bytesRead;
1061                 bytesRead = 0;
1062             } else {
1063                 /* We need to write some of tbuffer out and fill it with buffer */
1064                 int towrite = bytesRead - (sizeof(tbuffer) - tbuffersize);
1065                 w = rx_Write(call, tbuffer, towrite);
1066                 if (w != towrite) {
1067                     ErrorLog(0, taskId, -1, 0,
1068                              "Error in RX write: Wrote %d bytes\n", w);
1069                     ERROR_EXIT(-1);
1070                 }
1071                 totalWritten += w;
1072                 tbuffersize -= w;
1073
1074                 /* Move the data in tbuffer up */
1075                 memcpy(tbuffer, tbuffer + towrite, tbuffersize);
1076
1077                 /* Now copy buffer in */
1078                 memcpy(tbuffer + tbuffersize, buffer, bytesRead);
1079                 tbuffersize += bytesRead;
1080                 bytesRead = 0;
1081             }
1082         }
1083     }
1084
1085     /* Pull the volume trailer from the last two buffers */
1086     found =
1087         FindVolTrailer2(tbuffer, tbuffersize, &headBytes, buffer, bytesRead,
1088                         &tailBytes, &volTrailer);
1089
1090     if (!found) {
1091         ErrorLog(0, taskId, TC_MISSINGTRAILER, 0, "Missing volume trailer\n");
1092         ERROR_EXIT(TC_MISSINGTRAILER);
1093     }
1094
1095     /* Now rx_write the data in the last two blocks */
1096     if (headBytes) {
1097         w = rx_Write(call, tbuffer, headBytes);
1098         if (w != headBytes) {
1099             ErrorLog(0, taskId, -1, 0,
1100                      "Error in RX trail1 write: Wrote %d bytes\n", w);
1101             ERROR_EXIT(-1);
1102         }
1103         totalWritten += w;
1104     }
1105     if (tailBytes) {
1106         w = rx_Write(call, buffer, tailBytes);
1107         if (w != tailBytes) {
1108             ErrorLog(0, taskId, -1, 0,
1109                      "Error in RX trail2 write: Wrote %d bytes\n", w);
1110             ERROR_EXIT(-1);
1111         }
1112         totalWritten += w;
1113     }
1114
1115   error_exit:
1116 #endif /*xbsa */
1117     return code;
1118 }
1119
1120 /* restoreVolume
1121  *      sends the contents of volume dump  to Rx Stream associated
1122  *      with <call>
1123  */
1124
1125 afs_int32
1126 restoreVolumeData(struct rx_call *call, void *rock)
1127 {
1128     struct restoreParams *rparamsPtr = (struct restoreParams *)rock;
1129     afs_int32 curChunk;
1130     afs_uint32 totalWritten = 0;
1131     afs_int32 code = 0;
1132     afs_int32 headBytes, tailBytes, w;
1133     afs_int32 taskId;
1134     afs_int32 nbytes;           /* # bytes data in last tape block read */
1135     struct volumeHeader tapeVolTrailer;
1136     int found;
1137     int moretoread;
1138     afs_int32 startRbuf, endRbuf, startWbuf, endWbuf, buf, pbuf, lastbuf;
1139     struct tc_restoreDesc *Restore;
1140     struct dumpNode *nodePtr;
1141     struct butm_tapeInfo *tapeInfoPtr;
1142     char *origVolName;
1143     afs_int32 origVolID;
1144
1145     nodePtr = rparamsPtr->nodePtr;
1146     taskId = nodePtr->taskID;
1147     Restore = nodePtr->restores;
1148     tapeInfoPtr = rparamsPtr->tapeInfoPtr;
1149     origVolName = Restore[rparamsPtr->frag].oldName;
1150     origVolID = Restore[rparamsPtr->frag].origVid;
1151
1152     /* Read the volume one fragment at a time */
1153     while (rparamsPtr->frag < nodePtr->arraySize) {
1154         /*w */
1155         curChunk = BIGCHUNK + 1;        /* Check if should abort */
1156
1157         /* Read the volume fragment one block at a time until
1158          * find a volume trailer
1159          */
1160         moretoread = 1;
1161         startRbuf = 0;
1162         endRbuf = 0;
1163         startWbuf = 0;
1164         while (moretoread) {
1165             /* Fill the circular buffer with tape blocks
1166              * Search for volume trailer in the process.
1167              */
1168             buf = startRbuf;
1169             do {
1170                 code =
1171                     butm_ReadFileData(tapeInfoPtr, bufferBlock[buf].data,
1172                                       BUTM_BLKSIZE, &nbytes);
1173                 if (code) {
1174                     ErrorLog(0, taskId, code, tapeInfoPtr->error,
1175                              "Can't read FileData on tape %s\n",
1176                              rparamsPtr->mntTapeName);
1177                     ERROR_EXIT(code);
1178                 }
1179                 curChunk += BUTM_BLKSIZE;
1180
1181                 /* Periodically update status structure and check if should abort */
1182                 if (curChunk > BIGCHUNK) {
1183                     curChunk = 0;
1184
1185                     lock_Status();
1186                     nodePtr->statusNodePtr->nKBytes = totalWritten / 1024;
1187                     unlock_Status();
1188
1189                     if (checkAbortByTaskId(taskId))
1190                         ERROR_EXIT(TC_ABORTEDBYREQUEST);
1191                 }
1192
1193                 /* step to next block in buffer */
1194                 pbuf = buf;
1195                 buf = ((buf + 1) == tapeblocks) ? 0 : (buf + 1);
1196
1197                 /* If this is the end of the volume, the exit the loop */
1198                 if ((nbytes != BUTM_BLKSIZE)
1199                     ||
1200                     (FindVolTrailer
1201                      (bufferBlock[pbuf].data, nbytes, &tailBytes,
1202                       &tapeVolTrailer)))
1203                     moretoread = 0;
1204
1205             } while (moretoread && (buf != endRbuf));
1206
1207             /* Write the buffer upto (but not including) the last read block
1208              * If volume is completely read, then leave the last two blocks.
1209              */
1210             lastbuf = endWbuf = pbuf;
1211             if (!moretoread && (endWbuf != startWbuf))
1212                 endWbuf = (endWbuf == 0) ? (tapeblocks - 1) : (endWbuf - 1);
1213
1214             for (buf = startWbuf; buf != endWbuf;
1215                  buf = (((buf + 1) == tapeblocks) ? 0 : (buf + 1))) {
1216                 w = rx_Write(call, bufferBlock[buf].data, BUTM_BLKSIZE);
1217                 if (w != BUTM_BLKSIZE) {
1218                     ErrorLog(0, taskId, -1, 0, "Error in RX write\n");
1219                     ERROR_EXIT(-1);
1220                 }
1221                 totalWritten += BUTM_BLKSIZE;
1222             }
1223
1224             /* Setup pointers to refill buffer */
1225             startRbuf = ((lastbuf + 1) == tapeblocks) ? 0 : (lastbuf + 1);
1226             endRbuf = endWbuf;
1227             startWbuf = endWbuf;
1228         }
1229
1230         /* lastbuf is last block read and it has nbytes of data
1231          * startWbuf is the 2nd to last block read
1232          * Seach for the volume trailer in these two blocks.
1233          */
1234         if (lastbuf == startWbuf)
1235             found =
1236                 FindVolTrailer2(NULL, 0, &headBytes,
1237                                 bufferBlock[lastbuf].data, nbytes, &tailBytes,
1238                                 &tapeVolTrailer);
1239         else
1240             found =
1241                 FindVolTrailer2(bufferBlock[startWbuf].data, BUTM_BLKSIZE,
1242                                 &headBytes, bufferBlock[lastbuf].data, nbytes,
1243                                 &tailBytes, &tapeVolTrailer);
1244         if (!found) {
1245             ErrorLog(0, taskId, TC_MISSINGTRAILER, 0,
1246                      "Missing volume trailer on tape %s\n",
1247                      rparamsPtr->mntTapeName);
1248             ERROR_EXIT(TC_MISSINGTRAILER);
1249         }
1250
1251         /* Now rx_write the data in the last two blocks */
1252         if (headBytes) {
1253             w = rx_Write(call, bufferBlock[startWbuf].data, headBytes);
1254             if (w != headBytes) {
1255                 ErrorLog(0, taskId, -1, 0, "Error in RX write\n");
1256                 ERROR_EXIT(-1);
1257             }
1258             totalWritten += headBytes;
1259         }
1260         if (tailBytes) {
1261             w = rx_Write(call, bufferBlock[lastbuf].data, tailBytes);
1262             if (w != tailBytes) {
1263                 ErrorLog(0, taskId, -1, 0, "Error in RX write\n");
1264                 ERROR_EXIT(-1);
1265             }
1266             totalWritten += tailBytes;
1267         }
1268
1269         /* Exit the loop if the volume is not continued on next tape */
1270         if (!tapeVolTrailer.contd)
1271             break;              /* We've read the entire volume */
1272
1273         /* Volume is continued on next tape.
1274          * Step to the next volume fragment and prompt for its tape.
1275          * When a volume has multiple frags, those frags are on different
1276          * tapes. So we know that we need to prompt for a tape.
1277          */
1278         rparamsPtr->frag++;
1279         if (rparamsPtr->frag >= nodePtr->arraySize)
1280             break;
1281
1282         unmountTape(taskId, tapeInfoPtr);
1283         strcpy(rparamsPtr->mntTapeName, Restore[rparamsPtr->frag].tapeName);
1284         rparamsPtr->tapeID =
1285             (Restore[rparamsPtr->frag].
1286              initialDumpId ? Restore[rparamsPtr->frag].
1287              initialDumpId : Restore[rparamsPtr->frag].dbDumpId);
1288         code =
1289             GetRestoreTape(taskId, tapeInfoPtr, rparamsPtr->mntTapeName,
1290                            rparamsPtr->tapeID, 1);
1291         if (code)
1292             ERROR_EXIT(code);
1293
1294         /* Position to the frag and read the volume header */
1295         code =
1296             GetVolumeHead(taskId, tapeInfoPtr,
1297                           Restore[rparamsPtr->frag].position, origVolName,
1298                           origVolID);
1299         if (code) {
1300             ErrorLog(0, taskId, code, 0,
1301                      "Can't find volume %s (%u) on tape %s\n", origVolName,
1302                      origVolID, rparamsPtr->mntTapeName);
1303             ERROR_EXIT(TC_VOLUMENOTONTAPE);
1304         }
1305     }                           /*w */
1306
1307   error_exit:
1308     return code;
1309 }
1310
1311 /* SkipTape
1312  *    Find all the volumes on a specific tape and mark them to skip.
1313  */
1314 int
1315 SkipTape(struct tc_restoreDesc *Restore, afs_int32 size, afs_int32 index,
1316          char *tapename, afs_int32 tapeid, afs_int32 taskid)
1317 {
1318     afs_int32 i, tid;
1319
1320     for (i = index; i < size; i++) {
1321         if (Restore[i].flags & RDFLAG_SKIP)
1322             continue;
1323         tid =
1324             (Restore[i].initialDumpId ? Restore[i].initialDumpId : Restore[i].
1325              dbDumpId);
1326         if ((strcmp(Restore[i].tapeName, tapename) == 0) && (tid == tapeid)) {
1327             SkipVolume(Restore, size, i, Restore[i].origVid, taskid);
1328         }
1329     }
1330     return 0;
1331 }
1332
1333 /* SkipVolume
1334  *    Find all the entries for a volume and mark them to skip.
1335  */
1336 int
1337 SkipVolume(struct tc_restoreDesc *Restore, afs_int32 size, afs_int32 index,
1338            afs_int32 volid, afs_int32 taskid)
1339 {
1340     afs_int32 i;
1341     int report = 1;
1342
1343     for (i = index; i < size; i++) {
1344         if (Restore[i].flags & RDFLAG_SKIP)
1345             continue;
1346         if (Restore[i].origVid == volid) {
1347             Restore[i].flags |= RDFLAG_SKIP;
1348             if (report) {
1349                 TLog(taskid, "Restore: Skipping %svolume %s (%u)\n",
1350                      ((Restore[i].dumpLevel == 0) ? "" : "remainder of "),
1351                      Restore[i].oldName, volid);
1352                 report = 0;
1353             }
1354         }
1355     }
1356     return 0;
1357 }
1358
1359 int
1360 xbsaRestoreVolume(afs_uint32 taskId, struct tc_restoreDesc *restoreInfo,
1361                   struct restoreParams *rparamsPtr)
1362 {
1363     afs_int32 code = 0;
1364 #ifdef xbsa
1365     afs_int32 rc;
1366     afs_int32 newServer, newPart, newVolId;
1367     char *newVolName;
1368     int restoreflags, havetrans = 0, startread = 0;
1369     afs_int32 bytesRead, endData = 0;
1370     afs_uint32 dumpID;
1371     struct budb_dumpEntry dumpEntry;
1372     char volumeNameStr[XBSA_MAX_PATHNAME], dumpIdStr[XBSA_MAX_OSNAME];
1373     struct volumeHeader volHeader, hostVolHeader;
1374
1375     if (restoretofile) {
1376         restoretofilefd = fopen(restoretofile, "w+");
1377     }
1378
1379     dumpID = restoreInfo->dbDumpId;
1380
1381     rc = bcdb_FindDumpByID(dumpID, &dumpEntry);
1382     if (rc) {
1383         ErrorLog(0, taskId, rc, 0, "Can't read database for dump %u\n",
1384                  dumpID);
1385         ERROR_EXIT(rc);
1386     }
1387
1388     /* ADSM servers restore ADSM and BUTA dumps */
1389     if ((xbsaType == XBSA_SERVER_TYPE_ADSM)
1390         && !(dumpEntry.flags & (BUDB_DUMP_ADSM | BUDB_DUMP_BUTA))) {
1391         ELog(taskId,
1392              "The dump requested by this restore operation for the "
1393              "volumeset is incompatible with this instance of butc\n");
1394         /* Skip the entire dump (one dump per tape) */
1395         ERROR_EXIT(TC_SKIPTAPE);
1396     }
1397
1398     /* make sure we are connected to the correct server. */
1399     if ((strlen((char *)dumpEntry.tapes.tapeServer) != 0)
1400         && (strcmp((char *)dumpEntry.tapes.tapeServer, butxInfo.serverName) !=
1401             0)) {
1402         if ((dumpEntry.flags & (BUDB_DUMP_XBSA_NSS | BUDB_DUMP_BUTA))
1403             && !forcemultiple) {
1404             TLog(taskId,
1405                  "Dump %d is on server %s but butc is connected "
1406                  "to server %s (attempting to restore)\n", dumpID,
1407                  (char *)dumpEntry.tapes.tapeServer, butxInfo.serverName);
1408         } else {
1409             TLog(taskId,
1410                  "Dump %d is on server %s but butc is connected "
1411                  "to server %s (switching servers)\n", dumpID,
1412                  (char *)dumpEntry.tapes.tapeServer, butxInfo.serverName);
1413
1414             rc = InitToServer(taskId, &butxInfo,
1415                               (char *)dumpEntry.tapes.tapeServer);
1416             if (rc != XBSA_SUCCESS)
1417                 ERROR_EXIT(TC_SKIPTAPE);
1418         }
1419     }
1420
1421     /* Start a transaction and query the server for the correct fileset dump */
1422     rc = xbsa_BeginTrans(&butxInfo);
1423     if (rc != XBSA_SUCCESS) {
1424         ELog(taskId, "Unable to create a new transaction\n");
1425         ERROR_EXIT(TC_SKIPTAPE);
1426     }
1427     havetrans = 1;
1428
1429     if (dumpEntry.flags & BUDB_DUMP_BUTA) {     /* old buta style names */
1430         sprintf(dumpIdStr, "/%d", dumpID);
1431         strcpy(volumeNameStr, "/");
1432         strcat(volumeNameStr, restoreInfo->oldName);
1433     } else {                    /* new butc names */
1434         extern char *butcdumpIdStr;
1435         strcpy(dumpIdStr, butcdumpIdStr);
1436         sprintf(volumeNameStr, "/%d", dumpID);
1437         strcat(volumeNameStr, "/");
1438         strcat(volumeNameStr, restoreInfo->oldName);
1439     }
1440
1441     rc = xbsa_QueryObject(&butxInfo, dumpIdStr, volumeNameStr);
1442     if (rc != XBSA_SUCCESS) {
1443         ELog(taskId,
1444              "Unable to locate object (%s) of dump (%s) on the server\n",
1445              volumeNameStr, dumpIdStr);
1446         ERROR_EXIT(rc);
1447     }
1448
1449     rc = xbsa_EndTrans(&butxInfo);
1450     havetrans = 0;
1451     if (rc != XBSA_SUCCESS) {
1452         ELog(taskId, "Unable to terminate the current transaction\n");
1453         ERROR_EXIT(rc);
1454     }
1455
1456     if (checkAbortByTaskId(taskId))
1457         ERROR_EXIT(TC_ABORTEDBYREQUEST);
1458
1459     /* Now start a transaction on the volume to restore and read the
1460      * volumeheader. We do this before starting a transaction on
1461      * volserver to restore the volume because the XBSA server may take
1462      * a while to mount and seek to the volume causing the volserver to
1463      * time out.
1464      */
1465     rc = xbsa_BeginTrans(&butxInfo);
1466     if (rc != XBSA_SUCCESS) {
1467         ELog(taskId, "Unable to create a new transaction\n");
1468         ERROR_EXIT(TC_SKIPTAPE);
1469     }
1470     havetrans = 1;
1471
1472     rc = xbsa_ReadObjectBegin(&butxInfo, (char *)&volHeader,
1473                               sizeof(volHeader), &bytesRead, &endData);
1474     if (restoretofile && (bytesRead > 0)) {
1475         fwrite((char *)&volHeader, bytesRead, 1, restoretofilefd);      /* Save to a file */
1476     }
1477     if (rc != XBSA_SUCCESS) {
1478         ELog(taskId,
1479              "Unable to begin reading of the volume from the server\n");
1480         ERROR_EXIT(rc);
1481     }
1482     startread = 1;
1483
1484     if ((bytesRead != sizeof(volHeader)) || endData) {
1485         ELog(taskId,
1486              "The size of data read (%d) does not equal the size of data requested (%d)\n",
1487              bytesRead, sizeof(volHeader));
1488         ERROR_EXIT(TC_BADVOLHEADER);
1489     }
1490
1491     /* convert and check the volume header */
1492     rc = VolHeaderToHost(&hostVolHeader, &volHeader);
1493     if (rc) {
1494         ErrorLog(0, taskId, code, 0, "Can't convert volume header\n");
1495         ERROR_EXIT(rc);
1496     }
1497
1498     if ((strcmp(hostVolHeader.volumeName, restoreInfo->oldName) != 0)
1499         || (restoreInfo->origVid
1500             && (hostVolHeader.volumeID != restoreInfo->origVid))
1501         || (hostVolHeader.magic != TC_VOLBEGINMAGIC))
1502         ERROR_EXIT(TC_BADVOLHEADER);
1503
1504     /* Set up prior restoring volume data */
1505     newVolName = restoreInfo->newName;
1506     newVolId = restoreInfo->vid;
1507     newServer = restoreInfo->hostAddr;
1508     newPart = restoreInfo->partition;
1509     restoreflags = 0;
1510     if ((restoreInfo->dumpLevel == 0)
1511         || (restoreInfo->flags & RDFLAG_FIRSTDUMP))
1512         restoreflags |= RV_FULLRST;
1513     if (!(restoreInfo->flags & RDFLAG_LASTDUMP))
1514         restoreflags |= RV_OFFLINE;
1515
1516     if (checkAbortByTaskId(taskId))
1517         ERROR_EXIT(TC_ABORTEDBYREQUEST);
1518
1519     /* Start the restore of the volume data. This is the code we want to return */
1520     code =
1521         UV_RestoreVolume(htonl(newServer), newPart, newVolId, newVolName,
1522                          restoreflags, xbsaRestoreVolumeData,
1523                          (char *)rparamsPtr);
1524   error_exit:
1525     if (startread) {
1526         rc = xbsa_ReadObjectEnd(&butxInfo);
1527         if (rc != XBSA_SUCCESS) {
1528             ELog(taskId,
1529                  "Unable to terminate reading of the volume from the server\n");
1530             ERROR_EXIT(rc);
1531         }
1532     }
1533
1534     if (havetrans) {
1535         rc = xbsa_EndTrans(&butxInfo);
1536         if (rc != XBSA_SUCCESS) {
1537             ELog(taskId, "Unable to terminate the current transaction\n");
1538             if (!code)
1539                 code = rc;
1540         }
1541     }
1542
1543     if (restoretofile && restoretofilefd) {
1544         fclose(restoretofilefd);
1545     }
1546 #endif
1547     return (code);
1548 }
1549
1550 int
1551 restoreVolume(afs_uint32 taskId, struct tc_restoreDesc *restoreInfo,
1552               struct restoreParams *rparamsPtr)
1553 {
1554     afs_int32 code = 0, rc;
1555     afs_int32 newServer, newPart, newVolId;
1556     char *newVolName;
1557     int restoreflags;
1558     afs_uint32 tapeID;
1559     struct butm_tapeInfo *tapeInfoPtr = rparamsPtr->tapeInfoPtr;
1560
1561     /* Check if we need a tape and prompt for one if so */
1562     tapeID =
1563         (restoreInfo->initialDumpId ? restoreInfo->
1564          initialDumpId : restoreInfo->dbDumpId);
1565     if ((rparamsPtr->frag == 0)
1566         || (strcmp(restoreInfo->tapeName, rparamsPtr->mntTapeName) != 0)
1567         || (tapeID != rparamsPtr->tapeID)) {
1568         /* Unmount the previous tape */
1569         unmountTape(taskId, tapeInfoPtr);
1570
1571         /* Remember this new tape */
1572         strcpy(rparamsPtr->mntTapeName, restoreInfo->tapeName);
1573         rparamsPtr->tapeID = tapeID;
1574
1575         /* Mount a new tape */
1576         rc = GetRestoreTape(taskId, tapeInfoPtr, rparamsPtr->mntTapeName,
1577                             rparamsPtr->tapeID,
1578                             ((rparamsPtr->frag == 0) ? autoQuery : 1));
1579         if (rc)
1580             ERROR_EXIT(rc);
1581     }
1582
1583     /* Seek to the correct spot and read the header information */
1584     rc = GetVolumeHead(taskId, tapeInfoPtr, restoreInfo->position,
1585                        restoreInfo->oldName, restoreInfo->origVid);
1586     if (rc)
1587         ERROR_EXIT(rc);
1588
1589     /* Set up prior restoring volume data */
1590     newVolName = restoreInfo->newName;
1591     newVolId = restoreInfo->vid;
1592     newServer = restoreInfo->hostAddr;
1593     newPart = restoreInfo->partition;
1594     restoreflags = 0;
1595     if ((restoreInfo->dumpLevel == 0)
1596         || (restoreInfo->flags & RDFLAG_FIRSTDUMP))
1597         restoreflags |= RV_FULLRST;
1598     if (!(restoreInfo->flags & RDFLAG_LASTDUMP))
1599         restoreflags |= RV_OFFLINE;
1600
1601     if (checkAbortByTaskId(taskId))
1602         ERROR_EXIT(TC_ABORTEDBYREQUEST);
1603
1604     /* Start the restore of the volume data. This is the code we
1605      * want to return.
1606      */
1607     code =
1608         UV_RestoreVolume(htonl(newServer), newPart, newVolId, newVolName,
1609                          restoreflags, restoreVolumeData, (char *)rparamsPtr);
1610
1611     /* Read the FileEnd marker for the volume and step to next FM */
1612     rc = butm_ReadFileEnd(tapeInfoPtr);
1613     if (rc) {
1614         ErrorLog(0, taskId, rc, tapeInfoPtr->error,
1615                  "Can't read EOF on tape\n");
1616     }
1617
1618   error_exit:
1619     return (code);
1620 }
1621
1622 /* Restorer
1623  *      created as a LWP by the server stub, <newNode> is a pointer to all
1624  *      the parameters Restorer needs
1625  */
1626 void *
1627 Restorer(void *param) {
1628     struct dumpNode *newNode = (struct dumpNode *) param;
1629
1630     afs_int32 code = 0, tcode;
1631     afs_uint32 taskId;
1632     char *newVolName;
1633     struct butm_tapeInfo tapeInfo;
1634     struct tc_restoreDesc *Restore;
1635     struct tc_restoreDesc *RestoreDesc;
1636     struct restoreParams rparams;
1637     afs_int32 allocbufferSize;
1638     time_t startTime, endTime;
1639     afs_int32 goodrestore = 0;
1640
1641     afs_pthread_setname_self("restorer");
1642     taskId = newNode->taskID;
1643     setStatus(taskId, DRIVE_WAIT);
1644     EnterDeviceQueue(deviceLatch);
1645     clearStatus(taskId, DRIVE_WAIT);
1646
1647     printf("\n\n");
1648     TLog(taskId, "Restore\n");
1649
1650     memset(&tapeInfo, 0, sizeof(tapeInfo));
1651     if (!CONF_XBSA) {
1652         tapeInfo.structVersion = BUTM_MAJORVERSION;
1653         tcode = butm_file_Instantiate(&tapeInfo, &globalTapeConfig);
1654         if (tcode) {
1655             ErrorLog(0, taskId, tcode, tapeInfo.error,
1656                      "Can't initialize the tape module\n");
1657             ERROR_EXIT(tcode);
1658         }
1659     }
1660
1661     if (checkAbortByTaskId(taskId))
1662         ERROR_EXIT(TC_ABORTEDBYREQUEST);
1663
1664     memset(&rparams, 0, sizeof(rparams));
1665     rparams.nodePtr = newNode;
1666     rparams.tapeInfoPtr = &tapeInfo;
1667     Restore = newNode->restores;        /* Array of vol fragments to restore */
1668
1669     /* Allocate memory in which to restore the volumes data into */
1670     if (CONF_XBSA) {
1671         allocbufferSize = dataSize = BufferSize;
1672     } else {
1673         /* Must have at least two tape blocks */
1674         tapeblocks = BufferSize / BUTM_BLOCKSIZE;
1675         if (tapeblocks < 2)
1676             tapeblocks = 2;
1677         allocbufferSize = tapeblocks * BUTM_BLOCKSIZE;  /* This many full tapeblocks */
1678     }
1679     bufferBlock = NULL;
1680     bufferBlock = (struct TapeBlock *)malloc(allocbufferSize);
1681     if (!bufferBlock)
1682         ERROR_EXIT(TC_NOMEMORY);
1683     memset(bufferBlock, 0, allocbufferSize);
1684
1685     startTime = time(0);
1686     for (rparams.frag = 0; (rparams.frag < newNode->arraySize);
1687          rparams.frag++) {
1688         RestoreDesc = &Restore[rparams.frag];
1689
1690         /* Skip the volume if it was requested to */
1691         if (RestoreDesc->flags & RDFLAG_SKIP) {
1692             if (RestoreDesc->flags & RDFLAG_LASTDUMP) {
1693                 /* If the volume was restored, should bring it online */
1694             }
1695             continue;
1696         }
1697
1698         newVolName = RestoreDesc->newName;
1699
1700         /* Make sure the server to restore to is good */
1701         if (!RestoreDesc->hostAddr) {
1702             ErrorLog(0, taskId, 0, 0, "Illegal host ID 0 for volume %s\n",
1703                      newVolName);
1704             ERROR_EXIT(TC_INTERNALERROR);
1705         }
1706
1707         if (checkAbortByTaskId(taskId))
1708             ERROR_EXIT(TC_ABORTEDBYREQUEST);
1709
1710         TapeLog(1, taskId, 0, 0, "Restoring volume %s\n", newVolName);
1711         lock_Status();
1712         strncpy(newNode->statusNodePtr->volumeName, newVolName,
1713                 BU_MAXNAMELEN);
1714         unlock_Status();
1715
1716         /* restoreVolume function takes care of all the related fragments
1717          * spanning various tapes. On return the complete volume has been
1718          * restored
1719          */
1720         if (CONF_XBSA) {
1721             tcode = xbsaRestoreVolume(taskId, RestoreDesc, &rparams);
1722         } else {
1723             tcode = restoreVolume(taskId, RestoreDesc, &rparams);
1724         }
1725         if (tcode) {
1726             if (tcode == TC_ABORTEDBYREQUEST) {
1727                 ERROR_EXIT(tcode);
1728             } else if (tcode == TC_SKIPTAPE) {
1729                 afs_uint32 tapeID;
1730                 tapeID =
1731                     (RestoreDesc->initialDumpId ? RestoreDesc->
1732                      initialDumpId : RestoreDesc->dbDumpId);
1733                 SkipTape(Restore, newNode->arraySize, rparams.frag,
1734                          RestoreDesc->tapeName, tapeID, taskId);
1735             } else {
1736                 ErrorLog(0, taskId, tcode, 0, "Can't restore volume %s\n",
1737                          newVolName);
1738                 SkipVolume(Restore, newNode->arraySize, rparams.frag,
1739                            RestoreDesc->origVid, taskId);
1740             }
1741             rparams.frag--;
1742             continue;
1743         }
1744
1745         goodrestore++;
1746     }
1747
1748   error_exit:
1749     endTime = time(0);
1750     if (!CONF_XBSA) {
1751         unmountTape(taskId, &tapeInfo);
1752     } else {
1753 #ifdef xbsa
1754         code = InitToServer(taskId, &butxInfo, 0);      /* Return to original server */
1755 #endif
1756     }
1757
1758     if (bufferBlock)
1759         free(bufferBlock);
1760
1761     if (code == TC_ABORTEDBYREQUEST) {
1762         ErrorLog(0, taskId, 0, 0, "Restore: Aborted by request\n");
1763         clearStatus(taskId, ABORT_REQUEST);
1764         setStatus(taskId, ABORT_DONE);
1765     } else if (code) {
1766         TapeLog(0, taskId, code, 0, "Restore: Finished with errors\n");
1767         setStatus(taskId, TASK_ERROR);
1768     } else {
1769         TLog(taskId, "Restore: Finished\n");
1770     }
1771
1772     if (centralLogIO && startTime) {
1773         long timediff;
1774         afs_int32 hrs, min, sec, tmp;
1775         char line[1024];
1776         struct tm tmstart, tmend;
1777
1778         localtime_r(&startTime, &tmstart);
1779         localtime_r(&endTime, &tmend);
1780         timediff = (int)endTime - (int)startTime;
1781         hrs = timediff / 3600;
1782         tmp = timediff % 3600;
1783         min = tmp / 60;
1784         sec = tmp % 60;
1785
1786         sprintf(line,
1787                 "%-5d  %02d/%02d/%04d %02d:%02d:%02d  "
1788                 "%02d/%02d/%04d %02d:%02d:%02d  " "%02d:%02d:%02d  "
1789                 "%d of %d volume%s restored\n", taskId, tmstart.tm_mon + 1,
1790                 tmstart.tm_mday, tmstart.tm_year + 1900, tmstart.tm_hour,
1791                 tmstart.tm_min, tmstart.tm_sec, tmend.tm_mon + 1,
1792                 tmend.tm_mday, tmend.tm_year + 1900, tmend.tm_hour,
1793                 tmend.tm_min, tmend.tm_sec, hrs, min, sec, goodrestore,
1794                 newNode->arraySize, ((newNode->arraySize > 1) ? "s" : ""));
1795
1796         fwrite(line, strlen(line), 1, centralLogIO);
1797         fflush(centralLogIO);
1798     }
1799
1800     setStatus(taskId, TASK_DONE);
1801
1802     FreeNode(taskId);
1803     LeaveDeviceQueue(deviceLatch);
1804     return (void *)(intptr_t)(code);
1805 }
1806
1807 /* this is just scaffolding, creates new tape label with name <tapeName> */
1808
1809 void
1810 GetNewLabel(struct butm_tapeInfo *tapeInfoPtr, char *pName, char *AFSName,
1811             struct butm_tapeLabel *tapeLabel)
1812 {
1813     struct timeval tp;
1814     afs_uint32 size;
1815
1816     memset(tapeLabel, 0, sizeof(struct butm_tapeLabel));
1817
1818     if (!CONF_XBSA) {
1819         butm_GetSize(tapeInfoPtr, &size);
1820         if (!size)
1821             size = globalTapeConfig.capacity;
1822     } else {
1823         size = 0;               /* no tape size */
1824     }
1825     gettimeofday(&tp, NULL);
1826
1827     tapeLabel->structVersion = CUR_TAPE_VERSION;
1828     tapeLabel->creationTime = tp.tv_sec;
1829     tapeLabel->size = size;
1830     tapeLabel->expirationDate = 0;      /* 1970 sometime */
1831     tapeLabel->dumpPath[0] = 0; /* no path name  */
1832     tapeLabel->useCount = 0;
1833     strcpy(tapeLabel->AFSName, AFSName);
1834     strcpy(tapeLabel->pName, pName);
1835     strcpy(tapeLabel->cell, globalCellName);
1836     strcpy(tapeLabel->comment, "AFS Backup Software");
1837     strcpy(tapeLabel->creator.name, "AFS 3.6");
1838     strcpy(tapeLabel->creator.instance, "");
1839     strcpy(tapeLabel->creator.cell, globalCellName);
1840 }
1841
1842 /* extracts trailer out of buffer, nbytes is set to total data in
1843  * buffer - trailer size */
1844 afs_int32
1845 ExtractTrailer(char *buffer, afs_int32 size, afs_int32 *nbytes,
1846                struct volumeHeader *volTrailerPtr)
1847 {
1848     afs_int32 code = 0;
1849     afs_int32 startPos;
1850     struct volumeHeader tempTrailer;
1851
1852     for (startPos = 0;
1853          startPos <=
1854          (size - sizeof(struct volumeHeader) + sizeof(tempTrailer.pad));
1855          startPos++) {
1856         code = readVolumeHeader(buffer, startPos, &tempTrailer);
1857         if (code == 0) {
1858             code = VolHeaderToHost(volTrailerPtr, &tempTrailer);
1859             if (code)
1860                 break;
1861
1862             if (nbytes)
1863                 *nbytes = startPos;
1864             return 1;           /* saw the trailer */
1865         }
1866     }
1867
1868     if (nbytes)
1869         *nbytes = size / 2;
1870     return 0;                   /* did not see the trailer */
1871 }
1872
1873 int
1874 FindVolTrailer(char *buffer, afs_int32 size, afs_int32 *dSize,
1875                struct volumeHeader *volTrailerPtr)
1876 {
1877     afs_int32 offset, s;
1878     int found;
1879
1880     *dSize = size;
1881     if (!buffer)
1882         return 0;
1883
1884     s = sizeof(struct volumeHeader) + sizeof(volTrailerPtr->pad);
1885     if (s > size)
1886         s = size;
1887
1888     found = ExtractTrailer((buffer + size - s), s, &offset, volTrailerPtr);
1889     if (found)
1890         *dSize -= (s - offset);
1891     return found;
1892 }
1893
1894 int
1895 FindVolTrailer2(char *buffera, afs_int32 sizea, afs_int32 *dataSizea,
1896                 char *bufferb, afs_int32 sizeb, afs_int32 *dataSizeb,
1897                 struct volumeHeader *volTrailerPtr)
1898 {
1899     afs_int32 offset, s;
1900     afs_int32 headB, tailB;
1901     int found = 0;
1902
1903     if (!buffera)
1904         sizea = 0;
1905     if (!bufferb)
1906         sizeb = 0;
1907     *dataSizea = sizea;
1908     *dataSizeb = sizeb;
1909
1910     s = sizeof(struct volumeHeader) + sizeof(volTrailerPtr->pad);
1911     if (sizeb >= s) {
1912         found = FindVolTrailer(bufferb, sizeb, dataSizeb, volTrailerPtr);
1913     } else {
1914         tailB = sizeb;
1915         headB = (s - sizeb);    /*(s > sizeb) */
1916         if (headB > sizea) {
1917             headB = sizea;
1918             s = headB + tailB;
1919             if (!s)
1920                 return 0;
1921         }
1922
1923         memset(tapeVolumeHT, 0, sizeof(tapeVolumeHT));
1924         if (headB)
1925             memcpy(tapeVolumeHT, buffera + sizea - headB, headB);
1926         if (tailB)
1927             memcpy(tapeVolumeHT + headB, bufferb, tailB);
1928         if (ExtractTrailer(tapeVolumeHT, s, &offset, volTrailerPtr)) {
1929             found = 1;
1930             if (offset > headB) {
1931                 /* *dataSizea remains unchanged */
1932                 *dataSizeb = offset - headB;
1933             } else {
1934                 *dataSizea -= (headB - offset); /*(headB >= offset) */
1935                 *dataSizeb = 0;
1936             }
1937         }
1938     }
1939     return found;
1940 }
1941
1942
1943 Date
1944 ExpirationDate(afs_int32 dumpid)
1945 {
1946     afs_int32 code;
1947     Date expiration = 0;
1948     struct budb_dumpEntry dumpEntry;
1949     struct budb_tapeEntry tapeEntry;
1950     struct budb_volumeEntry volEntry;
1951
1952     if (dumpid) {
1953         /*
1954          * Get the expiration date from DB if its there. The expiration of
1955          * any tape will be the most future expiration of any dump in the
1956          * set. Can't use bcdb_FindTape because dumpid here pertains to the
1957          * initial dump id.
1958          */
1959         code = bcdb_FindLastTape(dumpid, &dumpEntry, &tapeEntry, &volEntry);
1960         if (!code)
1961             expiration = tapeEntry.expires;
1962     }
1963     return (expiration);
1964 }
1965
1966 /* Returns true or false depending on whether the tape is expired or not */
1967
1968 int
1969 tapeExpired(struct butm_tapeLabel *tapeLabelPtr)
1970 {
1971     Date expiration;
1972     struct timeval tp;
1973
1974     expiration = ExpirationDate(tapeLabelPtr->dumpid);
1975     if (!expiration)
1976         expiration = tapeLabelPtr->expirationDate;
1977
1978     gettimeofday(&tp, NULL);
1979     return ((expiration < tp.tv_sec) ? 1 : 0);
1980 }
1981
1982 /* updateTapeLabel
1983  *      given the label on the tape, delete any old information from the
1984  *      database.
1985
1986  * Deletes all entries that match the volset.dumpnode
1987  *      and the dump path.
1988  */
1989
1990 int
1991 updateTapeLabel(struct labelTapeIf *labelIfPtr,
1992                 struct butm_tapeInfo *tapeInfoPtr,
1993                 struct butm_tapeLabel *newLabelPtr)
1994 {
1995     struct butm_tapeLabel oldLabel;
1996     afs_int32 i, code = 0;
1997     afs_uint32 taskId;
1998     int tapeIsLabeled = 0;
1999     int interactiveFlag;
2000     int tapecount = 1;
2001
2002     interactiveFlag = autoQuery;
2003     taskId = labelIfPtr->taskId;
2004
2005     while (1) {
2006         if (interactiveFlag) {
2007             code =
2008                 PromptForTape(LABELOPCODE, TNAME(newLabelPtr), 0,
2009                               labelIfPtr->taskId, tapecount);
2010             if (code)
2011                 ERROR_EXIT(code);
2012         }
2013         interactiveFlag = 1;
2014         tapecount++;
2015
2016         /* mount the tape */
2017         code = butm_Mount(tapeInfoPtr, newLabelPtr->AFSName);
2018         if (code) {
2019             TapeLog(0, taskId, code, tapeInfoPtr->error, "Can't open tape\n");
2020             goto newtape;
2021         }
2022
2023         code = butm_ReadLabel(tapeInfoPtr, &oldLabel, 1);       /* will rewind the tape */
2024         if (!code) {
2025             tapeIsLabeled = 1;
2026
2027             if ((strcmp(newLabelPtr->AFSName, "") != 0)
2028                 && (strcmp(oldLabel.pName, "") != 0)) {
2029                 /* We are setting the AFS name, yet tape
2030                  * has a permanent name (not allowed).
2031                  */
2032                 TLog(taskId, "Can't label. Tape has permanent label '%s'\n",
2033                      oldLabel.pName);
2034                 goto newtape;
2035             }
2036
2037             if (!tapeExpired(&oldLabel)) {
2038                 if (!queryoperator) {
2039                     TLog(taskId, "This tape has not expired\n");
2040                     goto newtape;
2041                 }
2042                 if (Ask("This tape has not expired - proceed") == 0)
2043                     goto newtape;
2044             }
2045
2046             /* Keep the permanent name */
2047             if (strcmp(newLabelPtr->pName, "") == 0) {
2048                 strcpy(newLabelPtr->pName, oldLabel.pName);
2049             } else if (strcmp(newLabelPtr->pName, TC_NULLTAPENAME) == 0) {
2050                 strcpy(newLabelPtr->pName, "");
2051             }
2052         }
2053
2054         /* extract useful information from the old label */
2055         if (tapeIsLabeled && oldLabel.structVersion >= TAPE_VERSION_3) {
2056             newLabelPtr->dumpid = 0;
2057             newLabelPtr->useCount = oldLabel.useCount + 1;
2058         }
2059
2060         /* now write the new label */
2061         code = butm_Create(tapeInfoPtr, newLabelPtr, 1);        /* will rewind the tape */
2062         if (code) {
2063             ErrorLog(0, taskId, code, tapeInfoPtr->error,
2064                      "Can't label tape\n");
2065             goto newtape;
2066         }
2067
2068         break;
2069
2070       newtape:
2071         unmountTape(taskId, tapeInfoPtr);
2072     }
2073
2074     /* delete obsolete information from the database */
2075     if (tapeIsLabeled && oldLabel.structVersion >= TAPE_VERSION_3) {
2076         /* delete based on dump id */
2077         if (oldLabel.dumpid) {
2078             i = bcdb_deleteDump(oldLabel.dumpid, 0, 0, 0);
2079             if (i && (i != BUDB_NOENT))
2080                 ErrorLog(0, taskId, i, 0,
2081                          "Warning: Can't delete old dump %u from database\n",
2082                          oldLabel.dumpid);
2083         }
2084     }
2085
2086   error_exit:
2087     unmountTape(taskId, tapeInfoPtr);
2088     return (code);
2089 }
2090
2091 /* Labeller
2092  *      LWP created by the server stub. Labels the tape with name and size
2093  *      specified by <label>
2094  */
2095
2096 void *
2097 Labeller(void *param)
2098 {
2099     struct labelTapeIf *labelIfPtr = (struct labelTapeIf *)param;
2100
2101     struct tc_tapeLabel *label = &labelIfPtr->label;
2102
2103     struct butm_tapeLabel newTapeLabel;
2104     struct butm_tapeInfo tapeInfo;
2105     afs_uint32 taskId;
2106     afs_int32 code = 0;
2107
2108     afs_pthread_setname_self("labeller");
2109     taskId = labelIfPtr->taskId;
2110     setStatus(taskId, DRIVE_WAIT);
2111     EnterDeviceQueue(deviceLatch);
2112     clearStatus(taskId, DRIVE_WAIT);
2113
2114     printf("\n\n");
2115     TLog(taskId, "Labeltape\n");
2116
2117     memset(&tapeInfo, 0, sizeof(tapeInfo));
2118     tapeInfo.structVersion = BUTM_MAJORVERSION;
2119     code = butm_file_Instantiate(&tapeInfo, &globalTapeConfig);
2120     if (code) {
2121         ErrorLog(0, taskId, code, tapeInfo.error,
2122                  "Can't initialize the tape module\n");
2123         ERROR_EXIT(code);
2124     }
2125
2126     GetNewLabel(&tapeInfo, label->pname, label->afsname, &newTapeLabel);
2127     if (label->size)
2128         newTapeLabel.size = label->size;
2129     else
2130         newTapeLabel.size = globalTapeConfig.capacity;
2131
2132     code = updateTapeLabel(labelIfPtr, &tapeInfo, &newTapeLabel);
2133     if (code)
2134         ERROR_EXIT(code);
2135
2136   error_exit:
2137     if (code == TC_ABORTEDBYREQUEST) {
2138         ErrorLog(0, taskId, 0, 0, "Labeltape: Aborted by request\n");
2139         clearStatus(taskId, ABORT_REQUEST);
2140         setStatus(taskId, ABORT_DONE);
2141     } else if (code) {
2142         ErrorLog(0, taskId, code, 0, "Labeltape: Finished with errors\n");
2143         setStatus(taskId, TASK_ERROR);
2144     } else {
2145         TLog(taskId, "Labelled tape %s size %u Kbytes\n",
2146              TNAME(&newTapeLabel), newTapeLabel.size);
2147     }
2148     setStatus(labelIfPtr->taskId, TASK_DONE);
2149
2150     free(labelIfPtr);
2151     LeaveDeviceQueue(deviceLatch);
2152     return (void *)(intptr_t)(code);
2153 }
2154
2155 /* PrintTapeLabel
2156  *      print out the tape label.
2157  */
2158
2159 void
2160 PrintTapeLabel(struct butm_tapeLabel *labelptr)
2161 {
2162     char tapeName[BU_MAXTAPELEN + 32];
2163     time_t t;
2164
2165     printf("Tape label\n");
2166     printf("----------\n");
2167     TAPENAME(tapeName, labelptr->pName, labelptr->dumpid);
2168     printf("permanent tape name = %s\n", tapeName);
2169     TAPENAME(tapeName, labelptr->AFSName, labelptr->dumpid);
2170     printf("AFS tape name = %s\n", tapeName);
2171     t = labelptr->creationTime;
2172     printf("creationTime = %s", ctime(&t));
2173     if (labelptr->expirationDate) {
2174         t = labelptr->expirationDate;
2175         printf("expirationDate = %s", cTIME(&t));
2176     }
2177     printf("cell = %s\n", labelptr->cell);
2178     printf("size = %u Kbytes\n", labelptr->size);
2179     printf("dump path = %s\n", labelptr->dumpPath);
2180
2181     if (labelptr->structVersion >= TAPE_VERSION_3) {
2182         printf("dump id = %u\n", labelptr->dumpid);
2183         printf("useCount = %d\n", labelptr->useCount);
2184     }
2185     printf("-- End of tape label --\n\n");
2186 }
2187
2188 /* ReadLabel
2189  *      Read the label from a tape.
2190  *      Currently prints out a "detailed" summary of the label but passes
2191  *      back only selected fields.
2192  */
2193
2194 int
2195 ReadLabel(struct tc_tapeLabel *label)
2196 {
2197     struct butm_tapeLabel newTapeLabel;
2198     struct butm_tapeInfo tapeInfo;
2199     afs_uint32 taskId;
2200     Date expir;
2201     afs_int32 code = 0;
2202     int interactiveFlag;
2203     int tapecount = 1;
2204
2205     EnterDeviceQueue(deviceLatch);
2206     taskId = allocTaskId();     /* reqd for lower level rtns */
2207
2208     printf("\n\n");
2209     TLog(taskId, "Readlabel\n");
2210
2211     memset(&tapeInfo, 0, sizeof(tapeInfo));
2212     tapeInfo.structVersion = BUTM_MAJORVERSION;
2213     code = butm_file_Instantiate(&tapeInfo, &globalTapeConfig);
2214     if (code) {
2215         ErrorLog(0, taskId, code, tapeInfo.error,
2216                  "Can't initialize the tape module\n");
2217         ERROR_EXIT(code);
2218     }
2219     memset(&newTapeLabel, 0, sizeof(newTapeLabel));
2220
2221     interactiveFlag = autoQuery;
2222
2223     while (1) {
2224         if (interactiveFlag) {
2225             code = PromptForTape(READLABELOPCODE, "", 0, taskId, tapecount);
2226             if (code)
2227                 ERROR_EXIT(code);
2228         }
2229         interactiveFlag = 1;
2230         tapecount++;
2231
2232         code = butm_Mount(&tapeInfo, "");
2233         if (code) {
2234             TapeLog(0, taskId, code, tapeInfo.error, "Can't open tape\n");
2235             goto newtape;
2236         }
2237         break;
2238
2239       newtape:
2240         unmountTape(taskId, &tapeInfo);
2241     }
2242
2243     code = butm_ReadLabel(&tapeInfo, &newTapeLabel, 1); /* will rewind the tape */
2244     if (code) {
2245         if (code == BUTM_NOLABEL) {
2246             printf("Tape is unlabelled\n");
2247             ERROR_EXIT(code);
2248         }
2249         ErrorLog(1, taskId, code, tapeInfo.error, "Can't read tape label\n");
2250         ERROR_EXIT(code);
2251     }
2252
2253     /* copy the fields to be passed to the caller */
2254     label->size = newTapeLabel.size;
2255     label->tapeId = newTapeLabel.dumpid;
2256     strcpy(label->afsname, newTapeLabel.AFSName);
2257     strcpy(label->pname, newTapeLabel.pName);
2258
2259
2260     expir = ExpirationDate(newTapeLabel.dumpid);
2261     if (expir)
2262         newTapeLabel.expirationDate = expir;
2263
2264     PrintTapeLabel(&newTapeLabel);
2265
2266   error_exit:
2267     unmountTape(taskId, &tapeInfo);
2268
2269     if (code == TC_ABORTEDBYREQUEST)
2270         ErrorLog(0, taskId, 0, 0, "ReadLabel: Aborted by request\n");
2271     else if (code && (code != BUTM_NOLABEL))
2272         ErrorLog(0, taskId, code, 0, "ReadLabel: Finished with errors\n");
2273     else
2274         TLog(taskId, "ReadLabel: Finished\n");
2275
2276     LeaveDeviceQueue(deviceLatch);
2277     return (code);
2278 }
2279
2280 /* Function to read volume header and trailer structure from tape, taking
2281    into consideration, different word alignment rules.
2282 */
2283 afs_int32
2284 readVolumeHeader(char *buffer,          /* in - buffer to read header from */
2285                  afs_int32 bufloc,      /* in - header's location in buffer */
2286                  struct volumeHeader *header) /* out -header structure */
2287 {
2288     struct volumeHeader vhptr, *tempvhptr;
2289     afs_int32 firstSplice = (afs_int32) ((char*)& vhptr.pad - (char*) & vhptr);
2290     int padLen = sizeof(vhptr.pad);     /* pad to achieve 4 byte alignment */
2291     int nextSplice = sizeof(struct volumeHeader) - firstSplice - padLen;
2292
2293     /* Four cases are to be handled
2294      *
2295      * Volume Header (byte alignment)
2296      * -----------------------
2297      * Tape   In Core
2298      * ----   -------
2299      * Case 1:  4       1
2300      * Case 2:  4       4
2301      * Case 3:  1       1
2302      * Case 4:  1       4
2303      * -----------------------
2304      *
2305      * Case 2 and Case 3 are identical cases and handled the same way.
2306      * Case 1 and Case 4 are separate cases. In one case the pad needs
2307      * to be removed and in the other, it needs to be spliced in. The
2308      * four cases are handled as follows
2309      */
2310     tempvhptr = (struct volumeHeader *)(buffer + bufloc);
2311     if ((strncmp(tempvhptr->preamble, "H++NAME#", 8) == 0)
2312         && (strncmp(tempvhptr->postamble, "T--NAME#", 8) == 0)) {
2313         /* Handle Cases 2 & 3 */
2314         memcpy(&vhptr, buffer + bufloc, sizeof(struct volumeHeader));
2315         HEADER_CHECKS(vhptr, header);
2316
2317         /* Handle Case 4 */
2318         memset(&vhptr, 0, sizeof(struct volumeHeader));
2319         memcpy(&vhptr, buffer + bufloc, firstSplice);
2320         memset(&vhptr.pad, 0, padLen);
2321         memcpy(&vhptr.volumeID, buffer + bufloc + firstSplice, nextSplice);
2322         HEADER_CHECKS(vhptr, header);
2323
2324         /* Handle Case 1 */
2325         memset(&vhptr, 0, sizeof(struct volumeHeader));
2326         memcpy(&vhptr, buffer + bufloc, firstSplice);
2327         /* probably GCC bug 37060; however, no guarantee on length of buffer */
2328         tempvhptr = (struct volumeHeader *)(buffer + firstSplice);
2329         memcpy(tempvhptr, buffer + bufloc + firstSplice + padLen,
2330                nextSplice);
2331         HEADER_CHECKS(vhptr, header);
2332
2333     }
2334     return (TC_BADVOLHEADER);
2335 }