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