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 = (unsigned short)dwValue;
  79
  80             dummyLen = sizeof(DWORD);
  81             code = RegQueryValueEx(parmKey, "HardDeadTimeout", NULL, NULL,
  82                                     (BYTE *) &dwValue, &dummyLen);
  83             if (code == ERROR_SUCCESS)
  84                 HardDeadtimeout = (unsigned short)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 = (unsigned short) (RDRtimeout / 2);
  92         afsi_log("ConnDeadTimeout is %d", ConnDeadtimeout);
  93         if (HardDeadtimeout == 0)
  94             HardDeadtimeout = (unsigned short) 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
 415                 lock_ObtainMutex(&scp->mx);
 416                 lock_ObtainWrite(&cm_scacheLock);
 417                 cm_RemoveSCacheFromHashTable(scp);
 418                 lock_ReleaseWrite(&cm_scacheLock);
 419                 scp->flags |= CM_SCACHEFLAG_DELETED;
 420                 lock_ReleaseMutex(&scp->mx);
 421                 cm_ReleaseSCache(scp);
 422
 423                 if (pscp) {
 424                     if (cm_HaveCallback(pscp)) {
 425                         lock_ObtainMutex(&pscp->mx);
 426                         cm_DiscardSCache(pscp);
 427                         lock_ReleaseMutex(&pscp->mx);
 428                     }
 429                     cm_ReleaseSCache(pscp);
 430                 }
 431             }
 432         } else {
 433             osi_Log0(afsd_logp, "cm_Analyze passed VNOVNODE unknown fid.");
 434         }
 435     }
 436
 437     /* RX codes */
 438     else if (errorCode == RX_CALL_TIMEOUT) {
 439         /* server took longer than hardDeadTime
 440          * don't mark server as down but don't retry
 441          * this is to prevent the SMB session from timing out
 442          * In addition, we log an event to the event log
 443          */
 444
 445         /* Log server being offline for this volume */
 446         sprintf(addr, "%d.%d.%d.%d",
 447                  ((serverp->addr.sin_addr.s_addr & 0xff)),
 448                  ((serverp->addr.sin_addr.s_addr & 0xff00)>> 8),
 449                  ((serverp->addr.sin_addr.s_addr & 0xff0000)>> 16),
 450                  ((serverp->addr.sin_addr.s_addr & 0xff000000)>> 24));
 451
 452         LogEvent(EVENTLOG_WARNING_TYPE, MSG_RX_HARD_DEAD_TIME_EXCEEDED, addr);
 453
 454         retry = 0;
 455         osi_Log1(afsd_logp, "cm_Analyze: hardDeadTime exceeded addr[%s]",
 456                  osi_LogSaveString(afsd_logp,addr));
 457     }
 458     else if (errorCode >= -64 && errorCode < 0) {
 459         /* mark server as down */
 460         lock_ObtainMutex(&serverp->mx);
 461         serverp->flags |= CM_SERVERFLAG_DOWN;
 462         lock_ReleaseMutex(&serverp->mx);
 463         cm_ForceNewConnections(serverp);
 464         if ( timeLeft > 2 )
 465             retry = 1;
 466     }
 467     else if (errorCode == RXKADEXPIRED || errorCode == RXKADBADTICKET) {
 468         if (!dead_session) {
 469             lock_ObtainMutex(&userp->mx);
 470             ucellp = cm_GetUCell(userp, serverp->cellp);
 471             if (ucellp->ticketp) {
 472                 free(ucellp->ticketp);
 473                 ucellp->ticketp = NULL;
 474             }
 475             ucellp->flags &= ~CM_UCELLFLAG_RXKAD;
 476             ucellp->gen++;
 477             lock_ReleaseMutex(&userp->mx);
 478             if ( timeLeft > 2 )
 479                 retry = 1;
 480         }
 481     } else if (errorCode == VICECONNBAD || errorCode == VICETOKENDEAD) {
 482         cm_ForceNewConnections(serverp);
 483         if ( timeLeft > 2 )
 484             retry = 1;
 485     } else {
 486         if (errorCode) {
 487             char * s = "unknown error";
 488             switch ( errorCode ) {
 489             case RXKADINCONSISTENCY: s = "RXKADINCONSISTENCY"; break;
 490             case RXKADPACKETSHORT  : s = "RXKADPACKETSHORT";   break;
 491             case RXKADLEVELFAIL    : s = "RXKADLEVELFAIL";     break;
 492             case RXKADTICKETLEN    : s = "RXKADTICKETLEN";     break;
 493             case RXKADOUTOFSEQUENCE: s = "RXKADOUTOFSEQUENCE"; break;
 494             case RXKADNOAUTH       : s = "RXKADNOAUTH";        break;
 495             case RXKADBADKEY       : s = "RXKADBADKEY";        break;
 496             case RXKADBADTICKET    : s = "RXKADBADTICKET";     break;
 497             case RXKADUNKNOWNKEY   : s = "RXKADUNKNOWNKEY";    break;
 498             case RXKADEXPIRED      : s = "RXKADEXPIRED";       break;
 499             case RXKADSEALEDINCON  : s = "RXKADSEALEDINCON";   break;
 500             case RXKADDATALEN      : s = "RXKADDATALEN";       break;
 501             case RXKADILLEGALLEVEL : s = "RXKADILLEGALLEVEL";  break;
 502             case VSALVAGE          : s = "VSALVAGE";           break;
 503             case VNOVNODE          : s = "VNOVNODE";           break;
 504             case VNOVOL            : s = "VNOVOL";             break;
 505             case VVOLEXISTS        : s = "VVOLEXISTS";         break;
 506             case VNOSERVICE        : s = "VNOSERVICE";         break;
 507             case VOFFLINE          : s = "VOFFLINE";           break;
 508             case VONLINE           : s = "VONLINE";            break;
 509             case VDISKFULL         : s = "VDISKFULL";          break;
 510             case VOVERQUOTA        : s = "VOVERQUOTA";         break;
 511             case VBUSY             : s = "VBUSY";              break;
 512             case VMOVED            : s = "VMOVED";             break;
 513             case VIO               : s = "VIO";                break;
 514             case VRESTRICTED       : s = "VRESTRICTED";        break;
 515             case VRESTARTING       : s = "VRESTARTING";        break;
 516             case VREADONLY         : s = "VREADONLY";          break;
 517             case EAGAIN            : s = "EAGAIN";             break;
 518             case UAEAGAIN          : s = "UAEAGAIN";           break;
 519             case EINVAL            : s = "EINVAL";             break;
 520             case UAEINVAL          : s = "UAEINVAL";           break;
 521             case EACCES            : s = "EACCES";             break;
 522             case UAEACCES          : s = "UAEACCES";           break;
 523             case ENOENT            : s = "ENOENT";             break;
 524             case UAENOENT          : s = "UAENOENT";           break;
 525             case VICECONNBAD       : s = "VICECONNBAD";        break;
 526             case VICETOKENDEAD     : s = "VICETOKENDEAD";      break;
 527             case CM_ERROR_NOSUCHCELL        : s = "CM_ERROR_NOSUCHCELL";         break;
 528             case CM_ERROR_NOSUCHVOLUME      : s = "CM_ERROR_NOSUCHVOLUME";       break;
 529             case CM_ERROR_TIMEDOUT          : s = "CM_ERROR_TIMEDOUT";           break;
 530             case CM_ERROR_RETRY             : s = "CM_ERROR_RETRY";              break;
 531             case CM_ERROR_NOACCESS          : s = "CM_ERROR_NOACCESS";           break;
 532             case CM_ERROR_NOSUCHFILE        : s = "CM_ERROR_NOSUCHFILE";         break;
 533             case CM_ERROR_STOPNOW           : s = "CM_ERROR_STOPNOW";            break;
 534             case CM_ERROR_TOOBIG            : s = "CM_ERROR_TOOBIG";             break;
 535             case CM_ERROR_INVAL             : s = "CM_ERROR_INVAL";              break;
 536             case CM_ERROR_BADFD             : s = "CM_ERROR_BADFD";              break;
 537             case CM_ERROR_BADFDOP           : s = "CM_ERROR_BADFDOP";            break;
 538             case CM_ERROR_EXISTS            : s = "CM_ERROR_EXISTS";             break;
 539             case CM_ERROR_CROSSDEVLINK      : s = "CM_ERROR_CROSSDEVLINK";       break;
 540             case CM_ERROR_BADOP             : s = "CM_ERROR_BADOP";              break;
 541             case CM_ERROR_BADPASSWORD       : s = "CM_ERROR_BADPASSWORD";        break;
 542             case CM_ERROR_NOTDIR            : s = "CM_ERROR_NOTDIR";             break;
 543             case CM_ERROR_ISDIR             : s = "CM_ERROR_ISDIR";              break;
 544             case CM_ERROR_READONLY          : s = "CM_ERROR_READONLY";           break;
 545             case CM_ERROR_WOULDBLOCK        : s = "CM_ERROR_WOULDBLOCK";         break;
 546             case CM_ERROR_QUOTA             : s = "CM_ERROR_QUOTA";              break;
 547             case CM_ERROR_SPACE             : s = "CM_ERROR_SPACE";              break;
 548             case CM_ERROR_BADSHARENAME      : s = "CM_ERROR_BADSHARENAME";       break;
 549             case CM_ERROR_BADTID            : s = "CM_ERROR_BADTID";             break;
 550             case CM_ERROR_UNKNOWN           : s = "CM_ERROR_UNKNOWN";            break;
 551             case CM_ERROR_NOMORETOKENS      : s = "CM_ERROR_NOMORETOKENS";       break;
 552             case CM_ERROR_NOTEMPTY          : s = "CM_ERROR_NOTEMPTY";           break;
 553             case CM_ERROR_USESTD            : s = "CM_ERROR_USESTD";             break;
 554             case CM_ERROR_REMOTECONN        : s = "CM_ERROR_REMOTECONN";         break;
 555             case CM_ERROR_ATSYS             : s = "CM_ERROR_ATSYS";              break;
 556             case CM_ERROR_NOSUCHPATH        : s = "CM_ERROR_NOSUCHPATH";         break;
 557             case CM_ERROR_CLOCKSKEW         : s = "CM_ERROR_CLOCKSKEW";          break;
 558             case CM_ERROR_BADSMB            : s = "CM_ERROR_BADSMB";             break;
 559             case CM_ERROR_ALLBUSY           : s = "CM_ERROR_ALLBUSY";            break;
 560             case CM_ERROR_NOFILES           : s = "CM_ERROR_NOFILES";            break;
 561             case CM_ERROR_PARTIALWRITE      : s = "CM_ERROR_PARTIALWRITE";       break;
 562             case CM_ERROR_NOIPC             : s = "CM_ERROR_NOIPC";              break;
 563             case CM_ERROR_BADNTFILENAME     : s = "CM_ERROR_BADNTFILENAME";      break;
 564             case CM_ERROR_BUFFERTOOSMALL    : s = "CM_ERROR_BUFFERTOOSMALL";     break;
 565             case CM_ERROR_RENAME_IDENTICAL  : s = "CM_ERROR_RENAME_IDENTICAL";   break;
 566             case CM_ERROR_ALLOFFLINE        : s = "CM_ERROR_ALLOFFLINE";         break;
 567             case CM_ERROR_AMBIGUOUS_FILENAME: s = "CM_ERROR_AMBIGUOUS_FILENAME"; break;
 568             case CM_ERROR_BADLOGONTYPE      : s = "CM_ERROR_BADLOGONTYPE";       break;
 569             case CM_ERROR_GSSCONTINUE       : s = "CM_ERROR_GSSCONTINUE";        break;
 570             case CM_ERROR_TIDIPC            : s = "CM_ERROR_TIDIPC";             break;
 571             case CM_ERROR_TOO_MANY_SYMLINKS : s = "CM_ERROR_TOO_MANY_SYMLINKS";  break;
 572             case CM_ERROR_PATH_NOT_COVERED  : s = "CM_ERROR_PATH_NOT_COVERED";   break;
 573             case CM_ERROR_LOCK_CONFLICT     : s = "CM_ERROR_LOCK_CONFLICT";      break;
 574             case CM_ERROR_SHARING_VIOLATION : s = "CM_ERROR_SHARING_VIOLATION";  break;
 575             case CM_ERROR_ALLDOWN           : s = "CM_ERROR_ALLDOWN";            break;
 576             case CM_ERROR_TOOFEWBUFS        : s = "CM_ERROR_TOOFEWBUFS";         break;
 577             case CM_ERROR_TOOMANYBUFS       : s = "CM_ERROR_TOOMANYBUFS";        break;
 578             }
 579             osi_Log2(afsd_logp, "cm_Analyze: ignoring error code 0x%x (%s)",
 580                      errorCode, s);
 581             retry = 0;
 582         }
 583     }
 584
 585     if (retry && dead_session)
 586         retry = 0;
 587
 588   out:
 589     /* drop this on the way out */
 590     if (connp)
 591         cm_PutConn(connp);
 592
 593     /* retry until we fail to find a connection */
 594     return retry;
 595 }
 596
 597 long cm_ConnByMServers(cm_serverRef_t *serversp, cm_user_t *usersp,
 598         cm_req_t *reqp, cm_conn_t **connpp)
 599 {
 600     long code;
 601     cm_serverRef_t *tsrp;
 602     cm_server_t *tsp;
 603     long firstError = 0;
 604     int someBusy = 0, someOffline = 0, allOffline = 1, allBusy = 1, allDown = 1;
 605     long timeUsed, timeLeft, hardTimeLeft;
 606
 607     if (serversp == NULL) {
 608         osi_Log1(afsd_logp, "cm_ConnByMServers returning 0x%x", CM_ERROR_NOSUCHVOLUME);
 609         return CM_ERROR_NOSUCHVOLUME;
 610     }
 611
 612     *connpp = NULL;
 613
 614     timeUsed = (GetTickCount() - reqp->startTime) / 1000;
 615
 616     /* leave 5 seconds margin of safety */
 617     timeLeft =  ConnDeadtimeout - timeUsed - 5;
 618     hardTimeLeft = HardDeadtimeout - timeUsed - 5;
 619
 620     lock_ObtainWrite(&cm_serverLock);
 621     for (tsrp = serversp; tsrp; tsrp=tsrp->next) {
 622         tsp = tsrp->server;
 623         cm_GetServerNoLock(tsp);
 624         lock_ReleaseWrite(&cm_serverLock);
 625         if (!(tsp->flags & CM_SERVERFLAG_DOWN)) {
 626             allDown = 0;
 627             if (tsrp->status == busy) {
 628                 allOffline = 0;
 629                 someBusy = 1;
 630             } else if (tsrp->status == offline) {
 631                 allBusy = 0;
 632                 someOffline = 1;
 633             } else {
 634                 allOffline = 0;
 635                 allBusy = 0;
 636                 code = cm_ConnByServer(tsp, usersp, connpp);
 637                 if (code == 0) {        /* cm_CBS only returns 0 */
 638                     cm_PutServer(tsp);
 639                     /* Set RPC timeout */
 640                     if (timeLeft > ConnDeadtimeout)
 641                         timeLeft = ConnDeadtimeout;
 642
 643                     if (hardTimeLeft > HardDeadtimeout)
 644                         hardTimeLeft = HardDeadtimeout;
 645
 646                     lock_ObtainMutex(&(*connpp)->mx);
 647                     rx_SetConnDeadTime((*connpp)->callp, timeLeft);
 648                     rx_SetConnHardDeadTime((*connpp)->callp, (u_short) hardTimeLeft);
 649                     lock_ReleaseMutex(&(*connpp)->mx);
 650                     return 0;
 651                 }
 652
 653                 /* therefore, this code is never executed */
 654                 if (firstError == 0)
 655                     firstError = code;
 656             }
 657         }
 658         lock_ObtainWrite(&cm_serverLock);
 659         cm_PutServerNoLock(tsp);
 660     }
 661     lock_ReleaseWrite(&cm_serverLock);
 662
 663     if (firstError == 0) {
 664         if (allDown)
 665             firstError = CM_ERROR_ALLDOWN;
 666         else if (allBusy)
 667             firstError = CM_ERROR_ALLBUSY;
 668         else if (allOffline || (someBusy && someOffline))
 669             firstError = CM_ERROR_ALLOFFLINE;
 670         else {
 671             osi_Log0(afsd_logp, "cm_ConnByMServers returning impossible error TIMEDOUT");
 672             firstError = CM_ERROR_TIMEDOUT;
 673         }
 674     }
 675
 676     osi_Log1(afsd_logp, "cm_ConnByMServers returning 0x%x", firstError);
 677     return firstError;
 678 }
 679
 680 /* called with a held server to GC all bad connections hanging off of the server */
 681 void cm_GCConnections(cm_server_t *serverp)
 682 {
 683     cm_conn_t *tcp;
 684     cm_conn_t **lcpp;
 685     cm_user_t *userp;
 686
 687     lock_ObtainWrite(&cm_connLock);
 688     lcpp = &serverp->connsp;
 689     for (tcp = *lcpp; tcp; tcp = *lcpp) {
 690         userp = tcp->userp;
 691         if (userp && tcp->refCount == 0 && (userp->vcRefs == 0)) {
 692             /* do the deletion of this guy */
 693             cm_PutServer(tcp->serverp);
 694             cm_ReleaseUser(userp);
 695             *lcpp = tcp->nextp;
 696             rx_DestroyConnection(tcp->callp);
 697             lock_FinalizeMutex(&tcp->mx);
 698             free(tcp);
 699         }
 700         else {
 701             /* just advance to the next */
 702             lcpp = &tcp->nextp;
 703         }
 704     }
 705     lock_ReleaseWrite(&cm_connLock);
 706 }
 707
 708 static void cm_NewRXConnection(cm_conn_t *tcp, cm_ucell_t *ucellp,
 709                                cm_server_t *serverp)
 710 {
 711     unsigned short port;
 712     int serviceID;
 713     int secIndex;
 714     struct rx_securityClass *secObjp;
 715
 716     if (serverp->type == CM_SERVER_VLDB) {
 717         port = htons(7003);
 718         serviceID = 52;
 719     }
 720     else {
 721         osi_assert(serverp->type == CM_SERVER_FILE);
 722         port = htons(7000);
 723         serviceID = 1;
 724     }
 725     if (ucellp->flags & CM_UCELLFLAG_RXKAD) {
 726         secIndex = 2;
 727         if (cryptall) {
 728             tcp->cryptlevel = rxkad_crypt;
 729         } else {
 730             tcp->cryptlevel = rxkad_clear;
 731         }
 732         secObjp = rxkad_NewClientSecurityObject(tcp->cryptlevel,
 733                                                 &ucellp->sessionKey, ucellp->kvno,
 734                                                 ucellp->ticketLen, ucellp->ticketp);
 735     } else {
 736         /* normal auth */
 737         secIndex = 0;
 738         tcp->cryptlevel = rxkad_clear;
 739         secObjp = rxnull_NewClientSecurityObject();
 740     }
 741     osi_assert(secObjp != NULL);
 742     tcp->callp = rx_NewConnection(serverp->addr.sin_addr.s_addr,
 743                                   port,
 744                                   serviceID,
 745                                   secObjp,
 746                                   secIndex);
 747     rx_SetConnDeadTime(tcp->callp, ConnDeadtimeout);
 748     rx_SetConnHardDeadTime(tcp->callp, HardDeadtimeout);
 749     tcp->ucgen = ucellp->gen;
 750     if (secObjp)
 751         rxs_Release(secObjp);   /* Decrement the initial refCount */
 752 }
 753
 754 long cm_ConnByServer(cm_server_t *serverp, cm_user_t *userp, cm_conn_t **connpp)
 755 {
 756     cm_conn_t *tcp;
 757     cm_ucell_t *ucellp;
 758
 759     lock_ObtainMutex(&userp->mx);
 760     lock_ObtainWrite(&cm_connLock);
 761     for (tcp = serverp->connsp; tcp; tcp=tcp->nextp) {
 762         if (tcp->userp == userp)
 763             break;
 764     }
 765
 766     /* find ucell structure */
 767     ucellp = cm_GetUCell(userp, serverp->cellp);
 768     if (!tcp) {
 769         cm_GetServer(serverp);
 770         tcp = malloc(sizeof(*tcp));
 771         memset(tcp, 0, sizeof(*tcp));
 772         tcp->nextp = serverp->connsp;
 773         serverp->connsp = tcp;
 774         cm_HoldUser(userp);
 775         tcp->userp = userp;
 776         lock_InitializeMutex(&tcp->mx, "cm_conn_t mutex");
 777         lock_ObtainMutex(&tcp->mx);
 778         tcp->serverp = serverp;
 779         tcp->cryptlevel = rxkad_clear;
 780         cm_NewRXConnection(tcp, ucellp, serverp);
 781         tcp->refCount = 1;
 782         lock_ReleaseMutex(&tcp->mx);
 783     } else {
 784         if ((tcp->flags & CM_CONN_FLAG_FORCE_NEW) ||
 785             (tcp->ucgen < ucellp->gen) ||
 786             (tcp->cryptlevel != (cryptall ? (ucellp->flags & CM_UCELLFLAG_RXKAD ? rxkad_crypt : rxkad_clear) : rxkad_clear)))
 787         {
 788             if (tcp->ucgen < ucellp->gen)
 789                 osi_Log0(afsd_logp, "cm_ConnByServer replace connection due to token update");
 790             else
 791                 osi_Log0(afsd_logp, "cm_ConnByServer replace connection due to crypt change");
 792             lock_ObtainMutex(&tcp->mx);
 793             tcp->flags &= ~CM_CONN_FLAG_FORCE_NEW;
 794             rx_DestroyConnection(tcp->callp);
 795             cm_NewRXConnection(tcp, ucellp, serverp);
 796             lock_ReleaseMutex(&tcp->mx);
 797         }
 798         tcp->refCount++;
 799     }
 800     lock_ReleaseWrite(&cm_connLock);
 801     lock_ReleaseMutex(&userp->mx);
 802
 803     /* return this pointer to our caller */
 804     osi_Log1(afsd_logp, "cm_ConnByServer returning conn 0x%p", tcp);
 805     *connpp = tcp;
 806
 807     return 0;
 808 }
 809
 810 long cm_Conn(struct cm_fid *fidp, struct cm_user *userp, cm_req_t *reqp,
 811              cm_conn_t **connpp)
 812 {
 813     long code;
 814
 815     cm_serverRef_t **serverspp;
 816
 817     code = cm_GetServerList(fidp, userp, reqp, &serverspp);
 818     if (code) {
 819         *connpp = NULL;
 820         return code;
 821     }
 822
 823     code = cm_ConnByMServers(*serverspp, userp, reqp, connpp);
 824     cm_FreeServerList(serverspp);
 825     return code;
 826 }
 827
 828 extern struct rx_connection *
 829 cm_GetRxConn(cm_conn_t *connp)
 830 {
 831     struct rx_connection * rxconn;
 832     lock_ObtainMutex(&connp->mx);
 833     rxconn = connp->callp;
 834     rx_GetConnection(rxconn);
 835     lock_ReleaseMutex(&connp->mx);
 836     return rxconn;
 837 }
 838
 839 void cm_ForceNewConnections(cm_server_t *serverp)
 840 {
 841     cm_conn_t *tcp;
 842
 843     lock_ObtainWrite(&cm_connLock);
 844     for (tcp = serverp->connsp; tcp; tcp=tcp->nextp) {
 845         lock_ObtainMutex(&tcp->mx);
 846         tcp->flags |= CM_CONN_FLAG_FORCE_NEW;
 847         lock_ReleaseMutex(&tcp->mx);
 848     }
 849     lock_ReleaseWrite(&cm_connLock);
 850 }