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