sin/samba-mirror
1
0
Fork 0
mirror of https://github.com/samba-team/samba.git synced 2025-02-26 21:57:41 +03:00
Code

Change the client library to write directly out of

Browse Source 
the incoming buffer in the non-signed case. Speeds
up writes by over 10% or so. Complete the server
recvfile implementation.
Jeremy.
(This used to be commit 81ca5853b2475f123faab3b550f0a7b24ae3c208)
This commit is contained in:
Jeremy Allison 2007-11-02 12:21:34 -07:00
parent f2a63dccab
commit 329365684b
6 changed files with 179 additions and 42 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

30
source3/client/client.c
View File

@ -3227,6 +3227,35 @@ static int cmd_show_connect( void )
return 0;
}
/****************************************************************************
iosize command
***************************************************************************/
int cmd_iosize(void)
{
fstring buf;
int iosize;
if (!next_token_nr(NULL,buf,NULL,sizeof(buf))) {
DEBUG(0, ("iosize <n> or iosize 0x<n>. "
"Minimum is 16384 (0x4000), "
"max is 16776960 (0xFFFF00)\n"));
return 1;
}
iosize = strtol(buf,NULL,0);
if (iosize < 0 || iosize > 0xFFFF00) {
DEBUG(0, ("iosize out of range (min = 16384 (0x4000), "
"max = 16776960 (0x0xFFFF00)"));
return 1;
}
io_bufsize = iosize;
d_printf("iosize is now %d\n", io_bufsize);
return 0;
}
/* Some constants for completing filename arguments */
#define COMPL_NONE 0 /* No completions */
@ -3265,6 +3294,7 @@ static struct
{"hardlink",cmd_hardlink,"<src> <dest> create a Windows hard link",{COMPL_REMOTE,COMPL_REMOTE}},
{"help",cmd_help,"[command] give help on a command",{COMPL_NONE,COMPL_NONE}},
{"history",cmd_history,"displays the command history",{COMPL_NONE,COMPL_NONE}},
{"iosize",cmd_iosize,"iosize <number> (default 64512)",{COMPL_NONE,COMPL_NONE}},
{"lcd",cmd_lcd,"[directory] change/report the local current working directory",{COMPL_LOCAL,COMPL_NONE}},
{"link",cmd_link,"<oldname> <newname> create a UNIX hard link",{COMPL_REMOTE,COMPL_REMOTE}},
{"lock",cmd_lock,"lock <fnum> [r|w] <hex-start> <hex-len> : set a POSIX lock",{COMPL_REMOTE,COMPL_REMOTE}},

1
source3/include/client.h
View File

