Now that we always require a 64 bit off_t, we no longer need SMB_OFF_T.
Andrew Bartlett
Autobuild-User: Andrew Bartlett <abartlet@samba.org>
Autobuild-Date: Fri Apr 6 01:47:43 CEST 2012 on sn-devel-104
return -1;
}
-static ssize_t skel_pread(vfs_handle_struct *handle, files_struct *fsp, void *data, size_t n, SMB_OFF_T offset)
+static ssize_t skel_pread(vfs_handle_struct *handle, files_struct *fsp, void *data, size_t n, off_t offset)
{
errno = ENOSYS;
return -1;
return -1;
}
-static ssize_t skel_pwrite(vfs_handle_struct *handle, files_struct *fsp, const void *data, size_t n, SMB_OFF_T offset)
+static ssize_t skel_pwrite(vfs_handle_struct *handle, files_struct *fsp, const void *data, size_t n, off_t offset)
{
errno = ENOSYS;
return -1;
}
-static SMB_OFF_T skel_lseek(vfs_handle_struct *handle, files_struct *fsp, SMB_OFF_T offset, int whence)
+static off_t skel_lseek(vfs_handle_struct *handle, files_struct *fsp, off_t offset, int whence)
{
errno = ENOSYS;
- return (SMB_OFF_T)-1;
+ return (off_t)-1;
}
-static ssize_t skel_sendfile(vfs_handle_struct *handle, int tofd, files_struct *fromfsp, const DATA_BLOB *hdr, SMB_OFF_T offset, size_t n)
+static ssize_t skel_sendfile(vfs_handle_struct *handle, int tofd, files_struct *fromfsp, const DATA_BLOB *hdr, off_t offset, size_t n)
{
errno = ENOSYS;
return -1;
}
-static ssize_t skel_recvfile(vfs_handle_struct *handle, int fromfd, files_struct *tofsp, SMB_OFF_T offset, size_t n)
+static ssize_t skel_recvfile(vfs_handle_struct *handle, int fromfd, files_struct *tofsp, off_t offset, size_t n)
{
errno = ENOSYS;
return -1;
return -1;
}
-static int skel_ftruncate(vfs_handle_struct *handle, files_struct *fsp, SMB_OFF_T offset)
+static int skel_ftruncate(vfs_handle_struct *handle, files_struct *fsp, off_t offset)
{
errno = ENOSYS;
return -1;
static int skel_fallocate(vfs_handle_struct *handle, files_struct *fsp,
enum vfs_fallocate_mode mode,
- SMB_OFF_T offset, SMB_OFF_T len)
+ off_t offset, off_t len)
{
errno = ENOSYS;
return -1;
}
-static bool skel_lock(vfs_handle_struct *handle, files_struct *fsp, int op, SMB_OFF_T offset, SMB_OFF_T count, int type)
+static bool skel_lock(vfs_handle_struct *handle, files_struct *fsp, int op, off_t offset, off_t count, int type)
{
errno = ENOSYS;
return false;
return -1;
}
-static bool skel_getlock(vfs_handle_struct *handle, files_struct *fsp, SMB_OFF_T *poffset, SMB_OFF_T *pcount, int *ptype, pid_t *ppid)
+static bool skel_getlock(vfs_handle_struct *handle, files_struct *fsp, off_t *poffset, off_t *pcount, int *ptype, pid_t *ppid)
{
errno = ENOSYS;
return false;
return SMB_VFS_NEXT_READ(handle, fsp, data, n);
}
-static ssize_t skel_pread(vfs_handle_struct *handle, files_struct *fsp, void *data, size_t n, SMB_OFF_T offset)
+static ssize_t skel_pread(vfs_handle_struct *handle, files_struct *fsp, void *data, size_t n, off_t offset)
{
return SMB_VFS_NEXT_PREAD(handle, fsp, data, n, offset);
}
return SMB_VFS_NEXT_WRITE(handle, fsp, data, n);
}
-static ssize_t skel_pwrite(vfs_handle_struct *handle, files_struct *fsp, const void *data, size_t n, SMB_OFF_T offset)
+static ssize_t skel_pwrite(vfs_handle_struct *handle, files_struct *fsp, const void *data, size_t n, off_t offset)
{
return SMB_VFS_NEXT_PWRITE(handle, fsp, data, n, offset);
}
-static SMB_OFF_T skel_lseek(vfs_handle_struct *handle, files_struct *fsp, SMB_OFF_T offset, int whence)
+static off_t skel_lseek(vfs_handle_struct *handle, files_struct *fsp, off_t offset, int whence)
{
return SMB_VFS_NEXT_LSEEK(handle, fsp, offset, whence);
}
-static ssize_t skel_sendfile(vfs_handle_struct *handle, int tofd, files_struct *fromfsp, const DATA_BLOB *hdr, SMB_OFF_T offset, size_t n)
+static ssize_t skel_sendfile(vfs_handle_struct *handle, int tofd, files_struct *fromfsp, const DATA_BLOB *hdr, off_t offset, size_t n)
{
return SMB_VFS_NEXT_SENDFILE(handle, tofd, fromfsp, hdr, offset, n);
}
-static ssize_t skel_recvfile(vfs_handle_struct *handle, int fromfd, files_struct *tofsp, SMB_OFF_T offset, size_t n)
+static ssize_t skel_recvfile(vfs_handle_struct *handle, int fromfd, files_struct *tofsp, off_t offset, size_t n)
{
return SMB_VFS_NEXT_RECVFILE(handle, fromfd, tofsp, offset, n);
}
return SMB_VFS_NEXT_NTIMES(handle, smb_fname, ft);
}
-static int skel_ftruncate(vfs_handle_struct *handle, files_struct *fsp, SMB_OFF_T offset)
+static int skel_ftruncate(vfs_handle_struct *handle, files_struct *fsp, off_t offset)
{
return SMB_VFS_NEXT_FTRUNCATE(handle, fsp, offset);
}
static int skel_fallocate(vfs_handle_struct *handle, files_struct *fsp,
enum vfs_fallocate_mode mode,
- SMB_OFF_T offset,
- SMB_OFF_T len)
+ off_t offset,
+ off_t len)
{
return SMB_VFS_NEXT_FALLOCATE(handle, fsp, mode, offset, len);
}
-static bool skel_lock(vfs_handle_struct *handle, files_struct *fsp, int op, SMB_OFF_T offset, SMB_OFF_T count, int type)
+static bool skel_lock(vfs_handle_struct *handle, files_struct *fsp, int op, off_t offset, off_t count, int type)
{
return SMB_VFS_NEXT_LOCK(handle, fsp, op, offset, count, type);
}
return SMB_VFS_NEXT_LINUX_SETLEASE(handle, fsp, leasetype);
}
-static bool skel_getlock(vfs_handle_struct *handle, files_struct *fsp, SMB_OFF_T *poffset, SMB_OFF_T *pcount, int *ptype, pid_t *ppid)
+static bool skel_getlock(vfs_handle_struct *handle, files_struct *fsp, off_t *poffset, off_t *pcount, int *ptype, pid_t *ppid)
{
return SMB_VFS_NEXT_GETLOCK(handle, fsp, poffset, pcount, ptype, ppid);
}
struct push_state {
XFILE *f;
- SMB_OFF_T nread;
+ off_t nread;
};
static size_t push_source(uint8_t *buf, size_t n, void *priv)
bool newhandle = false;
struct timespec tp_start;
uint16 attr;
- SMB_OFF_T size;
+ off_t size;
off_t start = 0;
- SMB_OFF_T nread = 0;
+ off_t nread = 0;
int rc = 0;
struct cli_state *targetcli = NULL;
char *targetname = NULL;
{
fstring altname;
struct timespec b_time, a_time, m_time, c_time;
- SMB_OFF_T size;
+ off_t size;
uint16_t mode;
SMB_INO_T ino;
NTTIME tmp;
TALLOC_CTX *ctx = talloc_tos();
uint16_t fnum;
XFILE *f;
- SMB_OFF_T start = 0;
+ off_t start = 0;
int rc = 0;
struct timespec tp_start;
struct cli_state *targetcli;
typedef struct file_info_struct file_info2;
struct file_info_struct {
- SMB_OFF_T size;
+ off_t size;
uint16 mode;
uid_t uid;
gid_t gid;
#define INO_T_VAL(p, ofs) ((SMB_INO_T)(IVAL((p),(ofs))))
#endif
-#ifndef SMB_OFF_T
-# define SMB_OFF_T off_t
-#endif
-
/* TODO: remove this macros */
#define SBIG_UINT(p, ofs, v) SBVAL(p, ofs, v)
#define BIG_UINT(p, ofs) BVAL(p, ofs)
/* this should really be a 64 bit type if possible */
typedef uint64_t br_off;
-#define SMB_OFF_T_BITS (sizeof(SMB_OFF_T)*8)
+#define SMB_OFF_T_BITS (sizeof(off_t)*8)
/*
* Set the define that tells us if we can do 64 bit
#define SOFF_T(p, ofs, v) (SIVAL(p,ofs,(v)&0xFFFFFFFF), SIVAL(p,(ofs)+4,(v)>>32))
#define SOFF_T_R(p, ofs, v) (SIVAL(p,(ofs)+4,(v)&0xFFFFFFFF), SIVAL(p,ofs,(v)>>32))
-#define IVAL_TO_SMB_OFF_T(buf,off) ((SMB_OFF_T)(( ((uint64_t)(IVAL((buf),(off)))) & ((uint64_t)0xFFFFFFFF) )))
+#define IVAL_TO_SMB_OFF_T(buf,off) ((off_t)(( ((uint64_t)(IVAL((buf),(off)))) & ((uint64_t)0xFFFFFFFF) )))
#ifndef HAVE_BLKSIZE_T
/* This is mainly for HP/UX which defines st_blksize as long */
*/
typedef struct DOS_ATTR_DESC {
int mode;
- SMB_OFF_T size;
+ off_t size;
time_t create_time;
time_t access_time;
time_t write_time;
struct _SMBCFILE {
int cli_fd;
char *fname;
- SMB_OFF_T offset;
+ off_t offset;
struct _SMBCSRV *srv;
bool file;
struct smbc_dir_list *dir_list, *dir_end, *dir_next;
SMBCSRV *srv,
const char *path,
uint16 *mode,
- SMB_OFF_T *size,
+ off_t *size,
struct timespec *create_time_ts,
struct timespec *access_time_ts,
struct timespec *write_time_ts,
uint16_t current_vuid);
int print_spool_write(files_struct *fsp, const char *data, uint32_t size,
- SMB_OFF_T offset, uint32_t *written);
+ off_t offset, uint32_t *written);
void print_spool_end(files_struct *fsp, enum file_close_type close_type);
ssize_t sys_recvfile(int fromfd,
int tofd,
- SMB_OFF_T offset,
+ off_t offset,
size_t count);
ssize_t sys_recvfile(int fromfd,
int tofd,
- SMB_OFF_T offset,
+ off_t offset,
size_t count);
ssize_t drain_socket(int sockfd, size_t count);
/* The following definitions come from lib/sendfile.c */
-ssize_t sys_sendfile(int tofd, int fromfd, const DATA_BLOB *header, SMB_OFF_T offset, size_t count);
+ssize_t sys_sendfile(int tofd, int fromfd, const DATA_BLOB *header, off_t offset, size_t count);
/* The following definitions come from lib/server_mutex.c */
ssize_t sys_read(int fd, void *buf, size_t count);
ssize_t sys_write(int fd, const void *buf, size_t count);
ssize_t sys_writev(int fd, const struct iovec *iov, int iovcnt);
-ssize_t sys_pread(int fd, void *buf, size_t count, SMB_OFF_T off);
-ssize_t sys_pwrite(int fd, const void *buf, size_t count, SMB_OFF_T off);
+ssize_t sys_pread(int fd, void *buf, size_t count, off_t off);
+ssize_t sys_pwrite(int fd, const void *buf, size_t count, off_t off);
ssize_t sys_send(int s, const void *msg, size_t len, int flags);
ssize_t sys_recvfrom(int s, void *buf, size_t len, int flags, struct sockaddr *from, socklen_t *fromlen);
int sys_fcntl_ptr(int fd, int cmd, void *arg);
bool fake_dir_create_times);
int sys_lstat(const char *fname,SMB_STRUCT_STAT *sbuf,
bool fake_dir_create_times);
-int sys_posix_fallocate(int fd, SMB_OFF_T offset, SMB_OFF_T len);
-int sys_fallocate(int fd, enum vfs_fallocate_mode mode, SMB_OFF_T offset, SMB_OFF_T len);
+int sys_posix_fallocate(int fd, off_t offset, off_t len);
+int sys_fallocate(int fd, enum vfs_fallocate_mode mode, off_t offset, off_t len);
void kernel_flock(int fd, uint32 share_mode, uint32 access_mask);
DIR *sys_fdopendir(int fd);
int sys_mknod(const char *path, mode_t mode, SMB_DEV_T dev);
ssize_t message_push_blob(uint8 **outbuf, DATA_BLOB blob);
char *unix_clean_name(TALLOC_CTX *ctx, const char *s);
char *clean_name(TALLOC_CTX *ctx, const char *s);
-ssize_t write_data_at_offset(int fd, const char *buffer, size_t N, SMB_OFF_T pos);
+ssize_t write_data_at_offset(int fd, const char *buffer, size_t N, off_t pos);
int set_blocking(int fd, bool set);
NTSTATUS init_before_fork(void);
NTSTATUS reinit_after_fork(struct messaging_context *msg_ctx,
bool is_in_path(const char *name, name_compare_entry *namelist, bool case_sensitive);
void set_namearray(name_compare_entry **ppname_array, const char *namelist);
void free_namearray(name_compare_entry *name_array);
-bool fcntl_lock(int fd, int op, SMB_OFF_T offset, SMB_OFF_T count, int type);
-bool fcntl_getlock(int fd, SMB_OFF_T *poffset, SMB_OFF_T *pcount, int *ptype, pid_t *ppid);
+bool fcntl_lock(int fd, int op, off_t offset, off_t count, int type);
+bool fcntl_getlock(int fd, off_t *poffset, off_t *pcount, int *ptype, pid_t *ppid);
bool is_myname(const char *s);
void ra_lanman_string( const char *native_lanman );
const char *get_remote_arch_str(void);
#include "librpc/gen_ndr/security.h"
typedef struct write_cache {
- SMB_OFF_T file_size;
- SMB_OFF_T offset;
+ off_t file_size;
+ off_t offset;
size_t alloc_size;
size_t data_size;
char *data;
size_t ref_count;
int fd;
uint64_t position_information;
- SMB_OFF_T pos;
+ off_t pos;
uint32 private_options; /* NT Create options, but we only look at
* NTCREATEX_OPTIONS_PRIVATE_DENY_DOS and
* NTCREATEX_OPTIONS_PRIVATE_DENY_FCB and
*/
struct stream_struct {
- SMB_OFF_T size;
- SMB_OFF_T alloc_size;
+ off_t size;
+ off_t alloc_size;
char *name;
};
ssize_t (*read_fn)(void *, void *, size_t),
ssize_t (*write_fn)(void *, const void *, size_t));
-SMB_OFF_T transfer_file(int infd, int outfd, SMB_OFF_T n);
+off_t transfer_file(int infd, int outfd, off_t n);
#endif /* __TRANSFER_FILE_H__ */
/* Leave at 29 - not yet releases. Add fsctl. Richard Sharpe */
/* Leave at 29 - not yet released. add SMB_VFS_GET_DFS_REFERRAL() - metze */
/* Leave at 29 - not yet released. Remove l{list,get,set,remove}xattr - abartlet */
+/* Leave at 29 - not yet released. move to plain off_t - abartlet */
#define SMB_VFS_INTERFACE_VERSION 29
/*
int *pinfo);
int (*close_fn)(struct vfs_handle_struct *handle, struct files_struct *fsp);
ssize_t (*read_fn)(struct vfs_handle_struct *handle, struct files_struct *fsp, void *data, size_t n);
- ssize_t (*pread_fn)(struct vfs_handle_struct *handle, struct files_struct *fsp, void *data, size_t n, SMB_OFF_T offset);
+ ssize_t (*pread_fn)(struct vfs_handle_struct *handle, struct files_struct *fsp, void *data, size_t n, off_t offset);
ssize_t (*write_fn)(struct vfs_handle_struct *handle, struct files_struct *fsp, const void *data, size_t n);
- ssize_t (*pwrite_fn)(struct vfs_handle_struct *handle, struct files_struct *fsp, const void *data, size_t n, SMB_OFF_T offset);
- SMB_OFF_T (*lseek_fn)(struct vfs_handle_struct *handle, struct files_struct *fsp, SMB_OFF_T offset, int whence);
- ssize_t (*sendfile_fn)(struct vfs_handle_struct *handle, int tofd, files_struct *fromfsp, const DATA_BLOB *header, SMB_OFF_T offset, size_t count);
- ssize_t (*recvfile_fn)(struct vfs_handle_struct *handle, int fromfd, files_struct *tofsp, SMB_OFF_T offset, size_t count);
+ ssize_t (*pwrite_fn)(struct vfs_handle_struct *handle, struct files_struct *fsp, const void *data, size_t n, off_t offset);
+ off_t (*lseek_fn)(struct vfs_handle_struct *handle, struct files_struct *fsp, off_t offset, int whence);
+ ssize_t (*sendfile_fn)(struct vfs_handle_struct *handle, int tofd, files_struct *fromfsp, const DATA_BLOB *header, off_t offset, size_t count);
+ ssize_t (*recvfile_fn)(struct vfs_handle_struct *handle, int fromfd, files_struct *tofsp, off_t offset, size_t count);
int (*rename_fn)(struct vfs_handle_struct *handle,
const struct smb_filename *smb_fname_src,
const struct smb_filename *smb_fname_dst);
int (*ntimes_fn)(struct vfs_handle_struct *handle,
const struct smb_filename *smb_fname,
struct smb_file_time *ft);
- int (*ftruncate_fn)(struct vfs_handle_struct *handle, struct files_struct *fsp, SMB_OFF_T offset);
+ int (*ftruncate_fn)(struct vfs_handle_struct *handle, struct files_struct *fsp, off_t offset);
int (*fallocate_fn)(struct vfs_handle_struct *handle,
struct files_struct *fsp,
enum vfs_fallocate_mode mode,
- SMB_OFF_T offset,
- SMB_OFF_T len);
- bool (*lock_fn)(struct vfs_handle_struct *handle, struct files_struct *fsp, int op, SMB_OFF_T offset, SMB_OFF_T count, int type);
+ off_t offset,
+ off_t len);
+ bool (*lock_fn)(struct vfs_handle_struct *handle, struct files_struct *fsp, int op, off_t offset, off_t count, int type);
int (*kernel_flock_fn)(struct vfs_handle_struct *handle, struct files_struct *fsp,
uint32 share_mode, uint32_t access_mask);
int (*linux_setlease_fn)(struct vfs_handle_struct *handle, struct files_struct *fsp, int leasetype);
- bool (*getlock_fn)(struct vfs_handle_struct *handle, struct files_struct *fsp, SMB_OFF_T *poffset, SMB_OFF_T *pcount, int *ptype, pid_t *ppid);
+ bool (*getlock_fn)(struct vfs_handle_struct *handle, struct files_struct *fsp, off_t *poffset, off_t *pcount, int *ptype, pid_t *ppid);
int (*symlink_fn)(struct vfs_handle_struct *handle, const char *oldpath, const char *newpath);
int (*readlink_fn)(struct vfs_handle_struct *handle, const char *path, char *buf, size_t bufsiz);
int (*link_fn)(struct vfs_handle_struct *handle, const char *oldpath, const char *newpath);
struct files_struct *fsp, void *data, size_t n);
ssize_t smb_vfs_call_pread(struct vfs_handle_struct *handle,
struct files_struct *fsp, void *data, size_t n,
- SMB_OFF_T offset);
+ off_t offset);
ssize_t smb_vfs_call_write(struct vfs_handle_struct *handle,
struct files_struct *fsp, const void *data,
size_t n);
ssize_t smb_vfs_call_pwrite(struct vfs_handle_struct *handle,
struct files_struct *fsp, const void *data,
- size_t n, SMB_OFF_T offset);
-SMB_OFF_T smb_vfs_call_lseek(struct vfs_handle_struct *handle,
- struct files_struct *fsp, SMB_OFF_T offset,
+ size_t n, off_t offset);
+off_t smb_vfs_call_lseek(struct vfs_handle_struct *handle,
+ struct files_struct *fsp, off_t offset,
int whence);
ssize_t smb_vfs_call_sendfile(struct vfs_handle_struct *handle, int tofd,
files_struct *fromfsp, const DATA_BLOB *header,
- SMB_OFF_T offset, size_t count);
+ off_t offset, size_t count);
ssize_t smb_vfs_call_recvfile(struct vfs_handle_struct *handle, int fromfd,
- files_struct *tofsp, SMB_OFF_T offset,
+ files_struct *tofsp, off_t offset,
size_t count);
int smb_vfs_call_rename(struct vfs_handle_struct *handle,
const struct smb_filename *smb_fname_src,
const struct smb_filename *smb_fname,
struct smb_file_time *ft);
int smb_vfs_call_ftruncate(struct vfs_handle_struct *handle,
- struct files_struct *fsp, SMB_OFF_T offset);
+ struct files_struct *fsp, off_t offset);
int smb_vfs_call_fallocate(struct vfs_handle_struct *handle,
struct files_struct *fsp,
enum vfs_fallocate_mode mode,
- SMB_OFF_T offset,
- SMB_OFF_T len);
+ off_t offset,
+ off_t len);
bool smb_vfs_call_lock(struct vfs_handle_struct *handle,
- struct files_struct *fsp, int op, SMB_OFF_T offset,
- SMB_OFF_T count, int type);
+ struct files_struct *fsp, int op, off_t offset,
+ off_t count, int type);
int smb_vfs_call_kernel_flock(struct vfs_handle_struct *handle,
struct files_struct *fsp, uint32 share_mode,
uint32_t access_mask);
int smb_vfs_call_linux_setlease(struct vfs_handle_struct *handle,
struct files_struct *fsp, int leasetype);
bool smb_vfs_call_getlock(struct vfs_handle_struct *handle,
- struct files_struct *fsp, SMB_OFF_T *poffset,
- SMB_OFF_T *pcount, int *ptype, pid_t *ppid);
+ struct files_struct *fsp, off_t *poffset,
+ off_t *pcount, int *ptype, pid_t *ppid);
int smb_vfs_call_symlink(struct vfs_handle_struct *handle, const char *oldpath,
const char *newpath);
int smb_vfs_call_readlink(struct vfs_handle_struct *handle,
static ssize_t default_sys_recvfile(int fromfd,
int tofd,
- SMB_OFF_T offset,
+ off_t offset,
size_t count)
{
int saved_errno = 0;
return 0;
}
- if (tofd != -1 && offset != (SMB_OFF_T)-1) {
+ if (tofd != -1 && offset != (off_t)-1) {
if (lseek(tofd, offset, SEEK_SET) == -1) {
if (errno != ESPIPE) {
return -1;
ssize_t sys_recvfile(int fromfd,
int tofd,
- SMB_OFF_T offset,
+ off_t offset,
size_t count)
{
static int pipefd[2] = { -1, -1 };
ssize_t sys_recvfile(int fromfd,
int tofd,
- SMB_OFF_T offset,
+ off_t offset,
size_t count)
{
return default_sys_recvfile(fromfd, tofd, offset, count);
#define MSG_MORE 0x8000
#endif
-ssize_t sys_sendfile(int tofd, int fromfd, const DATA_BLOB *header, SMB_OFF_T offset, size_t count)
+ssize_t sys_sendfile(int tofd, int fromfd, const DATA_BLOB *header, off_t offset, size_t count)
{
size_t total=0;
ssize_t ret;
#define MSG_MORE 0x8000
#endif
-ssize_t sys_sendfile(int tofd, int fromfd, const DATA_BLOB *header, SMB_OFF_T offset, size_t count)
+ssize_t sys_sendfile(int tofd, int fromfd, const DATA_BLOB *header, off_t offset, size_t count)
{
size_t total=0;
ssize_t ret;
* and uses a normal read. JRA.
*/
- if ((sizeof(SMB_OFF_T) >= 8) && (offset + count > (SMB_OFF_T)0x7FFFFFFF)) {
+ if ((sizeof(off_t) >= 8) && (offset + count > (off_t)0x7FFFFFFF)) {
errno = ENOSYS;
return -1;
}
#include <sys/sendfile.h>
-ssize_t sys_sendfile(int tofd, int fromfd, const DATA_BLOB *header, SMB_OFF_T offset, size_t count)
+ssize_t sys_sendfile(int tofd, int fromfd, const DATA_BLOB *header, off_t offset, size_t count)
{
int sfvcnt;
size_t total, xferred;
#include <sys/socket.h>
#include <sys/uio.h>
-ssize_t sys_sendfile(int tofd, int fromfd, const DATA_BLOB *header, SMB_OFF_T offset, size_t count)
+ssize_t sys_sendfile(int tofd, int fromfd, const DATA_BLOB *header, off_t offset, size_t count)
{
size_t total=0;
struct iovec hdtrl[2];
#include <sys/socket.h>
#include <sys/uio.h>
-ssize_t sys_sendfile(int tofd, int fromfd, const DATA_BLOB *header, SMB_OFF_T offset, size_t count)
+ssize_t sys_sendfile(int tofd, int fromfd, const DATA_BLOB *header, off_t offset, size_t count)
{
size_t total=0;
struct sf_hdtr hdr;
total = count;
while (total + hdtrl.iov_len) {
- SMB_OFF_T nwritten;
+ off_t nwritten;
int ret;
/*
/* Contributed by William Jojo <jojowil@hvcc.edu> */
#include <sys/socket.h>
-ssize_t sys_sendfile(int tofd, int fromfd, const DATA_BLOB *header, SMB_OFF_T offset, size_t count)
+ssize_t sys_sendfile(int tofd, int fromfd, const DATA_BLOB *header, off_t offset, size_t count)
{
struct sf_parms hdtrl;
#else /* No sendfile implementation. Return error. */
-ssize_t sys_sendfile(int tofd, int fromfd, const DATA_BLOB *header, SMB_OFF_T offset, size_t count)
+ssize_t sys_sendfile(int tofd, int fromfd, const DATA_BLOB *header, off_t offset, size_t count)
{
/* No sendfile syscall. */
errno = ENOSYS;
********************************************************************/
#if defined(HAVE_PREAD)
-ssize_t sys_pread(int fd, void *buf, size_t count, SMB_OFF_T off)
+ssize_t sys_pread(int fd, void *buf, size_t count, off_t off)
{
ssize_t ret;
********************************************************************/
#if defined(HAVE_PWRITE)
-ssize_t sys_pwrite(int fd, const void *buf, size_t count, SMB_OFF_T off)
+ssize_t sys_pwrite(int fd, const void *buf, size_t count, off_t off)
{
ssize_t ret;
/*******************************************************************
An posix_fallocate() wrapper.
********************************************************************/
-int sys_posix_fallocate(int fd, SMB_OFF_T offset, SMB_OFF_T len)
+int sys_posix_fallocate(int fd, off_t offset, off_t len)
{
#if defined(HAVE_POSIX_FALLOCATE) && !defined(HAVE_BROKEN_POSIX_FALLOCATE)
return posix_fallocate(fd, offset, len);
#elif defined(F_RESVSP64)
/* this handles XFS on IRIX */
struct flock64 fl;
- SMB_OFF_T new_len = offset + len;
+ off_t new_len = offset + len;
int ret;
struct stat64 sbuf;
#include <linux/falloc.h>
#endif
-int sys_fallocate(int fd, enum vfs_fallocate_mode mode, SMB_OFF_T offset, SMB_OFF_T len)
+int sys_fallocate(int fd, enum vfs_fallocate_mode mode, off_t offset, off_t len)
{
#if defined(HAVE_LINUX_FALLOCATE64) || defined(HAVE_LINUX_FALLOCATE)
int lmode;
Write data into an fd at a given offset. Ignore seek errors.
********************************************************************/
-ssize_t write_data_at_offset(int fd, const char *buffer, size_t N, SMB_OFF_T pos)
+ssize_t write_data_at_offset(int fd, const char *buffer, size_t N, off_t pos)
{
size_t total=0;
ssize_t ret;
- if (pos == (SMB_OFF_T)-1) {
+ if (pos == (off_t)-1) {
return write_data(fd, buffer, N);
}
#if defined(HAVE_PWRITE) || defined(HAVE_PRWITE64)
F_UNLCK in *ptype if the region is unlocked). False if the call failed.
****************************************************************************/
-bool fcntl_getlock(int fd, SMB_OFF_T *poffset, SMB_OFF_T *pcount, int *ptype, pid_t *ppid)
+bool fcntl_getlock(int fd, off_t *poffset, off_t *pcount, int *ptype, pid_t *ppid)
{
struct flock lock;
int ret;
return sys_write(*fd, buf, len);
}
-SMB_OFF_T transfer_file(int infd, int outfd, SMB_OFF_T n)
+off_t transfer_file(int infd, int outfd, off_t n)
{
- return (SMB_OFF_T)transfer_file_internal(&infd, &outfd, (size_t)n,
+ return (off_t)transfer_file_internal(&infd, &outfd, (size_t)n,
sys_read_fn, sys_write_fn);
}
uint16_t vwv[1];
int zone_offset;
uint16_t attr;
- SMB_OFF_T size;
+ off_t size;
time_t change_time;
time_t access_time;
time_t write_time;
return;
}
- state->size = (SMB_OFF_T)IVAL(vwv+6,0);
+ state->size = (off_t)IVAL(vwv+6,0);
state->attr = SVAL(vwv+10,0);
state->change_time = make_unix_date2(vwv+0, state->zone_offset);
state->access_time = make_unix_date2(vwv+2, state->zone_offset);
NTSTATUS cli_getattrE_recv(struct tevent_req *req,
uint16_t *attr,
- SMB_OFF_T *size,
+ off_t *size,
time_t *change_time,
time_t *access_time,
time_t *write_time)
NTSTATUS cli_getattrE(struct cli_state *cli,
uint16_t fnum,
uint16_t *attr,
- SMB_OFF_T *size,
+ off_t *size,
time_t *change_time,
time_t *access_time,
time_t *write_time)
struct cli_getatr_state {
int zone_offset;
uint16_t attr;
- SMB_OFF_T size;
+ off_t size;
time_t write_time;
};
}
state->attr = SVAL(vwv+0,0);
- state->size = (SMB_OFF_T)IVAL(vwv+3,0);
+ state->size = (off_t)IVAL(vwv+3,0);
state->write_time = make_unix_date3(vwv+1, state->zone_offset);
tevent_req_done(req);
NTSTATUS cli_getatr_recv(struct tevent_req *req,
uint16_t *attr,
- SMB_OFF_T *size,
+ off_t *size,
time_t *write_time)
{
struct cli_getatr_state *state = tevent_req_data(
NTSTATUS cli_getatr(struct cli_state *cli,
const char *fname,
uint16_t *attr,
- SMB_OFF_T *size,
+ off_t *size,
time_t *write_time)
{
TALLOC_CTX *frame = talloc_stackframe();
time_t *change_time,
time_t *access_time,
time_t *write_time,
- SMB_OFF_T *size,
+ off_t *size,
uint16 *mode)
{
struct cli_qpathinfo1_state *state = tevent_req_data(
time_t *change_time,
time_t *access_time,
time_t *write_time,
- SMB_OFF_T *size,
+ off_t *size,
uint16 *mode)
{
TALLOC_CTX *frame = talloc_stackframe();
struct timespec *access_time,
struct timespec *write_time,
struct timespec *change_time,
- SMB_OFF_T *size, uint16 *mode,
+ off_t *size, uint16 *mode,
SMB_INO_T *ino)
{
struct cli_qpathinfo2_state *state = tevent_req_data(
struct timespec *access_time,
struct timespec *write_time,
struct timespec *change_time,
- SMB_OFF_T *size, uint16 *mode,
+ off_t *size, uint16 *mode,
SMB_INO_T *ino)
{
TALLOC_CTX *frame = talloc_stackframe();
****************************************************************************/
NTSTATUS cli_qfileinfo_basic(struct cli_state *cli, uint16_t fnum,
- uint16 *mode, SMB_OFF_T *size,
+ uint16 *mode, off_t *size,
struct timespec *create_time,
struct timespec *access_time,
struct timespec *write_time,
time_t *change_time,
time_t *access_time,
time_t *write_time,
- SMB_OFF_T *size,
+ off_t *size,
uint16 *mode);
NTSTATUS cli_qpathinfo1(struct cli_state *cli,
const char *fname,
time_t *change_time,
time_t *access_time,
time_t *write_time,
- SMB_OFF_T *size,
+ off_t *size,
uint16 *mode);
NTSTATUS cli_setpathinfo_basic(struct cli_state *cli, const char *fname,
time_t create_time,
struct timespec *access_time,
struct timespec *write_time,
struct timespec *change_time,
- SMB_OFF_T *size, uint16 *mode,
+ off_t *size, uint16 *mode,
SMB_INO_T *ino);
NTSTATUS cli_qpathinfo2(struct cli_state *cli, const char *fname,
struct timespec *create_time,
struct timespec *access_time,
struct timespec *write_time,
struct timespec *change_time,
- SMB_OFF_T *size, uint16 *mode,
+ off_t *size, uint16 *mode,
SMB_INO_T *ino);
struct tevent_req *cli_qpathinfo_streams_send(TALLOC_CTX *mem_ctx,
struct tevent_context *ev,
NTSTATUS cli_qfilename(struct cli_state *cli, uint16_t fnum,
TALLOC_CTX *mem_ctx, char **name);
NTSTATUS cli_qfileinfo_basic(struct cli_state *cli, uint16_t fnum,
- uint16 *mode, SMB_OFF_T *size,
+ uint16 *mode, off_t *size,
struct timespec *create_time,
struct timespec *access_time,
struct timespec *write_time,
struct cli_state *cli;
uint16_t fnum;
off_t start_offset;
- SMB_OFF_T size;
+ off_t size;
NTSTATUS (*sink)(char *buf, size_t n, void *priv);
void *priv;
/*
* For how many bytes did we send requests already?
*/
- SMB_OFF_T requested;
+ off_t requested;
/*
* Next request index to push into "sink". This walks around the "req"
* How many bytes did we push into "sink"?
*/
- SMB_OFF_T pushed;
+ off_t pushed;
};
static char *cli_pull_print(struct tevent_req *req, TALLOC_CTX *mem_ctx)
struct event_context *ev,
struct cli_state *cli,
uint16_t fnum, off_t start_offset,
- SMB_OFF_T size, size_t window_size,
+ off_t size, size_t window_size,
NTSTATUS (*sink)(char *buf, size_t n,
void *priv),
void *priv)
for (i=0; i<state->num_reqs; i++) {
struct cli_pull_subreq *subreq = &state->reqs[i];
- SMB_OFF_T size_left;
+ off_t size_left;
size_t request_thistime;
if (state->requested >= size) {
if (state->requested < state->size) {
struct tevent_req *new_req;
- SMB_OFF_T size_left;
+ off_t size_left;
size_t request_thistime;
size_left = state->size - state->requested;
tevent_req_done(req);
}
-NTSTATUS cli_pull_recv(struct tevent_req *req, SMB_OFF_T *received)
+NTSTATUS cli_pull_recv(struct tevent_req *req, off_t *received)
{
struct cli_pull_state *state = tevent_req_data(
req, struct cli_pull_state);
}
NTSTATUS cli_pull(struct cli_state *cli, uint16_t fnum,
- off_t start_offset, SMB_OFF_T size, size_t window_size,
+ off_t start_offset, off_t size, size_t window_size,
NTSTATUS (*sink)(char *buf, size_t n, void *priv),
- void *priv, SMB_OFF_T *received)
+ void *priv, off_t *received)
{
TALLOC_CTX *frame = talloc_stackframe();
struct event_context *ev;
size_t *nread)
{
NTSTATUS status;
- SMB_OFF_T ret;
+ off_t ret;
status = cli_pull(cli, fnum, offset, size, size,
cli_read_sink, &buf, &ret);
if (errno == EACCES) { /* Check if the file is a directory */
int saverr = errno;
- SMB_OFF_T size = 0;
+ off_t size = 0;
uint16 mode = 0;
struct timespec write_time_ts;
struct timespec access_time_ts;
SMBCSRV *srv,
const char *path,
uint16 *mode,
- SMB_OFF_T *size,
+ off_t *size,
struct timespec *create_time_ts,
struct timespec *access_time_ts,
struct timespec *write_time_ts,
off_t offset,
int whence)
{
- SMB_OFF_T size;
+ off_t size;
char *server = NULL, *share = NULL, *user = NULL, *password = NULL;
char *path = NULL;
char *targetpath = NULL;
targetcli, file->cli_fd, NULL,
&size, NULL, NULL, NULL, NULL,
NULL))) {
- SMB_OFF_T b_size = size;
+ off_t b_size = size;
if (!NT_STATUS_IS_OK(cli_getattrE(targetcli, file->cli_fd,
NULL, &b_size, NULL, NULL, NULL))) {
errno = EINVAL;
SMBCFILE *file,
off_t length)
{
- SMB_OFF_T size = length;
+ off_t size = length;
char *server = NULL;
char *share = NULL;
char *user = NULL;
setup_stat(SMBCCTX *context,
struct stat *st,
const char *fname,
- SMB_OFF_T size,
+ off_t size,
int mode)
{
TALLOC_CTX *frame = talloc_stackframe();
struct timespec write_time_ts;
struct timespec access_time_ts;
struct timespec change_time_ts;
- SMB_OFF_T size = 0;
+ off_t size = 0;
uint16 mode = 0;
SMB_INO_T ino = 0;
TALLOC_CTX *frame = talloc_stackframe();
struct timespec change_time_ts;
struct timespec access_time_ts;
struct timespec write_time_ts;
- SMB_OFF_T size;
+ off_t size;
uint16 mode;
char *server = NULL;
char *share = NULL;
struct timespec write_time_ts;
struct timespec access_time_ts;
struct timespec change_time_ts;
- SMB_OFF_T size = 0;
+ off_t size = 0;
uint16 mode = 0;
SMB_INO_T inode = 0;
DOS_ATTR_DESC *ret;
}
if (strncasecmp_m(tok, "SIZE:", 5) == 0) {
- dad->size = (SMB_OFF_T)atof(tok+5);
+ dad->size = (off_t)atof(tok+5);
continue;
}
time_t write_time = (time_t)0;
time_t access_time = (time_t)0;
time_t change_time = (time_t)0;
- SMB_OFF_T size = 0;
+ off_t size = 0;
uint16 mode = 0;
SMB_INO_T ino = 0;
struct cli_state *cli = srv->cli;
uint16_t fnum);
NTSTATUS cli_getattrE_recv(struct tevent_req *req,
uint16_t *attr,
- SMB_OFF_T *size,
+ off_t *size,
time_t *change_time,
time_t *access_time,
time_t *write_time);
NTSTATUS cli_getattrE(struct cli_state *cli,
uint16_t fnum,
uint16_t *attr,
- SMB_OFF_T *size,
+ off_t *size,
time_t *change_time,
time_t *access_time,
time_t *write_time);
const char *fname);
NTSTATUS cli_getatr_recv(struct tevent_req *req,
uint16_t *attr,
- SMB_OFF_T *size,
+ off_t *size,
time_t *write_time);
NTSTATUS cli_getatr(struct cli_state *cli,
const char *fname,
uint16_t *attr,
- SMB_OFF_T *size,
+ off_t *size,
time_t *write_time);
struct tevent_req *cli_setatr_send(TALLOC_CTX *mem_ctx,
struct event_context *ev,
struct event_context *ev,
struct cli_state *cli,
uint16_t fnum, off_t start_offset,
- SMB_OFF_T size, size_t window_size,
+ off_t size, size_t window_size,
NTSTATUS (*sink)(char *buf, size_t n,
void *priv),
void *priv);
-NTSTATUS cli_pull_recv(struct tevent_req *req, SMB_OFF_T *received);
+NTSTATUS cli_pull_recv(struct tevent_req *req, off_t *received);
NTSTATUS cli_pull(struct cli_state *cli, uint16_t fnum,
- off_t start_offset, SMB_OFF_T size, size_t window_size,
+ off_t start_offset, off_t size, size_t window_size,
NTSTATUS (*sink)(char *buf, size_t n, void *priv),
- void *priv, SMB_OFF_T *received);
+ void *priv, off_t *received);
NTSTATUS cli_read(struct cli_state *cli, uint16_t fnum,
char *buf, off_t offset, size_t size,
size_t *nread);
False if not.
****************************************************************************/
-static bool posix_lock_in_range(SMB_OFF_T *offset_out, SMB_OFF_T *count_out,
+static bool posix_lock_in_range(off_t *offset_out, off_t *count_out,
uint64_t u_offset, uint64_t u_count)
{
- SMB_OFF_T offset = (SMB_OFF_T)u_offset;
- SMB_OFF_T count = (SMB_OFF_T)u_count;
+ off_t offset = (off_t)u_offset;
+ off_t count = (off_t)u_count;
/*
* For the type of system we are, attempt to
- * find the maximum positive lock offset as an SMB_OFF_T.
+ * find the maximum positive lock offset as an off_t.
*/
#if defined(MAX_POSITIVE_LOCK_OFFSET) /* Some systems have arbitrary limits. */
- SMB_OFF_T max_positive_lock_offset = (MAX_POSITIVE_LOCK_OFFSET);
+ off_t max_positive_lock_offset = (MAX_POSITIVE_LOCK_OFFSET);
#else
/*
- * In this case SMB_OFF_T is 64 bits,
+ * In this case off_t is 64 bits,
* and the underlying system can handle 64 bit signed locks.
*/
- SMB_OFF_T mask2 = ((SMB_OFF_T)0x4) << (SMB_OFF_T_BITS-4);
- SMB_OFF_T mask = (mask2<<1);
- SMB_OFF_T max_positive_lock_offset = ~mask;
+ off_t mask2 = ((off_t)0x4) << (SMB_OFF_T_BITS-4);
+ off_t mask = (mask2<<1);
+ off_t max_positive_lock_offset = ~mask;
#endif
/*
* any Win32 locks of length zero. JRA.
*/
- if (count == (SMB_OFF_T)0) {
+ if (count == (off_t)0) {
DEBUG(10,("posix_lock_in_range: count = 0, ignoring.\n"));
return False;
}
}
bool smb_vfs_call_lock(struct vfs_handle_struct *handle,
- struct files_struct *fsp, int op, SMB_OFF_T offset,
- SMB_OFF_T count, int type)
+ struct files_struct *fsp, int op, off_t offset,
+ off_t count, int type)
{
VFS_FIND(lock);
return handle->fns->lock_fn(handle, fsp, op, offset, count, type);
broken NFS implementations.
****************************************************************************/
-static bool posix_fcntl_lock(files_struct *fsp, int op, SMB_OFF_T offset, SMB_OFF_T count, int type)
+static bool posix_fcntl_lock(files_struct *fsp, int op, off_t offset, off_t count, int type)
{
bool ret;
* 32 bit NFS mounted filesystems. Just ignore it.
*/
- if (offset & ~((SMB_OFF_T)0x7fffffff)) {
+ if (offset & ~((off_t)0x7fffffff)) {
DEBUG(0,("Offset greater than 31 bits. Returning success.\n"));
return True;
}
- if (count & ~((SMB_OFF_T)0x7fffffff)) {
+ if (count & ~((off_t)0x7fffffff)) {
/* 32 bit NFS file system, retry with smaller offset */
DEBUG(0,("Count greater than 31 bits - retrying with 31 bit truncated length.\n"));
errno = 0;
}
bool smb_vfs_call_getlock(struct vfs_handle_struct *handle,
- struct files_struct *fsp, SMB_OFF_T *poffset,
- SMB_OFF_T *pcount, int *ptype, pid_t *ppid)
+ struct files_struct *fsp, off_t *poffset,
+ off_t *pcount, int *ptype, pid_t *ppid)
{
VFS_FIND(getlock);
return handle->fns->getlock_fn(handle, fsp, poffset, pcount, ptype,
broken NFS implementations.
****************************************************************************/
-static bool posix_fcntl_getlock(files_struct *fsp, SMB_OFF_T *poffset, SMB_OFF_T *pcount, int *ptype)
+static bool posix_fcntl_getlock(files_struct *fsp, off_t *poffset, off_t *pcount, int *ptype)
{
pid_t pid;
bool ret;
* 32 bit NFS mounted filesystems. Just ignore it.
*/
- if (*poffset & ~((SMB_OFF_T)0x7fffffff)) {
+ if (*poffset & ~((off_t)0x7fffffff)) {
DEBUG(0,("Offset greater than 31 bits. Returning success.\n"));
return True;
}
- if (*pcount & ~((SMB_OFF_T)0x7fffffff)) {
+ if (*pcount & ~((off_t)0x7fffffff)) {
/* 32 bit NFS file system, retry with smaller offset */
DEBUG(0,("Count greater than 31 bits - retrying with 31 bit truncated length.\n"));
errno = 0;
enum brl_type *plock_type,
enum brl_flavour lock_flav)
{
- SMB_OFF_T offset;
- SMB_OFF_T count;
+ off_t offset;
+ off_t count;
int posix_lock_type = map_posix_lock_type(fsp,*plock_type);
DEBUG(10,("is_posix_locked: File %s, offset = %.0f, count = %.0f, "
struct lock_list {
struct lock_list *next;
struct lock_list *prev;
- SMB_OFF_T start;
- SMB_OFF_T size;
+ off_t start;
+ off_t size;
};
/****************************************************************************
int num_locks,
int *errno_ret)
{
- SMB_OFF_T offset;
- SMB_OFF_T count;
+ off_t offset;
+ off_t count;
int posix_lock_type = map_posix_lock_type(fsp,lock_type);
bool ret = True;
size_t lock_count;
const struct lock_struct *plocks,
int num_locks)
{
- SMB_OFF_T offset;
- SMB_OFF_T count;
+ off_t offset;
+ off_t count;
bool ret = True;
TALLOC_CTX *ul_ctx = NULL;
struct lock_list *ulist = NULL;
enum brl_type lock_type,
int *errno_ret)
{
- SMB_OFF_T offset;
- SMB_OFF_T count;
+ off_t offset;
+ off_t count;
int posix_lock_type = map_posix_lock_type(fsp,lock_type);
DEBUG(5,("set_posix_lock_posix_flavour: File %s, offset = %.0f, count "
int num_locks)
{
bool ret = True;
- SMB_OFF_T offset;
- SMB_OFF_T count;
+ off_t offset;
+ off_t count;
TALLOC_CTX *ul_ctx = NULL;
struct lock_list *ulist = NULL;
struct lock_list *ul = NULL;
int *granted_oplock);
ssize_t onefs_sys_sendfile(connection_struct *conn, int tofd, int fromfd,
- const DATA_BLOB *header, SMB_OFF_T offset,
+ const DATA_BLOB *header, off_t offset,
size_t count);
-ssize_t onefs_sys_recvfile(int fromfd, int tofd, SMB_OFF_T offset,
+ssize_t onefs_sys_recvfile(int fromfd, int tofd, off_t offset,
size_t count);
void init_stat_ex_from_onefs_stat(struct stat_ex *dst, const struct stat *src);
static bool add_one_stream(TALLOC_CTX *mem_ctx, unsigned int *num_streams,
struct stream_struct **streams,
- const char *name, SMB_OFF_T size,
- SMB_OFF_T alloc_size)
+ const char *name, off_t size,
+ off_t alloc_size)
{
struct stream_struct *tmp;
* FreeBSD based sendfile implementation that allows for atomic semantics.
*/
static ssize_t onefs_sys_do_sendfile(int tofd, int fromfd,
- const DATA_BLOB *header, SMB_OFF_T offset, size_t count, bool atomic)
+ const DATA_BLOB *header, off_t offset, size_t count, bool atomic)
{
size_t total=0;
struct sf_hdtr hdr;
total = count;
while (total + hdtrl.iov_len) {
- SMB_OFF_T nwritten;
+ off_t nwritten;
int ret;
/*
* Handles the subtleties of using sendfile with CIFS.
*/
ssize_t onefs_sys_sendfile(connection_struct *conn, int tofd, int fromfd,
- const DATA_BLOB *header, SMB_OFF_T offset,
+ const DATA_BLOB *header, off_t offset,
size_t count)
{
bool atomic = false;
* from the socket into the buffer, the spill buffer is then written with a
* standard pwrite.
*/
-ssize_t onefs_sys_recvfile(int fromfd, int tofd, SMB_OFF_T offset,
+ssize_t onefs_sys_recvfile(int fromfd, int tofd, off_t offset,
size_t count)
{
char *spill_buffer = NULL;
struct rw_cmd {
size_t n;
- SMB_OFF_T offset;
+ off_t offset;
bool read_cmd;
};
static bool prime_cache(
struct vfs_handle_struct * handle,
files_struct * fsp,
- SMB_OFF_T offset,
+ off_t offset,
size_t count)
{
- SMB_OFF_T * last;
+ off_t * last;
ssize_t nread;
- last = (SMB_OFF_T *)VFS_ADD_FSP_EXTENSION(handle, fsp, SMB_OFF_T, NULL);
+ last = (off_t *)VFS_ADD_FSP_EXTENSION(handle, fsp, off_t, NULL);
if (!last) {
return False;
}
int tofd,
files_struct * fromfsp,
const DATA_BLOB * header,
- SMB_OFF_T offset,
+ off_t offset,
size_t count)
{
if (g_readbuf && offset == 0) {
void * data,
size_t count)
{
- SMB_OFF_T offset;
+ off_t offset;
offset = SMB_VFS_LSEEK(fsp, 0, SEEK_CUR);
if (offset >= 0 && g_readbuf) {
files_struct * fsp,
void * data,
size_t count,
- SMB_OFF_T offset)
+ off_t offset)
{
if (g_readbuf) {
prime_cache(handle, fsp, offset, count);
struct commit_info
{
/* For chunk-based commits */
- SMB_OFF_T dbytes; /* Dirty (uncommitted) bytes */
- SMB_OFF_T dthresh; /* Dirty data threshold */
+ off_t dbytes; /* Dirty (uncommitted) bytes */
+ off_t dthresh; /* Dirty data threshold */
/* For commits on EOF */
enum eof_mode on_eof;
- SMB_OFF_T eof; /* Expected file size */
+ off_t eof; /* Expected file size */
};
static int commit_do(
static int commit(
struct vfs_handle_struct * handle,
files_struct * fsp,
- SMB_OFF_T offset,
+ off_t offset,
ssize_t last_write)
{
struct commit_info *c;
int flags,
mode_t mode)
{
- SMB_OFF_T dthresh;
+ off_t dthresh;
const char *eof_mode;
struct commit_info *c = NULL;
int fd;
files_struct * fsp,
const void * data,
size_t count,
- SMB_OFF_T offset)
+ off_t offset)
{
ssize_t ret;
static int commit_ftruncate(
vfs_handle_struct * handle,
files_struct * fsp,
- SMB_OFF_T len)
+ off_t len)
{
int result;
#include "smbprofile.h"
#define MODULE "crossrename"
-static SMB_OFF_T module_sizelimit;
+static off_t module_sizelimit;
static int crossrename_connect(
struct vfs_handle_struct * handle,
return ret;
}
- module_sizelimit = (SMB_OFF_T) lp_parm_int(SNUM(handle->conn),
+ module_sizelimit = (off_t) lp_parm_int(SNUM(handle->conn),
MODULE, "sizelimit", 20);
/* convert from MiB to byte: */
module_sizelimit *= 1048576;
}
static ssize_t vfswrap_pread(vfs_handle_struct *handle, files_struct *fsp, void *data,
- size_t n, SMB_OFF_T offset)
+ size_t n, off_t offset)
{
ssize_t result;
}
#else /* HAVE_PREAD */
- SMB_OFF_T curr;
+ off_t curr;
int lerrno;
curr = SMB_VFS_LSEEK(fsp, 0, SEEK_CUR);
}
static ssize_t vfswrap_pwrite(vfs_handle_struct *handle, files_struct *fsp, const void *data,
- size_t n, SMB_OFF_T offset)
+ size_t n, off_t offset)
{
ssize_t result;
}
#else /* HAVE_PWRITE */
- SMB_OFF_T curr;
+ off_t curr;
int lerrno;
curr = SMB_VFS_LSEEK(fsp, 0, SEEK_CUR);
return result;
}
-static SMB_OFF_T vfswrap_lseek(vfs_handle_struct *handle, files_struct *fsp, SMB_OFF_T offset, int whence)
+static off_t vfswrap_lseek(vfs_handle_struct *handle, files_struct *fsp, off_t offset, int whence)
{
- SMB_OFF_T result = 0;
+ off_t result = 0;
START_PROFILE(syscall_lseek);
}
static ssize_t vfswrap_sendfile(vfs_handle_struct *handle, int tofd, files_struct *fromfsp, const DATA_BLOB *hdr,
- SMB_OFF_T offset, size_t n)
+ off_t offset, size_t n)
{
ssize_t result;
static ssize_t vfswrap_recvfile(vfs_handle_struct *handle,
int fromfd,
files_struct *tofsp,
- SMB_OFF_T offset,
+ off_t offset,
size_t n)
{
ssize_t result;
allocate is set.
**********************************************************************/
-static int strict_allocate_ftruncate(vfs_handle_struct *handle, files_struct *fsp, SMB_OFF_T len)
+static int strict_allocate_ftruncate(vfs_handle_struct *handle, files_struct *fsp, off_t len)
{
- SMB_OFF_T space_to_write;
+ off_t space_to_write;
uint64_t space_avail;
uint64_t bsize,dfree,dsize;
int ret;
return 0;
}
-static int vfswrap_ftruncate(vfs_handle_struct *handle, files_struct *fsp, SMB_OFF_T len)
+static int vfswrap_ftruncate(vfs_handle_struct *handle, files_struct *fsp, off_t len)
{
int result = -1;
SMB_STRUCT_STAT *pst;
static int vfswrap_fallocate(vfs_handle_struct *handle,
files_struct *fsp,
enum vfs_fallocate_mode mode,
- SMB_OFF_T offset,
- SMB_OFF_T len)
+ off_t offset,
+ off_t len)
{
int result;
return result;
}
-static bool vfswrap_lock(vfs_handle_struct *handle, files_struct *fsp, int op, SMB_OFF_T offset, SMB_OFF_T count, int type)
+static bool vfswrap_lock(vfs_handle_struct *handle, files_struct *fsp, int op, off_t offset, off_t count, int type)
{
bool result;
return 0;
}
-static bool vfswrap_getlock(vfs_handle_struct *handle, files_struct *fsp, SMB_OFF_T *poffset, SMB_OFF_T *pcount, int *ptype, pid_t *ppid)
+static bool vfswrap_getlock(vfs_handle_struct *handle, files_struct *fsp, off_t *poffset, off_t *pcount, int *ptype, pid_t *ppid)
{
bool result;
}
static ssize_t smb_full_audit_pread(vfs_handle_struct *handle, files_struct *fsp,
- void *data, size_t n, SMB_OFF_T offset)
+ void *data, size_t n, off_t offset)
{
ssize_t result;
static ssize_t smb_full_audit_pwrite(vfs_handle_struct *handle, files_struct *fsp,
const void *data, size_t n,
- SMB_OFF_T offset)
+ off_t offset)
{
ssize_t result;
return result;
}
-static SMB_OFF_T smb_full_audit_lseek(vfs_handle_struct *handle, files_struct *fsp,
- SMB_OFF_T offset, int whence)
+static off_t smb_full_audit_lseek(vfs_handle_struct *handle, files_struct *fsp,
+ off_t offset, int whence)
{
ssize_t result;
static ssize_t smb_full_audit_sendfile(vfs_handle_struct *handle, int tofd,
files_struct *fromfsp,
- const DATA_BLOB *hdr, SMB_OFF_T offset,
+ const DATA_BLOB *hdr, off_t offset,
size_t n)
{
ssize_t result;
static ssize_t smb_full_audit_recvfile(vfs_handle_struct *handle, int fromfd,
files_struct *tofsp,
- SMB_OFF_T offset,
+ off_t offset,
size_t n)
{
ssize_t result;
}
static int smb_full_audit_ftruncate(vfs_handle_struct *handle, files_struct *fsp,
- SMB_OFF_T len)
+ off_t len)
{
int result;
static int smb_full_audit_fallocate(vfs_handle_struct *handle, files_struct *fsp,
enum vfs_fallocate_mode mode,
- SMB_OFF_T offset,
- SMB_OFF_T len)
+ off_t offset,
+ off_t len)
{
int result;
}
static bool smb_full_audit_lock(vfs_handle_struct *handle, files_struct *fsp,
- int op, SMB_OFF_T offset, SMB_OFF_T count, int type)
+ int op, off_t offset, off_t count, int type)
{
bool result;
}
static bool smb_full_audit_getlock(vfs_handle_struct *handle, files_struct *fsp,
- SMB_OFF_T *poffset, SMB_OFF_T *pcount, int *ptype, pid_t *ppid)
+ off_t *poffset, off_t *pcount, int *ptype, pid_t *ppid)
{
bool result;
static int vfs_gpfs_fallocate(struct vfs_handle_struct *handle,
struct files_struct *fsp, enum vfs_fallocate_mode mode,
- SMB_OFF_T offset, SMB_OFF_T len)
+ off_t offset, off_t len)
{
int ret;
struct gpfs_config_data *config;
}
static int vfs_gpfs_ftruncate(vfs_handle_struct *handle, files_struct *fsp,
- SMB_OFF_T len)
+ off_t len)
{
int result;
struct gpfs_config_data *config;
static ssize_t vfs_gpfs_sendfile(vfs_handle_struct *handle, int tofd,
files_struct *fsp, const DATA_BLOB *hdr,
- SMB_OFF_T offset, size_t n)
+ off_t offset, size_t n)
{
if ((fsp->fsp_name->st.vfs_private & GPFS_WINATTR_OFFLINE) != 0) {
errno = ENOSYS;
#include "vfs_gpfs.h"
static ssize_t vfs_gpfs_hsm_notify_pread(vfs_handle_struct *handle, files_struct *fsp,
- void *data, size_t n, SMB_OFF_T offset)
+ void *data, size_t n, off_t offset)
{
ssize_t ret;
static ssize_t vfs_gpfs_hsm_notify_pwrite(struct vfs_handle_struct *handle,
struct files_struct *fsp,
- const void *data, size_t n, SMB_OFF_T offset)
+ const void *data, size_t n, off_t offset)
{
ssize_t ret;
static ssize_t onefs_sendfile(vfs_handle_struct *handle, int tofd,
files_struct *fromfsp, const DATA_BLOB *header,
- SMB_OFF_T offset, size_t count)
+ off_t offset, size_t count)
{
ssize_t result;
}
static ssize_t onefs_recvfile(vfs_handle_struct *handle, int fromfd,
- files_struct *tofsp, SMB_OFF_T offset,
+ files_struct *tofsp, off_t offset,
size_t count)
{
ssize_t result;
#define MODULE "prealloc"
static int module_debug;
-static int preallocate_space(int fd, SMB_OFF_T size)
+static int preallocate_space(int fd, off_t size)
{
int err;
#ifndef HAVE_GPFS
* truncate calls specially.
*/
if ((flags & O_CREAT) || (flags & O_TRUNC)) {
- SMB_OFF_T * psize;
+ off_t * psize;
- psize = VFS_ADD_FSP_EXTENSION(handle, fsp, SMB_OFF_T, NULL);
+ psize = VFS_ADD_FSP_EXTENSION(handle, fsp, off_t, NULL);
if (psize == NULL || *psize == -1) {
return fd;
}
static int prealloc_ftruncate(vfs_handle_struct * handle,
files_struct * fsp,
- SMB_OFF_T offset)
+ off_t offset)
{
- SMB_OFF_T *psize;
+ off_t *psize;
int ret = SMB_VFS_NEXT_FTRUNCATE(handle, fsp, offset);
/* Maintain the allocated space even in the face of truncates. */
#endif
struct readahead_data {
- SMB_OFF_T off_bound;
- SMB_OFF_T len;
+ off_t off_bound;
+ off_t len;
bool didmsg;
};
int tofd,
files_struct *fromfsp,
const DATA_BLOB *header,
- SMB_OFF_T offset,
+ off_t offset,
size_t count)
{
struct readahead_data *rhd = (struct readahead_data *)handle->data;
files_struct *fsp,
void *data,
size_t count,
- SMB_OFF_T offset)
+ off_t offset)
{
struct readahead_data *rhd = (struct readahead_data *)handle->data;
return tmp_lp;
}
-static SMB_OFF_T recycle_maxsize(vfs_handle_struct *handle)
+static off_t recycle_maxsize(vfs_handle_struct *handle)
{
- SMB_OFF_T maxsize;
+ off_t maxsize;
maxsize = conv_str_size(lp_parm_const_string(SNUM(handle->conn),
"recycle", "maxsize", NULL));
return maxsize;
}
-static SMB_OFF_T recycle_minsize(vfs_handle_struct *handle)
+static off_t recycle_minsize(vfs_handle_struct *handle)
{
- SMB_OFF_T minsize;
+ off_t minsize;
minsize = conv_str_size(lp_parm_const_string(SNUM(handle->conn),
"recycle", "minsize", NULL));
* @param fname file name
* @return size in bytes
**/
-static SMB_OFF_T recycle_get_file_size(vfs_handle_struct *handle,
+static off_t recycle_get_file_size(vfs_handle_struct *handle,
const struct smb_filename *smb_fname)
{
struct smb_filename *smb_fname_tmp = NULL;
NTSTATUS status;
- SMB_OFF_T size;
+ off_t size;
status = copy_smb_filename(talloc_tos(), smb_fname, &smb_fname_tmp);
if (!NT_STATUS_IS_OK(status)) {
- size = (SMB_OFF_T)0;
+ size = (off_t)0;
goto out;
}
if (SMB_VFS_STAT(handle->conn, smb_fname_tmp) != 0) {
DEBUG(0,("recycle: stat for %s returned %s\n",
smb_fname_str_dbg(smb_fname_tmp), strerror(errno)));
- size = (SMB_OFF_T)0;
+ size = (off_t)0;
goto out;
}
const char *base;
char *repository = NULL;
int i = 1;
- SMB_OFF_T maxsize, minsize;
- SMB_OFF_T file_size; /* space_avail; */
+ off_t maxsize, minsize;
+ off_t file_size; /* space_avail; */
bool exist;
NTSTATUS status;
int rc = -1;
int tofd,
files_struct *fromfsp,
const DATA_BLOB *hdr,
- SMB_OFF_T offset,
+ off_t offset,
size_t n)
{
struct rw_data s_data;
static ssize_t smb_traffic_analyzer_recvfile(vfs_handle_struct *handle,
int fromfd,
files_struct *tofsp,
- SMB_OFF_T offset,
+ off_t offset,
size_t n)
{
struct rw_data s_data;
static ssize_t smb_traffic_analyzer_pread(vfs_handle_struct *handle, \
- files_struct *fsp, void *data, size_t n, SMB_OFF_T offset)
+ files_struct *fsp, void *data, size_t n, off_t offset)
{
struct rw_data s_data;
}
static ssize_t smb_traffic_analyzer_pwrite(vfs_handle_struct *handle, \
- files_struct *fsp, const void *data, size_t n, SMB_OFF_T offset)
+ files_struct *fsp, const void *data, size_t n, off_t offset)
{
struct rw_data s_data;
static bool add_one_stream(TALLOC_CTX *mem_ctx, unsigned int *num_streams,
struct stream_struct **streams,
- const char *name, SMB_OFF_T size,
- SMB_OFF_T alloc_size)
+ const char *name, off_t size,
+ off_t alloc_size)
{
struct stream_struct *tmp;
static bool add_one_stream(TALLOC_CTX *mem_ctx, unsigned int *num_streams,
struct stream_struct **streams,
- const char *name, SMB_OFF_T size,
- SMB_OFF_T alloc_size)
+ const char *name, off_t size,
+ off_t alloc_size)
{
struct stream_struct *tmp;
static ssize_t streams_xattr_pwrite(vfs_handle_struct *handle,
files_struct *fsp, const void *data,
- size_t n, SMB_OFF_T offset)
+ size_t n, off_t offset)
{
struct stream_io *sio =
(struct stream_io *)VFS_FETCH_FSP_EXTENSION(handle, fsp);
static ssize_t streams_xattr_pread(vfs_handle_struct *handle,
files_struct *fsp, void *data,
- size_t n, SMB_OFF_T offset)
+ size_t n, off_t offset)
{
struct stream_io *sio =
(struct stream_io *)VFS_FETCH_FSP_EXTENSION(handle, fsp);
static int streams_xattr_ftruncate(struct vfs_handle_struct *handle,
struct files_struct *fsp,
- SMB_OFF_T offset)
+ off_t offset)
{
int ret;
uint8 *tmp;
static int streams_xattr_fallocate(struct vfs_handle_struct *handle,
struct files_struct *fsp,
enum vfs_fallocate_mode mode,
- SMB_OFF_T offset,
- SMB_OFF_T len)
+ off_t offset,
+ off_t len)
{
struct stream_io *sio =
(struct stream_io *)VFS_FETCH_FSP_EXTENSION(handle, fsp);
static ssize_t smb_time_audit_pread(vfs_handle_struct *handle,
files_struct *fsp,
- void *data, size_t n, SMB_OFF_T offset)
+ void *data, size_t n, off_t offset)
{
ssize_t result;
struct timespec ts1,ts2;
static ssize_t smb_time_audit_pwrite(vfs_handle_struct *handle,
files_struct *fsp,
const void *data, size_t n,
- SMB_OFF_T offset)
+ off_t offset)
{
ssize_t result;
struct timespec ts1,ts2;
return result;
}
-static SMB_OFF_T smb_time_audit_lseek(vfs_handle_struct *handle,
+static off_t smb_time_audit_lseek(vfs_handle_struct *handle,
files_struct *fsp,
- SMB_OFF_T offset, int whence)
+ off_t offset, int whence)
{
- SMB_OFF_T result;
+ off_t result;
struct timespec ts1,ts2;
double timediff;
static ssize_t smb_time_audit_sendfile(vfs_handle_struct *handle, int tofd,
files_struct *fromfsp,
- const DATA_BLOB *hdr, SMB_OFF_T offset,
+ const DATA_BLOB *hdr, off_t offset,
size_t n)
{
ssize_t result;
static ssize_t smb_time_audit_recvfile(vfs_handle_struct *handle, int fromfd,
files_struct *tofsp,
- SMB_OFF_T offset,
+ off_t offset,
size_t n)
{
ssize_t result;
static int smb_time_audit_ftruncate(vfs_handle_struct *handle,
files_struct *fsp,
- SMB_OFF_T len)
+ off_t len)
{
int result;
struct timespec ts1,ts2;
static int smb_time_audit_fallocate(vfs_handle_struct *handle,
files_struct *fsp,
enum vfs_fallocate_mode mode,
- SMB_OFF_T offset,
- SMB_OFF_T len)
+ off_t offset,
+ off_t len)
{
int result;
struct timespec ts1,ts2;
}
static bool smb_time_audit_lock(vfs_handle_struct *handle, files_struct *fsp,
- int op, SMB_OFF_T offset, SMB_OFF_T count,
+ int op, off_t offset, off_t count,
int type)
{
bool result;
static bool smb_time_audit_getlock(vfs_handle_struct *handle,
files_struct *fsp,
- SMB_OFF_T *poffset, SMB_OFF_T *pcount,
+ off_t *poffset, off_t *pcount,
int *ptype, pid_t *ppid)
{
bool result;
}
static ssize_t tsmsm_sendfile(vfs_handle_struct *handle, int tofd, files_struct *fsp, const DATA_BLOB *hdr,
- SMB_OFF_T offset, size_t n)
+ off_t offset, size_t n)
{
bool file_offline = tsmsm_aio_force(handle, fsp);
/* We do overload pread to allow notification when file becomes online after offline status */
/* We don't intercept SMB_VFS_READ here because all file I/O now goes through SMB_VFS_PREAD instead */
static ssize_t tsmsm_pread(struct vfs_handle_struct *handle, struct files_struct *fsp,
- void *data, size_t n, SMB_OFF_T offset) {
+ void *data, size_t n, off_t offset) {
ssize_t result;
bool notify_online = tsmsm_aio_force(handle, fsp);
}
static ssize_t tsmsm_pwrite(struct vfs_handle_struct *handle, struct files_struct *fsp,
- const void *data, size_t n, SMB_OFF_T offset) {
+ const void *data, size_t n, off_t offset) {
ssize_t result;
bool notify_online = tsmsm_aio_force(handle, fsp);
int fd;
size_t new_entry_length;
char *new_entry;
- SMB_OFF_T offpos;
+ off_t offpos;
/* Open the smbpassword file - for update. */
fp = startsmbfilepwent(pfile, PWF_UPDATE, &smbpasswd_state->pw_file_lock_depth);
bool found_entry = False;
bool got_pass_last_set_time = False;
- SMB_OFF_T pwd_seekpos = 0;
+ off_t pwd_seekpos = 0;
int i;
int wr_len;
}
/* Skip OEM header (if any) and the DOS stub to start of Windows header */
- if (SMB_VFS_LSEEK(fsp, SVAL(buf,DOS_HEADER_LFANEW_OFFSET), SEEK_SET) == (SMB_OFF_T)-1) {
+ if (SMB_VFS_LSEEK(fsp, SVAL(buf,DOS_HEADER_LFANEW_OFFSET), SEEK_SET) == (off_t)-1) {
DEBUG(3,("get_file_version: File [%s] too short, errno = %d\n",
fname, errno));
/* Assume this isn't an error... the file just looks sort of like a PE/NE file */
/* Just skip over optional header to get to section table */
if (SMB_VFS_LSEEK(fsp,
SVAL(buf,PE_HEADER_OPTIONAL_HEADER_SIZE)-(NE_HEADER_SIZE-PE_HEADER_SIZE),
- SEEK_CUR) == (SMB_OFF_T)-1) {
+ SEEK_CUR) == (off_t)-1) {
DEBUG(3,("get_file_version: File [%s] Windows optional header too short, errno = %d\n",
fname, errno));
goto error_exit;
}
/* Seek to the start of the .rsrc section info */
- if (SMB_VFS_LSEEK(fsp, section_pos, SEEK_SET) == (SMB_OFF_T)-1) {
+ if (SMB_VFS_LSEEK(fsp, section_pos, SEEK_SET) == (off_t)-1) {
DEBUG(3,("get_file_version: PE file [%s] too short for section info, errno = %d\n",
fname, errno));
goto error_exit;
int print_spool_write(files_struct *fsp,
const char *data, uint32_t size,
- SMB_OFF_T offset, uint32_t *written)
+ off_t offset, uint32_t *written)
{
SMB_STRUCT_STAT st;
ssize_t n;
NTSTATUS schedule_aio_read_and_X(connection_struct *conn,
struct smb_request *smbreq,
- files_struct *fsp, SMB_OFF_T startpos,
+ files_struct *fsp, off_t startpos,
size_t smb_maxcnt)
{
struct aio_extra *aio_ex;
NTSTATUS schedule_aio_write_and_X(connection_struct *conn,
struct smb_request *smbreq,
files_struct *fsp, const char *data,
- SMB_OFF_T startpos,
+ off_t startpos,
size_t numtowrite)
{
struct aio_extra *aio_ex;
files_struct *fsp,
TALLOC_CTX *ctx,
DATA_BLOB *preadbuf,
- SMB_OFF_T startpos,
+ off_t startpos,
size_t smb_maxcnt)
{
struct aio_extra *aio_ex;
#else
NTSTATUS schedule_aio_read_and_X(connection_struct *conn,
struct smb_request *smbreq,
- files_struct *fsp, SMB_OFF_T startpos,
+ files_struct *fsp, off_t startpos,
size_t smb_maxcnt)
{
return NT_STATUS_RETRY;
NTSTATUS schedule_aio_write_and_X(connection_struct *conn,
struct smb_request *smbreq,
files_struct *fsp, const char *data,
- SMB_OFF_T startpos,
+ off_t startpos,
size_t numtowrite)
{
return NT_STATUS_RETRY;
files_struct *fsp,
TALLOC_CTX *ctx,
DATA_BLOB *preadbuf,
- SMB_OFF_T startpos,
+ off_t startpos,
size_t smb_maxcnt)
{
return NT_STATUS_RETRY;
goto out;
}
- if (transfer_file(tmp_fd,outfd,(SMB_OFF_T)st.st_ex_size) == (SMB_OFF_T)-1) {
+ if (transfer_file(tmp_fd,outfd,(off_t)st.st_ex_size) == (off_t)-1) {
int err = errno;
close(tmp_fd);
close(outfd);
char *buf,
const char *mask,
const char *fname,
- SMB_OFF_T size,
+ off_t size,
uint32 mode,
time_t date,
bool uc)
const char *mask,
uint32_t dirtype,
char **_fname,
- SMB_OFF_T *_size,
+ off_t *_size,
uint32_t *_mode,
struct timespec *_date,
bool check_descend,
#include "smbd/globals.h"
#include "smbprofile.h"
-static bool setup_write_cache(files_struct *, SMB_OFF_T);
+static bool setup_write_cache(files_struct *, off_t);
/****************************************************************************
Read from write cache if we can.
****************************************************************************/
-static bool read_from_write_cache(files_struct *fsp,char *data,SMB_OFF_T pos,size_t n)
+static bool read_from_write_cache(files_struct *fsp,char *data,off_t pos,size_t n)
{
write_cache *wcp = fsp->wcp;
Read from a file.
****************************************************************************/
-ssize_t read_file(files_struct *fsp,char *data,SMB_OFF_T pos,size_t n)
+ssize_t read_file(files_struct *fsp,char *data,off_t pos,size_t n)
{
ssize_t ret=0,readret;
static ssize_t real_write_file(struct smb_request *req,
files_struct *fsp,
const char *data,
- SMB_OFF_T pos,
+ off_t pos,
size_t n)
{
ssize_t ret;
ssize_t write_file(struct smb_request *req,
files_struct *fsp,
const char *data,
- SMB_OFF_T pos,
+ off_t pos,
size_t n)
{
write_cache *wcp = fsp->wcp;
Setup the write cache structure.
****************************************************************************/
-static bool setup_write_cache(files_struct *fsp, SMB_OFF_T file_size)
+static bool setup_write_cache(files_struct *fsp, off_t file_size)
{
ssize_t alloc_size = lp_write_cache_size(SNUM(fsp->conn));
write_cache *wcp;
Cope with a size change.
****************************************************************************/
-void set_filelen_write_cache(files_struct *fsp, SMB_OFF_T file_size)
+void set_filelen_write_cache(files_struct *fsp, off_t file_size)
{
if(fsp->wcp) {
/* The cache *must* have been flushed before we do this. */
/* Breakout the oplock request bits so we can set the
reply bits separately. */
uint32 fattr=0;
- SMB_OFF_T file_len = 0;
+ off_t file_len = 0;
int info = 0;
files_struct *fsp = NULL;
char *p = NULL;
char *data = *ppdata;
/* Breakout the oplock request bits so we can set the reply bits separately. */
uint32 fattr=0;
- SMB_OFF_T file_len = 0;
+ off_t file_len = 0;
int info = 0;
files_struct *fsp = NULL;
char *p = NULL;
files_struct *fsp1,*fsp2;
uint32 fattr;
int info;
- SMB_OFF_T ret=-1;
+ off_t ret=-1;
NTSTATUS status = NT_STATUS_OK;
char *parent;
file_set_dosmode(conn, smb_fname_dst, fattr, parent, false);
TALLOC_FREE(parent);
- if (ret < (SMB_OFF_T)smb_fname_src->st.st_ex_size) {
+ if (ret < (off_t)smb_fname_src->st.st_ex_size) {
status = NT_STATUS_DISK_FULL;
goto out;
}
NTSTATUS schedule_aio_read_and_X(connection_struct *conn,
struct smb_request *req,
- files_struct *fsp, SMB_OFF_T startpos,
+ files_struct *fsp, off_t startpos,
size_t smb_maxcnt);
NTSTATUS schedule_aio_write_and_X(connection_struct *conn,
struct smb_request *req,
files_struct *fsp, const char *data,
- SMB_OFF_T startpos,
+ off_t startpos,
size_t numtowrite);
NTSTATUS schedule_smb2_aio_read(connection_struct *conn,
struct smb_request *smbreq,
files_struct *fsp,
TALLOC_CTX *ctx,
DATA_BLOB *preadbuf,
- SMB_OFF_T startpos,
+ off_t startpos,
size_t smb_maxcnt);
NTSTATUS schedule_aio_smb2_write(connection_struct *conn,
struct smb_request *smbreq,
char *buf,
const char *mask,
const char *fname,
- SMB_OFF_T size,
+ off_t size,
uint32 mode,
time_t date,
bool uc);
const char *mask,
uint32 dirtype,
char **pp_fname_out,
- SMB_OFF_T *size,
+ off_t *size,
uint32 *mode,
struct timespec *date,
bool check_descend,
/* The following definitions come from smbd/fileio.c */
-ssize_t read_file(files_struct *fsp,char *data,SMB_OFF_T pos,size_t n);
+ssize_t read_file(files_struct *fsp,char *data,off_t pos,size_t n);
void update_write_time_handler(struct event_context *ctx,
struct timed_event *te,
struct timeval now,
ssize_t write_file(struct smb_request *req,
files_struct *fsp,
const char *data,
- SMB_OFF_T pos,
+ off_t pos,
size_t n);
void delete_write_cache(files_struct *fsp);
-void set_filelen_write_cache(files_struct *fsp, SMB_OFF_T file_size);
+void set_filelen_write_cache(files_struct *fsp, off_t file_size);
ssize_t flush_write_cache(files_struct *fsp, enum flush_reason_enum reason);
NTSTATUS sync_file(connection_struct *conn, files_struct *fsp, bool write_through);
int fsp_stat(files_struct *fsp);
uint32 dirtype, struct smb_filename *smb_fname,
bool has_wild);
void reply_unlink(struct smb_request *req);
-ssize_t fake_sendfile(files_struct *fsp, SMB_OFF_T startpos, size_t nread);
+ssize_t fake_sendfile(files_struct *fsp, off_t startpos, size_t nread);
void sendfile_short_send(files_struct *fsp,
ssize_t nread,
size_t headersize,
NTSTATUS vfs_file_exist(connection_struct *conn, struct smb_filename *smb_fname);
ssize_t vfs_read_data(files_struct *fsp, char *buf, size_t byte_count);
ssize_t vfs_pread_data(files_struct *fsp, char *buf,
- size_t byte_count, SMB_OFF_T offset);
+ size_t byte_count, off_t offset);
ssize_t vfs_write_data(struct smb_request *req,
files_struct *fsp,
const char *buffer,
files_struct *fsp,
const char *buffer,
size_t N,
- SMB_OFF_T offset);
+ off_t offset);
int vfs_allocate_file_space(files_struct *fsp, uint64_t len);
-int vfs_set_filelen(files_struct *fsp, SMB_OFF_T len);
-int vfs_slow_fallocate(files_struct *fsp, SMB_OFF_T offset, SMB_OFF_T len);
-int vfs_fill_sparse(files_struct *fsp, SMB_OFF_T len);
-SMB_OFF_T vfs_transfer_file(files_struct *in, files_struct *out, SMB_OFF_T n);
+int vfs_set_filelen(files_struct *fsp, off_t len);
+int vfs_slow_fallocate(files_struct *fsp, off_t offset, off_t len);
+int vfs_fill_sparse(files_struct *fsp, off_t len);
+off_t vfs_transfer_file(files_struct *in, files_struct *out, off_t n);
const char *vfs_readdirname(connection_struct *conn, void *p,
SMB_STRUCT_STAT *sbuf, char **talloced);
int vfs_ChDir(connection_struct *conn, const char *path);
struct smb_filename *smb_fname = NULL;
char *fname = NULL;
int mode=0;
- SMB_OFF_T size=0;
+ off_t size=0;
time_t mtime=0;
const char *p;
NTSTATUS status;
char *directory = NULL;
struct smb_filename *smb_fname = NULL;
char *fname = NULL;
- SMB_OFF_T size;
+ off_t size;
uint32 mode;
struct timespec date;
uint32 dirtype;
struct smb_filename *smb_fname = NULL;
char *fname = NULL;
uint32 fattr=0;
- SMB_OFF_T size = 0;
+ off_t size = 0;
time_t mtime=0;
int info;
files_struct *fsp;
reply_nterror(req, NT_STATUS_DISK_FULL);
goto out;
}
- retval = vfs_set_filelen(fsp, (SMB_OFF_T)allocation_size);
+ retval = vfs_set_filelen(fsp, (off_t)allocation_size);
if (retval < 0) {
close_file(req, fsp, ERROR_CLOSE);
reply_nterror(req, NT_STATUS_DISK_FULL);
Fake (read/write) sendfile. Returns -1 on read or write fail.
****************************************************************************/
-ssize_t fake_sendfile(files_struct *fsp, SMB_OFF_T startpos, size_t nread)
+ssize_t fake_sendfile(files_struct *fsp, off_t startpos, size_t nread)
{
size_t bufsize;
size_t tosend = nread;
static void send_file_readbraw(connection_struct *conn,
struct smb_request *req,
files_struct *fsp,
- SMB_OFF_T startpos,
+ off_t startpos,
size_t nread,
ssize_t mincount)
{
struct smbd_server_connection *sconn = req->sconn;
ssize_t maxcount,mincount;
size_t nread = 0;
- SMB_OFF_T startpos;
+ off_t startpos;
files_struct *fsp;
struct lock_struct lock;
- SMB_OFF_T size = 0;
+ off_t size = 0;
START_PROFILE(SMBreadbraw);
* This is a large offset (64 bit) read.
*/
- startpos |= (((SMB_OFF_T)IVAL(req->vwv+8, 0)) << 32);
+ startpos |= (((off_t)IVAL(req->vwv+8, 0)) << 32);
if(startpos < 0) {
DEBUG(0,("reply_readbraw: negative 64 bit "
connection_struct *conn = req->conn;
ssize_t nread = -1;
char *data;
- SMB_OFF_T startpos;
+ off_t startpos;
size_t numtoread;
NTSTATUS status;
files_struct *fsp;
size_t numtoread;
ssize_t nread = 0;
char *data;
- SMB_OFF_T startpos;
+ off_t startpos;
int outsize = 0;
files_struct *fsp;
struct lock_struct lock;
****************************************************************************/
static void send_file_readX(connection_struct *conn, struct smb_request *req,
- files_struct *fsp, SMB_OFF_T startpos,
+ files_struct *fsp, off_t startpos,
size_t smb_maxcnt)
{
ssize_t nread = -1;
struct smbd_server_connection *sconn = req->sconn;
connection_struct *conn = req->conn;
files_struct *fsp;
- SMB_OFF_T startpos;
+ off_t startpos;
size_t smb_maxcnt;
bool big_readX = False;
#if 0
/*
* This is a large offset (64 bit) read.
*/
- startpos |= (((SMB_OFF_T)IVAL(req->vwv+10, 0)) << 32);
+ startpos |= (((off_t)IVAL(req->vwv+10, 0)) << 32);
}
ssize_t total_written=0;
size_t numtowrite=0;
size_t tcount;
- SMB_OFF_T startpos;
+ off_t startpos;
const char *data=NULL;
bool write_through;
files_struct *fsp;
connection_struct *conn = req->conn;
ssize_t nwritten = -1;
size_t numtowrite;
- SMB_OFF_T startpos;
+ off_t startpos;
const char *data;
NTSTATUS status = NT_STATUS_OK;
files_struct *fsp;
connection_struct *conn = req->conn;
size_t numtowrite;
ssize_t nwritten = -1;
- SMB_OFF_T startpos;
+ off_t startpos;
const char *data;
files_struct *fsp;
struct lock_struct lock;
/*
* This is actually an allocate call, and set EOF. JRA.
*/
- nwritten = vfs_allocate_file_space(fsp, (SMB_OFF_T)startpos);
+ nwritten = vfs_allocate_file_space(fsp, (off_t)startpos);
if (nwritten < 0) {
reply_nterror(req, NT_STATUS_DISK_FULL);
goto strict_unlock;
}
- nwritten = vfs_set_filelen(fsp, (SMB_OFF_T)startpos);
+ nwritten = vfs_set_filelen(fsp, (off_t)startpos);
if (nwritten < 0) {
reply_nterror(req, NT_STATUS_DISK_FULL);
goto strict_unlock;
connection_struct *conn = req->conn;
files_struct *fsp;
struct lock_struct lock;
- SMB_OFF_T startpos;
+ off_t startpos;
size_t numtowrite;
bool write_through;
ssize_t nwritten;
/*
* This is a large offset (64 bit) write.
*/
- startpos |= (((SMB_OFF_T)IVAL(req->vwv+12, 0)) << 32);
+ startpos |= (((off_t)IVAL(req->vwv+12, 0)) << 32);
}
void reply_lseek(struct smb_request *req)
{
connection_struct *conn = req->conn;
- SMB_OFF_T startpos;
- SMB_OFF_T res= -1;
+ off_t startpos;
+ off_t res= -1;
int mode,umode;
files_struct *fsp;
mode = SVAL(req->vwv+1, 0) & 3;
/* NB. This doesn't use IVAL_TO_SMB_OFF_T as startpos can be signed in this case. */
- startpos = (SMB_OFF_T)IVALS(req->vwv+2, 0);
+ startpos = (off_t)IVALS(req->vwv+2, 0);
switch (mode) {
case 0:
if (umode == SEEK_END) {
if((res = SMB_VFS_LSEEK(fsp,startpos,umode)) == -1) {
if(errno == EINVAL) {
- SMB_OFF_T current_pos = startpos;
+ off_t current_pos = startpos;
if(fsp_stat(fsp) == -1) {
reply_nterror(req,
size_t numtowrite;
ssize_t nwritten = -1;
NTSTATUS close_status = NT_STATUS_OK;
- SMB_OFF_T startpos;
+ off_t startpos;
const char *data;
struct timespec mtime;
files_struct *fsp;
data = (const char *)req->buf + 3;
- if (write_file(req,fsp,data,(SMB_OFF_T)-1,numtowrite) != numtowrite) {
+ if (write_file(req,fsp,data,(off_t)-1,numtowrite) != numtowrite) {
reply_nterror(req, map_nt_error_from_unix(errno));
END_PROFILE(SMBsplwr);
return;
bool target_is_directory)
{
struct smb_filename *smb_fname_dst_tmp = NULL;
- SMB_OFF_T ret=-1;
+ off_t ret=-1;
files_struct *fsp1,*fsp2;
uint32 dosattrs;
uint32 new_create_disposition;
goto out;
}
- if (ret != (SMB_OFF_T)smb_fname_src->st.st_ex_size) {
+ if (ret != (off_t)smb_fname_src->st.st_ex_size) {
status = NT_STATUS_DISK_FULL;
goto out;
}
fsp,
state,
&state->out_data,
- (SMB_OFF_T)in_offset,
+ (off_t)in_offset,
(size_t)in_length);
if (NT_STATUS_IS_OK(status)) {
uint32 open_size;
char *pname;
char *fname = NULL;
- SMB_OFF_T size=0;
+ off_t size=0;
int fattr=0,mtime=0;
SMB_INO_T inode = 0;
int smb_action = 0;
files_struct *fsp,
const struct smb_filename *smb_fname,
const SMB_STRUCT_STAT *psbuf,
- SMB_OFF_T size,
+ off_t size,
bool fail_after_createfile)
{
NTSTATUS status = NT_STATUS_OK;
const struct smb_filename *smb_fname,
bool fail_after_createfile)
{
- SMB_OFF_T size;
+ off_t size;
if (total_data < 8) {
return NT_STATUS_INVALID_PARAMETER;
}
size = IVAL(pdata,0);
- size |= (((SMB_OFF_T)IVAL(pdata,4)) << 32);
+ size |= (((off_t)IVAL(pdata,4)) << 32);
DEBUG(10,("smb_set_file_end_of_file_info: Set end of file info for "
"file %s to %.0f\n", smb_fname_str_dbg(smb_fname),
(double)size));
struct smb_file_time ft;
uint32 raw_unixmode;
mode_t unixmode;
- SMB_OFF_T size = 0;
+ off_t size = 0;
uid_t set_owner = (uid_t)SMB_UID_NO_CHANGE;
gid_t set_grp = (uid_t)SMB_GID_NO_CHANGE;
NTSTATUS status = NT_STATUS_OK;
if(IVAL(pdata, 0) != SMB_SIZE_NO_CHANGE_LO &&
IVAL(pdata, 4) != SMB_SIZE_NO_CHANGE_HI) {
size=IVAL(pdata,0); /* first 8 Bytes are size */
- size |= (((SMB_OFF_T)IVAL(pdata,4)) << 32);
+ size |= (((off_t)IVAL(pdata,4)) << 32);
}
ft.atime = interpret_long_date(pdata+24); /* access_time */
}
ssize_t vfs_pread_data(files_struct *fsp, char *buf,
- size_t byte_count, SMB_OFF_T offset)
+ size_t byte_count, off_t offset)
{
size_t total=0;
req->unread_bytes = 0;
return SMB_VFS_RECVFILE(req->sconn->sock,
fsp,
- (SMB_OFF_T)-1,
+ (off_t)-1,
N);
}
files_struct *fsp,
const char *buffer,
size_t N,
- SMB_OFF_T offset)
+ off_t offset)
{
size_t total=0;
ssize_t ret;
DEBUG(10,("vfs_allocate_file_space: file %s, len %.0f\n",
fsp_str_dbg(fsp), (double)len));
- if (((SMB_OFF_T)len) < 0) {
+ if (((off_t)len) < 0) {
DEBUG(0,("vfs_allocate_file_space: %s negative len "
"requested.\n", fsp_str_dbg(fsp)));
errno = EINVAL;
contend_level2_oplocks_begin(fsp, LEVEL2_CONTEND_ALLOC_SHRINK);
flush_write_cache(fsp, SIZECHANGE_FLUSH);
- if ((ret = SMB_VFS_FTRUNCATE(fsp, (SMB_OFF_T)len)) != -1) {
+ if ((ret = SMB_VFS_FTRUNCATE(fsp, (off_t)len)) != -1) {
set_filelen_write_cache(fsp, len);
}
Returns 0 on success, -1 on failure.
****************************************************************************/
-int vfs_set_filelen(files_struct *fsp, SMB_OFF_T len)
+int vfs_set_filelen(files_struct *fsp, off_t len)
{
int ret;
#define SPARSE_BUF_WRITE_SIZE (32*1024)
-int vfs_slow_fallocate(files_struct *fsp, SMB_OFF_T offset, SMB_OFF_T len)
+int vfs_slow_fallocate(files_struct *fsp, off_t offset, off_t len)
{
ssize_t pwrite_ret;
size_t total = 0;
Returns 0 on success, -1 on failure.
****************************************************************************/
-int vfs_fill_sparse(files_struct *fsp, SMB_OFF_T len)
+int vfs_fill_sparse(files_struct *fsp, off_t len)
{
int ret;
NTSTATUS status;
- SMB_OFF_T offset;
+ off_t offset;
size_t num_to_write;
status = vfs_stat_fsp(fsp);
return SMB_VFS_WRITE(fsp, buf, len);
}
-SMB_OFF_T vfs_transfer_file(files_struct *in, files_struct *out, SMB_OFF_T n)
+off_t vfs_transfer_file(files_struct *in, files_struct *out, off_t n)
{
return transfer_file_internal((void *)in, (void *)out, n,
vfs_read_fn, vfs_write_fn);
ssize_t smb_vfs_call_pread(struct vfs_handle_struct *handle,
struct files_struct *fsp, void *data, size_t n,
- SMB_OFF_T offset)
+ off_t offset)
{
VFS_FIND(pread);
return handle->fns->pread_fn(handle, fsp, data, n, offset);
ssize_t smb_vfs_call_pwrite(struct vfs_handle_struct *handle,
struct files_struct *fsp, const void *data,
- size_t n, SMB_OFF_T offset)
+ size_t n, off_t offset)
{
VFS_FIND(pwrite);
return handle->fns->pwrite_fn(handle, fsp, data, n, offset);
}
-SMB_OFF_T smb_vfs_call_lseek(struct vfs_handle_struct *handle,
- struct files_struct *fsp, SMB_OFF_T offset,
+off_t smb_vfs_call_lseek(struct vfs_handle_struct *handle,
+ struct files_struct *fsp, off_t offset,
int whence)
{
VFS_FIND(lseek);
ssize_t smb_vfs_call_sendfile(struct vfs_handle_struct *handle, int tofd,
files_struct *fromfsp, const DATA_BLOB *header,
- SMB_OFF_T offset, size_t count)
+ off_t offset, size_t count)
{
VFS_FIND(sendfile);
return handle->fns->sendfile_fn(handle, tofd, fromfsp, header, offset,
}
ssize_t smb_vfs_call_recvfile(struct vfs_handle_struct *handle, int fromfd,
- files_struct *tofsp, SMB_OFF_T offset,
+ files_struct *tofsp, off_t offset,
size_t count)
{
VFS_FIND(recvfile);
}
int smb_vfs_call_ftruncate(struct vfs_handle_struct *handle,
- struct files_struct *fsp, SMB_OFF_T offset)
+ struct files_struct *fsp, off_t offset)
{
VFS_FIND(ftruncate);
return handle->fns->ftruncate_fn(handle, fsp, offset);
int smb_vfs_call_fallocate(struct vfs_handle_struct *handle,
struct files_struct *fsp,
enum vfs_fallocate_mode mode,
- SMB_OFF_T offset,
- SMB_OFF_T len)
+ off_t offset,
+ off_t len)
{
VFS_FIND(fallocate);
return handle->fns->fallocate_fn(handle, fsp, mode, offset, len);
static NTSTATUS cmd_lseek(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, const char **argv)
{
int fd, offset, whence;
- SMB_OFF_T pos;
+ off_t pos;
if (argc != 4) {
printf("Usage: lseek <fd> <offset> <whence>\n...where whence is 1 => SEEK_SET, 2 => SEEK_CUR, 3 => SEEK_END\n");
}
pos = SMB_VFS_LSEEK(vfs->files[fd], offset, whence);
- if (pos == (SMB_OFF_T)-1) {
+ if (pos == (off_t)-1) {
printf("lseek: error=%d (%s)\n", errno, strerror(errno));
return NT_STATUS_UNSUCCESSFUL;
}
static NTSTATUS cmd_ftruncate(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, const char **argv)
{
int fd;
- SMB_OFF_T off;
+ off_t off;
if (argc != 3) {
printf("Usage: ftruncate <fd> <length>\n");
return NT_STATUS_OK;
const char *fname = "append";
NTSTATUS status;
uint16_t fnum;
- SMB_OFF_T size;
+ off_t size;
uint8_t c = '\0';
bool ret = false;
static struct cli_state *cli1;
uint16_t fnum1;
const char *lockfname = "\\large.dat";
- SMB_OFF_T fsize;
+ off_t fsize;
char buf[126*1024];
bool correct = True;
NTSTATUS status;
{
struct cli_state *cli;
uint16_t fnum;
- SMB_OFF_T size;
+ off_t size;
time_t c_time, a_time, m_time;
struct timespec c_time_ts, a_time_ts, m_time_ts, w_time_ts, m_time2_ts;
const char *fname = "\\trans2.tst";
const char *fname = "\\readonly.file";
uint16_t fnum1, fnum2;
char buf[20];
- SMB_OFF_T fsize;
+ off_t fsize;
bool correct = True;
char *tmp_path;
NTSTATUS status;
fstring alt_name;
NTSTATUS status;
time_t change_time, access_time, write_time;
- SMB_OFF_T size;
+ off_t size;
uint16_t mode;
printf("starting mangle1 test\n");
"testdir:{4c8cc155-6c1e-11d1-8e41-00c04fb9386d}:$DATA";
NTSTATUS status;
time_t change_time, access_time, write_time;
- SMB_OFF_T size;
+ off_t size;
uint16_t mode, fnum;
bool ret = true;
}
for (c=1; c < 0x10000; c++) {
- SMB_OFF_T size;
+ off_t size;
if (c == '.' || c == '\\') continue;