2 * Copyright 2000, International Business Machines Corporation and others.
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
10 #include <afsconfig.h>
11 #include <afs/param.h>
16 #include <afs/bubasics.h>
17 #include <afs/afsutil.h>
22 #include "budb_errs.h"
24 #include "budb_internal.h"
25 #include "budb_prototypes.h"
27 /* ----------------------------------
28 * structure printing utilities
29 * ----------------------------------
33 printDbHeader(struct DbHeader
*ptr
)
35 time_t created
= ptr
->created
;
36 printf("version = %d\n", ptr
->dbversion
);
37 printf("created = %s", ctime(&created
));
38 printf("cell = %s\n", ptr
->cell
);
39 printf("lastDumpId = %u\n", ptr
->lastDumpId
);
40 printf("lastInstanceId = %d\n", ptr
->lastInstanceId
);
41 printf("lastTapeId = %d\n", ptr
->lastTapeId
);
45 printDump(FILE *fid
, struct dump
*dptr
)
47 time_t created
= dptr
->created
;
48 fprintf(fid
, "id = %u\n", dptr
->id
);
49 fprintf(fid
, "idHashChain = %d\n", dptr
->idHashChain
);
50 fprintf(fid
, "name = %s\n", dptr
->dumpName
);
51 fprintf(fid
, "vsname = %s\n", dptr
->volumeSet
);
52 fprintf(fid
, "dumpPath = %s\n", dptr
->dumpPath
);
53 fprintf(fid
, "nameHashChain = %d\n", dptr
->nameHashChain
);
54 fprintf(fid
, "flags = 0x%x\n", dptr
->flags
);
55 fprintf(fid
, "parent = %u\n", dptr
->parent
);
56 fprintf(fid
, "created = %s", ctime(&created
));
57 fprintf(fid
, "nVolumes = %d\n", dptr
->nVolumes
);
58 /* printTapeSet(&dptr->tapes); */
59 fprintf(fid
, "firstTape = %d\n", dptr
->firstTape
);
60 /* printKtcPrincipal(&dptr->dumper); */
65 printDumpEntry(struct budb_dumpEntry
*deptr
)
67 time_t created
= deptr
->created
;
68 printf("id = %u\n", deptr
->id
);
69 printf("Initial id = %u\n", deptr
->initialDumpID
);
70 printf("Appended id = %u\n", deptr
->appendedDumpID
);
71 printf("parent = %u\n", deptr
->parent
);
72 printf("level = %d\n", deptr
->level
);
73 printf("flags = 0x%x", deptr
->flags
);
74 if (deptr
->flags
== 0)
75 printf(": Successful");
76 if (deptr
->flags
& BUDB_DUMP_INCOMPLETE
)
77 printf(": Incomplete");
78 if (deptr
->flags
& BUDB_DUMP_TAPEERROR
)
79 printf(": Tape error");
80 if (deptr
->flags
& BUDB_DUMP_INPROGRESS
)
81 printf(": In progress");
82 if (deptr
->flags
& BUDB_DUMP_ABORTED
)
84 if (deptr
->flags
& BUDB_DUMP_ADSM
)
85 printf(": (ADSM)"); /* XBSA interface to ADSM */
86 if (deptr
->flags
& BUDB_DUMP_BUTA
)
87 printf(": (BUTA)"); /* buta dump */
89 printf("volumeSet = %s\n", deptr
->volumeSetName
);
90 printf("dump path = %s\n", deptr
->dumpPath
);
91 printf("name = %s\n", deptr
->name
);
92 printf("created = %s", ctime(&created
));
93 printf("nVolumes = %d\n", deptr
->nVolumes
);
95 printTapeSet(&deptr
->tapes
, (deptr
->flags
& BUDB_DUMP_XBSA_NSS
));
96 printPrincipal(&deptr
->dumper
);
99 /* printMemoryHashTable
100 * print the hash table structure, i.e. the header structure.
103 printMemoryHashTable(FILE *fid
, struct memoryHashTable
*mhtptr
)
105 fprintf(fid
, "threadOffset = %d\n", mhtptr
->threadOffset
);
106 fprintf(fid
, "length = %d\n", mhtptr
->length
);
107 fprintf(fid
, "progress = %d\n", mhtptr
->progress
);
108 fprintf(fid
, "size = %d\n", mhtptr
->size
);
109 fprintf(fid
, "oldsize = %d\n", mhtptr
->oldSize
);
114 printPrincipal(struct budb_principal
*ptr
)
116 printf("name = %s\n", ptr
->name
);
117 printf("instance = %s\n", ptr
->instance
);
118 printf("cell = %s\n", ptr
->cell
);
123 printStructDumpHeader(struct structDumpHeader
*ptr
)
125 printf("type = %d\n", ptr
->type
);
126 printf("structure version = %d\n", ptr
->structversion
);
127 printf("size = %d bytes\n", ptr
->size
);
132 printTape(FILE *fid
, struct tape
*tptr
)
134 time_t written
= tptr
->written
;
135 fprintf(fid
, "name = %s\n", tptr
->name
);
136 fprintf(fid
, "nameHashChain = %d\n", tptr
->nameHashChain
);
137 fprintf(fid
, "flags = 0x%x\n", tptr
->flags
);
138 fprintf(fid
, "written = %s", ctime(&written
));
139 fprintf(fid
, "nMBytes = %d\n", tptr
->nMBytes
);
140 fprintf(fid
, "nBytes = %d\n", tptr
->nBytes
);
141 fprintf(fid
, "nFiles = %d\n", tptr
->nFiles
);
142 fprintf(fid
, "nVolumes = %d\n", tptr
->nVolumes
);
143 fprintf(fid
, "seq = %d\n", tptr
->seq
);
144 fprintf(fid
, "dump = %d\n", tptr
->dump
);
145 fprintf(fid
, "nextTape = %d\n", tptr
->nextTape
);
146 fprintf(fid
, "firstVol = %d\n", tptr
->firstVol
);
147 fprintf(fid
, "labelPos = %d\n", tptr
->labelpos
);
148 fprintf(fid
, "useCount = %d\n", tptr
->useCount
);
153 printTapeEntry(struct budb_tapeEntry
*teptr
)
155 time_t written
= teptr
->written
;
156 time_t expires
= teptr
->expires
;
158 printf("name = %s\n", teptr
->name
);
159 printf("flags = 0x%x", teptr
->flags
);
160 if (teptr
->flags
& BUDB_TAPE_TAPEERROR
)
162 if (teptr
->flags
& BUDB_TAPE_DELETED
)
164 if (teptr
->flags
& BUDB_TAPE_BEINGWRITTEN
)
165 printf(": In progress");
166 if (teptr
->flags
& BUDB_TAPE_ABORTED
)
168 if (teptr
->flags
& BUDB_TAPE_STAGED
)
170 if (teptr
->flags
& BUDB_TAPE_WRITTEN
)
171 printf(": Successful");
173 printf("written = %s", ctime(&written
));
174 printf("expires = %s", cTIME(&expires
));
175 printf("kBytes Tape Used = %u\n", teptr
->useKBytes
);
176 printf("nMBytes Data = %d\n", teptr
->nMBytes
);
177 printf("nBytes Data = %d\n", teptr
->nBytes
);
178 printf("nFiles = %d\n", teptr
->nFiles
);
179 printf("nVolumes = %d\n", teptr
->nVolumes
);
180 printf("seq = %d\n", teptr
->seq
);
181 printf("labelPos = %d\n", teptr
->labelpos
);
182 printf("useCount = %d\n", teptr
->useCount
);
183 printf("dump = %d\n", teptr
->dump
);
188 printTapeSet(struct budb_tapeSet
*tsptr
,
189 afs_int32 nss
) /* is the tapeserver name an accurate name */
191 printf("Group id = %d\n", tsptr
->id
);
192 printf("tapeServer = %s%s\n", tsptr
->tapeServer
,
193 (nss
? " (single server)" : ""));
194 printf("format = %s\n", tsptr
->format
);
195 printf("maxTapes = %d\n", tsptr
->maxTapes
);
196 /* printf("a = %d\n",tsptr->a ); */
197 /* printf("b = %d\n",tsptr->b); */
198 printf("Start Tape Seq = %d\n", tsptr
->b
);
203 printVolumeEntry(struct budb_volumeEntry
*veptr
)
205 time_t clone
= veptr
->clone
;
206 printf("name = %s\n", veptr
->name
);
207 printf("flags = 0x%x", veptr
->flags
);
208 if (veptr
->flags
& BUDB_VOL_TAPEERROR
)
209 printf(": Tape Error");
210 if (veptr
->flags
& BUDB_VOL_FILEERROR
)
211 printf(": File Error");
212 if (veptr
->flags
& BUDB_VOL_BEINGWRITTEN
)
213 printf(": In progress");
214 if (veptr
->flags
& BUDB_VOL_FIRSTFRAG
)
215 printf(": First fragment");
216 if (veptr
->flags
& BUDB_VOL_LASTFRAG
)
217 printf(": Last fragment");
218 if (veptr
->flags
& BUDB_VOL_ABORTED
)
221 printf("id = %d\n", veptr
->id
);
222 printf("server = %s\n", veptr
->server
);
223 printf("partition = %d\n", veptr
->partition
);
224 printf("tapeSeq = %d\n", veptr
->tapeSeq
);
226 printf("position = %d\n", veptr
->position
);
227 printf("clone = %s", ctime(&clone
));
228 printf("startByte = %d\n", veptr
->startByte
);
229 printf("nBytes = %d\n", veptr
->nBytes
);
230 printf("seq = %d\n", veptr
->seq
);
232 printf("dump = %d\n", veptr
->dump
);
233 printf("tape = %s\n", veptr
->tape
);
238 printVolFragment(FILE *fid
, struct volFragment
*vfptr
)
240 time_t clone
= vfptr
->clone
;
241 time_t incTime
= vfptr
->incTime
;
242 fprintf(fid
, "vol = %d\n", vfptr
->vol
);
243 fprintf(fid
, "sameNameChain = %d\n", vfptr
->sameNameChain
);
244 fprintf(fid
, "tape = %d\n", vfptr
->tape
);
245 fprintf(fid
, "sameTapeChain = %d\n", vfptr
->sameTapeChain
);
246 fprintf(fid
, "position = %d\n", vfptr
->position
);
247 fprintf(fid
, "clone = %s", ctime(&clone
));
248 fprintf(fid
, "incTime = %s", ctime(&incTime
));
249 fprintf(fid
, "startByte = %d\n", vfptr
->startByte
);
250 fprintf(fid
, "nBytes = %d\n", vfptr
->nBytes
);
251 fprintf(fid
, "flags = %d\n", vfptr
->flags
);
252 fprintf(fid
, "sequence = %d\n", vfptr
->sequence
);
257 printVolInfo(FILE *fid
, struct volInfo
*viptr
)
259 fprintf(fid
, "name = %s\n", viptr
->name
);
260 fprintf(fid
, "nameHashChain = %d\n", viptr
->nameHashChain
);
261 fprintf(fid
, "id = %d\n", viptr
->id
);
262 fprintf(fid
, "server = %s\n", viptr
->server
);
263 fprintf(fid
, "partition = %d\n", viptr
->partition
);
264 fprintf(fid
, "flags = 0x%x\n", viptr
->flags
);
265 fprintf(fid
, "sameNameHead = %d\n", viptr
->sameNameHead
);
266 fprintf(fid
, "sameNameChain = %d\n", viptr
->sameNameChain
);
267 fprintf(fid
, "firstFragment = %d\n", viptr
->firstFragment
);
268 fprintf(fid
, "nFrags = %d\n", viptr
->nFrags
);
273 /* -----------------------------------------
274 * structure xdr routines
275 * -----------------------------------------
278 /* utilities - network to host conversion
279 * currently used for debug only
283 volFragment_ntoh(struct volFragment
*netVfPtr
,
284 struct volFragment
*hostVfPtr
)
286 hostVfPtr
->vol
= ntohl(netVfPtr
->vol
);
287 hostVfPtr
->sameNameChain
= ntohl(netVfPtr
->sameNameChain
);
288 hostVfPtr
->tape
= ntohl(netVfPtr
->tape
);
289 hostVfPtr
->sameTapeChain
= ntohl(netVfPtr
->sameTapeChain
);
290 hostVfPtr
->position
= ntohl(netVfPtr
->position
);
291 hostVfPtr
->clone
= ntohl(netVfPtr
->clone
);
292 hostVfPtr
->incTime
= ntohl(netVfPtr
->incTime
);
293 hostVfPtr
->startByte
= ntohl(netVfPtr
->startByte
);
294 hostVfPtr
->nBytes
= ntohl(netVfPtr
->nBytes
);
295 hostVfPtr
->flags
= ntohs(netVfPtr
->flags
);
296 hostVfPtr
->sequence
= ntohs(netVfPtr
->sequence
);
300 volInfo_ntoh(struct volInfo
*netViPtr
,
301 struct volInfo
*hostViPtr
)
303 strcpy(hostViPtr
->name
, netViPtr
->name
);
304 hostViPtr
->nameHashChain
= ntohl(netViPtr
->nameHashChain
);
305 hostViPtr
->id
= ntohl(netViPtr
->id
);
306 strcpy(hostViPtr
->server
, netViPtr
->server
);
307 hostViPtr
->partition
= ntohl(netViPtr
->partition
);
308 hostViPtr
->flags
= ntohl(netViPtr
->flags
);
309 hostViPtr
->sameNameHead
= ntohl(netViPtr
->sameNameHead
);
310 hostViPtr
->sameNameChain
= ntohl(netViPtr
->sameNameChain
);
311 hostViPtr
->firstFragment
= ntohl(netViPtr
->firstFragment
);
312 hostViPtr
->nFrags
= ntohl(netViPtr
->nFrags
);
316 tape_ntoh(struct tape
*netTapePtr
,
317 struct tape
*hostTapePtr
)
319 strcpy(hostTapePtr
->name
, netTapePtr
->name
);
320 hostTapePtr
->nameHashChain
= ntohl(netTapePtr
->nameHashChain
);
321 hostTapePtr
->flags
= ntohl(netTapePtr
->flags
);
323 /* tape id conversion here */
324 hostTapePtr
->written
= ntohl(netTapePtr
->written
);
325 hostTapePtr
->nMBytes
= ntohl(netTapePtr
->nMBytes
);
326 hostTapePtr
->nBytes
= ntohl(netTapePtr
->nBytes
);
327 hostTapePtr
->nFiles
= ntohl(netTapePtr
->nFiles
);
328 hostTapePtr
->nVolumes
= ntohl(netTapePtr
->nVolumes
);
329 hostTapePtr
->seq
= ntohl(netTapePtr
->seq
);
330 hostTapePtr
->dump
= ntohl(netTapePtr
->dump
);
331 hostTapePtr
->nextTape
= ntohl(netTapePtr
->nextTape
);
332 hostTapePtr
->labelpos
= ntohl(netTapePtr
->labelpos
);
333 hostTapePtr
->firstVol
= ntohl(netTapePtr
->firstVol
);
334 hostTapePtr
->useCount
= ntohl(netTapePtr
->useCount
);
338 dump_ntoh(struct dump
*netDumpPtr
,
339 struct dump
*hostDumpPtr
)
341 hostDumpPtr
->id
= ntohl(netDumpPtr
->id
);
342 hostDumpPtr
->idHashChain
= ntohl(netDumpPtr
->idHashChain
);
343 strlcpy(hostDumpPtr
->dumpName
, netDumpPtr
->dumpName
,
344 sizeof(hostDumpPtr
->dumpName
));
345 strlcpy(hostDumpPtr
->dumpPath
, netDumpPtr
->dumpPath
,
346 sizeof(hostDumpPtr
->dumpPath
));
347 strlcpy(hostDumpPtr
->volumeSet
, netDumpPtr
->volumeSet
,
348 sizeof(hostDumpPtr
->volumeSet
));
349 hostDumpPtr
->nameHashChain
= ntohl(netDumpPtr
->nameHashChain
);
350 hostDumpPtr
->flags
= ntohl(netDumpPtr
->flags
);
351 hostDumpPtr
->parent
= ntohl(netDumpPtr
->parent
);
352 hostDumpPtr
->created
= ntohl(netDumpPtr
->created
);
353 hostDumpPtr
->nVolumes
= ntohl(netDumpPtr
->nVolumes
);
354 hostDumpPtr
->level
= ntohl(netDumpPtr
->level
);
356 tapeSet_ntoh(&netDumpPtr
->tapes
, &hostDumpPtr
->tapes
);
358 hostDumpPtr
->firstTape
= ntohl(netDumpPtr
->firstTape
);
360 hostDumpPtr
->dumper
= netDumpPtr
->dumper
;
364 DbHeader_ntoh(struct DbHeader
*netptr
,
365 struct DbHeader
*hostptr
)
367 hostptr
->dbversion
= ntohl(netptr
->dbversion
);
368 hostptr
->created
= ntohl(netptr
->created
);
369 strcpy(hostptr
->cell
, netptr
->cell
);
370 hostptr
->lastDumpId
= ntohl(netptr
->lastDumpId
);
371 hostptr
->lastInstanceId
= ntohl(netptr
->lastInstanceId
);
372 hostptr
->lastTapeId
= ntohl(netptr
->lastTapeId
);
376 dumpEntry_ntoh(struct budb_dumpEntry
*netptr
,
377 struct budb_dumpEntry
*hostptr
)
379 hostptr
->id
= ntohl(netptr
->id
);
380 hostptr
->initialDumpID
= ntohl(netptr
->initialDumpID
);
381 hostptr
->appendedDumpID
= ntohl(netptr
->appendedDumpID
);
382 hostptr
->parent
= ntohl(netptr
->parent
);
383 hostptr
->level
= ntohl(netptr
->level
);
384 hostptr
->flags
= ntohl(netptr
->flags
);
385 strcpy(hostptr
->volumeSetName
, netptr
->volumeSetName
);
386 strcpy(hostptr
->dumpPath
, netptr
->dumpPath
);
387 strcpy(hostptr
->name
, netptr
->name
);
388 hostptr
->created
= ntohl(netptr
->created
);
389 hostptr
->incTime
= ntohl(netptr
->incTime
);
390 hostptr
->nVolumes
= ntohl(netptr
->nVolumes
);
392 tapeSet_ntoh(&netptr
->tapes
, &hostptr
->tapes
);
393 principal_ntoh(&netptr
->dumper
, &hostptr
->dumper
);
397 principal_hton(struct budb_principal
*hostptr
,
398 struct budb_principal
*netptr
)
400 strcpy(netptr
->name
, hostptr
->name
);
401 strcpy(netptr
->instance
, hostptr
->instance
);
402 strcpy(netptr
->cell
, hostptr
->cell
);
406 principal_ntoh(struct budb_principal
*netptr
,
407 struct budb_principal
*hostptr
)
409 strcpy(hostptr
->name
, netptr
->name
);
410 strcpy(hostptr
->instance
, netptr
->instance
);
411 strcpy(hostptr
->cell
, netptr
->cell
);
415 structDumpHeader_hton(struct structDumpHeader
*hostPtr
,
416 struct structDumpHeader
*netPtr
)
418 netPtr
->type
= htonl(hostPtr
->type
);
419 netPtr
->structversion
= htonl(hostPtr
->structversion
);
420 netPtr
->size
= htonl(hostPtr
->size
);
424 structDumpHeader_ntoh(struct structDumpHeader
*netPtr
,
425 struct structDumpHeader
*hostPtr
)
427 hostPtr
->type
= ntohl(netPtr
->type
);
428 hostPtr
->structversion
= ntohl(netPtr
->structversion
);
429 hostPtr
->size
= ntohl(netPtr
->size
);
433 tapeEntry_ntoh(struct budb_tapeEntry
*netptr
,
434 struct budb_tapeEntry
*hostptr
)
436 strcpy(hostptr
->name
, netptr
->name
);
437 hostptr
->flags
= ntohl(netptr
->flags
);
438 hostptr
->written
= ntohl(netptr
->written
);
439 hostptr
->expires
= ntohl(netptr
->expires
);
440 hostptr
->nMBytes
= ntohl(netptr
->nMBytes
);
441 hostptr
->nBytes
= ntohl(netptr
->nBytes
);
442 hostptr
->nFiles
= ntohl(netptr
->nFiles
);
443 hostptr
->nVolumes
= ntohl(netptr
->nVolumes
);
444 hostptr
->seq
= ntohl(netptr
->seq
);
445 hostptr
->labelpos
= ntohl(netptr
->labelpos
);
446 hostptr
->useCount
= ntohl(netptr
->useCount
);
447 hostptr
->useKBytes
= ntohl(netptr
->useKBytes
);
448 hostptr
->dump
= ntohl(netptr
->dump
);
452 tapeSet_hton(struct budb_tapeSet
*hostptr
,
453 struct budb_tapeSet
*netptr
)
455 netptr
->id
= htonl(hostptr
->id
);
456 strcpy(netptr
->tapeServer
, hostptr
->tapeServer
);
457 strcpy(netptr
->format
, hostptr
->format
);
458 netptr
->maxTapes
= htonl(hostptr
->maxTapes
);
459 netptr
->a
= htonl(hostptr
->a
);
460 netptr
->b
= htonl(hostptr
->b
);
465 tapeSet_ntoh(struct budb_tapeSet
*netptr
,
466 struct budb_tapeSet
*hostptr
)
468 hostptr
->id
= ntohl(netptr
->id
);
469 strcpy(hostptr
->tapeServer
, netptr
->tapeServer
);
470 strcpy(hostptr
->format
, netptr
->format
);
471 hostptr
->maxTapes
= ntohl(netptr
->maxTapes
);
472 hostptr
->a
= ntohl(netptr
->a
);
473 hostptr
->b
= ntohl(netptr
->b
);
478 textBlock_hton(struct textBlock
*hostptr
,
479 struct textBlock
*netptr
)
481 netptr
->version
= htonl(hostptr
->version
);
482 netptr
->size
= htonl(hostptr
->size
);
483 netptr
->textAddr
= htonl(hostptr
->textAddr
);
484 netptr
->newsize
= htonl(hostptr
->newsize
);
485 netptr
->newTextAddr
= htonl(hostptr
->newTextAddr
);
489 textBlock_ntoh(struct textBlock
*netptr
,
490 struct textBlock
*hostptr
)
492 hostptr
->version
= ntohl(netptr
->version
);
493 hostptr
->size
= ntohl(netptr
->size
);
494 hostptr
->textAddr
= ntohl(netptr
->textAddr
);
495 hostptr
->newsize
= ntohl(netptr
->newsize
);
496 hostptr
->newTextAddr
= ntohl(netptr
->newTextAddr
);
500 textLock_hton(db_lockP hostptr
, db_lockP netptr
)
502 netptr
->type
= htonl(hostptr
->type
);
503 netptr
->lockState
= htonl(hostptr
->lockState
);
504 netptr
->lockTime
= htonl(hostptr
->lockTime
);
505 netptr
->expires
= htonl(hostptr
->expires
);
506 netptr
->instanceId
= htonl(hostptr
->instanceId
);
507 netptr
->lockHost
= htonl(hostptr
->lockHost
);
511 textLock_ntoh(db_lockP netptr
, db_lockP hostptr
)
513 hostptr
->type
= ntohl(netptr
->type
);
514 hostptr
->lockState
= ntohl(netptr
->lockState
);
515 hostptr
->lockTime
= ntohl(netptr
->lockTime
);
516 hostptr
->expires
= ntohl(netptr
->expires
);
517 hostptr
->instanceId
= ntohl(netptr
->instanceId
);
518 hostptr
->lockHost
= ntohl(netptr
->lockHost
);
522 volumeEntry_ntoh(struct budb_volumeEntry
*netptr
,
523 struct budb_volumeEntry
*hostptr
)
525 strcpy(hostptr
->name
, netptr
->name
);
526 hostptr
->flags
= ntohl(netptr
->flags
);
527 hostptr
->id
= ntohl(netptr
->id
);
528 strcpy(hostptr
->server
, netptr
->server
);
529 hostptr
->partition
= ntohl(netptr
->partition
);
530 hostptr
->tapeSeq
= ntohl(netptr
->tapeSeq
);
532 hostptr
->position
= ntohl(netptr
->position
);
533 hostptr
->clone
= ntohl(netptr
->clone
);
534 hostptr
->incTime
= ntohl(netptr
->incTime
);
535 hostptr
->startByte
= ntohl(netptr
->startByte
);
536 hostptr
->nBytes
= ntohl(netptr
->nBytes
);
537 hostptr
->seq
= ntohl(netptr
->seq
);
539 hostptr
->dump
= ntohl(netptr
->dump
);
540 strcpy(hostptr
->tape
, netptr
->tape
);
543 /* -------------------------------------
544 * structure conversion & copy routines
545 * -------------------------------------
549 copy_ktcPrincipal_to_budbPrincipal(struct ktc_principal
*ktcPtr
,
550 struct budb_principal
*budbPtr
)
552 strncpy(budbPtr
->name
, ktcPtr
->name
, sizeof(budbPtr
->name
));
553 strncpy(budbPtr
->instance
, ktcPtr
->instance
, sizeof(budbPtr
->instance
));
554 strncpy(budbPtr
->cell
, ktcPtr
->cell
, sizeof(budbPtr
->cell
));
559 * dumpPtr - host format
563 dumpToBudbDump(dbDumpP dumpPtr
, struct budb_dumpEntry
*budbDumpPtr
)
565 budbDumpPtr
->id
= dumpPtr
->id
;
566 budbDumpPtr
->initialDumpID
= dumpPtr
->initialDumpID
;
567 budbDumpPtr
->parent
= dumpPtr
->parent
;
568 budbDumpPtr
->level
= dumpPtr
->level
;
569 budbDumpPtr
->flags
= dumpPtr
->flags
;
571 strcpy(budbDumpPtr
->volumeSetName
, dumpPtr
->volumeSet
);
572 strcpy(budbDumpPtr
->dumpPath
, dumpPtr
->dumpPath
);
573 strcpy(budbDumpPtr
->name
, dumpPtr
->dumpName
);
575 budbDumpPtr
->created
= dumpPtr
->created
;
576 budbDumpPtr
->nVolumes
= dumpPtr
->nVolumes
;
578 memcpy(&budbDumpPtr
->tapes
, &dumpPtr
->tapes
, sizeof(struct budb_tapeSet
));
579 copy_ktcPrincipal_to_budbPrincipal(&dumpPtr
->dumper
,
580 &budbDumpPtr
->dumper
);
585 tapeToBudbTape(struct tape
*tapePtr
, struct budb_tapeEntry
*budbTapePtr
)
587 strcpy(budbTapePtr
->name
, tapePtr
->name
);
588 budbTapePtr
->flags
= tapePtr
->flags
;
589 budbTapePtr
->written
= tapePtr
->written
;
590 budbTapePtr
->expires
= tapePtr
->expires
;
591 budbTapePtr
->nMBytes
= tapePtr
->nMBytes
;
592 budbTapePtr
->nBytes
= tapePtr
->nBytes
;
593 budbTapePtr
->nFiles
= tapePtr
->nFiles
;
594 budbTapePtr
->nVolumes
= tapePtr
->nVolumes
;
595 budbTapePtr
->seq
= tapePtr
->seq
;
596 budbTapePtr
->labelpos
= tapePtr
->labelpos
;
597 budbTapePtr
->useCount
= tapePtr
->useCount
;
598 budbTapePtr
->useKBytes
= tapePtr
->useKBytes
;
603 volsToBudbVol(struct volFragment
*volFragPtr
, struct volInfo
*volInfoPtr
,
604 struct budb_volumeEntry
*budbVolPtr
)
606 strcpy(budbVolPtr
->name
, volInfoPtr
->name
);
607 budbVolPtr
->flags
= volInfoPtr
->flags
;
608 budbVolPtr
->id
= volInfoPtr
->id
;
609 strcpy(budbVolPtr
->server
, volInfoPtr
->server
);
610 budbVolPtr
->partition
= volInfoPtr
->partition
;
611 budbVolPtr
->tapeSeq
= 0; /* Don't know it so mark invalid */
613 budbVolPtr
->position
= volFragPtr
->position
;
614 budbVolPtr
->clone
= volFragPtr
->clone
;
615 budbVolPtr
->incTime
= volFragPtr
->incTime
;
616 budbVolPtr
->startByte
= volFragPtr
->startByte
;
617 budbVolPtr
->nBytes
= volFragPtr
->nBytes
;
618 budbVolPtr
->seq
= volFragPtr
->sequence
;
622 /* ----------------------------------
623 * structure initialization routines
624 * ---------------------------------
628 * this fills in the tape set with the current default tapeset
631 * dumpname - volset.dumplevel
638 default_tapeset(struct budb_tapeSet
*tapesetPtr
, char *dumpname
)
640 memset(tapesetPtr
, 0, sizeof(*tapesetPtr
));
642 strcpy(tapesetPtr
->format
, dumpname
);
643 strcat(tapesetPtr
->format
, ".%d");
646 tapesetPtr
->maxTapes
= 0;