2000-06-12 09:32:28 +04:00
/*
2002-01-30 09:08:46 +03:00
Unix SMB / CIFS implementation .
2000-06-12 09:34:14 +04:00
change notify handling
Copyright ( C ) Andrew Tridgell 2000
totally rewrote the async signal, notification and oplock notification
handling in Samba. This was needed due to several limitations and
races in the previous code - as a side effect the new code is much
cleaner :)
in summary:
- changed sys_select() to avoid a signal/select race condition. It is a
rare race but once we have signals doing notification and oplocks it
is important.
- changed our main processing loop to take advantage of the new
sys_select semantics
- split the notify code into implementaion dependent and general
parts. Added the following structure that defines an implementation:
struct cnotify_fns {
void * (*register_notify)(connection_struct *conn, char *path, uint32 flags);
BOOL (*check_notify)(connection_struct *conn, uint16 vuid, char *path, uint32 flags, void *data, time_t t);
void (*remove_notify)(void *data);
};
then I wrote two implementations, one using hash/poll (like our old
code) and the other using the new Linux kernel change notify. It
should be easy to add other change notify implementations by creating
a sructure of the above type.
- fixed a bug in change notify where we were returning the wrong error
code.
- rewrote the core change notify code to be much simpler
- moved to real-time signals for leases and change notify
Amazingly, it all seems to work. I was very surprised!
(This used to be commit 44766c39e0027c762bee8b33b12c621c109a3267)
2000-06-12 19:53:31 +04:00
Copyright ( C ) Jeremy Allison 1994 - 1998
2007-01-21 14:49:00 +03:00
Copyright ( C ) Volker Lendecke 2007
2000-06-12 09:32:28 +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
2000-06-12 09:32:28 +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 04:52:41 +04:00
along with this program . If not , see < http : //www.gnu.org/licenses/>.
2000-06-12 09:32:28 +04:00
*/
# include "includes.h"
2011-03-22 18:57:01 +03:00
# include "smbd/smbd.h"
2009-01-08 14:03:45 +03:00
# include "smbd/globals.h"
2010-07-07 03:50:56 +04:00
# include "../librpc/gen_ndr/ndr_notify.h"
2015-04-21 11:16:16 +03:00
# include "librpc/gen_ndr/ndr_file_id.h"
2018-11-06 17:21:37 +03:00
# include "libcli/security/privileges.h"
# include "libcli/security/security.h"
2000-06-12 09:32:28 +04:00
2014-04-04 19:00:16 +04:00
struct notify_change_event {
struct timespec when ;
uint32_t action ;
const char * name ;
} ;
2012-06-05 11:38:05 +04:00
struct notify_change_buf {
2016-06-24 17:27:34 +03:00
/*
* Filters for reinitializing after notifyd has been restarted
*/
uint32_t filter ;
uint32_t subdir_filter ;
2012-06-05 11:38:05 +04:00
/*
* If no requests are pending , changes are queued here . Simple array ,
* we only append .
*/
2019-01-16 23:29:51 +03:00
uint32_t max_buffer_size ;
2012-06-05 11:38:05 +04:00
/*
* num_changes = = - 1 means that we have got a catch - all change , when
* asked we just return NT_STATUS_OK without specific changes .
*/
int num_changes ;
2014-04-04 19:00:16 +04:00
struct notify_change_event * changes ;
2012-06-05 11:38:05 +04:00
/*
* If no changes are around requests are queued here . Using a linked
* list , because we have to append at the end and delete from the top .
*/
struct notify_change_request * requests ;
} ;
2007-02-02 17:55:21 +03:00
struct notify_change_request {
struct notify_change_request * prev , * next ;
struct files_struct * fsp ; /* backpointer for cancel by mid */
2008-11-05 00:04:58 +03:00
struct smb_request * req ;
2015-05-03 07:01:14 +03:00
uint32_t filter ;
uint32_t max_param ;
2009-06-30 17:01:00 +04:00
void ( * reply_fn ) ( struct smb_request * req ,
NTSTATUS error_code ,
uint8_t * buf , size_t len ) ;
2007-02-02 17:55:21 +03:00
struct notify_mid_map * mid_map ;
void * backend_data ;
} ;
2014-04-04 19:03:44 +04:00
static void notify_fsp ( files_struct * fsp , struct timespec when ,
2015-05-03 07:01:14 +03:00
uint32_t action , const char * name ) ;
2007-02-02 17:55:21 +03:00
2012-06-05 11:36:36 +04:00
bool change_notify_fsp_has_changes ( struct files_struct * fsp )
{
if ( fsp = = NULL ) {
return false ;
}
if ( fsp - > notify = = NULL ) {
return false ;
}
if ( fsp - > notify - > num_changes = = 0 ) {
return false ;
}
return true ;
}
2007-01-17 21:23:37 +03:00
/*
* For NTCancel , we need to find the notify_change_request indexed by
* mid . Separate list here .
*/
struct notify_mid_map {
struct notify_mid_map * prev , * next ;
struct notify_change_request * req ;
2010-04-13 08:40:28 +04:00
uint64_t mid ;
2007-01-17 21:23:37 +03:00
} ;
2014-04-04 19:00:16 +04:00
static bool notify_change_record_identical ( struct notify_change_event * c1 ,
struct notify_change_event * c2 )
2007-07-07 01:46:43 +04:00
{
/* Note this is deliberately case sensitive. */
if ( c1 - > action = = c2 - > action & &
strcmp ( c1 - > name , c2 - > name ) = = 0 ) {
return True ;
}
return False ;
}
2014-09-09 03:16:24 +04:00
static int compare_notify_change_events ( const void * p1 , const void * p2 )
{
const struct notify_change_event * e1 = p1 ;
const struct notify_change_event * e2 = p2 ;
return timespec_compare ( & e1 - > when , & e2 - > when ) ;
}
2007-10-19 04:40:25 +04:00
static bool notify_marshall_changes ( int num_changes ,
2015-05-03 07:01:14 +03:00
uint32_t max_offset ,
2014-04-04 19:00:16 +04:00
struct notify_change_event * changes ,
2010-07-07 03:50:56 +04:00
DATA_BLOB * final_blob )
2007-01-17 19:23:45 +03:00
{
int i ;
2009-06-30 00:17:17 +04:00
if ( num_changes = = - 1 ) {
return false ;
}
2014-09-09 03:16:24 +04:00
/*
* Sort the notifies by timestamp when the event happened to avoid
* coalescing and thus dropping events .
*/
qsort ( changes , num_changes ,
sizeof ( * changes ) , compare_notify_change_events ) ;
2007-01-17 19:23:45 +03:00
for ( i = 0 ; i < num_changes ; i + + ) {
2010-07-07 03:50:56 +04:00
enum ndr_err_code ndr_err ;
2014-04-04 19:00:16 +04:00
struct notify_change_event * c ;
2010-07-07 03:50:56 +04:00
struct FILE_NOTIFY_INFORMATION m ;
DATA_BLOB blob ;
2015-10-17 01:13:47 +03:00
uint16_t pad = 0 ;
2007-01-17 19:23:45 +03:00
2007-07-07 01:46:43 +04:00
/* Coalesce any identical records. */
while ( i + 1 < num_changes & &
notify_change_record_identical ( & changes [ i ] ,
& changes [ i + 1 ] ) ) {
i + + ;
}
c = & changes [ i ] ;
2010-07-07 03:50:56 +04:00
m . FileName1 = c - > name ;
m . FileNameLength = strlen_m ( c - > name ) * 2 ;
m . Action = c - > action ;
2015-10-17 01:13:47 +03:00
m . _pad = data_blob_null ;
2007-01-17 19:23:45 +03:00
/*
* Offset to next entry , only if there is one
*/
2015-10-17 01:13:47 +03:00
if ( i = = ( num_changes - 1 ) ) {
m . NextEntryOffset = 0 ;
} else {
if ( ( m . FileNameLength % 4 ) = = 2 ) {
m . _pad = data_blob_const ( & pad , 2 ) ;
}
m . NextEntryOffset =
ndr_size_FILE_NOTIFY_INFORMATION ( & m , 0 ) ;
}
2010-07-07 03:50:56 +04:00
ndr_err = ndr_push_struct_blob ( & blob , talloc_tos ( ) , & m ,
( ndr_push_flags_fn_t ) ndr_push_FILE_NOTIFY_INFORMATION ) ;
if ( ! NDR_ERR_CODE_IS_SUCCESS ( ndr_err ) ) {
return false ;
}
2007-01-17 19:23:45 +03:00
2010-07-07 03:50:56 +04:00
if ( DEBUGLEVEL > = 10 ) {
NDR_PRINT_DEBUG ( FILE_NOTIFY_INFORMATION , & m ) ;
}
2007-01-17 19:23:45 +03:00
2010-07-07 03:50:56 +04:00
if ( ! data_blob_append ( talloc_tos ( ) , final_blob ,
blob . data , blob . length ) ) {
data_blob_free ( & blob ) ;
return false ;
2010-07-06 04:18:35 +04:00
}
2010-07-07 03:50:56 +04:00
data_blob_free ( & blob ) ;
2007-07-18 03:01:02 +04:00
2010-07-07 03:50:56 +04:00
if ( final_blob - > length > max_offset ) {
2007-07-18 03:01:02 +04:00
/* Too much data for client. */
2008-06-17 12:46:20 +04:00
DEBUG ( 10 , ( " Client only wanted %d bytes, trying to "
" marshall %d bytes \n " , ( int ) max_offset ,
2010-07-07 03:50:56 +04:00
( int ) final_blob - > length ) ) ;
2007-07-18 03:01:02 +04:00
return False ;
}
2007-01-17 19:23:45 +03:00
}
return True ;
}
2000-06-12 09:32:28 +04:00
/****************************************************************************
Setup the common parts of the return packet and send it .
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
2003-08-02 12:48:01 +04:00
2010-06-12 15:17:51 +04:00
void change_notify_reply ( struct smb_request * req ,
2009-06-30 00:17:17 +04:00
NTSTATUS error_code ,
uint32_t max_param ,
2009-06-30 17:01:00 +04:00
struct notify_change_buf * notify_buf ,
void ( * reply_fn ) ( struct smb_request * req ,
2010-06-12 15:17:51 +04:00
NTSTATUS error_code ,
uint8_t * buf , size_t len ) )
2007-01-17 19:23:45 +03:00
{
2010-07-07 03:50:56 +04:00
DATA_BLOB blob = data_blob_null ;
2007-01-17 19:23:45 +03:00
2009-06-30 00:17:17 +04:00
if ( ! NT_STATUS_IS_OK ( error_code ) ) {
2009-06-30 17:01:00 +04:00
reply_fn ( req , error_code , NULL , 0 ) ;
2009-06-30 00:17:17 +04:00
return ;
}
2019-01-16 23:29:51 +03:00
if ( notify_buf = = NULL ) {
2009-06-30 17:01:00 +04:00
reply_fn ( req , NT_STATUS_OK , NULL , 0 ) ;
2007-01-21 14:49:00 +03:00
return ;
}
2019-01-16 23:29:51 +03:00
max_param = MIN ( max_param , notify_buf - > max_buffer_size ) ;
2007-07-18 03:01:02 +04:00
if ( ! notify_marshall_changes ( notify_buf - > num_changes , max_param ,
2010-07-07 03:50:56 +04:00
notify_buf - > changes , & blob ) ) {
2007-07-05 22:28:18 +04:00
/*
* We exceed what the client is willing to accept . Send
* nothing .
*/
2010-07-07 03:50:56 +04:00
data_blob_free ( & blob ) ;
2007-01-17 19:23:45 +03:00
}
2010-07-07 03:50:56 +04:00
reply_fn ( req , NT_STATUS_OK , blob . data , blob . length ) ;
2007-01-17 19:23:45 +03:00
2010-07-07 03:50:56 +04:00
data_blob_free ( & blob ) ;
2007-02-02 17:55:21 +03:00
TALLOC_FREE ( notify_buf - > changes ) ;
notify_buf - > num_changes = 0 ;
}
2016-06-14 16:00:29 +03:00
struct notify_fsp_state {
struct files_struct * notified_fsp ;
struct timespec when ;
const struct notify_event * e ;
} ;
static struct files_struct * notify_fsp_cb ( struct files_struct * fsp ,
void * private_data )
{
struct notify_fsp_state * state = private_data ;
if ( fsp = = state - > notified_fsp ) {
DBG_DEBUG ( " notify_callback called for %s \n " , fsp_str_dbg ( fsp ) ) ;
notify_fsp ( fsp , state - > when , state - > e - > action , state - > e - > path ) ;
return fsp ;
}
return NULL ;
}
2016-06-14 15:54:32 +03:00
void notify_callback ( struct smbd_server_connection * sconn ,
void * private_data , struct timespec when ,
2016-06-14 07:54:11 +03:00
const struct notify_event * e )
2007-02-02 17:55:21 +03:00
{
2016-06-14 16:00:29 +03:00
struct notify_fsp_state state = {
. notified_fsp = private_data , . when = when , . e = e
} ;
files_forall ( sconn , notify_fsp_cb , & state ) ;
2007-02-02 17:55:21 +03:00
}
2019-01-16 23:29:51 +03:00
NTSTATUS change_notify_create ( struct files_struct * fsp ,
uint32_t max_buffer_size ,
uint32_t filter ,
2007-10-19 04:40:25 +04:00
bool recursive )
2007-02-02 17:55:21 +03:00
{
2016-06-13 17:22:31 +03:00
size_t len = fsp_fullbasepath ( fsp , NULL , 0 ) ;
char fullpath [ len + 1 ] ;
2012-03-22 17:58:24 +04:00
NTSTATUS status = NT_STATUS_NOT_IMPLEMENTED ;
2007-02-02 17:55:21 +03:00
2020-07-08 04:25:23 +03:00
/*
* Setting a changenotify needs READ / LIST access
* on the directory handle .
*/
if ( ! ( fsp - > access_mask & SEC_DIR_LIST ) ) {
return NT_STATUS_ACCESS_DENIED ;
}
2012-03-09 17:45:21 +04:00
if ( fsp - > notify ! = NULL ) {
DEBUG ( 1 , ( " change_notify_create: fsp->notify != NULL, "
" fname = %s \n " , fsp - > fsp_name - > base_name ) ) ;
return NT_STATUS_INVALID_PARAMETER ;
}
2007-02-02 17:55:21 +03:00
2011-06-07 05:44:43 +04:00
if ( ! ( fsp - > notify = talloc_zero ( NULL , struct notify_change_buf ) ) ) {
2007-02-02 17:55:21 +03:00
DEBUG ( 0 , ( " talloc failed \n " ) ) ;
return NT_STATUS_NO_MEMORY ;
}
2016-06-24 17:27:34 +03:00
fsp - > notify - > filter = filter ;
fsp - > notify - > subdir_filter = recursive ? filter : 0 ;
2019-01-16 23:29:51 +03:00
fsp - > notify - > max_buffer_size = max_buffer_size ;
2007-02-02 17:55:21 +03:00
2016-06-13 17:22:31 +03:00
fsp_fullbasepath ( fsp , fullpath , sizeof ( fullpath ) ) ;
2007-02-02 17:55:21 +03:00
2012-03-15 16:02:15 +04:00
/*
* Avoid / . at the end of the path name . notify can ' t deal with it .
*/
if ( len > 1 & & fullpath [ len - 1 ] = = ' . ' & & fullpath [ len - 2 ] = = ' / ' ) {
fullpath [ len - 2 ] = ' \0 ' ;
}
2016-06-24 17:27:34 +03:00
if ( ( fsp - > notify - > filter ! = 0 ) | |
( fsp - > notify - > subdir_filter ! = 0 ) ) {
2012-04-04 16:51:43 +04:00
status = notify_add ( fsp - > conn - > sconn - > notify_ctx ,
2016-06-24 17:27:34 +03:00
fullpath , fsp - > notify - > filter ,
fsp - > notify - > subdir_filter , fsp ) ;
2012-03-22 17:58:24 +04:00
}
2016-06-13 17:22:31 +03:00
2007-02-02 17:55:21 +03:00
return status ;
2007-01-17 19:23:45 +03:00
}
2008-11-05 00:04:58 +03:00
NTSTATUS change_notify_add_request ( struct smb_request * req ,
2015-05-03 07:01:14 +03:00
uint32_t max_param ,
uint32_t filter , bool recursive ,
2009-06-30 17:01:00 +04:00
struct files_struct * fsp ,
void ( * reply_fn ) ( struct smb_request * req ,
NTSTATUS error_code ,
uint8_t * buf , size_t len ) )
2007-01-17 19:23:45 +03:00
{
struct notify_change_request * request = NULL ;
struct notify_mid_map * map = NULL ;
2010-06-12 14:43:11 +04:00
struct smbd_server_connection * sconn = req - > sconn ;
2007-01-17 19:23:45 +03:00
2008-06-17 12:46:20 +04:00
DEBUG ( 10 , ( " change_notify_add_request: Adding request for %s: "
2009-07-11 01:50:37 +04:00
" max_param = %d \n " , fsp_str_dbg ( fsp ) , ( int ) max_param ) ) ;
2008-06-17 12:46:20 +04:00
2008-11-05 00:04:58 +03:00
if ( ! ( request = talloc ( NULL , struct notify_change_request ) )
| | ! ( map = talloc ( request , struct notify_mid_map ) ) ) {
TALLOC_FREE ( request ) ;
2007-01-17 19:23:45 +03:00
return NT_STATUS_NO_MEMORY ;
}
request - > mid_map = map ;
map - > req = request ;
2008-11-05 00:04:58 +03:00
request - > req = talloc_move ( request , & req ) ;
2007-07-18 03:01:02 +04:00
request - > max_param = max_param ;
2007-01-17 19:23:45 +03:00
request - > filter = filter ;
request - > fsp = fsp ;
2009-06-30 17:01:00 +04:00
request - > reply_fn = reply_fn ;
2007-01-31 17:42:56 +03:00
request - > backend_data = NULL ;
2007-07-18 03:01:02 +04:00
2016-02-05 13:32:18 +03:00
DLIST_ADD_END ( fsp - > notify - > requests , request ) ;
2007-01-17 19:23:45 +03:00
2008-11-05 00:04:58 +03:00
map - > mid = request - > req - > mid ;
2021-09-09 01:06:11 +03:00
DLIST_ADD ( sconn - > notify_mid_maps , map ) ;
2001-10-19 12:37:32 +04:00
2007-01-17 19:23:45 +03:00
return NT_STATUS_OK ;
}
2010-06-12 15:13:20 +04:00
static void change_notify_remove_request ( struct smbd_server_connection * sconn ,
struct notify_change_request * remove_req )
2000-06-12 09:32:28 +04:00
{
2007-01-17 19:23:45 +03:00
files_struct * fsp ;
struct notify_change_request * req ;
totally rewrote the async signal, notification and oplock notification
handling in Samba. This was needed due to several limitations and
races in the previous code - as a side effect the new code is much
cleaner :)
in summary:
- changed sys_select() to avoid a signal/select race condition. It is a
rare race but once we have signals doing notification and oplocks it
is important.
- changed our main processing loop to take advantage of the new
sys_select semantics
- split the notify code into implementaion dependent and general
parts. Added the following structure that defines an implementation:
struct cnotify_fns {
void * (*register_notify)(connection_struct *conn, char *path, uint32 flags);
BOOL (*check_notify)(connection_struct *conn, uint16 vuid, char *path, uint32 flags, void *data, time_t t);
void (*remove_notify)(void *data);
};
then I wrote two implementations, one using hash/poll (like our old
code) and the other using the new Linux kernel change notify. It
should be easy to add other change notify implementations by creating
a sructure of the above type.
- fixed a bug in change notify where we were returning the wrong error
code.
- rewrote the core change notify code to be much simpler
- moved to real-time signals for leases and change notify
Amazingly, it all seems to work. I was very surprised!
(This used to be commit 44766c39e0027c762bee8b33b12c621c109a3267)
2000-06-12 19:53:31 +04:00
2007-01-17 19:23:45 +03:00
/*
* Paranoia checks , the fsp referenced must must have the request in
* its list of pending requests
*/
fsp = remove_req - > fsp ;
SMB_ASSERT ( fsp - > notify ! = NULL ) ;
for ( req = fsp - > notify - > requests ; req ; req = req - > next ) {
if ( req = = remove_req ) {
break ;
totally rewrote the async signal, notification and oplock notification
handling in Samba. This was needed due to several limitations and
races in the previous code - as a side effect the new code is much
cleaner :)
in summary:
- changed sys_select() to avoid a signal/select race condition. It is a
rare race but once we have signals doing notification and oplocks it
is important.
- changed our main processing loop to take advantage of the new
sys_select semantics
- split the notify code into implementaion dependent and general
parts. Added the following structure that defines an implementation:
struct cnotify_fns {
void * (*register_notify)(connection_struct *conn, char *path, uint32 flags);
BOOL (*check_notify)(connection_struct *conn, uint16 vuid, char *path, uint32 flags, void *data, time_t t);
void (*remove_notify)(void *data);
};
then I wrote two implementations, one using hash/poll (like our old
code) and the other using the new Linux kernel change notify. It
should be easy to add other change notify implementations by creating
a sructure of the above type.
- fixed a bug in change notify where we were returning the wrong error
code.
- rewrote the core change notify code to be much simpler
- moved to real-time signals for leases and change notify
Amazingly, it all seems to work. I was very surprised!
(This used to be commit 44766c39e0027c762bee8b33b12c621c109a3267)
2000-06-12 19:53:31 +04:00
}
}
2007-01-17 19:23:45 +03:00
if ( req = = NULL ) {
2007-06-16 01:58:49 +04:00
smb_panic ( " notify_req not found in fsp's requests " ) ;
2007-01-17 19:23:45 +03:00
}
DLIST_REMOVE ( fsp - > notify - > requests , req ) ;
2021-09-09 01:06:11 +03:00
DLIST_REMOVE ( sconn - > notify_mid_maps , req - > mid_map ) ;
2008-11-05 00:04:58 +03:00
TALLOC_FREE ( req ) ;
2006-12-31 20:52:24 +03:00
}
2015-05-01 21:04:55 +03:00
static void smbd_notify_cancel_by_map ( struct notify_mid_map * map )
{
struct smb_request * smbreq = map - > req - > req ;
struct smbd_server_connection * sconn = smbreq - > sconn ;
2015-05-01 21:02:38 +03:00
struct smbd_smb2_request * smb2req = smbreq - > smb2req ;
2015-05-01 21:04:55 +03:00
NTSTATUS notify_status = NT_STATUS_CANCELLED ;
2015-05-01 21:02:38 +03:00
if ( smb2req ! = NULL ) {
2017-12-21 16:47:06 +03:00
NTSTATUS sstatus ;
2015-05-01 21:02:38 +03:00
if ( smb2req - > session = = NULL ) {
2017-12-21 16:47:06 +03:00
sstatus = NT_STATUS_USER_SESSION_DELETED ;
} else {
sstatus = smb2req - > session - > status ;
2015-05-01 21:02:38 +03:00
}
2017-12-21 16:47:06 +03:00
if ( NT_STATUS_EQUAL ( sstatus , NT_STATUS_NETWORK_SESSION_EXPIRED ) ) {
sstatus = NT_STATUS_OK ;
}
if ( ! NT_STATUS_IS_OK ( sstatus ) ) {
2020-06-19 22:38:59 +03:00
notify_status = NT_STATUS_NOTIFY_CLEANUP ;
2017-12-21 16:47:06 +03:00
} else if ( smb2req - > tcon = = NULL ) {
2020-06-19 22:38:59 +03:00
notify_status = NT_STATUS_NOTIFY_CLEANUP ;
2015-05-01 21:02:38 +03:00
} else if ( ! NT_STATUS_IS_OK ( smb2req - > tcon - > status ) ) {
2020-06-19 22:38:59 +03:00
notify_status = NT_STATUS_NOTIFY_CLEANUP ;
2015-05-01 21:02:38 +03:00
}
}
2015-05-01 21:04:55 +03:00
change_notify_reply ( smbreq , notify_status ,
0 , NULL , map - > req - > reply_fn ) ;
change_notify_remove_request ( sconn , map - > req ) ;
}
2006-12-31 20:52:24 +03:00
/****************************************************************************
2007-01-09 19:12:54 +03:00
Delete entries by mid from the change notify pending queue . Always send reply .
2006-12-31 20:52:24 +03:00
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
2019-06-19 22:15:38 +03:00
bool remove_pending_change_notify_requests_by_mid (
2010-06-12 15:20:17 +04:00
struct smbd_server_connection * sconn , uint64_t mid )
2006-12-31 20:52:24 +03:00
{
2007-01-17 19:23:45 +03:00
struct notify_mid_map * map ;
2006-12-31 20:52:24 +03:00
2021-09-09 01:06:11 +03:00
for ( map = sconn - > notify_mid_maps ; map ; map = map - > next ) {
2007-01-17 19:23:45 +03:00
if ( map - > mid = = mid ) {
break ;
2007-01-09 19:12:54 +03:00
}
2006-12-31 20:52:24 +03:00
}
2007-01-17 19:23:45 +03:00
if ( map = = NULL ) {
2019-06-19 22:15:38 +03:00
return false ;
2007-01-17 19:23:45 +03:00
}
2015-05-01 21:04:55 +03:00
smbd_notify_cancel_by_map ( map ) ;
2019-06-19 22:15:38 +03:00
return true ;
2007-01-17 19:23:45 +03:00
}
2010-06-12 15:08:31 +04:00
void smbd_notify_cancel_by_smbreq ( const struct smb_request * smbreq )
2009-08-15 12:07:00 +04:00
{
2010-06-12 15:08:31 +04:00
struct smbd_server_connection * sconn = smbreq - > sconn ;
2009-08-15 12:07:00 +04:00
struct notify_mid_map * map ;
2021-09-09 01:06:11 +03:00
for ( map = sconn - > notify_mid_maps ; map ; map = map - > next ) {
2009-08-15 12:07:00 +04:00
if ( map - > req - > req = = smbreq ) {
break ;
}
}
if ( map = = NULL ) {
return ;
}
2015-05-01 21:04:55 +03:00
smbd_notify_cancel_by_map ( map ) ;
2009-08-15 12:07:00 +04:00
}
2015-04-21 11:16:16 +03:00
static struct files_struct * smbd_notify_cancel_deleted_fn (
struct files_struct * fsp , void * private_data )
{
struct file_id * fid = talloc_get_type_abort (
private_data , struct file_id ) ;
if ( file_id_equal ( & fsp - > file_id , fid ) ) {
remove_pending_change_notify_requests_by_fid (
fsp , NT_STATUS_DELETE_PENDING ) ;
}
return NULL ;
}
void smbd_notify_cancel_deleted ( struct messaging_context * msg ,
void * private_data , uint32_t msg_type ,
struct server_id server_id , DATA_BLOB * data )
{
struct smbd_server_connection * sconn = talloc_get_type_abort (
private_data , struct smbd_server_connection ) ;
struct file_id * fid ;
enum ndr_err_code ndr_err ;
fid = talloc ( talloc_tos ( ) , struct file_id ) ;
if ( fid = = NULL ) {
DEBUG ( 1 , ( " talloc failed \n " ) ) ;
return ;
}
ndr_err = ndr_pull_struct_blob_all (
data , fid , fid , ( ndr_pull_flags_fn_t ) ndr_pull_file_id ) ;
if ( ! NDR_ERR_CODE_IS_SUCCESS ( ndr_err ) ) {
DEBUG ( 10 , ( " %s: ndr_pull_file_id failed: %s \n " , __func__ ,
ndr_errstr ( ndr_err ) ) ) ;
goto done ;
}
files_forall ( sconn , smbd_notify_cancel_deleted_fn , fid ) ;
done :
TALLOC_FREE ( fid ) ;
}
2016-06-21 17:23:19 +03:00
static struct files_struct * smbd_notifyd_reregister ( struct files_struct * fsp ,
void * private_data )
{
DBG_DEBUG ( " reregister %s \n " , fsp - > fsp_name - > base_name ) ;
if ( ( fsp - > conn - > sconn - > notify_ctx ! = NULL ) & &
( fsp - > notify ! = NULL ) & &
( ( fsp - > notify - > filter ! = 0 ) | |
( fsp - > notify - > subdir_filter ! = 0 ) ) ) {
size_t len = fsp_fullbasepath ( fsp , NULL , 0 ) ;
char fullpath [ len + 1 ] ;
NTSTATUS status ;
fsp_fullbasepath ( fsp , fullpath , sizeof ( fullpath ) ) ;
if ( len > 1 & & fullpath [ len - 1 ] = = ' . ' & &
fullpath [ len - 2 ] = = ' / ' ) {
fullpath [ len - 2 ] = ' \0 ' ;
}
status = notify_add ( fsp - > conn - > sconn - > notify_ctx ,
fullpath , fsp - > notify - > filter ,
fsp - > notify - > subdir_filter , fsp ) ;
if ( ! NT_STATUS_IS_OK ( status ) ) {
DBG_DEBUG ( " notify_add failed: %s \n " ,
nt_errstr ( status ) ) ;
}
}
return NULL ;
}
void smbd_notifyd_restarted ( struct messaging_context * msg ,
void * private_data , uint32_t msg_type ,
struct server_id server_id , DATA_BLOB * data )
{
struct smbd_server_connection * sconn = talloc_get_type_abort (
private_data , struct smbd_server_connection ) ;
TALLOC_FREE ( sconn - > notify_ctx ) ;
2018-05-24 08:18:10 +03:00
sconn - > notify_ctx = notify_init ( sconn , sconn - > msg_ctx ,
2016-06-21 17:23:19 +03:00
sconn , notify_callback ) ;
if ( sconn - > notify_ctx = = NULL ) {
DBG_DEBUG ( " notify_init failed \n " ) ;
return ;
}
files_forall ( sconn , smbd_notifyd_reregister , sconn - > notify_ctx ) ;
}
2007-01-17 19:23:45 +03:00
/****************************************************************************
Delete entries by fnum from the change notify pending queue .
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
void remove_pending_change_notify_requests_by_fid ( files_struct * fsp ,
NTSTATUS status )
{
if ( fsp - > notify = = NULL ) {
return ;
}
while ( fsp - > notify - > requests ! = NULL ) {
2010-06-12 15:17:51 +04:00
change_notify_reply ( fsp - > notify - > requests - > req ,
2009-06-30 17:01:00 +04:00
status , 0 , NULL ,
fsp - > notify - > requests - > reply_fn ) ;
2010-06-12 15:13:20 +04:00
change_notify_remove_request ( fsp - > conn - > sconn ,
fsp - > notify - > requests ) ;
2007-01-17 19:23:45 +03:00
}
2000-06-12 09:32:28 +04:00
}
2015-05-03 07:01:14 +03:00
void notify_fname ( connection_struct * conn , uint32_t action , uint32_t filter ,
2007-01-31 17:14:57 +03:00
const char * path )
2007-01-17 19:23:45 +03:00
{
2012-03-21 15:18:09 +04:00
struct notify_context * notify_ctx = conn - > sconn - > notify_ctx ;
2007-01-17 19:23:45 +03:00
2008-11-18 23:45:42 +03:00
if ( path [ 0 ] = = ' . ' & & path [ 1 ] = = ' / ' ) {
path + = 2 ;
}
2014-01-02 20:54:53 +04:00
notify_trigger ( notify_ctx , action , filter , conn - > connectpath , path ) ;
2007-01-17 19:23:45 +03:00
}
2018-11-06 17:21:37 +03:00
static bool user_can_stat_name_under_fsp ( files_struct * fsp , const char * name )
{
uint32_t rights ;
2021-06-07 21:25:39 +03:00
struct smb_filename * fname = NULL ;
2018-11-06 17:21:37 +03:00
char * filepath = NULL ;
NTSTATUS status ;
char * p = NULL ;
/*
* Assume we get filepath ( relative to the share )
* like this :
*
* ' dir1 / dir2 / dir3 / file '
*
* We start with LIST and TRAVERSE on the
* direct parent ( ' dir1 / dir2 / dir3 ' )
*
* Then we switch to just TRAVERSE for
* the rest : ' dir1 / dir2 ' , ' dir1 ' , ' . '
*
* For a file in the share root , we ' ll have
* ' file '
* and would just check ' . ' with LIST and TRAVERSE .
*
* It ' s important to always check ' . ' as the last step ,
* which means we check the permissions of the share root
* directory .
*/
if ( ISDOT ( fsp - > fsp_name - > base_name ) ) {
filepath = talloc_strdup ( talloc_tos ( ) , name ) ;
} else {
filepath = talloc_asprintf ( talloc_tos ( ) ,
" %s/%s " ,
fsp - > fsp_name - > base_name ,
name ) ;
}
if ( filepath = = NULL ) {
DBG_ERR ( " Memory allocation failed \n " ) ;
return false ;
}
rights = SEC_DIR_LIST | SEC_DIR_TRAVERSE ;
p = strrchr_m ( filepath , ' / ' ) ;
/*
2023-07-18 12:30:18 +03:00
* Check each path component , excluding the share root .
2018-11-06 17:21:37 +03:00
*
* We could check all components including root using
* a do { . . } while ( ) loop , but IMHO the logic is clearer
* having the share root check separately afterwards .
*/
while ( p ! = NULL ) {
* p = ' \0 ' ;
2021-06-07 21:25:39 +03:00
status = synthetic_pathref ( talloc_tos ( ) ,
fsp - > conn - > cwd_fsp ,
filepath ,
NULL ,
NULL ,
0 ,
0 ,
& fname ) ;
if ( ! NT_STATUS_IS_OK ( status ) ) {
DBG_ERR ( " synthetic_pathref failed for %s, error %s \n " ,
filepath ,
nt_errstr ( status ) ) ;
TALLOC_FREE ( fname ) ;
TALLOC_FREE ( filepath ) ;
return false ;
}
2021-06-08 22:24:17 +03:00
status = smbd_check_access_rights_fsp ( fsp - > conn - > cwd_fsp ,
fname - > fsp ,
2018-11-06 17:21:37 +03:00
false ,
rights ) ;
if ( ! NT_STATUS_IS_OK ( status ) ) {
DBG_DEBUG ( " Access rights for %s/%s: %s \n " ,
fsp - > conn - > connectpath ,
filepath ,
nt_errstr ( status ) ) ;
2021-06-07 21:25:39 +03:00
TALLOC_FREE ( fname ) ;
2018-11-06 17:21:37 +03:00
TALLOC_FREE ( filepath ) ;
return false ;
}
2021-06-07 21:25:39 +03:00
TALLOC_FREE ( fname ) ;
2018-11-06 17:21:37 +03:00
rights = SEC_DIR_TRAVERSE ;
p = strrchr_m ( filepath , ' / ' ) ;
}
TALLOC_FREE ( filepath ) ;
/* Finally check share root. */
filepath = talloc_strdup ( talloc_tos ( ) , " . " ) ;
if ( filepath = = NULL ) {
DBG_ERR ( " Memory allocation failed \n " ) ;
return false ;
}
2021-06-07 21:25:39 +03:00
status = synthetic_pathref ( talloc_tos ( ) ,
fsp - > conn - > cwd_fsp ,
filepath ,
NULL ,
NULL ,
0 ,
0 ,
& fname ) ;
if ( ! NT_STATUS_IS_OK ( status ) ) {
DBG_ERR ( " synthetic_pathref failed for %s, error %s \n " ,
filepath ,
nt_errstr ( status ) ) ;
TALLOC_FREE ( fname ) ;
TALLOC_FREE ( filepath ) ;
return false ;
}
2021-06-08 22:24:17 +03:00
status = smbd_check_access_rights_fsp ( fsp - > conn - > cwd_fsp ,
fname - > fsp ,
2018-11-06 17:21:37 +03:00
false ,
rights ) ;
if ( ! NT_STATUS_IS_OK ( status ) ) {
2021-06-07 21:25:39 +03:00
DBG_DEBUG ( " TRAVERSE access rights for %s failed with %s \n " ,
2018-11-06 17:21:37 +03:00
fsp - > conn - > connectpath ,
nt_errstr ( status ) ) ;
2021-06-07 21:25:39 +03:00
TALLOC_FREE ( fname ) ;
2018-11-06 17:21:37 +03:00
TALLOC_FREE ( filepath ) ;
return false ;
}
2021-06-07 21:25:39 +03:00
TALLOC_FREE ( fname ) ;
2018-11-06 17:21:37 +03:00
TALLOC_FREE ( filepath ) ;
return true ;
}
2014-04-04 19:03:44 +04:00
static void notify_fsp ( files_struct * fsp , struct timespec when ,
2015-05-03 07:01:14 +03:00
uint32_t action , const char * name )
2007-01-17 19:23:45 +03:00
{
2014-04-04 19:00:16 +04:00
struct notify_change_event * change , * changes ;
2007-06-16 15:48:11 +04:00
char * tmp ;
2007-01-17 19:23:45 +03:00
if ( fsp - > notify = = NULL ) {
/*
* Nobody is waiting , don ' t queue
*/
return ;
}
2018-11-06 17:21:37 +03:00
if ( lp_honor_change_notify_privilege ( SNUM ( fsp - > conn ) ) ) {
bool has_sec_change_notify_privilege ;
bool expose = false ;
has_sec_change_notify_privilege = security_token_has_privilege (
fsp - > conn - > session_info - > security_token ,
SEC_PRIV_CHANGE_NOTIFY ) ;
if ( has_sec_change_notify_privilege ) {
expose = true ;
} else {
bool ok ;
ok = become_user_without_service_by_fsp ( fsp ) ;
if ( ok ) {
expose = user_can_stat_name_under_fsp ( fsp , name ) ;
unbecome_user_without_service ( ) ;
}
}
DBG_DEBUG ( " has_sec_change_notify_privilege=%s "
" expose=%s for %s notify %s \n " ,
has_sec_change_notify_privilege ? " true " : " false " ,
expose ? " true " : " false " ,
fsp - > fsp_name - > base_name , name ) ;
if ( ! expose ) {
return ;
}
}
2007-01-17 19:23:45 +03:00
/*
* Someone has triggered a notify previously , queue the change for
2007-02-02 17:55:21 +03:00
* later .
2007-01-17 19:23:45 +03:00
*/
2007-02-02 17:55:21 +03:00
if ( ( fsp - > notify - > num_changes > 1000 ) | | ( name = = NULL ) ) {
2007-01-21 14:49:00 +03:00
/*
2007-02-02 17:55:21 +03:00
* The real number depends on the client buf , just provide a
2009-02-18 03:20:18 +03:00
* guard against a DoS here . If name = = NULL the CN backend is
* alerting us to a problem . Possibly dropped events . Clear
* queued changes and send the catch - all response to the client
* if a request is pending .
2007-01-21 14:49:00 +03:00
*/
TALLOC_FREE ( fsp - > notify - > changes ) ;
fsp - > notify - > num_changes = - 1 ;
2009-02-18 03:20:18 +03:00
if ( fsp - > notify - > requests ! = NULL ) {
2010-06-12 15:17:51 +04:00
change_notify_reply ( fsp - > notify - > requests - > req ,
2009-06-30 00:17:17 +04:00
NT_STATUS_OK ,
2009-02-18 03:20:18 +03:00
fsp - > notify - > requests - > max_param ,
2009-06-30 17:01:00 +04:00
fsp - > notify ,
fsp - > notify - > requests - > reply_fn ) ;
2010-06-12 15:13:20 +04:00
change_notify_remove_request ( fsp - > conn - > sconn ,
fsp - > notify - > requests ) ;
2009-02-18 03:20:18 +03:00
}
2007-01-21 14:49:00 +03:00
return ;
}
2009-02-18 03:20:18 +03:00
/* If we've exceeded the server side queue or received a NULL name
* from the underlying CN implementation , don ' t queue up any more
* requests until we can send a catch - all response to the client */
2007-01-21 14:49:00 +03:00
if ( fsp - > notify - > num_changes = = - 1 ) {
return ;
}
2011-06-07 05:10:15 +04:00
if ( ! ( changes = talloc_realloc (
2007-01-17 19:23:45 +03:00
fsp - > notify , fsp - > notify - > changes ,
2014-04-04 19:00:16 +04:00
struct notify_change_event ,
fsp - > notify - > num_changes + 1 ) ) ) {
2007-01-17 19:23:45 +03:00
DEBUG ( 0 , ( " talloc_realloc failed \n " ) ) ;
return ;
}
fsp - > notify - > changes = changes ;
change = & ( fsp - > notify - > changes [ fsp - > notify - > num_changes ] ) ;
2007-06-16 15:48:11 +04:00
if ( ! ( tmp = talloc_strdup ( changes , name ) ) ) {
2007-05-08 00:53:10 +04:00
DEBUG ( 0 , ( " talloc_strdup failed \n " ) ) ;
return ;
}
2007-06-16 15:48:11 +04:00
string_replace ( tmp , ' / ' , ' \\ ' ) ;
2023-07-18 12:30:18 +03:00
change - > name = tmp ;
2007-06-16 15:48:11 +04:00
2014-04-04 19:03:44 +04:00
change - > when = when ;
2007-01-21 14:49:00 +03:00
change - > action = action ;
2007-01-17 19:23:45 +03:00
fsp - > notify - > num_changes + = 1 ;
2007-01-31 17:42:56 +03:00
if ( fsp - > notify - > requests = = NULL ) {
/*
* Nobody is waiting , so don ' t send anything . The ot
*/
return ;
}
if ( action = = NOTIFY_ACTION_OLD_NAME ) {
/*
* We have to send the two rename events in one reply . So hold
* the first part back .
*/
2007-05-08 00:53:10 +04:00
return ;
2007-01-31 17:42:56 +03:00
}
/*
* Someone is waiting for the change , trigger the reply immediately .
*
* TODO : do we have to walk the lists of requests pending ?
*/
2010-06-12 15:17:51 +04:00
change_notify_reply ( fsp - > notify - > requests - > req ,
2009-06-30 00:17:17 +04:00
NT_STATUS_OK ,
2007-07-18 03:01:02 +04:00
fsp - > notify - > requests - > max_param ,
2009-06-30 17:01:00 +04:00
fsp - > notify ,
fsp - > notify - > requests - > reply_fn ) ;
2007-01-31 17:42:56 +03:00
2010-06-12 15:13:20 +04:00
change_notify_remove_request ( fsp - > conn - > sconn , fsp - > notify - > requests ) ;
2007-01-17 19:23:45 +03:00
}
2015-05-03 07:01:14 +03:00
char * notify_filter_string ( TALLOC_CTX * mem_ctx , uint32_t filter )
2007-01-31 17:28:08 +03:00
{
char * result = NULL ;
result = talloc_strdup ( mem_ctx , " " ) ;
2023-02-13 04:58:52 +03:00
if ( result = = NULL ) {
return NULL ;
}
2007-01-31 17:28:08 +03:00
2023-02-13 04:58:52 +03:00
if ( filter & FILE_NOTIFY_CHANGE_FILE_NAME ) {
2007-01-31 17:28:08 +03:00
result = talloc_asprintf_append ( result , " FILE_NAME| " ) ;
2023-02-13 04:58:52 +03:00
if ( result = = NULL ) {
return NULL ;
}
}
if ( filter & FILE_NOTIFY_CHANGE_DIR_NAME ) {
2007-01-31 17:28:08 +03:00
result = talloc_asprintf_append ( result , " DIR_NAME| " ) ;
2023-02-13 04:58:52 +03:00
if ( result = = NULL ) {
return NULL ;
}
}
if ( filter & FILE_NOTIFY_CHANGE_ATTRIBUTES ) {
2007-01-31 17:28:08 +03:00
result = talloc_asprintf_append ( result , " ATTRIBUTES| " ) ;
2023-02-13 04:58:52 +03:00
if ( result = = NULL ) {
return NULL ;
}
}
if ( filter & FILE_NOTIFY_CHANGE_SIZE ) {
2007-01-31 17:28:08 +03:00
result = talloc_asprintf_append ( result , " SIZE| " ) ;
2023-02-13 04:58:52 +03:00
if ( result = = NULL ) {
return NULL ;
}
}
if ( filter & FILE_NOTIFY_CHANGE_LAST_WRITE ) {
2007-01-31 17:28:08 +03:00
result = talloc_asprintf_append ( result , " LAST_WRITE| " ) ;
2023-02-13 04:58:52 +03:00
if ( result = = NULL ) {
return NULL ;
}
}
if ( filter & FILE_NOTIFY_CHANGE_LAST_ACCESS ) {
2007-01-31 17:28:08 +03:00
result = talloc_asprintf_append ( result , " LAST_ACCESS| " ) ;
2023-02-13 04:58:52 +03:00
if ( result = = NULL ) {
return NULL ;
}
}
if ( filter & FILE_NOTIFY_CHANGE_CREATION ) {
2007-01-31 17:28:08 +03:00
result = talloc_asprintf_append ( result , " CREATION| " ) ;
2023-02-13 04:58:52 +03:00
if ( result = = NULL ) {
return NULL ;
}
}
if ( filter & FILE_NOTIFY_CHANGE_EA ) {
2007-01-31 17:28:08 +03:00
result = talloc_asprintf_append ( result , " EA| " ) ;
2023-02-13 04:58:52 +03:00
if ( result = = NULL ) {
return NULL ;
}
}
if ( filter & FILE_NOTIFY_CHANGE_SECURITY ) {
2007-01-31 17:28:08 +03:00
result = talloc_asprintf_append ( result , " SECURITY| " ) ;
2023-02-13 04:58:52 +03:00
if ( result = = NULL ) {
return NULL ;
}
}
if ( filter & FILE_NOTIFY_CHANGE_STREAM_NAME ) {
2007-01-31 17:28:08 +03:00
result = talloc_asprintf_append ( result , " STREAM_NAME| " ) ;
2023-02-13 04:58:52 +03:00
if ( result = = NULL ) {
return NULL ;
}
}
if ( filter & FILE_NOTIFY_CHANGE_STREAM_SIZE ) {
2007-01-31 17:28:08 +03:00
result = talloc_asprintf_append ( result , " STREAM_SIZE| " ) ;
2023-02-13 04:58:52 +03:00
if ( result = = NULL ) {
return NULL ;
}
}
if ( filter & FILE_NOTIFY_CHANGE_STREAM_WRITE ) {
2007-01-31 17:28:08 +03:00
result = talloc_asprintf_append ( result , " STREAM_WRITE| " ) ;
2023-02-13 04:58:52 +03:00
if ( result = = NULL ) {
return NULL ;
}
}
2007-01-31 17:28:08 +03:00
if ( * result = = ' \0 ' ) return result ;
result [ strlen ( result ) - 1 ] = ' \0 ' ;
return result ;
}
2012-03-21 14:55:55 +04:00
struct sys_notify_context * sys_notify_context_create ( TALLOC_CTX * mem_ctx ,
2013-02-18 12:56:41 +04:00
struct tevent_context * ev )
2007-01-31 16:47:37 +03:00
{
struct sys_notify_context * ctx ;
2011-06-07 05:38:41 +04:00
if ( ! ( ctx = talloc ( mem_ctx , struct sys_notify_context ) ) ) {
2007-01-31 16:47:37 +03:00
DEBUG ( 0 , ( " talloc failed \n " ) ) ;
return NULL ;
}
ctx - > ev = ev ;
ctx - > private_data = NULL ;
return ctx ;
}