static NTSTATUS cmd_write(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, const char **argv)
{
int fd, size, wsize;
if (argc != 3) {
printf("Usage: write <fd> <size>\n");
return NT_STATUS_OK;
}
/* some error checking should go here */
fd = atoi(argv[1]);
size = atoi(argv[2]);
if (vfs->data == NULL) {
printf("write: error=-1 (buffer empty, please populate it before writing)");
return NT_STATUS_UNSUCCESSFUL;
}
if (vfs->data_size < size) {
printf("write: error=-1 (buffer too small, please put some more data in)");
return NT_STATUS_UNSUCCESSFUL;
}
wsize = SMB_VFS_WRITE(vfs->files[fd], fd, vfs->data, size);
if (wsize == -1) {
printf("write: error=%d (%s)\n", errno, strerror(errno));
return NT_STATUS_UNSUCCESSFUL;
}
printf("write: ok\n");
return NT_STATUS_OK;
}
ssize_t vfs_write_data(struct smb_request *req,
files_struct *fsp,
const char *buffer,
size_t N)
{
size_t total=0;
ssize_t ret;
if (req && req->unread_bytes) {
SMB_ASSERT(req->unread_bytes == N);
/* VFS_RECVFILE must drain the socket
* before returning. */
req->unread_bytes = 0;
return SMB_VFS_RECVFILE(smbd_server_fd(),
fsp,
(SMB_OFF_T)-1,
N);
}
while (total < N) {
ret = SMB_VFS_WRITE(fsp, buffer + total, N - total);
if (ret == -1)
return -1;
if (ret == 0)
return total;
total += ret;
}
return (ssize_t)total;
}
static int strict_allocate_ftruncate(vfs_handle_struct *handle, files_struct *fsp, int fd, SMB_OFF_T len)
{
SMB_STRUCT_STAT st;
SMB_OFF_T currpos = SMB_VFS_LSEEK(fsp, fd, 0, SEEK_CUR);
unsigned char zero_space[4096];
SMB_OFF_T space_to_write;
if (currpos == -1)
return -1;
if (SMB_VFS_FSTAT(fsp, fd, &st) == -1)
return -1;
space_to_write = len - st.st_size;
#ifdef S_ISFIFO
if (S_ISFIFO(st.st_mode))
return 0;
#endif
if (st.st_size == len)
return 0;
/* Shrink - just ftruncate. */
if (st.st_size > len)
return sys_ftruncate(fd, len);
/* Write out the real space on disk. */
if (SMB_VFS_LSEEK(fsp, fd, st.st_size, SEEK_SET) != st.st_size)
return -1;
space_to_write = len - st.st_size;
memset(zero_space, '\0', sizeof(zero_space));
while ( space_to_write > 0) {
SMB_OFF_T retlen;
SMB_OFF_T current_len_to_write = MIN(sizeof(zero_space),space_to_write);
retlen = SMB_VFS_WRITE(fsp,fsp->fh->fd,(char *)zero_space,current_len_to_write);
if (retlen <= 0)
return -1;
space_to_write -= retlen;
}
/* Seek to where we were */
if (SMB_VFS_LSEEK(fsp, fd, currpos, SEEK_SET) != currpos)
return -1;
return 0;
}
ssize_t vfswrap_pwrite(vfs_handle_struct *handle, files_struct *fsp, int fd, const void *data,
size_t n, SMB_OFF_T offset)
{
ssize_t result;
#if defined(HAVE_PWRITE) || defined(HAVE_PRWITE64)
START_PROFILE_BYTES(syscall_pwrite, n);
result = sys_pwrite(fd, data, n, offset);
END_PROFILE(syscall_pwrite);
if (result == -1 && errno == ESPIPE) {
/* Maintain the fiction that pipes can be sought on. */
result = SMB_VFS_WRITE(fsp, fd, data, n);
}
#else /* HAVE_PWRITE */
SMB_OFF_T curr;
int lerrno;
curr = SMB_VFS_LSEEK(fsp, fd, 0, SEEK_CUR);
if (curr == -1) {
return -1;
}
if (SMB_VFS_LSEEK(fsp, fd, offset, SEEK_SET) == -1) {
return -1;
}
result = SMB_VFS_WRITE(fsp, fd, data, n);
lerrno = errno;
SMB_VFS_LSEEK(fsp, fd, curr, SEEK_SET);
errno = lerrno;
#endif /* HAVE_PWRITE */
return result;
}
ssize_t vfs_write_data(files_struct *fsp,const char *buffer,size_t N)
{
size_t total=0;
ssize_t ret;
while (total < N) {
ret = SMB_VFS_WRITE(fsp,fsp->fh->fd,buffer + total,N - total);
if (ret == -1)
return -1;
if (ret == 0)
return total;
total += ret;
}
return (ssize_t)total;
}
int vfswrap_ftruncate(vfs_handle_struct *handle, files_struct *fsp, int fd, SMB_OFF_T len)
{
int result = -1;
SMB_STRUCT_STAT st;
char c = 0;
SMB_OFF_T currpos;
START_PROFILE(syscall_ftruncate);
if (lp_strict_allocate(SNUM(fsp->conn))) {
result = strict_allocate_ftruncate(handle, fsp, fd, len);
END_PROFILE(syscall_ftruncate);
return result;
}
/* we used to just check HAVE_FTRUNCATE_EXTEND and only use
sys_ftruncate if the system supports it. Then I discovered that
you can have some filesystems that support ftruncate
expansion and some that don't! On Linux fat can't do
ftruncate extend but ext2 can. */
result = sys_ftruncate(fd, len);
if (result == 0)
goto done;
/* According to W. R. Stevens advanced UNIX prog. Pure 4.3 BSD cannot
extend a file with ftruncate. Provide alternate implementation
for this */
currpos = SMB_VFS_LSEEK(fsp, fd, 0, SEEK_CUR);
if (currpos == -1) {
goto done;
}
/* Do an fstat to see if the file is longer than the requested
size in which case the ftruncate above should have
succeeded or shorter, in which case seek to len - 1 and
write 1 byte of zero */
if (SMB_VFS_FSTAT(fsp, fd, &st) == -1) {
goto done;
}
#ifdef S_ISFIFO
if (S_ISFIFO(st.st_mode)) {
result = 0;
goto done;
}
#endif
if (st.st_size == len) {
result = 0;
goto done;
}
if (st.st_size > len) {
/* the sys_ftruncate should have worked */
goto done;
}
if (SMB_VFS_LSEEK(fsp, fd, len-1, SEEK_SET) != len -1)
goto done;
if (SMB_VFS_WRITE(fsp, fd, &c, 1)!=1)
goto done;
/* Seek to where we were */
if (SMB_VFS_LSEEK(fsp, fd, currpos, SEEK_SET) != currpos)
goto done;
result = 0;
done:
END_PROFILE(syscall_ftruncate);
return result;
}