b9d82e78c1c9ea0cc9665f8250e889d74aa39216
[openafs.git] / 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