src/WINNT/afsd/cm_conn.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 <afs/param.h>
  11 #include <afs/stds.h>
  12
  13 #include <windows.h>
  14 #include <string.h>
  15 #include <malloc.h>
  16 #include <osi.h>
  17 #include "afsd.h"
  18 #include <rx/rx.h>
  19 #include <rx/rxkad.h>
  20 #include <afs/unified_afs.h>
  21 #include <WINNT/afsreg.h>
  22
  23 osi_rwlock_t cm_connLock;
  24
  25 long RDRtimeout = CM_CONN_DEFAULTRDRTIMEOUT;
  26 unsigned short ConnDeadtimeout = CM_CONN_CONNDEADTIME;
  27 unsigned short HardDeadtimeout = CM_CONN_HARDDEADTIME;
  28
  29 #define LANMAN_WKS_PARAM_KEY "SYSTEM\\CurrentControlSet\\Services\\lanmanworkstation\\parameters"
  30 #define LANMAN_WKS_SESSION_TIMEOUT "SessTimeout"
  31
  32 afs_int32 cryptall = 0;
  33
  34 void cm_PutConn(cm_conn_t *connp)
  35 {
  36         lock_ObtainWrite(&cm_connLock);
  37         osi_assert(connp->refCount-- > 0);
  38         lock_ReleaseWrite(&cm_connLock);
  39 }
  40
  41 void cm_InitConn(void)
  42 {
  43     static osi_once_t once;
  44     long code;
  45     DWORD dwValue;
  46     DWORD dummyLen;
  47     HKEY parmKey;
  48
  49     if (osi_Once(&once)) {
  50         lock_InitializeRWLock(&cm_connLock, "connection global lock");
  51
  52         /* keisa - read timeout value for lanmanworkstation  service.
  53          * jaltman - as per
  54          *   http://support.microsoft.com:80/support/kb/articles/Q102/0/67.asp&NoWebContent=1
  55          * the SessTimeout is a minimum timeout not a maximum timeout.  Therefore,
  56          * I believe that the default should not be short.  Instead, we should wait until
  57          * RX times out before reporting a timeout to the SMB client.
  58          */
  59         code = RegOpenKeyEx(HKEY_LOCAL_MACHINE, LANMAN_WKS_PARAM_KEY,
  60                             0, KEY_QUERY_VALUE, &parmKey);
  61         if (code == ERROR_SUCCESS)
  62         {
  63             dummyLen = sizeof(DWORD);
  64             code = RegQueryValueEx(parmKey, LANMAN_WKS_SESSION_TIMEOUT, NULL, NULL,
  65                                    (BYTE *) &dwValue, &dummyLen);
  66             if (code == ERROR_SUCCESS)
  67                 RDRtimeout = dwValue;
  68             RegCloseKey(parmKey);
  69         }
  70
  71         code = RegOpenKeyEx(HKEY_LOCAL_MACHINE, AFSREG_CLT_SVC_PARAM_SUBKEY,
  72                              0, KEY_QUERY_VALUE, &parmKey);
  73         if (code == ERROR_SUCCESS) {
  74             dummyLen = sizeof(DWORD);
  75             code = RegQueryValueEx(parmKey, "ConnDeadTimeout", NULL, NULL,
  76                                     (BYTE *) &dwValue, &dummyLen);
  77             if (code == ERROR_SUCCESS)
  78                 ConnDeadtimeout = dwValue;
  79
  80             dummyLen = sizeof(DWORD);
  81             code = RegQueryValueEx(parmKey, "HardDeadTimeout", NULL, NULL,
  82                                     (BYTE *) &dwValue, &dummyLen);
  83             if (code == ERROR_SUCCESS)
  84                 HardDeadtimeout = dwValue;
  85             afsi_log("HardDeadTimeout is %d", HardDeadtimeout);
  86             RegCloseKey(parmKey);
  87         }
  88
  89         afsi_log("lanmanworkstation : SessTimeout %d", RDRtimeout);
  90         if (ConnDeadtimeout == 0)
  91             ConnDeadtimeout = RDRtimeout / 2;
  92         afsi_log("ConnDeadTimeout is %d", ConnDeadtimeout);
  93         if (HardDeadtimeout == 0)
  94             HardDeadtimeout = RDRtimeout;
  95         afsi_log("HardDeadTimeout is %d", HardDeadtimeout);
  96
  97         osi_EndOnce(&once);
  98     }
  99 }
 100
 101 void cm_InitReq(cm_req_t *reqp)
 102 {
 103         memset((char *)reqp, 0, sizeof(cm_req_t));
 104         reqp->startTime = GetTickCount();
 105 }
 106
 107 static long cm_GetServerList(struct cm_fid *fidp, struct cm_user *userp,
 108         struct cm_req *reqp, cm_serverRef_t ***serversppp)
 109 {
 110     long code;
 111     cm_volume_t *volp = NULL;
 112     cm_cell_t *cellp = NULL;
 113
 114     if (!fidp) {
 115         *serversppp = NULL;
 116         return 0;
 117     }
 118
 119     cellp = cm_FindCellByID(fidp->cell);
 120     if (!cellp) return CM_ERROR_NOSUCHCELL;
 121
 122     code = cm_GetVolumeByID(cellp, fidp->volume, userp, reqp, &volp);
 123     if (code) return code;
 124
 125     *serversppp = cm_GetVolServers(volp, fidp->volume);
 126
 127     cm_PutVolume(volp);
 128     return 0;
 129 }
 130
 131 /*
 132  * Analyze the error return from an RPC.  Determine whether or not to retry,
 133  * and if we're going to retry, determine whether failover is appropriate,
 134  * and whether timed backoff is appropriate.
 135  *
 136  * If the error code is from cm_Conn() or friends, it will be a CM_ERROR code.
 137  * Otherwise it will be an RPC code.  This may be a UNIX code (e.g. EDQUOT), or
 138  * it may be an RX code, or it may be a special code (e.g. VNOVOL), or it may
 139  * be a security code (e.g. RXKADEXPIRED).
 140  *
 141  * If the error code is from cm_Conn() or friends, connp will be NULL.
 142  *
 143  * For VLDB calls, fidp will be NULL.
 144  *
 145  * volSyncp and/or cbrp may also be NULL.
 146  */
 147 int
 148 cm_Analyze(cm_conn_t *connp, cm_user_t *userp, cm_req_t *reqp,
 149            struct cm_fid *fidp,
 150            AFSVolSync *volSyncp,
 151            cm_serverRef_t * serversp,
 152            cm_callbackRequest_t *cbrp, long errorCode)
 153 {
 154     cm_server_t *serverp = NULL;
 155     cm_serverRef_t **serverspp = NULL;
 156     cm_serverRef_t *tsrp;
 157     cm_cell_t  *cellp = NULL;
 158     cm_ucell_t *ucellp;
 159     int retry = 0;
 160     int free_svr_list = 0;
 161     int dead_session;
 162     long timeUsed, timeLeft;
 163     long code;
 164     char addr[16];
 165
 166     osi_Log2(afsd_logp, "cm_Analyze connp 0x%p, code 0x%x",
 167              connp, errorCode);
 168
 169     /* no locking required, since connp->serverp never changes after
 170      * creation */
 171     dead_session = (userp->cellInfop == NULL);
 172     if (connp)
 173         serverp = connp->serverp;
 174
 175     /* Update callback pointer */
 176     if (cbrp && serverp && errorCode == 0) {
 177         if (cbrp->serverp) {
 178             if ( cbrp->serverp != serverp ) {
 179                 lock_ObtainWrite(&cm_serverLock);
 180                 cm_PutServerNoLock(cbrp->serverp);
 181                 cm_GetServerNoLock(serverp);
 182                 lock_ReleaseWrite(&cm_serverLock);
 183             }
 184         } else {
 185             cm_GetServer(serverp);
 186         }
 187         lock_ObtainWrite(&cm_callbackLock);
 188         cbrp->serverp = serverp;
 189         lock_ReleaseWrite(&cm_callbackLock);
 190     }
 191
 192     /* If not allowed to retry, don't */
 193     if (reqp->flags & CM_REQ_NORETRY)
 194         goto out;
 195
 196     /* if timeout - check that it did not exceed the HardDead timeout
 197      * and retry */
 198
 199     /* timeleft - get if from reqp the same way as cmXonnByMServers does */
 200     timeUsed = (GetTickCount() - reqp->startTime) / 1000;
 201
 202     /* leave 5 seconds margin for sleep */
 203     timeLeft = HardDeadtimeout - timeUsed;
 204
 205     if (errorCode == CM_ERROR_TIMEDOUT) {
 206         if (timeLeft > 5 ) {
 207             thrd_Sleep(3000);
 208             if (cellp == NULL && serverp)
 209                 cellp = serverp->cellp;
 210             if (cellp == NULL && serversp) {
 211                 struct cm_serverRef * refp;
 212                 for ( refp=serversp ; cellp == NULL && refp != NULL; refp=refp->next) {
 213                     if ( refp->server )
 214                         cellp = refp->server->cellp;
 215                 }
 216             }
 217             cm_CheckServers(CM_FLAG_CHECKDOWNSERVERS, cellp);
 218             retry = 1;
 219         }
 220     }
 221
 222     /* if there is nosuchvolume, then we have a situation in which a
 223      * previously known volume no longer has a set of servers
 224      * associated with it.  Either the volume has moved or
 225      * the volume has been deleted.  Try to find a new server list
 226      * until the timeout period expires.
 227      */
 228     else if (errorCode == CM_ERROR_NOSUCHVOLUME) {
 229         osi_Log0(afsd_logp, "cm_Analyze passed CM_ERROR_NOSUCHVOLUME.");
 230         if (timeLeft > 7) {
 231             thrd_Sleep(5000);
 232
 233             retry = 1;
 234
 235             if (fidp != NULL)   /* Not a VLDB call */
 236                 cm_ForceUpdateVolume(fidp, userp, reqp);
 237         }
 238     }
 239
 240     else if (errorCode == CM_ERROR_ALLDOWN) {
 241         osi_Log0(afsd_logp, "cm_Analyze passed CM_ERROR_ALLDOWN.");
 242         /* Servers marked DOWN will be restored by the background daemon
 243          * thread as they become available.
 244          */
 245     }
 246
 247     else if (errorCode == CM_ERROR_ALLOFFLINE) {
 248         if (timeLeft > 7) {
 249             osi_Log0(afsd_logp, "cm_Analyze passed CM_ERROR_ALLOFFLINE.");
 250             thrd_Sleep(5000);
 251
 252             if (fidp) { /* Not a VLDB call */
 253                 if (!serversp) {
 254                     code = cm_GetServerList(fidp, userp, reqp, &serverspp);
 255                     if (code == 0) {
 256                         serversp = *serverspp;
 257                         free_svr_list = 1;
 258                     }
 259                 }
 260                 if (serversp) {
 261                     lock_ObtainWrite(&cm_serverLock);
 262                     for (tsrp = serversp; tsrp; tsrp=tsrp->next)
 263                         tsrp->status = not_busy;
 264                     lock_ReleaseWrite(&cm_serverLock);
 265                     if (free_svr_list) {
 266                         cm_FreeServerList(&serversp);
 267                         *serverspp = serversp;
 268                     }
 269                     retry = 1;
 270                 }
 271
 272                 cm_ForceUpdateVolume(fidp, userp, reqp);
 273             } else { /* VLDB call */
 274                 if (serversp) {
 275                     lock_ObtainWrite(&cm_serverLock);
 276                     for (tsrp = serversp; tsrp; tsrp=tsrp->next)
 277                         tsrp->status = not_busy;
 278                     lock_ReleaseWrite(&cm_serverLock);
 279                     if (free_svr_list) {
 280                         cm_FreeServerList(&serversp);
 281                         *serverspp = serversp;
 282                     }
 283                 }
 284             }
 285         }
 286     }
 287
 288     /* if all servers are busy, mark them non-busy and start over */
 289     else if (errorCode == CM_ERROR_ALLBUSY) {
 290         osi_Log0(afsd_logp, "cm_Analyze passed CM_ERROR_ALLBUSY.");
 291         if (timeLeft > 7) {
 292             thrd_Sleep(5000);
 293             if (!serversp) {
 294                 code = cm_GetServerList(fidp, userp, reqp, &serverspp);
 295                 if (code == 0) {
 296                     serversp = *serverspp;
 297                     free_svr_list = 1;
 298                 }
 299             }
 300             lock_ObtainWrite(&cm_serverLock);
 301             for (tsrp = serversp; tsrp; tsrp=tsrp->next) {
 302                 if (tsrp->status == busy)
 303                     tsrp->status = not_busy;
 304             }
 305             lock_ReleaseWrite(&cm_serverLock);
 306             if (free_svr_list) {
 307                 cm_FreeServerList(&serversp);
 308                 *serverspp = serversp;
 309             }
 310             retry = 1;
 311         }
 312     }
 313
 314     /* special codes:  VBUSY and VRESTARTING */
 315     else if (errorCode == VBUSY || errorCode == VRESTARTING) {
 316         if (!serversp) {
 317             code = cm_GetServerList(fidp, userp, reqp, &serverspp);
 318             if (code == 0) {
 319                 serversp = *serverspp;
 320                 free_svr_list = 1;
 321             }
 322         }
 323         lock_ObtainWrite(&cm_serverLock);
 324         for (tsrp = serversp; tsrp; tsrp=tsrp->next) {
 325             if (tsrp->server == serverp
 326                  && tsrp->status == not_busy) {
 327                 tsrp->status = busy;
 328                 break;
 329             }
 330         }
 331         lock_ReleaseWrite(&cm_serverLock);
 332         if (free_svr_list) {
 333             cm_FreeServerList(&serversp);
 334             *serverspp = serversp;
 335         }
 336         retry = 1;
 337     }
 338
 339     /* special codes:  missing volumes */
 340     else if (errorCode == VNOVOL || errorCode == VMOVED || errorCode == VOFFLINE ||
 341              errorCode == VSALVAGE || errorCode == VNOSERVICE || errorCode == VIO)
 342     {
 343         char addr[16];
 344         char *format;
 345         DWORD msgID;
 346         switch ( errorCode ) {
 347         case VNOVOL:
 348             msgID = MSG_SERVER_REPORTS_VNOVOL;
 349             format = "Server %s reported volume %d as not attached.";
 350             break;
 351         case VMOVED:
 352             msgID = MSG_SERVER_REPORTS_VMOVED;
 353             format = "Server %s reported volume %d as moved.";
 354             break;
 355         case VOFFLINE:
 356             msgID = MSG_SERVER_REPORTS_VOFFLINE;
 357             format = "Server %s reported volume %d as offline.";
 358             break;
 359         case VSALVAGE:
 360             msgID = MSG_SERVER_REPORTS_VSALVAGE;
 361             format = "Server %s reported volume %d as needs salvage.";
 362             break;
 363         case VNOSERVICE:
 364             msgID = MSG_SERVER_REPORTS_VNOSERVICE;
 365             format = "Server %s reported volume %d as not in service.";
 366             break;
 367         case VIO:
 368             msgID = MSG_SERVER_REPORTS_VIO;
 369             format = "Server %s reported volume %d as temporarily unaccessible.";
 370             break;
 371         }
 372
 373         /* Log server being offline for this volume */
 374         sprintf(addr, "%d.%d.%d.%d",
 375                  ((serverp->addr.sin_addr.s_addr & 0xff)),
 376                  ((serverp->addr.sin_addr.s_addr & 0xff00)>> 8),
 377                  ((serverp->addr.sin_addr.s_addr & 0xff0000)>> 16),
 378                  ((serverp->addr.sin_addr.s_addr & 0xff000000)>> 24));
 379
 380         osi_Log2(afsd_logp, format, osi_LogSaveString(afsd_logp,addr), fidp->volume);
 381         LogEvent(EVENTLOG_WARNING_TYPE, msgID, addr, fidp->volume);
 382
 383         /* Mark server offline for this volume */
 384         if (!serversp) {
 385             code = cm_GetServerList(fidp, userp, reqp, &serverspp);
 386             if (code == 0) {
 387                 serversp = *serverspp;
 388                 free_svr_list = 1;
 389             }
 390         }
 391         for (tsrp = serversp; tsrp; tsrp=tsrp->next) {
 392             if (tsrp->server == serverp)
 393                 tsrp->status = offline;
 394         }
 395         if (free_svr_list) {
 396             cm_FreeServerList(&serversp);
 397             *serverspp = serversp;
 398         }
 399         if ( timeLeft > 2 )
 400             retry = 1;
 401     } else if ( errorCode == VNOVNODE ) {
 402         if ( fidp ) {
 403             cm_scache_t * scp;
 404             osi_Log4(afsd_logp, "cm_Analyze passed VNOVNODE cell %u vol %u vn %u uniq %u.",
 405                       fidp->cell, fidp->volume, fidp->vnode, fidp->unique);
 406
 407             scp = cm_FindSCache(fidp);
 408             if (scp) {
 409                 cm_scache_t *pscp = NULL;
 410
 411                 if (scp->fileType != CM_SCACHETYPE_DIRECTORY)
 412                     pscp = cm_FindSCacheParent(scp);
 413
 414                 lock_ObtainWrite(&cm_scacheLock);
 415                 cm_RecycleSCache(scp, CM_SCACHE_RECYCLEFLAG_DESTROY_BUFFERS);
 416                 cm_ReleaseSCacheNoLock(scp);
 417                 lock_ReleaseWrite(&cm_scacheLock);
 418
 419                 if (pscp) {
 420                     if (pscp->cbExpires > 0 && pscp->cbServerp != NULL) {
 421                         lock_ObtainMutex(&pscp->mx);
 422                         cm_DiscardSCache(pscp);
 423                         lock_ReleaseMutex(&pscp->mx);
 424                     }
 425                     cm_ReleaseSCache(pscp);
 426                 }
 427             }
 428         } else {
 429             osi_Log0(afsd_logp, "cm_Analyze passed VNOVNODE unknown fid.");
 430         }
 431     }
 432
 433     /* RX codes */
 434     else if (errorCode == RX_CALL_TIMEOUT) {
 435         /* server took longer than hardDeadTime
 436          * don't mark server as down but don't retry
 437          * this is to prevent the SMB session from timing out
 438          * In addition, we log an event to the event log
 439          */
 440
 441         /* Log server being offline for this volume */
 442         sprintf(addr, "%d.%d.%d.%d",
 443                  ((serverp->addr.sin_addr.s_addr & 0xff)),
 444                  ((serverp->addr.sin_addr.s_addr & 0xff00)>> 8),
 445                  ((serverp->addr.sin_addr.s_addr & 0xff0000)>> 16),
 446                  ((serverp->addr.sin_addr.s_addr & 0xff000000)>> 24));
 447
 448         LogEvent(EVENTLOG_WARNING_TYPE, MSG_RX_HARD_DEAD_TIME_EXCEEDED, addr);
 449
 450         retry = 0;
 451         osi_Log1(afsd_logp, "cm_Analyze: hardDeadTime exceeded addr[%s]",
 452                  osi_LogSaveString(afsd_logp,addr));
 453     }
 454     else if (errorCode >= -64 && errorCode < 0) {
 455         /* mark server as down */
 456         lock_ObtainMutex(&serverp->mx);
 457         serverp->flags |= CM_SERVERFLAG_DOWN;
 458         lock_ReleaseMutex(&serverp->mx);
 459         cm_ForceNewConnections(serverp);
 460         if ( timeLeft > 2 )
 461             retry = 1;
 462     }
 463     else if (errorCode == RXKADEXPIRED ||
 464              errorCode == RXKADBADTICKET) {
 465         if (!dead_session) {
 466             lock_ObtainMutex(&userp->mx);
 467             ucellp = cm_GetUCell(userp, serverp->cellp);
 468             if (ucellp->ticketp) {
 469                 free(ucellp->ticketp);
 470                 ucellp->ticketp = NULL;
 471             }
 472             ucellp->flags &= ~CM_UCELLFLAG_RXKAD;
 473             ucellp->gen++;
 474             lock_ReleaseMutex(&userp->mx);
 475             if ( timeLeft > 2 )
 476                 retry = 1;
 477         }
 478     } else {
 479         if (errorCode) {
 480             char * s = "unknown error";
 481             switch ( errorCode ) {
 482             case RXKADINCONSISTENCY: s = "RXKADINCONSISTENCY"; break;
 483             case RXKADPACKETSHORT  : s = "RXKADPACKETSHORT";   break;
 484             case RXKADLEVELFAIL    : s = "RXKADLEVELFAIL";     break;
 485             case RXKADTICKETLEN    : s = "RXKADTICKETLEN";     break;
 486             case RXKADOUTOFSEQUENCE: s = "RXKADOUTOFSEQUENCE"; break;
 487             case RXKADNOAUTH       : s = "RXKADNOAUTH";        break;
 488             case RXKADBADKEY       : s = "RXKADBADKEY";        break;
 489             case RXKADBADTICKET    : s = "RXKADBADTICKET";     break;
 490             case RXKADUNKNOWNKEY   : s = "RXKADUNKNOWNKEY";    break;
 491             case RXKADEXPIRED      : s = "RXKADEXPIRED";       break;
 492             case RXKADSEALEDINCON  : s = "RXKADSEALEDINCON";   break;
 493             case RXKADDATALEN      : s = "RXKADDATALEN";       break;
 494             case RXKADILLEGALLEVEL : s = "RXKADILLEGALLEVEL";  break;
 495             case VSALVAGE          : s = "VSALVAGE";           break;
 496             case VNOVNODE          : s = "VNOVNODE";           break;
 497             case VNOVOL            : s = "VNOVOL";             break;
 498             case VVOLEXISTS        : s = "VVOLEXISTS";         break;
 499             case VNOSERVICE        : s = "VNOSERVICE";         break;
 500             case VOFFLINE          : s = "VOFFLINE";           break;
 501             case VONLINE           : s = "VONLINE";            break;
 502             case VDISKFULL         : s = "VDISKFULL";          break;
 503             case VOVERQUOTA        : s = "VOVERQUOTA";         break;
 504             case VBUSY             : s = "VBUSY";              break;
 505             case VMOVED            : s = "VMOVED";             break;
 506             case VIO               : s = "VIO";                break;
 507             case VRESTRICTED       : s = "VRESTRICTED";        break;
 508             case VRESTARTING       : s = "VRESTARTING";        break;
 509             case VREADONLY         : s = "VREADONLY";          break;
 510             case EAGAIN            : s = "EAGAIN";             break;
 511             case UAEAGAIN          : s = "UAEAGAIN";           break;
 512             case EINVAL            : s = "EINVAL";             break;
 513             case UAEINVAL          : s = "UAEINVAL";           break;
 514             case EACCES            : s = "EACCES";             break;
 515             case UAEACCES          : s = "UAEACCES";           break;
 516             case ENOENT            : s = "ENOENT";             break;
 517             case UAENOENT          : s = "UAENOENT";           break;
 518             case CM_ERROR_NOSUCHCELL        : s = "CM_ERROR_NOSUCHCELL";         break;
 519             case CM_ERROR_NOSUCHVOLUME      : s = "CM_ERROR_NOSUCHVOLUME";       break;
 520             case CM_ERROR_TIMEDOUT          : s = "CM_ERROR_TIMEDOUT";           break;
 521             case CM_ERROR_RETRY             : s = "CM_ERROR_RETRY";              break;
 522             case CM_ERROR_NOACCESS          : s = "CM_ERROR_NOACCESS";           break;
 523             case CM_ERROR_NOSUCHFILE        : s = "CM_ERROR_NOSUCHFILE";         break;
 524             case CM_ERROR_STOPNOW           : s = "CM_ERROR_STOPNOW";            break;
 525             case CM_ERROR_TOOBIG            : s = "CM_ERROR_TOOBIG";             break;
 526             case CM_ERROR_INVAL             : s = "CM_ERROR_INVAL";              break;
 527             case CM_ERROR_BADFD             : s = "CM_ERROR_BADFD";              break;
 528             case CM_ERROR_BADFDOP           : s = "CM_ERROR_BADFDOP";            break;
 529             case CM_ERROR_EXISTS            : s = "CM_ERROR_EXISTS";             break;
 530             case CM_ERROR_CROSSDEVLINK      : s = "CM_ERROR_CROSSDEVLINK";       break;
 531             case CM_ERROR_BADOP             : s = "CM_ERROR_BADOP";              break;
 532             case CM_ERROR_BADPASSWORD       : s = "CM_ERROR_BADPASSWORD";        break;
 533             case CM_ERROR_NOTDIR            : s = "CM_ERROR_NOTDIR";             break;
 534             case CM_ERROR_ISDIR             : s = "CM_ERROR_ISDIR";              break;
 535             case CM_ERROR_READONLY          : s = "CM_ERROR_READONLY";           break;
 536             case CM_ERROR_WOULDBLOCK        : s = "CM_ERROR_WOULDBLOCK";         break;
 537             case CM_ERROR_QUOTA             : s = "CM_ERROR_QUOTA";              break;
 538             case CM_ERROR_SPACE             : s = "CM_ERROR_SPACE";              break;
 539             case CM_ERROR_BADSHARENAME      : s = "CM_ERROR_BADSHARENAME";       break;
 540             case CM_ERROR_BADTID            : s = "CM_ERROR_BADTID";             break;
 541             case CM_ERROR_UNKNOWN           : s = "CM_ERROR_UNKNOWN";            break;
 542             case CM_ERROR_NOMORETOKENS      : s = "CM_ERROR_NOMORETOKENS";       break;
 543             case CM_ERROR_NOTEMPTY          : s = "CM_ERROR_NOTEMPTY";           break;
 544             case CM_ERROR_USESTD            : s = "CM_ERROR_USESTD";             break;
 545             case CM_ERROR_REMOTECONN        : s = "CM_ERROR_REMOTECONN";         break;
 546             case CM_ERROR_ATSYS             : s = "CM_ERROR_ATSYS";              break;
 547             case CM_ERROR_NOSUCHPATH        : s = "CM_ERROR_NOSUCHPATH";         break;
 548             case CM_ERROR_CLOCKSKEW         : s = "CM_ERROR_CLOCKSKEW";          break;
 549             case CM_ERROR_BADSMB            : s = "CM_ERROR_BADSMB";             break;
 550             case CM_ERROR_ALLBUSY           : s = "CM_ERROR_ALLBUSY";            break;
 551             case CM_ERROR_NOFILES           : s = "CM_ERROR_NOFILES";            break;
 552             case CM_ERROR_PARTIALWRITE      : s = "CM_ERROR_PARTIALWRITE";       break;
 553             case CM_ERROR_NOIPC             : s = "CM_ERROR_NOIPC";              break;
 554             case CM_ERROR_BADNTFILENAME     : s = "CM_ERROR_BADNTFILENAME";      break;
 555             case CM_ERROR_BUFFERTOOSMALL    : s = "CM_ERROR_BUFFERTOOSMALL";     break;
 556             case CM_ERROR_RENAME_IDENTICAL  : s = "CM_ERROR_RENAME_IDENTICAL";   break;
 557             case CM_ERROR_ALLOFFLINE        : s = "CM_ERROR_ALLOFFLINE";         break;
 558             case CM_ERROR_AMBIGUOUS_FILENAME: s = "CM_ERROR_AMBIGUOUS_FILENAME"; break;
 559             case CM_ERROR_BADLOGONTYPE      : s = "CM_ERROR_BADLOGONTYPE";       break;
 560             case CM_ERROR_GSSCONTINUE       : s = "CM_ERROR_GSSCONTINUE";        break;
 561             case CM_ERROR_TIDIPC            : s = "CM_ERROR_TIDIPC";             break;
 562             case CM_ERROR_TOO_MANY_SYMLINKS : s = "CM_ERROR_TOO_MANY_SYMLINKS";  break;
 563             case CM_ERROR_PATH_NOT_COVERED  : s = "CM_ERROR_PATH_NOT_COVERED";   break;
 564             case CM_ERROR_LOCK_CONFLICT     : s = "CM_ERROR_LOCK_CONFLICT";      break;
 565             case CM_ERROR_SHARING_VIOLATION : s = "CM_ERROR_SHARING_VIOLATION";  break;
 566             case CM_ERROR_ALLDOWN           : s = "CM_ERROR_ALLDOWN";            break;
 567             case CM_ERROR_TOOFEWBUFS        : s = "CM_ERROR_TOOFEWBUFS";         break;
 568             case CM_ERROR_TOOMANYBUFS       : s = "CM_ERROR_TOOMANYBUFS";        break;
 569             }
 570             osi_Log2(afsd_logp, "cm_Analyze: ignoring error code 0x%x (%s)",
 571                      errorCode, s);
 572             retry = 0;
 573         }
 574     }
 575
 576     if (retry && dead_session)
 577         retry = 0;
 578
 579   out:
 580     /* drop this on the way out */
 581     if (connp)
 582         cm_PutConn(connp);
 583
 584     /* retry until we fail to find a connection */
 585     return retry;
 586 }
 587
 588 long cm_ConnByMServers(cm_serverRef_t *serversp, cm_user_t *usersp,
 589         cm_req_t *reqp, cm_conn_t **connpp)
 590 {
 591     long code;
 592     cm_serverRef_t *tsrp;
 593     cm_server_t *tsp;
 594     long firstError = 0;
 595     int someBusy = 0, someOffline = 0, allOffline = 1, allBusy = 1, allDown = 1;
 596     long timeUsed, timeLeft, hardTimeLeft;
 597
 598     if (serversp == NULL) {
 599         osi_Log1(afsd_logp, "cm_ConnByMServers returning 0x%x", CM_ERROR_NOSUCHVOLUME);
 600         return CM_ERROR_NOSUCHVOLUME;
 601     }
 602
 603     *connpp = NULL;
 604
 605     timeUsed = (GetTickCount() - reqp->startTime) / 1000;
 606
 607     /* leave 5 seconds margin of safety */
 608     timeLeft =  ConnDeadtimeout - timeUsed - 5;
 609     hardTimeLeft = HardDeadtimeout - timeUsed - 5;
 610
 611     lock_ObtainWrite(&cm_serverLock);
 612     for (tsrp = serversp; tsrp; tsrp=tsrp->next) {
 613         tsp = tsrp->server;
 614         cm_GetServerNoLock(tsp);
 615         lock_ReleaseWrite(&cm_serverLock);
 616         if (!(tsp->flags & CM_SERVERFLAG_DOWN)) {
 617             allDown = 0;
 618             if (tsrp->status == busy) {
 619                 allOffline = 0;
 620                 someBusy = 1;
 621             } else if (tsrp->status == offline) {
 622                 allBusy = 0;
 623                 someOffline = 1;
 624             } else {
 625                 allOffline = 0;
 626                 allBusy = 0;
 627                 code = cm_ConnByServer(tsp, usersp, connpp);
 628                 if (code == 0) {        /* cm_CBS only returns 0 */
 629                     cm_PutServer(tsp);
 630                     /* Set RPC timeout */
 631                     if (timeLeft > ConnDeadtimeout)
 632                         timeLeft = ConnDeadtimeout;
 633
 634                     if (hardTimeLeft > HardDeadtimeout)
 635                         hardTimeLeft = HardDeadtimeout;
 636
 637                     lock_ObtainMutex(&(*connpp)->mx);
 638                     rx_SetConnDeadTime((*connpp)->callp, timeLeft);
 639                     rx_SetConnHardDeadTime((*connpp)->callp, (u_short) hardTimeLeft);
 640                     lock_ReleaseMutex(&(*connpp)->mx);
 641                     return 0;
 642                 }
 643
 644                 /* therefore, this code is never executed */
 645                 if (firstError == 0)
 646                     firstError = code;
 647             }
 648         }
 649         lock_ObtainWrite(&cm_serverLock);
 650         cm_PutServerNoLock(tsp);
 651     }
 652     lock_ReleaseWrite(&cm_serverLock);
 653
 654     if (firstError == 0) {
 655         if (allDown)
 656             firstError = CM_ERROR_ALLDOWN;
 657         else if (allBusy)
 658             firstError = CM_ERROR_ALLBUSY;
 659         else if (allOffline || (someBusy && someOffline))
 660             firstError = CM_ERROR_ALLOFFLINE;
 661         else {
 662             osi_Log0(afsd_logp, "cm_ConnByMServers returning impossible error TIMEDOUT");
 663             firstError = CM_ERROR_TIMEDOUT;
 664         }
 665     }
 666
 667     osi_Log1(afsd_logp, "cm_ConnByMServers returning 0x%x", firstError);
 668     return firstError;
 669 }
 670
 671 /* called with a held server to GC all bad connections hanging off of the server */
 672 void cm_GCConnections(cm_server_t *serverp)
 673 {
 674     cm_conn_t *tcp;
 675     cm_conn_t **lcpp;
 676     cm_user_t *userp;
 677
 678     lock_ObtainWrite(&cm_connLock);
 679     lcpp = &serverp->connsp;
 680     for (tcp = *lcpp; tcp; tcp = *lcpp) {
 681         userp = tcp->userp;
 682         if (userp && tcp->refCount == 0 && (userp->vcRefs == 0)) {
 683             /* do the deletion of this guy */
 684             cm_PutServer(tcp->serverp);
 685             cm_ReleaseUser(userp);
 686             *lcpp = tcp->nextp;
 687             rx_DestroyConnection(tcp->callp);
 688             lock_FinalizeMutex(&tcp->mx);
 689             free(tcp);
 690         }
 691         else {
 692             /* just advance to the next */
 693             lcpp = &tcp->nextp;
 694         }
 695     }
 696     lock_ReleaseWrite(&cm_connLock);
 697 }
 698
 699 static void cm_NewRXConnection(cm_conn_t *tcp, cm_ucell_t *ucellp,
 700                                cm_server_t *serverp)
 701 {
 702     unsigned short port;
 703     int serviceID;
 704     int secIndex;
 705     struct rx_securityClass *secObjp;
 706
 707     if (serverp->type == CM_SERVER_VLDB) {
 708         port = htons(7003);
 709         serviceID = 52;
 710     }
 711     else {
 712         osi_assert(serverp->type == CM_SERVER_FILE);
 713         port = htons(7000);
 714         serviceID = 1;
 715     }
 716     if (ucellp->flags & CM_UCELLFLAG_RXKAD) {
 717         secIndex = 2;
 718         if (cryptall) {
 719             tcp->cryptlevel = rxkad_crypt;
 720         } else {
 721             tcp->cryptlevel = rxkad_clear;
 722         }
 723         secObjp = rxkad_NewClientSecurityObject(tcp->cryptlevel,
 724                                                 &ucellp->sessionKey, ucellp->kvno,
 725                                                 ucellp->ticketLen, ucellp->ticketp);
 726     } else {
 727         /* normal auth */
 728         secIndex = 0;
 729         tcp->cryptlevel = rxkad_clear;
 730         secObjp = rxnull_NewClientSecurityObject();
 731     }
 732     osi_assert(secObjp != NULL);
 733     tcp->callp = rx_NewConnection(serverp->addr.sin_addr.s_addr,
 734                                   port,
 735                                   serviceID,
 736                                   secObjp,
 737                                   secIndex);
 738     rx_SetConnDeadTime(tcp->callp, ConnDeadtimeout);
 739     rx_SetConnHardDeadTime(tcp->callp, HardDeadtimeout);
 740     tcp->ucgen = ucellp->gen;
 741     if (secObjp)
 742         rxs_Release(secObjp);   /* Decrement the initial refCount */
 743 }
 744
 745 long cm_ConnByServer(cm_server_t *serverp, cm_user_t *userp, cm_conn_t **connpp)
 746 {
 747     cm_conn_t *tcp;
 748     cm_ucell_t *ucellp;
 749
 750     lock_ObtainMutex(&userp->mx);
 751     lock_ObtainWrite(&cm_connLock);
 752     for (tcp = serverp->connsp; tcp; tcp=tcp->nextp) {
 753         if (tcp->userp == userp)
 754             break;
 755     }
 756
 757     /* find ucell structure */
 758     ucellp = cm_GetUCell(userp, serverp->cellp);
 759     if (!tcp) {
 760         cm_GetServer(serverp);
 761         tcp = malloc(sizeof(*tcp));
 762         memset(tcp, 0, sizeof(*tcp));
 763         tcp->nextp = serverp->connsp;
 764         serverp->connsp = tcp;
 765         cm_HoldUser(userp);
 766         tcp->userp = userp;
 767         lock_InitializeMutex(&tcp->mx, "cm_conn_t mutex");
 768         lock_ObtainMutex(&tcp->mx);
 769         tcp->serverp = serverp;
 770         tcp->cryptlevel = rxkad_clear;
 771         cm_NewRXConnection(tcp, ucellp, serverp);
 772         tcp->refCount = 1;
 773         lock_ReleaseMutex(&tcp->mx);
 774     } else {
 775         if ((tcp->flags & CM_CONN_FLAG_FORCE_NEW) ||
 776             (tcp->ucgen < ucellp->gen) ||
 777             (tcp->cryptlevel != (cryptall ? (ucellp->flags & CM_UCELLFLAG_RXKAD ? rxkad_crypt : rxkad_clear) : rxkad_clear)))
 778         {
 779             if (tcp->ucgen < ucellp->gen)
 780                 osi_Log0(afsd_logp, "cm_ConnByServer replace connection due to token update");
 781             else
 782                 osi_Log0(afsd_logp, "cm_ConnByServer replace connection due to crypt change");
 783             lock_ObtainMutex(&tcp->mx);
 784             tcp->flags &= ~CM_CONN_FLAG_FORCE_NEW;
 785             rx_DestroyConnection(tcp->callp);
 786             cm_NewRXConnection(tcp, ucellp, serverp);
 787             lock_ReleaseMutex(&tcp->mx);
 788         }
 789         tcp->refCount++;
 790     }
 791     lock_ReleaseWrite(&cm_connLock);
 792     lock_ReleaseMutex(&userp->mx);
 793
 794     /* return this pointer to our caller */
 795     osi_Log1(afsd_logp, "cm_ConnByServer returning conn 0x%p", tcp);
 796     *connpp = tcp;
 797
 798     return 0;
 799 }
 800
 801 long cm_Conn(struct cm_fid *fidp, struct cm_user *userp, cm_req_t *reqp,
 802              cm_conn_t **connpp)
 803 {
 804     long code;
 805
 806     cm_serverRef_t **serverspp;
 807
 808     code = cm_GetServerList(fidp, userp, reqp, &serverspp);
 809     if (code) {
 810         *connpp = NULL;
 811         return code;
 812     }
 813
 814     code = cm_ConnByMServers(*serverspp, userp, reqp, connpp);
 815     cm_FreeServerList(serverspp);
 816     return code;
 817 }
 818
 819 extern struct rx_connection *
 820 cm_GetRxConn(cm_conn_t *connp)
 821 {
 822     struct rx_connection * rxconn;
 823     lock_ObtainMutex(&connp->mx);
 824     rxconn = connp->callp;
 825     rx_GetConnection(rxconn);
 826     lock_ReleaseMutex(&connp->mx);
 827     return rxconn;
 828 }
 829
 830 void cm_ForceNewConnections(cm_server_t *serverp)
 831 {
 832     cm_conn_t *tcp;
 833
 834     lock_ObtainWrite(&cm_connLock);
 835     for (tcp = serverp->connsp; tcp; tcp=tcp->nextp) {
 836         lock_ObtainMutex(&tcp->mx);
 837         tcp->flags |= CM_CONN_FLAG_FORCE_NEW;
 838         lock_ReleaseMutex(&tcp->mx);
 839     }
 840     lock_ReleaseWrite(&cm_connLock);
 841 }