return;
}
- reply_outbuf(req, 2, 0);
+ reply_smb1_outbuf(req, 2, 0);
SSVAL(req->outbuf,smb_vwv0,xconn->smb1.negprot.max_recv);
SSVAL(req->outbuf,smb_vwv1,conn->cnum);
SSVAL(req->outbuf,smb_tid,conn->cnum);
server_devicetype = "A:";
if (get_Protocol() < PROTOCOL_NT1) {
- reply_outbuf(req, 2, 0);
+ reply_smb1_outbuf(req, 2, 0);
if (message_push_string(&req->outbuf, server_devicetype,
STR_TERMINATE|STR_ASCII) == -1) {
reply_nterror(req, NT_STATUS_NO_MEMORY);
uint32_t perm1 = 0;
uint32_t perm2 = 0;
- reply_outbuf(req, 7, 0);
+ reply_smb1_outbuf(req, 7, 0);
if (IS_IPC(conn)) {
perm1 = FILE_ALL_ACCESS;
SIVAL(req->outbuf, smb_vwv3, perm1);
SIVAL(req->outbuf, smb_vwv5, perm2);
} else {
- reply_outbuf(req, 3, 0);
+ reply_smb1_outbuf(req, 3, 0);
}
if ((message_push_string(&req->outbuf, server_devicetype,
return;
}
- reply_outbuf(req, 8, replysize+1);
+ reply_smb1_outbuf(req, 8, replysize+1);
SSVAL(req->outbuf,smb_vwv1,replysize); /* Total data bytes returned */
SSVAL(req->outbuf,smb_vwv5,replysize); /* Data bytes this buffer */
SSVAL(req->outbuf,smb_vwv6,52); /* Offset to data */
struct smb_filename *smb_fname = NULL;
char *name = NULL;
NTSTATUS status;
+ struct files_struct *dirfsp = NULL;
uint32_t ucf_flags = ucf_flags_from_smb_request(req);
+ NTTIME twrp = 0;
TALLOC_CTX *ctx = talloc_tos();
START_PROFILE(SMBcheckpath);
DEBUG(3,("reply_checkpath %s mode=%d\n", name, (int)SVAL(req->vwv+0, 0)));
- status = filename_convert(ctx,
- conn,
- name,
- ucf_flags,
- 0,
- &smb_fname);
-
+ if (ucf_flags & UCF_GMT_PATHNAME) {
+ extract_snapshot_token(name, &twrp);
+ }
+ status = filename_convert_dirfsp(ctx,
+ conn,
+ name,
+ ucf_flags,
+ twrp,
+ &dirfsp,
+ &smb_fname);
if (!NT_STATUS_IS_OK(status)) {
if (NT_STATUS_EQUAL(status,NT_STATUS_PATH_NOT_COVERED)) {
reply_botherror(req, NT_STATUS_PATH_NOT_COVERED,
goto out;
}
- reply_outbuf(req, 0, 0);
+ reply_smb1_outbuf(req, 0, 0);
path_err:
/* We special case this - as when a Windows machine
goto out;
}
- /* dos smetimes asks for a stat of "" - it returns a "hidden directory"
- under WfWg - weird! */
+ /*
+ * dos sometimes asks for a stat of "" - it returns a "hidden
+ * directory" under WfWg - weird!
+ */
if (*fname == '\0') {
mode = FILE_ATTRIBUTE_HIDDEN | FILE_ATTRIBUTE_DIRECTORY;
if (!CAN_WRITE(conn)) {
}
}
- reply_outbuf(req, 10, 0);
+ reply_smb1_outbuf(req, 10, 0);
SSVAL(req->outbuf,smb_vwv0,mode);
if(lp_dos_filetime_resolution(SNUM(conn)) ) {
goto out;
}
- reply_outbuf(req, 0, 0);
+ reply_smb1_outbuf(req, 0, 0);
DEBUG(3, ("setatr name=%s mode=%d\n", smb_fname_str_dbg(smb_fname),
mode));
}
}
- reply_outbuf(req, 5, 0);
+ reply_smb1_outbuf(req, 5, 0);
if (get_Protocol() <= PROTOCOL_LANMAN2) {
double total_space, free_space;
expect_close = True;
}
- reply_outbuf(req, 1, 3);
+ reply_smb1_outbuf(req, 1, 3);
maxentries = SVAL(req->vwv+0, 0);
dirtype = SVAL(req->vwv+1, 0);
p = (const char *)req->buf + 1;
nt_status = SMB_VFS_CREATE_FILE(
conn, /* conn */
req, /* req */
+ NULL, /* dirfsp */
smb_dname, /* dname */
FILE_LIST_DIRECTORY, /* access_mask */
FILE_SHARE_READ|
dptr_num = -1;
}
- reply_outbuf(req, 1, 0);
+ reply_smb1_outbuf(req, 1, 0);
SSVAL(req->outbuf,smb_vwv0,0);
DEBUG(3,("search close\n"));
off_t size = 0;
time_t mtime=0;
int info;
+ struct files_struct *dirfsp = NULL;
files_struct *fsp;
int oplock_request;
int deny_mode;
uint32_t private_flags = 0;
NTSTATUS status;
uint32_t ucf_flags;
+ NTTIME twrp = 0;
TALLOC_CTX *ctx = talloc_tos();
START_PROFILE(SMBopen);
ucf_flags = filename_create_ucf_flags(req, create_disposition);
- status = filename_convert(ctx,
- conn,
- fname,
- ucf_flags,
- 0,
- &smb_fname);
+ if (ucf_flags & UCF_GMT_PATHNAME) {
+ extract_snapshot_token(fname, &twrp);
+ }
+ status = filename_convert_dirfsp(ctx,
+ conn,
+ fname,
+ ucf_flags,
+ twrp,
+ &dirfsp,
+ &smb_fname);
if (!NT_STATUS_IS_OK(status)) {
if (NT_STATUS_EQUAL(status,NT_STATUS_PATH_NOT_COVERED)) {
reply_botherror(req,
status = SMB_VFS_CREATE_FILE(
conn, /* conn */
req, /* req */
+ dirfsp, /* dirfsp */
smb_fname, /* fname */
access_mask, /* access_mask */
share_mode, /* share_access */
goto out;
}
- reply_outbuf(req, 7, 0);
+ reply_smb1_outbuf(req, 7, 0);
SSVAL(req->outbuf,smb_vwv0,fsp->fnum);
SSVAL(req->outbuf,smb_vwv1,fattr);
if(lp_dos_filetime_resolution(SNUM(conn)) ) {
uint32_t fattr=0;
int mtime=0;
int smb_action = 0;
+ struct files_struct *dirfsp = NULL;
files_struct *fsp;
NTSTATUS status;
uint64_t allocation_size;
uint32_t create_options = 0;
uint32_t private_flags = 0;
uint32_t ucf_flags;
+ NTTIME twrp = 0;
TALLOC_CTX *ctx = talloc_tos();
START_PROFILE(SMBopenX);
ucf_flags = filename_create_ucf_flags(req, create_disposition);
- status = filename_convert(ctx,
- conn,
- fname,
- ucf_flags,
- 0,
- &smb_fname);
+ if (ucf_flags & UCF_GMT_PATHNAME) {
+ extract_snapshot_token(fname, &twrp);
+ }
+
+ status = filename_convert_dirfsp(ctx,
+ conn,
+ fname,
+ ucf_flags,
+ twrp,
+ &dirfsp,
+ &smb_fname);
if (!NT_STATUS_IS_OK(status)) {
if (NT_STATUS_EQUAL(status,NT_STATUS_PATH_NOT_COVERED)) {
reply_botherror(req,
status = SMB_VFS_CREATE_FILE(
conn, /* conn */
req, /* req */
+ dirfsp, /* dirfsp */
smb_fname, /* fname */
access_mask, /* access_mask */
share_mode, /* share_access */
*/
if (open_flags & EXTENDED_RESPONSE_REQUIRED) {
- reply_outbuf(req, 19, 0);
+ reply_smb1_outbuf(req, 19, 0);
} else {
- reply_outbuf(req, 15, 0);
+ reply_smb1_outbuf(req, 15, 0);
}
SSVAL(req->outbuf, smb_vwv0, 0xff); /* andx chain ends */
TALLOC_FREE(session);
- reply_outbuf(smb1req, 2, 0);
+ reply_smb1_outbuf(smb1req, 2, 0);
SSVAL(smb1req->outbuf, smb_vwv0, 0xff); /* andx chain ends */
SSVAL(smb1req->outbuf, smb_vwv1, 0); /* no andx offset */
char *fname = NULL;
uint32_t fattr = 0;
struct smb_file_time ft;
+ struct files_struct *dirfsp = NULL;
files_struct *fsp;
int oplock_request = 0;
NTSTATUS status;
uint32_t create_disposition;
uint32_t create_options = 0;
uint32_t ucf_flags;
+ NTTIME twrp = 0;
TALLOC_CTX *ctx = talloc_tos();
START_PROFILE(SMBcreate);
}
ucf_flags = filename_create_ucf_flags(req, create_disposition);
- status = filename_convert(ctx,
- conn,
- fname,
- ucf_flags,
- 0,
- &smb_fname);
+ if (ucf_flags & UCF_GMT_PATHNAME) {
+ extract_snapshot_token(fname, &twrp);
+ }
+
+ status = filename_convert_dirfsp(ctx,
+ conn,
+ fname,
+ ucf_flags,
+ twrp,
+ &dirfsp,
+ &smb_fname);
if (!NT_STATUS_IS_OK(status)) {
if (NT_STATUS_EQUAL(status,NT_STATUS_PATH_NOT_COVERED)) {
reply_botherror(req,
status = SMB_VFS_CREATE_FILE(
conn, /* conn */
req, /* req */
+ dirfsp, /* dirfsp */
smb_fname, /* fname */
access_mask, /* access_mask */
share_mode, /* share_access */
goto out;
}
- reply_outbuf(req, 1, 0);
+ reply_smb1_outbuf(req, 1, 0);
SSVAL(req->outbuf,smb_vwv0,fsp->fnum);
if (oplock_request && lp_fake_oplocks(SNUM(conn))) {
char *wire_name = NULL;
char *fname = NULL;
uint32_t fattr;
+ struct files_struct *dirfsp = NULL;
files_struct *fsp;
int oplock_request;
char *s;
NTSTATUS status;
int i;
uint32_t ucf_flags;
+ NTTIME twrp = 0;
TALLOC_CTX *ctx = talloc_tos();
START_PROFILE(SMBctemp);
}
ucf_flags = filename_create_ucf_flags(req, FILE_CREATE);
- status = filename_convert(ctx, conn,
- fname,
- ucf_flags,
- 0,
- &smb_fname);
+ if (ucf_flags & UCF_GMT_PATHNAME) {
+ extract_snapshot_token(fname, &twrp);
+ }
+ status = filename_convert_dirfsp(ctx,
+ conn,
+ fname,
+ ucf_flags,
+ twrp,
+ &dirfsp,
+ &smb_fname);
if (!NT_STATUS_IS_OK(status)) {
if (NT_STATUS_EQUAL(status,NT_STATUS_PATH_NOT_COVERED)) {
reply_botherror(req, NT_STATUS_PATH_NOT_COVERED,
status = SMB_VFS_CREATE_FILE(
conn, /* conn */
req, /* req */
+ dirfsp, /* dirfsp */
smb_fname, /* fname */
FILE_GENERIC_READ | FILE_GENERIC_WRITE, /* access_mask */
FILE_SHARE_READ | FILE_SHARE_WRITE, /* share_access */
if (NT_STATUS_EQUAL(status, NT_STATUS_OBJECT_NAME_COLLISION)) {
TALLOC_FREE(fname);
+ TALLOC_FREE(dirfsp);
TALLOC_FREE(smb_fname);
continue;
}
goto out;
}
- reply_outbuf(req, 1, 0);
+ reply_smb1_outbuf(req, 1, 0);
SSVAL(req->outbuf,smb_vwv0,fsp->fnum);
/* the returned filename is relative to the directory */
DEBUG(3,("reply_unlink : %s\n", smb_fname_str_dbg(smb_fname)));
- status = unlink_internals(conn, req, dirtype, smb_fname);
+ status = unlink_internals(conn, req, dirtype, NULL, smb_fname);
if (!NT_STATUS_IS_OK(status)) {
if (open_was_deferred(req->xconn, req->mid)) {
/* We have re-scheduled this call. */
goto out;
}
- reply_outbuf(req, 0, 0);
+ reply_smb1_outbuf(req, 0, 0);
out:
TALLOC_FREE(smb_fname);
END_PROFILE(SMBunlink);
/*
* However the requested READ size IS affected by max_send. Insanity.... JRA.
*/
- maxtoread = req->xconn->smb1.sessions.max_send - (smb_size + 5*2 + 3);
+ maxtoread = req->xconn->smb1.sessions.max_send - (MIN_SMB_SIZE + 5*2 + 3);
if (numtoread > maxtoread) {
DBG_WARNING("requested read size (%zu) is greater than "
numtoread = maxtoread;
}
- reply_outbuf(req, 5, numtoread + 3);
+ reply_smb1_outbuf(req, 5, numtoread + 3);
data = smb_buf(req->outbuf) + 3;
goto send;
}
- srv_set_message((char *)req->outbuf, 5, nread+3, False);
+ srv_smb1_set_message((char *)req->outbuf, 5, nread+3, False);
SSVAL(req->outbuf,smb_vwv0,nread);
SSVAL(req->outbuf,smb_vwv5,nread+3);
fsp_fnum_dbg(fsp), (int)numtoread, (int)nread));
send:
- ok = srv_send_smb(req->xconn,
+ ok = smb1_srv_send(req->xconn,
(char *)req->outbuf,
true,
req->seqnum+1,
IS_CONN_ENCRYPTED(req->conn),
NULL);
if (!ok) {
- exit_server_cleanly("reply_lock_done: srv_send_smb failed.");
+ exit_server_cleanly("reply_lock_done: smb1_srv_send failed.");
}
TALLOC_FREE(req);
END_PROFILE(SMBlockread);
/*
* The requested read size cannot be greater than max_send. JRA.
*/
- maxtoread = xconn->smb1.sessions.max_send - (smb_size + 5*2 + 3);
+ maxtoread = xconn->smb1.sessions.max_send - (MIN_SMB_SIZE + 5*2 + 3);
if (numtoread > maxtoread) {
DEBUG(0,("reply_read: requested read size (%u) is greater than maximum allowed (%u/%u). \
numtoread = maxtoread;
}
- reply_outbuf(req, 5, numtoread+3);
+ reply_smb1_outbuf(req, 5, numtoread+3);
data = smb_buf(req->outbuf) + 3;
goto out;
}
- srv_set_message((char *)req->outbuf, 5, nread+3, False);
+ srv_smb1_set_message((char *)req->outbuf, 5, nread+3, False);
SSVAL(req->outbuf,smb_vwv0,nread);
SSVAL(req->outbuf,smb_vwv5,nread+3);
{
size_t outsize;
- outsize = srv_set_message(outbuf,12,smb_maxcnt + 1 /* padding byte */,
+ outsize = srv_smb1_set_message(outbuf,12,smb_maxcnt + 1 /* padding byte */,
False);
memset(outbuf+smb_vwv0,'\0',24); /* valgrind init. */
header = data_blob_const(headerbuf, sizeof(headerbuf));
- construct_reply_common_req(req, (char *)headerbuf);
+ construct_smb1_reply_common_req(req, (char *)headerbuf);
setup_readX_header((char *)headerbuf, smb_maxcnt);
nread = SMB_VFS_SENDFILE(xconn->transport.sock, fsp, &header,
goto nosendfile_read;
}
- construct_reply_common_req(req, (char *)headerbuf);
+ construct_smb1_reply_common_req(req, (char *)headerbuf);
setup_readX_header((char *)headerbuf, smb_maxcnt);
/* Send out the header. */
nosendfile_read:
- reply_outbuf(req, 12, smb_maxcnt + 1 /* padding byte */);
+ reply_smb1_outbuf(req, 12, smb_maxcnt + 1 /* padding byte */);
SSVAL(req->outbuf, smb_vwv0, 0xff); /* andx chain ends */
SSVAL(req->outbuf, smb_vwv1, 0); /* no andx offset */
{
uint8_t *old_outbuf = req->outbuf;
- reply_outbuf(req, 1, 0);
+ reply_smb1_outbuf(req, 1, 0);
memcpy(req->outbuf, old_outbuf, smb_size);
TALLOC_FREE(old_outbuf);
* it to send more bytes */
memcpy(buf, req->inbuf, smb_size);
- srv_set_message(buf,get_Protocol()>PROTOCOL_COREPLUS?1:0,0,True);
+ srv_smb1_set_message(buf,get_Protocol()>PROTOCOL_COREPLUS?1:0,0,True);
SCVAL(buf,smb_com,SMBwritebraw);
SSVALS(buf,smb_vwv0,0xFFFF);
show_msg(buf);
- if (!srv_send_smb(req->xconn,
+ if (!smb1_srv_send(req->xconn,
buf,
false, 0, /* no signing */
IS_CONN_ENCRYPTED(conn),
&req->pcd)) {
- exit_server_cleanly("reply_writebraw: srv_send_smb "
+ exit_server_cleanly("reply_writebraw: smb1_srv_send "
"failed.");
}
}
/* Set up outbuf to return the correct size */
- reply_outbuf(req, 1, 0);
+ reply_smb1_outbuf(req, 1, 0);
if (numtowrite != 0) {
}
}
- reply_outbuf(req, 1, 0);
+ reply_smb1_outbuf(req, 1, 0);
SSVAL(req->outbuf,smb_vwv0,nwritten);
goto out;
}
- reply_outbuf(req, 1, 0);
+ reply_smb1_outbuf(req, 1, 0);
SSVAL(req->outbuf,smb_vwv0,nwritten);
goto out;
}
- reply_outbuf(req, 6, 0);
+ reply_smb1_outbuf(req, 6, 0);
SSVAL(req->outbuf, smb_vwv0, 0xff); /* andx chain ends */
SSVAL(req->outbuf, smb_vwv1, 0); /* no andx offset */
SSVAL(req->outbuf,smb_vwv2,nwritten);
fh_set_pos(fsp->fh, res);
- reply_outbuf(req, 2, 0);
+ reply_smb1_outbuf(req, 2, 0);
SIVAL(req->outbuf,smb_vwv0,res);
DEBUG(3,("lseek %s ofs=%.0f newpos = %.0f mode=%d\n",
}
}
- reply_outbuf(req, 0, 0);
+ reply_smb1_outbuf(req, 0, 0);
DEBUG(3,("flush\n"));
END_PROFILE(SMBflush);
close_file_free(NULL, &fsp, SHUTDOWN_CLOSE);
}
- reply_outbuf(smb1req, 0, 0);
+ reply_smb1_outbuf(smb1req, 0, 0);
/*
* The following call is needed to push the
* reply data back out the socket after async
return;
}
- reply_outbuf(smb1req, 0, 0);
+ reply_smb1_outbuf(smb1req, 0, 0);
END_PROFILE(SMBclose);
return;
}
status = close_file_free(smb1req, &state->fsp, NORMAL_CLOSE);
if (NT_STATUS_IS_OK(status)) {
- reply_outbuf(smb1req, 0, 0);
+ reply_smb1_outbuf(smb1req, 0, 0);
} else {
reply_nterror(smb1req, status);
}
goto out;
}
- reply_outbuf(req, 1, 0);
+ reply_smb1_outbuf(req, 1, 0);
SSVAL(req->outbuf,smb_vwv0,nwritten);
TALLOC_FREE(subreq);
if (NT_STATUS_IS_OK(status)) {
- reply_outbuf(req, 0, 0);
+ reply_smb1_outbuf(req, 0, 0);
} else {
reply_nterror(req, status);
}
- ok = srv_send_smb(req->xconn,
+ ok = smb1_srv_send(req->xconn,
(char *)req->outbuf,
true,
req->seqnum+1,
IS_CONN_ENCRYPTED(req->conn),
NULL);
if (!ok) {
- exit_server_cleanly("reply_lock_done: srv_send_smb failed.");
+ exit_server_cleanly("reply_lock_done: smb1_srv_send failed.");
}
TALLOC_FREE(req);
END_PROFILE(SMBlock);
lck.offset,
lck.count);
- reply_outbuf(req, 0, 0);
+ reply_smb1_outbuf(req, 0, 0);
END_PROFILE(SMBunlock);
return;
TALLOC_FREE(tcon);
- reply_outbuf(smb1req, 0, 0);
+ reply_smb1_outbuf(smb1req, 0, 0);
/*
* The following call is needed to push the
* reply data back out the socket after async
smb_reverb = SVAL(req->vwv+0, 0);
- reply_outbuf(req, 1, req->buflen);
+ reply_smb1_outbuf(req, 1, req->buflen);
/* copy any incoming data back out */
if (req->buflen > 0) {
SSVAL(req->outbuf,smb_vwv0,seq_num);
show_msg((char *)req->outbuf);
- if (!srv_send_smb(req->xconn,
+ if (!smb1_srv_send(req->xconn,
(char *)req->outbuf,
true, req->seqnum+1,
IS_CONN_ENCRYPTED(conn)||req->encrypted,
cur_pcd))
- exit_server_cleanly("reply_echo: srv_send_smb failed.");
+ exit_server_cleanly("reply_echo: smb1_srv_send failed.");
}
DEBUG(3,("echo %d times\n", smb_reverb));
return;
}
- reply_outbuf(req, 1, 0);
+ reply_smb1_outbuf(req, 1, 0);
SSVAL(req->outbuf,smb_vwv0,fsp->fnum);
DEBUG(3,("openprint fd=%d %s\n",
return;
}
- reply_outbuf(req, 0, 0);
+ reply_smb1_outbuf(req, 0, 0);
END_PROFILE(SMBsplclose);
return;
return;
}
- reply_outbuf(req, 2, 3);
+ reply_smb1_outbuf(req, 2, 3);
SSVAL(req->outbuf,smb_vwv0,0);
SSVAL(req->outbuf,smb_vwv1,0);
SCVAL(smb_buf(req->outbuf),0,1);
DEBUG(3, ("printwrite %s num=%d\n", fsp_fnum_dbg(fsp), numtowrite));
- reply_outbuf(req, 0, 0);
+ reply_smb1_outbuf(req, 0, 0);
END_PROFILE(SMBsplwr);
return;
goto out;
}
- reply_outbuf(req, 0, 0);
+ reply_smb1_outbuf(req, 0, 0);
DEBUG(3, ("mkdir %s\n", smb_dname->base_name));
out:
char *directory = NULL;
NTSTATUS status;
TALLOC_CTX *ctx = talloc_tos();
+ struct files_struct *dirfsp = NULL;
files_struct *fsp = NULL;
int info = 0;
+ NTTIME twrp = 0;
uint32_t ucf_flags = ucf_flags_from_smb_request(req);
START_PROFILE(SMBrmdir);
goto out;
}
- status = filename_convert(ctx, conn,
- directory,
- ucf_flags,
- 0,
- &smb_dname);
+ if (ucf_flags & UCF_GMT_PATHNAME) {
+ extract_snapshot_token(directory, &twrp);
+ }
+ status = filename_convert_dirfsp(ctx,
+ conn,
+ directory,
+ ucf_flags,
+ twrp,
+ &dirfsp,
+ &smb_dname);
if (!NT_STATUS_IS_OK(status)) {
if (NT_STATUS_EQUAL(status,NT_STATUS_PATH_NOT_COVERED)) {
reply_botherror(req, NT_STATUS_PATH_NOT_COVERED,
status = SMB_VFS_CREATE_FILE(
conn, /* conn */
req, /* req */
+ dirfsp, /* dirfsp */
smb_dname, /* fname */
DELETE_ACCESS, /* access_mask */
(FILE_SHARE_READ | FILE_SHARE_WRITE | /* share_access */
if (!NT_STATUS_IS_OK(status)) {
reply_nterror(req, status);
} else {
- reply_outbuf(req, 0, 0);
+ reply_smb1_outbuf(req, 0, 0);
}
DEBUG(3, ("rmdir %s\n", smb_fname_str_dbg(smb_dname)));
status = rename_internals(ctx,
conn,
req,
+ NULL, /* src_dirfsp */
smb_fname_src,
+ NULL, /* dst_dirfsp */
smb_fname_dst,
dst_original_lcomp,
attrs,
goto out;
}
- reply_outbuf(req, 0, 0);
+ reply_smb1_outbuf(req, 0, 0);
out:
TALLOC_FREE(smb_fname_src);
TALLOC_FREE(smb_fname_dst);
ulocks[0],
NT_STATUS_OK);
if (ok) {
- reply_outbuf(req, 2, 0);
+ reply_smb1_outbuf(req, 2, 0);
SSVAL(req->outbuf, smb_vwv0, 0xff);
SSVAL(req->outbuf, smb_vwv1, 0);
END_PROFILE(SMBlockingX);
if (num_locks == 0) {
/* See smbtorture3 lock11 test */
- reply_outbuf(req, 2, 0);
+ reply_smb1_outbuf(req, 2, 0);
/* andx chain ends */
SSVAL(req->outbuf, smb_vwv0, 0xff);
SSVAL(req->outbuf, smb_vwv1, 0);
return;
}
- reply_outbuf(req, 2, 0);
+ reply_smb1_outbuf(req, 2, 0);
SSVAL(req->outbuf, smb_vwv0, 0xff);
SSVAL(req->outbuf, smb_vwv1, 0);
END_PROFILE(SMBlockingX);
DBG_DEBUG("smbd_smb1_do_locks_recv returned %s\n", nt_errstr(status));
if (NT_STATUS_IS_OK(status)) {
- reply_outbuf(req, 2, 0);
+ reply_smb1_outbuf(req, 2, 0);
SSVAL(req->outbuf, smb_vwv0, 0xff); /* andx chain ends */
SSVAL(req->outbuf, smb_vwv1, 0); /* no andx offset */
} else {
reply_nterror(req, status);
}
- ok = srv_send_smb(req->xconn,
+ ok = smb1_srv_send(req->xconn,
(char *)req->outbuf,
true,
req->seqnum+1,
IS_CONN_ENCRYPTED(req->conn),
NULL);
if (!ok) {
- exit_server_cleanly("reply_lock_done: srv_send_smb failed.");
+ exit_server_cleanly("reply_lock_done: smb1_srv_send failed.");
}
TALLOC_FREE(req);
END_PROFILE(SMBlockingX);
ft.create_time = time_t_to_full_timespec(
srv_make_unix_date2(req->vwv+1));
- reply_outbuf(req, 0, 0);
+ reply_smb1_outbuf(req, 0, 0);
/*
* Patch from Ray Frush <frush@engr.colostate.edu>
* this.
*/
- reply_outbuf(req, 11, 0);
+ reply_smb1_outbuf(req, 11, 0);
create_ts = get_create_timespec(conn, fsp, fsp->fsp_name);
srv_put_dos_date2((char *)req->outbuf, smb_vwv0, create_ts.tv_sec);
}
}
- reply_outbuf(req, 0, 0);
+ reply_smb1_outbuf(req, 0, 0);
DEBUG(3,("SMBfindclose dptr_num = %d\n", dptr_num));
END_PROFILE(SMBfindclose);
return;
}
+
+/****************************************************************************
+ Reply to a SMBfindnclose (stop FINDNOTIFYFIRST directory search).
+****************************************************************************/
+
+void reply_findnclose(struct smb_request *req)
+{
+ int dptr_num;
+
+ START_PROFILE(SMBfindnclose);
+
+ if (req->wct < 1) {
+ reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
+ END_PROFILE(SMBfindnclose);
+ return;
+ }
+
+ dptr_num = SVAL(req->vwv+0, 0);
+
+ DEBUG(3,("reply_findnclose, dptr_num = %d\n", dptr_num));
+
+ /* We never give out valid handles for a
+ findnotifyfirst - so any dptr_num is ok here.
+ Just ignore it. */
+
+ reply_smb1_outbuf(req, 0, 0);
+
+ DEBUG(3,("SMB_findnclose dptr_num = %d\n", dptr_num));
+
+ END_PROFILE(SMBfindnclose);
+ return;
+}
git.samba.org / samba.git / blobdiff