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