vlserver: always use the hostaddress table in GetAddrsU
[openafs.git] / src / vlserver / vlprocs.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 #include <roken.h>
14
15 #include <lock.h>
16 #include <afs/afsutil.h>
17 #include <ubik.h>
18 #include <rx/xdr.h>
19 #include <rx/rx.h>
20 #include <rx/rxkad.h>
21 #include <afs/keys.h>
22 #include <afs/cellconfig.h>
23
24 #include "vlserver.h"
25 #include "vlserver_internal.h"
26 #include "afs/audit.h"
27
28 #ifdef HAVE_POSIX_REGEX         /* use POSIX regexp library */
29 #include <regex.h>
30 #endif
31
32 extern int smallMem;
33 extern int extent_mod;
34 extern struct afsconf_dir *vldb_confdir;
35 extern struct ubik_dbase *VL_dbase;
36 int maxnservers;
37 #define ABORT(c) do { \
38     code = (c); \
39     goto abort; \
40 } while (0)
41 #undef END
42 #define END(c) do { \
43     code = (c); \
44     goto end; \
45 } while (0)
46
47 #define VLDBALLOCLIMIT  10000
48 #define VLDBALLOCINCR   2048
49
50 static int put_attributeentry(struct vl_ctx *ctx,
51                               struct vldbentry **, struct vldbentry **,
52                               struct vldbentry **, bulkentries *,
53                               struct nvlentry *, afs_int32 *, afs_int32 *);
54 static int put_nattributeentry(struct vl_ctx *ctx,
55                                struct nvldbentry **, struct nvldbentry **,
56                                struct nvldbentry **, nbulkentries *,
57                                struct nvlentry *, afs_int32, afs_int32,
58                                afs_int32 *, afs_int32 *);
59 static int RemoveEntry(struct vl_ctx *ctx, afs_int32 entryptr,
60                        struct nvlentry *tentry);
61 static void ReleaseEntry(struct nvlentry *tentry, afs_int32 releasetype);
62 static int check_vldbentry(struct vldbentry *aentry);
63 static int check_nvldbentry(struct nvldbentry *aentry);
64 static int vldbentry_to_vlentry(struct vl_ctx *ctx,
65                                 struct vldbentry *VldbEntry,
66                                 struct nvlentry *VlEntry);
67 static int nvldbentry_to_vlentry(struct vl_ctx *ctx,
68                                  struct nvldbentry *VldbEntry,
69                                  struct nvlentry *VlEntry);
70 static int get_vldbupdateentry(struct vl_ctx *ctx, afs_int32 blockindex,
71                                struct VldbUpdateEntry *updateentry,
72                                struct nvlentry *VlEntry);
73 static int repsite_exists(struct nvlentry *VlEntry, int server, int partition);
74 static void repsite_compress(struct nvlentry *VlEntry, int offset);
75 static int vlentry_to_vldbentry(struct vl_ctx *ctx,
76                                 struct nvlentry *VlEntry,
77                                 struct vldbentry *VldbEntry);
78 static int vlentry_to_nvldbentry(struct vl_ctx *ctx,
79                                  struct nvlentry *VlEntry,
80                                  struct nvldbentry *VldbEntry);
81 static int vlentry_to_uvldbentry(struct vl_ctx *ctx,
82                                  struct nvlentry *VlEntry,
83                                  struct uvldbentry *VldbEntry);
84 static int InvalidVolname(char *volname);
85 static int InvalidVoltype(afs_int32 voltype);
86 static int InvalidOperation(afs_int32 voloper);
87 static int InvalidReleasetype(afs_int32 releasetype);
88 static int IpAddrToRelAddr(struct vl_ctx *ctx, afs_uint32 ipaddr, int create);
89 static int ChangeIPAddr(struct vl_ctx *ctx, afs_uint32 ipaddr1,
90                         afs_uint32 ipaddr2);
91
92 static_inline void
93 countRequest(int opcode)
94 {
95     if (opcode != 0) {
96         dynamic_statistics.requests[opcode - VL_LOWEST_OPCODE]++;
97     }
98 }
99
100 static_inline void
101 countAbort(int opcode)
102 {
103     if (opcode != 0) {
104         dynamic_statistics.aborts[opcode - VL_LOWEST_OPCODE]++;
105     }
106 }
107
108
109 static_inline int
110 multiHomedExtentBase(struct vl_ctx *ctx, int srvidx, struct extentaddr **exp,
111                      int *basePtr)
112 {
113     int base;
114     int index;
115
116     *exp = NULL;
117     *basePtr = 0;
118
119     if ((ctx->hostaddress[srvidx] & 0xff000000) == 0xff000000) {
120         base = (ctx->hostaddress[srvidx] >> 16) & 0xff;
121         index = ctx->hostaddress[srvidx] & 0x0000ffff;
122         if (base >= VL_MAX_ADDREXTBLKS) {
123             VLog(0, ("Internal error: Multihome extent base is too large. "
124                      "Base %d index %d\n", base, index));
125             return VL_IO;
126         }
127         if (index >= VL_MHSRV_PERBLK) {
128             VLog(0, ("Internal error: Multihome extent index is too large. "
129                      "Base %d index %d\n", base, index));
130             return VL_IO;
131         }
132         if (!ctx->ex_addr[base]) {
133             VLog(0, ("Internal error: Multihome extent does not exist. "
134                      "Base %d\n", base));
135             return VL_IO;
136         }
137
138         *basePtr = base;
139         *exp = &ctx->ex_addr[base][index];
140     }
141
142     return 0;
143 }
144
145 static_inline int
146 multiHomedExtent(struct vl_ctx *ctx, int srvidx, struct extentaddr **exp)
147 {
148     int base;
149
150     return multiHomedExtentBase(ctx, srvidx, exp, &base);
151 }
152
153 #define AFS_RXINFO_LEN 128
154 static char *
155 rxkadInfo(char *str, struct rx_connection *conn, struct in_addr hostAddr)
156 {
157     int code;
158     char tname[64] = "";
159     char tinst[64] = "";
160     char tcell[64] = "";
161     afs_uint32 exp;
162
163     code = rxkad_GetServerInfo(conn, NULL, &exp, tname, tinst, tcell,
164                                NULL);
165     if (!code)
166         snprintf(str, AFS_RXINFO_LEN,
167                  "%s rxkad:%s%s%s%s%s", inet_ntoa(hostAddr), tname,
168                 (tinst[0] == '\0') ? "" : ".",
169                 (tinst[0] == '\0') ? "" : tinst,
170                 (tcell[0] == '\0') ? "" : "@",
171                 (tcell[0] == '\0') ? "" : tcell);
172     else
173         snprintf(str, AFS_RXINFO_LEN, "%s noauth", inet_ntoa(hostAddr));
174     return (str);
175 }
176
177 static char *
178 rxinfo(char *str, struct rx_call *rxcall)
179 {
180     struct rx_connection *conn;
181     struct in_addr hostAddr;
182     rx_securityIndex authClass;
183
184     conn = rx_ConnectionOf(rxcall);
185     authClass = rx_SecurityClassOf(conn);
186     hostAddr.s_addr = rx_HostOf(rx_PeerOf(conn));
187
188     switch(authClass) {
189     case RX_SECIDX_KAD:
190         return rxkadInfo(str, conn, hostAddr);
191     default:
192         ;
193     }
194
195     snprintf(str, AFS_RXINFO_LEN, "%s noauth", inet_ntoa(hostAddr));
196     return str;
197 }
198
199
200 /* This is called to initialize the database, set the appropriate locks and make sure that the vldb header is valid */
201 int
202 Init_VLdbase(struct vl_ctx *ctx,
203              int locktype,      /* indicate read or write transaction */
204              int opcode)
205 {
206     int code = 0, pass, wl;
207
208     for (pass = 1; pass <= 3; pass++) {
209         if (pass == 2) {        /* take write lock to rebuild the db */
210             code = ubik_BeginTrans(VL_dbase, UBIK_WRITETRANS, &ctx->trans);
211             wl = 1;
212         } else if (locktype == LOCKREAD) {
213             code =
214                 ubik_BeginTransReadAnyWrite(VL_dbase, UBIK_READTRANS, &ctx->trans);
215             wl = 0;
216         } else {
217             code = ubik_BeginTrans(VL_dbase, UBIK_WRITETRANS, &ctx->trans);
218             wl = 1;
219         }
220         if (code)
221             return code;
222
223         code = ubik_SetLock(ctx->trans, 1, 1, locktype);
224         if (code) {
225             countAbort(opcode);
226             ubik_AbortTrans(ctx->trans);
227             return code;
228         }
229
230         /* check that dbase is initialized and setup cheader */
231         /* 2nd pass we try to rebuild the header */
232         code = CheckInit(ctx->trans, ((pass == 2) ? 1 : 0));
233         if (!code && wl && extent_mod)
234             code = readExtents(ctx->trans);     /* Fix the mh extent blocks */
235         if (code) {
236             countAbort(opcode);
237             ubik_AbortTrans(ctx->trans);
238             /* Only rebuld if the database is empty */
239             /* Exit if can't rebuild */
240             if ((pass == 1) && (code != VL_EMPTY))
241                 return code;
242             if (pass == 2)
243                 return code;
244         } else {                /* No code */
245             if (pass == 2) {
246                 ubik_EndTrans(ctx->trans);      /* Rebuilt db. End trans, then retake original lock */
247             } else {
248                 break;          /* didn't rebuild and successful - exit */
249             }
250         }
251     }
252     if (code == 0) {
253         code = vlsetcache(ctx, locktype);
254     }
255     return code;
256 }
257
258
259 /* Create a new vldb entry; both new volume id and name must be unique
260  * (non-existant in vldb).
261  */
262
263 afs_int32
264 SVL_CreateEntry(struct rx_call *rxcall, struct vldbentry *newentry)
265 {
266     int this_op = VLCREATEENTRY;
267     struct vl_ctx ctx;
268     afs_int32 code, blockindex;
269     struct nvlentry tentry;
270     char rxstr[AFS_RXINFO_LEN];
271
272     countRequest(this_op);
273     if (!afsconf_SuperUser(vldb_confdir, rxcall, NULL)) {
274         code = VL_PERM;
275         goto end;
276     }
277
278     /* Do some validity tests on new entry */
279     if ((code = check_vldbentry(newentry))
280         || (code = Init_VLdbase(&ctx, LOCKWRITE, this_op)))
281         goto end;
282
283     VLog(1,
284          ("OCreate Volume %d %s\n", newentry->volumeId[RWVOL],
285           rxinfo(rxstr, rxcall)));
286     if (EntryIDExists(&ctx, newentry->volumeId, MAXTYPES, &code)) {
287         /* at least one of the specified IDs already exists; we fail */
288         code = VL_IDEXIST;
289         goto abort;
290     } else if (code) {
291         goto abort;
292     }
293
294     /* Is this following check (by volume name) necessary?? */
295     /* If entry already exists, we fail */
296     if (FindByName(&ctx, newentry->name, &tentry, &code)) {
297         code = VL_NAMEEXIST;
298         goto abort;
299     } else if (code) {
300         goto abort;
301     }
302
303     blockindex = AllocBlock(&ctx, &tentry);
304     if (blockindex == 0) {
305         code = VL_CREATEFAIL;
306         goto abort;
307     }
308
309     memset(&tentry, 0, sizeof(struct nvlentry));
310     /* Convert to its internal representation; both in host byte order */
311     if ((code = vldbentry_to_vlentry(&ctx, newentry, &tentry))) {
312         FreeBlock(&ctx, blockindex);
313         goto abort;
314     }
315
316     /* Actually insert the entry in vldb */
317     code = ThreadVLentry(&ctx, blockindex, &tentry);
318     if (code) {
319         FreeBlock(&ctx, blockindex);
320         goto abort;
321     } else {
322         code = ubik_EndTrans(ctx.trans);
323         goto end;
324     }
325
326   abort:
327     countAbort(this_op);
328     ubik_AbortTrans(ctx.trans);
329
330   end:
331     osi_auditU(rxcall, VLCreateEntryEvent, code, AUD_STR,
332                (newentry ? newentry->name : NULL), AUD_END);
333     return code;
334 }
335
336
337 afs_int32
338 SVL_CreateEntryN(struct rx_call *rxcall, struct nvldbentry *newentry)
339 {
340     int this_op = VLCREATEENTRYN;
341     struct vl_ctx ctx;
342     afs_int32 code, blockindex;
343     struct nvlentry tentry;
344     char rxstr[AFS_RXINFO_LEN];
345
346     countRequest(this_op);
347     if (!afsconf_SuperUser(vldb_confdir, rxcall, NULL)) {
348         code = VL_PERM;
349         goto end;
350     }
351
352     /* Do some validity tests on new entry */
353     if ((code = check_nvldbentry(newentry))
354         || (code = Init_VLdbase(&ctx, LOCKWRITE, this_op)))
355         goto end;
356
357     VLog(1,
358          ("Create Volume %d %s\n", newentry->volumeId[RWVOL],
359           rxinfo(rxstr, rxcall)));
360     if (EntryIDExists(&ctx, newentry->volumeId, MAXTYPES, &code)) {
361         /* at least one of the specified IDs already exists; we fail */
362         code = VL_IDEXIST;
363         goto abort;
364     } else if (code) {
365         goto abort;
366     }
367
368     /* Is this following check (by volume name) necessary?? */
369     /* If entry already exists, we fail */
370     if (FindByName(&ctx, newentry->name, &tentry, &code)) {
371         code = VL_NAMEEXIST;
372         goto abort;
373     } else if (code) {
374         goto abort;
375     }
376
377     blockindex = AllocBlock(&ctx, &tentry);
378     if (blockindex == 0) {
379         code = VL_CREATEFAIL;
380         goto abort;
381     }
382
383     memset(&tentry, 0, sizeof(struct nvlentry));
384     /* Convert to its internal representation; both in host byte order */
385     if ((code = nvldbentry_to_vlentry(&ctx, newentry, &tentry))) {
386         FreeBlock(&ctx, blockindex);
387         goto abort;
388     }
389
390     /* Actually insert the entry in vldb */
391     code = ThreadVLentry(&ctx, blockindex, &tentry);
392     if (code) {
393         FreeBlock(&ctx, blockindex);
394         goto abort;
395     } else {
396         code = ubik_EndTrans(ctx.trans);
397         goto end;
398     }
399
400   abort:
401     countAbort(this_op);
402     ubik_AbortTrans(ctx.trans);
403
404   end:
405     osi_auditU(rxcall, VLCreateEntryEvent, code, AUD_STR,
406                (newentry ? newentry->name : NULL), AUD_END);
407     return code;
408 }
409
410
411 afs_int32
412 SVL_ChangeAddr(struct rx_call *rxcall, afs_uint32 ip1, afs_uint32 ip2)
413 {
414     int this_op = VLCHANGEADDR;
415     struct vl_ctx ctx;
416     afs_int32 code;
417     char rxstr[AFS_RXINFO_LEN];
418
419     countRequest(this_op);
420     if (!afsconf_SuperUser(vldb_confdir, rxcall, NULL)) {
421         code = VL_PERM;
422         goto end;
423     }
424
425     if ((code = Init_VLdbase(&ctx, LOCKWRITE, this_op)))
426         goto end;
427
428     VLog(1, ("Change Addr %u -> %u %s\n", ip1, ip2, rxinfo(rxstr, rxcall)));
429     if ((code = ChangeIPAddr(&ctx, ip1, ip2)))
430         goto abort;
431     else {
432         code = ubik_EndTrans(ctx.trans);
433         goto end;
434     }
435
436   abort:
437     countAbort(this_op);
438     ubik_AbortTrans(ctx.trans);
439
440   end:
441     osi_auditU(rxcall, VLChangeAddrEvent, code, AUD_LONG, ip1, AUD_LONG,
442                ip2, AUD_END);
443     return code;
444 }
445
446 /* Delete a vldb entry given the volume id. */
447 afs_int32
448 SVL_DeleteEntry(struct rx_call *rxcall, afs_uint32 volid, afs_int32 voltype)
449 {
450     int this_op = VLDELETEENTRY;
451     struct vl_ctx ctx;
452     afs_int32 blockindex, code;
453     struct nvlentry tentry;
454     char rxstr[AFS_RXINFO_LEN];
455
456     countRequest(this_op);
457     if (!afsconf_SuperUser(vldb_confdir, rxcall, NULL))
458         END(VL_PERM);
459
460     if ((voltype != -1) && (InvalidVoltype(voltype)))
461         END(VL_BADVOLTYPE);
462
463     if ((code = Init_VLdbase(&ctx, LOCKWRITE, this_op)))
464         goto end;
465
466     VLog(1, ("Delete Volume %u %s\n", volid, rxinfo(rxstr, rxcall)));
467     blockindex = FindByID(&ctx, volid, voltype, &tentry, &code);
468     if (blockindex == 0) {      /* volid not found */
469         if (!code)
470             code = VL_NOENT;
471         goto abort;
472     }
473
474     if (tentry.flags & VLDELETED) {     /* Already deleted; return */
475         ABORT(VL_ENTDELETED);
476     }
477     if ((code = RemoveEntry(&ctx, blockindex, &tentry))) {
478         goto abort;
479     }
480     code = (ubik_EndTrans(ctx.trans));
481     goto end;
482
483   abort:
484     countAbort(this_op);
485     ubik_AbortTrans(ctx.trans);
486
487   end:
488     osi_auditU(rxcall, VLDeleteEntryEvent, code, AUD_LONG, volid,
489                AUD_END);
490     return code;
491 }
492
493
494 /* Get a vldb entry given its volume id; make sure it's not a deleted entry. */
495 int
496 GetEntryByID(struct rx_call *rxcall,
497              afs_uint32 volid,
498              afs_int32 voltype,
499              char *aentry,      /* entry data copied here */
500              afs_int32 new,
501              afs_int32 this_op)
502 {
503     struct vl_ctx ctx;
504     afs_int32 blockindex, code;
505     struct nvlentry tentry;
506     char rxstr[AFS_RXINFO_LEN];
507
508     countRequest(this_op);
509
510     if ((voltype != -1) && (InvalidVoltype(voltype)))
511         return VL_BADVOLTYPE;
512     if ((code = Init_VLdbase(&ctx, LOCKREAD, this_op)))
513         return code;
514
515     VLog(5, ("GetVolumeByID %u (%d) %s\n", volid, new,
516              rxinfo(rxstr, rxcall)));
517     blockindex = FindByID(&ctx, volid, voltype, &tentry, &code);
518     if (blockindex == 0) {      /* entry not found */
519         if (!code)
520             code = VL_NOENT;
521         goto abort;
522     }
523     if (tentry.flags & VLDELETED) {     /* Entry is deleted! */
524         code = VL_ENTDELETED;
525         goto abort;
526     }
527     /* Convert from the internal to external form */
528     if (new == 1)
529         code = vlentry_to_nvldbentry(&ctx, &tentry, (struct nvldbentry *)aentry);
530     else if (new == 2)
531         code = vlentry_to_uvldbentry(&ctx, &tentry, (struct uvldbentry *)aentry);
532     else
533         code = vlentry_to_vldbentry(&ctx, &tentry, (struct vldbentry *)aentry);
534
535     if (code)
536         goto abort;
537
538     return (ubik_EndTrans(ctx.trans));
539
540 abort:
541     countAbort(this_op);
542     ubik_AbortTrans(ctx.trans);
543     return code;
544 }
545
546 afs_int32
547 SVL_GetEntryByID(struct rx_call *rxcall,
548                  afs_uint32 volid,
549                  afs_int32 voltype,
550                  vldbentry *aentry)             /* entry data copied here */
551 {
552     return (GetEntryByID(rxcall, volid, voltype, (char *)aentry, 0,
553                          VLGETENTRYBYID));
554 }
555
556 afs_int32
557 SVL_GetEntryByIDN(struct rx_call *rxcall,
558                   afs_uint32 volid,
559                   afs_int32 voltype,
560                   nvldbentry *aentry)   /* entry data copied here */
561 {
562     return (GetEntryByID(rxcall, volid, voltype, (char *)aentry, 1,
563                          VLGETENTRYBYIDN));
564 }
565
566 afs_int32
567 SVL_GetEntryByIDU(struct rx_call *rxcall,
568                   afs_uint32 volid,
569                   afs_int32 voltype,
570                   uvldbentry *aentry)   /* entry data copied here */
571 {
572     return (GetEntryByID(rxcall, volid, voltype, (char *)aentry, 2,
573                          VLGETENTRYBYIDU));
574 }
575
576 /* returns true if the id is a decimal integer, in which case we interpret
577  * it as an id.  make the cache manager much simpler */
578 static int
579 NameIsId(char *aname)
580 {
581     int tc;
582     while ((tc = *aname++)) {
583         if (tc > '9' || tc < '0')
584             return 0;
585     }
586     return 1;
587 }
588
589 /* Get a vldb entry given the volume's name; of course, very similar to
590  * VLGetEntryByID() above. */
591 afs_int32
592 GetEntryByName(struct rx_call *rxcall,
593                char *volname,
594                char *aentry,            /* entry data copied here */
595                int new,
596                int this_op)
597 {
598     struct vl_ctx ctx;
599     afs_int32 blockindex, code;
600     struct nvlentry tentry;
601     char rxstr[AFS_RXINFO_LEN];
602
603     if (NameIsId(volname)) {
604         return GetEntryByID(rxcall, strtoul(volname, NULL, 10), -1, aentry, new, this_op);
605     }
606     if (InvalidVolname(volname))
607         return VL_BADNAME;
608     if ((code = Init_VLdbase(&ctx, LOCKREAD, this_op)))
609         return code;
610     VLog(5, ("GetVolumeByName %s (%d) %s\n", volname, new, rxinfo(rxstr, rxcall)));
611     blockindex = FindByName(&ctx, volname, &tentry, &code);
612     if (blockindex == 0) {      /* entry not found */
613         if (!code)
614             code = VL_NOENT;
615         goto abort;
616     }
617     if (tentry.flags & VLDELETED) {     /* Entry is deleted */
618         code = VL_ENTDELETED;
619         goto abort;
620     }
621     /* Convert to external entry representation */
622     if (new == 1)
623         code = vlentry_to_nvldbentry(&ctx, &tentry, (struct nvldbentry *)aentry);
624     else if (new == 2)
625         code = vlentry_to_uvldbentry(&ctx, &tentry, (struct uvldbentry *)aentry);
626     else
627         code = vlentry_to_vldbentry(&ctx, &tentry, (struct vldbentry *)aentry);
628
629     if (code)
630         goto abort;
631
632     return (ubik_EndTrans(ctx.trans));
633
634 abort:
635     countAbort(this_op);
636     ubik_AbortTrans(ctx.trans);
637     return code;
638
639 }
640
641 afs_int32
642 SVL_GetEntryByNameO(struct rx_call *rxcall,
643                     char *volname,
644                     struct vldbentry *aentry)   /* entry data copied here */
645 {
646     return (GetEntryByName(rxcall, volname, (char *)aentry, 0,
647                            VLGETENTRYBYNAME));
648 }
649
650
651 afs_int32
652 SVL_GetEntryByNameN(struct rx_call *rxcall,
653                     char *volname,
654                     struct nvldbentry *aentry)  /* entry data copied here */
655 {
656     return (GetEntryByName(rxcall, volname, (char *)aentry, 1,
657                            VLGETENTRYBYNAMEN));
658 }
659
660 afs_int32
661 SVL_GetEntryByNameU(struct rx_call *rxcall,
662                     char *volname,
663                     struct uvldbentry *aentry)  /* entry data copied here */
664 {
665     return (GetEntryByName(rxcall, volname, (char *)aentry, 2,
666                            VLGETENTRYBYNAMEU));
667 }
668
669
670
671 /* Get the current value of the maximum volume id and bump the volume id counter by Maxvolidbump. */
672 afs_int32
673 SVL_GetNewVolumeId(struct rx_call *rxcall, afs_uint32 Maxvolidbump,
674                    afs_uint32 *newvolumeid)
675 {
676     int this_op = VLGETNEWVOLUMEID;
677     afs_int32 code;
678     afs_uint32 maxvolumeid;
679     struct vl_ctx ctx;
680     char rxstr[AFS_RXINFO_LEN];
681
682     countRequest(this_op);
683     if (!afsconf_SuperUser(vldb_confdir, rxcall, NULL))
684         END(VL_PERM);
685
686     if (Maxvolidbump > MAXBUMPCOUNT)
687         END(VL_BADVOLIDBUMP);
688
689     if ((code = Init_VLdbase(&ctx, LOCKWRITE, this_op)))
690         goto end;
691
692     *newvolumeid = maxvolumeid = NextUnusedID(&ctx,
693         ntohl(ctx.cheader->vital_header.MaxVolumeId), Maxvolidbump, &code);
694     if (code) {
695         goto abort;
696     }
697
698     maxvolumeid += Maxvolidbump;
699     VLog(1, ("GetNewVolid newmax=%u %s\n", maxvolumeid, rxinfo(rxstr, rxcall)));
700     ctx.cheader->vital_header.MaxVolumeId = htonl(maxvolumeid);
701     if (write_vital_vlheader(&ctx)) {
702         ABORT(VL_IO);
703     }
704     code = (ubik_EndTrans(ctx.trans));
705     goto end;
706
707   abort:
708     countAbort(this_op);
709     ubik_AbortTrans(ctx.trans);
710
711   end:
712     osi_auditU(rxcall, VLGetNewVolumeIdEvent, code, AUD_END);
713     return code;
714 }
715
716
717 /* Simple replace the contents of the vldb entry, volid, with
718  * newentry. No individual checking/updating per field (alike
719  * VLUpdateEntry) is done. */
720
721 afs_int32
722 SVL_ReplaceEntry(struct rx_call *rxcall, afs_uint32 volid, afs_int32 voltype,
723                  struct vldbentry *newentry, afs_int32 releasetype)
724 {
725     int this_op = VLREPLACEENTRY;
726     struct vl_ctx ctx;
727     afs_int32 blockindex, code, typeindex;
728     int hashnewname;
729     int hashVol[MAXTYPES];
730     struct nvlentry tentry;
731     afs_uint32 checkids[MAXTYPES];
732     char rxstr[AFS_RXINFO_LEN];
733
734     countRequest(this_op);
735     for (typeindex = 0; typeindex < MAXTYPES; typeindex++)
736         hashVol[typeindex] = 0;
737     hashnewname = 0;
738     if (!afsconf_SuperUser(vldb_confdir, rxcall, NULL))
739         END(VL_PERM);
740
741     if ((code = check_vldbentry(newentry)))
742         goto end;
743
744     if (voltype != -1 && InvalidVoltype(voltype))
745         END(VL_BADVOLTYPE);
746
747     if (releasetype && InvalidReleasetype(releasetype))
748         END(VL_BADRELLOCKTYPE);
749     if ((code = Init_VLdbase(&ctx, LOCKWRITE, this_op)))
750         goto end;
751
752     VLog(1, ("OReplace Volume %u %s\n", volid, rxinfo(rxstr, rxcall)));
753     /* find vlentry we're changing */
754     blockindex = FindByID(&ctx, volid, voltype, &tentry, &code);
755     if (blockindex == 0) {      /* entry not found */
756         if (!code)
757             code = VL_NOENT;
758         goto abort;
759     }
760
761     /* check that we're not trying to change the RW vol ID */
762     if (newentry->volumeId[RWVOL] != tentry.volumeId[RWVOL]) {
763         ABORT(VL_BADENTRY);
764     }
765
766     /* make sure none of the IDs we are changing to are already in use */
767     memset(&checkids, 0, sizeof(checkids));
768     for (typeindex = ROVOL; typeindex < MAXTYPES; typeindex++) {
769         if (tentry.volumeId[typeindex] != newentry->volumeId[typeindex]) {
770             checkids[typeindex] = newentry->volumeId[typeindex];
771         }
772     }
773     if (EntryIDExists(&ctx, checkids, MAXTYPES, &code)) {
774         ABORT(VL_IDEXIST);
775     } else if (code) {
776         goto abort;
777     }
778
779     /* make sure the name we're changing to doesn't already exist */
780     if (strcmp(newentry->name, tentry.name)) {
781         struct nvlentry tmp_entry;
782         if (FindByName(&ctx, newentry->name, &tmp_entry, &code)) {
783             ABORT(VL_NAMEEXIST);
784         } else if (code) {
785             goto abort;
786         }
787     }
788
789     /* unhash volid entries if they're disappearing or changing.
790      * Remember if we need to hash in the new value (we don't have to
791      * rehash if volid stays same */
792     for (typeindex = ROVOL; typeindex <= BACKVOL; typeindex++) {
793         if (tentry.volumeId[typeindex] != newentry->volumeId[typeindex]) {
794             if (tentry.volumeId[typeindex])
795                 if ((code =
796                     UnhashVolid(&ctx, typeindex, blockindex, &tentry))) {
797                     goto abort;
798                 }
799             /* we must rehash new id if the id is different and the ID is nonzero */
800             hashVol[typeindex] = 1;     /* must rehash this guy if he exists */
801         }
802     }
803
804     /* Rehash volname if it changes */
805     if (strcmp(newentry->name, tentry.name)) {  /* Name changes; redo hashing */
806         if ((code = UnhashVolname(&ctx, blockindex, &tentry))) {
807             goto abort;
808         }
809         hashnewname = 1;
810     }
811
812     /* after this, tentry is new entry, not old one.  vldbentry_to_vlentry
813      * doesn't touch hash chains */
814     if ((code = vldbentry_to_vlentry(&ctx, newentry, &tentry))) {
815         goto abort;
816     }
817
818     for (typeindex = ROVOL; typeindex <= BACKVOL; typeindex++) {
819         if (hashVol[typeindex] && tentry.volumeId[typeindex]) {
820             if ((code = HashVolid(&ctx, typeindex, blockindex, &tentry))) {
821                 goto abort;
822             }
823         }
824     }
825
826     if (hashnewname)
827         HashVolname(&ctx, blockindex, &tentry);
828
829     if (releasetype)
830         ReleaseEntry(&tentry, releasetype);     /* Unlock entry if necessary */
831     if (vlentrywrite(ctx.trans, blockindex, &tentry, sizeof(tentry))) {
832         ABORT(VL_IO);
833     }
834
835     END(ubik_EndTrans(ctx.trans));
836
837   abort:
838     countAbort(this_op);
839     ubik_AbortTrans(ctx.trans);
840
841   end:
842     osi_auditU(rxcall, VLReplaceVLEntryEvent, code, AUD_LONG, volid,
843                AUD_END);
844     return code;
845 }
846
847 afs_int32
848 SVL_ReplaceEntryN(struct rx_call *rxcall, afs_uint32 volid, afs_int32 voltype,
849                   struct nvldbentry *newentry, afs_int32 releasetype)
850 {
851     int this_op = VLREPLACEENTRYN;
852     struct vl_ctx ctx;
853     afs_int32 blockindex, code, typeindex;
854     int hashnewname;
855     int hashVol[MAXTYPES];
856     struct nvlentry tentry;
857     char rxstr[AFS_RXINFO_LEN];
858
859     countRequest(this_op);
860     for (typeindex = 0; typeindex < MAXTYPES; typeindex++)
861         hashVol[typeindex] = 0;
862     hashnewname = 0;
863     if (!afsconf_SuperUser(vldb_confdir, rxcall, NULL))
864         END(VL_PERM);
865
866     if ((code = check_nvldbentry(newentry)))
867         goto end;
868
869     if (voltype != -1 && InvalidVoltype(voltype))
870         END(VL_BADVOLTYPE);
871
872     if (releasetype && InvalidReleasetype(releasetype))
873         END(VL_BADRELLOCKTYPE);
874     if ((code = Init_VLdbase(&ctx, LOCKWRITE, this_op)))
875         goto end;
876
877     VLog(1, ("Replace Volume %u %s\n", volid, rxinfo(rxstr, rxcall)));
878     /* find vlentry we're changing */
879     blockindex = FindByID(&ctx, volid, voltype, &tentry, &code);
880     if (blockindex == 0) {      /* entry not found */
881         if (!code)
882             code = VL_NOENT;
883         goto abort;
884     }
885
886     /* check that we're not trying to change the RW vol ID */
887     if (newentry->volumeId[RWVOL] != tentry.volumeId[RWVOL]) {
888         ABORT(VL_BADENTRY);
889     }
890
891     /* unhash volid entries if they're disappearing or changing.
892      * Remember if we need to hash in the new value (we don't have to
893      * rehash if volid stays same */
894     for (typeindex = ROVOL; typeindex <= BACKVOL; typeindex++) {
895         if (tentry.volumeId[typeindex] != newentry->volumeId[typeindex]) {
896             if (tentry.volumeId[typeindex])
897                 if ((code =
898                     UnhashVolid(&ctx, typeindex, blockindex, &tentry))) {
899                     goto abort;
900                 }
901             /* we must rehash new id if the id is different and the ID is nonzero */
902             hashVol[typeindex] = 1;     /* must rehash this guy if he exists */
903         }
904     }
905
906     /* Rehash volname if it changes */
907     if (strcmp(newentry->name, tentry.name)) {  /* Name changes; redo hashing */
908         if ((code = UnhashVolname(&ctx, blockindex, &tentry))) {
909             goto abort;
910         }
911         hashnewname = 1;
912     }
913
914     /* after this, tentry is new entry, not old one.  vldbentry_to_vlentry
915      * doesn't touch hash chains */
916     if ((code = nvldbentry_to_vlentry(&ctx, newentry, &tentry))) {
917         goto abort;
918     }
919
920     for (typeindex = ROVOL; typeindex <= BACKVOL; typeindex++) {
921         if (hashVol[typeindex] && tentry.volumeId[typeindex]) {
922             if ((code = HashVolid(&ctx, typeindex, blockindex, &tentry))) {
923                 goto abort;
924             }
925         }
926     }
927
928     if (hashnewname)
929         HashVolname(&ctx, blockindex, &tentry);
930
931     if (releasetype)
932         ReleaseEntry(&tentry, releasetype);     /* Unlock entry if necessary */
933     if (vlentrywrite(ctx.trans, blockindex, &tentry, sizeof(tentry))) {
934         ABORT(VL_IO);
935     }
936
937     END(ubik_EndTrans(ctx.trans));
938
939   abort:
940     countAbort(this_op);
941     ubik_AbortTrans(ctx.trans);
942
943   end:
944     osi_auditU(rxcall, VLReplaceVLEntryEvent, code, AUD_LONG, volid,
945                AUD_END);
946     return code;
947 }
948
949
950 /* Update a vldb entry (accessed thru its volume id). Almost all of the
951  * entry's fields can be modified in a single call by setting the
952  * appropriate bits in the Mask field in VldbUpdateentry. */
953 /* this routine may never have been tested; use replace entry instead
954  * unless you're brave */
955 afs_int32
956 SVL_UpdateEntry(struct rx_call *rxcall,
957                 afs_uint32 volid,
958                 afs_int32 voltype,
959                 struct VldbUpdateEntry *updateentry,    /* Update entry copied here */
960                 afs_int32 releasetype)
961 {
962     int this_op = VLUPDATEENTRY;
963     struct vl_ctx ctx;
964     afs_int32 blockindex, code;
965     struct nvlentry tentry;
966     char rxstr[AFS_RXINFO_LEN];
967
968     countRequest(this_op);
969     if (!afsconf_SuperUser(vldb_confdir, rxcall, NULL))
970         END(VL_PERM);
971     if ((voltype != -1) && (InvalidVoltype(voltype)))
972         END(VL_BADVOLTYPE);
973     if (releasetype && InvalidReleasetype(releasetype))
974         END(VL_BADRELLOCKTYPE);
975     if ((code = Init_VLdbase(&ctx, LOCKWRITE, this_op)))
976         goto end;
977
978     VLog(1, ("Update Volume %u %s\n", volid, rxinfo(rxstr, rxcall)));
979     blockindex = FindByID(&ctx, volid, voltype, &tentry, &code);
980     if (blockindex == 0) {      /* entry not found */
981         if (!code)
982             code = VL_NOENT;
983         goto abort;
984     }
985
986     /* Do the actual updating of the entry, tentry. */
987     if ((code =
988         get_vldbupdateentry(&ctx, blockindex, updateentry, &tentry))) {
989         goto abort;
990     }
991     if (releasetype)
992         ReleaseEntry(&tentry, releasetype);     /* Unlock entry if necessary */
993     if (vlentrywrite(ctx.trans, blockindex, &tentry, sizeof(tentry))) {
994         ABORT(VL_IO);
995     }
996     END(ubik_EndTrans(ctx.trans));
997
998   abort:
999     countAbort(this_op);
1000     ubik_AbortTrans(ctx.trans);
1001
1002   end:
1003     osi_auditU(rxcall, VLUpdateEntryEvent, code, AUD_LONG, volid,
1004                AUD_END);
1005     return code;
1006 }
1007
1008
1009 afs_int32
1010 SVL_UpdateEntryByName(struct rx_call *rxcall,
1011                       char *volname,
1012                       struct VldbUpdateEntry *updateentry, /* Update entry copied here */
1013                       afs_int32 releasetype)
1014 {
1015     int this_op = VLUPDATEENTRYBYNAME;
1016     struct vl_ctx ctx;
1017     afs_int32 blockindex, code;
1018     struct nvlentry tentry;
1019
1020     countRequest(this_op);
1021     if (!afsconf_SuperUser(vldb_confdir, rxcall, NULL))
1022         END(VL_PERM);
1023     if (releasetype && InvalidReleasetype(releasetype))
1024         END(VL_BADRELLOCKTYPE);
1025     if ((code = Init_VLdbase(&ctx, LOCKWRITE, this_op)))
1026         goto end;
1027
1028     blockindex = FindByName(&ctx, volname, &tentry, &code);
1029     if (blockindex == 0) {      /* entry not found */
1030         if (!code)
1031             code = VL_NOENT;
1032         goto abort;
1033     }
1034
1035     /* Do the actual updating of the entry, tentry. */
1036     if ((code =
1037         get_vldbupdateentry(&ctx, blockindex, updateentry, &tentry))) {
1038         goto abort;
1039     }
1040     if (releasetype)
1041         ReleaseEntry(&tentry, releasetype);     /* Unlock entry if necessary */
1042     if (vlentrywrite(ctx.trans, blockindex, &tentry, sizeof(tentry))) {
1043         ABORT(VL_IO);
1044     }
1045     END(ubik_EndTrans(ctx.trans));
1046
1047   abort:
1048     countAbort(this_op);
1049     ubik_AbortTrans(ctx.trans);
1050
1051   end:
1052     osi_auditU(rxcall, VLUpdateEntryEvent, code, AUD_LONG, -1, AUD_END);
1053     return code;
1054 }
1055
1056
1057 /* Set a lock to the vldb entry for volid (of type voltype if not -1). */
1058 afs_int32
1059 SVL_SetLock(struct rx_call *rxcall, afs_uint32 volid, afs_int32 voltype,
1060             afs_int32 voloper)
1061 {
1062     int this_op = VLSETLOCK;
1063     afs_int32 timestamp, blockindex, code;
1064     struct vl_ctx ctx;
1065     struct nvlentry tentry;
1066     char rxstr[AFS_RXINFO_LEN];
1067
1068     countRequest(this_op);
1069     if (!afsconf_SuperUser(vldb_confdir, rxcall, NULL))
1070         END(VL_PERM);
1071     if ((voltype != -1) && (InvalidVoltype(voltype)))
1072         END(VL_BADVOLTYPE);
1073     if (InvalidOperation(voloper))
1074         END(VL_BADVOLOPER);
1075     if ((code = Init_VLdbase(&ctx, LOCKWRITE, this_op)))
1076         goto end;
1077
1078     VLog(1, ("SetLock Volume %u %s\n", volid, rxinfo(rxstr, rxcall)));
1079     blockindex = FindByID(&ctx, volid, voltype, &tentry, &code);
1080     if (blockindex == NULLO) {
1081         if (!code)
1082             code = VL_NOENT;
1083         goto abort;
1084     }
1085     if (tentry.flags & VLDELETED) {
1086         ABORT(VL_ENTDELETED);
1087     }
1088     timestamp = FT_ApproxTime();
1089
1090     /* Check if entry is already locked; note that we unlock any entry
1091      * locked more than MAXLOCKTIME seconds */
1092     if ((tentry.LockTimestamp)
1093         && ((timestamp - tentry.LockTimestamp) < MAXLOCKTIME)) {
1094         ABORT(VL_ENTRYLOCKED);
1095     }
1096
1097     /* Consider it an unlocked entry: set current timestamp, caller
1098      * and active vol operation */
1099     tentry.LockTimestamp = timestamp;
1100     tentry.LockAfsId = 0;       /* Not implemented yet */
1101     if (tentry.flags & VLOP_RELEASE) {
1102         ABORT(VL_RERELEASE);
1103     }
1104     tentry.flags &= ~VLOP_ALLOPERS;     /* Clear any possible older operation bit */
1105     tentry.flags |= voloper;
1106
1107     if (vlentrywrite(ctx.trans, blockindex, &tentry, sizeof(tentry))) {
1108         ABORT(VL_IO);
1109     }
1110     END(ubik_EndTrans(ctx.trans));
1111
1112   abort:
1113     countAbort(this_op);
1114     ubik_AbortTrans(ctx.trans);
1115
1116   end:
1117     osi_auditU(rxcall, VLSetLockEvent, code, AUD_LONG, volid, AUD_END);
1118     return code;
1119 }
1120
1121
1122 /* Release an already locked vldb entry. Releasetype determines what
1123  * fields (afsid and/or volume operation) will be cleared along with
1124  * the lock time stamp. */
1125
1126 afs_int32
1127 SVL_ReleaseLock(struct rx_call *rxcall, afs_uint32 volid, afs_int32 voltype,
1128                 afs_int32 releasetype)
1129 {
1130     int this_op = VLRELEASELOCK;
1131     afs_int32 blockindex, code;
1132     struct vl_ctx ctx;
1133     struct nvlentry tentry;
1134     char rxstr[AFS_RXINFO_LEN];
1135
1136     countRequest(this_op);
1137     if (!afsconf_SuperUser(vldb_confdir, rxcall, NULL))
1138         END(VL_PERM);
1139     if ((voltype != -1) && (InvalidVoltype(voltype)))
1140         END(VL_BADVOLTYPE);
1141     if (releasetype && InvalidReleasetype(releasetype))
1142         END(VL_BADRELLOCKTYPE);
1143     if ((code = Init_VLdbase(&ctx, LOCKWRITE, this_op)))
1144         goto end;
1145
1146     VLog(1, ("ReleaseLock Volume %u %s\n", volid, rxinfo(rxstr, rxcall)));
1147     blockindex = FindByID(&ctx, volid, voltype, &tentry, &code);
1148     if (blockindex == NULLO) {
1149         if (!code)
1150             code = VL_NOENT;
1151         goto abort;
1152     }
1153     if (tentry.flags & VLDELETED) {
1154         ABORT(VL_ENTDELETED);
1155     }
1156     if (releasetype)
1157         ReleaseEntry(&tentry, releasetype);     /* Unlock the appropriate fields */
1158     if (vlentrywrite(ctx.trans, blockindex, &tentry, sizeof(tentry))) {
1159         ABORT(VL_IO);
1160     }
1161     END(ubik_EndTrans(ctx.trans));
1162
1163   abort:
1164     countAbort(this_op);
1165     ubik_AbortTrans(ctx.trans);
1166
1167   end:
1168     osi_auditU(rxcall, VLReleaseLockEvent, code, AUD_LONG, volid,
1169                AUD_END);
1170     return code;
1171 }
1172
1173
1174 /* ListEntry returns a single vldb entry, aentry, with offset previous_index;
1175  * the remaining parameters (i.e. next_index) are used so that sequential
1176  * calls to this routine will get the next (all) vldb entries.
1177  */
1178 afs_int32
1179 SVL_ListEntry(struct rx_call *rxcall, afs_int32 previous_index,
1180               afs_int32 *count, afs_int32 *next_index,
1181               struct vldbentry *aentry)
1182 {
1183     int this_op = VLLISTENTRY;
1184     int code;
1185     struct vl_ctx ctx;
1186     struct nvlentry tentry;
1187     char rxstr[AFS_RXINFO_LEN];
1188
1189     countRequest(this_op);
1190     if ((code = Init_VLdbase(&ctx, LOCKREAD, this_op)))
1191         return code;
1192     VLog(25, ("OListEntry index=%d %s\n", previous_index,
1193               rxinfo(rxstr, rxcall)));
1194     *next_index = NextEntry(&ctx, previous_index, &tentry, count);
1195     if (*next_index) {
1196         code = vlentry_to_vldbentry(&ctx, &tentry, aentry);
1197         if (code) {
1198             countAbort(this_op);
1199             ubik_AbortTrans(ctx.trans);
1200             return code;
1201         }
1202     }
1203     return (ubik_EndTrans(ctx.trans));
1204 }
1205
1206 /* ListEntry returns a single vldb entry, aentry, with offset previous_index;
1207  * the remaining parameters (i.e. next_index) are used so that sequential
1208  * calls to this routine will get the next (all) vldb entries.
1209  */
1210 afs_int32
1211 SVL_ListEntryN(struct rx_call *rxcall, afs_int32 previous_index,
1212                afs_int32 *count, afs_int32 *next_index,
1213                struct nvldbentry *aentry)
1214 {
1215     int this_op = VLLISTENTRYN;
1216     int code;
1217     struct vl_ctx ctx;
1218     struct nvlentry tentry;
1219     char rxstr[AFS_RXINFO_LEN];
1220
1221     countRequest(this_op);
1222     if ((code = Init_VLdbase(&ctx, LOCKREAD, this_op)))
1223         return code;
1224     VLog(25, ("ListEntry index=%d %s\n", previous_index, rxinfo(rxstr, rxcall)));
1225     *next_index = NextEntry(&ctx, previous_index, &tentry, count);
1226     if (*next_index) {
1227         code = vlentry_to_nvldbentry(&ctx, &tentry, aentry);
1228         if (code) {
1229             countAbort(this_op);
1230             ubik_AbortTrans(ctx.trans);
1231             return code;
1232         }
1233     }
1234
1235     return (ubik_EndTrans(ctx.trans));
1236 }
1237
1238
1239 /* Retrieves in vldbentries all vldb entries that match the specified
1240  * attributes (by server number, partition, volume type, and flag); if volume
1241  * id is specified then the associated list for that entry is returned.
1242  * CAUTION: This could be a very expensive call since in most cases
1243  * sequential search of all vldb entries is performed.
1244  */
1245 afs_int32
1246 SVL_ListAttributes(struct rx_call *rxcall,
1247                    struct VldbListByAttributes *attributes,
1248                    afs_int32 *nentries,
1249                    bulkentries *vldbentries)
1250 {
1251     int this_op = VLLISTATTRIBUTES;
1252     int code, allocCount = 0;
1253     struct vl_ctx ctx;
1254     struct nvlentry tentry;
1255     struct vldbentry *Vldbentry = 0, *VldbentryFirst = 0, *VldbentryLast = 0;
1256     int pollcount = 0;
1257     char rxstr[AFS_RXINFO_LEN];
1258
1259     countRequest(this_op);
1260     vldbentries->bulkentries_val = 0;
1261     vldbentries->bulkentries_len = *nentries = 0;
1262     if ((code = Init_VLdbase(&ctx, LOCKREAD, this_op)))
1263         return code;
1264     allocCount = VLDBALLOCCOUNT;
1265     Vldbentry = VldbentryFirst = vldbentries->bulkentries_val =
1266         malloc(allocCount * sizeof(vldbentry));
1267     if (Vldbentry == NULL) {
1268         code = VL_NOMEM;
1269         goto abort;
1270     }
1271     VldbentryLast = VldbentryFirst + allocCount;
1272     /* Handle the attribute by volume id totally separate of the rest
1273      * (thus additional Mask values are ignored if VLLIST_VOLUMEID is set!) */
1274     if (attributes->Mask & VLLIST_VOLUMEID) {
1275         afs_int32 blockindex;
1276
1277         blockindex =
1278             FindByID(&ctx, attributes->volumeid, -1, &tentry, &code);
1279         if (blockindex == 0) {
1280             if (!code)
1281                 code = VL_NOENT;
1282             goto abort;
1283         }
1284
1285         code = put_attributeentry(&ctx, &Vldbentry, &VldbentryFirst,
1286                                   &VldbentryLast, vldbentries, &tentry,
1287                                   nentries, &allocCount);
1288         if (code)
1289             goto abort;
1290     } else {
1291         afs_int32 nextblockindex = 0, count = 0, k = 0, match = 0;
1292         while ((nextblockindex =
1293                NextEntry(&ctx, nextblockindex, &tentry, &count))) {
1294             if (++pollcount > 50) {
1295 #ifndef AFS_PTHREAD_ENV
1296                 IOMGR_Poll();
1297 #endif
1298                 pollcount = 0;
1299             }
1300             match = 0;
1301             if (attributes->Mask & VLLIST_SERVER) {
1302                 int serverindex;
1303                 if ((serverindex =
1304                      IpAddrToRelAddr(&ctx, attributes->server, 0)) == -1)
1305                     continue;
1306                 for (k = 0; k < OMAXNSERVERS; k++) {
1307                     if (tentry.serverNumber[k] == BADSERVERID)
1308                         break;
1309                     if (tentry.serverNumber[k] == serverindex) {
1310                         match = 1;
1311                         break;
1312                     }
1313                 }
1314                 if (!match)
1315                     continue;
1316             }
1317             if (attributes->Mask & VLLIST_PARTITION) {
1318                 if (match) {
1319                     if (tentry.serverPartition[k] != attributes->partition)
1320                         continue;
1321                 } else {
1322                     for (k = 0; k < OMAXNSERVERS; k++) {
1323                         if (tentry.serverNumber[k] == BADSERVERID)
1324                             break;
1325                         if (tentry.serverPartition[k] ==
1326                             attributes->partition) {
1327                             match = 1;
1328                             break;
1329                         }
1330                     }
1331                     if (!match)
1332                         continue;
1333                 }
1334             }
1335
1336             if (attributes->Mask & VLLIST_FLAG) {
1337                 if (!(tentry.flags & attributes->flag))
1338                     continue;
1339             }
1340             code = put_attributeentry(&ctx, &Vldbentry, &VldbentryFirst,
1341                                       &VldbentryLast, vldbentries, &tentry,
1342                                       nentries, &allocCount);
1343             if (code)
1344                 goto abort;
1345         }
1346     }
1347     if (vldbentries->bulkentries_len
1348         && (allocCount > vldbentries->bulkentries_len)) {
1349
1350         vldbentries->bulkentries_val =
1351             realloc(vldbentries->bulkentries_val,
1352                     vldbentries->bulkentries_len * sizeof(vldbentry));
1353         if (vldbentries->bulkentries_val == NULL) {
1354             code = VL_NOMEM;
1355             goto abort;
1356         }
1357     }
1358     VLog(5,
1359          ("ListAttrs nentries=%d %s\n", vldbentries->bulkentries_len,
1360           rxinfo(rxstr, rxcall)));
1361     return (ubik_EndTrans(ctx.trans));
1362
1363 abort:
1364     if (vldbentries->bulkentries_val)
1365         free(vldbentries->bulkentries_val);
1366     vldbentries->bulkentries_val = 0;
1367     vldbentries->bulkentries_len = 0;
1368
1369     countAbort(this_op);
1370     ubik_AbortTrans(ctx.trans);
1371
1372     return code;
1373 }
1374
1375 afs_int32
1376 SVL_ListAttributesN(struct rx_call *rxcall,
1377                     struct VldbListByAttributes *attributes,
1378                     afs_int32 *nentries,
1379                     nbulkentries *vldbentries)
1380 {
1381     int this_op = VLLISTATTRIBUTESN;
1382     int code, allocCount = 0;
1383     struct vl_ctx ctx;
1384     struct nvlentry tentry;
1385     struct nvldbentry *Vldbentry = 0, *VldbentryFirst = 0, *VldbentryLast = 0;
1386     int pollcount = 0;
1387     char rxstr[AFS_RXINFO_LEN];
1388
1389     countRequest(this_op);
1390     vldbentries->nbulkentries_val = 0;
1391     vldbentries->nbulkentries_len = *nentries = 0;
1392     if ((code = Init_VLdbase(&ctx, LOCKREAD, this_op)))
1393         return code;
1394     allocCount = VLDBALLOCCOUNT;
1395     Vldbentry = VldbentryFirst = vldbentries->nbulkentries_val =
1396         malloc(allocCount * sizeof(nvldbentry));
1397     if (Vldbentry == NULL) {
1398         code = VL_NOMEM;
1399         goto abort;
1400     }
1401     VldbentryLast = VldbentryFirst + allocCount;
1402     /* Handle the attribute by volume id totally separate of the rest
1403      * (thus additional Mask values are ignored if VLLIST_VOLUMEID is set!) */
1404     if (attributes->Mask & VLLIST_VOLUMEID) {
1405         afs_int32 blockindex;
1406
1407         blockindex =
1408             FindByID(&ctx, attributes->volumeid, -1, &tentry, &code);
1409         if (blockindex == 0) {
1410             if (!code)
1411                 code = VL_NOENT;
1412             goto abort;
1413         }
1414
1415         code = put_nattributeentry(&ctx, &Vldbentry, &VldbentryFirst,
1416                                    &VldbentryLast, vldbentries, &tentry,
1417                                    0, 0, nentries, &allocCount);
1418         if (code)
1419             goto abort;
1420     } else {
1421         afs_int32 nextblockindex = 0, count = 0, k = 0, match = 0;
1422         while ((nextblockindex =
1423                NextEntry(&ctx, nextblockindex, &tentry, &count))) {
1424             if (++pollcount > 50) {
1425 #ifndef AFS_PTHREAD_ENV
1426                 IOMGR_Poll();
1427 #endif
1428                 pollcount = 0;
1429             }
1430
1431             match = 0;
1432             if (attributes->Mask & VLLIST_SERVER) {
1433                 int serverindex;
1434                 if ((serverindex =
1435                      IpAddrToRelAddr(&ctx, attributes->server, 0)) == -1)
1436                     continue;
1437                 for (k = 0; k < NMAXNSERVERS; k++) {
1438                     if (tentry.serverNumber[k] == BADSERVERID)
1439                         break;
1440                     if (tentry.serverNumber[k] == serverindex) {
1441                         match = 1;
1442                         break;
1443                     }
1444                 }
1445                 if (!match)
1446                     continue;
1447             }
1448             if (attributes->Mask & VLLIST_PARTITION) {
1449                 if (match) {
1450                     if (tentry.serverPartition[k] != attributes->partition)
1451                         continue;
1452                 } else {
1453                     for (k = 0; k < NMAXNSERVERS; k++) {
1454                         if (tentry.serverNumber[k] == BADSERVERID)
1455                             break;
1456                         if (tentry.serverPartition[k] ==
1457                             attributes->partition) {
1458                             match = 1;
1459                             break;
1460                         }
1461                     }
1462                     if (!match)
1463                         continue;
1464                 }
1465             }
1466
1467             if (attributes->Mask & VLLIST_FLAG) {
1468                 if (!(tentry.flags & attributes->flag))
1469                     continue;
1470             }
1471             code = put_nattributeentry(&ctx, &Vldbentry, &VldbentryFirst,
1472                                        &VldbentryLast, vldbentries,
1473                                        &tentry, 0, 0, nentries, &allocCount);
1474             if (code)
1475                 goto abort;
1476         }
1477     }
1478     if (vldbentries->nbulkentries_len
1479         && (allocCount > vldbentries->nbulkentries_len)) {
1480
1481         vldbentries->nbulkentries_val =
1482             realloc(vldbentries->nbulkentries_val,
1483                     vldbentries->nbulkentries_len * sizeof(nvldbentry));
1484         if (vldbentries->nbulkentries_val == NULL) {
1485             code = VL_NOMEM;
1486             goto abort;
1487         }
1488     }
1489     VLog(5,
1490          ("NListAttrs nentries=%d %s\n", vldbentries->nbulkentries_len,
1491           rxinfo(rxstr, rxcall)));
1492     return (ubik_EndTrans(ctx.trans));
1493
1494 abort:
1495     countAbort(this_op);
1496     ubik_AbortTrans(ctx.trans);
1497     if (vldbentries->nbulkentries_val)
1498         free(vldbentries->nbulkentries_val);
1499     vldbentries->nbulkentries_val = 0;
1500     vldbentries->nbulkentries_len = 0;
1501     return code;
1502 }
1503
1504
1505 afs_int32
1506 SVL_ListAttributesN2(struct rx_call *rxcall,
1507                      struct VldbListByAttributes *attributes,
1508                      char *name,                /* Wildcarded volume name */
1509                      afs_int32 startindex,
1510                      afs_int32 *nentries,
1511                      nbulkentries *vldbentries,
1512                      afs_int32 *nextstartindex)
1513 {
1514     int this_op = VLLISTATTRIBUTESN2;
1515     int code = 0, maxCount = VLDBALLOCCOUNT;
1516     struct vl_ctx ctx;
1517     struct nvlentry tentry;
1518     struct nvldbentry *Vldbentry = 0, *VldbentryFirst = 0, *VldbentryLast = 0;
1519     afs_int32 blockindex = 0, count = 0, k, match;
1520     afs_int32 matchindex = 0;
1521     int serverindex = -1;       /* no server found */
1522     int findserver = 0, findpartition = 0, findflag = 0, findname = 0;
1523     int pollcount = 0;
1524     int namematchRWBK, namematchRO, thismatch;
1525     int matchtype = 0;
1526     char volumename[VL_MAXNAMELEN+2]; /* regex anchors */
1527     char rxstr[AFS_RXINFO_LEN];
1528 #ifdef HAVE_POSIX_REGEX
1529     regex_t re;
1530     int need_regfree = 0;
1531 #else
1532     char *t;
1533 #endif
1534
1535     countRequest(this_op);
1536     vldbentries->nbulkentries_val = 0;
1537     vldbentries->nbulkentries_len = 0;
1538     *nentries = 0;
1539     *nextstartindex = -1;
1540
1541     code = Init_VLdbase(&ctx, LOCKREAD, this_op);
1542     if (code)
1543         return code;
1544
1545     Vldbentry = VldbentryFirst = vldbentries->nbulkentries_val =
1546         malloc(maxCount * sizeof(nvldbentry));
1547     if (Vldbentry == NULL) {
1548         countAbort(this_op);
1549         ubik_AbortTrans(ctx.trans);
1550         return VL_NOMEM;
1551     }
1552
1553     VldbentryLast = VldbentryFirst + maxCount;
1554
1555     /* Handle the attribute by volume id totally separate of the rest
1556      * (thus additional Mask values are ignored if VLLIST_VOLUMEID is set!)
1557      */
1558     if (attributes->Mask & VLLIST_VOLUMEID) {
1559         blockindex =
1560             FindByID(&ctx, attributes->volumeid, -1, &tentry, &code);
1561         if (blockindex == 0) {
1562             if (!code)
1563                 code = VL_NOENT;
1564         } else {
1565             code =
1566                 put_nattributeentry(&ctx, &Vldbentry, &VldbentryFirst,
1567                                     &VldbentryLast, vldbentries, &tentry, 0,
1568                                     0, nentries, &maxCount);
1569             if (code)
1570                 goto done;
1571         }
1572     }
1573
1574     /* Search each entry in the database and return all entries
1575      * that match the request. It checks volumename (with
1576      * wildcarding), entry flags, server, and partition.
1577      */
1578     else {
1579         /* Get the server index for matching server address */
1580         if (attributes->Mask & VLLIST_SERVER) {
1581             serverindex =
1582                 IpAddrToRelAddr(&ctx, attributes->server, 0);
1583             if (serverindex == -1)
1584                 goto done;
1585             findserver = 1;
1586         }
1587         findpartition = ((attributes->Mask & VLLIST_PARTITION) ? 1 : 0);
1588         findflag = ((attributes->Mask & VLLIST_FLAG) ? 1 : 0);
1589         if (name && (strcmp(name, ".*") != 0) && (strcmp(name, "") != 0)) {
1590             sprintf(volumename, "^%s$", name);
1591 #ifdef HAVE_POSIX_REGEX
1592             if (regcomp(&re, volumename, REG_NOSUB) != 0) {
1593                 code = VL_BADNAME;
1594                 goto done;
1595             }
1596             need_regfree = 1;
1597 #else
1598             t = (char *)re_comp(volumename);
1599             if (t) {
1600                 code = VL_BADNAME;
1601                 goto done;
1602             }
1603 #endif
1604             findname = 1;
1605         }
1606
1607         /* Read each entry and see if it is the one we want */
1608         blockindex = startindex;
1609         while ((blockindex = NextEntry(&ctx, blockindex, &tentry, &count))) {
1610             if (++pollcount > 50) {
1611 #ifndef AFS_PTHREAD_ENV
1612                 IOMGR_Poll();
1613 #endif
1614                 pollcount = 0;
1615             }
1616
1617             /* Step through each server index searching for a match.
1618              * Match to an existing RW, BK, or RO volume name (preference
1619              * is in this order). Remember which index we matched against.
1620              */
1621             namematchRWBK = namematchRO = 0;    /* 0->notTried; 1->match; 2->noMatch */
1622             match = 0;
1623             for (k = 0;
1624                  (k < NMAXNSERVERS
1625                   && (tentry.serverNumber[k] != BADSERVERID)); k++) {
1626                 thismatch = 0;  /* does this index match */
1627
1628                 /* Match against the RW or BK volume name. Remember
1629                  * results in namematchRWBK. Prefer RW over BK.
1630                  */
1631                 if (tentry.serverFlags[k] & VLSF_RWVOL) {
1632                     /* Does the name match the RW name */
1633                     if (tentry.flags & VLF_RWEXISTS) {
1634                         if (findname) {
1635                             sprintf(volumename, "%s", tentry.name);
1636 #ifdef HAVE_POSIX_REGEX
1637                             if (regexec(&re, volumename, 0, NULL, 0) == 0) {
1638                                 thismatch = VLSF_RWVOL;
1639                             }
1640 #else
1641                             if (re_exec(volumename)) {
1642                                 thismatch = VLSF_RWVOL;
1643                             }
1644 #endif
1645                         } else {
1646                             thismatch = VLSF_RWVOL;
1647                         }
1648                     }
1649
1650                     /* Does the name match the BK name */
1651                     if (!thismatch && (tentry.flags & VLF_BACKEXISTS)) {
1652                         if (findname) {
1653                             sprintf(volumename, "%s.backup", tentry.name);
1654 #ifdef HAVE_POSIX_REGEX
1655                             if (regexec(&re, volumename, 0, NULL, 0) == 0) {
1656                                 thismatch = VLSF_BACKVOL;
1657                             }
1658 #else
1659                             if (re_exec(volumename)) {
1660                                 thismatch = VLSF_BACKVOL;
1661                             }
1662 #endif
1663                         } else {
1664                             thismatch = VLSF_BACKVOL;
1665                         }
1666                     }
1667
1668                     namematchRWBK = (thismatch ? 1 : 2);
1669                 }
1670
1671                 /* Match with the RO volume name. Compare once and
1672                  * remember results in namematchRO. Note that this will
1673                  * pick up entries marked NEWREPSITEs and DONTUSE.
1674                  */
1675                 else {
1676                     if (tentry.flags & VLF_ROEXISTS) {
1677                         if (findname) {
1678                             if (namematchRO) {
1679                                 thismatch =
1680                                     ((namematchRO == 1) ? VLSF_ROVOL : 0);
1681                             } else {
1682                                 sprintf(volumename, "%s.readonly",
1683                                         tentry.name);
1684 #ifdef HAVE_POSIX_REGEX
1685                             if (regexec(&re, volumename, 0, NULL, 0) == 0) {
1686                                 thismatch = VLSF_ROVOL;
1687                             }
1688 #else
1689                                 if (re_exec(volumename))
1690                                     thismatch = VLSF_ROVOL;
1691 #endif
1692                             }
1693                         } else {
1694                             thismatch = VLSF_ROVOL;
1695                         }
1696                     }
1697                     namematchRO = (thismatch ? 1 : 2);
1698                 }
1699
1700                 /* Is there a server match */
1701                 if (thismatch && findserver
1702                     && (tentry.serverNumber[k] != serverindex))
1703                     thismatch = 0;
1704
1705                 /* Is there a partition match */
1706                 if (thismatch && findpartition
1707                     && (tentry.serverPartition[k] != attributes->partition))
1708                     thismatch = 0;
1709
1710                 /* Is there a flag match */
1711                 if (thismatch && findflag
1712                     && !(tentry.flags & attributes->flag))
1713                     thismatch = 0;
1714
1715                 /* We found a match. Remember the index, and type */
1716                 if (thismatch) {
1717                     match = 1;
1718                     matchindex = k;
1719                     matchtype = thismatch;
1720                 }
1721
1722                 /* Since we prefer RW and BK volume matches over RO matches,
1723                  * if we have already checked the RWBK name, then we already
1724                  * found the best match and so end the search.
1725                  *
1726                  * If we tried matching against the RW, BK, and RO volume names
1727                  * and both failed, then we end the search (none will match).
1728                  */
1729                 if ((match && namematchRWBK)
1730                     || ((namematchRWBK == 2) && (namematchRO == 2)))
1731                     break;
1732             }
1733
1734             /* Passed all the tests. Take it */
1735             if (match) {
1736                 code =
1737                     put_nattributeentry(&ctx, &Vldbentry, &VldbentryFirst,
1738                                         &VldbentryLast, vldbentries, &tentry,
1739                                         matchtype, matchindex, nentries,
1740                                         &maxCount);
1741                 if (code)
1742                     goto done;
1743
1744                 if (*nentries >= maxCount)
1745                     break;      /* collected the max */
1746             }
1747         }
1748         *nextstartindex = (blockindex ? blockindex : -1);
1749     }
1750
1751   done:
1752 #ifdef HAVE_POSIX_REGEX
1753     if (need_regfree)
1754         regfree(&re);
1755 #endif
1756
1757     if (code) {
1758         countAbort(this_op);
1759         ubik_AbortTrans(ctx.trans);
1760         if (vldbentries->nbulkentries_val)
1761             free(vldbentries->nbulkentries_val);
1762         vldbentries->nbulkentries_val = 0;
1763         vldbentries->nbulkentries_len = 0;
1764         *nextstartindex = -1;
1765         return code;
1766     } else {
1767         VLog(5,
1768              ("N2ListAttrs nentries=%d %s\n", vldbentries->nbulkentries_len,
1769               rxinfo(rxstr, rxcall)));
1770         return (ubik_EndTrans(ctx.trans));
1771     }
1772 }
1773
1774
1775 /* Retrieves in vldbentries all vldb entries that match the specified
1776  * attributes (by server number, partition, volume type, and flag); if
1777  * volume id is specified then the associated list for that entry is
1778  * returned. CAUTION: This could be a very expensive call since in most
1779  * cases sequential search of all vldb entries is performed.
1780  */
1781 afs_int32
1782 SVL_LinkedList(struct rx_call *rxcall,
1783                struct VldbListByAttributes *attributes,
1784                afs_int32 *nentries,
1785                vldb_list *vldbentries)
1786 {
1787     int this_op = VLLINKEDLIST;
1788     int code;
1789     struct vl_ctx ctx;
1790     struct nvlentry tentry;
1791     vldblist vllist, *vllistptr;
1792     afs_int32 blockindex, count, match;
1793     afs_int32 k = 0;
1794     int serverindex;
1795     int pollcount = 0;
1796
1797     countRequest(this_op);
1798     if ((code = Init_VLdbase(&ctx, LOCKREAD, this_op)))
1799         return code;
1800
1801     *nentries = 0;
1802     vldbentries->node = NULL;
1803     vllistptr = &vldbentries->node;
1804
1805     /* List by volumeid */
1806     if (attributes->Mask & VLLIST_VOLUMEID) {
1807         blockindex =
1808             FindByID(&ctx, attributes->volumeid, -1, &tentry, &code);
1809         if (!blockindex) {
1810             if (!code)
1811                 code = VL_NOENT;
1812             goto abort;
1813         }
1814
1815         vllist = malloc(sizeof(single_vldbentry));
1816         if (vllist == NULL) {
1817             code = VL_NOMEM;
1818             goto abort;
1819         }
1820         code = vlentry_to_vldbentry(&ctx, &tentry, &vllist->VldbEntry);
1821         if (code)
1822             goto abort;
1823
1824         vllist->next_vldb = NULL;
1825
1826         *vllistptr = vllist;    /* Thread onto list */
1827         vllistptr = &vllist->next_vldb;
1828         (*nentries)++;
1829     }
1830
1831     /* Search by server, partition, and flags */
1832     else {
1833         for (blockindex = NextEntry(&ctx, 0, &tentry, &count); blockindex;
1834              blockindex = NextEntry(&ctx, blockindex, &tentry, &count)) {
1835             match = 0;
1836
1837             if (++pollcount > 50) {
1838 #ifndef AFS_PTHREAD_ENV
1839                 IOMGR_Poll();
1840 #endif
1841                 pollcount = 0;
1842             }
1843
1844             /* Does this volume exist on the desired server */
1845             if (attributes->Mask & VLLIST_SERVER) {
1846                 serverindex =
1847                     IpAddrToRelAddr(&ctx, attributes->server, 0);
1848                 if (serverindex == -1)
1849                     continue;
1850                 for (k = 0; k < OMAXNSERVERS; k++) {
1851                     if (tentry.serverNumber[k] == BADSERVERID)
1852                         break;
1853                     if (tentry.serverNumber[k] == serverindex) {
1854                         match = 1;
1855                         break;
1856                     }
1857                 }
1858                 if (!match)
1859                     continue;
1860             }
1861
1862             /* Does this volume exist on the desired partition */
1863             if (attributes->Mask & VLLIST_PARTITION) {
1864                 if (match) {
1865                     if (tentry.serverPartition[k] != attributes->partition)
1866                         match = 0;
1867                 } else {
1868                     for (k = 0; k < OMAXNSERVERS; k++) {
1869                         if (tentry.serverNumber[k] == BADSERVERID)
1870                             break;
1871                         if (tentry.serverPartition[k] ==
1872                             attributes->partition) {
1873                             match = 1;
1874                             break;
1875                         }
1876                     }
1877                 }
1878                 if (!match)
1879                     continue;
1880             }
1881
1882             /* Does this volume have the desired flags */
1883             if (attributes->Mask & VLLIST_FLAG) {
1884                 if (!(tentry.flags & attributes->flag))
1885                     continue;
1886             }
1887
1888             vllist = malloc(sizeof(single_vldbentry));
1889             if (vllist == NULL) {
1890                 code = VL_NOMEM;
1891                 goto abort;
1892             }
1893             code = vlentry_to_vldbentry(&ctx, &tentry, &vllist->VldbEntry);
1894             if (code)
1895                 goto abort;
1896
1897             vllist->next_vldb = NULL;
1898
1899             *vllistptr = vllist;        /* Thread onto list */
1900             vllistptr = &vllist->next_vldb;
1901             (*nentries)++;
1902             if (smallMem && (*nentries >= VLDBALLOCCOUNT)) {
1903                 code = VL_SIZEEXCEEDED;
1904                 goto abort;
1905             }
1906         }
1907     }
1908     *vllistptr = NULL;
1909     return (ubik_EndTrans(ctx.trans));
1910
1911 abort:
1912     countAbort(this_op);
1913     ubik_AbortTrans(ctx.trans);
1914     return code;
1915 }
1916
1917 afs_int32
1918 SVL_LinkedListN(struct rx_call *rxcall,
1919                 struct VldbListByAttributes *attributes,
1920                 afs_int32 *nentries,
1921                 nvldb_list *vldbentries)
1922 {
1923     int this_op = VLLINKEDLISTN;
1924     int code;
1925     struct vl_ctx ctx;
1926     struct nvlentry tentry;
1927     nvldblist vllist, *vllistptr;
1928     afs_int32 blockindex, count, match;
1929     afs_int32 k = 0;
1930     int serverindex;
1931     int pollcount = 0;
1932
1933     countRequest(this_op);
1934     if ((code = Init_VLdbase(&ctx, LOCKREAD, this_op)))
1935         return code;
1936
1937     *nentries = 0;
1938     vldbentries->node = NULL;
1939     vllistptr = &vldbentries->node;
1940
1941     /* List by volumeid */
1942     if (attributes->Mask & VLLIST_VOLUMEID) {
1943         blockindex =
1944             FindByID(&ctx, attributes->volumeid, -1, &tentry, &code);
1945         if (!blockindex) {
1946             if (!code)
1947                 code = VL_NOENT;
1948             goto abort;
1949         }
1950
1951         vllist = malloc(sizeof(single_nvldbentry));
1952         if (vllist == NULL) {
1953             code = VL_NOMEM;
1954             goto abort;
1955         }
1956         code = vlentry_to_nvldbentry(&ctx, &tentry, &vllist->VldbEntry);
1957         if (code)
1958             goto abort;
1959
1960         vllist->next_vldb = NULL;
1961
1962         *vllistptr = vllist;    /* Thread onto list */
1963         vllistptr = &vllist->next_vldb;
1964         (*nentries)++;
1965     }
1966
1967     /* Search by server, partition, and flags */
1968     else {
1969         for (blockindex = NextEntry(&ctx, 0, &tentry, &count); blockindex;
1970              blockindex = NextEntry(&ctx, blockindex, &tentry, &count)) {
1971             match = 0;
1972
1973             if (++pollcount > 50) {
1974 #ifndef AFS_PTHREAD_ENV
1975                 IOMGR_Poll();
1976 #endif
1977                 pollcount = 0;
1978             }
1979
1980             /* Does this volume exist on the desired server */
1981             if (attributes->Mask & VLLIST_SERVER) {
1982                 serverindex =
1983                     IpAddrToRelAddr(&ctx, attributes->server, 0);
1984                 if (serverindex == -1)
1985                     continue;
1986                 for (k = 0; k < NMAXNSERVERS; k++) {
1987                     if (tentry.serverNumber[k] == BADSERVERID)
1988                         break;
1989                     if (tentry.serverNumber[k] == serverindex) {
1990                         match = 1;
1991                         break;
1992                     }
1993                 }
1994                 if (!match)
1995                     continue;
1996             }
1997
1998             /* Does this volume exist on the desired partition */
1999             if (attributes->Mask & VLLIST_PARTITION) {
2000                 if (match) {
2001                     if (tentry.serverPartition[k] != attributes->partition)
2002                         match = 0;
2003                 } else {
2004                     for (k = 0; k < NMAXNSERVERS; k++) {
2005                         if (tentry.serverNumber[k] == BADSERVERID)
2006                             break;
2007                         if (tentry.serverPartition[k] ==
2008                             attributes->partition) {
2009                             match = 1;
2010                             break;
2011                         }
2012                     }
2013                 }
2014                 if (!match)
2015                     continue;
2016             }
2017
2018             /* Does this volume have the desired flags */
2019             if (attributes->Mask & VLLIST_FLAG) {
2020                 if (!(tentry.flags & attributes->flag))
2021                     continue;
2022             }
2023
2024             vllist = malloc(sizeof(single_nvldbentry));
2025             if (vllist == NULL) {
2026                 code = VL_NOMEM;
2027                 goto abort;
2028             }
2029             code = vlentry_to_nvldbentry(&ctx, &tentry, &vllist->VldbEntry);
2030             if (code)
2031                 goto abort;
2032
2033             vllist->next_vldb = NULL;
2034
2035             *vllistptr = vllist;        /* Thread onto list */
2036             vllistptr = &vllist->next_vldb;
2037             (*nentries)++;
2038             if (smallMem && (*nentries >= VLDBALLOCCOUNT)) {
2039                 code = VL_SIZEEXCEEDED;
2040                 goto abort;
2041             }
2042         }
2043     }
2044     *vllistptr = NULL;
2045     return (ubik_EndTrans(ctx.trans));
2046
2047 abort:
2048     countAbort(this_op);
2049     ubik_AbortTrans(ctx.trans);
2050     return code;
2051 }
2052
2053 /* Get back vldb header statistics (allocs, frees, maxvolumeid,
2054  * totalentries, etc) and dynamic statistics (number of requests and/or
2055  * aborts per remote procedure call, etc)
2056  */
2057 afs_int32
2058 SVL_GetStats(struct rx_call *rxcall,
2059              vldstats *stats,
2060              vital_vlheader *vital_header)
2061 {
2062     int this_op = VLGETSTATS;
2063     afs_int32 code;
2064     struct vl_ctx ctx;
2065     char rxstr[AFS_RXINFO_LEN];
2066
2067     countRequest(this_op);
2068 #ifdef  notdef
2069     /* Allow users to get statistics freely */
2070     if (!afsconf_SuperUser(vldb_confdir, rxcall, NULL)) /* Must be in 'UserList' to use */
2071         return VL_PERM;
2072 #endif
2073     if ((code = Init_VLdbase(&ctx, LOCKREAD, this_op)))
2074         return code;
2075     VLog(5, ("GetStats %s\n", rxinfo(rxstr, rxcall)));
2076     memcpy((char *)vital_header, (char *)&ctx.cheader->vital_header,
2077            sizeof(vital_vlheader));
2078     memcpy((char *)stats, (char *)&dynamic_statistics, sizeof(vldstats));
2079     return (ubik_EndTrans(ctx.trans));
2080 }
2081
2082 /* Get the list of file server addresses from the VLDB.  Currently it's pretty
2083  * easy to do.  In the future, it might require a little bit of grunging
2084  * through the VLDB, but that's life.
2085  */
2086 afs_int32
2087 SVL_GetAddrs(struct rx_call *rxcall,
2088              afs_int32 Handle,
2089              afs_int32 spare2,
2090              struct VLCallBack *spare3,
2091              afs_int32 *nentries,
2092              bulkaddrs *addrsp)
2093 {
2094     int this_op = VLGETADDRS;
2095     afs_int32 code;
2096     struct vl_ctx ctx;
2097     int nservers, i;
2098     afs_uint32 *taddrp;
2099
2100     countRequest(this_op);
2101     addrsp->bulkaddrs_len = *nentries = 0;
2102     addrsp->bulkaddrs_val = 0;
2103     memset(spare3, 0, sizeof(struct VLCallBack));
2104
2105     if ((code = Init_VLdbase(&ctx, LOCKREAD, this_op)))
2106         return code;
2107
2108     VLog(5, ("GetAddrs\n"));
2109     addrsp->bulkaddrs_val = taddrp =
2110         malloc(sizeof(afs_int32) * (MAXSERVERID + 1));
2111     nservers = *nentries = addrsp->bulkaddrs_len = 0;
2112
2113     if (!taddrp) {
2114         code = VL_NOMEM;
2115         goto abort;
2116     }
2117
2118     for (i = 0; i <= MAXSERVERID; i++) {
2119         if ((*taddrp = ntohl(ctx.cheader->IpMappedAddr[i]))) {
2120             taddrp++;
2121             nservers++;
2122         }
2123     }
2124
2125     addrsp->bulkaddrs_len = *nentries = nservers;
2126     return (ubik_EndTrans(ctx.trans));
2127
2128 abort:
2129     countAbort(this_op);
2130     ubik_AbortTrans(ctx.trans);
2131     return code;
2132 }
2133
2134 static_inline void
2135 append_addr(char *buffer, afs_uint32 addr, size_t buffer_size)
2136 {
2137     int n = strlen(buffer);
2138     if (buffer_size > n) {
2139         snprintf(buffer + n, buffer_size - n, "%u.%u.%u.%u",
2140                  (addr >> 24) & 0xff, (addr >> 16) & 0xff, (addr >> 8) & 0xff,
2141                  addr & 0xff);
2142     }
2143 }
2144
2145 afs_int32
2146 SVL_RegisterAddrs(struct rx_call *rxcall, afsUUID *uuidp, afs_int32 spare1,
2147                   bulkaddrs *addrsp)
2148 {
2149     int this_op = VLREGADDR;
2150     afs_int32 code;
2151     struct vl_ctx ctx;
2152     int cnt, h, i, j, k, m;
2153     struct extentaddr *exp = 0, *tex;
2154     char addrbuf[256];
2155     afsUUID tuuid;
2156     afs_uint32 addrs[VL_MAXIPADDRS_PERMH];
2157     int base;
2158     int count, willChangeEntry, foundUuidEntry, willReplaceCnt;
2159     int WillReplaceEntry, WillChange[MAXSERVERID + 1];
2160     int FoundUuid = 0;
2161     int ReplaceEntry = 0;
2162     int srvidx, mhidx;
2163
2164     countRequest(this_op);
2165     if (!afsconf_SuperUser(vldb_confdir, rxcall, NULL))
2166         return (VL_PERM);
2167     if ((code = Init_VLdbase(&ctx, LOCKWRITE, this_op)))
2168         return code;
2169
2170     /* Eliminate duplicates from IP address list */
2171     for (k = 0, cnt = 0; k < addrsp->bulkaddrs_len; k++) {
2172         if (addrsp->bulkaddrs_val[k] == 0)
2173             continue;
2174         for (m = 0; m < cnt; m++) {
2175             if (addrs[m] == addrsp->bulkaddrs_val[k])
2176                 break;
2177         }
2178         if (m == cnt) {
2179             if (m == VL_MAXIPADDRS_PERMH) {
2180                 VLog(0,
2181                      ("Number of addresses exceeds %d. Cannot register IP addr 0x%x in VLDB\n",
2182                       VL_MAXIPADDRS_PERMH, addrsp->bulkaddrs_val[k]));
2183             } else {
2184                 addrs[m] = addrsp->bulkaddrs_val[k];
2185                 cnt++;
2186             }
2187         }
2188     }
2189     if (cnt <= 0) {
2190         code = VL_INDEXERANGE;
2191         goto abort;
2192     }
2193
2194     count = 0;
2195     willReplaceCnt = 0;
2196     foundUuidEntry = 0;
2197     /* For each server registered within the VLDB */
2198     for (srvidx = 0; srvidx <= MAXSERVERID; srvidx++) {
2199         willChangeEntry = 0;
2200         WillReplaceEntry = 1;
2201         code = multiHomedExtent(&ctx, srvidx, &exp);
2202         if (code)
2203              continue;
2204
2205         if (exp) {
2206             /* See if the addresses to register will change this server entry */
2207             tuuid = exp->ex_hostuuid;
2208             afs_ntohuuid(&tuuid);
2209             if (afs_uuid_equal(uuidp, &tuuid)) {
2210                 foundUuidEntry = 1;
2211                 FoundUuid = srvidx;
2212             } else {
2213                 for (mhidx = 0; mhidx < VL_MAXIPADDRS_PERMH; mhidx++) {
2214                     if (!exp->ex_addrs[mhidx])
2215                         continue;
2216                     for (k = 0; k < cnt; k++) {
2217                         if (ntohl(exp->ex_addrs[mhidx]) == addrs[k]) {
2218                             willChangeEntry = 1;
2219                             WillChange[count] = srvidx;
2220                             break;
2221                         }
2222                     }
2223                     if (k >= cnt)
2224                         WillReplaceEntry = 0;
2225                 }
2226             }
2227         } else {
2228             /* The server is not registered as a multihomed.
2229              * See if the addresses to register will replace this server entry.
2230              */
2231             for (k = 0; k < cnt; k++) {
2232                 if (ctx.hostaddress[srvidx] == addrs[k]) {
2233                     willChangeEntry = 1;
2234                     WillChange[count] = srvidx;
2235                     WillReplaceEntry = 1;
2236                     break;
2237                 }
2238             }
2239         }
2240         if (willChangeEntry) {
2241             if (WillReplaceEntry) {
2242                 willReplaceCnt++;
2243                 ReplaceEntry = srvidx;
2244             }
2245             count++;
2246         }
2247     }
2248
2249     /* If we found the uuid in the VLDB and if we are replacing another
2250      * entire entry, then complain and fail. Also, if we did not find
2251      * the uuid in the VLDB and the IP addresses being registered was
2252      * found in more than one other entry, then we don't know which one
2253      * to replace and will complain and fail.
2254      */
2255     if ((foundUuidEntry && (willReplaceCnt > 0))
2256         || (!foundUuidEntry && (count > 1))) {
2257         VLog(0,
2258              ("The following fileserver is being registered in the VLDB:\n"));
2259         for (addrbuf[0] = '\0', k = 0; k < cnt; k++) {
2260             if (k > 0)
2261                 strlcat(addrbuf, " ", sizeof(addrbuf));
2262             append_addr(addrbuf, addrs[k], sizeof(addrbuf));
2263         }
2264         VLog(0, ("      [%s]\n", addrbuf));
2265
2266         if (foundUuidEntry) {
2267             code = multiHomedExtent(&ctx, FoundUuid, &exp);
2268             if (code == 0) {
2269                 VLog(0, ("   It would have replaced the existing VLDB server "
2270                          "entry:\n"));
2271                 for (addrbuf[0] = '\0', mhidx = 0; mhidx < VL_MAXIPADDRS_PERMH; mhidx++) {
2272                     if (!exp->ex_addrs[mhidx])
2273                         continue;
2274                     if (mhidx > 0)
2275                         strlcat(addrbuf, " ", sizeof(addrbuf));
2276                     append_addr(addrbuf, ntohl(exp->ex_addrs[mhidx]), sizeof(addrbuf));
2277                 }
2278                 VLog(0, ("      entry %d: [%s]\n", FoundUuid, addrbuf));
2279             }
2280         }
2281
2282         if (count == 1)
2283             VLog(0, ("   Yet another VLDB server entry exists:\n"));
2284         else
2285             VLog(0, ("   Yet other VLDB server entries exist:\n"));
2286         for (j = 0; j < count; j++) {
2287             srvidx = WillChange[j];
2288             VLog(0, ("      entry %d: ", srvidx));
2289
2290             code = multiHomedExtent(&ctx, srvidx, &exp);
2291             if (code)
2292                 goto abort;
2293
2294             addrbuf[0] = '\0';
2295             if (exp) {
2296                 for (mhidx = 0; mhidx < VL_MAXIPADDRS_PERMH; mhidx++) {
2297                     if (!exp->ex_addrs[mhidx])
2298                         continue;
2299                     if (mhidx > 0)
2300                         strlcat(addrbuf, " ", sizeof(addrbuf));
2301                     append_addr(addrbuf, ntohl(exp->ex_addrs[mhidx]), sizeof(addrbuf));
2302                 }
2303             } else {
2304                 append_addr(addrbuf, ctx.hostaddress[srvidx], sizeof(addrbuf));
2305             }
2306             VLog(0, ("      entry %d: [%s]\n", srvidx, addrbuf));
2307         }
2308
2309         if (count == 1)
2310             VLog(0, ("   You must 'vos changeaddr' this other server entry\n"));
2311         else
2312             VLog(0,
2313                 ("   You must 'vos changeaddr' these other server entries\n"));
2314         if (foundUuidEntry)
2315             VLog(0,
2316                 ("   and/or remove the sysid file from the registering fileserver\n"));
2317         VLog(0, ("   before the fileserver can be registered in the VLDB.\n"));
2318
2319         code = VL_MULTIPADDR;
2320         goto abort;
2321     }
2322
2323     /* Passed the checks. Now find and update the existing mh entry, or create
2324      * a new mh entry.
2325      */
2326     if (foundUuidEntry) {
2327         /* Found the entry with same uuid. See if we need to change it */
2328         int change = 0;
2329
2330         code = multiHomedExtentBase(&ctx, FoundUuid, &exp, &base);
2331         if (code)
2332             goto abort;
2333
2334         /* Determine if the entry has changed */
2335         for (k = 0; ((k < cnt) && !change); k++) {
2336             if (ntohl(exp->ex_addrs[k]) != addrs[k])
2337                 change = 1;
2338         }
2339         for (; ((k < VL_MAXIPADDRS_PERMH) && !change); k++) {
2340             if (exp->ex_addrs[k] != 0)
2341                 change = 1;
2342         }
2343         if (!change) {
2344             return (ubik_EndTrans(ctx.trans));
2345         }
2346     }
2347
2348     VLog(0, ("The following fileserver is being registered in the VLDB:\n"));
2349     for (addrbuf[0] = '\0', k = 0; k < cnt; k++) {
2350         if (k > 0)
2351             strlcat(addrbuf, " ", sizeof(addrbuf));
2352         append_addr(addrbuf, addrs[k], sizeof(addrbuf));
2353     }
2354     VLog(0, ("      [%s]\n", addrbuf));
2355
2356     if (foundUuidEntry) {
2357         VLog(0,
2358             ("   It will replace the following existing entry in the VLDB (same uuid):\n"));
2359         for (addrbuf[0] = '\0', k = 0; k < VL_MAXIPADDRS_PERMH; k++) {
2360             if (exp->ex_addrs[k] == 0)
2361                 continue;
2362             if (k > 0)
2363                 strlcat(addrbuf, " ", sizeof(addrbuf));
2364             append_addr(addrbuf, ntohl(exp->ex_addrs[k]), sizeof(addrbuf));
2365         }
2366         VLog(0, ("      entry %d: [%s]\n", FoundUuid, addrbuf));
2367     } else if (willReplaceCnt || (count == 1)) {
2368         /* If we are not replacing an entry and there is only one entry to change,
2369          * then we will replace that entry.
2370          */
2371         if (!willReplaceCnt) {
2372             ReplaceEntry = WillChange[0];
2373             willReplaceCnt++;
2374         }
2375
2376         /* Have an entry that needs to be replaced */
2377         code = multiHomedExtentBase(&ctx, ReplaceEntry, &exp, &base);
2378         if (code)
2379             goto abort;
2380
2381         if (exp) {
2382             VLog(0,
2383                 ("   It will replace the following existing entry in the VLDB (new uuid):\n"));
2384             for (addrbuf[0] = '\0', k = 0; k < VL_MAXIPADDRS_PERMH; k++) {
2385                 if (exp->ex_addrs[k] == 0)
2386                     continue;
2387                 if (k > 0)
2388                     strlcat(addrbuf, " ", sizeof(addrbuf));
2389                 append_addr(addrbuf, ntohl(exp->ex_addrs[k]), sizeof(addrbuf));
2390             }
2391             VLog(0, ("      entry %d: [%s]\n", ReplaceEntry, addrbuf));
2392         } else {
2393             /* Not a mh entry. So we have to create a new mh entry and
2394              * put it on the ReplaceEntry slot of the ctx.hostaddress array.
2395              */
2396             addrbuf[0] = '\0';
2397             append_addr(addrbuf, ctx.hostaddress[ReplaceEntry], sizeof(addrbuf));
2398             VLog(0, ("   It will replace existing entry %d, %s,"
2399                      " in the VLDB (new uuid):\n", ReplaceEntry, addrbuf));
2400             code =
2401                 FindExtentBlock(&ctx, uuidp, 1, ReplaceEntry, &exp, &base);
2402             if (code || !exp) {
2403                 if (!code)
2404                     code = VL_IO;
2405                 goto abort;
2406             }
2407         }
2408     } else {
2409         /* There is no entry for this server, must create a new mh entry as
2410          * well as use a new slot of the ctx.hostaddress array.
2411          */
2412         VLog(0, ("   It will create a new entry in the VLDB.\n"));
2413         code = FindExtentBlock(&ctx, uuidp, 1, -1, &exp, &base);
2414         if (code || !exp) {
2415             if (!code)
2416                 code = VL_IO;
2417             goto abort;
2418         }
2419     }
2420
2421     /* Now we have a mh entry to fill in. Update the uuid, bump the
2422      * uniquifier, and fill in its IP addresses.
2423      */
2424     tuuid = *uuidp;
2425     afs_htonuuid(&tuuid);
2426     exp->ex_hostuuid = tuuid;
2427     exp->ex_uniquifier = htonl(ntohl(exp->ex_uniquifier) + 1);
2428     for (k = 0; k < cnt; k++) {
2429         exp->ex_addrs[k] = htonl(addrs[k]);
2430     }
2431     for (; k < VL_MAXIPADDRS_PERMH; k++) {
2432         exp->ex_addrs[k] = 0;
2433     }
2434
2435     /* Write the new mh entry out */
2436     if (vlwrite
2437         (ctx.trans,
2438          DOFFSET(ntohl(ctx.ex_addr[0]->ex_contaddrs[base]),
2439                  (char *)ctx.ex_addr[base], (char *)exp), (char *)exp,
2440          sizeof(*exp))) {
2441         code = VL_IO;
2442         goto abort;
2443     }
2444
2445     /* Remove any common addresses from other mh entres. We know these entries
2446      * are being changed and not replaced so they are mh entries.
2447      */
2448     m = 0;
2449     for (i = 0; i < count; i++) {
2450         afs_int32 doff;
2451
2452         /* Skip the entry we replaced */
2453         if (willReplaceCnt && (WillChange[i] == ReplaceEntry))
2454             continue;
2455
2456         code = multiHomedExtentBase(&ctx, WillChange[i], &tex, &base);
2457         if (code)
2458             goto abort;
2459
2460         if (++m == 1)
2461             VLog(0,
2462                 ("   The following existing entries in the VLDB will be updated:\n"));
2463
2464         for (addrbuf[0] = '\0', h = j = 0; j < VL_MAXIPADDRS_PERMH; j++) {
2465             if (tex->ex_addrs[j]) {
2466                 if (j > 0)
2467                     strlcat(addrbuf, " ", sizeof(addrbuf));
2468                 append_addr(addrbuf, ntohl(tex->ex_addrs[j]), sizeof(addrbuf));
2469             }
2470
2471             for (k = 0; k < cnt; k++) {
2472                 if (ntohl(tex->ex_addrs[j]) == addrs[k])
2473                     break;
2474             }
2475             if (k >= cnt) {
2476                 /* Not found, so we keep it */
2477                 tex->ex_addrs[h] = tex->ex_addrs[j];
2478                 h++;
2479             }
2480         }
2481         for (j = h; j < VL_MAXIPADDRS_PERMH; j++) {
2482             tex->ex_addrs[j] = 0;       /* zero rest of mh entry */
2483         }
2484         VLog(0, ("      entry %d: [%s]\n", WillChange[i], addrbuf));
2485
2486         /* Write out the modified mh entry */
2487         tex->ex_uniquifier = htonl(ntohl(tex->ex_uniquifier) + 1);
2488         doff =
2489             DOFFSET(ntohl(ctx.ex_addr[0]->ex_contaddrs[base]),
2490                     (char *)ctx.ex_addr[base], (char *)tex);
2491         if (vlwrite(ctx.trans, doff, (char *)tex, sizeof(*tex))) {
2492             code = VL_IO;
2493             goto abort;
2494         }
2495     }
2496
2497     return (ubik_EndTrans(ctx.trans));
2498
2499 abort:
2500     countAbort(this_op);
2501     ubik_AbortTrans(ctx.trans);
2502     return code;
2503 }
2504
2505 afs_int32
2506 SVL_GetAddrsU(struct rx_call *rxcall,
2507               struct ListAddrByAttributes *attributes,
2508               afsUUID *uuidpo,
2509               afs_int32 *uniquifier,
2510               afs_int32 *nentries,
2511               bulkaddrs *addrsp)
2512 {
2513     int this_op = VLGETADDRSU;
2514     afs_int32 code, index;
2515     struct vl_ctx ctx;
2516     int nservers, i, j, base = 0;
2517     struct extentaddr *exp = 0;
2518     afsUUID tuuid;
2519     afs_uint32 *taddrp, taddr;
2520     char rxstr[AFS_RXINFO_LEN];
2521
2522     countRequest(this_op);
2523     addrsp->bulkaddrs_len = *nentries = 0;
2524     addrsp->bulkaddrs_val = 0;
2525     VLog(5, ("GetAddrsU %s\n", rxinfo(rxstr, rxcall)));
2526     if ((code = Init_VLdbase(&ctx, LOCKREAD, this_op)))
2527         return code;
2528
2529     if (attributes->Mask & VLADDR_IPADDR) {
2530         if (attributes->Mask & (VLADDR_INDEX | VLADDR_UUID)) {
2531             code = VL_BADMASK;
2532             goto abort;
2533         }
2534         /* Search for a server registered with the VLDB with this ip address. */
2535         for (index = 0; index <= MAXSERVERID; index++) {
2536             code = multiHomedExtent(&ctx, index, &exp);
2537             if (code)
2538                 continue;
2539
2540             if (exp) {
2541                 for (j = 0; j < VL_MAXIPADDRS_PERMH; j++) {
2542                     if (exp->ex_addrs[j]
2543                         && (ntohl(exp->ex_addrs[j]) == attributes->ipaddr)) {
2544                         break;
2545                     }
2546                 }
2547                 if (j < VL_MAXIPADDRS_PERMH)
2548                     break;
2549             }
2550         }
2551         if (index > MAXSERVERID) {
2552             code = VL_NOENT;
2553             goto abort;
2554         }
2555     } else if (attributes->Mask & VLADDR_INDEX) {
2556         if (attributes->Mask & (VLADDR_IPADDR | VLADDR_UUID)) {
2557             code = VL_BADMASK;
2558             goto abort;
2559         }
2560         /* VLADDR_INDEX index is one based */
2561         if (attributes->index < 1 || attributes->index > MAXSERVERID) {
2562             code = VL_INDEXERANGE;
2563             goto abort;
2564         }
2565         index = attributes->index - 1;
2566         code = multiHomedExtent(&ctx, index, &exp);
2567         if (code) {
2568             code = VL_NOENT;
2569             goto abort;
2570         }
2571     } else if (attributes->Mask & VLADDR_UUID) {
2572         if (attributes->Mask & (VLADDR_IPADDR | VLADDR_INDEX)) {
2573             code = VL_BADMASK;
2574             goto abort;
2575         }
2576         if (!ctx.ex_addr[0]) {  /* mh servers probably aren't setup on this vldb */
2577             code = VL_NOENT;
2578             goto abort;
2579         }
2580         code = FindExtentBlock(&ctx, &attributes->uuid, 0, -1, &exp, &base);
2581         if (code)
2582             goto abort;
2583     } else {
2584         code = VL_BADMASK;
2585         goto abort;
2586     }
2587
2588     if (exp == NULL) {
2589         code = VL_NOENT;
2590         goto abort;
2591     }
2592     addrsp->bulkaddrs_val = taddrp =
2593         malloc(sizeof(afs_int32) * (MAXSERVERID + 1));
2594     nservers = *nentries = addrsp->bulkaddrs_len = 0;
2595     if (!taddrp) {
2596         code = VL_NOMEM;
2597         goto abort;
2598     }
2599     tuuid = exp->ex_hostuuid;
2600     afs_ntohuuid(&tuuid);
2601     if (afs_uuid_is_nil(&tuuid)) {
2602         code = VL_NOENT;
2603         goto abort;
2604     }
2605     if (uuidpo)
2606         *uuidpo = tuuid;
2607     if (uniquifier)
2608         *uniquifier = ntohl(exp->ex_uniquifier);
2609     for (i = 0; i < VL_MAXIPADDRS_PERMH; i++) {
2610         if (exp->ex_addrs[i]) {
2611             taddr = ntohl(exp->ex_addrs[i]);
2612             /* Weed out duplicates */
2613             for (j = 0; j < nservers; j++) {
2614                 if (taddrp[j] == taddr)
2615                     break;
2616             }
2617             if ((j == nservers) && (j <= MAXSERVERID)) {
2618                 taddrp[nservers] = taddr;
2619                 nservers++;
2620             }
2621         }
2622     }
2623     addrsp->bulkaddrs_len = *nentries = nservers;
2624     return (ubik_EndTrans(ctx.trans));
2625
2626 abort:
2627     countAbort(this_op);
2628     ubik_AbortTrans(ctx.trans);
2629     return code;
2630 }
2631
2632 /* ============> End of Exported vldb RPC functions <============= */
2633
2634
2635 /* Routine that copies the given vldb entry to the output buffer, vldbentries. */
2636 static int
2637 put_attributeentry(struct vl_ctx *ctx,
2638                    struct vldbentry **Vldbentry,
2639                    struct vldbentry **VldbentryFirst,
2640                    struct vldbentry **VldbentryLast,
2641                    bulkentries *vldbentries,
2642                    struct nvlentry *entry,
2643                    afs_int32 *nentries,
2644                    afs_int32 *alloccnt)
2645 {
2646     vldbentry *reall;
2647     afs_int32 allo;
2648     int code;
2649
2650     if (*Vldbentry == *VldbentryLast) {
2651         if (smallMem)
2652             return VL_SIZEEXCEEDED;     /* no growing if smallMem defined */
2653
2654         /* Allocate another set of memory; each time allocate twice as
2655          * many blocks as the last time. When we reach VLDBALLOCLIMIT,
2656          * then grow in increments of VLDBALLOCINCR.
2657          */
2658         allo = (*alloccnt > VLDBALLOCLIMIT) ? VLDBALLOCINCR : *alloccnt;
2659         reall = realloc(*VldbentryFirst,
2660                         (*alloccnt + allo) * sizeof(vldbentry));
2661         if (reall == NULL)
2662             return VL_NOMEM;
2663
2664         *VldbentryFirst = vldbentries->bulkentries_val = reall;
2665         *Vldbentry = *VldbentryFirst + *alloccnt;
2666         *VldbentryLast = *Vldbentry + allo;
2667         *alloccnt += allo;
2668     }
2669
2670     code = vlentry_to_vldbentry(ctx, entry, *Vldbentry);
2671     if (code)
2672         return code;
2673
2674     (*Vldbentry)++;
2675     (*nentries)++;
2676     vldbentries->bulkentries_len++;
2677     return 0;
2678 }
2679
2680 static int
2681 put_nattributeentry(struct vl_ctx *ctx,
2682                     struct nvldbentry **Vldbentry,
2683                     struct nvldbentry **VldbentryFirst,
2684                     struct nvldbentry **VldbentryLast,
2685                     nbulkentries *vldbentries,
2686                     struct nvlentry *entry,
2687                     afs_int32 matchtype,
2688                     afs_int32 matchindex,
2689                     afs_int32 *nentries,
2690                     afs_int32 *alloccnt)
2691 {
2692     nvldbentry *reall;
2693     afs_int32 allo;
2694     int code;
2695
2696     if (*Vldbentry == *VldbentryLast) {
2697         if (smallMem)
2698             return VL_SIZEEXCEEDED;     /* no growing if smallMem defined */
2699
2700         /* Allocate another set of memory; each time allocate twice as
2701          * many blocks as the last time. When we reach VLDBALLOCLIMIT,
2702          * then grow in increments of VLDBALLOCINCR.
2703          */
2704         allo = (*alloccnt > VLDBALLOCLIMIT) ? VLDBALLOCINCR : *alloccnt;
2705         reall = realloc(*VldbentryFirst,
2706                         (*alloccnt + allo) * sizeof(nvldbentry));
2707         if (reall == NULL)
2708             return VL_NOMEM;
2709
2710         *VldbentryFirst = vldbentries->nbulkentries_val = reall;
2711         *Vldbentry = *VldbentryFirst + *alloccnt;
2712         *VldbentryLast = *Vldbentry + allo;
2713         *alloccnt += allo;
2714     }
2715     code = vlentry_to_nvldbentry(ctx, entry, *Vldbentry);
2716     if (code)
2717         return code;
2718
2719     (*Vldbentry)->matchindex = (matchtype << 16) + matchindex;
2720     (*Vldbentry)++;
2721     (*nentries)++;
2722     vldbentries->nbulkentries_len++;
2723     return 0;
2724 }
2725
2726
2727 /* Common code to actually remove a vldb entry from the database. */
2728 static int
2729 RemoveEntry(struct vl_ctx *ctx, afs_int32 entryptr,
2730             struct nvlentry *tentry)
2731 {
2732     int code;
2733
2734     if ((code = UnthreadVLentry(ctx, entryptr, tentry)))
2735         return code;
2736     if ((code = FreeBlock(ctx, entryptr)))
2737         return code;
2738     return 0;
2739 }
2740
2741 static void
2742 ReleaseEntry(struct nvlentry *tentry, afs_int32 releasetype)
2743 {
2744     if (releasetype & LOCKREL_TIMESTAMP)
2745         tentry->LockTimestamp = 0;
2746     if (releasetype & LOCKREL_OPCODE)
2747         tentry->flags &= ~VLOP_ALLOPERS;
2748     if (releasetype & LOCKREL_AFSID)
2749         tentry->LockAfsId = 0;
2750 }
2751
2752
2753 /* Verify that the incoming vldb entry is valid; multi type of error codes
2754  * are returned. */
2755 static int
2756 check_vldbentry(struct vldbentry *aentry)
2757 {
2758     afs_int32 i;
2759
2760     if (InvalidVolname(aentry->name))
2761         return VL_BADNAME;
2762     if (aentry->nServers <= 0 || aentry->nServers > OMAXNSERVERS)
2763         return VL_BADSERVER;
2764     for (i = 0; i < aentry->nServers; i++) {
2765 /*      if (aentry->serverNumber[i] < 0 || aentry->serverNumber[i] > MAXSERVERID)
2766             return VL_BADSERVER;        */
2767         if (aentry->serverPartition[i] < 0
2768             || aentry->serverPartition[i] > MAXPARTITIONID)
2769             return VL_BADPARTITION;
2770         if (aentry->serverFlags[i] < 0
2771             || aentry->serverFlags[i] > MAXSERVERFLAG)
2772             return VL_BADSERVERFLAG;
2773     }
2774     return 0;
2775 }
2776
2777 static int
2778 check_nvldbentry(struct nvldbentry *aentry)
2779 {
2780     afs_int32 i;
2781
2782     if (InvalidVolname(aentry->name))
2783         return VL_BADNAME;
2784     if (aentry->nServers <= 0 || aentry->nServers > NMAXNSERVERS)
2785         return VL_BADSERVER;
2786     for (i = 0; i < aentry->nServers; i++) {
2787 /*      if (aentry->serverNumber[i] < 0 || aentry->serverNumber[i] > MAXSERVERID)
2788             return VL_BADSERVER;        */
2789         if (aentry->serverPartition[i] < 0
2790             || aentry->serverPartition[i] > MAXPARTITIONID)
2791             return VL_BADPARTITION;
2792         if (aentry->serverFlags[i] < 0
2793             || aentry->serverFlags[i] > MAXSERVERFLAG)
2794             return VL_BADSERVERFLAG;
2795     }
2796     return 0;
2797 }
2798
2799
2800 /* Convert from the external vldb entry representation to its internal
2801    (more compact) form.  This call should not change the hash chains! */
2802 static int
2803 vldbentry_to_vlentry(struct vl_ctx *ctx,
2804                      struct vldbentry *VldbEntry,
2805                      struct nvlentry *VlEntry)
2806 {
2807     int i, serverindex;
2808
2809     if (strcmp(VlEntry->name, VldbEntry->name))
2810         strncpy(VlEntry->name, VldbEntry->name, sizeof(VlEntry->name));
2811     for (i = 0; i < VldbEntry->nServers; i++) {
2812         serverindex = IpAddrToRelAddr(ctx, VldbEntry->serverNumber[i], 1);
2813         if (serverindex == -1)
2814             return VL_BADSERVER;
2815         VlEntry->serverNumber[i] = serverindex;
2816         VlEntry->serverPartition[i] = VldbEntry->serverPartition[i];
2817         VlEntry->serverFlags[i] = VldbEntry->serverFlags[i];
2818     }
2819     for (; i < OMAXNSERVERS; i++)
2820         VlEntry->serverNumber[i] = VlEntry->serverPartition[i] =
2821             VlEntry->serverFlags[i] = BADSERVERID;
2822     for (i = 0; i < MAXTYPES; i++)
2823         VlEntry->volumeId[i] = VldbEntry->volumeId[i];
2824     VlEntry->cloneId = VldbEntry->cloneId;
2825     VlEntry->flags = VldbEntry->flags;
2826     return 0;
2827 }
2828
2829 static int
2830 nvldbentry_to_vlentry(struct vl_ctx *ctx,
2831                       struct nvldbentry *VldbEntry,
2832                       struct nvlentry *VlEntry)
2833 {
2834     int i, serverindex;
2835
2836     if (strcmp(VlEntry->name, VldbEntry->name))
2837         strncpy(VlEntry->name, VldbEntry->name, sizeof(VlEntry->name));
2838     for (i = 0; i < VldbEntry->nServers; i++) {
2839         serverindex = IpAddrToRelAddr(ctx, VldbEntry->serverNumber[i], 1);
2840         if (serverindex == -1)
2841             return VL_BADSERVER;
2842         VlEntry->serverNumber[i] = serverindex;
2843         VlEntry->serverPartition[i] = VldbEntry->serverPartition[i];
2844         VlEntry->serverFlags[i] = VldbEntry->serverFlags[i];
2845     }
2846     for (; i < NMAXNSERVERS; i++)
2847         VlEntry->serverNumber[i] = VlEntry->serverPartition[i] =
2848             VlEntry->serverFlags[i] = BADSERVERID;
2849     for (i = 0; i < MAXTYPES; i++)
2850         VlEntry->volumeId[i] = VldbEntry->volumeId[i];
2851     VlEntry->cloneId = VldbEntry->cloneId;
2852     VlEntry->flags = VldbEntry->flags;
2853     return 0;
2854 }
2855
2856
2857 /* Update the vldb entry with the new fields as indicated by the value of
2858  * the Mask entry in the updateentry structure. All necessary validation
2859  * checks are performed.
2860  */
2861 static int
2862 get_vldbupdateentry(struct vl_ctx *ctx,
2863                     afs_int32 blockindex,
2864                     struct VldbUpdateEntry *updateentry,
2865                     struct nvlentry *VlEntry)
2866 {
2867     int i, j, code, serverindex;
2868     afs_uint32 checkids[MAXTYPES];
2869
2870     /* check if any specified new IDs are already present in the db. Do
2871      * this check before doing anything else, so we don't get a half-
2872      * updated entry. */
2873     memset(&checkids, 0, sizeof(checkids));
2874     if (updateentry->Mask & VLUPDATE_RWID) {
2875         checkids[RWVOL] = updateentry->spares3; /* rw id */
2876     }
2877     if (updateentry->Mask & VLUPDATE_READONLYID) {
2878         checkids[ROVOL] = updateentry->ReadOnlyId;
2879     }
2880     if (updateentry->Mask & VLUPDATE_BACKUPID) {
2881         checkids[BACKVOL] = updateentry->BackupId;
2882     }
2883
2884     if (EntryIDExists(ctx, checkids, MAXTYPES, &code)) {
2885         return VL_IDEXIST;
2886     } else if (code) {
2887         return code;
2888     }
2889
2890     if (updateentry->Mask & VLUPDATE_VOLUMENAME) {
2891         struct nvlentry tentry;
2892
2893         if (InvalidVolname(updateentry->name))
2894             return VL_BADNAME;
2895
2896         if (FindByName(ctx, updateentry->name, &tentry, &code)) {
2897             return VL_NAMEEXIST;
2898         } else if (code) {
2899             return code;
2900         }
2901
2902         if ((code = UnhashVolname(ctx, blockindex, VlEntry)))
2903             return code;
2904         strncpy(VlEntry->name, updateentry->name, sizeof(VlEntry->name));
2905         HashVolname(ctx, blockindex, VlEntry);
2906     }
2907
2908     if (updateentry->Mask & VLUPDATE_VOLNAMEHASH) {
2909         if ((code = UnhashVolname(ctx, blockindex, VlEntry))) {
2910             if (code != VL_NOENT)
2911                 return code;
2912         }
2913         HashVolname(ctx, blockindex, VlEntry);
2914     }
2915
2916     if (updateentry->Mask & VLUPDATE_FLAGS) {
2917         VlEntry->flags = updateentry->flags;
2918     }
2919     if (updateentry->Mask & VLUPDATE_CLONEID) {
2920         VlEntry->cloneId = updateentry->cloneId;
2921     }
2922     if (updateentry->Mask & VLUPDATE_RWID) {
2923         if ((code = UnhashVolid(ctx, RWVOL, blockindex, VlEntry))) {
2924             if (code != VL_NOENT)
2925                 return code;
2926         }
2927         VlEntry->volumeId[RWVOL] = updateentry->spares3;        /* rw id */
2928         if ((code = HashVolid(ctx, RWVOL, blockindex, VlEntry)))
2929             return code;
2930     }
2931     if (updateentry->Mask & VLUPDATE_READONLYID) {
2932         if ((code = UnhashVolid(ctx, ROVOL, blockindex, VlEntry))) {
2933             if (code != VL_NOENT)
2934                 return code;
2935         }
2936         VlEntry->volumeId[ROVOL] = updateentry->ReadOnlyId;
2937         if ((code = HashVolid(ctx, ROVOL, blockindex, VlEntry)))
2938             return code;
2939     }
2940     if (updateentry->Mask & VLUPDATE_BACKUPID) {
2941         if ((code = UnhashVolid(ctx, BACKVOL, blockindex, VlEntry))) {
2942             if (code != VL_NOENT)
2943                 return code;
2944         }
2945         VlEntry->volumeId[BACKVOL] = updateentry->BackupId;
2946         if ((code = HashVolid(ctx, BACKVOL, blockindex, VlEntry)))
2947             return code;
2948     }
2949     if (updateentry->Mask & VLUPDATE_REPSITES) {
2950         if (updateentry->nModifiedRepsites <= 0
2951             || updateentry->nModifiedRepsites > OMAXNSERVERS)
2952             return VL_BADSERVER;
2953         for (i = 0; i < updateentry->nModifiedRepsites; i++) {
2954 /*          if (updateentry->RepsitesTargetServer[i] < 0 || updateentry->RepsitesTargetServer[i] > MAXSERVERID)
2955                 return VL_BADSERVER;    */
2956             if (updateentry->RepsitesTargetPart[i] < 0
2957                 || updateentry->RepsitesTargetPart[i] > MAXPARTITIONID)
2958                 return VL_BADPARTITION;
2959             if (updateentry->RepsitesMask[i] & VLUPDATE_REPS_DELETE) {
2960                 if ((j =
2961                      repsite_exists(VlEntry,
2962                                     IpAddrToRelAddr(ctx, updateentry->
2963                                                     RepsitesTargetServer[i],
2964                                                     1),
2965                                     updateentry->RepsitesTargetPart[i])) !=
2966                     -1)
2967                     repsite_compress(VlEntry, j);
2968                 else
2969                     return VL_NOREPSERVER;
2970             }
2971             if (updateentry->RepsitesMask[i] & VLUPDATE_REPS_ADD) {
2972 /*              if (updateentry->RepsitesNewServer[i] < 0 || updateentry->RepsitesNewServer[i] > MAXSERVERID)
2973                     return VL_BADSERVER;                */
2974                 if (updateentry->RepsitesNewPart[i] < 0
2975                     || updateentry->RepsitesNewPart[i] > MAXPARTITIONID)
2976                     return VL_BADPARTITION;
2977                 if (repsite_exists
2978                     (VlEntry,
2979                      IpAddrToRelAddr(ctx, updateentry->RepsitesNewServer[i], 1),
2980                      updateentry->RepsitesNewPart[i]) != -1)
2981                     return VL_DUPREPSERVER;
2982                 for (j = 0;
2983                      VlEntry->serverNumber[j] != BADSERVERID
2984                      && j < OMAXNSERVERS; j++);
2985                 if (j >= OMAXNSERVERS)
2986                     return VL_REPSFULL;
2987                 if ((serverindex =
2988                      IpAddrToRelAddr(ctx, updateentry->RepsitesNewServer[i],
2989                                      1)) == -1)
2990                     return VL_BADSERVER;
2991                 VlEntry->serverNumber[j] = serverindex;
2992                 VlEntry->serverPartition[j] = updateentry->RepsitesNewPart[i];
2993                 if (updateentry->RepsitesNewFlags[i] < 0
2994                     || updateentry->RepsitesNewFlags[i] > MAXSERVERFLAG)
2995                     return VL_BADSERVERFLAG;
2996                 VlEntry->serverFlags[j] = updateentry->RepsitesNewFlags[i];
2997             }
2998             if (updateentry->RepsitesMask[i] & VLUPDATE_REPS_MODSERV) {
2999 /*n             if (updateentry->RepsitesNewServer[i] < 0 || updateentry->RepsitesNewServer[i] > MAXSERVERID)
3000                     return VL_BADSERVER;            */
3001                 if ((j =
3002                      repsite_exists(VlEntry,
3003                                     IpAddrToRelAddr(ctx, updateentry->
3004                                                     RepsitesTargetServer[i],
3005                                                     1),
3006                                     updateentry->RepsitesTargetPart[i])) !=
3007                     -1) {
3008                     VlEntry->serverNumber[j] =
3009                         IpAddrToRelAddr(ctx, updateentry->RepsitesNewServer[i],
3010                                         1);
3011                 } else
3012                     return VL_NOREPSERVER;
3013             }
3014             if (updateentry->RepsitesMask[i] & VLUPDATE_REPS_MODPART) {
3015                 if (updateentry->RepsitesNewPart[i] < 0
3016                     || updateentry->RepsitesNewPart[i] > MAXPARTITIONID)
3017                     return VL_BADPARTITION;
3018                 if ((j =
3019                      repsite_exists(VlEntry,
3020                                     IpAddrToRelAddr(ctx, updateentry->
3021                                                     RepsitesTargetServer[i],
3022                                                     1),
3023                                     updateentry->RepsitesTargetPart[i])) !=
3024                     -1)
3025                     VlEntry->serverPartition[j] =
3026                         updateentry->RepsitesNewPart[i];
3027                 else
3028                     return VL_NOREPSERVER;
3029             }
3030             if (updateentry->RepsitesMask[i] & VLUPDATE_REPS_MODFLAG) {
3031                 if ((j =
3032                      repsite_exists(VlEntry,
3033                                     IpAddrToRelAddr(ctx, updateentry->
3034                                                     RepsitesTargetServer[i],
3035                                                     1),
3036                                     updateentry->RepsitesTargetPart[i])) !=
3037                     -1) {
3038                     if (updateentry->RepsitesNewFlags[i] < 0
3039                         || updateentry->RepsitesNewFlags[i] > MAXSERVERFLAG)
3040                         return VL_BADSERVERFLAG;
3041                     VlEntry->serverFlags[j] =
3042                         updateentry->RepsitesNewFlags[i];
3043                 } else
3044                     return VL_NOREPSERVER;
3045             }
3046         }
3047     }
3048     return 0;
3049 }
3050
3051
3052 /* Check if the specified [server,partition] entry is found in the vldb
3053  * entry's repsite table; it's offset in the table is returned, if it's
3054  * present there. */
3055 static int
3056 repsite_exists(struct nvlentry *VlEntry, int server, int partition)
3057 {
3058     int i;
3059
3060     for (i = 0; VlEntry->serverNumber[i] != BADSERVERID && i < OMAXNSERVERS;
3061          i++) {
3062         if ((VlEntry->serverNumber[i] == server)
3063             && (VlEntry->serverPartition[i] == partition))
3064             return i;
3065     }
3066     return -1;
3067 }
3068
3069
3070
3071 /* Repsite table compression: used when deleting a repsite entry so that
3072  * all active repsite entries are on the top of the table. */
3073 static void
3074 repsite_compress(struct nvlentry *VlEntry, int offset)
3075 {
3076     int repsite_offset = offset;
3077     for (;
3078          VlEntry->serverNumber[repsite_offset] != BADSERVERID
3079          && repsite_offset < OMAXNSERVERS - 1; repsite_offset++) {
3080         VlEntry->serverNumber[repsite_offset] =
3081             VlEntry->serverNumber[repsite_offset + 1];
3082         VlEntry->serverPartition[repsite_offset] =
3083             VlEntry->serverPartition[repsite_offset + 1];
3084         VlEntry->serverFlags[repsite_offset] =
3085             VlEntry->serverFlags[repsite_offset + 1];
3086     }
3087     VlEntry->serverNumber[repsite_offset] = BADSERVERID;
3088 }
3089
3090
3091 /* Convert from the internal (compacted) vldb entry to the external
3092  * representation used by the interface. */
3093 static int
3094 vlentry_to_vldbentry(struct vl_ctx *ctx, struct nvlentry *VlEntry,
3095                      struct vldbentry *VldbEntry)
3096 {
3097     int i, j, code;
3098     struct extentaddr *exp;
3099
3100     memset(VldbEntry, 0, sizeof(struct vldbentry));
3101     strncpy(VldbEntry->name, VlEntry->name, sizeof(VldbEntry->name));
3102     for (i = 0; i < OMAXNSERVERS; i++) {
3103         if (VlEntry->serverNumber[i] == BADSERVERID)
3104             break;
3105         j = VlEntry->serverNumber[i];
3106         code = multiHomedExtent(ctx, VlEntry->serverNumber[i], &exp);
3107         if (code)
3108             return code;
3109         if (exp) {
3110             /* For now return the first ip address back */
3111             for (j = 0; j < VL_MAXIPADDRS_PERMH; j++) {
3112                 if (exp->ex_addrs[j]) {
3113                     VldbEntry->serverNumber[i] = ntohl(exp->ex_addrs[j]);
3114                     break;
3115                 }
3116             }
3117         } else
3118             VldbEntry->serverNumber[i] =
3119                 ctx->hostaddress[VlEntry->serverNumber[i]];
3120         VldbEntry->serverPartition[i] = VlEntry->serverPartition[i];
3121         VldbEntry->serverFlags[i] = VlEntry->serverFlags[i];
3122     }
3123     VldbEntry->nServers = i;
3124     for (i = 0; i < MAXTYPES; i++)
3125         VldbEntry->volumeId[i] = VlEntry->volumeId[i];
3126     VldbEntry->cloneId = VlEntry->cloneId;
3127     VldbEntry->flags = VlEntry->flags;
3128
3129     return 0;
3130 }
3131
3132
3133 /* Convert from the internal (compacted) vldb entry to the external
3134  * representation used by the interface. */
3135 static int
3136 vlentry_to_nvldbentry(struct vl_ctx *ctx, struct nvlentry *VlEntry,
3137                       struct nvldbentry *VldbEntry)
3138 {
3139     int i, j, code;
3140     struct extentaddr *exp;
3141
3142     memset(VldbEntry, 0, sizeof(struct nvldbentry));
3143     strncpy(VldbEntry->name, VlEntry->name, sizeof(VldbEntry->name));
3144     for (i = 0; i < NMAXNSERVERS; i++) {
3145         if (VlEntry->serverNumber[i] == BADSERVERID)
3146             break;
3147         code = multiHomedExtent(ctx, VlEntry->serverNumber[i], &exp);
3148         if (code)
3149             return code;
3150
3151         if (exp) {
3152             /* For now return the first ip address back */
3153             for (j = 0; j < VL_MAXIPADDRS_PERMH; j++) {
3154                 if (exp->ex_addrs[j]) {
3155                     VldbEntry->serverNumber[i] = ntohl(exp->ex_addrs[j]);
3156                     break;
3157                 }
3158             }
3159         } else
3160             VldbEntry->serverNumber[i] =
3161                 ctx->hostaddress[VlEntry->serverNumber[i]];
3162         VldbEntry->serverPartition[i] = VlEntry->serverPartition[i];
3163         VldbEntry->serverFlags[i] = VlEntry->serverFlags[i];
3164     }
3165     VldbEntry->nServers = i;
3166     for (i = 0; i < MAXTYPES; i++)
3167         VldbEntry->volumeId[i] = VlEntry->volumeId[i];
3168     VldbEntry->cloneId = VlEntry->cloneId;
3169     VldbEntry->flags = VlEntry->flags;
3170
3171     return 0;
3172 }
3173
3174 static int
3175 vlentry_to_uvldbentry(struct vl_ctx *ctx, struct nvlentry *VlEntry,
3176                       struct uvldbentry *VldbEntry)
3177 {
3178     int i, code;
3179     struct extentaddr *exp;
3180
3181     memset(VldbEntry, 0, sizeof(struct uvldbentry));
3182     strncpy(VldbEntry->name, VlEntry->name, sizeof(VldbEntry->name));
3183     for (i = 0; i < NMAXNSERVERS; i++) {
3184         if (VlEntry->serverNumber[i] == BADSERVERID)
3185             break;
3186         VldbEntry->serverFlags[i] = VlEntry->serverFlags[i];
3187         VldbEntry->serverUnique[i] = 0;
3188         code = multiHomedExtent(ctx, VlEntry->serverNumber[i], &exp);
3189         if (code)
3190             return code;
3191
3192         if (exp) {
3193             afsUUID tuuid;
3194
3195             tuuid = exp->ex_hostuuid;
3196             afs_ntohuuid(&tuuid);
3197             VldbEntry->serverFlags[i] |= VLSF_UUID;
3198             VldbEntry->serverNumber[i] = tuuid;
3199             VldbEntry->serverUnique[i] = ntohl(exp->ex_uniquifier);
3200         } else {
3201             VldbEntry->serverNumber[i].time_low =
3202                 ctx->hostaddress[VlEntry->serverNumber[i]];
3203         }
3204         VldbEntry->serverPartition[i] = VlEntry->serverPartition[i];
3205
3206     }
3207     VldbEntry->nServers = i;
3208     for (i = 0; i < MAXTYPES; i++)
3209         VldbEntry->volumeId[i] = VlEntry->volumeId[i];
3210     VldbEntry->cloneId = VlEntry->cloneId;
3211     VldbEntry->flags = VlEntry->flags;
3212
3213     return 0;
3214 }
3215
3216 #define LEGALCHARS ".ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_"
3217
3218
3219 /* Verify that the volname is a valid volume name. */
3220 static int
3221 InvalidVolname(char *volname)
3222 {
3223     char *map;
3224     int slen;
3225
3226     map = LEGALCHARS;
3227     slen = strlen(volname);
3228     if (slen >= VL_MAXNAMELEN)
3229         return 1;
3230     return (slen != strspn(volname, map));
3231 }
3232
3233
3234 /* Verify that the given volume type is valid. */
3235 static int
3236 InvalidVoltype(afs_int32 voltype)
3237 {
3238     if (voltype != RWVOL && voltype != ROVOL && voltype != BACKVOL)
3239         return 1;
3240     return 0;
3241 }
3242
3243
3244 static int
3245 InvalidOperation(afs_int32 voloper)
3246 {
3247     if (voloper != VLOP_MOVE && voloper != VLOP_RELEASE
3248         && voloper != VLOP_BACKUP && voloper != VLOP_DELETE
3249         && voloper != VLOP_DUMP)
3250         return 1;
3251     return 0;
3252 }
3253
3254 static int
3255 InvalidReleasetype(afs_int32 releasetype)
3256 {
3257     if ((releasetype & LOCKREL_TIMESTAMP) || (releasetype & LOCKREL_OPCODE)
3258         || (releasetype & LOCKREL_AFSID))
3259         return 0;
3260     return 1;
3261 }
3262
3263 static int
3264 IpAddrToRelAddr(struct vl_ctx *ctx, afs_uint32 ipaddr, int create)
3265 {
3266     int i, j;
3267     afs_int32 code;
3268     struct extentaddr *exp;
3269
3270     for (i = 0; i <= MAXSERVERID; i++) {
3271         if (ctx->hostaddress[i] == ipaddr)
3272             return i;
3273         code = multiHomedExtent(ctx, i, &exp);
3274         if (code)
3275             return -1;
3276         if (exp) {
3277             for (j = 0; j < VL_MAXIPADDRS_PERMH; j++) {
3278                 if (exp->ex_addrs[j] && (ntohl(exp->ex_addrs[j]) == ipaddr)) {
3279                     return i;
3280                 }
3281             }
3282         }
3283     }
3284
3285     /* allocate the new server a server id pronto */
3286     if (create) {
3287         for (i = 0; i <= MAXSERVERID; i++) {
3288             if (ctx->cheader->IpMappedAddr[i] == 0) {
3289                 ctx->cheader->IpMappedAddr[i] = htonl(ipaddr);
3290                 code =
3291                     vlwrite(ctx->trans,
3292                             DOFFSET(0, ctx->cheader, &ctx->cheader->IpMappedAddr[i]),
3293                             (char *)&ctx->cheader->IpMappedAddr[i],
3294                             sizeof(afs_int32));
3295                 ctx->hostaddress[i] = ipaddr;
3296                 if (code)
3297                     return -1;
3298                 return i;
3299             }
3300         }
3301     }
3302     return -1;
3303 }
3304
3305 static int
3306 ChangeIPAddr(struct vl_ctx *ctx, afs_uint32 ipaddr1, afs_uint32 ipaddr2)
3307 {
3308     int i, j;
3309     afs_int32 code;
3310     struct extentaddr *exp = NULL;
3311     int base;
3312     int mhidx;
3313     afsUUID tuuid;
3314     afs_int32 blockindex, count;
3315     int pollcount = 0;
3316     struct nvlentry tentry;
3317     int ipaddr1_id = -1, ipaddr2_id = -1;
3318     char addrbuf1[256];
3319     char addrbuf2[256];
3320
3321     /* Don't let addr change to 256.*.*.* : Causes internal error below */
3322     if ((ipaddr2 & 0xff000000) == 0xff000000)
3323         return (VL_BADSERVER);
3324
3325     /* If we are removing an address, ip1 will be -1 and ip2 will be
3326      * the original address. This prevents an older revision vlserver
3327      * from removing the IP address (won't find server 0xfffffff in
3328      * the VLDB). An older revision vlserver does not have the check
3329      * to see if any volumes exist on the server being removed.
3330      */
3331     if (ipaddr1 == 0xffffffff) {
3332         ipaddr1 = ipaddr2;
3333         ipaddr2 = 0;
3334     }
3335
3336     for (i = 0; i <= MAXSERVERID; i++) {
3337         code = multiHomedExtentBase(ctx, i, &exp, &base);
3338         if (code)
3339             return code;
3340
3341         if (exp) {
3342             for (mhidx = 0; mhidx < VL_MAXIPADDRS_PERMH; mhidx++) {
3343                 if (!exp->ex_addrs[mhidx])
3344                     continue;
3345                 if (ntohl(exp->ex_addrs[mhidx]) == ipaddr1) {
3346                     ipaddr1_id = i;
3347                 }
3348                 if (ipaddr2 != 0 && ntohl(exp->ex_addrs[mhidx]) == ipaddr2) {
3349                     ipaddr2_id = i;
3350                 }
3351             }
3352         } else {
3353             if (ctx->hostaddress[i] == ipaddr1) {
3354                 exp = NULL;
3355                 ipaddr1_id = i;
3356             }
3357             if (ipaddr2 != 0 && ctx->hostaddress[i] == ipaddr2) {
3358                 ipaddr2_id = i;
3359             }
3360         }
3361
3362         if (ipaddr1_id >= 0 && (ipaddr2 == 0 || ipaddr2_id >= 0)) {
3363             /* we've either found both IPs already in the VLDB, or we found
3364              * ipaddr1, and we're not going to find ipaddr2 because it's 0 */
3365             break;
3366         }
3367     }
3368
3369     if (ipaddr1_id < 0) {
3370         return VL_NOENT;        /* not found */
3371     }
3372
3373     if (ipaddr2_id >= 0 && ipaddr2_id != ipaddr1_id) {
3374         char buf1[16], buf2[16];
3375         VLog(0, ("Cannot change IP address from %s to %s because the latter "
3376                  "is in use by server id %d\n",
3377                  afs_inet_ntoa_r(htonl(ipaddr1), buf1),
3378                  afs_inet_ntoa_r(htonl(ipaddr2), buf2),
3379                  ipaddr2_id));
3380         return VL_MULTIPADDR;
3381     }
3382
3383     /* If we are removing a server entry, a volume cannot
3384      * exist on the server. If one does, don't remove the
3385      * server entry: return error "volume entry exists".
3386      */
3387     if (ipaddr2 == 0) {
3388         for (blockindex = NextEntry(ctx, 0, &tentry, &count); blockindex;
3389              blockindex = NextEntry(ctx, blockindex, &tentry, &count)) {
3390             if (++pollcount > 50) {
3391 #ifndef AFS_PTHREAD_ENV
3392                 IOMGR_Poll();
3393 #endif
3394                 pollcount = 0;
3395             }
3396             for (j = 0; j < NMAXNSERVERS; j++) {
3397                 if (tentry.serverNumber[j] == BADSERVERID)
3398                     break;
3399                 if (tentry.serverNumber[j] == ipaddr1_id) {
3400                     return VL_IDEXIST;
3401                 }
3402             }
3403         }
3404     }
3405
3406     /* Log a message saying we are changing/removing an IP address */
3407     VLog(0,
3408          ("The following IP address is being %s:\n",
3409           (ipaddr2 ? "changed" : "removed")));
3410     addrbuf1[0] = addrbuf2[0] = '\0';
3411     if (exp) {
3412         for (mhidx = 0; mhidx < VL_MAXIPADDRS_PERMH; mhidx++) {
3413             if (!exp->ex_addrs[mhidx])
3414                 continue;
3415             if (mhidx > 0)
3416                 strlcat(addrbuf1, " ", sizeof(addrbuf1));
3417             append_addr(addrbuf1, ntohl(exp->ex_addrs[mhidx]), sizeof(addrbuf1));
3418         }
3419     } else {
3420         append_addr(addrbuf1, ipaddr1, sizeof(addrbuf1));
3421     }
3422     if (ipaddr2) {
3423         append_addr(addrbuf2, ipaddr2, sizeof(addrbuf2));
3424     }
3425     VLog(0, ("      entry %d: [%s] -> [%s]\n", i, addrbuf1, addrbuf2));
3426
3427     /* Change the registered uuuid addresses */
3428     if (exp) {
3429         memset(&tuuid, 0, sizeof(afsUUID));
3430         afs_htonuuid(&tuuid);
3431         exp->ex_hostuuid = tuuid;
3432         code =
3433             vlwrite(ctx->trans,
3434                     DOFFSET(ntohl(ctx->ex_addr[0]->ex_contaddrs[base]),
3435                             (char *)ctx->ex_addr[base], (char *)exp),
3436                     (char *)&tuuid, sizeof(tuuid));
3437         if (code)
3438             return VL_IO;
3439     }
3440
3441     /* Now change the host address entry */
3442     ctx->cheader->IpMappedAddr[ipaddr1_id] = htonl(ipaddr2);
3443     code =
3444         vlwrite(ctx->trans, DOFFSET(0, ctx->cheader, &ctx->cheader->IpMappedAddr[ipaddr1_id]),
3445                 (char *)
3446                 &ctx->cheader->IpMappedAddr[ipaddr1_id], sizeof(afs_int32));
3447     ctx->hostaddress[ipaddr1_id] = ipaddr2;
3448     if (code)
3449         return VL_IO;
3450
3451     return 0;
3452 }
3453
3454 /* see if the vlserver is back yet */
3455 afs_int32
3456 SVL_ProbeServer(struct rx_call *rxcall)
3457 {
3458     return 0;
3459 }