/*
* 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 <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)
{
long cm_MapRPCError(long error, cm_req_t *reqp)
{
- if (error == 0)
+ if (error == 0)
return 0;
/* If we had to stop retrying, report our saved error code. */
error = et_to_sys_error(error);
- if (error < 0)
- error = CM_ERROR_TIMEDOUT;
- else if (error == EROFS)
+ if (error == RX_CALL_DEAD ||
+ error == RX_CALL_TIMEOUT ||
+ error == RX_CALL_BUSY ||
+ error == RX_MSGSIZE ||
+ error == VNOSERVICE)
+ error = CM_ERROR_TIMEDOUT;
+ else if (error == RX_CALL_IDLE)
+ error = EIO;
+ else if (error == RX_INVALID_OPERATION)
+ error = CM_ERROR_INVAL_NET_RESP;
+ else if (error < 0)
+ error = CM_ERROR_UNKNOWN;
+ else if (error == EINVAL)
+ error = CM_ERROR_INVAL;
+ else if (error == EROFS)
error = CM_ERROR_READONLY;
- else if (error == EACCES)
+ else if (error == EACCES)
error = CM_ERROR_NOACCESS;
- else if (error == EXDEV)
+ else if (error == EXDEV)
error = CM_ERROR_CROSSDEVLINK;
- else if (error == EEXIST)
+ else if (error == EEXIST)
error = CM_ERROR_EXISTS;
- else if (error == ENOTDIR)
+ else if (error == ENOTDIR)
error = CM_ERROR_NOTDIR;
else if (error == ENOENT)
error = CM_ERROR_NOSUCHFILE;
error = CM_ERROR_QUOTA;
else if (error == VNOVNODE)
error = CM_ERROR_BADFD;
+ else if (error == VSALVAGE || error == VOFFLINE)
+ error = CM_ERROR_ALLOFFLINE;
+ else if (error == VBUSY || error == VRESTARTING)
+ error = CM_ERROR_ALLBUSY;
else if (error == EISDIR)
return CM_ERROR_ISDIR;
return error;
long cm_MapRPCErrorRmdir(long error, cm_req_t *reqp)
{
- if (error == 0)
+ if (error == 0)
return 0;
/* If we had to stop retrying, report our saved error code. */
error = et_to_sys_error(error);
- if (error < 0)
- error = CM_ERROR_TIMEDOUT;
- else if (error == EROFS)
+ if (error == RX_CALL_DEAD ||
+ error == RX_CALL_TIMEOUT ||
+ error == RX_CALL_BUSY ||
+ error == RX_CALL_IDLE ||
+ error == RX_MSGSIZE ||
+ error == VNOSERVICE)
+ error = CM_ERROR_TIMEDOUT;
+ else if (error == VNOVNODE)
+ error = CM_ERROR_BADFD;
+ else if (error == VSALVAGE || error == VOFFLINE)
+ error = CM_ERROR_ALLOFFLINE;
+ else if (error == VBUSY || error == VRESTARTING)
+ error = CM_ERROR_ALLBUSY;
+ else if (error == RX_INVALID_OPERATION)
+ error = CM_ERROR_INVAL_NET_RESP;
+ else if (error < 0)
+ error = CM_ERROR_UNKNOWN;
+ else if (error == EROFS)
error = CM_ERROR_READONLY;
- else if (error == ENOTDIR)
+ else if (error == ENOTDIR)
error = CM_ERROR_NOTDIR;
- else if (error == EACCES)
+ else if (error == EACCES)
error = CM_ERROR_NOACCESS;
- else if (error == ENOENT)
+ else if (error == ENOENT)
error = CM_ERROR_NOSUCHFILE;
- else if (error == ENOTEMPTY
+ else if (error == EINVAL)
+ error = CM_ERROR_INVAL;
+ else if (error == ENOTEMPTY
+ || error == EEXIST
|| error == 17 /* AIX */
|| error == 66 /* SunOS 4, Digital UNIX */
|| error == 93 /* Solaris 2, IRIX */
|| error == 247) /* HP/UX */
error = CM_ERROR_NOTEMPTY;
return error;
-}
+}
long cm_MapVLRPCError(long error, cm_req_t *reqp)
{
error = et_to_sys_error(error);
- if (error < 0)
+ if (error == RX_CALL_DEAD ||
+ error == RX_CALL_TIMEOUT ||
+ error == RX_CALL_BUSY ||
+ error == RX_CALL_IDLE ||
+ error == RX_MSGSIZE ||
+ error == VNOSERVICE)
error = CM_ERROR_TIMEDOUT;
- else if (error == VL_NOENT || error == VL_BADNAME)
+ else if (error == RX_INVALID_OPERATION)
+ error = CM_ERROR_INVAL_NET_RESP;
+ else if (error == RX_RESTARTING)
+ error = CM_ERROR_ALLBUSY;
+ else if (error < 0)
+ error = CM_ERROR_UNKNOWN;
+ else if (error == EINVAL)
+ error = CM_ERROR_INVAL;
+ 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;
else tsp = (cm_space_t *) malloc(sizeof(cm_space_t));
(void) memset(tsp, 0, sizeof(cm_space_t));
lock_ReleaseWrite(&cm_utilsLock);
-
+
return tsp;
}
int sawDot = 0;
clientchar_t tc;
int charCount = 0;
-
+
if (namep == NULL || !namep[0])
return 0;
/*
* Number unparsing map for generating 8.3 names;
- * The version taken from DFS was on drugs.
+ * The version taken from DFS was on drugs.
* You can't include '&' and '@' in a file name.
*/
char cm_8Dot3Mapping[42] =
{'0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
- 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'J', 'K',
- 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U',
+ 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'J', 'K',
+ 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U',
'V', 'W', 'X', 'Y', 'Z', '_', '-', '$', '#', '!', '{', '}'
};
int cm_8Dot3MapSize = sizeof(cm_8Dot3Mapping);
*shortNameEndp = shortName;
}
+void cm_Gen8Dot3VolNameW(afs_uint32 cell, afs_uint32 volume,
+ clientchar_t *shortName, clientchar_t **shortNameEndp)
+{
+ clientchar_t number[12];
+ int i, nsize = 0;
+ int validExtension = 0;
+
+ /* Unparse the file's cell and volume numbers */
+ do {
+ number[nsize] = cm_8Dot3Mapping[cell % cm_8Dot3MapSize];
+ nsize++;
+ cell /= cm_8Dot3MapSize;
+ } while (cell);
+ do {
+ number[nsize] = cm_8Dot3Mapping[volume % cm_8Dot3MapSize];
+ nsize++;
+ volume /= cm_8Dot3MapSize;
+ } while (volume && nsize < 8);
+
+ /* Copy uniquifier characters */
+ for (i=0; i < nsize; i++) {
+ *shortName++ = number[i];
+ }
+
+ /* Add extension characters */
+ *shortName++ = '.'; /* copy dot */
+ *shortName++ = 'v';
+ *shortName++ = 'o';
+ *shortName++ = 'l';
+
+ /* Trailing null */
+ *shortName = 0;
+
+ if (shortNameEndp)
+ *shortNameEndp = shortName;
+}
+
/*! \brief Compare 'pattern' (containing metacharacters '*' and '?') with the file name 'name'.
\note This procedure works recursively calling itself.
\return BOOL : TRUE/FALSE (match/mistmatch)
*/
-static BOOL
-szWildCardMatchFileName(clientchar_t * pattern, clientchar_t * name, int casefold)
+static BOOL
+szWildCardMatchFileName(clientchar_t * pattern, clientchar_t * name, int casefold)
{
clientchar_t upattern[MAX_PATH];
clientchar_t uname[MAX_PATH];
/* do a case-folding search of the star name mask with the name in namep.
* Return 1 if we match, otherwise 0.
*/
-int cm_MatchMask(clientchar_t *namep, clientchar_t *maskp, int flags)
+int cm_MatchMask(clientchar_t *namep, clientchar_t *maskp, int flags)
{
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))
+ if ((flags & CM_FLAG_8DOT3) && !cm_Is8Dot3(namep))
return 0;
casefold = (flags & CM_FLAG_CASEFOLD) ? 1 : 0;
return FALSE;
}
-HANDLE
+HANDLE
cm_LoadAfsdHookLib(void)
{
char dllname[260];
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
+ LARGE_INTEGER ll;
+
+#ifdef _USE_32BIT_TIME_T
+ ll.QuadPart = UInt32x32To64(unixTime, 10000000) + 116444736000000000;
+#else
+ ll.QuadPart = unixTime * 10000000 + 116444736000000000;
+#endif
+ largeTimep->dwLowDateTime = ll.LowPart;
+ largeTimep->dwHighDateTime = ll.HighPart;
+}
+
+void cm_UnixTimeFromLargeSearchTime(time_t *unixTimep, FILETIME *largeTimep)
+{
+ // Note that LONGLONG is a 64-bit value
+ LARGE_INTEGER ll;
+
+ ll.HighPart = largeTimep->dwHighDateTime;
+ ll.LowPart = largeTimep->dwLowDateTime;
+
+ ll.QuadPart -= 116444736000000000;
+ ll.QuadPart /= 10000000;
+
+ *unixTimep = (time_t)ll.QuadPart;
+}
+
+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);
+}
+
+afs_uint32
+cm_NextHighestPowerOf2(afs_uint32 n)
+{
+ n--;
+ n |= n >> 1;
+ n |= n >> 2;
+ n |= n >> 4;
+ n |= n >> 8;
+ n |= n >> 16;
+ n++;
+ return n;
+}