ubik sync client error recovery
[openafs.git] / src / ubik / beacon.c
1 /*
2  * Copyright 2000, International Business Machines Corporation and others.
3  * All Rights Reserved.
4  *
5  * This software has been released under the terms of the IBM Public
6  * License.  For details, see the LICENSE file in the top-level source
7  * directory or online at http://www.openafs.org/dl/license10.html
8  */
9
10 #include <afsconfig.h>
11 #include <afs/param.h>
12
13 #include <roken.h>
14
15 #include <sys/types.h>
16 #include <string.h>
17 #include <stdarg.h>
18 #include <errno.h>
19
20 #ifdef AFS_NT40_ENV
21 #include <winsock2.h>
22 #include <time.h>
23 #else
24 #include <sys/file.h>
25 #include <sys/time.h>
26 #include <sys/socket.h>
27 #include <netinet/in.h>
28 #include <netdb.h>
29 #endif
30
31 #include <lock.h>
32 #include <rx/xdr.h>
33 #include <rx/rx.h>
34 #include <rx/rxkad.h>
35 #include <rx/rx_multi.h>
36 #include <afs/cellconfig.h>
37 #ifndef AFS_NT40_ENV
38 #include <afs/afsutil.h>
39 #include <afs/netutils.h>
40 #endif
41
42 #define UBIK_INTERNALS
43 #include "ubik.h"
44 #include "ubik_int.h"
45
46 /*! \name statics used to determine if we're the sync site */
47 static afs_int32 syncSiteUntil = 0;     /*!< valid only if amSyncSite */
48 int ubik_amSyncSite = 0;        /*!< flag telling if I'm sync site */
49 static int nServers;            /*!< total number of servers */
50 static char amIMagic = 0;       /*!< is this host the magic host */
51 char amIClone = 0;              /*!< is this a clone which doesn't vote */
52 static char ubik_singleServer = 0;
53 /*\}*/
54 int (*ubik_CRXSecurityProc) (void *rock, struct rx_securityClass **,
55                              afs_int32 *);
56 void *ubik_CRXSecurityRock;
57 afs_int32 ubikSecIndex;
58 struct rx_securityClass *ubikSecClass;
59 static int ubeacon_InitServerListCommon(afs_uint32 ame,
60                                         struct afsconf_cell *info,
61                                         char clones[],
62                                         afs_uint32 aservers[]);
63 static int verifyInterfaceAddress(afs_uint32 *ame, struct afsconf_cell *info,
64                                   afs_uint32 aservers[]);
65 static int updateUbikNetworkAddress(afs_uint32 ubik_host[UBIK_MAX_INTERFACE_ADDR]);
66
67
68 /*! \file
69  * Module responsible for both deciding if we're currently the sync site,
70  * and keeping collecting votes so as to stay sync site.
71  *
72  * The basic module contacts all of the servers it can, trying to get them to vote
73  * for this server for sync site.  The vote request message (called a beacon message)
74  * also specifies until which time this site claims to be the sync site, if at all, thus enabling
75  * receiving sites to know how long the sync site guarantee is made for.
76  *
77  * Each  of these beacon messages is thus both a declaration of how long this site will
78  * remain sync site, and an attempt to extend that time by collecting votes for a later
79  * sync site extension.
80  *
81  * The voting module is responsible for choosing a reasonable time until which it promises
82  * not to vote for someone else.  This parameter (BIG seconds) is not actually passed in
83  * the interface (perhaps it should be?) but is instead a compile time constant that both
84  * sides know about.
85
86  * The beacon and vote modules work intimately together; the vote module decides how long
87  * it should promise the beacon module its vote, and the beacon module takes all of these
88  * votes and decides for how long it is the synchronization site.
89  */
90
91 /*! \brief procedure called from debug rpc call to get this module's state for debugging */
92 void
93 ubeacon_Debug(struct ubik_debug *aparm)
94 {
95     /* fill in beacon's state fields in the ubik_debug structure */
96     aparm->syncSiteUntil = syncSiteUntil;
97     aparm->nServers = nServers;
98 }
99
100 /*!
101  * \brief Procedure that determines whether this site has enough current votes to remain sync site.
102  *
103  * Called from higher-level modules (everything but the vote module).
104  *
105  * If we're the sync site, check that our guarantees, obtained by the ubeacon_Interact()
106  * light-weight process, haven't expired.  We're sync site as long as a majority of the
107  * servers in existence have promised us unexpired guarantees.  The variable #ubik_syncSiteUntil
108  * contains the time at which the latest of the majority of the sync site guarantees expires
109  * (if the variable #ubik_amSyncSite is true)
110  * This module also calls up to the recovery module if it thinks that the recovery module
111  * may have to pick up a new database (which offucr sif [sic] we lose the sync site votes).
112  *
113  * \return 1 if local site is the sync site
114  * \return 0 if sync site is elsewhere
115  */
116 int
117 ubeacon_AmSyncSite(void)
118 {
119     afs_int32 now;
120     afs_int32 rcode;
121
122     /* special case for fast startup */
123     if (nServers == 1 && !amIClone) {
124         return 1;               /* one guy is always the sync site */
125     }
126
127     if (ubik_amSyncSite == 0 || amIClone)
128         rcode = 0;              /* if I don't think I'm the sync site, say so */
129     else {
130         now = FT_ApproxTime();
131         if (syncSiteUntil <= now) {     /* if my votes have expired, say so */
132             if (ubik_amSyncSite)
133                 ubik_dprint("Ubik: I am no longer the sync site\n");
134             ubik_amSyncSite = 0;
135             rcode = 0;
136         } else {
137             rcode = 1;          /* otherwise still have the required votes */
138         }
139     }
140     if (rcode == 0)
141         urecovery_ResetState(); /* force recovery to re-execute */
142     ubik_dprint("beacon: amSyncSite is %d\n", rcode);
143     return rcode;
144 }
145
146 /*!
147  * \see ubeacon_InitServerListCommon()
148  */
149 int
150 ubeacon_InitServerListByInfo(afs_uint32 ame, struct afsconf_cell *info,
151                              char clones[])
152 {
153     afs_int32 code;
154
155     code = ubeacon_InitServerListCommon(ame, info, clones, 0);
156     return code;
157 }
158
159 /*!
160  * \param ame "address of me"
161  * \param aservers list of other servers
162  *
163  * \see ubeacon_InitServerListCommon()
164  */
165 int
166 ubeacon_InitServerList(afs_uint32 ame, afs_uint32 aservers[])
167 {
168     afs_int32 code;
169
170     code =
171         ubeacon_InitServerListCommon(ame, (struct afsconf_cell *)0, 0,
172                                      aservers);
173     return code;
174 }
175
176 void
177 ubeacon_InitSecurityClass(void)
178 {
179     int i;
180     /* get the security index to use, if we can */
181     if (ubik_CRXSecurityProc) {
182         i = (*ubik_CRXSecurityProc) (ubik_CRXSecurityRock, &ubikSecClass,
183                                      &ubikSecIndex);
184     } else
185         i = 1;
186     if (i) {
187         /* don't have sec module yet */
188         ubikSecIndex = 0;
189         ubikSecClass = rxnull_NewClientSecurityObject();
190     }
191 }
192
193 void
194 ubeacon_ReinitServer(struct ubik_server *ts)
195 {
196     if (!afsconf_UpToDate(ubik_CRXSecurityRock)) {
197         struct rx_connection *disk_rxcid;
198         struct rx_connection *vote_rxcid;
199         struct rx_connection *tmp;
200         ubeacon_InitSecurityClass();
201         disk_rxcid =
202             rx_NewConnection(rx_HostOf(rx_PeerOf(ts->disk_rxcid)),
203                              ubik_callPortal, DISK_SERVICE_ID,
204                              ubikSecClass, ubikSecIndex);
205         if (disk_rxcid) {
206             tmp = ts->disk_rxcid;
207             ts->disk_rxcid = disk_rxcid;
208             rx_PutConnection(tmp);
209         }
210         vote_rxcid =
211             rx_NewConnection(rx_HostOf(rx_PeerOf(ts->vote_rxcid)),
212                              ubik_callPortal, VOTE_SERVICE_ID,
213                              ubikSecClass, ubikSecIndex);
214         if (vote_rxcid) {
215             tmp = ts->vote_rxcid;
216             ts->vote_rxcid = vote_rxcid;
217             rx_PutConnection(tmp);
218         }
219     }
220 }
221
222 /*!
223  * \brief setup server list
224  *
225  * \param ame "address of me"
226  * \param aservers list of other servers
227  *
228  * called only at initialization to set up the list of servers to
229  * contact for votes.  Just creates the server structure.
230  *
231  * The "magic" host is the one with the lowest internet address.  It is
232  * magic because its vote counts epsilon more than the others.  This acts
233  * as a tie-breaker when we have an even number of hosts in the system.
234  * For example, if the "magic" host is up in a 2 site system, then it
235  * is sync site.  Without the magic host hack, if anyone crashed in a 2
236  * site system, we'd be out of business.
237  *
238  * \note There are two connections in every server structure, one for
239  * vote calls (which must always go through quickly) and one for database
240  * operations, which are subject to waiting for locks.  If we used only
241  * one, the votes would sometimes get held up behind database operations,
242  * and the sync site guarantees would timeout even though the host would be
243  * up for communication.
244  *
245  * \see ubeacon_InitServerList(), ubeacon_InitServerListByInfo()
246  */
247 int
248 ubeacon_InitServerListCommon(afs_uint32 ame, struct afsconf_cell *info,
249                              char clones[], afs_uint32 aservers[])
250 {
251     struct ubik_server *ts;
252     afs_int32 me = -1;
253     afs_int32 servAddr;
254     afs_int32 i, code;
255     afs_int32 magicHost;
256     struct ubik_server *magicServer;
257
258     /* verify that the addresses passed in are correct */
259     if ((code = verifyInterfaceAddress(&ame, info, aservers)))
260         return code;
261
262     ubeacon_InitSecurityClass();
263
264     magicHost = ntohl(ame);     /* do comparisons in host order */
265     magicServer = (struct ubik_server *)0;
266
267     if (info) {
268         for (i = 0; i < info->numServers; i++) {
269             if (ntohl((afs_uint32) info->hostAddr[i].sin_addr.s_addr) ==
270                 ntohl((afs_uint32) ame)) {
271                 me = i;
272                 if (clones[i]) {
273                     amIClone = 1;
274                     magicHost = 0;
275                 }
276             }
277         }
278         nServers = 0;
279         for (i = 0; i < info->numServers; i++) {
280             if (i == me)
281                 continue;
282             ts = (struct ubik_server *)malloc(sizeof(struct ubik_server));
283             memset(ts, 0, sizeof(struct ubik_server));
284             ts->next = ubik_servers;
285             ubik_servers = ts;
286             ts->addr[0] = info->hostAddr[i].sin_addr.s_addr;
287             if (clones[i]) {
288                 ts->isClone = 1;
289             } else {
290                 if (!magicHost
291                     || ntohl((afs_uint32) ts->addr[0]) <
292                     (afs_uint32) magicHost) {
293                     magicHost = ntohl(ts->addr[0]);
294                     magicServer = ts;
295                 }
296                 ++nServers;
297             }
298             /* for vote reqs */
299             ts->vote_rxcid =
300                 rx_NewConnection(info->hostAddr[i].sin_addr.s_addr,
301                                  ubik_callPortal, VOTE_SERVICE_ID,
302                                  ubikSecClass, ubikSecIndex);
303             /* for disk reqs */
304             ts->disk_rxcid =
305                 rx_NewConnection(info->hostAddr[i].sin_addr.s_addr,
306                                  ubik_callPortal, DISK_SERVICE_ID,
307                                  ubikSecClass, ubikSecIndex);
308             ts->up = 1;
309         }
310     } else {
311         i = 0;
312         while ((servAddr = *aservers++)) {
313             if (i >= MAXSERVERS)
314                 return UNHOSTS; /* too many hosts */
315             ts = (struct ubik_server *)malloc(sizeof(struct ubik_server));
316             memset(ts, 0, sizeof(struct ubik_server));
317             ts->next = ubik_servers;
318             ubik_servers = ts;
319             ts->addr[0] = servAddr;     /* primary address in  net byte order */
320             ts->vote_rxcid = rx_NewConnection(servAddr, ubik_callPortal, VOTE_SERVICE_ID, ubikSecClass, ubikSecIndex);  /* for vote reqs */
321             ts->disk_rxcid = rx_NewConnection(servAddr, ubik_callPortal, DISK_SERVICE_ID, ubikSecClass, ubikSecIndex);  /* for disk reqs */
322             ts->isClone = 0;    /* don't know about clones */
323             ts->up = 1;
324             if (ntohl((afs_uint32) servAddr) < (afs_uint32) magicHost) {
325                 magicHost = ntohl(servAddr);
326                 magicServer = ts;
327             }
328             i++;
329         }
330     }
331     if (magicServer)
332         magicServer->magic = 1; /* remember for when counting votes */
333
334     if (!amIClone && !magicServer)
335         amIMagic = 1;
336     if (info) {
337         if (!amIClone)
338             ++nServers;         /* count this server as well as the remotes */
339     } else
340         nServers = i + 1;       /* count this server as well as the remotes */
341
342     ubik_quorum = (nServers >> 1) + 1;  /* compute the majority figure */
343     /* send addrs to all other servers */
344     code = updateUbikNetworkAddress(ubik_host);
345     if (code)
346         return code;
347
348 /* Shoud we set some defaults for RX??
349     r_retryInterval = 2;
350     r_nRetries = (RPCTIMEOUT/r_retryInterval);
351 */
352     if (info) {
353         if (!ubik_servers)      /* special case 1 server */
354             ubik_singleServer = 1;
355         if (nServers == 1 && !amIClone) {
356             ubik_amSyncSite = 1;        /* let's start as sync site */
357             syncSiteUntil = 0x7fffffff; /* and be it quite a while */
358         }
359     } else {
360         if (nServers == 1)      /* special case 1 server */
361             ubik_singleServer = 1;
362     }
363
364     if (ubik_singleServer) {
365         if (!ubik_amSyncSite)
366             ubik_dprint("Ubik: I am the sync site - 1 server\n");
367         ubik_amSyncSite = 1;
368         syncSiteUntil = 0x7fffffff;     /* quite a while */
369     }
370     return 0;
371 }
372
373 /*!
374  * \brief main lwp loop for code that sends out beacons.
375  *
376  * This code only runs while we're sync site or we want to be the sync site.
377  * It runs in its very own light-weight process.
378  */
379 void *
380 ubeacon_Interact(void *dummy)
381 {
382     afs_int32 code;
383     struct timeval tt;
384     struct rx_connection *connections[MAXSERVERS];
385     struct ubik_server *servers[MAXSERVERS];
386     afs_int32 i;
387     struct ubik_server *ts;
388     afs_int32 temp, yesVotes, lastWakeupTime, oldestYesVote, syncsite;
389     struct ubik_tid ttid;
390     afs_int32 startTime;
391
392     /* loop forever getting votes */
393     lastWakeupTime = 0;         /* keep track of time we last started a vote collection */
394     while (1) {
395
396         /* don't wakeup more than every POLLTIME seconds */
397         temp = (lastWakeupTime + POLLTIME) - FT_ApproxTime();
398         /* don't sleep if last collection phase took too long (probably timed someone out ) */
399         if (temp > 0) {
400             if (temp > POLLTIME)
401                 temp = POLLTIME;
402             tt.tv_sec = temp;
403             tt.tv_usec = 0;
404 #ifdef AFS_PTHREAD_ENV
405             code = select(0, 0, 0, 0, &tt);
406 #else
407             code = IOMGR_Select(0, 0, 0, 0, &tt);
408 #endif
409         } else
410             code = 0;
411
412         lastWakeupTime = FT_ApproxTime();       /* started a new collection phase */
413
414         if (ubik_singleServer)
415             continue;           /* special-case 1 server for speedy startup */
416
417         if (!uvote_ShouldIRun())
418             continue;           /* if voter has heard from a better candidate than us, don't bother running */
419
420         /* otherwise we should run for election, or we're the sync site (and have already won);
421          * send out the beacon packets */
422         /* build list of all up hosts (noticing dead hosts are running again
423          * is a task for the recovery module, not the beacon module), and
424          * prepare to send them an r multi-call containing the beacon message */
425         i = 0;                  /* collect connections */
426         for (ts = ubik_servers; ts; ts = ts->next) {
427             if (ts->up && ts->addr[0] != ubik_host[0]) {
428                 servers[i] = ts;
429                 connections[i++] = ts->vote_rxcid;
430             }
431         }
432         servers[i] = (struct ubik_server *)0;   /* end of list */
433         /* note that we assume in the vote module that we'll always get at least BIGTIME
434          * seconds of vote from anyone who votes for us, which means we can conservatively
435          * assume we'll be fine until SMALLTIME seconds after we start collecting votes */
436         /* this next is essentially an expansion of rgen's ServBeacon routine */
437
438         ttid.epoch = ubik_epochTime;
439         if (ubik_dbase->flags & DBWRITING) {
440             /*
441              * if a write is in progress, we have to send the writeTidCounter
442              * which holds the tid counter of the write transaction , and not
443              * send the tidCounter value which holds the tid counter of the
444              * last transaction.
445              */
446             ttid.counter = ubik_dbase->writeTidCounter;
447         } else
448             ttid.counter = ubik_dbase->tidCounter + 1;
449 #if defined(UBIK_PAUSE)
450         ubik_dbase->flags |= DBVOTING;
451 #endif /* UBIK_PAUSE */
452
453         /* now analyze return codes, counting up our votes */
454         yesVotes = 0;           /* count how many to ensure we have quorum */
455         oldestYesVote = 0x7fffffff;     /* time quorum expires */
456         syncsite = ubeacon_AmSyncSite();
457         startTime = FT_ApproxTime();
458         /*
459          * Don't waste time using mult Rx calls if there are no connections out there
460          */
461         if (i > 0) {
462             char hoststr[16];
463             multi_Rx(connections, i) {
464                 multi_VOTE_Beacon(syncsite, startTime, &ubik_dbase->version,
465                                   &ttid);
466                 temp = FT_ApproxTime(); /* now, more or less */
467                 ts = servers[multi_i];
468                 ts->lastBeaconSent = temp;
469                 code = multi_error;
470                 /* note that the vote time (the return code) represents the time
471                  * the vote was computed, *not* the time the vote expires.  We compute
472                  * the latter down below if we got enough votes to go with */
473                 if (code > 0) {
474                     if ((code & ~0xff) == ERROR_TABLE_BASE_RXK) {
475                         ubik_dprint("token error %d from host %s\n",
476                                     code, afs_inet_ntoa_r(ts->addr[0], hoststr));
477                         ts->up = 0;
478                         ts->beaconSinceDown = 0;
479                         urecovery_LostServer(ts);
480                     } else {
481                         ts->lastVoteTime = code;
482                         if (code < oldestYesVote)
483                             oldestYesVote = code;
484                         ts->lastVote = 1;
485                         if (!ts->isClone)
486                             yesVotes += 2;
487                         if (ts->magic)
488                             yesVotes++; /* the extra epsilon */
489                         ts->up = 1;     /* server is up (not really necessary: recovery does this for real) */
490                         ts->beaconSinceDown = 1;
491                         ubik_dprint("yes vote from host %s\n",
492                                     afs_inet_ntoa_r(ts->addr[0], hoststr));
493                     }
494                 } else if (code == 0) {
495                     ts->lastVoteTime = temp;
496                     ts->lastVote = 0;
497                     ts->beaconSinceDown = 1;
498                     ubik_dprint("no vote from %s\n",
499                                 afs_inet_ntoa_r(ts->addr[0], hoststr));
500                 } else if (code < 0) {
501                     ts->up = 0;
502                     ts->beaconSinceDown = 0;
503                     urecovery_LostServer(ts);
504                     ubik_dprint("time out from %s\n",
505                                 afs_inet_ntoa_r(ts->addr[0], hoststr));
506                 }
507             }
508             multi_End;
509         }
510         /* now call our own voter module to see if we'll vote for ourself.  Note that
511          * the same restrictions apply for our voting for ourself as for our voting
512          * for anyone else. */
513         i = SVOTE_Beacon((struct rx_call *)0, ubeacon_AmSyncSite(), startTime,
514                          &ubik_dbase->version, &ttid);
515         if (i) {
516             yesVotes += 2;
517             if (amIMagic)
518                 yesVotes++;     /* extra epsilon */
519             if (i < oldestYesVote)
520                 oldestYesVote = i;
521         }
522 #if defined(UBIK_PAUSE)
523         ubik_dbase->flags &= ~DBVOTING;
524 #endif /* UBIK_PAUSE */
525
526         /* now decide if we have enough votes to become sync site.
527          * Note that we can still get enough votes even if we didn't for ourself. */
528         if (yesVotes > nServers) {      /* yesVotes is bumped by 2 or 3 for each site */
529             if (!ubik_amSyncSite)
530                 ubik_dprint("Ubik: I am the sync site\n");
531             ubik_amSyncSite = 1;
532             syncSiteUntil = oldestYesVote + SMALLTIME;
533 #ifndef AFS_PTHREAD_ENV
534                 /* I did not find a corresponding LWP_WaitProcess(&ubik_amSyncSite) --
535                    this may be a spurious signal call -- sjenkins */
536                 LWP_NoYieldSignal(&ubik_amSyncSite);
537 #endif
538         } else {
539             if (ubik_amSyncSite)
540                 ubik_dprint("Ubik: I am no longer the sync site\n");
541             ubik_amSyncSite = 0;
542             urecovery_ResetState();     /* tell recovery we're no longer the sync site */
543         }
544
545     }                           /* while loop */
546     return NULL;
547 }
548
549 /*!
550  * \brief Verify that a given IP addresses does actually exist on this machine.
551  *
552  * \param ame      the pointer to my IP address specified in the
553  *                 CellServDB file.
554  * \param aservers an array containing IP
555  *                 addresses of remote ubik servers. The array is
556  *                 terminated by a zero address.
557  *
558  * Algorithm     : Verify that my IP addresses \p ame does actually exist
559  *                 on this machine.  If any of my IP addresses are there
560  *                 in the remote server list \p aserver, remove them from
561  *                 this list.  Update global variable \p ubik_host[] with
562  *                 my IP addresses.
563  *
564  * \return 0 on success, non-zero on failure
565  */
566 static int
567 verifyInterfaceAddress(afs_uint32 *ame, struct afsconf_cell *info,
568                        afs_uint32 aservers[]) {
569     afs_uint32 myAddr[UBIK_MAX_INTERFACE_ADDR], *servList, tmpAddr;
570     afs_uint32 myAddr2[UBIK_MAX_INTERFACE_ADDR];
571     char hoststr[16];
572     int tcount, count, found, i, j, totalServers, start, end, usednetfiles =
573         0;
574
575     if (info)
576         totalServers = info->numServers;
577     else {                      /* count the number of servers */
578         for (totalServers = 0, servList = aservers; *servList; servList++)
579             totalServers++;
580     }
581
582     if (AFSDIR_SERVER_NETRESTRICT_FILEPATH || AFSDIR_SERVER_NETINFO_FILEPATH) {
583         /*
584          * Find addresses we are supposed to register as per the netrestrict file
585          * if it exists, else just register all the addresses we find on this
586          * host as returned by rx_getAllAddr (in NBO)
587          */
588         char reason[1024];
589         count =
590             parseNetFiles(myAddr, NULL, NULL, UBIK_MAX_INTERFACE_ADDR, reason,
591                           AFSDIR_SERVER_NETINFO_FILEPATH,
592                           AFSDIR_SERVER_NETRESTRICT_FILEPATH);
593         if (count < 0) {
594             ubik_print("ubik: Can't register any valid addresses:%s\n",
595                        reason);
596             ubik_print("Aborting..\n");
597             return UBADHOST;
598         }
599         usednetfiles++;
600     } else {
601         /* get all my interface addresses in net byte order */
602         count = rx_getAllAddr(myAddr, UBIK_MAX_INTERFACE_ADDR);
603     }
604
605     if (count <= 0) {           /* no address found */
606         ubik_print("ubik: No network addresses found, aborting..");
607         return UBADHOST;
608     }
609
610     /* verify that the My-address passed in by ubik is correct */
611     for (j = 0, found = 0; j < count; j++) {
612         if (*ame == myAddr[j]) {        /* both in net byte order */
613             found = 1;
614             break;
615         }
616     }
617
618     if (!found) {
619         ubik_print("ubik: primary address %s does not exist\n",
620                    afs_inet_ntoa_r(*ame, hoststr));
621         /* if we had the result of rx_getAllAddr already, avoid subverting
622          * the "is gethostbyname(gethostname()) us" check. If we're
623          * using NetInfo/NetRestrict, we assume they have enough clue
624          * to avoid that big hole in their foot from the loaded gun. */
625         if (usednetfiles) {
626             /* take the address we did get, then see if ame was masked */
627             *ame = myAddr[0];
628             tcount = rx_getAllAddr(myAddr2, UBIK_MAX_INTERFACE_ADDR);
629             if (tcount <= 0) {  /* no address found */
630                 ubik_print("ubik: No network addresses found, aborting..");
631                 return UBADHOST;
632             }
633
634             /* verify that the My-address passed in by ubik is correct */
635             for (j = 0, found = 0; j < tcount; j++) {
636                 if (*ame == myAddr2[j]) {       /* both in net byte order */
637                     found = 1;
638                     break;
639                 }
640             }
641         }
642         if (!found)
643             return UBADHOST;
644     }
645
646     /* if any of my addresses are there in serverList, then
647      ** use that as my primary addresses : the higher level
648      ** application screwed up in dealing with multihomed concepts
649      */
650     for (j = 0, found = 0; j < count; j++) {
651         for (i = 0; i < totalServers; i++) {
652             if (info)
653                 tmpAddr = (afs_uint32) info->hostAddr[i].sin_addr.s_addr;
654             else
655                 tmpAddr = aservers[i];
656             if (myAddr[j] == tmpAddr) {
657                 *ame = tmpAddr;
658                 if (!info)
659                     aservers[i] = 0;
660                 found = 1;
661             }
662         }
663     }
664     if (found)
665         ubik_print("Using %s as my primary address\n", afs_inet_ntoa_r(*ame, hoststr));
666
667     if (!info) {
668         /* get rid of servers which were purged because all
669          ** those interface addresses are myself
670          */
671         for (start = 0, end = totalServers - 1; (start < end); start++, end--) {
672             /* find the first zero entry from the beginning */
673             for (; (start < end) && (aservers[start]); start++);
674
675             /* find the last non-zero entry from the end */
676             for (; (end >= 0) && (!aservers[end]); end--);
677
678             /* if there is nothing more to purge, exit from loop */
679             if (start >= end)
680                 break;
681
682             /* move the entry */
683             aservers[start] = aservers[end];
684             aservers[end] = 0;  /* this entry was moved */
685         }
686     }
687
688     /* update all my addresses in ubik_host in such a way
689      ** that ubik_host[0] has the primary address
690      */
691     ubik_host[0] = *ame;
692     for (j = 0, i = 1; j < count; j++)
693         if (*ame != myAddr[j])
694             ubik_host[i++] = myAddr[j];
695
696     return 0;                   /* return success */
697 }
698
699
700 /*!
701  * \brief Exchange IP address information with remote servers.
702  *
703  * \param ubik_host an array containing all my IP addresses.
704  *
705  * Algorithm     : Do an RPC to all remote ubik servers infroming them
706  *                 about my IP addresses. Get their IP addresses and
707  *                 update my linked list of ubik servers \p ubik_servers
708  *
709  * \return 0 on success, non-zero on failure
710  */
711 static int
712 updateUbikNetworkAddress(afs_uint32 ubik_host[UBIK_MAX_INTERFACE_ADDR])
713 {
714     int j, count, code = 0;
715     UbikInterfaceAddr inAddr, outAddr;
716     struct rx_connection *conns[MAXSERVERS];
717     struct ubik_server *ts, *server[MAXSERVERS];
718     char buffer[32];
719     char hoststr[16];
720
721     for (count = 0, ts = ubik_servers; ts; count++, ts = ts->next) {
722         conns[count] = ts->disk_rxcid;
723         server[count] = ts;
724     }
725
726
727     /* inform all other servers only if there are more than one
728      * database servers in the cell */
729
730     if (count > 0) {
731
732         for (j = 0; j < UBIK_MAX_INTERFACE_ADDR; j++)
733             inAddr.hostAddr[j] = ntohl(ubik_host[j]);
734
735
736         /* do the multi-RX RPC to all other servers */
737         multi_Rx(conns, count) {
738             multi_DISK_UpdateInterfaceAddr(&inAddr, &outAddr);
739             ts = server[multi_i];       /* reply received from this server */
740             if (!multi_error) {
741                 if (ts->addr[0] != htonl(outAddr.hostAddr[0])) {
742                     code = UBADHOST;
743                     strcpy(buffer, afs_inet_ntoa_r(ts->addr[0], hoststr));
744                     ubik_print("ubik:Two primary addresses for same server \
745                     %s %s\n", buffer,
746                     afs_inet_ntoa_r(htonl(outAddr.hostAddr[0]), hoststr));
747                 } else {
748                     for (j = 1; j < UBIK_MAX_INTERFACE_ADDR; j++)
749                         ts->addr[j] = htonl(outAddr.hostAddr[j]);
750                 }
751             } else if (multi_error == RXGEN_OPCODE) {   /* pre 3.5 remote server */
752                 ubik_print
753                     ("ubik server %s does not support UpdateInterfaceAddr RPC\n",
754                      afs_inet_ntoa_r(ts->addr[0], hoststr));
755             } else if (multi_error == UBADHOST) {
756                 code = UBADHOST;        /* remote CellServDB inconsistency */
757                 ubik_print("Inconsistent Cell Info on server: ");
758                 for (j = 0; j < UBIK_MAX_INTERFACE_ADDR && ts->addr[j]; j++)
759                     ubik_print("%s ", afs_inet_ntoa_r(ts->addr[j], hoststr));
760                 ubik_print("\n");
761             } else {
762                 ts->up = 0;     /* mark the remote server as down */
763             }
764         }
765         multi_End;
766     }
767     return code;
768 }