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