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