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