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