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