/*
* Copyright 2000, International Business Machines Corporation and others.
* All Rights Reserved.
- *
+ *
* This software has been released under the terms of the IBM Public
* License. For details, see the LICENSE file in the top-level source
* directory or online at http://www.openafs.org/dl/license10.html
*/
+#include <afsconfig.h>
#include <afs/param.h>
+
+#include <roken.h>
+
#include <afs/stds.h>
#include <afs/afs_args.h>
#endif
#include <rx\rx.h>
#include <rx\rx_null.h>
+#include <rx\rxstat.h>
#include <WINNT/syscfg.h>
#include <WINNT/afsreg.h>
+#include <afs\afscbint.h>
#include "smb.h"
#include "cm_rpc.h"
#include "lanahelper.h"
#include <strsafe.h>
#include "cm_memmap.h"
-
-extern int RXAFSCB_ExecuteRequest(struct rx_call *z_call);
-extern int RXSTATS_ExecuteRequest(struct rx_call *z_call);
+#include "msrpc.h"
+#ifdef DEBUG
+#include <crtdbg.h>
+#endif
extern afs_uint32 cryptall;
extern afs_uint32 cm_anonvldb;
#endif
extern afs_int32 cm_OfflineROIsValid;
extern afs_int32 cm_giveUpAllCBs;
-extern const char **smb_ExecutableExtensions;
+extern const clientchar_t **smb_ExecutableExtensions;
osi_log_t *afsd_logp;
cm_config_data_t cm_data;
-char cm_rootVolumeName[VL_MAXNAMELEN];
+fschar_t cm_rootVolumeName[VL_MAXNAMELEN];
DWORD cm_rootVolumeNameLen;
-char cm_mountRoot[1024];
+
+fschar_t cm_mountRoot[1024];
DWORD cm_mountRootLen;
+
+clientchar_t cm_mountRootC[1024];
+DWORD cm_mountRootCLen;
+
+int cm_readonlyVolumeVersioning = 0;
int cm_logChunkSize;
int cm_chunkSize;
+int cm_virtualCache = 0;
+afs_int32 cm_verifyData = 0;
+int cm_shortNames = 1;
int smb_UseV3 = 1;
+afs_uint32 smb_Enabled = 1;
int LANadapter;
long cm_HostAddr;
unsigned short cm_callbackport = CM_DEFAULT_CALLBACKPORT;
-char cm_NetbiosName[MAX_NB_NAME_LENGTH] = "";
+char cm_NetbiosName[MAX_NB_NAME_LENGTH] = "NOT.YET.SET";
+clientchar_t cm_NetbiosNameC[MAX_NB_NAME_LENGTH] = _C("NOT.YET.SET");
char cm_CachePath[MAX_PATH];
-DWORD cm_CachePathLen;
DWORD cm_ValidateCache = 1;
BOOL reportSessionStartups = FALSE;
cm_initparams_v1 cm_initParams;
-char *cm_sysName = 0;
-unsigned int cm_sysNameCount = 0;
-char *cm_sysNameList[MAXNUMSYSNAMES];
+unsigned int cm_sysNameCount = 0;
+clientchar_t *cm_sysNameList[MAXNUMSYSNAMES];
+unsigned int cm_sysName64Count = 0;
+clientchar_t *cm_sysName64List[MAXNUMSYSNAMES];
DWORD TraceOption = 0;
HANDLE afsi_file;
-#ifdef AFS_AFSDB_ENV
int cm_dnsEnabled = 1;
-#endif
static int afsi_log_useTimestamp = 1;
WriteFile(afsi_file, u, (DWORD)strlen(u), &zilch, NULL);
#ifdef NOTSERVICE
printf("%s", u);
-#endif
+#endif
} else {
if (afsi_file != INVALID_HANDLE_VALUE)
WriteFile(afsi_file, s, (DWORD)strlen(s), &zilch, NULL);
}
}
-extern initUpperCaseTable();
-void afsd_initUpperCaseTable()
-{
- initUpperCaseTable();
-}
-
void
afsi_start()
{
afsi_log("OEM Code Page = %d", GetOEMCP());
afsi_log("locale = %s", setlocale(LC_ALL,NULL));
#ifdef COMMENT
- /* Two things to look into. First, should mbstowcs() be performing
- * character set translations from OEM to Unicode in smb3.c;
- * Second, do we need to set this translation in each function
- * due to multi-threading.
+ /* Two things to look into. First, should mbstowcs() be performing
+ * character set translations from OEM to Unicode in smb3.c;
+ * Second, do we need to set this translation in each function
+ * due to multi-threading.
*/
afsi_log("locale -> %s", setlocale(LC_ALL, ".OCP"));
afsi_log("_setmbcp = %d -> %d", _setmbcp(_MB_CP_OEM), _getmbcp());
int len;
char buf[256];
- if (!logReady)
+ if (!logReady)
return;
len = GetTempPath(sizeof(buf)-10, buf);
CloseHandle(handle);
}
-static void
-configureBackConnectionHostNames(void)
-{
- /* On Windows XP SP2, Windows 2003 SP1, and all future Windows operating systems
- * there is a restriction on the use of SMB authentication on loopback connections.
- * There are two work arounds available:
- *
- * (1) We can disable the check for matching host names. This does not
- * require a reboot:
- * [HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\Lsa]
- * "DisableLoopbackCheck"=dword:00000001
- *
- * (2) We can add the AFS SMB/CIFS service name to an approved list. This
- * does require a reboot:
- * [HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\Lsa\MSV1_0]
- * "BackConnectionHostNames"=multi-sz
- *
- * The algorithm will be:
- * (1) Check to see if cm_NetbiosName exists in the BackConnectionHostNames list
- * (2a) If not, add it to the list. (This will not take effect until the next reboot.)
- * (2b1) and check to see if DisableLoopbackCheck is set.
- * (2b2) If not set, set the DisableLoopbackCheck value to 0x1
- * (2b3) and create HKLM\SOFTWARE\OpenAFS\Client UnsetDisableLoopbackCheck
- * (2c) else If cm_NetbiosName exists in the BackConnectionHostNames list,
- * check for the UnsetDisableLoopbackCheck value.
- * If set, set the DisableLoopbackCheck flag to 0x0
- * and delete the UnsetDisableLoopbackCheck value
- *
- * Starting in Longhorn Beta 1, an entry in the BackConnectionHostNames value will
- * force Windows to use the loopback authentication mechanism for the specified
- * services.
- */
- HKEY hkLsa;
- HKEY hkMSV10;
- HKEY hkClient;
- DWORD dwType;
- DWORD dwSize, dwAllocSize;
- DWORD dwValue;
- PBYTE pHostNames = NULL, pName = NULL;
- BOOL bNameFound = FALSE;
-
- if ( RegOpenKeyEx( HKEY_LOCAL_MACHINE,
- "SYSTEM\\CurrentControlSet\\Control\\Lsa\\MSV1_0",
- 0,
- KEY_READ|KEY_WRITE,
- &hkMSV10) == ERROR_SUCCESS )
- {
- if ((RegQueryValueEx( hkMSV10, "BackConnectionHostNames", 0,
- &dwType, NULL, &dwAllocSize) == ERROR_SUCCESS) &&
- (dwType == REG_MULTI_SZ))
- {
- dwAllocSize += 1 /* in case the source string is not nul terminated */
- + strlen(cm_NetbiosName) + 2;
- pHostNames = malloc(dwAllocSize);
- dwSize = dwAllocSize;
- if (RegQueryValueEx( hkMSV10, "BackConnectionHostNames", 0, &dwType,
- pHostNames, &dwSize) == ERROR_SUCCESS)
- {
- for (pName = pHostNames;
- (pName - pHostNames < dwSize) && *pName ;
- pName += strlen(pName) + 1)
- {
- if ( !stricmp(pName, cm_NetbiosName) ) {
- bNameFound = TRUE;
- break;
- }
- }
- }
- }
-
- if ( !bNameFound ) {
- size_t size = strlen(cm_NetbiosName) + 2;
- if ( !pHostNames ) {
- pHostNames = malloc(size);
- pName = pHostNames;
- }
- StringCbCopyA(pName, size, cm_NetbiosName);
- pName += size - 1;
- *pName = '\0'; /* add a second nul terminator */
-
- dwType = REG_MULTI_SZ;
- dwSize = pName - pHostNames + 1;
- RegSetValueEx( hkMSV10, "BackConnectionHostNames", 0, dwType, pHostNames, dwSize);
-
- if ( RegOpenKeyEx( HKEY_LOCAL_MACHINE,
- "SYSTEM\\CurrentControlSet\\Control\\Lsa",
- 0,
- KEY_READ|KEY_WRITE,
- &hkLsa) == ERROR_SUCCESS )
- {
- dwSize = sizeof(DWORD);
- if ( RegQueryValueEx( hkLsa, "DisableLoopbackCheck", 0, &dwType, (LPBYTE)&dwValue, &dwSize) != ERROR_SUCCESS ||
- dwValue == 0 ) {
- dwType = REG_DWORD;
- dwSize = sizeof(DWORD);
- dwValue = 1;
- RegSetValueEx( hkLsa, "DisableLoopbackCheck", 0, dwType, (LPBYTE)&dwValue, dwSize);
-
- if (RegCreateKeyEx( HKEY_LOCAL_MACHINE,
- AFSREG_CLT_OPENAFS_SUBKEY,
- 0,
- NULL,
- REG_OPTION_NON_VOLATILE,
- KEY_READ|KEY_WRITE,
- NULL,
- &hkClient,
- NULL) == ERROR_SUCCESS) {
-
- dwType = REG_DWORD;
- dwSize = sizeof(DWORD);
- dwValue = 1;
- RegSetValueEx( hkClient, "RemoveDisableLoopbackCheck", 0, dwType, (LPBYTE)&dwValue, dwSize);
- RegCloseKey(hkClient);
- }
- RegCloseKey(hkLsa);
- }
- }
- } else {
- if (RegCreateKeyEx( HKEY_LOCAL_MACHINE,
- AFSREG_CLT_OPENAFS_SUBKEY,
- 0,
- NULL,
- REG_OPTION_NON_VOLATILE,
- KEY_READ|KEY_WRITE,
- NULL,
- &hkClient,
- NULL) == ERROR_SUCCESS) {
-
- dwSize = sizeof(DWORD);
- if ( RegQueryValueEx( hkClient, "RemoveDisableLoopbackCheck", 0, &dwType, (LPBYTE)&dwValue, &dwSize) == ERROR_SUCCESS &&
- dwValue == 1 ) {
- if ( RegOpenKeyEx( HKEY_LOCAL_MACHINE,
- "SYSTEM\\CurrentControlSet\\Control\\Lsa",
- 0,
- KEY_READ|KEY_WRITE,
- &hkLsa) == ERROR_SUCCESS )
- {
- RegDeleteValue(hkLsa, "DisableLoopbackCheck");
- RegCloseKey(hkLsa);
- }
- }
- RegDeleteValue(hkClient, "RemoveDisableLoopbackCheck");
- RegCloseKey(hkClient);
- }
- }
- RegCloseKey(hkMSV10);
- }
-
- if (pHostNames)
- free(pHostNames);
-}
-
-
static void afsd_InitServerPreferences(void)
{
HKEY hkPrefs = 0;
struct sockaddr_in saddr;
cm_server_t *tsp;
- if (RegOpenKeyEx( HKEY_LOCAL_MACHINE,
+ if (RegOpenKeyEx( HKEY_LOCAL_MACHINE,
AFSREG_CLT_OPENAFS_SUBKEY "\\Server Preferences\\VLDB",
0,
KEY_READ|KEY_QUERY_VALUE,
saddr.sin_addr.S_un.S_addr = *(unsigned long *)pEntry->h_addr;
}
+ saddr.sin_port = htons(7003);
saddr.sin_family = AF_INET;
dwRank += (rand() & 0x000f);
- tsp = cm_FindServer(&saddr, CM_SERVER_VLDB);
+ tsp = cm_FindServer(&saddr, CM_SERVER_VLDB, FALSE);
if ( tsp ) /* an existing server - ref count increased */
{
- tsp->ipRank = (USHORT)dwRank; /* no need to protect by mutex*/
+ lock_ObtainMutex(&tsp->mx);
+ tsp->adminRank = (USHORT)dwRank;
+ _InterlockedOr(&tsp->flags, CM_SERVERFLAG_PREF_SET);
+ cm_RankServer(tsp);
+ lock_ReleaseMutex(&tsp->mx);
/* set preferences for an existing vlserver */
cm_ChangeRankCellVLServer(tsp);
}
else /* add a new server without a cell */
{
- tsp = cm_NewServer(&saddr, CM_SERVER_VLDB, NULL, CM_FLAG_NOPROBE); /* refcount = 1 */
- tsp->ipRank = (USHORT)dwRank;
+ tsp = cm_NewServer(&saddr, CM_SERVER_VLDB, NULL, NULL, CM_FLAG_NOPROBE); /* refcount = 1 */
+ lock_ObtainMutex(&tsp->mx);
+ tsp->adminRank = (USHORT)dwRank;
+ _InterlockedOr(&tsp->flags, CM_SERVERFLAG_PREF_SET);
+ cm_RankServer(tsp);
+ lock_ReleaseMutex(&tsp->mx);
}
}
RegCloseKey(hkPrefs);
}
- if (RegOpenKeyEx( HKEY_LOCAL_MACHINE,
+ if (RegOpenKeyEx( HKEY_LOCAL_MACHINE,
AFSREG_CLT_OPENAFS_SUBKEY "\\Server Preferences\\File",
0,
KEY_READ|KEY_QUERY_VALUE,
saddr.sin_addr.S_un.S_addr = *(unsigned long *)pEntry->h_addr;
}
+ saddr.sin_port = htons(7000);
saddr.sin_family = AF_INET;
dwRank += (rand() & 0x000f);
- tsp = cm_FindServer(&saddr, CM_SERVER_FILE);
+ tsp = cm_FindServer(&saddr, CM_SERVER_FILE, FALSE);
if ( tsp ) /* an existing server - ref count increased */
{
- tsp->ipRank = (USHORT)dwRank; /* no need to protect by mutex*/
-
- /* find volumes which might have RO copy
- /* on server and change the ordering of
- * their RO list
+ lock_ObtainMutex(&tsp->mx);
+ tsp->adminRank = (USHORT)dwRank;
+ _InterlockedOr(&tsp->flags, CM_SERVERFLAG_PREF_SET);
+ cm_RankServer(tsp);
+ lock_ReleaseMutex(&tsp->mx);
+
+ /* find volumes which might have RO copy
+ /* on server and change the ordering of
+ * their RO list
*/
cm_ChangeRankVolume(tsp);
cm_PutServer(tsp); /* decrease refcount */
}
else /* add a new server without a cell */
{
- tsp = cm_NewServer(&saddr, CM_SERVER_FILE, NULL, CM_FLAG_NOPROBE); /* refcount = 1 */
- tsp->ipRank = (USHORT)dwRank;
+ tsp = cm_NewServer(&saddr, CM_SERVER_FILE, NULL, NULL, CM_FLAG_NOPROBE); /* refcount = 1 */
+ lock_ObtainMutex(&tsp->mx);
+ tsp->adminRank = (USHORT)dwRank;
+ _InterlockedOr(&tsp->flags, CM_SERVERFLAG_PREF_SET);
+ cm_RankServer(tsp);
+ lock_ReleaseMutex(&tsp->mx);
}
}
}
}
+
+#ifndef _WIN64
+typedef BOOL (WINAPI *LPFN_ISWOW64PROCESS) (HANDLE, PBOOL);
+
+static BOOL
+is_wow64(void)
+{
+ static BOOL bChecked = FALSE;
+ static BOOL bIsWow64 = FALSE;
+
+ if (!bChecked)
+ {
+ HANDLE h1 = NULL;
+ LPFN_ISWOW64PROCESS fnIsWow64Process = NULL;
+
+ h1 = GetModuleHandle("kernel32.dll");
+ fnIsWow64Process =
+ (LPFN_ISWOW64PROCESS)GetProcAddress(h1, "IsWow64Process");
+
+ /* If we don't find the fnIsWow64Process function then we
+ * are not running in a broken Wow64
+ */
+ if (fnIsWow64Process)
+ fnIsWow64Process(GetCurrentProcess(), &bIsWow64);
+
+ bChecked = TRUE;
+ }
+
+ return bIsWow64;
+}
+#endif /* _WIN64 */
+
/*
* AFSD Initialization
*/
-int afsd_InitCM(char **reasonP)
+static int
+afsd_InitRoot(char **reasonP)
+{
+ long code;
+ cm_req_t req;
+
+ cm_InitReq(&req);
+
+ if (cm_freelanceEnabled) {
+ cm_FakeRootFid(&cm_data.rootFid);
+ } else {
+ int attempts = 10;
+
+ osi_Log0(afsd_logp, "Loading Root Volume from cell");
+ do {
+ code = cm_FindVolumeByName(cm_data.rootCellp, cm_rootVolumeName, cm_rootUserp,
+ &req, CM_GETVOL_FLAG_CREATE, &cm_data.rootVolumep);
+ afsi_log("cm_FindVolumeByName code %x root vol %x", code,
+ (code ? (cm_volume_t *)-1 : cm_data.rootVolumep));
+ } while (code && --attempts);
+ if (code != 0) {
+ *reasonP = "can't find root volume in root cell";
+ return -1;
+ }
+
+ /* compute the root fid */
+ cm_SetFid(&cm_data.rootFid, cm_data.rootCellp->cellID, cm_GetROVolumeID(cm_data.rootVolumep), 1, 1);
+ }
+
+ code = cm_GetSCache(&cm_data.rootFid, NULL, &cm_data.rootSCachep, cm_rootUserp, &req);
+ afsi_log("cm_GetSCache code %x scache %x", code,
+ (code ? (cm_scache_t *)-1 : cm_data.rootSCachep));
+ if (code != 0) {
+ *reasonP = "unknown error";
+ return -1;
+ }
+
+ return 0;
+}
+
+int
+afsd_InitCM(char **reasonP)
{
osi_uid_t debugID;
afs_uint64 cacheBlocks;
DWORD dwValue;
DWORD rx_enable_peer_stats;
DWORD rx_enable_process_stats;
+ DWORD rx_udpbufsize = -1;
+ DWORD lockOrderValidation;
long traceBufSize;
long maxcpus;
long ltt, ltto;
long rx_nojumbo;
- long virtualCache = 0;
- char rootCellName[256];
+ int rx_max_rwin_size;
+ int rx_max_swin_size;
+ int rx_min_peer_timeout;
+ DWORD virtualCache = 0;
+ fschar_t rootCellName[256];
struct rx_service *serverp;
static struct rx_securityClass *nullServerSecurityClassp;
struct hostent *thp;
/*int freelanceEnabled;*/
WSADATA WSAjunk;
int i;
- char *p, *q;
int cm_noIPAddr; /* number of client network interfaces */
int cm_IPAddr[CM_MAXINTERFACE_ADDR]; /* client's IP address in host order */
int cm_SubnetMask[CM_MAXINTERFACE_ADDR];/* client's subnet mask in host order*/
int cm_NetMtu[CM_MAXINTERFACE_ADDR]; /* client's MTU sizes */
int cm_NetFlags[CM_MAXINTERFACE_ADDR]; /* network flags */
+ DWORD dwPriority;
+ OSVERSIONINFO osVersion;
+
+ /* Get the version of Windows */
+ memset(&osVersion, 0x00, sizeof(osVersion));
+ osVersion.dwOSVersionInfoSize = sizeof(osVersion);
+ GetVersionEx(&osVersion);
WSAStartup(0x0101, &WSAjunk);
- afsd_initUpperCaseTable();
init_et_to_sys_error();
+ cm_utilsInit();
+
/* setup osidebug server at RPC slot 1000 */
osi_LongToUID(1000, &debugID);
code = osi_InitDebug(&debugID);
afsi_log("osi_InitDebug code %d", code);
+#ifndef _WIN64
+ if (is_wow64())
+ {
+ *reasonP = "32-bit OpenAFS Service is incompatible with the WOW64 environment";
+ return -1;
+ }
+#endif
+
// osi_LockTypeSetDefault("stat"); /* comment this out for speed */
if (code != 0) {
if (code == RPC_S_NO_PROTSEQS)
/* Look up configuration parameters in Registry */
code = RegOpenKeyEx(HKEY_LOCAL_MACHINE, AFSREG_CLT_SVC_PARAM_SUBKEY,
- 0, KEY_QUERY_VALUE, &parmKey);
+ 0, KEY_QUERY_VALUE, &parmKey);
if (code != ERROR_SUCCESS) {
FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM
| FORMAT_MESSAGE_ALLOCATE_BUFFER,
osi_panic(buf, __FILE__, __LINE__);
}
+ dummyLen = sizeof(dwPriority);
+ code = RegQueryValueEx(parmKey, "PriorityClass", NULL, NULL,
+ (BYTE *) &dwPriority, &dummyLen);
+ if (code != ERROR_SUCCESS || dwPriority == 0) {
+ dwPriority = HIGH_PRIORITY_CLASS;
+ }
+ if (dwPriority != GetPriorityClass(GetCurrentProcess()))
+ SetPriorityClass(GetCurrentProcess(), dwPriority);
+ afsi_log("PriorityClass 0x%x", GetPriorityClass(GetCurrentProcess()));
+
+ dummyLen = sizeof(lockOrderValidation);
+ code = RegQueryValueEx(parmKey, "LockOrderValidation", NULL, NULL,
+ (BYTE *) &lockOrderValidation, &dummyLen);
+ if (code != ERROR_SUCCESS) {
+#ifdef DEBUG
+ lockOrderValidation = 1;
+#else
+ lockOrderValidation = 0;
+#endif
+ }
+ osi_SetLockOrderValidation(lockOrderValidation);
+ afsi_log("Lock Order Validation %s", lockOrderValidation ? "On" : "Off");
+
dummyLen = sizeof(maxcpus);
code = RegQueryValueEx(parmKey, "MaxCPUs", NULL, NULL,
(BYTE *) &maxcpus, &dummyLen);
- if (code == ERROR_SUCCESS) {
+ if (code != ERROR_SUCCESS) {
+ maxcpus = 2;
+ }
+
+ {
HANDLE hProcess;
DWORD_PTR processAffinityMask, systemAffinityMask;
if ( hProcess != NULL &&
GetProcessAffinityMask(hProcess, &processAffinityMask, &systemAffinityMask) )
{
- int i, n, bits;
+ int i, n, bits, cpu_count = 0;
DWORD_PTR mask, newAffinityMask;
#if defined(_WIN64)
#else
bits = 32;
#endif
- for ( i=0, n=0, mask=1, newAffinityMask=0; i<bits && n<maxcpus; i++ ) {
+ for ( i=0, n=0, mask=1, newAffinityMask=0; i<bits; i++ ) {
if ( processAffinityMask & mask ) {
- newAffinityMask |= mask;
- n++;
+ cpu_count++;
+ if (n<maxcpus) {
+ newAffinityMask |= mask;
+ n++;
+ }
}
mask *= 2;
}
- SetProcessAffinityMask(hProcess, newAffinityMask);
+ if (maxcpus == 0) {
+ afsi_log("No CPU Restrictions; %d cpu(s) available", cpu_count);
+ } else {
+ SetProcessAffinityMask(hProcess, newAffinityMask);
+ }
CloseHandle(hProcess);
- afsi_log("CPU Restrictions set to %d cpu(s); %d cpu(s) available", maxcpus, n);
+ afsi_log("CPU Restrictions set to %d cpu(s); %d cpu(s) available", maxcpus, cpu_count);
} else {
- afsi_log("CPU Restrictions set to %d cpu(s); unable to access process information", maxcpus);
+ afsi_log("CPU Restrictions requested %d cpu(s); unable to access process information", maxcpus);
}
}
osi_Log0(afsd_logp, "Log init");
+ dummyLen = sizeof(smb_monitorReqs);
+ code = RegQueryValueEx(parmKey, "SMBRequestMonitor", NULL, NULL,
+ (BYTE *) &smb_monitorReqs, &dummyLen);
+ afsi_log("SMB request monitoring is %s", (smb_monitorReqs != 0)? "enabled": "disabled");
+
+ dummyLen = sizeof(virtualCache);
+ code = RegQueryValueEx(parmKey, "NonPersistentCaching", NULL, NULL,
+ (LPBYTE)&virtualCache, &dummyLen);
+ if (!code)
+ cm_virtualCache = virtualCache ? 1 : 0;
+ afsi_log("Cache type is %s", (cm_virtualCache?"VIRTUAL":"FILE"));
+
+ if (!cm_virtualCache) {
+ dummyLen = sizeof(cm_ValidateCache);
+ code = RegQueryValueEx(parmKey, "ValidateCache", NULL, NULL,
+ (LPBYTE)&cm_ValidateCache, &dummyLen);
+ if ( cm_ValidateCache < 0 || cm_ValidateCache > 2 )
+ cm_ValidateCache = 1;
+ switch (cm_ValidateCache) {
+ case 0:
+ afsi_log("Cache Validation disabled");
+ break;
+ case 1:
+ afsi_log("Cache Validation on Startup");
+ break;
+ case 2:
+ afsi_log("Cache Validation on Startup and Shutdown");
+ break;
+ }
+ }
+
dummyLen = sizeof(cacheSize);
code = RegQueryValueEx(parmKey, "CacheSize", NULL, NULL,
(BYTE *) &cacheSize, &dummyLen);
- if (code == ERROR_SUCCESS)
- afsi_log("Cache size %d", cacheSize);
- else {
+ if (code != ERROR_SUCCESS)
cacheSize = CM_CONFIGDEFAULT_CACHESIZE;
- afsi_log("Default cache size %d", cacheSize);
+
+ if (cm_virtualCache) {
+ MEMORYSTATUSEX memStatus;
+ DWORD maxCacheSize;
+
+ memStatus.dwLength = sizeof(memStatus);
+ if (GlobalMemoryStatusEx(&memStatus)) {
+ /* Set maxCacheSize to 10% of physical memory */
+ maxCacheSize = (DWORD)(memStatus.ullTotalPhys / 1024 / 10);
+ } else {
+ /* Cannot determine physical memory, set limit to 64MB */
+ maxCacheSize = 65536;
+ }
+ if (cacheSize > maxCacheSize) {
+ afsi_log("Requested Cache size %u", cacheSize);
+ cacheSize = maxCacheSize;
+ }
}
+ afsi_log("Allocated Cache size %u", cacheSize);
dummyLen = sizeof(logChunkSize);
code = RegQueryValueEx(parmKey, "ChunkSize", NULL, NULL,
code = RegQueryValueEx(parmKey, "blockSize", NULL, NULL,
(BYTE *) &blockSize, &dummyLen);
if (code == ERROR_SUCCESS) {
- if (blockSize < 1 ||
- (blockSize > 1024 && (blockSize % CM_CONFIGDEFAULT_BLOCKSIZE != 0)))
+ if (blockSize < 1 ||
+ (blockSize > 1024 && (blockSize % CM_CONFIGDEFAULT_BLOCKSIZE != 0)))
{
afsi_log("Invalid block size %u specified, using default", blockSize);
blockSize = CM_CONFIGDEFAULT_BLOCKSIZE;
} else {
- /*
+ /*
* if the blockSize is less than 1024 we permit the blockSize to be
* specified in multiples of the default blocksize
*/
blockSize = CM_CONFIGDEFAULT_BLOCKSIZE;
}
if (blockSize > cm_chunkSize) {
- afsi_log("Block size (%d) cannot be larger than Chunk size (%d).",
+ afsi_log("Block size (%d) cannot be larger than Chunk size (%d).",
blockSize, cm_chunkSize);
blockSize = cm_chunkSize;
}
ltto = 120;
} else {
ltto = 0;
- }
+ }
smb_LogoffTransferTimeout = ltto;
afsi_log("Logoff token transfer timeout %d seconds", ltto);
+ dummyLen = sizeof(cm_NetbiosName);
+ code = RegQueryValueEx(parmKey, "NetbiosName", NULL, NULL,
+ (LPBYTE) cm_NetbiosName, &dummyLen);
+ if (code == ERROR_SUCCESS)
+ afsi_log("NetbiosName %s", cm_NetbiosName);
+ else {
+ cm_FsStrCpy(cm_NetbiosName, lengthof(cm_NetbiosName), "AFS");
+ afsi_log("Default NetbiosName AFS");
+ }
+ cm_Utf8ToClientString(cm_NetbiosName, -1, cm_NetbiosNameC, MAX_NB_NAME_LENGTH);
+
dummyLen = sizeof(cm_rootVolumeName);
code = RegQueryValueEx(parmKey, "RootVolume", NULL, NULL,
- cm_rootVolumeName, &dummyLen);
+ (LPBYTE) cm_rootVolumeName, &dummyLen);
if (code == ERROR_SUCCESS)
afsi_log("Root volume %s", cm_rootVolumeName);
else {
- StringCbCopyA(cm_rootVolumeName, sizeof(cm_rootVolumeName), "root.afs");
+ cm_FsStrCpy(cm_rootVolumeName, lengthof(cm_rootVolumeName), "root.afs");
afsi_log("Default root volume name root.afs");
}
- cm_mountRootLen = sizeof(cm_mountRoot);
- code = RegQueryValueEx(parmKey, "MountRoot", NULL, NULL,
- cm_mountRoot, &cm_mountRootLen);
+ cm_mountRootCLen = sizeof(cm_mountRootC);
+ code = RegQueryValueExW(parmKey, L"MountRoot", NULL, NULL,
+ (LPBYTE) cm_mountRootC, &cm_mountRootCLen);
if (code == ERROR_SUCCESS) {
- afsi_log("Mount root %s", cm_mountRoot);
- cm_mountRootLen = (DWORD)strlen(cm_mountRoot);
+ afsi_log("Mount root %S", cm_mountRootC);
+ cm_mountRootCLen = (DWORD)cm_ClientStrLen(cm_mountRootC);
} else {
- StringCbCopyA(cm_mountRoot, sizeof(cm_mountRoot), "/afs");
- cm_mountRootLen = 4;
+ cm_ClientStrCpy(cm_mountRootC, lengthof(cm_mountRootC), _C("/afs"));
+ cm_mountRootCLen = (DWORD)cm_ClientStrLen(cm_mountRootC);
/* Don't log */
}
+ cm_ClientStringToFsString(cm_mountRootC, -1, cm_mountRoot, lengthof(cm_mountRoot));
+ cm_mountRootLen = (DWORD)cm_FsStrLen(cm_mountRoot);
+
dummyLen = sizeof(buf);
code = RegQueryValueEx(parmKey, "CachePath", NULL, ®Type,
- buf, &dummyLen);
+ buf, &dummyLen);
if (code == ERROR_SUCCESS && buf[0]) {
if (regType == REG_EXPAND_SZ) {
dummyLen = ExpandEnvironmentStrings(buf, cm_CachePath, sizeof(cm_CachePath));
} else {
dummyLen = ExpandEnvironmentStrings("%TEMP%\\AFSCache", cm_CachePath, sizeof(cm_CachePath));
if (dummyLen > sizeof(cm_CachePath)) {
- afsi_log("Cache path [%%TEMP%%\\AFSCache] longer than %d after expanding env strings",
+ afsi_log("Cache path [%%TEMP%%\\AFSCache] longer than %d after expanding env strings",
sizeof(cm_CachePath));
osi_panic("CachePath too long", __FILE__, __LINE__);
}
afsi_log("Default cache path %s", cm_CachePath);
}
- dummyLen = sizeof(virtualCache);
- code = RegQueryValueEx(parmKey, "NonPersistentCaching", NULL, NULL,
- (LPBYTE)&virtualCache, &dummyLen);
- afsi_log("Cache type is %s", (virtualCache?"VIRTUAL":"FILE"));
-
- if (!virtualCache) {
- dummyLen = sizeof(cm_ValidateCache);
- code = RegQueryValueEx(parmKey, "ValidateCache", NULL, NULL,
- (LPBYTE)&cm_ValidateCache, &dummyLen);
- if ( cm_ValidateCache < 0 || cm_ValidateCache > 2 )
- cm_ValidateCache = 1;
- switch (cm_ValidateCache) {
- case 0:
- afsi_log("Cache Validation disabled");
- break;
- case 1:
- afsi_log("Cache Validation on Startup");
- break;
- case 2:
- afsi_log("Cache Validation on Startup and Shutdown");
- break;
- }
- }
-
dummyLen = sizeof(traceOnPanic);
code = RegQueryValueEx(parmKey, "TrapOnPanic", NULL, NULL,
(BYTE *) &traceOnPanic, &dummyLen);
}
for ( i=0; i < MAXNUMSYSNAMES; i++ ) {
- cm_sysNameList[i] = osi_Alloc(MAXSYSNAME);
+ cm_sysNameList[i] = osi_Alloc(MAXSYSNAME * sizeof(clientchar_t));
cm_sysNameList[i][0] = '\0';
+ cm_sysName64List[i] = osi_Alloc(MAXSYSNAME * sizeof(clientchar_t));
+ cm_sysName64List[i][0] = '\0';
}
- cm_sysName = cm_sysNameList[0];
- dummyLen = sizeof(buf);
- code = RegQueryValueEx(parmKey, "SysName", NULL, NULL, buf, &dummyLen);
- if (code != ERROR_SUCCESS || !buf[0]) {
+ /* Process SysName lists from the registry */
+ {
+ clientchar_t *p, *q;
+ clientchar_t * cbuf = (clientchar_t *) buf;
+
+ dummyLen = sizeof(buf);
+ code = RegQueryValueExW(parmKey, L"SysName", NULL, NULL, (LPBYTE) cbuf, &dummyLen);
+ if (code != ERROR_SUCCESS || !cbuf[0]) {
#if defined(_IA64_)
- StringCbCopyA(buf, sizeof(buf), "ia64_win64");
+ cm_ClientStrCpy(cbuf, lengthof(buf), _C("ia64_win64"));
#elif defined(_AMD64_)
- StringCbCopyA(buf, sizeof(buf), "amd64_win64 x86_win32 i386_w2k");
+ cm_ClientStrCpy(cbuf, lengthof(buf), _C("amd64_win64 x86_win32 i386_w2k"));
#else /* assume x86 32-bit */
- StringCbCopyA(buf, sizeof(buf), "x86_win32 i386_w2k i386_nt40");
+ cm_ClientStrCpy(cbuf, lengthof(buf), _C("x86_win32 i386_w2k i386_nt40"));
#endif
- }
- afsi_log("Sys name %s", buf);
+ }
+ afsi_log("Sys name list: %S", cbuf);
+
+ /* breakup buf into individual search string entries */
+ for (p = q = cbuf; p < cbuf + dummyLen; p++) {
+ if (*p == '\0' || iswspace(*p)) {
+ memcpy(cm_sysNameList[cm_sysNameCount],q,(p-q) * sizeof(clientchar_t));
+ cm_sysNameList[cm_sysNameCount][p-q] = '\0';
+ cm_sysNameCount++;
+ do {
+ if (*p == '\0')
+ goto done_sysname32;
+ p++;
+ } while (*p == '\0' || isspace(*p));
+ q = p;
+ p--;
+ }
+ }
+ done_sysname32:
+ ;
- /* breakup buf into individual search string entries */
- for (p = q = buf; p < buf + dummyLen; p++)
- {
- if (*p == '\0' || isspace(*p)) {
- memcpy(cm_sysNameList[cm_sysNameCount],q,p-q);
- cm_sysNameList[cm_sysNameCount][p-q] = '\0';
- cm_sysNameCount++;
-
- do {
- if (*p == '\0')
- goto done_sysname;
- p++;
- } while (*p == '\0' || isspace(*p));
- q = p;
- p--;
+#ifdef _WIN64
+ /*
+ * If there is a 64-bit list, process it. Otherwise, we will leave
+ * it undefined which implies that the 32-bit list be used for both.
+ * The 64-bit list is only used for the native file system driver.
+ * The SMB redirector interface does not provide any means of indicating
+ * the source of the request.
+ */
+ dummyLen = sizeof(buf);
+ code = RegQueryValueExW(parmKey, L"SysName64", NULL, NULL, (LPBYTE) cbuf, &dummyLen);
+ if (code == ERROR_SUCCESS && cbuf[0]) {
+ afsi_log("Sys name 64 list: %S", cbuf);
+
+ /* breakup buf into individual search string entries */
+ for (p = q = cbuf; p < cbuf + dummyLen; p++) {
+ if (*p == '\0' || iswspace(*p)) {
+ memcpy(cm_sysName64List[cm_sysName64Count],q,(p-q) * sizeof(clientchar_t));
+ cm_sysName64List[cm_sysName64Count][p-q] = '\0';
+ cm_sysName64Count++;
+ do {
+ if (*p == '\0')
+ goto done_sysname64;
+ p++;
+ } while (*p == '\0' || isspace(*p));
+ q = p;
+ p--;
+ }
+ }
}
+ done_sysname64:
+ ;
+#endif
}
- done_sysname:
- StringCbCopyA(cm_sysName, MAXSYSNAME, cm_sysNameList[0]);
dummyLen = sizeof(cryptall);
code = RegQueryValueEx(parmKey, "SecurityLevel", NULL, NULL,
- (BYTE *) &cryptall, &dummyLen);
+ (BYTE *) &cryptall, &dummyLen);
if (code == ERROR_SUCCESS) {
- afsi_log("SecurityLevel is %s", cryptall?"crypt":"clear");
+ afsi_log("SecurityLevel is %s", cryptall == 1?"crypt": cryptall == 2?"auth":"clear");
} else {
cryptall = 0;
afsi_log("Default SecurityLevel is clear");
}
- if (cryptall)
+ if (cryptall == 1)
LogEvent(EVENTLOG_INFORMATION_TYPE, MSG_CRYPT_ON);
+ else if (cryptall == 2)
+ LogEvent(EVENTLOG_INFORMATION_TYPE, MSG_CRYPT_AUTH);
else
LogEvent(EVENTLOG_INFORMATION_TYPE, MSG_CRYPT_OFF);
- dummyLen = sizeof(cryptall);
+ dummyLen = sizeof(cm_verifyData);
+ code = RegQueryValueEx(parmKey, "VerifyData", NULL, NULL,
+ (BYTE *) &cm_verifyData, &dummyLen);
+ afsi_log("VerifyData is %s", cm_verifyData?"on":"off");
+
+ dummyLen = sizeof(cm_anonvldb);
code = RegQueryValueEx(parmKey, "ForceAnonVLDB", NULL, NULL,
(BYTE *) &cm_anonvldb, &dummyLen);
afsi_log("CM ForceAnonVLDB is %s", cm_anonvldb ? "on" : "off");
-#ifdef AFS_AFSDB_ENV
dummyLen = sizeof(cm_dnsEnabled);
code = RegQueryValueEx(parmKey, "UseDNS", NULL, NULL,
(BYTE *) &cm_dnsEnabled, &dummyLen);
if (code == ERROR_SUCCESS) {
afsi_log("DNS %s be used to find AFS cell servers",
cm_dnsEnabled ? "will" : "will not");
- }
+ }
else {
cm_dnsEnabled = 1; /* default on */
afsi_log("Default to use DNS to find AFS cell servers");
}
-#else /* AFS_AFSDB_ENV */
- afsi_log("AFS not built with DNS support to find AFS cell servers");
-#endif /* AFS_AFSDB_ENV */
#ifdef AFS_FREELANCE_CLIENT
dummyLen = sizeof(cm_freelanceEnabled);
code = RegQueryValueEx(parmKey, "FreelanceClient", NULL, NULL,
(BYTE *) &cm_freelanceEnabled, &dummyLen);
- if (code == ERROR_SUCCESS) {
- afsi_log("Freelance client feature %s activated",
- cm_freelanceEnabled ? "is" : "is not");
- }
- else {
- cm_freelanceEnabled = 1; /* default on */
- }
+ afsi_log("Freelance client feature %s activated",
+ cm_freelanceEnabled ? "is" : "is not");
+
+ dummyLen = sizeof(cm_freelanceImportCellServDB);
+ code = RegQueryValueEx(parmKey, "FreelanceImportCellServDB", NULL, NULL,
+ (BYTE *) &cm_freelanceImportCellServDB, &dummyLen);
+ afsi_log("Freelance client %s import CellServDB",
+ cm_freelanceImportCellServDB ? "does" : "does not");
+
+ dummyLen = sizeof(cm_freelanceDiscovery);
+ code = RegQueryValueEx(parmKey, "FreelanceDiscovery", NULL, NULL,
+ (BYTE *) &cm_freelanceDiscovery, &dummyLen);
+ afsi_log("Freelance client discovery is %s",
+ cm_freelanceDiscovery ? "on" : "off");
+
#endif /* AFS_FREELANCE_CLIENT */
dummyLen = sizeof(smb_UseUnicode);
afsi_log("Dot files/dirs will %sbe marked hidden",
smb_hideDotFiles ? "" : "not ");
+ dummyLen = sizeof(dwValue);
+ code = RegQueryValueEx(parmKey, "UnixModeFileDefault", NULL, NULL,
+ (BYTE *) &dwValue, &dummyLen);
+ if (code == ERROR_SUCCESS) {
+ smb_unixModeDefaultFile = (dwValue & 07777);
+ }
+ afsi_log("Default unix mode bits for files is 0%04o", smb_unixModeDefaultFile);
+
+ dummyLen = sizeof(dwValue);
+ code = RegQueryValueEx(parmKey, "UnixModeDirDefault", NULL, NULL,
+ (BYTE *) &dwValue, &dummyLen);
+ if (code == ERROR_SUCCESS) {
+ smb_unixModeDefaultDir = (dwValue & 07777);
+ }
+ afsi_log("Default unix mode bits for directories is 0%04o", smb_unixModeDefaultDir);
+
dummyLen = sizeof(smb_maxMpxRequests);
code = RegQueryValueEx(parmKey, "MaxMpxRequests", NULL, NULL,
(BYTE *) &smb_maxMpxRequests, &dummyLen);
code = RegQueryValueEx(parmKey, "SMBAuthType", NULL, NULL,
(BYTE *) &smb_authType, &dummyLen);
- if (code != ERROR_SUCCESS ||
+ if (code != ERROR_SUCCESS ||
(smb_authType != SMB_AUTH_EXTENDED && smb_authType != SMB_AUTH_NTLM && smb_authType != SMB_AUTH_NONE)) {
smb_authType = SMB_AUTH_EXTENDED; /* default is to use extended authentication */
}
afsi_log("SMB authentication type is %s", ((smb_authType == SMB_AUTH_NONE)?"NONE":((smb_authType == SMB_AUTH_EXTENDED)?"EXTENDED":"NTLM")));
+ dummyLen = sizeof(rx_max_rwin_size);
+ code = RegQueryValueEx(parmKey, "RxMaxRecvWinSize", NULL, NULL,
+ (BYTE *) &rx_max_rwin_size, &dummyLen);
+ if (code == ERROR_SUCCESS)
+ rx_SetMaxReceiveWindow(rx_max_rwin_size);
+ afsi_log("Rx Maximum Receive Window Size is %d", rx_GetMaxReceiveWindow());
+
+ dummyLen = sizeof(rx_max_swin_size);
+ code = RegQueryValueEx(parmKey, "RxMaxSendWinSize", NULL, NULL,
+ (BYTE *) &rx_max_swin_size, &dummyLen);
+ if (code == ERROR_SUCCESS)
+ rx_SetMaxSendWindow(rx_max_swin_size);
+ afsi_log("Rx Maximum Send Window Size is %d", rx_GetMaxSendWindow());
+
+ dummyLen = sizeof(rx_min_peer_timeout);
+ code = RegQueryValueEx(parmKey, "RxMinPeerTimeout", NULL, NULL,
+ (BYTE *) &rx_min_peer_timeout, &dummyLen);
+ if (code == ERROR_SUCCESS)
+ rx_SetMinPeerTimeout(rx_min_peer_timeout);
+ afsi_log("Rx Minimum Peer Timeout is %d ms", rx_GetMinPeerTimeout());
+
+ dummyLen = sizeof(rx_pmtu_discovery);
+ code = RegQueryValueEx(parmKey, "RxPMTUDiscovery", NULL, NULL,
+ (BYTE *) &rx_pmtu_discovery, &dummyLen);
+ afsi_log("Rx PMTU Discovery is %d ms", rx_pmtu_discovery);
+
dummyLen = sizeof(rx_nojumbo);
code = RegQueryValueEx(parmKey, "RxNoJumbo", NULL, NULL,
(BYTE *) &rx_nojumbo, &dummyLen);
if (code != ERROR_SUCCESS) {
- rx_nojumbo = 0;
+ DWORD jumbo;
+ dummyLen = sizeof(jumbo);
+ code = RegQueryValueEx(parmKey, "RxJumbo", NULL, NULL,
+ (BYTE *) &jumbo, &dummyLen);
+ if (code != ERROR_SUCCESS) {
+ rx_nojumbo = 1;
+ } else {
+ rx_nojumbo = !jumbo;
+ }
}
if (rx_nojumbo)
afsi_log("RX Jumbograms are disabled");
+ else
+ afsi_log("RX Jumbograms are enabled");
dummyLen = sizeof(rx_extraPackets);
code = RegQueryValueEx(parmKey, "RxExtraPackets", NULL, NULL,
(BYTE *) &rx_extraPackets, &dummyLen);
if (code != ERROR_SUCCESS) {
- rx_extraPackets = 120;
+ rx_extraPackets = (numBkgD + numSvThreads + 5) * 64;
}
if (rx_extraPackets)
afsi_log("RX extraPackets is %d", rx_extraPackets);
+ dummyLen = sizeof(rx_udpbufsize);
+ code = RegQueryValueEx(parmKey, "RxUdpBufSize", NULL, NULL,
+ (BYTE *) &rx_udpbufsize, &dummyLen);
+ if (code != ERROR_SUCCESS) {
+ rx_udpbufsize = 256*1024;
+ }
+ if (rx_udpbufsize != -1)
+ afsi_log("RX udpbufsize is %d", rx_udpbufsize);
+
dummyLen = sizeof(rx_mtu);
code = RegQueryValueEx(parmKey, "RxMaxMTU", NULL, NULL,
(BYTE *) &rx_mtu, &dummyLen);
(BYTE *) &dwValue, &dummyLen);
if (code == ERROR_SUCCESS) {
cm_enableServerLocks = (unsigned short) dwValue;
- }
+ }
switch (cm_enableServerLocks) {
case 0:
afsi_log("EnableServerLocks: never");
(BYTE *) &dwValue, &dummyLen);
if (code == ERROR_SUCCESS) {
cm_deleteReadOnly = (unsigned short) dwValue;
- }
+ }
afsi_log("CM DeleteReadOnly is %u", cm_deleteReadOnly);
-
+
#ifdef USE_BPLUS
dummyLen = sizeof(DWORD);
code = RegQueryValueEx(parmKey, "BPlusTrees", NULL, NULL,
(BYTE *) &dwValue, &dummyLen);
if (code == ERROR_SUCCESS) {
cm_BPlusTrees = (unsigned short) dwValue;
- }
+ }
afsi_log("CM BPlusTrees is %u", cm_BPlusTrees);
if (cm_BPlusTrees && !cm_InitBPlusDir()) {
afsi_log("CM BPlusTrees is not supported");
#endif
- if ((RegQueryValueEx( parmKey, "PrefetchExecutableExtensions", 0,
- ®Type, NULL, &dummyLen) == ERROR_SUCCESS) &&
- (regType == REG_MULTI_SZ))
+ if ((RegQueryValueExW( parmKey, L"PrefetchExecutableExtensions", 0,
+ ®Type, NULL, &dummyLen) == ERROR_SUCCESS) &&
+ (regType == REG_MULTI_SZ))
{
- char * pSz;
+ clientchar_t * pSz;
dummyLen += 3; /* in case the source string is not nul terminated */
pSz = malloc(dummyLen);
- if ((RegQueryValueEx( parmKey, "PrefetchExecutableExtensions", 0, ®Type,
- pSz, &dummyLen) == ERROR_SUCCESS) &&
+ if ((RegQueryValueExW( parmKey, L"PrefetchExecutableExtensions", 0, ®Type,
+ (LPBYTE) pSz, &dummyLen) == ERROR_SUCCESS) &&
(regType == REG_MULTI_SZ))
{
int cnt;
- char * p;
+ clientchar_t * p;
- for (cnt = 0, p = pSz; (p - pSz < dummyLen) && *p; cnt++, p += strlen(p) + 1);
+ for (cnt = 0, p = pSz; (p - pSz < dummyLen) && *p; cnt++, p += cm_ClientStrLen(p) + 1);
- smb_ExecutableExtensions = malloc(sizeof(char *) * (cnt+1));
+ smb_ExecutableExtensions = malloc(sizeof(clientchar_t *) * (cnt+1));
- for (cnt = 0, p = pSz; (p - pSz < dummyLen) && *p; cnt++, p += strlen(p) + 1)
- {
+ for (cnt = 0, p = pSz; (p - pSz < dummyLen) && *p; cnt++, p += cm_ClientStrLen(p) + 1) {
smb_ExecutableExtensions[cnt] = p;
- afsi_log("PrefetchExecutableExtension: \"%s\"", p);
+ afsi_log("PrefetchExecutableExtension: \"%S\"", p);
}
smb_ExecutableExtensions[cnt] = NULL;
}
-
+
if (!smb_ExecutableExtensions)
free(pSz);
}
(BYTE *) &dwValue, &dummyLen);
if (code == ERROR_SUCCESS) {
cm_OfflineROIsValid = (unsigned short) dwValue;
- }
- afsi_log("CM OfflineReadOnlyIsValid is %u", cm_deleteReadOnly);
-
+ }
+ afsi_log("CM OfflineReadOnlyIsValid is %u", cm_OfflineROIsValid);
+
dummyLen = sizeof(DWORD);
code = RegQueryValueEx(parmKey, "GiveUpAllCallBacks", NULL, NULL,
(BYTE *) &dwValue, &dummyLen);
if (code == ERROR_SUCCESS) {
cm_giveUpAllCBs = (unsigned short) dwValue;
- }
+ }
afsi_log("CM GiveUpAllCallBacks is %u", cm_giveUpAllCBs);
dummyLen = sizeof(DWORD);
(BYTE *) &dwValue, &dummyLen);
if (code == ERROR_SUCCESS) {
cm_followBackupPath = (unsigned short) dwValue;
- }
+ }
afsi_log("CM FollowBackupPath is %u", cm_followBackupPath);
+ dummyLen = sizeof(DWORD);
+ code = RegQueryValueEx(parmKey, "PerFileAccessCheck", NULL, NULL,
+ (BYTE *) &dwValue, &dummyLen);
+ if (code == ERROR_SUCCESS) {
+ cm_accessPerFileCheck = (int) dwValue;
+ }
+ afsi_log("CM PerFileAccessCheck is %d", cm_accessPerFileCheck);
+
+ dummyLen = sizeof(DWORD);
+ code = RegQueryValueEx(parmKey, "ReadOnlyVolumeVersioning", NULL, NULL,
+ (BYTE *) &dwValue, &dummyLen);
+ if (code == ERROR_SUCCESS) {
+ cm_readonlyVolumeVersioning = (unsigned short) dwValue;
+ }
+ afsi_log("CM ReadOnlyVolumeVersioning is %u", cm_readonlyVolumeVersioning);
+
+ dummyLen = sizeof(DWORD);
+ code = RegQueryValueEx(parmKey, "ShortNames", NULL, NULL,
+ (BYTE *) &dwValue, &dummyLen);
+ if (code == ERROR_SUCCESS) {
+ cm_shortNames = (unsigned short) dwValue;
+ } else {
+ /* disable by default on Win7, Win 8, Server 2008 R2 and Server 2012 */
+ if (osVersion.dwMajorVersion > 6 ||
+ osVersion.dwMajorVersion == 6 &&
+ osVersion.dwMinorVersion >= 1)
+ cm_shortNames = 0;
+ else
+ cm_shortNames = 1;
+ }
+ afsi_log("CM ShortNames is %u", cm_shortNames);
+
RegCloseKey (parmKey);
cacheBlocks = ((afs_uint64)cacheSize * 1024) / blockSize;
-
+
/* get network related info */
cm_noIPAddr = CM_MAXINTERFACE_ADDR;
code = syscfg_GetIFInfo(&cm_noIPAddr,
cm_IPAddr[0], cm_SubnetMask[0]);
/*
- * Save client configuration for GetCacheConfig requests
+ * Save client configuration for GetCacheConf\eig requests
*/
cm_initParams.nChunkFiles = 0;
cm_initParams.nStatCaches = stats;
cm_initParams.setTime = 0;
cm_initParams.memCache = 1;
- /* Ensure the AFS Netbios Name is registered to allow loopback access */
- configureBackConnectionHostNames();
-
/* init user daemon, and other packages */
cm_InitUser();
cm_InitConn();
cm_InitServer();
-
+
cm_InitIoctl();
-
+
smb_InitIoctl();
-
+
cm_InitCallback();
cm_InitNormalization();
- code = cm_InitMappedMemory(virtualCache, cm_CachePath, stats, volumes, cells, cm_chunkSize, cacheBlocks, blockSize);
+ code = cm_InitMappedMemory(cm_virtualCache, cm_CachePath, stats, volumes, cells, cm_chunkSize, cacheBlocks, blockSize);
afsi_log("cm_InitMappedMemory code %x", code);
if (code != 0) {
*reasonP = "error initializing cache file";
return -1;
}
-#ifdef AFS_AFSDB_ENV
+ /* Must be called after cm_InitMappedMemory. */
+ cm_EAccesInitCache();
+
#if !defined(_WIN32_WINNT) || (_WIN32_WINNT < 0x0500)
if (cm_InitDNS(cm_dnsEnabled) == -1)
cm_dnsEnabled = 0; /* init failed, so deactivate */
afsi_log("cm_InitDNS %d", cm_dnsEnabled);
#endif
-#endif
/* Set RX parameters before initializing RX */
if ( rx_nojumbo ) {
afsi_log("rx_SetMaxMTU %d successful", rx_mtu);
}
- /* initialize RX, and tell it to listen to the callbackport,
+ if ( rx_udpbufsize != -1 ) {
+ rx_SetUdpBufSize(rx_udpbufsize);
+ afsi_log("rx_SetUdpBufSize %d", rx_udpbufsize);
+ }
+
+ rx_SetBusyChannelError(1); /* Activate busy call channel reporting */
+
+ /* initialize RX, and tell it to listen to the callbackport,
* which is used for callback RPC messages.
*/
code = rx_Init(htons(cm_callbackport));
*reasonP = "unknown error";
return -1;
}
+ rx_SetMinProcs(serverp, 2);
+ rx_SetMaxProcs(serverp, 4);
+ rx_SetCheckReach(serverp, 1);
nullServerSecurityClassp = rxnull_NewServerSecurityObject();
serverp = rx_NewService(0, RX_STATS_SERVICE_ID, "rpcstats",
*reasonP = "unknown error";
return -1;
}
-
+ rx_SetMinProcs(serverp, 2);
+ rx_SetMaxProcs(serverp, 4);
+
/* start server threads, *not* donating this one to the pool */
rx_StartServer(0);
afsi_log("rx_StartServer");
rx_enableProcessRPCStats();
code = cm_GetRootCellName(rootCellName);
- afsi_log("cm_GetRootCellName code %d, cm_freelanceEnabled= %d, rcn= %s",
- code, cm_freelanceEnabled, (code ? "<none>" : rootCellName));
- if (code != 0 && !cm_freelanceEnabled)
+ afsi_log("cm_GetRootCellName code %d, cm_freelanceEnabled= %d, rcn= %s",
+ code, cm_freelanceEnabled, (code ? "<none>" : rootCellName));
+ if (code != 0 && !cm_freelanceEnabled)
{
*reasonP = "can't find root cell name in " AFS_CELLSERVDB;
return -1;
- }
+ }
else if (cm_freelanceEnabled)
cm_data.rootCellp = NULL;
- if (code == 0 && !cm_freelanceEnabled)
+ if (code == 0 && !cm_freelanceEnabled)
{
cm_data.rootCellp = cm_GetCell(rootCellName, CM_FLAG_CREATE);
afsi_log("cm_GetCell addr %x", PtrToUlong(cm_data.rootCellp));
- if (cm_data.rootCellp == NULL)
+ if (cm_data.rootCellp == NULL)
{
*reasonP = "can't find root cell in " AFS_CELLSERVDB;
return -1;
/* Initialize the RPC server for session keys */
RpcInit();
+ /* Initialize the RPC server for pipe services */
+ MSRPC_Init();
+
afsd_InitServerPreferences();
- return 0;
+
+ code = afsd_InitRoot(reasonP);
+
+ return code;
}
int afsd_ShutdownCM(void)
{
+ MSRPC_Shutdown();
+
cm_ReleaseSCache(cm_data.rootSCachep);
+ cm_utilsCleanup();
+
+ cm_shutdown = 1;
+
return 0;
}
int afsd_InitDaemons(char **reasonP)
{
- long code;
- cm_req_t req;
-
- cm_InitReq(&req);
-
- /* this should really be in an init daemon from here on down */
-
- if (!cm_freelanceEnabled) {
- int attempts = 10;
-
- osi_Log0(afsd_logp, "Loading Root Volume from cell");
- do {
- code = cm_FindVolumeByName(cm_data.rootCellp, cm_rootVolumeName, cm_rootUserp,
- &req, CM_GETVOL_FLAG_CREATE, &cm_data.rootVolumep);
- afsi_log("cm_FindVolumeByName code %x root vol %x", code,
- (code ? (cm_volume_t *)-1 : cm_data.rootVolumep));
- } while (code && --attempts);
- if (code != 0) {
- *reasonP = "can't find root volume in root cell";
- return -1;
- }
- }
-
- /* compute the root fid */
- if (!cm_freelanceEnabled) {
- cm_SetFid(&cm_data.rootFid, cm_data.rootCellp->cellID, cm_GetROVolumeID(cm_data.rootVolumep), 1, 1);
- }
- else
- cm_FakeRootFid(&cm_data.rootFid);
-
- code = cm_GetSCache(&cm_data.rootFid, &cm_data.rootSCachep, cm_rootUserp, &req);
- afsi_log("cm_GetSCache code %x scache %x", code,
- (code ? (cm_scache_t *)-1 : cm_data.rootSCachep));
- if (code != 0) {
- *reasonP = "unknown error";
- return -1;
- }
-
cm_InitDaemon(numBkgD);
afsi_log("cm_InitDaemon complete");
smb_AsyncStoreSize = cm_data.buf_blockSize;
else
smb_AsyncStoreSize = (dwValue & ~(cm_data.buf_blockSize-1));
- } else
+ } else
smb_AsyncStoreSize = CM_CONFIGDEFAULT_ASYNCSTORESIZE;
afsi_log("SMBAsyncStoreSize = %d", smb_AsyncStoreSize);
-
+
+ dummyLen = sizeof(DWORD);
+ code = RegQueryValueEx(parmKey, "SMBInterfaceEnabled", NULL, NULL,
+ (BYTE *) &dwValue, &dummyLen);
+ if (code == ERROR_SUCCESS)
+ smb_Enabled = dwValue ? 1 : 0;
+ afsi_log("SMBInterfaceEnabled = %d", smb_Enabled);
+
RegCloseKey (parmKey);
}
- /* Do this last so that we don't handle requests before init is done.
- * Here we initialize the SMB listener.
- */
- smb_Init(afsd_logp, smb_UseV3, numSvThreads, aMBfunc);
- afsi_log("smb_Init complete");
+ if ( smb_Enabled ) {
+ /* Do this last so that we don't handle requests before init is done.
+ * Here we initialize the SMB listener.
+ */
+ smb_Init(afsd_logp, smb_UseV3, numSvThreads, aMBfunc);
+ afsi_log("smb_Init complete");
+ } else {
+ smb_configureBackConnectionHostNames(FALSE);
+
+ if (msftSMBRedirectorSupportsExtendedTimeouts()) {
+ afsi_log("Microsoft SMB Redirector supports Extended Timeouts");
+ smb_configureExtendedSMBSessionTimeouts(FALSE);
+ }
+ afsi_log("smb_Init skipped");
+ }
return 0;
}
#endif
DWORD symOptions;
char functionName[MAXNAMELEN];
-
+
IMAGEHLP_MODULE Module;
IMAGEHLP_LINE Line;
-
+
STACKFRAME s;
IMAGEHLP_SYMBOL *pSym;
-
+
afsi_log_useTimestamp = 0;
-
+
pSym = (IMAGEHLP_SYMBOL *) GlobalAlloc(0, sizeof (IMAGEHLP_SYMBOL) + MAXNAMELEN);
-
+
memset( &s, '\0', sizeof s );
if (!SymInitialize(hProcess, NULL, 1) )
{
afsi_log("SymInitialize(): GetLastError() = %lu\n", GetLastError() );
-
+
SymCleanup( hProcess );
GlobalFree(pSym);
-
+
return;
}
-
+
symOptions = SymGetOptions();
symOptions |= SYMOPT_LOAD_LINES;
symOptions &= ~SYMOPT_UNDNAME;
SymSetOptions( symOptions );
-
+
/*
* init STACKFRAME for first call
* Notes: AddrModeFlat is just an assumption. I hate VDM debugging.
memset( pSym, '\0', sizeof (IMAGEHLP_SYMBOL) + MAXNAMELEN );
pSym->SizeOfStruct = sizeof (IMAGEHLP_SYMBOL);
pSym->MaxNameLength = MAXNAMELEN;
-
+
memset( &Line, '\0', sizeof Line );
Line.SizeOfStruct = sizeof Line;
-
+
memset( &Module, '\0', sizeof Module );
Module.SizeOfStruct = sizeof Module;
-
+
offset = 0;
-
+
afsi_log("\n--# FV EIP----- RetAddr- FramePtr StackPtr Symbol" );
-
+
for ( frameNum = 0; ; ++ frameNum )
{
/*
- * get next stack frame (StackWalk(), SymFunctionTableAccess(),
+ * get next stack frame (StackWalk(), SymFunctionTableAccess(),
* SymGetModuleBase()). if this returns ERROR_INVALID_ADDRESS (487) or
* ERROR_NOACCESS (998), you can assume that either you are done, or
* that the stack is so hosed that the next deeper frame could not be
* found.
*/
- if ( ! StackWalk( IMAGE_FILE_MACHINE_I386, hProcess, hThread, &s, c,
- NULL, SymFunctionTableAccess, SymGetModuleBase,
+ if ( ! StackWalk( IMAGE_FILE_MACHINE_I386, hProcess, hThread, &s, c,
+ NULL, SymFunctionTableAccess, SymGetModuleBase,
NULL ) )
break;
-
+
/* display its contents */
afsi_log("\n%3d %c%c %08lx %08lx %08lx %08lx ",
frameNum, s.Far? 'F': '.', s.Virtual? 'V': '.',
s.AddrPC.Offset, s.AddrReturn.Offset,
s.AddrFrame.Offset, s.AddrStack.Offset );
-
+
if ( s.AddrPC.Offset == 0 )
{
afsi_log("(-nosymbols- PC == 0)" );
}
else
- {
+ {
/* show procedure info from a valid PC */
if (!SymGetSymFromAddr(hProcess, s.AddrPC.Offset, &offset, pSym))
{
if ( GetLastError() != ERROR_INVALID_ADDRESS )
{
- afsi_log("SymGetSymFromAddr(): errno = %lu",
+ afsi_log("SymGetSymFromAddr(): errno = %lu",
GetLastError());
}
}
else
{
- UnDecorateSymbolName(pSym->Name, functionName, MAXNAMELEN,
+ UnDecorateSymbolName(pSym->Name, functionName, MAXNAMELEN,
UNDNAME_NAME_ONLY);
afsi_log("%s", functionName );
{
if (GetLastError() != ERROR_INVALID_ADDRESS)
{
- afsi_log("Error: SymGetLineFromAddr(): errno = %lu",
+ afsi_log("Error: SymGetLineFromAddr(): errno = %lu",
GetLastError());
}
}
else
{
- afsi_log(" Line: %s(%lu) %+ld bytes", Line.FileName,
+ afsi_log(" Line: %s(%lu) %+ld bytes", Line.FileName,
Line.LineNumber, offset);
}
}
-
+
/* no return address means no deeper stackframe */
if (s.AddrReturn.Offset == 0)
{
break;
}
}
-
+
if (GetLastError() != 0)
{
afsi_log("\nStackWalk(): errno = %lu\n", GetLastError());
}
-
+
SymCleanup(hProcess);
GlobalFree(pSym);
}
static HANDLE
OpenDumpFile(void)
{
+ char tmp[256];
char wd[256];
+ SYSTEMTIME st;
DWORD code;
- code = GetEnvironmentVariable("TEMP", wd, sizeof(wd));
- if ( code == 0 || code > sizeof(wd) )
+ code = GetEnvironmentVariable("TEMP", tmp, sizeof(tmp));
+ if ( code == 0 || code > sizeof(tmp) )
{
- if (!GetWindowsDirectory(wd, sizeof(wd)))
+ if (!GetWindowsDirectory(tmp, sizeof(tmp)))
return NULL;
}
- StringCbCatA(wd, sizeof(wd), "\\afsd.dmp");
+ GetLocalTime(&st);
+ StringCbPrintfA(wd, sizeof(wd),
+ "%s\\afsd-%04d-%02d-%02d-%02d_%02d_%02d.dmp", tmp,
+ st.wYear, st.wMonth, st.wDay, st.wHour, st.wMinute, st.wSecond);
return CreateFile( wd, GENERIC_WRITE, FILE_SHARE_READ, NULL,
CREATE_ALWAYS, FILE_FLAG_WRITE_THROUGH, NULL);
}
-void
+void
GenerateMiniDump(PEXCEPTION_POINTERS ep)
{
- if (IsDebuggerPresent())
- return;
+ if (IsDebuggerPresent())
+ return;
- if (ep == NULL)
+ if (ep == NULL)
{
// Generate exception to get proper context in dump
- __try
+ __try
{
RaiseException(DBG_CONTINUE, 0, 0, NULL);
- }
- __except(GenerateMiniDump(GetExceptionInformation()), EXCEPTION_CONTINUE_EXECUTION)
+ }
+ __except(GenerateMiniDump(GetExceptionInformation()), EXCEPTION_CONTINUE_EXECUTION)
{
}
- }
+ }
else
{
MINIDUMP_EXCEPTION_INFORMATION eInfo;
LONG __stdcall afsd_ExceptionFilter(EXCEPTION_POINTERS *ep)
{
CONTEXT context;
-#ifdef _DEBUG
+#ifdef _DEBUG
BOOL allocRequestBrk = FALSE;
-#endif
+#endif
HMODULE hLib = NULL;
-
- afsi_log("UnhandledException : code : 0x%x, address: 0x%x\n",
- ep->ExceptionRecord->ExceptionCode,
+
+ afsi_log("UnhandledException : code : 0x%x, address: 0x%x\n",
+ ep->ExceptionRecord->ExceptionCode,
ep->ExceptionRecord->ExceptionAddress);
-
+
#ifdef _DEBUG
- if (afsd_crtDbgBreakCurrent &&
+ if (afsd_crtDbgBreakCurrent &&
*afsd_crtDbgBreakCurrent == _CrtSetBreakAlloc(*afsd_crtDbgBreakCurrent))
- {
+ {
allocRequestBrk = TRUE;
afsi_log("Breaking on alloc request # %d\n", *afsd_crtDbgBreakCurrent);
}
#endif
-
+
/* save context if we want to print the stack information */
context = *ep->ContextRecord;
-
+
afsd_printStack(GetCurrentThread(), &context);
GenerateMiniDump(ep);
if (ep->ExceptionRecord->ExceptionCode == EXCEPTION_BREAKPOINT)
{
afsi_log("\nEXCEPTION_BREAKPOINT - continue execution ...\n");
-
+
#ifdef _DEBUG
if (allocRequestBrk)
{
afsd_crtDbgBreakCurrent++;
_CrtSetBreakAlloc(*afsd_crtDbgBreakCurrent);
}
-#endif
-#if defined(_X86)
+#endif
+#if defined(_X86)
ep->ContextRecord->Eip++;
#endif
#if defined(_AMD64_)
return EXCEPTION_CONTINUE_SEARCH;
}
}
-
+
void afsd_SetUnhandledExceptionFilter()
{
#ifndef NOTRACE
SetUnhandledExceptionFilter(afsd_ExceptionFilter);
#endif
}
-
+
#ifdef _DEBUG
void afsd_DbgBreakAllocInit()
{
memset(afsd_crtDbgBreaks, -1, sizeof(afsd_crtDbgBreaks));
afsd_crtDbgBreakCurrent = afsd_crtDbgBreaks;
}
-
+
void afsd_DbgBreakAdd(DWORD requestNumber)
{
int i;
git://git.openafs.org / openafs.git / blobdiff