@ -29,6 +29,7 @@
#define CLI_SAMBA_MAX_LARGE_READX_SIZE (127*1024) /* Works for Samba servers */
#define CLI_WINDOWS_MAX_LARGE_READX_SIZE ((64*1024)-2) /* Windows servers are broken.... */
#define CLI_SAMBA_MAX_POSIX_LARGE_READX_SIZE (0xFFFF00) /* 24-bit len. */
#define CLI_SAMBA_MAX_POSIX_LARGE_WRITEX_SIZE (0xFFFF00) /* 24-bit len. */
/*
* These definitions depend on smb.h

4
source3/include/smb_macros.h
View File

@ -193,8 +193,8 @@
buf[2] = (len&0xFF00)>>8; buf[3] = len&0xFF; } while (0)
#define smb_len_large(buf) (PVAL(buf,3)|(PVAL(buf,2)<<8)|(PVAL(buf,1)<<16))
#define _smb_setlen_large(buf,len) do { buf[0] = 0; buf[1] = (len&0xFF0000)>>16; \
buf[2] = (len&0xFF00)>>8; buf[3] = len&0xFF; } while (0)
#define _smb_setlen_large(buf,len) do { buf[0] = 0; buf[1] = ((len)&0xFF0000)>>16; \
buf[2] = ((len)&0xFF00)>>8; buf[3] = (len)&0xFF; } while (0)
/*******************************************************************
find the difference in milliseconds between two struct timeval

65
source3/libsmb/clientgen.c
View File

@ -251,15 +251,15 @@ bool cli_receive_smb_readX_header(struct cli_state *cli)
static ssize_t write_socket(int fd, const char *buf, size_t len)
{
ssize_t ret=0;
DEBUG(6,("write_socket(%d,%d)\n",fd,(int)len));
ret = write_data(fd,buf,len);
DEBUG(6,("write_socket(%d,%d) wrote %d\n",fd,(int)len,(int)ret));
if(ret <= 0)
DEBUG(0,("write_socket: Error writing %d bytes to socket %d: ERRNO = %s\n",
(int)len, fd, strerror(errno) ));
return(ret);
}
@ -300,6 +300,65 @@ bool cli_send_smb(struct cli_state *cli)
return True;
}
/****************************************************************************
Send a "direct" writeX smb to a fd.
****************************************************************************/
bool cli_send_smb_direct_writeX(struct cli_state *cli,
const char *p,
size_t extradata)
{
/* First length to send is the offset to the data. */
size_t len = SVAL(cli->outbuf,smb_vwv11) + 4;
size_t nwritten=0;
ssize_t ret;
/* fd == -1 causes segfaults -- Tom (tom@ninja.nl) */
if (cli->fd == -1) {
return false;
}
if (client_is_signing_on(cli)) {
DEBUG(0,("cli_send_smb_large: cannot send signed packet.\n"));
return false;
}
while (nwritten < len) {
ret = write_socket(cli->fd,cli->outbuf+nwritten,len - nwritten);
if (ret <= 0) {
close(cli->fd);
cli->fd = -1;
cli->smb_rw_error = WRITE_ERROR;
DEBUG(0,("Error writing %d bytes to client. %d (%s)\n",
(int)len,(int)ret, strerror(errno) ));
return false;
}
nwritten += ret;
}
/* Now write the extra data. */
nwritten=0;
while (nwritten < extradata) {
ret = write_socket(cli->fd,p+nwritten,extradata - nwritten);
if (ret <= 0) {
close(cli->fd);
cli->fd = -1;
cli->smb_rw_error = WRITE_ERROR;
DEBUG(0,("Error writing %d extradata "
"bytes to client. %d (%s)\n",
(int)extradata,(int)ret, strerror(errno) ));
return False;
}
nwritten += ret;
}
/* Increment the mid so we can tell between responses. */
cli->mid++;
if (!cli->mid)
cli->mid++;
return true;
}
/****************************************************************************
Setup basics in a outgoing packet.
****************************************************************************/

106
source3/libsmb/clireadwrite.c
View File

