#include <WINNT\afsreg.h>
#include "smb.h"
+#include "msrpc.h"
#include "lanahelper.h"
+#define STRSAFE_NO_DEPRECATE
+#include <strsafe.h>
+
/* These characters are illegal in Windows filenames */
-static char *illegalChars = "\\/:*?\"<>|";
+static clientchar_t *illegalChars = _C("\\/:*?\"<>|");
static int smbShutdownFlag = 0;
static int smb_ListenerState = SMB_LISTENER_UNINITIALIZED;
osi_rwlock_t smb_rctLock;
osi_mutex_t smb_ListenerLock;
osi_mutex_t smb_StartedLock;
-
+
unsigned char smb_LANadapter = LANA_INVALID;
unsigned char smb_sharename[NCBNAMSZ+1] = {0};
int smb_LanAdapterChangeDetected = 0;
+afs_uint32 smb_AsyncStore = 1;
+afs_uint32 smb_AsyncStoreSize = CM_CONFIGDEFAULT_ASYNCSTORESIZE;
BOOL isGateway = FALSE;
smb_packet_t *smb_packetFreeListp;
smb_ncb_t *smb_ncbFreeListp;
-int smb_NumServerThreads;
+afs_uint32 smb_NumServerThreads;
-int numNCBs, numSessions, numVCs;
+afs_uint32 numNCBs, numSessions, numVCs;
int smb_maxVCPerServer;
int smb_maxMpxRequests;
/* for raw write */
typedef struct raw_write_cont {
- long code;
- osi_hyper_t offset;
- long count;
- char *buf;
- int writeMode;
- long alreadyWritten;
+ long code;
+ osi_hyper_t offset;
+ long count;
+ char *buf;
+ int writeMode;
+ long alreadyWritten;
} raw_write_cont_t;
/* dir search stuff */
smb_dirSearch_t *smb_firstDirSearchp;
smb_dirSearch_t *smb_lastDirSearchp;
+/* Initial mode bits for files and directories. Set to 0 to use
+ defaults. */
+int smb_unixModeDefaultFile = 0666;
+int smb_unixModeDefaultDir = 0777;
+
/* hide dot files? */
int smb_hideDotFiles;
+/* Negotiate Unicode support? */
+LONG smb_UseUnicode;
+
/* global state about V3 protocols */
int smb_useV3; /* try to negotiate V3 */
-static showErrors = 0;
+static int showErrors = 0;
/* MessageBox or something like it */
-int (_stdcall *smb_MBfunc)(HWND, LPCTSTR, LPCTSTR, UINT) = NULL;
+int (_stdcall *smb_MBfunc)(HWND, LPCTSTR, LPCTSTR, UINT)
+= NULL;
/* GMT time info:
* Time in Unix format of midnight, 1/1/1970 local time.
*/
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);
#ifdef LOG_PACKET
void smb_LogPacket(smb_packet_t *packet);
#endif /* LOG_PACKET */
-
-char smb_ServerDomainName[MAX_COMPUTERNAME_LENGTH + 1] = ""; /* domain name */
+
+clientchar_t smb_ServerDomainName[MAX_COMPUTERNAME_LENGTH + 1] = _C(""); /* domain name */
int smb_ServerDomainNameLength = 0;
-char smb_ServerOS[] = "Windows 5.0"; /* Faux OS String */
-int smb_ServerOSLength = sizeof(smb_ServerOS);
-char smb_ServerLanManager[] = "Windows 2000 LAN Manager"; /* Faux LAN Manager string */
-int smb_ServerLanManagerLength = sizeof(smb_ServerLanManager);
+clientchar_t smb_ServerOS[] = _C("Windows 5.0"); /* Faux OS String */
+int smb_ServerOSLength = lengthof(smb_ServerOS);
+clientchar_t smb_ServerLanManager[] = _C("Windows 2000 LAN Manager"); /* Faux LAN Manager string */
+int smb_ServerLanManagerLength = lengthof(smb_ServerLanManager);
/* Faux server GUID. This is never checked. */
GUID smb_ServerGUID = { 0x40015cb8, 0x058a, 0x44fc, { 0xae, 0x7e, 0xbb, 0x29, 0x52, 0xee, 0x7e, 0xff }};
-void smb_ResetServerPriority()
-{
- void * p = TlsGetValue(smb_TlsRequestSlot);
- if (p) {
- free(p);
- TlsSetValue(smb_TlsRequestSlot, NULL);
- SetThreadPriority(GetCurrentThread(), THREAD_PRIORITY_NORMAL);
- }
-}
-
-void smb_SetRequestStartTime()
+void smb_InitReq(cm_req_t *reqp)
{
- 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(), (now - *tp) / 15);
- }
+ cm_InitReq(reqp);
+ reqp->flags |= CM_REQ_SOURCE_SMB;
}
-
const char * ncb_error_string(int code)
{
const char * s;
switch ( code ) {
- case 0x01: s = "llegal buffer length"; break;
- case 0x03: s = "illegal command"; break;
- case 0x05: s = "command timed out"; break;
- case 0x06: s = "message incomplete, issue another command"; break;
- case 0x07: s = "illegal buffer address"; break;
- case 0x08: s = "session number out of range"; break;
- case 0x09: s = "no resource available"; break;
- case 0x0a: s = "session closed"; break;
- case 0x0b: s = "command cancelled"; break;
- case 0x0d: s = "duplicate name"; break;
- case 0x0e: s = "name table full"; break;
- case 0x0f: s = "no deletions, name has active sessions"; break;
- case 0x11: s = "local session table full"; break;
- case 0x12: s = "remote session table full"; break;
- case 0x13: s = "illegal name number"; break;
- case 0x14: s = "no callname"; break;
- case 0x15: s = "cannot put * in NCB_NAME"; break;
- case 0x16: s = "name in use on remote adapter"; break;
- case 0x17: s = "name deleted"; break;
- case 0x18: s = "session ended abnormally"; break;
- case 0x19: s = "name conflict detected"; break;
- case 0x21: s = "interface busy, IRET before retrying"; break;
- case 0x22: s = "too many commands outstanding, retry later";break;
- case 0x23: s = "ncb_lana_num field invalid"; break;
- case 0x24: s = "command completed while cancel occurring "; break;
- case 0x26: s = "command not valid to cancel"; break;
- case 0x30: s = "name defined by anther local process"; break;
- case 0x34: s = "environment undefined. RESET required"; break;
- case 0x35: s = "required OS resources exhausted"; break;
- case 0x36: s = "max number of applications exceeded"; break;
- case 0x37: s = "no saps available for netbios"; break;
- case 0x38: s = "requested resources are not available"; break;
- case 0x39: s = "invalid ncb address or length > segment"; break;
- case 0x3B: s = "invalid NCB DDID"; break;
- case 0x3C: s = "lock of user area failed"; break;
- case 0x3f: s = "NETBIOS not loaded"; break;
- case 0x40: s = "system error"; break;
+ case 0x01: s = "NRC_BUFLEN llegal buffer length"; break;
+ case 0x03: s = "NRC_ILLCMD illegal command"; break;
+ case 0x05: s = "NRC_CMDTMO command timed out"; break;
+ case 0x06: s = "NRC_INCOMP message incomplete, issue another command"; break;
+ case 0x07: s = "NRC_BADDR illegal buffer address"; break;
+ case 0x08: s = "NRC_SNUMOUT session number out of range"; break;
+ case 0x09: s = "NRC_NORES no resource available"; break;
+ case 0x0a: s = "NRC_SCLOSED asession closed"; break;
+ case 0x0b: s = "NRC_CMDCAN command cancelled"; break;
+ case 0x0d: s = "NRC_DUPNAME duplicate name"; break;
+ case 0x0e: s = "NRC_NAMTFUL name table full"; break;
+ case 0x0f: s = "NRC_ACTSES no deletions, name has active sessions"; break;
+ case 0x11: s = "NRC_LOCTFUL local session table full"; break;
+ case 0x12: s = "NRC_REMTFUL remote session table full"; break;
+ case 0x13: s = "NRC_ILLNN illegal name number"; break;
+ case 0x14: s = "NRC_NOCALL no callname"; break;
+ case 0x15: s = "NRC_NOWILD cannot put * in NCB_NAME"; break;
+ case 0x16: s = "NRC_INUSE name in use on remote adapter"; break;
+ case 0x17: s = "NRC_NAMERR name deleted"; break;
+ case 0x18: s = "NRC_SABORT session ended abnormally"; break;
+ case 0x19: s = "NRC_NAMCONF name conflict detected"; break;
+ case 0x21: s = "NRC_IFBUSY interface busy, IRET before retrying"; break;
+ case 0x22: s = "NRC_TOOMANY too many commands outstanding, retry later";break;
+ case 0x23: s = "NRC_BRIDGE ncb_lana_num field invalid"; break;
+ case 0x24: s = "NRC_CANOCCR command completed while cancel occurring "; break;
+ case 0x26: s = "NRC_CANCEL command not valid to cancel"; break;
+ case 0x30: s = "NRC_DUPENV name defined by anther local process"; break;
+ case 0x34: s = "NRC_ENVNOTDEF xenvironment undefined. RESET required"; break;
+ case 0x35: s = "NRC_OSRESNOTAV required OS resources exhausted"; break;
+ case 0x36: s = "NRC_MAXAPPS max number of applications exceeded"; break;
+ case 0x37: s = "NRC_NOSAPS no saps available for netbios"; break;
+ case 0x38: s = "NRC_NORESOURCES requested resources are not available"; break;
+ case 0x39: s = "NRC_INVADDRESS invalid ncb address or length > segment"; break;
+ case 0x3B: s = "NRC_INVDDID invalid NCB DDID"; break;
+ case 0x3C: s = "NRC_LOCKFAILlock of user area failed"; break;
+ case 0x3f: s = "NRC_OPENERR NETBIOS not loaded"; break;
+ case 0x40: s = "NRC_SYSTEM system error"; break;
default: s = "unknown error";
}
return 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)
* turns out to be impolitic in NT. See defect 10007.
*/
#ifdef notdef
- if ((scp->unixModeBits & 0222) == 0 || (scp->flags & CM_SCACHEFLAG_RO))
+ if ((scp->unixModeBits & 0200) == 0 || (scp->flags & CM_SCACHEFLAG_RO))
attrs |= SMB_ATTR_READONLY; /* turn on read-only flag */
#else
- if ((scp->unixModeBits & 0222) == 0)
+ if ((scp->unixModeBits & 0200) == 0)
attrs |= SMB_ATTR_READONLY; /* turn on read-only flag */
#endif
return attrs;
}
+void smb_SetInitialModeBitsForFile(int smb_attr, cm_attr_t * attr)
+{
+ if (smb_unixModeDefaultFile != 0) {
+ attr->mask |= CM_ATTRMASK_UNIXMODEBITS;
+ attr->unixModeBits = smb_unixModeDefaultFile;
+ if (smb_attr & SMB_ATTR_READONLY)
+ attr->unixModeBits &= ~0222;
+ }
+}
+
+void smb_SetInitialModeBitsForDir(int smb_attr, cm_attr_t * attr)
+{
+ if (smb_unixModeDefaultDir != 0) {
+ attr->mask |= CM_ATTRMASK_UNIXMODEBITS;
+ attr->unixModeBits = smb_unixModeDefaultDir;
+ }
+}
+
/* Check if the named file/dir is a dotfile/dotdir */
/* String pointed to by lastComp can have leading slashes, but otherwise should have
no other patch components */
-unsigned int smb_IsDotFile(char *lastComp) {
- char *s;
+unsigned int smb_IsDotFile(clientchar_t *lastComp) {
+ clientchar_t *s;
+
if(lastComp) {
/* skip over slashes */
for(s=lastComp;*s && (*s == '\\' || *s == '/'); s++);
return 0;
/* nulls, curdir and parent dir doesn't count */
- if (!*s)
+ if (!*s)
return 0;
- if (*s == '.') {
+ if (*s == _C('.')) {
if (!*(s + 1))
return 0;
- if(*(s+1) == '.' && !*(s + 2))
+ if(*(s+1) == _C('.') && !*(s + 2))
return 0;
return 1;
}
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
+smb_vc_t *smb_FindVCDbg(unsigned short lsn, int flags, int lana, char *file, long line)
+#else
smb_vc_t *smb_FindVC(unsigned short lsn, int flags, int lana)
+#endif
{
smb_vc_t *vcp;
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));
vcp->uidCounter = 1; /* UID 0 is reserved for blank user */
vcp->nextp = smb_allVCsp;
smb_allVCsp = vcp;
- lock_InitializeMutex(&vcp->mx, "vc_t mutex");
+ lock_InitializeMutex(&vcp->mx, "vc_t mutex", LOCK_HIERARCHY_SMB_VC);
vcp->lsn = lsn;
vcp->lana = lana;
vcp->secCtx = NULL;
if (ntsEx == STATUS_SUCCESS) {
memcpy(vcp->encKey, lsaResp->ChallengeToClient, MSV1_0_CHALLENGE_LENGTH);
- LsaFreeReturnBuffer(lsaResp);
} else {
/*
* This will cause the subsequent authentication to fail but
*/
memset(vcp->encKey, 0, MSV1_0_CHALLENGE_LENGTH);
}
+ if (lsaResp)
+ LsaFreeReturnBuffer(lsaResp);
}
else
memset(vcp->encKey, 0, MSV1_0_CHALLENGE_LENGTH);
osi_Log0(smb_logp, "WARNING: numVCs wrapping around");
}
}
+#ifdef DEBUG_SMB_REFCOUNT
+ if (vcp) {
+ afsi_log("%s:%d smb_FindVC vcp 0x%p ref %d", file, line, vcp, vcp->refCount);
+ osi_Log4(smb_logp,"%s:%d smb_FindVC vcp 0x%p ref %d", file, line, vcp, vcp->refCount);
+ }
+#endif
lock_ReleaseWrite(&smb_rctLock);
lock_ReleaseWrite(&smb_globalLock);
return vcp;
}
-int smb_IsStarMask(char *maskp)
+static int smb_Is8Dot3StarMask(clientchar_t *maskp)
{
int i;
- char tc;
+ clientchar_t tc;
for(i=0; i<11; i++) {
tc = *maskp++;
- if (tc == '?' || tc == '*' || tc == '>')
+ if (tc == _C('?') || tc == _C('*') || tc == _C('>'))
return 1;
- }
+ }
+ return 0;
+}
+
+static int smb_IsStarMask(clientchar_t *maskp)
+{
+ clientchar_t tc;
+
+ while (*maskp) {
+ tc = *maskp++;
+ if (tc == _C('?') || tc == _C('*') || tc == _C('>'))
+ return 1;
+ }
return 0;
}
+#ifdef DEBUG_SMB_REFCOUNT
+void smb_ReleaseVCInternalDbg(smb_vc_t *vcp, char * file, long line)
+#define smb_ReleaseVCInternal(a) smb_ReleaseVCInternalDbg(a, file, line)
+#else
void smb_ReleaseVCInternal(smb_vc_t *vcp)
+#endif
{
smb_vc_t **vcpp;
smb_vc_t * avcp;
+ lock_AssertWrite(&smb_rctLock);
vcp->refCount--;
if (vcp->refCount == 0) {
if (vcp->flags & SMB_VCFLAG_ALREADYDEAD) {
+#ifdef DEBUG_SMB_REFCOUNT
+ afsi_log("%s:%d smb_ReleaseVCInternal vcp 0x%p is dead ref %d", file, line, vcp, vcp->refCount);
+ osi_Log4(smb_logp,"%s:%d smb_ReleaseVCInternal vcp 0x%p is dead ref %d", file, line, vcp, vcp->refCount);
+#endif
/* remove VCP from smb_deadVCsp */
for (vcpp = &smb_deadVCsp; *vcpp; vcpp = &((*vcpp)->nextp)) {
if (*vcpp == vcp) {
memset(vcp,0,sizeof(smb_vc_t));
free(vcp);
} else {
+#ifdef DEBUG_SMB_REFCOUNT
+ afsi_log("%s:%d smb_ReleaseVCInternal vcp 0x%p is alive ref %d", file, line, vcp, vcp->refCount);
+#endif
for (avcp = smb_allVCsp; avcp; avcp = avcp->nextp) {
if (avcp == vcp)
break;
}
osi_Log3(smb_logp,"VCP not dead and %sin smb_allVCsp vcp %x ref %d",
- avcp?"not ":"",vcp, vcp->refCount);
-#ifdef DEBUG
- GenerateMiniDump(NULL);
-#endif
+ avcp?"":"not ",vcp, vcp->refCount);
+
/* This is a wrong. However, I suspect that there is an undercount
* and I don't want to release 1.4.1 in a state that will allow
* smb_vc_t objects to be deallocated while still in the
* smb_allVCsp list. The list is supposed to keep a reference
* to the smb_vc_t. Put it back.
*/
- vcp->refCount++;
+ if (avcp) {
+ vcp->refCount++;
+#ifdef DEBUG_SMB_REFCOUNT
+ afsi_log("%s:%d smb_ReleaseVCInternal vcp 0x%p is in smb_allVCsp ref %d", file, line, vcp, vcp->refCount);
+ osi_Log4(smb_logp,"%s:%d smb_ReleaseVCInternal vcp 0x%p is in smb_allVCsp ref %d", file, line, vcp, vcp->refCount);
+#endif
+ }
}
+ } else if (vcp->flags & SMB_VCFLAG_ALREADYDEAD) {
+ /* The reference count is non-zero but the VC is dead.
+ * This implies that some FIDs, TIDs, etc on the VC have yet to
+ * be cleaned up. If we were not called by smb_CleanupDeadVC(),
+ * add a reference that will be dropped by
+ * smb_CleanupDeadVC() and try to cleanup the VC again.
+ * Eventually the refCount will drop to zero when all of the
+ * active threads working with the VC end their task.
+ */
+ if (!(vcp->flags & SMB_VCFLAG_CLEAN_IN_PROGRESS)) {
+ vcp->refCount++; /* put the refCount back */
+ lock_ReleaseWrite(&smb_rctLock);
+ smb_CleanupDeadVC(vcp);
+#ifdef DEBUG_SMB_REFCOUNT
+ afsi_log("%s:%d smb_ReleaseVCInternal vcp 0x%p after CleanupDeadVC ref %d", file, line, vcp, vcp->refCount);
+ osi_Log4(smb_logp,"%s:%d smb_ReleaseVCInternal vcp 0x%p after CleanupDeadVC ref %d", file, line, vcp, vcp->refCount);
+#endif
+ lock_ObtainWrite(&smb_rctLock);
+ }
+ } else {
+#ifdef DEBUG_SMB_REFCOUNT
+ afsi_log("%s:%d smb_ReleaseVCInternal vcp 0x%p ref %d", file, line, vcp, vcp->refCount);
+ osi_Log4(smb_logp,"%s:%d smb_ReleaseVCInternal vcp 0x%p ref %d", file, line, vcp, vcp->refCount);
+#endif
}
}
+#ifdef DEBUG_SMB_REFCOUNT
+void smb_ReleaseVCNoLockDbg(smb_vc_t *vcp, char * file, long line)
+#else
void smb_ReleaseVCNoLock(smb_vc_t *vcp)
+#endif
{
+ lock_AssertWrite(&smb_rctLock);
osi_Log2(smb_logp,"smb_ReleaseVCNoLock vcp %x ref %d",vcp, vcp->refCount);
smb_ReleaseVCInternal(vcp);
}
+#ifdef DEBUG_SMB_REFCOUNT
+void smb_ReleaseVCDbg(smb_vc_t *vcp, char * file, long line)
+#else
void smb_ReleaseVC(smb_vc_t *vcp)
+#endif
{
lock_ObtainWrite(&smb_rctLock);
osi_Log2(smb_logp,"smb_ReleaseVC vcp %x ref %d",vcp, vcp->refCount);
lock_ReleaseWrite(&smb_rctLock);
}
+#ifdef DEBUG_SMB_REFCOUNT
+void smb_HoldVCNoLockDbg(smb_vc_t *vcp, char * file, long line)
+#else
void smb_HoldVCNoLock(smb_vc_t *vcp)
+#endif
{
+ lock_AssertWrite(&smb_rctLock);
vcp->refCount++;
+#ifdef DEBUG_SMB_REFCOUNT
+ afsi_log("%s:%d smb_HoldVCNoLock vcp 0x%p ref %d", file, line, vcp, vcp->refCount);
+ osi_Log4(smb_logp,"%s:%d smb_HoldVCNoLock vcp 0x%p ref %d", file, line, vcp, vcp->refCount);
+#else
osi_Log2(smb_logp,"smb_HoldVCNoLock vcp %x ref %d",vcp, vcp->refCount);
+#endif
}
+#ifdef DEBUG_SMB_REFCOUNT
+void smb_HoldVCDbg(smb_vc_t *vcp, char * file, long line)
+#else
void smb_HoldVC(smb_vc_t *vcp)
+#endif
{
lock_ObtainWrite(&smb_rctLock);
vcp->refCount++;
+#ifdef DEBUG_SMB_REFCOUNT
+ afsi_log("%s:%d smb_HoldVC vcp 0x%p ref %d", file, line, vcp, vcp->refCount);
+ osi_Log4(smb_logp,"%s:%d smb_HoldVC vcp 0x%p ref %d", file, line, vcp, vcp->refCount);
+#else
osi_Log2(smb_logp,"smb_HoldVC vcp %x ref %d",vcp, vcp->refCount);
+#endif
lock_ReleaseWrite(&smb_rctLock);
}
smb_user_t *uidpIter;
smb_user_t *uidpNext;
smb_vc_t **vcpp;
-
+ afs_uint32 refCount = 0;
lock_ObtainMutex(&vcp->mx);
if (vcp->flags & SMB_VCFLAG_CLEAN_IN_PROGRESS) {
for (fidpIter = vcp->fidsp; fidpIter; fidpIter = fidpNext) {
fidpNext = (smb_fid_t *) osi_QNext(&fidpIter->q);
- if (fidpIter->delete)
+ if (fidpIter->deleteOk)
continue;
fid = fidpIter->fid;
for (tidpIter = vcp->tidsp; tidpIter; tidpIter = tidpNext) {
tidpNext = tidpIter->nextp;
- if (tidpIter->delete)
+ if (tidpIter->deleteOk)
continue;
- tidpIter->delete = 1;
+ tidpIter->deleteOk = 1;
tid = tidpIter->tid;
osi_Log2(smb_logp, " Cleanup TID %d (tidp=0x%x)", tid, tidpIter);
for (uidpIter = vcp->usersp; uidpIter; uidpIter = uidpNext) {
uidpNext = uidpIter->nextp;
- if (uidpIter->delete)
+ if (uidpIter->deleteOk)
continue;
- uidpIter->delete = 1;
+ uidpIter->deleteOk = 1;
/* do not add an additional reference count for the smb_user_t
* as the smb_vc_t already is holding a reference */
}
/* The vcp is now on the deadVCsp list. We intentionally drop the
- * reference so that the refcount can reach 0 and we can delete it */
+ * reference so that the refcount can reach 0 and we can delete it
+ *
+ * If the refCount == 1 going into the ReleaseVCNoLock call
+ * the object will be freed and it won't be safe to clear
+ * the flag.
+ */
+ refCount = vcp->refCount;
smb_ReleaseVCNoLock(vcp);
-
+ if (refCount > 1) {
+ lock_ObtainMutex(&vcp->mx);
+ vcp->flags &= ~SMB_VCFLAG_CLEAN_IN_PROGRESS;
+ lock_ReleaseMutex(&vcp->mx);
+ }
+
lock_ReleaseWrite(&smb_rctLock);
osi_Log1(smb_logp, "Finished cleaning up dead vcp 0x%x", vcp);
}
+#ifdef DEBUG_SMB_REFCOUNT
+smb_tid_t *smb_FindTIDDbg(smb_vc_t *vcp, unsigned short tid, int flags, char * file, long line)
+#else
smb_tid_t *smb_FindTID(smb_vc_t *vcp, unsigned short tid, int flags)
+#endif
{
smb_tid_t *tidp;
lock_ObtainWrite(&smb_rctLock);
retry:
for (tidp = vcp->tidsp; tidp; tidp = tidp->nextp) {
- if (tidp->refCount == 0 && tidp->delete) {
+ if (tidp->refCount == 0 && tidp->deleteOk) {
tidp->refCount++;
smb_ReleaseTID(tidp, TRUE);
goto retry;
if (tid == tidp->tid) {
tidp->refCount++;
break;
- }
+ }
}
if (!tidp && (flags & SMB_FLAG_CREATE)) {
tidp = malloc(sizeof(*tidp));
tidp->vcp = vcp;
smb_HoldVCNoLock(vcp);
vcp->tidsp = tidp;
- lock_InitializeMutex(&tidp->mx, "tid_t mutex");
+ lock_InitializeMutex(&tidp->mx, "tid_t mutex", LOCK_HIERARCHY_SMB_TID);
tidp->tid = tid;
}
+#ifdef DEBUG_SMB_REFCOUNT
+ if (tidp) {
+ afsi_log("%s:%d smb_FindTID tidp 0x%p ref %d", file, line, tidp, tidp->refCount);
+ osi_Log4(smb_logp,"%s:%d smb_FindTID tidp 0x%p ref %d", file, line, tidp, tidp->refCount);
+ }
+#endif
lock_ReleaseWrite(&smb_rctLock);
return tidp;
-}
+}
+#ifdef DEBUG_SMB_REFCOUNT
+void smb_HoldTIDNoLockDbg(smb_tid_t *tidp, char * file, long line)
+#else
void smb_HoldTIDNoLock(smb_tid_t *tidp)
+#endif
{
+ lock_AssertWrite(&smb_rctLock);
tidp->refCount++;
+#ifdef DEBUG_SMB_REFCOUNT
+ afsi_log("%s:%d smb_HoldTIDNoLock tidp 0x%p ref %d", file, line, tidp, tidp->refCount);
+ osi_Log4(smb_logp,"%s:%d smb_HoldTIDNoLock tidp 0x%p ref %d", file, line, tidp, tidp->refCount);
+#endif
}
+#ifdef DEBUG_SMB_REFCOUNT
+void smb_ReleaseTIDDbg(smb_tid_t *tidp, afs_uint32 locked, char *file, long line)
+#else
void smb_ReleaseTID(smb_tid_t *tidp, afs_uint32 locked)
+#endif
{
smb_tid_t *tp;
smb_tid_t **ltpp;
- cm_user_t *userp;
+ cm_user_t *userp = NULL;
+ smb_vc_t *vcp = NULL;
- userp = NULL;
if (!locked)
lock_ObtainWrite(&smb_rctLock);
+ else
+ lock_AssertWrite(&smb_rctLock);
+
osi_assertx(tidp->refCount-- > 0, "smb_tid_t refCount 0");
- if (tidp->refCount == 0 && (tidp->delete)) {
- ltpp = &tidp->vcp->tidsp;
- for(tp = *ltpp; tp; ltpp = &tp->nextp, tp = *ltpp) {
- if (tp == tidp)
- break;
+#ifdef DEBUG_SMB_REFCOUNT
+ afsi_log("%s:%d smb_ReleaseTID tidp 0x%p ref %d deleteOk %d", file, line, tidp, tidp->refCount, tidp->deleteOk);
+ osi_Log5(smb_logp,"%s:%d smb_ReleaseTID tidp 0x%p ref %d deleteOk %d", file, line, tidp, tidp->refCount, tidp->deleteOk);
+#endif
+ if (tidp->refCount == 0) {
+ if (tidp->deleteOk) {
+ ltpp = &tidp->vcp->tidsp;
+ for(tp = *ltpp; tp; ltpp = &tp->nextp, tp = *ltpp) {
+ if (tp == tidp)
+ break;
+ }
+ osi_assertx(tp != NULL, "null smb_tid_t");
+ *ltpp = tp->nextp;
+ lock_FinalizeMutex(&tidp->mx);
+ userp = tidp->userp; /* remember to drop ref later */
+ tidp->userp = NULL;
+ vcp = tidp->vcp;
+ tidp->vcp = NULL;
+ free(tidp);
}
- osi_assertx(tp != NULL, "null smb_tid_t");
- *ltpp = tp->nextp;
- lock_FinalizeMutex(&tidp->mx);
- userp = tidp->userp; /* remember to drop ref later */
- tidp->userp = NULL;
- smb_ReleaseVCNoLock(tidp->vcp);
- tidp->vcp = NULL;
}
+ if (vcp)
+ smb_ReleaseVCNoLock(vcp);
if (!locked)
lock_ReleaseWrite(&smb_rctLock);
if (userp)
for(uidp = vcp->usersp; uidp; uidp = uidp->nextp) {
if (uid == uidp->userID) {
uidp->refCount++;
- osi_Log3(smb_logp, "smb_FindUID vcp[0x%p] found-uid[%d] name[%s]",
+ osi_Log3(smb_logp, "smb_FindUID vcp[0x%p] found-uid[%d] name[%S]",
vcp, uidp->userID,
- osi_LogSaveString(smb_logp, (uidp->unp) ? uidp->unp->name : ""));
+ ((uidp->unp)? osi_LogSaveClientString(smb_logp, uidp->unp->name):_C("")));
break;
}
}
uidp->vcp = vcp;
smb_HoldVCNoLock(vcp);
vcp->usersp = uidp;
- lock_InitializeMutex(&uidp->mx, "user_t mutex");
+ lock_InitializeMutex(&uidp->mx, "user_t mutex", LOCK_HIERARCHY_SMB_UID);
uidp->userID = uid;
- osi_Log3(smb_logp, "smb_FindUID vcp[0x%p] new-uid[%d] name[%s]",
- vcp, uidp->userID,
- osi_LogSaveString(smb_logp,uidp->unp ? uidp->unp->name : ""));
+ osi_Log3(smb_logp, "smb_FindUID vcp[0x%p] new-uid[%d] name[%S]",
+ vcp, uidp->userID,
+ ((uidp->unp)?osi_LogSaveClientString(smb_logp,uidp->unp->name):_C("")));
}
lock_ReleaseWrite(&smb_rctLock);
return uidp;
}
-smb_username_t *smb_FindUserByName(char *usern, char *machine, afs_uint32 flags)
+smb_username_t *smb_FindUserByName(clientchar_t *usern, clientchar_t *machine,
+ afs_uint32 flags)
{
smb_username_t *unp= NULL;
lock_ObtainWrite(&smb_rctLock);
for(unp = usernamesp; unp; unp = unp->nextp) {
- if (stricmp(unp->name, usern) == 0 &&
- stricmp(unp->machine, machine) == 0) {
+ if (cm_ClientStrCmpI(unp->name, usern) == 0 &&
+ cm_ClientStrCmpI(unp->machine, machine) == 0) {
unp->refCount++;
break;
}
memset(unp, 0, sizeof(*unp));
unp->refCount = 1;
unp->nextp = usernamesp;
- unp->name = strdup(usern);
- unp->machine = strdup(machine);
+ unp->name = cm_ClientStrDup(usern);
+ unp->machine = cm_ClientStrDup(machine);
usernamesp = unp;
- lock_InitializeMutex(&unp->mx, "username_t mutex");
+ lock_InitializeMutex(&unp->mx, "username_t mutex", LOCK_HIERARCHY_SMB_USERNAME);
if (flags & SMB_FLAG_AFSLOGON)
unp->flags = SMB_USERNAMEFLAG_AFSLOGON;
}
return unp;
}
-smb_user_t *smb_FindUserByNameThisSession(smb_vc_t *vcp, char *usern)
+smb_user_t *smb_FindUserByNameThisSession(smb_vc_t *vcp, clientchar_t *usern)
{
smb_user_t *uidp= NULL;
for(uidp = vcp->usersp; uidp; uidp = uidp->nextp) {
if (!uidp->unp)
continue;
- if (stricmp(uidp->unp->name, usern) == 0) {
+ if (cm_stricmp_utf16(uidp->unp->name, usern) == 0) {
uidp->refCount++;
- osi_Log3(smb_logp,"smb_FindUserByNameThisSession vcp[0x%p] uid[%d] match-name[%s]",
- vcp,uidp->userID,osi_LogSaveString(smb_logp,usern));
+ osi_Log3(smb_logp,"smb_FindUserByNameThisSession vcp[0x%p] uid[%d] match-name[%S]",
+ vcp,uidp->userID,osi_LogSaveClientString(smb_logp,usern));
break;
} else
continue;
free(unp->name);
free(unp->machine);
free(unp);
- }
+ }
lock_ReleaseWrite(&smb_rctLock);
if (userp)
cm_ReleaseUser(userp);
void smb_HoldUIDNoLock(smb_user_t *uidp)
{
+ lock_AssertWrite(&smb_rctLock);
uidp->refCount++;
}
* Return a pointer to a pathname extracted from a TID structure. The
* TID structure is not held; assume it won't go away.
*/
-long smb_LookupTIDPath(smb_vc_t *vcp, unsigned short tid, char ** treepath)
+long smb_LookupTIDPath(smb_vc_t *vcp, unsigned short tid, clientchar_t ** treepath)
{
smb_tid_t *tidp;
long code = 0;
* If the SMB_FLAG_CREATE flag is set, we allocate a new
* smb_fid_t data structure if desired File ID cannot be found.
*/
+#ifdef DEBUG_SMB_REFCOUNT
+smb_fid_t *smb_FindFIDDbg(smb_vc_t *vcp, unsigned short fid, int flags, char *file, long line)
+#else
smb_fid_t *smb_FindFID(smb_vc_t *vcp, unsigned short fid, int flags)
+#endif
{
smb_fid_t *fidp;
int newFid = 0;
- if (fid == 0 && !(flags & SMB_FLAG_CREATE))
- return NULL;
-
- lock_ObtainWrite(&smb_rctLock);
- /* figure out if we need to allocate a new file ID */
if (fid == 0) {
+ if (!(flags & SMB_FLAG_CREATE))
+ return NULL;
newFid = 1;
- fid = vcp->fidCounter;
}
+ lock_ObtainWrite(&smb_rctLock);
+ if (newFid)
+ fid = vcp->fidCounter;
retry:
+
for(fidp = vcp->fidsp; fidp; fidp = (smb_fid_t *) osi_QNext(&fidp->q)) {
- if (fidp->refCount == 0 && fidp->delete) {
+ if (fidp->refCount == 0 && fidp->deleteOk) {
fidp->refCount++;
lock_ReleaseWrite(&smb_rctLock);
smb_ReleaseFID(fidp);
lock_ObtainWrite(&smb_rctLock);
+ /*
+ * We dropped the smb_rctLock so the fid value we are using
+ * may now be used by another thread. Start over with the
+ * current vcp->fidCounter.
+ */
+ if (newFid)
+ fid = vcp->fidCounter;
goto retry;
}
if (fid == fidp->fid) {
if (newFid) {
+ osi_Log1(smb_logp, "smb_FindFID New Fid Requested. fid %d found -- retrying ...", fid);
fid++;
if (fid == 0xFFFF) {
osi_Log1(smb_logp,
if (!fidp && (flags & SMB_FLAG_CREATE)) {
char eventName[MAX_PATH];
EVENT_HANDLE event;
+
+ if (!newFid)
+ osi_Log1(smb_logp, "smb_FindFID New Fid Not Requested, Fid %d Not Found and CREATE flag set.", fid);
+ else
+ osi_Log1(smb_logp, "smb_FindFID New Fid Requested. Creating fid %d", fid);
+
sprintf(eventName,"fid_t event vcp=%d fid=%d", vcp->vcID, fid);
event = thrd_CreateEvent(NULL, FALSE, TRUE, eventName);
if ( GetLastError() == ERROR_ALREADY_EXISTS ) {
fidp->refCount = 1;
fidp->vcp = vcp;
smb_HoldVCNoLock(vcp);
- lock_InitializeMutex(&fidp->mx, "fid_t mutex");
+ lock_InitializeMutex(&fidp->mx, "fid_t mutex", LOCK_HIERARCHY_SMB_FID);
fidp->fid = fid;
fidp->curr_chunk = fidp->prev_chunk = -2;
fidp->raw_write_event = event;
}
}
+#ifdef DEBUG_SMB_REFCOUNT
+ if (fidp) {
+ afsi_log("%s:%d smb_FindFID fidp 0x%p ref %d", file, line, fidp, fidp->refCount);
+ osi_Log4(smb_logp,"%s:%d smb_FindFID fidp 0x%p ref %d", file, line, fidp, fidp->refCount);
+ }
+#endif
lock_ReleaseWrite(&smb_rctLock);
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);
+ osi_Log4(smb_logp,"%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
+void smb_HoldFIDNoLockDbg(smb_fid_t *fidp, char *file, long line)
+#else
void smb_HoldFIDNoLock(smb_fid_t *fidp)
+#endif
{
+ lock_AssertWrite(&smb_rctLock);
fidp->refCount++;
+#ifdef DEBUG_SMB_REFCOUNT
+ afsi_log("%s:%d smb_HoldFIDNoLock fidp 0x%p ref %d", file, line, fidp, fidp->refCount);
+ osi_Log4(smb_logp,"%s:%d smb_HoldFIDNoLock fidp 0x%p ref %d", file, line, fidp, fidp->refCount);
+#endif
}
-/* 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
void smb_ReleaseFID(smb_fid_t *fidp)
+#endif
{
cm_scache_t *scp = NULL;
cm_user_t *userp = NULL;
lock_ObtainMutex(&fidp->mx);
lock_ObtainWrite(&smb_rctLock);
osi_assertx(fidp->refCount-- > 0, "smb_fid_t refCount 0");
- if (fidp->refCount == 0 && (fidp->delete)) {
- vcp = fidp->vcp;
- fidp->vcp = NULL;
- scp = fidp->scp; /* release after lock is released */
- if (scp) {
- lock_ObtainMutex(&scp->mx);
- scp->flags &= ~CM_SCACHEFLAG_SMB_FID;
- lock_ReleaseMutex(&scp->mx);
- osi_Log2(smb_logp,"smb_ReleaseFID fidp 0x%p scp 0x%p", fidp, scp);
- fidp->scp = NULL;
- }
- userp = fidp->userp;
- fidp->userp = NULL;
+#ifdef DEBUG_SMB_REFCOUNT
+ afsi_log("%s:%d smb_ReleaseFID fidp 0x%p ref %d deleteOk %d", file, line, fidp, fidp->refCount, fidp->deleteOk);
+ osi_Log5(smb_logp,"%s:%d smb_ReleaseFID fidp 0x%p ref %d deleteOk %d", file, line, fidp, fidp->refCount, fidp->deleteOk);
+#endif
+ if (fidp->refCount == 0) {
+ if (fidp->deleteOk) {
+ vcp = fidp->vcp;
+ fidp->vcp = NULL;
+ scp = fidp->scp; /* release after lock is released */
+ if (scp) {
+ lock_ObtainWrite(&scp->rw);
+ scp->flags &= ~CM_SCACHEFLAG_SMB_FID;
+ lock_ReleaseWrite(&scp->rw);
+ osi_Log2(smb_logp,"smb_ReleaseFID fidp 0x%p scp 0x%p", fidp, scp);
+ fidp->scp = NULL;
+ }
+ userp = fidp->userp;
+ fidp->userp = NULL;
- if (vcp->fidsp)
- osi_QRemove((osi_queue_t **) &vcp->fidsp, &fidp->q);
- thrd_CloseHandle(fidp->raw_write_event);
+ if (vcp->fidsp)
+ osi_QRemove((osi_queue_t **) &vcp->fidsp, &fidp->q);
+ thrd_CloseHandle(fidp->raw_write_event);
- /* and see if there is ioctl stuff to free */
- ioctlp = fidp->ioctlp;
- if (ioctlp) {
- if (ioctlp->prefix)
+ /* and see if there is ioctl stuff to free */
+ ioctlp = fidp->ioctlp;
+ if (ioctlp) {
+ if (ioctlp->prefix)
cm_FreeSpace(ioctlp->prefix);
- if (ioctlp->inAllocp)
- free(ioctlp->inAllocp);
- if (ioctlp->outAllocp)
- free(ioctlp->outAllocp);
- free(ioctlp);
- }
- lock_ReleaseMutex(&fidp->mx);
- lock_FinalizeMutex(&fidp->mx);
- free(fidp);
+ if (ioctlp->ioctl.inAllocp)
+ free(ioctlp->ioctl.inAllocp);
+ if (ioctlp->ioctl.outAllocp)
+ free(ioctlp->ioctl.outAllocp);
+ free(ioctlp);
+ }
- if (vcp)
- smb_ReleaseVCNoLock(vcp);
- } else {
- lock_ReleaseMutex(&fidp->mx);
+ smb_CleanupRPCFid(fidp);
+
+ lock_ReleaseMutex(&fidp->mx);
+ lock_FinalizeMutex(&fidp->mx);
+ free(fidp);
+ fidp = NULL;
+
+ if (vcp)
+ smb_ReleaseVCNoLock(vcp);
+ }
}
+ if (fidp)
+ lock_ReleaseMutex(&fidp->mx);
+
lock_ReleaseWrite(&smb_rctLock);
/* now release the scache structure */
* Case-insensitive search for one string in another;
* used to find variable names in submount pathnames.
*/
-static char *smb_stristr(char *str1, char *str2)
+static clientchar_t *smb_stristr(clientchar_t *str1, clientchar_t *str2)
{
- char *cursor;
+ clientchar_t *cursor;
for (cursor = str1; *cursor; cursor++)
- if (stricmp(cursor, str2) == 0)
+ if (cm_ClientStrCmpI(cursor, str2) == 0)
return cursor;
return NULL;
* name has been identified by smb_stristr() and is in substr. Variable name
* length (plus one) is in substr_size. Variable value is in newstr.
*/
-static void smb_subst(char *str1, char *substr, unsigned int substr_size,
- char *newstr)
+static void smb_subst(clientchar_t *str1, int cchstr1, clientchar_t *substr,
+ unsigned int substr_size, clientchar_t *newstr)
{
- char temp[1024];
-
- strcpy(temp, substr + substr_size - 1);
- strcpy(substr, newstr);
- strcat(str1, temp);
-}
+ clientchar_t temp[1024];
-char VNUserName[] = "%USERNAME%";
-char VNLCUserName[] = "%LCUSERNAME%";
-char VNComputerName[] = "%COMPUTERNAME%";
-char VNLCComputerName[] = "%LCCOMPUTERNAME%";
+ cm_ClientStrCpy(temp, lengthof(temp), substr + substr_size - 1);
+ cm_ClientStrCpy(substr, cchstr1 - (substr - str1), newstr);
+ cm_ClientStrCat(str1, cchstr1, temp);
+}
+clientchar_t VNUserName[] = _C("%USERNAME%");
+clientchar_t VNLCUserName[] = _C("%LCUSERNAME%");
+clientchar_t VNComputerName[] = _C("%COMPUTERNAME%");
+clientchar_t VNLCComputerName[] = _C("%LCCOMPUTERNAME%");
typedef struct smb_findShare_rock {
- char * shareName;
- char * match;
+ clientchar_t * shareName;
+ clientchar_t * match;
int matchType;
} smb_findShare_rock_t;
{
int matchType = 0;
smb_findShare_rock_t * vrock = (smb_findShare_rock_t *) rockp;
- if (!strnicmp(dep->name, vrock->shareName, 12)) {
- if(!stricmp(dep->name, vrock->shareName))
+ normchar_t normName[MAX_PATH];
+
+ if (cm_FsStringToNormString(dep->name, -1, normName, sizeof(normName)/sizeof(normName[0])) == 0) {
+ osi_Log1(smb_logp, "Skipping entry [%s]. Can't normalize FS string",
+ osi_LogSaveString(smb_logp, dep->name));
+ return 0;
+ }
+
+ if (!cm_ClientStrCmpNI(normName, vrock->shareName, 12)) {
+ if(!cm_ClientStrCmpI(normName, vrock->shareName))
matchType = SMB_FINDSHARE_EXACT_MATCH;
else
matchType = SMB_FINDSHARE_PARTIAL_MATCH;
- if(vrock->match) free(vrock->match);
- vrock->match = strdup(dep->name);
+ if(vrock->match)
+ free(vrock->match);
+ vrock->match = cm_FsStringToClientStringAlloc(dep->name, -1, NULL);
vrock->matchType = matchType;
if(matchType == SMB_FINDSHARE_EXACT_MATCH)
/* find a shareName in the table of submounts */
-int smb_FindShare(smb_vc_t *vcp, smb_user_t *uidp, char *shareName,
- char **pathNamep)
-{
- DWORD len;
- char pathName[1024];
- char *var;
- char temp[1024];
+int smb_FindShare(smb_vc_t *vcp, smb_user_t *uidp,
+ clientchar_t *shareName,
+ clientchar_t **pathNamep)
+{
+ DWORD cblen;
+ DWORD cchlen;
+ clientchar_t pathName[1024];
+ clientchar_t *var;
DWORD sizeTemp;
- char *p, *q;
+ clientchar_t *p, *q;
+ fschar_t *cellname = NULL;
HKEY parmKey;
DWORD code;
DWORD allSubmount = 1;
* world to do so.
*/
code = RegOpenKeyEx(HKEY_LOCAL_MACHINE, AFSREG_CLT_SVC_PARAM_SUBKEY,
- 0, KEY_QUERY_VALUE, &parmKey);
+ 0, KEY_QUERY_VALUE, &parmKey);
if (code == ERROR_SUCCESS) {
- len = sizeof(allSubmount);
+ cblen = sizeof(allSubmount);
code = RegQueryValueEx(parmKey, "AllSubmount", NULL, NULL,
- (BYTE *) &allSubmount, &len);
+ (BYTE *) &allSubmount, &cblen);
if (code != ERROR_SUCCESS) {
allSubmount = 1;
}
RegCloseKey (parmKey);
}
- if (allSubmount && _stricmp(shareName, "all") == 0) {
+ if (allSubmount && cm_ClientStrCmpI(shareName, _C("all")) == 0) {
*pathNamep = NULL;
return 1;
}
/* In case, the all share is disabled we need to still be able
* to handle ioctl requests
*/
- if (_stricmp(shareName, "ioctl$") == 0) {
- *pathNamep = strdup("/.__ioctl__");
+ if (cm_ClientStrCmpI(shareName, _C("ioctl$")) == 0) {
+ *pathNamep = cm_ClientStrDup(_C("/.__ioctl__"));
return 1;
}
- if (_stricmp(shareName, "IPC$") == 0 ||
- _stricmp(shareName, "srvsvc") == 0 ||
- _stricmp(shareName, "wkssvc") == 0 ||
- _stricmp(shareName, SMB_IOCTL_FILENAME_NOSLASH) == 0 ||
- _stricmp(shareName, "DESKTOP.INI") == 0
- ) {
+ if (MSRPC_IsWellKnownService(shareName) ||
+ cm_ClientStrCmpIA(shareName, _C(SMB_IOCTL_FILENAME_NOSLASH)) == 0 ||
+ cm_ClientStrCmpIA(shareName, _C("DESKTOP.INI")) == 0
+ ) {
*pathNamep = NULL;
return 0;
}
*
* They look like <cell>{%,#}<volume>
*/
- if (strchr(shareName, '%') != NULL ||
- strchr(shareName, '#') != NULL) {
- char pathstr[CELL_MAXNAMELEN + VL_MAXNAMELEN + 1 + CM_PREFIX_VOL_CCH];
- /* make room for '/@vol:' + mountchar + NULL terminator*/
+ if (cm_ClientStrChr(shareName, '%') != NULL ||
+ cm_ClientStrChr(shareName, '#') != NULL) {
+ clientchar_t pathstr[CELL_MAXNAMELEN + VL_MAXNAMELEN + 1 + CM_PREFIX_VOL_CCH];
+ /* make room for '/@vol:' + mountchar + NULL terminator*/
- osi_Log1(smb_logp, "smb_FindShare found volume reference [%s]",
- osi_LogSaveString(smb_logp, shareName));
+ osi_Log1(smb_logp, "smb_FindShare found volume reference [%S]",
+ osi_LogSaveClientString(smb_logp, shareName));
- snprintf(pathstr, sizeof(pathstr)/sizeof(char),
- "/" CM_PREFIX_VOL "%s", shareName);
- pathstr[sizeof(pathstr)/sizeof(char) - 1] = '\0';
- len = strlen(pathstr) + 1;
+ cm_ClientStrPrintfN(pathstr, lengthof(pathstr),
+ _C("/") _C(CM_PREFIX_VOL) _C("%s"), shareName);
+ cchlen = (DWORD)(cm_ClientStrLen(pathstr) + 1);
- *pathNamep = malloc(len);
+ *pathNamep = malloc(cchlen * sizeof(clientchar_t));
if (*pathNamep) {
- strcpy(*pathNamep, pathstr);
- strlwr(*pathNamep);
- osi_Log1(smb_logp, " returning pathname [%s]",
- osi_LogSaveString(smb_logp, *pathNamep));
+ cm_ClientStrCpy(*pathNamep, cchlen, pathstr);
+ cm_ClientStrLwr(*pathNamep);
+ osi_Log1(smb_logp, " returning pathname [%S]",
+ osi_LogSaveClientString(smb_logp, *pathNamep));
return 1;
} else {
}
code = RegOpenKeyEx(HKEY_LOCAL_MACHINE, AFSREG_CLT_OPENAFS_SUBKEY "\\Submounts",
- 0, KEY_QUERY_VALUE, &parmKey);
+ 0, KEY_QUERY_VALUE, &parmKey);
if (code == ERROR_SUCCESS) {
- len = sizeof(pathName);
- code = RegQueryValueEx(parmKey, shareName, NULL, NULL,
- (BYTE *) pathName, &len);
+ cblen = sizeof(pathName);
+ code = RegQueryValueExW(parmKey, shareName, NULL, NULL,
+ (BYTE *) pathName, &cblen);
if (code != ERROR_SUCCESS)
- len = 0;
+ cblen = 0;
RegCloseKey (parmKey);
} else {
- len = 0;
- }
- if (len != 0 && len != sizeof(pathName) - 1) {
+ cblen = 0;
+ }
+ cchlen = cblen / sizeof(clientchar_t);
+ if (cchlen != 0 && cchlen != lengthof(pathName) - 1) {
/* We can accept either unix or PC style AFS pathnames. Convert
* Unix-style to PC style here for internal use.
*/
p = pathName;
- if (strncmp(p, cm_mountRoot, strlen(cm_mountRoot)) == 0)
- p += strlen(cm_mountRoot); /* skip mount path */
+ cchlen = lengthof(pathName);
+
+ /* within this code block, we maintain, cchlen = writeable
+ buffer length of p */
+
+ if (cm_ClientStrCmpN(p, cm_mountRootC, cm_mountRootCLen) == 0) {
+ p += cm_mountRootCLen; /* skip mount path */
+ cchlen -= (DWORD)(p - pathName);
+ }
+
q = p;
while (*q) {
- if (*q == '/') *q = '\\'; /* change to \ */
+ if (*q == _C('/')) *q = _C('\\'); /* change to \ */
q++;
}
while (1)
{
+ clientchar_t temp[1024];
+
if (var = smb_stristr(p, VNUserName)) {
if (uidp && uidp->unp)
- smb_subst(p, var, sizeof(VNUserName),uidp->unp->name);
+ smb_subst(p, cchlen, var, lengthof(VNUserName),uidp->unp->name);
else
- smb_subst(p, var, sizeof(VNUserName)," ");
+ smb_subst(p, cchlen, var, lengthof(VNUserName), _C(" "));
}
else if (var = smb_stristr(p, VNLCUserName))
{
if (uidp && uidp->unp)
- strcpy(temp, uidp->unp->name);
+ cm_ClientStrCpy(temp, lengthof(temp), uidp->unp->name);
else
- strcpy(temp, " ");
- _strlwr(temp);
- smb_subst(p, var, sizeof(VNLCUserName), temp);
+ cm_ClientStrCpy(temp, lengthof(temp), _C(" "));
+ cm_ClientStrLwr(temp);
+ smb_subst(p, cchlen, var, lengthof(VNLCUserName), temp);
}
else if (var = smb_stristr(p, VNComputerName))
{
- sizeTemp = sizeof(temp);
- GetComputerName((LPTSTR)temp, &sizeTemp);
- smb_subst(p, var, sizeof(VNComputerName), temp);
+ sizeTemp = lengthof(temp);
+ GetComputerNameW(temp, &sizeTemp);
+ smb_subst(p, cchlen, var, lengthof(VNComputerName), temp);
}
else if (var = smb_stristr(p, VNLCComputerName))
{
- sizeTemp = sizeof(temp);
+ sizeTemp = lengthof(temp);
GetComputerName((LPTSTR)temp, &sizeTemp);
- _strlwr(temp);
- smb_subst(p, var, sizeof(VNLCComputerName), temp);
+ cm_ClientStrLwr(temp);
+ smb_subst(p, cchlen, var, lengthof(VNLCComputerName), temp);
}
else
break;
}
- *pathNamep = strdup(p);
+ *pathNamep = cm_ClientStrDup(p);
return 1;
}
else
cm_req_t req;
smb_findShare_rock_t vrock;
osi_hyper_t thyper;
- char * p = shareName;
+ fschar_t ftemp[1024];
+ clientchar_t * p = shareName;
int rw = 0;
/* attempt to locate a partial match in root.afs. This is because
when using the ANSI RAP calls, the share name is limited to 13 chars
and hence is truncated. Of course we prefer exact matches. */
- cm_InitReq(&req);
+ smb_InitReq(&req);
thyper.HighPart = 0;
thyper.LowPart = 0;
- vrock.shareName = shareName;
+ vrock.shareName = cm_ClientStringToNormStringAlloc(shareName, -1, NULL);
+ if (vrock.shareName == NULL)
+ return 0;
vrock.match = NULL;
vrock.matchType = 0;
cm_HoldSCache(cm_data.rootSCachep);
code = cm_ApplyDir(cm_data.rootSCachep, smb_FindShareProc, &vrock, &thyper,
- (uidp? (uidp->unp ? uidp->unp->userp : NULL) : NULL), &req, NULL);
+ (uidp? (uidp->unp ? uidp->unp->userp : NULL) : NULL), &req, NULL);
cm_ReleaseSCache(cm_data.rootSCachep);
+ free(vrock.shareName);
+ vrock.shareName = NULL;
+
if (vrock.matchType) {
- sprintf(pathName,"/%s/",vrock.match);
- *pathNamep = strdup(strlwr(pathName));
+ cm_ClientStrPrintfN(pathName, lengthof(pathName), _C("/%s/"), vrock.match);
+ *pathNamep = cm_ClientStrDup(cm_ClientStrLwr(pathName));
free(vrock.match);
return 1;
}
rw = 1;
}
/* Get the full name for this cell */
- code = cm_SearchCellFile(p, temp, 0, 0);
-#ifdef AFS_AFSDB_ENV
+ cellname = cm_ClientStringToFsStringAlloc(p, -1, NULL);
+ code = cm_SearchCellRegistry(1, cellname, ftemp, 0, 0, 0);
+ if (code && code != CM_ERROR_FORCE_DNS_LOOKUP)
+ code = cm_SearchCellFile(cellname, ftemp, 0, 0);
if (code && cm_dnsEnabled) {
int ttl;
- code = cm_SearchCellByDNS(p, temp, &ttl, 0, 0);
+ code = cm_SearchCellByDNS(cellname, ftemp, &ttl, 0, 0);
}
-#endif
+ if (cellname)
+ free(cellname);
+
/* construct the path */
- if (code == 0) {
- sprintf(pathName,rw ? "/.%s/" : "/%s/",temp);
- *pathNamep = strdup(strlwr(pathName));
+ if (code == 0) {
+ clientchar_t temp[1024];
+
+ if (cm_FsStringToClientString(ftemp, -1, temp, 1024) != 0) {
+ cm_ClientStrPrintfN(pathName, (int)lengthof(pathName),
+ rw ? _C("/.%S/") : _C("/%S/"), temp);
+ *pathNamep = cm_ClientStrDup(cm_ClientStrLwr(pathName));
return 1;
}
}
+ }
/* failure */
*pathNamep = NULL;
return 0;
#define CSC_POLICY_PROGRAMS 2
#define CSC_POLICY_DISABLE 3
-int smb_FindShareCSCPolicy(char *shareName)
+int smb_FindShareCSCPolicy(clientchar_t *shareName)
{
DWORD len;
- char policy[1024];
+ clientchar_t policy[1024];
DWORD dwType;
HKEY hkCSCPolicy;
int retval = CSC_POLICY_MANUAL;
- RegCreateKeyEx( HKEY_LOCAL_MACHINE,
- AFSREG_CLT_OPENAFS_SUBKEY "\\CSCPolicy",
- 0,
- "AFS",
- REG_OPTION_NON_VOLATILE,
- KEY_READ,
- NULL,
- &hkCSCPolicy,
- NULL );
+ if (RegCreateKeyEx( HKEY_LOCAL_MACHINE,
+ AFSREG_CLT_OPENAFS_SUBKEY "\\CSCPolicy",
+ 0,
+ "AFS",
+ REG_OPTION_NON_VOLATILE,
+ KEY_READ,
+ NULL,
+ &hkCSCPolicy,
+ NULL ) != ERROR_SUCCESS)
+ retval = cm_ClientStrCmpIA(_C("all"),shareName) ? CSC_POLICY_MANUAL : CSC_POLICY_DISABLE;
len = sizeof(policy);
- if ( RegQueryValueEx( hkCSCPolicy, shareName, 0, &dwType, policy, &len ) ||
+ if ( RegQueryValueExW( hkCSCPolicy, shareName, 0, &dwType, (LPBYTE) policy, &len ) ||
len == 0) {
- retval = stricmp("all",shareName) ? CSC_POLICY_MANUAL : CSC_POLICY_DISABLE;
+ retval = cm_ClientStrCmpIA(_C("all"),shareName) ? CSC_POLICY_MANUAL : CSC_POLICY_DISABLE;
+ }
+ else if (cm_ClientStrCmpIA(policy, _C("manual")) == 0)
+ {
+ retval = CSC_POLICY_MANUAL;
}
- else if (stricmp(policy, "documents") == 0)
+ else if (cm_ClientStrCmpIA(policy, _C("documents")) == 0)
{
retval = CSC_POLICY_DOCUMENTS;
}
- else if (stricmp(policy, "programs") == 0)
+ else if (cm_ClientStrCmpIA(policy, _C("programs")) == 0)
{
retval = CSC_POLICY_PROGRAMS;
}
- else if (stricmp(policy, "disable") == 0)
+ else if (cm_ClientStrCmpIA(policy, _C("disable")) == 0)
{
retval = CSC_POLICY_DISABLE;
}
if (!smb_lastDirSearchp)
smb_lastDirSearchp = (smb_dirSearch_t *) &dsp->q;
}
- lock_ObtainMutex(&dsp->mx);
dsp->refCount++;
- lock_ReleaseMutex(&dsp->mx);
break;
}
}
void smb_DeleteDirSearch(smb_dirSearch_t *dsp)
{
- lock_ObtainWrite(&smb_globalLock);
lock_ObtainMutex(&dsp->mx);
osi_Log3(smb_logp,"smb_DeleteDirSearch cookie %d dsp 0x%p scp 0x%p",
dsp->cookie, dsp, dsp->scp);
dsp->flags |= SMB_DIRSEARCH_DELETE;
if (dsp->scp != NULL) {
- lock_ObtainMutex(&dsp->scp->mx);
+ lock_ObtainWrite(&dsp->scp->rw);
if (dsp->flags & SMB_DIRSEARCH_BULKST) {
dsp->flags &= ~SMB_DIRSEARCH_BULKST;
dsp->scp->flags &= ~CM_SCACHEFLAG_BULKSTATTING;
dsp->scp->bulkStatProgress = hzero;
}
- lock_ReleaseMutex(&dsp->scp->mx);
+ lock_ReleaseWrite(&dsp->scp->rw);
}
lock_ReleaseMutex(&dsp->mx);
- lock_ReleaseWrite(&smb_globalLock);
}
/* Must be called with the smb_globalLock held */
{
cm_scache_t *scp = NULL;
- lock_ObtainMutex(&dsp->mx);
osi_assertx(dsp->refCount-- > 0, "cm_scache_t refCount 0");
- if (dsp->refCount == 0 && (dsp->flags & SMB_DIRSEARCH_DELETE)) {
- if (&dsp->q == (osi_queue_t *) smb_lastDirSearchp)
- smb_lastDirSearchp = (smb_dirSearch_t *) osi_QPrev(&smb_lastDirSearchp->q);
- osi_QRemove((osi_queue_t **) &smb_firstDirSearchp, &dsp->q);
- lock_ReleaseMutex(&dsp->mx);
- lock_FinalizeMutex(&dsp->mx);
- scp = dsp->scp;
- osi_Log3(smb_logp,"smb_ReleaseDirSearch cookie %d dsp 0x%p scp 0x%p",
- dsp->cookie, dsp, scp);
- free(dsp);
- } else {
- lock_ReleaseMutex(&dsp->mx);
+ if (dsp->refCount == 0) {
+ lock_ObtainMutex(&dsp->mx);
+ if (dsp->flags & SMB_DIRSEARCH_DELETE) {
+ if (&dsp->q == (osi_queue_t *) smb_lastDirSearchp)
+ smb_lastDirSearchp = (smb_dirSearch_t *) osi_QPrev(&smb_lastDirSearchp->q);
+ osi_QRemove((osi_queue_t **) &smb_firstDirSearchp, &dsp->q);
+ lock_ReleaseMutex(&dsp->mx);
+ lock_FinalizeMutex(&dsp->mx);
+ scp = dsp->scp;
+ osi_Log3(smb_logp,"smb_ReleaseDirSearch cookie %d dsp 0x%p scp 0x%p",
+ dsp->cookie, dsp, scp);
+ free(dsp);
+ } else {
+ lock_ReleaseMutex(&dsp->mx);
+ }
}
/* do this now to avoid spurious locking hierarchy creation */
if (scp)
void smb_GCDirSearches(int isV3)
{
smb_dirSearch_t *prevp;
- smb_dirSearch_t *tp;
+ smb_dirSearch_t *dsp;
smb_dirSearch_t *victimsp[SMB_DIRSEARCH_GCMAX];
int victimCount;
int i;
victimCount = 0; /* how many have we got so far */
- for (tp = smb_lastDirSearchp; tp; tp=prevp) {
+ for (dsp = smb_lastDirSearchp; dsp; dsp=prevp) {
/* we'll move tp from queue, so
* do this early.
*/
- prevp = (smb_dirSearch_t *) osi_QPrev(&tp->q);
+ prevp = (smb_dirSearch_t *) osi_QPrev(&dsp->q);
/* if no one is using this guy, and we're either in the new protocol,
* or we're in the old one and this is a small enough ID to be useful
* to the old protocol, GC this guy.
*/
- if (tp->refCount == 0 && (isV3 || tp->cookie <= 255)) {
+ if (dsp->refCount == 0 && (isV3 || dsp->cookie <= 255)) {
/* hold and delete */
- lock_ObtainMutex(&tp->mx);
- tp->flags |= SMB_DIRSEARCH_DELETE;
- lock_ReleaseMutex(&tp->mx);
- victimsp[victimCount++] = tp;
- tp->refCount++;
+ lock_ObtainMutex(&dsp->mx);
+ dsp->flags |= SMB_DIRSEARCH_DELETE;
+ lock_ReleaseMutex(&dsp->mx);
+ victimsp[victimCount++] = dsp;
+ dsp->refCount++;
}
/* don't do more than this */
/* don't need to watch for refcount zero and deleted, since
* we haven't dropped the global lock.
*/
- lock_ObtainMutex(&dsp->mx);
dsp->refCount--;
- lock_ReleaseMutex(&dsp->mx);
++smb_dirSearchCounter;
continue;
}
dsp->cookie = smb_dirSearchCounter;
++smb_dirSearchCounter;
dsp->refCount = 1;
- lock_InitializeMutex(&dsp->mx, "cm_dirSearch_t");
+ lock_InitializeMutex(&dsp->mx, "cm_dirSearch_t", LOCK_HIERARCHY_SMB_DIRSEARCH);
dsp->lastTime = osi_Time();
osi_QAdd((osi_queue_t **) &smb_firstDirSearchp, &dsp->q);
if (!smb_lastDirSearchp)
return dsp;
}
-static smb_packet_t *GetPacket(void)
+static smb_packet_t *smb_GetPacket(void)
{
smb_packet_t *tbp;
smb_packetFreeListp = tbp->nextp;
lock_ReleaseWrite(&smb_globalLock);
if (!tbp) {
- tbp = calloc(65540,1);
+ tbp = calloc(sizeof(*tbp),1);
tbp->magic = SMB_PACKETMAGIC;
tbp->ncbp = NULL;
tbp->vcp = NULL;
tbp->ncb_length = 0;
tbp->flags = 0;
tbp->spacep = NULL;
-
+ tbp->stringsp = NULL;
}
osi_assertx(tbp->magic == SMB_PACKETMAGIC, "invalid smb_packet_t magic");
smb_packet_t *smb_CopyPacket(smb_packet_t *pkt)
{
smb_packet_t *tbp;
- tbp = GetPacket();
+ tbp = smb_GetPacket();
memcpy(tbp, pkt, sizeof(smb_packet_t));
tbp->wctp = tbp->data + (unsigned int)(pkt->wctp - pkt->data);
+ tbp->stringsp = NULL;
if (tbp->vcp)
smb_HoldVC(tbp->vcp);
return tbp;
}
-static NCB *GetNCB(void)
+static NCB *smb_GetNCB(void)
{
smb_ncb_t *tbp;
NCB *ncbp;
return ncbp;
}
+static void FreeSMBStrings(smb_packet_t * pkt)
+{
+ cm_space_t * s;
+ cm_space_t * ns;
+
+ for (s = pkt->stringsp; s; s = ns) {
+ ns = s->nextp;
+ cm_FreeSpace(s);
+ }
+ pkt->stringsp = NULL;
+}
+
void smb_FreePacket(smb_packet_t *tbp)
{
smb_vc_t * vcp = NULL;
tbp->oddByte = 0;
tbp->ncb_length = 0;
tbp->flags = 0;
+ FreeSMBStrings(tbp);
lock_ReleaseWrite(&smb_globalLock);
if (vcp)
smb_ReleaseVC(vcp);
}
-static void FreeNCB(NCB *bufferp)
+static void smb_FreeNCB(NCB *bufferp)
{
smb_ncb_t *tbp;
void smb_SetSMBParm(smb_packet_t *smbp, int slot, unsigned int parmValue)
{
- char *parmDatap;
+ unsigned char *parmDatap;
/* make sure we have enough slots */
if (*smbp->wctp <= slot)
void smb_SetSMBParmLong(smb_packet_t *smbp, int slot, unsigned int parmValue)
{
- char *parmDatap;
+ unsigned char *parmDatap;
/* make sure we have enough slots */
if (*smbp->wctp <= slot)
void smb_SetSMBParmDouble(smb_packet_t *smbp, int slot, char *parmValuep)
{
- char *parmDatap;
+ unsigned char *parmDatap;
int i;
/* make sure we have enough slots */
void smb_SetSMBParmByte(smb_packet_t *smbp, int slot, unsigned int parmValue)
{
- char *parmDatap;
+ unsigned char *parmDatap;
/* make sure we have enough slots */
if (*smbp->wctp <= slot) {
*parmDatap++ = parmValue & 0xff;
}
-void smb_StripLastComponent(char *outPathp, char **lastComponentp, char *inPathp)
+
+
+void smb_StripLastComponent(clientchar_t *outPathp, clientchar_t **lastComponentp,
+ clientchar_t *inPathp)
{
- char *lastSlashp;
-
- lastSlashp = strrchr(inPathp, '\\');
- if (lastComponentp)
+ clientchar_t *lastSlashp;
+ clientchar_t *streamp = NULL;
+ clientchar_t *typep = NULL;
+
+ lastSlashp = cm_ClientStrRChr(inPathp, '\\');
+ 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 = ':';
+ osi_Log2(smb_logp, "smb_StripLastComponent found stream [%S] type [%S]",
+ osi_LogSaveClientString(smb_logp,streamp),
+ osi_LogSaveClientString(smb_logp,typep));
+ }
+
while (1) {
if (inPathp == lastSlashp)
break;
}
}
-unsigned char *smb_ParseASCIIBlock(unsigned char *inp, char **chainpp)
+clientchar_t *smb_ParseASCIIBlock(smb_packet_t * pktp, unsigned char *inp,
+ char **chainpp, int flags)
{
- if (*inp++ != 0x4)
- return NULL;
- if (chainpp) {
- *chainpp = inp + strlen(inp) + 1; /* skip over null-terminated string */
+ size_t cb;
+ afs_uint32 type = *inp++;
+
+ /*
+ * 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 (type == 0x2 /* Dialect */ || !WANTS_UNICODE(pktp))
+ flags |= SMB_STRF_FORCEASCII;
+#endif
+
+ return smb_ParseStringBuf(pktp->data, &pktp->stringsp, inp, &cb, chainpp, flags);
+}
+
+clientchar_t *smb_ParseString(smb_packet_t * pktp, unsigned char * inp,
+ char ** chainpp, int flags)
+{
+ size_t cb;
+
+#ifdef SMB_UNICODE
+ if (!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 | SMB_STRF_SRCNULTERM);
+}
+
+clientchar_t *smb_ParseStringCb(smb_packet_t * pktp, unsigned char * inp,
+ size_t cb, char ** chainpp, int flags)
+{
+#ifdef SMB_UNICODE
+ if (!WANTS_UNICODE(pktp))
+ flags |= SMB_STRF_FORCEASCII;
+#endif
+
+ return smb_ParseStringBuf(pktp->data, &pktp->stringsp, inp, &cb, chainpp, flags);
+}
+
+clientchar_t *smb_ParseStringCch(smb_packet_t * pktp, unsigned char * inp,
+ size_t cch, char ** chainpp, int flags)
+{
+ size_t cb = cch;
+
+#ifdef SMB_UNICODE
+ if (!WANTS_UNICODE(pktp))
+ flags |= SMB_STRF_FORCEASCII;
+ else
+ cb = cch * sizeof(wchar_t);
+#endif
+
+ return smb_ParseStringBuf(pktp->data, &pktp->stringsp, inp, &cb, chainpp, flags);
+}
+
+clientchar_t *
+smb_ParseStringBuf(const unsigned char * bufbase,
+ cm_space_t ** stringspp,
+ unsigned char *inp, size_t *pcb_max,
+ char **chainpp, int flags)
+{
+#ifdef SMB_UNICODE
+ if (!(flags & SMB_STRF_FORCEASCII)) {
+ size_t cch_src;
+ cm_space_t * spacep;
+ int null_terms = 0;
+
+ if (bufbase && ((inp - bufbase) % 2) != 0) {
+ inp++; /* unicode strings are always word aligned */
+ }
+
+ if (*pcb_max > 0) {
+ if (FAILED(StringCchLengthW((const wchar_t *) inp, *pcb_max / sizeof(wchar_t),
+ &cch_src))) {
+ cch_src = *pcb_max / sizeof(wchar_t);
+ *pcb_max = 0;
+ null_terms = 0;
+ } else {
+ *pcb_max -= (cch_src + 1) * sizeof(wchar_t);
+ null_terms = 1;
+ }
+ } else {
+ cch_src = 0;
+ }
+
+ spacep = cm_GetSpace();
+ spacep->nextp = *stringspp;
+ *stringspp = spacep;
+
+ if (cch_src == 0) {
+ if (chainpp) {
+ *chainpp = inp + sizeof(wchar_t);
+ }
+
+ *(spacep->wdata) = 0;
+ return spacep->wdata;
+ }
+
+ StringCchCopyNW(spacep->wdata,
+ lengthof(spacep->wdata),
+ (const clientchar_t *) inp, cch_src);
+
+ if (chainpp)
+ *chainpp = inp + (cch_src + null_terms)*sizeof(wchar_t);
+
+ return spacep->wdata;
+
+ } else {
+#endif
+ cm_space_t * spacep;
+ int cchdest;
+
+ /* Not using Unicode */
+ if (chainpp) {
+ *chainpp = inp + strlen(inp) + 1;
+ }
+
+ spacep = cm_GetSpace();
+ spacep->nextp = *stringspp;
+ *stringspp = spacep;
+
+ cchdest = lengthof(spacep->wdata);
+ cm_Utf8ToUtf16(inp, (int)((flags & SMB_STRF_SRCNULTERM)? -1 : *pcb_max),
+ spacep->wdata, cchdest);
+
+ return spacep->wdata;
+#ifdef SMB_UNICODE
+ }
+#endif
+}
+
+unsigned char * smb_UnparseString(smb_packet_t * pktp, unsigned char * outp,
+ clientchar_t * str,
+ size_t * plen, int flags)
+{
+ size_t buffersize;
+ int align = 0;
+
+ if (outp == NULL) {
+ /* we are only calculating the required size */
+
+ if (plen == NULL)
+ return NULL;
+
+#ifdef SMB_UNICODE
+
+ if (WANTS_UNICODE(pktp) && !(flags & SMB_STRF_FORCEASCII)) {
+
+ StringCbLengthW(str, SMB_STRINGBUFSIZE * sizeof(wchar_t), plen);
+ if (!(flags & SMB_STRF_IGNORENUL))
+ *plen += sizeof(wchar_t);
+
+ return (unsigned char *) 1; /* return TRUE if we are using unicode */
+ }
+ else
+#endif
+ {
+ /* Storing ANSI */
+
+ size_t cch_str;
+ size_t cch_dest;
+
+ cch_str = cm_ClientStrLen(str);
+ cch_dest = cm_ClientStringToUtf8(str, (int)cch_str, NULL, 0);
+
+ if (plen)
+ *plen = ((flags & SMB_STRF_IGNORENUL)? cch_dest: cch_dest+1);
+
+ return NULL;
+ }
+
+ /* Not reached. */
+ }
+
+ /* if outp != NULL ... */
+
+ /* Number of bytes left in the buffer.
+
+ If outp lies inside the packet data buffer, we assume that the
+ buffer is the packet data buffer. Otherwise we assume that the
+ buffer is sizeof(packet->data).
+
+ */
+ if (outp >= pktp->data && outp < pktp->data + sizeof(pktp->data)) {
+ align = (int)((outp - pktp->data) % 2);
+ buffersize = (pktp->data + sizeof(pktp->data)) - ((char *) outp);
+ } else {
+ align = (int)(((size_t) outp) % 2);
+ buffersize = (int)sizeof(pktp->data);
+ }
+
+#ifdef SMB_UNICODE
+
+ if (WANTS_UNICODE(pktp) && !(flags & SMB_STRF_FORCEASCII)) {
+ int nchars;
+
+ if (align)
+ *outp++ = '\0';
+
+ if (*str == _C('\0')) {
+
+ if (buffersize < sizeof(wchar_t))
+ return NULL;
+
+ *((wchar_t *) outp) = L'\0';
+ if (plen && !(flags & SMB_STRF_IGNORENUL))
+ *plen += sizeof(wchar_t);
+ return outp + sizeof(wchar_t);
+ }
+
+ nchars = cm_ClientStringToUtf16(str, -1, (wchar_t *) outp, (int)(buffersize / sizeof(wchar_t)));
+ if (nchars == 0) {
+ osi_Log2(smb_logp, "UnparseString: Can't convert string to Unicode [%S], GLE=%d",
+ osi_LogSaveClientString(smb_logp, str),
+ GetLastError());
+ return NULL;
+ }
+
+ if (plen)
+ *plen += sizeof(wchar_t) * ((flags & SMB_STRF_IGNORENUL)? nchars - 1: nchars);
+
+ return outp + sizeof(wchar_t) * nchars;
+ }
+ else
+#endif
+ {
+ /* Storing ANSI */
+ size_t cch_dest;
+
+ cch_dest = cm_ClientStringToUtf8(str, -1, outp, (int)buffersize);
+
+ if (plen)
+ *plen += ((flags & SMB_STRF_IGNORENUL)? cch_dest - 1: cch_dest);
+
+ return outp + cch_dest;
}
- return inp;
}
unsigned char *smb_ParseVblBlock(unsigned char *inp, char **chainpp, int *lengthp)
return inp;
}
+unsigned char *smb_ParseDataBlock(unsigned char *inp, char **chainpp, int *lengthp)
+{
+ int tlen;
+
+ if (*inp++ != 0x1) return NULL;
+ tlen = inp[0] + (inp[1]<<8);
+ inp += 2; /* skip length field */
+
+ if (chainpp) {
+ *chainpp = inp + tlen;
+ }
+
+ if (lengthp) *lengthp = tlen;
+
+ return inp;
+}
+
/* format a packet as a response */
void smb_FormatResponsePacket(smb_vc_t *vcp, smb_packet_t *inp, smb_packet_t *op)
{
outp->reb |= SMB_FLAGS_CANONICAL_PATHNAMES;
#endif
outp->flg2 = SMB_FLAGS2_KNOWS_LONG_NAMES;
+#ifdef SMB_UNICODE
+ if ((vcp->flags & SMB_VCFLAG_USEUNICODE) == SMB_VCFLAG_USEUNICODE)
+ outp->flg2 |= SMB_FLAGS2_UNICODE;
+#endif
/* copy fields in generic packet area */
op->wctp = &outp->wct;
ncbp = inp->ncbp;
if (ncbp == NULL) {
- ncbp = GetNCB();
+ ncbp = smb_GetNCB();
localNCB = 1;
}
- memset((char *)ncbp, 0, sizeof(NCB));
+ memset(ncbp, 0, sizeof(NCB));
extra = 2 * (*inp->wctp); /* space used by parms, in bytes */
tp = inp->wctp + 1+ extra; /* points to count of data bytes */
}
if (localNCB)
- FreeNCB(ncbp);
+ smb_FreeNCB(ncbp);
}
void smb_MapNTError(long code, unsigned long *NTStatusp)
/* map CM_ERROR_* errors to NT 32-bit status codes */
/* NT Status codes are listed in ntstatus.h not winerror.h */
- if (code == CM_ERROR_NOSUCHCELL) {
- NTStatus = 0xC000000FL; /* No such file */
+ if (code == 0) {
+ NTStatus = 0;
+ }
+ else if (code == CM_ERROR_NOSUCHCELL) {
+ NTStatus = 0xC0000034L; /* Name not found */
}
else if (code == CM_ERROR_NOSUCHVOLUME) {
- NTStatus = 0xC000000FL; /* No such file */
+ NTStatus = 0xC0000034L; /* Name not found */
}
else if (code == CM_ERROR_TIMEDOUT) {
#ifdef COMMENT
NTStatus = 0xC00000CFL; /* Sharing Paused */
-#else
+
+ /* Do not send Timeout to the SMB redirector.
+ * It causes the redirector to drop the connection */
NTStatus = 0x00000102L; /* Timeout */
+ /* do not send Retry to the SMB redirector.
+ * It believes the error comes from the transport
+ * layer not from the SMB server. */
+ NTStatus = 0xC000022DL; /* Retry */
+#else
+ NTStatus = 0xC00000B5L; /* I/O Timeout */
#endif
}
else if (code == CM_ERROR_RETRY) {
+#ifdef COMMENT
NTStatus = 0xC000022DL; /* Retry */
+#else
+ NTStatus = 0xC00000B5L; /* I/O Timeout */
+#endif
}
else if (code == CM_ERROR_NOACCESS) {
NTStatus = 0xC0000022L; /* Access denied */
}
else if (code == CM_ERROR_NOSUCHFILE ||
code == CM_ERROR_BPLUS_NOMATCH) {
- NTStatus = 0xC000000FL; /* No such file */
+ NTStatus = 0xC0000034L; /* Name not found */
}
else if (code == CM_ERROR_NOSUCHPATH) {
NTStatus = 0xC000003AL; /* Object path not found */
else if (code == CM_ERROR_BADFDOP) {
NTStatus = 0xC0000022L; /* Access denied */
}
+ else if (code == CM_ERROR_UNKNOWN) {
+ NTStatus = 0xC0000022L; /* Access denied */
+ }
else if (code == CM_ERROR_EXISTS) {
NTStatus = 0xC0000035L; /* Object name collision */
}
#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 = 0xC000013DL; /* Remote Resources */
#endif
}
- else if (code == CM_ERROR_CLOCKSKEW) {
+ else if (code == CM_ERROR_CLOCKSKEW ||
+ code == RXKADNOAUTH) {
NTStatus = 0xC0000133L; /* Time difference at DC */
}
else if (code == CM_ERROR_BADTID) {
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 = 0xC0000257L; /* Path Not Covered */
}
else if (code == CM_ERROR_ALLBUSY) {
+#ifdef COMMENT
NTStatus = 0xC000022DL; /* Retry */
+#else
+ NTStatus = 0xC00000B5L; /* I/O Timeout */
+#endif
}
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_RANGE_NOT_LOCKED) {
NTStatus = 0xC000007EL; /* Range Not Locked */
}
- else {
+ else if (code == CM_ERROR_NOSUCHDEVICE) {
+ NTStatus = 0xC000000EL; /* No Such Device */
+ }
+ else if (code == CM_ERROR_LOCK_NOT_GRANTED) {
+ NTStatus = 0xC0000055L; /* Lock Not Granted */
+ }
+ 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_UNKNOWN) {
+ 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 ||
+ code == RXKADNOAUTH) {
+ 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)
{
return CM_ERROR_BADOP;
}
+/* SMB_COM_ECHO */
long smb_ReceiveCoreEcho(smb_vc_t *vcp, smb_packet_t *inp, smb_packet_t *outp)
{
unsigned short EchoCount, i;
return 0;
}
+/* SMB_COM_READ_RAW */
long smb_ReceiveCoreReadRaw(smb_vc_t *vcp, smb_packet_t *inp, smb_packet_t *outp)
{
osi_hyper_t offset;
unsigned short fd;
unsigned pid;
smb_fid_t *fidp;
+ smb_t *smbp = (smb_t*) inp;
long code = 0;
cm_user_t *userp = NULL;
NCB *ncbp;
fd, offset.HighPart, offset.LowPart, count);
fidp = smb_FindFID(vcp, fd, 0);
- if (!fidp)
+ if (!fidp) {
+ osi_Log2(smb_logp, "smb_ReceiveCoreReadRaw Unknown SMB Fid vcp 0x%p fid %d",
+ vcp, fd);
goto send1;
+ }
+ 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);
code = CM_ERROR_NOSUCHFILE;
goto send1a;
}
-
- pid = ((smb_t *) inp)->pid;
+ pid = smbp->pid;
{
LARGE_INTEGER LOffset, LLength;
cm_key_t key;
LLength.HighPart = 0;
LLength.LowPart = count;
- lock_ObtainMutex(&fidp->scp->mx);
+ lock_ObtainWrite(&fidp->scp->rw);
code = cm_LockCheckRead(fidp->scp, LOffset, LLength, key);
- lock_ReleaseMutex(&fidp->scp->mx);
+ 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 */
send1:
ncbp = outp->ncbp;
- memset((char *)ncbp, 0, sizeof(NCB));
+ memset(ncbp, 0, sizeof(NCB));
ncbp->ncb_length = (unsigned short) finalCount;
ncbp->ncb_lsn = (unsigned char) vcp->lsn;
return 0;
}
+/* SMB_COM_NEGOTIATE */
long smb_ReceiveNegotiate(smb_vc_t *vcp, smb_packet_t *inp, smb_packet_t *outp)
{
char *namep;
* and NT Find *
* and NT SMB's *
* and raw mode
- * and DFS */
+ * and DFS
+ * and Unicode */
caps = NTNEGOTIATE_CAPABILITY_NTSTATUS |
#ifdef DFS_SUPPORT
NTNEGOTIATE_CAPABILITY_DFS |
if ( smb_authType == SMB_AUTH_EXTENDED )
caps |= NTNEGOTIATE_CAPABILITY_EXTENDED_SECURITY;
+#ifdef SMB_UNICODE
+ if ( smb_UseUnicode ) {
+ caps |= NTNEGOTIATE_CAPABILITY_UNICODE;
+ }
+#endif
+
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 */
datap = smb_GetSMBData(outp, NULL);
memcpy(datap,vcp->encKey,MSV1_0_CHALLENGE_LENGTH);
/* and the faux domain name */
- strcpy(datap + MSV1_0_CHALLENGE_LENGTH,smb_ServerDomainName);
+ cm_ClientStringToUtf8(smb_ServerDomainName, -1,
+ datap + MSV1_0_CHALLENGE_LENGTH,
+ (int)(sizeof(outp->data)/sizeof(char) - (datap - outp->data)));
} else if ( smb_authType == SMB_AUTH_EXTENDED ) {
void * secBlob;
int secBlobLength;
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 */
/* paste in a new encryption key */
memcpy(datap, vcp->encKey, MSV1_0_CHALLENGE_LENGTH);
/* and the faux domain name */
- strcpy(datap + MSV1_0_CHALLENGE_LENGTH, smb_ServerDomainName);
+ cm_ClientStringToUtf8(smb_ServerDomainName, -1,
+ datap + MSV1_0_CHALLENGE_LENGTH,
+ (int)(sizeof(outp->data)/sizeof(char) - (datap - outp->data)));
} else {
smb_SetSMBParm(outp, 11, 0); /* encryption key length */
smb_SetSMBParm(outp, 12, 0); /* resvd */
void smb_CheckVCs(void)
{
smb_vc_t * vcp, *nextp;
- smb_packet_t * outp = GetPacket();
+ smb_packet_t * outp = smb_GetPacket();
smb_t *smbp;
lock_ObtainWrite(&smb_rctLock);
osi_panic("afsd: invalid smb_vc_t detected in smb_allVCsp",
__FILE__, __LINE__);
+ /* on the first pass hold 'vcp' which was not held as 'nextp' */
+ if (vcp != nextp)
+ smb_HoldVCNoLock(vcp);
+
+ /*
+ * obtain a reference to 'nextp' now because we drop the
+ * smb_rctLock later and the list contents could change
+ * or 'vcp' could be destroyed when released.
+ */
nextp = vcp->nextp;
+ if (nextp)
+ smb_HoldVCNoLock(nextp);
- if (vcp->flags & SMB_VCFLAG_ALREADYDEAD)
+ if (vcp->flags & SMB_VCFLAG_ALREADYDEAD) {
+ smb_ReleaseVCNoLock(vcp);
continue;
+ }
- smb_HoldVCNoLock(vcp);
- if (nextp)
- smb_HoldVCNoLock(nextp);
smb_FormatResponsePacket(vcp, NULL, outp);
smbp = (smb_t *)outp;
outp->inCom = smbp->com = 0x2b /* Echo */;
lock_ObtainWrite(&smb_rctLock);
smb_ReleaseVCNoLock(vcp);
- if (nextp)
- smb_ReleaseVCNoLock(nextp);
}
lock_ReleaseWrite(&smb_rctLock);
smb_FreePacket(outp);
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();
now = osi_Time();
lock_ObtainWrite(&smb_rctLock);
for ( unpp=&usernamesp; *unpp; ) {
- int delete = 0;
+ int deleteOk = 0;
smb_username_t *unp;
lock_ObtainMutex(&(*unpp)->mx);
;
else if (!smb_LogoffTokenTransfer ||
((*unpp)->last_logoff_t + smb_LogoffTransferTimeout < now))
- delete = 1;
+ deleteOk = 1;
lock_ReleaseMutex(&(*unpp)->mx);
- if (delete) {
+ if (deleteOk) {
cm_user_t * userp;
unp = *unpp;
if (wl->state == SMB_WAITINGLOCKSTATE_DONE)
continue;
+ if (wl->state == SMB_WAITINGLOCKSTATE_CANCELLED) {
+ code = CM_ERROR_LOCK_NOT_GRANTED;
+ break;
+ }
+
osi_assertx(wl->state != SMB_WAITINGLOCKSTATE_ERROR, "!SMB_WAITINGLOCKSTATE_ERROR");
/* wl->state is either _DONE or _WAITING. _ERROR
if (code == CM_ERROR_WOULDBLOCK) {
/* no progress */
- if (wlRequest->timeRemaining != 0xffffffff
- && (wlRequest->timeRemaining -= 1000) < 0)
+ if (wlRequest->msTimeout != 0xffffffff
+ && ((osi_Time() - wlRequest->start_t) * 1000 > wlRequest->msTimeout))
goto endWait;
continue;
scp = wlRequest->scp;
osi_Log2(smb_logp,"smb_WaitingLocksDaemon wlRequest 0x%p scp 0x%p", wlRequest, scp);
- cm_InitReq(&req);
+ smb_InitReq(&req);
- lock_ObtainMutex(&scp->mx);
+ lock_ObtainWrite(&scp->rw);
for (wl = wlRequest->locks; wl; wl = wlNext) {
wlNext = (smb_waitingLock_t *) osi_QNext(&wl->q);
-
- cm_Unlock(scp, wlRequest->lockType, wl->LOffset,
- wl->LLength, wl->key, NULL, &req);
+
+ if (wl->state == SMB_WAITINGLOCKSTATE_DONE)
+ cm_Unlock(scp, wlRequest->lockType, wl->LOffset,
+ wl->LLength, wl->key, 0, NULL, &req);
osi_QRemove((osi_queue_t **) &wlRequest->locks, &wl->q);
free(wl);
}
- lock_ReleaseMutex(&scp->mx);
+ lock_ReleaseWrite(&scp->rw);
} else {
vcp = wlRequest->vcp;
inp = wlRequest->inp;
outp = wlRequest->outp;
- ncbp = GetNCB();
+ ncbp = smb_GetNCB();
ncbp->ncb_length = inp->ncb_length;
inp->spacep = cm_GetSpace();
smb_FreePacket(outp);
smb_ReleaseVC(vcp);
cm_ReleaseSCache(wlRequest->scp);
- FreeNCB(ncbp);
+ smb_FreeNCB(ncbp);
free(wlRequest);
} while (nwlRequest && smbShutdownFlag == 0);
thrd_Sleep(1000);
return 0;
}
+/* SMB_COM_TREE_CONNECT */
long smb_ReceiveCoreTreeConnect(smb_vc_t *vcp, smb_packet_t *inp, smb_packet_t *rsp)
{
smb_tid_t *tidp;
smb_user_t *uidp;
unsigned short newTid;
- char shareName[AFSPATHMAX];
- char *sharePath;
+ clientchar_t shareName[AFSPATHMAX];
+ clientchar_t *sharePath;
int shareFound;
- char *tp;
- char *pathp;
- char *passwordp;
+ clientchar_t *tp;
+ clientchar_t *pathp;
cm_user_t *userp;
osi_Log0(smb_logp, "SMB receive tree connect");
/* parse input parameters */
- tp = smb_GetSMBData(inp, NULL);
- pathp = smb_ParseASCIIBlock(tp, &tp);
- if (smb_StoreAnsiFilenames)
- OemToChar(pathp,pathp);
- passwordp = smb_ParseASCIIBlock(tp, &tp);
- tp = strrchr(pathp, '\\');
+ {
+ 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)
return CM_ERROR_BADSMB;
- strcpy(shareName, tp+1);
+ cm_ClientStrCpy(shareName, lengthof(shareName), tp+1);
lock_ObtainMutex(&vcp->mx);
newTid = vcp->tidCounter++;
tidp = smb_FindTID(vcp, newTid, SMB_FLAG_CREATE);
uidp = smb_FindUID(vcp, ((smb_t *)inp)->uid, 0);
+ if (!uidp)
+ return CM_ERROR_BADSMB;
userp = smb_GetUserFromUID(uidp);
shareFound = smb_FindShare(vcp, uidp, shareName, &sharePath);
- if (uidp)
- smb_ReleaseUID(uidp);
+ smb_ReleaseUID(uidp);
if (!shareFound) {
smb_ReleaseTID(tidp, FALSE);
return CM_ERROR_BADSHARENAME;
return 0;
}
-unsigned char *smb_ParseDataBlock(unsigned char *inp, char **chainpp, int *lengthp)
-{
- int tlen;
-
- if (*inp++ != 0x1) return NULL;
- tlen = inp[0] + (inp[1]<<8);
- inp += 2; /* skip length field */
-
- if (chainpp) {
- *chainpp = inp + tlen;
- }
-
- if (lengthp) *lengthp = tlen;
-
- return inp;
-}
-
/* set maskp to the mask part of the incoming path.
* Mask is 11 bytes long (8.3 with the dot elided).
* Returns true if succeeds with a valid name, otherwise it does
* its best, but returns false.
*/
-int smb_Get8Dot3MaskFromPath(unsigned char *maskp, unsigned char *pathp)
+int smb_Get8Dot3MaskFromPath(clientchar_t *maskp, clientchar_t *pathp)
{
- char *tp;
- char *up;
+ clientchar_t *tp;
+ clientchar_t *up;
int i;
int tc;
int valid8Dot3;
maskp[11] = '\0';
/* find last backslash, or use whole thing if there is none */
- tp = strrchr(pathp, '\\');
+ tp = cm_ClientStrRChr(pathp, '\\');
if (!tp)
tp = pathp;
else
/* unreachable */
}
-int smb_Match8Dot3Mask(char *unixNamep, char *maskp)
+int smb_Match8Dot3Mask(clientchar_t *unixNamep, clientchar_t *maskp)
{
- char umask[11];
+ clientchar_t umask[11];
int valid;
int i;
- char tc1;
- char tc2;
- char *tp1;
- char *tp2;
+ clientchar_t tc1;
+ clientchar_t tc2;
+ clientchar_t *tp1;
+ clientchar_t *tp2;
- /* XXX redo this, calling smb_V3MatchMask with a converted mask */
+ /* XXX redo this, calling cm_MatchMask with a converted mask */
valid = smb_Get8Dot3MaskFromPath(umask, unixNamep);
if (!valid)
tp1 = umask; /* real name, in mask format */
tp2 = maskp; /* mask, in mask format */
for(i=0; i<11; i++) {
- tc1 = *tp1++; /* char from real name */
- tc2 = *tp2++; /* char from mask */
- tc1 = (char) cm_foldUpper[(unsigned char)tc1];
- tc2 = (char) cm_foldUpper[(unsigned char)tc2];
+ tc1 = *tp1++; /* clientchar_t from real name */
+ tc2 = *tp2++; /* clientchar_t from mask */
+ tc1 = (clientchar_t) cm_foldUpper[(clientchar_t)tc1];
+ tc2 = (clientchar_t) cm_foldUpper[(clientchar_t)tc2];
if (tc1 == tc2)
continue;
if (tc2 == '?' && tc1 != ' ')
return 1;
}
-char *smb_FindMask(char *pathp)
+clientchar_t *smb_FindMask(clientchar_t *pathp)
{
- char *tp;
+ clientchar_t *tp;
- tp = strrchr(pathp, '\\'); /* find last slash */
+ tp = cm_ClientStrRChr(pathp, '\\'); /* find last slash */
if (tp)
return tp+1; /* skip the slash */
return pathp; /* no slash, return the entire path */
}
+/* SMB_COM_SEARCH for a volume label
+
+ (This is called from smb_ReceiveCoreSearchDir() and not an actual
+ dispatch function.) */
long smb_ReceiveCoreSearchVolume(smb_vc_t *vcp, smb_packet_t *inp, smb_packet_t *outp)
{
- unsigned char *pathp;
+ clientchar_t *pathp;
unsigned char *tp;
- unsigned char mask[12];
+ clientchar_t mask[12];
unsigned char *statBlockp;
unsigned char initStatBlock[21];
int statLen;
/* pull pathname and stat block out of request */
tp = smb_GetSMBData(inp, NULL);
- pathp = smb_ParseASCIIBlock(tp, (char **) &tp);
- osi_assertx(pathp != NULL, "null path");
- if (smb_StoreAnsiFilenames)
- OemToChar(pathp,pathp);
- statBlockp = smb_ParseVblBlock(tp, (char **) &tp, &statLen);
+ pathp = smb_ParseASCIIBlock(inp, tp, &tp,
+ SMB_STRF_ANSIPATH|SMB_STRF_FORCEASCII);
+ if (!pathp)
+ return CM_ERROR_BADSMB;
+ statBlockp = smb_ParseVblBlock(tp, &tp, &statLen);
osi_assertx(statBlockp != NULL, "null statBlock");
if (statLen == 0) {
statBlockp = initStatBlock;
*tp++ = 0;
*tp++ = 0;
+ /* The filename is a UCHAR buffer that is ASCII even if Unicode
+ was negotiated. */
+
/* finally, null-terminated 8.3 pathname, which we set to AFS */
memset(tp, ' ', 13);
strcpy(tp, "AFS");
}
static long
-smb_ApplyDirListPatches(smb_dirListPatch_t **dirPatchespp,
- char * tidPathp, char * relPathp,
+smb_ApplyDirListPatches(cm_scache_t * dscp, smb_dirListPatch_t **dirPatchespp,
+ clientchar_t * tidPathp, clientchar_t * relPathp,
cm_user_t *userp, cm_req_t *reqp)
{
long code = 0;
char attr;
smb_dirListPatch_t *patchp;
smb_dirListPatch_t *npatchp;
- char path[AFSPATHMAX];
+ clientchar_t path[AFSPATHMAX];
+ afs_uint32 rights;
+ afs_int32 mustFake = 0;
+
+ code = cm_FindACLCache(dscp, userp, &rights);
+ if (code == -1) {
+ lock_ObtainWrite(&dscp->rw);
+ code = cm_SyncOp(dscp, NULL, userp, reqp, PRSFS_READ,
+ CM_SCACHESYNC_NEEDCALLBACK | CM_SCACHESYNC_GETSTATUS);
+ lock_ReleaseWrite(&dscp->rw);
+ if (code == CM_ERROR_NOACCESS) {
+ mustFake = 1;
+ code = 0;
+ }
+ }
+ if (code)
+ goto cleanup;
+
+ if (!mustFake) { /* Bulk Stat */
+ afs_uint32 count;
+ cm_bulkStat_t *bsp = malloc(sizeof(cm_bulkStat_t));
+
+ memset(bsp, 0, sizeof(cm_bulkStat_t));
+
+ for (patchp = *dirPatchespp, count=0;
+ patchp;
+ patchp = (smb_dirListPatch_t *) osi_QNext(&patchp->q)) {
+ cm_scache_t *tscp = cm_FindSCache(&patchp->fid);
+ int i;
+
+ if (tscp) {
+ if (lock_TryWrite(&tscp->rw)) {
+ /* we have an entry that we can look at */
+ if (!(tscp->flags & CM_SCACHEFLAG_EACCESS) && cm_HaveCallback(tscp)) {
+ /* we have a callback on it. Don't bother
+ * fetching this stat entry, since we're happy
+ * with the info we have.
+ */
+ lock_ReleaseWrite(&tscp->rw);
+ cm_ReleaseSCache(tscp);
+ continue;
+ }
+ lock_ReleaseWrite(&tscp->rw);
+ } /* got lock */
+ cm_ReleaseSCache(tscp);
+ } /* found entry */
+
+ i = bsp->counter++;
+ bsp->fids[i].Volume = patchp->fid.volume;
+ bsp->fids[i].Vnode = patchp->fid.vnode;
+ bsp->fids[i].Unique = patchp->fid.unique;
+
+ if (bsp->counter == AFSCBMAX) {
+ code = cm_TryBulkStatRPC(dscp, bsp, userp, reqp);
+ memset(bsp, 0, sizeof(cm_bulkStat_t));
+ }
+ }
+
+ if (bsp->counter > 0)
+ code = cm_TryBulkStatRPC(dscp, bsp, userp, reqp);
+
+ free(bsp);
+ }
for (patchp = *dirPatchespp; patchp; patchp =
(smb_dirListPatch_t *) osi_QNext(&patchp->q)) {
dptr = patchp->dptr;
- snprintf(path, AFSPATHMAX, "%s\\%s", relPathp ? relPathp : "", patchp->dep->name);
+ cm_ClientStrPrintfN(path, AFSPATHMAX, _C("%s\\%s"),
+ relPathp ? relPathp : _C(""), patchp->dep->name);
reqp->relPathp = path;
reqp->tidPathp = tidPathp;
*dptr++ = SMB_ATTR_HIDDEN;
continue;
}
- lock_ObtainMutex(&scp->mx);
- code = cm_SyncOp(scp, NULL, userp, reqp, 0,
- CM_SCACHESYNC_NEEDCALLBACK | CM_SCACHESYNC_GETSTATUS);
- if (code) {
- lock_ReleaseMutex(&scp->mx);
- cm_ReleaseSCache(scp);
- if (patchp->flags & SMB_DIRLISTPATCH_DOTFILE)
- *dptr++ = SMB_ATTR_HIDDEN;
- continue;
- }
+ lock_ObtainWrite(&scp->rw);
+ if (mustFake || (scp->flags & CM_SCACHEFLAG_EACCESS) || !cm_HaveCallback(scp)) {
+ lock_ReleaseWrite(&scp->rw);
- cm_SyncOpDone(scp, NULL, CM_SCACHESYNC_NEEDCALLBACK | CM_SCACHESYNC_GETSTATUS);
+ /* set the attribute */
+ switch (scp->fileType) {
+ case CM_SCACHETYPE_DIRECTORY:
+ case CM_SCACHETYPE_MOUNTPOINT:
+ case CM_SCACHETYPE_INVALID:
+ attr = SMB_ATTR_DIRECTORY;
+ break;
+ case CM_SCACHETYPE_SYMLINK:
+ if (cm_TargetPerceivedAsDirectory(scp->mountPointStringp))
+ attr = SMB_ATTR_DIRECTORY;
+ else
+ attr = SMB_ATTR_NORMAL;
+ break;
+ default:
+ /* if we get here we either have a normal file
+ * or we have a file for which we have never
+ * received status info. In this case, we can
+ * check the even/odd value of the entry's vnode.
+ * odd means it is to be treated as a directory
+ * and even means it is to be treated as a file.
+ */
+ if (mustFake && (scp->fid.vnode & 0x1))
+ attr = SMB_ATTR_DIRECTORY;
+ else
+ attr = SMB_ATTR_NORMAL;
+ }
+ *dptr++ = attr;
+
+ /* 1969-12-31 23:59:58 +00*/
+ dosTime = 0xEBBFBF7D;
- attr = smb_Attributes(scp);
- /* check hidden attribute (the flag is only ON when dot file hiding is on ) */
- if (patchp->flags & SMB_DIRLISTPATCH_DOTFILE)
- attr |= SMB_ATTR_HIDDEN;
- *dptr++ = attr;
+ /* copy out time */
+ shortTemp = (unsigned short) (dosTime & 0xffff);
+ *((u_short *)dptr) = shortTemp;
+ dptr += 2;
- /* get dos time */
- smb_SearchTimeFromUnixTime(&dosTime, scp->clientModTime);
+ /* and copy out date */
+ shortTemp = (unsigned short) ((dosTime>>16) & 0xffff);
+ *((u_short *)dptr) = shortTemp;
+ dptr += 2;
- /* copy out time */
- shortTemp = (unsigned short) (dosTime & 0xffff);
- *((u_short *)dptr) = shortTemp;
- dptr += 2;
-
- /* and copy out date */
- shortTemp = (unsigned short) ((dosTime>>16) & 0xffff);
- *((u_short *)dptr) = shortTemp;
- dptr += 2;
+ /* copy out file length */
+ *((u_long *)dptr) = 0;
+ dptr += 4;
+ } else {
+ lock_ConvertWToR(&scp->rw);
+ attr = smb_Attributes(scp);
+ /* check hidden attribute (the flag is only ON when dot file hiding is on ) */
+ if (patchp->flags & SMB_DIRLISTPATCH_DOTFILE)
+ attr |= SMB_ATTR_HIDDEN;
+ *dptr++ = attr;
+
+ /* get dos time */
+ cm_SearchTimeFromUnixTime(&dosTime, scp->clientModTime);
+
+ /* copy out time */
+ shortTemp = (unsigned short) (dosTime & 0xffff);
+ *((u_short *)dptr) = shortTemp;
+ dptr += 2;
+
+ /* and copy out date */
+ shortTemp = (unsigned short) ((dosTime>>16) & 0xffff);
+ *((u_short *)dptr) = shortTemp;
+ dptr += 2;
- /* copy out file length */
- *((u_long *)dptr) = scp->length.LowPart;
- dptr += 4;
- lock_ReleaseMutex(&scp->mx);
+ /* copy out file length */
+ *((u_long *)dptr) = scp->length.LowPart;
+ dptr += 4;
+ lock_ReleaseRead(&scp->rw);
+ }
cm_ReleaseSCache(scp);
}
/* and mark the list as empty */
*dirPatchespp = NULL;
+ cleanup:
return code;
}
+/* SMB_COM_SEARCH */
long smb_ReceiveCoreSearchDir(smb_vc_t *vcp, smb_packet_t *inp, smb_packet_t *outp)
{
int attribute;
long nextCookie;
- char *tp;
+ unsigned char *tp;
long code = 0;
- char *pathp;
+ clientchar_t *pathp;
cm_dirEntry_t *dep = 0;
int maxCount;
smb_dirListPatch_t *dirListPatchesp;
cm_pageHeader_t *pageHeaderp;
cm_user_t *userp = NULL;
int slotInPage;
- char shortName[13];
- char *actualName;
- char *shortNameEnd;
- char mask[12];
+ clientchar_t mask[12];
int returnedNames;
long nextEntryCookie;
int numDirChunks; /* # of 32 byte dir chunks in this entry */
int starPattern;
int rootPath = 0;
int caseFold;
- char *tidPathp = 0;
+ clientchar_t *tidPathp = 0;
cm_req_t req;
cm_fid_t fid;
int fileType;
- cm_InitReq(&req);
+ smb_InitReq(&req);
maxCount = smb_GetSMBParm(inp, 0);
caseFold = CM_FLAG_CASEFOLD;
tp = smb_GetSMBData(inp, NULL);
- pathp = smb_ParseASCIIBlock(tp, &tp);
- if (smb_StoreAnsiFilenames)
- OemToChar(pathp,pathp);
- inCookiep = smb_ParseVblBlock(tp, &tp, &dataLength);
+ pathp = smb_ParseASCIIBlock(inp, tp, &tp,
+ SMB_STRF_ANSIPATH|SMB_STRF_FORCEASCII);
+ 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 (attribute & 0x8)
return smb_ReceiveCoreSearchVolume(vcp, inp, outp);
- osi_Log2(smb_logp, "SMB receive search dir count %d [%s]",
- maxCount, osi_LogSaveString(smb_logp, pathp));
+ osi_Log2(smb_logp, "SMB receive search dir count %d [%S]",
+ maxCount, osi_LogSaveClientString(smb_logp, pathp));
if (*pathp == 0) { /* null pathp, treat as root dir */
if (!(attribute & SMB_ATTR_DIRECTORY)) /* exclude dirs */
memcpy(dsp->mask, mask, 12);
/* track if this is likely to match a lot of entries */
- if (smb_IsStarMask(mask))
+ if (smb_Is8Dot3StarMask(mask))
starPattern = 1;
else
starPattern = 0;
dsp = smb_FindDirSearch(inCookiep[12]);
if (!dsp) {
/* can't find dir search status; fatal error */
- osi_Log3(smb_logp, "SMB receive search dir bad cookie: cookie %d nextCookie %u [%s]",
- inCookiep[12], nextCookie, osi_LogSaveString(smb_logp, pathp));
+ osi_Log3(smb_logp, "SMB receive search dir bad cookie: cookie %d nextCookie %u [%S]",
+ inCookiep[12], nextCookie, osi_LogSaveClientString(smb_logp, pathp));
return CM_ERROR_BADFD;
}
attribute = dsp->attribute;
code = 0;
} else {
spacep = inp->spacep;
- smb_StripLastComponent(spacep->data, NULL, pathp);
+ smb_StripLastComponent(spacep->wdata, NULL, pathp);
code = smb_LookupTIDPath(vcp, ((smb_t *)inp)->tid, &tidPathp);
if (code) {
lock_ReleaseMutex(&dsp->mx);
smb_ReleaseDirSearch(dsp);
return CM_ERROR_NOFILES;
}
- strcpy(dsp->tidPath, tidPathp ? tidPathp : "/");
- strcpy(dsp->relPath, spacep->data);
+ cm_ClientStrCpy(dsp->tidPath, lengthof(dsp->tidPath), tidPathp ? tidPathp : _C("/"));
+ cm_ClientStrCpy(dsp->relPath, lengthof(dsp->relPath), spacep->wdata);
- code = cm_NameI(cm_data.rootSCachep, spacep->data,
+ code = cm_NameI(cm_data.rootSCachep, spacep->wdata,
caseFold | CM_FLAG_FOLLOW, userp, tidPathp, &req, &scp);
if (code == 0) {
#ifdef DFS_SUPPORT
if (scp->fileType == CM_SCACHETYPE_DFSLINK) {
- int pnc = cm_VolStatus_Notify_DFS_Mapping(scp, tidPathp, spacep->data);
+ int pnc;
+
+ pnc = cm_VolStatus_Notify_DFS_Mapping(scp, tidPathp, spacep->wdata);
cm_ReleaseSCache(scp);
lock_ReleaseMutex(&dsp->mx);
cm_ReleaseUser(userp);
if ( WANTS_DFS_PATHNAMES(inp) || pnc )
return CM_ERROR_PATH_NOT_COVERED;
else
- return CM_ERROR_BADSHARENAME;
+ return CM_ERROR_NOSUCHPATH;
}
#endif /* DFS_SUPPORT */
* now.
*/
cm_HoldSCache(scp);
- lock_ObtainMutex(&scp->mx);
- if ((scp->flags & CM_SCACHEFLAG_BULKSTATTING) == 0
- && LargeIntegerGreaterOrEqualToZero(scp->bulkStatProgress)) {
- scp->flags |= CM_SCACHEFLAG_BULKSTATTING;
- dsp->flags |= SMB_DIRSEARCH_BULKST;
- dsp->scp->bulkStatProgress = hzero;
- }
- lock_ReleaseMutex(&scp->mx);
+ lock_ObtainWrite(&scp->rw);
+ dsp->flags |= SMB_DIRSEARCH_BULKST;
+ lock_ReleaseWrite(&scp->rw);
}
}
lock_ReleaseMutex(&dsp->mx);
smb_SetSMBParm(outp, 0, 0);
/* get the directory size */
- lock_ObtainMutex(&scp->mx);
+ lock_ObtainWrite(&scp->rw);
code = cm_SyncOp(scp, NULL, userp, &req, 0,
CM_SCACHESYNC_NEEDCALLBACK | CM_SCACHESYNC_GETSTATUS);
if (code) {
- lock_ReleaseMutex(&scp->mx);
+ lock_ReleaseWrite(&scp->rw);
cm_ReleaseSCache(scp);
cm_ReleaseUser(userp);
smb_DeleteDirSearch(dsp);
code = 0;
returnedNames = 0;
while (1) {
+ clientchar_t *actualName = NULL;
+ int free_actualName = 0;
+ clientchar_t shortName[13];
+ clientchar_t *shortNameEnd;
+
/* make sure that curOffset.LowPart doesn't point to the first
* 32 bytes in the 2nd through last dir page, and that it doesn't
* point at the first 13 32-byte chunks in the first dir page,
buf_Release(bufferp);
bufferp = NULL;
}
- lock_ReleaseMutex(&scp->mx);
- code = buf_Get(scp, &thyper, &bufferp);
+ lock_ReleaseWrite(&scp->rw);
+ 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
* the status info for files in the dir.
*/
- if (starPattern) {
- smb_ApplyDirListPatches(&dirListPatchesp, dsp->tidPath, dsp->relPath, userp, &req);
- lock_ObtainMutex(&scp->mx);
- if ((dsp->flags & SMB_DIRSEARCH_BULKST) &&
- LargeIntegerGreaterThanOrEqualTo(thyper,
- scp->bulkStatProgress)) {
- /* Don't bulk stat if risking timeout */
- int now = GetTickCount();
- if (now - req.startTime > RDRtimeout * 1000) {
- scp->bulkStatProgress = thyper;
- scp->flags &= ~CM_SCACHEFLAG_BULKSTATTING;
- dsp->flags &= ~SMB_DIRSEARCH_BULKST;
- dsp->scp->bulkStatProgress = hzero;
- } else
- code = cm_TryBulkStat(scp, &thyper, userp, &req);
- }
- } else {
- lock_ObtainMutex(&scp->mx);
- }
+ if (starPattern)
+ smb_ApplyDirListPatches(scp, &dirListPatchesp, dsp->tidPath, dsp->relPath, userp, &req);
+
+ lock_ObtainWrite(&scp->rw);
lock_ReleaseMutex(&dsp->mx);
if (code) {
osi_Log2(smb_logp, "SMB search dir buf_Get scp %x failed %d", scp, code);
nextEntryCookie = curOffset.LowPart + (CM_DIR_CHUNKSIZE * numDirChunks);
/* Compute 8.3 name if necessary */
- actualName = dep->name;
+ actualName = cm_FsStringToClientStringAlloc(dep->name, -1, NULL);
if (dep->fid.vnode != 0 && !cm_Is8Dot3(actualName)) {
- cm_Gen8Dot3Name(dep, shortName, &shortNameEnd);
+ if (actualName)
+ free(actualName);
+ cm_Gen8Dot3NameInt(dep->name, &dep->fid, shortName, &shortNameEnd);
actualName = shortName;
+ free_actualName = 0;
+ } else {
+ free_actualName = 1;
+ }
+
+ if (actualName == NULL) {
+ /* Couldn't convert the name for some reason */
+ osi_Log1(smb_logp, "SMB search dir skipping entry :[%s]",
+ osi_LogSaveString(smb_logp, dep->name));
+ goto nextEntry;
}
- osi_Log3(smb_logp, "SMB search dir vn %d name %s (%s)",
- dep->fid.vnode, osi_LogSaveString(smb_logp, dep->name),
- osi_LogSaveString(smb_logp, actualName));
+ osi_Log3(smb_logp, "SMB search dir vn %d name %s (%S)",
+ dep->fid.vnode, osi_LogSaveString(smb_logp, dep->name),
+ osi_LogSaveClientString(smb_logp, actualName));
if (dep->fid.vnode != 0 && smb_Match8Dot3Mask(actualName, mask)) {
/* this is one of the entries to use: it is not deleted
*op++ = resByte;
memcpy(op, mask, 11); op += 11;
- *op++ = (char) dsp->cookie; /* they say it must be non-zero */
- *op++ = (char)(nextEntryCookie & 0xff);
- *op++ = (char)((nextEntryCookie>>8) & 0xff);
- *op++ = (char)((nextEntryCookie>>16) & 0xff);
- *op++ = (char)((nextEntryCookie>>24) & 0xff);
+ *op++ = (unsigned char) dsp->cookie; /* they say it must be non-zero */
+ *op++ = (unsigned char)(nextEntryCookie & 0xff);
+ *op++ = (unsigned char)((nextEntryCookie>>8) & 0xff);
+ *op++ = (unsigned char)((nextEntryCookie>>16) & 0xff);
+ *op++ = (unsigned char)((nextEntryCookie>>24) & 0xff);
memcpy(op, &clientCookie, 4); op += 4;
/* now we emit the attribute. This is sort of tricky,
* it fits in 8.3 or the pattern wouldn't match, but it
* never hurts to be sure.
*/
- strncpy(op, actualName, 13);
+ cm_ClientStringToUtf8(actualName, -1, op, 13);
if (smb_StoreAnsiFilenames)
CharToOem(op, op);
+ /* This is a UCHAR field, which is ASCII even if Unicode
+ is negotiated. */
/* Uppercase if requested by client */
if (!KNOWS_LONG_NAMES(inp))
} /* if we're including this name */
nextEntry:
+ if (free_actualName && actualName) {
+ free(actualName);
+ actualName = NULL;
+ }
+
/* and adjust curOffset to be where the new cookie is */
thyper.HighPart = 0;
thyper.LowPart = CM_DIR_CHUNKSIZE * numDirChunks;
} /* while copying data for dir listing */
/* release the mutex */
- lock_ReleaseMutex(&scp->mx);
+ lock_ReleaseWrite(&scp->rw);
if (bufferp) {
buf_Release(bufferp);
bufferp = NULL;
/* apply and free last set of patches; if not doing a star match, this
* will be empty, but better safe (and freeing everything) than sorry.
*/
- smb_ApplyDirListPatches(&dirListPatchesp, dsp->tidPath, dsp->relPath, userp, &req);
+ smb_ApplyDirListPatches(scp, &dirListPatchesp, dsp->tidPath, dsp->relPath, userp, &req);
/* special return code for unsuccessful search */
if (code == 0 && dataLength < 21 && returnedNames == 0)
*/
temp -= 3; /* deduct vbl block info */
osi_assertx(temp == (43 * returnedNames), "unexpected data length");
- origOp[1] = (char)(temp & 0xff);
- origOp[2] = (char)((temp>>8) & 0xff);
+ origOp[1] = (unsigned char)(temp & 0xff);
+ origOp[2] = (unsigned char)((temp>>8) & 0xff);
if (returnedNames == 0)
smb_DeleteDirSearch(dsp);
smb_ReleaseDirSearch(dsp);
return code;
}
+
/* verify that this is a valid path to a directory. I don't know why they
* don't use the get file attributes call.
+ *
+ * SMB_COM_CHECK_DIRECTORY
*/
long smb_ReceiveCoreCheckPath(smb_vc_t *vcp, smb_packet_t *inp, smb_packet_t *outp)
{
- char *pathp;
+ clientchar_t *pathp;
long code = 0;
cm_scache_t *rootScp;
cm_scache_t *newScp;
cm_user_t *userp;
unsigned int attrs;
int caseFold;
- char *tidPathp;
+ clientchar_t *tidPathp;
cm_req_t req;
+ char * pdata;
- cm_InitReq(&req);
+ smb_InitReq(&req);
- pathp = smb_GetSMBData(inp, NULL);
- pathp = smb_ParseASCIIBlock(pathp, NULL);
+ pdata = smb_GetSMBData(inp, NULL);
+ pathp = smb_ParseASCIIBlock(inp, pdata, NULL, SMB_STRF_ANSIPATH);
if (!pathp)
- return CM_ERROR_BADFD;
- if (smb_StoreAnsiFilenames)
- OemToChar(pathp,pathp);
- osi_Log1(smb_logp, "SMB receive check path %s",
- osi_LogSaveString(smb_logp, pathp));
+ return CM_ERROR_BADSMB;
+ osi_Log1(smb_logp, "SMB receive check path %S",
+ osi_LogSaveClientString(smb_logp, pathp));
rootScp = cm_data.rootSCachep;
if ( WANTS_DFS_PATHNAMES(inp) || pnc )
return CM_ERROR_PATH_NOT_COVERED;
else
- return CM_ERROR_BADSHARENAME;
+ return CM_ERROR_NOSUCHPATH;
}
#endif /* DFS_SUPPORT */
/* now lock the vnode with a callback; returns with newScp locked */
- lock_ObtainMutex(&newScp->mx);
+ lock_ObtainWrite(&newScp->rw);
code = cm_SyncOp(newScp, NULL, userp, &req, PRSFS_LOOKUP,
CM_SCACHESYNC_GETSTATUS | CM_SCACHESYNC_NEEDCALLBACK);
if (code) {
if (code != CM_ERROR_NOACCESS) {
- lock_ReleaseMutex(&newScp->mx);
+ lock_ReleaseWrite(&newScp->rw);
cm_ReleaseSCache(newScp);
cm_ReleaseUser(userp);
return code;
if (!(attrs & SMB_ATTR_DIRECTORY))
code = CM_ERROR_NOTDIR;
- lock_ReleaseMutex(&newScp->mx);
+ lock_ReleaseWrite(&newScp->rw);
cm_ReleaseSCache(newScp);
cm_ReleaseUser(userp);
return code;
}
+/* SMB_COM_SET_INFORMATION */
long smb_ReceiveCoreSetFileAttributes(smb_vc_t *vcp, smb_packet_t *inp, smb_packet_t *outp)
{
- char *pathp;
+ clientchar_t *pathp;
long code = 0;
cm_scache_t *rootScp;
unsigned short attribute;
afs_uint32 dosTime;
cm_user_t *userp;
int caseFold;
- char *tidPathp;
+ clientchar_t *tidPathp;
+ char * datap;
cm_req_t req;
- cm_InitReq(&req);
+ smb_InitReq(&req);
/* decode basic attributes we're passed */
attribute = smb_GetSMBParm(inp, 0);
dosTime = smb_GetSMBParm(inp, 1) | (smb_GetSMBParm(inp, 2) << 16);
- pathp = smb_GetSMBData(inp, NULL);
- pathp = smb_ParseASCIIBlock(pathp, NULL);
+ datap = smb_GetSMBData(inp, NULL);
+ pathp = smb_ParseASCIIBlock(inp, datap, NULL, SMB_STRF_ANSIPATH);
if (!pathp)
return CM_ERROR_BADSMB;
- if (smb_StoreAnsiFilenames)
- OemToChar(pathp,pathp);
osi_Log2(smb_logp, "SMB receive setfile attributes time %d, attr 0x%x",
dosTime, attribute);
if ( WANTS_DFS_PATHNAMES(inp) || pnc )
return CM_ERROR_PATH_NOT_COVERED;
else
- return CM_ERROR_BADSHARENAME;
+ return CM_ERROR_NOSUCHPATH;
}
#endif /* DFS_SUPPORT */
* need the current status to determine what the new status is, in some
* cases.
*/
- lock_ObtainMutex(&newScp->mx);
+ lock_ObtainWrite(&newScp->rw);
code = cm_SyncOp(newScp, NULL, userp, &req, 0,
CM_SCACHESYNC_GETSTATUS | CM_SCACHESYNC_NEEDCALLBACK);
if (code) {
- lock_ReleaseMutex(&newScp->mx);
+ lock_ReleaseWrite(&newScp->rw);
cm_ReleaseSCache(newScp);
cm_ReleaseUser(userp);
return code;
/* Check for RO volume */
if (newScp->flags & CM_SCACHEFLAG_RO) {
- lock_ReleaseMutex(&newScp->mx);
+ lock_ReleaseWrite(&newScp->rw);
cm_ReleaseSCache(newScp);
cm_ReleaseUser(userp);
return CM_ERROR_READONLY;
attr.mask |= CM_ATTRMASK_CLIENTMODTIME;
smb_UnixTimeFromDosUTime(&attr.clientModTime, dosTime);
}
- if ((newScp->unixModeBits & 0222) && (attribute & SMB_ATTR_READONLY) != 0) {
+ if ((newScp->unixModeBits & 0200) && (attribute & SMB_ATTR_READONLY) != 0) {
/* we're told to make a writable file read-only */
attr.unixModeBits = newScp->unixModeBits & ~0222;
attr.mask |= CM_ATTRMASK_UNIXMODEBITS;
}
- else if ((newScp->unixModeBits & 0222) == 0 && (attribute & SMB_ATTR_READONLY) == 0) {
+ else if ((newScp->unixModeBits & 0200) == 0 && (attribute & SMB_ATTR_READONLY) == 0) {
/* we're told to make a read-only file writable */
attr.unixModeBits = newScp->unixModeBits | 0222;
attr.mask |= CM_ATTRMASK_UNIXMODEBITS;
}
- lock_ReleaseMutex(&newScp->mx);
+ lock_ReleaseWrite(&newScp->rw);
/* now call setattr */
if (attr.mask)
return code;
}
+
long smb_ReceiveCoreGetFileAttributes(smb_vc_t *vcp, smb_packet_t *inp, smb_packet_t *outp)
{
- char *pathp;
+ clientchar_t *pathp;
long code = 0;
cm_scache_t *rootScp;
cm_scache_t *newScp, *dscp;
int attrs;
cm_user_t *userp;
int caseFold;
- char *tidPathp;
+ clientchar_t *tidPathp;
cm_space_t *spacep;
- char *lastComp;
+ clientchar_t *lastComp;
+ char * datap;
cm_req_t req;
- cm_InitReq(&req);
+ smb_InitReq(&req);
- pathp = smb_GetSMBData(inp, NULL);
- pathp = smb_ParseASCIIBlock(pathp, NULL);
+ datap = smb_GetSMBData(inp, NULL);
+ pathp = smb_ParseASCIIBlock(inp, datap, NULL, SMB_STRF_ANSIPATH);
if (!pathp)
return CM_ERROR_BADSMB;
if (*pathp == 0) /* null path */
- pathp = "\\";
- else
- if (smb_StoreAnsiFilenames)
- OemToChar(pathp,pathp);
+ pathp = _C("\\");
- osi_Log1(smb_logp, "SMB receive getfile attributes path %s",
- osi_LogSaveString(smb_logp, pathp));
+ osi_Log1(smb_logp, "SMB receive getfile attributes path %S",
+ osi_LogSaveClientString(smb_logp, pathp));
rootScp = cm_data.rootSCachep;
* http://msdn.microsoft.com/library/en-us/shellcc/platform/shell/programmersguide/shell_basics/shell_basics_extending/custom.asp
*/
spacep = inp->spacep;
- smb_StripLastComponent(spacep->data, &lastComp, pathp);
+ smb_StripLastComponent(spacep->wdata, &lastComp, pathp);
#ifndef SPECIAL_FOLDERS
- if (lastComp && stricmp(lastComp, "\\desktop.ini") == 0) {
- code = cm_NameI(rootScp, spacep->data,
+ if (lastComp && cm_ClientStrCmpIA(lastComp, _C("\\desktop.ini")) == 0) {
+ code = cm_NameI(rootScp, spacep->wdata,
caseFold | CM_FLAG_DIRSEARCH | CM_FLAG_FOLLOW,
userp, tidPathp, &req, &dscp);
if (code == 0) {
#ifdef DFS_SUPPORT
if (dscp->fileType == CM_SCACHETYPE_DFSLINK) {
- int pnc = cm_VolStatus_Notify_DFS_Mapping(dscp, tidPathp, spacep->data);
+ int pnc = cm_VolStatus_Notify_DFS_Mapping(dscp, tidPathp,
+ spacep->wdata);
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 */
/* now lock the vnode with a callback; returns with newScp locked */
- lock_ObtainMutex(&newScp->mx);
+ lock_ObtainWrite(&newScp->rw);
code = cm_SyncOp(newScp, NULL, userp, &req, 0,
CM_SCACHESYNC_GETSTATUS | CM_SCACHESYNC_NEEDCALLBACK);
if (code) {
- lock_ReleaseMutex(&newScp->mx);
+ lock_ReleaseWrite(&newScp->rw);
cm_ReleaseSCache(newScp);
cm_ReleaseUser(userp);
return code;
cm_SyncOpDone(newScp, NULL, CM_SCACHESYNC_NEEDCALLBACK | CM_SCACHESYNC_GETSTATUS);
-#ifdef undef
- /* use smb_Attributes instead. Also the fact that a file is
- * in a readonly volume doesn't mean it shojuld be marked as RO
- */
- if (newScp->fileType == CM_SCACHETYPE_DIRECTORY ||
- newScp->fileType == CM_SCACHETYPE_MOUNTPOINT ||
- newScp->fileType == CM_SCACHETYPE_INVALID)
- attrs = SMB_ATTR_DIRECTORY;
- else
- attrs = 0;
- if ((newScp->unixModeBits & 0222) == 0 || (newScp->flags & CM_SCACHEFLAG_RO))
- attrs |= SMB_ATTR_READONLY; /* turn on read-only flag */
-#else
attrs = smb_Attributes(newScp);
-#endif
smb_SetSMBParm(outp, 0, attrs);
smb_SetSMBParm(outp, 8, 0);
smb_SetSMBParm(outp, 9, 0);
smb_SetSMBDataLength(outp, 0);
- lock_ReleaseMutex(&newScp->mx);
+ lock_ReleaseWrite(&newScp->rw);
cm_ReleaseSCache(newScp);
cm_ReleaseUser(userp);
return 0;
}
+/* SMB_COM_TREE_DISCONNECT */
long smb_ReceiveCoreTreeDisconnect(smb_vc_t *vcp, smb_packet_t *inp, smb_packet_t *outp)
{
smb_tid_t *tidp;
tidp = smb_FindTID(vcp, ((smb_t *)inp)->tid, 0);
if (tidp) {
lock_ObtainWrite(&smb_rctLock);
- tidp->delete = 1;
+ tidp->deleteOk = 1;
smb_ReleaseTID(tidp, TRUE);
lock_ReleaseWrite(&smb_rctLock);
}
return 0;
}
+/* SMB_COM_0PEN */
long smb_ReceiveCoreOpen(smb_vc_t *vcp, smb_packet_t *inp, smb_packet_t *outp)
{
smb_fid_t *fidp;
- char *pathp;
- char *lastNamep;
+ clientchar_t *pathp;
+ clientchar_t *lastNamep;
int share;
int attribute;
long code = 0;
afs_uint32 dosTime;
int caseFold;
cm_space_t *spacep;
- char *tidPathp;
+ clientchar_t *tidPathp;
+ char * datap;
cm_req_t req;
- cm_InitReq(&req);
+ smb_InitReq(&req);
- pathp = smb_GetSMBData(inp, NULL);
- pathp = smb_ParseASCIIBlock(pathp, NULL);
- if (smb_StoreAnsiFilenames)
- OemToChar(pathp,pathp);
-
- osi_Log1(smb_logp, "SMB receive open file [%s]", osi_LogSaveString(smb_logp, pathp));
+ 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));
#ifdef DEBUG_VERBOSE
{
attribute = smb_GetSMBParm(inp, 1);
spacep = inp->spacep;
- smb_StripLastComponent(spacep->data, &lastNamep, pathp);
- if (lastNamep && strcmp(lastNamep, SMB_IOCTL_FILENAME) == 0) {
+ /* smb_StripLastComponent will strip "::$DATA" if present */
+ smb_StripLastComponent(spacep->wdata, &lastNamep, pathp);
+
+ if (!cm_IsValidClientString(pathp)) {
+#ifdef DEBUG
+ clientchar_t * hexp;
+
+ hexp = cm_GetRawCharsAlloc(pathp, -1);
+ osi_Log1(smb_logp, "CoreOpen rejecting invalid name. [%S]",
+ osi_LogSaveClientString(smb_logp, hexp));
+ if (hexp)
+ free(hexp);
+#else
+ osi_Log0(smb_logp, "CoreOpen rejecting invalid name");
+#endif
+ return CM_ERROR_BADNTFILENAME;
+ }
+
+ 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_ObtainMutex(&scp->mx);
- scp->flags |= CM_SCACHEFLAG_SMB_FID;
- lock_ReleaseMutex(&scp->mx);
-
- /* 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_ObtainMutex(&scp->mx);
+ /* 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(&scp->mx);
+ lock_ReleaseMutex(&fidp->mx);
+ lock_ReleaseRead(&scp->rw);
/* notify open */
cm_Open(scp, 0, userp);
cm_user_t *userp;
cm_req_t *reqp;
smb_vc_t *vcp;
- char *maskp; /* pointer to the star pattern */
+ clientchar_t *maskp; /* pointer to the star pattern */
int flags;
int any;
cm_dirEntryList_t * matches;
smb_unlinkRock_t *rockp;
int caseFold;
int match;
- char shortName[13];
- char *matchName;
+ normchar_t matchName[MAX_PATH];
rockp = vrockp;
if (!(rockp->vcp->flags & SMB_VCFLAG_USEV3))
caseFold |= CM_FLAG_8DOT3;
- matchName = dep->name;
- match = smb_V3MatchMask(matchName, rockp->maskp, caseFold);
+ if (cm_FsStringToNormString(dep->name, -1, matchName, lengthof(matchName)) == 0) {
+ /* Can't convert name */
+ osi_Log1(smb_logp, "Skipping entry [%s]. Can't normalize FS string.",
+ osi_LogSaveString(smb_logp, dep->name));
+ return 0;
+ }
+
+ match = cm_MatchMask(matchName, rockp->maskp, caseFold);
if (!match &&
- (rockp->flags & SMB_MASKFLAG_TILDE) &&
- !cm_Is8Dot3(dep->name)) {
- cm_Gen8Dot3Name(dep, shortName, NULL);
- matchName = shortName;
+ (rockp->flags & SMB_MASKFLAG_TILDE) &&
+ !cm_Is8Dot3(matchName)) {
+ cm_Gen8Dot3Name(dep, matchName, NULL);
/* 8.3 matches are always case insensitive */
- match = smb_V3MatchMask(matchName, rockp->maskp, caseFold | CM_FLAG_CASEFOLD);
+ match = cm_MatchMask(matchName, rockp->maskp, caseFold | CM_FLAG_CASEFOLD);
}
if (match) {
- osi_Log1(smb_logp, "Found match %s",
- osi_LogSaveString(smb_logp, matchName));
+ osi_Log1(smb_logp, "Found match %S",
+ osi_LogSaveClientString(smb_logp, matchName));
cm_DirEntryListAdd(dep->name, &rockp->matches);
rockp->any = 1;
/* If we made a case sensitive exact match, we might as well quit now. */
- if (!(rockp->flags & SMB_MASKFLAG_CASEFOLD) && !strcmp(matchName, rockp->maskp))
+ if (!(rockp->flags & SMB_MASKFLAG_CASEFOLD) && !cm_ClientStrCmp(matchName, rockp->maskp))
code = CM_ERROR_STOPNOW;
else
code = 0;
return code;
}
+/* SMB_COM_DELETE */
long smb_ReceiveCoreUnlink(smb_vc_t *vcp, smb_packet_t *inp, smb_packet_t *outp)
{
int attribute;
long code = 0;
- char *pathp;
- char *tp;
+ clientchar_t *pathp;
+ unsigned char *tp;
cm_space_t *spacep;
cm_scache_t *dscp;
- char *lastNamep;
+ clientchar_t *lastNamep;
smb_unlinkRock_t rock;
cm_user_t *userp;
osi_hyper_t thyper;
int caseFold;
- char *tidPathp;
+ clientchar_t *tidPathp;
cm_req_t req;
- cm_InitReq(&req);
+ smb_InitReq(&req);
+ memset(&rock, 0, sizeof(rock));
attribute = smb_GetSMBParm(inp, 0);
tp = smb_GetSMBData(inp, NULL);
- pathp = smb_ParseASCIIBlock(tp, &tp);
- if (smb_StoreAnsiFilenames)
- OemToChar(pathp,pathp);
+ pathp = smb_ParseASCIIBlock(inp, tp, &tp, SMB_STRF_ANSIPATH);
+ if (!pathp)
+ return CM_ERROR_BADSMB;
- osi_Log1(smb_logp, "SMB receive unlink %s",
- osi_LogSaveString(smb_logp, pathp));
+ osi_Log1(smb_logp, "SMB receive unlink %S",
+ osi_LogSaveClientString(smb_logp, pathp));
spacep = inp->spacep;
- smb_StripLastComponent(spacep->data, &lastNamep, pathp);
+ smb_StripLastComponent(spacep->wdata, &lastNamep, pathp);
userp = smb_GetUserFromVCP(vcp, inp);
cm_ReleaseUser(userp);
return CM_ERROR_NOSUCHPATH;
}
- code = cm_NameI(cm_data.rootSCachep, spacep->data, caseFold, userp, tidPathp,
+ code = cm_NameI(cm_data.rootSCachep, spacep->wdata, caseFold, userp, tidPathp,
&req, &dscp);
if (code) {
cm_ReleaseUser(userp);
#ifdef DFS_SUPPORT
if (dscp->fileType == CM_SCACHETYPE_DFSLINK) {
- int pnc = cm_VolStatus_Notify_DFS_Mapping(dscp, tidPathp,spacep->data);
+ int pnc = cm_VolStatus_Notify_DFS_Mapping(dscp, tidPathp, spacep->wdata);
cm_ReleaseSCache(dscp);
cm_ReleaseUser(userp);
if ( WANTS_DFS_PATHNAMES(inp) || pnc )
return CM_ERROR_PATH_NOT_COVERED;
else
- return CM_ERROR_BADSHARENAME;
+ return CM_ERROR_NOSUCHPATH;
}
#endif /* DFS_SUPPORT */
lastNamep++;
rock.any = 0;
- rock.maskp = smb_FindMask(pathp);
- rock.flags = ((strchr(rock.maskp, '~') != NULL) ? SMB_MASKFLAG_TILDE : 0);
+ rock.maskp = cm_ClientStringToNormStringAlloc(smb_FindMask(pathp), -1, NULL);
+ if (!rock.maskp) {
+ code = CM_ERROR_NOSUCHFILE;
+ goto done;
+ }
+ rock.flags = ((cm_ClientStrChr(rock.maskp, '~') != NULL) ? SMB_MASKFLAG_TILDE : 0);
thyper.LowPart = 0;
thyper.HighPart = 0;
cm_dirEntryList_t * entry;
for (entry = rock.matches; code == 0 && entry; entry = entry->nextp) {
+ normchar_t normalizedName[MAX_PATH];
+
+ /* Note: entry->name is a non-normalized name */
osi_Log1(smb_logp, "Unlinking %s",
osi_LogSaveString(smb_logp, entry->name));
- code = cm_Unlink(dscp, entry->name, userp, &req);
+
+ /* We assume this works because entry->name was
+ successfully converted in smb_UnlinkProc() once. */
+ cm_FsStringToNormString(entry->name, -1,
+ normalizedName, lengthof(normalizedName));
+
+ code = cm_Unlink(dscp, entry->name, normalizedName, userp, &req);
if (code == 0 && (dscp->flags & CM_SCACHEFLAG_ANYWATCH))
smb_NotifyChange(FILE_ACTION_REMOVED,
FILE_NOTIFY_CHANGE_FILE_NAME | FILE_NOTIFY_CHANGE_CREATION,
- dscp, entry->name, NULL, TRUE);
+ dscp, normalizedName, NULL, TRUE);
}
}
cm_DirEntryListFree(&rock.matches);
+ done:
+ if (userp)
cm_ReleaseUser(userp);
+ if (dscp)
cm_ReleaseSCache(dscp);
+ if (rock.maskp)
+ free(rock.maskp);
+
if (code == 0 && !rock.any)
code = CM_ERROR_NOSUCHFILE;
return code;
}
typedef struct smb_renameRock {
- cm_scache_t *odscp; /* old dir */
- cm_scache_t *ndscp; /* new dir */
- cm_user_t *userp; /* user */
- cm_req_t *reqp; /* request struct */
- smb_vc_t *vcp; /* virtual circuit */
- char *maskp; /* pointer to star pattern of old file name */
- int flags; /* tilde, casefold, etc */
- char *newNamep; /* ptr to the new file's name */
- char oldName[MAX_PATH];
+ cm_scache_t *odscp; /* old dir */
+ cm_scache_t *ndscp; /* new dir */
+ cm_user_t *userp; /* user */
+ cm_req_t *reqp; /* request struct */
+ smb_vc_t *vcp; /* virtual circuit */
+ normchar_t *maskp; /* pointer to star pattern of old file name */
+ int flags; /* tilde, casefold, etc */
+ clientchar_t *newNamep; /* ptr to the new file's name */
+ fschar_t fsOldName[MAX_PATH]; /* raw FS name */
+ clientchar_t clOldName[MAX_PATH]; /* client name */
int any;
} smb_renameRock_t;
smb_renameRock_t *rockp;
int caseFold;
int match;
- char shortName[13]="";
+ normchar_t matchName[MAX_PATH];
rockp = (smb_renameRock_t *) vrockp;
+ if (cm_FsStringToNormString(dep->name, -1, matchName, lengthof(matchName)) == 0) {
+ /* Can't convert string */
+ osi_Log1(smb_logp, "Skpping entry [%s]. Can't normalize FS string",
+ osi_LogSaveString(smb_logp, dep->name));
+ return 0;
+ }
+
caseFold = ((rockp->flags & SMB_MASKFLAG_CASEFOLD)? CM_FLAG_CASEFOLD : 0);
if (!(rockp->vcp->flags & SMB_VCFLAG_USEV3))
caseFold |= CM_FLAG_8DOT3;
- match = smb_V3MatchMask(dep->name, rockp->maskp, caseFold);
+ match = cm_MatchMask(matchName, rockp->maskp, caseFold);
if (!match &&
(rockp->flags & SMB_MASKFLAG_TILDE) &&
- !cm_Is8Dot3(dep->name)) {
- cm_Gen8Dot3Name(dep, shortName, NULL);
- match = smb_V3MatchMask(shortName, rockp->maskp, caseFold);
+ !cm_Is8Dot3(matchName)) {
+ cm_Gen8Dot3Name(dep, matchName, NULL);
+ match = cm_MatchMask(matchName, rockp->maskp, caseFold);
}
if (match) {
rockp->any = 1;
- strncpy(rockp->oldName, dep->name, sizeof(rockp->oldName)/sizeof(char) - 1);
- rockp->oldName[sizeof(rockp->oldName)/sizeof(char) - 1] = '\0';
- code = CM_ERROR_STOPNOW;
+ StringCbCopyA(rockp->fsOldName, sizeof(rockp->fsOldName), dep->name);
+ cm_ClientStrCpy(rockp->clOldName, lengthof(rockp->clOldName),
+ matchName);
+ code = CM_ERROR_STOPNOW;
} else {
code = 0;
}
long
-smb_Rename(smb_vc_t *vcp, smb_packet_t *inp, char * oldPathp, char * newPathp, int attrs)
+smb_Rename(smb_vc_t *vcp, smb_packet_t *inp, clientchar_t * oldPathp, clientchar_t * newPathp, int attrs)
{
long code = 0;
cm_space_t *spacep = NULL;
cm_scache_t *newDscp = NULL;
cm_scache_t *tmpscp= NULL;
cm_scache_t *tmpscp2 = NULL;
- char *oldLastNamep;
- char *newLastNamep;
+ clientchar_t *oldLastNamep;
+ clientchar_t *newLastNamep;
osi_hyper_t thyper;
cm_user_t *userp;
int caseFold;
- char *tidPathp;
+ clientchar_t *tidPathp;
DWORD filter;
cm_req_t req;
return CM_ERROR_NOSUCHPATH;
}
- cm_InitReq(&req);
+ smb_InitReq(&req);
+ memset(&rock, 0, sizeof(rock));
+
spacep = inp->spacep;
- smb_StripLastComponent(spacep->data, &oldLastNamep, oldPathp);
+ smb_StripLastComponent(spacep->wdata, &oldLastNamep, oldPathp);
caseFold = CM_FLAG_FOLLOW | CM_FLAG_CASEFOLD;
- code = cm_NameI(cm_data.rootSCachep, spacep->data, caseFold,
+ code = cm_NameI(cm_data.rootSCachep, spacep->wdata, caseFold,
userp, tidPathp, &req, &oldDscp);
if (code) {
cm_ReleaseUser(userp);
#ifdef DFS_SUPPORT
if (oldDscp->fileType == CM_SCACHETYPE_DFSLINK) {
- int pnc = cm_VolStatus_Notify_DFS_Mapping(oldDscp, tidPathp, spacep->data);
+ int pnc = cm_VolStatus_Notify_DFS_Mapping(oldDscp, tidPathp, spacep->wdata);
cm_ReleaseSCache(oldDscp);
cm_ReleaseUser(userp);
if ( WANTS_DFS_PATHNAMES(inp) || pnc )
return CM_ERROR_PATH_NOT_COVERED;
else
- return CM_ERROR_BADSHARENAME;
+ return CM_ERROR_NOSUCHPATH;
}
#endif /* DFS_SUPPORT */
- smb_StripLastComponent(spacep->data, &newLastNamep, newPathp);
- code = cm_NameI(cm_data.rootSCachep, spacep->data, caseFold,
+ smb_StripLastComponent(spacep->wdata, &newLastNamep, newPathp);
+ code = cm_NameI(cm_data.rootSCachep, spacep->wdata, caseFold,
userp, tidPathp, &req, &newDscp);
if (code) {
#ifdef DFS_SUPPORT
if (newDscp->fileType == CM_SCACHETYPE_DFSLINK) {
- int pnc = cm_VolStatus_Notify_DFS_Mapping(newDscp, tidPathp, spacep->data);
+ int pnc = cm_VolStatus_Notify_DFS_Mapping(newDscp, tidPathp, spacep->wdata);
cm_ReleaseSCache(oldDscp);
cm_ReleaseSCache(newDscp);
cm_ReleaseUser(userp);
if ( WANTS_DFS_PATHNAMES(inp) || pnc )
return CM_ERROR_PATH_NOT_COVERED;
else
- return CM_ERROR_BADSHARENAME;
+ return CM_ERROR_NOSUCHPATH;
}
#endif /* DFS_SUPPORT */
/* TODO: The old name could be a wildcard. The new name must not be */
- /* do the vnode call */
- rock.odscp = oldDscp;
- rock.ndscp = newDscp;
- rock.userp = userp;
- rock.reqp = &req;
- rock.vcp = vcp;
- rock.maskp = oldLastNamep;
- rock.flags = ((strchr(oldLastNamep, '~') != NULL) ? SMB_MASKFLAG_TILDE : 0);
- rock.newNamep = newLastNamep;
- rock.oldName[0] = '\0';
- rock.any = 0;
-
/* Check if the file already exists; if so return error */
code = cm_Lookup(newDscp,newLastNamep,CM_FLAG_CHECKPATH,userp,&req,&tmpscp);
if ((code != CM_ERROR_NOSUCHFILE) && (code != CM_ERROR_BPLUS_NOMATCH) &&
(code != CM_ERROR_NOSUCHPATH) && (code != CM_ERROR_NOSUCHVOLUME) )
{
- osi_Log2(smb_logp, " lookup returns %ld for [%s]", code,
- osi_LogSaveString(smb_logp, newLastNamep));
+ osi_Log2(smb_logp, " lookup returns %ld for [%S]", code,
+ osi_LogSaveClientString(smb_logp, newLastNamep));
/* Check if the old and the new names differ only in case. If so return
* success, else return CM_ERROR_EXISTS
*/
- if (!code && oldDscp == newDscp && !stricmp(oldLastNamep, newLastNamep)) {
+ if (!code && oldDscp == newDscp && !cm_ClientStrCmpI(oldLastNamep, newLastNamep)) {
/* This would be a success only if the old file is *as same as* the new file */
code = cm_Lookup(oldDscp, oldLastNamep, CM_FLAG_CHECKPATH, userp, &req, &tmpscp2);
osi_Log0(smb_logp, "Can't rename. Target already exists");
code = CM_ERROR_EXISTS;
}
+ goto done;
+ }
- if (tmpscp != NULL)
- cm_ReleaseSCache(tmpscp);
- cm_ReleaseSCache(newDscp);
- cm_ReleaseSCache(oldDscp);
- cm_ReleaseUser(userp);
- return code;
+ /* do the vnode call */
+ rock.odscp = oldDscp;
+ rock.ndscp = newDscp;
+ rock.userp = userp;
+ rock.reqp = &req;
+ rock.vcp = vcp;
+ rock.maskp = cm_ClientStringToNormStringAlloc(oldLastNamep, -1, NULL);
+ if (!rock.maskp) {
+ code = CM_ERROR_NOSUCHFILE;
+ goto done;
}
+ rock.flags = ((cm_ClientStrChr(oldLastNamep, '~') != NULL) ? SMB_MASKFLAG_TILDE : 0);
+ rock.newNamep = newLastNamep;
+ rock.fsOldName[0] = '\0';
+ rock.clOldName[0] = '\0';
+ rock.any = 0;
/* Now search the directory for the pattern, and do the appropriate rename when found */
thyper.LowPart = 0; /* search dir from here */
}
osi_Log1(smb_logp, "smb_RenameProc returns %ld", code);
- if (code == CM_ERROR_STOPNOW && rock.oldName[0] != '\0') {
- code = cm_Rename(rock.odscp, rock.oldName,
+ if (code == CM_ERROR_STOPNOW && rock.fsOldName[0] != '\0') {
+ code = cm_Rename(rock.odscp, rock.fsOldName, rock.clOldName,
rock.ndscp, rock.newNamep, rock.userp,
- rock.reqp);
+ rock.reqp);
/* if the call worked, stop doing the search now, since we
* really only want to rename one file.
*/
+ if (code)
+ osi_Log0(smb_logp, "cm_Rename failure");
osi_Log1(smb_logp, "cm_Rename returns %ld", code);
} else if (code == 0) {
code = CM_ERROR_NOSUCHFILE;
if (oldDscp == newDscp) {
if (oldDscp->flags & CM_SCACHEFLAG_ANYWATCH)
smb_NotifyChange(FILE_ACTION_RENAMED_OLD_NAME,
- filter, oldDscp, oldLastNamep,
- newLastNamep, TRUE);
+ filter, oldDscp, rock.clOldName,
+ newLastNamep, TRUE);
} else {
if (oldDscp->flags & CM_SCACHEFLAG_ANYWATCH)
smb_NotifyChange(FILE_ACTION_RENAMED_OLD_NAME,
- filter, oldDscp, oldLastNamep,
+ filter, oldDscp, rock.clOldName,
NULL, TRUE);
if (newDscp->flags & CM_SCACHEFLAG_ANYWATCH)
smb_NotifyChange(FILE_ACTION_RENAMED_NEW_NAME,
- filter, newDscp, newLastNamep,
- NULL, TRUE);
+ filter, newDscp, newLastNamep,
+ NULL, TRUE);
}
}
+ done:
if (tmpscp != NULL)
cm_ReleaseSCache(tmpscp);
- cm_ReleaseUser(userp);
- cm_ReleaseSCache(oldDscp);
- cm_ReleaseSCache(newDscp);
+ if (userp)
+ cm_ReleaseUser(userp);
+ if (oldDscp)
+ cm_ReleaseSCache(oldDscp);
+ if (newDscp)
+ cm_ReleaseSCache(newDscp);
+ if (rock.maskp)
+ free(rock.maskp);
+
return code;
}
long
-smb_Link(smb_vc_t *vcp, smb_packet_t *inp, char * oldPathp, char * newPathp)
+smb_Link(smb_vc_t *vcp, smb_packet_t *inp, clientchar_t * oldPathp, clientchar_t * newPathp)
{
long code = 0;
cm_space_t *spacep = NULL;
cm_scache_t *tmpscp= NULL;
cm_scache_t *tmpscp2 = NULL;
cm_scache_t *sscp = NULL;
- char *oldLastNamep;
- char *newLastNamep;
+ clientchar_t *oldLastNamep;
+ clientchar_t *newLastNamep;
cm_user_t *userp;
int caseFold;
- char *tidPathp;
+ clientchar_t *tidPathp;
DWORD filter;
cm_req_t req;
return CM_ERROR_NOSUCHPATH;
}
- cm_InitReq(&req);
+ smb_InitReq(&req);
caseFold = CM_FLAG_FOLLOW | CM_FLAG_CASEFOLD;
spacep = inp->spacep;
- smb_StripLastComponent(spacep->data, &oldLastNamep, oldPathp);
+ smb_StripLastComponent(spacep->wdata, &oldLastNamep, oldPathp);
- code = cm_NameI(cm_data.rootSCachep, spacep->data, caseFold,
+ code = cm_NameI(cm_data.rootSCachep, spacep->wdata, caseFold,
userp, tidPathp, &req, &oldDscp);
if (code) {
cm_ReleaseUser(userp);
#ifdef DFS_SUPPORT
if (oldDscp->fileType == CM_SCACHETYPE_DFSLINK) {
- int pnc = cm_VolStatus_Notify_DFS_Mapping(oldDscp, tidPathp, spacep->data);
+ int pnc = cm_VolStatus_Notify_DFS_Mapping(oldDscp, tidPathp, spacep->wdata);
cm_ReleaseSCache(oldDscp);
cm_ReleaseUser(userp);
if ( WANTS_DFS_PATHNAMES(inp) || pnc )
return CM_ERROR_PATH_NOT_COVERED;
else
- return CM_ERROR_BADSHARENAME;
+ return CM_ERROR_NOSUCHPATH;
}
#endif /* DFS_SUPPORT */
- smb_StripLastComponent(spacep->data, &newLastNamep, newPathp);
- code = cm_NameI(cm_data.rootSCachep, spacep->data, caseFold,
+ smb_StripLastComponent(spacep->wdata, &newLastNamep, newPathp);
+ code = cm_NameI(cm_data.rootSCachep, spacep->wdata, caseFold,
userp, tidPathp, &req, &newDscp);
if (code) {
cm_ReleaseSCache(oldDscp);
#ifdef DFS_SUPPORT
if (newDscp->fileType == CM_SCACHETYPE_DFSLINK) {
- int pnc = cm_VolStatus_Notify_DFS_Mapping(newDscp, tidPathp, spacep->data);
+ int pnc = cm_VolStatus_Notify_DFS_Mapping(newDscp, tidPathp, spacep->wdata);
cm_ReleaseSCache(newDscp);
cm_ReleaseSCache(oldDscp);
cm_ReleaseUser(userp);
if ( WANTS_DFS_PATHNAMES(inp) || pnc )
return CM_ERROR_PATH_NOT_COVERED;
else
- return CM_ERROR_BADSHARENAME;
+ return CM_ERROR_NOSUCHPATH;
}
#endif /* DFS_SUPPORT */
newLastNamep++;
/* now lookup the old name */
- osi_Log1(smb_logp," looking up [%s]", osi_LogSaveString(smb_logp,oldLastNamep));
+ osi_Log1(smb_logp," looking up [%S]", osi_LogSaveClientString(smb_logp,oldLastNamep));
code = cm_Lookup(oldDscp, oldLastNamep, CM_FLAG_CHECKPATH | CM_FLAG_CASEFOLD, userp, &req, &sscp);
if (code) {
cm_ReleaseSCache(oldDscp);
if ((code != CM_ERROR_NOSUCHFILE) && (code != CM_ERROR_BPLUS_NOMATCH) &&
(code != CM_ERROR_NOSUCHPATH) && (code != CM_ERROR_NOSUCHVOLUME) )
{
- osi_Log2(smb_logp, " lookup returns %ld for [%s]", code,
- osi_LogSaveString(smb_logp, newLastNamep));
+ osi_Log2(smb_logp, " lookup returns %ld for [%S]", code,
+ osi_LogSaveClientString(smb_logp, newLastNamep));
/* if the existing link is to the same file, then we return success */
if (!code) {
}
/* now create the hardlink */
- osi_Log1(smb_logp," Attempting to create new link [%s]", osi_LogSaveString(smb_logp, newLastNamep));
+ osi_Log1(smb_logp," Attempting to create new link [%S]", osi_LogSaveClientString(smb_logp, newLastNamep));
code = cm_Link(newDscp, newLastNamep, sscp, 0, userp, &req);
osi_Log1(smb_logp," Link returns 0x%x", code);
return code;
}
+/* SMB_COM_RENAME */
long
smb_ReceiveCoreRename(smb_vc_t *vcp, smb_packet_t *inp, smb_packet_t *outp)
{
- char *oldPathp;
- char *newPathp;
- char *tp;
+ clientchar_t *oldPathp;
+ clientchar_t *newPathp;
+ unsigned char *tp;
long code;
tp = smb_GetSMBData(inp, NULL);
- oldPathp = smb_ParseASCIIBlock(tp, &tp);
- if (smb_StoreAnsiFilenames)
- OemToChar(oldPathp,oldPathp);
- newPathp = smb_ParseASCIIBlock(tp, &tp);
- if (smb_StoreAnsiFilenames)
- OemToChar(newPathp,newPathp);
+ 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),
+ osi_LogSaveClientString(smb_logp, newPathp));
+
+ if (!cm_IsValidClientString(newPathp)) {
+#ifdef DEBUG
+ clientchar_t * hexp;
- osi_Log2(smb_logp, "smb rename [%s] to [%s]",
- osi_LogSaveString(smb_logp, oldPathp),
- osi_LogSaveString(smb_logp, newPathp));
+ hexp = cm_GetRawCharsAlloc(newPathp, -1);
+ osi_Log1(smb_logp, "CoreRename rejecting invalid name. [%S]",
+ osi_LogSaveClientString(smb_logp, hexp));
+ if (hexp)
+ free(hexp);
+#else
+ osi_Log0(smb_logp, "CoreRename rejecting invalid name");
+#endif
+ return CM_ERROR_BADNTFILENAME;
+ }
code = smb_Rename(vcp,inp,oldPathp,newPathp,0);
cm_scache_t *dscp;
cm_user_t *userp;
cm_req_t *reqp;
- char *maskp; /* pointer to the star pattern */
+ normchar_t *maskp; /* pointer to the star pattern */
int flags;
int any;
cm_dirEntryList_t * matches;
long code = 0;
smb_rmdirRock_t *rockp;
int match;
- char shortName[13];
- char *matchName;
+ normchar_t matchName[MAX_PATH];
rockp = (smb_rmdirRock_t *) vrockp;
- matchName = dep->name;
+ if (cm_FsStringToNormString(dep->name, -1, matchName, lengthof(matchName)) == 0) {
+ osi_Log1(smb_logp, "Skipping entry [%s]. Can't normalize FS string",
+ osi_LogSaveString(smb_logp, dep->name));
+ return 0;
+ }
+
if (rockp->flags & SMB_MASKFLAG_CASEFOLD)
- match = (cm_stricmp(matchName, rockp->maskp) == 0);
+ match = (cm_ClientStrCmpI(matchName, rockp->maskp) == 0);
else
- match = (strcmp(matchName, rockp->maskp) == 0);
+ match = (cm_ClientStrCmp(matchName, rockp->maskp) == 0);
if (!match &&
(rockp->flags & SMB_MASKFLAG_TILDE) &&
- !cm_Is8Dot3(dep->name)) {
- cm_Gen8Dot3Name(dep, shortName, NULL);
- matchName = shortName;
- match = (cm_stricmp(matchName, rockp->maskp) == 0);
+ !cm_Is8Dot3(matchName)) {
+ cm_Gen8Dot3Name(dep, matchName, NULL);
+ match = (cm_ClientStrCmpI(matchName, rockp->maskp) == 0);
}
if (match) {
- rockp->any = 1;
+ rockp->any = 1;
cm_DirEntryListAdd(dep->name, &rockp->matches);
}
return 0;
}
+
long smb_ReceiveCoreRemoveDir(smb_vc_t *vcp, smb_packet_t *inp, smb_packet_t *outp)
{
long code = 0;
- char *pathp;
- char *tp;
+ clientchar_t *pathp;
+ unsigned char *tp;
cm_space_t *spacep;
cm_scache_t *dscp;
- char *lastNamep;
+ clientchar_t *lastNamep;
smb_rmdirRock_t rock;
cm_user_t *userp;
osi_hyper_t thyper;
int caseFold;
- char *tidPathp;
+ clientchar_t *tidPathp;
cm_req_t req;
- cm_InitReq(&req);
+ smb_InitReq(&req);
+ memset(&rock, 0, sizeof(rock));
tp = smb_GetSMBData(inp, NULL);
- pathp = smb_ParseASCIIBlock(tp, &tp);
- if (smb_StoreAnsiFilenames)
- OemToChar(pathp,pathp);
+ pathp = smb_ParseASCIIBlock(inp, tp, &tp, SMB_STRF_ANSIPATH);
+ if (!pathp)
+ return CM_ERROR_BADSMB;
spacep = inp->spacep;
- smb_StripLastComponent(spacep->data, &lastNamep, pathp);
+ smb_StripLastComponent(spacep->wdata, &lastNamep, pathp);
userp = smb_GetUserFromVCP(vcp, inp);
cm_ReleaseUser(userp);
return CM_ERROR_NOSUCHPATH;
}
- code = cm_NameI(cm_data.rootSCachep, spacep->data, caseFold | CM_FLAG_FOLLOW,
+ code = cm_NameI(cm_data.rootSCachep, spacep->wdata, caseFold | CM_FLAG_FOLLOW,
userp, tidPathp, &req, &dscp);
if (code) {
#ifdef DFS_SUPPORT
if (dscp->fileType == CM_SCACHETYPE_DFSLINK) {
- int pnc = cm_VolStatus_Notify_DFS_Mapping(dscp, tidPathp, spacep->data);
+ int pnc = cm_VolStatus_Notify_DFS_Mapping(dscp, tidPathp, spacep->wdata);
cm_ReleaseSCache(dscp);
cm_ReleaseUser(userp);
if ( WANTS_DFS_PATHNAMES(inp) || pnc )
return CM_ERROR_PATH_NOT_COVERED;
else
- return CM_ERROR_BADSHARENAME;
+ return CM_ERROR_NOSUCHPATH;
}
#endif /* DFS_SUPPORT */
lastNamep++;
rock.any = 0;
- rock.maskp = lastNamep;
- rock.flags = ((strchr(rock.maskp, '~') != NULL) ? SMB_MASKFLAG_TILDE : 0);
+ rock.maskp = cm_ClientStringToNormStringAlloc(lastNamep, -1, NULL);
+ if (!rock.maskp) {
+ code = CM_ERROR_NOSUCHFILE;
+ goto done;
+ }
+ rock.flags = ((cm_ClientStrChr(rock.maskp, '~') != NULL) ? SMB_MASKFLAG_TILDE : 0);
thyper.LowPart = 0;
thyper.HighPart = 0;
cm_dirEntryList_t * entry;
for (entry = rock.matches; code == 0 && entry; entry = entry->nextp) {
+ clientchar_t clientName[MAX_PATH];
+
+ /* We assume this will succeed because smb_RmdirProc()
+ successfully converted entry->name once above. */
+ cm_FsStringToClientString(entry->name, -1, clientName, lengthof(clientName));
+
osi_Log1(smb_logp, "Removing directory %s",
osi_LogSaveString(smb_logp, entry->name));
- code = cm_RemoveDir(dscp, entry->name, userp, &req);
+ code = cm_RemoveDir(dscp, entry->name, clientName, userp, &req);
if (code == 0 && (dscp->flags & CM_SCACHEFLAG_ANYWATCH))
smb_NotifyChange(FILE_ACTION_REMOVED,
FILE_NOTIFY_CHANGE_DIR_NAME | FILE_NOTIFY_CHANGE_CREATION,
- dscp, entry->name, NULL, TRUE);
+ dscp, clientName, NULL, TRUE);
}
}
+ done:
+ if (rock.matches)
cm_DirEntryListFree(&rock.matches);
+ if (userp)
cm_ReleaseUser(userp);
+ if (dscp)
cm_ReleaseSCache(dscp);
if (code == 0 && !rock.any)
code = CM_ERROR_NOSUCHFILE;
+
+ if (rock.maskp)
+ free(rock.maskp);
+
return code;
}
+/* SMB_COM_FLUSH */
long smb_ReceiveCoreFlush(smb_vc_t *vcp, smb_packet_t *inp, smb_packet_t *outp)
{
unsigned short fid;
long code = 0;
cm_req_t req;
- cm_InitReq(&req);
+ smb_InitReq(&req);
fid = smb_GetSMBParm(inp, 0);
fid = smb_ChainFID(fid, inp);
fidp = smb_FindFID(vcp, fid, 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;
+ if (!fidp) {
+ osi_Log2(smb_logp, "smb_ReceiveCoreFlush Unknown SMB Fid vcp 0x%p fid %d",
+ vcp, fid);
+ return CM_ERROR_BADFD;
}
+ 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->flags & SMB_FID_OPENWRITE) {
- cm_scache_t * scp = fidp->scp;
- cm_HoldSCache(scp);
- lock_ReleaseMutex(&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);
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;
}
struct smb_FullNameRock {
- char *name;
- cm_scache_t *vnode;
- char *fullName;
+ clientchar_t *name;
+ cm_scache_t *vnode;
+ clientchar_t *fullName;
+ fschar_t *originalName;
};
int smb_FullNameProc(cm_scache_t *scp, cm_dirEntry_t *dep, void *rockp,
osi_hyper_t *offp)
{
- char shortName[13];
+ normchar_t matchName[MAX_PATH];
struct smb_FullNameRock *vrockp;
vrockp = (struct smb_FullNameRock *)rockp;
- if (!cm_Is8Dot3(dep->name)) {
+ if (cm_FsStringToNormString(dep->name, -1, matchName, lengthof(matchName)) == 0) {
+ osi_Log1(smb_logp, "Skipping entry [%s]. Can't normalize FS string",
+ osi_LogSaveString(smb_logp, dep->name));
+ return 0;
+ }
+
+ if (!cm_Is8Dot3(matchName)) {
+ clientchar_t shortName[13];
+
cm_Gen8Dot3Name(dep, shortName, NULL);
- if (cm_stricmp(shortName, vrockp->name) == 0) {
- vrockp->fullName = strdup(dep->name);
+ if (cm_ClientStrCmpIA(shortName, vrockp->name) == 0) {
+ vrockp->fullName = cm_ClientStrDup(matchName);
+ vrockp->originalName = cm_FsStrDup(dep->name);
return CM_ERROR_STOPNOW;
}
}
- if (cm_stricmp(dep->name, vrockp->name) == 0 &&
+ if (cm_ClientStrCmpI(matchName, vrockp->name) == 0 &&
ntohl(dep->fid.vnode) == vrockp->vnode->fid.vnode &&
ntohl(dep->fid.unique) == vrockp->vnode->fid.unique) {
- vrockp->fullName = strdup(dep->name);
+ vrockp->fullName = cm_ClientStrDup(matchName);
+ vrockp->originalName = cm_FsStrDup(dep->name);
return CM_ERROR_STOPNOW;
}
return 0;
}
-void smb_FullName(cm_scache_t *dscp, cm_scache_t *scp, char *pathp,
- char **newPathp, cm_user_t *userp, cm_req_t *reqp)
+void smb_FullName(cm_scache_t *dscp, cm_scache_t *scp, clientchar_t *pathp,
+ clientchar_t **newPathp, fschar_t ** originalPathp,
+ cm_user_t *userp, cm_req_t *reqp)
{
struct smb_FullNameRock rock;
long code = 0;
+ memset(&rock, 0, sizeof(rock));
rock.name = pathp;
rock.vnode = scp;
code = cm_ApplyDir(dscp, smb_FullNameProc, &rock, NULL, userp, reqp, NULL);
- if (code == CM_ERROR_STOPNOW)
+ if (code == CM_ERROR_STOPNOW) {
*newPathp = rock.fullName;
- else
- *newPathp = strdup(pathp);
+ *originalPathp = rock.originalName;
+ } else {
+ *newPathp = cm_ClientStrDup(pathp);
+ *originalPathp = cm_ClientStringToFsStringAlloc(pathp, -1, NULL);
+ }
}
long smb_CloseFID(smb_vc_t *vcp, smb_fid_t *fidp, cm_user_t *userp,
long code = 0;
cm_req_t req;
cm_scache_t *dscp = NULL;
- char *pathp = NULL;
+ clientchar_t *pathp = NULL;
cm_scache_t * scp = NULL;
cm_scache_t *delscp = NULL;
- int deleted = 0;
int nullcreator = 0;
osi_Log4(smb_logp, "smb_CloseFID Closing fidp 0x%x (fid=%d scp=0x%x vcp=0x%x)",
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_ReleaseMutex(&fidp->mx);
}
- cm_InitReq(&req);
+ smb_InitReq(&req);
lock_ObtainWrite(&smb_rctLock);
- if (fidp->delete) {
- osi_Log0(smb_logp, " Fid already closed.");
- lock_ReleaseWrite(&smb_rctLock);
- return CM_ERROR_BADFD;
+ if (fidp->deleteOk) {
+ osi_Log0(smb_logp, " Fid already closed.");
+ lock_ReleaseWrite(&smb_rctLock);
+ return CM_ERROR_BADFD;
}
- fidp->delete = 1;
+ 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 = strdup(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 */
(fidp->flags & (SMB_FID_OPENWRITE | SMB_FID_DELONCLOSE))
== SMB_FID_OPENWRITE) {
if (dosTime != 0 && dosTime != -1) {
+ lock_ObtainWrite(&fidp->scp->rw);
scp->mask |= CM_SCACHEMASK_CLIENTMODTIME;
/* This fixes defect 10958 */
CompensateForSmbClientLastWriteTimeBugs(&dosTime);
- smb_UnixTimeFromDosUTime(&fidp->scp->clientModTime, dosTime);
+ smb_UnixTimeFromDosUTime(&scp->clientModTime, dosTime);
+ lock_ReleaseWrite(&fidp->scp->rw);
+ }
+ if (smb_AsyncStore != 2) {
+ lock_ReleaseMutex(&fidp->mx);
+ code = cm_FSync(scp, userp, &req);
+ lock_ObtainMutex(&fidp->mx);
}
- lock_ReleaseMutex(&fidp->mx);
- code = cm_FSync(scp, userp, &req);
- lock_ObtainMutex(&fidp->mx);
}
else
code = 0;
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_ObtainMutex(&scp->mx);
+ lock_ObtainWrite(&scp->rw);
tcode = cm_SyncOp(scp, NULL, userp, &req, 0,
CM_SCACHESYNC_NEEDCALLBACK
post_syncopdone:
- lock_ReleaseMutex(&scp->mx);
+ lock_ReleaseWrite(&scp->rw);
lock_ObtainMutex(&fidp->mx);
}
if (fidp->flags & SMB_FID_DELONCLOSE) {
- char *fullPathp;
+ clientchar_t *fullPathp = NULL;
+ fschar_t *originalNamep = NULL;
lock_ReleaseMutex(&fidp->mx);
cm_HoldSCache(scp);
delscp = scp;
}
- smb_FullName(dscp, delscp, pathp, &fullPathp, userp, &req);
+ smb_FullName(dscp, delscp, pathp, &fullPathp, &originalNamep, userp, &req);
if (delscp->fileType == CM_SCACHETYPE_DIRECTORY) {
- code = cm_RemoveDir(dscp, fullPathp, userp, &req);
+ code = cm_RemoveDir(dscp, originalNamep, fullPathp, userp, &req);
if (code == 0) {
- deleted = 1;
if (dscp->flags & CM_SCACHEFLAG_ANYWATCH)
smb_NotifyChange(FILE_ACTION_REMOVED,
FILE_NOTIFY_CHANGE_DIR_NAME | FILE_NOTIFY_CHANGE_CREATION,
dscp, fullPathp, NULL, TRUE);
}
} else {
- code = cm_Unlink(dscp, fullPathp, userp, &req);
+ code = cm_Unlink(dscp, originalNamep, fullPathp, userp, &req);
if (code == 0) {
- deleted = 1;
if (dscp->flags & CM_SCACHEFLAG_ANYWATCH)
smb_NotifyChange(FILE_ACTION_REMOVED,
FILE_NOTIFY_CHANGE_FILE_NAME | FILE_NOTIFY_CHANGE_CREATION,
dscp, fullPathp, NULL, TRUE);
}
}
- free(fullPathp);
+
+ if (fullPathp)
+ free(fullPathp);
+ if (originalNamep)
+ free(originalNamep);
+
lock_ObtainMutex(&fidp->mx);
fidp->flags &= ~SMB_FID_DELONCLOSE;
}
cm_ReleaseSCache(dscp);
if (delscp) {
- if (deleted) {
- lock_ObtainMutex(&delscp->mx);
- if (deleted)
- delscp->flags |= CM_SCACHEFLAG_DELETED;
- lock_ReleaseMutex(&delscp->mx);
- }
cm_ReleaseSCache(delscp);
}
if (scp) {
- lock_ObtainMutex(&scp->mx);
+ lock_ObtainWrite(&scp->rw);
if (nullcreator && scp->creator == userp)
scp->creator = NULL;
- scp->flags &= ~CM_SCACHEFLAG_SMB_FID;
- lock_ReleaseMutex(&scp->mx);
- cm_ReleaseSCache(scp);
+ scp->flags &= ~CM_SCACHEFLAG_SMB_FID;
+ lock_ReleaseWrite(&scp->rw);
+ cm_ReleaseSCache(scp);
}
if (pathp)
- free(pathp);
+ free(pathp);
return code;
}
+/* SMB_COM_CLOSE */
long smb_ReceiveCoreClose(smb_vc_t *vcp, smb_packet_t *inp, smb_packet_t *outp)
{
unsigned short fid;
fid = smb_ChainFID(fid, inp);
fidp = smb_FindFID(vcp, fid, 0);
if (!fidp) {
+ osi_Log2(smb_logp, "smb_ReceiveCoreClose Unknown SMB Fid vcp 0x%p fid %d",
+ vcp, fid);
return CM_ERROR_BADFD;
}
/*
* smb_ReadData -- common code for Read, Read And X, and Raw Read
*/
-long smb_ReadData(smb_fid_t *fidp, osi_hyper_t *offsetp, long count, char *op,
+long smb_ReadData(smb_fid_t *fidp, osi_hyper_t *offsetp, afs_uint32 count, char *op,
cm_user_t *userp, long *readp)
{
osi_hyper_t offset;
osi_hyper_t thyper;
osi_hyper_t lastByte;
osi_hyper_t bufferOffset;
- long bufIndex, nbytes;
+ long bufIndex;
+ afs_uint32 nbytes;
int chunk;
int sequential = (fidp->flags & SMB_FID_SEQUENTIAL);
cm_req_t req;
- cm_InitReq(&req);
+ osi_Log3(smb_logp, "smb_ReadData fid %d, off 0x%x, size 0x%x",
+ fidp->fid, offsetp->LowPart, count);
+
+ *readp = 0;
+
+ lock_ObtainMutex(&fidp->mx);
+ /* make sure we have a readable FD */
+ if (!(fidp->flags & SMB_FID_OPENREAD_LISTDIR)) {
+ osi_Log2(smb_logp, "smb_ReadData fid %d not OPENREAD_LISTDIR flags 0x%x",
+ fidp->fid, fidp->flags);
+ lock_ReleaseMutex(&fidp->mx);
+ code = CM_ERROR_BADFDOP;
+ goto done2;
+ }
+
+ if (!fidp->scp) {
+ lock_ReleaseMutex(&fidp->mx);
+ code = CM_ERROR_BADFD;
+ goto done2;
+ }
+
+ smb_InitReq(&req);
bufferp = NULL;
offset = *offsetp;
- lock_ObtainMutex(&fidp->mx);
scp = fidp->scp;
cm_HoldSCache(scp);
- lock_ObtainMutex(&scp->mx);
+ lock_ObtainWrite(&scp->rw);
if (offset.HighPart == 0) {
chunk = offset.LowPart >> cm_logChunkSize;
buf_Release(bufferp);
bufferp = NULL;
}
- lock_ReleaseMutex(&scp->mx);
+ lock_ReleaseWrite(&scp->rw);
- code = buf_Get(scp, &thyper, &bufferp);
+ code = buf_Get(scp, &thyper, &req, &bufferp);
- lock_ObtainMutex(&scp->mx);
+ lock_ObtainWrite(&scp->rw);
if (code) goto done;
bufferOffset = thyper;
} /* while 1 */
done:
- lock_ReleaseMutex(&scp->mx);
+ lock_ReleaseWrite(&scp->rw);
if (bufferp)
buf_Release(bufferp);
cm_ReleaseSCache(scp);
+ done2:
+ osi_Log3(smb_logp, "smb_ReadData fid %d returns 0x%x read %d bytes",
+ fidp->fid, code, *readp);
return code;
}
/*
* smb_WriteData -- common code for Write and Raw Write
*/
-long smb_WriteData(smb_fid_t *fidp, osi_hyper_t *offsetp, long count, char *op,
+long smb_WriteData(smb_fid_t *fidp, osi_hyper_t *offsetp, afs_uint32 count, char *op,
cm_user_t *userp, long *writtenp)
{
osi_hyper_t offset = *offsetp;
long code = 0;
long written = 0;
- cm_scache_t *scp;
+ cm_scache_t *scp = NULL;
osi_hyper_t fileLength; /* file's length at start of write */
osi_hyper_t minLength; /* don't read past this */
afs_uint32 nbytes; /* # of bytes to transfer this iteration */
osi_hyper_t bufferOffset;
afs_uint32 bufIndex; /* index in buffer where our data is */
int doWriteBack = 0;
- osi_hyper_t writeBackOffset;/* offset of region to write back when
- * I/O is done */
+ osi_hyper_t writeBackOffset;/* offset of region to write back when I/O is done */
DWORD filter = 0;
cm_req_t req;
+ int needSyncOpDone = 0;
osi_Log3(smb_logp, "smb_WriteData fid %d, off 0x%x, size 0x%x",
fidp->fid, offsetp->LowPart, count);
*writtenp = 0;
- cm_InitReq(&req);
-
lock_ObtainMutex(&fidp->mx);
/* make sure we have a writable FD */
if (!(fidp->flags & SMB_FID_OPENWRITE)) {
fidp->fid, fidp->flags);
lock_ReleaseMutex(&fidp->mx);
code = CM_ERROR_BADFDOP;
- goto done;
+ goto done2;
}
+ smb_InitReq(&req);
+
scp = fidp->scp;
cm_HoldSCache(scp);
lock_ReleaseMutex(&fidp->mx);
- lock_ObtainMutex(&scp->mx);
+ lock_ObtainWrite(&scp->rw);
/* start by looking up the file's end */
code = cm_SyncOp(scp, NULL, userp, &req, 0,
CM_SCACHESYNC_NEEDCALLBACK
* based upon cm_chunkSize but we desire cm_chunkSize to be large
* so that we can read larger amounts of data at a time.
*/
- if ((thyper.LowPart & ~(cm_data.buf_blockSize-1)) !=
- (offset.LowPart & ~(cm_data.buf_blockSize-1))) {
+ if (smb_AsyncStore == 1 &&
+ (thyper.LowPart & ~(smb_AsyncStoreSize-1)) !=
+ (offset.LowPart & ~(smb_AsyncStoreSize-1))) {
/* they're different */
doWriteBack = 1;
writeBackOffset.HighPart = offset.HighPart;
- writeBackOffset.LowPart = offset.LowPart & ~(cm_data.buf_blockSize-1);
+ writeBackOffset.LowPart = offset.LowPart & ~(smb_AsyncStoreSize-1);
}
-
+
*writtenp = count;
/* now, copy the data one buffer at a time, until we've filled the
* request packet */
- while (1) {
- /* if we've copied all the data requested, we're done */
- if (count <= 0)
- break;
+ while (count != 0) {
/* handle over quota or out of space */
if (scp->flags & (CM_SCACHEFLAG_OVERQUOTA | CM_SCACHEFLAG_OUTOFSPACE)) {
if (!bufferp || !LargeIntegerEqualTo(thyper, bufferOffset)) {
/* wrong buffer */
if (bufferp) {
+ if (needSyncOpDone) {
+ cm_SyncOpDone(scp, bufferp,
+ CM_SCACHESYNC_NEEDCALLBACK
+ | CM_SCACHESYNC_WRITE
+ | CM_SCACHESYNC_BUFLOCKED);
+ needSyncOpDone = 0;
+ }
lock_ReleaseMutex(&bufferp->mx);
buf_Release(bufferp);
bufferp = NULL;
}
- lock_ReleaseMutex(&scp->mx);
+ lock_ReleaseWrite(&scp->rw);
- code = buf_Get(scp, &thyper, &bufferp);
+ code = buf_Get(scp, &thyper, &req, &bufferp);
lock_ObtainMutex(&bufferp->mx);
- lock_ObtainMutex(&scp->mx);
+ lock_ObtainWrite(&scp->rw);
if (code) goto done;
bufferOffset = thyper;
/* now get the data in the cache */
- while (1) {
- code = cm_SyncOp(scp, bufferp, userp, &req, 0,
- CM_SCACHESYNC_NEEDCALLBACK
- | CM_SCACHESYNC_WRITE
- | CM_SCACHESYNC_BUFLOCKED);
- if (code)
- goto done;
-
- cm_SyncOpDone(scp, bufferp,
- CM_SCACHESYNC_NEEDCALLBACK
- | CM_SCACHESYNC_WRITE
- | CM_SCACHESYNC_BUFLOCKED);
+ while (code == 0) {
+ if (!needSyncOpDone) {
+ code = cm_SyncOp(scp, bufferp, userp, &req, 0,
+ CM_SCACHESYNC_NEEDCALLBACK
+ | CM_SCACHESYNC_WRITE
+ | CM_SCACHESYNC_BUFLOCKED);
+ if (code)
+ goto done;
+
+ needSyncOpDone = 1;
+ }
/* If we're overwriting the entire buffer, or
* if we're writing at or past EOF, mark the
* Use minLength instead of scp->length, since
* the latter has already been updated by this
* call.
+ *
+ * The scp lock has been dropped multiple times
+ * so the minLength must be refreshed before it
+ * is used.
*/
+
+ minLength = scp->length;
+ if (LargeIntegerGreaterThan(minLength, scp->serverLength))
+ minLength = scp->serverLength;
+
if (LargeIntegerGreaterThanOrEqualTo(bufferp->offset, minLength)
|| LargeIntegerEqualTo(offset, bufferp->offset)
&& (count >= cm_data.buf_blockSize
ConvertLongToLargeInteger(count)),
minLength))) {
if (count < cm_data.buf_blockSize
- && bufferp->dataVersion == -1)
+ && bufferp->dataVersion == CM_BUF_VERSION_BAD)
memset(bufferp->datap, 0,
cm_data.buf_blockSize);
bufferp->dataVersion = scp->dataVersion;
if (cm_HaveBuffer(scp, bufferp, 1)) break;
/* otherwise, load the buffer and try again */
+ cm_SyncOpDone(scp, bufferp,
+ CM_SCACHESYNC_NEEDCALLBACK
+ | CM_SCACHESYNC_WRITE
+ | CM_SCACHESYNC_BUFLOCKED);
+ needSyncOpDone = 0;
+
lock_ReleaseMutex(&bufferp->mx);
code = cm_GetBuffer(scp, bufferp, NULL, userp,
&req);
- lock_ReleaseMutex(&scp->mx);
+ lock_ReleaseWrite(&scp->rw);
lock_ObtainMutex(&bufferp->mx);
- lock_ObtainMutex(&scp->mx);
- if (code) break;
+ lock_ObtainWrite(&scp->rw);
}
- if (code) {
- lock_ReleaseMutex(&bufferp->mx);
- buf_Release(bufferp);
- bufferp = NULL;
+ if (code)
goto done;
- }
} /* if (wrong buffer) ... */
/* now we have the right buffer loaded. Copy out the
/* now copy the data */
memcpy(bufferp->datap + bufIndex, op, nbytes);
- buf_SetDirty(bufferp, bufIndex, nbytes);
-
- /* and record the last writer */
- if (bufferp->userp != userp) {
- cm_HoldUser(userp);
- if (bufferp->userp)
- cm_ReleaseUser(bufferp->userp);
- bufferp->userp = userp;
- }
+ buf_SetDirty(bufferp, bufIndex, nbytes, userp);
/* adjust counters, pointers, etc. */
op += nbytes;
count -= nbytes;
written += nbytes;
- thyper.LowPart = nbytes;
- thyper.HighPart = 0;
- offset = LargeIntegerAdd(thyper, offset);
- } /* while 1 */
+ offset = LargeIntegerAdd(offset, ConvertLongToLargeInteger(nbytes));
+ } /* while count != 0 */
done:
- lock_ReleaseMutex(&scp->mx);
+ if (bufferp && needSyncOpDone) {
+ cm_SyncOpDone(scp, bufferp,
+ CM_SCACHESYNC_NEEDCALLBACK
+ | CM_SCACHESYNC_WRITE
+ | CM_SCACHESYNC_BUFLOCKED);
+ }
+
+ lock_ReleaseWrite(&scp->rw);
if (bufferp) {
lock_ReleaseMutex(&bufferp->mx);
lock_ObtainMutex(&fidp->mx);
if (code == 0 && filter != 0 && (fidp->flags & SMB_FID_NTOPEN)
- && (fidp->NTopen_dscp->flags & CM_SCACHEFLAG_ANYWATCH)) {
+ && (fidp->NTopen_dscp->flags & CM_SCACHEFLAG_ANYWATCH))
+ {
+ lock_ReleaseMutex(&fidp->mx);
smb_NotifyChange(FILE_ACTION_MODIFIED, filter,
fidp->NTopen_dscp, fidp->NTopen_pathp,
NULL, TRUE);
- }
- lock_ReleaseMutex(&fidp->mx);
-
- if (code == 0 && doWriteBack) {
- long code2;
+ } else {
+ lock_ReleaseMutex(&fidp->mx);
+ }
- lock_ObtainMutex(&scp->mx);
- osi_Log1(smb_logp, "smb_WriteData fid %d calling cm_SyncOp ASYNCSTORE",
- fidp->fid);
- code2 = cm_SyncOp(scp, NULL, userp, &req, 0, CM_SCACHESYNC_ASYNCSTORE);
- osi_Log2(smb_logp, "smb_WriteData fid %d calling cm_SyncOp ASYNCSTORE returns 0x%x",
- fidp->fid, code2);
- lock_ReleaseMutex(&scp->mx);
- cm_QueueBKGRequest(scp, cm_BkgStore, writeBackOffset.LowPart,
- writeBackOffset.HighPart,
- *writtenp & ~(cm_data.blockSize-1), 0, userp);
- /* cm_SyncOpDone is called at the completion of cm_BkgStore */
+ if (code == 0) {
+ if (smb_AsyncStore > 0) {
+ if (doWriteBack) {
+ long code2;
+
+ lock_ObtainWrite(&scp->rw);
+ osi_Log1(smb_logp, "smb_WriteData fid %d calling cm_SyncOp ASYNCSTORE",
+ fidp->fid);
+ code2 = cm_SyncOp(scp, NULL, userp, &req, 0, CM_SCACHESYNC_ASYNCSTORE);
+ osi_Log2(smb_logp, "smb_WriteData fid %d calling cm_SyncOp ASYNCSTORE returns 0x%x",
+ fidp->fid, code2);
+ lock_ReleaseWrite(&scp->rw);
+ cm_QueueBKGRequest(scp, cm_BkgStore, writeBackOffset.LowPart,
+ writeBackOffset.HighPart,
+ smb_AsyncStoreSize, 0, userp);
+ /* cm_SyncOpDone is called at the completion of cm_BkgStore */
+ }
+ } else {
+ cm_BufWrite(scp, offsetp, *writtenp, 0, userp, &req);
+ }
}
cm_ReleaseSCache(scp);
+ done2:
osi_Log3(smb_logp, "smb_WriteData fid %d returns 0x%x written %d bytes",
fidp->fid, code, *writtenp);
return code;
}
+/* SMB_COM_WRITE */
long smb_ReceiveCoreWrite(smb_vc_t *vcp, smb_packet_t *inp, smb_packet_t *outp)
{
unsigned short fd;
long written = 0, total_written = 0;
unsigned pid;
smb_fid_t *fidp;
+ 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;
fd = smb_ChainFID(fd, inp);
fidp = smb_FindFID(vcp, fd, 0);
if (!fidp) {
- osi_Log0(smb_logp, "smb_ReceiveCoreWrite fid not found");
+ osi_Log2(smb_logp, "smb_ReceiveCoreWrite Unknown SMB Fid vcp 0x%p fid %d",
+ vcp, fd);
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);
LARGE_INTEGER LOffset;
LARGE_INTEGER LLength;
- pid = ((smb_t *) inp)->pid;
+ pid = smbp->pid;
key = cm_GenerateKey(vcp->vcID, pid, fd);
LOffset.HighPart = offset.HighPart;
LLength.HighPart = 0;
LLength.LowPart = count;
- lock_ObtainMutex(&fidp->scp->mx);
- code = cm_LockCheckWrite(fidp->scp, LOffset, LLength, key);
- lock_ReleaseMutex(&fidp->scp->mx);
+ 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);
osi_Log1(smb_logp, "smb_ReceiveCoreWrite truncation to length 0x%x", offset.LowPart);
- cm_InitReq(&req);
+ smb_InitReq(&req);
truncAttr.mask = CM_ATTRMASK_LENGTH;
truncAttr.length.LowPart = offset.LowPart;
*/
lock_ObtainMutex(&fidp->mx);
if ((fidp->flags & SMB_FID_MTIMESETDONE) != SMB_FID_MTIMESETDONE) {
+ lock_ObtainWrite(&fidp->scp->rw);
fidp->scp->mask |= CM_SCACHEMASK_CLIENTMODTIME;
fidp->scp->clientModTime = time(NULL);
+ lock_ReleaseWrite(&fidp->scp->rw);
}
lock_ReleaseMutex(&fidp->mx);
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);
return 0;
}
+/* SMB_COM_WRITE_RAW */
long smb_ReceiveCoreWriteRaw(smb_vc_t *vcp, smb_packet_t *inp, smb_packet_t *outp, raw_write_cont_t *rwcp)
{
osi_hyper_t offset;
long totalCount;
unsigned short fd;
smb_fid_t *fidp;
+ 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) {
+ osi_Log2(smb_logp, "smb_ReceiveCoreWriteRaw Unknown SMB Fid vcp 0x%p fid %d",
+ vcp, fd);
+ 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;
LARGE_INTEGER LOffset;
LARGE_INTEGER LLength;
- pid = ((smb_t *) inp)->pid;
+ pid = smbp->pid;
key = cm_GenerateKey(vcp->vcID, pid, fd);
LOffset.HighPart = offset.HighPart;
LLength.HighPart = 0;
LLength.LowPart = count;
- lock_ObtainMutex(&fidp->scp->mx);
- code = cm_LockCheckWrite(fidp->scp, LOffset, LLength, key);
- lock_ReleaseMutex(&fidp->scp->mx);
+ 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;
}
*/
lock_ObtainMutex(&fidp->mx);
if ((fidp->flags & SMB_FID_LOOKSLIKECOPY) != SMB_FID_LOOKSLIKECOPY) {
+ lock_ObtainWrite(&fidp->scp->rw);
fidp->scp->mask |= CM_SCACHEMASK_CLIENTMODTIME;
fidp->scp->clientModTime = time(NULL);
+ lock_ReleaseWrite(&fidp->scp->rw);
}
lock_ReleaseMutex(&fidp->mx);
smb_ReleaseFID(fidp);
cm_ReleaseUser(userp);
+ cm_ReleaseSCache(scp);
if (code) {
smb_SetSMBParm(outp, 0, total_written);
return 0;
}
+/* SMB_COM_READ */
long smb_ReceiveCoreRead(smb_vc_t *vcp, smb_packet_t *inp, smb_packet_t *outp)
{
osi_hyper_t offset;
unsigned short fd;
unsigned pid;
smb_fid_t *fidp;
+ smb_t *smbp = (smb_t*) inp;
long code = 0;
cm_user_t *userp;
+ cm_scache_t *scp;
char *op;
fd = smb_GetSMBParm(inp, 0);
fd = smb_ChainFID(fd, inp);
fidp = smb_FindFID(vcp, fd, 0);
- if (!fidp)
+ if (!fidp) {
+ osi_Log2(smb_logp, "smb_ReceiveCoreRead Unknown SMB Fid vcp 0x%p fid %d",
+ vcp, fd);
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);
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);
{
LARGE_INTEGER LOffset, LLength;
cm_key_t key;
- pid = ((smb_t *) inp)->pid;
+ pid = smbp->pid;
key = cm_GenerateKey(vcp->vcID, pid, fd);
LOffset.HighPart = 0;
LLength.HighPart = 0;
LLength.LowPart = count;
- lock_ObtainMutex(&fidp->scp->mx);
- code = cm_LockCheckRead(fidp->scp, LOffset, LLength, key);
- lock_ReleaseMutex(&fidp->scp->mx);
+ 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;
}
+/* SMB_COM_CREATE_DIRECTORY */
long smb_ReceiveCoreMakeDir(smb_vc_t *vcp, smb_packet_t *inp, smb_packet_t *outp)
{
- char *pathp;
+ clientchar_t *pathp;
long code = 0;
cm_space_t *spacep;
- char *tp;
+ unsigned char *tp;
cm_user_t *userp;
cm_scache_t *dscp; /* dir we're dealing with */
cm_scache_t *scp; /* file we're creating */
cm_attr_t setAttr;
int initialModeBits;
- char *lastNamep;
+ clientchar_t *lastNamep;
int caseFold;
- char *tidPathp;
+ clientchar_t *tidPathp;
cm_req_t req;
- cm_InitReq(&req);
+ smb_InitReq(&req);
scp = NULL;
initialModeBits = 0777;
tp = smb_GetSMBData(inp, NULL);
- pathp = smb_ParseASCIIBlock(tp, &tp);
- if (smb_StoreAnsiFilenames)
- OemToChar(pathp,pathp);
-
- if (strcmp(pathp, "\\") == 0)
- return CM_ERROR_EXISTS;
+ pathp = smb_ParseASCIIBlock(inp, tp, &tp, SMB_STRF_ANSIPATH);
+ if (!pathp)
+ return CM_ERROR_BADSMB;
spacep = inp->spacep;
- smb_StripLastComponent(spacep->data, &lastNamep, pathp);
+ smb_StripLastComponent(spacep->wdata, &lastNamep, pathp);
+
+ if (cm_ClientStrCmp(pathp, _C("\\")) == 0)
+ return CM_ERROR_EXISTS;
userp = smb_GetUserFromVCP(vcp, inp);
return CM_ERROR_NOSUCHPATH;
}
- code = cm_NameI(cm_data.rootSCachep, spacep->data,
+ code = cm_NameI(cm_data.rootSCachep, spacep->wdata,
caseFold | CM_FLAG_FOLLOW | CM_FLAG_CHECKPATH,
userp, tidPathp, &req, &dscp);
#ifdef DFS_SUPPORT
if (dscp->fileType == CM_SCACHETYPE_DFSLINK) {
- int pnc = cm_VolStatus_Notify_DFS_Mapping(dscp, tidPathp, spacep->data);
+ int pnc = cm_VolStatus_Notify_DFS_Mapping(dscp, tidPathp, spacep->wdata);
cm_ReleaseSCache(dscp);
cm_ReleaseUser(userp);
if ( WANTS_DFS_PATHNAMES(inp) || pnc )
return CM_ERROR_PATH_NOT_COVERED;
else
- return CM_ERROR_BADSHARENAME;
+ return CM_ERROR_NOSUCHPATH;
}
#endif /* DFS_SUPPORT */
setAttr.mask = CM_ATTRMASK_CLIENTMODTIME;
setAttr.clientModTime = time(NULL);
- code = cm_MakeDir(dscp, lastNamep, 0, &setAttr, userp, &req);
+ smb_SetInitialModeBitsForDir(0, &setAttr);
+
+ code = cm_MakeDir(dscp, lastNamep, 0, &setAttr, userp, &req, NULL);
if (code == 0 && (dscp->flags & CM_SCACHEFLAG_ANYWATCH))
smb_NotifyChange(FILE_ACTION_ADDED,
FILE_NOTIFY_CHANGE_DIR_NAME,
return 0;
}
-BOOL smb_IsLegalFilename(char *filename)
+BOOL smb_IsLegalFilename(clientchar_t *filename)
{
/*
* Find the longest substring of filename that does not contain
* than the length of the whole string, then one or more of the
* illegal chars is in filename.
*/
- if (strcspn(filename, illegalChars) < strlen(filename))
+ if (cm_ClientStrCSpn(filename, illegalChars) < cm_ClientStrLen(filename))
return FALSE;
return TRUE;
-}
+}
+/* SMB_COM_CREATE and SMB_COM_CREATE_NEW */
long smb_ReceiveCoreCreate(smb_vc_t *vcp, smb_packet_t *inp, smb_packet_t *outp)
{
- char *pathp;
+ clientchar_t *pathp;
long code = 0;
cm_space_t *spacep;
- char *tp;
+ unsigned char *tp;
int excl;
cm_user_t *userp;
cm_scache_t *dscp; /* dir we're dealing with */
cm_scache_t *scp; /* file we're creating */
cm_attr_t setAttr;
- int initialModeBits;
smb_fid_t *fidp;
int attributes;
- char *lastNamep;
+ clientchar_t *lastNamep;
int caseFold;
afs_uint32 dosTime;
- char *tidPathp;
+ clientchar_t *tidPathp;
cm_req_t req;
int created = 0; /* the file was new */
- cm_InitReq(&req);
+ smb_InitReq(&req);
scp = NULL;
excl = (inp->inCom == 0x03)? 0 : 1;
attributes = smb_GetSMBParm(inp, 0);
dosTime = smb_GetSMBParm(inp, 1) | (smb_GetSMBParm(inp, 2) << 16);
- /* compute initial mode bits based on read-only flag in attributes */
- initialModeBits = 0666;
- if (attributes & SMB_ATTR_READONLY)
- initialModeBits &= ~0222;
-
tp = smb_GetSMBData(inp, NULL);
- pathp = smb_ParseASCIIBlock(tp, &tp);
- if (smb_StoreAnsiFilenames)
- OemToChar(pathp,pathp);
+ pathp = smb_ParseASCIIBlock(inp, tp, &tp, SMB_STRF_ANSIPATH);
+ if (!pathp)
+ return CM_ERROR_BADSMB;
spacep = inp->spacep;
- smb_StripLastComponent(spacep->data, &lastNamep, pathp);
+ /* smb_StripLastComponent will strip "::$DATA" if present */
+ smb_StripLastComponent(spacep->wdata, &lastNamep, pathp);
+
+ if (!cm_IsValidClientString(pathp)) {
+#ifdef DEBUG
+ clientchar_t * hexp;
+
+ hexp = cm_GetRawCharsAlloc(pathp, -1);
+ osi_Log1(smb_logp, "CoreCreate rejecting invalid name. [%S]",
+ osi_LogSaveClientString(smb_logp, hexp));
+ if (hexp)
+ free(hexp);
+#else
+ osi_Log0(smb_logp, "CoreCreate rejecting invalid name");
+#endif
+ return CM_ERROR_BADNTFILENAME;
+ }
userp = smb_GetUserFromVCP(vcp, inp);
cm_ReleaseUser(userp);
return CM_ERROR_NOSUCHPATH;
}
- code = cm_NameI(cm_data.rootSCachep, spacep->data, caseFold | CM_FLAG_FOLLOW,
+ code = cm_NameI(cm_data.rootSCachep, spacep->wdata, caseFold | CM_FLAG_FOLLOW,
userp, tidPathp, &req, &dscp);
if (code) {
#ifdef DFS_SUPPORT
if (dscp->fileType == CM_SCACHETYPE_DFSLINK) {
- int pnc = cm_VolStatus_Notify_DFS_Mapping(dscp, tidPathp, spacep->data);
+ int pnc = cm_VolStatus_Notify_DFS_Mapping(dscp, tidPathp, spacep->wdata);
cm_ReleaseSCache(dscp);
cm_ReleaseUser(userp);
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 (!smb_IsLegalFilename(lastNamep))
return CM_ERROR_BADNTFILENAME;
- osi_Log1(smb_logp, "SMB receive create [%s]", osi_LogSaveString( smb_logp, pathp ));
+ osi_Log1(smb_logp, "SMB receive create [%S]", osi_LogSaveClientString( smb_logp, pathp ));
#ifdef DEBUG_VERBOSE
{
char *hexp;
else {
setAttr.mask = CM_ATTRMASK_CLIENTMODTIME;
smb_UnixTimeFromDosUTime(&setAttr.clientModTime, dosTime);
+ smb_SetInitialModeBitsForFile(attributes, &setAttr);
+
code = cm_Create(dscp, lastNamep, 0, &setAttr, &scp, userp,
&req);
if (code == 0) {
/* save a pointer to the vnode */
fidp->scp = scp;
- lock_ObtainMutex(&scp->mx);
+ lock_ObtainWrite(&scp->rw);
scp->flags |= CM_SCACHEFLAG_SMB_FID;
- lock_ReleaseMutex(&scp->mx);
+ lock_ReleaseWrite(&scp->rw);
/* and the user */
fidp->userp = userp;
return 0;
}
+/* SMB_COM_SEEK */
long smb_ReceiveCoreSeek(smb_vc_t *vcp, smb_packet_t *inp, smb_packet_t *outp)
{
long code = 0;
cm_user_t *userp;
cm_req_t req;
- cm_InitReq(&req);
+ smb_InitReq(&req);
fd = smb_GetSMBParm(inp, 0);
whence = smb_GetSMBParm(inp, 1);
/* try to find the file descriptor */
fd = smb_ChainFID(fd, inp);
fidp = smb_FindFID(vcp, fd, 0);
- if (!fidp)
+ if (!fidp) {
+ osi_Log2(smb_logp, "smb_ReceiveCoreSeek Unknown SMB Fid vcp 0x%p fid %d",
+ vcp, fd);
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);
scp = fidp->scp;
cm_HoldSCache(scp);
lock_ReleaseMutex(&fidp->mx);
- lock_ObtainMutex(&scp->mx);
+ lock_ObtainWrite(&scp->rw);
code = cm_SyncOp(scp, NULL, userp, &req, 0,
CM_SCACHESYNC_NEEDCALLBACK | CM_SCACHESYNC_GETSTATUS);
if (code == 0) {
smb_SetSMBParm(outp, 1, (new_offset.LowPart>>16) & 0xffff);
smb_SetSMBDataLength(outp, 0);
}
- lock_ReleaseMutex(&scp->mx);
+ lock_ReleaseWrite(&scp->rw);
smb_ReleaseFID(fidp);
cm_ReleaseSCache(scp);
cm_ReleaseUser(userp);
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) {
+ smb_user_t *uidp;
+ smb_fid_t *fidp;
+ clientchar_t *treepath = NULL; /* do not free */
+ clientchar_t *pathname = NULL;
+ cm_fid_t afid = {0,0,0,0,0};
+
+ uidp = smb_FindUID(vcp, smbp->uid, 0);
+ smb_LookupTIDPath(vcp, smbp->tid, &treepath);
+ fidp = smb_FindFID(vcp, inp->fid, 0);
+
+ 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 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)
+ smb_ReleaseFID(fidp);
+ }
if (oldGen != sessionGen) {
LogEvent(EVENTLOG_WARNING_TYPE, MSG_BAD_SMB_WRONG_SESSION,
osi_Log3(smb_logp, "Request %s straddled session startup, "
"took %d ms, ncb length %d", opName, newTime - oldTime, ncbp->ncb_length);
}
- }
- else {
+
+ FreeSMBStrings(inp);
+ } else {
/* bad opcode, fail the request, after displaying it */
osi_Log1(smb_logp, "Received bad SMB req 0x%X", inp->inCom);
#ifdef LOG_PACKET
idx_session = code - WAIT_OBJECT_0;
- /* check idx range! */
- if (idx_session < 0 || idx_session > (sizeof(SessionEvents) / sizeof(SessionEvents[0])))
- {
- /* this is fatal - log as much as possible */
- osi_Log1(smb_logp, "Fatal: session idx [ %d ] out of range.\n", idx_session);
- osi_assertx(0, "invalid index");
- }
+ /* check idx range! */
+ if (idx_session < 0 || idx_session > (sizeof(SessionEvents) / sizeof(SessionEvents[0])))
+ {
+ /* this is fatal - log as much as possible */
+ osi_Log1(smb_logp, "Fatal: session idx [ %d ] out of range.\n", idx_session);
+ osi_assertx(0, "invalid index");
+ }
+
+ /* Get an NCB */
+ NCBretry:
+ code = thrd_WaitForMultipleObjects_Event(numNCBs, NCBavails,
+ FALSE, INFINITE);
+ if (code == WAIT_OBJECT_0) {
+ if (smbShutdownFlag == 1)
+ break;
+ else
+ goto NCBretry;
+ }
+
+ /* error checking */
+ if (code >= WAIT_ABANDONED_0 && code < (WAIT_ABANDONED_0 + numNCBs))
+ {
+ int abandonIdx = code - WAIT_ABANDONED_0;
+ osi_Log2(smb_logp, "Error: smb_ClientWaiter (NCBavails) event %d abandoned, errno %d\n", abandonIdx, GetLastError());
+ }
+
+ if (code == WAIT_IO_COMPLETION)
+ {
+ osi_Log0(smb_logp, "Error: smb_ClientWaiter (NCBavails) WAIT_IO_COMPLETION\n");
+ continue;
+ }
+
+ if (code == WAIT_TIMEOUT)
+ {
+ osi_Log1(smb_logp, "Error: smb_ClientWaiter (NCBavails) WAIT_TIMEOUT, errno %d\n", GetLastError());
+ }
+
+ if (code == WAIT_FAILED)
+ {
+ osi_Log1(smb_logp, "Error: smb_ClientWaiter (NCBavails) WAIT_FAILED, errno %d\n", GetLastError());
+ }
+
+ idx_NCB = code - WAIT_OBJECT_0;
+
+ /* check idx range! */
+ if (idx_NCB < 0 || idx_NCB > (sizeof(NCBsessions) / sizeof(NCBsessions[0])))
+ {
+ /* this is fatal - log as much as possible */
+ osi_Log1(smb_logp, "Fatal: idx_NCB [ %d ] out of range.\n", idx_NCB);
+ osi_assertx(0, "invalid index");
+ }
+
+ /* Link them together */
+ NCBsessions[idx_NCB] = idx_session;
+
+ /* Fire it up */
+ ncbp = NCBs[idx_NCB];
+ ncbp->ncb_lsn = (unsigned char) LSNs[idx_session];
+ ncbp->ncb_command = NCBRECV | ASYNCH;
+ ncbp->ncb_lana_num = lanas[idx_session];
+ ncbp->ncb_buffer = (unsigned char *) bufs[idx_NCB];
+ ncbp->ncb_event = NCBevents[idx_NCB];
+ ncbp->ncb_length = SMB_PACKETSIZE;
+ Netbios(ncbp);
+ }
+}
+
+typedef struct _monitored_task {
+ osi_queue_t q;
+ INT_PTR task_id;
+ LARGE_INTEGER start_time;
+ BOOL started;
+ BOOL trace_timer_hit;
+ BOOL dump_timer_hit;
+} monitored_task;
+
+typedef struct osi_queueHT {
+ osi_queue_t * headp;
+ osi_queue_t * tailp;
+} osi_queueHT_t;
+
+static osi_queue_t *smb_monitored_tasks = NULL;
+static osi_queue_t *smb_free_monitored_tasks = NULL;
+
+static osi_mutex_t _monitor_mx;
+
+static HANDLE h_monitored_task_queue = NULL;
+static HANDLE h_monitored_task_shutdown = NULL;
+
+static time_t smb_last_dump_time = 0;
+
+DWORD smb_monitorReqs = 0;
+
+/* FILETIME comparison fuzz */
+#define MONITOR_FUZZ_TIMEOUT (1 * 10000000i64)
+
+/* Trace timeout is at 60 seconds */
+#define MONITOR_TRACE_TIMEOUT (60 * 10000000i64)
+
+/* Dump timeout is at 120 seconds */
+#define MONITOR_DUMP_TIMEOUT (120 * 10000000i64)
+
+/* Time before another dump is performed in seconds*/
+#define MONITOR_DUMP_RESET_TIMEOUT (600)
+
+static void smb_PurgeOldTaskMonitors(osi_queueHT_t * taskmq)
+{
+ FILETIME now;
+ LARGE_INTEGER earliest;
+ monitored_task * t;
+
+ GetSystemTimeAsFileTime(&now);
+ earliest.LowPart = now.dwLowDateTime;
+ earliest.HighPart = now.dwHighDateTime;
+ earliest.QuadPart -= MONITOR_FUZZ_TIMEOUT + MONITOR_DUMP_TIMEOUT;
+
+ while ((t = (monitored_task *) taskmq->headp) != NULL &&
+
+ (t->start_time.QuadPart < earliest.QuadPart ||
+
+ t->dump_timer_hit)) {
+
+ osi_QRemoveHT(&taskmq->headp,
+ &taskmq->tailp,
+ &t->q);
+
+ lock_ObtainMutex(&_monitor_mx);
+ osi_QAdd(&smb_free_monitored_tasks, &t->q);
+ lock_ReleaseMutex(&_monitor_mx);
+ }
+
+#ifdef INVARIANT_CHECK
+ {
+ LARGE_INTEGER last;
+
+ last.QuadPart = 0;
+
+ for (t = (monitored_task *) taskmq->headp;
+ t;
+ t = (monitored_task *) osi_QNext(&t->q)) {
+ osi_assert(last.QuadPart <= t->start_time.QuadPart);
+ last.QuadPart = t->start_time.QuadPart;
+ }
+ }
+#endif
+}
+
+static void smb_SlurpNewTaskMonitors(osi_queueHT_t * taskmq)
+{
+ monitored_task * task;
+ monitored_task * tasks;
+
+ lock_ObtainMutex(&_monitor_mx);
+ tasks = (monitored_task *) smb_monitored_tasks;
+ smb_monitored_tasks = NULL;
+ lock_ReleaseMutex(&_monitor_mx);
+
+ while (tasks) {
+
+ task = tasks;
+ osi_QRemove((osi_queue_t **) &tasks, &task->q);
+
+ if (task->started) {
+
+ osi_queue_t q;
+ osi_queue_t *p;
+
+ q.nextp = NULL;
+ q.prevp = taskmq->tailp;
+
+ /* Insertion sort by start_time. Earliest request is
+ first. Since we are likely to receive new requests
+ later, we start inserting from the back. */
+ for (p = &q;
+ osi_QPrev(p) &&
+ ((monitored_task *) osi_QPrev(p))->start_time.QuadPart > task->start_time.QuadPart;
+ p = osi_QPrev(p));
+
+ if (p == &q)
+ osi_QAddT(&taskmq->headp, &taskmq->tailp, &task->q);
+ else if (p->prevp == NULL)
+ osi_QAddH(&taskmq->headp, &taskmq->tailp, &task->q);
+ else {
+ osi_queue_t *o = p->prevp;
+
+ osi_assert(o->nextp == p);
+
+ task->q.nextp = p;
+ task->q.prevp = o;
+ p->prevp = &task->q;
+ o->nextp = &task->q;
+ }
+
+ } else {
+ /* Some task ending */
+
+ osi_queue_t * p;
+
+ for (p = taskmq->headp;
+ p != NULL;
+ p = osi_QNext(p)) {
+
+ monitored_task * mt = (monitored_task *) p;
+
+ if (mt->task_id == task->task_id) {
+
+ osi_QRemoveHT(&taskmq->headp,
+ &taskmq->tailp, p);
+
+ lock_ObtainMutex(&_monitor_mx);
+ osi_QAdd(&smb_free_monitored_tasks, p);
+ lock_ReleaseMutex(&_monitor_mx);
+
+ break;
+ }
+ }
+
+ lock_ObtainMutex(&_monitor_mx);
+ osi_QAdd(&smb_free_monitored_tasks, &task->q);
+ lock_ReleaseMutex(&_monitor_mx);
+ }
+ }
+
+#ifdef INVARIANT_CHECK
+ {
+ LARGE_INTEGER last;
+ monitored_task * t;
+
+ last.QuadPart = 0;
+
+ for (t = (monitored_task *) taskmq->headp;
+ t;
+ t = (monitored_task *) osi_QNext(&t->q)) {
+ osi_assert(last.QuadPart <= t->start_time.QuadPart);
+ last.QuadPart = t->start_time.QuadPart;
+ }
+ }
+#endif
+}
+
+static void smb_HandleTaskMonitorEvent(monitored_task * task)
+{
+ if (!task->trace_timer_hit) {
+
+ task->trace_timer_hit = TRUE;
+
+ osi_LogEnable(afsd_logp);
+ rx_DebugOnOff(TRUE);
+
+ } else if (!task->dump_timer_hit) {
+ time_t now;
+
+ time(&now);
+
+ if (smb_last_dump_time + MONITOR_DUMP_RESET_TIMEOUT < now) {
+ task->dump_timer_hit = TRUE;
+ smb_last_dump_time = now;
+
+ GenerateMiniDump(NULL);
+ }
+ }
+}
+
+/**
+ * Server request monitoring
+ *
+ * The server monitor runs in a separate thread and monitors server
+ * requests for potential timeouts. It examines notifcations queued
+ * by smb_NotifyRequestEvent() and waits for potential timeout events:
+ *
+ * - After MONITOR_TRACE_TIMEOUT threshold elapses, the monitor
+ * enables trace logging.
+ *
+ * - After MONITOR_DUMP_TIMEOUT threshold elapses, the monitor writes
+ * out a dump file that will hopefully contain enough evidence to
+ * figure out why the timeout event occurred.
+ *
+ */
+void smb_ServerMonitor(VOID * parmp)
+{
+ osi_queueHT_t in_progress = { NULL, NULL };
+ HANDLE h_timer = NULL;
+
+ HANDLE h_all[3];
+
+ h_monitored_task_queue = CreateEvent(NULL, FALSE, FALSE, "Local\\OpenAFSTaskMonitor");
+ h_monitored_task_shutdown = CreateEvent(NULL, FALSE, FALSE, "Local\\OpenAFSTaskMonitorShutdown");
+ h_timer = CreateWaitableTimer(NULL, FALSE, "Local\\OpenAFSTaskMonitorTimer");
+
+ lock_InitializeMutex(&_monitor_mx, "Request monitor lock", LOCK_HIERARCHY_SMB_MONITOR);
+
+ h_all[0] = h_monitored_task_queue;
+ h_all[1] = h_timer;
+ h_all[2] = h_monitored_task_shutdown;
+
+ while(1) {
+ DWORD rv;
+
+ rv = WaitForMultipleObjects(3, h_all, FALSE, INFINITE);
+
+ if (rv == WAIT_OBJECT_0) {
+
+ smb_SlurpNewTaskMonitors(&in_progress);
+
+ } else if (rv == WAIT_OBJECT_0 + 1) {
+
+ smb_HandleTaskMonitorEvent((monitored_task *) in_progress.headp);
+
+ } else {
+
+ break;
- /* Get an NCB */
- NCBretry:
- code = thrd_WaitForMultipleObjects_Event(numNCBs, NCBavails,
- FALSE, INFINITE);
- if (code == WAIT_OBJECT_0) {
- if (smbShutdownFlag == 1)
- break;
- else
- goto NCBretry;
}
- /* error checking */
- if (code >= WAIT_ABANDONED_0 && code < (WAIT_ABANDONED_0 + numNCBs))
- {
- int abandonIdx = code - WAIT_ABANDONED_0;
- osi_Log2(smb_logp, "Error: smb_ClientWaiter (NCBavails) event %d abandoned, errno %d\n", abandonIdx, GetLastError());
- }
-
- if (code == WAIT_IO_COMPLETION)
+ /* refresh timers */
{
- osi_Log0(smb_logp, "Error: smb_ClientWaiter (NCBavails) WAIT_IO_COMPLETION\n");
- continue;
+ monitored_task * t;
+
+ smb_PurgeOldTaskMonitors(&in_progress);
+ t = (monitored_task *) in_progress.headp;
+
+ if (t && !t->trace_timer_hit) {
+ LARGE_INTEGER due;
+
+ due = t->start_time;
+ due.QuadPart += MONITOR_TRACE_TIMEOUT;
+
+ SetWaitableTimer(h_timer, &due, 0, NULL, NULL, FALSE);
+ } else if (t && !t->dump_timer_hit) {
+
+ LARGE_INTEGER due;
+
+ due = t->start_time;
+ due.QuadPart += MONITOR_DUMP_TIMEOUT;
+
+ SetWaitableTimer(h_timer, &due, 0, NULL, NULL, FALSE);
+ } else {
+ CancelWaitableTimer(h_timer);
+
+ /* CancelWaitableTimer() doesn't reset the timer if it
+ was already signalled. */
+ WaitForSingleObject(h_timer, 0);
+ }
}
-
- if (code == WAIT_TIMEOUT)
- {
- osi_Log1(smb_logp, "Error: smb_ClientWaiter (NCBavails) WAIT_TIMEOUT, errno %d\n", GetLastError());
+ }
+
+ {
+ HANDLE h;
+
+ h = h_monitored_task_queue;
+ h_monitored_task_queue = NULL;
+ CloseHandle(h);
+
+ h = h_monitored_task_shutdown;
+ h_monitored_task_shutdown = NULL;
+ CloseHandle(h);
+
+ CloseHandle(h_timer);
+
+ lock_FinalizeMutex(&_monitor_mx);
+ }
+
+ {
+ monitored_task * task;
+
+ while (in_progress.headp) {
+ task = (monitored_task *) in_progress.headp;
+ osi_QRemoveHT(&in_progress.headp, &in_progress.tailp, &task->q);
+ free(task);
}
-
- if (code == WAIT_FAILED)
- {
- osi_Log1(smb_logp, "Error: smb_ClientWaiter (NCBavails) WAIT_FAILED, errno %d\n", GetLastError());
+
+ for (task = (monitored_task *) smb_free_monitored_tasks;
+ task; task = (monitored_task *) smb_free_monitored_tasks) {
+ osi_QRemove(&smb_free_monitored_tasks, &task->q);
+ free(task);
}
-
- idx_NCB = code - WAIT_OBJECT_0;
- /* check idx range! */
- if (idx_NCB < 0 || idx_NCB > (sizeof(NCBsessions) / sizeof(NCBsessions[0])))
- {
- /* this is fatal - log as much as possible */
- osi_Log1(smb_logp, "Fatal: idx_NCB [ %d ] out of range.\n", idx_NCB);
- osi_assertx(0, "invalid index");
+ for (task = (monitored_task *) smb_monitored_tasks;
+ task; task = (monitored_task *) smb_monitored_tasks) {
+ osi_QRemove(&smb_monitored_tasks, &task->q);
+ free(task);
}
+ }
+}
- /* Link them together */
- NCBsessions[idx_NCB] = idx_session;
+void smb_NotifyRequestEvent(INT_PTR task_id, BOOL started)
+{
+ monitored_task * task;
- /* Fire it up */
- ncbp = NCBs[idx_NCB];
- ncbp->ncb_lsn = (unsigned char) LSNs[idx_session];
- ncbp->ncb_command = NCBRECV | ASYNCH;
- ncbp->ncb_lana_num = lanas[idx_session];
- ncbp->ncb_buffer = (unsigned char *) bufs[idx_NCB];
- ncbp->ncb_event = NCBevents[idx_NCB];
- ncbp->ncb_length = SMB_PACKETSIZE;
- Netbios(ncbp);
+ lock_ObtainMutex(&_monitor_mx);
+ task = (monitored_task *) smb_free_monitored_tasks;
+ if (task)
+ osi_QRemove(&smb_free_monitored_tasks, &task->q);
+ lock_ReleaseMutex(&_monitor_mx);
+
+ if (task == NULL)
+ task = malloc(sizeof(monitored_task));
+ memset(task, 0, sizeof(*task));
+
+ task->task_id = task_id;
+ task->started = started;
+
+ {
+ FILETIME now;
+
+ GetSystemTimeAsFileTime(&now);
+ task->start_time.HighPart = now.dwHighDateTime;
+ task->start_time.LowPart = now.dwLowDateTime;
}
+
+ lock_ObtainMutex(&_monitor_mx);
+ osi_QAdd(&smb_monitored_tasks, &task->q);
+ lock_ReleaseMutex(&_monitor_mx);
+
+ SetEvent(h_monitored_task_queue);
+}
+
+void smb_ShutdownMonitor()
+{
+ SetEvent(h_monitored_task_shutdown);
}
/*
UCHAR rc;
smb_vc_t *vcp = NULL;
smb_t *smbp;
+ extern void rx_StartClientThread(void);
rx_StartClientThread();
- outncbp = GetNCB();
- outbufp = GetPacket();
+ outncbp = smb_GetNCB();
+ outbufp = smb_GetPacket();
outbufp->ncbp = outncbp;
while (1) {
vcp = NULL;
}
- smb_ResetServerPriority();
+ cm_ResetServerPriority();
code = thrd_WaitForMultipleObjects_Event(numNCBs, NCBreturns[myIdx],
FALSE, INFINITE);
lock_ObtainWrite(&smb_globalLock);
dead_sessions[vcp->session] = TRUE;
lock_ReleaseWrite(&smb_globalLock);
- smb_CleanupDeadVC(vcp);
- smb_ReleaseVC(vcp);
- vcp = NULL;
} else {
lock_ReleaseMutex(&vcp->mx);
}
+ smb_CleanupDeadVC(vcp);
+ smb_ReleaseVC(vcp);
+ vcp = NULL;
}
goto doneWithNCB;
default:
/* A weird error code. Log it, sleep, and continue. */
vcp = smb_FindVC(ncbp->ncb_lsn, 0, lanas[idx_session]);
- if (vcp)
+ if (vcp) {
lock_ObtainMutex(&vcp->mx);
- if (vcp && vcp->errorCount++ > 3) {
- osi_Log2(smb_logp, "session [ %d ] closed, vcp->errorCount = %d", idx_session, vcp->errorCount);
- if (!(vcp->flags & SMB_VCFLAG_ALREADYDEAD)) {
- osi_Log2(smb_logp, "marking dead vcp 0x%x, user struct 0x%x",
- vcp, vcp->usersp);
- vcp->flags |= SMB_VCFLAG_ALREADYDEAD;
- lock_ReleaseMutex(&vcp->mx);
- lock_ObtainWrite(&smb_globalLock);
- dead_sessions[vcp->session] = TRUE;
- lock_ReleaseWrite(&smb_globalLock);
- smb_CleanupDeadVC(vcp);
- smb_ReleaseVC(vcp);
- vcp = NULL;
- } else {
- lock_ReleaseMutex(&vcp->mx);
- }
- goto doneWithNCB;
- }
- else {
- if (vcp)
+ if (vcp->errorCount++ > 3) {
+ osi_Log2(smb_logp, "session [ %d ] closed, vcp->errorCount = %d", idx_session, vcp->errorCount);
+ if (!(vcp->flags & SMB_VCFLAG_ALREADYDEAD)) {
+ osi_Log2(smb_logp, "marking dead vcp 0x%x, user struct 0x%x",
+ vcp, vcp->usersp);
+ vcp->flags |= SMB_VCFLAG_ALREADYDEAD;
+ lock_ReleaseMutex(&vcp->mx);
+ lock_ObtainWrite(&smb_globalLock);
+ dead_sessions[vcp->session] = TRUE;
+ lock_ReleaseWrite(&smb_globalLock);
+ } else {
+ lock_ReleaseMutex(&vcp->mx);
+ }
+ smb_CleanupDeadVC(vcp);
+ smb_ReleaseVC(vcp);
+ vcp = NULL;
+ goto doneWithNCB;
+ }
+ else {
lock_ReleaseMutex(&vcp->mx);
- thrd_Sleep(1000);
- thrd_SetEvent(SessionEvents[idx_session]);
+ smb_ReleaseVC(vcp);
+ vcp = NULL;
+ Sleep(10);
+ thrd_SetEvent(SessionEvents[idx_session]);
+ }
}
continue;
}
continue;
}
- smb_SetRequestStartTime();
+ cm_SetRequestStartTime();
+ if (smb_monitorReqs) {
+ smb_NotifyRequestEvent(GetCurrentThreadId(), TRUE);
+ }
vcp->errorCount = 0;
bufp = (struct smb_packet *) ncbp->ncb_buffer;
smbp = (smb_t *)bufp->data;
outbufp->flags = 0;
+#ifndef NOTRACE
__try
{
+#endif
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;
/* TODO: what else needs to be serialized? */
smb_DispatchPacket(vcp, bufp, outbufp, ncbp, NULL);
}
+#ifndef NOTRACE
}
__except( smb_ServerExceptionFilter() ) {
}
+#endif
+ if (smb_monitorReqs) {
+ smb_NotifyRequestEvent(GetCurrentThreadId(), FALSE);
+ }
smb_concurrentCalls--;
doneWithNCB:
}
if (vcp)
smb_ReleaseVC(vcp);
+ if (outbufp)
+ smb_FreePacket(outbufp);
+ if (outncbp)
+ smb_FreeNCB(outncbp);
}
/*
{
struct smb_packet *bufp;
EVENT_HANDLE retHandle;
- int i;
+ afs_uint32 i;
char eventName[MAX_PATH];
osi_assertx( idx < (sizeof(NCBs) / sizeof(NCBs[0])), "invalid index" );
- NCBs[idx] = GetNCB();
+ NCBs[idx] = smb_GetNCB();
sprintf(eventName,"NCBavails[%d]", idx);
NCBavails[idx] = thrd_CreateEvent(NULL, FALSE, TRUE, eventName);
if ( GetLastError() == ERROR_ALREADY_EXISTS )
osi_Log1(smb_logp, "Event Object Already Exists: %s", osi_LogSaveString(smb_logp, eventName));
for (i=0; i<smb_NumServerThreads; i++)
NCBreturns[i][idx] = retHandle;
- bufp = GetPacket();
+ bufp = smb_GetPacket();
bufp->spacep = cm_GetSpace();
bufs[idx] = bufp;
}
long code = 0;
long len;
long i;
- int session, thread;
+ afs_uint32 session, thread;
smb_vc_t *vcp = NULL;
int flags = 0;
char rname[NCBNAMSZ+1];
int cnamelen = MAX_COMPUTERNAME_LENGTH+1;
INT_PTR lana = (INT_PTR) parmp;
char eventName[MAX_PATH];
+ int bridgeCount = 0;
+ int nowildCount = 0;
- sprintf(eventName,"smb_Listener_lana_%d", (char)lana);
+ sprintf(eventName,"smb_Listener_lana_%d", (unsigned char)lana);
ListenerShutdown[lana] = thrd_CreateEvent(NULL, FALSE, FALSE, eventName);
if ( GetLastError() == ERROR_ALREADY_EXISTS )
thrd_ResetEvent(ListenerShutdown[lana]);
- ncbp = GetNCB();
+ ncbp = smb_GetNCB();
/* retrieve computer name */
GetComputerName(cname, &cnamelen);
if (code == NRC_NAMERR) {
/* An smb shutdown or Vista resume must have taken place */
- osi_Log2(smb_logp,
+ osi_Log1(smb_logp,
"NCBLISTEN lana=%d failed with NRC_NAMERR.",
- ncbp->ncb_lana_num, code);
+ ncbp->ncb_lana_num);
+ afsi_log("NCBLISTEN lana=%d failed with NRC_NAMERR.", ncbp->ncb_lana_num);
if (lock_TryMutex(&smb_StartedLock)) {
lana_list.lana[i] = LANA_INVALID;
} else if (code == NRC_BRIDGE || code != 0) {
int lanaRemaining = 0;
+ if (code == NRC_BRIDGE) {
+ if (++bridgeCount <= 5) {
+ afsi_log("NCBLISTEN lana=%d failed with NRC_BRIDGE, retrying ...", ncbp->ncb_lana_num);
+ continue;
+ }
+ } else if (code == NRC_NOWILD) {
+ if (++nowildCount <= 5) {
+ afsi_log("NCBLISTEN lana=%d failed with NRC_NOWILD, retrying ...", ncbp->ncb_lana_num);
+
+ if (bridgeCount > 0) {
+ memset(ncbp, 0, sizeof(*ncbp));
+ ncbp->ncb_command = NCBADDNAME;
+ ncbp->ncb_lana_num = (UCHAR)lana;
+ /* pad out with spaces instead of null termination */
+ len = (long)strlen(smb_localNamep);
+ strncpy(ncbp->ncb_name, smb_localNamep, NCBNAMSZ);
+ for (i=len; i<NCBNAMSZ; i++) ncbp->ncb_name[i] = ' ';
+ code = Netbios(ncbp);
+ }
+ continue;
+ }
+ }
+
while (!lock_TryMutex(&smb_StartedLock)) {
if (smb_ListenerState == SMB_LISTENER_STOPPED || smbShutdownFlag == 1)
goto exit_thread;
osi_Log2(smb_logp,
"NCBLISTEN lana=%d failed with %s. Listener thread exiting.",
ncbp->ncb_lana_num, ncb_error_string(code));
+ afsi_log("NCBLISTEN lana=%d failed with %s. Listener thread exiting.",
+ ncbp->ncb_lana_num, ncb_error_string(code));
for (i = 0; i < lana_list.length; i++) {
if (lana_list.lana[i] == lana) {
}
#endif /* 0 */
+ /* a successful packet received. clear bridge error count */
+ bridgeCount = 0;
+ nowildCount = 0;
+
/* check for remote conns */
/* first get remote name and insert null terminator */
memcpy(rname, ncbp->ncb_callname, NCBNAMSZ);
}
lock_ObtainMutex(&vcp->mx);
- strcpy(vcp->rname, rname);
+ cm_Utf8ToUtf16(rname, -1, vcp->rname, lengthof(vcp->rname));
vcp->flags |= flags;
lock_ReleaseMutex(&vcp->mx);
if (session >= SESSION_MAX - 1 || numNCBs >= NCB_MAX - 1) {
unsigned long code = CM_ERROR_ALLBUSY;
- smb_packet_t * outp = GetPacket();
+ smb_packet_t * outp = smb_GetPacket();
unsigned char *outWctp;
smb_t *smbp;
smbp->errHigh = (unsigned char) ((errCode >> 8) & 0xff);
smbp->rcls = errClass;
}
+
smb_SendPacket(vcp, outp);
smb_FreePacket(outp);
} /* dispatch while loop */
exit_thread:
- FreeNCB(ncbp);
+ smb_FreeNCB(ncbp);
thrd_SetEvent(ListenerShutdown[lana]);
return;
}
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)
{
/*
SUCCEEDED(lana_GetUncServerNameEx(NetbiosName, &lanaNum, &bGateway,
LANA_NETBIOS_NAME_FULL)) &&
lanaNum != LANA_INVALID && smb_LANadapter != lanaNum) {
- if ( isGateway != bGateway ||
- strcmp(cm_NetbiosName, NetbiosName) ) {
+ if ( isGateway != bGateway ) {
+ afsi_log("Lan Adapter Change detected (%d != %d): gateway %d != %d",
+ smb_LANadapter, lanaNum, isGateway, bGateway);
+ change = 1;
+ } else if (strcmp(cm_NetbiosName, NetbiosName) ) {
+ afsi_log("Lan Adapter Change detected (%d != %d): name %s != %s",
+ smb_LANadapter, lanaNum, cm_NetbiosName, NetbiosName);
change = 1;
} else {
- NCB *ncbp = GetNCB();
+ NCB *ncbp = smb_GetNCB();
ncbp->ncb_command = NCBENUM;
ncbp->ncb_buffer = (PUCHAR)&temp_list;
ncbp->ncb_length = sizeof(temp_list);
code = Netbios(ncbp);
if (code == 0) {
- if (temp_list.length != lana_list.length)
+ if (temp_list.length != lana_list.length) {
+ afsi_log("Lan Adapter Change detected (%d != %d): lan list length changed %d != %d",
+ smb_LANadapter, lanaNum, temp_list.length, lana_list.length);
change = 1;
- else {
+ } else {
for (i=0; i<lana_list.length; i++) {
if ( temp_list.lana[i] != lana_list.lana[i] ) {
+ afsi_log("Lan Adapter Change detected (%d != %d): lana[%d] %d != %d",
+ smb_LANadapter, lanaNum, i, temp_list.lana[i], lana_list.lana[i]);
change = 1;
break;
}
}
}
}
- FreeNCB(ncbp);
+ smb_FreeNCB(ncbp);
}
}
if (change) {
- afsi_log("Lan Adapter Change detected");
smb_StopListeners(1);
smb_RestartListeners(1);
}
return 0;
}
/* setup the NCB system */
- ncbp = GetNCB();
+ ncbp = smb_GetNCB();
/* Call lanahelper to get Netbios name, lan adapter number and gateway flag */
if (SUCCEEDED(code = lana_GetUncServerNameEx(cm_NetbiosName, &lanaNum, &isGateway, LANA_NETBIOS_NAME_FULL))) {
strcpy(smb_localNamep, cm_NetbiosName);
afsi_log("smb_localNamep is >%s<", smb_localNamep);
+ /* Also copy the value to the client character encoded string */
+ cm_Utf8ToClientString(cm_NetbiosName, -1, cm_NetbiosNameC, MAX_NB_NAME_LENGTH);
if (smb_LANadapter == LANA_INVALID) {
ncbp->ncb_command = NCBENUM;
}
/* we're done with the NCB now */
- FreeNCB(ncbp);
+ smb_FreeNCB(ncbp);
afsi_log("smb_NetbiosInit smb_LANadapter=%d",smb_LANadapter);
if (lana_list.length > 0)
}
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
memcpy(ncbp->ncb_name,smb_sharename,NCBNAMSZ);
code = Netbios(ncbp);
- afsi_log("Netbios NCBDELNAME lana=%d code=%d retcode=%d complete=%d",
+ afsi_log("StopListener: Netbios NCBDELNAME lana=%d code=%d retcode=%d complete=%d",
lana, code, ncbp->ncb_retcode, ncbp->ncb_cmd_cplt);
/* and then reset the LANA; this will cause the listener threads to exit */
if (code == 0)
code = ncbp->ncb_retcode;
if (code != 0) {
- afsi_log("Netbios NCBRESET lana %d error code %d", lana, code);
+ afsi_log("StopListener: Netbios NCBRESET lana %d error code %d", lana, code);
} else {
- afsi_log("Netbios NCBRESET lana %d succeeded", lana);
+ afsi_log("StopListener: Netbios NCBRESET lana %d succeeded", lana);
}
if (wait)
#endif
);
- ncbp = GetNCB();
+ ncbp = smb_GetNCB();
/* Unregister the SMB name */
for (l = 0; l < lana_list.length; l++) {
/* force a re-evaluation of the network adapters */
lana_list.length = 0;
smb_LANadapter = LANA_INVALID;
- FreeNCB(ncbp);
+ smb_FreeNCB(ncbp);
if (!locked)
lock_ReleaseMutex(&smb_StartedLock);
}
{
thread_t phandle;
int lpid;
- INT_PTR i;
+ UINT_PTR i;
struct tm myTime;
EVENT_HANDLE retHandle;
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();
smb_logp = logp;
/* and the global lock */
- lock_InitializeRWLock(&smb_globalLock, "smb global lock");
- lock_InitializeRWLock(&smb_rctLock, "smb refct and tree struct lock");
+ lock_InitializeRWLock(&smb_globalLock, "smb global lock", LOCK_HIERARCHY_SMB_GLOBAL);
+ lock_InitializeRWLock(&smb_rctLock, "smb refct and tree struct lock", LOCK_HIERARCHY_SMB_RCT_GLOBAL);
/* Raw I/O data structures */
- lock_InitializeMutex(&smb_RawBufLock, "smb raw buffer lock");
+ lock_InitializeMutex(&smb_RawBufLock, "smb raw buffer lock", LOCK_HIERARCHY_SMB_RAWBUF);
- lock_InitializeMutex(&smb_ListenerLock, "smb listener lock");
- lock_InitializeMutex(&smb_StartedLock, "smb started lock");
+ lock_InitializeMutex(&smb_ListenerLock, "smb listener lock", LOCK_HIERARCHY_SMB_LISTENER);
+ lock_InitializeMutex(&smb_StartedLock, "smb started lock", LOCK_HIERARCHY_SMB_STARTED);
/* 4 Raw I/O buffers */
smb_RawBufs = calloc(65536,1);
);
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 */
* It is actually the domain for local logins, and we are acting as
* a local SMB server.
*/
- bufsize = sizeof(smb_ServerDomainName) - 1;
- GetComputerName(smb_ServerDomainName, &bufsize);
+ bufsize = lengthof(smb_ServerDomainName) - 1;
+ GetComputerNameW(smb_ServerDomainName, &bufsize);
smb_ServerDomainNameLength = bufsize + 1; /* bufsize doesn't include terminator */
- afsi_log("Setting SMB server domain name to [%s]", smb_ServerDomainName);
+ afsi_log("Setting SMB server domain name to [%S]", smb_ServerDomainName);
}
/* Start listeners, waiters, servers, and daemons */
osi_assertx(phandle != NULL, "smb_WaitingLocksDaemon thread creation failure");
thrd_CloseHandle(phandle);
+ if (smb_monitorReqs) {
+ phandle = thrd_Create(NULL, 65536, (ThreadFunc) smb_ServerMonitor,
+ NULL, 0, &lpid, "smb_ServerMonitor");
+ osi_assertx(phandle != NULL, "smb_ServerMonitor thread creation failure");
+ thrd_CloseHandle(phandle);
+ }
+
lock_ReleaseMutex(&smb_StartedLock);
return;
}
{
NCB *ncbp;
long code = 0;
- int i;
+ afs_uint32 i;
smb_vc_t *vcp;
/*fprintf(stderr, "Entering smb_Shutdown\n");*/
/* setup the NCB system */
- ncbp = GetNCB();
+ ncbp = smb_GetNCB();
/* Block new sessions by setting shutdown flag */
smbShutdownFlag = 1;
/* Hang up all sessions */
- memset((char *)ncbp, 0, sizeof(NCB));
+ memset(ncbp, 0, sizeof(NCB));
for (i = 1; i < numSessions; i++)
{
if (dead_sessions[i])
}
/* Delete Netbios name */
- memset((char *)ncbp, 0, sizeof(NCB));
+ memset(ncbp, 0, sizeof(NCB));
for (i = 0; i < lana_list.length; i++) {
if (lana_list.lana[i] == LANA_INVALID) continue;
ncbp->ncb_command = NCBDELNAME;
if (code == 0)
code = ncbp->ncb_retcode;
if (code != 0) {
- fprintf(stderr, "Netbios NCBDELNAME lana %d error code %d",
+ fprintf(stderr, "Shutdown: Netbios NCBDELNAME lana %d error code %d",
ncbp->ncb_lana_num, code);
}
fflush(stderr);
if (fidp->scp != NULL) {
cm_scache_t * scp;
+ lock_ReleaseWrite(&smb_rctLock);
lock_ObtainMutex(&fidp->mx);
if (fidp->scp != NULL) {
scp = fidp->scp;
fidp->scp = NULL;
- lock_ObtainMutex(&scp->mx);
+ lock_ObtainWrite(&scp->rw);
scp->flags &= ~CM_SCACHEFLAG_SMB_FID;
- lock_ReleaseMutex(&scp->mx);
+ lock_ReleaseWrite(&scp->rw);
osi_Log2(smb_logp,"smb_Shutdown fidp 0x%p scp 0x%p", fidp, scp);
cm_ReleaseSCache(scp);
}
lock_ReleaseMutex(&fidp->mx);
+ lock_ObtainWrite(&smb_rctLock);
}
}
}
}
lock_ReleaseWrite(&smb_rctLock);
- FreeNCB(ncbp);
- TlsFree(smb_TlsRequestSlot);
+ smb_FreeNCB(ncbp);
+
+ if (smb_monitorReqs) {
+ smb_ShutdownMonitor();
+ }
}
/* Get the UNC \\<servername>\<sharename> prefix. */
char *smb_GetSharename()
{
char *name;
+ size_t len;
/* Make sure we have been properly initialized. */
if (smb_localNamep == NULL)
/* Allocate space for \\<servername>\<sharename>, plus the
* terminator.
*/
- name = malloc(strlen(smb_localNamep) + strlen("ALL") + 4);
- sprintf(name, "\\\\%s\\%s", smb_localNamep, "ALL");
+ len = (strlen(smb_localNamep) + strlen("ALL") + 4) * sizeof(char);
+ name = malloc(len);
+ snprintf(name, len, "\\\\%s\\%s", smb_localNamep, "ALL");
return name;
-}
+}
#ifdef LOG_PACKET
void smb_LogPacket(smb_packet_t *packet)
{
BYTE *vp, *cp;
+ smb_t * smbp;
unsigned length, paramlen, datalen, i, j;
char buf[81];
char hex[]={'0','1','2','3','4','5','6','7','8','9','a','b','c','d','e','f'};
osi_Log0(smb_logp, "*** SMB packet dump ***");
+ smbp = (smb_t *) packet->data;
vp = (BYTE *) packet->data;
- datalen = *((WORD*)(vp + (paramlen = ((unsigned)*(vp+20)) << 1)));
- length = paramlen + 2 + datalen;
-
+ paramlen = smbp->wct * 2;
+ datalen = *((WORD *) (smbp->vdata + paramlen));
+ length = sizeof(*smbp) + paramlen + 1 + datalen;
for (i=0;i < length; i+=16)
{
int smb_DumpVCP(FILE *outputFile, char *cookie, int lock)
{
int zilch;
- char output[1024];
+ char output[4196];
smb_vc_t *vcp;
-
+ smb_username_t *unp;
+ smb_waitingLockRequest_t *wlrp;
+
if (lock)
lock_ObtainRead(&smb_rctLock);
+ sprintf(output, "begin dumping smb_username_t\r\n");
+ WriteFile(outputFile, output, (DWORD)strlen(output), &zilch, NULL);
+ for (unp = usernamesp; unp; unp=unp->nextp)
+ {
+ cm_ucell_t *ucellp;
+
+ sprintf(output, "%s -- smb_unp=0x%p, refCount=%d, cm_userp=0x%p, flags=0x%x, logoff=%u, name=%S, machine=%S\r\n",
+ cookie, unp, unp->refCount, unp->userp, unp->flags, unp->last_logoff_t,
+ unp->name ? unp->name : _C("NULL"),
+ unp->machine ? unp->machine : _C("NULL"));
+ WriteFile(outputFile, output, (DWORD)strlen(output), &zilch, NULL);
+
+ sprintf(output, " begin dumping cm_ucell_t\r\n");
+ WriteFile(outputFile, output, (DWORD)strlen(output), &zilch, NULL);
+
+ for ( ucellp = unp->userp->cellInfop; ucellp; ucellp = ucellp->nextp ) {
+ sprintf(output, " %s -- ucellp=0x%p, cellp=0x%p, flags=0x%x, tktLen=%04u, kvno=%03u, expires=%I64u, gen=%d, name=%s, cellname=%s\r\n",
+ cookie, ucellp, ucellp->cellp, ucellp->flags, ucellp->ticketLen, ucellp->kvno,
+ ucellp->expirationTime, ucellp->gen,
+ ucellp->userName,
+ ucellp->cellp->name);
+ WriteFile(outputFile, output, (DWORD)strlen(output), &zilch, NULL);
+ }
+
+ sprintf(output, " done dumping cm_ucell_t\r\n");
+ WriteFile(outputFile, output, (DWORD)strlen(output), &zilch, NULL);
+
+ }
+ sprintf(output, "done dumping smb_username_t\r\n");
+ WriteFile(outputFile, output, (DWORD)strlen(output), &zilch, NULL);
+
+
+ sprintf(output, "begin dumping smb_waitingLockRequest_t\r\n");
+ WriteFile(outputFile, output, (DWORD)strlen(output), &zilch, NULL);
+
+
+ for ( wlrp = smb_allWaitingLocks; wlrp; wlrp = (smb_waitingLockRequest_t *) osi_QNext(&wlrp->q)) {
+ smb_waitingLock_t *lockp;
+
+ sprintf(output, "%s wlrp=0x%p vcp=0x%p, scp=0x%p, type=0x%x, start_t=0x%I64u msTimeout=0x%x\r\n",
+ cookie, wlrp, wlrp->vcp, wlrp->scp, wlrp->lockType, wlrp->start_t, wlrp->msTimeout);
+ WriteFile(outputFile, output, (DWORD)strlen(output), &zilch, NULL);
+
+ sprintf(output, " begin dumping smb_waitingLock_t\r\n");
+ WriteFile(outputFile, output, (DWORD)strlen(output), &zilch, NULL);
+ for (lockp = wlrp->locks; lockp; lockp = (smb_waitingLock_t *) osi_QNext(&lockp->q)) {
+ sprintf(output, " %s -- waitlockp=0x%p lockp=0x%p key=0x%I64x offset=0x%I64x length=0x%I64x state=0x%x\r\n",
+ cookie, lockp, lockp->lockp, lockp->key, lockp->LOffset.QuadPart, lockp->LLength.QuadPart, lockp->state);
+ WriteFile(outputFile, output, (DWORD)strlen(output), &zilch, NULL);
+ }
+ sprintf(output, " done dumping smb_waitingLock_t\r\n");
+ WriteFile(outputFile, output, (DWORD)strlen(output), &zilch, NULL);
+ }
+
+ sprintf(output, "done dumping smb_waitingLockRequest_t\r\n");
+ WriteFile(outputFile, output, (DWORD)strlen(output), &zilch, NULL);
+
sprintf(output, "begin dumping smb_vc_t\r\n");
WriteFile(outputFile, output, (DWORD)strlen(output), &zilch, NULL);
for (vcp = smb_allVCsp; vcp; vcp=vcp->nextp)
{
smb_fid_t *fidp;
+ smb_tid_t *tidp;
+ smb_user_t *userp;
- sprintf(output, "%s vcp=0x%p, refCount=%d, flags=%d, vcID=%d, lsn=%d, uidCounter=%d, tidCounter=%d, fidCounter=%d\r\n",
+ sprintf(output, "%s vcp=0x%p, refCount=%d, flags=0x%x, vcID=%d, lsn=%d, uidCounter=%d, tidCounter=%d, fidCounter=%d\r\n",
cookie, vcp, vcp->refCount, vcp->flags, vcp->vcID, vcp->lsn, vcp->uidCounter, vcp->tidCounter, vcp->fidCounter);
WriteFile(outputFile, output, (DWORD)strlen(output), &zilch, NULL);
- sprintf(output, "begin dumping smb_fid_t\r\n");
+ sprintf(output, " begin dumping smb_user_t\r\n");
+ WriteFile(outputFile, output, (DWORD)strlen(output), &zilch, NULL);
+ for (userp = vcp->usersp; userp; userp = userp->nextp) {
+ sprintf(output, " %s -- smb_userp=0x%p, refCount=%d, uid=%d, vcp=0x%p, unp=0x%p, flags=0x%x, delOk=%d\r\n",
+ cookie, userp, userp->refCount, userp->userID, userp->vcp, userp->unp, userp->flags, userp->deleteOk);
+ WriteFile(outputFile, output, (DWORD)strlen(output), &zilch, NULL);
+ }
+ sprintf(output, " done dumping smb_user_t\r\n");
+ WriteFile(outputFile, output, (DWORD)strlen(output), &zilch, NULL);
+
+ sprintf(output, " begin dumping smb_tid_t\r\n");
+ WriteFile(outputFile, output, (DWORD)strlen(output), &zilch, NULL);
+ for (tidp = vcp->tidsp; tidp; tidp = tidp->nextp) {
+ sprintf(output, " %s -- smb_tidp=0x%p, refCount=%d, tid=%d, vcp=0x%p, cm_userp=0x%p, flags=0x%x, delOk=%d, path=%S\r\n",
+ cookie, tidp, tidp->refCount, tidp->tid, tidp->vcp, tidp->userp, tidp->flags, tidp->deleteOk,
+ tidp->pathname ? tidp->pathname : _C("NULL"));
+ WriteFile(outputFile, output, (DWORD)strlen(output), &zilch, NULL);
+ }
+ sprintf(output, " done dumping smb_tid_t\r\n");
+ WriteFile(outputFile, output, (DWORD)strlen(output), &zilch, NULL);
+
+ sprintf(output, " begin dumping smb_fid_t\r\n");
WriteFile(outputFile, output, (DWORD)strlen(output), &zilch, NULL);
for (fidp = vcp->fidsp; fidp; fidp = (smb_fid_t *) osi_QNext(&fidp->q))
{
- sprintf(output, "%s -- smb_fidp=0x%p, refCount=%d, fid=%d, vcp=0x%p, scp=0x%p, ioctlp=0x%p, NTopen_pathp=%s, NTopen_wholepathp=%s\r\n",
- cookie, fidp, fidp->refCount, fidp->fid, fidp->vcp, fidp->scp, fidp->ioctlp,
- fidp->NTopen_pathp ? fidp->NTopen_pathp : "NULL",
- fidp->NTopen_wholepathp ? fidp->NTopen_wholepathp : "NULL");
+ sprintf(output, " %s -- smb_fidp=0x%p, refCount=%d, fid=%d, vcp=0x%p, scp=0x%p, userp=0x%p, ioctlp=0x%p, flags=0x%x, delOk=%d, NTopen_pathp=%S, NTopen_wholepathp=%S\r\n",
+ cookie, fidp, fidp->refCount, fidp->fid, fidp->vcp, fidp->scp, fidp->userp, fidp->ioctlp, fidp->flags, fidp->deleteOk,
+ fidp->NTopen_pathp ? fidp->NTopen_pathp : _C("NULL"),
+ fidp->NTopen_wholepathp ? fidp->NTopen_wholepathp : _C("NULL"));
WriteFile(outputFile, output, (DWORD)strlen(output), &zilch, NULL);
}
- sprintf(output, "done dumping smb_fid_t\r\n");
+ sprintf(output, " done dumping smb_fid_t\r\n");
WriteFile(outputFile, output, (DWORD)strlen(output), &zilch, NULL);
}
for (vcp = smb_deadVCsp; vcp; vcp=vcp->nextp)
{
smb_fid_t *fidp;
-
- sprintf(output, "%s vcp=0x%p, refCount=%d, flags=%d, vcID=%d, lsn=%d, uidCounter=%d, tidCounter=%d, fidCounter=%d\r\n",
- cookie, vcp, vcp->refCount, vcp->flags, vcp->vcID, vcp->lsn, vcp->uidCounter, vcp->tidCounter, vcp->fidCounter);
+ smb_tid_t *tidp;
+ smb_user_t *userp;
+
+ sprintf(output, "%s vcp=0x%p, refCount=%d, flags=0x%x, vcID=%d, lsn=%d, uidCounter=%d, tidCounter=%d, fidCounter=%d\r\n",
+ cookie, vcp, vcp->refCount, vcp->flags, vcp->vcID, vcp->lsn, vcp->uidCounter, vcp->tidCounter, vcp->fidCounter);
WriteFile(outputFile, output, (DWORD)strlen(output), &zilch, NULL);
- sprintf(output, "begin dumping smb_fid_t\r\n");
+ sprintf(output, " begin dumping smb_user_t\r\n");
+ WriteFile(outputFile, output, (DWORD)strlen(output), &zilch, NULL);
+ for (userp = vcp->usersp; userp; userp = userp->nextp) {
+ sprintf(output, " %s -- smb_userp=0x%p, refCount=%d, uid=%d, vcp=0x%p, unp=0x%p, flags=0x%x, delOk=%d\r\n",
+ cookie, userp, userp->refCount, userp->userID, userp->vcp, userp->unp, userp->flags, userp->deleteOk);
+ WriteFile(outputFile, output, (DWORD)strlen(output), &zilch, NULL);
+ }
+ sprintf(output, " done dumping smb_user_t\r\n");
+ WriteFile(outputFile, output, (DWORD)strlen(output), &zilch, NULL);
+
+ sprintf(output, " begin dumping smb_tid_t\r\n");
+ WriteFile(outputFile, output, (DWORD)strlen(output), &zilch, NULL);
+ for (tidp = vcp->tidsp; tidp; tidp = tidp->nextp) {
+ sprintf(output, " %s -- smb_tidp=0x%p, refCount=%d, tid=%d, vcp=0x%p, cm_userp=0x%p, flags=0x%x, delOk=%d, path=%S\r\n",
+ cookie, tidp, tidp->refCount, tidp->tid, tidp->vcp, tidp->userp, tidp->flags, tidp->deleteOk,
+ tidp->pathname ? tidp->pathname : _C("NULL"));
+ WriteFile(outputFile, output, (DWORD)strlen(output), &zilch, NULL);
+ }
+ sprintf(output, " done dumping smb_tid_t\r\n");
+ WriteFile(outputFile, output, (DWORD)strlen(output), &zilch, NULL);
+
+ sprintf(output, " begin dumping smb_fid_t\r\n");
WriteFile(outputFile, output, (DWORD)strlen(output), &zilch, NULL);
for (fidp = vcp->fidsp; fidp; fidp = (smb_fid_t *) osi_QNext(&fidp->q))
{
- sprintf(output, "%s -- smb_fidp=0x%p, refCount=%d, fid=%d, vcp=0x%p, scp=0x%p, ioctlp=0x%p, NTopen_pathp=%s, NTopen_wholepathp=%s\r\n",
- cookie, fidp, fidp->refCount, fidp->fid, fidp->vcp, fidp->scp, fidp->ioctlp,
- fidp->NTopen_pathp ? fidp->NTopen_pathp : "NULL",
- fidp->NTopen_wholepathp ? fidp->NTopen_wholepathp : "NULL");
+ sprintf(output, " %s -- smb_fidp=0x%p, refCount=%d, fid=%d, vcp=0x%p, scp=0x%p, userp=0x%p, ioctlp=0x%p, flags=0x%x, delOk=%d, NTopen_pathp=%S, NTopen_wholepathp=%S\r\n",
+ cookie, fidp, fidp->refCount, fidp->fid, fidp->vcp, fidp->scp, fidp->userp, fidp->ioctlp, fidp->flags, fidp->deleteOk,
+ fidp->NTopen_pathp ? fidp->NTopen_pathp : _C("NULL"),
+ fidp->NTopen_wholepathp ? fidp->NTopen_wholepathp : _C("NULL"));
WriteFile(outputFile, output, (DWORD)strlen(output), &zilch, NULL);
}
- sprintf(output, "done dumping smb_fid_t\r\n");
+ sprintf(output, " done dumping smb_fid_t\r\n");
WriteFile(outputFile, output, (DWORD)strlen(output), &zilch, NULL);
}
git://git.openafs.org / openafs.git / blobdiff