backup: Don't cast returns from malloc()
[openafs.git] / src / butc / tcudbprocs.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 IGNORE_SOME_GCC_WARNINGS
17 # pragma GCC diagnostic warning "-Wimplicit-function-declaration"
18 #endif
19
20 #include <afs/opr.h>
21 #include <rx/rx.h>
22 #include <afs/afsint.h>
23 #include <afs/prs_fs.h>
24 #include <afs/nfs.h>
25 #include <lwp.h>
26 #include <lock.h>
27 #include <afs/cellconfig.h>
28 #include <afs/keys.h>
29 #include <ubik.h>
30 #include <afs/acl.h>
31 #include <afs/volser.h>
32 #include <afs/vlserver.h>
33 #include <afs/tcdata.h>
34 #include <afs/budb.h>
35 #include <afs/budb_client.h>
36 #include <afs/bubasics.h>
37 #include <afs/bucoord_prototypes.h>
38 #include <afs/butm_prototypes.h>
39 #include <afs/budb_prototypes.h>
40 #include <afs/afsutil.h>
41
42 #include "butc_internal.h"
43 #include "error_macros.h"
44
45 /* GLOBAL CONFIGURATION PARAMETERS */
46 #define BIGCHUNK 102400
47
48 extern int dump_namecheck;
49 extern int autoQuery;
50
51 struct rstTapeInfo {
52     afs_int32 taskId;
53     afs_int32 tapeSeq;
54     afs_uint32 dumpid;
55 };
56
57 static void initTapeBuffering(void);
58 static int writeDbDump(struct butm_tapeInfo *, afs_uint32, Date, afs_uint32);
59 static int restoreDbEntries(struct butm_tapeInfo *, struct rstTapeInfo *);
60
61 int getTapeData(struct butm_tapeInfo *, struct rstTapeInfo *, void *,
62                 afs_int32);
63 int restoreDbHeader(struct butm_tapeInfo *, struct rstTapeInfo *,
64                     struct structDumpHeader *);
65 int restoreDbDump(struct butm_tapeInfo *, struct rstTapeInfo *,
66                   struct structDumpHeader *);
67 int restoreText(struct butm_tapeInfo *, struct rstTapeInfo *,
68                 struct structDumpHeader *);
69
70
71
72 void * KeepAlive(void *);
73 /* CreateDBDump
74  *      create a dump entry for a saved database
75  */
76
77 afs_int32
78 CreateDBDump(struct budb_dumpEntry *dumpEntryPtr)
79 {
80     afs_int32 code = 0;
81
82     memset(dumpEntryPtr, 0, sizeof(struct budb_dumpEntry));
83
84     strcpy(dumpEntryPtr->name, DUMP_TAPE_NAME);
85     strcpy(dumpEntryPtr->tapes.format, DUMP_TAPE_NAME);
86     strcat(dumpEntryPtr->tapes.format, ".%d");
87     strcpy(dumpEntryPtr->volumeSetName, "");
88     strcpy(dumpEntryPtr->dumpPath, "");
89     dumpEntryPtr->created = 0;  /* let database assign it */
90     dumpEntryPtr->incTime = 0;
91     dumpEntryPtr->nVolumes = 0;
92     dumpEntryPtr->initialDumpID = 0;
93     dumpEntryPtr->parent = 0;
94     dumpEntryPtr->level = 0;
95     dumpEntryPtr->tapes.maxTapes = 0;
96     dumpEntryPtr->tapes.b = 1;
97
98     /* now call the database to create the entry */
99     code = bcdb_CreateDump(dumpEntryPtr);
100     return (code);
101 }
102
103 struct tapeEntryList {
104     struct tapeEntryList *next;
105     afs_uint32 oldDumpId;
106     struct budb_tapeEntry tapeEnt;
107 };
108 struct tapeEntryList *listEntryHead;
109 struct tapeEntryList *listEntryPtr;
110 #define tapeEntryPtr (&listEntryPtr->tapeEnt)
111 struct budb_dumpEntry lastDump; /* the last dump of this volset */
112
113 /* GetDBTape
114  *      Load a DB tape, read and over write its label.
115  *      Leave the tape mounted.
116  */
117 afs_int32
118 GetDBTape(afs_int32 taskId, Date expires, struct butm_tapeInfo *tapeInfoPtr,
119           afs_uint32 dumpid, afs_int32 sequence, int queryFlag,
120           int *wroteLabel)
121 {
122     afs_int32 code = 0;
123     int interactiveFlag;
124     char tapeName[BU_MAXTAPELEN];
125     char strlevel[5];
126     struct timeval tp;
127     afs_int32 curTime;
128     int tapecount = 1;
129
130     struct butm_tapeLabel oldTapeLabel, newLabel;
131     struct tapeEntryList *endList;
132
133     /* construct the name of the tape */
134     sprintf(tapeName, "%s.%-d", DUMP_TAPE_NAME, sequence);
135
136     interactiveFlag = queryFlag;
137     *wroteLabel = 0;
138
139     while (!*wroteLabel) {      /*w */
140         if (interactiveFlag) {  /* need a tape to write */
141             code =
142                 PromptForTape(SAVEDBOPCODE, tapeName, dumpid, taskId,
143                               tapecount);
144             if (code)
145                 ERROR_EXIT(code);
146         }
147         interactiveFlag = 1;
148         tapecount++;
149
150         code = butm_Mount(tapeInfoPtr, tapeName);
151         if (code) {
152             TapeLog(0, taskId, code, tapeInfoPtr->error, "Can't open tape\n");
153             goto getNewTape;
154         }
155
156         memset(&oldTapeLabel, 0, sizeof(oldTapeLabel));
157         code = butm_ReadLabel(tapeInfoPtr, &oldTapeLabel, 1);   /* rewind tape */
158         if (code) {
159             oldTapeLabel.useCount = 0;  /* no label exists */
160             oldTapeLabel.structVersion = 0;
161             strcpy(oldTapeLabel.pName, "");
162         } else {
163             /* If tape has a name, it must be null or database tape name */
164             if (dump_namecheck && strcmp(oldTapeLabel.AFSName, "")
165                 && !databaseTape(oldTapeLabel.AFSName)) {
166                 char gotName[BU_MAXTAPELEN + 32];
167
168                 LABELNAME(gotName, &oldTapeLabel);
169                 TLog(taskId,
170                      "This tape %s must be a database tape or NULL tape\n",
171                      gotName);
172
173               getNewTape:
174                 unmountTape(taskId, tapeInfoPtr);
175                 continue;
176             }
177
178             /* Do not overwrite a tape that belongs to this dump */
179             if (oldTapeLabel.dumpid && (oldTapeLabel.dumpid == dumpid)) {
180                 ErrorLog(0, taskId, 0, 0,
181                          "Can't overwrite tape containing the dump in progress\n");
182                 goto getNewTape;
183             }
184
185             /* On first tape, the savedb has not started yet, so the database is not locked
186              * and we can therefore, access information from it. This is easier to do because
187              * database dumps don't have appended dumps (nor appended).
188              */
189             if (sequence == 1) {
190                 afs_uint32 dmp;
191                 struct budb_dumpEntry de, de2;
192
193                 /* Verify the tape has not expired
194                  * Early database dumps don't have a dumpid
195                  */
196                 if (!tapeExpired(&oldTapeLabel)) {
197                     TLog(taskId, "This tape has not expired\n");
198                     goto getNewTape;
199                 }
200
201                 /* Since the dumpset on this tape will be deleted from database, check if
202                  * any of the dumps in this dumpset are most-recent-dumps.
203                  */
204                 for (dmp = oldTapeLabel.dumpid; dmp; dmp = de.appendedDumpID) {
205                     if (dmp == lastDump.id) {
206                         memcpy(&de, &lastDump, sizeof(de));
207                         memcpy(&de2, &lastDump, sizeof(de2));
208                     } else {
209                         code = bcdb_FindDumpByID(dmp, &de);
210                         if (code)
211                             break;
212                         sprintf(strlevel, "%d", de.level);
213                         code =
214                             bcdb_FindLatestDump(de.volumeSetName, strlevel,
215                                                 &de2);
216                         if (code)
217                             continue;
218                     }
219
220                     if (de.id == de2.id) {
221                         if (strcmp(DUMP_TAPE_NAME, de2.name) == 0) {
222                             ErrorLog(0, taskId, 0, 0,
223                                      "Warning: Overwriting most recent dump %s (DumpID %u)\n",
224                                      de.name, de.id);
225                         } else {
226                             ErrorLog(0, taskId, 0, 0,
227                                      "Warning: Overwriting most recent dump of the '%s' volumeset: %s (DumpID %u)\n",
228                                      de.volumeSetName, de.name, de.id);
229                         }
230                     }
231                 }
232             }
233
234             /* Otherwise, the savedb is in progress and we can't
235              * access the database (it's locked). So we rely on the
236              * information available (and not the backup database).
237              */
238             else {
239                 /* Check the tape's expiration date. Use the expiration on the label */
240                 gettimeofday(&tp, NULL);
241                 curTime = tp.tv_sec;
242                 if (curTime < oldTapeLabel.expirationDate) {
243                     TLog(taskId, "This tape has not expired\n");
244                     goto getNewTape;
245                 }
246
247                 /* Check if this previous-dump of the dump-in-progress is on this tape */
248                 if (oldTapeLabel.dumpid
249                     && (oldTapeLabel.dumpid == lastDump.id)) {
250                     ErrorLog(0, taskId, 0, 0,
251                              "Warning: Overwriting most recent dump %s (DumpID %u)\n",
252                              lastDump.name, lastDump.id);
253                 }
254
255             }
256         }
257
258         GetNewLabel(tapeInfoPtr, oldTapeLabel.pName, tapeName, &newLabel);
259         newLabel.expirationDate = expires;
260         newLabel.useCount = oldTapeLabel.useCount + 1;
261         newLabel.dumpid = dumpid;
262         newLabel.size = tapeInfoPtr->tapeSize;
263
264         code = butm_Create(tapeInfoPtr, &newLabel, 1);  /* rewind tape */
265         if (code) {
266             TapeLog(0, taskId, code, tapeInfoPtr->error,
267                     "Can't label tape\n");
268             goto getNewTape;
269         }
270
271         *wroteLabel = 1;
272
273         /* Initialize a tapeEntry for later inclusion into the database */
274         listEntryPtr = calloc(1, sizeof(struct tapeEntryList));
275         if (!listEntryPtr)
276             ERROR_EXIT(TC_NOMEMORY);
277
278         /* Remember dumpid so we can delete it later */
279         if ((oldTapeLabel.structVersion >= TAPE_VERSION_3)
280             && oldTapeLabel.dumpid)
281             listEntryPtr->oldDumpId = oldTapeLabel.dumpid;
282
283         /* Fill in tape entry so we can save it later */
284         strcpy(tapeEntryPtr->name, TNAME(&newLabel));
285         tapeEntryPtr->flags = BUDB_TAPE_BEINGWRITTEN;
286         tapeEntryPtr->written = newLabel.creationTime;
287         tapeEntryPtr->expires = expires;
288         tapeEntryPtr->seq = sequence;
289         tapeEntryPtr->useCount = oldTapeLabel.useCount + 1;
290         tapeEntryPtr->dump = dumpid;
291         tapeEntryPtr->useKBytes = 0;
292         tapeEntryPtr->labelpos = 0;
293
294         /* Thread onto end of single-linked list */
295         if (listEntryHead) {
296             endList = listEntryHead;
297             while (endList->next)
298                 endList = endList->next;
299             endList->next = listEntryPtr;
300         } else
301             listEntryHead = listEntryPtr;
302     }                           /*w */
303
304   error_exit:
305     return (code);
306 }
307
308 /* freeTapeList
309  *       With the list of tapes, free the structures.
310  */
311
312 afs_int32
313 freeTapeList(void)
314 {
315     struct tapeEntryList *next;
316
317     listEntryPtr = listEntryHead;
318     while (listEntryPtr) {
319         next = listEntryPtr->next;
320         free(listEntryPtr);
321         listEntryPtr = next;
322     }
323
324     listEntryHead = NULL;
325     return (0);
326 }
327
328 /* addTapesToDb
329  *       With the list of tapes, add them to the database.
330  *       Also delete any olddumpids that are around.
331  */
332
333 afs_int32
334 addTapesToDb(afs_int32 taskId)
335 {
336     afs_int32 code = 0;
337     afs_int32 i, new;
338     struct tapeEntryList *next;
339
340     listEntryPtr = listEntryHead;
341     while (listEntryPtr) {
342         next = listEntryPtr->next;
343
344         /* Remove the old database entry */
345         if (listEntryPtr->oldDumpId) {
346             i = bcdb_deleteDump(listEntryPtr->oldDumpId, 0, 0, 0);
347             if (i && (i != BUDB_NOENT)) {
348                 ErrorLog(0, taskId, i, 0,
349                          "Unable to delete old DB entry %u.\n",
350                          listEntryPtr->oldDumpId);
351             }
352         }
353
354         /* Add the tape to the database */
355         code = bcdb_UseTape(tapeEntryPtr, &new);
356         if (code) {
357             ErrorLog(0, taskId, code, 0, "Can't add tape to database: %s\n",
358                      tapeEntryPtr->name);
359             ERROR_EXIT(code);
360         }
361
362         code = bcdb_FinishTape(tapeEntryPtr);
363         if (code) {
364             ErrorLog(0, taskId, code, 0, "Can't finish tape: %s\n",
365                      tapeEntryPtr->name);
366             ERROR_EXIT(code);
367         }
368
369         listEntryPtr = next;
370     }
371
372   error_exit:
373     return (code);
374 }
375
376 /* writeDbDump
377  * notes:
378  *      this code assumes that the blocksize on reads is smaller than
379  *      the blocksize on writes
380  */
381
382 static int
383 writeDbDump(struct butm_tapeInfo *tapeInfoPtr, afs_uint32 taskId,
384             Date expires, afs_uint32 dumpid)
385 {
386     afs_int32 blockSize;
387     afs_int32 writeBufNbytes = 0;
388     char *writeBlock = 0;
389     char *writeBuffer = 0;
390     char *writeBufPtr;
391     afs_int32 transferSize;
392
393     char *readBufPtr = NULL;
394     afs_int32 maxReadSize;
395
396     charListT charList;
397     afs_int32 done;
398     afs_int32 code;
399     afs_int32 chunksize = 0;
400     afs_int32 tc_EndMargin, tc_KEndMargin, kRemaining;
401     int sequence;
402     int wroteLabel;
403     int firstcall;
404 #ifdef AFS_PTHREAD_ENV
405     pthread_t alivePid;
406     pthread_attr_t tattr;
407     AFS_SIGSET_DECL;
408 #else
409     PROCESS alivePid;
410 #endif
411
412     extern struct tapeConfig globalTapeConfig;
413     extern struct udbHandleS udbHandle;
414
415     charList.charListT_val = 0;
416     charList.charListT_len = 0;
417     blockSize = BUTM_BLKSIZE;
418     writeBlock = malloc(BUTM_BLOCKSIZE);
419     if (!writeBlock)
420         ERROR_EXIT(TC_NOMEMORY);
421
422     writeBuffer = writeBlock + sizeof(struct blockMark);
423     memset(writeBuffer, 0, BUTM_BLKSIZE);
424     maxReadSize = 1024;
425
426     /*
427      * The margin of space to check for end of tape is set to the
428      * amount of space used to write an end-of-tape multiplied by 2.
429      * The amount of space is size of a 16K EODump marker, its EOF
430      * marker, and up to two EOF markers done on close (1 16K blocks +
431      * 3 EOF * markers).
432      */
433     tc_EndMargin = (16384 + 3 * globalTapeConfig.fileMarkSize) * 2;
434     tc_KEndMargin = tc_EndMargin / 1024;
435
436     /* have to write enclose the dump in file marks */
437     code = butm_WriteFileBegin(tapeInfoPtr);
438     if (code) {
439         ErrorLog(0, taskId, code, tapeInfoPtr->error,
440                  "Can't write FileBegin on tape\n");
441         ERROR_EXIT(code);
442     }
443
444     writeBufPtr = &writeBuffer[0];
445     firstcall = 1;
446     sequence = 1;
447
448     while (1) {                 /*w */
449         /* When no data in buffer, read data from the budb_server */
450         if (charList.charListT_len == 0) {
451             /* get more data. let rx allocate space */
452             if (charList.charListT_val) {
453                 free(charList.charListT_val);
454                 charList.charListT_val = 0;
455             }
456
457             /* get the data */
458             code =
459                 ubik_Call_SingleServer(BUDB_DumpDB, udbHandle.uh_client,
460                                        UF_SINGLESERVER, firstcall,
461                                        maxReadSize, &charList, &done);
462             if (code) {
463                 ErrorLog(0, taskId, code, 0, "Can't read database\n");
464                 ERROR_EXIT(code);
465             }
466
467             /* If this if the first call to the budb server, create a thread
468              * that will keep the connection alive (during tape changes).
469              */
470             if (firstcall) {
471 #ifdef AFS_PTHREAD_ENV
472                 code = pthread_attr_init(&tattr);
473                 if (code) {
474                     ErrorLog(0, taskId, code, 0,
475                              "Can't pthread_attr_init Keep-alive process\n");
476                     ERROR_EXIT(code);
477                 }
478
479                 code =
480                     pthread_attr_setdetachstate(&tattr,
481                                                 PTHREAD_CREATE_DETACHED);
482                 if (code) {
483                     ErrorLog(0, taskId, code, 0,
484                              "Can't pthread_attr_setdetachstate Keep-alive process\n");
485                     ERROR_EXIT(code);
486                 }
487
488                 AFS_SIGSET_CLEAR();
489                 code = pthread_create(&alivePid, &tattr, KeepAlive, 0);
490                 AFS_SIGSET_RESTORE();
491 #else
492                 code =
493                     LWP_CreateProcess(KeepAlive, 16384, 1, (void *)NULL,
494                                       "Keep-alive process", &alivePid);
495 #endif
496                 /* XXX should we check code here ??? XXX */
497             }
498             firstcall = 0;
499
500             readBufPtr = charList.charListT_val;
501         }
502
503         if ((charList.charListT_len == 0) && done)
504             break;
505
506         /* compute how many bytes and transfer to the write Buffer */
507         transferSize =
508             (charList.charListT_len <
509              (blockSize -
510               writeBufNbytes)) ? charList.charListT_len : (blockSize -
511                                                            writeBufNbytes);
512
513         memcpy(writeBufPtr, readBufPtr, transferSize);
514         charList.charListT_len -= transferSize;
515         writeBufPtr += transferSize;
516         readBufPtr += transferSize;
517         writeBufNbytes += transferSize;
518
519         /* If filled the write buffer, then write it to tape */
520         if (writeBufNbytes == blockSize) {
521             code = butm_WriteFileData(tapeInfoPtr, writeBuffer, 1, blockSize);
522             if (code) {
523                 ErrorLog(0, taskId, code, tapeInfoPtr->error,
524                          "Can't write data on tape\n");
525                 ERROR_EXIT(code);
526             }
527
528             memset(writeBuffer, 0, blockSize);
529             writeBufPtr = &writeBuffer[0];
530             writeBufNbytes = 0;
531
532             /* Every BIGCHUNK bytes check if aborted */
533             chunksize += blockSize;
534             if (chunksize > BIGCHUNK) {
535                 chunksize = 0;
536                 if (checkAbortByTaskId(taskId))
537                     ERROR_EXIT(TC_ABORTEDBYREQUEST);
538             }
539
540             /*
541              * check if tape is full - since we filled a blockSize worth of data
542              * assume that there is more data.
543              */
544             kRemaining = butm_remainingKSpace(tapeInfoPtr);
545             if (kRemaining < tc_KEndMargin) {
546                 code = butm_WriteFileEnd(tapeInfoPtr);
547                 if (code) {
548                     ErrorLog(0, taskId, code, tapeInfoPtr->error,
549                              "Can't write FileEnd on tape\n");
550                     ERROR_EXIT(code);
551                 }
552
553                 code = butm_WriteEOT(tapeInfoPtr);
554                 if (code) {
555                     ErrorLog(0, taskId, code, tapeInfoPtr->error,
556                              "Can't write end-of-dump on tape\n");
557                     ERROR_EXIT(code);
558                 }
559
560                 /* Mark tape as having been written */
561                 tapeEntryPtr->useKBytes =
562                     tapeInfoPtr->kBytes + (tapeInfoPtr->nBytes ? 1 : 0);
563                 tapeEntryPtr->flags = BUDB_TAPE_WRITTEN;
564
565                 unmountTape(taskId, tapeInfoPtr);
566
567                 /* Get next tape and writes its label */
568                 sequence++;
569                 code =
570                     GetDBTape(taskId, expires, tapeInfoPtr, dumpid, sequence,
571                               1, &wroteLabel);
572                 if (code)
573                     ERROR_EXIT(code);
574
575                 code = butm_WriteFileBegin(tapeInfoPtr);
576                 if (code) {
577                     ErrorLog(0, taskId, code, tapeInfoPtr->error,
578                              "Can't write FileBegin on tape\n");
579                     ERROR_EXIT(code);
580                 }
581             }
582         }
583     }                           /*w */
584
585     /* no more data to be read - if necessary, flush out the last buffer */
586     if (writeBufNbytes > 0) {
587         code = butm_WriteFileData(tapeInfoPtr, writeBuffer, 1, blockSize);
588         if (code) {
589             ErrorLog(1, taskId, code, tapeInfoPtr->error,
590                      "Can't write data on tape\n");
591             ERROR_EXIT(code);
592         }
593     }
594
595     code = butm_WriteFileEnd(tapeInfoPtr);
596     if (code) {
597         ErrorLog(0, taskId, code, tapeInfoPtr->error,
598                  "Can't write FileEnd on tape\n");
599         ERROR_EXIT(code);
600     }
601
602     /* Mark tape as having been written */
603     tapeEntryPtr->useKBytes =
604         tapeInfoPtr->kBytes + (tapeInfoPtr->nBytes ? 1 : 0);
605     tapeEntryPtr->flags = BUDB_TAPE_WRITTEN;
606
607   error_exit:
608     /* Let the KeepAlive process stop on its own */
609     code =
610         ubik_Call_SingleServer(BUDB_DumpDB, udbHandle.uh_client,
611                                UF_END_SINGLESERVER, 0);
612
613     if (writeBlock)
614         free(writeBlock);
615     if (charList.charListT_val)
616         free(charList.charListT_val);
617     return (code);
618 }
619
620 /* saveDbToTape
621  *      dump backup database to tape
622  */
623
624 void *
625 saveDbToTape(void *param)
626 {
627     struct saveDbIf *saveDbIfPtr = (struct saveDbIf *)param;
628     afs_int32 code;
629     afs_int32 i;
630     int wroteLabel;
631     afs_uint32 taskId;
632     Date expires;
633
634     struct butm_tapeInfo tapeInfo;
635     struct budb_dumpEntry dumpEntry;
636
637     extern struct deviceSyncNode *deviceLatch;
638     extern struct tapeConfig globalTapeConfig;
639
640     afs_pthread_setname_self("Db save");
641     expires = (saveDbIfPtr->archiveTime ? NEVERDATE : 0);
642     taskId = saveDbIfPtr->taskId;
643     dumpEntry.id = 0;
644
645     setStatus(taskId, DRIVE_WAIT);
646     EnterDeviceQueue(deviceLatch);      /* lock tape device */
647     clearStatus(taskId, DRIVE_WAIT);
648
649     printf("\n\n");
650     TLog(taskId, "SaveDb\n");
651
652     tapeInfo.structVersion = BUTM_MAJORVERSION;
653     code = butm_file_Instantiate(&tapeInfo, &globalTapeConfig);
654     if (code) {
655         ErrorLog(0, taskId, code, tapeInfo.error,
656                  "Can't initialize tape module\n");
657         ERROR_EXIT(code);
658     }
659
660     /* Determine what the last database dump was */
661     memset(&lastDump, 0, sizeof(lastDump));
662     code = bcdb_FindLatestDump("", "", &lastDump);
663     if (code) {
664         if (code != BUDB_NODUMPNAME) {
665             ErrorLog(0, taskId, code, 0, "Can't read backup database\n");
666             ERROR_EXIT(code);
667         }
668         memset(&lastDump, 0, sizeof(lastDump));
669     }
670
671     code = CreateDBDump(&dumpEntry);    /* Create a dump for this tape */
672     if (code) {
673         ErrorLog(0, taskId, code, 0, "Can't create dump in database\n");
674         ERROR_EXIT(code);
675     }
676
677
678     listEntryHead = NULL;
679
680     /* Get the tape and write a new label to it */
681     code =
682         GetDBTape(taskId, expires, &tapeInfo, dumpEntry.id, 1, autoQuery,
683                   &wroteLabel);
684
685     /*
686      * If did not write the label, remove created dump
687      * Else if wrote the label, remove old dump from db so it's not saved.
688      */
689     if (!wroteLabel) {
690         i = bcdb_deleteDump(dumpEntry.id, 0, 0, 0);
691         dumpEntry.id = 0;
692         if (i && (i != BUDB_NOENT))
693             ErrorLog(0, taskId, i, 0, "Unable to delete DB entry %u.\n",
694                      dumpEntry.id);
695     } else if (listEntryHead->oldDumpId) {
696         i = bcdb_deleteDump(listEntryHead->oldDumpId, 0, 0, 0);
697         listEntryHead->oldDumpId = 0;
698         if (i && (i != BUDB_NOENT)) {
699             ErrorLog(0, taskId, i, 0, "Unable to delete old DB entry %u.\n",
700                      listEntryHead->oldDumpId);
701             ERROR_EXIT(i);
702         }
703     }
704     if (code)
705         ERROR_EXIT(code);
706
707     TapeLog(1, taskId, 0, 0, "Tape accepted - now dumping database\n");
708
709     /* we have a writable tape */
710     code = writeDbDump(&tapeInfo, taskId, expires, dumpEntry.id);
711     if (code)
712         ERROR_EXIT(code);
713
714     /* Now delete the entries between time 0 and archive-time */
715     if (saveDbIfPtr->archiveTime)
716         code = bcdb_deleteDump(0, 0, saveDbIfPtr->archiveTime, 0);
717
718   error_exit:
719     unmountTape(taskId, &tapeInfo);
720
721     /* Add this dump's tapes to the database and mark it finished */
722     if (dumpEntry.id) {
723         i = addTapesToDb(taskId);
724         if (!code)
725             code = i;
726
727         i = bcdb_FinishDump(&dumpEntry);
728         if (!code)
729             code = i;
730     }
731     freeTapeList();
732
733     if (code == TC_ABORTEDBYREQUEST) {
734         TLog(taskId, "SaveDb: Aborted by request\n");
735         clearStatus(taskId, ABORT_REQUEST);
736         setStatus(taskId, ABORT_DONE);
737     } else if (code) {
738         TapeLog(0, taskId, code, 0, "SaveDb: Finished with errors\n");
739         setStatus(taskId, TASK_ERROR);
740     } else {
741         TLog(taskId, "SaveDb: Finished\n");
742     }
743     setStatus(taskId, TASK_DONE);
744
745     free(saveDbIfPtr);
746     LeaveDeviceQueue(deviceLatch);
747     return (void *)(intptr_t)(code);
748 }
749
750
751 /* makeDbDumpEntry()
752  *      Make a database dump entry given a tape label.
753  */
754
755 afs_int32
756 makeDbDumpEntry(struct budb_tapeEntry *tapeEntPtr,
757                 struct budb_dumpEntry *dumpEntryPtr)
758 {
759     memset(dumpEntryPtr, 0, sizeof(struct budb_dumpEntry));
760
761     dumpEntryPtr->id = tapeEntPtr->dump;
762     dumpEntryPtr->initialDumpID = 0;
763     dumpEntryPtr->parent = 0;
764     dumpEntryPtr->level = 0;
765     dumpEntryPtr->flags = 0;
766
767     strcpy(dumpEntryPtr->volumeSetName, "");
768     strcpy(dumpEntryPtr->dumpPath, "");
769     strcpy(dumpEntryPtr->name, DUMP_TAPE_NAME);
770
771     dumpEntryPtr->created = tapeEntPtr->dump;
772     dumpEntryPtr->incTime = 0;
773     dumpEntryPtr->nVolumes = 0;
774
775     strcpy(dumpEntryPtr->tapes.format, DUMP_TAPE_NAME);
776     strcat(dumpEntryPtr->tapes.format, ".%d");
777     dumpEntryPtr->tapes.b = tapeEntPtr->seq;
778     dumpEntryPtr->tapes.maxTapes = 0;
779     return 0;
780 }
781
782 /* readDbTape
783  *      prompt for a specific database tape
784  */
785
786 afs_int32
787 readDbTape(struct butm_tapeInfo *tapeInfoPtr,
788            struct rstTapeInfo *rstTapeInfoPtr, int query)
789 {
790     afs_int32 code = 0;
791     int interactiveFlag;
792     afs_int32 taskId;
793     struct butm_tapeLabel oldTapeLabel;
794     char AFStapeName[BU_MAXTAPELEN], tapeName[BU_MAXTAPELEN];
795     struct tapeEntryList *endList;
796     int tapecount = 1;
797     struct budb_dumpEntry de;
798     struct budb_tapeEntry te;
799
800     taskId = rstTapeInfoPtr->taskId;
801     interactiveFlag = query;
802
803     /* construct the name of the tape */
804     sprintf(AFStapeName, "%s.%-d", DUMP_TAPE_NAME, rstTapeInfoPtr->tapeSeq);
805     strcpy(tapeName, AFStapeName);
806
807     /* Will prompt for the latest saved database tape, but will accept any one */
808     if (rstTapeInfoPtr->tapeSeq == 1) {
809         code = bcdb_FindLatestDump("", "", &de);
810         if (!code)
811             rstTapeInfoPtr->dumpid = de.id;
812     }
813     if (rstTapeInfoPtr->dumpid) {
814         code =
815             bcdb_FindTapeSeq(rstTapeInfoPtr->dumpid, rstTapeInfoPtr->tapeSeq,
816                              &te);
817         if (!code)
818             strcpy(tapeName, te.name);
819     }
820     code = 0;
821
822     while (1) {                 /*w */
823         if (interactiveFlag) {  /* need a tape to read */
824             code =
825                 PromptForTape(RESTOREDBOPCODE, tapeName,
826                               rstTapeInfoPtr->dumpid, taskId, tapecount);
827             if (code)
828                 ERROR_EXIT(code);
829         }
830         interactiveFlag = 1;
831         tapecount++;
832
833         code = butm_Mount(tapeInfoPtr, tapeName);
834         if (code) {
835             TapeLog(0, taskId, code, tapeInfoPtr->error, "Can't open tape\n");
836             goto getNewTape;
837         }
838
839         code = butm_ReadLabel(tapeInfoPtr, &oldTapeLabel, 1);   /* will rewind the tape */
840         if (code) {
841             TapeLog(0, taskId, code, tapeInfoPtr->error,
842                     "Can't read tape label\n");
843             goto getNewTape;
844         }
845
846         /* Check for name of tape and matching dump id (if applicable). */
847         if ((strcmp(oldTapeLabel.AFSName, AFStapeName) != 0)
848             || ((rstTapeInfoPtr->tapeSeq != 1)
849                 && (oldTapeLabel.dumpid != rstTapeInfoPtr->dumpid))) {
850             char expTape[BU_MAXTAPELEN + 32];
851             char gotTape[BU_MAXTAPELEN + 32];
852
853             TAPENAME(expTape, tapeName, rstTapeInfoPtr->dumpid);
854             TAPENAME(gotTape, oldTapeLabel.AFSName, oldTapeLabel.dumpid);
855
856             TLog(taskId, "Tape label expected %s, label seen %s\n", expTape,
857                  gotTape);
858             goto getNewTape;
859         }
860
861         if (rstTapeInfoPtr->tapeSeq == 1)       /* Remember this dumpId */
862             rstTapeInfoPtr->dumpid = oldTapeLabel.dumpid;
863
864         break;
865
866       getNewTape:
867         unmountTape(taskId, tapeInfoPtr);
868     }                           /*w */
869
870
871     /* Initialize a tapeEntry for later inclusion into the database */
872     listEntryPtr = calloc(1, sizeof(struct tapeEntryList));
873     if (!listEntryPtr)
874         ERROR_EXIT(TC_NOMEMORY);
875
876     /* Fill in tape entry so we can save it later */
877     strcpy(tapeEntryPtr->name, TNAME(&oldTapeLabel));
878     tapeEntryPtr->dump = oldTapeLabel.dumpid;
879     tapeEntryPtr->flags = BUDB_TAPE_BEINGWRITTEN;
880     tapeEntryPtr->written = oldTapeLabel.creationTime;
881     tapeEntryPtr->expires = oldTapeLabel.expirationDate;
882     tapeEntryPtr->seq = extractTapeSeq(oldTapeLabel.AFSName);
883     tapeEntryPtr->useCount = oldTapeLabel.useCount;
884     tapeEntryPtr->useKBytes = 0;
885     tapeEntryPtr->labelpos = 0;
886
887     /* Thread onto end of single-linked list */
888     if (listEntryHead) {
889         endList = listEntryHead;
890         while (endList->next)
891             endList = endList->next;
892         endList->next = listEntryPtr;
893     } else
894         listEntryHead = listEntryPtr;
895
896   error_exit:
897     return (code);
898 }
899
900 static afs_int32 nbytes = 0;    /* # bytes left in buffer */
901 static void
902 initTapeBuffering(void)
903 {
904     nbytes = 0;
905 }
906
907
908 /* restoreDbEntries
909  *      restore all the items on the tape
910  * entry:
911  *      tape positioned after tape label
912  */
913
914 static int
915 restoreDbEntries(struct butm_tapeInfo *tapeInfoPtr,
916                  struct rstTapeInfo *rstTapeInfoPtr)
917 {
918     struct structDumpHeader netItemHeader, hostItemHeader;
919     afs_int32 more = 1;
920     afs_int32 taskId, code = 0;
921     int count = 0;
922
923     taskId = rstTapeInfoPtr->taskId;
924
925     /* clear state for the buffer routine(s) */
926     initTapeBuffering();
927
928     code = butm_ReadFileBegin(tapeInfoPtr);
929     if (code) {
930         ErrorLog(0, taskId, code, tapeInfoPtr->error,
931                  "Can't read FileBegin on tape\n");
932         ERROR_EXIT(code);
933     }
934
935     /* get the first item-header */
936     memset(&netItemHeader, 0, sizeof(netItemHeader));
937     code =
938         getTapeData(tapeInfoPtr, rstTapeInfoPtr, &netItemHeader,
939                     sizeof(netItemHeader));
940     if (code)
941         ERROR_EXIT(code);
942     structDumpHeader_ntoh(&netItemHeader, &hostItemHeader);
943
944     while (more) {
945         switch (hostItemHeader.type) {
946         case SD_DBHEADER:
947             code =
948                 restoreDbHeader(tapeInfoPtr, rstTapeInfoPtr, &hostItemHeader);
949             if (code)
950                 ERROR_EXIT(code);
951             break;
952
953         case SD_DUMP:
954             if (++count > 25) { /*every 25 dumps, wait */
955                 waitDbWatcher();
956                 count = 0;
957             }
958             code =
959                 restoreDbDump(tapeInfoPtr, rstTapeInfoPtr, &hostItemHeader);
960             if (code)
961                 ERROR_EXIT(code);
962             break;
963
964         case SD_TAPE:
965         case SD_VOLUME:
966             ERROR_EXIT(-1);
967             break;
968
969         case SD_TEXT_DUMPSCHEDULE:
970         case SD_TEXT_VOLUMESET:
971         case SD_TEXT_TAPEHOSTS:
972             code = restoreText(tapeInfoPtr, rstTapeInfoPtr, &hostItemHeader);
973             if (code)
974                 ERROR_EXIT(code);
975             break;
976
977         case SD_END:
978             more = 0;
979             break;
980
981         default:
982             TLog(taskId, "Unknown database header type %d\n",
983                  hostItemHeader.type);
984             ERROR_EXIT(-1);
985             break;
986         }
987     }
988
989     code = butm_ReadFileEnd(tapeInfoPtr);
990     if (code) {
991         ErrorLog(0, taskId, code, tapeInfoPtr->error,
992                  "Can't read EOF on tape\n");
993         ERROR_EXIT(code);
994     }
995
996     /* Mark tape as having been written */
997     tapeEntryPtr->useKBytes =
998         tapeInfoPtr->kBytes + (tapeInfoPtr->nBytes ? 1 : 0);
999     tapeEntryPtr->flags = BUDB_TAPE_WRITTEN;
1000
1001   error_exit:
1002     return (code);
1003 }
1004
1005 /* restoreDbFromTape
1006  *      restore the backup database from tape.
1007  */
1008
1009 void *
1010 restoreDbFromTape(void *param)
1011 {
1012     afs_uint32 taskId = (intptr_t) param;
1013     afs_int32 code = 0;
1014     afs_int32 i;
1015     struct butm_tapeInfo tapeInfo;
1016     struct rstTapeInfo rstTapeInfo;
1017     struct budb_dumpEntry dumpEntry;
1018
1019     extern struct tapeConfig globalTapeConfig;
1020     extern struct deviceSyncNode *deviceLatch;
1021
1022     afs_pthread_setname_self("Db restore");
1023     setStatus(taskId, DRIVE_WAIT);
1024     EnterDeviceQueue(deviceLatch);      /* lock tape device */
1025     clearStatus(taskId, DRIVE_WAIT);
1026
1027     printf("\n\n");
1028     TLog(taskId, "RestoreDb\n");
1029
1030     tapeInfo.structVersion = BUTM_MAJORVERSION;
1031     code = butm_file_Instantiate(&tapeInfo, &globalTapeConfig);
1032     if (code) {
1033         ErrorLog(0, taskId, code, tapeInfo.error,
1034                  "Can't initialize tape module\n");
1035         ERROR_EXIT(code);
1036     }
1037
1038     listEntryHead = NULL;
1039
1040     rstTapeInfo.taskId = taskId;
1041     rstTapeInfo.tapeSeq = 1;
1042     rstTapeInfo.dumpid = 0;
1043
1044     code = readDbTape(&tapeInfo, &rstTapeInfo, autoQuery);
1045     if (code)
1046         ERROR_EXIT(code);
1047
1048     code = restoreDbEntries(&tapeInfo, &rstTapeInfo);
1049     if (code)
1050         ERROR_EXIT(code);
1051
1052   error_exit:
1053     /* Now put this dump into the database */
1054     /* Make a dump entry from first tape   */
1055     listEntryPtr = listEntryHead;
1056     if (listEntryPtr) {
1057         makeDbDumpEntry(tapeEntryPtr, &dumpEntry);
1058         if (dumpEntry.id != 0) {
1059             i = bcdb_CreateDump(&dumpEntry);
1060             if (i) {
1061                 if (i == BUDB_DUMPIDEXISTS)
1062                     fprintf(stderr,
1063                             "Dump id %d not added to database - already exists\n",
1064                             dumpEntry.id);
1065                 else
1066                     TapeLog(0, taskId, i, 0,
1067                             "Dump id %d not added to database\n",
1068                             dumpEntry.id);
1069             } else {
1070                 i = addTapesToDb(taskId);
1071                 if (!code)
1072                     code = i;
1073
1074                 i = bcdb_FinishDump(&dumpEntry);
1075                 if (!code)
1076                     code = i;
1077             }
1078         }
1079         freeTapeList();
1080     }
1081
1082     unmountTape(taskId, &tapeInfo);
1083     waitDbWatcher();
1084
1085     if (code == TC_ABORTEDBYREQUEST) {
1086         TLog(taskId, "RestoreDb: Aborted by request\n");
1087         clearStatus(taskId, ABORT_REQUEST);
1088         setStatus(taskId, ABORT_DONE);
1089     } else if (code) {
1090         TapeLog(0, taskId, code, 0, "RestoreDb: Finished with errors\n");
1091         setStatus(taskId, TASK_ERROR);
1092     } else {
1093         TLog(taskId, "RestoreDb: Finished\n");
1094     }
1095
1096     LeaveDeviceQueue(deviceLatch);
1097     setStatus(taskId, TASK_DONE);
1098
1099     return (void *)(intptr_t)(code);
1100 }
1101
1102 /* KeepAlive
1103  *
1104  *      While dumping the database, keeps the connection alive.
1105  *      Every 10 seconds, wake up and ask to read 0 bytes of the database.
1106  *      This resets the database's internal timer so that it does not
1107  *      prematuraly quit (on asking for new tapes and such).
1108  *
1109  *      Use the same udbHandle as writeDbDump so we go to the same server.
1110  */
1111 void *
1112 KeepAlive(void *unused)
1113 {
1114     charListT charList;
1115     afs_int32 code;
1116     afs_int32 done;
1117
1118     extern struct udbHandleS udbHandle;
1119
1120     afs_pthread_setname_self("Keep-alive");
1121     while (1) {
1122 #ifdef AFS_PTHREAD_ENV
1123         sleep(5);
1124 #else
1125         IOMGR_Sleep(5);
1126 #endif
1127         charList.charListT_val = 0;
1128         charList.charListT_len = 0;
1129         code =
1130             ubik_Call_SingleServer(BUDB_DumpDB, udbHandle.uh_client,
1131                                    UF_SINGLESERVER, 0, 0, &charList, &done);
1132         if (code || done)
1133             break;
1134     }
1135     return 0;
1136 }
1137
1138
1139 /* restoreDbHeader
1140  *      restore special items in the header
1141  */
1142
1143 int
1144 restoreDbHeader(struct butm_tapeInfo *tapeInfo,
1145                 struct rstTapeInfo *rstTapeInfoPtr,
1146                 struct structDumpHeader *nextHeader)
1147 {
1148     struct structDumpHeader netItemHeader;
1149     struct DbHeader netDbHeader, hostDbHeader;
1150     afs_int32 code = 0;
1151
1152     extern struct udbHandleS udbHandle;
1153
1154     /* Read the database header */
1155     memset(&netDbHeader, 0, sizeof(netDbHeader));
1156     code =
1157         getTapeData(tapeInfo, rstTapeInfoPtr, &netDbHeader,
1158                     sizeof(netDbHeader));
1159     if (code)
1160         ERROR_EXIT(code);
1161     DbHeader_ntoh(&netDbHeader, &hostDbHeader);
1162
1163     /* Add the database header to the database */
1164     code =
1165         ubik_BUDB_RestoreDbHeader(udbHandle.uh_client, 0,
1166                   &hostDbHeader);
1167     if (code) {
1168         ErrorLog(0, rstTapeInfoPtr->taskId, code, 0,
1169                  "Can't restore DB Header\n");
1170         ERROR_EXIT(code);
1171     }
1172
1173     /* get the next item-header */
1174     memset(nextHeader, 0, sizeof(*nextHeader));
1175     code =
1176         getTapeData(tapeInfo, rstTapeInfoPtr, &netItemHeader,
1177                     sizeof(netItemHeader));
1178     if (code)
1179         ERROR_EXIT(code);
1180     structDumpHeader_ntoh(&netItemHeader, nextHeader);
1181
1182   error_exit:
1183     return (code);
1184 }
1185
1186
1187 /* restoreDbDump
1188  *      restore a single dump, including all its tapes and volumes, from
1189  *      the tape.
1190  * entry:
1191  *      nextHeader - ptr to structure for return value
1192  * exit:
1193  *      nextHeader - next structure header from tape
1194  * notes:
1195  *      upon entry, the dump structure header has been read confirming that
1196  *      a database dump tree exists on the tape
1197  */
1198
1199 int
1200 restoreDbDump(struct butm_tapeInfo *tapeInfo,
1201               struct rstTapeInfo *rstTapeInfoPtr,
1202               struct structDumpHeader *nextHeader)
1203 {
1204     struct budb_dumpEntry netDumpEntry, hostDumpEntry;
1205     struct budb_tapeEntry netTapeEntry, hostTapeEntry;
1206     struct budb_volumeEntry netVolumeEntry, hostVolumeEntry;
1207     struct structDumpHeader netItemHeader;
1208     int restoreThisDump = 1;
1209     afs_int32 code = 0;
1210
1211     extern struct udbHandleS udbHandle;
1212
1213     /* read dump entry */
1214     memset(&netDumpEntry, 0, sizeof(netDumpEntry));
1215     code =
1216         getTapeData(tapeInfo, rstTapeInfoPtr, &netDumpEntry,
1217                     sizeof(netDumpEntry));
1218     if (code)
1219         ERROR_EXIT(code);
1220
1221     /* If database tape does not have a dumpid (AFS 3.3) then no initial/appended dumps */
1222     if (rstTapeInfoPtr->dumpid == 0) {
1223         netDumpEntry.initialDumpID = 0;
1224         netDumpEntry.appendedDumpID = 0;
1225     }
1226
1227     dumpEntry_ntoh(&netDumpEntry, &hostDumpEntry);
1228
1229     /* The dump entry for this database tape is incomplete, so don't include it */
1230     if (hostDumpEntry.id == rstTapeInfoPtr->dumpid)
1231         restoreThisDump = 0;
1232
1233     /* add the dump to the database */
1234     if (restoreThisDump) {
1235         code =
1236             threadEntryDir(&hostDumpEntry, sizeof(hostDumpEntry),
1237                            DLQ_USEDUMP);
1238         if (code)
1239             ERROR_EXIT(code);
1240     }
1241
1242     /* get the next item-header */
1243     memset(nextHeader, 0, sizeof(*nextHeader));
1244     code =
1245         getTapeData(tapeInfo, rstTapeInfoPtr, &netItemHeader,
1246                     sizeof(netItemHeader));
1247     if (code)
1248         ERROR_EXIT(code);
1249     structDumpHeader_ntoh(&netItemHeader, nextHeader);
1250
1251     /* Add every tape to the db */
1252     while (nextHeader->type == SD_TAPE) {       /*t */
1253
1254         /* read the tape entry */
1255         memset(&netTapeEntry, 0, sizeof(netTapeEntry));
1256         code =
1257             getTapeData(tapeInfo, rstTapeInfoPtr, &netTapeEntry,
1258                         sizeof(netTapeEntry));
1259         if (code)
1260             ERROR_EXIT(code);
1261         tapeEntry_ntoh(&netTapeEntry, &hostTapeEntry);
1262
1263         /* Add the tape to the database */
1264         if (restoreThisDump) {
1265             code =
1266                 threadEntryDir(&hostTapeEntry, sizeof(hostTapeEntry),
1267                                DLQ_USETAPE);
1268             if (code)
1269                 ERROR_EXIT(code);
1270         }
1271
1272         /* get the next item-header */
1273         memset(nextHeader, 0, sizeof(*nextHeader));
1274         code =
1275             getTapeData(tapeInfo, rstTapeInfoPtr, &netItemHeader,
1276                         sizeof(netItemHeader));
1277         if (code)
1278             ERROR_EXIT(code);
1279         structDumpHeader_ntoh(&netItemHeader, nextHeader);
1280
1281         /* Add every volume to the db */
1282         while (nextHeader->type == SD_VOLUME) { /*v */
1283
1284             /* read the volume entry */
1285             memset(&netVolumeEntry, 0, sizeof(netVolumeEntry));
1286             code =
1287                 getTapeData(tapeInfo, rstTapeInfoPtr, &netVolumeEntry,
1288                             sizeof(netVolumeEntry));
1289             if (code)
1290                 ERROR_EXIT(code);
1291             volumeEntry_ntoh(&netVolumeEntry, &hostVolumeEntry);
1292
1293             if (restoreThisDump) {
1294                 code =
1295                     threadEntryDir(&hostVolumeEntry, sizeof(hostVolumeEntry),
1296                                    DLQ_VOLENTRY);
1297                 if (code)
1298                     ERROR_EXIT(code);
1299             }
1300
1301             /* get the next item-header */
1302             memset(nextHeader, 0, sizeof(*nextHeader));
1303             code =
1304                 getTapeData(tapeInfo, rstTapeInfoPtr, &netItemHeader,
1305                             sizeof(netItemHeader));
1306             if (code)
1307                 ERROR_EXIT(code);
1308             structDumpHeader_ntoh(&netItemHeader, nextHeader);
1309         }                       /*v */
1310
1311         /* Finish the tape */
1312         if (restoreThisDump) {
1313             code =
1314                 threadEntryDir(&hostTapeEntry, sizeof(hostTapeEntry),
1315                                DLQ_FINISHTAPE);
1316             if (code)
1317                 ERROR_EXIT(code);
1318         }
1319     }                           /*t */
1320
1321     /* Finish the dump */
1322     if (restoreThisDump) {
1323         code =
1324             threadEntryDir(&hostDumpEntry, sizeof(hostDumpEntry),
1325                            DLQ_FINISHDUMP);
1326         if (code)
1327             ERROR_EXIT(code);
1328     }
1329
1330   error_exit:
1331     return (code);
1332 }
1333
1334 /* saveTextFile
1335  *      Save the specified file as configuration text in the ubik database.
1336  *      Have to setup the client text structure so that we can call
1337  *      the routine to transmit the text to the db.
1338  */
1339
1340 afs_int32
1341 saveTextFile(afs_int32 taskId, afs_int32 textType, char *fileName)
1342 {
1343     udbClientTextP ctPtr = 0;
1344     afs_int32 code = 0;
1345     int tlock = 0;
1346
1347     ctPtr = calloc(1, sizeof(*ctPtr));
1348     if (!ctPtr)
1349         ERROR_EXIT(TC_NOMEMORY);
1350
1351     ctPtr->textType = textType;
1352
1353     /* lock the text in the database */
1354     code = bc_LockText(ctPtr);
1355     if (code) {
1356         ErrorLog(0, taskId, code, 0, "Can't lock text file\n");
1357         ERROR_EXIT(code);
1358     }
1359     tlock = 1;
1360
1361     ctPtr->textStream = fopen(fileName, "r");
1362     if (!ctPtr->textStream) {
1363         ErrorLog(0, taskId, errno, 0, "Can't open text file\n");
1364         ERROR_EXIT(errno);
1365     }
1366
1367     /* now send the text to the database */
1368     code = bcdb_SaveTextFile(ctPtr);
1369     if (code) {
1370         ErrorLog(0, taskId, code, 0, "Can't save text file\n");
1371         ERROR_EXIT(code);
1372     }
1373
1374   error_exit:
1375     if (ctPtr) {
1376         if (ctPtr->textStream)
1377             fclose(ctPtr->textStream);
1378         if (tlock)
1379             bc_UnlockText(ctPtr);
1380         free(ctPtr);
1381     }
1382     return (code);
1383 }
1384
1385 /* restoreText
1386  *      read the text off the tape, and store it in the appropriate
1387  *      text type in the database.
1388  * entry:
1389  *      nextHeader - ptr to struct for return information
1390  * exit:
1391  *      nextHeader - struct header for next item on the tape
1392  */
1393
1394 int
1395 restoreText(struct butm_tapeInfo *tapeInfo,
1396             struct rstTapeInfo *rstTapeInfoPtr,
1397             struct structDumpHeader *nextHeader)
1398 {
1399     char filename[64];
1400     afs_int32 nbytes;
1401     char *readBuffer = 0;
1402     afs_int32 readBlockSize;
1403     afs_int32 transferSize;
1404     struct structDumpHeader netItemHeader;
1405     int fid = -1;
1406     afs_int32 code = 0;
1407
1408     udbClientTextP ctPtr = 0;
1409     afs_int32 textType;
1410
1411     ctPtr = malloc(sizeof(*ctPtr));
1412     if (!ctPtr)
1413         ERROR_EXIT(TC_NOMEMORY);
1414
1415     /* determine the type of text block */
1416     switch (nextHeader->type) {
1417     case SD_TEXT_DUMPSCHEDULE:
1418         textType = TB_DUMPSCHEDULE;
1419         break;
1420
1421     case SD_TEXT_VOLUMESET:
1422         textType = TB_VOLUMESET;
1423         break;
1424
1425     case SD_TEXT_TAPEHOSTS:
1426         textType = TB_TAPEHOSTS;
1427         break;
1428
1429     default:
1430         ErrorLog(0, rstTapeInfoPtr->taskId, TC_INTERNALERROR, 0,
1431                  "Unknown text block\n");
1432         ERROR_EXIT(TC_INTERNALERROR);
1433         break;
1434     }
1435
1436     /* open the text file */
1437     sprintf(filename, "%s/bu_XXXXXX", gettmpdir());
1438     fid = mkstemp(filename);
1439     if (fid < 0) {
1440         ErrorLog(0, rstTapeInfoPtr->taskId, errno, 0,
1441                  "Can't open temporary text file: %s\n", filename);
1442         ERROR_EXIT(errno);
1443     }
1444
1445     /* allocate buffer for text */
1446     readBlockSize = BUTM_BLKSIZE;
1447     readBuffer = malloc(readBlockSize);
1448     if (!readBuffer)
1449         ERROR_EXIT(TC_NOMEMORY);
1450
1451     /* read the text into the temporary file */
1452     nbytes = nextHeader->size;
1453     while (nbytes > 0) {
1454         transferSize = (readBlockSize < nbytes) ? readBlockSize : nbytes;
1455
1456         /* read it from the tape */
1457         code =
1458             getTapeData(tapeInfo, rstTapeInfoPtr, readBuffer, transferSize);
1459         if (code)
1460             ERROR_EXIT(code);
1461
1462         /* write to the file */
1463         if (write(fid, readBuffer, transferSize) != transferSize) {
1464             ErrorLog(0, rstTapeInfoPtr->taskId, errno, 0,
1465                      "Can't write temporary text file: %s\n", filename);
1466             ERROR_EXIT(errno);
1467         }
1468
1469         nbytes -= transferSize;
1470     }
1471
1472     close(fid);
1473     fid = -1;
1474     code = saveTextFile(rstTapeInfoPtr->taskId, textType, filename);
1475     if (code)
1476         ERROR_EXIT(code);
1477     unlink(filename);
1478
1479     /* get the next item-header */
1480     memset(nextHeader, 0, sizeof(*nextHeader));
1481     code =
1482         getTapeData(tapeInfo, rstTapeInfoPtr, &netItemHeader,
1483                     sizeof(netItemHeader));
1484     if (code)
1485         ERROR_EXIT(code);
1486     structDumpHeader_ntoh(&netItemHeader, nextHeader);
1487
1488   error_exit:
1489     if (ctPtr)
1490         free(ctPtr);
1491     if (readBuffer)
1492         free(readBuffer);
1493     if (fid != -1) {
1494         close(fid);
1495         unlink(filename);
1496     }
1497     return (code);
1498 }
1499
1500
1501 /* ----------------------------------
1502  * Tape data buffering - for reading database dumps
1503  * ----------------------------------
1504  */
1505
1506 static char *tapeReadBuffer = 0;        /* input buffer */
1507 static char *tapeReadBufferPtr = 0;     /* position in buffer */
1508
1509 /* getTapeData
1510  *      Read information from tape, and place the requested number of bytes
1511  *      in the buffer supplied
1512  * entry:
1513  *      tapeInfo
1514  *      rstTapeInfoPtr - Info about the dump being restored.
1515  *      buffer - buffer for requested data
1516  *      requestedBytes - no. of bytes requested
1517  * exit:
1518  *      fn retn - 0, ok, n, error
1519  */
1520
1521 int
1522 getTapeData(struct butm_tapeInfo *tapeInfoPtr,
1523             struct rstTapeInfo *rstTapeInfoPtr,
1524             void *out, afs_int32 requestedBytes)
1525 {
1526     char *buffer = (char *) out;
1527     afs_int32 taskId, transferBytes;
1528     afs_int32 code = 0;
1529
1530     taskId = rstTapeInfoPtr->taskId;
1531
1532     if (checkAbortByTaskId(taskId))
1533         ERROR_EXIT(TC_ABORTEDBYREQUEST);
1534
1535     if (!tapeReadBuffer) {
1536         tapeReadBuffer = malloc(BUTM_BLOCKSIZE);
1537         if (!tapeReadBuffer)
1538             ERROR_EXIT(TC_NOMEMORY);
1539     }
1540
1541     while (requestedBytes > 0) {
1542         if (nbytes == 0) {
1543             tapeReadBufferPtr = &tapeReadBuffer[sizeof(struct blockMark)];
1544
1545             /* get more data */
1546             code =
1547                 butm_ReadFileData(tapeInfoPtr, tapeReadBufferPtr,
1548                                   BUTM_BLKSIZE, &nbytes);
1549             if (code) {
1550                 /* detect if we hit the end-of-tape and get next tape */
1551                 if (code == BUTM_ENDVOLUME) {
1552                     /* Update fields in tape entry for this tape */
1553                     tapeEntryPtr->flags = BUDB_TAPE_WRITTEN;
1554                     tapeEntryPtr->useKBytes =
1555                         tapeInfoPtr->kBytes + (tapeInfoPtr->nBytes ? 1 : 0);
1556
1557                     unmountTape(taskId, tapeInfoPtr);
1558
1559                     rstTapeInfoPtr->tapeSeq++;
1560                     code = readDbTape(tapeInfoPtr, rstTapeInfoPtr, 1);
1561                     if (code)
1562                         ERROR_EXIT(code);
1563
1564                     code = butm_ReadFileBegin(tapeInfoPtr);
1565                     if (code) {
1566                         ErrorLog(0, taskId, code, tapeInfoPtr->error,
1567                                  "Can't read FileBegin on tape\n");
1568                         ERROR_EXIT(code);
1569                     }
1570
1571                     continue;
1572                 }
1573
1574                 ErrorLog(0, taskId, code, tapeInfoPtr->error,
1575                          "Can't read FileData on tape\n");
1576                 ERROR_EXIT(code);
1577             }
1578         }
1579
1580         /* copy out data */
1581         transferBytes = (nbytes < requestedBytes) ? nbytes : requestedBytes;
1582         memcpy(buffer, tapeReadBufferPtr, transferBytes);
1583         tapeReadBufferPtr += transferBytes;
1584         buffer += transferBytes;
1585         nbytes -= transferBytes;
1586         requestedBytes -= transferBytes;
1587     }
1588
1589   error_exit:
1590     return (code);
1591 }