vcp = malloc(sizeof(*vcp));
memset(vcp, 0, sizeof(*vcp));
vcp->vcID = numVCs++;
- vcp->refCount = 1;
+ vcp->refCount = 2; /* smb_allVCsp and caller */
vcp->tidCounter = 1;
vcp->fidCounter = 1;
- vcp->uidCounter = 1; /* UID 0 is reserved for blank user */
+ vcp->uidCounter = 1; /* UID 0 is reserved for blank user */
vcp->nextp = smb_allVCsp;
smb_allVCsp = vcp;
lock_InitializeMutex(&vcp->mx, "vc_t mutex");
return 0;
}
-void smb_ReleaseVCNoLock(smb_vc_t *vcp)
+void smb_ReleaseVCInternal(smb_vc_t *vcp)
{
- osi_Log2(smb_logp,"smb_ReleaseVCNoLock vcp %x ref %d",vcp, vcp->refCount);
#ifdef DEBUG
osi_assert(vcp->refCount-- != 0);
#else
vcp->refCount--;
#endif
+
+ if (vcp->refCount == 0) {
+ memset(vcp,0,sizeof(smb_vc_t));
+ free(vcp);
+ }
+}
+
+void smb_ReleaseVCNoLock(smb_vc_t *vcp)
+{
+ osi_Log2(smb_logp,"smb_ReleaseVCNoLock vcp %x ref %d",vcp, vcp->refCount);
+ smb_ReleaseVCInternal(vcp);
}
void smb_ReleaseVC(smb_vc_t *vcp)
{
lock_ObtainWrite(&smb_rctLock);
osi_Log2(smb_logp,"smb_ReleaseVC vcp %x ref %d",vcp, vcp->refCount);
-#ifdef DEBUG
- osi_assert(vcp->refCount-- != 0);
-#else
- vcp->refCount--;
-#endif
+ smb_ReleaseVCInternal(vcp);
lock_ReleaseWrite(&smb_rctLock);
}
smb_user_t *userpNext;
smb_user_t *userp;
unsigned short uid;
+ smb_vc_t **vcpp;
osi_Log1(smb_logp, "Cleaning up dead vcp 0x%x", vcp);
lock_ObtainRead(&smb_rctLock);
}
+ /* remove VCP from smb_allVCsp */
+ for (vcpp = &smb_allVCsp; *vcpp; vcpp = &((*vcpp)->nextp)) {
+ if (*vcpp == vcp) {
+ *vcpp = vcp->nextp;
+ smb_ReleaseVCNoLock(vcp);
+ break;
+ }
+ }
lock_ReleaseRead(&smb_rctLock);
-
osi_Log0(smb_logp, "Done cleaning up dead vcp");
}
uidp = malloc(sizeof(*uidp));
memset(uidp, 0, sizeof(*uidp));
uidp->nextp = vcp->usersp;
- uidp->refCount = 1;
+ uidp->refCount = 2; /* one for the vcp and one for the caller */
uidp->vcp = vcp;
smb_HoldVCNoLock(vcp);
vcp->usersp = uidp;
lock_ObtainWrite(&smb_rctLock);
osi_assert(uidp->refCount-- > 0);
- if (uidp->refCount == 0 && (uidp->flags & SMB_USERFLAG_DELETE)) {
+ if (uidp->refCount == 0) {
lupp = &uidp->vcp->usersp;
for(up = *lupp; up; lupp = &up->nextp, up = *lupp) {
if (up == uidp)
cm_user_t *smb_GetUser(smb_vc_t *vcp, smb_packet_t *inp)
{
smb_user_t *uidp;
- cm_user_t *up;
+ cm_user_t *up = NULL;
smb_t *smbp;
smbp = (smb_t *) inp;
uidp = smb_FindUID(vcp, smbp->uid, 0);
- if ((!uidp) || (!uidp->unp))
- return NULL;
-
+ if (!uidp)
+ return NULL;
+
lock_ObtainMutex(&uidp->mx);
- up = uidp->unp->userp;
- cm_HoldUser(up);
+ if (uidp->unp) {
+ up = uidp->unp->userp;
+ cm_HoldUser(up);
+ }
lock_ReleaseMutex(&uidp->mx);
smb_ReleaseUID(uidp);
-
return up;
}
s = "unknown error";
}
osi_Log2(smb_logp, "SendPacket failure code %d \"%s\"", code, s);
+ osi_Log2(smb_logp, "setting dead_vcp 0x%x, user struct 0x%x",
+ vcp, vcp->usersp);
+ smb_HoldVC(vcp);
+ if (dead_vcp) {
+ osi_Log1(smb_logp,"Previous dead_vcp %x", dead_vcp);
+ smb_CleanupDeadVC(dead_vcp);
+ smb_ReleaseVC(dead_vcp);
+ }
+ dead_vcp = vcp;
+ vcp->flags |= SMB_VCFLAG_ALREADYDEAD;
}
if (localNCB)
ongoingOps - 1);
if (!isGateway) {
if (active_vcp) {
- DWORD now = GetCurrentTime();
- if (now - last_msg_time >= 30000
- && now - last_msg_time <= 90000) {
- osi_Log1(smb_logp,
- "Setting dead_vcp %x", active_vcp);
- if (dead_vcp) {
+ DWORD now = GetTickCount();
+ if (now - last_msg_time >= 30000) {
+ smb_vc_t *avcp = active_vcp;
+ active_vcp = NULL;
+ osi_Log1(smb_logp,"Setting dead_vcp %x", avcp);
+ if (dead_vcp) {
+ osi_Log1(smb_logp,"Previous dead_vcp %x", dead_vcp);
+ smb_CleanupDeadVC(dead_vcp);
smb_ReleaseVC(dead_vcp);
- osi_Log1(smb_logp,
- "Previous dead_vcp %x", dead_vcp);
}
- smb_HoldVC(active_vcp);
- dead_vcp = active_vcp;
+ smb_HoldVC(avcp);
+ dead_vcp = avcp;
dead_vcp->flags |= SMB_VCFLAG_ALREADYDEAD;
+ smb_ReleaseVC(avcp);
}
}
}
LargeIntegerGreaterThanOrEqualTo(thyper,
scp->bulkStatProgress)) {
/* Don't bulk stat if risking timeout */
- int now = GetCurrentTime();
+ int now = GetTickCount();
if (now - req.startTime > 5000) {
scp->bulkStatProgress = thyper;
scp->flags &= ~CM_SCACHEFLAG_BULKSTATTING;
/* Remember session generation number and time */
oldGen = sessionGen;
- oldTime = GetCurrentTime();
+ oldTime = GetTickCount();
while (inp->inCom != 0xff) {
dp = &smb_dispatchTable[inp->inCom];
HANDLE h;
char *ptbuf[1];
char s[100];
- newTime = GetCurrentTime();
+ newTime = GetTickCount();
h = RegisterEventSource(NULL, AFS_DAEMON_EVENT_NAME);
sprintf(s, "Pkt straddled session startup, took %d ms, ncb length %d",
newTime - oldTime, ncbp->ncb_length);
if (!(vcp->flags & SMB_VCFLAG_ALREADYDEAD)) {
if (active_vcp != vcp) {
if (active_vcp) {
- smb_ReleaseVC(active_vcp);
osi_Log2(smb_logp,
"Replacing active_vcp %x with %x", active_vcp, vcp);
+ smb_ReleaseVC(active_vcp);
}
smb_HoldVC(vcp);
active_vcp = vcp;
}
- last_msg_time = GetCurrentTime();
- } else if (active_vcp == vcp) {
+ last_msg_time = GetTickCount();
+ } else if (active_vcp == vcp) { /* the vcp is dead */
smb_ReleaseVC(active_vcp);
active_vcp = NULL;
}
-
return;
}
osi_Log2(smb_logp, "NCBRECV pending lsn %d session %d", ncbp->ncb_lsn, idx_session);
continue;
- case NRC_SCLOSED:
case NRC_SNUMOUT:
case NRC_SABORT:
+ case NRC_SCLOSED:
/* Client closed session */
- dead_sessions[idx_session] = TRUE;
+ dead_sessions[idx_session] = TRUE;
if (vcp)
smb_ReleaseVC(vcp);
vcp = smb_FindVC(ncbp->ncb_lsn, 0, lanas[idx_session]);
- /* Should also release vcp. [done] 2004-05-11 jaltman
- * Also, should do
- * sanity check that all TID's are gone.
- *
- * TODO: check if we could use LSNs[idx_session] instead,
- * also cleanup after dead vcp
- */
if (vcp) {
- if (dead_vcp == vcp)
+ if (dead_vcp == vcp)
osi_Log1(smb_logp, "dead_vcp already set, 0x%x", dead_vcp);
else if (!(vcp->flags & SMB_VCFLAG_ALREADYDEAD)) {
osi_Log2(smb_logp, "setting dead_vcp 0x%x, user struct 0x%x",
vcp, vcp->usersp);
- smb_HoldVC(vcp);
+ smb_HoldVC(vcp);
if (dead_vcp) {
+ osi_Log1(smb_logp,"Previous dead_vcp %x", dead_vcp);
+ smb_CleanupDeadVC(dead_vcp);
smb_ReleaseVC(dead_vcp);
- osi_Log1(smb_logp,
- "Previous dead_vcp %x", dead_vcp);
}
dead_vcp = vcp;
vcp->flags |= SMB_VCFLAG_ALREADYDEAD;
}
- smb_CleanupDeadVC(vcp);
-
if (vcp->justLoggedOut) {
loggedOut = 1;
loggedOutTime = vcp->logoffTime;
void smb_InitIoctl(void)
{
- int i;
- for (i=0; i<SMB_IOCTL_MAXPROCS; i++)
- smb_ioctlProcsp[i] = NULL;
-
- smb_ioctlProcsp[VIOCGETAL] = cm_IoctlGetACL;
- smb_ioctlProcsp[VIOC_FILE_CELL_NAME] = cm_IoctlGetFileCellName;
- smb_ioctlProcsp[VIOCSETAL] = cm_IoctlSetACL;
- smb_ioctlProcsp[VIOC_FLUSHVOLUME] = cm_IoctlFlushVolume;
- smb_ioctlProcsp[VIOCFLUSH] = cm_IoctlFlushFile;
- smb_ioctlProcsp[VIOCSETVOLSTAT] = cm_IoctlSetVolumeStatus;
- smb_ioctlProcsp[VIOCGETVOLSTAT] = cm_IoctlGetVolumeStatus;
- smb_ioctlProcsp[VIOCWHEREIS] = cm_IoctlWhereIs;
- smb_ioctlProcsp[VIOC_AFS_STAT_MT_PT] = cm_IoctlStatMountPoint;
- smb_ioctlProcsp[VIOC_AFS_DELETE_MT_PT] = cm_IoctlDeleteMountPoint;
- smb_ioctlProcsp[VIOCCKSERV] = cm_IoctlCheckServers;
- smb_ioctlProcsp[VIOC_GAG] = cm_IoctlGag;
- smb_ioctlProcsp[VIOCCKBACK] = cm_IoctlCheckVolumes;
- smb_ioctlProcsp[VIOCSETCACHESIZE] = cm_IoctlSetCacheSize;
- smb_ioctlProcsp[VIOCGETCACHEPARMS] = cm_IoctlGetCacheParms;
- smb_ioctlProcsp[VIOCGETCELL] = cm_IoctlGetCell;
- smb_ioctlProcsp[VIOCNEWCELL] = cm_IoctlNewCell;
- smb_ioctlProcsp[VIOC_GET_WS_CELL] = cm_IoctlGetWsCell;
- smb_ioctlProcsp[VIOC_AFS_SYSNAME] = cm_IoctlSysName;
- smb_ioctlProcsp[VIOC_GETCELLSTATUS] = cm_IoctlGetCellStatus;
- smb_ioctlProcsp[VIOC_SETCELLSTATUS] = cm_IoctlSetCellStatus;
- smb_ioctlProcsp[VIOC_SETSPREFS] = cm_IoctlSetSPrefs;
- smb_ioctlProcsp[VIOC_GETSPREFS] = cm_IoctlGetSPrefs;
- smb_ioctlProcsp[VIOC_STOREBEHIND] = cm_IoctlStoreBehind;
- smb_ioctlProcsp[VIOC_AFS_CREATE_MT_PT] = cm_IoctlCreateMountPoint;
- smb_ioctlProcsp[VIOC_TRACECTL] = cm_IoctlTraceControl;
- smb_ioctlProcsp[VIOCSETTOK] = cm_IoctlSetToken;
- smb_ioctlProcsp[VIOCGETTOK] = cm_IoctlGetTokenIter;
- smb_ioctlProcsp[VIOCNEWGETTOK] = cm_IoctlGetToken;
- smb_ioctlProcsp[VIOCDELTOK] = cm_IoctlDelToken;
- smb_ioctlProcsp[VIOCDELALLTOK] = cm_IoctlDelAllToken;
- smb_ioctlProcsp[VIOC_SYMLINK] = cm_IoctlSymlink;
- smb_ioctlProcsp[VIOC_LISTSYMLINK] = cm_IoctlListlink;
- smb_ioctlProcsp[VIOC_DELSYMLINK] = cm_IoctlDeletelink;
- smb_ioctlProcsp[VIOC_MAKESUBMOUNT] = cm_IoctlMakeSubmount;
- smb_ioctlProcsp[VIOC_GETRXKCRYPT] = cm_IoctlGetRxkcrypt;
- smb_ioctlProcsp[VIOC_SETRXKCRYPT] = cm_IoctlSetRxkcrypt;
- smb_ioctlProcsp[VIOC_ISSYMLINK] = cm_IoctlIslink;
+ int i;
+ for (i=0; i<SMB_IOCTL_MAXPROCS; i++)
+ smb_ioctlProcsp[i] = NULL;
+
+ smb_ioctlProcsp[VIOCGETAL] = cm_IoctlGetACL;
+ smb_ioctlProcsp[VIOC_FILE_CELL_NAME] = cm_IoctlGetFileCellName;
+ smb_ioctlProcsp[VIOCSETAL] = cm_IoctlSetACL;
+ smb_ioctlProcsp[VIOC_FLUSHVOLUME] = cm_IoctlFlushVolume;
+ smb_ioctlProcsp[VIOCFLUSH] = cm_IoctlFlushFile;
+ smb_ioctlProcsp[VIOCSETVOLSTAT] = cm_IoctlSetVolumeStatus;
+ smb_ioctlProcsp[VIOCGETVOLSTAT] = cm_IoctlGetVolumeStatus;
+ smb_ioctlProcsp[VIOCWHEREIS] = cm_IoctlWhereIs;
+ smb_ioctlProcsp[VIOC_AFS_STAT_MT_PT] = cm_IoctlStatMountPoint;
+ smb_ioctlProcsp[VIOC_AFS_DELETE_MT_PT] = cm_IoctlDeleteMountPoint;
+ smb_ioctlProcsp[VIOCCKSERV] = cm_IoctlCheckServers;
+ smb_ioctlProcsp[VIOC_GAG] = cm_IoctlGag;
+ smb_ioctlProcsp[VIOCCKBACK] = cm_IoctlCheckVolumes;
+ smb_ioctlProcsp[VIOCSETCACHESIZE] = cm_IoctlSetCacheSize;
+ smb_ioctlProcsp[VIOCGETCACHEPARMS] = cm_IoctlGetCacheParms;
+ smb_ioctlProcsp[VIOCGETCELL] = cm_IoctlGetCell;
+ smb_ioctlProcsp[VIOCNEWCELL] = cm_IoctlNewCell;
+ smb_ioctlProcsp[VIOC_GET_WS_CELL] = cm_IoctlGetWsCell;
+ smb_ioctlProcsp[VIOC_AFS_SYSNAME] = cm_IoctlSysName;
+ smb_ioctlProcsp[VIOC_GETCELLSTATUS] = cm_IoctlGetCellStatus;
+ smb_ioctlProcsp[VIOC_SETCELLSTATUS] = cm_IoctlSetCellStatus;
+ smb_ioctlProcsp[VIOC_SETSPREFS] = cm_IoctlSetSPrefs;
+ smb_ioctlProcsp[VIOC_GETSPREFS] = cm_IoctlGetSPrefs;
+ smb_ioctlProcsp[VIOC_STOREBEHIND] = cm_IoctlStoreBehind;
+ smb_ioctlProcsp[VIOC_AFS_CREATE_MT_PT] = cm_IoctlCreateMountPoint;
+ smb_ioctlProcsp[VIOC_TRACECTL] = cm_IoctlTraceControl;
+ smb_ioctlProcsp[VIOCSETTOK] = cm_IoctlSetToken;
+ smb_ioctlProcsp[VIOCGETTOK] = cm_IoctlGetTokenIter;
+ smb_ioctlProcsp[VIOCNEWGETTOK] = cm_IoctlGetToken;
+ smb_ioctlProcsp[VIOCDELTOK] = cm_IoctlDelToken;
+ smb_ioctlProcsp[VIOCDELALLTOK] = cm_IoctlDelAllToken;
+ smb_ioctlProcsp[VIOC_SYMLINK] = cm_IoctlSymlink;
+ smb_ioctlProcsp[VIOC_LISTSYMLINK] = cm_IoctlListlink;
+ smb_ioctlProcsp[VIOC_DELSYMLINK] = cm_IoctlDeletelink;
+ smb_ioctlProcsp[VIOC_MAKESUBMOUNT] = cm_IoctlMakeSubmount;
+ smb_ioctlProcsp[VIOC_GETRXKCRYPT] = cm_IoctlGetRxkcrypt;
+ smb_ioctlProcsp[VIOC_SETRXKCRYPT] = cm_IoctlSetRxkcrypt;
+ smb_ioctlProcsp[VIOC_ISSYMLINK] = cm_IoctlIslink;
#ifdef DJGPP
- smb_ioctlProcsp[VIOC_SHUTDOWN] = cm_IoctlShutdown;
+ smb_ioctlProcsp[VIOC_SHUTDOWN] = cm_IoctlShutdown;
#endif
- smb_ioctlProcsp[VIOC_TRACEMEMDUMP] = cm_IoctlMemoryDump;
- smb_ioctlProcsp[VIOC_ISSYMLINK] = cm_IoctlIslink;
- smb_ioctlProcsp[VIOC_FLUSHALL] = cm_IoctlFlushAllVolumes;
- smb_ioctlProcsp[VIOCGETFID] = cm_IoctlGetFid;
- smb_ioctlProcsp[VIOCGETOWNER] = cm_IoctlGetOwner;
- smb_ioctlProcsp[VIOC_RXSTAT_PROC] = cm_IoctlRxStatProcess;
- smb_ioctlProcsp[VIOC_RXSTAT_PEER] = cm_IoctlRxStatPeer;
-}
+ smb_ioctlProcsp[VIOC_TRACEMEMDUMP] = cm_IoctlMemoryDump;
+ smb_ioctlProcsp[VIOC_ISSYMLINK] = cm_IoctlIslink;
+ smb_ioctlProcsp[VIOC_FLUSHALL] = cm_IoctlFlushAllVolumes;
+ smb_ioctlProcsp[VIOCGETFID] = cm_IoctlGetFid;
+ smb_ioctlProcsp[VIOCGETOWNER] = cm_IoctlGetOwner;
+ smb_ioctlProcsp[VIOC_RXSTAT_PROC] = cm_IoctlRxStatProcess;
+ smb_ioctlProcsp[VIOC_RXSTAT_PEER] = cm_IoctlRxStatPeer;
+}
/* called to make a fid structure into an IOCTL fid structure */
void smb_SetupIoctlFid(smb_fid_t *fidp, cm_space_t *prefix)
*/
void smb_IoctlPrepareWrite(smb_fid_t *fidp, smb_ioctl_t *ioctlp)
{
- /* make sure the buffer(s) are allocated */
- if (!ioctlp->inAllocp) ioctlp->inAllocp = malloc(SMB_IOCTL_MAXDATA);
- if (!ioctlp->outAllocp) ioctlp->outAllocp = malloc(SMB_IOCTL_MAXDATA);
-
- /* Fixes fs la problem. We do a StrToOEM later and if this data isn't initialized we get memory issues. */
- (void) memset(ioctlp->inAllocp, 0, SMB_IOCTL_MAXDATA);
- (void) memset(ioctlp->outAllocp, 0, SMB_IOCTL_MAXDATA);
-
- /* and make sure that we've reset our state for the new incoming request */
- if (!(ioctlp->flags & SMB_IOCTLFLAG_DATAIN)) {
- ioctlp->inCopied = 0;
- ioctlp->outCopied = 0;
- ioctlp->inDatap = ioctlp->inAllocp;
- ioctlp->outDatap = ioctlp->outAllocp;
- ioctlp->flags |= SMB_IOCTLFLAG_DATAIN;
- }
-}
+ /* make sure the buffer(s) are allocated */
+ if (!ioctlp->inAllocp) ioctlp->inAllocp = malloc(SMB_IOCTL_MAXDATA);
+ if (!ioctlp->outAllocp) ioctlp->outAllocp = malloc(SMB_IOCTL_MAXDATA);
+
+ /* Fixes fs la problem. We do a StrToOEM later and if this data isn't initialized we get memory issues. */
+ (void) memset(ioctlp->inAllocp, 0, SMB_IOCTL_MAXDATA);
+ (void) memset(ioctlp->outAllocp, 0, SMB_IOCTL_MAXDATA);
+
+ /* and make sure that we've reset our state for the new incoming request */
+ if (!(ioctlp->flags & SMB_IOCTLFLAG_DATAIN)) {
+ ioctlp->inCopied = 0;
+ ioctlp->outCopied = 0;
+ ioctlp->inDatap = ioctlp->inAllocp;
+ ioctlp->outDatap = ioctlp->outAllocp;
+ ioctlp->flags |= SMB_IOCTLFLAG_DATAIN;
+ }
+}
/* called from smb_ReceiveCoreRead when we receive a read on the ioctl fid */
long smb_IoctlRead(smb_fid_t *fidp, smb_vc_t *vcp, smb_packet_t *inp,
- smb_packet_t *outp)
+ smb_packet_t *outp)
{
- smb_ioctl_t *iop;
- long count;
- long leftToCopy;
- char *op;
- long code;
- cm_user_t *userp;
-
- iop = fidp->ioctlp;
- count = smb_GetSMBParm(inp, 1);
- userp = smb_GetUser(vcp, inp);
-
- /* Identify tree */
+ smb_ioctl_t *iop;
+ long count;
+ long leftToCopy;
+ char *op;
+ long code;
+ cm_user_t *userp;
+
+ iop = fidp->ioctlp;
+ count = smb_GetSMBParm(inp, 1);
+ userp = smb_GetUser(vcp, inp);
+
+ /* Identify tree */
code = smb_LookupTIDPath(vcp, ((smb_t *)inp)->tid, &iop->tidPathp);
- if(code) {
+ if (code) {
cm_ReleaseUser(userp);
return CM_ERROR_NOSUCHPATH;
}
- /* turn the connection around, if required */
- code = smb_IoctlPrepareRead(fidp, iop, userp);
+ /* turn the connection around, if required */
+ code = smb_IoctlPrepareRead(fidp, iop, userp);
- if (code) {
- cm_ReleaseUser(userp);
- return code;
- }
+ if (code) {
+ cm_ReleaseUser(userp);
+ return code;
+ }
- leftToCopy = (iop->outDatap - iop->outAllocp) - iop->outCopied;
- if (count > leftToCopy) count = leftToCopy;
-
- /* now set the parms for a read of count bytes */
- smb_SetSMBParm(outp, 0, count);
- smb_SetSMBParm(outp, 1, 0);
- smb_SetSMBParm(outp, 2, 0);
- smb_SetSMBParm(outp, 3, 0);
- smb_SetSMBParm(outp, 4, 0);
-
- smb_SetSMBDataLength(outp, count+3);
-
- op = smb_GetSMBData(outp, NULL);
- *op++ = 1;
- *op++ = (char)(count & 0xff);
- *op++ = (char)((count >> 8) & 0xff);
-
- /* now copy the data into the response packet */
- memcpy(op, iop->outCopied + iop->outAllocp, count);
+ leftToCopy = (iop->outDatap - iop->outAllocp) - iop->outCopied;
+ if (count > leftToCopy) count = leftToCopy;
- /* and adjust the counters */
- iop->outCopied += count;
-
- cm_ReleaseUser(userp);
- smb_ReleaseFID(fidp);
+ /* now set the parms for a read of count bytes */
+ smb_SetSMBParm(outp, 0, count);
+ smb_SetSMBParm(outp, 1, 0);
+ smb_SetSMBParm(outp, 2, 0);
+ smb_SetSMBParm(outp, 3, 0);
+ smb_SetSMBParm(outp, 4, 0);
- return 0;
-}
+ smb_SetSMBDataLength(outp, count+3);
+
+ op = smb_GetSMBData(outp, NULL);
+ *op++ = 1;
+ *op++ = (char)(count & 0xff);
+ *op++ = (char)((count >> 8) & 0xff);
+
+ /* now copy the data into the response packet */
+ memcpy(op, iop->outCopied + iop->outAllocp, count);
+
+ /* and adjust the counters */
+ iop->outCopied += count;
+
+ cm_ReleaseUser(userp);
+ smb_ReleaseFID(fidp);
+
+ return 0;
+}
/* called from smb_ReceiveCoreWrite when we receive a write call on the IOCTL
* file descriptor.
*/
long smb_IoctlWrite(smb_fid_t *fidp, smb_vc_t *vcp, smb_packet_t *inp, smb_packet_t *outp)
{
- smb_ioctl_t *iop;
- long count;
- long code;
- char *op;
- int inDataBlockCount;
-
- code = 0;
- count = smb_GetSMBParm(inp, 1);
- iop = fidp->ioctlp;
-
- smb_IoctlPrepareWrite(fidp, iop);
+ smb_ioctl_t *iop;
+ long count;
+ long code;
+ char *op;
+ int inDataBlockCount;
- op = smb_GetSMBData(inp, NULL);
- op = smb_ParseDataBlock(op, NULL, &inDataBlockCount);
-
- if (count + iop->inCopied > SMB_IOCTL_MAXDATA) {
- code = CM_ERROR_TOOBIG;
- goto done;
- }
+ code = 0;
+ count = smb_GetSMBParm(inp, 1);
+ iop = fidp->ioctlp;
- /* copy data */
- memcpy(iop->inDatap + iop->inCopied, op, count);
+ smb_IoctlPrepareWrite(fidp, iop);
+
+ op = smb_GetSMBData(inp, NULL);
+ op = smb_ParseDataBlock(op, NULL, &inDataBlockCount);
+
+ if (count + iop->inCopied > SMB_IOCTL_MAXDATA) {
+ code = CM_ERROR_TOOBIG;
+ goto done;
+ }
- /* adjust counts */
- iop->inCopied += count;
+ /* copy data */
+ memcpy(iop->inDatap + iop->inCopied, op, count);
-done:
- /* return # of bytes written */
- if (code == 0) {
- smb_SetSMBParm(outp, 0, count);
- smb_SetSMBDataLength(outp, 0);
- }
+ /* adjust counts */
+ iop->inCopied += count;
- smb_ReleaseFID(fidp);
- return code;
+ done:
+ /* return # of bytes written */
+ if (code == 0) {
+ smb_SetSMBParm(outp, 0, count);
+ smb_SetSMBDataLength(outp, 0);
+ }
+
+ smb_ReleaseFID(fidp);
+ return code;
}
/* called from V3 read to handle IOCTL descriptor reads */
long smb_IoctlV3Read(smb_fid_t *fidp, smb_vc_t *vcp, smb_packet_t *inp, smb_packet_t *outp)
{
- smb_ioctl_t *iop;
+ smb_ioctl_t *iop;
long count;
long code;
long leftToCopy;
iop = fidp->ioctlp;
count = smb_GetSMBParm(inp, 5);
- userp = smb_GetUser(vcp, inp);
- osi_assert(userp != 0);
+ userp = smb_GetUser(vcp, inp);
+ osi_assert(userp != 0);
uidp = smb_FindUID(vcp, ((smb_t *)inp)->uid, 0);
iop->uidp = uidp;
- if (uidp && uidp->unp)
+ if (uidp && uidp->unp) {
osi_Log3(afsd_logp, "Ioctl uid %d user %x name %s",
- uidp->userID, userp,
- osi_LogSaveString(afsd_logp, uidp->unp->name));
- else {
+ uidp->userID, userp,
+ osi_LogSaveString(afsd_logp, uidp->unp->name));
+ } else {
if (uidp)
- osi_Log2(afsd_logp, "Ioctl uid %d user %x no name",
- uidp->userID, userp);
+ osi_Log2(afsd_logp, "Ioctl uid %d user %x no name",
+ uidp->userID, userp);
else
- osi_Log1(afsd_logp, "Ioctl no uid user %x no name",
- userp);
+ osi_Log1(afsd_logp, "Ioctl no uid user %x no name",
+ userp);
}
- code = smb_LookupTIDPath(vcp, ((smb_t *)inp)->tid, &iop->tidPathp);
- if(code) {
- smb_ReleaseUID(uidp);
+ code = smb_LookupTIDPath(vcp, ((smb_t *)inp)->tid, &iop->tidPathp);
+ if (code) {
+ if (uidp)
+ smb_ReleaseUID(uidp);
cm_ReleaseUser(userp);
smb_ReleaseFID(fidp);
return CM_ERROR_NOSUCHPATH;
}
- code = smb_IoctlPrepareRead(fidp, iop, userp);
+ code = smb_IoctlPrepareRead(fidp, iop, userp);
if (uidp) {
iop->uidp = 0;
smb_ReleaseUID(uidp);
}
if (code) {
- cm_ReleaseUser(userp);
+ cm_ReleaseUser(userp);
smb_ReleaseFID(fidp);
- return code;
+ return code;
}
- leftToCopy = (iop->outDatap - iop->outAllocp) - iop->outCopied;
+ leftToCopy = (iop->outDatap - iop->outAllocp) - iop->outCopied;
if (count > leftToCopy) count = leftToCopy;
- /* 0 and 1 are reserved for request chaining, were setup by our caller,
- * and will be further filled in after we return.
- */
- smb_SetSMBParm(outp, 2, 0); /* remaining bytes, for pipes */
- smb_SetSMBParm(outp, 3, 0); /* resvd */
- smb_SetSMBParm(outp, 4, 0); /* resvd */
- smb_SetSMBParm(outp, 5, count); /* # of bytes we're going to read */
- /* fill in #6 when we have all the parameters' space reserved */
- smb_SetSMBParm(outp, 7, 0); /* resv'd */
- smb_SetSMBParm(outp, 8, 0); /* resv'd */
- smb_SetSMBParm(outp, 9, 0); /* resv'd */
- smb_SetSMBParm(outp, 10, 0); /* resv'd */
- smb_SetSMBParm(outp, 11, 0); /* reserved */
-
- /* get op ptr after putting in the last parm, since otherwise we don't
- * know where the data really is.
- */
- op = smb_GetSMBData(outp, NULL);
-
- /* now fill in offset from start of SMB header to first data byte (to op) */
- smb_SetSMBParm(outp, 6, ((int) (op - outp->data)));
-
- /* set the packet data length the count of the # of bytes */
- smb_SetSMBDataLength(outp, count);
-
- /* now copy the data into the response packet */
- memcpy(op, iop->outCopied + iop->outAllocp, count);
-
- /* and adjust the counters */
- iop->outCopied += count;
-
- /* and cleanup things */
- cm_ReleaseUser(userp);
- smb_ReleaseFID(fidp);
+ /* 0 and 1 are reserved for request chaining, were setup by our caller,
+ * and will be further filled in after we return.
+ */
+ smb_SetSMBParm(outp, 2, 0); /* remaining bytes, for pipes */
+ smb_SetSMBParm(outp, 3, 0); /* resvd */
+ smb_SetSMBParm(outp, 4, 0); /* resvd */
+ smb_SetSMBParm(outp, 5, count); /* # of bytes we're going to read */
+ /* fill in #6 when we have all the parameters' space reserved */
+ smb_SetSMBParm(outp, 7, 0); /* resv'd */
+ smb_SetSMBParm(outp, 8, 0); /* resv'd */
+ smb_SetSMBParm(outp, 9, 0); /* resv'd */
+ smb_SetSMBParm(outp, 10, 0); /* resv'd */
+ smb_SetSMBParm(outp, 11, 0); /* reserved */
+
+ /* get op ptr after putting in the last parm, since otherwise we don't
+ * know where the data really is.
+ */
+ op = smb_GetSMBData(outp, NULL);
+
+ /* now fill in offset from start of SMB header to first data byte (to op) */
+ smb_SetSMBParm(outp, 6, ((int) (op - outp->data)));
+
+ /* set the packet data length the count of the # of bytes */
+ smb_SetSMBDataLength(outp, count);
+
+ /* now copy the data into the response packet */
+ memcpy(op, iop->outCopied + iop->outAllocp, count);
+
+ /* and adjust the counters */
+ iop->outCopied += count;
+
+ /* and cleanup things */
+ cm_ReleaseUser(userp);
+ smb_ReleaseFID(fidp);
- return 0;
+ return 0;
}
/* called from Read Raw to handle IOCTL descriptor reads */
#endif /* DJGPP */
)
{
- smb_ioctl_t *iop;
- long leftToCopy;
- NCB *ncbp;
- long code;
- cm_user_t *userp;
+ smb_ioctl_t *iop;
+ long leftToCopy;
+ NCB *ncbp;
+ long code;
+ cm_user_t *userp;
#ifdef DJGPP
- dos_ptr dos_ncb;
+ dos_ptr dos_ncb;
- if (rawBuf == 0)
- {
- osi_Log0(afsd_logp, "Failed to get raw buf for smb_IoctlReadRaw");
- return -1;
- }
+ if (rawBuf == 0)
+ {
+ osi_Log0(afsd_logp, "Failed to get raw buf for smb_IoctlReadRaw");
+ return -1;
+ }
#endif /* DJGPP */
- iop = fidp->ioctlp;
-
- userp = smb_GetUser(vcp, inp);
-
- {
- smb_user_t *uidp;
-
- uidp = smb_FindUID(vcp, ((smb_t *)inp)->uid, 0);
- if (uidp && uidp->unp)
- osi_Log3(afsd_logp, "Ioctl uid %d user %x name %s",
- uidp->userID, userp,
- osi_LogSaveString(afsd_logp, uidp->unp->name));
- else if (uidp)
- osi_Log2(afsd_logp, "Ioctl uid %d user %x no name",
- uidp->userID, userp);
- else
- osi_Log1(afsd_logp, "Ioctl no uid user %x no name",
- userp);
- if (uidp) smb_ReleaseUID(uidp);
+ iop = fidp->ioctlp;
+
+ userp = smb_GetUser(vcp, inp);
+
+ /* Log the user */
+ {
+ smb_user_t *uidp;
+
+ uidp = smb_FindUID(vcp, ((smb_t *)inp)->uid, 0);
+ if (uidp && uidp->unp) {
+ osi_Log3(afsd_logp, "Ioctl uid %d user %x name %s",
+ uidp->userID, userp,
+ osi_LogSaveString(afsd_logp, uidp->unp->name));
+ } else if (uidp) {
+ osi_Log2(afsd_logp, "Ioctl uid %d user %x no name",
+ uidp->userID, userp);
+ } else {
+ osi_Log1(afsd_logp, "Ioctl no uid user %x no name",
+ userp);
}
+ if (uidp)
+ smb_ReleaseUID(uidp);
+ }
code = smb_LookupTIDPath(vcp, ((smb_t *)inp)->tid, &iop->tidPathp);
if(code) {
return CM_ERROR_NOSUCHPATH;
}
- code = smb_IoctlPrepareRead(fidp, iop, userp);
- if (code) {
- cm_ReleaseUser(userp);
- smb_ReleaseFID(fidp);
- return code;
- }
+ code = smb_IoctlPrepareRead(fidp, iop, userp);
+ if (code) {
+ cm_ReleaseUser(userp);
+ smb_ReleaseFID(fidp);
+ return code;
+ }
- leftToCopy = (iop->outDatap - iop->outAllocp) - iop->outCopied;
+ leftToCopy = (iop->outDatap - iop->outAllocp) - iop->outCopied;
- ncbp = outp->ncbp;
- memset((char *)ncbp, 0, sizeof(NCB));
+ ncbp = outp->ncbp;
+ memset((char *)ncbp, 0, sizeof(NCB));
- ncbp->ncb_length = (unsigned short) leftToCopy;
- ncbp->ncb_lsn = (unsigned char) vcp->lsn;
- ncbp->ncb_command = NCBSEND;
+ ncbp->ncb_length = (unsigned short) leftToCopy;
+ ncbp->ncb_lsn = (unsigned char) vcp->lsn;
+ ncbp->ncb_command = NCBSEND;
/*ncbp->ncb_lana_num = smb_LANadapter;*/
- ncbp->ncb_lana_num = vcp->lana;
+ ncbp->ncb_lana_num = vcp->lana;
#ifndef DJGPP
- ncbp->ncb_buffer = iop->outCopied + iop->outAllocp;
- code = Netbios(ncbp);
+ ncbp->ncb_buffer = iop->outCopied + iop->outAllocp;
+ code = Netbios(ncbp);
#else /* DJGPP */
- dosmemput(iop->outCopied + iop->outAllocp, ncbp->ncb_length, rawBuf);
- ncbp->ncb_buffer = rawBuf;
- dos_ncb = ((smb_ncb_t *)ncbp)->dos_ncb;
- code = Netbios(ncbp, dos_ncb);
+ dosmemput(iop->outCopied + iop->outAllocp, ncbp->ncb_length, rawBuf);
+ ncbp->ncb_buffer = rawBuf;
+ dos_ncb = ((smb_ncb_t *)ncbp)->dos_ncb;
+ code = Netbios(ncbp, dos_ncb);
#endif /* !DJGPP */
- if (code != 0)
- osi_Log1(afsd_logp, "ReadRaw send failure code %d", code);
+ if (code != 0)
+ osi_Log1(afsd_logp, "ReadRaw send failure code %d", code);
- cm_ReleaseUser(userp);
- smb_ReleaseFID(fidp);
+ cm_ReleaseUser(userp);
+ smb_ReleaseFID(fidp);
- return 0;
+ return 0;
}
projects / packages / o / openafs.git / commitdiff