src/ubik/ubikclient.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 #include <afs/stds.h>
  13
  14 #include <roken.h>
  15 #include <afs/opr.h>
  16 #ifdef AFS_PTHREAD_ENV
  17 # include <opr/lock.h>
  18 #endif
  19
  20 #ifdef IGNORE_SOME_GCC_WARNINGS
  21 # pragma GCC diagnostic warning "-Wstrict-prototypes"
  22 #endif
  23
  24 #ifdef UKERNEL
  25 #include "afsincludes.h"
  26 #endif
  27
  28 #include <afs/pthread_glock.h>
  29 #include <rx/xdr.h>
  30 #include <rx/rx.h>
  31 #include <lock.h>
  32 #include <afs/rxgen_consts.h>
  33 #define UBIK_LEGACY_CALLITER
  34 #include "ubik.h"
  35
  36 short ubik_initializationState; /*!< initial state is zero */
  37
  38
  39 /*!
  40  * \brief Parse list for clients.
  41  */
  42 int
  43 ubik_ParseClientList(int argc, char **argv, afs_uint32 * aothers)
  44 {
  45     afs_int32 i;
  46     char *tp;
  47     struct hostent *th;
  48     afs_uint32 temp;
  49     afs_int32 counter;
  50     int inServer;
  51
  52     inServer = 0;               /* haven't seen -servers yet */
  53     counter = 0;
  54     for (i = 1; i < argc; i++) {
  55         /* look for -servers argument */
  56         tp = argv[i];
  57
  58         if (inServer) {
  59             if (*tp == '-')
  60                 break;          /* done */
  61             /* otherwise this is a new host name */
  62             LOCK_GLOBAL_MUTEX;
  63             th = gethostbyname(tp);
  64             if (!th) {
  65                 UNLOCK_GLOBAL_MUTEX;
  66                 return UBADHOST;
  67             }
  68             memmove((void *)&temp, (const void *)th->h_addr,
  69                     sizeof(afs_int32));
  70             UNLOCK_GLOBAL_MUTEX;
  71             if (counter++ >= MAXSERVERS)
  72                 return UNHOSTS;
  73             *aothers++ = temp;
  74         } else {
  75             /* haven't seen a -server yet */
  76             if (!strcmp(tp, "-servers")) {
  77                 inServer = 1;
  78             }
  79         }
  80     }
  81     if (!inServer) {
  82         /* never saw a -server */
  83         return UNOENT;
  84     }
  85     if (counter < MAXSERVERS)
  86         *aothers++ = 0;         /* null terminate if room */
  87     return 0;
  88 }
  89
  90 #ifdef AFS_PTHREAD_ENV
  91 #include <pthread.h>
  92
  93 static pthread_once_t random_once = PTHREAD_ONCE_INIT;
  94 static int called_afs_random_once;
  95 static pthread_key_t random_number_key;
  96
  97 static void
  98 afs_random_once(void)
  99 {
 100     opr_Verify(pthread_key_create(&random_number_key, NULL) == 0);
 101     called_afs_random_once = 1;
 102 }
 103
 104 #endif
 105
 106 #if !defined(UKERNEL)
 107 /*!
 108  * \brief use time and pid to try to get some initial randomness.
 109  */
 110 #define ranstage(x)     (x)= (afs_uint32) (3141592621U*((afs_uint32)x)+1)
 111
 112 /*!
 113  * \brief Random number generator and constants from KnuthV2 2d ed, p170
 114  *
 115  * Rules: \n
 116  * X = (aX + c) % m \n
 117  * m is a power of two \n
 118  * a % 8 is 5 \n
 119  * a is 0.73m  should be 0.01m .. 0.99m \n
 120  * c is more or less immaterial.  1 or a is suggested. \n
 121  *
 122  * NB:  LOW ORDER BITS are not very random.  To get small random numbers,
 123  *      treat result as <1, with implied binary point, and multiply by
 124  *      desired modulus.
 125  *
 126  * NB:  Has to be unsigned, since shifts on signed quantities may preserve
 127  *      the sign bit.
 128  *
 129  * In this case, m == 2^32, the mod operation is implicit. a == pi, which
 130  * is used because it has some interesting characteristics (lacks any
 131  * interesting bit-patterns).
 132  */
 133 unsigned int
 134 afs_random(void)
 135 {
 136 #ifdef AFS_PTHREAD_ENV
 137     afs_uint32 state;
 138
 139     if (!called_afs_random_once)
 140         pthread_once(&random_once, afs_random_once);
 141
 142     state = (uintptr_t) pthread_getspecific(random_number_key);
 143 #else
 144     static afs_uint32 state = 0;
 145 #endif
 146
 147     if (!state) {
 148         int i;
 149         state = time(0) + getpid();
 150         for (i = 0; i < 15; i++) {
 151             ranstage(state);
 152         }
 153     }
 154
 155     ranstage(state);
 156 #ifdef AFS_PTHREAD_ENV
 157     pthread_setspecific(random_number_key, (const void *)(uintptr_t)state);
 158 #endif
 159     return (state);
 160
 161 }
 162
 163 /*!
 164  * \brief Returns int 0..14 using the high bits of a pseudo-random number instead of
 165  * the low bits, as the low bits are "less random" than the high ones...
 166  *
 167  * \todo Slight roundoff error exists, an excercise for the reader.
 168  *
 169  * Need to multiply by something with lots of ones in it, so multiply by
 170  * 8 or 16 is right out.
 171  */
 172 static unsigned int
 173 afs_randomMod15(void)
 174 {
 175     afs_uint32 temp;
 176
 177     temp = afs_random() >> 4;
 178     temp = (temp * 15) >> 28;
 179
 180     return temp;
 181 }
 182 #endif /* !defined(UKERNEL) */
 183
 184 #ifdef abs
 185 #undef abs
 186 #endif /* abs */
 187 #define abs(a) ((a) < 0 ? -1*(a) : (a))
 188 int
 189 ubik_ClientInit(struct rx_connection **serverconns,
 190                 struct ubik_client **aclient)
 191 {
 192     int i, j;
 193     int count;
 194     int offset;
 195     struct ubik_client *tc;
 196
 197     initialize_U_error_table();
 198
 199     if (*aclient) {             /* the application is doing a re-initialization */
 200         LOCK_UBIK_CLIENT((*aclient));
 201         /* this is an important defensive check */
 202         if (!((*aclient)->initializationState)) {
 203             UNLOCK_UBIK_CLIENT((*aclient));
 204             return UREINITIALIZE;
 205         }
 206
 207         /* release all existing connections */
 208         for (tc = *aclient, i = 0; i < MAXSERVERS; i++) {
 209             struct rx_connection *rxConn = ubik_GetRPCConn(tc, i);
 210             if (rxConn == 0)
 211                 break;
 212 #ifdef AFS_PTHREAD_ENV
 213             rx_ReleaseCachedConnection(rxConn);
 214 #else
 215             rx_DestroyConnection(rxConn);
 216 #endif
 217         }
 218         UNLOCK_UBIK_CLIENT((*aclient));
 219 #ifdef AFS_PTHREAD_ENV
 220         if (pthread_mutex_destroy(&((*aclient)->cm)))
 221             return UMUTEXDESTROY;
 222 #endif
 223     } else {
 224         tc = malloc(sizeof(struct ubik_client));
 225     }
 226     if (tc == NULL)
 227         return UNOMEM;
 228     memset((void *)tc, 0, sizeof(*tc));
 229 #ifdef AFS_PTHREAD_ENV
 230     if (pthread_mutex_init(&(tc->cm), (const pthread_mutexattr_t *)0)) {
 231         free(tc);
 232         return UMUTEXINIT;
 233     }
 234 #endif
 235     tc->initializationState = ++ubik_initializationState;
 236
 237     /* first count the # of server conns so we can randomize properly */
 238     count = 0;
 239     for (i = 0; i < MAXSERVERS; i++) {
 240         if (serverconns[i] == (struct rx_connection *)0)
 241             break;
 242         count++;
 243     }
 244
 245     /* here count is the # of servers we're actually passed in.  Compute
 246      * offset, a number between 0..count-1, where we'll start copying from the
 247      * client-provided array. */
 248     for (i = 0; i < count; i++) {
 249         offset = afs_randomMod15() % count;
 250         for (j = abs(offset); j < 2 * count; j++) {
 251             if (!tc->conns[abs(j % count)]) {
 252                 tc->conns[abs(j % count)] = serverconns[i];
 253                 break;
 254             }
 255         }
 256     }
 257
 258     *aclient = tc;
 259     return 0;
 260 }
 261
 262 /*!
 263  * \brief Destroy an ubik connection.
 264  *
 265  * It calls rx to destroy the component rx connections, then frees the ubik
 266  * connection structure.
 267  */
 268 afs_int32
 269 ubik_ClientDestroy(struct ubik_client * aclient)
 270 {
 271     int c;
 272
 273     if (aclient == 0)
 274         return 0;
 275     LOCK_UBIK_CLIENT(aclient);
 276     for (c = 0; c < MAXSERVERS; c++) {
 277         struct rx_connection *rxConn = ubik_GetRPCConn(aclient, c);
 278         if (rxConn == 0)
 279             break;
 280 #ifdef AFS_PTHREAD_ENV
 281         rx_ReleaseCachedConnection(rxConn);
 282 #else
 283         rx_DestroyConnection(rxConn);
 284 #endif
 285     }
 286     aclient->initializationState = 0;   /* client in not initialized */
 287     UNLOCK_UBIK_CLIENT(aclient);
 288 #ifdef AFS_PTHREAD_ENV
 289     pthread_mutex_destroy(&(aclient->cm));      /* ignore failure */
 290 #endif
 291     free(aclient);
 292     return 0;
 293 }
 294
 295 /*!
 296  * \brief So that intermittent failures that cause connections to die
 297  *     don't kill whole ubik connection, refresh them when the connection is in
 298  *     error.
 299  */
 300 struct rx_connection *
 301 ubik_RefreshConn(struct rx_connection *tc)
 302 {
 303     afs_uint32 host;
 304     u_short port;
 305     u_short service;
 306     struct rx_securityClass *sc;
 307     int si;
 308     struct rx_connection *newTc;
 309
 310     host = rx_HostOf(rx_PeerOf(tc));
 311     port = rx_PortOf(rx_PeerOf(tc));
 312     service = rx_ServiceIdOf(tc);
 313     sc = rx_SecurityObjectOf(tc);
 314     si = rx_SecurityClassOf(tc);
 315
 316     /*
 317      * destroy old one after creating new one so that refCount on security
 318      * object cannot reach zero.
 319      */
 320     newTc = rx_NewConnection(host, port, service, sc, si);
 321     rx_DestroyConnection(tc);
 322     return newTc;
 323 }
 324
 325 #ifdef AFS_PTHREAD_ENV
 326
 327 pthread_once_t ubik_client_once = PTHREAD_ONCE_INIT;
 328 pthread_mutex_t ubik_client_mutex;
 329 #define LOCK_UCLNT_CACHE do { \
 330     opr_Verify(pthread_once(&ubik_client_once, ubik_client_init_mutex) == 0); \
 331     MUTEX_ENTER(&ubik_client_mutex); \
 332   } while (0)
 333 #define UNLOCK_UCLNT_CACHE MUTEX_EXIT(&ubik_client_mutex)
 334
 335 void
 336 ubik_client_init_mutex(void)
 337 {
 338     MUTEX_INIT(&ubik_client_mutex, "client init", MUTEX_DEFAULT, 0);
 339 }
 340
 341 #else
 342
 343 #define LOCK_UCLNT_CACHE
 344 #define UNLOCK_UCLNT_CACHE
 345
 346 #endif
 347
 348 #define SYNCCOUNT 10
 349 static int *calls_needsync[SYNCCOUNT];  /* proc calls that need the sync site */
 350 static int synccount = 0;
 351
 352
 353
 354 /*!
 355  * \brief Call this after getting back a #UNOTSYNC.
 356  *
 357  * \note Getting a #UNOTSYNC error code back does \b not guarantee
 358  * that there is a sync site yet elected.  However, if there is a sync
 359  * site out there somewhere, and you're trying an operation that
 360  * requires a sync site, ubik will return #UNOTSYNC, indicating the
 361  * operation won't work until you find a sync site
 362  */
 363 static int
 364 try_GetSyncSite(struct ubik_client *aclient, afs_int32 apos)
 365 {
 366     struct rx_peer *rxp;
 367     afs_int32 code;
 368     int i;
 369     afs_int32 thisHost, newHost;
 370     struct rx_connection *tc;
 371     short origLevel;
 372
 373     origLevel = aclient->initializationState;
 374
 375     /* get this conn */
 376     tc = aclient->conns[apos];
 377     if (tc && rx_ConnError(tc)) {
 378         aclient->conns[apos] = (tc = ubik_RefreshConn(tc));
 379     }
 380     if (!tc) {
 381         return -1;
 382     }
 383
 384     /* now see if we can find the sync site host */
 385     code = VOTE_GetSyncSite(tc, &newHost);
 386     if (aclient->initializationState != origLevel) {
 387         return -1;              /* somebody did a ubik_ClientInit */
 388     }
 389
 390     if (!code && newHost) {
 391         newHost = htonl(newHost);       /* convert back to network order */
 392
 393         /*
 394          * position count at the appropriate slot in the client
 395          * structure and retry. If we can't find in slot, we'll just
 396          * continue through the whole list
 397          */
 398         for (i = 0; i < MAXSERVERS; i++) {
 399             rxp = rx_PeerOf(aclient->conns[i]);
 400             thisHost = rx_HostOf(rxp);
 401             if (!thisHost) {
 402                 return -1;
 403             } else if (thisHost == newHost) {
 404                 return i;       /* we were told to use this one */
 405             }
 406         }
 407     }
 408     return -1;
 409 }
 410
 411 #define NEED_LOCK 1
 412 #define NO_LOCK 0
 413
 414 /*!
 415  * \brief Create an internal version of ubik_CallIter that takes an additional
 416  * parameter - to indicate whether the ubik client handle has already
 417  * been locked.
 418  */
 419 static afs_int32
 420 CallIter(int (*aproc) (), struct ubik_client *aclient,
 421          afs_int32 aflags, int *apos, long p1, long p2, long p3, long p4,
 422          long p5, long p6, long p7, long p8, long p9, long p10, long p11,
 423          long p12, long p13, long p14, long p15, long p16, int needlock)
 424 {
 425     afs_int32 code;
 426     struct rx_connection *tc;
 427     short origLevel;
 428
 429     if (needlock) {
 430         LOCK_UBIK_CLIENT(aclient);
 431     }
 432     origLevel = aclient->initializationState;
 433
 434     code = UNOSERVERS;
 435
 436     while (*apos < MAXSERVERS) {
 437         /* tc is the next conn to try */
 438         tc = aclient->conns[*apos];
 439         if (!tc)
 440             goto errout;
 441
 442         if (rx_ConnError(tc)) {
 443             tc = ubik_RefreshConn(tc);
 444             aclient->conns[*apos] = tc;
 445         }
 446
 447         if ((aflags & UPUBIKONLY) && (aclient->states[*apos] & CFLastFailed)) {
 448             (*apos)++;          /* try another one if this server is down */
 449         } else {
 450             break;              /* this is the desired path */
 451         }
 452     }
 453     if (*apos >= MAXSERVERS)
 454         goto errout;
 455
 456     code =
 457         (*aproc) (tc, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13,
 458                   p14, p15, p16);
 459     if (aclient->initializationState != origLevel)
 460         /* somebody did a ubik_ClientInit */
 461         goto errout;
 462
 463     /* what should I do in case of UNOQUORUM ? */
 464     if (code < 0) {
 465         aclient->states[*apos] |= CFLastFailed; /* network errors */
 466     } else {
 467         /* either misc ubik code, or misc application code or success. */
 468         aclient->states[*apos] &= ~CFLastFailed;        /* operation worked */
 469     }
 470
 471     (*apos)++;
 472 errout:
 473     if (needlock) {
 474         UNLOCK_UBIK_CLIENT(aclient);
 475     }
 476     return code;
 477 }
 478
 479 /*!
 480  * \brief This is part of an iterator.  It doesn't handle finding sync sites.
 481  */
 482 afs_int32
 483 ubik_CallIter(int (*aproc) (), struct ubik_client *aclient,
 484                                afs_int32 aflags, int *apos, long p1, long p2,
 485                                long p3, long p4, long p5, long p6, long p7,
 486                                long p8, long p9, long p10, long p11, long p12,
 487                                long p13, long p14, long p15, long p16)
 488 {
 489     return CallIter(aproc, aclient, aflags, apos, p1, p2, p3, p4, p5, p6, p7,
 490                     p8, p9, p10, p11, p12, p13, p14, p15, p16, NEED_LOCK);
 491 }
 492
 493 /*!
 494  * \brief Call this instead of stub and we'll guarantee to find a host that's up.
 495  *
 496  * \todo In the future, we should also put in a protocol to find the sync site.
 497  */
 498 afs_int32
 499 ubik_Call_New(int (*aproc) (), struct ubik_client *aclient,
 500               afs_int32 aflags, long p1, long p2, long p3, long p4, long p5,
 501               long p6, long p7, long p8, long p9, long p10, long p11,
 502               long p12, long p13, long p14, long p15, long p16)
 503 {
 504     afs_int32 code, rcode;
 505     afs_int32 count;
 506     afs_int32 temp;
 507     int pass;
 508     int stepBack;
 509     short origLevel;
 510
 511     LOCK_UBIK_CLIENT(aclient);
 512   restart:
 513     rcode = UNOSERVERS;
 514     origLevel = aclient->initializationState;
 515
 516     /* Do two passes. First pass only checks servers known running */
 517     for (aflags |= UPUBIKONLY, pass = 0; pass < 2;
 518          pass++, aflags &= ~UPUBIKONLY) {
 519         stepBack = 0;
 520         count = 0;
 521         while (1) {
 522             code =
 523                 CallIter(aproc, aclient, aflags, &count, p1, p2, p3, p4, p5,
 524                          p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16,
 525                          NO_LOCK);
 526             if (code && (aclient->initializationState != origLevel)) {
 527                 goto restart;
 528             }
 529             if (code == UNOSERVERS) {
 530                 break;
 531             }
 532             rcode = code;       /* remember code from last good call */
 533
 534             if (code == UNOTSYNC) {     /* means this requires a sync site */
 535                 if (aclient->conns[3]) {        /* don't bother unless 4 or more srv */
 536                     temp = try_GetSyncSite(aclient, count);
 537                     if (aclient->initializationState != origLevel) {
 538                         goto restart;   /* somebody did a ubik_ClientInit */
 539                     }
 540                     if ((temp >= 0) && ((temp > count) || (stepBack++ <= 2))) {
 541                         count = temp;   /* generally try to make progress */
 542                     }
 543                 }
 544             } else if ((code >= 0) && (code != UNOQUORUM)) {
 545                 UNLOCK_UBIK_CLIENT(aclient);
 546                 return code;    /* success or global error condition */
 547             }
 548         }
 549     }
 550     UNLOCK_UBIK_CLIENT(aclient);
 551     return rcode;
 552 }
 553
 554 /*!
 555  * call this instead of stub and we'll guarantee to find a host that's up.
 556  *
 557  * \todo In the future, we should also put in a protocol to find the sync site.
 558  */
 559 afs_int32
 560 ubik_Call(int (*aproc) (), struct ubik_client *aclient,
 561           afs_int32 aflags, long p1, long p2, long p3, long p4,
 562           long p5, long p6, long p7, long p8, long p9, long p10,
 563           long p11, long p12, long p13, long p14, long p15, long p16)
 564 {
 565     afs_int32 rcode, code, newHost, thisHost, i, count;
 566     int chaseCount, pass, needsync, inlist, j;
 567     struct rx_connection *tc;
 568     struct rx_peer *rxp;
 569     short origLevel;
 570
 571     if (aflags & UBIK_CALL_NEW)
 572         return ubik_Call_New(aproc, aclient, aflags, p1, p2, p3, p4,
 573                              p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15,
 574                              p16);
 575
 576     if (!aclient)
 577         return UNOENT;
 578     LOCK_UBIK_CLIENT(aclient);
 579
 580   restart:
 581     origLevel = aclient->initializationState;
 582     rcode = UNOSERVERS;
 583     chaseCount = inlist = needsync = 0;
 584
 585     LOCK_UCLNT_CACHE;
 586     for (j = 0; ((j < SYNCCOUNT) && calls_needsync[j]); j++) {
 587         if (calls_needsync[j] == (int *)aproc) {
 588             inlist = needsync = 1;
 589             break;
 590         }
 591     }
 592     UNLOCK_UCLNT_CACHE;
 593     /*
 594      * First  pass, we try all servers that are up.
 595      * Second pass, we try all servers.
 596      */
 597     for (pass = 0; pass < 2; pass++) {  /*p */
 598         /* For each entry in our servers list */
 599         for (count = 0;; count++) {     /*s */
 600
 601             if (needsync) {
 602                 /* Need a sync site. Lets try to quickly find it */
 603                 if (aclient->syncSite) {
 604                     newHost = aclient->syncSite;        /* already in network order */
 605                     aclient->syncSite = 0;      /* Will reset if it works */
 606                 } else if (aclient->conns[3]) {
 607                     /* If there are fewer than four db servers in a cell,
 608                      * there's no point in making the GetSyncSite call.
 609                      * At best, it's a wash. At worst, it results in more
 610                      * RPCs than you would otherwise make.
 611                      */
 612                     tc = aclient->conns[count];
 613                     if (tc && rx_ConnError(tc)) {
 614                         aclient->conns[count] = tc = ubik_RefreshConn(tc);
 615                     }
 616                     if (!tc)
 617                         break;
 618                     code = VOTE_GetSyncSite(tc, &newHost);
 619                     if (aclient->initializationState != origLevel)
 620                         goto restart;   /* somebody did a ubik_ClientInit */
 621                     if (code)
 622                         newHost = 0;
 623                     newHost = htonl(newHost);   /* convert to network order */
 624                 } else {
 625                     newHost = 0;
 626                 }
 627                 if (newHost) {
 628                     /* position count at the appropriate slot in the client
 629                      * structure and retry. If we can't find in slot, we'll
 630                      * just continue through the whole list
 631                      */
 632                     for (i = 0; i < MAXSERVERS && aclient->conns[i]; i++) {
 633                         rxp = rx_PeerOf(aclient->conns[i]);
 634                         thisHost = rx_HostOf(rxp);
 635                         if (!thisHost)
 636                             break;
 637                         if (thisHost == newHost) {
 638                             if (chaseCount++ > 2)
 639                                 break;  /* avoid loop asking */
 640                             count = i;  /* this index is the sync site */
 641                             break;
 642                         }
 643                     }
 644                 }
 645             }
 646             /*needsync */
 647             tc = aclient->conns[count];
 648             if (tc && rx_ConnError(tc)) {
 649                 aclient->conns[count] = tc = ubik_RefreshConn(tc);
 650             }
 651             if (!tc)
 652                 break;
 653
 654             if ((pass == 0) && (aclient->states[count] & CFLastFailed)) {
 655                 continue;       /* this guy's down */
 656             }
 657
 658             rcode =
 659                 (*aproc) (tc, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11,
 660                           p12, p13, p14, p15, p16);
 661             if (aclient->initializationState != origLevel) {
 662                 /* somebody did a ubik_ClientInit */
 663                 if (rcode)
 664                     goto restart;       /* call failed */
 665                 else
 666                     goto done;  /* call suceeded */
 667             }
 668             if (rcode < 0) {    /* network errors */
 669                 aclient->states[count] |= CFLastFailed; /* Mark serer down */
 670             } else if (rcode == UNOTSYNC) {
 671                 needsync = 1;
 672             } else if (rcode != UNOQUORUM) {
 673                 /* either misc ubik code, or misc appl code, or success. */
 674                 aclient->states[count] &= ~CFLastFailed;        /* mark server up */
 675                 goto done;      /* all done */
 676             }
 677         }                       /*s */
 678     }                           /*p */
 679
 680   done:
 681     if (needsync) {
 682         if (!inlist) {          /* Remember proc call that needs sync site */
 683             LOCK_UCLNT_CACHE;
 684             calls_needsync[synccount % SYNCCOUNT] = (int *)aproc;
 685             synccount++;
 686             UNLOCK_UCLNT_CACHE;
 687             inlist = 1;
 688         }
 689         if (!rcode) {           /* Remember the sync site - cmd successful */
 690             rxp = rx_PeerOf(aclient->conns[count]);
 691             aclient->syncSite = rx_HostOf(rxp);
 692         }
 693     }
 694     UNLOCK_UBIK_CLIENT(aclient);
 695     return rcode;
 696 }