2003-06-04 17:13:41 +04:00
/*
* Skeleton VFS module . Implements passthrough operation of all VFS
* calls to disk functions .
*
* Copyright ( C ) Tim Potter , 1999 - 2000
* Copyright ( C ) Alexander Bokovoy , 2002
* Copyright ( C ) Stefan ( metze ) Metzmacher , 2003
2009-09-26 08:39:52 +04:00
* Copyright ( C ) Jeremy Allison 2009
2003-06-04 17:13:41 +04:00
*
* 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
2007-07-09 23:25:36 +04:00
* the Free Software Foundation ; either version 3 of the License , or
2003-06-04 17:13:41 +04:00
* ( 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
2007-07-10 09:23:25 +04:00
* along with this program ; if not , see < http : //www.gnu.org/licenses/>.
2003-06-04 17:13:41 +04:00
*/
2011-12-14 00:26:21 +04:00
# include "../source3/include/includes.h"
2012-07-09 19:17:25 +04:00
# include "lib/util/tevent_unix.h"
2013-01-15 20:22:59 +04:00
# include "lib/util/tevent_ntstatus.h"
2003-06-04 17:13:41 +04:00
/* PLEASE,PLEASE READ THE VFS MODULES CHAPTER OF THE
SAMBA DEVELOPERS GUIDE ! ! ! ! ! !
*/
/* If you take this file as template for your module
2009-09-26 09:02:18 +04:00
* please make sure that you remove all skel_XXX ( ) functions you don ' t
* want to implement ! ! The passthrough operations are not
* neccessary in a real module .
2003-06-04 17:13:41 +04:00
*
* - - metze
*/
2012-10-11 00:53:29 +04:00
static int skel_connect ( vfs_handle_struct * handle , const char * service ,
const char * user )
2003-06-04 17:13:41 +04:00
{
2006-07-11 22:06:52 +04:00
return SMB_VFS_NEXT_CONNECT ( handle , service , user ) ;
2003-06-04 17:13:41 +04:00
}
2006-07-11 22:06:52 +04:00
static void skel_disconnect ( vfs_handle_struct * handle )
2003-06-04 17:13:41 +04:00
{
2006-07-11 22:06:52 +04:00
SMB_VFS_NEXT_DISCONNECT ( handle ) ;
2003-06-04 17:13:41 +04:00
}
2017-05-23 20:40:47 +03:00
static uint64_t skel_disk_free ( vfs_handle_struct * handle ,
const struct smb_filename * smb_fname ,
uint64_t * bsize ,
uint64_t * dfree ,
uint64_t * dsize )
2003-06-04 17:13:41 +04:00
{
2017-05-23 20:40:47 +03:00
return SMB_VFS_NEXT_DISK_FREE ( handle , smb_fname , bsize , dfree , dsize ) ;
2003-06-04 17:13:41 +04:00
}
2017-06-01 21:45:25 +03:00
static int skel_get_quota ( vfs_handle_struct * handle ,
const struct smb_filename * smb_fname ,
enum SMB_QUOTA_TYPE qtype ,
unid_t id ,
SMB_DISK_QUOTA * dq )
2003-06-04 17:13:41 +04:00
{
2017-06-01 21:45:25 +03:00
return SMB_VFS_NEXT_GET_QUOTA ( handle , smb_fname , qtype , id , dq ) ;
2003-06-04 17:13:41 +04:00
}
2012-10-11 00:53:29 +04:00
static int skel_set_quota ( vfs_handle_struct * handle , enum SMB_QUOTA_TYPE qtype ,
unid_t id , SMB_DISK_QUOTA * dq )
2003-06-04 17:13:41 +04:00
{
2006-07-11 22:06:52 +04:00
return SMB_VFS_NEXT_SET_QUOTA ( handle , qtype , id , dq ) ;
2003-06-04 17:13:41 +04:00
}
2012-10-11 00:53:29 +04:00
static int skel_get_shadow_copy_data ( vfs_handle_struct * handle ,
files_struct * fsp ,
struct shadow_copy_data * shadow_copy_data ,
bool labels )
2003-08-08 01:49:01 +04:00
{
2012-10-11 00:53:29 +04:00
return SMB_VFS_NEXT_GET_SHADOW_COPY_DATA ( handle , fsp , shadow_copy_data ,
labels ) ;
2003-08-08 01:49:01 +04:00
}
2017-06-03 01:26:06 +03:00
static int skel_statvfs ( struct vfs_handle_struct * handle ,
const struct smb_filename * smb_fname ,
2012-10-11 00:53:29 +04:00
struct vfs_statvfs_struct * statbuf )
2005-10-20 21:33:17 +04:00
{
2017-06-03 01:26:06 +03:00
return SMB_VFS_NEXT_STATVFS ( handle , smb_fname , statbuf ) ;
2005-10-20 21:33:17 +04:00
}
2012-10-11 00:53:29 +04:00
static uint32_t skel_fs_capabilities ( struct vfs_handle_struct * handle ,
enum timestamp_set_resolution * p_ts_res )
2009-09-26 08:39:52 +04:00
{
return SMB_VFS_NEXT_FS_CAPABILITIES ( handle , p_ts_res ) ;
}
2011-10-08 11:18:02 +04:00
static NTSTATUS skel_get_dfs_referrals ( struct vfs_handle_struct * handle ,
struct dfs_GetDFSReferral * r )
{
return SMB_VFS_NEXT_GET_DFS_REFERRALS ( handle , r ) ;
}
2016-02-27 01:53:12 +03:00
static DIR * skel_opendir ( vfs_handle_struct * handle ,
const struct smb_filename * smb_fname ,
const char * mask ,
uint32_t attr )
2003-06-04 17:13:41 +04:00
{
2016-02-27 01:53:12 +03:00
return SMB_VFS_NEXT_OPENDIR ( handle , smb_fname , mask , attr ) ;
2003-06-04 17:13:41 +04:00
}
2012-04-10 05:16:57 +04:00
static NTSTATUS skel_snap_check_path ( struct vfs_handle_struct * handle ,
TALLOC_CTX * mem_ctx ,
const char * service_path ,
char * * base_volume )
{
return SMB_VFS_NEXT_SNAP_CHECK_PATH ( handle , mem_ctx , service_path ,
base_volume ) ;
}
static NTSTATUS skel_snap_create ( struct vfs_handle_struct * handle ,
TALLOC_CTX * mem_ctx ,
const char * base_volume ,
time_t * tstamp ,
bool rw ,
char * * base_path ,
char * * snap_path )
{
return SMB_VFS_NEXT_SNAP_CREATE ( handle , mem_ctx , base_volume , tstamp ,
rw , base_path , snap_path ) ;
}
static NTSTATUS skel_snap_delete ( struct vfs_handle_struct * handle ,
TALLOC_CTX * mem_ctx ,
char * base_path ,
char * snap_path )
{
return SMB_VFS_NEXT_SNAP_DELETE ( handle , mem_ctx , base_path , snap_path ) ;
}
2012-10-11 00:53:29 +04:00
static DIR * skel_fdopendir ( vfs_handle_struct * handle , files_struct * fsp ,
2015-05-14 03:26:01 +03:00
const char * mask , uint32_t attr )
2011-02-09 02:07:48 +03:00
{
return SMB_VFS_NEXT_FDOPENDIR ( handle , fsp , mask , attr ) ;
}
2012-03-28 06:18:14 +04:00
static struct dirent * skel_readdir ( vfs_handle_struct * handle ,
2012-10-11 00:53:29 +04:00
DIR * dirp , SMB_STRUCT_STAT * sbuf )
2003-06-04 17:13:41 +04:00
{
2009-02-24 17:28:54 +03:00
return SMB_VFS_NEXT_READDIR ( handle , dirp , sbuf ) ;
2003-06-04 17:13:41 +04:00
}
2012-10-11 00:53:29 +04:00
static void skel_seekdir ( vfs_handle_struct * handle , DIR * dirp , long offset )
2004-11-10 02:55:04 +03:00
{
2009-09-26 08:39:52 +04:00
SMB_VFS_NEXT_SEEKDIR ( handle , dirp , offset ) ;
2004-11-10 02:55:04 +03:00
}
2012-10-11 00:53:29 +04:00
static long skel_telldir ( vfs_handle_struct * handle , DIR * dirp )
2004-11-10 02:55:04 +03:00
{
2006-07-11 22:06:52 +04:00
return SMB_VFS_NEXT_TELLDIR ( handle , dirp ) ;
2004-11-10 02:55:04 +03:00
}
2012-03-28 06:22:03 +04:00
static void skel_rewind_dir ( vfs_handle_struct * handle , DIR * dirp )
2004-11-10 02:55:04 +03:00
{
2009-09-26 08:39:52 +04:00
SMB_VFS_NEXT_REWINDDIR ( handle , dirp ) ;
2004-11-10 02:55:04 +03:00
}
2019-09-04 22:20:46 +03:00
static int skel_mkdirat ( vfs_handle_struct * handle ,
struct files_struct * dirfsp ,
const struct smb_filename * smb_fname ,
mode_t mode )
{
return SMB_VFS_NEXT_MKDIRAT ( handle ,
dirfsp ,
smb_fname ,
mode ) ;
}
2012-10-11 00:53:29 +04:00
static int skel_closedir ( vfs_handle_struct * handle , DIR * dir )
2003-06-04 17:13:41 +04:00
{
2006-07-11 22:06:52 +04:00
return SMB_VFS_NEXT_CLOSEDIR ( handle , dir ) ;
2003-06-04 17:13:41 +04:00
}
2009-06-16 23:01:13 +04:00
static int skel_open ( vfs_handle_struct * handle , struct smb_filename * smb_fname ,
files_struct * fsp , int flags , mode_t mode )
2003-06-04 17:13:41 +04:00
{
2009-06-16 23:01:13 +04:00
return SMB_VFS_NEXT_OPEN ( handle , smb_fname , fsp , flags , mode ) ;
2003-06-04 17:13:41 +04:00
}
2009-09-26 08:39:52 +04:00
static NTSTATUS skel_create_file ( struct vfs_handle_struct * handle ,
2012-10-11 00:53:29 +04:00
struct smb_request * req ,
uint16_t root_dir_fid ,
struct smb_filename * smb_fname ,
uint32_t access_mask ,
uint32_t share_access ,
uint32_t create_disposition ,
uint32_t create_options ,
uint32_t file_attributes ,
uint32_t oplock_request ,
2019-08-07 23:00:11 +03:00
const struct smb2_lease * lease ,
2012-10-11 00:53:29 +04:00
uint64_t allocation_size ,
uint32_t private_flags ,
struct security_descriptor * sd ,
struct ea_list * ea_list ,
2014-11-26 16:12:51 +03:00
files_struct * * result , int * pinfo ,
const struct smb2_create_blobs * in_context_blobs ,
struct smb2_create_blobs * out_context_blobs )
2009-09-26 08:39:52 +04:00
{
return SMB_VFS_NEXT_CREATE_FILE ( handle ,
2012-10-11 00:53:29 +04:00
req ,
root_dir_fid ,
smb_fname ,
access_mask ,
share_access ,
create_disposition ,
create_options ,
file_attributes ,
oplock_request ,
2013-08-21 17:56:14 +04:00
lease ,
2012-10-11 00:53:29 +04:00
allocation_size ,
private_flags ,
2014-11-26 16:12:51 +03:00
sd , ea_list , result , pinfo ,
in_context_blobs , out_context_blobs ) ;
2009-09-26 08:39:52 +04:00
}
static int skel_close_fn ( vfs_handle_struct * handle , files_struct * fsp )
2003-06-04 17:13:41 +04:00
{
2008-01-11 16:19:28 +03:00
return SMB_VFS_NEXT_CLOSE ( handle , fsp ) ;
2003-06-04 17:13:41 +04:00
}
2012-10-11 00:53:29 +04:00
static ssize_t skel_pread ( vfs_handle_struct * handle , files_struct * fsp ,
void * data , size_t n , off_t offset )
2004-01-06 04:22:14 +03:00
{
2008-01-07 02:14:19 +03:00
return SMB_VFS_NEXT_PREAD ( handle , fsp , data , n , offset ) ;
2004-01-06 04:22:14 +03:00
}
2012-07-09 19:17:25 +04:00
struct skel_pread_state {
ssize_t ret ;
2016-02-26 12:54:01 +03:00
struct vfs_aio_state vfs_aio_state ;
2012-07-09 19:17:25 +04:00
} ;
static void skel_pread_done ( struct tevent_req * subreq ) ;
static struct tevent_req * skel_pread_send ( struct vfs_handle_struct * handle ,
TALLOC_CTX * mem_ctx ,
struct tevent_context * ev ,
struct files_struct * fsp ,
void * data , size_t n , off_t offset )
{
struct tevent_req * req , * subreq ;
struct skel_pread_state * state ;
req = tevent_req_create ( mem_ctx , & state , struct skel_pread_state ) ;
if ( req = = NULL ) {
return NULL ;
}
subreq = SMB_VFS_NEXT_PREAD_SEND ( state , ev , handle , fsp , data ,
n , offset ) ;
if ( tevent_req_nomem ( subreq , req ) ) {
return tevent_req_post ( req , ev ) ;
}
tevent_req_set_callback ( subreq , skel_pread_done , req ) ;
return req ;
}
static void skel_pread_done ( struct tevent_req * subreq )
{
2012-10-11 00:53:29 +04:00
struct tevent_req * req =
tevent_req_callback_data ( subreq , struct tevent_req ) ;
struct skel_pread_state * state =
tevent_req_data ( req , struct skel_pread_state ) ;
2012-07-09 19:17:25 +04:00
2016-02-26 12:54:01 +03:00
state - > ret = SMB_VFS_PREAD_RECV ( subreq , & state - > vfs_aio_state ) ;
2012-07-09 19:17:25 +04:00
TALLOC_FREE ( subreq ) ;
tevent_req_done ( req ) ;
}
2016-02-26 12:54:01 +03:00
static ssize_t skel_pread_recv ( struct tevent_req * req ,
struct vfs_aio_state * vfs_aio_state )
2012-07-09 19:17:25 +04:00
{
2012-10-11 00:53:29 +04:00
struct skel_pread_state * state =
tevent_req_data ( req , struct skel_pread_state ) ;
2012-07-09 19:17:25 +04:00
2016-02-26 12:54:01 +03:00
if ( tevent_req_is_unix_error ( req , & vfs_aio_state - > error ) ) {
2012-07-09 19:17:25 +04:00
return - 1 ;
}
2016-02-26 12:54:01 +03:00
* vfs_aio_state = state - > vfs_aio_state ;
2012-07-09 19:17:25 +04:00
return state - > ret ;
}
2012-10-11 00:53:29 +04:00
static ssize_t skel_pwrite ( vfs_handle_struct * handle , files_struct * fsp ,
const void * data , size_t n , off_t offset )
2004-01-06 04:22:14 +03:00
{
2008-01-07 11:23:04 +03:00
return SMB_VFS_NEXT_PWRITE ( handle , fsp , data , n , offset ) ;
2004-01-06 04:22:14 +03:00
}
2012-07-09 19:17:25 +04:00
struct skel_pwrite_state {
ssize_t ret ;
2016-02-26 12:54:01 +03:00
struct vfs_aio_state vfs_aio_state ;
2012-07-09 19:17:25 +04:00
} ;
static void skel_pwrite_done ( struct tevent_req * subreq ) ;
static struct tevent_req * skel_pwrite_send ( struct vfs_handle_struct * handle ,
TALLOC_CTX * mem_ctx ,
struct tevent_context * ev ,
struct files_struct * fsp ,
const void * data ,
size_t n , off_t offset )
{
struct tevent_req * req , * subreq ;
struct skel_pwrite_state * state ;
req = tevent_req_create ( mem_ctx , & state , struct skel_pwrite_state ) ;
if ( req = = NULL ) {
return NULL ;
}
subreq = SMB_VFS_NEXT_PWRITE_SEND ( state , ev , handle , fsp , data ,
2012-10-11 00:53:29 +04:00
n , offset ) ;
2012-07-09 19:17:25 +04:00
if ( tevent_req_nomem ( subreq , req ) ) {
return tevent_req_post ( req , ev ) ;
}
tevent_req_set_callback ( subreq , skel_pwrite_done , req ) ;
return req ;
}
static void skel_pwrite_done ( struct tevent_req * subreq )
{
2012-10-11 00:53:29 +04:00
struct tevent_req * req =
tevent_req_callback_data ( subreq , struct tevent_req ) ;
struct skel_pwrite_state * state =
tevent_req_data ( req , struct skel_pwrite_state ) ;
2012-07-09 19:17:25 +04:00
2016-02-26 12:54:01 +03:00
state - > ret = SMB_VFS_PWRITE_RECV ( subreq , & state - > vfs_aio_state ) ;
2012-07-09 19:17:25 +04:00
TALLOC_FREE ( subreq ) ;
tevent_req_done ( req ) ;
}
2016-02-26 12:54:01 +03:00
static ssize_t skel_pwrite_recv ( struct tevent_req * req ,
struct vfs_aio_state * vfs_aio_state )
2012-07-09 19:17:25 +04:00
{
2012-10-11 00:53:29 +04:00
struct skel_pwrite_state * state =
tevent_req_data ( req , struct skel_pwrite_state ) ;
2012-07-09 19:17:25 +04:00
2016-02-26 12:54:01 +03:00
if ( tevent_req_is_unix_error ( req , & vfs_aio_state - > error ) ) {
2012-07-09 19:17:25 +04:00
return - 1 ;
}
2016-02-26 12:54:01 +03:00
* vfs_aio_state = state - > vfs_aio_state ;
2012-07-09 19:17:25 +04:00
return state - > ret ;
}
2012-10-11 00:53:29 +04:00
static off_t skel_lseek ( vfs_handle_struct * handle , files_struct * fsp ,
off_t offset , int whence )
2003-06-04 17:13:41 +04:00
{
2008-01-07 12:15:08 +03:00
return SMB_VFS_NEXT_LSEEK ( handle , fsp , offset , whence ) ;
2003-06-04 17:13:41 +04:00
}
2012-10-11 00:53:29 +04:00
static ssize_t skel_sendfile ( vfs_handle_struct * handle , int tofd ,
files_struct * fromfsp , const DATA_BLOB * hdr ,
off_t offset , size_t n )
2007-10-30 03:16:13 +03:00
{
2008-01-11 02:51:19 +03:00
return SMB_VFS_NEXT_SENDFILE ( handle , tofd , fromfsp , hdr , offset , n ) ;
2007-10-30 03:16:13 +03:00
}
2012-10-11 00:53:29 +04:00
static ssize_t skel_recvfile ( vfs_handle_struct * handle , int fromfd ,
files_struct * tofsp , off_t offset , size_t n )
2007-10-30 03:16:13 +03:00
{
2008-01-11 03:26:54 +03:00
return SMB_VFS_NEXT_RECVFILE ( handle , fromfd , tofsp , offset , n ) ;
2007-10-30 03:16:13 +03:00
}
2019-08-09 01:22:31 +03:00
static int skel_renameat ( vfs_handle_struct * handle ,
files_struct * srcfsp ,
const struct smb_filename * smb_fname_src ,
files_struct * dstfsp ,
const struct smb_filename * smb_fname_dst )
{
return SMB_VFS_NEXT_RENAMEAT ( handle ,
srcfsp ,
smb_fname_src ,
dstfsp ,
smb_fname_dst ) ;
}
2012-07-13 12:22:25 +04:00
struct skel_fsync_state {
int ret ;
2016-02-26 12:54:01 +03:00
struct vfs_aio_state vfs_aio_state ;
2012-07-13 12:22:25 +04:00
} ;
static void skel_fsync_done ( struct tevent_req * subreq ) ;
static struct tevent_req * skel_fsync_send ( struct vfs_handle_struct * handle ,
TALLOC_CTX * mem_ctx ,
struct tevent_context * ev ,
struct files_struct * fsp )
{
struct tevent_req * req , * subreq ;
struct skel_fsync_state * state ;
req = tevent_req_create ( mem_ctx , & state , struct skel_fsync_state ) ;
if ( req = = NULL ) {
return NULL ;
}
subreq = SMB_VFS_NEXT_FSYNC_SEND ( state , ev , handle , fsp ) ;
if ( tevent_req_nomem ( subreq , req ) ) {
return tevent_req_post ( req , ev ) ;
}
tevent_req_set_callback ( subreq , skel_fsync_done , req ) ;
return req ;
}
static void skel_fsync_done ( struct tevent_req * subreq )
{
2012-10-11 00:53:29 +04:00
struct tevent_req * req =
tevent_req_callback_data ( subreq , struct tevent_req ) ;
struct skel_fsync_state * state =
tevent_req_data ( req , struct skel_fsync_state ) ;
2012-07-13 12:22:25 +04:00
2016-02-26 12:54:01 +03:00
state - > ret = SMB_VFS_FSYNC_RECV ( subreq , & state - > vfs_aio_state ) ;
2012-07-13 12:22:25 +04:00
TALLOC_FREE ( subreq ) ;
tevent_req_done ( req ) ;
}
2016-02-26 12:54:01 +03:00
static int skel_fsync_recv ( struct tevent_req * req ,
struct vfs_aio_state * vfs_aio_state )
2012-07-13 12:22:25 +04:00
{
2012-10-11 00:53:29 +04:00
struct skel_fsync_state * state =
tevent_req_data ( req , struct skel_fsync_state ) ;
2012-07-13 12:22:25 +04:00
2016-02-26 12:54:01 +03:00
if ( tevent_req_is_unix_error ( req , & vfs_aio_state - > error ) ) {
2012-07-13 12:22:25 +04:00
return - 1 ;
}
2016-02-26 12:54:01 +03:00
* vfs_aio_state = state - > vfs_aio_state ;
2012-07-13 12:22:25 +04:00
return state - > ret ;
}
2009-06-23 02:26:56 +04:00
static int skel_stat ( vfs_handle_struct * handle , struct smb_filename * smb_fname )
2003-06-04 17:13:41 +04:00
{
2009-06-23 02:26:56 +04:00
return SMB_VFS_NEXT_STAT ( handle , smb_fname ) ;
2003-06-04 17:13:41 +04:00
}
2012-10-11 00:53:29 +04:00
static int skel_fstat ( vfs_handle_struct * handle , files_struct * fsp ,
SMB_STRUCT_STAT * sbuf )
2003-06-04 17:13:41 +04:00
{
2008-01-07 15:21:26 +03:00
return SMB_VFS_NEXT_FSTAT ( handle , fsp , sbuf ) ;
2003-06-04 17:13:41 +04:00
}
2012-10-11 00:53:29 +04:00
static int skel_lstat ( vfs_handle_struct * handle ,
struct smb_filename * smb_fname )
2003-06-04 17:13:41 +04:00
{
2009-06-23 02:26:56 +04:00
return SMB_VFS_NEXT_LSTAT ( handle , smb_fname ) ;
2003-06-04 17:13:41 +04:00
}
2012-10-11 00:53:29 +04:00
static uint64_t skel_get_alloc_size ( struct vfs_handle_struct * handle ,
struct files_struct * fsp ,
const SMB_STRUCT_STAT * sbuf )
2009-09-26 08:39:52 +04:00
{
return SMB_VFS_NEXT_GET_ALLOC_SIZE ( handle , fsp , sbuf ) ;
}
2019-09-12 00:37:31 +03:00
static int skel_unlinkat ( vfs_handle_struct * handle ,
struct files_struct * dirfsp ,
const struct smb_filename * smb_fname ,
int flags )
{
return SMB_VFS_NEXT_UNLINKAT ( handle ,
dirfsp ,
smb_fname ,
flags ) ;
}
2016-03-02 03:20:25 +03:00
static int skel_chmod ( vfs_handle_struct * handle ,
const struct smb_filename * smb_fname ,
mode_t mode )
2003-06-04 17:13:41 +04:00
{
2016-03-02 03:20:25 +03:00
return SMB_VFS_NEXT_CHMOD ( handle , smb_fname , mode ) ;
2003-06-04 17:13:41 +04:00
}
2012-10-11 00:53:29 +04:00
static int skel_fchmod ( vfs_handle_struct * handle , files_struct * fsp ,
mode_t mode )
2003-06-04 17:13:41 +04:00
{
2008-01-07 15:44:37 +03:00
return SMB_VFS_NEXT_FCHMOD ( handle , fsp , mode ) ;
2003-06-04 17:13:41 +04:00
}
2012-10-11 00:53:29 +04:00
static int skel_fchown ( vfs_handle_struct * handle , files_struct * fsp ,
uid_t uid , gid_t gid )
2003-06-04 17:13:41 +04:00
{
2008-01-07 16:26:00 +03:00
return SMB_VFS_NEXT_FCHOWN ( handle , fsp , uid , gid ) ;
2003-06-04 17:13:41 +04:00
}
2016-03-04 01:34:57 +03:00
static int skel_lchown ( vfs_handle_struct * handle ,
const struct smb_filename * smb_fname ,
uid_t uid ,
gid_t gid )
2007-05-24 03:55:12 +04:00
{
2016-03-04 01:34:57 +03:00
return SMB_VFS_NEXT_LCHOWN ( handle , smb_fname , uid , gid ) ;
2007-05-24 03:55:12 +04:00
}
2017-06-29 21:29:33 +03:00
static int skel_chdir ( vfs_handle_struct * handle ,
const struct smb_filename * smb_fname )
2003-06-04 17:13:41 +04:00
{
2017-06-29 21:29:33 +03:00
return SMB_VFS_NEXT_CHDIR ( handle , smb_fname ) ;
2003-06-04 17:13:41 +04:00
}
2017-06-30 00:32:47 +03:00
static struct smb_filename * skel_getwd ( vfs_handle_struct * handle ,
TALLOC_CTX * ctx )
2003-06-04 17:13:41 +04:00
{
2017-06-30 00:32:47 +03:00
return SMB_VFS_NEXT_GETWD ( handle , ctx ) ;
2003-06-04 17:13:41 +04:00
}
2009-07-03 00:39:20 +04:00
static int skel_ntimes ( vfs_handle_struct * handle ,
const struct smb_filename * smb_fname ,
struct smb_file_time * ft )
2003-06-04 17:13:41 +04:00
{
2009-07-03 00:39:20 +04:00
return SMB_VFS_NEXT_NTIMES ( handle , smb_fname , ft ) ;
2003-06-04 17:13:41 +04:00
}
2012-10-11 00:53:29 +04:00
static int skel_ftruncate ( vfs_handle_struct * handle , files_struct * fsp ,
off_t offset )
2003-06-04 17:13:41 +04:00
{
2008-01-07 17:55:09 +03:00
return SMB_VFS_NEXT_FTRUNCATE ( handle , fsp , offset ) ;
2003-06-04 17:13:41 +04:00
}
2010-12-18 10:08:01 +03:00
static int skel_fallocate ( vfs_handle_struct * handle , files_struct * fsp ,
2015-02-09 20:21:59 +03:00
uint32_t mode , off_t offset , off_t len )
2010-12-03 03:25:59 +03:00
{
2010-12-18 10:08:01 +03:00
return SMB_VFS_NEXT_FALLOCATE ( handle , fsp , mode , offset , len ) ;
2010-12-03 03:25:59 +03:00
}
2012-10-11 00:53:29 +04:00
static bool skel_lock ( vfs_handle_struct * handle , files_struct * fsp , int op ,
off_t offset , off_t count , int type )
2003-06-04 17:13:41 +04:00
{
2008-01-07 18:38:23 +03:00
return SMB_VFS_NEXT_LOCK ( handle , fsp , op , offset , count , type ) ;
2003-06-04 17:13:41 +04:00
}
2012-10-11 00:53:29 +04:00
static int skel_kernel_flock ( struct vfs_handle_struct * handle ,
2015-05-14 03:26:01 +03:00
struct files_struct * fsp , uint32_t share_mode ,
uint32_t access_mask )
2009-09-26 08:39:52 +04:00
{
2009-12-07 12:15:49 +03:00
return SMB_VFS_NEXT_KERNEL_FLOCK ( handle , fsp , share_mode , access_mask ) ;
2009-09-26 08:39:52 +04:00
}
2019-09-27 08:49:37 +03:00
static int skel_fcntl ( struct vfs_handle_struct * handle ,
struct files_struct * fsp , int cmd , va_list cmd_arg )
{
void * arg ;
va_list dup_cmd_arg ;
int result ;
va_copy ( dup_cmd_arg , cmd_arg ) ;
arg = va_arg ( dup_cmd_arg , void * ) ;
result = SMB_VFS_NEXT_FCNTL ( handle , fsp , cmd , arg ) ;
va_end ( dup_cmd_arg ) ;
return result ;
}
2012-10-11 00:53:29 +04:00
static int skel_linux_setlease ( struct vfs_handle_struct * handle ,
struct files_struct * fsp , int leasetype )
2009-09-26 08:39:52 +04:00
{
return SMB_VFS_NEXT_LINUX_SETLEASE ( handle , fsp , leasetype ) ;
}
2012-10-11 00:53:29 +04:00
static bool skel_getlock ( vfs_handle_struct * handle , files_struct * fsp ,
off_t * poffset , off_t * pcount , int * ptype ,
pid_t * ppid )
2006-04-10 19:33:04 +04:00
{
2008-01-09 00:13:25 +03:00
return SMB_VFS_NEXT_GETLOCK ( handle , fsp , poffset , pcount , ptype , ppid ) ;
2006-04-10 19:33:04 +04:00
}
2019-08-30 22:01:13 +03:00
static int skel_symlinkat ( vfs_handle_struct * handle ,
const char * link_contents ,
struct files_struct * dirfsp ,
const struct smb_filename * new_smb_fname )
{
return SMB_VFS_NEXT_SYMLINKAT ( handle ,
link_contents ,
dirfsp ,
new_smb_fname ) ;
}
2019-08-22 23:42:26 +03:00
static int skel_vfs_readlinkat ( vfs_handle_struct * handle ,
files_struct * dirfsp ,
const struct smb_filename * smb_fname ,
char * buf ,
size_t bufsiz )
{
return SMB_VFS_NEXT_READLINKAT ( handle ,
dirfsp ,
smb_fname ,
buf ,
bufsiz ) ;
}
2019-08-13 02:49:26 +03:00
static int skel_linkat ( vfs_handle_struct * handle ,
files_struct * srcfsp ,
const struct smb_filename * old_smb_fname ,
files_struct * dstfsp ,
const struct smb_filename * new_smb_fname ,
int flags )
{
return SMB_VFS_NEXT_LINKAT ( handle ,
srcfsp ,
old_smb_fname ,
dstfsp ,
new_smb_fname ,
flags ) ;
}
2019-08-21 02:31:00 +03:00
static int skel_mknodat ( vfs_handle_struct * handle ,
files_struct * dirfsp ,
const struct smb_filename * smb_fname ,
mode_t mode ,
SMB_DEV_T dev )
{
return SMB_VFS_NEXT_MKNODAT ( handle ,
dirfsp ,
smb_fname ,
mode ,
dev ) ;
}
2017-06-30 21:32:59 +03:00
static struct smb_filename * skel_realpath ( vfs_handle_struct * handle ,
TALLOC_CTX * ctx ,
const struct smb_filename * smb_fname )
2003-06-04 17:13:41 +04:00
{
2017-06-30 21:32:59 +03:00
return SMB_VFS_NEXT_REALPATH ( handle , ctx , smb_fname ) ;
2003-06-04 17:13:41 +04:00
}
2017-05-20 02:15:55 +03:00
static int skel_chflags ( vfs_handle_struct * handle ,
const struct smb_filename * smb_fname ,
2012-10-11 00:53:29 +04:00
uint flags )
2007-03-08 20:06:16 +03:00
{
2017-05-20 02:15:55 +03:00
return SMB_VFS_NEXT_CHFLAGS ( handle , smb_fname , flags ) ;
2007-03-08 20:06:16 +03:00
}
2007-08-02 13:19:04 +04:00
static struct file_id skel_file_id_create ( vfs_handle_struct * handle ,
2009-02-16 10:38:53 +03:00
const SMB_STRUCT_STAT * sbuf )
2007-08-02 13:19:04 +04:00
{
2009-02-16 10:38:53 +03:00
return SMB_VFS_NEXT_FILE_ID_CREATE ( handle , sbuf ) ;
2007-08-02 13:19:04 +04:00
}
2019-06-29 15:08:04 +03:00
static uint64_t skel_fs_file_id ( vfs_handle_struct * handle ,
const SMB_STRUCT_STAT * sbuf )
{
return SMB_VFS_NEXT_FS_FILE_ID ( handle , sbuf ) ;
}
2017-06-03 13:57:59 +03:00
struct skel_offload_read_state {
struct vfs_handle_struct * handle ;
DATA_BLOB token ;
} ;
static void skel_offload_read_done ( struct tevent_req * subreq ) ;
static struct tevent_req * skel_offload_read_send (
TALLOC_CTX * mem_ctx ,
struct tevent_context * ev ,
struct vfs_handle_struct * handle ,
struct files_struct * fsp ,
uint32_t fsctl ,
uint32_t ttl ,
off_t offset ,
size_t to_copy )
{
struct tevent_req * req = NULL ;
struct skel_offload_read_state * state = NULL ;
struct tevent_req * subreq = NULL ;
req = tevent_req_create ( mem_ctx , & state , struct skel_offload_read_state ) ;
if ( req = = NULL ) {
return NULL ;
}
* state = ( struct skel_offload_read_state ) {
. handle = handle ,
} ;
subreq = SMB_VFS_NEXT_OFFLOAD_READ_SEND ( mem_ctx , ev , handle , fsp ,
fsctl , ttl , offset , to_copy ) ;
if ( tevent_req_nomem ( subreq , req ) ) {
return tevent_req_post ( req , ev ) ;
}
tevent_req_set_callback ( subreq , skel_offload_read_done , req ) ;
return req ;
}
static void skel_offload_read_done ( struct tevent_req * subreq )
{
struct tevent_req * req = tevent_req_callback_data (
subreq , struct tevent_req ) ;
struct skel_offload_read_state * state = tevent_req_data (
req , struct skel_offload_read_state ) ;
NTSTATUS status ;
status = SMB_VFS_NEXT_OFFLOAD_READ_RECV ( subreq ,
state - > handle ,
state ,
& state - > token ) ;
TALLOC_FREE ( subreq ) ;
if ( tevent_req_nterror ( req , status ) ) {
return ;
}
tevent_req_done ( req ) ;
return ;
}
static NTSTATUS skel_offload_read_recv ( struct tevent_req * req ,
struct vfs_handle_struct * handle ,
TALLOC_CTX * mem_ctx ,
DATA_BLOB * _token )
{
struct skel_offload_read_state * state = tevent_req_data (
req , struct skel_offload_read_state ) ;
DATA_BLOB token ;
NTSTATUS status ;
if ( tevent_req_is_nterror ( req , & status ) ) {
tevent_req_received ( req ) ;
return status ;
}
token = data_blob_talloc ( mem_ctx ,
state - > token . data ,
state - > token . length ) ;
tevent_req_received ( req ) ;
if ( token . data = = NULL ) {
return NT_STATUS_NO_MEMORY ;
}
* _token = token ;
return NT_STATUS_OK ;
}
2017-06-04 14:50:33 +03:00
struct skel_offload_write_state {
2013-01-15 20:22:59 +04:00
struct vfs_handle_struct * handle ;
off_t copied ;
} ;
2017-06-04 14:50:33 +03:00
static void skel_offload_write_done ( struct tevent_req * subreq ) ;
2013-01-15 20:22:59 +04:00
2017-06-04 14:50:33 +03:00
static struct tevent_req * skel_offload_write_send ( struct vfs_handle_struct * handle ,
2013-01-15 20:22:59 +04:00
TALLOC_CTX * mem_ctx ,
struct tevent_context * ev ,
2017-06-09 14:02:49 +03:00
uint32_t fsctl ,
DATA_BLOB * token ,
off_t transfer_offset ,
2013-01-15 20:22:59 +04:00
struct files_struct * dest_fsp ,
off_t dest_off ,
2017-06-10 10:05:55 +03:00
off_t num )
2013-01-15 20:22:59 +04:00
{
struct tevent_req * req ;
struct tevent_req * subreq ;
2017-06-04 14:50:33 +03:00
struct skel_offload_write_state * state ;
2013-01-15 20:22:59 +04:00
2017-06-04 14:50:33 +03:00
req = tevent_req_create ( mem_ctx , & state , struct skel_offload_write_state ) ;
2013-01-15 20:22:59 +04:00
if ( req = = NULL ) {
return NULL ;
}
2017-06-04 14:50:33 +03:00
state - > handle = handle ;
subreq = SMB_VFS_NEXT_OFFLOAD_WRITE_SEND ( handle , state , ev ,
2017-06-09 14:02:49 +03:00
fsctl , token , transfer_offset ,
2017-06-10 10:05:55 +03:00
dest_fsp , dest_off , num ) ;
2013-01-15 20:22:59 +04:00
if ( tevent_req_nomem ( subreq , req ) ) {
return tevent_req_post ( req , ev ) ;
}
2017-06-04 14:50:33 +03:00
tevent_req_set_callback ( subreq , skel_offload_write_done , req ) ;
2013-01-15 20:22:59 +04:00
return req ;
}
2017-06-04 14:50:33 +03:00
static void skel_offload_write_done ( struct tevent_req * subreq )
2013-01-15 20:22:59 +04:00
{
struct tevent_req * req = tevent_req_callback_data (
subreq , struct tevent_req ) ;
2017-06-04 14:50:33 +03:00
struct skel_offload_write_state * state
= tevent_req_data ( req , struct skel_offload_write_state ) ;
2013-01-15 20:22:59 +04:00
NTSTATUS status ;
2017-06-04 14:50:33 +03:00
status = SMB_VFS_NEXT_OFFLOAD_WRITE_RECV ( state - > handle ,
2013-01-15 20:22:59 +04:00
subreq ,
2017-06-04 14:50:33 +03:00
& state - > copied ) ;
2013-01-15 20:22:59 +04:00
TALLOC_FREE ( subreq ) ;
if ( tevent_req_nterror ( req , status ) ) {
return ;
}
tevent_req_done ( req ) ;
}
2017-06-04 14:50:33 +03:00
static NTSTATUS skel_offload_write_recv ( struct vfs_handle_struct * handle ,
2013-01-15 20:22:59 +04:00
struct tevent_req * req ,
off_t * copied )
{
2017-06-04 14:50:33 +03:00
struct skel_offload_write_state * state
= tevent_req_data ( req , struct skel_offload_write_state ) ;
2013-01-15 20:22:59 +04:00
NTSTATUS status ;
2017-06-04 14:50:33 +03:00
* copied = state - > copied ;
2013-01-15 20:22:59 +04:00
if ( tevent_req_is_nterror ( req , & status ) ) {
tevent_req_received ( req ) ;
return status ;
}
tevent_req_received ( req ) ;
return NT_STATUS_OK ;
}
2013-11-18 17:54:30 +04:00
static NTSTATUS skel_get_compression ( struct vfs_handle_struct * handle ,
TALLOC_CTX * mem_ctx ,
struct files_struct * fsp ,
struct smb_filename * smb_fname ,
uint16_t * _compression_fmt )
{
return SMB_VFS_NEXT_GET_COMPRESSION ( handle , mem_ctx , fsp , smb_fname ,
_compression_fmt ) ;
}
static NTSTATUS skel_set_compression ( struct vfs_handle_struct * handle ,
TALLOC_CTX * mem_ctx ,
struct files_struct * fsp ,
uint16_t compression_fmt )
{
return SMB_VFS_NEXT_SET_COMPRESSION ( handle , mem_ctx , fsp ,
compression_fmt ) ;
}
2009-09-26 08:39:52 +04:00
static NTSTATUS skel_streaminfo ( struct vfs_handle_struct * handle ,
struct files_struct * fsp ,
2016-03-05 01:16:13 +03:00
const struct smb_filename * smb_fname ,
2009-09-26 08:39:52 +04:00
TALLOC_CTX * mem_ctx ,
unsigned int * num_streams ,
struct stream_struct * * streams )
{
return SMB_VFS_NEXT_STREAMINFO ( handle ,
2016-03-05 01:16:13 +03:00
fsp ,
smb_fname ,
mem_ctx ,
num_streams ,
streams ) ;
2009-09-26 08:39:52 +04:00
}
static int skel_get_real_filename ( struct vfs_handle_struct * handle ,
2012-10-11 00:53:29 +04:00
const char * path ,
const char * name ,
TALLOC_CTX * mem_ctx , char * * found_name )
2009-09-26 08:39:52 +04:00
{
return SMB_VFS_NEXT_GET_REAL_FILENAME ( handle ,
2012-10-11 00:53:29 +04:00
path , name , mem_ctx , found_name ) ;
2009-09-26 08:39:52 +04:00
}
static const char * skel_connectpath ( struct vfs_handle_struct * handle ,
2017-06-30 23:37:03 +03:00
const struct smb_filename * smb_fname )
2009-09-26 08:39:52 +04:00
{
2017-06-30 23:37:03 +03:00
return SMB_VFS_NEXT_CONNECTPATH ( handle , smb_fname ) ;
2009-09-26 08:39:52 +04:00
}
static NTSTATUS skel_brl_lock_windows ( struct vfs_handle_struct * handle ,
2012-10-11 00:53:29 +04:00
struct byte_range_lock * br_lck ,
2019-07-01 15:55:42 +03:00
struct lock_struct * plock )
2009-09-26 08:39:52 +04:00
{
2019-07-01 15:55:42 +03:00
return SMB_VFS_NEXT_BRL_LOCK_WINDOWS ( handle , br_lck , plock ) ;
2009-09-26 08:39:52 +04:00
}
static bool skel_brl_unlock_windows ( struct vfs_handle_struct * handle ,
2012-10-11 00:53:29 +04:00
struct byte_range_lock * br_lck ,
const struct lock_struct * plock )
2009-09-26 08:39:52 +04:00
{
2019-07-01 16:25:27 +03:00
return SMB_VFS_NEXT_BRL_UNLOCK_WINDOWS ( handle , br_lck , plock ) ;
2009-09-26 08:39:52 +04:00
}
2017-07-09 15:34:10 +03:00
static bool skel_strict_lock_check ( struct vfs_handle_struct * handle ,
struct files_struct * fsp ,
struct lock_struct * plock )
2009-09-26 08:39:52 +04:00
{
2017-07-09 15:34:10 +03:00
return SMB_VFS_NEXT_STRICT_LOCK_CHECK ( handle , fsp , plock ) ;
2009-09-26 08:39:52 +04:00
}
static NTSTATUS skel_translate_name ( struct vfs_handle_struct * handle ,
2012-10-11 00:53:29 +04:00
const char * mapped_name ,
enum vfs_translate_direction direction ,
TALLOC_CTX * mem_ctx , char * * pmapped_name )
2009-09-26 08:39:52 +04:00
{
2009-12-07 12:15:49 +03:00
return SMB_VFS_NEXT_TRANSLATE_NAME ( handle , mapped_name , direction ,
mem_ctx , pmapped_name ) ;
2009-09-26 08:39:52 +04:00
}
2011-10-11 20:18:46 +04:00
static NTSTATUS skel_fsctl ( struct vfs_handle_struct * handle ,
2012-10-11 00:53:29 +04:00
struct files_struct * fsp ,
TALLOC_CTX * ctx ,
uint32_t function ,
uint16_t req_flags , /* Needed for UNICODE ... */
const uint8_t * _in_data ,
uint32_t in_len ,
uint8_t * * _out_data ,
uint32_t max_out_len , uint32_t * out_len )
2011-10-11 20:18:46 +04:00
{
return SMB_VFS_NEXT_FSCTL ( handle ,
2012-10-11 00:53:29 +04:00
fsp ,
ctx ,
function ,
req_flags ,
_in_data ,
in_len , _out_data , max_out_len , out_len ) ;
2011-10-11 20:18:46 +04:00
}
2014-11-26 16:30:37 +03:00
static NTSTATUS skel_readdir_attr ( struct vfs_handle_struct * handle ,
const struct smb_filename * fname ,
TALLOC_CTX * mem_ctx ,
struct readdir_attr_data * * pattr_data )
{
return SMB_VFS_NEXT_READDIR_ATTR ( handle , fname , mem_ctx , pattr_data ) ;
}
2016-03-20 22:51:32 +03:00
static NTSTATUS skel_get_dos_attributes ( struct vfs_handle_struct * handle ,
struct smb_filename * smb_fname ,
uint32_t * dosmode )
{
return SMB_VFS_NEXT_GET_DOS_ATTRIBUTES ( handle ,
smb_fname ,
dosmode ) ;
}
2018-03-15 15:08:55 +03:00
struct skel_get_dos_attributes_state {
struct vfs_aio_state aio_state ;
uint32_t dosmode ;
} ;
static void skel_get_dos_attributes_done ( struct tevent_req * subreq ) ;
static struct tevent_req * skel_get_dos_attributes_send (
TALLOC_CTX * mem_ctx ,
2018-12-28 14:12:20 +03:00
struct tevent_context * ev ,
2018-03-15 15:08:55 +03:00
struct vfs_handle_struct * handle ,
files_struct * dir_fsp ,
struct smb_filename * smb_fname )
{
struct tevent_req * req = NULL ;
struct skel_get_dos_attributes_state * state = NULL ;
struct tevent_req * subreq = NULL ;
req = tevent_req_create ( mem_ctx , & state ,
struct skel_get_dos_attributes_state ) ;
if ( req = = NULL ) {
return NULL ;
}
subreq = SMB_VFS_NEXT_GET_DOS_ATTRIBUTES_SEND ( mem_ctx ,
2018-12-28 14:12:20 +03:00
ev ,
2018-03-15 15:08:55 +03:00
handle ,
dir_fsp ,
smb_fname ) ;
if ( tevent_req_nomem ( subreq , req ) ) {
return tevent_req_post ( req , ev ) ;
}
tevent_req_set_callback ( subreq , skel_get_dos_attributes_done , req ) ;
return req ;
}
static void skel_get_dos_attributes_done ( struct tevent_req * subreq )
{
struct tevent_req * req =
tevent_req_callback_data ( subreq ,
struct tevent_req ) ;
struct skel_get_dos_attributes_state * state =
tevent_req_data ( req ,
struct skel_get_dos_attributes_state ) ;
NTSTATUS status ;
status = SMB_VFS_NEXT_GET_DOS_ATTRIBUTES_RECV ( subreq ,
& state - > aio_state ,
& state - > dosmode ) ;
TALLOC_FREE ( subreq ) ;
if ( tevent_req_nterror ( req , status ) ) {
return ;
}
tevent_req_done ( req ) ;
return ;
}
static NTSTATUS skel_get_dos_attributes_recv ( struct tevent_req * req ,
struct vfs_aio_state * aio_state ,
uint32_t * dosmode )
{
struct skel_get_dos_attributes_state * state =
tevent_req_data ( req ,
struct skel_get_dos_attributes_state ) ;
NTSTATUS status ;
if ( tevent_req_is_nterror ( req , & status ) ) {
tevent_req_received ( req ) ;
return status ;
}
* aio_state = state - > aio_state ;
* dosmode = state - > dosmode ;
tevent_req_received ( req ) ;
return NT_STATUS_OK ;
}
2016-03-20 22:51:32 +03:00
static NTSTATUS skel_fget_dos_attributes ( struct vfs_handle_struct * handle ,
struct files_struct * fsp ,
uint32_t * dosmode )
{
return SMB_VFS_NEXT_FGET_DOS_ATTRIBUTES ( handle ,
fsp ,
dosmode ) ;
}
static NTSTATUS skel_set_dos_attributes ( struct vfs_handle_struct * handle ,
const struct smb_filename * smb_fname ,
uint32_t dosmode )
{
return SMB_VFS_NEXT_SET_DOS_ATTRIBUTES ( handle ,
smb_fname ,
dosmode ) ;
}
static NTSTATUS skel_fset_dos_attributes ( struct vfs_handle_struct * handle ,
struct files_struct * fsp ,
uint32_t dosmode )
{
return SMB_VFS_NEXT_FSET_DOS_ATTRIBUTES ( handle ,
fsp ,
dosmode ) ;
}
2008-01-09 00:13:25 +03:00
static NTSTATUS skel_fget_nt_acl ( vfs_handle_struct * handle , files_struct * fsp ,
2015-05-14 03:26:01 +03:00
uint32_t security_info ,
2012-10-10 04:50:27 +04:00
TALLOC_CTX * mem_ctx ,
struct security_descriptor * * ppdesc )
2003-06-04 17:13:41 +04:00
{
2012-10-11 00:53:29 +04:00
return SMB_VFS_NEXT_FGET_NT_ACL ( handle , fsp , security_info , mem_ctx ,
ppdesc ) ;
2003-06-04 17:13:41 +04:00
}
2008-01-09 00:13:25 +03:00
static NTSTATUS skel_get_nt_acl ( vfs_handle_struct * handle ,
2016-02-12 21:30:10 +03:00
const struct smb_filename * smb_fname ,
uint32_t security_info ,
2012-10-10 04:50:27 +04:00
TALLOC_CTX * mem_ctx ,
struct security_descriptor * * ppdesc )
2003-06-04 17:13:41 +04:00
{
2016-02-12 21:30:10 +03:00
return SMB_VFS_NEXT_GET_NT_ACL ( handle ,
smb_fname ,
security_info ,
mem_ctx ,
ppdesc ) ;
2003-06-04 17:13:41 +04:00
}
2007-06-27 02:49:10 +04:00
static NTSTATUS skel_fset_nt_acl ( vfs_handle_struct * handle , files_struct * fsp ,
2015-05-14 03:26:01 +03:00
uint32_t security_info_sent ,
2012-10-11 00:53:29 +04:00
const struct security_descriptor * psd )
2003-06-04 17:13:41 +04:00
{
2008-01-07 02:21:12 +03:00
return SMB_VFS_NEXT_FSET_NT_ACL ( handle , fsp , security_info_sent , psd ) ;
2003-06-04 17:13:41 +04:00
}
2012-10-10 03:18:32 +04:00
static SMB_ACL_T skel_sys_acl_get_file ( vfs_handle_struct * handle ,
2017-05-24 03:11:18 +03:00
const struct smb_filename * smb_fname ,
2012-10-10 03:18:32 +04:00
SMB_ACL_TYPE_T type ,
TALLOC_CTX * mem_ctx )
2003-06-04 17:13:41 +04:00
{
2017-05-24 03:11:18 +03:00
return SMB_VFS_NEXT_SYS_ACL_GET_FILE ( handle , smb_fname , type , mem_ctx ) ;
2003-06-04 17:13:41 +04:00
}
2012-10-10 03:18:32 +04:00
static SMB_ACL_T skel_sys_acl_get_fd ( vfs_handle_struct * handle ,
2012-10-11 00:53:29 +04:00
files_struct * fsp , TALLOC_CTX * mem_ctx )
2003-06-04 17:13:41 +04:00
{
2012-10-10 03:18:32 +04:00
return SMB_VFS_NEXT_SYS_ACL_GET_FD ( handle , fsp , mem_ctx ) ;
2003-06-04 17:13:41 +04:00
}
2012-10-11 00:53:29 +04:00
static int skel_sys_acl_blob_get_file ( vfs_handle_struct * handle ,
2017-05-24 03:35:59 +03:00
const struct smb_filename * smb_fname ,
TALLOC_CTX * mem_ctx ,
char * * blob_description ,
DATA_BLOB * blob )
2012-09-10 06:44:01 +04:00
{
2017-05-24 03:35:59 +03:00
return SMB_VFS_NEXT_SYS_ACL_BLOB_GET_FILE ( handle , smb_fname , mem_ctx ,
2012-10-11 00:53:29 +04:00
blob_description , blob ) ;
2012-09-10 06:44:01 +04:00
}
2012-10-11 00:53:29 +04:00
static int skel_sys_acl_blob_get_fd ( vfs_handle_struct * handle ,
files_struct * fsp , TALLOC_CTX * mem_ctx ,
char * * blob_description , DATA_BLOB * blob )
2012-09-10 06:44:01 +04:00
{
2012-10-11 00:53:29 +04:00
return SMB_VFS_NEXT_SYS_ACL_BLOB_GET_FD ( handle , fsp , mem_ctx ,
blob_description , blob ) ;
2012-09-10 06:44:01 +04:00
}
2017-05-24 20:47:46 +03:00
static int skel_sys_acl_set_file ( vfs_handle_struct * handle ,
const struct smb_filename * smb_fname ,
SMB_ACL_TYPE_T acltype ,
SMB_ACL_T theacl )
2003-06-04 17:13:41 +04:00
{
2017-05-24 20:47:46 +03:00
return SMB_VFS_NEXT_SYS_ACL_SET_FILE ( handle , smb_fname ,
acltype , theacl ) ;
2003-06-04 17:13:41 +04:00
}
2012-10-11 00:53:29 +04:00
static int skel_sys_acl_set_fd ( vfs_handle_struct * handle , files_struct * fsp ,
SMB_ACL_T theacl )
2003-06-04 17:13:41 +04:00
{
2008-01-09 00:13:25 +03:00
return SMB_VFS_NEXT_SYS_ACL_SET_FD ( handle , fsp , theacl ) ;
2003-06-04 17:13:41 +04:00
}
2012-10-11 00:53:29 +04:00
static int skel_sys_acl_delete_def_file ( vfs_handle_struct * handle ,
2017-05-24 01:33:31 +03:00
const struct smb_filename * smb_fname )
2003-06-04 17:13:41 +04:00
{
2017-05-24 01:33:31 +03:00
return SMB_VFS_NEXT_SYS_ACL_DELETE_DEF_FILE ( handle , smb_fname ) ;
2003-06-04 17:13:41 +04:00
}
2017-05-26 02:42:04 +03:00
static ssize_t skel_getxattr ( vfs_handle_struct * handle ,
const struct smb_filename * smb_fname ,
const char * name ,
void * value ,
size_t size )
2003-06-06 11:09:30 +04:00
{
2017-05-26 02:42:04 +03:00
return SMB_VFS_NEXT_GETXATTR ( handle , smb_fname , name , value , size ) ;
2003-06-06 11:09:30 +04:00
}
2018-03-13 10:14:53 +03:00
struct skel_getxattrat_state {
struct vfs_aio_state aio_state ;
ssize_t xattr_size ;
uint8_t * xattr_value ;
} ;
static void skel_getxattrat_done ( struct tevent_req * subreq ) ;
static struct tevent_req * skel_getxattrat_send (
TALLOC_CTX * mem_ctx ,
2018-12-27 18:32:46 +03:00
struct tevent_context * ev ,
2018-03-13 10:14:53 +03:00
struct vfs_handle_struct * handle ,
files_struct * dir_fsp ,
const struct smb_filename * smb_fname ,
const char * xattr_name ,
size_t alloc_hint )
{
struct tevent_req * req = NULL ;
struct skel_getxattrat_state * state = NULL ;
struct tevent_req * subreq = NULL ;
req = tevent_req_create ( mem_ctx , & state ,
struct skel_getxattrat_state ) ;
if ( req = = NULL ) {
return NULL ;
}
subreq = SMB_VFS_NEXT_GETXATTRAT_SEND ( state ,
2018-12-27 18:32:46 +03:00
ev ,
2018-03-13 10:14:53 +03:00
handle ,
dir_fsp ,
smb_fname ,
xattr_name ,
alloc_hint ) ;
if ( tevent_req_nomem ( subreq , req ) ) {
return tevent_req_post ( req , ev ) ;
}
tevent_req_set_callback ( subreq , skel_getxattrat_done , req ) ;
return req ;
}
static void skel_getxattrat_done ( struct tevent_req * subreq )
{
struct tevent_req * req = tevent_req_callback_data (
subreq , struct tevent_req ) ;
struct skel_getxattrat_state * state = tevent_req_data (
req , struct skel_getxattrat_state ) ;
state - > xattr_size = SMB_VFS_NEXT_GETXATTRAT_RECV ( subreq ,
& state - > aio_state ,
state ,
& state - > xattr_value ) ;
TALLOC_FREE ( subreq ) ;
if ( state - > xattr_size = = - 1 ) {
tevent_req_error ( req , state - > aio_state . error ) ;
return ;
}
tevent_req_done ( req ) ;
}
static ssize_t skel_getxattrat_recv ( struct tevent_req * req ,
struct vfs_aio_state * aio_state ,
TALLOC_CTX * mem_ctx ,
uint8_t * * xattr_value )
{
struct skel_getxattrat_state * state = tevent_req_data (
req , struct skel_getxattrat_state ) ;
ssize_t xattr_size ;
if ( tevent_req_is_unix_error ( req , & aio_state - > error ) ) {
tevent_req_received ( req ) ;
return - 1 ;
}
* aio_state = state - > aio_state ;
xattr_size = state - > xattr_size ;
if ( xattr_value ! = NULL ) {
* xattr_value = talloc_move ( mem_ctx , & state - > xattr_value ) ;
}
tevent_req_received ( req ) ;
return xattr_size ;
}
2012-10-11 00:53:29 +04:00
static ssize_t skel_fgetxattr ( vfs_handle_struct * handle ,
struct files_struct * fsp , const char * name ,
void * value , size_t size )
2003-06-06 11:09:30 +04:00
{
2012-10-11 00:53:29 +04:00
return SMB_VFS_NEXT_FGETXATTR ( handle , fsp , name , value , size ) ;
2003-06-06 11:09:30 +04:00
}
2017-05-23 23:12:29 +03:00
static ssize_t skel_listxattr ( vfs_handle_struct * handle ,
const struct smb_filename * smb_fname ,
char * list ,
size_t size )
2003-06-06 11:09:30 +04:00
{
2017-05-23 23:12:29 +03:00
return SMB_VFS_NEXT_LISTXATTR ( handle , smb_fname , list , size ) ;
2003-06-06 11:09:30 +04:00
}
2012-10-11 00:53:29 +04:00
static ssize_t skel_flistxattr ( vfs_handle_struct * handle ,
struct files_struct * fsp , char * list ,
size_t size )
2003-06-06 11:09:30 +04:00
{
2012-10-11 00:53:29 +04:00
return SMB_VFS_NEXT_FLISTXATTR ( handle , fsp , list , size ) ;
2003-06-06 11:09:30 +04:00
}
2017-05-24 21:35:50 +03:00
static int skel_removexattr ( vfs_handle_struct * handle ,
const struct smb_filename * smb_fname ,
const char * name )
2003-06-06 11:09:30 +04:00
{
2017-05-24 21:35:50 +03:00
return SMB_VFS_NEXT_REMOVEXATTR ( handle , smb_fname , name ) ;
2003-06-06 11:09:30 +04:00
}
2012-10-11 00:53:29 +04:00
static int skel_fremovexattr ( vfs_handle_struct * handle ,
struct files_struct * fsp , const char * name )
2003-06-06 11:09:30 +04:00
{
2012-10-11 00:53:29 +04:00
return SMB_VFS_NEXT_FREMOVEXATTR ( handle , fsp , name ) ;
2003-06-06 11:09:30 +04:00
}
2017-05-25 22:41:31 +03:00
static int skel_setxattr ( vfs_handle_struct * handle ,
const struct smb_filename * smb_fname ,
const char * name ,
const void * value ,
size_t size ,
int flags )
2003-06-06 11:09:30 +04:00
{
2017-05-25 22:41:31 +03:00
return SMB_VFS_NEXT_SETXATTR ( handle , smb_fname ,
name , value , size , flags ) ;
2003-06-06 11:09:30 +04:00
}
2012-10-11 00:53:29 +04:00
static int skel_fsetxattr ( vfs_handle_struct * handle , struct files_struct * fsp ,
const char * name , const void * value , size_t size ,
int flags )
2003-06-06 11:09:30 +04:00
{
2012-10-11 00:53:29 +04:00
return SMB_VFS_NEXT_FSETXATTR ( handle , fsp , name , value , size , flags ) ;
2003-06-06 11:09:30 +04:00
}
2003-06-04 17:13:41 +04:00
2012-10-11 00:53:29 +04:00
static bool skel_aio_force ( struct vfs_handle_struct * handle ,
struct files_struct * fsp )
2008-01-17 04:22:31 +03:00
{
2012-10-11 00:53:29 +04:00
return SMB_VFS_NEXT_AIO_FORCE ( handle , fsp ) ;
2008-01-17 04:22:31 +03:00
}
2018-07-24 19:58:59 +03:00
static NTSTATUS skel_audit_file ( struct vfs_handle_struct * handle ,
struct smb_filename * file ,
struct security_acl * sacl ,
uint32_t access_requested ,
uint32_t access_denied )
{
return SMB_VFS_NEXT_AUDIT_FILE ( handle ,
file ,
sacl ,
access_requested ,
access_denied ) ;
}
2018-07-24 23:03:01 +03:00
static NTSTATUS skel_durable_cookie ( struct vfs_handle_struct * handle ,
struct files_struct * fsp ,
TALLOC_CTX * mem_ctx ,
DATA_BLOB * cookie )
{
return SMB_VFS_NEXT_DURABLE_COOKIE ( handle ,
fsp ,
mem_ctx ,
cookie ) ;
}
static NTSTATUS skel_durable_disconnect ( struct vfs_handle_struct * handle ,
struct files_struct * fsp ,
const DATA_BLOB old_cookie ,
TALLOC_CTX * mem_ctx ,
DATA_BLOB * new_cookie )
{
return SMB_VFS_NEXT_DURABLE_DISCONNECT ( handle ,
fsp ,
old_cookie ,
mem_ctx ,
new_cookie ) ;
}
static NTSTATUS skel_durable_reconnect ( struct vfs_handle_struct * handle ,
struct smb_request * smb1req ,
struct smbXsrv_open * op ,
const DATA_BLOB old_cookie ,
TALLOC_CTX * mem_ctx ,
struct files_struct * * fsp ,
DATA_BLOB * new_cookie )
{
return SMB_VFS_NEXT_DURABLE_RECONNECT ( handle ,
smb1req ,
op ,
old_cookie ,
mem_ctx ,
fsp ,
new_cookie ) ;
}
2003-06-04 17:13:41 +04:00
/* VFS operations structure */
2018-07-25 13:30:37 +03:00
static struct vfs_fn_pointers skel_transparent_fns = {
2003-06-04 17:13:41 +04:00
/* Disk operations */
2009-09-26 08:39:52 +04:00
. connect_fn = skel_connect ,
2011-12-04 08:45:04 +04:00
. disconnect_fn = skel_disconnect ,
. disk_free_fn = skel_disk_free ,
. get_quota_fn = skel_get_quota ,
. set_quota_fn = skel_set_quota ,
. get_shadow_copy_data_fn = skel_get_shadow_copy_data ,
. statvfs_fn = skel_statvfs ,
. fs_capabilities_fn = skel_fs_capabilities ,
. get_dfs_referrals_fn = skel_get_dfs_referrals ,
2012-04-10 05:16:57 +04:00
. snap_check_path_fn = skel_snap_check_path ,
. snap_create_fn = skel_snap_create ,
. snap_delete_fn = skel_snap_delete ,
2003-08-08 01:49:01 +04:00
2003-06-04 17:13:41 +04:00
/* Directory operations */
2011-12-04 08:45:04 +04:00
. opendir_fn = skel_opendir ,
. fdopendir_fn = skel_fdopendir ,
. readdir_fn = skel_readdir ,
. seekdir_fn = skel_seekdir ,
. telldir_fn = skel_telldir ,
. rewind_dir_fn = skel_rewind_dir ,
2019-09-04 22:20:46 +03:00
. mkdirat_fn = skel_mkdirat ,
2011-12-04 08:45:04 +04:00
. closedir_fn = skel_closedir ,
2003-06-04 17:13:41 +04:00
/* File operations */
2011-04-21 00:55:25 +04:00
. open_fn = skel_open ,
2011-12-04 08:45:04 +04:00
. create_file_fn = skel_create_file ,
2009-09-26 08:39:52 +04:00
. close_fn = skel_close_fn ,
2011-12-04 08:45:04 +04:00
. pread_fn = skel_pread ,
2012-07-09 19:17:25 +04:00
. pread_send_fn = skel_pread_send ,
. pread_recv_fn = skel_pread_recv ,
2011-12-04 08:45:04 +04:00
. pwrite_fn = skel_pwrite ,
2012-07-09 19:17:25 +04:00
. pwrite_send_fn = skel_pwrite_send ,
. pwrite_recv_fn = skel_pwrite_recv ,
2011-12-04 08:45:04 +04:00
. lseek_fn = skel_lseek ,
. sendfile_fn = skel_sendfile ,
. recvfile_fn = skel_recvfile ,
2019-08-09 01:22:31 +03:00
. renameat_fn = skel_renameat ,
2012-07-13 12:22:25 +04:00
. fsync_send_fn = skel_fsync_send ,
. fsync_recv_fn = skel_fsync_recv ,
2011-12-04 08:45:04 +04:00
. stat_fn = skel_stat ,
. fstat_fn = skel_fstat ,
. lstat_fn = skel_lstat ,
. get_alloc_size_fn = skel_get_alloc_size ,
2019-09-12 00:37:31 +03:00
. unlinkat_fn = skel_unlinkat ,
2011-12-04 08:45:04 +04:00
. chmod_fn = skel_chmod ,
. fchmod_fn = skel_fchmod ,
. fchown_fn = skel_fchown ,
. lchown_fn = skel_lchown ,
. chdir_fn = skel_chdir ,
. getwd_fn = skel_getwd ,
. ntimes_fn = skel_ntimes ,
. ftruncate_fn = skel_ftruncate ,
. fallocate_fn = skel_fallocate ,
. lock_fn = skel_lock ,
. kernel_flock_fn = skel_kernel_flock ,
2019-09-27 08:49:37 +03:00
. fcntl_fn = skel_fcntl ,
2011-12-04 08:45:04 +04:00
. linux_setlease_fn = skel_linux_setlease ,
. getlock_fn = skel_getlock ,
2019-08-30 22:01:13 +03:00
. symlinkat_fn = skel_symlinkat ,
2019-08-22 23:42:26 +03:00
. readlinkat_fn = skel_vfs_readlinkat ,
2019-08-13 02:49:26 +03:00
. linkat_fn = skel_linkat ,
2019-08-21 02:31:00 +03:00
. mknodat_fn = skel_mknodat ,
2011-12-04 08:45:04 +04:00
. realpath_fn = skel_realpath ,
. chflags_fn = skel_chflags ,
. file_id_create_fn = skel_file_id_create ,
2019-06-29 15:08:04 +03:00
. fs_file_id_fn = skel_fs_file_id ,
2017-06-03 13:57:59 +03:00
. offload_read_send_fn = skel_offload_read_send ,
. offload_read_recv_fn = skel_offload_read_recv ,
2017-06-04 14:50:33 +03:00
. offload_write_send_fn = skel_offload_write_send ,
. offload_write_recv_fn = skel_offload_write_recv ,
2013-11-18 17:54:30 +04:00
. get_compression_fn = skel_get_compression ,
. set_compression_fn = skel_set_compression ,
2011-12-04 08:45:04 +04:00
. streaminfo_fn = skel_streaminfo ,
. get_real_filename_fn = skel_get_real_filename ,
. connectpath_fn = skel_connectpath ,
. brl_lock_windows_fn = skel_brl_lock_windows ,
. brl_unlock_windows_fn = skel_brl_unlock_windows ,
2017-07-09 15:34:10 +03:00
. strict_lock_check_fn = skel_strict_lock_check ,
2011-12-04 08:45:04 +04:00
. translate_name_fn = skel_translate_name ,
. fsctl_fn = skel_fsctl ,
2014-11-26 16:30:37 +03:00
. readdir_attr_fn = skel_readdir_attr ,
2018-07-24 19:58:59 +03:00
. audit_file_fn = skel_audit_file ,
2009-09-26 08:39:52 +04:00
2016-03-20 22:51:32 +03:00
/* DOS attributes. */
. get_dos_attributes_fn = skel_get_dos_attributes ,
2018-03-15 15:08:55 +03:00
. get_dos_attributes_send_fn = skel_get_dos_attributes_send ,
. get_dos_attributes_recv_fn = skel_get_dos_attributes_recv ,
2016-03-20 22:51:32 +03:00
. fget_dos_attributes_fn = skel_fget_dos_attributes ,
. set_dos_attributes_fn = skel_set_dos_attributes ,
. fset_dos_attributes_fn = skel_fset_dos_attributes ,
2009-09-26 08:39:52 +04:00
/* NT ACL operations. */
2011-12-04 08:45:04 +04:00
. fget_nt_acl_fn = skel_fget_nt_acl ,
. get_nt_acl_fn = skel_get_nt_acl ,
. fset_nt_acl_fn = skel_fset_nt_acl ,
2009-09-26 08:39:52 +04:00
/* POSIX ACL operations. */
2011-12-04 08:45:04 +04:00
. sys_acl_get_file_fn = skel_sys_acl_get_file ,
. sys_acl_get_fd_fn = skel_sys_acl_get_fd ,
2012-09-10 06:44:01 +04:00
. sys_acl_blob_get_file_fn = skel_sys_acl_blob_get_file ,
. sys_acl_blob_get_fd_fn = skel_sys_acl_blob_get_fd ,
2011-12-04 08:45:04 +04:00
. sys_acl_set_file_fn = skel_sys_acl_set_file ,
. sys_acl_set_fd_fn = skel_sys_acl_set_fd ,
. sys_acl_delete_def_file_fn = skel_sys_acl_delete_def_file ,
2008-01-17 04:22:31 +03:00
2003-06-06 11:09:30 +04:00
/* EA operations. */
2011-12-04 08:45:04 +04:00
. getxattr_fn = skel_getxattr ,
2018-03-13 10:14:53 +03:00
. getxattrat_send_fn = skel_getxattrat_send ,
. getxattrat_recv_fn = skel_getxattrat_recv ,
2011-12-04 08:45:04 +04:00
. fgetxattr_fn = skel_fgetxattr ,
. listxattr_fn = skel_listxattr ,
. flistxattr_fn = skel_flistxattr ,
. removexattr_fn = skel_removexattr ,
. fremovexattr_fn = skel_fremovexattr ,
. setxattr_fn = skel_setxattr ,
. fsetxattr_fn = skel_fsetxattr ,
2009-09-26 08:39:52 +04:00
/* aio operations */
2011-12-04 08:45:04 +04:00
. aio_force_fn = skel_aio_force ,
2018-07-24 23:03:01 +03:00
/* durable handle operations */
. durable_cookie_fn = skel_durable_cookie ,
. durable_disconnect_fn = skel_durable_disconnect ,
. durable_reconnect_fn = skel_durable_reconnect ,
2003-06-04 17:13:41 +04:00
} ;
2015-08-13 19:16:20 +03:00
static_decl_vfs ;
2017-04-20 22:24:43 +03:00
NTSTATUS vfs_skel_transparent_init ( TALLOC_CTX * ctx )
2003-06-04 17:13:41 +04:00
{
2018-07-23 10:02:52 +03:00
/*
* smb_vfs_assert_all_fns ( ) is only needed in
* order to have a complete example .
*
* A transparent vfs module typically don ' t
* need to implement every calls .
*/
smb_vfs_assert_all_fns ( & skel_transparent_fns , " skel_transparent " ) ;
2012-10-11 00:53:29 +04:00
return smb_register_vfs ( SMB_VFS_INTERFACE_VERSION , " skel_transparent " ,
& skel_transparent_fns ) ;
2003-06-04 17:13:41 +04:00
}