@ -1,18 +1,18 @@
/*
/*
Unix SMB/CIFS implementation.
client file read/write routines
Copyright (C) Andrew Tridgell 1994-1998
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
@ -23,7 +23,7 @@
Issue a single SMBread and don't wait for a reply.
****************************************************************************/
static bool cli_issue_read(struct cli_state *cli, int fnum, off_t offset,
static bool cli_issue_read(struct cli_state *cli, int fnum, off_t offset,
size_t size, int i)
{
bool bigoffset = False;
@ -31,11 +31,11 @@ static bool cli_issue_read(struct cli_state *cli, int fnum, off_t offset,
memset(cli->outbuf,'\0',smb_size);
memset(cli->inbuf,'\0',smb_size);
if ((SMB_BIG_UINT)offset >> 32)
if ((SMB_BIG_UINT)offset >> 32)
bigoffset = True;
set_message(cli->outbuf,bigoffset ? 12 : 10,0,True);
SCVAL(cli->outbuf,smb_com,SMBreadX);
SSVAL(cli->outbuf,smb_tid,cli->cnum);
cli_setup_packet(cli);
@ -68,7 +68,7 @@ ssize_t cli_read(struct cli_state *cli, int fnum, char *buf, off_t offset, size_
/* We can only do direct reads if not signing. */
bool direct_reads = !client_is_signing_on(cli);
if (size == 0)
if (size == 0)
return 0;
/*
@ -280,18 +280,25 @@ ssize_t cli_readraw(struct cli_state *cli, int fnum, char *buf, off_t offset, si
return total;
}
#endif
/****************************************************************************
issue a single SMBwrite and don't wait for a reply
Issue a single SMBwrite and don't wait for a reply.
****************************************************************************/
static bool cli_issue_write(struct cli_state *cli, int fnum, off_t offset,
uint16 mode, const char *buf,
size_t size, int i)
static bool cli_issue_write(struct cli_state *cli,
int fnum,
off_t offset,
uint16 mode,
const char *buf,
size_t size,
int i)
{
char *p;
bool large_writex = False;
bool large_writex = false;
/* We can only do direct writes if not signing. */
bool direct_writes = !client_is_signing_on(cli);
if (size + 1 > cli->bufsize) {
if (!direct_writes && size + 1 > cli->bufsize) {
cli->outbuf = (char *)SMB_REALLOC(cli->outbuf, size + 1024);
if (!cli->outbuf) {
return False;
@ -311,10 +318,11 @@ static bool cli_issue_write(struct cli_state *cli, int fnum, off_t offset,
large_writex = True;
}
if (large_writex)
if (large_writex) {
set_message(cli->outbuf,14,0,True);
else
} else {
set_message(cli->outbuf,12,0,True);
}
SCVAL(cli->outbuf,smb_com,SMBwriteX);
SSVAL(cli->outbuf,smb_tid,cli->cnum);
@ -334,7 +342,7 @@ static bool cli_issue_write(struct cli_state *cli, int fnum, off_t offset,
* locally. However, this check might already have been
* done by our callers.
*/
SSVAL(cli->outbuf,smb_vwv9,((size>>16)&1));
SSVAL(cli->outbuf,smb_vwv9,(size>>16));
SSVAL(cli->outbuf,smb_vwv10,size);
/* +1 is pad byte. */
SSVAL(cli->outbuf,smb_vwv11,
@ -346,13 +354,27 @@ static bool cli_issue_write(struct cli_state *cli, int fnum, off_t offset,
p = smb_base(cli->outbuf) + SVAL(cli->outbuf,smb_vwv11) -1;
*p++ = '\0'; /* pad byte. */
memcpy(p, buf, size);
cli_setup_bcc(cli, p+size);
if (!direct_writes) {
memcpy(p, buf, size);
}
if (size > 0x1FFFF) {
/* This is a POSIX 14 word large write. */
set_message_bcc(cli->outbuf, 0); /* Set bcc to zero. */
_smb_setlen_large(cli->outbuf,smb_size + 28 + 1 /* pad */ + size - 4);
} else {
cli_setup_bcc(cli, p+size);
}
SSVAL(cli->outbuf,smb_mid,cli->mid + i);
show_msg(cli->outbuf);
return cli_send_smb(cli);
if (direct_writes) {
/* For direct writes we now need to write the data
* directly out of buf. */
return cli_send_smb_direct_writeX(cli, buf, size);
} else {
return cli_send_smb(cli);
}
}
/****************************************************************************
@ -371,8 +393,8 @@ ssize_t cli_write(struct cli_state *cli,
unsigned int issued = 0;
unsigned int received = 0;
int mpx = 1;
int block = cli->max_xmit - (smb_size+32);
int blocks = (size + (block-1)) / block;
size_t writesize;
int blocks;
if(cli->max_mux > 1) {
mpx = cli->max_mux-1;
@ -380,11 +402,29 @@ ssize_t cli_write(struct cli_state *cli,
mpx = 1;
}
if (!client_is_signing_on(cli) &&
(cli->posix_capabilities & CIFS_UNIX_LARGE_WRITE_CAP) &&
(cli->capabilities & CAP_LARGE_FILES)) {
/* Only do massive writes if we can do them direct
* with no signing. */
writesize = CLI_SAMBA_MAX_POSIX_LARGE_WRITEX_SIZE;
} else if (cli->capabilities & CAP_LARGE_READX) {
if (cli->is_samba) {
writesize = CLI_SAMBA_MAX_LARGE_READX_SIZE;
} else {
writesize = CLI_WINDOWS_MAX_LARGE_READX_SIZE;
}
} else {
writesize = (cli->max_xmit - (smb_size+32)) & ~1023;
}
blocks = (size + (writesize-1)) / writesize;
while (received < blocks) {
while ((issued - received < mpx) && (issued < blocks)) {
ssize_t bsent = issued * block;
ssize_t size1 = MIN(block, size - bsent);
ssize_t bsent = issued * writesize;
ssize_t size1 = MIN(writesize, size - bsent);
if (!cli_issue_write(cli, fnum, offset + bsent,
write_mode,
@ -394,8 +434,9 @@ ssize_t cli_write(struct cli_state *cli,
issued++;
}
if (!cli_receive_smb(cli))
if (!cli_receive_smb(cli)) {
return bwritten;
}
received++;
@ -406,9 +447,10 @@ ssize_t cli_write(struct cli_state *cli,
bwritten += (((int)(SVAL(cli->inbuf, smb_vwv4)))<<16);
}
while (received < issued && cli_receive_smb(cli))
while (received < issued && cli_receive_smb(cli)) {
received++;
}
return bwritten;
}
@ -424,7 +466,7 @@ ssize_t cli_smbwrite(struct cli_state *cli,
do {
size_t size = MIN(size1, cli->max_xmit - 48);
memset(cli->outbuf,'\0',smb_size);
memset(cli->inbuf,'\0',smb_size);
@ -433,25 +475,25 @@ ssize_t cli_smbwrite(struct cli_state *cli,
SCVAL(cli->outbuf,smb_com,SMBwrite);
SSVAL(cli->outbuf,smb_tid,cli->cnum);
cli_setup_packet(cli);
SSVAL(cli->outbuf,smb_vwv0,fnum);
SSVAL(cli->outbuf,smb_vwv1,size);
SIVAL(cli->outbuf,smb_vwv2,offset);
SSVAL(cli->outbuf,smb_vwv4,0);
p = smb_buf(cli->outbuf);
*p++ = 1;
SSVAL(p, 0, size); p += 2;
memcpy(p, buf + total, size); p += size;
cli_setup_bcc(cli, p);
if (!cli_send_smb(cli))
return -1;
if (!cli_receive_smb(cli))
return -1;
if (cli_is_error(cli))
return -1;

15
source3/smbd/reply.c
View File

@ -3848,12 +3848,12 @@ void reply_write(connection_struct *conn, struct smb_request *req)
(2*14) + /* word count (including bcc) */ \
1 /* pad byte */)
bool is_valid_writeX_buffer(char *inbuf)
bool is_valid_writeX_buffer(const char *inbuf)
{
size_t numtowrite;
connection_struct *conn = NULL;
unsigned int doff = 0;
size_t len = smb_len(inbuf);
size_t len = smb_len_large(inbuf);
if (CVAL(inbuf,smb_com) != SMBwriteX ||
CVAL(inbuf,smb_vwv0) != 0xFF ||
@ -3867,14 +3867,19 @@ bool is_valid_writeX_buffer(char *inbuf)
if (IS_IPC(conn)) {
return false;
}
doff = SVAL(inbuf,smb_vwv11);
numtowrite = SVAL(inbuf,smb_vwv10);
numtowrite |= ((((size_t)SVAL(inbuf,smb_vwv9)) & 1 )<<16);
if (len > doff && len - doff > 0xFFFF) {
numtowrite |= (((size_t)SVAL(inbuf,smb_vwv9))<<16);
}
if (numtowrite == 0) {
return false;
}
/* Ensure the sizes match up. */
doff = SVAL(inbuf,smb_vwv11);
/* Ensure the sizes match up. */
if (doff < STANDARD_WRITE_AND_X_HEADER_SIZE) {
/* no pad byte...old smbclient :-( */
return false;