/* Faux server GUID. This is never checked. */
GUID smb_ServerGUID = { 0x40015cb8, 0x058a, 0x44fc, { 0xae, 0x7e, 0xbb, 0x29, 0x52, 0xee, 0x7e, 0xff }};
+void smb_InitReq(cm_req_t *reqp)
+{
+ cm_InitReq(reqp);
+ reqp->flags |= CM_REQ_SOURCE_SMB;
+}
+
void smb_ResetServerPriority()
{
void * p = TlsGetValue(smb_TlsRequestSlot);
*unixTimep = dosTime + smb_localZero;
}
+#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_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;
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. Add a reference that will be dropped by
+ * 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.
*/
- vcp->refCount++; /* put the refCount back */
- lock_ReleaseWrite(&smb_rctLock);
- smb_CleanupDeadVC(vcp);
- lock_ObtainWrite(&smb_rctLock);
+ 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);
}
}
/* 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 */
- refCount = vcp->refCount;
- smb_ReleaseVCNoLock(vcp);
-
- /*
+ * 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;
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_InitializeMutex(&tidp->mx, "tid_t mutex");
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->deleteOk)) {
- 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 (!locked)
lock_ReleaseWrite(&smb_rctLock);
if (userp)
cm_ReleaseUser(userp);
+ if (vcp)
+ smb_ReleaseVCNoLock(vcp);
}
smb_user_t *smb_FindUID(smb_vc_t *vcp, unsigned short uid, int flags)
void smb_HoldUIDNoLock(smb_user_t *uidp)
{
+ lock_AssertWrite(&smb_rctLock);
uidp->refCount++;
}
* 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;
}
}
+#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;
}
+#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;
break;
}
}
+#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;
}
+#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 */
+#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->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;
+#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->ioctl.inAllocp)
- free(ioctlp->ioctl.inAllocp);
- if (ioctlp->ioctl.outAllocp)
- free(ioctlp->ioctl.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);
+ }
+ lock_ReleaseMutex(&fidp->mx);
+ lock_FinalizeMutex(&fidp->mx);
+ free(fidp);
+ fidp = NULL;
- if (vcp)
- smb_ReleaseVCNoLock(vcp);
- } else {
- lock_ReleaseMutex(&fidp->mx);
+ if (vcp)
+ smb_ReleaseVCNoLock(vcp);
+ }
}
+ if (fidp)
+ lock_ReleaseMutex(&fidp->mx);
+
lock_ReleaseWrite(&smb_rctLock);
/* now release the scache structure */
if (cm_ClientStrCmpN(p, cm_mountRootC, cm_mountRootCLen) == 0) {
p += cm_mountRootCLen; /* skip mount path */
- cchlen -= (p - pathName);
+ cchlen -= (DWORD)(p - pathName);
}
q = p;
/* 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;
rw = 1;
}
/* Get the full name for this cell */
- cellname = cm_ClientStringToFsStringAlloc(p, cm_ClientStrLen(p), NULL);
+ cellname = cm_ClientStringToFsStringAlloc(p, -1, NULL);
code = cm_SearchCellFile(cellname, ftemp, 0, 0);
#ifdef AFS_AFSDB_ENV
if (code && cm_dnsEnabled) {
if (code == 0) {
clientchar_t temp[1024];
- cm_FsStringToClientString(ftemp, cm_FsStrLen(ftemp), temp, 1024);
- cm_ClientStrPrintfN(pathName, lengthof(pathName),
+ cm_FsStringToClientString(ftemp, (int)cm_FsStrLen(ftemp), temp, 1024);
+ cm_ClientStrPrintfN(pathName, (int)lengthof(pathName),
rw ? _C("/.%S/") : _C("/%S/"), temp);
*pathNamep = cm_ClientStrDup(cm_ClientStrLwr(pathName));
return 1;
return dsp;
}
-static smb_packet_t *GetPacket(void)
+static smb_packet_t *smb_GetPacket(void)
{
smb_packet_t *tbp;
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;
return tbp;
}
-static NCB *GetNCB(void)
+static NCB *smb_GetNCB(void)
{
smb_ncb_t *tbp;
NCB *ncbp;
smb_ReleaseVC(vcp);
}
-static void FreeNCB(NCB *bufferp)
+static void smb_FreeNCB(NCB *bufferp)
{
smb_ncb_t *tbp;
*stringspp = spacep;
cchdest = lengthof(spacep->wdata);
- cm_Utf8ToUtf16(inp, *pcb_max, spacep->wdata, cchdest);
+ cm_Utf8ToUtf16(inp, (int)*pcb_max, spacep->wdata, cchdest);
return spacep->wdata;
#ifdef SMB_UNICODE
{
/* Storing ANSI */
- int cch_str;
- int cch_dest;
+ size_t cch_str;
+ size_t cch_dest;
cch_str = cm_ClientStrLen(str);
- cch_dest = cm_ClientStringToUtf8(str, cch_str, NULL, 0);
+ cch_dest = cm_ClientStringToUtf8(str, (int)cch_str, NULL, 0);
if (plen)
*plen = ((flags & SMB_STRF_IGNORENULL)? cch_dest: cch_dest+1);
*/
if (outp >= pktp->data && outp < pktp->data + sizeof(pktp->data)) {
- align = ((outp - pktp->data) % 2);
+ align = (int)((outp - pktp->data) % 2);
buffersize = (pktp->data + sizeof(pktp->data)) - ((char *) outp);
} else {
- align = (((size_t) outp) % 2);
- buffersize = sizeof(pktp->data);
+ align = (int)(((size_t) outp) % 2);
+ buffersize = (int)sizeof(pktp->data);
}
#ifdef SMB_UNICODE
return outp + sizeof(wchar_t);
}
- nchars = cm_ClientStringToUtf16(str, -1, (wchar_t *) outp, buffersize / 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),
/* Storing ANSI */
size_t cch_dest;
- cch_dest = cm_ClientStringToUtf8(str, -1, outp, buffersize);
+ cch_dest = cm_ClientStringToUtf8(str, -1, outp, (int)buffersize);
if (plen)
*plen += ((flags & SMB_STRF_IGNORENULL)? cch_dest - 1: cch_dest);
ncbp = inp->ncbp;
if (ncbp == NULL) {
- ncbp = GetNCB();
+ ncbp = smb_GetNCB();
localNCB = 1;
}
}
if (localNCB)
- FreeNCB(ncbp);
+ smb_FreeNCB(ncbp);
}
void smb_MapNTError(long code, unsigned long *NTStatusp)
/* and the faux domain name */
cm_ClientStringToUtf8(smb_ServerDomainName, -1,
datap + MSV1_0_CHALLENGE_LENGTH,
- sizeof(outp->data)/sizeof(char) - (datap - outp->data));
+ (int)(sizeof(outp->data)/sizeof(char) - (datap - outp->data)));
} else if ( smb_authType == SMB_AUTH_EXTENDED ) {
void * secBlob;
int secBlobLength;
/* and the faux domain name */
cm_ClientStringToUtf8(smb_ServerDomainName, -1,
datap + MSV1_0_CHALLENGE_LENGTH,
- sizeof(outp->data)/sizeof(char) - (datap - outp->data));
+ (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);
scp = wlRequest->scp;
osi_Log2(smb_logp,"smb_WaitingLocksDaemon wlRequest 0x%p scp 0x%p", wlRequest, scp);
- cm_InitReq(&req);
+ smb_InitReq(&req);
lock_ObtainWrite(&scp->rw);
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);
cm_fid_t fid;
int fileType;
- cm_InitReq(&req);
+ smb_InitReq(&req);
maxCount = smb_GetSMBParm(inp, 0);
* the status info for files in the dir.
*/
if (starPattern) {
- smb_ApplyDirListPatches(&dirListPatchesp, dsp->tidPath, dsp->relPath, userp, &req);
lock_ObtainWrite(&scp->rw);
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);
+ code = cm_TryBulkStat(scp, &thyper, userp, &req);
}
- } else {
- lock_ObtainWrite(&scp->rw);
+ lock_ReleaseWrite(&scp->rw);
+ smb_ApplyDirListPatches(&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);
curOffset = LargeIntegerAdd(thyper, curOffset);
} /* while copying data for dir listing */
+ /* If there is anything left to bulk stat ... */
+ if ((dsp->flags & SMB_DIRSEARCH_BULKST) &&
+ LargeIntegerGreaterThanOrEqualTo(thyper,
+ scp->bulkStatProgress)) {
+ thyper.LowPart = curOffset.LowPart & ~(cm_data.buf_blockSize-1);
+ code = cm_TryBulkStat(scp, &thyper, userp, &req);
+ }
+
/* release the mutex */
lock_ReleaseWrite(&scp->rw);
if (bufferp) {
cm_req_t req;
char * pdata;
- cm_InitReq(&req);
+ smb_InitReq(&req);
pdata = smb_GetSMBData(inp, NULL);
pathp = smb_ParseASCIIBlock(inp, pdata, NULL, SMB_STRF_ANSIPATH);
char * datap;
cm_req_t req;
- cm_InitReq(&req);
+ smb_InitReq(&req);
/* decode basic attributes we're passed */
attribute = smb_GetSMBParm(inp, 0);
char * datap;
cm_req_t req;
- cm_InitReq(&req);
+ smb_InitReq(&req);
datap = smb_GetSMBData(inp, NULL);
pathp = smb_ParseASCIIBlock(inp, datap, NULL, SMB_STRF_ANSIPATH);
char * datap;
cm_req_t req;
- cm_InitReq(&req);
+ smb_InitReq(&req);
datap = smb_GetSMBData(inp, NULL);
pathp = smb_ParseASCIIBlock(inp, datap, NULL, SMB_STRF_ANSIPATH);
clientchar_t *tidPathp;
cm_req_t req;
- cm_InitReq(&req);
+ smb_InitReq(&req);
attribute = smb_GetSMBParm(inp, 0);
return CM_ERROR_NOSUCHPATH;
}
- cm_InitReq(&req);
+ smb_InitReq(&req);
spacep = inp->spacep;
smb_StripLastComponent(spacep->wdata, &oldLastNamep, oldPathp);
return CM_ERROR_NOSUCHPATH;
}
- cm_InitReq(&req);
+ smb_InitReq(&req);
caseFold = CM_FLAG_FOLLOW | CM_FLAG_CASEFOLD;
clientchar_t *tidPathp;
cm_req_t req;
- cm_InitReq(&req);
+ smb_InitReq(&req);
tp = smb_GetSMBData(inp, NULL);
pathp = smb_ParseASCIIBlock(inp, tp, &tp, SMB_STRF_ANSIPATH);
long code = 0;
cm_req_t req;
- cm_InitReq(&req);
+ smb_InitReq(&req);
fid = smb_GetSMBParm(inp, 0);
lock_ReleaseMutex(&fidp->mx);
}
- cm_InitReq(&req);
+ smb_InitReq(&req);
lock_ObtainWrite(&smb_rctLock);
if (fidp->deleteOk) {
goto done2;
}
- cm_InitReq(&req);
+ smb_InitReq(&req);
bufferp = NULL;
offset = *offsetp;
goto done2;
}
- cm_InitReq(&req);
+ smb_InitReq(&req);
scp = fidp->scp;
cm_HoldSCache(scp);
/* 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;
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;
clientchar_t *tidPathp;
cm_req_t req;
- cm_InitReq(&req);
+ smb_InitReq(&req);
scp = NULL;
setAttr.mask = CM_ATTRMASK_CLIENTMODTIME;
setAttr.clientModTime = time(NULL);
- code = cm_MakeDir(dscp, lastNamep, 0, &setAttr, userp, &req);
+ 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,
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;
cm_user_t *userp;
cm_req_t req;
- cm_InitReq(&req);
+ smb_InitReq(&req);
fd = smb_GetSMBParm(inp, 0);
whence = smb_GetSMBParm(inp, 1);
rx_StartClientThread();
- outncbp = GetNCB();
- outbufp = GetPacket();
+ outncbp = smb_GetNCB();
+ outbufp = smb_GetPacket();
outbufp->ncbp = outncbp;
while (1) {
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;
}
}
if (vcp)
smb_ReleaseVC(vcp);
+ if (outbufp)
+ smb_FreePacket(outbufp);
+ if (outncbp)
+ smb_FreeNCB(outncbp);
}
/*
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;
}
if ( GetLastError() == ERROR_ALREADY_EXISTS )
thrd_ResetEvent(ListenerShutdown[lana]);
- ncbp = GetNCB();
+ ncbp = smb_GetNCB();
/* retrieve computer name */
GetComputerName(cname, &cnamelen);
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;
} /* dispatch while loop */
exit_thread:
- FreeNCB(ncbp);
+ smb_FreeNCB(ncbp);
thrd_SetEvent(ListenerShutdown[lana]);
return;
}
strcmp(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);
}
}
}
- FreeNCB(ncbp);
+ smb_FreeNCB(ncbp);
}
}
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))) {
}
/* 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)
#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);
}
/*fprintf(stderr, "Entering smb_Shutdown\n");*/
/* setup the NCB system */
- ncbp = GetNCB();
+ ncbp = smb_GetNCB();
/* Block new sessions by setting shutdown flag */
smbShutdownFlag = 1;
}
}
lock_ReleaseWrite(&smb_rctLock);
- FreeNCB(ncbp);
+ smb_FreeNCB(ncbp);
TlsFree(smb_TlsRequestSlot);
}
char *smb_GetSharename()
{
char *name;
- int len;
+ size_t len;
/* Make sure we have been properly initialized. */
if (smb_localNamep == NULL)
{
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",
+ 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);
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",
+ 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 : _C("NULL"),
fidp->NTopen_wholepathp ? fidp->NTopen_wholepathp : _C("NULL"));
{
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",
+ 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);
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",
+ 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 : _C("NULL"),
fidp->NTopen_wholepathp ? fidp->NTopen_wholepathp : _C("NULL"));
git://git.openafs.org / openafs.git / blobdiff