367a01766237dbd13b39f2028382befe612953cf
[openafs.git] / src / budb / struct_ops.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 #include <afs/stds.h>
13
14 #include <roken.h>
15
16 #include <afs/bubasics.h>
17 #include <afs/afsutil.h>
18 #include <rx/xdr.h>
19 #include <rx/rx.h>
20
21 #include "budb.h"
22 #include "budb_errs.h"
23 #include "database.h"
24 #include "budb_internal.h"
25 #include "budb_prototypes.h"
26
27 /* ----------------------------------
28  * structure printing utilities
29  * ----------------------------------
30  */
31
32 void
33 printDbHeader(struct DbHeader *ptr)
34 {
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);
42 }
43
44 void
45 printDump(FILE *fid, struct dump *dptr)
46 {
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); */
61
62 }
63
64 void
65 printDumpEntry(struct budb_dumpEntry *deptr)
66 {
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)
83         printf(": 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 */
88     printf("\n");
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);
94
95     printTapeSet(&deptr->tapes, (deptr->flags & BUDB_DUMP_XBSA_NSS));
96     printPrincipal(&deptr->dumper);
97 }
98
99 /* printHashTable
100  *      print the hash table structure, i.e. the header structure.
101  */
102
103 void
104 printHashTable(FILE *fid, struct hashTable *htptr)
105 {
106     fprintf(fid, "functionType = %d\n", htptr->functionType);
107     fprintf(fid, "threadOffset = %d\n", htptr->threadOffset);
108     fprintf(fid, "entries = %d\n", htptr->entries);
109     fprintf(fid, "length = %d\n", htptr->length);
110     fprintf(fid, "table = %d\n", htptr->table);
111     fprintf(fid, "progress = %d\n", htptr->progress);
112     fprintf(fid, "oldLength = %d\n", htptr->oldLength);
113     fprintf(fid, "oldTable = %d\n", htptr->oldTable);
114 }
115
116 /* printMemoryHashTable
117  *      print the hash table structure, i.e. the header structure.
118  */
119 int
120 printMemoryHashTable(FILE *fid, struct memoryHashTable *mhtptr)
121 {
122     fprintf(fid, "threadOffset = %d\n", mhtptr->threadOffset);
123     fprintf(fid, "length = %d\n", mhtptr->length);
124     fprintf(fid, "progress = %d\n", mhtptr->progress);
125     fprintf(fid, "size = %d\n", mhtptr->size);
126     fprintf(fid, "oldsize = %d\n", mhtptr->oldSize);
127     return 0;
128 }
129
130 int
131 printPrincipal(struct budb_principal *ptr)
132 {
133     printf("name = %s\n", ptr->name);
134     printf("instance = %s\n", ptr->instance);
135     printf("cell = %s\n", ptr->cell);
136     return 0;
137 }
138
139 int
140 printStructDumpHeader(struct structDumpHeader *ptr)
141 {
142     printf("type = %d\n", ptr->type);
143     printf("structure version = %d\n", ptr->structversion);
144     printf("size = %d bytes\n", ptr->size);
145     return 0;
146 }
147
148 int
149 printTape(FILE *fid, struct tape *tptr)
150 {
151     time_t written = tptr->written;
152     fprintf(fid, "name = %s\n", tptr->name);
153     fprintf(fid, "nameHashChain = %d\n", tptr->nameHashChain);
154     fprintf(fid, "flags = 0x%x\n", tptr->flags);
155     fprintf(fid, "written = %s", ctime(&written));
156     fprintf(fid, "nMBytes = %d\n", tptr->nMBytes);
157     fprintf(fid, "nBytes = %d\n", tptr->nBytes);
158     fprintf(fid, "nFiles = %d\n", tptr->nFiles);
159     fprintf(fid, "nVolumes = %d\n", tptr->nVolumes);
160     fprintf(fid, "seq = %d\n", tptr->seq);
161     fprintf(fid, "dump = %d\n", tptr->dump);
162     fprintf(fid, "nextTape = %d\n", tptr->nextTape);
163     fprintf(fid, "firstVol = %d\n", tptr->firstVol);
164     fprintf(fid, "labelPos = %d\n", tptr->labelpos);
165     fprintf(fid, "useCount = %d\n", tptr->useCount);
166     return 0;
167 }
168
169 int
170 printTapeEntry(struct budb_tapeEntry *teptr)
171 {
172     time_t written = teptr->written;
173     time_t expires = teptr->expires;
174
175     printf("name = %s\n", teptr->name);
176     printf("flags = 0x%x", teptr->flags);
177     if (teptr->flags & BUDB_TAPE_TAPEERROR)
178         printf(": Error");
179     if (teptr->flags & BUDB_TAPE_DELETED)
180         printf(": Deleted");
181     if (teptr->flags & BUDB_TAPE_BEINGWRITTEN)
182         printf(": In progress");
183     if (teptr->flags & BUDB_TAPE_ABORTED)
184         printf(": Aborted");
185     if (teptr->flags & BUDB_TAPE_STAGED)
186         printf(": Staged");
187     if (teptr->flags & BUDB_TAPE_WRITTEN)
188         printf(": Successful");
189     printf("\n");
190     printf("written = %s", ctime(&written));
191     printf("expires = %s", cTIME(&expires));
192     printf("kBytes Tape Used = %u\n", teptr->useKBytes);
193     printf("nMBytes Data = %d\n", teptr->nMBytes);
194     printf("nBytes  Data = %d\n", teptr->nBytes);
195     printf("nFiles = %d\n", teptr->nFiles);
196     printf("nVolumes = %d\n", teptr->nVolumes);
197     printf("seq = %d\n", teptr->seq);
198     printf("labelPos = %d\n", teptr->labelpos);
199     printf("useCount = %d\n", teptr->useCount);
200     printf("dump = %d\n", teptr->dump);
201     return 0;
202 }
203
204 int
205 printTapeSet(struct budb_tapeSet *tsptr,
206              afs_int32 nss)     /* is the tapeserver name an accurate name */
207 {
208     printf("Group id  = %d\n", tsptr->id);
209     printf("tapeServer = %s%s\n", tsptr->tapeServer,
210            (nss ? " (single server)" : ""));
211     printf("format = %s\n", tsptr->format);
212     printf("maxTapes = %d\n", tsptr->maxTapes);
213 /*  printf("a  = %d\n",tsptr->a ); */
214 /*  printf("b = %d\n",tsptr->b);   */
215     printf("Start Tape Seq = %d\n", tsptr->b);
216     return 0;
217 }
218
219 int
220 printVolumeEntry(struct budb_volumeEntry *veptr)
221 {
222     time_t clone = veptr->clone;
223     printf("name = %s\n", veptr->name);
224     printf("flags = 0x%x", veptr->flags);
225     if (veptr->flags & BUDB_VOL_TAPEERROR)
226         printf(": Tape Error");
227     if (veptr->flags & BUDB_VOL_FILEERROR)
228         printf(": File Error");
229     if (veptr->flags & BUDB_VOL_BEINGWRITTEN)
230         printf(": In progress");
231     if (veptr->flags & BUDB_VOL_FIRSTFRAG)
232         printf(": First fragment");
233     if (veptr->flags & BUDB_VOL_LASTFRAG)
234         printf(": Last fragment");
235     if (veptr->flags & BUDB_VOL_ABORTED)
236         printf(": Aborted");
237     printf("\n");
238     printf("id = %d\n", veptr->id);
239     printf("server = %s\n", veptr->server);
240     printf("partition = %d\n", veptr->partition);
241     printf("tapeSeq = %d\n", veptr->tapeSeq);
242
243     printf("position = %d\n", veptr->position);
244     printf("clone = %s", ctime(&clone));
245     printf("startByte = %d\n", veptr->startByte);
246     printf("nBytes = %d\n", veptr->nBytes);
247     printf("seq = %d\n", veptr->seq);
248
249     printf("dump = %d\n", veptr->dump);
250     printf("tape = %s\n", veptr->tape);
251     return 0;
252 }
253
254 int
255 printVolFragment(FILE *fid, struct volFragment *vfptr)
256 {
257     time_t clone = vfptr->clone;
258     time_t incTime = vfptr->incTime;
259     fprintf(fid, "vol = %d\n", vfptr->vol);
260     fprintf(fid, "sameNameChain = %d\n", vfptr->sameNameChain);
261     fprintf(fid, "tape = %d\n", vfptr->tape);
262     fprintf(fid, "sameTapeChain = %d\n", vfptr->sameTapeChain);
263     fprintf(fid, "position = %d\n", vfptr->position);
264     fprintf(fid, "clone = %s", ctime(&clone));
265     fprintf(fid, "incTime = %s", ctime(&incTime));
266     fprintf(fid, "startByte = %d\n", vfptr->startByte);
267     fprintf(fid, "nBytes = %d\n", vfptr->nBytes);
268     fprintf(fid, "flags = %d\n", vfptr->flags);
269     fprintf(fid, "sequence = %d\n", vfptr->sequence);
270     return 0;
271 }
272
273 int
274 printVolInfo(FILE *fid, struct volInfo *viptr)
275 {
276     fprintf(fid, "name = %s\n", viptr->name);
277     fprintf(fid, "nameHashChain = %d\n", viptr->nameHashChain);
278     fprintf(fid, "id = %d\n", viptr->id);
279     fprintf(fid, "server = %s\n", viptr->server);
280     fprintf(fid, "partition = %d\n", viptr->partition);
281     fprintf(fid, "flags = 0x%x\n", viptr->flags);
282     fprintf(fid, "sameNameHead = %d\n", viptr->sameNameHead);
283     fprintf(fid, "sameNameChain = %d\n", viptr->sameNameChain);
284     fprintf(fid, "firstFragment = %d\n", viptr->firstFragment);
285     fprintf(fid, "nFrags = %d\n", viptr->nFrags);
286     return 0;
287 }
288
289
290 /* -----------------------------------------
291  * structure xdr routines
292  * -----------------------------------------
293  */
294
295 /* utilities - network to host conversion
296  *      currently used for debug only
297  */
298
299 void
300 volFragment_ntoh(struct volFragment *netVfPtr,
301                  struct volFragment *hostVfPtr)
302 {
303     hostVfPtr->vol = ntohl(netVfPtr->vol);
304     hostVfPtr->sameNameChain = ntohl(netVfPtr->sameNameChain);
305     hostVfPtr->tape = ntohl(netVfPtr->tape);
306     hostVfPtr->sameTapeChain = ntohl(netVfPtr->sameTapeChain);
307     hostVfPtr->position = ntohl(netVfPtr->position);
308     hostVfPtr->clone = ntohl(netVfPtr->clone);
309     hostVfPtr->incTime = ntohl(netVfPtr->incTime);
310     hostVfPtr->startByte = ntohl(netVfPtr->startByte);
311     hostVfPtr->nBytes = ntohl(netVfPtr->nBytes);
312     hostVfPtr->flags = ntohs(netVfPtr->flags);
313     hostVfPtr->sequence = ntohs(netVfPtr->sequence);
314 }
315
316 void
317 volInfo_ntoh(struct volInfo *netViPtr,
318              struct volInfo *hostViPtr)
319 {
320     strcpy(hostViPtr->name, netViPtr->name);
321     hostViPtr->nameHashChain = ntohl(netViPtr->nameHashChain);
322     hostViPtr->id = ntohl(netViPtr->id);
323     strcpy(hostViPtr->server, netViPtr->server);
324     hostViPtr->partition = ntohl(netViPtr->partition);
325     hostViPtr->flags = ntohl(netViPtr->flags);
326     hostViPtr->sameNameHead = ntohl(netViPtr->sameNameHead);
327     hostViPtr->sameNameChain = ntohl(netViPtr->sameNameChain);
328     hostViPtr->firstFragment = ntohl(netViPtr->firstFragment);
329     hostViPtr->nFrags = ntohl(netViPtr->nFrags);
330 }
331
332 void
333 tape_ntoh(struct tape *netTapePtr,
334           struct tape *hostTapePtr)
335 {
336     strcpy(hostTapePtr->name, netTapePtr->name);
337     hostTapePtr->nameHashChain = ntohl(netTapePtr->nameHashChain);
338     hostTapePtr->flags = ntohl(netTapePtr->flags);
339
340     /* tape id conversion here */
341     hostTapePtr->written = ntohl(netTapePtr->written);
342     hostTapePtr->nMBytes = ntohl(netTapePtr->nMBytes);
343     hostTapePtr->nBytes = ntohl(netTapePtr->nBytes);
344     hostTapePtr->nFiles = ntohl(netTapePtr->nFiles);
345     hostTapePtr->nVolumes = ntohl(netTapePtr->nVolumes);
346     hostTapePtr->seq = ntohl(netTapePtr->seq);
347     hostTapePtr->dump = ntohl(netTapePtr->dump);
348     hostTapePtr->nextTape = ntohl(netTapePtr->nextTape);
349     hostTapePtr->labelpos = ntohl(netTapePtr->labelpos);
350     hostTapePtr->firstVol = ntohl(netTapePtr->firstVol);
351     hostTapePtr->useCount = ntohl(netTapePtr->useCount);
352 }
353
354 void
355 dump_ntoh(struct dump *netDumpPtr,
356           struct dump *hostDumpPtr)
357 {
358     hostDumpPtr->id = ntohl(netDumpPtr->id);
359     hostDumpPtr->idHashChain = ntohl(netDumpPtr->idHashChain);
360     strlcpy(hostDumpPtr->dumpName, netDumpPtr->dumpName,
361             sizeof(hostDumpPtr->dumpName));
362     strlcpy(hostDumpPtr->dumpPath, netDumpPtr->dumpPath,
363             sizeof(hostDumpPtr->dumpPath));
364     strlcpy(hostDumpPtr->volumeSet, netDumpPtr->volumeSet,
365             sizeof(hostDumpPtr->volumeSet));
366     hostDumpPtr->nameHashChain = ntohl(netDumpPtr->nameHashChain);
367     hostDumpPtr->flags = ntohl(netDumpPtr->flags);
368     hostDumpPtr->parent = ntohl(netDumpPtr->parent);
369     hostDumpPtr->created = ntohl(netDumpPtr->created);
370     hostDumpPtr->nVolumes = ntohl(netDumpPtr->nVolumes);
371     hostDumpPtr->level = ntohl(netDumpPtr->level);
372
373     tapeSet_ntoh(&netDumpPtr->tapes, &hostDumpPtr->tapes);
374
375     hostDumpPtr->firstTape = ntohl(netDumpPtr->firstTape);
376
377     hostDumpPtr->dumper = netDumpPtr->dumper;
378 }
379
380 void
381 DbHeader_ntoh(struct DbHeader *netptr,
382               struct DbHeader *hostptr)
383 {
384     hostptr->dbversion = ntohl(netptr->dbversion);
385     hostptr->created = ntohl(netptr->created);
386     strcpy(hostptr->cell, netptr->cell);
387     hostptr->lastDumpId = ntohl(netptr->lastDumpId);
388     hostptr->lastInstanceId = ntohl(netptr->lastInstanceId);
389     hostptr->lastTapeId = ntohl(netptr->lastTapeId);
390 }
391
392 void
393 dumpEntry_ntoh(struct budb_dumpEntry *netptr,
394                struct budb_dumpEntry *hostptr)
395 {
396     hostptr->id = ntohl(netptr->id);
397     hostptr->initialDumpID = ntohl(netptr->initialDumpID);
398     hostptr->appendedDumpID = ntohl(netptr->appendedDumpID);
399     hostptr->parent = ntohl(netptr->parent);
400     hostptr->level = ntohl(netptr->level);
401     hostptr->flags = ntohl(netptr->flags);
402     strcpy(hostptr->volumeSetName, netptr->volumeSetName);
403     strcpy(hostptr->dumpPath, netptr->dumpPath);
404     strcpy(hostptr->name, netptr->name);
405     hostptr->created = ntohl(netptr->created);
406     hostptr->incTime = ntohl(netptr->incTime);
407     hostptr->nVolumes = ntohl(netptr->nVolumes);
408
409     tapeSet_ntoh(&netptr->tapes, &hostptr->tapes);
410     principal_ntoh(&netptr->dumper, &hostptr->dumper);
411 }
412
413 void
414 principal_hton(struct budb_principal *hostptr,
415                struct budb_principal *netptr)
416 {
417     strcpy(netptr->name, hostptr->name);
418     strcpy(netptr->instance, hostptr->instance);
419     strcpy(netptr->cell, hostptr->cell);
420 }
421
422 void
423 principal_ntoh(struct budb_principal *netptr,
424                struct budb_principal *hostptr)
425 {
426     strcpy(hostptr->name, netptr->name);
427     strcpy(hostptr->instance, netptr->instance);
428     strcpy(hostptr->cell, netptr->cell);
429 }
430
431 void
432 structDumpHeader_hton(struct structDumpHeader *hostPtr,
433                       struct structDumpHeader *netPtr)
434 {
435     netPtr->type = htonl(hostPtr->type);
436     netPtr->structversion = htonl(hostPtr->structversion);
437     netPtr->size = htonl(hostPtr->size);
438 }
439
440 void
441 structDumpHeader_ntoh(struct structDumpHeader *netPtr,
442                       struct structDumpHeader *hostPtr)
443 {
444     hostPtr->type = ntohl(netPtr->type);
445     hostPtr->structversion = ntohl(netPtr->structversion);
446     hostPtr->size = ntohl(netPtr->size);
447 }
448
449 void
450 tapeEntry_ntoh(struct budb_tapeEntry *netptr,
451                struct budb_tapeEntry *hostptr)
452 {
453     strcpy(hostptr->name, netptr->name);
454     hostptr->flags = ntohl(netptr->flags);
455     hostptr->written = ntohl(netptr->written);
456     hostptr->expires = ntohl(netptr->expires);
457     hostptr->nMBytes = ntohl(netptr->nMBytes);
458     hostptr->nBytes = ntohl(netptr->nBytes);
459     hostptr->nFiles = ntohl(netptr->nFiles);
460     hostptr->nVolumes = ntohl(netptr->nVolumes);
461     hostptr->seq = ntohl(netptr->seq);
462     hostptr->labelpos = ntohl(netptr->labelpos);
463     hostptr->useCount = ntohl(netptr->useCount);
464     hostptr->useKBytes = ntohl(netptr->useKBytes);
465     hostptr->dump = ntohl(netptr->dump);
466 }
467
468 int
469 tapeSet_hton(struct budb_tapeSet *hostptr,
470              struct budb_tapeSet *netptr)
471 {
472     netptr->id = htonl(hostptr->id);
473     strcpy(netptr->tapeServer, hostptr->tapeServer);
474     strcpy(netptr->format, hostptr->format);
475     netptr->maxTapes = htonl(hostptr->maxTapes);
476     netptr->a = htonl(hostptr->a);
477     netptr->b = htonl(hostptr->b);
478     return 0;
479 }
480
481 int
482 tapeSet_ntoh(struct budb_tapeSet *netptr,
483              struct budb_tapeSet *hostptr)
484 {
485     hostptr->id = ntohl(netptr->id);
486     strcpy(hostptr->tapeServer, netptr->tapeServer);
487     strcpy(hostptr->format, netptr->format);
488     hostptr->maxTapes = ntohl(netptr->maxTapes);
489     hostptr->a = ntohl(netptr->a);
490     hostptr->b = ntohl(netptr->b);
491     return 0;
492 }
493
494 void
495 textBlock_hton(struct textBlock *hostptr,
496                struct textBlock *netptr)
497 {
498     netptr->version = htonl(hostptr->version);
499     netptr->size = htonl(hostptr->size);
500     netptr->textAddr = htonl(hostptr->textAddr);
501     netptr->newsize = htonl(hostptr->newsize);
502     netptr->newTextAddr = htonl(hostptr->newTextAddr);
503 }
504
505 void
506 textBlock_ntoh(struct textBlock *netptr,
507                struct textBlock *hostptr)
508 {
509     hostptr->version = ntohl(netptr->version);
510     hostptr->size = ntohl(netptr->size);
511     hostptr->textAddr = ntohl(netptr->textAddr);
512     hostptr->newsize = ntohl(netptr->newsize);
513     hostptr->newTextAddr = ntohl(netptr->newTextAddr);
514 }
515
516 void
517 textLock_hton(db_lockP hostptr, db_lockP netptr)
518 {
519     netptr->type = htonl(hostptr->type);
520     netptr->lockState = htonl(hostptr->lockState);
521     netptr->lockTime = htonl(hostptr->lockTime);
522     netptr->expires = htonl(hostptr->expires);
523     netptr->instanceId = htonl(hostptr->instanceId);
524     netptr->lockHost = htonl(hostptr->lockHost);
525 }
526
527 void
528 textLock_ntoh(db_lockP netptr, db_lockP hostptr)
529 {
530     hostptr->type = ntohl(netptr->type);
531     hostptr->lockState = ntohl(netptr->lockState);
532     hostptr->lockTime = ntohl(netptr->lockTime);
533     hostptr->expires = ntohl(netptr->expires);
534     hostptr->instanceId = ntohl(netptr->instanceId);
535     hostptr->lockHost = ntohl(netptr->lockHost);
536 }
537
538 void
539 volumeEntry_ntoh(struct budb_volumeEntry *netptr,
540                  struct budb_volumeEntry *hostptr)
541 {
542     strcpy(hostptr->name, netptr->name);
543     hostptr->flags = ntohl(netptr->flags);
544     hostptr->id = ntohl(netptr->id);
545     strcpy(hostptr->server, netptr->server);
546     hostptr->partition = ntohl(netptr->partition);
547     hostptr->tapeSeq = ntohl(netptr->tapeSeq);
548
549     hostptr->position = ntohl(netptr->position);
550     hostptr->clone = ntohl(netptr->clone);
551     hostptr->incTime = ntohl(netptr->incTime);
552     hostptr->startByte = ntohl(netptr->startByte);
553     hostptr->nBytes = ntohl(netptr->nBytes);
554     hostptr->seq = ntohl(netptr->seq);
555
556     hostptr->dump = ntohl(netptr->dump);
557     strcpy(hostptr->tape, netptr->tape);
558 }
559
560 /* -------------------------------------
561  * structure conversion & copy routines
562  * -------------------------------------
563  */
564
565 void
566 copy_ktcPrincipal_to_budbPrincipal(struct ktc_principal *ktcPtr,
567                                    struct budb_principal *budbPtr)
568 {
569     strncpy(budbPtr->name, ktcPtr->name, sizeof(budbPtr->name));
570     strncpy(budbPtr->instance, ktcPtr->instance, sizeof(budbPtr->instance));
571     strncpy(budbPtr->cell, ktcPtr->cell, sizeof(budbPtr->cell));
572 }
573
574 /* dumpToBudbDump
575  * entry:
576  *      dumpPtr - host format
577  */
578
579 int
580 dumpToBudbDump(dbDumpP dumpPtr, struct budb_dumpEntry *budbDumpPtr)
581 {
582     budbDumpPtr->id = dumpPtr->id;
583     budbDumpPtr->initialDumpID = dumpPtr->initialDumpID;
584     budbDumpPtr->parent = dumpPtr->parent;
585     budbDumpPtr->level = dumpPtr->level;
586     budbDumpPtr->flags = dumpPtr->flags;
587
588     strcpy(budbDumpPtr->volumeSetName, dumpPtr->volumeSet);
589     strcpy(budbDumpPtr->dumpPath, dumpPtr->dumpPath);
590     strcpy(budbDumpPtr->name, dumpPtr->dumpName);
591
592     budbDumpPtr->created = dumpPtr->created;
593     budbDumpPtr->nVolumes = dumpPtr->nVolumes;
594
595     memcpy(&budbDumpPtr->tapes, &dumpPtr->tapes, sizeof(struct budb_tapeSet));
596     copy_ktcPrincipal_to_budbPrincipal(&dumpPtr->dumper,
597                                        &budbDumpPtr->dumper);
598     return (0);
599 }
600
601 int
602 tapeToBudbTape(struct tape *tapePtr, struct budb_tapeEntry *budbTapePtr)
603 {
604     strcpy(budbTapePtr->name, tapePtr->name);
605     budbTapePtr->flags = tapePtr->flags;
606     budbTapePtr->written = tapePtr->written;
607     budbTapePtr->expires = tapePtr->expires;
608     budbTapePtr->nMBytes = tapePtr->nMBytes;
609     budbTapePtr->nBytes = tapePtr->nBytes;
610     budbTapePtr->nFiles = tapePtr->nFiles;
611     budbTapePtr->nVolumes = tapePtr->nVolumes;
612     budbTapePtr->seq = tapePtr->seq;
613     budbTapePtr->labelpos = tapePtr->labelpos;
614     budbTapePtr->useCount = tapePtr->useCount;
615     budbTapePtr->useKBytes = tapePtr->useKBytes;
616     return (0);
617 }
618
619 int
620 volsToBudbVol(struct volFragment *volFragPtr, struct volInfo *volInfoPtr,
621               struct budb_volumeEntry *budbVolPtr)
622 {
623     strcpy(budbVolPtr->name, volInfoPtr->name);
624     budbVolPtr->flags = volInfoPtr->flags;
625     budbVolPtr->id = volInfoPtr->id;
626     strcpy(budbVolPtr->server, volInfoPtr->server);
627     budbVolPtr->partition = volInfoPtr->partition;
628     budbVolPtr->tapeSeq = 0;    /* Don't know it so mark invalid */
629
630     budbVolPtr->position = volFragPtr->position;
631     budbVolPtr->clone = volFragPtr->clone;
632     budbVolPtr->incTime = volFragPtr->incTime;
633     budbVolPtr->startByte = volFragPtr->startByte;
634     budbVolPtr->nBytes = volFragPtr->nBytes;
635     budbVolPtr->seq = volFragPtr->sequence;
636     return (0);
637 }
638
639 /* ----------------------------------
640  * structure initialization routines
641  *  ---------------------------------
642  */
643
644 /* default_tapeset
645  *      this fills in the tape set with the current default tapeset
646  *      format;
647  * entry:
648  *      dumpname - volset.dumplevel
649  * exit:
650  *      0 - ok
651  *      n - error
652  */
653
654 int
655 default_tapeset(struct budb_tapeSet *tapesetPtr, char *dumpname)
656 {
657     memset(tapesetPtr, 0, sizeof(*tapesetPtr));
658
659     strcpy(tapesetPtr->format, dumpname);
660     strcat(tapesetPtr->format, ".%d");
661     tapesetPtr->a = 1;
662     tapesetPtr->b = 1;
663     tapesetPtr->maxTapes = 0;
664     return 0;
665 }