bcdb-listdumps-argument-fix-20090122
[openafs.git] / src / bucoord / ubik_db_if.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 /* Interface and supporting routines for the backup system's ubik database */
11
12 #include <afsconfig.h>
13 #include <afs/stds.h>
14
15 RCSID
16     ("$Header$");
17
18 #include <sys/types.h>
19 #include <fcntl.h>
20 #ifdef AFS_NT40_ENV
21 #include <winsock2.h>
22 #elif defined(AFS_SUN5_ENV)
23 #include <netdb.h>
24 #else
25 #include <sys/param.h>          /* for hostnames etc */
26 #endif
27 #include <afs/auth.h>
28 #include <afs/cellconfig.h>
29 #include <ubik.h>
30 #include <afs/volser.h>
31 #include <afs/afsutil.h>
32 #include <afs/bubasics.h>
33 #include <afs/budb_client.h>
34 #include <afs/budb.h>
35 #include <afs/com_err.h>
36 #include <errno.h>
37
38 #include "bc.h"
39 #include "error_macros.h"
40
41 /* protos */
42 afs_int32 bcdb_AddVolume(register struct budb_volumeEntry *);
43 afs_int32 bcdb_AddVolumes(register struct budb_volumeEntry *, afs_int32 );
44 afs_int32 bcdb_CreateDump(register struct budb_dumpEntry *) ;
45 afs_int32 bcdb_deleteDump(afs_int32, afs_int32, afs_int32, budb_dumpsList *);
46 /*note the pinter to the function comes from ubik/ubikclient ubik_Call function.*/
47 afs_int32 bcdb_listDumps (afs_int32, afs_int32,afs_int32,afs_int32, budb_dumpsList *,
48  budb_dumpsList *);
49 afs_int32 bcdb_DeleteVDP(char *, char *, afs_int32 );
50 afs_int32 bcdb_FindClone(afs_int32, char *, afs_int32 *);
51
52 extern char *whoami;
53
54 /* -------------------------------------
55  * Globals 
56  * -------------------------------------
57  */
58
59 struct udbHandleS udbHandle;
60
61 /* -------------------------------------
62  * interface routines (alphabetic)
63  * -------------------------------------
64  */
65
66 afs_int32 bcdb_AddVolume(register struct budb_volumeEntry *veptr)
67 {
68     afs_int32 code;
69
70     code = ubik_BUDB_AddVolume(udbHandle.uh_client, 0, veptr);
71     return (code);
72 }
73
74 afs_int32 bcdb_AddVolumes(register struct budb_volumeEntry *veptr, afs_int32 count)
75 {
76     struct budb_volumeList volumeList;
77     afs_int32 code;
78
79     volumeList.budb_volumeList_len = count;
80     volumeList.budb_volumeList_val = veptr;
81     code = ubik_BUDB_AddVolumes(udbHandle.uh_client, 0, &volumeList);
82     return (code);
83 }
84
85
86 afs_int32 bcdb_CreateDump(register struct budb_dumpEntry *deptr)
87 {
88     afs_int32 code;
89
90     code = ubik_BUDB_CreateDump(udbHandle.uh_client, 0, deptr);
91     return (code);
92 }
93
94 afs_int32 bcdb_deleteDump(afs_int32 dumpID, afs_int32 fromTime, afs_int32 toTime, 
95   budb_dumpsList *dumps)
96 {
97     afs_int32 code;
98     budb_dumpsList dumpsList, *dumpsPtr;
99
100     dumpsList.budb_dumpsList_len = 0;
101     dumpsList.budb_dumpsList_val = 0;
102     dumpsPtr = (dumps ? dumps : &dumpsList);
103
104     code =
105         ubik_BUDB_DeleteDump(udbHandle.uh_client, 0, dumpID, fromTime,
106                   toTime, dumpsPtr);
107     if (dumpsList.budb_dumpsList_val)
108         free(dumpsList.budb_dumpsList_val);
109     return (code);
110 }
111
112 afs_int32 bcdb_listDumps (afs_int32 sflags, afs_int32 groupId,afs_int32 fromTime, afs_int32 toTime,budb_dumpsList *dumps, budb_dumpsList *flags)
113 {
114     afs_int32 code;
115     budb_dumpsList dumpsList, *dumpsPtr;
116     budb_dumpsList flagsList, *flagsPtr;
117
118     dumpsList.budb_dumpsList_len = 0;
119     dumpsList.budb_dumpsList_val = 0;
120     dumpsPtr = (dumps ? dumps : &dumpsList);
121
122     flagsList.budb_dumpsList_len = 0;
123     flagsList.budb_dumpsList_val = 0;
124     flagsPtr = (flags ? flags : &flagsList);
125
126     code =
127         ubik_BUDB_ListDumps(udbHandle.uh_client, 0, sflags, "", groupId,
128                   fromTime, toTime, dumpsPtr, flagsPtr);
129
130     if (dumpsList.budb_dumpsList_val)
131         free(dumpsList.budb_dumpsList_val);
132     if (flagsList.budb_dumpsList_val)
133         free(flagsList.budb_dumpsList_val);
134     return (code);
135 }
136
137
138 afs_int32 bcdb_DeleteVDP(char *dumpSetName, char *dumpPath, afs_int32 dumpID)
139 {
140     afs_int32 code;
141
142     code =
143         ubik_BUDB_DeleteVDP(udbHandle.uh_client, 0, dumpSetName,
144                   dumpPath, dumpID);
145     return (code);
146 }
147
148 /* bcdb_FindClone
149  *      Returns the clone time of a volume by going up the parent chain.
150  *      If no clone time is found, a clone time of 0 is returned, forcing
151  *      a full dump.
152  * entry:
153  *      dumpID - of the first dump to examine.
154  *      volName - name of the volume for whom a clone time is required
155  *      clonetime - ptr to vbl for returning result
156  * exit:
157  *      0 - clonetime set appropriately
158  *      -1 - error occured in traversing chain, clone time set to 0.
159  *      -2 - no clone times found, clone time set to 0
160  */
161
162 afs_int32 bcdb_FindClone(afs_int32 dumpID, char *volName, afs_int32 *clonetime)
163 {
164     afs_int32 code;
165     code =
166         ubik_BUDB_FindClone(udbHandle.uh_client, 0, dumpID, volName,
167                   clonetime);
168     return (code);
169 }
170
171 /* bcdb_FindDump
172  *      scan entire database for latest volume dump before adate.  Optimize
173  *      further by reading only the first line of the dump and if it is older
174  *      than the oldest acceptable dump we've found so far, we don't bother
175  *      scanning the dump file we've just opened
176  *
177  *      Used by restore code when restoring a user requested volume(s)
178  * entry:
179  *      volumeName - name of volume to match on
180  *      beforeDate - look for dumps older than this date
181  * exit:
182  *      deptr - desciptor of most recent dump
183  * notes:
184  *      should be able to implement this in a single call rather than
185  *      the current multiple bcdb_ call algorithm.
186  */
187
188 bcdb_FindDump(volumeName, beforeDate, deptr)
189      char *volumeName;
190      afs_int32 beforeDate;
191      struct budb_dumpEntry *deptr;
192 {
193     afs_int32 code;
194     code =
195         ubik_BUDB_FindDump(udbHandle.uh_client, 0, volumeName,
196                   beforeDate, deptr);
197     return (code);
198 }
199
200 /* bcdb_FindDumpByID
201  *      find a dump by id. Currently insists on a single return value.
202  * entry:
203  *      dumpID - id to lookup
204  * exit:
205  */
206 bcdb_FindDumpByID(dumpID, deptr)
207      afs_int32 dumpID;
208      register struct budb_dumpEntry *deptr;
209 {
210     register afs_int32 code;
211     afs_int32 nextindex;
212     afs_int32 dbTime;
213     budb_dumpList dl;
214
215     /* initialize the dump list */
216     dl.budb_dumpList_len = 0;
217     dl.budb_dumpList_val = 0;
218
219     /* outline algorithm */
220     code = ubik_BUDB_GetDumps(udbHandle.uh_client, 0, BUDB_MAJORVERSION, BUDB_OP_DUMPID, "",    /* no name */
221                      dumpID,    /* start */
222                      0,         /* end */
223                      0,         /* index */
224                      &nextindex, &dbTime, &dl);
225
226     if ((code != 0)
227         || (dl.budb_dumpList_len != 1)  /* single retn val expected */
228         ) {
229 /*      printf("bcdb_FindDumpByID: code %d, nvalues %d\n",
230                code, dl.budb_dumpList_len); */
231         if (code == 0)
232             code = 1;           /* multiple id's */
233         goto error;
234     }
235
236     memcpy(deptr, dl.budb_dumpList_val, sizeof(*deptr));
237
238   exit:
239     if (dl.budb_dumpList_val) {
240         /* free any allocated structures */
241         free(dl.budb_dumpList_val);
242     }
243     return (code);
244
245   error:
246     memset(deptr, 0, sizeof(*deptr));
247     goto exit;
248 }
249
250 /* bcdb_FindLastVolClone
251  *      Returns the clone time, from the most recent dump of volName, when
252  *      dumped in the volume set volSetName, with dump schedule dumpName.
253  *      The clone time can be used to check if the volume has been correctly
254  *      re-cloned, and also is used as the time from which to do the current
255  *      incremental dump.
256  * entry:
257  *      volSetName - name of volume set
258  *      dumpName - full path of dump node
259  *      volName - name of volume for whom a clone time is required
260  *      clonetime - ptr to vbl for result
261  * exit:
262  *      0 - clonetime set appropriately
263  * notes:
264  *      used only for warning generation. Suggest that this be omitted.
265  */
266
267 afs_int32
268 bcdb_FindLastVolClone(volSetName, dumpName, volName, clonetime)
269      char *volSetName;
270      char *dumpName;
271      char *volName;
272      afs_int32 *clonetime;
273 {
274     /* server notes
275      * search by dumpName
276      * match on volumeset and dump path
277      * search for the volume name
278      */
279     return (0);
280 }
281
282 /* bcdb_FindLatestDump
283  *      find the latest dump with volume set component avname and the
284  *      specified dump pathname. Used to find a dump, relative to which an
285  *      incremental dump can be done. Defines the parent <-> child relations
286  *      for restores.
287  * entry:
288  *      avname: volume set name
289  *      dumpPath: full path of dump node
290  * exit:
291  *      0:  adentry: dump entry structure filled in.
292  *      -1: probably an internal error
293  *      2: no such entry
294  * Notes for 4.0:
295  *      Need to store volumeset name in dump in order to implement this.
296  *      Need new routine since params are two strings
297  */
298
299 bcdb_FindLatestDump(volSetName, dumpPath, deptr)
300      char *volSetName;
301      char *dumpPath;
302      struct budb_dumpEntry *deptr;
303 {
304     afs_int32 code;
305     code =
306         ubik_BUDB_FindLatestDump(udbHandle.uh_client, 0, volSetName,
307                   dumpPath, deptr);
308     return (code);
309 }
310
311
312 /* bcdb_FindTape
313  *      find a tape
314  * entry:
315  *      dumpid: dump id to which tape beint32s
316  *      tapeName: name of tape
317  */
318
319 bcdb_FindTape(dumpid, tapeName, teptr)
320      afs_int32 dumpid;
321      char *tapeName;
322      struct budb_tapeEntry *teptr;
323 {
324     budb_tapeList tl;
325     afs_int32 next;
326     afs_int32 dbTime;
327     afs_int32 code = 0;
328
329     memset(teptr, 0, sizeof(*teptr));
330     tl.budb_tapeList_len = 0;
331     tl.budb_tapeList_val = 0;
332
333     code =
334         ubik_BUDB_GetTapes(udbHandle.uh_client, 0, BUDB_MAJORVERSION,
335                   BUDB_OP_TAPENAME | BUDB_OP_DUMPID, tapeName, dumpid, 0, 0,
336                   &next, &dbTime, &tl);
337
338     if (code)
339         ERROR(code);
340
341     if (tl.budb_tapeList_len != 1)
342         ERROR(BC_NOTUNIQUE);    /* expecting a single descriptor */
343
344     memcpy(teptr, tl.budb_tapeList_val, sizeof(*teptr));
345
346   error_exit:
347     if (tl.budb_tapeList_val)
348         free(tl.budb_tapeList_val);
349     return (code);
350 }
351
352 bcdb_FindTapeSeq(dumpid, tapeSeq, teptr)
353      afs_int32 dumpid;
354      afs_int32 tapeSeq;
355      struct budb_tapeEntry *teptr;
356 {
357     budb_tapeList tl;
358     afs_int32 next;
359     afs_int32 dbTime;
360     afs_int32 code = 0;
361
362     memset(teptr, 0, sizeof(*teptr));
363     tl.budb_tapeList_len = 0;
364     tl.budb_tapeList_val = 0;
365
366     code =
367         ubik_BUDB_GetTapes(udbHandle.uh_client, 0, BUDB_MAJORVERSION,
368                   BUDB_OP_TAPESEQ | BUDB_OP_DUMPID, "", dumpid, tapeSeq, 0,
369                   &next, &dbTime, &tl);
370     if (code)
371         ERROR(code);
372
373     if (tl.budb_tapeList_len != 1)
374         ERROR(BC_NOTUNIQUE);    /* expecting a single descriptor */
375
376     memcpy(teptr, tl.budb_tapeList_val, sizeof(*teptr));
377
378   error_exit:
379     if (tl.budb_tapeList_val)
380         free(tl.budb_tapeList_val);
381     return (code);
382 }
383
384 /* bcdb_FindVolumes
385  * notes: 
386  *      - this is part of dblookup. The existing semantics will not work since
387  *      they do lookups based on dump id.
388  *      - in the restore code, it uses this to extract information about
389  *      the volume. Need current semantics. Could filter the output, selecting
390  *      on the dumpid.
391  *      - Suggest that the lookup be based on volume name only, with optional
392  *      match on backup, and readonly volumes.
393  *      - Further, need to check if the volume structure returns enough
394  *      information
395  */
396
397 afs_int32
398 bcdb_FindVolumes(dumpID, volumeName, returnArray, last, next, maxa, nEntries)
399      afs_int32 dumpID;
400      char *volumeName;
401      struct budb_volumeEntry *returnArray;
402      afs_int32 last;
403      afs_int32 *next;
404      afs_int32 maxa;
405      afs_int32 *nEntries;
406 {
407     budb_volumeList vl;
408     afs_int32 dbTime;
409     afs_int32 code;
410
411     vl.budb_volumeList_len = maxa;
412     vl.budb_volumeList_val = returnArray;
413
414     /* outline algorithm */
415     code = ubik_BUDB_GetVolumes(udbHandle.uh_client, 0, BUDB_MAJORVERSION, BUDB_OP_VOLUMENAME | BUDB_OP_DUMPID, volumeName,     /* name */
416                      dumpID,    /* start */
417                      0,         /* end */
418                      last,      /* index */
419                      next,      /* nextindex */
420                      &dbTime, &vl);
421
422     *nEntries = vl.budb_volumeList_len;
423     return (code);
424 }
425
426
427 bcdb_FinishDump(deptr)
428      register struct budb_dumpEntry *deptr;
429 {
430     afs_int32 code;
431     code = ubik_BUDB_FinishDump(udbHandle.uh_client, 0, deptr);
432     return (code);
433 }
434
435 bcdb_FinishTape(teptr)
436      register struct budb_tapeEntry *teptr;
437 {
438     afs_int32 code;
439     code = ubik_BUDB_FinishTape(udbHandle.uh_client, 0, teptr);
440     return (code);
441
442 }
443
444 /* bcdb_LookupVolumes
445  */
446
447 afs_int32
448 bcdb_LookupVolume(volumeName, returnArray, last, next, maxa, nEntries)
449      char *volumeName;
450      struct budb_volumeEntry *returnArray;
451      afs_int32 last;
452      afs_int32 *next;
453      afs_int32 maxa;
454      afs_int32 *nEntries;
455 {
456     budb_volumeList vl;
457     afs_int32 dbTime;
458     afs_int32 code;
459
460     vl.budb_volumeList_len = maxa;
461     vl.budb_volumeList_val = returnArray;
462
463     /* outline algorithm */
464     code = ubik_BUDB_GetVolumes(udbHandle.uh_client, 0, BUDB_MAJORVERSION, BUDB_OP_VOLUMENAME, volumeName,      /* name */
465                      0,         /* start */
466                      0,         /* end */
467                      last,      /* index */
468                      next,      /* nextindex */
469                      &dbTime, &vl);
470     if (code) {
471         *nEntries = 0;
472         return (code);
473     }
474     *nEntries = vl.budb_volumeList_len;
475     return (0);
476 }
477
478
479 bcdb_UseTape(teptr, newFlag)
480      register struct budb_tapeEntry *teptr;
481      afs_int32 *newFlag;
482 {
483     afs_int32 code;
484     code = ubik_BUDB_UseTape(udbHandle.uh_client, 0, teptr, newFlag);
485     return (code);
486 }
487
488
489 /* ---- text configuration handling routines ----
490  * 
491  * notes: 
492  *      The caller should pass in/out a fid for an unlinked, open file to prevent
493  *      tampering with the files contents; 
494  */
495
496 /* bcdb_GetTextFile
497  *      extract the specified textType and put it in a temporary, local
498  *      file.
499  * entry:
500  *      ctPtr - ptr to client structure with all the required information
501  */
502
503 bcdb_GetTextFile(register udbClientTextP ctPtr)
504 {
505     afs_int32 bufferSize;
506     afs_int32 offset, nextOffset;
507     charListT charList;
508     afs_int32 code = 0;
509
510     /* Initialize charlistT_val. We try to deallocate this structure based on
511      * this */
512     memset((void *)&charList, 0, sizeof(charList));
513
514     /* check params and cleanup any previous state */
515     if (ctPtr->lockHandle == 0)
516         ERROR(BUDB_INTERNALERROR);
517
518     if (ctPtr->textStream == NULL)      /* Should have an open stream */
519         ERROR(BUDB_INTERNALERROR);
520
521     /* allocate a buffer */
522     bufferSize = 1024;
523     charList.charListT_val = (char *)malloc(bufferSize);
524     if (charList.charListT_val == 0)
525         ERROR(BUDB_INTERNALERROR);
526     charList.charListT_len = bufferSize;
527
528     offset = 0;
529     nextOffset = 0;
530     ctPtr->textSize = 0;
531     while (nextOffset != -1) {
532         offset = nextOffset;
533         charList.charListT_len = bufferSize;
534         code =
535             ubik_BUDB_GetText(udbHandle.uh_client, 0, ctPtr->lockHandle,
536                       ctPtr->textType, bufferSize, offset, &nextOffset,
537                       &charList);
538
539         if (code)
540             ERROR(code);
541
542         code =
543             fwrite(charList.charListT_val, sizeof(char),
544                    charList.charListT_len, ctPtr->textStream);
545         if (ferror(ctPtr->textStream))
546             ERROR(BUDB_INTERNALERROR);
547
548         ctPtr->textSize += charList.charListT_len;
549     }
550
551     /* get text version */
552     code =
553         ubik_BUDB_GetTextVersion(udbHandle.uh_client, 0,
554                   ctPtr->textType, &ctPtr->textVersion);
555     if (code)
556         ERROR(code);
557
558   normal_exit:
559     fflush(ctPtr->textStream);  /* debug */
560
561     /* exit, leaving the configuration text file open */
562     if (charList.charListT_val)
563         free(charList.charListT_val);
564     return (code);
565
566   error_exit:
567     if (ctPtr->textStream != NULL) {
568         fclose(ctPtr->textStream);
569         ctPtr->textStream = NULL;
570     }
571     goto normal_exit;
572 }
573
574
575 /* bcdb_SaveTextFile
576  *      save the text file in ubik database
577  * entry:
578  *      textType - identifies type of configuration file
579  *      filename - where to get the text from
580  */
581
582 bcdb_SaveTextFile(ctPtr)
583      udbClientTextP ctPtr;
584 {
585     afs_int32 bufferSize;
586     afs_int32 offset, chunkSize, fileSize;
587     charListT charList;
588     afs_int32 code = 0;
589     afs_int32 filesize();
590
591     /* allocate a buffer */
592     bufferSize = 1024;
593     charList.charListT_val = (char *)malloc(bufferSize);
594     if (charList.charListT_val == 0)
595         ERROR(BUDB_INTERNALERROR);
596     charList.charListT_len = bufferSize;
597
598     if (ctPtr->textStream == NULL)
599         ERROR(BUDB_INTERNALERROR);
600     rewind(ctPtr->textStream);
601
602     fileSize = (afs_int32) filesize(ctPtr->textStream);
603
604     dprintf(("filesize is %d\n", fileSize));
605
606     rewind(ctPtr->textStream);
607
608     /* special case empty files */
609     if (fileSize == 0) {
610         charList.charListT_len = 0;
611         code =
612             ubik_BUDB_SaveText(udbHandle.uh_client, 0,
613                       ctPtr->lockHandle, ctPtr->textType, 0,
614                       BUDB_TEXT_COMPLETE, &charList);
615         goto error_exit;
616     }
617
618     offset = 0;
619     while (fileSize != 0) {
620         chunkSize = MIN(fileSize, bufferSize);
621         code =
622             fread(charList.charListT_val, sizeof(char), chunkSize,
623                   ctPtr->textStream);
624
625         if (code != chunkSize)
626             printf("code = %d\n", code);
627         if (ferror(ctPtr->textStream))
628             ERROR(BUDB_INTERNALERROR);
629
630         charList.charListT_len = chunkSize;
631         code =
632             ubik_BUDB_SaveText(udbHandle.uh_client, 0,
633                       ctPtr->lockHandle, ctPtr->textType, offset,
634                       (chunkSize == fileSize) ? BUDB_TEXT_COMPLETE : 0,
635                       &charList);
636         if (code)
637             ERROR(code);
638
639         fileSize -= chunkSize;
640         offset += chunkSize;
641     }
642
643   error_exit:
644     /* if ( ctPtr->textStream >= 0 )
645      * close(ctPtr->textStream); */
646     if (charList.charListT_val)
647         free(charList.charListT_val);
648     return (code);
649 }
650
651 bcdb_FindLastTape(dumpID, dumpEntry, tapeEntry, volEntry)
652      afs_int32 dumpID;
653      struct budb_dumpEntry *dumpEntry;
654      struct budb_tapeEntry *tapeEntry;
655      struct budb_volumeEntry *volEntry;
656 {
657     return (ubik_BUDB_FindLastTape(udbHandle.uh_client, 0, dumpID, dumpEntry,
658              tapeEntry, volEntry));
659 }
660
661 bcdb_MakeDumpAppended(appendedDumpID, initialDumpID, startTapeSeq)
662      afs_int32 appendedDumpID;
663      afs_int32 initialDumpID;
664      afs_int32 startTapeSeq;
665 {
666     return (ubik_BUDB_MakeDumpAppended(udbHandle.uh_client, 0, appendedDumpID,
667              initialDumpID, startTapeSeq));
668 }
669
670
671 /* -------------------------------------
672  * misc. support routines
673  * -------------------------------------
674  */
675
676 afs_int32
677 filesize(stream)
678      FILE *stream;
679 {
680     afs_int32 offset;
681     afs_int32 size;
682
683     offset = ftell(stream);
684     fseek(stream, (afs_int32) 0, 2);    /* end of file */
685     size = ftell(stream);
686     fseek(stream, offset, 0);
687     return (size);
688 }
689
690
691 /* ------------------------------------
692  * misc. support routines - general text management
693  * ------------------------------------
694  */
695
696
697 /* bc_LockText
698  *      locks the text described by the ctPtr
699  * entry:
700  *      ctptr - client text ptr
701  * exit:
702  *      0 - success
703  *      n - fail
704  */
705
706 bc_LockText(ctPtr)
707      register udbClientTextP ctPtr;
708 {
709     afs_int32 code;
710     afs_int32 timeout, j = 0;
711
712     if (ctPtr->lockHandle != 0)
713         return (1);             /* already locked */
714
715     timeout =
716         ((ctPtr->textSize == 0) ? 30 : ((ctPtr->textSize / 50000) + 10));
717
718     while (1) {
719         code =
720             ubik_BUDB_GetLock(udbHandle.uh_client, 0,
721                       udbHandle.uh_instanceId, ctPtr->textType, timeout,
722                       &ctPtr->lockHandle);
723         if ((code != BUDB_LOCKED) && (code != BUDB_SELFLOCKED)) {
724             break;
725         }
726
727         /* Mention something every 30 seconds */
728         if (++j >= 30) {
729             afs_com_err(whoami, code,
730                     "; Waiting for db configuration text unlock");
731             j = 0;
732         }
733 #ifdef AFS_PTHREAD_ENV
734         sleep(1);
735 #else
736         IOMGR_Sleep(1);
737 #endif
738     }
739
740     /* cleanup */
741     if (code)
742         ctPtr->lockHandle = 0;
743     return (code);
744 }
745
746 /* bc_UnlockText
747  *      unlocks the text described by the ctPtr
748  * entry:
749  *      ctptr - client text ptr
750  * exit:
751  *      0 - success
752  *      n - fail
753  */
754
755 bc_UnlockText(ctPtr)
756      register udbClientTextP ctPtr;
757 {
758     afs_int32 code = 0;
759
760     if (ctPtr->lockHandle == 0)
761         return (0);
762
763     code =
764         ubik_BUDB_FreeLock(udbHandle.uh_client, 0, ctPtr->lockHandle);
765     ctPtr->lockHandle = 0;
766
767     /* Don't try to analyse the error. Let the lock timeout */
768     return (code);
769 }
770
771 /* bc_CheckTextVersion
772  * exit:
773  *      0 - version # ok
774  *      n - out of date or error
775  */
776
777 bc_CheckTextVersion(ctPtr)
778      register udbClientTextP ctPtr;
779 {
780     afs_int32 code;
781     afs_uint32 tversion;
782
783     if (ctPtr->textVersion == -1)
784         return (BC_VERSIONMISMATCH);
785
786     code =
787         ubik_BUDB_GetTextVersion(udbHandle.uh_client, 0,
788                   ctPtr->textType, &tversion);
789     if (code)
790         return (code);
791     if (tversion != ctPtr->textVersion)
792         return (BC_VERSIONMISMATCH);
793     return (0);
794 }
795
796 /* -------------------------------------
797  * initialization routines
798  * -------------------------------------
799  */
800
801 /* vldbClientInit 
802  *      Initialize a client for the vl ubik database.
803  */
804 vldbClientInit(noAuthFlag, localauth, cellName, cstruct, ttoken)
805      int noAuthFlag;
806      int localauth;
807      char *cellName;
808      struct ubik_client **cstruct;
809      struct ktc_token *ttoken;
810 {
811     afs_int32 code = 0;
812     struct afsconf_dir *acdir;
813     struct rc_securityClass *sc;
814     afs_int32 i, scIndex = 0;   /* Index of Rx security object - noauth */
815     struct afsconf_cell info;
816     struct ktc_principal sname;
817     struct rx_connection *serverconns[VLDB_MAXSERVERS];
818
819
820     /* Find out about the given cell */
821     acdir =
822         afsconf_Open((localauth ? AFSDIR_SERVER_ETC_DIRPATH :
823                       AFSDIR_CLIENT_ETC_DIRPATH));
824     if (!acdir) {
825         afs_com_err(whoami, 0, "Can't open configuration directory '%s'",
826                 (localauth ? AFSDIR_SERVER_ETC_DIRPATH :
827                  AFSDIR_CLIENT_ETC_DIRPATH));
828         ERROR(BC_NOCELLCONFIG);
829     }
830
831     if (!cellName[0]) {
832         char cname[64];
833
834         code = afsconf_GetLocalCell(acdir, cname, sizeof(cname));
835         if (code) {
836             afs_com_err(whoami, code,
837                     "; Can't get the local cell name - check %s/%s",
838                     (localauth ? AFSDIR_SERVER_ETC_DIRPATH :
839                      AFSDIR_CLIENT_ETC_DIRPATH), AFSDIR_THISCELL_FILE);
840             ERROR(code);
841         }
842         strcpy(cellName, cname);
843     }
844
845     code = afsconf_GetCellInfo(acdir, cellName, AFSCONF_VLDBSERVICE, &info);
846     if (code) {
847         afs_com_err(whoami, code, "; Can't find cell %s's hosts in %s/%s",
848                 cellName,
849                 (localauth ? AFSDIR_SERVER_ETC_DIRPATH :
850                  AFSDIR_CLIENT_ETC_DIRPATH), AFSDIR_CELLSERVDB_FILE);
851         ERROR(BC_NOCELLCONFIG);
852     }
853
854     /*
855      * Grab tickets if we care about authentication.
856      */
857     ttoken->endTime = 0;
858     if (localauth) {
859         code = afsconf_GetLatestKey(acdir, 0, 0);
860         if (code) {
861             afs_com_err(whoami, code, "; Can't get key from local key file");
862             ERROR(code);
863         } else {
864             code = afsconf_ClientAuth(acdir, &sc, &scIndex);
865             if (code) {
866                 afs_com_err(whoami, code, "; Calling ClientAuth");
867                 ERROR(code);
868             }
869
870             ttoken->endTime = NEVERDATE;
871         }
872     } else {
873         if (!noAuthFlag) {
874             strcpy(sname.cell, info.name);
875             sname.instance[0] = 0;
876             strcpy(sname.name, "afs");
877
878             code =
879                 ktc_GetToken(&sname, ttoken, sizeof(struct ktc_token), NULL);
880             if (code) {
881                 afs_com_err(whoami, code, 0,
882                         "; Can't get AFS tokens - running unauthenticated");
883             } else {
884                 if ((ttoken->kvno < 0) || (ttoken->kvno > 255))
885                     afs_com_err(whoami, 0,
886                             "Funny kvno (%d) in ticket, proceeding",
887                             ttoken->kvno);
888
889                 scIndex = 2;
890             }
891         }
892
893         switch (scIndex) {
894         case 0:
895             sc = rxnull_NewClientSecurityObject();
896             break;
897         case 2:
898             sc = (struct rx_securityClass *)
899                 rxkad_NewClientSecurityObject(rxkad_clear,
900                                               &ttoken->sessionKey,
901                                               ttoken->kvno, ttoken->ticketLen,
902                                               ttoken->ticket);
903             break;
904         default:
905             afs_com_err(whoami, 0, "Unsupported authentication type %d", scIndex);
906             ERROR(-1);
907             break;
908         }
909     }
910
911     if (!sc) {
912         afs_com_err(whoami, 0,
913                 "Can't create a security object with security index %d",
914                 scIndex);
915         ERROR(-1);
916     }
917
918     /* tell UV module about default authentication */
919     UV_SetSecurity(sc, scIndex);
920
921     if (info.numServers > VLDB_MAXSERVERS) {
922         afs_com_err(whoami, 0,
923                 "Warning: %d VLDB servers exist for cell '%s', can only remember the first %d",
924                 info.numServers, cellName, VLDB_MAXSERVERS);
925         info.numServers = VLDB_MAXSERVERS;
926     }
927
928     for (i = 0; i < info.numServers; i++)
929         serverconns[i] =
930             rx_NewConnection(info.hostAddr[i].sin_addr.s_addr,
931                              info.hostAddr[i].sin_port, USER_SERVICE_ID, sc,
932                              scIndex);
933     serverconns[i] = 0;
934
935     *cstruct = 0;
936     code = ubik_ClientInit(serverconns, cstruct);
937     if (code) {
938         afs_com_err(whoami, code, "; Can't initialize ubik connection to vldb");
939         ERROR(code);
940     }
941
942   error_exit:
943     if (acdir)
944         afsconf_Close(acdir);
945     return (code);
946 }
947
948 /* udbClientInit
949  *      initialize a client for the backup systems ubik database.
950  */
951
952 afs_int32
953 udbClientInit(noAuthFlag, localauth, cellName)
954      int noAuthFlag;
955      int localauth;
956      char *cellName;
957 {
958     struct ktc_principal principal;
959     struct ktc_token token;
960     struct afsconf_cell info;
961     struct afsconf_dir *acdir;
962     int i;
963     afs_int32 code = 0;
964
965     acdir =
966         afsconf_Open((localauth ? AFSDIR_SERVER_ETC_DIRPATH :
967                       AFSDIR_CLIENT_ETC_DIRPATH));
968     if (!acdir) {
969         afs_com_err(whoami, 0, "Can't open configuration directory '%s'",
970                 (localauth ? AFSDIR_SERVER_ETC_DIRPATH :
971                  AFSDIR_CLIENT_ETC_DIRPATH));
972         ERROR(BC_NOCELLCONFIG);
973     }
974
975     if (!cellName[0]) {
976         char cname[64];
977
978         code = afsconf_GetLocalCell(acdir, cname, sizeof(cname));
979         if (code) {
980             afs_com_err(whoami, code,
981                     "; Can't get the local cell name - check %s/%s",
982                     (localauth ? AFSDIR_SERVER_ETC_DIRPATH :
983                      AFSDIR_CLIENT_ETC_DIRPATH), AFSDIR_THISCELL_FILE);
984             ERROR(code);
985         }
986         strcpy(cellName, cname);
987     }
988
989     code = afsconf_GetCellInfo(acdir, cellName, 0, &info);
990     if (code) {
991         afs_com_err(whoami, code, "; Can't find cell %s's hosts in %s/%s",
992                 cellName,
993                 (localauth ? AFSDIR_SERVER_ETC_DIRPATH :
994                  AFSDIR_CLIENT_ETC_DIRPATH), AFSDIR_CELLSERVDB_FILE);
995         ERROR(BC_NOCELLCONFIG);
996     }
997
998     udbHandle.uh_scIndex = RX_SCINDEX_NULL;
999
1000     if (localauth) {
1001         code = afsconf_GetLatestKey(acdir, 0, 0);
1002         if (code) {
1003             afs_com_err(whoami, code, "; Can't get key from local key file");
1004             ERROR(-1);
1005         } else {
1006             code =
1007                 afsconf_ClientAuth(acdir, &udbHandle.uh_secobj,
1008                                    &udbHandle.uh_scIndex);
1009             if (code) {
1010                 afs_com_err(whoami, code, "; Calling ClientAuth");
1011                 ERROR(-1);
1012             }
1013         }
1014     } else {
1015         if (!noAuthFlag) {
1016             /* setup principal */
1017             strcpy(principal.cell, info.name);
1018             principal.instance[0] = 0;
1019             strcpy(principal.name, "afs");
1020
1021             /* get token */
1022             code = ktc_GetToken(&principal, &token, sizeof(token), NULL);
1023             if (code) {
1024                 afs_com_err(whoami, code,
1025                         "; Can't get tokens - running unauthenticated");
1026             } else {
1027                 if ((token.kvno < 0) || (token.kvno > 255))
1028                     afs_com_err(whoami, 0,
1029                             "Unexpected kvno (%d) in ticket - proceeding",
1030                             token.kvno);
1031                 udbHandle.uh_scIndex = RX_SCINDEX_KAD;  /* Kerberos */
1032             }
1033         }
1034
1035         switch (udbHandle.uh_scIndex) {
1036         case 0:
1037             udbHandle.uh_secobj = rxnull_NewClientSecurityObject();
1038             break;
1039
1040         case 2:
1041             udbHandle.uh_secobj = (struct rx_securityClass *)
1042                 rxkad_NewClientSecurityObject(rxkad_clear, &token.sessionKey,
1043                                               token.kvno, token.ticketLen,
1044                                               token.ticket);
1045             break;
1046
1047         default:
1048             afs_com_err(whoami, 0, "Unsupported authentication type %d",
1049                     udbHandle.uh_scIndex);
1050             ERROR(-1);
1051             break;
1052         }
1053     }
1054
1055     if (!udbHandle.uh_secobj) {
1056         afs_com_err(whoami, 0,
1057                 "Can't create a security object with security index %d",
1058                 udbHandle.uh_secobj);
1059         ERROR(-1);
1060     }
1061
1062     if (info.numServers > MAXSERVERS) {
1063         afs_com_err(whoami, 0,
1064                 "Warning: %d BDB servers exist for cell '%s', can only remember the first %d",
1065                 info.numServers, cellName, MAXSERVERS);
1066         info.numServers = MAXSERVERS;
1067     }
1068
1069     /* establish connections to the servers. Check for failed connections? */
1070     for (i = 0; i < info.numServers; i++) {
1071         udbHandle.uh_serverConn[i] =
1072             rx_NewConnection(info.hostAddr[i].sin_addr.s_addr,
1073                              htons(AFSCONF_BUDBPORT), BUDB_SERVICE,
1074                              udbHandle.uh_secobj, udbHandle.uh_scIndex);
1075     }
1076     udbHandle.uh_serverConn[i] = 0;
1077
1078     code = ubik_ClientInit(udbHandle.uh_serverConn, &udbHandle.uh_client);
1079     if (code) {
1080         afs_com_err(whoami, code,
1081                 "; Can't initialize ubik connection to backup database");
1082         ERROR(code);
1083     }
1084
1085     /* Try to quickly find a good site by setting deadtime low */
1086     for (i = 0; i < info.numServers; i++)
1087         rx_SetConnDeadTime(udbHandle.uh_client->conns[i], 1);
1088     code =
1089         ubik_BUDB_GetInstanceId(udbHandle.uh_client, 0,
1090                   &udbHandle.uh_instanceId);
1091
1092     /* Reset dead time back up to default */
1093     for (i = 0; i < info.numServers; i++)
1094         rx_SetConnDeadTime(udbHandle.uh_client->conns[i], 60);
1095
1096     /* If did not find a site on first quick pass, try again */
1097     if (code == -1)
1098         code =
1099             ubik_BUDB_GetInstanceId(udbHandle.uh_client, 0,
1100                       &udbHandle.uh_instanceId);
1101     if (code) {
1102         afs_com_err(whoami, code, "; Can't access backup database");
1103         ERROR(code);
1104     }
1105
1106   error_exit:
1107     if (acdir)
1108         afsconf_Close(acdir);
1109     return (code);
1110 }
1111
1112 /* -------------------------------------
1113  * specialized ubik support
1114  * -------------------------------------
1115  */
1116
1117 #include <rx/xdr.h>
1118 #include <rx/rx.h>
1119 #include <lock.h>
1120
1121 /* notes
1122  *      1) first call with SINGLESERVER set, record the server to be used.
1123  *      2) subsequent calls use that server. If a failure is encountered,
1124  *         the state is cleaned up and the error returned back to the caller.
1125  *      3) upon completion, the user must make a dummy call with
1126  *         END_SINGLESERVER set, to clean up state.
1127  *      4) if the vanilla ubik_Call is ever modified, the END_SINGLESERVER
1128  *         flag can be discarded. The first call without SINGLESERVER set
1129  *         can clean up the state.
1130  */
1131
1132 struct ubikCallState {
1133     afs_int32 ucs_flags;        /* state flags */
1134     afs_int32 ucs_selectedServer;       /* which server selected */
1135 };
1136
1137 static struct ubikCallState uServer;
1138
1139 /* ubik_Call_SingleServer
1140  *      variant of ubik_Call. This is used by the backup system to initiate
1141  *      a series of calls to a single ubik server. The first call sets up
1142  *      process state (not recorded in ubik) that requires all further calls
1143  *      of that group to be made to the same server process.
1144  *
1145  *      call this instead of stub and we'll guarantee to find a host that's up.
1146  *      in the future, we should also put in a protocol to find the sync site
1147  */
1148
1149 afs_int32
1150 ubik_Call_SingleServer(aproc, aclient, aflags, p1, p2, p3, p4, p5, p6, p7, p8,
1151                        p9, p10, p11, p12, p13, p14, p15, p16)
1152      register struct ubik_client *aclient;
1153      int (*aproc) ();
1154      afs_int32 aflags;
1155      char *p1, *p2, *p3, *p4, *p5, *p6, *p7, *p8, *p9, *p10, *p11, *p12, *p13,
1156          *p14, *p15, *p16;
1157 {
1158     register afs_int32 code;
1159     afs_int32 someCode, newHost, thisHost;
1160     register afs_int32 i;
1161     register afs_int32 count;
1162     int chaseCount;
1163     int pass;
1164     struct rx_connection *tc;
1165     struct rx_peer *rxp;
1166
1167     if ((aflags & (UF_SINGLESERVER | UF_END_SINGLESERVER)) != 0) {
1168         if (((aflags & UF_SINGLESERVER) != 0)
1169             && ((uServer.ucs_flags & UF_SINGLESERVER) != 0)
1170             ) {
1171
1172             /* have a selected server */
1173             tc = aclient->conns[uServer.ucs_selectedServer];
1174
1175             code =
1176                 (*aproc) (tc, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11,
1177                           p12, p13, p14, p15, p16);
1178             if (code) {
1179                 /* error. Clean up single server state */
1180                 memset(&uServer, 0, sizeof(uServer));
1181             }
1182             return (code);
1183         } else if ((aflags & UF_END_SINGLESERVER) != 0) {
1184             memset(&uServer, 0, sizeof(uServer));
1185             return (0);
1186         }
1187     }
1188
1189     someCode = UNOSERVERS;
1190     chaseCount = 0;
1191     pass = 0;
1192     count = 0;
1193     while (1) {                 /*w */
1194
1195         /* tc is the next conn to try */
1196         tc = aclient->conns[count];
1197         if (tc == 0) {
1198             if (pass == 0) {
1199                 pass = 1;       /* in pass 1, we look at down hosts, too */
1200                 count = 0;
1201                 continue;
1202             } else
1203                 break;          /* nothing left to try */
1204         }
1205         if (pass == 0 && (aclient->states[count] & CFLastFailed)) {
1206             count++;
1207             continue;           /* this guy's down, try someone else first */
1208         }
1209
1210         code =
1211             (*aproc) (tc, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12,
1212                       p13, p14, p15, p16);
1213
1214         /* note that getting a UNOTSYNC error code back does *not* guarantee
1215          * that there is a sync site yet elected.  However, if there is a
1216          * sync site out there somewhere, and you're trying an operation that
1217          * requires a sync site, ubik will return UNOTSYNC, indicating the
1218          * operation won't work until you find a sync site
1219          */
1220         if (code == UNOTSYNC) { /*ns */
1221             /* means that this requires a sync site to work */
1222             someCode = code;    /* remember an error, if this fails */
1223
1224             /* now see if we can find the sync site host */
1225             code = VOTE_GetSyncSite(tc, &newHost);
1226             if (code == 0 && newHost != 0) {
1227                 newHost = htonl(newHost);       /* convert back to network order */
1228
1229                 /* position count at the appropriate slot in the client
1230                  * structure and retry. If we can't find in slot, we'll just
1231                  * continue through the whole list
1232                  */
1233                 for (i = 0; i < MAXSERVERS; i++) {      /*f */
1234                     rxp = rx_PeerOf(aclient->conns[i]);
1235                     if (!(thisHost = rx_HostOf(rxp))) {
1236                         count++;        /* host not found, try the next dude */
1237                         break;
1238                     }
1239                     if (thisHost == newHost) {
1240                         /* avoid asking in a loop */
1241                         if (chaseCount++ > 2)
1242                             break;
1243                         count = i;      /* we were told to use this one */
1244                         break;
1245                     }
1246                 }               /*f */
1247             } else
1248                 count++;        /* not directed, keep looking for a sync site */
1249             continue;
1250         } /*ns */
1251         else if (code == UNOQUORUM) {   /* this guy is still recovering */
1252             someCode = code;
1253             count++;
1254             continue;
1255         } else if (code < 0) {  /* network errors */
1256             someCode = code;
1257             aclient->states[count] |= CFLastFailed;
1258             count++;
1259             continue;
1260         } else {
1261             /* ok, operation worked */
1262             aclient->states[count] &= ~CFLastFailed;
1263             /* either misc ubik code, or misc application code (incl success)
1264              */
1265
1266             /* if the call succeeded, setup connection state for subsequent
1267              * calls
1268              */
1269             if ((code == 0)
1270                 && ((aflags & UF_SINGLESERVER) != 0)
1271                 ) {
1272                 /* need to save state */
1273                 uServer.ucs_flags = UF_SINGLESERVER;
1274                 uServer.ucs_selectedServer = count;
1275             }
1276
1277             return code;
1278         }
1279     }                           /*w */
1280     return someCode;
1281 }
1282
1283
1284 /* -------------------------------------
1285  * debug and test routines 
1286  * -------------------------------------
1287  */
1288
1289 /* udbLocalInit
1290  *      For testing only. Open a connect to the database server running on
1291  *      the local host
1292  * exit:
1293  *      0 - ubik connection established in the global udbHandle structure
1294  *      n - error.
1295  */
1296
1297 udbLocalInit()
1298 {
1299     afs_int32 serverList[MAXSERVERS];
1300     char hostname[256];
1301     char *args[3];
1302     int i;
1303     afs_int32 code;
1304
1305     /* get our host name */
1306     gethostname(hostname, sizeof(hostname));
1307     /* strcpy(hostname, "hops"); */
1308
1309     args[0] = "";
1310     args[1] = "-servers";
1311     args[2] = hostname;
1312
1313     code = ubik_ParseClientList(3, args, serverList);
1314     if (code) {
1315         afs_com_err(whoami, code, "; udbLocalInit: parsing ubik server list");
1316         return (-1);
1317     }
1318
1319     udbHandle.uh_scIndex = RX_SCINDEX_NULL;
1320     udbHandle.uh_secobj = (struct rx_securityClass *)
1321         rxnull_NewClientSecurityObject();
1322
1323     for (i = 0; serverList[i] != 0; i++) {
1324         udbHandle.uh_serverConn[i] =
1325             rx_NewConnection(serverList[i], htons(AFSCONF_BUDBPORT),
1326                              BUDB_SERVICE, udbHandle.uh_secobj,
1327                              udbHandle.uh_scIndex);
1328         if (udbHandle.uh_serverConn[i] == 0) {
1329             afs_com_err(whoami, 0, "connection %d failed", i);
1330             continue;
1331         }
1332     }
1333     udbHandle.uh_serverConn[i] = 0;
1334     code = ubik_ClientInit(udbHandle.uh_serverConn, &udbHandle.uh_client);
1335     if (code) {
1336         afs_com_err(whoami, code, "; in ubik_ClientInit");
1337         return (code);
1338     }
1339
1340     code =
1341         ubik_BUDB_GetInstanceId(udbHandle.uh_client, 0,
1342                   &udbHandle.uh_instanceId);
1343     if (code) {
1344         afs_com_err(whoami, code, "; Can't estblish instance Id");
1345         return (code);
1346     }
1347
1348    /* abort: */
1349     return (0);
1350 }
1351
1352 /* bc_openTextFile - This function opens a temp file to read in the
1353  * config text recd from the bu server. On Unix, an unlink() is done on
1354  * the file as soon as it is opened, so when the program exits, the file will
1355  * be removed automatically, while being invisible while in use.
1356  * On NT, however, the file must be explicitly deleted after use with an unlink()
1357  * Input:
1358  *  Pointer to a udhClientTextP struct. The open stream ptr is stored in
1359  *           the udbClientTextP.textStream member.
1360  * Output: The temp file name is returned in tmpFileName. This should be used
1361  *   to delete the file when done with it.
1362  * Return Values: 
1363  *     !0: error code
1364  *     0: Success.
1365  */
1366 int
1367 bc_openTextFile(udbClientTextP ctPtr, char *tmpFileName)
1368 {
1369     int code = 0;
1370
1371     if (ctPtr->textStream != NULL)
1372         fclose(ctPtr->textStream);
1373
1374     sprintf(tmpFileName, "%s/bu_XXXXXX", gettmpdir());
1375 #ifdef AFS_LINUX20_ENV
1376     mkstemp(tmpFileName);
1377 #else
1378     mktemp(tmpFileName);
1379 #endif
1380     ctPtr->textStream = fopen(tmpFileName, "w+");
1381     if (ctPtr->textStream == NULL)
1382         ERROR(BUDB_INTERNALERROR);
1383
1384 #ifndef AFS_NT40_ENV            /* This can't be done on NT */
1385     /* make the file invisible to others */
1386     code = unlink(tmpFileName);
1387     if (code)
1388         ERROR(errno);
1389 #endif
1390
1391     dprintf(("file is %s\n", tmpFileName));
1392
1393   normal_exit:
1394     return code;
1395
1396   error_exit:
1397     if (ctPtr->textStream != NULL) {
1398         fclose(ctPtr->textStream);
1399         ctPtr->textStream = NULL;
1400     }
1401     goto normal_exit;
1402 }
1403
1404
1405 /* bc_closeTextFile: This function closes any actual temp files associated with
1406  * a udbClientText structure. 
1407  * Input: ctPtr->textStream - stream to close
1408  *        tmpFileName - temp file name to delete
1409  * RetVal: 
1410  *    0  - Success
1411  *    !0 - error code
1412  */
1413 int
1414 bc_closeTextFile(udbClientTextP ctPtr, char *tmpFileName)
1415 {
1416     int code = 0;
1417
1418     if (ctPtr->textStream)
1419         fclose(ctPtr->textStream);
1420
1421     if (*tmpFileName) {         /* we have a valid name */
1422         code = unlink(tmpFileName);
1423         if (code < 0)
1424             code = errno;
1425     }
1426     return code;
1427 }