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