src/WINNT/client_config/drivemap.cpp

   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 extern "C" {
  11 #include <afs/param.h>
  12 #include <afs/stds.h>
  13 #include <rx/rxkad.h>
  14 #include <afs/fs_utils.h>
  15 }
  16 #include <windows.h>
  17 #include <stdlib.h>
  18 #include <stdio.h>
  19 #include <WINNT/TaLocale.h>
  20 #undef REALLOC
  21 #include "drivemap.h"
  22 #include <time.h>
  23 #include <adssts.h>
  24 #define DEBUG_VERBOSE
  25 #include <osilog.h>
  26 #include <lanahelper.h>
  27
  28 extern void Config_GetLanAdapter (ULONG *pnLanAdapter);
  29
  30 /*
  31  * REGISTRY ___________________________________________________________________
  32  *
  33  */
  34
  35 #undef AFSConfigKeyName
  36 const TCHAR sAFSConfigKeyName[] = TEXT("SYSTEM\\CurrentControlSet\\Services\\TransarcAFSDaemon\\Parameters");
  37
  38
  39 /*
  40  * PROFILE SECTIONS ___________________________________________________________
  41  *
  42  */
  43
  44 #define cREALLOC_SUBMOUNTS   4
  45
  46 static TCHAR cszINIFILE[] = TEXT("afsdsbmt.ini");
  47 static TCHAR cszSECTION_SUBMOUNTS[] = TEXT("AFS Submounts");
  48 static TCHAR cszSECTION_MAPPINGS[] = TEXT("AFS Mappings");
  49 static TCHAR cszSECTION_ACTIVE[] = TEXT("AFS Active");
  50
  51 static TCHAR cszAUTOSUBMOUNT[] = TEXT("Auto");
  52 static TCHAR cszLANMANDEVICE[] = TEXT("\\Device\\LanmanRedirector\\");
  53
  54
  55 /*
  56  * STRINGS ____________________________________________________________________
  57  *
  58  */
  59
  60 static LPTSTR AllocateStringMemory (size_t cch)
  61 {
  62    LPTSTR psz = (LPTSTR)Allocate (sizeof(TCHAR) * (cch+1));
  63    memset (psz, 0x00, sizeof(TCHAR) * (cch+1));
  64    return psz;
  65 }
  66
  67 static void FreeStringMemory (LPTSTR pszString)
  68 {
  69    Free (pszString);
  70 }
  71
  72 static int lstrncmpi (LPCTSTR pszA, LPCTSTR pszB, size_t cch)
  73 {
  74    if (!pszA || !pszB)
  75       {
  76       return (!pszB) - (!pszA);   // A,!B:1, !A,B:-1, !A,!B:0
  77       }
  78
  79    for ( ; cch > 0; cch--, pszA = CharNext(pszA), pszB = CharNext(pszB))
  80       {
  81       TCHAR chA = toupper( *pszA );
  82       TCHAR chB = toupper( *pszB );
  83
  84       if (!chA || !chB)
  85          return (!chB) - (!chA);    // A,!B:1, !A,B:-1, !A,!B:0
  86
  87       if (chA != chB)
  88          return (int)(chA) - (int)(chB);   // -1:A<B, 0:A==B, 1:A>B
  89       }
  90
  91    return 0;  // no differences before told to stop comparing, so A==B
  92 }
  93
  94
  95 /*
  96  * REALLOC ____________________________________________________________________
  97  *
  98  */
  99
 100 #ifndef REALLOC
 101 #define REALLOC(_a,_c,_r,_i) DriveMapReallocFunction ((LPVOID*)&_a,sizeof(*_a),&_c,_r,_i)
 102 BOOL DriveMapReallocFunction (LPVOID *ppTarget, size_t cbElement, size_t *pcTarget, size_t cReq, size_t cInc)
 103 {
 104    LPVOID pNew;
 105    size_t cNew;
 106
 107    if (cReq <= *pcTarget)
 108       return TRUE;
 109
 110    if ((cNew = cInc * ((cReq + cInc-1) / cInc)) <= 0)
 111       return FALSE;
 112
 113    if ((pNew = Allocate (cbElement * cNew)) == NULL)
 114       return FALSE;
 115    memset (pNew, 0x00, cbElement * cNew);
 116
 117    if (*pcTarget != 0)
 118    {
 119       memcpy (pNew, *ppTarget, cbElement * (*pcTarget));
 120       Free (*ppTarget);
 121    }
 122
 123    *ppTarget = pNew;
 124    *pcTarget = cNew;
 125    return TRUE;
 126 }
 127 #endif
 128
 129
 130 /*
 131  * WINDOWS NT STUFF ___________________________________________________________
 132  *
 133  */
 134
 135 static BOOL IsWindowsNT (void)
 136 {
 137    static BOOL fChecked = FALSE;
 138    static BOOL fIsWinNT = FALSE;
 139
 140    if (!fChecked)
 141       {
 142       fChecked = TRUE;
 143
 144       OSVERSIONINFO Version;
 145       memset (&Version, 0x00, sizeof(Version));
 146       Version.dwOSVersionInfoSize = sizeof(Version);
 147
 148       if (GetVersionEx (&Version))
 149          {
 150          if (Version.dwPlatformId == VER_PLATFORM_WIN32_NT)
 151             fIsWinNT = TRUE;
 152          }
 153       }
 154
 155    return fIsWinNT;
 156 }
 157
 158 /* Check if the OS is Windows 2000 or higher.
 159 */
 160 BOOL IsWindows2000 (void)
 161 {
 162    static BOOL fChecked = FALSE;
 163    static BOOL fIsWin2K = FALSE;
 164
 165    if (!fChecked)
 166       {
 167       fChecked = TRUE;
 168
 169       OSVERSIONINFO Version;
 170       memset (&Version, 0x00, sizeof(Version));
 171       Version.dwOSVersionInfoSize = sizeof(Version);
 172
 173       if (GetVersionEx (&Version))
 174          {
 175          if (Version.dwPlatformId == VER_PLATFORM_WIN32_NT &&
 176              Version.dwMajorVersion >= 5)
 177              fIsWin2K = TRUE;
 178          }
 179       }
 180
 181    return fIsWin2K;
 182 }
 183
 184 /*
 185  * GENERAL ____________________________________________________________________
 186  *
 187  */
 188
 189 void GetClientNetbiosName (LPTSTR pszName)
 190 {
 191     *pszName = TEXT('\0');
 192     lana_GetNetbiosName(pszName, LANA_NETBIOS_NAME_FULL);
 193 }
 194
 195
 196 BOOL SubmountToPath (PDRIVEMAPLIST pList, LPTSTR pszPath, LPTSTR pszSubmount, BOOL fMarkInUse)
 197 {
 198    // We can't do this translation unless we're under Windows NT.
 199    //
 200    if (!IsWindowsNT())
 201       return FALSE;
 202
 203    // \\computer-afs\all always maps to "/afs"
 204    //
 205    if (!lstrcmpi (pszSubmount, TEXT("all")))
 206       {
 207       lstrcpy (pszPath, cm_slash_mount_root);
 208       return TRUE;
 209       }
 210
 211    // Otherwise, look up our list of submounts.
 212    //
 213    for (size_t ii = 0; ii < pList->cSubmounts; ++ii)
 214       {
 215       if (!lstrcmpi (pList->aSubmounts[ii].szSubmount, pszSubmount))
 216          {
 217          if (fMarkInUse)
 218             pList->aSubmounts[ii].fInUse = TRUE;
 219          AdjustAfsPath (pszPath, pList->aSubmounts[ii].szMapping, TRUE, TRUE);
 220          return TRUE;
 221          }
 222       }
 223
 224    return FALSE;
 225 }
 226
 227
 228 BOOL IsValidSubmountName (LPTSTR pszSubmount)
 229 {
 230    if (!*pszSubmount)
 231       return FALSE;
 232    if (lstrlen (pszSubmount) > 12)
 233       return FALSE;
 234
 235    for ( ; *pszSubmount; ++pszSubmount)
 236       {
 237       if (!isprint(*pszSubmount))
 238          return FALSE;
 239       if (*pszSubmount == TEXT(' '))
 240          return FALSE;
 241       if (*pszSubmount == TEXT('\t'))
 242          return FALSE;
 243       }
 244
 245    return TRUE;
 246 }
 247
 248
 249 /*
 250  * PIOCTL SUPPORT _____________________________________________________________
 251  *
 252  */
 253
 254 extern "C" {
 255
 256 #include "../afsd/fs_utils.h"
 257
 258 #define __CM_CONFIG_INTERFACES_ONLY__
 259 #include "../afsd/cm_config.h"
 260
 261 #define __CM_IOCTL_INTERFACES_ONLY__
 262 #include "../afsd/cm_ioctl.h"
 263
 264 } // extern "C"
 265
 266 #define PIOCTL_MAXSIZE     2048
 267
 268
 269 BOOL fCanIssuePIOCTL (void)
 270 {
 271    if (!IsWindowsNT())
 272       {
 273       TCHAR szGateway[ 256 ] = TEXT("");
 274       GetClientNetbiosName (szGateway);
 275       return (szGateway[0]) ? TRUE : FALSE;
 276       }
 277
 278    SERVICE_STATUS Status;
 279    memset (&Status, 0x00, sizeof(Status));
 280    Status.dwCurrentState = SERVICE_STOPPED;
 281
 282    SC_HANDLE hManager;
 283    if ((hManager = OpenSCManager (NULL, NULL, GENERIC_READ)) != NULL)
 284       {
 285       SC_HANDLE hService;
 286       if ((hService = OpenService (hManager, TEXT("TransarcAFSDaemon"), GENERIC_READ)) != NULL)
 287          {
 288          QueryServiceStatus (hService, &Status);
 289          CloseServiceHandle (hService);
 290          }
 291
 292       CloseServiceHandle (hManager);
 293       }
 294
 295    return (Status.dwCurrentState == SERVICE_RUNNING) ? TRUE : FALSE;
 296 }
 297
 298
 299 /*
 300  * QUERYDRIVEMAPLIST __________________________________________________________
 301  *
 302  */
 303
 304 void QueryDriveMapList_ReadSubmounts (PDRIVEMAPLIST pList)
 305 {
 306    if (IsWindowsNT())
 307       {
 308       size_t cchLHS = 1024;
 309       LPTSTR mszLHS = AllocateStringMemory (cchLHS);
 310
 311       for (int iRetry = 0; iRetry < 5; ++iRetry)
 312          {
 313          DWORD rc = GetPrivateProfileString (cszSECTION_SUBMOUNTS, NULL, TEXT(""), mszLHS, cchLHS, cszINIFILE);
 314          if ((rc != cchLHS-1) && (rc != cchLHS-2))
 315             break;
 316
 317          FreeStringMemory (mszLHS);
 318          cchLHS *= 2;
 319          mszLHS = AllocateStringMemory (cchLHS);
 320          }
 321
 322       for (LPTSTR psz = mszLHS; psz && *psz; psz += 1+lstrlen(psz))
 323          {
 324          SUBMOUNT Submount;
 325          memset (&Submount, 0x00, sizeof(SUBMOUNT));
 326          lstrcpy (Submount.szSubmount, psz);
 327
 328          TCHAR szMapping[ MAX_PATH ] = TEXT("");
 329          GetPrivateProfileString (cszSECTION_SUBMOUNTS, Submount.szSubmount, TEXT(""), szMapping, MAX_PATH, cszINIFILE);
 330          if (szMapping[0] != TEXT('\0'))
 331             {
 332             AdjustAfsPath (Submount.szMapping, szMapping, FALSE, TRUE);
 333
 334             for (size_t ii = 0; ii < pList->cSubmounts; ++ii)
 335                {
 336                if (!pList->aSubmounts[ii].szSubmount[0])
 337                   break;
 338                }
 339             if (REALLOC (pList->aSubmounts, pList->cSubmounts, 1+ii, cREALLOC_SUBMOUNTS))
 340                {
 341                memcpy (&pList->aSubmounts[ii], &Submount, sizeof(SUBMOUNT));
 342                }
 343             }
 344          }
 345
 346       FreeStringMemory (mszLHS);
 347       }
 348 }
 349
 350
 351 void QueryDriveMapList_ReadMappings (PDRIVEMAPLIST pList)
 352 {
 353    size_t cchLHS = 1024;
 354    LPTSTR mszLHS = AllocateStringMemory (cchLHS);
 355
 356    for (int iRetry = 0; iRetry < 5; ++iRetry)
 357       {
 358       DWORD rc = GetPrivateProfileString (cszSECTION_MAPPINGS, NULL, TEXT(""), mszLHS, cchLHS, cszINIFILE);
 359       if ((rc != cchLHS-1) && (rc != cchLHS-2))
 360          break;
 361
 362       FreeStringMemory (mszLHS);
 363       cchLHS *= 2;
 364       mszLHS = AllocateStringMemory (cchLHS);
 365       }
 366
 367    for (LPTSTR psz = mszLHS; psz && *psz; psz += 1+lstrlen(psz))
 368       {
 369       DRIVEMAP DriveMap;
 370       memset (&DriveMap, 0x00, sizeof(DRIVEMAP));
 371       DriveMap.chDrive = toupper(*psz);
 372       DriveMap.fPersistent = TRUE;
 373       if ((DriveMap.chDrive < chDRIVE_A) || (DriveMap.chDrive > chDRIVE_Z))
 374          continue;
 375
 376       TCHAR szMapping[ MAX_PATH ] = TEXT("");
 377       GetPrivateProfileString (cszSECTION_MAPPINGS, psz, TEXT(""), szMapping, MAX_PATH, cszINIFILE);
 378       if (szMapping[0] != TEXT('\0'))
 379          {
 380          AdjustAfsPath (DriveMap.szMapping, szMapping, TRUE, TRUE);
 381          if (DriveMap.szMapping[ lstrlen(DriveMap.szMapping)-1 ] == TEXT('*'))
 382             {
 383             DriveMap.fPersistent = FALSE;
 384             DriveMap.szMapping[ lstrlen(DriveMap.szMapping)-1 ] = TEXT('\0');
 385             }
 386          size_t iDrive = DriveMap.chDrive - chDRIVE_A;
 387          memcpy (&pList->aDriveMap[ iDrive ], &DriveMap, sizeof(DRIVEMAP));
 388          }
 389       }
 390
 391    FreeStringMemory (mszLHS);
 392 }
 393
 394 BOOL ForceMapActive (TCHAR chDrive)
 395 {
 396     TCHAR szDrive[2];
 397     TCHAR szActive[32];
 398
 399     szDrive[0] = chDrive;
 400     szDrive[1] = 0;
 401
 402     GetPrivateProfileString (cszSECTION_ACTIVE, szDrive, TEXT("0"), szActive, sizeof(szActive), cszINIFILE);
 403
 404     if ( !lstrcmp(szActive,"1") || !lstrcmpi(szActive,"true") || !lstrcmpi(szActive,"on") || !lstrcmpi(szActive,"yes") )
 405         return TRUE;
 406     return FALSE;
 407 }
 408
 409
 410 void WriteActiveMap (TCHAR chDrive, BOOL on)
 411 {
 412     TCHAR szDrive[2];
 413
 414     szDrive[0] = chDrive;
 415     szDrive[1] = 0;
 416
 417     WritePrivateProfileString (cszSECTION_ACTIVE, szDrive, on ? "1" : "0", cszINIFILE);
 418 }
 419
 420 void QueryDriveMapList_WriteMappings (PDRIVEMAPLIST pList)
 421 {
 422    WriteDriveMappings (pList);
 423 }
 424
 425
 426 void WriteDriveMappings (PDRIVEMAPLIST pList)
 427 {
 428    WritePrivateProfileString (cszSECTION_MAPPINGS, NULL, NULL, cszINIFILE);
 429
 430    for (size_t iDrive = 0; iDrive < 26; ++iDrive)
 431       {
 432       if (pList->aDriveMap[iDrive].szMapping[0] != TEXT('\0'))
 433          {
 434          TCHAR szLHS[] = TEXT("*");
 435          szLHS[0] = pList->aDriveMap[iDrive].chDrive;
 436
 437          TCHAR szRHS[MAX_PATH];
 438          AdjustAfsPath (szRHS, pList->aDriveMap[iDrive].szMapping, TRUE, TRUE);
 439          if (!pList->aDriveMap[iDrive].fPersistent)
 440             lstrcat (szRHS, TEXT("*"));
 441
 442          WritePrivateProfileString (cszSECTION_MAPPINGS, szLHS, szRHS, cszINIFILE);
 443          }
 444       }
 445 }
 446
 447 BOOL DriveIsGlobalAfsDrive(TCHAR chDrive)
 448 {
 449    TCHAR szKeyName[128];
 450    TCHAR szValueName[128];
 451    TCHAR szValue[128];
 452    HKEY hKey;
 453
 454    _stprintf(szKeyName, TEXT("%s\\GlobalAutoMapper"), sAFSConfigKeyName);
 455
 456    if (RegOpenKeyEx(HKEY_LOCAL_MACHINE, szKeyName, 0, KEY_QUERY_VALUE, &hKey) != ERROR_SUCCESS)
 457       return FALSE;
 458
 459    _stprintf(szValueName, TEXT("%c:"), chDrive);
 460
 461    DWORD dwSize = sizeof(szValue);
 462    BOOL bIsGlobal = (RegQueryValueEx (hKey, szValueName, NULL, NULL, (PBYTE)szValue, &dwSize) == ERROR_SUCCESS);
 463
 464    RegCloseKey (hKey);
 465
 466    return bIsGlobal;
 467 }
 468
 469
 470 void QueryDriveMapList_FindNetworkDrives (PDRIVEMAPLIST pList, BOOL *pfFoundNew)
 471 {
 472    for (TCHAR chDrive = chDRIVE_A; chDrive <= chDRIVE_Z; ++chDrive)
 473       {
 474       TCHAR szSubmount[ MAX_PATH ];
 475       if (!GetDriveSubmount (chDrive, szSubmount))
 476          continue;
 477
 478       // We've got a mapping!  Drive {chDrive} is mapped to submount
 479       // {szSubmount}. See if that submount makes sense.
 480       //
 481       if (!IsWindowsNT())
 482          {
 483          size_t iDrive = chDrive - chDRIVE_A;
 484          if (pList->aDriveMap[ iDrive ].szMapping[0] != TEXT('\0'))
 485             {
 486             pList->aDriveMap[ iDrive ].fActive = TRUE;
 487             lstrcpy (pList->aDriveMap[ iDrive ].szSubmount, szSubmount);
 488             }
 489          continue;
 490          }
 491       else // (IsWindowsNT())
 492          {
 493          TCHAR szAfsPath[ MAX_PATH ];
 494          if (!SubmountToPath (pList, szAfsPath, szSubmount, TRUE))
 495             continue;
 496
 497          // Okay, we know that drive {chDrive} is mapped to afs path {szAfsPath}.
 498          // If this drive is a global afs drive, then reject it.  Otherwise, look
 499          // at pList->aDriveMap, to see if this drive mapping is already in our
 500          // list. If not, add it and set pfFoundNew.
 501          //
 502          if (DriveIsGlobalAfsDrive(chDrive))
 503             continue;
 504
 505          size_t iDrive = chDrive - chDRIVE_A;
 506          if (lstrcmpi (pList->aDriveMap[ iDrive ].szMapping, szAfsPath))
 507             {
 508             *pfFoundNew = TRUE;
 509             pList->aDriveMap[ iDrive ].fPersistent = TRUE;
 510             }
 511          pList->aDriveMap[ iDrive ].fActive = TRUE;
 512          pList->aDriveMap[ iDrive ].chDrive = chDrive;
 513          lstrcpy (pList->aDriveMap[ iDrive ].szSubmount, szSubmount);
 514          AdjustAfsPath (pList->aDriveMap[ iDrive ].szMapping, szAfsPath, TRUE, TRUE);
 515          }
 516       }
 517 }
 518
 519
 520 void QueryDriveMapList (PDRIVEMAPLIST pList)
 521 {
 522    // Initialize the data structure
 523    //
 524    memset (pList, 0x00, sizeof(DRIVEMAPLIST));
 525    for (size_t ii = 0; ii < 26; ++ii)
 526       pList->aDriveMap[ii].chDrive = chDRIVE_A + ii;
 527
 528    // Read the current lists of submounts and drive letter mappings
 529    //
 530    QueryDriveMapList_ReadSubmounts (pList);
 531    QueryDriveMapList_ReadMappings (pList);
 532
 533    // Look through the current list of network drives, and see if
 534    // any are currently mapped to AFS. If we find any which are mapped
 535    // into AFS unexpectedly, we'll have to rewrite the mappings list.
 536    //
 537    BOOL fFoundNew = FALSE;
 538    QueryDriveMapList_FindNetworkDrives (pList, &fFoundNew);
 539
 540    if (fFoundNew)
 541       {
 542       QueryDriveMapList_WriteMappings (pList);
 543       }
 544 }
 545
 546
 547 void FreeDriveMapList (PDRIVEMAPLIST pList)
 548 {
 549    if (pList->aSubmounts)
 550       Free (pList->aSubmounts);
 551    memset (pList, 0x00, sizeof(DRIVEMAPLIST));
 552 }
 553
 554
 555 BOOL PathToSubmount (LPTSTR pszSubmount, LPTSTR pszMapping, LPTSTR pszSubmountReq, ULONG *pStatus)
 556 {
 557    if (pszSubmountReq && !IsValidSubmountName (pszSubmountReq))
 558       pszSubmountReq = NULL;
 559
 560    TCHAR szAfsPath[ MAX_PATH ];
 561    AdjustAfsPath (szAfsPath, pszMapping, TRUE, TRUE);
 562
 563    // Try to ask AFSD for a new submount name.
 564    //
 565    if (!fCanIssuePIOCTL())
 566       return FALSE;
 567
 568    BYTE InData[ PIOCTL_MAXSIZE ];
 569    memset (InData, 0x00, sizeof(InData));
 570
 571    LPTSTR pszInData = (LPTSTR)InData;
 572    lstrcpy (pszInData, pszMapping);
 573    pszInData += 1+lstrlen(pszInData);
 574    if (pszSubmountReq)
 575       lstrcpy (pszInData, pszSubmountReq);
 576
 577    BYTE OutData[ PIOCTL_MAXSIZE ];
 578    memset (OutData, 0x00, sizeof(OutData));
 579
 580    struct ViceIoctl IOInfo;
 581    IOInfo.in = (char *)InData;
 582    IOInfo.in_size = PIOCTL_MAXSIZE;
 583    IOInfo.out = (char *)OutData;
 584    IOInfo.out_size = PIOCTL_MAXSIZE;
 585
 586    ULONG status = pioctl (0, VIOC_MAKESUBMOUNT, &IOInfo, 1);
 587    if (pStatus)
 588        *pStatus = status;
 589
 590    if (status)
 591       return FALSE;
 592
 593    lstrcpy (pszSubmount, (LPCTSTR)OutData);
 594    return (pszSubmount[0] != TEXT('\0')) ? TRUE : FALSE;
 595 }
 596
 597
 598 BOOL ActivateDriveMap (TCHAR chDrive, LPTSTR pszMapping, LPTSTR pszSubmountReq, BOOL fPersistent, DWORD *pdwStatus)
 599 {
 600    // We can only map drives to places in AFS using this function.
 601    //
 602    if ( (lstrncmpi (pszMapping, cm_slash_mount_root, lstrlen(cm_slash_mount_root))) &&
 603         (lstrncmpi (pszMapping, cm_back_slash_mount_root, lstrlen(cm_back_slash_mount_root))) )
 604       {
 605       if (pdwStatus)
 606          *pdwStatus = ERROR_BAD_NETPATH;
 607       return FALSE;
 608       }
 609
 610    // First we have to translate {pszMapping} into a submount, and if there is
 611    // no current submount associated with this path, we'll have to make one.
 612    //
 613    ULONG status;
 614    TCHAR szSubmount[ MAX_PATH ];
 615    if (!PathToSubmount (szSubmount, pszMapping, pszSubmountReq, &status))
 616       {
 617       if (pdwStatus)
 618          *pdwStatus = status;
 619       return FALSE;
 620       }
 621
 622    // We now have a submount name and drive letter--map the network drive.
 623    DWORD rc=MountDOSDrive(chDrive,szSubmount,fPersistent);
 624    if (rc == NO_ERROR)
 625       return TRUE;
 626
 627    if (pdwStatus)
 628       *pdwStatus = rc;
 629    return FALSE;
 630 }
 631
 632
 633 BOOL InactivateDriveMap (TCHAR chDrive, DWORD *pdwStatus)
 634 {
 635    DWORD rc = DisMountDOSDrive(chDrive, FALSE);
 636    if (rc == NO_ERROR)
 637       return TRUE;
 638
 639    if (pdwStatus)
 640       *pdwStatus = rc;
 641    return FALSE;
 642 }
 643
 644
 645 void AddSubMount (LPTSTR pszSubmount, LPTSTR pszMapping)
 646 {
 647    TCHAR szRHS[ MAX_PATH ];
 648    AdjustAfsPath (szRHS, pszMapping, FALSE, TRUE);
 649    if (!szRHS[0])
 650       lstrcpy (szRHS, TEXT("/"));
 651    WritePrivateProfileString (cszSECTION_SUBMOUNTS, pszSubmount, szRHS, cszINIFILE);
 652 }
 653
 654
 655 void RemoveSubMount (LPTSTR pszSubmount)
 656 {
 657    WritePrivateProfileString (cszSECTION_SUBMOUNTS, pszSubmount, NULL, cszINIFILE);
 658 }
 659
 660
 661 void AdjustAfsPath (LPTSTR pszTarget, LPCTSTR pszSource, BOOL fWantAFS, BOOL fWantForwardSlashes)
 662 {
 663     if (!*pszSource)
 664         lstrcpy (pszTarget, (fWantAFS) ? cm_slash_mount_root : TEXT(""));
 665     else if ((*pszSource != TEXT('/')) && (*pszSource != TEXT('\\')))
 666         wsprintf (pszTarget, TEXT("%s/%s"),cm_slash_mount_root, pszSource);
 667     // We don't want to strip afs off the start if it is part of something for example afscell.company.com
 668     else if (fWantAFS && (lstrncmpi (&pszSource[1], cm_mount_root, strlen(cm_mount_root))) || !((pszSource[strlen(cm_slash_mount_root)] == TEXT('/')) ||
 669                                                                                                  (pszSource[strlen(cm_slash_mount_root)] == TEXT('\\')) ||
 670                                                                                                  (lstrlen(pszSource) == strlen(cm_slash_mount_root))))
 671         wsprintf (pszTarget, TEXT("%s%s"),cm_slash_mount_root, pszSource);
 672     else if (!fWantAFS && (!lstrncmpi (&pszSource[1], cm_mount_root, strlen(cm_mount_root)) && ((pszSource[strlen(cm_slash_mount_root)] == TEXT('/')) ||
 673                                                                                                  (pszSource[strlen(cm_slash_mount_root)] == TEXT('\\')) ||
 674                                                                                                  (lstrlen(pszSource) == strlen(cm_slash_mount_root)))))
 675         lstrcpy (pszTarget, &pszSource[strlen(cm_slash_mount_root)]);
 676     else
 677         lstrcpy (pszTarget, pszSource);
 678
 679    for (LPTSTR pch = pszTarget; *pch; ++pch)
 680       {
 681       if (fWantForwardSlashes)
 682          {
 683          *pch = (*pch == TEXT('\\')) ? TEXT('/') : (*pch);
 684          }
 685       else // (!fWantForwardSlashes)
 686          {
 687          *pch = (*pch == TEXT('/')) ? TEXT('\\') : (*pch);
 688          }
 689       }
 690
 691    if (lstrlen(pszTarget) &&
 692        ((pszTarget[lstrlen(pszTarget)-1] == TEXT('/')) ||
 693         (pszTarget[lstrlen(pszTarget)-1] == TEXT('\\'))))
 694       {
 695       pszTarget[lstrlen(pszTarget)-1] = TEXT('\0');
 696       }
 697 }
 698
 699 BOOL GetDriveSubmount (TCHAR chDrive, LPTSTR pszSubmountNow)
 700 {
 701     TCHAR szDrive[] = TEXT("*:");
 702     szDrive[0] = chDrive;
 703
 704     TCHAR szMapping[ _MAX_PATH ] = TEXT("");
 705     LPTSTR pszSubmount = szMapping;
 706     TCHAR szNetBiosName[32];
 707
 708     memset(szNetBiosName, '\0', sizeof(szNetBiosName));
 709     lana_GetNetbiosName(szNetBiosName, LANA_NETBIOS_NAME_FULL);
 710     _tcscat(szNetBiosName, TEXT("\\"));
 711
 712    if (IsWindowsNT())
 713    {
 714        if (!QueryDosDevice (szDrive, szMapping, MAX_PATH))
 715            return FALSE;
 716
 717       // Now if this is an AFS network drive mapping, {szMapping} will be:
 718       //
 719       //   \Device\LanmanRedirector\<Drive>:\<netbiosname>\submount
 720       //
 721       // on Windows NT. On Windows 2000, it will be:
 722       //
 723       //   \Device\LanmanRedirector\;<Drive>:0\<netbiosname>\submount
 724       //
 725       // (This is presumably to support multiple drive mappings with
 726       // Terminal Server).
 727       //
 728       // on Windows XP and 2003, it will be :
 729       //   \Device\LanmanRedirector\;<Drive>:<AuthID>\<netbiosname>\submount
 730       //
 731       //   where : <Drive> : DOS drive letter
 732       //           <AuthID>: Authentication ID, 16 char hex.
 733       //           <netbiosname>: Netbios name of server
 734       //
 735       if (_tcsnicmp(szMapping, cszLANMANDEVICE, _tcslen(cszLANMANDEVICE)))
 736          return FALSE;
 737       pszSubmount = &szMapping[ _tcslen(cszLANMANDEVICE) ];
 738
 739       if (IsWindows2000())
 740           {
 741           if (*(pszSubmount) != TEXT(';'))
 742              return FALSE;
 743           } else
 744                 --pszSubmount;
 745
 746       if (toupper(*(++pszSubmount)) != chDrive)
 747          return FALSE;
 748
 749       if (*(++pszSubmount) != TEXT(':'))
 750          return FALSE;
 751
 752 #ifdef COMMENT
 753        // No longer a safe assumption on XP
 754       if (IsWindows2000())
 755           if (*(++pszSubmount) != TEXT('0'))
 756              return FALSE;
 757 #endif
 758
 759       // scan for next "\"
 760       while (*(++pszSubmount) != TEXT('\\'))
 761       {
 762           if (*pszSubmount==0)
 763               return FALSE;
 764       }
 765
 766        // note that szNetBiosName has a '\\' tagged in the end earlier
 767       for (++pszSubmount; *pszSubmount && (*pszSubmount != TEXT('\\')); ++pszSubmount)
 768          if (!_tcsncicmp(pszSubmount, szNetBiosName, _tcslen(szNetBiosName)))
 769             break;
 770       if ((!*pszSubmount) || (*pszSubmount == TEXT('\\')))
 771          return FALSE;
 772
 773        pszSubmount += _tcslen(szNetBiosName);
 774       }
 775    else // (!IsWindowsNT())
 776       {
 777       DWORD dwSize = MAX_PATH;
 778       if (WNetGetConnection (szDrive, szMapping, &dwSize) != NO_ERROR)
 779          return FALSE;
 780       if (*(pszSubmount++) != TEXT('\\'))
 781          return FALSE;
 782       if (*(pszSubmount++) != TEXT('\\'))
 783          return FALSE;
 784       for ( ; *pszSubmount && (*pszSubmount != TEXT('\\')); ++pszSubmount)
 785          if (!lstrncmpi (pszSubmount, szNetBiosName, lstrlen(szNetBiosName)))
 786             break;
 787       if ((!*pszSubmount) || (*pszSubmount == TEXT('\\')))
 788          return FALSE;
 789       pszSubmount += lstrlen(szNetBiosName);
 790       }
 791
 792    if (!pszSubmount || !*pszSubmount)
 793       return FALSE;
 794
 795    lstrcpy (pszSubmountNow, pszSubmount);
 796    return TRUE;
 797 }
 798
 799 /* Generate Random User name random acording to time*/
 800 DWORD dwOldState=0;
 801 TCHAR pUserName[MAXRANDOMNAMELEN]=TEXT("");
 802 BOOL fUserName=FALSE;
 803 #define AFSLogonOptionName TEXT("System\\CurrentControlSet\\Services\\TransarcAFSDaemon\\NetworkProvider")
 804
 805 void SetBitLogonOption(BOOL set,DWORD value)
 806 {
 807
 808    RWLogonOption(FALSE,((set)?value | RWLogonOption(TRUE,0):RWLogonOption(TRUE,0) & ~value) );
 809 }
 810
 811 DWORD RWLogonOption(BOOL read,DWORD value)
 812 {
 813         // if read is true then if value==0 return registry value
 814         // if read and value!=0 then use value to test registry, return TRUE if value bits match value read
 815    HKEY hk;
 816    DWORD dwDisp;
 817         DWORD LSPtype, LSPsize;
 818         DWORD rval;
 819    if (read)
 820    {
 821            rval=0;
 822                 if (RegOpenKeyEx(HKEY_LOCAL_MACHINE, AFSLogonOptionName,0, KEY_QUERY_VALUE, &hk)==ERROR_SUCCESS)
 823                 {
 824                         LSPsize=sizeof(rval);
 825                         RegQueryValueEx(hk, "LogonOptions", NULL,
 826                                                 &LSPtype, (LPBYTE)&rval, &LSPsize);
 827                         RegCloseKey (hk);
 828                 }
 829                 return (value==0)?rval:((rval & value)==value);
 830
 831    } else {     //write
 832                 if (RegCreateKeyEx (HKEY_LOCAL_MACHINE, AFSLogonOptionName, 0, NULL, 0, KEY_SET_VALUE, NULL, &hk, &dwDisp) == ERROR_SUCCESS)
 833                 {
 834                         RegSetValueEx(hk,TEXT("LogonOptions"),NULL,REG_DWORD,(LPBYTE)&value,sizeof(value));
 835                         RegCloseKey (hk);
 836                 }
 837                 return TRUE;
 838    }
 839 }
 840
 841 void MapShareName(char *pszCmdLineA)
 842 {
 843         fUserName = TRUE;
 844         TCHAR *p=pUserName;
 845         pszCmdLineA++;
 846         while (*pszCmdLineA && (*pszCmdLineA != ' '))
 847         {
 848           *p++=*pszCmdLineA++;
 849         }
 850 }
 851
 852 void GenRandomName(TCHAR *pname,int len)
 853 {
 854         if (fUserName)
 855         {               //user name was passed through command line, use once
 856                 fUserName=FALSE;
 857                 return;
 858         }
 859         srand( (unsigned)time( NULL ) );
 860         for (int i=0;i<len;i++)
 861                 pname[i]='a'+(rand() % 26);
 862         pname[len]=0;
 863         return;
 864 }
 865
 866 /*
 867         Make a connection using users name
 868         if fUserName then force a connection
 869 */
 870
 871 BOOL TestAndDoMapShare(DWORD dwState)
 872 {
 873     if ((dwState!=SERVICE_RUNNING) || (dwOldState!=SERVICE_START_PENDING))
 874         {
 875                 dwOldState=dwState;
 876                 return TRUE;
 877         }
 878         dwOldState=SERVICE_RUNNING;
 879         if (RWLogonOption(TRUE,LOGON_OPTION_HIGHSECURITY))
 880             return (DoMapShare() && GlobalMountDrive());
 881         return GlobalMountDrive();
 882 }
 883
 884 BOOL IsServiceActive()
 885 {
 886    SC_HANDLE hManager;
 887    SERVICE_STATUS Status;
 888    if ((hManager = OpenSCManager (NULL, NULL, GENERIC_READ)) != NULL)
 889       {
 890       SC_HANDLE hService;
 891       if ((hService = OpenService (hManager, TEXT("TransarcAFSDaemon"), GENERIC_READ)) != NULL)
 892          {
 893          QueryServiceStatus (hService, &Status);
 894          CloseServiceHandle (hService);
 895          }
 896
 897       CloseServiceHandle (hManager);
 898       }
 899
 900    return (Status.dwCurrentState == SERVICE_RUNNING) ? TRUE : FALSE;
 901 }
 902
 903 void TestAndDoUnMapShare()
 904 {
 905         if (!RWLogonOption(TRUE,LOGON_OPTION_HIGHSECURITY))
 906                 return;
 907         DoUnMapShare(FALSE);
 908 }
 909
 910 void DoUnMapShare(BOOL drivemap)        //disconnect drivemap
 911 {
 912         TCHAR szMachine[MAX_PATH],szPath[MAX_PATH];
 913         DWORD rc=28;
 914         HANDLE hEnum;
 915         LPNETRESOURCE lpnrLocal,lpnr=NULL;
 916         DWORD res;
 917         DWORD cbBuffer=16384;
 918         DWORD cEntries=-1;
 919         CHAR *pSubmount="";
 920
 921     memset(szMachine, '\0', sizeof(szMachine));
 922     lana_GetNetbiosName(szMachine, LANA_NETBIOS_NAME_FULL);
 923
 924    // Initialize the data structure
 925         if ((res=WNetOpenEnum(RESOURCE_CONNECTED,RESOURCETYPE_DISK,RESOURCEUSAGE_CONNECTABLE,lpnr,&hEnum))!=NO_ERROR)
 926                 return;
 927         sprintf(szPath,"\\\\%s\\",szMachine);
 928         _strlwr(szPath);
 929         lpnrLocal=(LPNETRESOURCE) GlobalAlloc(GPTR,cbBuffer);
 930         do {
 931                 memset(lpnrLocal,0,cbBuffer);
 932                 if ((res = WNetEnumResource(hEnum,&cEntries,lpnrLocal,&cbBuffer))==NO_ERROR)
 933                 {
 934                         for (DWORD i=0;i<cEntries;i++)
 935                         {
 936                                 if (strstr(_strlwr(lpnrLocal[i].lpRemoteName),szPath))
 937                                 {
 938                                         if ((lpnrLocal[i].lpLocalName) && (strlen(lpnrLocal[i].lpLocalName)>0))
 939                                         {
 940                                                 if (drivemap) {
 941                                                     DisMountDOSDrive(*lpnrLocal[i].lpLocalName);
 942                             DEBUG_EVENT1("AFS DriveUnMap","UnMap-Local=%x",res);
 943                         }
 944                                         } else {
 945                                             DisMountDOSDriveFull(lpnrLocal[i].lpRemoteName);
 946                         DEBUG_EVENT1("AFS DriveUnMap","UnMap-Remote=%x",res);
 947                     }
 948                                 }
 949                         }
 950                 }
 951         } while (res!=ERROR_NO_MORE_ITEMS);
 952         GlobalFree((HGLOBAL)lpnrLocal);
 953         WNetCloseEnum(hEnum);
 954 }
 955
 956 BOOL DoMapShareChange()
 957 {
 958         DRIVEMAPLIST List;
 959         TCHAR szMachine[ MAX_PATH],szPath[MAX_PATH];
 960         DWORD rc=28;
 961         HANDLE hEnum;
 962         LPNETRESOURCE lpnrLocal,lpnr=NULL;
 963         DWORD res;
 964         DWORD cEntries=-1;
 965     DWORD cbBuffer=16384;
 966
 967     memset(szMachine, '\0', sizeof(szMachine));
 968     lana_GetNetbiosName(szMachine, LANA_NETBIOS_NAME_FULL);
 969
 970     // Initialize the data structure
 971         if (!IsServiceActive())
 972                 return TRUE;
 973         memset (&List, 0x00, sizeof(DRIVEMAPLIST));
 974         for (size_t ii = 0; ii < 26; ++ii)
 975                 List.aDriveMap[ii].chDrive = chDRIVE_A + ii;
 976         QueryDriveMapList_ReadSubmounts (&List);
 977         if ((res=WNetOpenEnum(RESOURCE_CONNECTED,RESOURCETYPE_DISK,RESOURCEUSAGE_CONNECTABLE,lpnr,&hEnum))!=NO_ERROR)
 978                 return FALSE;
 979         lpnrLocal=(LPNETRESOURCE) GlobalAlloc(GPTR,cbBuffer);
 980         sprintf(szPath,"\\\\%s\\",szMachine);
 981         _strlwr(szPath);
 982         do {
 983                 memset(lpnrLocal,0,cbBuffer);
 984                 if ((res = WNetEnumResource(hEnum,&cEntries,lpnrLocal,&cbBuffer))==NO_ERROR)
 985                 {
 986                         for (DWORD i=0;i<cEntries;i++)
 987                         {
 988                                 if (strstr(_strlwr(lpnrLocal[i].lpRemoteName),szPath)==NULL)
 989                                         continue;       //only look at real afs mappings
 990                                 CHAR * pSubmount=strrchr(lpnrLocal[i].lpRemoteName,'\\')+1;
 991                                 if (lstrcmpi(pSubmount,"all")==0)
 992                                         continue;                               // do not remove 'all'
 993                                 for (DWORD j=0;j<List.cSubmounts;j++)
 994                                 {
 995                                         if (
 996                                                 (List.aSubmounts[j].szSubmount[0]) &&
 997                                                 (lstrcmpi(List.aSubmounts[j].szSubmount,pSubmount)==0)
 998                                                 )
 999                                         {
1000                                                 List.aSubmounts[j].fInUse=TRUE;
1001                                                 goto nextname;
1002                                         }
1003                                 }
1004                                 // wasn't on list so lets remove
1005                                 DisMountDOSDrive(pSubmount);
1006                                 nextname:;
1007                         }
1008                 }
1009         } while (res!=ERROR_NO_MORE_ITEMS);
1010         GlobalFree((HGLOBAL)lpnrLocal);
1011         WNetCloseEnum(hEnum);
1012         sprintf(szPath,"\\\\%s\\all",szMachine);
1013
1014         // Lets connect all submounts that weren't connectd
1015     DWORD cbUser=MAXRANDOMNAMELEN-1;
1016         CHAR szUser[MAXRANDOMNAMELEN];
1017     CHAR * pUser = NULL;
1018         if (WNetGetUser(szPath,(LPSTR)szUser,&cbUser)!=NO_ERROR) {
1019         if (RWLogonOption(TRUE,LOGON_OPTION_HIGHSECURITY)) {
1020             if (!pUserName[0]) {
1021                 GenRandomName(szUser,MAXRANDOMNAMELEN-1);
1022                 pUser = szUser;
1023             } else {
1024                 pUser = pUserName;
1025             }
1026         }
1027     } else {
1028                 if ((pUser=strchr(szUser,'\\'))!=NULL)
1029             pUser++;
1030         }
1031
1032     for (DWORD j=0;j<List.cSubmounts;j++)
1033         {
1034                 if (List.aSubmounts[j].fInUse)
1035                         continue;
1036                 DWORD res=MountDOSDrive(0,List.aSubmounts[j].szSubmount,FALSE,pUser);
1037         }
1038         return TRUE;
1039 }
1040
1041 BOOL DoMapShare()
1042 {
1043         DRIVEMAPLIST List;
1044         DWORD rc=28;
1045         BOOL bMappedAll=FALSE;
1046
1047    // Initialize the data structure
1048         DEBUG_EVENT0("AFS DoMapShare");
1049         QueryDriveMapList (&List);
1050         DoUnMapShare(TRUE);
1051         // All connections have been removed
1052         // Lets restore them after making the connection from the random name
1053
1054         TCHAR szMachine[ MAX_PATH],szPath[MAX_PATH];
1055     memset(szMachine, '\0', sizeof(szMachine));
1056     lana_GetNetbiosName(szMachine, LANA_NETBIOS_NAME_FULL);
1057     sprintf(szPath,"\\\\%s\\all",szMachine);
1058
1059     // Lets connect all submounts that weren't connectd
1060     DWORD cbUser=MAXRANDOMNAMELEN-1;
1061         CHAR szUser[MAXRANDOMNAMELEN];
1062     CHAR * pUser = NULL;
1063         if (WNetGetUser(szPath,(LPSTR)szUser,&cbUser)!=NO_ERROR) {
1064         if (RWLogonOption(TRUE,LOGON_OPTION_HIGHSECURITY)) {
1065             if (!pUserName[0]) {
1066                 GenRandomName(szUser,MAXRANDOMNAMELEN-1);
1067                 pUser = szUser;
1068             } else {
1069                 pUser = pUserName;
1070             }
1071         }
1072     } else {
1073                 if ((pUser=strchr(szUser,'\\'))!=NULL)
1074             pUser++;
1075         }
1076
1077         for (DWORD i=0;i<List.cSubmounts;i++)
1078         {
1079                 if (List.aSubmounts[i].szSubmount[0])
1080                 {
1081                         DWORD res=MountDOSDrive(0,List.aSubmounts[i].szSubmount,FALSE,pUser);
1082                         if (lstrcmpi("all",List.aSubmounts[i].szSubmount)==0)
1083                                 bMappedAll=TRUE;
1084                 }
1085         }
1086         if (!bMappedAll)        //make sure all is mapped also
1087         {
1088         DWORD res=MountDOSDrive(0,"all",FALSE,pUser);
1089         if (res==ERROR_SESSION_CREDENTIAL_CONFLICT)
1090         {
1091             DisMountDOSDrive("all");
1092             MountDOSDrive(0,"all",FALSE,pUser);
1093         }
1094         }
1095         for (TCHAR chDrive = chDRIVE_A; chDrive <= chDRIVE_Z; ++chDrive)
1096         {
1097                 if (List.aDriveMap[chDrive-chDRIVE_A].fActive ||
1098             ForceMapActive(chDrive))
1099                 {
1100             TCHAR szSubmount[ MAX_PATH ];
1101             if (List.aDriveMap[chDrive-chDRIVE_A].szSubmount[0])
1102                 lstrcpy(szSubmount,List.aDriveMap[chDrive-chDRIVE_A].szSubmount);
1103             else if (!PathToSubmount (szSubmount, List.aDriveMap[chDrive-chDRIVE_A].szMapping, NULL, NULL))
1104                 continue;
1105
1106             BOOL fPersistent = List.aDriveMap[chDrive-chDRIVE_A].fPersistent;
1107             if (RWLogonOption(TRUE,LOGON_OPTION_HIGHSECURITY))
1108                 fPersistent = FALSE;
1109                     DWORD res=MountDOSDrive(chDrive
1110                                             ,szSubmount
1111                                             ,fPersistent,pUser);
1112                 }
1113         }
1114         return TRUE;
1115 }
1116
1117 BOOL GlobalMountDrive()
1118 {
1119     char szDriveToMapTo[5];
1120     DWORD dwResult;
1121     char szKeyName[256];
1122     HKEY hKey;
1123     DWORD dwIndex = 0;
1124     DWORD dwDriveSize;
1125     DWORD dwSubMountSize;
1126     char unsigned szSubMount[256];
1127     char cm_HostName[200];
1128     DWORD dwType=sizeof(cm_HostName);
1129     if (!IsServiceActive())
1130         return TRUE;
1131     if (!GetComputerName(cm_HostName, &dwType))
1132         return TRUE;
1133     sprintf(szKeyName, "%s\\GlobalAutoMapper", sAFSConfigKeyName);
1134
1135     dwResult = RegOpenKeyEx(HKEY_LOCAL_MACHINE, szKeyName, 0, KEY_QUERY_VALUE,
1136                             &hKey);
1137     if (dwResult != ERROR_SUCCESS)
1138         return TRUE;
1139
1140     while (1) {
1141         dwDriveSize = sizeof(szDriveToMapTo);
1142         dwSubMountSize = sizeof(szSubMount);
1143         dwResult = RegEnumValue(hKey, dwIndex++, szDriveToMapTo, &dwDriveSize,
1144                                 0, &dwType, szSubMount, &dwSubMountSize);
1145         if (dwResult != ERROR_MORE_DATA) {
1146             if (dwResult != ERROR_SUCCESS) {
1147                 if (dwResult != ERROR_NO_MORE_ITEMS)
1148                 {
1149                     DEBUG_EVENT1("AFS DriveMap","Failed to read GlobalAutoMapper values: %d",dwResult);
1150                 }
1151                 break;
1152             }
1153         }
1154         dwResult=MountDOSDrive(*szDriveToMapTo,(const char *)szSubMount,FALSE);
1155     }
1156     RegCloseKey(hKey);
1157     return TRUE;
1158 }
1159
1160 DWORD MountDOSDrive(char chDrive,const char *szSubmount,BOOL bPersistent,const char * pUsername)
1161 {
1162     TCHAR szPath[MAX_PATH];
1163     TCHAR szClient[MAX_PATH];
1164     TCHAR szDrive[3] = TEXT("?:");
1165     sprintf(szDrive,"%c:",chDrive);
1166     GetClientNetbiosName (szClient);
1167     sprintf(szPath,"\\\\%s\\%s",szClient,szSubmount);
1168     NETRESOURCE nr;
1169     memset (&nr, 0x00, sizeof(NETRESOURCE));
1170     nr.dwType=RESOURCETYPE_DISK;
1171     nr.lpLocalName=szDrive;
1172     nr.lpRemoteName=szPath;
1173     nr.dwDisplayType = RESOURCEDISPLAYTYPE_SHARE;
1174     DWORD res=WNetAddConnection2(&nr,NULL,pUsername,(bPersistent)?CONNECT_UPDATE_PROFILE:0);
1175     DEBUG_EVENT5("AFS DriveMap","Mount %s Local[%s] Remote[%s] User[%s]=%x",
1176                   (bPersistent)?"Persistant" : "NonPresistant",
1177                   szDrive,szPath,pUsername?pUsername:"NULL",res);
1178     return res;
1179 }
1180
1181 DWORD DisMountDOSDriveFull(const char *szPath,BOOL bForce)
1182 {
1183     DWORD res=WNetCancelConnection(szPath,bForce);
1184     DEBUG_EVENT3("AFS DriveMap","%sDismount Remote[%s]=%x",
1185                   bForce ? "Forced " : "",szPath,res);
1186     return (res==ERROR_NOT_CONNECTED)?NO_ERROR:res;
1187 }
1188
1189 DWORD DisMountDOSDrive(const char *pSubmount,BOOL bForce)
1190 {
1191     TCHAR szPath[MAX_PATH];
1192     TCHAR szClient[MAX_PATH];
1193     GetClientNetbiosName (szClient);
1194     sprintf(szPath,"\\\\%s\\%s",szClient,pSubmount);
1195     return DisMountDOSDriveFull(szPath,bForce);
1196 }
1197
1198
1199 DWORD DisMountDOSDrive(const char chDrive,BOOL bForce)
1200 {
1201     TCHAR szPath[MAX_PATH];
1202     sprintf(szPath,"%c:",chDrive);
1203     return DisMountDOSDriveFull(szPath,bForce);
1204 }