2010-01-06 21:45:24 +03:00
/*
* Time auditing VFS module for samba . Log time taken for VFS call to syslog
* facility .
*
* Copyright ( C ) Abhidnya Chirmule < achirmul @ in . ibm . com > 2009
*
* This program is free software ; you can redistribute it and / or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation ; either version 3 of the License , or
* ( at your option ) any later version .
*
* This program is distributed in the hope that it will be useful ,
* but WITHOUT ANY WARRANTY ; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE . See the
* GNU General Public License for more details .
*
* You should have received a copy of the GNU General Public License
* along with this program ; if not , see < http : //www.gnu.org/licenses/>.
*/
/*
* This module implements logging for time taken for all Samba VFS operations .
*
* vfs objects = time_audit
*/
# include "includes.h"
2011-03-23 00:34:22 +03:00
# include "smbd/smbd.h"
2011-03-25 15:42:42 +03:00
# include "ntioctl.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"
2010-01-06 21:45:24 +03:00
# undef DBGC_CLASS
# define DBGC_CLASS DBGC_VFS
static double audit_timeout ;
2012-07-25 20:39:57 +04:00
static void smb_time_audit_log_msg ( const char * syscallname , double elapsed ,
const char * msg )
2010-01-06 21:45:24 +03:00
{
2012-07-25 20:39:57 +04:00
DEBUG ( 0 , ( " WARNING: VFS call \" %s \" took unexpectedly long "
" (%.2f seconds) %s%s-- Validate that file and storage "
2010-01-06 21:45:24 +03:00
" subsystems are operating normally \n " , syscallname ,
2012-07-25 20:39:57 +04:00
elapsed , ( msg ! = NULL ) ? msg : " " ,
( msg ! = NULL ) ? " " : " " ) ) ;
}
static void smb_time_audit_log ( const char * syscallname , double elapsed )
{
smb_time_audit_log_msg ( syscallname , elapsed , NULL ) ;
}
static void smb_time_audit_log_fsp ( const char * syscallname , double elapsed ,
const struct files_struct * fsp )
{
char * base_name = NULL ;
char * connectpath = NULL ;
char * msg = NULL ;
if ( fsp = = NULL ) {
smb_time_audit_log ( syscallname , elapsed ) ;
return ;
}
if ( fsp - > conn )
connectpath = fsp - > conn - > connectpath ;
if ( fsp - > fsp_name )
base_name = fsp - > fsp_name - > base_name ;
if ( connectpath ! = NULL & & base_name ! = NULL ) {
msg = talloc_asprintf ( talloc_tos ( ) , " filename = \" %s/%s \" " ,
connectpath , base_name ) ;
} else if ( connectpath ! = NULL & & base_name = = NULL ) {
msg = talloc_asprintf ( talloc_tos ( ) , " connectpath = \" %s \" , "
" base_name = <NULL> " ,
connectpath ) ;
} else if ( connectpath = = NULL & & base_name ! = NULL ) {
msg = talloc_asprintf ( talloc_tos ( ) , " connectpath = <NULL>, "
" base_name = \" %s \" " ,
base_name ) ;
} else { /* connectpath == NULL && base_name == NULL */
msg = talloc_asprintf ( talloc_tos ( ) , " connectpath = <NULL>, "
" base_name = <NULL> " ) ;
}
smb_time_audit_log_msg ( syscallname , elapsed , msg ) ;
TALLOC_FREE ( msg ) ;
}
static void smb_time_audit_log_fname ( const char * syscallname , double elapsed ,
const char * fname )
{
char cwd [ PATH_MAX ] ;
char * msg = NULL ;
if ( getcwd ( cwd , sizeof ( cwd ) ) = = NULL ) {
snprintf ( cwd , sizeof ( cwd ) , " <getcwd() error %d> " , errno ) ;
}
if ( fname ! = NULL ) {
msg = talloc_asprintf ( talloc_tos ( ) ,
" cwd = \" %s \" , filename = \" %s \" " ,
cwd , fname ) ;
} else {
msg = talloc_asprintf ( talloc_tos ( ) ,
" cwd = \" %s \" , filename = <NULL> " ,
cwd ) ;
}
smb_time_audit_log_msg ( syscallname , elapsed , msg ) ;
TALLOC_FREE ( msg ) ;
}
static void smb_time_audit_log_smb_fname ( const char * syscallname , double elapsed ,
const struct smb_filename * smb_fname )
{
if ( smb_fname ! = NULL ) {
smb_time_audit_log_fname ( syscallname , elapsed ,
smb_fname - > base_name ) ;
} else {
smb_time_audit_log_fname ( syscallname , elapsed ,
" smb_fname = <NULL> " ) ;
}
2010-01-06 21:45:24 +03:00
}
static int smb_time_audit_connect ( vfs_handle_struct * handle ,
const char * svc , const char * user )
{
int result ;
2010-11-10 02:40:29 +03:00
struct timespec ts1 , ts2 ;
2010-01-06 21:45:24 +03:00
double timediff ;
if ( ! handle ) {
return - 1 ;
}
2010-11-10 02:40:29 +03:00
clock_gettime_mono ( & ts1 ) ;
2010-01-06 21:45:24 +03:00
result = SMB_VFS_NEXT_CONNECT ( handle , svc , user ) ;
2010-11-10 02:40:29 +03:00
clock_gettime_mono ( & ts2 ) ;
timediff = nsec_time_diff ( & ts2 , & ts1 ) * 1.0e-9 ;
2010-01-06 21:45:24 +03:00
if ( timediff > audit_timeout ) {
2012-07-25 20:39:57 +04:00
smb_time_audit_log_msg ( " connect " , timediff , user ) ;
2010-01-06 21:45:24 +03:00
}
return result ;
}
static void smb_time_audit_disconnect ( vfs_handle_struct * handle )
{
2010-11-10 02:40:29 +03:00
struct timespec ts1 , ts2 ;
2010-01-06 21:45:24 +03:00
double timediff ;
2010-11-10 02:40:29 +03:00
clock_gettime_mono ( & ts1 ) ;
2010-01-06 21:45:24 +03:00
SMB_VFS_NEXT_DISCONNECT ( handle ) ;
2010-11-10 02:40:29 +03:00
clock_gettime_mono ( & ts2 ) ;
timediff = nsec_time_diff ( & ts2 , & ts1 ) * 1.0e-9 ;
2010-01-06 21:45:24 +03:00
if ( timediff > audit_timeout ) {
smb_time_audit_log ( " disconnect " , timediff ) ;
}
}
static uint64_t smb_time_audit_disk_free ( vfs_handle_struct * handle ,
2015-02-16 21:26:24 +03:00
const char * path , uint64_t * bsize ,
2010-01-06 21:45:24 +03:00
uint64_t * dfree , uint64_t * dsize )
{
uint64_t result ;
2010-11-10 02:40:29 +03:00
struct timespec ts1 , ts2 ;
2010-01-06 21:45:24 +03:00
double timediff ;
2010-11-10 02:40:29 +03:00
clock_gettime_mono ( & ts1 ) ;
2015-02-16 21:26:24 +03:00
result = SMB_VFS_NEXT_DISK_FREE ( handle , path , bsize , dfree , dsize ) ;
2010-11-10 02:40:29 +03:00
clock_gettime_mono ( & ts2 ) ;
timediff = nsec_time_diff ( & ts2 , & ts1 ) * 1.0e-9 ;
2010-01-06 21:45:24 +03:00
/* Don't have a reasonable notion of failure here */
if ( timediff > audit_timeout ) {
2012-07-25 20:39:57 +04:00
smb_time_audit_log_fname ( " disk_free " , timediff , path ) ;
2010-01-06 21:45:24 +03:00
}
return result ;
}
static int smb_time_audit_get_quota ( struct vfs_handle_struct * handle ,
2016-01-10 14:29:25 +03:00
const char * path , enum SMB_QUOTA_TYPE qtype ,
unid_t id , SMB_DISK_QUOTA * qt )
2010-01-06 21:45:24 +03:00
{
int result ;
2010-11-10 02:40:29 +03:00
struct timespec ts1 , ts2 ;
2010-01-06 21:45:24 +03:00
double timediff ;
2010-11-10 02:40:29 +03:00
clock_gettime_mono ( & ts1 ) ;
2016-01-10 14:29:25 +03:00
result = SMB_VFS_NEXT_GET_QUOTA ( handle , path , qtype , id , qt ) ;
2010-11-10 02:40:29 +03:00
clock_gettime_mono ( & ts2 ) ;
timediff = nsec_time_diff ( & ts2 , & ts1 ) * 1.0e-9 ;
2010-01-06 21:45:24 +03:00
if ( timediff > audit_timeout ) {
smb_time_audit_log ( " get_quota " , timediff ) ;
}
return result ;
}
static int smb_time_audit_set_quota ( struct vfs_handle_struct * handle ,
enum SMB_QUOTA_TYPE qtype , unid_t id ,
SMB_DISK_QUOTA * qt )
{
int result ;
2010-11-10 02:40:29 +03:00
struct timespec ts1 , ts2 ;
2010-01-06 21:45:24 +03:00
double timediff ;
2010-11-10 02:40:29 +03:00
clock_gettime_mono ( & ts1 ) ;
2010-01-06 21:45:24 +03:00
result = SMB_VFS_NEXT_SET_QUOTA ( handle , qtype , id , qt ) ;
2010-11-10 02:40:29 +03:00
clock_gettime_mono ( & ts2 ) ;
timediff = nsec_time_diff ( & ts2 , & ts1 ) * 1.0e-9 ;
2010-01-06 21:45:24 +03:00
if ( timediff > audit_timeout ) {
smb_time_audit_log ( " set_quota " , timediff ) ;
}
return result ;
}
static int smb_time_audit_get_shadow_copy_data ( struct vfs_handle_struct * handle ,
struct files_struct * fsp ,
2011-05-30 14:06:31 +04:00
struct shadow_copy_data * shadow_copy_data ,
2010-01-06 21:45:24 +03:00
bool labels )
{
int result ;
2010-11-10 02:40:29 +03:00
struct timespec ts1 , ts2 ;
2010-01-06 21:45:24 +03:00
double timediff ;
2010-11-10 02:40:29 +03:00
clock_gettime_mono ( & ts1 ) ;
2010-01-06 21:45:24 +03:00
result = SMB_VFS_NEXT_GET_SHADOW_COPY_DATA ( handle , fsp ,
shadow_copy_data , labels ) ;
2010-11-10 02:40:29 +03:00
clock_gettime_mono ( & ts2 ) ;
timediff = nsec_time_diff ( & ts2 , & ts1 ) * 1.0e-9 ;
2010-01-06 21:45:24 +03:00
if ( timediff > audit_timeout ) {
2012-07-25 20:39:57 +04:00
smb_time_audit_log_fsp ( " get_shadow_copy_data " , timediff , fsp ) ;
2010-01-06 21:45:24 +03:00
}
return result ;
}
static int smb_time_audit_statvfs ( struct vfs_handle_struct * handle ,
const char * path ,
struct vfs_statvfs_struct * statbuf )
{
int result ;
2010-11-10 02:40:29 +03:00
struct timespec ts1 , ts2 ;
2010-01-06 21:45:24 +03:00
double timediff ;
2010-11-10 02:40:29 +03:00
clock_gettime_mono ( & ts1 ) ;
2010-01-06 21:45:24 +03:00
result = SMB_VFS_NEXT_STATVFS ( handle , path , statbuf ) ;
2010-11-10 02:40:29 +03:00
clock_gettime_mono ( & ts2 ) ;
timediff = nsec_time_diff ( & ts2 , & ts1 ) * 1.0e-9 ;
2010-01-06 21:45:24 +03:00
if ( timediff > audit_timeout ) {
2012-07-25 20:39:57 +04:00
smb_time_audit_log_fname ( " statvfs " , timediff , path ) ;
2010-01-06 21:45:24 +03:00
}
return result ;
}
static uint32_t smb_time_audit_fs_capabilities ( struct vfs_handle_struct * handle ,
enum timestamp_set_resolution * p_ts_res )
{
uint32_t result ;
2010-11-10 02:40:29 +03:00
struct timespec ts1 , ts2 ;
2010-01-06 21:45:24 +03:00
double timediff ;
2010-11-10 02:40:29 +03:00
clock_gettime_mono ( & ts1 ) ;
2010-01-06 21:45:24 +03:00
result = SMB_VFS_NEXT_FS_CAPABILITIES ( handle , p_ts_res ) ;
2010-11-10 02:40:29 +03:00
clock_gettime_mono ( & ts2 ) ;
timediff = nsec_time_diff ( & ts2 , & ts1 ) * 1.0e-9 ;
2010-01-06 21:45:24 +03:00
if ( timediff > audit_timeout ) {
smb_time_audit_log ( " fs_capabilities " , timediff ) ;
}
return result ;
}
2016-04-05 02:42:49 +03:00
static NTSTATUS smb_time_audit_get_dfs_referrals (
struct vfs_handle_struct * handle ,
struct dfs_GetDFSReferral * r )
{
NTSTATUS result ;
struct timespec ts1 , ts2 ;
double timediff ;
clock_gettime_mono ( & ts1 ) ;
result = SMB_VFS_NEXT_GET_DFS_REFERRALS ( handle , r ) ;
clock_gettime_mono ( & ts2 ) ;
timediff = nsec_time_diff ( & ts2 , & ts1 ) * 1.0e-9 ;
if ( timediff > audit_timeout ) {
smb_time_audit_log ( " get_dfs_referrals( " , timediff ) ;
}
return result ;
}
2012-04-10 05:16:57 +04:00
static NTSTATUS smb_time_audit_snap_check_path ( struct vfs_handle_struct * handle ,
TALLOC_CTX * mem_ctx ,
const char * service_path ,
char * * base_volume )
{
NTSTATUS status ;
struct timespec ts1 , ts2 ;
double timediff ;
clock_gettime_mono ( & ts1 ) ;
status = SMB_VFS_NEXT_SNAP_CHECK_PATH ( handle , mem_ctx , service_path ,
base_volume ) ;
clock_gettime_mono ( & ts2 ) ;
timediff = nsec_time_diff ( & ts2 , & ts1 ) * 1.0e-9 ;
if ( timediff > audit_timeout ) {
smb_time_audit_log ( " snap_check_path " , timediff ) ;
}
return status ;
}
static NTSTATUS smb_time_audit_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 )
{
NTSTATUS status ;
struct timespec ts1 , ts2 ;
double timediff ;
clock_gettime_mono ( & ts1 ) ;
status = SMB_VFS_NEXT_SNAP_CREATE ( handle , mem_ctx , base_volume , tstamp ,
rw , base_path , snap_path ) ;
clock_gettime_mono ( & ts2 ) ;
timediff = nsec_time_diff ( & ts2 , & ts1 ) * 1.0e-9 ;
if ( timediff > audit_timeout ) {
smb_time_audit_log ( " snap_create " , timediff ) ;
}
return status ;
}
static NTSTATUS smb_time_audit_snap_delete ( struct vfs_handle_struct * handle ,
TALLOC_CTX * mem_ctx ,
char * base_path ,
char * snap_path )
{
NTSTATUS status ;
struct timespec ts1 , ts2 ;
double timediff ;
clock_gettime_mono ( & ts1 ) ;
status = SMB_VFS_NEXT_SNAP_DELETE ( handle , mem_ctx , base_path ,
snap_path ) ;
clock_gettime_mono ( & ts2 ) ;
timediff = nsec_time_diff ( & ts2 , & ts1 ) * 1.0e-9 ;
if ( timediff > audit_timeout ) {
smb_time_audit_log ( " snap_delete " , timediff ) ;
}
return status ;
}
2012-03-28 06:22:03 +04:00
static DIR * smb_time_audit_opendir ( vfs_handle_struct * handle ,
2016-02-27 01:53:12 +03:00
const struct smb_filename * smb_fname ,
2015-05-01 06:16:18 +03:00
const char * mask , uint32_t attr )
2010-01-06 21:45:24 +03:00
{
2012-03-28 06:22:03 +04:00
DIR * result ;
2010-11-10 02:40:29 +03:00
struct timespec ts1 , ts2 ;
2010-01-06 21:45:24 +03:00
double timediff ;
2010-11-10 02:40:29 +03:00
clock_gettime_mono ( & ts1 ) ;
2016-02-27 01:53:12 +03:00
result = SMB_VFS_NEXT_OPENDIR ( handle , smb_fname , mask , attr ) ;
2010-11-10 02:40:29 +03:00
clock_gettime_mono ( & ts2 ) ;
timediff = nsec_time_diff ( & ts2 , & ts1 ) * 1.0e-9 ;
2010-01-06 21:45:24 +03:00
if ( timediff > audit_timeout ) {
2016-02-27 01:53:12 +03:00
smb_time_audit_log_smb_fname ( " opendir " , timediff , smb_fname ) ;
2010-01-06 21:45:24 +03:00
}
return result ;
}
2012-03-28 06:22:03 +04:00
static DIR * smb_time_audit_fdopendir ( vfs_handle_struct * handle ,
2011-02-09 02:07:48 +03:00
files_struct * fsp ,
2015-05-01 06:16:18 +03:00
const char * mask , uint32_t attr )
2011-02-09 02:07:48 +03:00
{
2012-03-28 06:22:03 +04:00
DIR * result ;
2011-02-09 02:07:48 +03:00
struct timespec ts1 , ts2 ;
double timediff ;
clock_gettime_mono ( & ts1 ) ;
result = SMB_VFS_NEXT_FDOPENDIR ( handle , fsp , mask , attr ) ;
clock_gettime_mono ( & ts2 ) ;
timediff = nsec_time_diff ( & ts2 , & ts1 ) * 1.0e-9 ;
if ( timediff > audit_timeout ) {
2012-07-25 20:39:57 +04:00
smb_time_audit_log_fsp ( " fdopendir " , timediff , fsp ) ;
2011-02-09 02:07:48 +03:00
}
return result ;
}
2012-03-28 06:18:14 +04:00
static struct dirent * smb_time_audit_readdir ( vfs_handle_struct * handle ,
2012-03-28 06:22:03 +04:00
DIR * dirp ,
2010-01-06 21:45:24 +03:00
SMB_STRUCT_STAT * sbuf )
{
2012-03-28 06:18:14 +04:00
struct dirent * result ;
2010-11-10 02:40:29 +03:00
struct timespec ts1 , ts2 ;
2010-01-06 21:45:24 +03:00
double timediff ;
2010-11-10 02:40:29 +03:00
clock_gettime_mono ( & ts1 ) ;
2010-01-06 21:45:24 +03:00
result = SMB_VFS_NEXT_READDIR ( handle , dirp , sbuf ) ;
2010-11-10 02:40:29 +03:00
clock_gettime_mono ( & ts2 ) ;
timediff = nsec_time_diff ( & ts2 , & ts1 ) * 1.0e-9 ;
2010-01-06 21:45:24 +03:00
if ( timediff > audit_timeout ) {
smb_time_audit_log ( " readdir " , timediff ) ;
}
return result ;
}
static void smb_time_audit_seekdir ( vfs_handle_struct * handle ,
2012-03-28 06:22:03 +04:00
DIR * dirp , long offset )
2010-01-06 21:45:24 +03:00
{
2010-11-10 02:40:29 +03:00
struct timespec ts1 , ts2 ;
2010-01-06 21:45:24 +03:00
double timediff ;
2010-11-10 02:40:29 +03:00
clock_gettime_mono ( & ts1 ) ;
2010-01-06 21:45:24 +03:00
SMB_VFS_NEXT_SEEKDIR ( handle , dirp , offset ) ;
2010-11-10 02:40:29 +03:00
clock_gettime_mono ( & ts2 ) ;
timediff = nsec_time_diff ( & ts2 , & ts1 ) * 1.0e-9 ;
2010-01-06 21:45:24 +03:00
if ( timediff > audit_timeout ) {
smb_time_audit_log ( " seekdir " , timediff ) ;
}
}
static long smb_time_audit_telldir ( vfs_handle_struct * handle ,
2012-03-28 06:22:03 +04:00
DIR * dirp )
2010-01-06 21:45:24 +03:00
{
long result ;
2010-11-10 02:40:29 +03:00
struct timespec ts1 , ts2 ;
2010-01-06 21:45:24 +03:00
double timediff ;
2010-11-10 02:40:29 +03:00
clock_gettime_mono ( & ts1 ) ;
2010-01-06 21:45:24 +03:00
result = SMB_VFS_NEXT_TELLDIR ( handle , dirp ) ;
2010-11-10 02:40:29 +03:00
clock_gettime_mono ( & ts2 ) ;
timediff = nsec_time_diff ( & ts2 , & ts1 ) * 1.0e-9 ;
2010-01-06 21:45:24 +03:00
if ( timediff > audit_timeout ) {
smb_time_audit_log ( " telldir " , timediff ) ;
}
return result ;
}
static void smb_time_audit_rewinddir ( vfs_handle_struct * handle ,
2012-03-28 06:22:03 +04:00
DIR * dirp )
2010-01-06 21:45:24 +03:00
{
2010-11-10 02:40:29 +03:00
struct timespec ts1 , ts2 ;
2010-01-06 21:45:24 +03:00
double timediff ;
2010-11-10 02:40:29 +03:00
clock_gettime_mono ( & ts1 ) ;
2010-01-06 21:45:24 +03:00
SMB_VFS_NEXT_REWINDDIR ( handle , dirp ) ;
2010-11-10 02:40:29 +03:00
clock_gettime_mono ( & ts2 ) ;
timediff = nsec_time_diff ( & ts2 , & ts1 ) * 1.0e-9 ;
2010-01-06 21:45:24 +03:00
if ( timediff > audit_timeout ) {
smb_time_audit_log ( " rewinddir " , timediff ) ;
}
}
static int smb_time_audit_mkdir ( vfs_handle_struct * handle ,
2016-02-24 00:14:03 +03:00
const struct smb_filename * smb_fname ,
mode_t mode )
2010-01-06 21:45:24 +03:00
{
int result ;
2010-11-10 02:40:29 +03:00
struct timespec ts1 , ts2 ;
2010-01-06 21:45:24 +03:00
double timediff ;
2010-11-10 02:40:29 +03:00
clock_gettime_mono ( & ts1 ) ;
2016-02-24 00:14:03 +03:00
result = SMB_VFS_NEXT_MKDIR ( handle , smb_fname , mode ) ;
2010-11-10 02:40:29 +03:00
clock_gettime_mono ( & ts2 ) ;
timediff = nsec_time_diff ( & ts2 , & ts1 ) * 1.0e-9 ;
2010-01-06 21:45:24 +03:00
if ( timediff > audit_timeout ) {
2016-02-24 00:14:03 +03:00
smb_time_audit_log_smb_fname ( " mkdir " ,
timediff ,
smb_fname ) ;
2010-01-06 21:45:24 +03:00
}
return result ;
}
static int smb_time_audit_rmdir ( vfs_handle_struct * handle ,
2016-02-25 01:02:45 +03:00
const struct smb_filename * smb_fname )
2010-01-06 21:45:24 +03:00
{
int result ;
2010-11-10 02:40:29 +03:00
struct timespec ts1 , ts2 ;
2010-01-06 21:45:24 +03:00
double timediff ;
2010-11-10 02:40:29 +03:00
clock_gettime_mono ( & ts1 ) ;
2016-02-25 01:02:45 +03:00
result = SMB_VFS_NEXT_RMDIR ( handle , smb_fname ) ;
2010-11-10 02:40:29 +03:00
clock_gettime_mono ( & ts2 ) ;
timediff = nsec_time_diff ( & ts2 , & ts1 ) * 1.0e-9 ;
2010-01-06 21:45:24 +03:00
if ( timediff > audit_timeout ) {
2016-02-25 01:02:45 +03:00
smb_time_audit_log_smb_fname ( " rmdir " ,
timediff ,
smb_fname ) ;
2010-01-06 21:45:24 +03:00
}
return result ;
}
static int smb_time_audit_closedir ( vfs_handle_struct * handle ,
2012-03-28 06:22:03 +04:00
DIR * dirp )
2010-01-06 21:45:24 +03:00
{
int result ;
2010-11-10 02:40:29 +03:00
struct timespec ts1 , ts2 ;
2010-01-06 21:45:24 +03:00
double timediff ;
2010-11-10 02:40:29 +03:00
clock_gettime_mono ( & ts1 ) ;
2010-01-06 21:45:24 +03:00
result = SMB_VFS_NEXT_CLOSEDIR ( handle , dirp ) ;
2010-11-10 02:40:29 +03:00
clock_gettime_mono ( & ts2 ) ;
timediff = nsec_time_diff ( & ts2 , & ts1 ) * 1.0e-9 ;
2010-01-06 21:45:24 +03:00
if ( timediff > audit_timeout ) {
smb_time_audit_log ( " closedir " , timediff ) ;
}
return result ;
}
static void smb_time_audit_init_search_op ( vfs_handle_struct * handle ,
2012-03-28 06:22:03 +04:00
DIR * dirp )
2010-01-06 21:45:24 +03:00
{
2010-11-10 02:40:29 +03:00
struct timespec ts1 , ts2 ;
2010-01-06 21:45:24 +03:00
double timediff ;
2010-11-10 02:40:29 +03:00
clock_gettime_mono ( & ts1 ) ;
2010-01-06 21:45:24 +03:00
SMB_VFS_NEXT_INIT_SEARCH_OP ( handle , dirp ) ;
2010-11-10 02:40:29 +03:00
clock_gettime_mono ( & ts2 ) ;
timediff = nsec_time_diff ( & ts2 , & ts1 ) * 1.0e-9 ;
2010-01-06 21:45:24 +03:00
if ( timediff > audit_timeout ) {
smb_time_audit_log ( " init_search_op " , timediff ) ;
}
}
static int smb_time_audit_open ( vfs_handle_struct * handle ,
struct smb_filename * fname ,
files_struct * fsp ,
int flags , mode_t mode )
{
int result ;
2010-11-10 02:40:29 +03:00
struct timespec ts1 , ts2 ;
2010-01-06 21:45:24 +03:00
double timediff ;
2010-11-10 02:40:29 +03:00
clock_gettime_mono ( & ts1 ) ;
2010-01-06 21:45:24 +03:00
result = SMB_VFS_NEXT_OPEN ( handle , fname , fsp , flags , mode ) ;
2010-11-10 02:40:29 +03:00
clock_gettime_mono ( & ts2 ) ;
timediff = nsec_time_diff ( & ts2 , & ts1 ) * 1.0e-9 ;
2010-01-06 21:45:24 +03:00
if ( timediff > audit_timeout ) {
2012-07-25 20:39:57 +04:00
smb_time_audit_log_fsp ( " open " , timediff , fsp ) ;
2010-01-06 21:45:24 +03:00
}
return result ;
}
static NTSTATUS smb_time_audit_create_file ( vfs_handle_struct * handle ,
struct smb_request * req ,
uint16_t root_dir_fid ,
struct smb_filename * 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 ,
2013-08-21 17:56:14 +04:00
struct smb2_lease * lease ,
2010-01-06 21:45:24 +03:00
uint64_t allocation_size ,
uint32_t private_flags ,
struct security_descriptor * sd ,
struct ea_list * ea_list ,
files_struct * * result_fsp ,
2014-11-26 16:12:51 +03:00
int * pinfo ,
const struct smb2_create_blobs * in_context_blobs ,
struct smb2_create_blobs * out_context_blobs )
2010-01-06 21:45:24 +03:00
{
NTSTATUS result ;
2010-11-10 02:40:29 +03:00
struct timespec ts1 , ts2 ;
2010-01-06 21:45:24 +03:00
double timediff ;
2010-11-10 02:40:29 +03:00
clock_gettime_mono ( & ts1 ) ;
2010-01-06 21:45:24 +03:00
result = SMB_VFS_NEXT_CREATE_FILE (
handle , /* handle */
req , /* req */
root_dir_fid , /* root_dir_fid */
fname , /* fname */
access_mask , /* access_mask */
share_access , /* share_access */
create_disposition , /* create_disposition*/
create_options , /* create_options */
file_attributes , /* file_attributes */
oplock_request , /* oplock_request */
2013-08-21 17:56:14 +04:00
lease , /* lease */
2010-01-06 21:45:24 +03:00
allocation_size , /* allocation_size */
private_flags ,
sd , /* sd */
ea_list , /* ea_list */
result_fsp , /* result */
2014-11-26 16:12:51 +03:00
pinfo ,
in_context_blobs , out_context_blobs ) ; /* create context */
2010-11-10 02:40:29 +03:00
clock_gettime_mono ( & ts2 ) ;
timediff = nsec_time_diff ( & ts2 , & ts1 ) * 1.0e-9 ;
2010-01-06 21:45:24 +03:00
if ( timediff > audit_timeout ) {
2012-07-25 20:39:57 +04:00
/*
* can ' t use result_fsp this time , may have
* invalid content causing smbd crash
*/
smb_time_audit_log_smb_fname ( " create_file " , timediff ,
fname ) ;
2010-01-06 21:45:24 +03:00
}
return result ;
}
static int smb_time_audit_close ( vfs_handle_struct * handle , files_struct * fsp )
{
int result ;
2010-11-10 02:40:29 +03:00
struct timespec ts1 , ts2 ;
2010-01-06 21:45:24 +03:00
double timediff ;
2010-11-10 02:40:29 +03:00
clock_gettime_mono ( & ts1 ) ;
2010-01-06 21:45:24 +03:00
result = SMB_VFS_NEXT_CLOSE ( handle , fsp ) ;
2010-11-10 02:40:29 +03:00
clock_gettime_mono ( & ts2 ) ;
timediff = nsec_time_diff ( & ts2 , & ts1 ) * 1.0e-9 ;
2010-01-06 21:45:24 +03:00
if ( timediff > audit_timeout ) {
2012-07-25 20:39:57 +04:00
smb_time_audit_log_fsp ( " close " , timediff , fsp ) ;
2010-01-06 21:45:24 +03:00
}
return result ;
}
static ssize_t smb_time_audit_read ( vfs_handle_struct * handle ,
files_struct * fsp , void * data , size_t n )
{
ssize_t result ;
2010-11-10 02:40:29 +03:00
struct timespec ts1 , ts2 ;
2010-01-06 21:45:24 +03:00
double timediff ;
2010-11-10 02:40:29 +03:00
clock_gettime_mono ( & ts1 ) ;
2010-01-06 21:45:24 +03:00
result = SMB_VFS_NEXT_READ ( handle , fsp , data , n ) ;
2010-11-10 02:40:29 +03:00
clock_gettime_mono ( & ts2 ) ;
timediff = nsec_time_diff ( & ts2 , & ts1 ) * 1.0e-9 ;
2010-01-06 21:45:24 +03:00
if ( timediff > audit_timeout ) {
2012-07-25 20:39:57 +04:00
smb_time_audit_log_fsp ( " read " , timediff , fsp ) ;
2010-01-06 21:45:24 +03:00
}
return result ;
}
static ssize_t smb_time_audit_pread ( vfs_handle_struct * handle ,
files_struct * fsp ,
2012-04-05 08:53:08 +04:00
void * data , size_t n , off_t offset )
2010-01-06 21:45:24 +03:00
{
ssize_t result ;
2010-11-10 02:40:29 +03:00
struct timespec ts1 , ts2 ;
2010-01-06 21:45:24 +03:00
double timediff ;
2010-11-10 02:40:29 +03:00
clock_gettime_mono ( & ts1 ) ;
2010-01-06 21:45:24 +03:00
result = SMB_VFS_NEXT_PREAD ( handle , fsp , data , n , offset ) ;
2010-11-10 02:40:29 +03:00
clock_gettime_mono ( & ts2 ) ;
timediff = nsec_time_diff ( & ts2 , & ts1 ) * 1.0e-9 ;
2010-01-06 21:45:24 +03:00
if ( timediff > audit_timeout ) {
2012-07-25 20:39:57 +04:00
smb_time_audit_log_fsp ( " pread " , timediff , fsp ) ;
2010-01-06 21:45:24 +03:00
}
return result ;
}
2012-07-09 19:17:25 +04:00
struct smb_time_audit_pread_state {
2012-07-25 20:39:57 +04:00
struct files_struct * fsp ;
2012-07-09 19:17:25 +04:00
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 smb_time_audit_pread_done ( struct tevent_req * subreq ) ;
static struct tevent_req * smb_time_audit_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 smb_time_audit_pread_state * state ;
req = tevent_req_create ( mem_ctx , & state ,
struct smb_time_audit_pread_state ) ;
if ( req = = NULL ) {
return NULL ;
}
2012-07-25 20:39:57 +04:00
state - > fsp = fsp ;
2012-07-09 19:17:25 +04:00
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 , smb_time_audit_pread_done , req ) ;
return req ;
}
static void smb_time_audit_pread_done ( struct tevent_req * subreq )
{
struct tevent_req * req = tevent_req_callback_data (
subreq , struct tevent_req ) ;
struct smb_time_audit_pread_state * state = tevent_req_data (
req , struct smb_time_audit_pread_state ) ;
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 smb_time_audit_pread_recv ( struct tevent_req * req ,
struct vfs_aio_state * vfs_aio_state )
2012-07-09 19:17:25 +04:00
{
struct smb_time_audit_pread_state * state = tevent_req_data (
req , struct smb_time_audit_pread_state ) ;
double timediff ;
2016-02-26 14:54:23 +03:00
timediff = state - > vfs_aio_state . duration * 1.0e-9 ;
2012-07-09 19:17:25 +04:00
if ( timediff > audit_timeout ) {
2016-02-26 14:54:23 +03:00
smb_time_audit_log_fsp ( " async pread " , timediff , state - > fsp ) ;
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 ;
}
2010-01-06 21:45:24 +03:00
static ssize_t smb_time_audit_write ( vfs_handle_struct * handle ,
files_struct * fsp ,
const void * data , size_t n )
{
ssize_t result ;
2010-11-10 02:40:29 +03:00
struct timespec ts1 , ts2 ;
2010-01-06 21:45:24 +03:00
double timediff ;
2010-11-10 02:40:29 +03:00
clock_gettime_mono ( & ts1 ) ;
2010-01-06 21:45:24 +03:00
result = SMB_VFS_NEXT_WRITE ( handle , fsp , data , n ) ;
2010-11-10 02:40:29 +03:00
clock_gettime_mono ( & ts2 ) ;
timediff = nsec_time_diff ( & ts2 , & ts1 ) * 1.0e-9 ;
2010-01-06 21:45:24 +03:00
if ( timediff > audit_timeout ) {
2012-07-25 20:39:57 +04:00
smb_time_audit_log_fsp ( " write " , timediff , fsp ) ;
2010-01-06 21:45:24 +03:00
}
return result ;
}
static ssize_t smb_time_audit_pwrite ( vfs_handle_struct * handle ,
files_struct * fsp ,
const void * data , size_t n ,
2012-04-05 08:53:08 +04:00
off_t offset )
2010-01-06 21:45:24 +03:00
{
ssize_t result ;
2010-11-10 02:40:29 +03:00
struct timespec ts1 , ts2 ;
2010-01-06 21:45:24 +03:00
double timediff ;
2010-11-10 02:40:29 +03:00
clock_gettime_mono ( & ts1 ) ;
2010-01-06 21:45:24 +03:00
result = SMB_VFS_NEXT_PWRITE ( handle , fsp , data , n , offset ) ;
2010-11-10 02:40:29 +03:00
clock_gettime_mono ( & ts2 ) ;
timediff = nsec_time_diff ( & ts2 , & ts1 ) * 1.0e-9 ;
2010-01-06 21:45:24 +03:00
if ( timediff > audit_timeout ) {
2012-07-25 20:39:57 +04:00
smb_time_audit_log_fsp ( " pwrite " , timediff , fsp ) ;
2010-01-06 21:45:24 +03:00
}
return result ;
}
2012-07-09 19:17:25 +04:00
struct smb_time_audit_pwrite_state {
2012-07-25 20:39:57 +04:00
struct files_struct * fsp ;
2012-07-09 19:17:25 +04:00
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 smb_time_audit_pwrite_done ( struct tevent_req * subreq ) ;
static struct tevent_req * smb_time_audit_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 smb_time_audit_pwrite_state * state ;
req = tevent_req_create ( mem_ctx , & state ,
struct smb_time_audit_pwrite_state ) ;
if ( req = = NULL ) {
return NULL ;
}
2012-07-25 20:39:57 +04:00
state - > fsp = fsp ;
2012-07-09 19:17:25 +04:00
subreq = SMB_VFS_NEXT_PWRITE_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 , smb_time_audit_pwrite_done , req ) ;
return req ;
}
static void smb_time_audit_pwrite_done ( struct tevent_req * subreq )
{
struct tevent_req * req = tevent_req_callback_data (
subreq , struct tevent_req ) ;
struct smb_time_audit_pwrite_state * state = tevent_req_data (
req , struct smb_time_audit_pwrite_state ) ;
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 smb_time_audit_pwrite_recv ( struct tevent_req * req ,
struct vfs_aio_state * vfs_aio_state )
2012-07-09 19:17:25 +04:00
{
struct smb_time_audit_pwrite_state * state = tevent_req_data (
req , struct smb_time_audit_pwrite_state ) ;
double timediff ;
2016-02-26 14:54:23 +03:00
timediff = state - > vfs_aio_state . duration * 1.0e-9 ;
2012-07-09 19:17:25 +04:00
if ( timediff > audit_timeout ) {
2016-02-26 14:54:23 +03:00
smb_time_audit_log_fsp ( " async pwrite " , timediff , state - > fsp ) ;
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-04-05 08:53:08 +04:00
static off_t smb_time_audit_lseek ( vfs_handle_struct * handle ,
2010-01-06 21:45:24 +03:00
files_struct * fsp ,
2012-04-05 08:53:08 +04:00
off_t offset , int whence )
2010-01-06 21:45:24 +03:00
{
2012-04-05 08:53:08 +04:00
off_t result ;
2010-11-10 02:40:29 +03:00
struct timespec ts1 , ts2 ;
2010-01-06 21:45:24 +03:00
double timediff ;
2010-11-10 02:40:29 +03:00
clock_gettime_mono ( & ts1 ) ;
2010-01-06 21:45:24 +03:00
result = SMB_VFS_NEXT_LSEEK ( handle , fsp , offset , whence ) ;
2010-11-10 02:40:29 +03:00
clock_gettime_mono ( & ts2 ) ;
timediff = nsec_time_diff ( & ts2 , & ts1 ) * 1.0e-9 ;
2010-01-06 21:45:24 +03:00
if ( timediff > audit_timeout ) {
2012-07-25 20:39:57 +04:00
smb_time_audit_log_fsp ( " lseek " , timediff , fsp ) ;
2010-01-06 21:45:24 +03:00
}
return result ;
}
static ssize_t smb_time_audit_sendfile ( vfs_handle_struct * handle , int tofd ,
files_struct * fromfsp ,
2012-04-05 08:53:08 +04:00
const DATA_BLOB * hdr , off_t offset ,
2010-01-06 21:45:24 +03:00
size_t n )
{
ssize_t result ;
2010-11-10 02:40:29 +03:00
struct timespec ts1 , ts2 ;
2010-01-06 21:45:24 +03:00
double timediff ;
2010-11-10 02:40:29 +03:00
clock_gettime_mono ( & ts1 ) ;
2010-01-06 21:45:24 +03:00
result = SMB_VFS_NEXT_SENDFILE ( handle , tofd , fromfsp , hdr , offset , n ) ;
2010-11-10 02:40:29 +03:00
clock_gettime_mono ( & ts2 ) ;
timediff = nsec_time_diff ( & ts2 , & ts1 ) * 1.0e-9 ;
2010-01-06 21:45:24 +03:00
if ( timediff > audit_timeout ) {
2012-07-25 20:39:57 +04:00
smb_time_audit_log_fsp ( " sendfile " , timediff , fromfsp ) ;
2010-01-06 21:45:24 +03:00
}
return result ;
}
static ssize_t smb_time_audit_recvfile ( vfs_handle_struct * handle , int fromfd ,
files_struct * tofsp ,
2012-04-05 08:53:08 +04:00
off_t offset ,
2010-01-06 21:45:24 +03:00
size_t n )
{
ssize_t result ;
2010-11-10 02:40:29 +03:00
struct timespec ts1 , ts2 ;
2010-01-06 21:45:24 +03:00
double timediff ;
2010-11-10 02:40:29 +03:00
clock_gettime_mono ( & ts1 ) ;
2010-01-06 21:45:24 +03:00
result = SMB_VFS_NEXT_RECVFILE ( handle , fromfd , tofsp , offset , n ) ;
2010-11-10 02:40:29 +03:00
clock_gettime_mono ( & ts2 ) ;
timediff = nsec_time_diff ( & ts2 , & ts1 ) * 1.0e-9 ;
2010-01-06 21:45:24 +03:00
if ( timediff > audit_timeout ) {
2012-07-25 20:39:57 +04:00
smb_time_audit_log_fsp ( " recvfile " , timediff , tofsp ) ;
2010-01-06 21:45:24 +03:00
}
return result ;
}
static int smb_time_audit_rename ( vfs_handle_struct * handle ,
const struct smb_filename * oldname ,
const struct smb_filename * newname )
{
int result ;
2010-11-10 02:40:29 +03:00
struct timespec ts1 , ts2 ;
2010-01-06 21:45:24 +03:00
double timediff ;
2010-11-10 02:40:29 +03:00
clock_gettime_mono ( & ts1 ) ;
2010-01-06 21:45:24 +03:00
result = SMB_VFS_NEXT_RENAME ( handle , oldname , newname ) ;
2010-11-10 02:40:29 +03:00
clock_gettime_mono ( & ts2 ) ;
timediff = nsec_time_diff ( & ts2 , & ts1 ) * 1.0e-9 ;
2010-01-06 21:45:24 +03:00
if ( timediff > audit_timeout ) {
2012-07-25 20:39:57 +04:00
smb_time_audit_log_smb_fname ( " rename " , timediff , newname ) ;
2010-01-06 21:45:24 +03:00
}
return result ;
}
static int smb_time_audit_fsync ( vfs_handle_struct * handle , files_struct * fsp )
{
int result ;
2010-11-10 02:40:29 +03:00
struct timespec ts1 , ts2 ;
2010-01-06 21:45:24 +03:00
double timediff ;
2010-11-10 02:40:29 +03:00
clock_gettime_mono ( & ts1 ) ;
2010-01-06 21:45:24 +03:00
result = SMB_VFS_NEXT_FSYNC ( handle , fsp ) ;
2010-11-10 02:40:29 +03:00
clock_gettime_mono ( & ts2 ) ;
timediff = nsec_time_diff ( & ts2 , & ts1 ) * 1.0e-9 ;
2010-01-06 21:45:24 +03:00
if ( timediff > audit_timeout ) {
2012-07-25 20:39:57 +04:00
smb_time_audit_log_fsp ( " fsync " , timediff , fsp ) ;
2010-01-06 21:45:24 +03:00
}
return result ;
}
2012-07-13 12:22:25 +04:00
struct smb_time_audit_fsync_state {
2012-07-25 20:39:57 +04:00
struct files_struct * fsp ;
2012-07-13 12:22:25 +04:00
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 smb_time_audit_fsync_done ( struct tevent_req * subreq ) ;
static struct tevent_req * smb_time_audit_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 smb_time_audit_fsync_state * state ;
req = tevent_req_create ( mem_ctx , & state ,
struct smb_time_audit_fsync_state ) ;
if ( req = = NULL ) {
return NULL ;
}
2012-07-25 20:39:57 +04:00
state - > fsp = fsp ;
2012-07-13 12:22:25 +04:00
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 , smb_time_audit_fsync_done , req ) ;
return req ;
}
static void smb_time_audit_fsync_done ( struct tevent_req * subreq )
{
struct tevent_req * req = tevent_req_callback_data (
subreq , struct tevent_req ) ;
struct smb_time_audit_fsync_state * state = tevent_req_data (
req , struct smb_time_audit_fsync_state ) ;
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 smb_time_audit_fsync_recv ( struct tevent_req * req ,
struct vfs_aio_state * vfs_aio_state )
2012-07-13 12:22:25 +04:00
{
struct smb_time_audit_fsync_state * state = tevent_req_data (
req , struct smb_time_audit_fsync_state ) ;
double timediff ;
2016-02-26 14:54:23 +03:00
timediff = state - > vfs_aio_state . duration * 1.0e-9 ;
2012-07-13 12:22:25 +04:00
if ( timediff > audit_timeout ) {
2016-02-26 14:54:23 +03:00
smb_time_audit_log_fsp ( " async fsync " , timediff , state - > fsp ) ;
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 ;
}
2010-01-06 21:45:24 +03:00
static int smb_time_audit_stat ( vfs_handle_struct * handle ,
struct smb_filename * fname )
{
int result ;
2010-11-10 02:40:29 +03:00
struct timespec ts1 , ts2 ;
2010-01-06 21:45:24 +03:00
double timediff ;
2010-11-10 02:40:29 +03:00
clock_gettime_mono ( & ts1 ) ;
2010-01-06 21:45:24 +03:00
result = SMB_VFS_NEXT_STAT ( handle , fname ) ;
2010-11-10 02:40:29 +03:00
clock_gettime_mono ( & ts2 ) ;
timediff = nsec_time_diff ( & ts2 , & ts1 ) * 1.0e-9 ;
2010-01-06 21:45:24 +03:00
if ( timediff > audit_timeout ) {
2012-07-25 20:39:57 +04:00
smb_time_audit_log_smb_fname ( " stat " , timediff , fname ) ;
2010-01-06 21:45:24 +03:00
}
return result ;
}
static int smb_time_audit_fstat ( vfs_handle_struct * handle , files_struct * fsp ,
SMB_STRUCT_STAT * sbuf )
{
int result ;
2010-11-10 02:40:29 +03:00
struct timespec ts1 , ts2 ;
2010-01-06 21:45:24 +03:00
double timediff ;
2010-11-10 02:40:29 +03:00
clock_gettime_mono ( & ts1 ) ;
2010-01-06 21:45:24 +03:00
result = SMB_VFS_NEXT_FSTAT ( handle , fsp , sbuf ) ;
2010-11-10 02:40:29 +03:00
clock_gettime_mono ( & ts2 ) ;
timediff = nsec_time_diff ( & ts2 , & ts1 ) * 1.0e-9 ;
2010-01-06 21:45:24 +03:00
if ( timediff > audit_timeout ) {
2012-07-25 20:39:57 +04:00
smb_time_audit_log_fsp ( " fstat " , timediff , fsp ) ;
2010-01-06 21:45:24 +03:00
}
return result ;
}
static int smb_time_audit_lstat ( vfs_handle_struct * handle ,
struct smb_filename * path )
{
int result ;
2010-11-10 02:40:29 +03:00
struct timespec ts1 , ts2 ;
2010-01-06 21:45:24 +03:00
double timediff ;
2010-11-10 02:40:29 +03:00
clock_gettime_mono ( & ts1 ) ;
2010-01-06 21:45:24 +03:00
result = SMB_VFS_NEXT_LSTAT ( handle , path ) ;
2010-11-10 02:40:29 +03:00
clock_gettime_mono ( & ts2 ) ;
timediff = nsec_time_diff ( & ts2 , & ts1 ) * 1.0e-9 ;
2010-01-06 21:45:24 +03:00
if ( timediff > audit_timeout ) {
2012-07-25 20:39:57 +04:00
smb_time_audit_log_smb_fname ( " lstat " , timediff , path ) ;
2010-01-06 21:45:24 +03:00
}
return result ;
}
static uint64_t smb_time_audit_get_alloc_size ( vfs_handle_struct * handle ,
files_struct * fsp ,
const SMB_STRUCT_STAT * sbuf )
{
2011-06-17 23:54:30 +04:00
uint64_t result ;
2010-11-10 02:40:29 +03:00
struct timespec ts1 , ts2 ;
2010-01-06 21:45:24 +03:00
double timediff ;
2010-11-10 02:40:29 +03:00
clock_gettime_mono ( & ts1 ) ;
2010-01-06 21:45:24 +03:00
result = SMB_VFS_NEXT_GET_ALLOC_SIZE ( handle , fsp , sbuf ) ;
2010-11-10 02:40:29 +03:00
clock_gettime_mono ( & ts2 ) ;
timediff = nsec_time_diff ( & ts2 , & ts1 ) * 1.0e-9 ;
2010-01-06 21:45:24 +03:00
if ( timediff > audit_timeout ) {
2012-07-25 20:39:57 +04:00
smb_time_audit_log_fsp ( " get_alloc_size " , timediff , fsp ) ;
2010-01-06 21:45:24 +03:00
}
return result ;
}
static int smb_time_audit_unlink ( vfs_handle_struct * handle ,
const struct smb_filename * path )
{
int result ;
2010-11-10 02:40:29 +03:00
struct timespec ts1 , ts2 ;
2010-01-06 21:45:24 +03:00
double timediff ;
2010-11-10 02:40:29 +03:00
clock_gettime_mono ( & ts1 ) ;
2010-01-06 21:45:24 +03:00
result = SMB_VFS_NEXT_UNLINK ( handle , path ) ;
2010-11-10 02:40:29 +03:00
clock_gettime_mono ( & ts2 ) ;
timediff = nsec_time_diff ( & ts2 , & ts1 ) * 1.0e-9 ;
2010-01-06 21:45:24 +03:00
if ( timediff > audit_timeout ) {
2012-07-25 20:39:57 +04:00
smb_time_audit_log_smb_fname ( " unlink " , timediff , path ) ;
2010-01-06 21:45:24 +03:00
}
return result ;
}
static int smb_time_audit_chmod ( vfs_handle_struct * handle ,
2016-03-02 03:20:25 +03:00
const struct smb_filename * smb_fname ,
mode_t mode )
2010-01-06 21:45:24 +03:00
{
int result ;
2010-11-10 02:40:29 +03:00
struct timespec ts1 , ts2 ;
2010-01-06 21:45:24 +03:00
double timediff ;
2010-11-10 02:40:29 +03:00
clock_gettime_mono ( & ts1 ) ;
2016-03-02 03:20:25 +03:00
result = SMB_VFS_NEXT_CHMOD ( handle , smb_fname , mode ) ;
2010-11-10 02:40:29 +03:00
clock_gettime_mono ( & ts2 ) ;
timediff = nsec_time_diff ( & ts2 , & ts1 ) * 1.0e-9 ;
2010-01-06 21:45:24 +03:00
if ( timediff > audit_timeout ) {
2016-03-02 03:20:25 +03:00
smb_time_audit_log_fname ( " chmod " ,
timediff ,
smb_fname - > base_name ) ;
2010-01-06 21:45:24 +03:00
}
return result ;
}
static int smb_time_audit_fchmod ( vfs_handle_struct * handle , files_struct * fsp ,
mode_t mode )
{
int result ;
2010-11-10 02:40:29 +03:00
struct timespec ts1 , ts2 ;
2010-01-06 21:45:24 +03:00
double timediff ;
2010-11-10 02:40:29 +03:00
clock_gettime_mono ( & ts1 ) ;
2010-01-06 21:45:24 +03:00
result = SMB_VFS_NEXT_FCHMOD ( handle , fsp , mode ) ;
2010-11-10 02:40:29 +03:00
clock_gettime_mono ( & ts2 ) ;
timediff = nsec_time_diff ( & ts2 , & ts1 ) * 1.0e-9 ;
2010-01-06 21:45:24 +03:00
if ( timediff > audit_timeout ) {
2012-07-25 20:39:57 +04:00
smb_time_audit_log_fsp ( " fchmod " , timediff , fsp ) ;
2010-01-06 21:45:24 +03:00
}
return result ;
}
static int smb_time_audit_chown ( vfs_handle_struct * handle ,
2016-03-03 22:54:23 +03:00
const struct smb_filename * smb_fname ,
uid_t uid ,
gid_t gid )
2010-01-06 21:45:24 +03:00
{
int result ;
2010-11-10 02:40:29 +03:00
struct timespec ts1 , ts2 ;
2010-01-06 21:45:24 +03:00
double timediff ;
2010-11-10 02:40:29 +03:00
clock_gettime_mono ( & ts1 ) ;
2016-03-03 22:54:23 +03:00
result = SMB_VFS_NEXT_CHOWN ( handle , smb_fname , uid , gid ) ;
2010-11-10 02:40:29 +03:00
clock_gettime_mono ( & ts2 ) ;
timediff = nsec_time_diff ( & ts2 , & ts1 ) * 1.0e-9 ;
2010-01-06 21:45:24 +03:00
if ( timediff > audit_timeout ) {
2016-03-03 22:54:23 +03:00
smb_time_audit_log_fname ( " chown " ,
timediff ,
smb_fname - > base_name ) ;
2010-01-06 21:45:24 +03:00
}
return result ;
}
static int smb_time_audit_fchown ( vfs_handle_struct * handle , files_struct * fsp ,
uid_t uid , gid_t gid )
{
int result ;
2010-11-10 02:40:29 +03:00
struct timespec ts1 , ts2 ;
2010-01-06 21:45:24 +03:00
double timediff ;
2010-11-10 02:40:29 +03:00
clock_gettime_mono ( & ts1 ) ;
2010-01-06 21:45:24 +03:00
result = SMB_VFS_NEXT_FCHOWN ( handle , fsp , uid , gid ) ;
2010-11-10 02:40:29 +03:00
clock_gettime_mono ( & ts2 ) ;
timediff = nsec_time_diff ( & ts2 , & ts1 ) * 1.0e-9 ;
2010-01-06 21:45:24 +03:00
if ( timediff > audit_timeout ) {
2012-07-25 20:39:57 +04:00
smb_time_audit_log_fsp ( " fchown " , timediff , fsp ) ;
2010-01-06 21:45:24 +03:00
}
return result ;
}
static int smb_time_audit_lchown ( vfs_handle_struct * handle ,
2016-03-04 01:34:57 +03:00
const struct smb_filename * smb_fname ,
uid_t uid ,
gid_t gid )
2010-01-06 21:45:24 +03:00
{
int result ;
2010-11-10 02:40:29 +03:00
struct timespec ts1 , ts2 ;
2010-01-06 21:45:24 +03:00
double timediff ;
2010-11-10 02:40:29 +03:00
clock_gettime_mono ( & ts1 ) ;
2016-03-04 01:34:57 +03:00
result = SMB_VFS_NEXT_LCHOWN ( handle , smb_fname , uid , gid ) ;
2010-11-10 02:40:29 +03:00
clock_gettime_mono ( & ts2 ) ;
timediff = nsec_time_diff ( & ts2 , & ts1 ) * 1.0e-9 ;
2010-01-06 21:45:24 +03:00
if ( timediff > audit_timeout ) {
2016-03-04 01:34:57 +03:00
smb_time_audit_log_fname ( " lchown " ,
timediff ,
smb_fname - > base_name ) ;
2010-01-06 21:45:24 +03:00
}
return result ;
}
static int smb_time_audit_chdir ( vfs_handle_struct * handle , const char * path )
{
int result ;
2010-11-10 02:40:29 +03:00
struct timespec ts1 , ts2 ;
2010-01-06 21:45:24 +03:00
double timediff ;
2010-11-10 02:40:29 +03:00
clock_gettime_mono ( & ts1 ) ;
2010-01-06 21:45:24 +03:00
result = SMB_VFS_NEXT_CHDIR ( handle , path ) ;
2010-11-10 02:40:29 +03:00
clock_gettime_mono ( & ts2 ) ;
2010-11-10 14:39:41 +03:00
timediff = nsec_time_diff ( & ts2 , & ts1 ) * 1.0e-9 ;
2010-01-06 21:45:24 +03:00
if ( timediff > audit_timeout ) {
2012-07-25 20:39:57 +04:00
smb_time_audit_log_fname ( " chdir " , timediff , path ) ;
2010-01-06 21:45:24 +03:00
}
return result ;
}
2011-06-01 03:36:06 +04:00
static char * smb_time_audit_getwd ( vfs_handle_struct * handle )
2010-01-06 21:45:24 +03:00
{
char * result ;
2010-11-10 02:40:29 +03:00
struct timespec ts1 , ts2 ;
2010-01-06 21:45:24 +03:00
double timediff ;
2010-11-10 02:40:29 +03:00
clock_gettime_mono ( & ts1 ) ;
2011-06-01 03:36:06 +04:00
result = SMB_VFS_NEXT_GETWD ( handle ) ;
2010-11-10 02:40:29 +03:00
clock_gettime_mono ( & ts2 ) ;
timediff = nsec_time_diff ( & ts2 , & ts1 ) * 1.0e-9 ;
2010-01-06 21:45:24 +03:00
if ( timediff > audit_timeout ) {
smb_time_audit_log ( " getwd " , timediff ) ;
}
return result ;
}
static int smb_time_audit_ntimes ( vfs_handle_struct * handle ,
const struct smb_filename * path ,
struct smb_file_time * ft )
{
int result ;
2010-11-10 02:40:29 +03:00
struct timespec ts1 , ts2 ;
2010-01-06 21:45:24 +03:00
double timediff ;
2010-11-10 02:40:29 +03:00
clock_gettime_mono ( & ts1 ) ;
2010-01-06 21:45:24 +03:00
result = SMB_VFS_NEXT_NTIMES ( handle , path , ft ) ;
2010-11-10 02:40:29 +03:00
clock_gettime_mono ( & ts2 ) ;
timediff = nsec_time_diff ( & ts2 , & ts1 ) * 1.0e-9 ;
2010-01-06 21:45:24 +03:00
if ( timediff > audit_timeout ) {
2012-07-25 20:39:57 +04:00
smb_time_audit_log_smb_fname ( " ntimes " , timediff , path ) ;
2010-01-06 21:45:24 +03:00
}
return result ;
}
static int smb_time_audit_ftruncate ( vfs_handle_struct * handle ,
files_struct * fsp ,
2012-04-05 08:53:08 +04:00
off_t len )
2010-01-06 21:45:24 +03:00
{
int result ;
2010-11-10 02:40:29 +03:00
struct timespec ts1 , ts2 ;
2010-01-06 21:45:24 +03:00
double timediff ;
2010-11-10 02:40:29 +03:00
clock_gettime_mono ( & ts1 ) ;
2010-01-06 21:45:24 +03:00
result = SMB_VFS_NEXT_FTRUNCATE ( handle , fsp , len ) ;
2010-11-10 02:40:29 +03:00
clock_gettime_mono ( & ts2 ) ;
timediff = nsec_time_diff ( & ts2 , & ts1 ) * 1.0e-9 ;
2010-01-06 21:45:24 +03:00
if ( timediff > audit_timeout ) {
2012-07-25 20:39:57 +04:00
smb_time_audit_log_fsp ( " ftruncate " , timediff , fsp ) ;
2010-01-06 21:45:24 +03:00
}
return result ;
}
2010-12-18 10:08:01 +03:00
static int smb_time_audit_fallocate ( vfs_handle_struct * handle ,
2010-12-03 03:25:59 +03:00
files_struct * fsp ,
2015-02-09 20:21:59 +03:00
uint32_t mode ,
2012-04-05 08:53:08 +04:00
off_t offset ,
off_t len )
2010-12-03 03:25:59 +03:00
{
int result ;
2014-12-06 02:37:11 +03:00
int saved_errno = 0 ;
2010-12-03 03:25:59 +03:00
struct timespec ts1 , ts2 ;
double timediff ;
clock_gettime_mono ( & ts1 ) ;
2010-12-18 10:08:01 +03:00
result = SMB_VFS_NEXT_FALLOCATE ( handle , fsp , mode , offset , len ) ;
2014-12-06 02:37:11 +03:00
if ( result = = - 1 ) {
saved_errno = errno ;
}
2010-12-03 03:25:59 +03:00
clock_gettime_mono ( & ts2 ) ;
timediff = nsec_time_diff ( & ts2 , & ts1 ) * 1.0e-9 ;
if ( timediff > audit_timeout ) {
2012-07-25 20:39:57 +04:00
smb_time_audit_log_fsp ( " fallocate " , timediff , fsp ) ;
2010-12-03 03:25:59 +03:00
}
2014-12-06 02:37:11 +03:00
if ( result = = - 1 ) {
errno = saved_errno ;
}
2010-12-03 03:25:59 +03:00
return result ;
}
2010-01-06 21:45:24 +03:00
static bool smb_time_audit_lock ( vfs_handle_struct * handle , files_struct * fsp ,
2012-04-05 08:53:08 +04:00
int op , off_t offset , off_t count ,
2010-01-06 21:45:24 +03:00
int type )
{
bool result ;
2010-11-10 02:40:29 +03:00
struct timespec ts1 , ts2 ;
2010-01-06 21:45:24 +03:00
double timediff ;
2010-11-10 02:40:29 +03:00
clock_gettime_mono ( & ts1 ) ;
2010-01-06 21:45:24 +03:00
result = SMB_VFS_NEXT_LOCK ( handle , fsp , op , offset , count , type ) ;
2010-11-10 02:40:29 +03:00
clock_gettime_mono ( & ts2 ) ;
timediff = nsec_time_diff ( & ts2 , & ts1 ) * 1.0e-9 ;
2010-01-06 21:45:24 +03:00
if ( timediff > audit_timeout ) {
2012-07-25 20:39:57 +04:00
smb_time_audit_log_fsp ( " lock " , timediff , fsp ) ;
2010-01-06 21:45:24 +03:00
}
return result ;
}
static int smb_time_audit_kernel_flock ( struct vfs_handle_struct * handle ,
struct files_struct * fsp ,
2015-05-01 06:16:18 +03:00
uint32_t share_mode , uint32_t access_mask )
2010-01-06 21:45:24 +03:00
{
int result ;
2010-11-10 02:40:29 +03:00
struct timespec ts1 , ts2 ;
2010-01-06 21:45:24 +03:00
double timediff ;
2010-11-10 02:40:29 +03:00
clock_gettime_mono ( & ts1 ) ;
2010-01-06 21:45:24 +03:00
result = SMB_VFS_NEXT_KERNEL_FLOCK ( handle , fsp , share_mode ,
access_mask ) ;
2010-11-10 02:40:29 +03:00
clock_gettime_mono ( & ts2 ) ;
timediff = nsec_time_diff ( & ts2 , & ts1 ) * 1.0e-9 ;
2010-01-06 21:45:24 +03:00
if ( timediff > audit_timeout ) {
2012-07-25 20:39:57 +04:00
smb_time_audit_log_fsp ( " kernel_flock " , timediff , fsp ) ;
2010-01-06 21:45:24 +03:00
}
return result ;
}
static int smb_time_audit_linux_setlease ( vfs_handle_struct * handle ,
files_struct * fsp ,
int leasetype )
{
int result ;
2010-11-10 02:40:29 +03:00
struct timespec ts1 , ts2 ;
2010-01-06 21:45:24 +03:00
double timediff ;
2010-11-10 02:40:29 +03:00
clock_gettime_mono ( & ts1 ) ;
2010-01-06 21:45:24 +03:00
result = SMB_VFS_NEXT_LINUX_SETLEASE ( handle , fsp , leasetype ) ;
2010-11-10 02:40:29 +03:00
clock_gettime_mono ( & ts2 ) ;
timediff = nsec_time_diff ( & ts2 , & ts1 ) * 1.0e-9 ;
2010-01-06 21:45:24 +03:00
if ( timediff > audit_timeout ) {
2012-07-25 20:39:57 +04:00
smb_time_audit_log_fsp ( " linux_setlease " , timediff , fsp ) ;
2010-01-06 21:45:24 +03:00
}
return result ;
}
static bool smb_time_audit_getlock ( vfs_handle_struct * handle ,
files_struct * fsp ,
2012-04-05 08:53:08 +04:00
off_t * poffset , off_t * pcount ,
2010-01-06 21:45:24 +03:00
int * ptype , pid_t * ppid )
{
bool result ;
2010-11-10 02:40:29 +03:00
struct timespec ts1 , ts2 ;
2010-01-06 21:45:24 +03:00
double timediff ;
2010-11-10 02:40:29 +03:00
clock_gettime_mono ( & ts1 ) ;
2010-01-06 21:45:24 +03:00
result = SMB_VFS_NEXT_GETLOCK ( handle , fsp , poffset , pcount , ptype ,
ppid ) ;
2010-11-10 02:40:29 +03:00
clock_gettime_mono ( & ts2 ) ;
timediff = nsec_time_diff ( & ts2 , & ts1 ) * 1.0e-9 ;
2010-01-06 21:45:24 +03:00
if ( timediff > audit_timeout ) {
2012-07-25 20:39:57 +04:00
smb_time_audit_log_fsp ( " getlock " , timediff , fsp ) ;
2010-01-06 21:45:24 +03:00
}
return result ;
}
static int smb_time_audit_symlink ( vfs_handle_struct * handle ,
const char * oldpath , const char * newpath )
{
int result ;
2010-11-10 02:40:29 +03:00
struct timespec ts1 , ts2 ;
2010-01-06 21:45:24 +03:00
double timediff ;
2010-11-10 02:40:29 +03:00
clock_gettime_mono ( & ts1 ) ;
2010-01-06 21:45:24 +03:00
result = SMB_VFS_NEXT_SYMLINK ( handle , oldpath , newpath ) ;
2010-11-10 02:40:29 +03:00
clock_gettime_mono ( & ts2 ) ;
timediff = nsec_time_diff ( & ts2 , & ts1 ) * 1.0e-9 ;
2010-01-06 21:45:24 +03:00
if ( timediff > audit_timeout ) {
2012-07-25 20:39:57 +04:00
smb_time_audit_log_fname ( " symlink " , timediff , newpath ) ;
2010-01-06 21:45:24 +03:00
}
return result ;
}
static int smb_time_audit_readlink ( vfs_handle_struct * handle ,
const char * path , char * buf , size_t bufsiz )
{
int result ;
2010-11-10 02:40:29 +03:00
struct timespec ts1 , ts2 ;
2010-01-06 21:45:24 +03:00
double timediff ;
2010-11-10 02:40:29 +03:00
clock_gettime_mono ( & ts1 ) ;
2010-01-06 21:45:24 +03:00
result = SMB_VFS_NEXT_READLINK ( handle , path , buf , bufsiz ) ;
2010-11-10 02:40:29 +03:00
clock_gettime_mono ( & ts2 ) ;
timediff = nsec_time_diff ( & ts2 , & ts1 ) * 1.0e-9 ;
2010-01-06 21:45:24 +03:00
if ( timediff > audit_timeout ) {
2012-07-25 20:39:57 +04:00
smb_time_audit_log_fname ( " readlink " , timediff , path ) ;
2010-01-06 21:45:24 +03:00
}
return result ;
}
static int smb_time_audit_link ( vfs_handle_struct * handle ,
const char * oldpath , const char * newpath )
{
int result ;
2010-11-10 02:40:29 +03:00
struct timespec ts1 , ts2 ;
2010-01-06 21:45:24 +03:00
double timediff ;
2010-11-10 02:40:29 +03:00
clock_gettime_mono ( & ts1 ) ;
2010-01-06 21:45:24 +03:00
result = SMB_VFS_NEXT_LINK ( handle , oldpath , newpath ) ;
2010-11-10 02:40:29 +03:00
clock_gettime_mono ( & ts2 ) ;
timediff = nsec_time_diff ( & ts2 , & ts1 ) * 1.0e-9 ;
2010-01-06 21:45:24 +03:00
if ( timediff > audit_timeout ) {
2012-07-25 20:39:57 +04:00
smb_time_audit_log_fname ( " link " , timediff , newpath ) ;
2010-01-06 21:45:24 +03:00
}
return result ;
}
static int smb_time_audit_mknod ( vfs_handle_struct * handle ,
const char * pathname , mode_t mode ,
SMB_DEV_T dev )
{
int result ;
2010-11-10 02:40:29 +03:00
struct timespec ts1 , ts2 ;
2010-01-06 21:45:24 +03:00
double timediff ;
2010-11-10 02:40:29 +03:00
clock_gettime_mono ( & ts1 ) ;
2010-01-06 21:45:24 +03:00
result = SMB_VFS_NEXT_MKNOD ( handle , pathname , mode , dev ) ;
2010-11-10 02:40:29 +03:00
clock_gettime_mono ( & ts2 ) ;
timediff = nsec_time_diff ( & ts2 , & ts1 ) * 1.0e-9 ;
2010-01-06 21:45:24 +03:00
if ( timediff > audit_timeout ) {
2012-07-25 20:39:57 +04:00
smb_time_audit_log_fname ( " mknod " , timediff , pathname ) ;
2010-01-06 21:45:24 +03:00
}
return result ;
}
static char * smb_time_audit_realpath ( vfs_handle_struct * handle ,
2010-11-20 03:29:26 +03:00
const char * path )
2010-01-06 21:45:24 +03:00
{
char * result ;
2010-11-10 02:40:29 +03:00
struct timespec ts1 , ts2 ;
2010-01-06 21:45:24 +03:00
double timediff ;
2010-11-10 02:40:29 +03:00
clock_gettime_mono ( & ts1 ) ;
2010-11-20 03:29:26 +03:00
result = SMB_VFS_NEXT_REALPATH ( handle , path ) ;
2010-11-10 02:40:29 +03:00
clock_gettime_mono ( & ts2 ) ;
timediff = nsec_time_diff ( & ts2 , & ts1 ) * 1.0e-9 ;
2010-01-06 21:45:24 +03:00
if ( timediff > audit_timeout ) {
2012-07-25 20:39:57 +04:00
smb_time_audit_log_fname ( " realpath " , timediff , path ) ;
2010-01-06 21:45:24 +03:00
}
return result ;
}
static int smb_time_audit_chflags ( vfs_handle_struct * handle ,
const char * path , unsigned int flags )
{
int result ;
2010-11-10 02:40:29 +03:00
struct timespec ts1 , ts2 ;
2010-01-06 21:45:24 +03:00
double timediff ;
2010-11-10 02:40:29 +03:00
clock_gettime_mono ( & ts1 ) ;
2010-01-06 21:45:24 +03:00
result = SMB_VFS_NEXT_CHFLAGS ( handle , path , flags ) ;
2010-11-10 02:40:29 +03:00
clock_gettime_mono ( & ts2 ) ;
timediff = nsec_time_diff ( & ts2 , & ts1 ) * 1.0e-9 ;
2010-01-06 21:45:24 +03:00
if ( timediff > audit_timeout ) {
2012-07-25 20:39:57 +04:00
smb_time_audit_log_fname ( " chflags " , timediff , path ) ;
2010-01-06 21:45:24 +03:00
}
return result ;
}
static struct file_id smb_time_audit_file_id_create ( struct vfs_handle_struct * handle ,
const SMB_STRUCT_STAT * sbuf )
{
struct file_id id_zero ;
struct file_id result ;
2010-11-10 02:40:29 +03:00
struct timespec ts1 , ts2 ;
2010-01-06 21:45:24 +03:00
double timediff ;
ZERO_STRUCT ( id_zero ) ;
2010-11-10 02:40:29 +03:00
clock_gettime_mono ( & ts1 ) ;
2010-01-06 21:45:24 +03:00
result = SMB_VFS_NEXT_FILE_ID_CREATE ( handle , sbuf ) ;
2010-11-10 02:40:29 +03:00
clock_gettime_mono ( & ts2 ) ;
timediff = nsec_time_diff ( & ts2 , & ts1 ) * 1.0e-9 ;
2010-01-06 21:45:24 +03:00
if ( timediff > audit_timeout ) {
smb_time_audit_log ( " file_id_create " , timediff ) ;
}
return result ;
}
static NTSTATUS smb_time_audit_streaminfo ( vfs_handle_struct * handle ,
struct files_struct * fsp ,
2016-03-05 01:16:13 +03:00
const struct smb_filename * smb_fname ,
2010-01-06 21:45:24 +03:00
TALLOC_CTX * mem_ctx ,
unsigned int * pnum_streams ,
struct stream_struct * * pstreams )
{
NTSTATUS result ;
2010-11-10 02:40:29 +03:00
struct timespec ts1 , ts2 ;
2010-01-06 21:45:24 +03:00
double timediff ;
2010-11-10 02:40:29 +03:00
clock_gettime_mono ( & ts1 ) ;
2016-03-05 01:16:13 +03:00
result = SMB_VFS_NEXT_STREAMINFO ( handle , fsp , smb_fname , mem_ctx ,
2010-01-06 21:45:24 +03:00
pnum_streams , pstreams ) ;
2010-11-10 02:40:29 +03:00
clock_gettime_mono ( & ts2 ) ;
timediff = nsec_time_diff ( & ts2 , & ts1 ) * 1.0e-9 ;
2010-01-06 21:45:24 +03:00
if ( timediff > audit_timeout ) {
2012-07-25 20:39:57 +04:00
smb_time_audit_log_fsp ( " streaminfo " , timediff , fsp ) ;
2010-01-06 21:45:24 +03:00
}
return result ;
}
static int smb_time_audit_get_real_filename ( struct vfs_handle_struct * handle ,
const char * path ,
const char * name ,
TALLOC_CTX * mem_ctx ,
char * * found_name )
{
int result ;
2010-11-10 02:40:29 +03:00
struct timespec ts1 , ts2 ;
2010-01-06 21:45:24 +03:00
double timediff ;
2010-11-10 02:40:29 +03:00
clock_gettime_mono ( & ts1 ) ;
2010-01-06 21:45:24 +03:00
result = SMB_VFS_NEXT_GET_REAL_FILENAME ( handle , path , name , mem_ctx ,
found_name ) ;
2010-11-10 02:40:29 +03:00
clock_gettime_mono ( & ts2 ) ;
timediff = nsec_time_diff ( & ts2 , & ts1 ) * 1.0e-9 ;
2010-01-06 21:45:24 +03:00
if ( timediff > audit_timeout ) {
2012-07-25 20:39:57 +04:00
smb_time_audit_log_fname ( " get_real_filename " , timediff , path ) ;
2010-01-06 21:45:24 +03:00
}
return result ;
}
static const char * smb_time_audit_connectpath ( vfs_handle_struct * handle ,
const char * fname )
{
const char * result ;
2010-11-10 02:40:29 +03:00
struct timespec ts1 , ts2 ;
2010-01-06 21:45:24 +03:00
double timediff ;
2010-11-10 02:40:29 +03:00
clock_gettime_mono ( & ts1 ) ;
2010-01-06 21:45:24 +03:00
result = SMB_VFS_NEXT_CONNECTPATH ( handle , fname ) ;
2010-11-10 02:40:29 +03:00
clock_gettime_mono ( & ts2 ) ;
timediff = nsec_time_diff ( & ts2 , & ts1 ) * 1.0e-9 ;
2010-01-06 21:45:24 +03:00
if ( timediff > audit_timeout ) {
2012-07-25 20:39:57 +04:00
smb_time_audit_log_fname ( " connectpath " , timediff , fname ) ;
2010-01-06 21:45:24 +03:00
}
return result ;
}
static NTSTATUS smb_time_audit_brl_lock_windows ( struct vfs_handle_struct * handle ,
struct byte_range_lock * br_lck ,
struct lock_struct * plock ,
2014-07-03 17:51:45 +04:00
bool blocking_lock )
2010-01-06 21:45:24 +03:00
{
NTSTATUS result ;
2010-11-10 02:40:29 +03:00
struct timespec ts1 , ts2 ;
2010-01-06 21:45:24 +03:00
double timediff ;
2010-11-10 02:40:29 +03:00
clock_gettime_mono ( & ts1 ) ;
2010-01-06 21:45:24 +03:00
result = SMB_VFS_NEXT_BRL_LOCK_WINDOWS ( handle , br_lck , plock ,
2014-07-03 17:51:45 +04:00
blocking_lock ) ;
2010-11-10 02:40:29 +03:00
clock_gettime_mono ( & ts2 ) ;
timediff = nsec_time_diff ( & ts2 , & ts1 ) * 1.0e-9 ;
2010-01-06 21:45:24 +03:00
if ( timediff > audit_timeout ) {
2012-07-25 20:39:57 +04:00
smb_time_audit_log_fsp ( " brl_lock_windows " , timediff ,
2013-09-10 21:41:32 +04:00
brl_fsp ( br_lck ) ) ;
2010-01-06 21:45:24 +03:00
}
return result ;
}
static bool smb_time_audit_brl_unlock_windows ( struct vfs_handle_struct * handle ,
struct messaging_context * msg_ctx ,
struct byte_range_lock * br_lck ,
const struct lock_struct * plock )
{
bool result ;
2010-11-10 02:40:29 +03:00
struct timespec ts1 , ts2 ;
2010-01-06 21:45:24 +03:00
double timediff ;
2010-11-10 02:40:29 +03:00
clock_gettime_mono ( & ts1 ) ;
2010-01-06 21:45:24 +03:00
result = SMB_VFS_NEXT_BRL_UNLOCK_WINDOWS ( handle , msg_ctx , br_lck ,
plock ) ;
2010-11-10 02:40:29 +03:00
clock_gettime_mono ( & ts2 ) ;
timediff = nsec_time_diff ( & ts2 , & ts1 ) * 1.0e-9 ;
2010-01-06 21:45:24 +03:00
if ( timediff > audit_timeout ) {
2012-07-25 20:39:57 +04:00
smb_time_audit_log_fsp ( " brl_unlock_windows " , timediff ,
2013-09-10 21:41:32 +04:00
brl_fsp ( br_lck ) ) ;
2010-01-06 21:45:24 +03:00
}
return result ;
}
static bool smb_time_audit_brl_cancel_windows ( struct vfs_handle_struct * handle ,
struct byte_range_lock * br_lck ,
2014-07-03 17:51:45 +04:00
struct lock_struct * plock )
2010-01-06 21:45:24 +03:00
{
bool result ;
2010-11-10 02:40:29 +03:00
struct timespec ts1 , ts2 ;
2010-01-06 21:45:24 +03:00
double timediff ;
2010-11-10 02:40:29 +03:00
clock_gettime_mono ( & ts1 ) ;
2014-07-03 17:51:45 +04:00
result = SMB_VFS_NEXT_BRL_CANCEL_WINDOWS ( handle , br_lck , plock ) ;
2010-11-10 02:40:29 +03:00
clock_gettime_mono ( & ts2 ) ;
timediff = nsec_time_diff ( & ts2 , & ts1 ) * 1.0e-9 ;
2010-01-06 21:45:24 +03:00
if ( timediff > audit_timeout ) {
2012-07-25 20:39:57 +04:00
smb_time_audit_log_fsp ( " brl_cancel_windows " , timediff ,
2013-09-10 21:41:32 +04:00
brl_fsp ( br_lck ) ) ;
2010-01-06 21:45:24 +03:00
}
return result ;
}
static bool smb_time_audit_strict_lock ( struct vfs_handle_struct * handle ,
struct files_struct * fsp ,
struct lock_struct * plock )
{
bool result ;
2010-11-10 02:40:29 +03:00
struct timespec ts1 , ts2 ;
2010-01-06 21:45:24 +03:00
double timediff ;
2010-11-10 02:40:29 +03:00
clock_gettime_mono ( & ts1 ) ;
2010-01-06 21:45:24 +03:00
result = SMB_VFS_NEXT_STRICT_LOCK ( handle , fsp , plock ) ;
2010-11-10 02:40:29 +03:00
clock_gettime_mono ( & ts2 ) ;
timediff = nsec_time_diff ( & ts2 , & ts1 ) * 1.0e-9 ;
2010-01-06 21:45:24 +03:00
if ( timediff > audit_timeout ) {
2012-07-25 20:39:57 +04:00
smb_time_audit_log_fsp ( " strict_lock " , timediff , fsp ) ;
2010-01-06 21:45:24 +03:00
}
return result ;
}
static void smb_time_audit_strict_unlock ( struct vfs_handle_struct * handle ,
struct files_struct * fsp ,
struct lock_struct * plock )
{
2010-11-10 02:40:29 +03:00
struct timespec ts1 , ts2 ;
2010-01-06 21:45:24 +03:00
double timediff ;
2010-11-10 02:40:29 +03:00
clock_gettime_mono ( & ts1 ) ;
2010-01-06 21:45:24 +03:00
SMB_VFS_NEXT_STRICT_UNLOCK ( handle , fsp , plock ) ;
2010-11-10 02:40:29 +03:00
clock_gettime_mono ( & ts2 ) ;
timediff = nsec_time_diff ( & ts2 , & ts1 ) * 1.0e-9 ;
2010-01-06 21:45:24 +03:00
if ( timediff > audit_timeout ) {
2012-07-25 20:39:57 +04:00
smb_time_audit_log_fsp ( " strict_unlock " , timediff , fsp ) ;
2010-01-06 21:45:24 +03:00
}
}
static NTSTATUS smb_time_audit_translate_name ( struct vfs_handle_struct * handle ,
const char * name ,
enum vfs_translate_direction direction ,
TALLOC_CTX * mem_ctx ,
char * * mapped_name )
{
NTSTATUS result ;
2010-11-10 02:40:29 +03:00
struct timespec ts1 , ts2 ;
2010-01-06 21:45:24 +03:00
double timediff ;
2010-11-10 02:40:29 +03:00
clock_gettime_mono ( & ts1 ) ;
2010-01-06 21:45:24 +03:00
result = SMB_VFS_NEXT_TRANSLATE_NAME ( handle , name , direction , mem_ctx ,
mapped_name ) ;
2010-11-10 02:40:29 +03:00
clock_gettime_mono ( & ts2 ) ;
timediff = nsec_time_diff ( & ts2 , & ts1 ) * 1.0e-9 ;
2010-01-06 21:45:24 +03:00
if ( timediff > audit_timeout ) {
2012-07-25 20:39:57 +04:00
smb_time_audit_log_fname ( " translate_name " , timediff , name ) ;
2010-01-06 21:45:24 +03:00
}
return result ;
}
2016-04-05 02:46:56 +03:00
static NTSTATUS smb_time_audit_fsctl ( struct vfs_handle_struct * handle ,
struct files_struct * fsp ,
TALLOC_CTX * ctx ,
uint32_t function ,
uint16_t req_flags ,
const uint8_t * _in_data ,
uint32_t in_len ,
uint8_t * * _out_data ,
uint32_t max_out_len ,
uint32_t * out_len )
{
NTSTATUS result ;
struct timespec ts1 , ts2 ;
double timediff ;
clock_gettime_mono ( & ts1 ) ;
result = SMB_VFS_NEXT_FSCTL ( handle ,
fsp ,
ctx ,
function ,
req_flags ,
_in_data ,
in_len ,
_out_data ,
max_out_len ,
out_len ) ;
clock_gettime_mono ( & ts2 ) ;
timediff = nsec_time_diff ( & ts2 , & ts1 ) * 1.0e-9 ;
if ( timediff > audit_timeout ) {
smb_time_audit_log_fsp ( " fsctl " , timediff , fsp ) ;
}
return result ;
}
2013-01-15 20:22:59 +04:00
struct time_audit_cc_state {
struct timespec ts_send ;
struct vfs_handle_struct * handle ;
off_t copied ;
} ;
static void smb_time_audit_copy_chunk_done ( struct tevent_req * subreq ) ;
static struct tevent_req * smb_time_audit_copy_chunk_send ( struct vfs_handle_struct * handle ,
TALLOC_CTX * mem_ctx ,
struct tevent_context * ev ,
struct files_struct * src_fsp ,
off_t src_off ,
struct files_struct * dest_fsp ,
off_t dest_off ,
off_t num )
{
struct tevent_req * req ;
struct tevent_req * subreq ;
struct time_audit_cc_state * cc_state ;
req = tevent_req_create ( mem_ctx , & cc_state , struct time_audit_cc_state ) ;
if ( req = = NULL ) {
return NULL ;
}
cc_state - > handle = handle ;
clock_gettime_mono ( & cc_state - > ts_send ) ;
subreq = SMB_VFS_NEXT_COPY_CHUNK_SEND ( handle , cc_state , ev ,
src_fsp , src_off ,
dest_fsp , dest_off , num ) ;
if ( tevent_req_nomem ( subreq , req ) ) {
return tevent_req_post ( req , ev ) ;
}
tevent_req_set_callback ( subreq , smb_time_audit_copy_chunk_done , req ) ;
return req ;
}
static void smb_time_audit_copy_chunk_done ( struct tevent_req * subreq )
{
struct tevent_req * req = tevent_req_callback_data (
subreq , struct tevent_req ) ;
struct time_audit_cc_state * cc_state
= tevent_req_data ( req , struct time_audit_cc_state ) ;
NTSTATUS status ;
status = SMB_VFS_NEXT_COPY_CHUNK_RECV ( cc_state - > handle ,
subreq ,
& cc_state - > copied ) ;
TALLOC_FREE ( subreq ) ;
if ( tevent_req_nterror ( req , status ) ) {
return ;
}
tevent_req_done ( req ) ;
}
static NTSTATUS smb_time_audit_copy_chunk_recv ( struct vfs_handle_struct * handle ,
struct tevent_req * req ,
off_t * copied )
{
struct time_audit_cc_state * cc_state
= tevent_req_data ( req , struct time_audit_cc_state ) ;
struct timespec ts_recv ;
double timediff ;
NTSTATUS status ;
clock_gettime_mono ( & ts_recv ) ;
timediff = nsec_time_diff ( & ts_recv , & cc_state - > ts_send ) * 1.0e-9 ;
if ( timediff > audit_timeout ) {
smb_time_audit_log ( " copy_chunk " , timediff ) ;
}
* copied = cc_state - > copied ;
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 smb_time_audit_get_compression ( vfs_handle_struct * handle ,
TALLOC_CTX * mem_ctx ,
struct files_struct * fsp ,
struct smb_filename * smb_fname ,
uint16_t * _compression_fmt )
{
NTSTATUS result ;
struct timespec ts1 , ts2 ;
double timediff ;
clock_gettime_mono ( & ts1 ) ;
result = SMB_VFS_NEXT_GET_COMPRESSION ( handle , mem_ctx , fsp , smb_fname ,
_compression_fmt ) ;
clock_gettime_mono ( & ts2 ) ;
timediff = nsec_time_diff ( & ts2 , & ts1 ) * 1.0e-9 ;
if ( timediff > audit_timeout ) {
if ( fsp ! = NULL ) {
smb_time_audit_log_fsp ( " get_compression " ,
timediff , fsp ) ;
} else {
smb_time_audit_log_smb_fname ( " get_compression " ,
timediff , smb_fname ) ;
}
}
return result ;
}
static NTSTATUS smb_time_audit_set_compression ( vfs_handle_struct * handle ,
TALLOC_CTX * mem_ctx ,
struct files_struct * fsp ,
uint16_t compression_fmt )
{
NTSTATUS result ;
struct timespec ts1 , ts2 ;
double timediff ;
clock_gettime_mono ( & ts1 ) ;
result = SMB_VFS_NEXT_SET_COMPRESSION ( handle , mem_ctx , fsp ,
compression_fmt ) ;
clock_gettime_mono ( & ts2 ) ;
timediff = nsec_time_diff ( & ts2 , & ts1 ) * 1.0e-9 ;
if ( timediff > audit_timeout ) {
smb_time_audit_log_fsp ( " set_compression " , timediff , fsp ) ;
}
return result ;
}
2014-11-26 16:30:37 +03:00
static NTSTATUS smb_time_audit_readdir_attr ( struct vfs_handle_struct * handle ,
const struct smb_filename * fname ,
TALLOC_CTX * mem_ctx ,
struct readdir_attr_data * * pattr_data )
{
NTSTATUS status ;
struct timespec ts1 , ts2 ;
double timediff ;
clock_gettime_mono ( & ts1 ) ;
status = SMB_VFS_NEXT_READDIR_ATTR ( handle , fname , mem_ctx , pattr_data ) ;
clock_gettime_mono ( & ts2 ) ;
timediff = nsec_time_diff ( & ts2 , & ts1 ) * 1.0e-9 ;
if ( timediff > audit_timeout ) {
smb_time_audit_log_smb_fname ( " readdir_attr " , timediff , fname ) ;
}
return status ;
}
2010-01-06 21:45:24 +03:00
static NTSTATUS smb_time_audit_fget_nt_acl ( vfs_handle_struct * handle ,
files_struct * fsp ,
2015-05-01 06:16:18 +03:00
uint32_t security_info ,
2012-10-10 04:50:27 +04:00
TALLOC_CTX * mem_ctx ,
2010-01-06 21:45:24 +03:00
struct security_descriptor * * ppdesc )
{
NTSTATUS result ;
2010-11-10 02:40:29 +03:00
struct timespec ts1 , ts2 ;
2010-01-06 21:45:24 +03:00
double timediff ;
2010-11-10 02:40:29 +03:00
clock_gettime_mono ( & ts1 ) ;
2012-10-10 04:50:27 +04:00
result = SMB_VFS_NEXT_FGET_NT_ACL ( handle , fsp , security_info ,
mem_ctx , ppdesc ) ;
2010-11-10 02:40:29 +03:00
clock_gettime_mono ( & ts2 ) ;
timediff = nsec_time_diff ( & ts2 , & ts1 ) * 1.0e-9 ;
2010-01-06 21:45:24 +03:00
if ( timediff > audit_timeout ) {
2012-07-25 20:39:57 +04:00
smb_time_audit_log_fsp ( " fget_nt_acl " , timediff , fsp ) ;
2010-01-06 21:45:24 +03:00
}
return result ;
}
static NTSTATUS smb_time_audit_get_nt_acl ( vfs_handle_struct * handle ,
2016-02-12 21:30:10 +03:00
const struct smb_filename * smb_fname ,
2015-05-01 06:16:18 +03:00
uint32_t security_info ,
2012-10-10 04:50:27 +04:00
TALLOC_CTX * mem_ctx ,
2010-01-06 21:45:24 +03:00
struct security_descriptor * * ppdesc )
{
NTSTATUS result ;
2010-11-10 02:40:29 +03:00
struct timespec ts1 , ts2 ;
2010-01-06 21:45:24 +03:00
double timediff ;
2010-11-10 02:40:29 +03:00
clock_gettime_mono ( & ts1 ) ;
2016-02-12 21:30:10 +03:00
result = SMB_VFS_NEXT_GET_NT_ACL ( handle , smb_fname , security_info ,
2012-10-10 04:50:27 +04:00
mem_ctx , ppdesc ) ;
2010-11-10 02:40:29 +03:00
clock_gettime_mono ( & ts2 ) ;
timediff = nsec_time_diff ( & ts2 , & ts1 ) * 1.0e-9 ;
2010-01-06 21:45:24 +03:00
if ( timediff > audit_timeout ) {
2016-02-12 21:30:10 +03:00
smb_time_audit_log_fname ( " get_nt_acl " ,
timediff ,
smb_fname - > base_name ) ;
2010-01-06 21:45:24 +03:00
}
return result ;
}
static NTSTATUS smb_time_audit_fset_nt_acl ( vfs_handle_struct * handle ,
files_struct * fsp ,
2015-05-01 06:16:18 +03:00
uint32_t security_info_sent ,
2010-01-06 21:45:24 +03:00
const struct security_descriptor * psd )
{
NTSTATUS result ;
2010-11-10 02:40:29 +03:00
struct timespec ts1 , ts2 ;
2010-01-06 21:45:24 +03:00
double timediff ;
2010-11-10 02:40:29 +03:00
clock_gettime_mono ( & ts1 ) ;
2010-01-06 21:45:24 +03:00
result = SMB_VFS_NEXT_FSET_NT_ACL ( handle , fsp , security_info_sent ,
psd ) ;
2010-11-10 02:40:29 +03:00
clock_gettime_mono ( & ts2 ) ;
timediff = nsec_time_diff ( & ts2 , & ts1 ) * 1.0e-9 ;
2010-01-06 21:45:24 +03:00
if ( timediff > audit_timeout ) {
2012-07-25 20:39:57 +04:00
smb_time_audit_log_fsp ( " fset_nt_acl " , timediff , fsp ) ;
2010-01-06 21:45:24 +03:00
}
return result ;
}
static int smb_time_audit_chmod_acl ( vfs_handle_struct * handle ,
2016-03-02 04:25:25 +03:00
const struct smb_filename * smb_fname ,
mode_t mode )
2010-01-06 21:45:24 +03:00
{
int result ;
2010-11-10 02:40:29 +03:00
struct timespec ts1 , ts2 ;
2010-01-06 21:45:24 +03:00
double timediff ;
2010-11-10 02:40:29 +03:00
clock_gettime_mono ( & ts1 ) ;
2016-03-02 04:25:25 +03:00
result = SMB_VFS_NEXT_CHMOD_ACL ( handle , smb_fname , mode ) ;
2010-11-10 02:40:29 +03:00
clock_gettime_mono ( & ts2 ) ;
timediff = nsec_time_diff ( & ts2 , & ts1 ) * 1.0e-9 ;
2010-01-06 21:45:24 +03:00
if ( timediff > audit_timeout ) {
2016-03-02 04:25:25 +03:00
smb_time_audit_log_fname ( " chmod_acl " ,
timediff ,
smb_fname - > base_name ) ;
2010-01-06 21:45:24 +03:00
}
return result ;
}
static int smb_time_audit_fchmod_acl ( vfs_handle_struct * handle ,
files_struct * fsp , mode_t mode )
{
int result ;
2010-11-10 02:40:29 +03:00
struct timespec ts1 , ts2 ;
2010-01-06 21:45:24 +03:00
double timediff ;
2010-11-10 02:40:29 +03:00
clock_gettime_mono ( & ts1 ) ;
2010-01-06 21:45:24 +03:00
result = SMB_VFS_NEXT_FCHMOD_ACL ( handle , fsp , mode ) ;
2010-11-10 02:40:29 +03:00
clock_gettime_mono ( & ts2 ) ;
timediff = nsec_time_diff ( & ts2 , & ts1 ) * 1.0e-9 ;
2010-01-06 21:45:24 +03:00
if ( timediff > audit_timeout ) {
2012-07-25 20:39:57 +04:00
smb_time_audit_log_fsp ( " fchmod_acl " , timediff , fsp ) ;
2010-01-06 21:45:24 +03:00
}
return result ;
}
static SMB_ACL_T smb_time_audit_sys_acl_get_file ( vfs_handle_struct * handle ,
const char * path_p ,
2012-10-10 03:18:32 +04:00
SMB_ACL_TYPE_T type ,
TALLOC_CTX * mem_ctx )
2010-01-06 21:45:24 +03:00
{
SMB_ACL_T result ;
2010-11-10 02:40:29 +03:00
struct timespec ts1 , ts2 ;
2010-01-06 21:45:24 +03:00
double timediff ;
2010-11-10 02:40:29 +03:00
clock_gettime_mono ( & ts1 ) ;
2012-10-10 03:18:32 +04:00
result = SMB_VFS_NEXT_SYS_ACL_GET_FILE ( handle , path_p , type , mem_ctx ) ;
2010-11-10 02:40:29 +03:00
clock_gettime_mono ( & ts2 ) ;
timediff = nsec_time_diff ( & ts2 , & ts1 ) * 1.0e-9 ;
2010-01-06 21:45:24 +03:00
if ( timediff > audit_timeout ) {
2012-07-25 20:39:57 +04:00
smb_time_audit_log_fname ( " sys_acl_get_file " , timediff , path_p ) ;
2010-01-06 21:45:24 +03:00
}
return result ;
}
static SMB_ACL_T smb_time_audit_sys_acl_get_fd ( vfs_handle_struct * handle ,
2012-10-10 03:18:32 +04:00
files_struct * fsp ,
TALLOC_CTX * mem_ctx )
2010-01-06 21:45:24 +03:00
{
SMB_ACL_T result ;
2010-11-10 02:40:29 +03:00
struct timespec ts1 , ts2 ;
2010-01-06 21:45:24 +03:00
double timediff ;
2010-11-10 02:40:29 +03:00
clock_gettime_mono ( & ts1 ) ;
2012-10-10 03:18:32 +04:00
result = SMB_VFS_NEXT_SYS_ACL_GET_FD ( handle , fsp , mem_ctx ) ;
2010-11-10 02:40:29 +03:00
clock_gettime_mono ( & ts2 ) ;
timediff = nsec_time_diff ( & ts2 , & ts1 ) * 1.0e-9 ;
2010-01-06 21:45:24 +03:00
if ( timediff > audit_timeout ) {
2012-07-25 20:39:57 +04:00
smb_time_audit_log_fsp ( " sys_acl_get_fd " , timediff , fsp ) ;
2010-01-06 21:45:24 +03:00
}
return result ;
}
2012-09-10 06:44:01 +04:00
static int smb_time_audit_sys_acl_blob_get_file ( vfs_handle_struct * handle ,
const char * path_p ,
TALLOC_CTX * mem_ctx ,
char * * blob_description ,
DATA_BLOB * blob )
{
int result ;
struct timespec ts1 , ts2 ;
double timediff ;
clock_gettime_mono ( & ts1 ) ;
2012-10-10 09:44:41 +04:00
result = SMB_VFS_NEXT_SYS_ACL_BLOB_GET_FILE ( handle , path_p , mem_ctx , blob_description , blob ) ;
2012-09-10 06:44:01 +04:00
clock_gettime_mono ( & ts2 ) ;
timediff = nsec_time_diff ( & ts2 , & ts1 ) * 1.0e-9 ;
if ( timediff > audit_timeout ) {
smb_time_audit_log ( " sys_acl_blob_get_file " , timediff ) ;
}
return result ;
}
static int smb_time_audit_sys_acl_blob_get_fd ( vfs_handle_struct * handle ,
files_struct * fsp ,
TALLOC_CTX * mem_ctx ,
char * * blob_description ,
DATA_BLOB * blob )
{
int result ;
struct timespec ts1 , ts2 ;
double timediff ;
clock_gettime_mono ( & ts1 ) ;
result = SMB_VFS_NEXT_SYS_ACL_BLOB_GET_FD ( handle , fsp , mem_ctx , blob_description , blob ) ;
clock_gettime_mono ( & ts2 ) ;
timediff = nsec_time_diff ( & ts2 , & ts1 ) * 1.0e-9 ;
if ( timediff > audit_timeout ) {
smb_time_audit_log ( " sys_acl_blob_get_fd " , timediff ) ;
}
return result ;
}
2010-01-06 21:45:24 +03:00
static int smb_time_audit_sys_acl_set_file ( vfs_handle_struct * handle ,
const char * name ,
SMB_ACL_TYPE_T acltype ,
SMB_ACL_T theacl )
{
int result ;
2010-11-10 02:40:29 +03:00
struct timespec ts1 , ts2 ;
2010-01-06 21:45:24 +03:00
double timediff ;
2010-11-10 02:40:29 +03:00
clock_gettime_mono ( & ts1 ) ;
2010-01-06 21:45:24 +03:00
result = SMB_VFS_NEXT_SYS_ACL_SET_FILE ( handle , name , acltype ,
theacl ) ;
2010-11-10 02:40:29 +03:00
clock_gettime_mono ( & ts2 ) ;
timediff = nsec_time_diff ( & ts2 , & ts1 ) * 1.0e-9 ;
2010-01-06 21:45:24 +03:00
if ( timediff > audit_timeout ) {
2012-07-25 20:39:57 +04:00
smb_time_audit_log_fname ( " sys_acl_set_file " , timediff , name ) ;
2010-01-06 21:45:24 +03:00
}
return result ;
}
static int smb_time_audit_sys_acl_set_fd ( vfs_handle_struct * handle ,
files_struct * fsp ,
SMB_ACL_T theacl )
{
int result ;
2010-11-10 02:40:29 +03:00
struct timespec ts1 , ts2 ;
2010-01-06 21:45:24 +03:00
double timediff ;
2010-11-10 02:40:29 +03:00
clock_gettime_mono ( & ts1 ) ;
2010-01-06 21:45:24 +03:00
result = SMB_VFS_NEXT_SYS_ACL_SET_FD ( handle , fsp , theacl ) ;
2010-11-10 02:40:29 +03:00
clock_gettime_mono ( & ts2 ) ;
timediff = nsec_time_diff ( & ts2 , & ts1 ) * 1.0e-9 ;
2010-01-06 21:45:24 +03:00
if ( timediff > audit_timeout ) {
2012-07-25 20:39:57 +04:00
smb_time_audit_log_fsp ( " sys_acl_set_fd " , timediff , fsp ) ;
2010-01-06 21:45:24 +03:00
}
return result ;
}
static int smb_time_audit_sys_acl_delete_def_file ( vfs_handle_struct * handle ,
const char * path )
{
int result ;
2010-11-10 02:40:29 +03:00
struct timespec ts1 , ts2 ;
2010-01-06 21:45:24 +03:00
double timediff ;
2010-11-10 02:40:29 +03:00
clock_gettime_mono ( & ts1 ) ;
2010-01-06 21:45:24 +03:00
result = SMB_VFS_NEXT_SYS_ACL_DELETE_DEF_FILE ( handle , path ) ;
2010-11-10 02:40:29 +03:00
clock_gettime_mono ( & ts2 ) ;
timediff = nsec_time_diff ( & ts2 , & ts1 ) * 1.0e-9 ;
2010-01-06 21:45:24 +03:00
if ( timediff > audit_timeout ) {
2012-07-25 20:39:57 +04:00
smb_time_audit_log_fname ( " sys_acl_delete_def_file " , timediff , path ) ;
2010-01-06 21:45:24 +03:00
}
return result ;
}
static ssize_t smb_time_audit_getxattr ( struct vfs_handle_struct * handle ,
const char * path , const char * name ,
void * value , size_t size )
{
ssize_t result ;
2010-11-10 02:40:29 +03:00
struct timespec ts1 , ts2 ;
2010-01-06 21:45:24 +03:00
double timediff ;
2010-11-10 02:40:29 +03:00
clock_gettime_mono ( & ts1 ) ;
2010-01-06 21:45:24 +03:00
result = SMB_VFS_NEXT_GETXATTR ( handle , path , name , value , size ) ;
2010-11-10 02:40:29 +03:00
clock_gettime_mono ( & ts2 ) ;
timediff = nsec_time_diff ( & ts2 , & ts1 ) * 1.0e-9 ;
2010-01-06 21:45:24 +03:00
if ( timediff > audit_timeout ) {
2012-07-25 20:39:57 +04:00
smb_time_audit_log_fname ( " getxattr " , timediff , path ) ;
2010-01-06 21:45:24 +03:00
}
return result ;
}
static ssize_t smb_time_audit_fgetxattr ( struct vfs_handle_struct * handle ,
struct files_struct * fsp ,
const char * name , void * value ,
size_t size )
{
ssize_t result ;
2010-11-10 02:40:29 +03:00
struct timespec ts1 , ts2 ;
2010-01-06 21:45:24 +03:00
double timediff ;
2010-11-10 02:40:29 +03:00
clock_gettime_mono ( & ts1 ) ;
2010-01-06 21:45:24 +03:00
result = SMB_VFS_NEXT_FGETXATTR ( handle , fsp , name , value , size ) ;
2010-11-10 02:40:29 +03:00
clock_gettime_mono ( & ts2 ) ;
timediff = nsec_time_diff ( & ts2 , & ts1 ) * 1.0e-9 ;
2010-01-06 21:45:24 +03:00
if ( timediff > audit_timeout ) {
2012-07-25 20:39:57 +04:00
smb_time_audit_log_fsp ( " fgetxattr " , timediff , fsp ) ;
2010-01-06 21:45:24 +03:00
}
return result ;
}
static ssize_t smb_time_audit_listxattr ( struct vfs_handle_struct * handle ,
const char * path , char * list ,
size_t size )
{
ssize_t result ;
2010-11-10 02:40:29 +03:00
struct timespec ts1 , ts2 ;
2010-01-06 21:45:24 +03:00
double timediff ;
2010-11-10 02:40:29 +03:00
clock_gettime_mono ( & ts1 ) ;
2010-01-06 21:45:24 +03:00
result = SMB_VFS_NEXT_LISTXATTR ( handle , path , list , size ) ;
2010-11-10 02:40:29 +03:00
clock_gettime_mono ( & ts2 ) ;
timediff = nsec_time_diff ( & ts2 , & ts1 ) * 1.0e-9 ;
2010-01-06 21:45:24 +03:00
if ( timediff > audit_timeout ) {
2012-07-25 20:39:57 +04:00
smb_time_audit_log_fname ( " listxattr " , timediff , path ) ;
2010-01-06 21:45:24 +03:00
}
return result ;
}
static ssize_t smb_time_audit_flistxattr ( struct vfs_handle_struct * handle ,
struct files_struct * fsp , char * list ,
size_t size )
{
ssize_t result ;
2010-11-10 02:40:29 +03:00
struct timespec ts1 , ts2 ;
2010-01-06 21:45:24 +03:00
double timediff ;
2010-11-10 02:40:29 +03:00
clock_gettime_mono ( & ts1 ) ;
2010-01-06 21:45:24 +03:00
result = SMB_VFS_NEXT_FLISTXATTR ( handle , fsp , list , size ) ;
2010-11-10 02:40:29 +03:00
clock_gettime_mono ( & ts2 ) ;
timediff = nsec_time_diff ( & ts2 , & ts1 ) * 1.0e-9 ;
2010-01-06 21:45:24 +03:00
if ( timediff > audit_timeout ) {
2012-07-25 20:39:57 +04:00
smb_time_audit_log_fsp ( " flistxattr " , timediff , fsp ) ;
2010-01-06 21:45:24 +03:00
}
return result ;
}
static int smb_time_audit_removexattr ( struct vfs_handle_struct * handle ,
const char * path , const char * name )
{
int result ;
2010-11-10 02:40:29 +03:00
struct timespec ts1 , ts2 ;
2010-01-06 21:45:24 +03:00
double timediff ;
2010-11-10 02:40:29 +03:00
clock_gettime_mono ( & ts1 ) ;
2010-01-06 21:45:24 +03:00
result = SMB_VFS_NEXT_REMOVEXATTR ( handle , path , name ) ;
2010-11-10 02:40:29 +03:00
clock_gettime_mono ( & ts2 ) ;
timediff = nsec_time_diff ( & ts2 , & ts1 ) * 1.0e-9 ;
2010-01-06 21:45:24 +03:00
if ( timediff > audit_timeout ) {
2012-07-25 20:39:57 +04:00
smb_time_audit_log_fname ( " removexattr " , timediff , path ) ;
2010-01-06 21:45:24 +03:00
}
return result ;
}
static int smb_time_audit_fremovexattr ( struct vfs_handle_struct * handle ,
struct files_struct * fsp ,
const char * name )
{
int result ;
2010-11-10 02:40:29 +03:00
struct timespec ts1 , ts2 ;
2010-01-06 21:45:24 +03:00
double timediff ;
2010-11-10 02:40:29 +03:00
clock_gettime_mono ( & ts1 ) ;
2010-01-06 21:45:24 +03:00
result = SMB_VFS_NEXT_FREMOVEXATTR ( handle , fsp , name ) ;
2010-11-10 02:40:29 +03:00
clock_gettime_mono ( & ts2 ) ;
timediff = nsec_time_diff ( & ts2 , & ts1 ) * 1.0e-9 ;
2010-01-06 21:45:24 +03:00
if ( timediff > audit_timeout ) {
2012-07-25 20:39:57 +04:00
smb_time_audit_log_fsp ( " fremovexattr " , timediff , fsp ) ;
2010-01-06 21:45:24 +03:00
}
return result ;
}
static int smb_time_audit_setxattr ( struct vfs_handle_struct * handle ,
const char * path , const char * name ,
const void * value , size_t size ,
int flags )
{
int result ;
2010-11-10 02:40:29 +03:00
struct timespec ts1 , ts2 ;
2010-01-06 21:45:24 +03:00
double timediff ;
2010-11-10 02:40:29 +03:00
clock_gettime_mono ( & ts1 ) ;
2010-01-06 21:45:24 +03:00
result = SMB_VFS_NEXT_SETXATTR ( handle , path , name , value , size ,
flags ) ;
2010-11-10 02:40:29 +03:00
clock_gettime_mono ( & ts2 ) ;
timediff = nsec_time_diff ( & ts2 , & ts1 ) * 1.0e-9 ;
2010-01-06 21:45:24 +03:00
if ( timediff > audit_timeout ) {
2012-07-25 20:39:57 +04:00
smb_time_audit_log_fname ( " setxattr " , timediff , path ) ;
2010-01-06 21:45:24 +03:00
}
return result ;
}
static int smb_time_audit_fsetxattr ( struct vfs_handle_struct * handle ,
struct files_struct * fsp , const char * name ,
const void * value , size_t size , int flags )
{
int result ;
2010-11-10 02:40:29 +03:00
struct timespec ts1 , ts2 ;
2010-01-06 21:45:24 +03:00
double timediff ;
2010-11-10 02:40:29 +03:00
clock_gettime_mono ( & ts1 ) ;
2010-01-06 21:45:24 +03:00
result = SMB_VFS_NEXT_FSETXATTR ( handle , fsp , name , value , size , flags ) ;
2010-11-10 02:40:29 +03:00
clock_gettime_mono ( & ts2 ) ;
timediff = nsec_time_diff ( & ts2 , & ts1 ) * 1.0e-9 ;
2010-01-06 21:45:24 +03:00
if ( timediff > audit_timeout ) {
2012-07-25 20:39:57 +04:00
smb_time_audit_log_fsp ( " fsetxattr " , timediff , fsp ) ;
2010-01-06 21:45:24 +03:00
}
return result ;
}
static bool smb_time_audit_aio_force ( struct vfs_handle_struct * handle ,
struct files_struct * fsp )
{
bool result ;
2010-11-10 02:40:29 +03:00
struct timespec ts1 , ts2 ;
2010-01-06 21:45:24 +03:00
double timediff ;
2010-11-10 02:40:29 +03:00
clock_gettime_mono ( & ts1 ) ;
2010-01-06 21:45:24 +03:00
result = SMB_VFS_NEXT_AIO_FORCE ( handle , fsp ) ;
2010-11-10 02:40:29 +03:00
clock_gettime_mono ( & ts2 ) ;
timediff = nsec_time_diff ( & ts2 , & ts1 ) * 1.0e-9 ;
2010-01-06 21:45:24 +03:00
if ( timediff > audit_timeout ) {
2012-07-25 20:39:57 +04:00
smb_time_audit_log_fsp ( " aio_force " , timediff , fsp ) ;
2010-01-06 21:45:24 +03:00
}
return result ;
}
2013-10-12 02:24:53 +04:00
static bool smb_time_audit_is_offline ( struct vfs_handle_struct * handle ,
const struct smb_filename * fname ,
SMB_STRUCT_STAT * sbuf )
{
bool result ;
struct timespec ts1 , ts2 ;
double timediff ;
clock_gettime_mono ( & ts1 ) ;
result = SMB_VFS_NEXT_IS_OFFLINE ( handle , fname , sbuf ) ;
clock_gettime_mono ( & ts2 ) ;
timediff = nsec_time_diff ( & ts2 , & ts1 ) * 1.0e-9 ;
if ( timediff > audit_timeout ) {
smb_time_audit_log_smb_fname ( " is_offline " , timediff , fname ) ;
}
return result ;
}
static int smb_time_audit_set_offline ( struct vfs_handle_struct * handle ,
const struct smb_filename * fname )
{
int result ;
struct timespec ts1 , ts2 ;
double timediff ;
clock_gettime_mono ( & ts1 ) ;
result = SMB_VFS_NEXT_SET_OFFLINE ( handle , fname ) ;
clock_gettime_mono ( & ts2 ) ;
timediff = nsec_time_diff ( & ts2 , & ts1 ) * 1.0e-9 ;
if ( timediff > audit_timeout ) {
smb_time_audit_log_smb_fname ( " set_offline " , timediff , fname ) ;
}
return result ;
}
2014-01-24 13:09:57 +04:00
static NTSTATUS smb_time_audit_durable_cookie ( struct vfs_handle_struct * handle ,
struct files_struct * fsp ,
TALLOC_CTX * mem_ctx ,
DATA_BLOB * cookie )
2013-10-12 02:24:53 +04:00
{
NTSTATUS result ;
struct timespec ts1 , ts2 ;
double timediff ;
clock_gettime_mono ( & ts1 ) ;
result = SMB_VFS_NEXT_DURABLE_COOKIE ( handle , fsp , mem_ctx , cookie ) ;
clock_gettime_mono ( & ts2 ) ;
timediff = nsec_time_diff ( & ts2 , & ts1 ) * 1.0e-9 ;
if ( timediff > audit_timeout ) {
smb_time_audit_log_fsp ( " durable_cookie " , timediff , fsp ) ;
}
return result ;
}
2014-01-24 13:09:57 +04:00
static NTSTATUS smb_time_audit_durable_disconnect ( struct vfs_handle_struct * handle ,
struct files_struct * fsp ,
const DATA_BLOB old_cookie ,
TALLOC_CTX * mem_ctx ,
DATA_BLOB * new_cookie )
2013-10-12 02:24:53 +04:00
{
NTSTATUS result ;
struct timespec ts1 , ts2 ;
double timediff ;
clock_gettime_mono ( & ts1 ) ;
result = SMB_VFS_NEXT_DURABLE_DISCONNECT ( handle , fsp , old_cookie ,
mem_ctx , new_cookie ) ;
clock_gettime_mono ( & ts2 ) ;
timediff = nsec_time_diff ( & ts2 , & ts1 ) * 1.0e-9 ;
if ( timediff > audit_timeout ) {
smb_time_audit_log_fsp ( " durable_disconnect " , timediff , fsp ) ;
}
return result ;
}
2014-01-24 13:09:57 +04:00
static NTSTATUS smb_time_audit_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 )
2013-10-12 02:24:53 +04:00
{
NTSTATUS result ;
struct timespec ts1 , ts2 ;
double timediff ;
2010-01-06 21:45:24 +03:00
2013-10-12 02:24:53 +04:00
clock_gettime_mono ( & ts1 ) ;
result = SMB_VFS_NEXT_DURABLE_RECONNECT ( handle , smb1req , op , old_cookie ,
mem_ctx , fsp , new_cookie ) ;
clock_gettime_mono ( & ts2 ) ;
timediff = nsec_time_diff ( & ts2 , & ts1 ) * 1.0e-9 ;
if ( timediff > audit_timeout ) {
smb_time_audit_log ( " durable_reconnect " , timediff ) ;
}
return result ;
}
2010-01-06 21:45:24 +03:00
/* VFS operations */
static struct vfs_fn_pointers vfs_time_audit_fns = {
. connect_fn = smb_time_audit_connect ,
2011-12-04 08:45:04 +04:00
. disconnect_fn = smb_time_audit_disconnect ,
. disk_free_fn = smb_time_audit_disk_free ,
. get_quota_fn = smb_time_audit_get_quota ,
. set_quota_fn = smb_time_audit_set_quota ,
. get_shadow_copy_data_fn = smb_time_audit_get_shadow_copy_data ,
. statvfs_fn = smb_time_audit_statvfs ,
. fs_capabilities_fn = smb_time_audit_fs_capabilities ,
2016-04-05 02:42:49 +03:00
. get_dfs_referrals_fn = smb_time_audit_get_dfs_referrals ,
2011-12-04 08:45:04 +04:00
. opendir_fn = smb_time_audit_opendir ,
. fdopendir_fn = smb_time_audit_fdopendir ,
. readdir_fn = smb_time_audit_readdir ,
. seekdir_fn = smb_time_audit_seekdir ,
. telldir_fn = smb_time_audit_telldir ,
. rewind_dir_fn = smb_time_audit_rewinddir ,
. mkdir_fn = smb_time_audit_mkdir ,
. rmdir_fn = smb_time_audit_rmdir ,
. closedir_fn = smb_time_audit_closedir ,
. init_search_op_fn = smb_time_audit_init_search_op ,
2011-04-21 00:55:25 +04:00
. open_fn = smb_time_audit_open ,
2011-12-04 08:45:04 +04:00
. create_file_fn = smb_time_audit_create_file ,
2010-01-06 21:45:24 +03:00
. close_fn = smb_time_audit_close ,
2011-12-04 08:45:04 +04:00
. read_fn = smb_time_audit_read ,
. pread_fn = smb_time_audit_pread ,
2012-07-09 19:17:25 +04:00
. pread_send_fn = smb_time_audit_pread_send ,
. pread_recv_fn = smb_time_audit_pread_recv ,
2011-12-04 08:45:04 +04:00
. write_fn = smb_time_audit_write ,
. pwrite_fn = smb_time_audit_pwrite ,
2012-07-09 19:17:25 +04:00
. pwrite_send_fn = smb_time_audit_pwrite_send ,
. pwrite_recv_fn = smb_time_audit_pwrite_recv ,
2011-12-04 08:45:04 +04:00
. lseek_fn = smb_time_audit_lseek ,
. sendfile_fn = smb_time_audit_sendfile ,
. recvfile_fn = smb_time_audit_recvfile ,
. rename_fn = smb_time_audit_rename ,
. fsync_fn = smb_time_audit_fsync ,
2012-07-13 12:22:25 +04:00
. fsync_send_fn = smb_time_audit_fsync_send ,
. fsync_recv_fn = smb_time_audit_fsync_recv ,
2011-12-04 08:45:04 +04:00
. stat_fn = smb_time_audit_stat ,
. fstat_fn = smb_time_audit_fstat ,
. lstat_fn = smb_time_audit_lstat ,
. get_alloc_size_fn = smb_time_audit_get_alloc_size ,
. unlink_fn = smb_time_audit_unlink ,
. chmod_fn = smb_time_audit_chmod ,
. fchmod_fn = smb_time_audit_fchmod ,
. chown_fn = smb_time_audit_chown ,
. fchown_fn = smb_time_audit_fchown ,
. lchown_fn = smb_time_audit_lchown ,
. chdir_fn = smb_time_audit_chdir ,
. getwd_fn = smb_time_audit_getwd ,
. ntimes_fn = smb_time_audit_ntimes ,
. ftruncate_fn = smb_time_audit_ftruncate ,
. fallocate_fn = smb_time_audit_fallocate ,
. lock_fn = smb_time_audit_lock ,
. kernel_flock_fn = smb_time_audit_kernel_flock ,
. linux_setlease_fn = smb_time_audit_linux_setlease ,
. getlock_fn = smb_time_audit_getlock ,
. symlink_fn = smb_time_audit_symlink ,
. readlink_fn = smb_time_audit_readlink ,
. link_fn = smb_time_audit_link ,
. mknod_fn = smb_time_audit_mknod ,
. realpath_fn = smb_time_audit_realpath ,
. chflags_fn = smb_time_audit_chflags ,
. file_id_create_fn = smb_time_audit_file_id_create ,
2016-04-05 02:39:22 +03:00
. copy_chunk_send_fn = smb_time_audit_copy_chunk_send ,
. copy_chunk_recv_fn = smb_time_audit_copy_chunk_recv ,
. get_compression_fn = smb_time_audit_get_compression ,
. set_compression_fn = smb_time_audit_set_compression ,
. snap_check_path_fn = smb_time_audit_snap_check_path ,
. snap_create_fn = smb_time_audit_snap_create ,
. snap_delete_fn = smb_time_audit_snap_delete ,
2011-12-04 08:45:04 +04:00
. streaminfo_fn = smb_time_audit_streaminfo ,
. get_real_filename_fn = smb_time_audit_get_real_filename ,
. connectpath_fn = smb_time_audit_connectpath ,
. brl_lock_windows_fn = smb_time_audit_brl_lock_windows ,
. brl_unlock_windows_fn = smb_time_audit_brl_unlock_windows ,
. brl_cancel_windows_fn = smb_time_audit_brl_cancel_windows ,
. strict_lock_fn = smb_time_audit_strict_lock ,
. strict_unlock_fn = smb_time_audit_strict_unlock ,
. translate_name_fn = smb_time_audit_translate_name ,
2016-04-05 02:46:56 +03:00
. fsctl_fn = smb_time_audit_fsctl ,
2016-04-05 02:39:22 +03:00
/* Missing
get_dos_attributes
fget_dos_attributes
set_dos_attributes
fset_dos_attributes
*/
2011-12-04 08:45:04 +04:00
. fget_nt_acl_fn = smb_time_audit_fget_nt_acl ,
. get_nt_acl_fn = smb_time_audit_get_nt_acl ,
. fset_nt_acl_fn = smb_time_audit_fset_nt_acl ,
2016-04-05 02:39:22 +03:00
/* Missing audit_file */
2011-12-04 08:45:04 +04:00
. chmod_acl_fn = smb_time_audit_chmod_acl ,
. fchmod_acl_fn = smb_time_audit_fchmod_acl ,
. sys_acl_get_file_fn = smb_time_audit_sys_acl_get_file ,
. sys_acl_get_fd_fn = smb_time_audit_sys_acl_get_fd ,
2012-09-10 06:44:01 +04:00
. sys_acl_blob_get_file_fn = smb_time_audit_sys_acl_blob_get_file ,
. sys_acl_blob_get_fd_fn = smb_time_audit_sys_acl_blob_get_fd ,
2011-12-04 08:45:04 +04:00
. sys_acl_set_file_fn = smb_time_audit_sys_acl_set_file ,
. sys_acl_set_fd_fn = smb_time_audit_sys_acl_set_fd ,
2012-08-31 21:33:57 +04:00
. sys_acl_delete_def_file_fn = smb_time_audit_sys_acl_delete_def_file ,
2011-12-04 08:45:04 +04:00
. getxattr_fn = smb_time_audit_getxattr ,
. fgetxattr_fn = smb_time_audit_fgetxattr ,
. listxattr_fn = smb_time_audit_listxattr ,
. flistxattr_fn = smb_time_audit_flistxattr ,
. removexattr_fn = smb_time_audit_removexattr ,
. fremovexattr_fn = smb_time_audit_fremovexattr ,
. setxattr_fn = smb_time_audit_setxattr ,
. fsetxattr_fn = smb_time_audit_fsetxattr ,
. aio_force_fn = smb_time_audit_aio_force ,
2013-10-12 02:24:53 +04:00
. is_offline_fn = smb_time_audit_is_offline ,
. set_offline_fn = smb_time_audit_set_offline ,
. durable_cookie_fn = smb_time_audit_durable_cookie ,
. durable_disconnect_fn = smb_time_audit_durable_disconnect ,
. durable_reconnect_fn = smb_time_audit_durable_reconnect ,
2016-04-05 02:39:22 +03:00
. readdir_attr_fn = smb_time_audit_readdir_attr ,
2010-01-06 21:45:24 +03:00
} ;
NTSTATUS vfs_time_audit_init ( void ) ;
NTSTATUS vfs_time_audit_init ( void )
{
audit_timeout = ( double ) lp_parm_int ( - 1 , " time_audit " , " timeout " ,
10000 ) / 1000.0 ;
return smb_register_vfs ( SMB_VFS_INTERFACE_VERSION , " time_audit " ,
& vfs_time_audit_fns ) ;
}