#include <errno.h>
#include <windows.h>
+#include <shlwapi.h>
#include <winsock2.h>
-#ifndef EWOULDBLOCK
-#define EWOULDBLOCK WSAEWOULDBLOCK
-#define EINPROGRESS WSAEINPROGRESS
-#define EALREADY WSAEALREADY
-#define ENOTSOCK WSAENOTSOCK
-#define EDESTADDRREQ WSAEDESTADDRREQ
-#define EMSGSIZE WSAEMSGSIZE
-#define EPROTOTYPE WSAEPROTOTYPE
-#define ENOPROTOOPT WSAENOPROTOOPT
-#define EPROTONOSUPPORT WSAEPROTONOSUPPORT
-#define ESOCKTNOSUPPORT WSAESOCKTNOSUPPORT
-#define EOPNOTSUPP WSAEOPNOTSUPP
-#define EPFNOSUPPORT WSAEPFNOSUPPORT
-#define EAFNOSUPPORT WSAEAFNOSUPPORT
-#define EADDRINUSE WSAEADDRINUSE
-#define EADDRNOTAVAIL WSAEADDRNOTAVAIL
-#define ENETDOWN WSAENETDOWN
-#define ENETUNREACH WSAENETUNREACH
-#define ENETRESET WSAENETRESET
-#define ECONNABORTED WSAECONNABORTED
-#define ECONNRESET WSAECONNRESET
-#define ENOBUFS WSAENOBUFS
-#define EISCONN WSAEISCONN
-#define ENOTCONN WSAENOTCONN
-#define ESHUTDOWN WSAESHUTDOWN
-#define ETOOMANYREFS WSAETOOMANYREFS
-#define ETIMEDOUT WSAETIMEDOUT
-#define ECONNREFUSED WSAECONNREFUSED
-#ifdef ELOOP
-#undef ELOOP
-#endif
-#define ELOOP WSAELOOP
-#ifdef ENAMETOOLONG
-#undef ENAMETOOLONG
-#endif
-#define ENAMETOOLONG WSAENAMETOOLONG
-#define EHOSTDOWN WSAEHOSTDOWN
-#define EHOSTUNREACH WSAEHOSTUNREACH
-#ifdef ENOTEMPTY
-#undef ENOTEMPTY
-#endif
-#define ENOTEMPTY WSAENOTEMPTY
-#define EPROCLIM WSAEPROCLIM
-#define EUSERS WSAEUSERS
-#define EDQUOT WSAEDQUOT
-#define ESTALE WSAESTALE
-#define EREMOTE WSAEREMOTE
-#endif /* EWOULDBLOCK */
-#include <afs/unified_afs.h>
-
#include <string.h>
#include <malloc.h>
+#define STRSAFE_NO_DEPRECATE
+#include <strsafe.h>
+
#include "afsd.h"
#include <osi.h>
#include <rx/rx.h>
-#define STRSAFE_NO_DEPRECATE
-#include <strsafe.h>
-
+#include <afs/unified_afs.h>
static osi_once_t cm_utilsOnce;
static int et2sys[512];
+static DWORD cm_TlsRequestSlot = -1;
+
+void cm_utilsInit(void)
+{
+ if (osi_Once(&cm_utilsOnce)) {
+ lock_InitializeRWLock(&cm_utilsLock, "cm_utilsLock", LOCK_HIERARCHY_UTILS_GLOBAL);
+
+ cm_TlsRequestSlot = TlsAlloc();
+
+ osi_EndOnce(&cm_utilsOnce);
+ }
+}
+
+void cm_utilsCleanup(void)
+{
+ TlsFree(cm_TlsRequestSlot);
+}
+
void
init_et_to_sys_error(void)
{
error = et_to_sys_error(error);
- if (error < 0)
- error = CM_ERROR_TIMEDOUT;
+ if (error == RX_CALL_DEAD ||
+ error == RX_CALL_TIMEOUT ||
+ error == RX_RESTARTING)
+ error = CM_ERROR_RETRY;
+ else if (error < 0)
+ error = CM_ERROR_UNKNOWN;
else if (error == EROFS)
error = CM_ERROR_READONLY;
else if (error == EACCES)
error = CM_ERROR_QUOTA;
else if (error == VNOVNODE)
error = CM_ERROR_BADFD;
+ else if (error == VNOSERVICE || error == VSALVAGE || error == VOFFLINE)
+ error = CM_ERROR_ALLOFFLINE;
else if (error == EISDIR)
return CM_ERROR_ISDIR;
return error;
error = et_to_sys_error(error);
- if (error < 0)
- error = CM_ERROR_TIMEDOUT;
+ if (error == RX_CALL_DEAD ||
+ error == RX_CALL_TIMEOUT ||
+ error == RX_RESTARTING)
+ error = CM_ERROR_RETRY;
+ else if (error < 0)
+ error = CM_ERROR_UNKNOWN;
else if (error == EROFS)
error = CM_ERROR_READONLY;
else if (error == ENOTDIR)
error = et_to_sys_error(error);
- if (error < 0)
- error = CM_ERROR_TIMEDOUT;
+ if (error == RX_CALL_DEAD ||
+ error == RX_CALL_TIMEOUT ||
+ error == RX_RESTARTING)
+ error = CM_ERROR_RETRY;
+ else if (error < 0)
+ error = CM_ERROR_UNKNOWN;
else if (error == VL_NOENT || error == VL_BADNAME)
error = CM_ERROR_NOSUCHVOLUME;
return error;
{
cm_space_t *tsp;
- if (osi_Once(&cm_utilsOnce)) {
- lock_InitializeRWLock(&cm_utilsLock, "cm_utilsLock", LOCK_HIERARCHY_UTILS_GLOBAL);
- osi_EndOnce(&cm_utilsOnce);
- }
-
+ cm_utilsInit();
+
lock_ObtainWrite(&cm_utilsLock);
if (tsp = cm_spaceListp) {
cm_spaceListp = tsp->nextp;
int sawDot = 0;
clientchar_t tc;
int charCount = 0;
-
+
+ if (namep == NULL || !namep[0])
+ return 0;
+
/*
* can't have a leading dot;
* special case for . and ..
cm_ClientCharNext(p), FALSE))
return TRUE;
} /* endfor */
+ if (*pattern == '.' && *pattern_next == '\0') {
+ for (p = name; p && *p; p = cm_ClientCharNext(p))
+ if (*p == '.')
+ break;
+ if (p && *p)
+ return FALSE;
+ return TRUE;
+ }
return FALSE;
default:
*/
int cm_MatchMask(clientchar_t *namep, clientchar_t *maskp, int flags)
{
- clientchar_t * newmask;
- int i, j, star, qmark, casefold, retval;
+ clientchar_t *newmask, lastchar = _C('\0');
+ int i, j, casefold, retval;
+ int star = 0, qmark = 0, dot = 0;
/* make sure we only match 8.3 names, if requested */
if ((flags & CM_FLAG_8DOT3) && !cm_Is8Dot3(namep))
* for example the sequence "*?*?*?*"
* must be turned into the form "*"
*/
- newmask = (clientchar_t *)malloc((cm_ClientStrLen(maskp)+1)*sizeof(clientchar_t));
+ newmask = (clientchar_t *)malloc((cm_ClientStrLen(maskp)+2)*sizeof(clientchar_t));
for ( i=0, j=0, star=0, qmark=0; maskp[i]; i++) {
+ lastchar = maskp[i];
switch ( maskp[i] ) {
case '?':
case '>':
case '*':
star++;
break;
+ case '.':
+ dot++;
+ /* fallthrough */
default:
if ( star ) {
newmask[j++] = '*';
while ( qmark-- )
newmask[j++] = '?';
}
+ if (dot == 0 && lastchar == '<')
+ newmask[j++] = '.';
newmask[j++] = '\0';
retval = szWildCardMatchFileName(newmask, namep, casefold) ? 1:0;
return retval;
}
+BOOL
+cm_TargetPerceivedAsDirectory(const fschar_t *target)
+{
+ char * ext;
+
+ ext = PathFindExtension(target);
+ if (!ext[0])
+ return TRUE;
+
+ return FALSE;
+}
+
+HANDLE
+cm_LoadAfsdHookLib(void)
+{
+ char dllname[260];
+ char *p;
+ HANDLE hLib;
+
+ if (!GetModuleFileName(NULL, dllname, sizeof(dllname)))
+ return NULL;
+
+ p = strrchr(dllname, '\\');
+ if (p) {
+ p++;
+ strcpy(p, AFSD_HOOK_DLL);
+ hLib = LoadLibrary(dllname);
+ } else {
+ hLib = LoadLibrary(AFSD_HOOK_DLL);
+ }
+
+ return hLib;
+}
+
+/*
+ * Obtain the file info structure for the specified file.
+ * If a full path is not specified, the search order is the
+ * same as that used by LoadLibrary().
+ */
+BOOL
+cm_GetOSFileVersion (char *filename, LARGE_INTEGER *liVer)
+{
+ DWORD dwHandle;
+ DWORD dwSize;
+ char* pInfo = NULL;
+ BOOL rc;
+ UINT uLen;
+ void *pbuf;
+ VS_FIXEDFILEINFO vsf;
+
+ dwSize = GetFileVersionInfoSizeA(filename,&dwHandle);
+ if (dwSize == 0) {
+ rc = FALSE;
+ goto done;
+ }
+ pInfo = (char*)malloc(dwSize);
+ if (!pInfo) {
+ rc = FALSE;
+ goto done;
+ }
+ rc = GetFileVersionInfoA(filename, dwHandle, dwSize, pInfo);
+ if (!rc)
+ goto done;
+ rc = VerQueryValueA(pInfo,"\\",&pbuf, &uLen);
+ if (!rc)
+ goto done;
+ memcpy(&vsf, pbuf, sizeof(VS_FIXEDFILEINFO));
+
+ liVer->LowPart = vsf.dwFileVersionLS;
+ liVer->HighPart = vsf.dwFileVersionMS;
+ rc = TRUE;
+
+ done:
+ if (pInfo)
+ free(pInfo);
+ return rc;
+}
+
+typedef BOOL (WINAPI *LPFN_ISWOW64PROCESS) (HANDLE, PBOOL);
+typedef BOOL (WINAPI *LPFN_DISABLEWOW64FSREDIRECTION) (PVOID *);
+typedef BOOL (WINAPI *LPFN_REVERTWOW64FSREDIRECTION) (PVOID);
+
+BOOL msftSMBRedirectorSupportsExtendedTimeouts(void)
+{
+ static BOOL fChecked = FALSE;
+ static BOOL fSupportsExtendedTimeouts = FALSE;
+
+ if (!fChecked)
+ {
+ BOOL isWow64 = FALSE;
+ OSVERSIONINFOEX Version;
+ HANDLE h1 = NULL;
+ LPFN_ISWOW64PROCESS fnIsWow64Process = NULL;
+ LPFN_DISABLEWOW64FSREDIRECTION fnDisableWow64FsRedirection = NULL;
+ LPFN_REVERTWOW64FSREDIRECTION fnRevertWow64FsRedirection = NULL;
+ PVOID Wow64RedirectionState;
+ LARGE_INTEGER fvFile, fvHotFixMin;
+
+ h1 = GetModuleHandle("kernel32.dll"); /* no refcount increase */
+ /*
+ * If we don't find the fnIsWow64Process function then we
+ * are not running in a Wow64 environment
+ */
+ fnIsWow64Process =
+ (LPFN_ISWOW64PROCESS)GetProcAddress(h1, "IsWow64Process");
+
+ memset (&Version, 0x00, sizeof(Version));
+ Version.dwOSVersionInfoSize = sizeof(Version);
+ GetVersionEx((OSVERSIONINFO *) &Version);
+
+ /*
+ * Support is available as hot fixes / service packs on:
+ * XP SP2
+ * XP SP3
+ * 2003 and XP64 SP2
+ * Vista and 2008 SP2
+ * Win7 and 2008 R2
+ */
+ if (Version.dwPlatformId == VER_PLATFORM_WIN32_NT &&
+ Version.dwMajorVersion >= 5) {
+
+ /* 32-bit XP */
+ if (Version.dwMajorVersion == 5 &&
+ Version.dwMinorVersion == 1) {
+
+ fvHotFixMin.HighPart = (5 << 16) | 1;
+
+ switch (Version.wServicePackMajor) {
+ case 3:
+ fvHotFixMin.LowPart = (2600 << 16) | 5815;
+ break;
+ case 2:
+ fvHotFixMin.LowPart = (2600 << 16) | 3572;
+ break;
+ default:
+ fSupportsExtendedTimeouts = (Version.wServicePackMajor > 3);
+ goto checked;
+ }
+ }
+
+ /* 64-bit XP and Server 2003 */
+ else if (Version.dwMajorVersion == 5 &&
+ Version.dwMinorVersion == 2) {
+
+ fvHotFixMin.HighPart = (5 << 16) | 2;
+
+ switch (Version.wServicePackMajor) {
+ case 2:
+ fvHotFixMin.LowPart = (3790 << 16) | 4479;
+ break;
+ case 1:
+ fvHotFixMin.LowPart = (3790 << 16) | 3310;
+ break;
+ default:
+ fSupportsExtendedTimeouts = (Version.wServicePackMajor > 2);
+ goto checked;
+ }
+ }
+
+ /* Vista and Server 2008 */
+ else if (Version.dwMajorVersion == 6 &&
+ Version.dwMinorVersion == 0) {
+
+ fvHotFixMin.HighPart = (6 << 16) | 0;
+
+ switch (Version.wServicePackMajor) {
+ case 2:
+ fvHotFixMin.LowPart = (6002 << 16) | 18005;
+ break;
+ default:
+ fSupportsExtendedTimeouts = (Version.wServicePackMajor > 2);
+ goto checked;
+ }
+ }
+
+ /* Windows 7 and Server 2008 R2 and beyond */
+ else if (Version.dwMajorVersion > 6 ||
+ Version.dwMajorVersion == 6 &&
+ Version.dwMinorVersion >= 1) {
+ fSupportsExtendedTimeouts = TRUE;
+ goto checked;
+ }
+
+ /* If wow64, disable wow64 redirection and preserve the existing state */
+ if (fnIsWow64Process &&
+ fnIsWow64Process(GetCurrentProcess(), &isWow64) &&
+ isWow64) {
+ fnDisableWow64FsRedirection =
+ (LPFN_DISABLEWOW64FSREDIRECTION)GetProcAddress(h1, "Wow64DisableWow64FsRedirection");
+ fnRevertWow64FsRedirection =
+ (LPFN_REVERTWOW64FSREDIRECTION)GetProcAddress(h1, "Wow64RevertWow64FsRedirection");
+ fnDisableWow64FsRedirection(&Wow64RedirectionState);
+ }
+
+ if (cm_GetOSFileVersion("drivers\\mrxsmb.sys", &fvFile) ||
+ (fvFile.QuadPart >= fvHotFixMin.QuadPart))
+ fSupportsExtendedTimeouts = TRUE;
+
+ /* If wow64, restore the previous redirection state */
+ if (fnIsWow64Process && isWow64) {
+ fnRevertWow64FsRedirection(Wow64RedirectionState);
+ }
+ }
+ checked:
+ fChecked = TRUE;
+ }
+
+ return fSupportsExtendedTimeouts;
+}
+
+void cm_ResetServerPriority()
+{
+ void * p = TlsGetValue(cm_TlsRequestSlot);
+ if (p) {
+ free(p);
+ TlsSetValue(cm_TlsRequestSlot, NULL);
+ SetThreadPriority(GetCurrentThread(), THREAD_PRIORITY_NORMAL);
+ }
+}
+
+void cm_SetRequestStartTime()
+{
+ time_t * tp = TlsGetValue(cm_TlsRequestSlot);
+ if (!tp)
+ tp = malloc(sizeof(time_t));
+ if (tp) {
+ *tp = osi_Time();
+
+ if (!TlsSetValue(cm_TlsRequestSlot, tp))
+ free(tp);
+ }
+}
+
+void cm_UpdateServerPriority()
+{
+ time_t *tp = TlsGetValue(cm_TlsRequestSlot);
+
+ if (tp) {
+ time_t now = osi_Time();
+
+ /* Give one priority boost for each 15 seconds */
+ SetThreadPriority(GetCurrentThread(), (int)((now - *tp) / 15));
+ }
+}
+
+
+void cm_LargeSearchTimeFromUnixTime(FILETIME *largeTimep, time_t unixTime)
+{
+ // Note that LONGLONG is a 64-bit value
+ LONGLONG ll;
+
+ ll = Int32x32To64(unixTime, 10000000) + 116444736000000000;
+ largeTimep->dwLowDateTime = (DWORD)(ll & 0xFFFFFFFF);
+ largeTimep->dwHighDateTime = (DWORD)(ll >> 32);
+}
+
+void cm_UnixTimeFromLargeSearchTime(time_t *unixTimep, FILETIME *largeTimep)
+{
+ // Note that LONGLONG is a 64-bit value
+ LONGLONG ll;
+
+ ll = largeTimep->dwHighDateTime;
+ ll <<= 32;
+ ll += largeTimep->dwLowDateTime;
+
+ ll -= 116444736000000000;
+ ll /= 10000000;
+
+ *unixTimep = (DWORD)ll;
+}
+
+void cm_SearchTimeFromUnixTime(afs_uint32 *searchTimep, time_t unixTime)
+{
+ struct tm *ltp;
+ int dosDate;
+ int dosTime;
+ struct tm localJunk;
+ time_t t = unixTime;
+
+ ltp = localtime(&t);
+
+ /* if we fail, make up something */
+ if (!ltp) {
+ ltp = &localJunk;
+ localJunk.tm_year = 89 - 20;
+ localJunk.tm_mon = 4;
+ localJunk.tm_mday = 12;
+ localJunk.tm_hour = 0;
+ localJunk.tm_min = 0;
+ localJunk.tm_sec = 0;
+ }
+
+ dosDate = ((ltp->tm_year-80)<<9) | ((ltp->tm_mon+1) << 5) | (ltp->tm_mday);
+ dosTime = (ltp->tm_hour<<11) | (ltp->tm_min << 5) | (ltp->tm_sec / 2);
+ *searchTimep = (dosDate<<16) | dosTime;
+}
+
+void cm_UnixTimeFromSearchTime(time_t *unixTimep, afs_uint32 searchTime)
+{
+ unsigned short dosDate;
+ unsigned short dosTime;
+ struct tm localTm;
+
+ dosDate = (unsigned short) (searchTime & 0xffff);
+ dosTime = (unsigned short) ((searchTime >> 16) & 0xffff);
+
+ localTm.tm_year = 80 + ((dosDate>>9) & 0x3f);
+ localTm.tm_mon = ((dosDate >> 5) & 0xf) - 1; /* January is 0 in localTm */
+ localTm.tm_mday = (dosDate) & 0x1f;
+ localTm.tm_hour = (dosTime>>11) & 0x1f;
+ localTm.tm_min = (dosTime >> 5) & 0x3f;
+ localTm.tm_sec = (dosTime & 0x1f) * 2;
+ localTm.tm_isdst = -1; /* compute whether DST in effect */
+
+ *unixTimep = mktime(&localTm);
+}
git://git.openafs.org / openafs.git / blobdiff