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 #if 0
 221 /*      These two functions are not needed as of the 1.2.2a updates.
 222         The old implementation used to 'bind' afslogon.dll to the credentials manager
 223         when the Integrated Logon was selected.
 224
 225         With version 1.2.2a afslogon.dll is always 'bound' to the credentials manager; therefore,
 226         the binding operation is done during installation.  Note: the Integrated Logon is
 227         selected by an entry in the registry (LogonOptions).
 228 */
 229 void Config_GetAuthentFlag (BOOL *pfFlag)
 230 {
 231    *pfFlag = FALSE;
 232
 233    HKEY hk;
 234    if (RegOpenKeyEx (HKEY_LOCAL_MACHINE, TEXT("System\\CurrentControlSet\\Control\\NetworkProvider\\Order"), 0, KEY_QUERY_VALUE, &hk) == ERROR_SUCCESS)
 235       {
 236       if (g.fIsWinNT)
 237          {
 238          TCHAR szProviders[ MAX_PATH ] = TEXT("");
 239          DWORD dwSize = sizeof(szProviders);
 240
 241          if (RegQueryValueEx (hk, TEXT("ProviderOrder"), NULL, NULL, (PBYTE)szProviders, &dwSize) == ERROR_SUCCESS)
 242             {
 243             for (LPTSTR pch = szProviders; *pch; )
 244                {
 245                if (!lstrncmpi (pch, TEXT("TransarcAFSDaemon"), lstrlen(TEXT("TransarcAFSDaemon"))))
 246                   *pfFlag = TRUE;
 247
 248                for ( ; *pch && (*pch != TEXT(',')); ++pch)
 249                   ;
 250                for ( ; *pch == TEXT(','); ++pch)
 251                   ;
 252                }
 253             }
 254
 255          RegCloseKey (hk);
 256          }
 257       else // (!g.fIsWinNT)
 258          {
 259          TCHAR szLHS[ MAX_PATH ] = TEXT("");
 260          DWORD dwSize = sizeof(szLHS);
 261
 262          if (RegQueryValueEx (hk, TEXT("TransarcAFSDaemon"), NULL, NULL, (PBYTE)szLHS, &dwSize) == ERROR_SUCCESS)
 263             *pfFlag = TRUE;
 264          }
 265       }
 266 }
 267
 268
 269 BOOL Config_SetAuthentFlag (BOOL fFlag, ULONG *pStatus)
 270 {
 271    ULONG status = 0;
 272    BOOL rc = FALSE;
 273
 274    HKEY hk;
 275    DWORD dwDisp;
 276    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)
 277       {
 278       if (g.fIsWinNT)
 279          {
 280          TCHAR szOldProviders[ MAX_PATH ] = TEXT("");
 281          TCHAR szNewProviders[ MAX_PATH ] = TEXT("");
 282          DWORD dwSize = sizeof(szOldProviders);
 283          RegQueryValueEx (hk, TEXT("ProviderOrder"), NULL, NULL, (PBYTE)szOldProviders, &dwSize);
 284
 285          for (LPTSTR pch = szOldProviders; *pch; )
 286             {
 287             BOOL fCopy = TRUE;
 288             if (!lstrncmpi (pch, TEXT("TransarcAFSDaemon"), lstrlen(TEXT("TransarcAFSDaemon"))))
 289                {
 290                fCopy = fFlag;
 291                fFlag = FALSE;
 292                }
 293
 294             if (fCopy)
 295                {
 296                LPTSTR pchOut = &szNewProviders[ lstrlen(szNewProviders) ];
 297                if (szNewProviders[0])
 298                   *pchOut++ = TEXT(',');
 299                for ( ; *pch && (*pch != TEXT(',')); )
 300                   *pchOut++ = *pch++;
 301                *pchOut = TEXT('\0');
 302                }
 303
 304             for ( ; *pch && (*pch != TEXT(',')); ++pch)
 305                ;
 306             for ( ; *pch == TEXT(','); ++pch)
 307                ;
 308             }
 309
 310          if (fFlag)
 311             {
 312             if (szNewProviders[0])
 313                lstrcat (szNewProviders, TEXT(","));
 314             lstrcat (szNewProviders, TEXT("TransarcAFSDaemon"));
 315             }
 316
 317          if ((status = RegSetValueEx (hk, TEXT("ProviderOrder"), NULL, REG_SZ, (PBYTE)szNewProviders, sizeof(TCHAR)*(1+lstrlen(szNewProviders)))) == ERROR_SUCCESS)
 318             rc = TRUE;
 319          }
 320       else // (!g.fIsWinNT)
 321          {
 322          TCHAR szLHS[ cchRESOURCE ] = TEXT("TransarcAFSDaemon");
 323          TCHAR szRHS[ cchRESOURCE ] = TEXT("");
 324
 325          if (fFlag)
 326             {
 327             if ((status = RegSetValueEx (hk, szLHS, NULL, REG_SZ, (PBYTE)szRHS, sizeof(TCHAR)*(lstrlen(szRHS)+1))) == 0)
 328                rc = TRUE;
 329             }
 330          else
 331             {
 332             RegDeleteValue (hk, szLHS);
 333             rc = TRUE;
 334             }
 335          }
 336
 337       RegCloseKey (hk);
 338       }
 339
 340    if (pStatus && !rc)
 341       *pStatus = status;
 342    if (!rc)
 343       Message (MB_ICONHAND, GetErrorTitle(), IDS_FAILCONFIG_AUTHENT, TEXT("%ld"), status);
 344    return rc;
 345 }
 346 #endif
 347
 348 void Config_GetTrayIconFlag (BOOL *pfFlag)
 349 {
 350    if (!Config_ReadNum (TEXT("ShowTrayIcon"), (DWORD*)pfFlag))
 351       *pfFlag = FALSE;
 352 }
 353
 354
 355 BOOL Config_SetTrayIconFlag (BOOL fFlag, ULONG *pStatus)
 356 {
 357    Config_WriteNum (TEXT("ShowTrayIcon"), fFlag);
 358
 359    for (HWND hSearch = GetWindow (GetDesktopWindow(), GW_CHILD);
 360         hSearch && IsWindow(hSearch);
 361         hSearch = GetWindow (hSearch, GW_HWNDNEXT))
 362       {
 363       TCHAR szClassName[ cchRESOURCE ];
 364       if (GetClassName (hSearch, szClassName, cchRESOURCE))
 365          {
 366          if (!lstrcmpi (szClassName, TEXT("AfsCreds")))
 367             break;
 368          }
 369       }
 370
 371    if (hSearch && IsWindow(hSearch))
 372       {
 373       UINT msgCheckTerminate = RegisterWindowMessage (TEXT("AfsCredsCheckTerminate"));
 374       PostMessage (hSearch, msgCheckTerminate, 0, 0);
 375       }
 376    else if (fFlag && !(hSearch && IsWindow(hSearch)))
 377       {
 378       WinExec (TEXT("AfsCreds.exe /quiet"), SW_SHOW);
 379       }
 380
 381    return TRUE;
 382 }
 383
 384
 385 PSERVERPREFS Config_GetServerPrefs (BOOL fVLServers)
 386 {
 387    PSERVERPREFS pPrefs = New (SERVERPREFS);
 388    memset (pPrefs, 0x00, sizeof(SERVERPREFS));
 389    pPrefs->fVLServers = fVLServers;
 390
 391    if (Config_GetServiceState() == SERVICE_RUNNING)
 392       {
 393       // We retrieve server prefs in batches--start that loop now.
 394       //
 395       size_t iOut = 0;
 396       for (int iOffset = 0; ; )
 397          {
 398          cm_SPrefRequest_t InData;
 399          memset (&InData, 0x00, sizeof(InData));
 400          InData.offset = iOffset;
 401          InData.flags = (pPrefs->fVLServers) ? CM_SPREF_VLONLY : 0;
 402          InData.num_servers = cSERVERPREFS_CHUNK;
 403
 404          BYTE OutDataStorage[ sizeof(cm_SPrefInfo_t) + cSERVERPREFS_CHUNK * sizeof(cm_SPref_t) ];
 405          memset (OutDataStorage, 0x00, sizeof(OutDataStorage));
 406          cm_SPrefInfo_t *pOutData = (cm_SPrefInfo_t *)OutDataStorage;
 407
 408          struct ViceIoctl IOInfo;
 409          IOInfo.in_size = sizeof(InData);
 410          IOInfo.in = (char *)&InData;
 411          IOInfo.out = (char *)pOutData;
 412          IOInfo.out_size = sizeof(cm_SPrefInfo_t) + cSERVERPREFS_CHUNK * sizeof(cm_SPref_t);
 413
 414          if (pioctl (0, VIOC_GETSPREFS, &IOInfo, 1) != 0)
 415             break;
 416
 417          if (!REALLOC (pPrefs->aPrefs, pPrefs->cPrefs, iOut + pOutData->num_servers, cREALLOC_PREFS))
 418             break;
 419
 420          for (size_t ii = 0; ii < pOutData->num_servers; ++ii)
 421             {
 422             pPrefs->aPrefs[ iOut ].ipServer = pOutData->servers[ ii ].host.s_addr;
 423             pPrefs->aPrefs[ iOut ].iRank = pOutData->servers[ ii ].rank;
 424             iOut ++;
 425             }
 426
 427          if ((iOffset = pOutData->next_offset) == 0)
 428             break;
 429          }
 430      }
 431
 432    return pPrefs;
 433 }
 434
 435
 436 BOOL Config_SetServerPrefs (PSERVERPREFS pPrefs, ULONG *pStatus)
 437 {
 438    BOOL rc = TRUE;
 439    ULONG status = 0;
 440
 441    if (pPrefs)
 442       {
 443       size_t cChanged = 0;
 444       for (size_t ii = 0; ii < pPrefs->cPrefs; ++ii)
 445          {
 446          if (pPrefs->aPrefs[ ii ].fChanged)
 447             ++cChanged;
 448          }
 449
 450       if (cChanged)
 451          {
 452          if (Config_GetServiceState() != SERVICE_RUNNING)
 453             {
 454             rc = FALSE;
 455             status = ERROR_SERVICE_NOT_ACTIVE;
 456             }
 457          else
 458             {
 459             size_t cbInDataStorage = sizeof(cm_SSetPref_t) + cChanged * sizeof(cm_SPref_t);
 460
 461             PBYTE pInDataStorage;
 462             if ((pInDataStorage = (PBYTE)Allocate (cbInDataStorage)) == NULL)
 463                {
 464                rc = FALSE;
 465                status = ERROR_NOT_ENOUGH_MEMORY;
 466                }
 467             else
 468                {
 469                memset (pInDataStorage, 0x00, sizeof(cbInDataStorage));
 470
 471                cm_SSetPref_t *pInData = (cm_SSetPref_t*)pInDataStorage;
 472                pInData->flags = (pPrefs->fVLServers) ? CM_SPREF_VLONLY : 0;
 473                pInData->num_servers = cChanged;
 474
 475                size_t iOut = 0;
 476                for (ii = 0; ii < pPrefs->cPrefs; ++ii)
 477                   {
 478                   if (pPrefs->aPrefs[ ii ].fChanged)
 479                      {
 480                      pInData->servers[ iOut ].host.s_addr = pPrefs->aPrefs[ ii ].ipServer;
 481                      pInData->servers[ iOut ].rank = (unsigned short)pPrefs->aPrefs[ ii ].iRank;
 482                      iOut++;
 483                      }
 484                   }
 485
 486                BYTE OutDataStorage[ PIOCTL_MAXSIZE ];
 487
 488                struct ViceIoctl IOInfo;
 489                IOInfo.in_size = cbInDataStorage;
 490                IOInfo.in = (char *)pInData;
 491                IOInfo.out = (char *)OutDataStorage;
 492                IOInfo.out_size = PIOCTL_MAXSIZE;
 493
 494                if ((status = pioctl (0, VIOC_SETSPREFS, &IOInfo, 1)) != 0)
 495                   {
 496                   rc = FALSE;
 497                   }
 498
 499                Free (pInDataStorage);
 500                }
 501             }
 502          }
 503       }
 504
 505    if (pStatus && !rc)
 506       *pStatus = status;
 507    if (!rc)
 508       Message (MB_ICONHAND, GetErrorTitle(), IDS_FAILCONFIG_PREFS, TEXT("%ld"), status);
 509    return rc;
 510 }
 511
 512
 513 void Config_FreeServerPrefs (PSERVERPREFS pPrefs)
 514 {
 515    if (pPrefs->aPrefs)
 516       Free (pPrefs->aPrefs);
 517    memset (pPrefs, 0xFD, sizeof(SERVERPREFS));
 518    Delete (pPrefs);
 519 }
 520
 521
 522 void Config_GetCacheSize (ULONG *pckCache)
 523 {
 524    if (!Config_ReadNum (TEXT("CacheSize"), (DWORD*)pckCache))
 525       *pckCache = CM_CONFIGDEFAULT_CACHESIZE;
 526 }
 527
 528
 529 BOOL Config_SetCacheSize (ULONG ckCache, ULONG *pStatus)
 530 {
 531    BOOL rc = TRUE;
 532    ULONG status = 0;
 533
 534    if (Config_GetServiceState() == SERVICE_RUNNING)
 535       {
 536       ULONG ckCacheNow;
 537       Config_GetCacheSize (&ckCacheNow);
 538       if (ckCacheNow > ckCache)
 539          {
 540          Message (MB_ICONHAND, GetErrorTitle(), IDS_SHRINKCACHE);
 541          return FALSE;
 542          }
 543
 544       struct ViceIoctl IOInfo;
 545       IOInfo.in_size = sizeof(ULONG);
 546       IOInfo.in = (char *)&ckCache;
 547       IOInfo.out = (char *)0;
 548       IOInfo.out_size = 0;
 549
 550       if ((status = pioctl (0, VIOCSETCACHESIZE, &IOInfo, 1)) != 0)
 551          {
 552          rc = FALSE;
 553          }
 554       }
 555
 556    if (rc)
 557       {
 558       Config_WriteNum (TEXT("CacheSize"), ckCache);
 559       }
 560
 561    if (pStatus && !rc)
 562       *pStatus = status;
 563    if (!rc)
 564       Message (MB_ICONHAND, GetErrorTitle(), IDS_FAILCONFIG_CACHE, TEXT("%ld"), status);
 565    return rc;
 566 }
 567
 568
 569
 570 void Config_GetChunkSize (ULONG *pckChunk)
 571 {
 572    if (!Config_ReadNum (TEXT("ChunkSize"), (DWORD*)pckChunk))
 573       *pckChunk = CM_CONFIGDEFAULT_CHUNKSIZE;
 574    *pckChunk = max (*pckChunk, 10);
 575    *pckChunk = (1 << ((*pckChunk)-10));
 576 }
 577
 578
 579 BOOL Config_SetChunkSize (ULONG ckChunk, ULONG *pStatus)
 580 {
 581    Config_WriteNum (TEXT("ChunkSize"), log2(ckChunk * 1024));
 582    g.fNeedRestart = TRUE;
 583    return TRUE;
 584 }
 585
 586
 587
 588 void Config_GetStatEntries (ULONG *pcEntries)
 589 {
 590    if (!Config_ReadNum (TEXT("Stats"), (DWORD*)pcEntries))
 591       *pcEntries = CM_CONFIGDEFAULT_STATS;
 592 }
 593
 594
 595 BOOL Config_SetStatEntries (ULONG cEntries, ULONG *pStatus)
 596 {
 597    Config_WriteNum (TEXT("Stats"), cEntries);
 598    g.fNeedRestart = TRUE;
 599    return TRUE;
 600 }
 601
 602
 603
 604 void Config_GetProbeInt (ULONG *pcsecProbe)
 605 {
 606    *pcsecProbe = 30;
 607    // TODO: NEED REGISTRY SETTING
 608 }
 609
 610
 611 BOOL Config_SetProbeInt (ULONG csecProbe, ULONG *pStatus)
 612 {
 613    BOOL rc = TRUE;
 614    ULONG status = 0;
 615
 616    // TODO: NEED REGISTRY SETTING
 617    if (Config_GetServiceState() == SERVICE_RUNNING)
 618       {
 619       struct chservinfo checkserv;
 620       memset (&checkserv, 0x00, sizeof(checkserv));
 621       checkserv.magic = 0x12345678;
 622       checkserv.tinterval = csecProbe;
 623
 624       BYTE OutData[ PIOCTL_MAXSIZE ];
 625       memset (OutData, 0x00, sizeof(OutData));
 626
 627       struct ViceIoctl IOInfo;
 628       IOInfo.in_size = sizeof(checkserv);
 629       IOInfo.in = (char *)&checkserv;
 630       IOInfo.out = (char *)OutData;
 631       IOInfo.out_size = PIOCTL_MAXSIZE;
 632
 633       if ((status = pioctl (0, VIOCCKSERV, &IOInfo, 1)) != 0)
 634          {
 635          rc = FALSE;
 636          }
 637       }
 638
 639    if (pStatus && !rc)
 640       *pStatus = status;
 641    if (!rc)
 642       Message (MB_ICONHAND, GetErrorTitle(), IDS_FAILCONFIG_PROBE, TEXT("%ld"), status);
 643    return rc;
 644 }
 645
 646
 647
 648 void Config_GetNumThreads (ULONG *pcThreads)
 649 {
 650    if (!Config_ReadNum (TEXT("ServerThreads"), (DWORD*)pcThreads))
 651       *pcThreads = CM_CONFIGDEFAULT_SVTHREADS;
 652 }
 653
 654
 655 BOOL Config_SetNumThreads (ULONG cThreads, ULONG *pStatus)
 656 {
 657    Config_WriteNum (TEXT("ServerThreads"), cThreads);
 658    g.fNeedRestart = TRUE;
 659    return TRUE;
 660 }
 661
 662
 663
 664 void Config_GetNumDaemons (ULONG *pcDaemons)
 665 {
 666    if (!Config_ReadNum (TEXT("Daemons"), (DWORD*)pcDaemons))
 667       *pcDaemons = CM_CONFIGDEFAULT_DAEMONS;
 668 }
 669
 670
 671 BOOL Config_SetNumDaemons (ULONG cDaemons, ULONG *pStatus)
 672 {
 673    Config_WriteNum (TEXT("Daemons"), cDaemons);
 674    g.fNeedRestart = TRUE;
 675    return TRUE;
 676 }
 677
 678
 679
 680 void Config_GetSysName (LPTSTR pszName)
 681 {
 682    if (!Config_ReadString (TEXT("SysName"), pszName, MAX_PATH))
 683       lstrcpy (pszName, TEXT("i386_nt40"));
 684 }
 685
 686
 687 BOOL Config_SetSysName (LPCTSTR pszName, ULONG *pStatus)
 688 {
 689    BOOL rc = TRUE;
 690    ULONG status = 0;
 691
 692    if (Config_GetServiceState() == SERVICE_RUNNING)
 693       {
 694       struct {
 695          ULONG cbData;
 696          TCHAR szData[ PIOCTL_MAXSIZE ];
 697       } InData;
 698       memset (&InData, 0x00, sizeof(InData));
 699       InData.cbData = lstrlen(pszName);
 700       lstrcpy (InData.szData, pszName);
 701
 702       BYTE OutData[ PIOCTL_MAXSIZE ];
 703       memset (OutData, 0x00, sizeof(OutData));
 704
 705       struct ViceIoctl IOInfo;
 706       IOInfo.in_size = sizeof(ULONG) +lstrlen(pszName) +1;
 707       IOInfo.in = (char *)&InData;
 708       IOInfo.out = (char *)OutData;
 709       IOInfo.out_size = PIOCTL_MAXSIZE;
 710
 711       if ((status = pioctl (0, VIOC_AFS_SYSNAME, &IOInfo, 1)) != 0)
 712          {
 713          rc = FALSE;
 714          }
 715       }
 716
 717    if (rc)
 718       {
 719       Config_WriteString (TEXT("SysName"), pszName);
 720       }
 721
 722    if (pStatus && !rc)
 723       *pStatus = status;
 724    if (!rc)
 725       Message (MB_ICONHAND, GetErrorTitle(), IDS_FAILCONFIG_SYSNAME, TEXT("%ld"), status);
 726    return rc;
 727 }
 728
 729
 730
 731 void Config_GetRootVolume (LPTSTR pszName)
 732 {
 733    if (!Config_ReadString (TEXT("RootVolume"), pszName, MAX_PATH))
 734       lstrcpy (pszName, TEXT("root.afs"));
 735 }
 736
 737
 738 BOOL Config_SetRootVolume (LPCTSTR pszName, ULONG *pStatus)
 739 {
 740    Config_WriteString (TEXT("RootVolume"), pszName);
 741    g.fNeedRestart = TRUE;
 742    return TRUE;
 743 }
 744
 745
 746
 747 void Config_GetMountRoot (LPTSTR pszPath)
 748 {
 749    if (!Config_ReadString (TEXT("MountRoot"), pszPath, MAX_PATH))
 750       lstrcpy (pszPath, TEXT("/afs"));
 751 }
 752
 753
 754 BOOL Config_SetMountRoot (LPCTSTR pszPath, ULONG *pStatus)
 755 {
 756    Config_WriteString (TEXT("MountRoot"), pszPath);
 757    g.fNeedRestart = TRUE;
 758    return TRUE;
 759 }
 760
 761
 762 BOOL Config_GetCacheInUse (ULONG *pckCacheInUse, ULONG *pStatus)
 763 {
 764    BOOL rc = TRUE;
 765    ULONG status = 0;
 766
 767    *pckCacheInUse = 0;
 768
 769    if (Config_GetServiceState() != SERVICE_RUNNING)
 770       {
 771       rc = FALSE;
 772       status = ERROR_SERVICE_NOT_ACTIVE;
 773       }
 774    else
 775       {
 776       BYTE OutData[ PIOCTL_MAXSIZE ];
 777       memset (OutData, 0x00, sizeof(OutData));
 778
 779       struct ViceIoctl IOInfo;
 780       IOInfo.in_size = 0;
 781       IOInfo.in = (char *)0;
 782       IOInfo.out = (char *)OutData;
 783       IOInfo.out_size = PIOCTL_MAXSIZE;
 784
 785       if ((status = pioctl (0, VIOCGETCACHEPARMS, &IOInfo, 1)) != 0)
 786          {
 787          rc = FALSE;
 788          }
 789       else
 790          {
 791          *pckCacheInUse = ((LONG*)OutData)[1];
 792          }
 793       }
 794
 795    if (pStatus && !rc)
 796       *pStatus = status;
 797    return rc;
 798 }
 799
 800 void Config_GetCachePath (LPTSTR pszCachePath)
 801 {
 802    if (!Config_ReadString (TEXT("CachePath"), pszCachePath, MAX_PATH)) {
 803       TCHAR szPath[MAX_PATH];
 804       GetWindowsDirectory(szPath, sizeof(szPath));
 805                 szPath[2] = 0;  /* get drive letter only */
 806                 strcat(szPath, "\\AFSCache");
 807
 808       lstrcpy (pszCachePath, szPath);
 809    }
 810 }
 811
 812 BOOL Config_SetCachePath(LPCTSTR pszPath, ULONG *pStatus)
 813 {
 814    Config_WriteString (TEXT("CachePath"), pszPath);
 815    g.fNeedRestart = TRUE;
 816    return TRUE;
 817 }
 818
 819 void Config_GetLanAdapter (ULONG *pnLanAdapter)
 820 {
 821    if (!Config_ReadNum (TEXT("LANadapter"), (DWORD*)pnLanAdapter))
 822       *pnLanAdapter = -1;
 823 }
 824
 825 BOOL Config_SetLanAdapter (ULONG nLanAdapter, ULONG *pStatus)
 826 {
 827    Config_WriteNum (TEXT("LANadapter"), nLanAdapter);
 828    g.fNeedRestart = TRUE;
 829    return TRUE;
 830 }
 831
 832 void Config_GetTrapOnPanic (BOOL *pfFlag)
 833 {
 834    if (!Config_ReadNum (TEXT("TrapOnPanic"), (DWORD*)pfFlag))
 835       *pfFlag = TRUE;
 836 }
 837
 838 BOOL Config_SetTrapOnPanic (BOOL fFlag, ULONG *pStatus)
 839 {
 840    Config_WriteNum (TEXT("TrapOnPanic"), fFlag);
 841    g.fNeedRestart = TRUE;
 842    return TRUE;
 843 }
 844
 845 void Config_GetTraceBufferSize (ULONG *pnBufSize)
 846 {
 847    if (!Config_ReadNum (TEXT("TraceBufferSize"), (DWORD*)pnBufSize))
 848       *pnBufSize = 5000;
 849 }
 850
 851 BOOL Config_SetTraceBufferSize (ULONG nBufSize, ULONG *pStatus)
 852 {
 853    Config_WriteNum (TEXT("TraceBufferSize"), nBufSize);
 854    g.fNeedRestart = TRUE;
 855    return TRUE;
 856 }
 857
 858 void Config_GetLoginRetryInterval (ULONG *pnInterval)
 859 {
 860    if (!Config_ReadNum (TEXT("LoginRetryInterval"), (DWORD*)pnInterval))
 861       *pnInterval = 30;
 862 }
 863
 864 BOOL Config_SetLoginRetryInterval (ULONG nInterval, ULONG *pStatus)
 865 {
 866    Config_WriteNum (TEXT("LoginRetryInterval"), nInterval);
 867    return TRUE;
 868 }
 869
 870 void Config_GetFailLoginsSilently (BOOL *pfFlag)
 871 {
 872    if (!Config_ReadNum (TEXT("FailLoginsSilently"), (DWORD*)pfFlag))
 873       *pfFlag = FALSE;
 874 }
 875
 876 BOOL Config_SetFailLoginsSilently (BOOL fFlag, ULONG *pStatus)
 877 {
 878    Config_WriteNum (TEXT("FailLoginsSilently"), fFlag);
 879    return TRUE;
 880 }
 881
 882 void Config_GetReportSessionStartups (BOOL *pfFlag)
 883 {
 884    if (!Config_ReadNum (TEXT("ReportSessionStartups"), (DWORD*)pfFlag))
 885       *pfFlag = FALSE;
 886 }
 887
 888 BOOL Config_SetReportSessionStartups (BOOL fFlag, ULONG *pStatus)
 889 {
 890    Config_WriteNum (TEXT("ReportSessionStartups"), fFlag);
 891    return TRUE;
 892 }
 893
 894 void Config_GetGlobalDriveList (DRIVEMAPLIST *pDriveList)
 895 {
 896    // Read the GlobalAutoMapper registry key
 897    TCHAR szDriveToMapTo[5];
 898    DWORD dwResult;
 899    TCHAR szKeyName[256];
 900    HKEY hKey;
 901    DWORD dwIndex = 0;
 902    DWORD dwDriveSize;
 903    DWORD dwSubMountSize;
 904    TCHAR szSubMount[256];
 905    DWORD dwType;
 906
 907    if (!pDriveList)
 908       return;
 909
 910    memset(pDriveList, 0, sizeof(DRIVEMAPLIST));
 911
 912    lstrcpy(szKeyName, AFSConfigKeyName);
 913    lstrcat(szKeyName, TEXT("\\GlobalAutoMapper"));
 914
 915    dwResult = RegOpenKeyEx(HKEY_LOCAL_MACHINE, szKeyName, 0, KEY_QUERY_VALUE, &hKey);
 916    if (dwResult != ERROR_SUCCESS)
 917       return;
 918
 919    // Get the drive map list so we can lookup the paths that go with our submounts
 920         DRIVEMAPLIST DriveMapList;
 921    memset(&DriveMapList, 0, sizeof(DRIVEMAPLIST));
 922    QueryDriveMapList (&DriveMapList);
 923
 924    while (1) {
 925       dwDriveSize = sizeof(szDriveToMapTo);
 926       dwSubMountSize = sizeof(szSubMount);
 927
 928       dwResult = RegEnumValue(hKey, dwIndex++, szDriveToMapTo, &dwDriveSize, 0, &dwType, (BYTE*)szSubMount, &dwSubMountSize);
 929       if (dwResult != ERROR_SUCCESS)
 930          break;
 931
 932       szDriveToMapTo[0] = _totupper(szDriveToMapTo[0]);
 933
 934       int nCurDrive = szDriveToMapTo[0] - TEXT('A');
 935
 936       pDriveList->aDriveMap[nCurDrive].chDrive = szDriveToMapTo[0];
 937       lstrcpy(pDriveList->aDriveMap[nCurDrive].szSubmount, szSubMount);
 938
 939       // Find the path that goes with this submount
 940       SubmountToPath (&DriveMapList, pDriveList->aDriveMap[nCurDrive].szMapping, szSubMount, FALSE);
 941    }
 942
 943    FreeDriveMapList(&DriveMapList);
 944
 945    RegCloseKey(hKey);
 946 }
 947
 948
 949 /*
 950  * Configuration Read/Modify Functions ________________________________________
 951  *
 952  * Temporarily these just modify the local Registry.
 953  * In the near future, they will modify the Registry on the
 954  * gateway, if a gateway is being used.
 955  *
 956  */
 957
 958 BOOL Config_ReadNum (LPCTSTR pszLHS, DWORD *pdwRHS)
 959 {
 960    HKEY hk;
 961    if (RegOpenKeyEx (HKEY_LOCAL_MACHINE, AFSConfigKeyName, 0, KEY_QUERY_VALUE, &hk) != ERROR_SUCCESS)
 962       return FALSE;
 963
 964    DWORD dwSize = sizeof(*pdwRHS);
 965    if (RegQueryValueEx (hk, pszLHS, NULL, NULL, (PBYTE)pdwRHS, &dwSize) != ERROR_SUCCESS)
 966       {
 967       RegCloseKey (hk);
 968       return FALSE;
 969       }
 970
 971    RegCloseKey (hk);
 972    return TRUE;
 973 }
 974
 975
 976 BOOL Config_ReadString (LPCTSTR pszLHS, LPTSTR pszRHS, size_t cchMax)
 977 {
 978    HKEY hk;
 979    if (RegOpenKeyEx (HKEY_LOCAL_MACHINE, AFSConfigKeyName, 0, KEY_QUERY_VALUE, &hk) != ERROR_SUCCESS)
 980       return FALSE;
 981
 982    DWORD dwSize = sizeof(TCHAR) * cchMax;
 983    if (RegQueryValueEx (hk, pszLHS, NULL, NULL, (PBYTE)pszRHS, &dwSize) != ERROR_SUCCESS)
 984       {
 985       RegCloseKey (hk);
 986       return FALSE;
 987       }
 988
 989    RegCloseKey (hk);
 990    return TRUE;
 991 }
 992
 993
 994 void Config_WriteNum (LPCTSTR pszLHS, DWORD dwRHS)
 995 {
 996    HKEY hk;
 997    DWORD dwDisp;
 998    if (RegCreateKeyEx (HKEY_LOCAL_MACHINE, AFSConfigKeyName, 0, TEXT("container"), 0, KEY_SET_VALUE, NULL, &hk, &dwDisp) == ERROR_SUCCESS)
 999       {
1000       RegSetValueEx (hk, pszLHS, NULL, REG_DWORD, (PBYTE)&dwRHS, sizeof(dwRHS));
1001       RegCloseKey (hk);
1002       }
1003 }
1004
1005
1006 void Config_WriteString (LPCTSTR pszLHS, LPCTSTR pszRHS)
1007 {
1008    HKEY hk;
1009    DWORD dwDisp;
1010    if (RegCreateKeyEx (HKEY_LOCAL_MACHINE, AFSConfigKeyName, 0, TEXT("container"), 0, KEY_SET_VALUE, NULL, &hk, &dwDisp) == ERROR_SUCCESS)
1011       {
1012       RegSetValueEx (hk, pszLHS, NULL, REG_SZ, (PBYTE)pszRHS, sizeof(TCHAR) * (1+lstrlen(pszRHS)));
1013       RegCloseKey (hk);
1014       }
1015 }
1016