#include <WINNT\afsreg.h>
#include "smb.h"
+#include "msrpc.h"
#include "lanahelper.h"
#define STRSAFE_NO_DEPRECATE
*/
time_t smb_localZero = 0;
-#define USE_NUMERIC_TIME_CONV 1
-
-#ifndef USE_NUMERIC_TIME_CONV
-/* Time difference for converting to kludge-GMT */
-afs_uint32 smb_NowTZ;
-#endif /* USE_NUMERIC_TIME_CONV */
-
char *smb_localNamep = NULL;
smb_vc_t *smb_allVCsp;
smb_waitingLockRequest_t *smb_allWaitingLocks;
-DWORD smb_TlsRequestSlot = -1;
-
/* forward decl */
void smb_DispatchPacket(smb_vc_t *vcp, smb_packet_t *inp, smb_packet_t *outp,
NCB *ncbp, raw_write_cont_t *rwcp);
reqp->flags |= CM_REQ_SOURCE_SMB;
}
-void smb_ResetServerPriority()
-{
- void * p = TlsGetValue(smb_TlsRequestSlot);
- if (p) {
- free(p);
- TlsSetValue(smb_TlsRequestSlot, NULL);
- SetThreadPriority(GetCurrentThread(), THREAD_PRIORITY_NORMAL);
- }
-}
-
-void smb_SetRequestStartTime()
-{
- time_t * tp = TlsGetValue(smb_TlsRequestSlot);
- if (!tp)
- tp = malloc(sizeof(time_t));
- if (tp) {
- *tp = osi_Time();
-
- if (!TlsSetValue(smb_TlsRequestSlot, tp))
- free(tp);
- }
-}
-
-void smb_UpdateServerPriority()
-{
- time_t *tp = TlsGetValue(smb_TlsRequestSlot);
-
- if (tp) {
- time_t now = osi_Time();
-
- /* Give one priority boost for each 15 seconds */
- SetThreadPriority(GetCurrentThread(), (int)((now - *tp) / 15));
- }
-}
-
-
const char * ncb_error_string(int code)
{
const char * s;
case 63:
return "RAP(63)NetWkStaGetInfo";
}
-}
+}
+
+char * myCrt_NmpipeDispatch(int i)
+{
+ switch(i) {
+ case SMB_TRANS_SET_NMPIPE_STATE:
+ return "SET NMPIPE STATE";
+
+ case SMB_TRANS_RAW_READ_NMPIPE:
+ return "RAW READ NMPIPE";
+
+ case SMB_TRANS_QUERY_NMPIPE_STATE:
+ return "QUERY NMPIPE STATE";
+
+ case SMB_TRANS_QUERY_NMPIPE_INFO:
+ return "QUERY NMPIPE INFO";
+
+ case SMB_TRANS_PEEK_NMPIPE:
+ return "PEEK NMPIPE";
+
+ case SMB_TRANS_TRANSACT_NMPIPE:
+ return "TRANSACT NMPIPE";
+
+ case SMB_TRANS_RAW_WRITE_NMPIPE:
+ return "WRITE NMPIPE";
+
+ case SMB_TRANS_READ_NMPIPE:
+ return "READ NMPIPE";
+
+ case SMB_TRANS_WRITE_NMPIPE:
+ return "WRITE NMPIPE";
+
+ case SMB_TRANS_WAIT_NMPIPE:
+ return "WAIT NMPIPE";
+
+ case SMB_TRANS_CALL_NMPIPE:
+ return "CALL NMPIPE";
+ }
+ return "(Unknown)";
+}
/* scache must be locked */
unsigned int smb_Attributes(cm_scache_t *scp)
FILETIME ft;
WORD wDate, wTime;
- smb_LargeSearchTimeFromUnixTime(&ft, unixTime);
+ cm_LargeSearchTimeFromUnixTime(&ft, unixTime);
if (!FileTimeToDosDateTime(&ft, &wDate, &wTime))
osi_Log1(smb_logp, "Failed to convert filetime to dos datetime: %d", GetLastError());
*pLastWriteTime -= (-bias * 60); /* Convert bias to seconds */
}
-#ifndef USE_NUMERIC_TIME_CONV
-/*
- * Calculate the difference (in seconds) between local time and GMT.
- * This enables us to convert file times to kludge-GMT.
- */
-static void
-smb_CalculateNowTZ()
+void smb_DosUTimeFromUnixTime(afs_uint32 *dosUTimep, time_t unixTime)
{
- time_t t;
- struct tm gmt_tm, local_tm;
- int days, hours, minutes, seconds;
-
- t = time(NULL);
- gmt_tm = *(gmtime(&t));
- local_tm = *(localtime(&t));
-
- days = local_tm.tm_yday - gmt_tm.tm_yday;
- hours = 24 * days + local_tm.tm_hour - gmt_tm.tm_hour;
- minutes = 60 * hours + local_tm.tm_min - gmt_tm.tm_min;
- seconds = 60 * minutes + local_tm.tm_sec - gmt_tm.tm_sec;
-
- smb_NowTZ = seconds;
+ time_t diff_t = unixTime - smb_localZero;
+#if defined(DEBUG) && !defined(_USE_32BIT_TIME_T)
+ osi_assertx(diff_t < _UI32_MAX, "time_t > _UI32_MAX");
+#endif
+ *dosUTimep = (afs_uint32)diff_t;
}
-#endif /* USE_NUMERIC_TIME_CONV */
-#ifdef USE_NUMERIC_TIME_CONV
-void smb_LargeSearchTimeFromUnixTime(FILETIME *largeTimep, time_t unixTime)
+void smb_UnixTimeFromDosUTime(time_t *unixTimep, afs_uint32 dosTime)
{
- // 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);
+ *unixTimep = dosTime + smb_localZero;
}
-#else
-void smb_LargeSearchTimeFromUnixTime(FILETIME *largeTimep, time_t unixTime)
+
+void smb_MarkAllVCsDead(smb_vc_t * exclude)
{
- struct tm *ltp;
- SYSTEMTIME stm;
- struct tm localJunk;
- time_t ersatz_unixTime;
+ smb_vc_t *vcp;
+ smb_vc_t **vcp_to_cleanup = NULL;
+ int n_to_cleanup = 0;
+ int i;
- /*
- * Must use kludge-GMT instead of real GMT.
- * kludge-GMT is computed by adding time zone difference to localtime.
- *
- * real GMT would be:
- * ltp = gmtime(&unixTime);
- */
- ersatz_unixTime = unixTime - smb_NowTZ;
- ltp = localtime(&ersatz_unixTime);
-
- /* 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;
- }
-
- stm.wYear = ltp->tm_year + 1900;
- stm.wMonth = ltp->tm_mon + 1;
- stm.wDayOfWeek = ltp->tm_wday;
- stm.wDay = ltp->tm_mday;
- stm.wHour = ltp->tm_hour;
- stm.wMinute = ltp->tm_min;
- stm.wSecond = ltp->tm_sec;
- stm.wMilliseconds = 0;
-
- SystemTimeToFileTime(&stm, largeTimep);
-}
-#endif /* USE_NUMERIC_TIME_CONV */
+ osi_Log1(smb_logp, "Marking all VCs as dead excluding %p", exclude);
-#ifdef USE_NUMERIC_TIME_CONV
-void smb_UnixTimeFromLargeSearchTime(time_t *unixTimep, FILETIME *largeTimep)
-{
- // Note that LONGLONG is a 64-bit value
- LONGLONG ll;
+ lock_ObtainWrite(&smb_globalLock); /* for dead_sessions[] */
+ lock_ObtainWrite(&smb_rctLock);
+ for (vcp = smb_allVCsp; vcp; vcp = vcp->nextp) {
- ll = largeTimep->dwHighDateTime;
- ll <<= 32;
- ll += largeTimep->dwLowDateTime;
+ if (vcp->magic != SMB_VC_MAGIC)
+ osi_panic("afsd: invalid smb_vc_t detected in smb_allVCsp",
+ __FILE__, __LINE__);
- ll -= 116444736000000000;
- ll /= 10000000;
+ if (vcp == exclude)
+ continue;
- *unixTimep = (DWORD)ll;
-}
-#else /* USE_NUMERIC_TIME_CONV */
-void smb_UnixTimeFromLargeSearchTime(time_t *unixTimep, FILETIME *largeTimep)
-{
- SYSTEMTIME stm;
- struct tm lt;
- long save_timezone;
-
- FileTimeToSystemTime(largeTimep, &stm);
-
- lt.tm_year = stm.wYear - 1900;
- lt.tm_mon = stm.wMonth - 1;
- lt.tm_wday = stm.wDayOfWeek;
- lt.tm_mday = stm.wDay;
- lt.tm_hour = stm.wHour;
- lt.tm_min = stm.wMinute;
- lt.tm_sec = stm.wSecond;
- lt.tm_isdst = -1;
-
- save_timezone = _timezone;
- _timezone += smb_NowTZ;
- *unixTimep = mktime(<);
- _timezone = save_timezone;
-}
-#endif /* USE_NUMERIC_TIME_CONV */
-
-void smb_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;
- }
+ lock_ObtainMutex(&vcp->mx);
+ if (!(vcp->flags & SMB_VCFLAG_ALREADYDEAD)) {
+ vcp->flags |= SMB_VCFLAG_ALREADYDEAD;
+ lock_ReleaseMutex(&vcp->mx);
+ dead_sessions[vcp->session] = TRUE;
+ } else {
+ lock_ReleaseMutex(&vcp->mx);
+ }
+ n_to_cleanup ++;
+ }
- 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;
-}
+ vcp_to_cleanup = malloc(sizeof(vcp_to_cleanup[0]) * n_to_cleanup);
+ i = 0;
+ for (vcp = smb_allVCsp; vcp; vcp = vcp->nextp) {
+ if (vcp == exclude)
+ continue;
-void smb_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);
-}
+ vcp_to_cleanup[i++] = vcp;
+ smb_HoldVCNoLock(vcp);
+ }
-void smb_DosUTimeFromUnixTime(afs_uint32 *dosUTimep, time_t unixTime)
-{
- time_t diff_t = unixTime - smb_localZero;
-#if defined(DEBUG) && !defined(_USE_32BIT_TIME_T)
- osi_assertx(diff_t < _UI32_MAX, "time_t > _UI32_MAX");
-#endif
- *dosUTimep = (afs_uint32)diff_t;
-}
+ osi_assert(i == n_to_cleanup);
-void smb_UnixTimeFromDosUTime(time_t *unixTimep, afs_uint32 dosTime)
-{
- *unixTimep = dosTime + smb_localZero;
+ lock_ReleaseWrite(&smb_rctLock);
+ lock_ReleaseWrite(&smb_globalLock);
+
+ for (i=0; i < n_to_cleanup; i++) {
+ smb_CleanupDeadVC(vcp_to_cleanup[i]);
+ smb_ReleaseVC(vcp_to_cleanup[i]);
+ vcp_to_cleanup[i] = 0;
+ }
+
+ free(vcp_to_cleanup);
}
#ifdef DEBUG_SMB_REFCOUNT
osi_panic("afsd: invalid smb_vc_t detected in smb_allVCsp",
__FILE__, __LINE__);
+ lock_ObtainMutex(&vcp->mx);
if (lsn == vcp->lsn && lana == vcp->lana &&
!(vcp->flags & SMB_VCFLAG_ALREADYDEAD)) {
+ lock_ReleaseMutex(&vcp->mx);
smb_HoldVCNoLock(vcp);
break;
}
+ lock_ReleaseMutex(&vcp->mx);
}
if (!vcp && (flags & SMB_FLAG_CREATE)) {
vcp = malloc(sizeof(*vcp));
static int smb_IsStarMask(clientchar_t *maskp)
{
- int i;
clientchar_t tc;
while (*maskp) {
free(tidp);
}
}
+ if (vcp)
+ smb_ReleaseVCNoLock(vcp);
if (!locked)
lock_ReleaseWrite(&smb_rctLock);
if (userp)
cm_ReleaseUser(userp);
- if (vcp)
- smb_ReleaseVCNoLock(vcp);
}
smb_user_t *smb_FindUID(smb_vc_t *vcp, unsigned short uid, int flags)
return fidp;
}
+
+/* Must not be called with scp->rw held because smb_ReleaseFID might be called */
#ifdef DEBUG_SMB_REFCOUNT
smb_fid_t *smb_FindFIDByScacheDbg(smb_vc_t *vcp, cm_scache_t * scp, char *file, long line)
#else
smb_fid_t *smb_FindFIDByScache(smb_vc_t *vcp, cm_scache_t * scp)
#endif
{
- smb_fid_t *fidp = NULL;
- int newFid = 0;
+ smb_fid_t *fidp = NULL, *nextp = NULL;
if (!scp)
return NULL;
+ /*
+ * If the fidp->scp changes out from under us then
+ * we must not grab a refCount. It means the *fidp
+ * was processed by smb_CloseFID() and the *fidp is
+ * no longer valid for use.
+ */
lock_ObtainWrite(&smb_rctLock);
- for(fidp = vcp->fidsp; fidp; fidp = (smb_fid_t *) osi_QNext(&fidp->q)) {
+ for(fidp = vcp->fidsp, (fidp ? fidp->refCount++ : 0); fidp; fidp = nextp, nextp = NULL) {
+ nextp = (smb_fid_t *) osi_QNext(&fidp->q);
+ if (nextp)
+ nextp->refCount++;
+
if (scp == fidp->scp) {
- fidp->refCount++;
- break;
+ lock_ReleaseWrite(&smb_rctLock);
+ lock_ObtainMutex(&fidp->mx);
+ lock_ObtainWrite(&smb_rctLock);
+ if (scp == fidp->scp) {
+ lock_ReleaseMutex(&fidp->mx);
+ break;
+ }
+ lock_ReleaseMutex(&fidp->mx);
+ }
+
+ if (fidp->refCount > 1) {
+ fidp->refCount--;
+ } else {
+ lock_ReleaseWrite(&smb_rctLock);
+ smb_ReleaseFID(fidp);
+ lock_ObtainWrite(&smb_rctLock);
+ }
+ }
+
+ if (nextp) {
+ if (nextp->refCount > 1) {
+ nextp->refCount--;
+ } else {
+ lock_ReleaseWrite(&smb_rctLock);
+ smb_ReleaseFID(nextp);
+ lock_ObtainWrite(&smb_rctLock);
}
}
+
#ifdef DEBUG_SMB_REFCOUNT
if (fidp) {
afsi_log("%s:%d smb_FindFIDByScache fidp 0x%p ref %d", file, line, fidp, fidp->refCount);
}
#endif
lock_ReleaseWrite(&smb_rctLock);
- return fidp;
+ return (fidp);
}
#ifdef DEBUG_SMB_REFCOUNT
}
-/* smb_ReleaseFID cannot be called while an cm_scache_t mutex lock is held */
-/* the sm_fid_t->mx and smb_rctLock must not be held */
+/* smb_ReleaseFID cannot be called while a cm_scache_t rwlock is held */
+/* the smb_fid_t->mx and smb_rctLock must not be held */
#ifdef DEBUG_SMB_REFCOUNT
void smb_ReleaseFIDDbg(smb_fid_t *fidp, char *file, long line)
#else
if (ioctlp->ioctl.outAllocp)
free(ioctlp->ioctl.outAllocp);
free(ioctlp);
- }
+ }
+
+ smb_CleanupRPCFid(fidp);
+
lock_ReleaseMutex(&fidp->mx);
lock_FinalizeMutex(&fidp->mx);
free(fidp);
return 1;
}
- if (cm_ClientStrCmpIA(shareName, _C("IPC$")) == 0 ||
- cm_ClientStrCmpIA(shareName, _C("srvsvc")) == 0 ||
- cm_ClientStrCmpIA(shareName, _C("wkssvc")) == 0 ||
+ if (MSRPC_IsWellKnownService(shareName) ||
cm_ClientStrCmpIA(shareName, _C(SMB_IOCTL_FILENAME_NOSLASH)) == 0 ||
cm_ClientStrCmpIA(shareName, _C("DESKTOP.INI")) == 0
) {
}
/* Get the full name for this cell */
cellname = cm_ClientStringToFsStringAlloc(p, -1, NULL);
- code = cm_SearchCellFile(cellname, ftemp, 0, 0);
+ code = cm_SearchCellRegistry(1, cellname, ftemp, 0, 0, 0);
+ if (code && code != CM_ERROR_FORCE_DNS_LOOKUP)
+ code = cm_SearchCellFile(cellname, ftemp, 0, 0);
#ifdef AFS_AFSDB_ENV
if (code && cm_dnsEnabled) {
int ttl;
clientchar_t *inPathp)
{
clientchar_t *lastSlashp;
-
+ clientchar_t *streamp = NULL;
+ clientchar_t *typep = NULL;
+
lastSlashp = cm_ClientStrRChr(inPathp, '\\');
- if (lastComponentp)
+ if (lastComponentp) {
*lastComponentp = lastSlashp;
+ }
if (lastSlashp) {
+ /*
+ * If the name contains a stream name and a type
+ * and the stream name is the nul-string and the
+ * type is $DATA, then strip "::$DATA" from the
+ * last component string that is returned.
+ *
+ * Otherwise, return the full path name and allow
+ * the file name to be rejected because it contains
+ * a colon.
+ */
+ typep = cm_ClientStrRChr(lastSlashp, L':');
+ if (typep && cm_ClientStrCmpI(typep, L":$DATA") == 0) {
+ *typep = '\0';
+ streamp = cm_ClientStrRChr(lastSlashp, L':');
+ if (streamp && cm_ClientStrCmpI(streamp, L":") == 0)
+ *streamp = '\0';
+ else
+ *typep = ':';
+ }
+
while (1) {
if (inPathp == lastSlashp)
break;
char **chainpp, int flags)
{
size_t cb;
+ afs_uint32 type = *inp++;
- if (*inp++ != 0x4)
- return NULL;
+ /*
+ * The first byte specifies the type of the input string.
+ * CIFS TR 1.0 3.2.10. This function only parses null terminated
+ * strings.
+ */
+ switch (type) {
+ /* Length Counted */
+ case 0x1: /* Data Block */
+ case 0x5: /* Variable Block */
+ cb = *inp++ << 16 | *inp++;
+ break;
+
+ /* Null-terminated string */
+ case 0x4: /* ASCII */
+ case 0x3: /* Pathname */
+ case 0x2: /* Dialect */
+ cb = sizeof(pktp->data) - (inp - pktp->data);
+ if (inp < pktp->data || inp >= pktp->data + sizeof(pktp->data)) {
+#ifdef DEBUG_UNICODE
+ DebugBreak();
+#endif
+ cb = sizeof(pktp->data);
+ }
+ break;
+
+ default:
+ return NULL; /* invalid input */
+ }
#ifdef SMB_UNICODE
- if (!WANTS_UNICODE(pktp))
+ if (type == 0x2 /* Dialect */ || !WANTS_UNICODE(pktp))
flags |= SMB_STRF_FORCEASCII;
#endif
- cb = sizeof(pktp->data) - (inp - pktp->data);
- if (inp < pktp->data || inp >= pktp->data + sizeof(pktp->data)) {
-#ifdef DEBUG_UNICODE
- DebugBreak();
-#endif
- cb = sizeof(pktp->data);
- }
return smb_ParseStringBuf(pktp->data, &pktp->stringsp, inp, &cb, chainpp, flags);
}
#endif /* COMMENT */
}
else if (code == CM_ERROR_BADSHARENAME) {
- NTStatus = 0xC00000CCL; /* Bad network name */
+ NTStatus = 0xC00000BEL; /* Bad network path (server valid, share bad) */
}
else if (code == CM_ERROR_NOIPC) {
#ifdef COMMENT
NTStatus = 0xC0000033L; /* Object name invalid */
}
else if (code == CM_ERROR_WOULDBLOCK) {
- NTStatus = 0xC0000055L; /* Lock not granted */
+ NTStatus = 0xC00000D8L; /* Can't wait */
}
else if (code == CM_ERROR_SHARING_VIOLATION) {
NTStatus = 0xC0000043L; /* Sharing violation */
NTStatus = 0xC000022DL; /* Retry */
}
else if (code == CM_ERROR_ALLOFFLINE || code == CM_ERROR_ALLDOWN) {
- NTStatus = 0xC00000BEL; /* Bad Network Path */
+ NTStatus = 0xC000003AL; /* Path not found */
}
else if (code >= ERROR_TABLE_BASE_RXK && code < ERROR_TABLE_BASE_RXK + 256) {
NTStatus = 0xC0000322L; /* No Kerberos key */
}
else if (code == CM_ERROR_LOCK_NOT_GRANTED) {
NTStatus = 0xC0000055L; /* Lock Not Granted */
- } else {
+ }
+ else if (code == ENOMEM) {
+ NTStatus = 0xC0000017L; /* Out of Memory */
+ }
+ else if (code == CM_ERROR_RPC_MOREDATA) {
+ NTStatus = 0x80000005L; /* Buffer overflow */
+ }
+ else {
NTStatus = 0xC0982001L; /* SMB non-specific error */
}
osi_Log2(smb_logp, "SMB SEND code %lX as NT %lX", code, NTStatus);
}
+/*
+ * NTSTATUS <-> Win32 Error Translation
+ * http://support.microsoft.com/kb/113996
+ */
+void smb_MapWin32Error(long code, unsigned long *Win32Ep)
+{
+ unsigned long Win32E;
+
+ /* map CM_ERROR_* errors to Win32 32-bit error codes */
+ if (code == 0) {
+ Win32E = 0;
+ }
+ else if (code == CM_ERROR_NOSUCHCELL) {
+ Win32E = ERROR_FILE_NOT_FOUND; /* No such file */
+ }
+ else if (code == CM_ERROR_NOSUCHVOLUME) {
+ Win32E = ERROR_FILE_NOT_FOUND; /* No such file */
+ }
+ else if (code == CM_ERROR_TIMEDOUT) {
+#ifdef COMMENT
+ Win32E = ERROR_SHARING_PAUSED; /* Sharing Paused */
+#else
+ Win32E = ERROR_UNEXP_NET_ERR; /* Timeout */
+#endif
+ }
+ else if (code == CM_ERROR_RETRY) {
+ Win32E = ERROR_RETRY; /* Retry */
+ }
+ else if (code == CM_ERROR_NOACCESS) {
+ Win32E = ERROR_ACCESS_DENIED; /* Access denied */
+ }
+ else if (code == CM_ERROR_READONLY) {
+ Win32E = ERROR_WRITE_PROTECT; /* Write protected */
+ }
+ else if (code == CM_ERROR_NOSUCHFILE ||
+ code == CM_ERROR_BPLUS_NOMATCH) {
+ Win32E = ERROR_FILE_NOT_FOUND; /* No such file */
+ }
+ else if (code == CM_ERROR_NOSUCHPATH) {
+ Win32E = ERROR_PATH_NOT_FOUND; /* Object path not found */
+ }
+ else if (code == CM_ERROR_TOOBIG) {
+ Win32E = ERROR_BAD_EXE_FORMAT; /* Invalid image format */
+ }
+ else if (code == CM_ERROR_INVAL) {
+ Win32E = ERROR_INVALID_PARAMETER;/* Invalid parameter */
+ }
+ else if (code == CM_ERROR_BADFD) {
+ Win32E = ERROR_INVALID_HANDLE; /* Invalid handle */
+ }
+ else if (code == CM_ERROR_BADFDOP) {
+ Win32E = ERROR_ACCESS_DENIED; /* Access denied */
+ }
+ else if (code == CM_ERROR_EXISTS) {
+ Win32E = ERROR_ALREADY_EXISTS; /* Object name collision */
+ }
+ else if (code == CM_ERROR_NOTEMPTY) {
+ Win32E = ERROR_DIR_NOT_EMPTY; /* Directory not empty */
+ }
+ else if (code == CM_ERROR_CROSSDEVLINK) {
+ Win32E = ERROR_NOT_SAME_DEVICE; /* Not same device */
+ }
+ else if (code == CM_ERROR_NOTDIR) {
+ Win32E = ERROR_DIRECTORY; /* Not a directory */
+ }
+ else if (code == CM_ERROR_ISDIR) {
+ Win32E = ERROR_ACCESS_DENIED; /* File is a directory */
+ }
+ else if (code == CM_ERROR_BADOP) {
+ Win32E = ERROR_NOT_SUPPORTED; /* Not supported */
+ }
+ else if (code == CM_ERROR_BADSHARENAME) {
+ Win32E = ERROR_BAD_NETPATH; /* Bad network path (server valid, share bad) */
+ }
+ else if (code == CM_ERROR_NOIPC) {
+#ifdef COMMENT
+ Win32E = ERROR_ACCESS_DENIED; /* Access Denied */
+#else
+ Win32E = ERROR_REM_NOT_LIST; /* Remote Resources */
+#endif
+ }
+ else if (code == CM_ERROR_CLOCKSKEW) {
+ Win32E = ERROR_TIME_SKEW; /* Time difference at DC */
+ }
+ else if (code == CM_ERROR_BADTID) {
+ Win32E = ERROR_FILE_NOT_FOUND; /* SMB bad TID */
+ }
+ else if (code == CM_ERROR_USESTD) {
+ Win32E = ERROR_ACCESS_DENIED; /* SMB use standard */
+ }
+ else if (code == CM_ERROR_QUOTA) {
+ Win32E = ERROR_NOT_ENOUGH_QUOTA;/* Quota exceeded */
+ }
+ else if (code == CM_ERROR_SPACE) {
+ Win32E = ERROR_DISK_FULL; /* Disk full */
+ }
+ else if (code == CM_ERROR_ATSYS) {
+ Win32E = ERROR_INVALID_NAME; /* Object name invalid */
+ }
+ else if (code == CM_ERROR_BADNTFILENAME) {
+ Win32E = ERROR_INVALID_NAME; /* Object name invalid */
+ }
+ else if (code == CM_ERROR_WOULDBLOCK) {
+ Win32E = WAIT_TIMEOUT; /* Can't wait */
+ }
+ else if (code == CM_ERROR_SHARING_VIOLATION) {
+ Win32E = ERROR_SHARING_VIOLATION; /* Sharing violation */
+ }
+ else if (code == CM_ERROR_LOCK_CONFLICT) {
+ Win32E = ERROR_LOCK_VIOLATION; /* Lock conflict */
+ }
+ else if (code == CM_ERROR_PARTIALWRITE) {
+ Win32E = ERROR_DISK_FULL; /* Disk full */
+ }
+ else if (code == CM_ERROR_BUFFERTOOSMALL) {
+ Win32E = ERROR_INSUFFICIENT_BUFFER; /* Buffer too small */
+ }
+ else if (code == CM_ERROR_AMBIGUOUS_FILENAME) {
+ Win32E = ERROR_ALREADY_EXISTS; /* Object name collision */
+ }
+ else if (code == CM_ERROR_BADPASSWORD) {
+ Win32E = ERROR_LOGON_FAILURE; /* unknown username or bad password */
+ }
+ else if (code == CM_ERROR_BADLOGONTYPE) {
+ Win32E = ERROR_INVALID_LOGON_TYPE; /* logon type not granted */
+ }
+ else if (code == CM_ERROR_GSSCONTINUE) {
+ Win32E = ERROR_MORE_DATA; /* more processing required */
+ }
+ else if (code == CM_ERROR_TOO_MANY_SYMLINKS) {
+#ifdef COMMENT
+ Win32E = ERROR_CANT_RESOLVE_FILENAME; /* reparse point not resolved */
+#else
+ Win32E = ERROR_ACCESS_DENIED; /* Access Denied */
+#endif
+ }
+ else if (code == CM_ERROR_PATH_NOT_COVERED) {
+ Win32E = ERROR_HOST_UNREACHABLE; /* Path Not Covered */
+ }
+ else if (code == CM_ERROR_ALLBUSY) {
+ Win32E = ERROR_RETRY; /* Retry */
+ }
+ else if (code == CM_ERROR_ALLOFFLINE || code == CM_ERROR_ALLDOWN) {
+ Win32E = ERROR_HOST_UNREACHABLE; /* Path not found */
+ }
+ else if (code >= ERROR_TABLE_BASE_RXK && code < ERROR_TABLE_BASE_RXK + 256) {
+ Win32E = SEC_E_NO_KERB_KEY; /* No Kerberos key */
+ }
+ else if (code == CM_ERROR_BAD_LEVEL) {
+ Win32E = ERROR_INVALID_LEVEL; /* Invalid Level */
+ }
+ else if (code == CM_ERROR_RANGE_NOT_LOCKED) {
+ Win32E = ERROR_NOT_LOCKED; /* Range Not Locked */
+ }
+ else if (code == CM_ERROR_NOSUCHDEVICE) {
+ Win32E = ERROR_FILE_NOT_FOUND; /* No Such Device */
+ }
+ else if (code == CM_ERROR_LOCK_NOT_GRANTED) {
+ Win32E = ERROR_LOCK_VIOLATION; /* Lock Not Granted */
+ }
+ else if (code == ENOMEM) {
+ Win32E = ERROR_NOT_ENOUGH_MEMORY; /* Out of Memory */
+ }
+ else if (code == CM_ERROR_RPC_MOREDATA) {
+ Win32E = ERROR_MORE_DATA; /* Buffer overflow */
+ }
+ else {
+ Win32E = ERROR_GEN_FAILURE; /* SMB non-specific error */
+ }
+
+ *Win32Ep = Win32E;
+ osi_Log2(smb_logp, "SMB SEND code %lX as Win32 %lX", code, Win32E);
+}
+
void smb_MapCoreError(long code, smb_vc_t *vcp, unsigned short *scodep,
unsigned char *classp)
{
if (!fidp)
goto send1;
- if (fidp->scp && (fidp->scp->flags & CM_SCACHEFLAG_DELETED)) {
+ lock_ObtainMutex(&fidp->mx);
+ if (!fidp->scp) {
+ lock_ReleaseMutex(&fidp->mx);
+ smb_ReleaseFID(fidp);
+ return CM_ERROR_BADFD;
+ }
+
+ if (fidp->scp->flags & CM_SCACHEFLAG_DELETED) {
+ lock_ReleaseMutex(&fidp->mx);
smb_CloseFID(vcp, fidp, NULL, 0);
code = CM_ERROR_NOSUCHFILE;
goto send1a;
}
-
pid = smbp->pid;
{
LARGE_INTEGER LOffset, LLength;
lock_ReleaseWrite(&fidp->scp->rw);
}
if (code) {
+ lock_ReleaseMutex(&fidp->mx);
goto send1a;
}
smb_RawBufs = *(char **)smb_RawBufs;
}
lock_ReleaseMutex(&smb_RawBufLock);
- if (!rawBuf)
+ if (!rawBuf) {
+ lock_ReleaseMutex(&fidp->mx);
goto send1a;
+ }
- lock_ObtainMutex(&fidp->mx);
if (fidp->flags & SMB_FID_IOCTL)
{
- lock_ReleaseMutex(&fidp->mx);
rc = smb_IoctlReadRaw(fidp, vcp, inp, outp);
if (rawBuf) {
/* Give back raw buffer */
smb_SetSMBParmLong(outp, 9, caps);
time(&unixTime);
- smb_SearchTimeFromUnixTime(&dosTime, unixTime);
+ cm_SearchTimeFromUnixTime(&dosTime, unixTime);
smb_SetSMBParmLong(outp, 11, LOWORD(dosTime));/* server time */
smb_SetSMBParmLong(outp, 13, HIWORD(dosTime));/* server date */
smb_SetSMBParm(outp, 6, 1); /* next 2: session key */
smb_SetSMBParm(outp, 7, 1);
time(&unixTime);
- smb_SearchTimeFromUnixTime(&dosTime, unixTime);
+ cm_SearchTimeFromUnixTime(&dosTime, unixTime);
smb_SetSMBParm(outp, 8, LOWORD(dosTime)); /* server time */
smb_SetSMBParm(outp, 9, HIWORD(dosTime)); /* server date */
myTime.tm_sec = 0;
smb_localZero = mktime(&myTime);
-#ifndef USE_NUMERIC_TIME_CONV
- smb_CalculateNowTZ();
-#endif /* USE_NUMERIC_TIME_CONV */
#ifdef AFS_FREELANCE
if ( smb_localZero != old_localZero )
cm_noteLocalMountPointChange();
if (wl->state == SMB_WAITINGLOCKSTATE_DONE)
cm_Unlock(scp, wlRequest->lockType, wl->LOffset,
- wl->LLength, wl->key, NULL, &req);
+ wl->LLength, wl->key, 0, NULL, &req);
osi_QRemove((osi_queue_t **) &wlRequest->locks, &wl->q);
char *tbp;
tbp = smb_GetSMBData(inp, NULL);
pathp = smb_ParseASCIIBlock(inp, tbp, &tbp, SMB_STRF_ANSIPATH);
+ if (!pathp)
+ return CM_ERROR_BADSMB;
}
tp = cm_ClientStrRChr(pathp, '\\');
if (!tp)
tp = smb_GetSMBData(inp, NULL);
pathp = smb_ParseASCIIBlock(inp, tp, &tp,
SMB_STRF_ANSIPATH|SMB_STRF_FORCEASCII);
- osi_assertx(pathp != NULL, "null path");
+ if (!pathp)
+ return CM_ERROR_BADSMB;
statBlockp = smb_ParseVblBlock(tp, &tp, &statLen);
osi_assertx(statBlockp != NULL, "null statBlock");
if (statLen == 0) {
*dptr++ = attr;
/* get dos time */
- smb_SearchTimeFromUnixTime(&dosTime, scp->clientModTime);
+ cm_SearchTimeFromUnixTime(&dosTime, scp->clientModTime);
/* copy out time */
shortTemp = (unsigned short) (dosTime & 0xffff);
tp = smb_GetSMBData(inp, NULL);
pathp = smb_ParseASCIIBlock(inp, tp, &tp,
SMB_STRF_ANSIPATH|SMB_STRF_FORCEASCII);
- inCookiep = smb_ParseVblBlock(tp, &tp, &dataLength);
+ if (!pathp)
+ return CM_ERROR_BADSMB;
- /* bail out if request looks bad */
- if (!tp || !pathp) {
+ inCookiep = smb_ParseVblBlock(tp, &tp, &dataLength);
+ if (!tp)
return CM_ERROR_BADSMB;
- }
/* We can handle long names */
if (vcp->flags & SMB_VCFLAG_USENT)
if ( WANTS_DFS_PATHNAMES(inp) || pnc )
return CM_ERROR_PATH_NOT_COVERED;
else
- return CM_ERROR_BADSHARENAME;
+ return CM_ERROR_NOSUCHPATH;
}
#endif /* DFS_SUPPORT */
bufferp = NULL;
}
lock_ReleaseWrite(&scp->rw);
- code = buf_Get(scp, &thyper, &bufferp);
+ code = buf_Get(scp, &thyper, &req, &bufferp);
lock_ObtainMutex(&dsp->mx);
/* now, if we're doing a star match, do bulk fetching of all of
pdata = smb_GetSMBData(inp, NULL);
pathp = smb_ParseASCIIBlock(inp, pdata, NULL, SMB_STRF_ANSIPATH);
if (!pathp)
- return CM_ERROR_BADFD;
+ return CM_ERROR_BADSMB;
osi_Log1(smb_logp, "SMB receive check path %S",
osi_LogSaveClientString(smb_logp, pathp));
if ( WANTS_DFS_PATHNAMES(inp) || pnc )
return CM_ERROR_PATH_NOT_COVERED;
else
- return CM_ERROR_BADSHARENAME;
+ return CM_ERROR_NOSUCHPATH;
}
#endif /* DFS_SUPPORT */
if ( WANTS_DFS_PATHNAMES(inp) || pnc )
return CM_ERROR_PATH_NOT_COVERED;
else
- return CM_ERROR_BADSHARENAME;
+ return CM_ERROR_NOSUCHPATH;
}
#endif /* DFS_SUPPORT */
if ( WANTS_DFS_PATHNAMES(inp) || pnc )
return CM_ERROR_PATH_NOT_COVERED;
else
- return CM_ERROR_BADSHARENAME;
+ return CM_ERROR_NOSUCHPATH;
} else
#endif /* DFS_SUPPORT */
if (dscp->fileType == CM_SCACHETYPE_MOUNTPOINT && !dscp->mountRootFid.volume)
if ( WANTS_DFS_PATHNAMES(inp) || pnc )
return CM_ERROR_PATH_NOT_COVERED;
else
- return CM_ERROR_BADSHARENAME;
+ return CM_ERROR_NOSUCHPATH;
}
#endif /* DFS_SUPPORT */
datap = smb_GetSMBData(inp, NULL);
pathp = smb_ParseASCIIBlock(inp, datap, NULL, SMB_STRF_ANSIPATH);
+ if (!pathp)
+ return CM_ERROR_BADSMB;
osi_Log1(smb_logp, "SMB receive open file [%S]", osi_LogSaveClientString(smb_logp, pathp));
}
#endif
+ share = smb_GetSMBParm(inp, 0);
+ attribute = smb_GetSMBParm(inp, 1);
+
+ spacep = inp->spacep;
+ /* smb_StripLastComponent will strip "::$DATA" if present */
+ smb_StripLastComponent(spacep->wdata, &lastNamep, pathp);
+
if (!cm_IsValidClientString(pathp)) {
#ifdef DEBUG
clientchar_t * hexp;
return CM_ERROR_BADNTFILENAME;
}
- share = smb_GetSMBParm(inp, 0);
- attribute = smb_GetSMBParm(inp, 1);
-
- spacep = inp->spacep;
- smb_StripLastComponent(spacep->wdata, &lastNamep, pathp);
if (lastNamep && cm_ClientStrCmp(lastNamep, _C(SMB_IOCTL_FILENAME)) == 0) {
/* special case magic file name for receiving IOCTL requests
* (since IOCTL calls themselves aren't getting through).
if ( WANTS_DFS_PATHNAMES(inp) || pnc )
return CM_ERROR_PATH_NOT_COVERED;
else
- return CM_ERROR_BADSHARENAME;
+ return CM_ERROR_NOSUCHPATH;
}
#endif /* DFS_SUPPORT */
fidp = smb_FindFID(vcp, 0, SMB_FLAG_CREATE);
osi_assertx(fidp, "null smb_fid_t");
- /* save a pointer to the vnode */
- fidp->scp = scp;
- osi_Log2(smb_logp,"smb_ReceiveCoreOpen fidp 0x%p scp 0x%p", fidp, scp);
- lock_ObtainWrite(&scp->rw);
- scp->flags |= CM_SCACHEFLAG_SMB_FID;
- lock_ReleaseWrite(&scp->rw);
-
- /* and the user */
- cm_HoldUser(userp);
- fidp->userp = userp;
-
lock_ObtainMutex(&fidp->mx);
if ((share & 0xf) == 0)
fidp->flags |= SMB_FID_OPENREAD_LISTDIR;
fidp->flags |= SMB_FID_OPENWRITE;
else
fidp->flags |= (SMB_FID_OPENREAD_LISTDIR | SMB_FID_OPENWRITE);
- lock_ReleaseMutex(&fidp->mx);
- lock_ObtainRead(&scp->rw);
+ /* save the user */
+ cm_HoldUser(userp);
+ fidp->userp = userp;
+
+ /* and a pointer to the vnode */
+ fidp->scp = scp;
+ osi_Log2(smb_logp,"smb_ReceiveCoreOpen fidp 0x%p scp 0x%p", fidp, scp);
+ lock_ObtainWrite(&scp->rw);
+ scp->flags |= CM_SCACHEFLAG_SMB_FID;
+
smb_SetSMBParm(outp, 0, fidp->fid);
smb_SetSMBParm(outp, 1, smb_Attributes(scp));
smb_DosUTimeFromUnixTime(&dosTime, scp->clientModTime);
/* pass the open mode back; XXXX add access checks */
smb_SetSMBParm(outp, 6, (share & 0xf));
smb_SetSMBDataLength(outp, 0);
+ lock_ReleaseMutex(&fidp->mx);
lock_ReleaseRead(&scp->rw);
/* notify open */
tp = smb_GetSMBData(inp, NULL);
pathp = smb_ParseASCIIBlock(inp, tp, &tp, SMB_STRF_ANSIPATH);
+ if (!pathp)
+ return CM_ERROR_BADSMB;
osi_Log1(smb_logp, "SMB receive unlink %S",
osi_LogSaveClientString(smb_logp, pathp));
if ( WANTS_DFS_PATHNAMES(inp) || pnc )
return CM_ERROR_PATH_NOT_COVERED;
else
- return CM_ERROR_BADSHARENAME;
+ return CM_ERROR_NOSUCHPATH;
}
#endif /* DFS_SUPPORT */
if ( WANTS_DFS_PATHNAMES(inp) || pnc )
return CM_ERROR_PATH_NOT_COVERED;
else
- return CM_ERROR_BADSHARENAME;
+ return CM_ERROR_NOSUCHPATH;
}
#endif /* DFS_SUPPORT */
if ( WANTS_DFS_PATHNAMES(inp) || pnc )
return CM_ERROR_PATH_NOT_COVERED;
else
- return CM_ERROR_BADSHARENAME;
+ return CM_ERROR_NOSUCHPATH;
}
#endif /* DFS_SUPPORT */
if ( WANTS_DFS_PATHNAMES(inp) || pnc )
return CM_ERROR_PATH_NOT_COVERED;
else
- return CM_ERROR_BADSHARENAME;
+ return CM_ERROR_NOSUCHPATH;
}
#endif /* DFS_SUPPORT */
if ( WANTS_DFS_PATHNAMES(inp) || pnc )
return CM_ERROR_PATH_NOT_COVERED;
else
- return CM_ERROR_BADSHARENAME;
+ return CM_ERROR_NOSUCHPATH;
}
#endif /* DFS_SUPPORT */
tp = smb_GetSMBData(inp, NULL);
oldPathp = smb_ParseASCIIBlock(inp, tp, &tp, SMB_STRF_ANSIPATH);
+ if (!oldPathp)
+ return CM_ERROR_BADSMB;
newPathp = smb_ParseASCIIBlock(inp, tp, &tp, SMB_STRF_ANSIPATH);
+ if (!newPathp)
+ return CM_ERROR_BADSMB;
osi_Log2(smb_logp, "smb rename [%S] to [%S]",
osi_LogSaveClientString(smb_logp, oldPathp),
tp = smb_GetSMBData(inp, NULL);
pathp = smb_ParseASCIIBlock(inp, tp, &tp, SMB_STRF_ANSIPATH);
+ if (!pathp)
+ return CM_ERROR_BADSMB;
spacep = inp->spacep;
smb_StripLastComponent(spacep->wdata, &lastNamep, pathp);
if ( WANTS_DFS_PATHNAMES(inp) || pnc )
return CM_ERROR_PATH_NOT_COVERED;
else
- return CM_ERROR_BADSHARENAME;
+ return CM_ERROR_NOSUCHPATH;
}
#endif /* DFS_SUPPORT */
fid = smb_ChainFID(fid, inp);
fidp = smb_FindFID(vcp, fid, 0);
if (!fidp)
- return CM_ERROR_BADFD;
+ return CM_ERROR_BADFD;
- if (fidp->scp && (fidp->scp->flags & CM_SCACHEFLAG_DELETED)) {
- smb_CloseFID(vcp, fidp, NULL, 0);
- smb_ReleaseFID(fidp);
- return CM_ERROR_NOSUCHFILE;
- }
+ userp = smb_GetUserFromVCP(vcp, inp);
lock_ObtainMutex(&fidp->mx);
- if (fidp->flags & SMB_FID_IOCTL) {
- lock_ReleaseMutex(&fidp->mx);
- smb_ReleaseFID(fidp);
+ if (!fidp->scp || (fidp->flags & SMB_FID_IOCTL)) {
+ cm_ReleaseUser(userp);
+ lock_ReleaseMutex(&fidp->mx);
+ smb_ReleaseFID(fidp);
return CM_ERROR_BADFD;
}
- lock_ReleaseMutex(&fidp->mx);
-
- userp = smb_GetUserFromVCP(vcp, inp);
- lock_ObtainMutex(&fidp->mx);
+ if (fidp->scp->flags & CM_SCACHEFLAG_DELETED) {
+ lock_ReleaseMutex(&fidp->mx);
+ cm_ReleaseUser(userp);
+ smb_CloseFID(vcp, fidp, NULL, 0);
+ smb_ReleaseFID(fidp);
+ return CM_ERROR_NOSUCHFILE;
+ }
+
if ((fidp->flags & SMB_FID_OPENWRITE) && smb_AsyncStore != 2) {
- cm_scache_t * scp = fidp->scp;
- cm_HoldSCache(scp);
- lock_ReleaseMutex(&fidp->mx);
+ cm_scache_t * scp = fidp->scp;
+ cm_HoldSCache(scp);
+ lock_ReleaseMutex(&fidp->mx);
code = cm_FSync(scp, userp, &req);
- cm_ReleaseSCache(scp);
+ cm_ReleaseSCache(scp);
} else {
+ lock_ReleaseMutex(&fidp->mx);
code = 0;
- lock_ReleaseMutex(&fidp->mx);
}
- smb_ReleaseFID(fidp);
-
cm_ReleaseUser(userp);
-
+ smb_ReleaseFID(fidp);
return code;
}
if (!userp) {
lock_ObtainMutex(&fidp->mx);
- if (!fidp->userp && !(fidp->flags & SMB_FID_IOCTL)) {
+ if (!fidp->userp && !(fidp->flags & (SMB_FID_IOCTL|
+ SMB_FID_RPC))) {
lock_ReleaseMutex(&fidp->mx);
osi_Log0(smb_logp, " No user specified. Not closing fid");
return CM_ERROR_BADFD;
lock_ObtainWrite(&smb_rctLock);
if (fidp->deleteOk) {
- osi_Log0(smb_logp, " Fid already closed.");
- lock_ReleaseWrite(&smb_rctLock);
- return CM_ERROR_BADFD;
+ osi_Log0(smb_logp, " Fid already closed.");
+ lock_ReleaseWrite(&smb_rctLock);
+ return CM_ERROR_BADFD;
}
fidp->deleteOk = 1;
lock_ReleaseWrite(&smb_rctLock);
lock_ObtainMutex(&fidp->mx);
if (fidp->NTopen_dscp) {
- dscp = fidp->NTopen_dscp;
- cm_HoldSCache(dscp);
+ dscp = fidp->NTopen_dscp;
+ cm_HoldSCache(dscp);
}
- if (fidp->NTopen_pathp) {
- pathp = cm_ClientStrDup(fidp->NTopen_pathp);
- }
+ if (fidp->NTopen_pathp)
+ pathp = cm_ClientStrDup(fidp->NTopen_pathp);
if (fidp->scp) {
- scp = fidp->scp;
- cm_HoldSCache(scp);
+ scp = fidp->scp;
+ cm_HoldSCache(scp);
}
/* Don't jump the gun on an async raw write */
scp->mask |= CM_SCACHEMASK_CLIENTMODTIME;
/* This fixes defect 10958 */
CompensateForSmbClientLastWriteTimeBugs(&dosTime);
- smb_UnixTimeFromDosUTime(&fidp->scp->clientModTime, dosTime);
+ smb_UnixTimeFromDosUTime(&scp->clientModTime, dosTime);
}
if (smb_AsyncStore != 2) {
lock_ReleaseMutex(&fidp->mx);
cm_key_t key;
long tcode;
- lock_ReleaseMutex(&fidp->mx);
+ lock_ReleaseMutex(&fidp->mx);
- /* CM_UNLOCK_BY_FID doesn't look at the process ID. We pass
- in zero. */
+ /* CM_UNLOCK_BY_FID doesn't look at the process ID. We pass
+ * in zero. */
key = cm_GenerateKey(vcp->vcID, 0, fidp->fid);
lock_ObtainWrite(&scp->rw);
}
if (scp) {
- lock_ObtainWrite(&scp->rw);
+ lock_ObtainWrite(&scp->rw);
if (nullcreator && scp->creator == userp)
scp->creator = NULL;
- scp->flags &= ~CM_SCACHEFLAG_SMB_FID;
- lock_ReleaseWrite(&scp->rw);
- cm_ReleaseSCache(scp);
+ scp->flags &= ~CM_SCACHEFLAG_SMB_FID;
+ lock_ReleaseWrite(&scp->rw);
+ cm_ReleaseSCache(scp);
}
if (pathp)
- free(pathp);
+ free(pathp);
return code;
}
code = CM_ERROR_BADFDOP;
goto done2;
}
-
+
+ if (!fidp->scp) {
+ lock_ReleaseMutex(&fidp->mx);
+ code = CM_ERROR_BADFD;
+ goto done2;
+ }
+
smb_InitReq(&req);
bufferp = NULL;
}
lock_ReleaseWrite(&scp->rw);
- code = buf_Get(scp, &thyper, &bufferp);
+ code = buf_Get(scp, &thyper, &req, &bufferp);
lock_ObtainWrite(&scp->rw);
if (code) goto done;
}
lock_ReleaseWrite(&scp->rw);
- code = buf_Get(scp, &thyper, &bufferp);
+ code = buf_Get(scp, &thyper, &req, &bufferp);
lock_ObtainMutex(&bufferp->mx);
lock_ObtainWrite(&scp->rw);
smb_t* smbp = (smb_t*) inp;
long code = 0;
cm_user_t *userp;
+ cm_scache_t *scp;
cm_attr_t truncAttr; /* attribute struct used for truncating file */
char *op;
int inDataBlockCount;
return CM_ERROR_BADFD;
}
- if (fidp->scp && (fidp->scp->flags & CM_SCACHEFLAG_DELETED)) {
- smb_CloseFID(vcp, fidp, NULL, 0);
- smb_ReleaseFID(fidp);
- return CM_ERROR_NOSUCHFILE;
- }
-
lock_ObtainMutex(&fidp->mx);
if (fidp->flags & SMB_FID_IOCTL) {
lock_ReleaseMutex(&fidp->mx);
osi_Log1(smb_logp, "smb_ReceiveCoreWrite ioctl code 0x%x", code);
return code;
}
+
+ if (fidp->flags & SMB_FID_RPC) {
+ lock_ReleaseMutex(&fidp->mx);
+ code = smb_RPCWrite(fidp, vcp, inp, outp);
+ smb_ReleaseFID(fidp);
+ osi_Log1(smb_logp, "smb_ReceiveCoreWrite RPC code 0x%x", code);
+ return code;
+ }
+
+ if (!fidp->scp) {
+ lock_ReleaseMutex(&fidp->mx);
+ smb_ReleaseFID(fidp);
+ return CM_ERROR_BADFD;
+ }
+
+ if (fidp->scp->flags & CM_SCACHEFLAG_DELETED) {
+ lock_ReleaseMutex(&fidp->mx);
+ smb_CloseFID(vcp, fidp, NULL, 0);
+ smb_ReleaseFID(fidp);
+ return CM_ERROR_NOSUCHFILE;
+ }
+
+ scp = fidp->scp;
+ cm_HoldSCache(scp);
lock_ReleaseMutex(&fidp->mx);
userp = smb_GetUserFromVCP(vcp, inp);
LLength.HighPart = 0;
LLength.LowPart = count;
- lock_ObtainWrite(&fidp->scp->rw);
- code = cm_LockCheckWrite(fidp->scp, LOffset, LLength, key);
- lock_ReleaseWrite(&fidp->scp->rw);
+ lock_ObtainWrite(&scp->rw);
+ code = cm_LockCheckWrite(scp, LOffset, LLength, key);
+ lock_ReleaseWrite(&scp->rw);
if (code) {
osi_Log1(smb_logp, "smb_ReceiveCoreWrite lock check failure 0x%x", code);
done:
smb_ReleaseFID(fidp);
cm_ReleaseUser(userp);
+ cm_ReleaseSCache(scp);
return code;
}
fd = smb_GetSMBParm(inp, 0);
fidp = smb_FindFID(vcp, fd, 0);
- if (fidp->scp && (fidp->scp->flags & CM_SCACHEFLAG_DELETED)) {
- smb_CloseFID(vcp, fidp, NULL, 0);
+ lock_ObtainMutex(&fidp->mx);
+ if (!fidp->scp) {
+ lock_ReleaseMutex(&fidp->mx);
smb_ReleaseFID(fidp);
return;
}
+ if (fidp->scp->flags & CM_SCACHEFLAG_DELETED) {
+ lock_ReleaseMutex(&fidp->mx);
+ smb_CloseFID(vcp, fidp, NULL, 0);
+ smb_ReleaseFID(fidp);
+ return;
+ }
+ lock_ReleaseMutex(&fidp->mx);
+
osi_Log3(smb_logp, "Completing Raw Write offset 0x%x:%08x count %x",
rwcp->offset.HighPart, rwcp->offset.LowPart, rwcp->count);
smb_t *smbp = (smb_t*) inp;
long code = 0;
cm_user_t *userp;
+ cm_scache_t *scp;
char *op;
unsigned short writeMode;
char *rawBuf;
fd = smb_ChainFID(fd, inp);
fidp = smb_FindFID(vcp, fd, 0);
- if (!fidp) {
+ if (!fidp)
+ return CM_ERROR_BADFD;
+
+ lock_ObtainMutex(&fidp->mx);
+ if (!fidp->scp) {
+ lock_ReleaseMutex(&fidp->mx);
+ smb_ReleaseFID(fidp);
return CM_ERROR_BADFD;
}
- if (fidp->scp && (fidp->scp->flags & CM_SCACHEFLAG_DELETED)) {
+ if (fidp->scp->flags & CM_SCACHEFLAG_DELETED) {
+ lock_ReleaseMutex(&fidp->mx);
smb_CloseFID(vcp, fidp, NULL, 0);
smb_ReleaseFID(fidp);
return CM_ERROR_NOSUCHFILE;
}
+ scp = fidp->scp;
+ cm_HoldSCache(scp);
+ lock_ReleaseMutex(&fidp->mx);
+
{
unsigned pid;
cm_key_t key;
LLength.HighPart = 0;
LLength.LowPart = count;
- lock_ObtainWrite(&fidp->scp->rw);
- code = cm_LockCheckWrite(fidp->scp, LOffset, LLength, key);
- lock_ReleaseWrite(&fidp->scp->rw);
+ lock_ObtainWrite(&scp->rw);
+ code = cm_LockCheckWrite(scp, LOffset, LLength, key);
+ lock_ReleaseWrite(&scp->rw);
if (code) {
+ cm_ReleaseSCache(scp);
smb_ReleaseFID(fidp);
return code;
}
smb_ReleaseFID(fidp);
cm_ReleaseUser(userp);
+ cm_ReleaseSCache(scp);
if (code) {
smb_SetSMBParm(outp, 0, total_written);
smb_t *smbp = (smb_t*) inp;
long code = 0;
cm_user_t *userp;
+ cm_scache_t *scp;
char *op;
fd = smb_GetSMBParm(inp, 0);
fidp = smb_FindFID(vcp, fd, 0);
if (!fidp)
return CM_ERROR_BADFD;
-
- if (fidp->scp && (fidp->scp->flags & CM_SCACHEFLAG_DELETED)) {
- smb_CloseFID(vcp, fidp, NULL, 0);
- smb_ReleaseFID(fidp);
- return CM_ERROR_NOSUCHFILE;
- }
lock_ObtainMutex(&fidp->mx);
if (fidp->flags & SMB_FID_IOCTL) {
smb_ReleaseFID(fidp);
return code;
}
+
+ if (fidp->flags & SMB_FID_RPC) {
+ lock_ReleaseMutex(&fidp->mx);
+ code = smb_RPCRead(fidp, vcp, inp, outp);
+ smb_ReleaseFID(fidp);
+ return code;
+ }
+
+ if (!fidp->scp) {
+ lock_ReleaseMutex(&fidp->mx);
+ smb_ReleaseFID(fidp);
+ return CM_ERROR_BADFD;
+ }
+
+ if (fidp->scp->flags & CM_SCACHEFLAG_DELETED) {
+ lock_ReleaseMutex(&fidp->mx);
+ smb_CloseFID(vcp, fidp, NULL, 0);
+ smb_ReleaseFID(fidp);
+ return CM_ERROR_NOSUCHFILE;
+ }
+
+ scp = fidp->scp;
+ cm_HoldSCache(scp);
lock_ReleaseMutex(&fidp->mx);
{
LLength.HighPart = 0;
LLength.LowPart = count;
- lock_ObtainWrite(&fidp->scp->rw);
- code = cm_LockCheckRead(fidp->scp, LOffset, LLength, key);
- lock_ReleaseWrite(&fidp->scp->rw);
+ lock_ObtainWrite(&scp->rw);
+ code = cm_LockCheckRead(scp, LOffset, LLength, key);
+ lock_ReleaseWrite(&scp->rw);
}
if (code) {
+ cm_ReleaseSCache(scp);
smb_ReleaseFID(fidp);
return code;
}
smb_ReleaseFID(fidp);
cm_ReleaseUser(userp);
+ cm_ReleaseSCache(scp);
return code;
}
tp = smb_GetSMBData(inp, NULL);
pathp = smb_ParseASCIIBlock(inp, tp, &tp, SMB_STRF_ANSIPATH);
-
- if (cm_ClientStrCmp(pathp, _C("\\")) == 0)
- return CM_ERROR_EXISTS;
+ if (!pathp)
+ return CM_ERROR_BADSMB;
spacep = inp->spacep;
smb_StripLastComponent(spacep->wdata, &lastNamep, pathp);
+ if (cm_ClientStrCmp(pathp, _C("\\")) == 0)
+ return CM_ERROR_EXISTS;
+
userp = smb_GetUserFromVCP(vcp, inp);
caseFold = CM_FLAG_CASEFOLD;
if ( WANTS_DFS_PATHNAMES(inp) || pnc )
return CM_ERROR_PATH_NOT_COVERED;
else
- return CM_ERROR_BADSHARENAME;
+ return CM_ERROR_NOSUCHPATH;
}
#endif /* DFS_SUPPORT */
tp = smb_GetSMBData(inp, NULL);
pathp = smb_ParseASCIIBlock(inp, tp, &tp, SMB_STRF_ANSIPATH);
+ if (!pathp)
+ return CM_ERROR_BADSMB;
+
+ spacep = inp->spacep;
+ /* smb_StripLastComponent will strip "::$DATA" if present */
+ smb_StripLastComponent(spacep->wdata, &lastNamep, pathp);
if (!cm_IsValidClientString(pathp)) {
#ifdef DEBUG
return CM_ERROR_BADNTFILENAME;
}
- spacep = inp->spacep;
- smb_StripLastComponent(spacep->wdata, &lastNamep, pathp);
-
userp = smb_GetUserFromVCP(vcp, inp);
caseFold = CM_FLAG_CASEFOLD;
if ( WANTS_DFS_PATHNAMES(inp) || pnc )
return CM_ERROR_PATH_NOT_COVERED;
else
- return CM_ERROR_BADSHARENAME;
+ return CM_ERROR_NOSUCHPATH;
}
#endif /* DFS_SUPPORT */
fidp = smb_FindFID(vcp, fd, 0);
if (!fidp)
return CM_ERROR_BADFD;
-
- if (fidp->scp && (fidp->scp->flags & CM_SCACHEFLAG_DELETED)) {
- smb_CloseFID(vcp, fidp, NULL, 0);
- smb_ReleaseFID(fidp);
- return CM_ERROR_NOSUCHFILE;
- }
lock_ObtainMutex(&fidp->mx);
- if (fidp->flags & SMB_FID_IOCTL) {
+ if (!fidp->scp || (fidp->flags & SMB_FID_IOCTL)) {
lock_ReleaseMutex(&fidp->mx);
smb_ReleaseFID(fidp);
return CM_ERROR_BADFD;
}
+
+ if (fidp->scp->flags & CM_SCACHEFLAG_DELETED) {
+ lock_ReleaseMutex(&fidp->mx);
+ smb_CloseFID(vcp, fidp, NULL, 0);
+ smb_ReleaseFID(fidp);
+ return CM_ERROR_NOSUCHFILE;
+ }
+
lock_ReleaseMutex(&fidp->mx);
-
+
userp = smb_GetUserFromVCP(vcp, inp);
lock_ObtainMutex(&fidp->mx);
if (dp->procp) {
/* we have a recognized operation */
char * opName = myCrt_Dispatch(inp->inCom);
+ smb_t *smbp;
- if (inp->inCom == 0x1d)
+ smbp = (smb_t *) inp;
+
+ osi_Log5(smb_logp,"Dispatch %s mid 0x%x vcp 0x%p lana %d lsn %d",
+ opName, smbp->mid, vcp,vcp->lana,vcp->lsn);
+ if (inp->inCom == 0x1d) {
/* Raw Write */
code = smb_ReceiveCoreWriteRaw (vcp, inp, outp, rwcp);
- else {
- osi_Log4(smb_logp,"Dispatch %s vcp 0x%p lana %d lsn %d",
- opName,vcp,vcp->lana,vcp->lsn);
+ } else {
code = (*(dp->procp)) (vcp, inp, outp);
- osi_Log4(smb_logp,"Dispatch return code 0x%x vcp 0x%p lana %d lsn %d",
- code,vcp,vcp->lana,vcp->lsn);
-#ifdef LOG_PACKET
- if ( code == CM_ERROR_BADSMB ||
- code == CM_ERROR_BADOP )
- smb_LogPacket(inp);
-#endif /* LOG_PACKET */
}
+ osi_Log5(smb_logp,"Dispatch return code 0x%x mid 0x%x vcp 0x%p lana %d lsn %d",
+ code, smbp->mid, vcp,vcp->lana,vcp->lsn);
newTime = GetTickCount();
- osi_Log2(smb_logp, "Dispatch %s duration %d ms", opName, newTime - oldTime);
+ osi_Log3(smb_logp, "Dispatch %s mid 0x%x duration %d ms",
+ opName, smbp->mid, newTime - oldTime);
+
+#ifdef LOG_PACKET
+ if ( code == CM_ERROR_BADSMB ||
+ code == CM_ERROR_BADOP )
+ smb_LogPacket(inp);
+#endif /* LOG_PACKET */
/* ReceiveV3Tran2A handles its own logging */
if (inp->inCom != 0x32 && newTime - oldTime > 45000) {
cm_fid_t afid = {0,0,0,0,0};
uidp = smb_FindUID(vcp, smbp->uid, 0);
- smb_LookupTIDPath(vcp,((smb_t *)inp)->tid, &treepath);
+ smb_LookupTIDPath(vcp, smbp->tid, &treepath);
fidp = smb_FindFID(vcp, inp->fid, 0);
- if (fidp && fidp->NTopen_pathp)
- pathname = fidp->NTopen_pathp;
- else if (inp->stringsp->wdata)
- pathname = inp->stringsp->wdata;
-
- if (fidp && fidp->scp)
- afid = fidp->scp->fid;
+ if (fidp) {
+ lock_ObtainMutex(&fidp->mx);
+ if (fidp->NTopen_pathp)
+ pathname = fidp->NTopen_pathp;
+ if (fidp->scp)
+ afid = fidp->scp->fid;
+ } else {
+ if (inp->stringsp->wdata)
+ pathname = inp->stringsp->wdata;
+ }
- afsi_log("Request %s duration %d ms user %S tid \"%S\" path? \"%S\" afid (%d.%d.%d.%d)",
- opName, newTime - oldTime,
- uidp ? uidp->unp->name : NULL,
+ afsi_log("Request %s duration %d ms user 0x%x \"%S\" pid 0x%x mid 0x%x tid 0x%x \"%S\" path? \"%S\" afid (%d.%d.%d.%d)",
+ opName, newTime - oldTime,
+ smbp->uid, uidp ? uidp->unp->name : NULL,
+ smbp->pid, smbp->mid, smbp->tid,
treepath,
pathname,
afid.cell, afid.volume, afid.vnode, afid.unique);
+ if (fidp)
+ lock_ReleaseMutex(&fidp->mx);
+
if (uidp)
smb_ReleaseUID(uidp);
if (fidp)
vcp = NULL;
}
- smb_ResetServerPriority();
+ cm_ResetServerPriority();
code = thrd_WaitForMultipleObjects_Event(numNCBs, NCBreturns[myIdx],
FALSE, INFINITE);
continue;
}
- smb_SetRequestStartTime();
+ cm_SetRequestStartTime();
vcp->errorCount = 0;
bufp = (struct smb_packet *) ncbp->ncb_buffer;
if (smbp->com == 0x1d) {
/* Special handling for Write Raw */
raw_write_cont_t rwc;
- EVENT_HANDLE rwevent;
- char eventName[MAX_PATH];
smb_DispatchPacket(vcp, bufp, outbufp, ncbp, &rwc);
if (rwc.code == 0) {
- rwevent = thrd_CreateEvent(NULL, FALSE, FALSE, TEXT("smb_Server() rwevent"));
+ EVENT_HANDLE rwevent;
+ char eventName[MAX_PATH];
+
+ snprintf(eventName, MAX_PATH, "smb_Server() rwevent %d", myIdx);
+ rwevent = thrd_CreateEvent(NULL, FALSE, FALSE, eventName);
if ( GetLastError() == ERROR_ALREADY_EXISTS )
osi_Log1(smb_logp, "Event Object Already Exists: %s", osi_LogSaveString(smb_logp, eventName));
+
ncbp->ncb_command = NCBRECV | ASYNCH;
ncbp->ncb_lsn = (unsigned char) vcp->lsn;
ncbp->ncb_lana_num = vcp->lana;
}
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.
+ *
+ * Do not permit the "DisableLoopbackCheck" value to be removed within the same
+ * service session that set it.
+ */
+ HKEY hkLsa;
+ HKEY hkMSV10;
+ HKEY hkClient;
+ DWORD dwType;
+ DWORD dwSize, dwAllocSize;
+ DWORD dwValue;
+ PBYTE pHostNames = NULL, pName = NULL;
+ BOOL bNameFound = FALSE;
+ static BOOL bLoopbackCheckDisabled = FALSE;
+
+ /* BackConnectionHostNames and DisableLoopbackCheck */
+ 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 */
+ + (DWORD)strlen(cm_NetbiosName) + 2;
+ pHostNames = malloc(dwAllocSize);
+ dwSize = dwAllocSize;
+ if (RegQueryValueEx( hkMSV10, "BackConnectionHostNames", 0, &dwType,
+ pHostNames, &dwSize) == ERROR_SUCCESS)
+ {
+ for (pName = pHostNames;
+ (pName - pHostNames < (int) 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 = (DWORD)(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);
+ bLoopbackCheckDisabled = TRUE;
+ RegCloseKey(hkClient);
+ }
+ RegCloseKey(hkLsa);
+ }
+ }
+ } else if (!bLoopbackCheckDisabled) {
+ 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);
+ }
+ }
+
+ if (pHostNames) {
+ free(pHostNames);
+ pHostNames = NULL;
+ }
+
+ RegCloseKey(hkMSV10);
+ }
+}
+
+
+static void
+configureExtendedSMBSessionTimeouts(void)
+{
+ /*
+ * In a Hot Fix to Windows 2003 SP2, the smb redirector was given the following
+ * new functionality:
+ *
+ * [HKLM\SYSTEM\CurrentControlSet\Services\LanManWorkstation\Parameters]
+ * "ReconnectableServers" REG_MULTI_SZ
+ * "ExtendedSessTimeout" REG_DWORD (seconds)
+ * "ServersWithExtendedSessTimeout" REG_MULTI_SZ
+ *
+ * These values can be used to prevent the smb redirector from timing out
+ * smb connection to the afs smb server prematurely.
+ */
+ HKEY hkLanMan;
+ DWORD dwType;
+ DWORD dwSize, dwAllocSize;
+ DWORD dwValue;
+ PBYTE pHostNames = NULL, pName = NULL;
+ BOOL bNameFound = FALSE;
+
+ if ( RegOpenKeyEx( HKEY_LOCAL_MACHINE,
+ "SYSTEM\\CurrentControlSet\\Services\\LanManWorkstation\\Parameters",
+ 0,
+ KEY_READ|KEY_WRITE,
+ &hkLanMan) == ERROR_SUCCESS )
+ {
+ if ((RegQueryValueEx( hkLanMan, "ReconnectableServers", 0,
+ &dwType, NULL, &dwAllocSize) == ERROR_SUCCESS) &&
+ (dwType == REG_MULTI_SZ))
+ {
+ dwAllocSize += 1 /* in case the source string is not nul terminated */
+ + (DWORD)strlen(cm_NetbiosName) + 2;
+ pHostNames = malloc(dwAllocSize);
+ dwSize = dwAllocSize;
+ if (RegQueryValueEx( hkLanMan, "ReconnectableServers", 0, &dwType,
+ pHostNames, &dwSize) == ERROR_SUCCESS)
+ {
+ for (pName = pHostNames;
+ (pName - pHostNames < (int) 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 = (DWORD)(pName - pHostNames + 1);
+ RegSetValueEx( hkLanMan, "ReconnectableServers", 0, dwType, pHostNames, dwSize);
+ }
+
+ if (pHostNames) {
+ free(pHostNames);
+ pHostNames = NULL;
+ }
+
+ if ((RegQueryValueEx( hkLanMan, "ServersWithExtendedSessTimeout", 0,
+ &dwType, NULL, &dwAllocSize) == ERROR_SUCCESS) &&
+ (dwType == REG_MULTI_SZ))
+ {
+ dwAllocSize += 1 /* in case the source string is not nul terminated */
+ + (DWORD)strlen(cm_NetbiosName) + 2;
+ pHostNames = malloc(dwAllocSize);
+ dwSize = dwAllocSize;
+ if (RegQueryValueEx( hkLanMan, "ServersWithExtendedSessTimeout", 0, &dwType,
+ pHostNames, &dwSize) == ERROR_SUCCESS)
+ {
+ for (pName = pHostNames;
+ (pName - pHostNames < (int) 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 = (DWORD)(pName - pHostNames + 1);
+ RegSetValueEx( hkLanMan, "ServersWithExtendedSessTimeout", 0, dwType, pHostNames, dwSize);
+ }
+
+ if (pHostNames) {
+ free(pHostNames);
+ pHostNames = NULL;
+ }
+
+ if ((RegQueryValueEx( hkLanMan, "ExtendedSessTimeout", 0,
+ &dwType, (LPBYTE)&dwValue, &dwAllocSize) != ERROR_SUCCESS) ||
+ (dwType != REG_DWORD))
+ {
+ dwType = REG_DWORD;
+ dwSize = sizeof(dwValue);
+ dwValue = 300; /* 5 minutes */
+ RegSetValueEx( hkLanMan, "ExtendedSessTimeout", 0, dwType, (const BYTE *)&dwValue, dwSize);
+ }
+ RegCloseKey(hkLanMan);
+ }
+}
+
+static void
smb_LanAdapterChangeThread(void *param)
{
/*
}
afsi_log("smb_StartListeners");
+ /* Ensure the AFS Netbios Name is registered to allow loopback access */
+ configureBackConnectionHostNames();
+
+ /* Configure Extended SMB Session Timeouts */
+ if (msftSMBRedirectorSupportsExtendedTimeouts()) {
+ afsi_log("Microsoft SMB Redirector supports Extended Timeouts");
+ configureExtendedSMBSessionTimeouts();
+ }
+
smb_ListenerState = SMB_LISTENER_STARTED;
cm_VolStatus_Network_Started(cm_NetbiosName
#ifdef _WIN64
char eventName[MAX_PATH];
int startListeners = 0;
- smb_TlsRequestSlot = TlsAlloc();
-
smb_MBfunc = aMBfunc;
smb_useV3 = useV3;
myTime.tm_sec = 0;
smb_localZero = mktime(&myTime);
-#ifndef USE_NUMERIC_TIME_CONV
- /* Initialize kludge-GMT */
- smb_CalculateNowTZ();
-#endif /* USE_NUMERIC_TIME_CONV */
#ifdef AFS_FREELANCE_CLIENT
/* Make sure the root.afs volume has the correct time */
cm_noteLocalMountPointChange();
);
if (nts != STATUS_SUCCESS && ntsEx != STATUS_SUCCESS) {
- char message[AFSPATHMAX];
- sprintf(message,"MsV1_0SetProcessOption failure: nts 0x%x ntsEx 0x%x",
- nts, ntsEx);
- OutputDebugString(message);
- afsi_log(message);
+ osi_Log2(smb_logp, "MsV1_0SetProcessOption failure: nts 0x%x ntsEx 0x%x",
+ nts, ntsEx);
+
+ afsi_log("MsV1_0SetProcessOption failure: nts 0x%x ntsEx 0x%x", nts, ntsEx);
} else {
- OutputDebugString("MsV1_0SetProcessOption success");
+ osi_Log0(smb_logp, "MsV1_0SetProcessOption success");
afsi_log("MsV1_0SetProcessOption success");
}
/* END - code from Larry */
}
lock_ReleaseWrite(&smb_rctLock);
smb_FreeNCB(ncbp);
- TlsFree(smb_TlsRequestSlot);
}
/* Get the UNC \\<servername>\<sharename> prefix. */
git://git.openafs.org / openafs.git / blobdiff