src/WINNT/client_config/config.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 }
  14
  15 #include "afs_config.h"
  16
  17 extern "C" {
  18
  19 #include "../afsd/fs_utils.h"
  20
  21 #define __CM_CONFIG_INTERFACES_ONLY__
  22 #include "../afsd/cm_config.h"
  23
  24 #define __CM_IOCTL_INTERFACES_ONLY__
  25 #include "../afsd/cm_ioctl.h"
  26
  27 } // extern "C"
  28
  29
  30 #define cREALLOC_PREFS       32
  31
  32 #define cSERVERPREFS_CHUNK  256
  33
  34 #define PIOCTL_MAXSIZE     2048
  35
  36
  37 /*
  38  * REGISTRY ___________________________________________________________________
  39  *
  40  */
  41
  42 static TCHAR cszLANMANDEVICE[] = TEXT("\\Device\\LanmanRedirector\\");
  43 const TCHAR AFSConfigKeyName[] = TEXT("SYSTEM\\CurrentControlSet\\Services\\TransarcAFSDaemon\\Parameters");
  44
  45
  46 /*
  47  * ROUTINES ___________________________________________________________________
  48  *
  49  */
  50
  51 static DWORD log2 (DWORD dwValue)
  52 {
  53    for (DWORD dwLog = 0; (DWORD)(1<<dwLog) < dwValue; ++dwLog)
  54       ;
  55    return dwLog;
  56 }
  57
  58 DWORD Config_GetServiceState (void)
  59 {
  60    if (!g.fIsWinNT)
  61       {
  62       TCHAR szGateway[ cchRESOURCE ] = TEXT("");
  63       Config_GetGatewayName (szGateway);
  64       return (szGateway[0]) ? SERVICE_RUNNING : SERVICE_STOPPED;
  65       }
  66
  67    SERVICE_STATUS Status;
  68    memset (&Status, 0x00, sizeof(Status));
  69
  70    SC_HANDLE hManager;
  71    if ((hManager = OpenSCManager (NULL, NULL, GENERIC_READ)) != NULL)
  72       {
  73       SC_HANDLE hService;
  74       if ((hService = OpenService (hManager, TEXT("TransarcAFSDaemon"), GENERIC_READ)) != NULL)
  75          {
  76          QueryServiceStatus (hService, &Status);
  77          CloseServiceHandle (hService);
  78          }
  79
  80       CloseServiceHandle (hManager);
  81       }
  82
  83    return Status.dwCurrentState;
  84 }
  85
  86
  87 /*
  88  * Configuration Routine ______________________________________________________
  89  *
  90  */
  91
  92 void Config_GetGatewayFlag (BOOL *pfFlag)
  93 {
  94    if (!Config_ReadNum (TEXT("IsGateway"), (DWORD*)pfFlag))
  95       *pfFlag = FALSE;
  96 }
  97
  98
  99 BOOL Config_SetGatewayFlag (BOOL fFlag, ULONG *pStatus)
 100 {
 101    Config_WriteNum (TEXT("IsGateway"), fFlag);
 102    g.fNeedRestart = TRUE;
 103    return TRUE;
 104 }
 105
 106
 107 void Config_GetGatewayName (LPTSTR pszName)
 108 {
 109    if (!Config_ReadString (TEXT("Gateway"), pszName, MAX_PATH))
 110       GetString (pszName, IDS_GATEWAY_UNKNOWN);
 111    else if (!*pszName)
 112       GetString (pszName, IDS_GATEWAY_UNKNOWN);
 113 }
 114
 115
 116 BOOL Config_SetGatewayName (LPCTSTR pszName, ULONG *pStatus)
 117 {
 118    TCHAR szBogus[ cchRESOURCE ];
 119    GetString (szBogus, IDS_GATEWAY_UNKNOWN);
 120    if (!lstrcmpi (szBogus, pszName))
 121       {
 122       Config_WriteString (TEXT("Gateway"), TEXT(""));
 123       }
 124    else
 125       {
 126       Config_WriteString (TEXT("Gateway"), pszName);
 127       }
 128
 129    return TRUE;
 130 }
 131
 132
 133 void Config_FixGatewayDrives (void)
 134 {
 135    // Zip through the user's network drives and reconnect
 136    // them as necessary.
 137    //
 138    for (TCHAR chDrive = chDRIVE_A; chDrive <= chDRIVE_Z; ++chDrive)
 139       {
 140       TCHAR szSubmount[ MAX_PATH ];
 141       if (!GetDriveSubmount (chDrive, szSubmount))
 142          continue;
 143
 144       // We've got a mapping into AFS!  Remove it, rather forcefully.
 145       //
 146       TCHAR szDrive[] = "@:";
 147       szDrive[0] = chDrive;
 148       WNetCancelConnection (szDrive, TRUE);
 149       }
 150
 151    // Now recreate our drive mappings, based on the user's already-
 152    // specified preferences.
 153    //
 154    DRIVEMAPLIST List;
 155    QueryDriveMapList (&List);
 156
 157    for (size_t ii = 0; ii < 26; ++ii)
 158       {
 159       if (!List.aDriveMap[ii].szMapping[0])
 160          continue;
 161       ActivateDriveMap (List.aDriveMap[ii].chDrive, List.aDriveMap[ii].szMapping, List.aDriveMap[ii].szSubmount, List.aDriveMap[ii].fPersistent);
 162       }
 163 }
 164
 165
 166 void Config_GetCellName (LPTSTR pszName)
 167 {
 168    if (!Config_ReadString (TEXT("Cell"), pszName, MAX_PATH))
 169       GetString (pszName, IDS_CELL_UNKNOWN);
 170    else if (!*pszName)
 171       GetString (pszName, IDS_CELL_UNKNOWN);
 172 }
 173
 174
 175 BOOL Config_ContactGateway (LPTSTR pszGateway, LPTSTR pszCell)
 176 {
 177    BOOL rc = FALSE;
 178
 179    BYTE OutData[ PIOCTL_MAXSIZE ];
 180    memset (OutData, 0x00, sizeof(OutData));
 181
 182    struct ViceIoctl IOInfo;
 183    IOInfo.in_size = 0;
 184    IOInfo.in = 0;
 185    IOInfo.out = (char *)OutData;
 186    IOInfo.out_size = PIOCTL_MAXSIZE;
 187
 188    TCHAR szOldGateway[ MAX_PATH ];
 189    Config_GetGatewayName (szOldGateway);
 190    Config_SetGatewayName (pszGateway);
 191
 192    ULONG status;
 193    if ((status = pioctl (0, VIOC_GET_WS_CELL, &IOInfo, 1)) == 0)
 194       {
 195       if (OutData[0])
 196          {
 197          lstrcpy (pszCell, (LPCTSTR)OutData);
 198          rc = TRUE;
 199          }
 200       }
 201
 202    Config_SetGatewayName (szOldGateway);
 203
 204    return rc;
 205 }
 206
 207
 208 BOOL Config_SetCellName (LPCTSTR pszName, ULONG *pStatus)
 209 {
 210    TCHAR szBogus[ cchRESOURCE ];
 211    GetString (szBogus, IDS_CELL_UNKNOWN);
 212    if (lstrcmpi (szBogus, pszName))
 213       {
 214       Config_WriteString (TEXT("Cell"), pszName);
 215       g.fNeedRestart = TRUE;
 216       }
 217    return TRUE;
 218 }
 219
 220
 221 void Config_GetAuthentFlag (BOOL *pfFlag)
 222 {
 223    *pfFlag = FALSE;
 224
 225    HKEY hk;
 226    if (RegOpenKeyEx (HKEY_LOCAL_MACHINE, TEXT("System\\CurrentControlSet\\Control\\NetworkProvider\\Order"), 0, KEY_QUERY_VALUE, &hk) == ERROR_SUCCESS)
 227       {
 228       if (g.fIsWinNT)
 229          {
 230          TCHAR szProviders[ MAX_PATH ] = TEXT("");
 231          DWORD dwSize = sizeof(szProviders);
 232
 233          if (RegQueryValueEx (hk, TEXT("ProviderOrder"), NULL, NULL, (PBYTE)szProviders, &dwSize) == ERROR_SUCCESS)
 234             {
 235             for (LPTSTR pch = szProviders; *pch; )
 236                {
 237                if (!lstrncmpi (pch, TEXT("TransarcAFSDaemon"), lstrlen(TEXT("TransarcAFSDaemon"))))
 238                   *pfFlag = TRUE;
 239
 240                for ( ; *pch && (*pch != TEXT(',')); ++pch)
 241                   ;
 242                for ( ; *pch == TEXT(','); ++pch)
 243                   ;
 244                }
 245             }
 246
 247          RegCloseKey (hk);
 248          }
 249       else // (!g.fIsWinNT)
 250          {
 251          TCHAR szLHS[ MAX_PATH ] = TEXT("");
 252          DWORD dwSize = sizeof(szLHS);
 253
 254          if (RegQueryValueEx (hk, TEXT("TransarcAFSDaemon"), NULL, NULL, (PBYTE)szLHS, &dwSize) == ERROR_SUCCESS)
 255             *pfFlag = TRUE;
 256          }
 257       }
 258 }
 259
 260
 261 BOOL Config_SetAuthentFlag (BOOL fFlag, ULONG *pStatus)
 262 {
 263    ULONG status = 0;
 264    BOOL rc = FALSE;
 265
 266    HKEY hk;
 267    DWORD dwDisp;
 268    if ((status = RegCreateKeyEx (HKEY_LOCAL_MACHINE, TEXT("System\\CurrentControlSet\\Control\\NetworkProvider\\Order"), 0, TEXT("container"), 0, KEY_QUERY_VALUE | KEY_SET_VALUE, NULL, &hk, &dwDisp)) == ERROR_SUCCESS)
 269       {
 270       if (g.fIsWinNT)
 271          {
 272          TCHAR szOldProviders[ MAX_PATH ] = TEXT("");
 273          TCHAR szNewProviders[ MAX_PATH ] = TEXT("");
 274          DWORD dwSize = sizeof(szOldProviders);
 275          RegQueryValueEx (hk, TEXT("ProviderOrder"), NULL, NULL, (PBYTE)szOldProviders, &dwSize);
 276
 277          for (LPTSTR pch = szOldProviders; *pch; )
 278             {
 279             BOOL fCopy = TRUE;
 280             if (!lstrncmpi (pch, TEXT("TransarcAFSDaemon"), lstrlen(TEXT("TransarcAFSDaemon"))))
 281                {
 282                fCopy = fFlag;
 283                fFlag = FALSE;
 284                }
 285
 286             if (fCopy)
 287                {
 288                LPTSTR pchOut = &szNewProviders[ lstrlen(szNewProviders) ];
 289                if (szNewProviders[0])
 290                   *pchOut++ = TEXT(',');
 291                for ( ; *pch && (*pch != TEXT(',')); )
 292                   *pchOut++ = *pch++;
 293                *pchOut = TEXT('\0');
 294                }
 295
 296             for ( ; *pch && (*pch != TEXT(',')); ++pch)
 297                ;
 298             for ( ; *pch == TEXT(','); ++pch)
 299                ;
 300             }
 301
 302          if (fFlag)
 303             {
 304             if (szNewProviders[0])
 305                lstrcat (szNewProviders, TEXT(","));
 306             lstrcat (szNewProviders, TEXT("TransarcAFSDaemon"));
 307             }
 308
 309          if ((status = RegSetValueEx (hk, TEXT("ProviderOrder"), NULL, REG_SZ, (PBYTE)szNewProviders, sizeof(TCHAR)*(1+lstrlen(szNewProviders)))) == ERROR_SUCCESS)
 310             rc = TRUE;
 311          }
 312       else // (!g.fIsWinNT)
 313          {
 314          TCHAR szLHS[ cchRESOURCE ] = TEXT("TransarcAFSDaemon");
 315          TCHAR szRHS[ cchRESOURCE ] = TEXT("");
 316
 317          if (fFlag)
 318             {
 319             if ((status = RegSetValueEx (hk, szLHS, NULL, REG_SZ, (PBYTE)szRHS, sizeof(TCHAR)*(lstrlen(szRHS)+1))) == 0)
 320                rc = TRUE;
 321             }
 322          else
 323             {
 324             RegDeleteValue (hk, szLHS);
 325             rc = TRUE;
 326             }
 327          }
 328
 329       RegCloseKey (hk);
 330       }
 331
 332    if (pStatus && !rc)
 333       *pStatus = status;
 334    if (!rc)
 335       Message (MB_ICONHAND, GetErrorTitle(), IDS_FAILCONFIG_AUTHENT, TEXT("%ld"), status);
 336    return rc;
 337 }
 338
 339
 340 void Config_GetTrayIconFlag (BOOL *pfFlag)
 341 {
 342    if (!Config_ReadNum (TEXT("ShowTrayIcon"), (DWORD*)pfFlag))
 343       *pfFlag = FALSE;
 344 }
 345
 346
 347 BOOL Config_SetTrayIconFlag (BOOL fFlag, ULONG *pStatus)
 348 {
 349    Config_WriteNum (TEXT("ShowTrayIcon"), fFlag);
 350
 351    for (HWND hSearch = GetWindow (GetDesktopWindow(), GW_CHILD);
 352         hSearch && IsWindow(hSearch);
 353         hSearch = GetWindow (hSearch, GW_HWNDNEXT))
 354       {
 355       TCHAR szClassName[ cchRESOURCE ];
 356       if (GetClassName (hSearch, szClassName, cchRESOURCE))
 357          {
 358          if (!lstrcmpi (szClassName, TEXT("AfsCreds")))
 359             break;
 360          }
 361       }
 362
 363    if (hSearch && IsWindow(hSearch))
 364       {
 365       UINT msgCheckTerminate = RegisterWindowMessage (TEXT("AfsCredsCheckTerminate"));
 366       PostMessage (hSearch, msgCheckTerminate, 0, 0);
 367       }
 368    else if (fFlag && !(hSearch && IsWindow(hSearch)))
 369       {
 370       WinExec (TEXT("AfsCreds.exe /quiet"), SW_SHOW);
 371       }
 372
 373    return TRUE;
 374 }
 375
 376
 377 PSERVERPREFS Config_GetServerPrefs (BOOL fVLServers)
 378 {
 379    PSERVERPREFS pPrefs = New (SERVERPREFS);
 380    memset (pPrefs, 0x00, sizeof(SERVERPREFS));
 381    pPrefs->fVLServers = fVLServers;
 382
 383    if (Config_GetServiceState() == SERVICE_RUNNING)
 384       {
 385       // We retrieve server prefs in batches--start that loop now.
 386       //
 387       size_t iOut = 0;
 388       for (int iOffset = 0; ; )
 389          {
 390          cm_SPrefRequest_t InData;
 391          memset (&InData, 0x00, sizeof(InData));
 392          InData.offset = iOffset;
 393          InData.flags = (pPrefs->fVLServers) ? CM_SPREF_VLONLY : 0;
 394          InData.num_servers = cSERVERPREFS_CHUNK;
 395
 396          BYTE OutDataStorage[ sizeof(cm_SPrefInfo_t) + cSERVERPREFS_CHUNK * sizeof(cm_SPref_t) ];
 397          memset (OutDataStorage, 0x00, sizeof(OutDataStorage));
 398          cm_SPrefInfo_t *pOutData = (cm_SPrefInfo_t *)OutDataStorage;
 399
 400          struct ViceIoctl IOInfo;
 401          IOInfo.in_size = sizeof(InData);
 402          IOInfo.in = (char *)&InData;
 403          IOInfo.out = (char *)pOutData;
 404          IOInfo.out_size = sizeof(cm_SPrefInfo_t) + cSERVERPREFS_CHUNK * sizeof(cm_SPref_t);
 405
 406          if (pioctl (0, VIOC_GETSPREFS, &IOInfo, 1) != 0)
 407             break;
 408
 409          if (!REALLOC (pPrefs->aPrefs, pPrefs->cPrefs, iOut + pOutData->num_servers, cREALLOC_PREFS))
 410             break;
 411
 412          for (size_t ii = 0; ii < pOutData->num_servers; ++ii)
 413             {
 414             pPrefs->aPrefs[ iOut ].ipServer = pOutData->servers[ ii ].host.s_addr;
 415             pPrefs->aPrefs[ iOut ].iRank = pOutData->servers[ ii ].rank;
 416             iOut ++;
 417             }
 418
 419          if ((iOffset = pOutData->next_offset) == 0)
 420             break;
 421          }
 422      }
 423
 424    return pPrefs;
 425 }
 426
 427
 428 BOOL Config_SetServerPrefs (PSERVERPREFS pPrefs, ULONG *pStatus)
 429 {
 430    BOOL rc = TRUE;
 431    ULONG status = 0;
 432
 433    if (pPrefs)
 434       {
 435       size_t cChanged = 0;
 436       for (size_t ii = 0; ii < pPrefs->cPrefs; ++ii)
 437          {
 438          if (pPrefs->aPrefs[ ii ].fChanged)
 439             ++cChanged;
 440          }
 441
 442       if (cChanged)
 443          {
 444          if (Config_GetServiceState() != SERVICE_RUNNING)
 445             {
 446             rc = FALSE;
 447             status = ERROR_SERVICE_NOT_ACTIVE;
 448             }
 449          else
 450             {
 451             size_t cbInDataStorage = sizeof(cm_SSetPref_t) + cChanged * sizeof(cm_SPref_t);
 452
 453             PBYTE pInDataStorage;
 454             if ((pInDataStorage = (PBYTE)Allocate (cbInDataStorage)) == NULL)
 455                {
 456                rc = FALSE;
 457                status = ERROR_NOT_ENOUGH_MEMORY;
 458                }
 459             else
 460                {
 461                memset (pInDataStorage, 0x00, sizeof(cbInDataStorage));
 462
 463                cm_SSetPref_t *pInData = (cm_SSetPref_t*)pInDataStorage;
 464                pInData->flags = (pPrefs->fVLServers) ? CM_SPREF_VLONLY : 0;
 465                pInData->num_servers = cChanged;
 466
 467                size_t iOut = 0;
 468                for (ii = 0; ii < pPrefs->cPrefs; ++ii)
 469                   {
 470                   if (pPrefs->aPrefs[ ii ].fChanged)
 471                      {
 472                      pInData->servers[ iOut ].host.s_addr = pPrefs->aPrefs[ ii ].ipServer;
 473                      pInData->servers[ iOut ].rank = (unsigned short)pPrefs->aPrefs[ ii ].iRank;
 474                      iOut++;
 475                      }
 476                   }
 477
 478                BYTE OutDataStorage[ PIOCTL_MAXSIZE ];
 479
 480                struct ViceIoctl IOInfo;
 481                IOInfo.in_size = cbInDataStorage;
 482                IOInfo.in = (char *)pInData;
 483                IOInfo.out = (char *)OutDataStorage;
 484                IOInfo.out_size = PIOCTL_MAXSIZE;
 485
 486                if ((status = pioctl (0, VIOC_SETSPREFS, &IOInfo, 1)) != 0)
 487                   {
 488                   rc = FALSE;
 489                   }
 490
 491                Free (pInDataStorage);
 492                }
 493             }
 494          }
 495       }
 496
 497    if (pStatus && !rc)
 498       *pStatus = status;
 499    if (!rc)
 500       Message (MB_ICONHAND, GetErrorTitle(), IDS_FAILCONFIG_PREFS, TEXT("%ld"), status);
 501    return rc;
 502 }
 503
 504
 505 void Config_FreeServerPrefs (PSERVERPREFS pPrefs)
 506 {
 507    if (pPrefs->aPrefs)
 508       Free (pPrefs->aPrefs);
 509    memset (pPrefs, 0xFD, sizeof(SERVERPREFS));
 510    Delete (pPrefs);
 511 }
 512
 513
 514 void Config_GetCacheSize (ULONG *pckCache)
 515 {
 516    if (!Config_ReadNum (TEXT("CacheSize"), (DWORD*)pckCache))
 517       *pckCache = CM_CONFIGDEFAULT_CACHESIZE;
 518 }
 519
 520
 521 BOOL Config_SetCacheSize (ULONG ckCache, ULONG *pStatus)
 522 {
 523    BOOL rc = TRUE;
 524    ULONG status = 0;
 525
 526    if (Config_GetServiceState() == SERVICE_RUNNING)
 527       {
 528       ULONG ckCacheNow;
 529       Config_GetCacheSize (&ckCacheNow);
 530       if (ckCacheNow > ckCache)
 531          {
 532          Message (MB_ICONHAND, GetErrorTitle(), IDS_SHRINKCACHE);
 533          return FALSE;
 534          }
 535
 536       struct ViceIoctl IOInfo;
 537       IOInfo.in_size = sizeof(ULONG);
 538       IOInfo.in = (char *)&ckCache;
 539       IOInfo.out = (char *)0;
 540       IOInfo.out_size = 0;
 541
 542       if ((status = pioctl (0, VIOCSETCACHESIZE, &IOInfo, 1)) != 0)
 543          {
 544          rc = FALSE;
 545          }
 546       }
 547
 548    if (rc)
 549       {
 550       Config_WriteNum (TEXT("CacheSize"), ckCache);
 551       }
 552
 553    if (pStatus && !rc)
 554       *pStatus = status;
 555    if (!rc)
 556       Message (MB_ICONHAND, GetErrorTitle(), IDS_FAILCONFIG_CACHE, TEXT("%ld"), status);
 557    return rc;
 558 }
 559
 560
 561
 562 void Config_GetChunkSize (ULONG *pckChunk)
 563 {
 564    if (!Config_ReadNum (TEXT("ChunkSize"), (DWORD*)pckChunk))
 565       *pckChunk = CM_CONFIGDEFAULT_CHUNKSIZE;
 566    *pckChunk = max (*pckChunk, 10);
 567    *pckChunk = (1 << ((*pckChunk)-10));
 568 }
 569
 570
 571 BOOL Config_SetChunkSize (ULONG ckChunk, ULONG *pStatus)
 572 {
 573    Config_WriteNum (TEXT("ChunkSize"), log2(ckChunk * 1024));
 574    g.fNeedRestart = TRUE;
 575    return TRUE;
 576 }
 577
 578
 579
 580 void Config_GetStatEntries (ULONG *pcEntries)
 581 {
 582    if (!Config_ReadNum (TEXT("Stats"), (DWORD*)pcEntries))
 583       *pcEntries = CM_CONFIGDEFAULT_STATS;
 584 }
 585
 586
 587 BOOL Config_SetStatEntries (ULONG cEntries, ULONG *pStatus)
 588 {
 589    Config_WriteNum (TEXT("Stats"), cEntries);
 590    g.fNeedRestart = TRUE;
 591    return TRUE;
 592 }
 593
 594
 595
 596 void Config_GetProbeInt (ULONG *pcsecProbe)
 597 {
 598    *pcsecProbe = 30;
 599    // TODO: NEED REGISTRY SETTING
 600 }
 601
 602
 603 BOOL Config_SetProbeInt (ULONG csecProbe, ULONG *pStatus)
 604 {
 605    BOOL rc = TRUE;
 606    ULONG status = 0;
 607
 608    // TODO: NEED REGISTRY SETTING
 609    if (Config_GetServiceState() == SERVICE_RUNNING)
 610       {
 611       struct chservinfo checkserv;
 612       memset (&checkserv, 0x00, sizeof(checkserv));
 613       checkserv.magic = 0x12345678;
 614       checkserv.tinterval = csecProbe;
 615
 616       BYTE OutData[ PIOCTL_MAXSIZE ];
 617       memset (OutData, 0x00, sizeof(OutData));
 618
 619       struct ViceIoctl IOInfo;
 620       IOInfo.in_size = sizeof(checkserv);
 621       IOInfo.in = (char *)&checkserv;
 622       IOInfo.out = (char *)OutData;
 623       IOInfo.out_size = PIOCTL_MAXSIZE;
 624
 625       if ((status = pioctl (0, VIOCCKSERV, &IOInfo, 1)) != 0)
 626          {
 627          rc = FALSE;
 628          }
 629       }
 630
 631    if (pStatus && !rc)
 632       *pStatus = status;
 633    if (!rc)
 634       Message (MB_ICONHAND, GetErrorTitle(), IDS_FAILCONFIG_PROBE, TEXT("%ld"), status);
 635    return rc;
 636 }
 637
 638
 639
 640 void Config_GetNumThreads (ULONG *pcThreads)
 641 {
 642    if (!Config_ReadNum (TEXT("ServerThreads"), (DWORD*)pcThreads))
 643       *pcThreads = CM_CONFIGDEFAULT_SVTHREADS;
 644 }
 645
 646
 647 BOOL Config_SetNumThreads (ULONG cThreads, ULONG *pStatus)
 648 {
 649    Config_WriteNum (TEXT("ServerThreads"), cThreads);
 650    g.fNeedRestart = TRUE;
 651    return TRUE;
 652 }
 653
 654
 655
 656 void Config_GetNumDaemons (ULONG *pcDaemons)
 657 {
 658    if (!Config_ReadNum (TEXT("Daemons"), (DWORD*)pcDaemons))
 659       *pcDaemons = CM_CONFIGDEFAULT_DAEMONS;
 660 }
 661
 662
 663 BOOL Config_SetNumDaemons (ULONG cDaemons, ULONG *pStatus)
 664 {
 665    Config_WriteNum (TEXT("Daemons"), cDaemons);
 666    g.fNeedRestart = TRUE;
 667    return TRUE;
 668 }
 669
 670
 671
 672 void Config_GetSysName (LPTSTR pszName)
 673 {
 674    if (!Config_ReadString (TEXT("SysName"), pszName, MAX_PATH))
 675       lstrcpy (pszName, TEXT("i386_nt40"));
 676 }
 677
 678
 679 BOOL Config_SetSysName (LPCTSTR pszName, ULONG *pStatus)
 680 {
 681    BOOL rc = TRUE;
 682    ULONG status = 0;
 683
 684    if (Config_GetServiceState() == SERVICE_RUNNING)
 685       {
 686       struct {
 687          ULONG cbData;
 688          TCHAR szData[ PIOCTL_MAXSIZE ];
 689       } InData;
 690       memset (&InData, 0x00, sizeof(InData));
 691       InData.cbData = lstrlen(pszName);
 692       lstrcpy (InData.szData, pszName);
 693
 694       BYTE OutData[ PIOCTL_MAXSIZE ];
 695       memset (OutData, 0x00, sizeof(OutData));
 696
 697       struct ViceIoctl IOInfo;
 698       IOInfo.in_size = sizeof(ULONG) +lstrlen(pszName) +1;
 699       IOInfo.in = (char *)&InData;
 700       IOInfo.out = (char *)OutData;
 701       IOInfo.out_size = PIOCTL_MAXSIZE;
 702
 703       if ((status = pioctl (0, VIOC_AFS_SYSNAME, &IOInfo, 1)) != 0)
 704          {
 705          rc = FALSE;
 706          }
 707       }
 708
 709    if (rc)
 710       {
 711       Config_WriteString (TEXT("SysName"), pszName);
 712       }
 713
 714    if (pStatus && !rc)
 715       *pStatus = status;
 716    if (!rc)
 717       Message (MB_ICONHAND, GetErrorTitle(), IDS_FAILCONFIG_SYSNAME, TEXT("%ld"), status);
 718    return rc;
 719 }
 720
 721
 722
 723 void Config_GetRootVolume (LPTSTR pszName)
 724 {
 725    if (!Config_ReadString (TEXT("RootVolume"), pszName, MAX_PATH))
 726       lstrcpy (pszName, TEXT("root.afs"));
 727 }
 728
 729
 730 BOOL Config_SetRootVolume (LPCTSTR pszName, ULONG *pStatus)
 731 {
 732    Config_WriteString (TEXT("RootVolume"), pszName);
 733    g.fNeedRestart = TRUE;
 734    return TRUE;
 735 }
 736
 737
 738
 739 void Config_GetMountRoot (LPTSTR pszPath)
 740 {
 741    if (!Config_ReadString (TEXT("MountRoot"), pszPath, MAX_PATH))
 742       lstrcpy (pszPath, TEXT("/afs"));
 743 }
 744
 745
 746 BOOL Config_SetMountRoot (LPCTSTR pszPath, ULONG *pStatus)
 747 {
 748    Config_WriteString (TEXT("MountRoot"), pszPath);
 749    g.fNeedRestart = TRUE;
 750    return TRUE;
 751 }
 752
 753
 754 BOOL Config_GetCacheInUse (ULONG *pckCacheInUse, ULONG *pStatus)
 755 {
 756    BOOL rc = TRUE;
 757    ULONG status = 0;
 758
 759    *pckCacheInUse = 0;
 760
 761    if (Config_GetServiceState() != SERVICE_RUNNING)
 762       {
 763       rc = FALSE;
 764       status = ERROR_SERVICE_NOT_ACTIVE;
 765       }
 766    else
 767       {
 768       BYTE OutData[ PIOCTL_MAXSIZE ];
 769       memset (OutData, 0x00, sizeof(OutData));
 770
 771       struct ViceIoctl IOInfo;
 772       IOInfo.in_size = 0;
 773       IOInfo.in = (char *)0;
 774       IOInfo.out = (char *)OutData;
 775       IOInfo.out_size = PIOCTL_MAXSIZE;
 776
 777       if ((status = pioctl (0, VIOCGETCACHEPARMS, &IOInfo, 1)) != 0)
 778          {
 779          rc = FALSE;
 780          }
 781       else
 782          {
 783          *pckCacheInUse = ((LONG*)OutData)[1];
 784          }
 785       }
 786
 787    if (pStatus && !rc)
 788       *pStatus = status;
 789    return rc;
 790 }
 791
 792 void Config_GetCachePath (LPTSTR pszCachePath)
 793 {
 794    if (!Config_ReadString (TEXT("CachePath"), pszCachePath, MAX_PATH)) {
 795       TCHAR szPath[MAX_PATH];
 796       GetWindowsDirectory(szPath, sizeof(szPath));
 797                 szPath[2] = 0;  /* get drive letter only */
 798                 strcat(szPath, "\\AFSCache");
 799
 800       lstrcpy (pszCachePath, szPath);
 801    }
 802 }
 803
 804 BOOL Config_SetCachePath(LPCTSTR pszPath, ULONG *pStatus)
 805 {
 806    Config_WriteString (TEXT("CachePath"), pszPath);
 807    g.fNeedRestart = TRUE;
 808    return TRUE;
 809 }
 810
 811 void Config_GetLanAdapter (ULONG *pnLanAdapter)
 812 {
 813    if (!Config_ReadNum (TEXT("LANadapter"), (DWORD*)pnLanAdapter))
 814       *pnLanAdapter = 0;
 815 }
 816
 817 BOOL Config_SetLanAdapter (ULONG nLanAdapter, ULONG *pStatus)
 818 {
 819    Config_WriteNum (TEXT("LANadapter"), nLanAdapter);
 820    g.fNeedRestart = TRUE;
 821    return TRUE;
 822 }
 823
 824 void Config_GetTrapOnPanic (BOOL *pfFlag)
 825 {
 826    if (!Config_ReadNum (TEXT("TrapOnPanic"), (DWORD*)pfFlag))
 827       *pfFlag = TRUE;
 828 }
 829
 830 BOOL Config_SetTrapOnPanic (BOOL fFlag, ULONG *pStatus)
 831 {
 832    Config_WriteNum (TEXT("TrapOnPanic"), fFlag);
 833    g.fNeedRestart = TRUE;
 834    return TRUE;
 835 }
 836
 837 void Config_GetTraceBufferSize (ULONG *pnBufSize)
 838 {
 839    if (!Config_ReadNum (TEXT("TraceBufferSize"), (DWORD*)pnBufSize))
 840       *pnBufSize = 5000;
 841 }
 842
 843 BOOL Config_SetTraceBufferSize (ULONG nBufSize, ULONG *pStatus)
 844 {
 845    Config_WriteNum (TEXT("TraceBufferSize"), nBufSize);
 846    g.fNeedRestart = TRUE;
 847    return TRUE;
 848 }
 849
 850 void Config_GetLoginRetryInterval (ULONG *pnInterval)
 851 {
 852    if (!Config_ReadNum (TEXT("LoginRetryInterval"), (DWORD*)pnInterval))
 853       *pnInterval = 30;
 854 }
 855
 856 BOOL Config_SetLoginRetryInterval (ULONG nInterval, ULONG *pStatus)
 857 {
 858    Config_WriteNum (TEXT("LoginRetryInterval"), nInterval);
 859    return TRUE;
 860 }
 861
 862 void Config_GetFailLoginsSilently (BOOL *pfFlag)
 863 {
 864    if (!Config_ReadNum (TEXT("FailLoginsSilently"), (DWORD*)pfFlag))
 865       *pfFlag = FALSE;
 866 }
 867
 868 BOOL Config_SetFailLoginsSilently (BOOL fFlag, ULONG *pStatus)
 869 {
 870    Config_WriteNum (TEXT("FailLoginsSilently"), fFlag);
 871    return TRUE;
 872 }
 873
 874 void Config_GetReportSessionStartups (BOOL *pfFlag)
 875 {
 876    if (!Config_ReadNum (TEXT("ReportSessionStartups"), (DWORD*)pfFlag))
 877       *pfFlag = FALSE;
 878 }
 879
 880 BOOL Config_SetReportSessionStartups (BOOL fFlag, ULONG *pStatus)
 881 {
 882    Config_WriteNum (TEXT("ReportSessionStartups"), fFlag);
 883    return TRUE;
 884 }
 885
 886 void Config_GetGlobalDriveList (DRIVEMAPLIST *pDriveList)
 887 {
 888    // Read the GlobalAutoMapper registry key
 889    TCHAR szDriveToMapTo[5];
 890    DWORD dwResult;
 891    TCHAR szKeyName[256];
 892    HKEY hKey;
 893    DWORD dwIndex = 0;
 894    DWORD dwDriveSize;
 895    DWORD dwSubMountSize;
 896    TCHAR szSubMount[256];
 897    DWORD dwType;
 898
 899    if (!pDriveList)
 900       return;
 901
 902    memset(pDriveList, 0, sizeof(DRIVEMAPLIST));
 903
 904    lstrcpy(szKeyName, AFSConfigKeyName);
 905    lstrcat(szKeyName, TEXT("\\GlobalAutoMapper"));
 906
 907    dwResult = RegOpenKeyEx(HKEY_LOCAL_MACHINE, szKeyName, 0, KEY_QUERY_VALUE, &hKey);
 908    if (dwResult != ERROR_SUCCESS)
 909       return;
 910
 911    // Get the drive map list so we can lookup the paths that go with our submounts
 912         DRIVEMAPLIST DriveMapList;
 913    memset(&DriveMapList, 0, sizeof(DRIVEMAPLIST));
 914    QueryDriveMapList (&DriveMapList);
 915
 916    while (1) {
 917       dwDriveSize = sizeof(szDriveToMapTo);
 918       dwSubMountSize = sizeof(szSubMount);
 919
 920       dwResult = RegEnumValue(hKey, dwIndex++, szDriveToMapTo, &dwDriveSize, 0, &dwType, (BYTE*)szSubMount, &dwSubMountSize);
 921       if (dwResult != ERROR_SUCCESS)
 922          break;
 923
 924       szDriveToMapTo[0] = _totupper(szDriveToMapTo[0]);
 925
 926       int nCurDrive = szDriveToMapTo[0] - TEXT('A');
 927
 928       pDriveList->aDriveMap[nCurDrive].chDrive = szDriveToMapTo[0];
 929       lstrcpy(pDriveList->aDriveMap[nCurDrive].szSubmount, szSubMount);
 930
 931       // Find the path that goes with this submount
 932       SubmountToPath (&DriveMapList, pDriveList->aDriveMap[nCurDrive].szMapping, szSubMount, FALSE);
 933    }
 934
 935    FreeDriveMapList(&DriveMapList);
 936
 937    RegCloseKey(hKey);
 938 }
 939
 940
 941 /*
 942  * Configuration Read/Modify Functions ________________________________________
 943  *
 944  * Temporarily these just modify the local Registry.
 945  * In the near future, they will modify the Registry on the
 946  * gateway, if a gateway is being used.
 947  *
 948  */
 949
 950 BOOL Config_ReadNum (LPCTSTR pszLHS, DWORD *pdwRHS)
 951 {
 952    HKEY hk;
 953    if (RegOpenKeyEx (HKEY_LOCAL_MACHINE, AFSConfigKeyName, 0, KEY_QUERY_VALUE, &hk) != ERROR_SUCCESS)
 954       return FALSE;
 955
 956    DWORD dwSize = sizeof(*pdwRHS);
 957    if (RegQueryValueEx (hk, pszLHS, NULL, NULL, (PBYTE)pdwRHS, &dwSize) != ERROR_SUCCESS)
 958       {
 959       RegCloseKey (hk);
 960       return FALSE;
 961       }
 962
 963    RegCloseKey (hk);
 964    return TRUE;
 965 }
 966
 967
 968 BOOL Config_ReadString (LPCTSTR pszLHS, LPTSTR pszRHS, size_t cchMax)
 969 {
 970    HKEY hk;
 971    if (RegOpenKeyEx (HKEY_LOCAL_MACHINE, AFSConfigKeyName, 0, KEY_QUERY_VALUE, &hk) != ERROR_SUCCESS)
 972       return FALSE;
 973
 974    DWORD dwSize = sizeof(TCHAR) * cchMax;
 975    if (RegQueryValueEx (hk, pszLHS, NULL, NULL, (PBYTE)pszRHS, &dwSize) != ERROR_SUCCESS)
 976       {
 977       RegCloseKey (hk);
 978       return FALSE;
 979       }
 980
 981    RegCloseKey (hk);
 982    return TRUE;
 983 }
 984
 985
 986 void Config_WriteNum (LPCTSTR pszLHS, DWORD dwRHS)
 987 {
 988    HKEY hk;
 989    DWORD dwDisp;
 990    if (RegCreateKeyEx (HKEY_LOCAL_MACHINE, AFSConfigKeyName, 0, TEXT("container"), 0, KEY_SET_VALUE, NULL, &hk, &dwDisp) == ERROR_SUCCESS)
 991       {
 992       RegSetValueEx (hk, pszLHS, NULL, REG_DWORD, (PBYTE)&dwRHS, sizeof(dwRHS));
 993       RegCloseKey (hk);
 994       }
 995 }
 996
 997
 998 void Config_WriteString (LPCTSTR pszLHS, LPCTSTR pszRHS)
 999 {
1000    HKEY hk;
1001    DWORD dwDisp;
1002    if (RegCreateKeyEx (HKEY_LOCAL_MACHINE, AFSConfigKeyName, 0, TEXT("container"), 0, KEY_SET_VALUE, NULL, &hk, &dwDisp) == ERROR_SUCCESS)
1003       {
1004       RegSetValueEx (hk, pszLHS, NULL, REG_SZ, (PBYTE)pszRHS, sizeof(TCHAR) * (1+lstrlen(pszRHS)));
1005       RegCloseKey (hk);
1006       }
1007 }
1008