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"
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 {
/*
* If no requests are pending , changes are queued here . Simple array ,
* we only append .
*/
/*
* 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 ;
2007-02-02 17:55:21 +03:00
uint32 filter ;
2007-07-18 03:01:02 +04:00
uint32 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 ;
} ;
static void notify_fsp ( files_struct * fsp , uint32 action , const char * name ) ;
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 ;
}
2007-10-19 04:40:25 +04:00
static bool notify_marshall_changes ( int num_changes ,
2007-07-18 03:01:02 +04:00
uint32 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 ;
}
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 ;
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 ;
m . NextEntryOffset = ( i = = num_changes - 1 ) ? 0 : ndr_size_FILE_NOTIFY_INFORMATION ( & m , 0 ) ;
2007-01-17 19:23:45 +03:00
/*
* Offset to next entry , only if there is one
*/
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 ;
}
if ( max_param = = 0 | | 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 ;
}
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 ;
}
static void notify_callback ( void * private_data , const struct notify_event * e )
{
files_struct * fsp = ( files_struct * ) private_data ;
2009-07-11 01:50:37 +04:00
DEBUG ( 10 , ( " notify_callback called for %s \n " , fsp_str_dbg ( fsp ) ) ) ;
2007-02-02 17:55:21 +03:00
notify_fsp ( fsp , e - > action , e - > path ) ;
}
2012-03-22 17:58:24 +04:00
static void sys_notify_callback ( struct sys_notify_context * ctx ,
void * private_data ,
struct notify_event * e )
{
files_struct * fsp = ( files_struct * ) private_data ;
DEBUG ( 10 , ( " sys_notify_callback called for %s \n " , fsp_str_dbg ( fsp ) ) ) ;
notify_fsp ( fsp , e - > action , e - > path ) ;
}
2007-02-02 17:55:21 +03:00
NTSTATUS change_notify_create ( struct files_struct * fsp , uint32 filter ,
2007-10-19 04:40:25 +04:00
bool recursive )
2007-02-02 17:55:21 +03:00
{
char * fullpath ;
2012-03-15 16:02:15 +04:00
size_t len ;
2012-04-04 16:51:43 +04:00
uint32_t subdir_filter ;
2012-03-22 17:58:24 +04:00
NTSTATUS status = NT_STATUS_NOT_IMPLEMENTED ;
2007-02-02 17:55:21 +03:00
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 ;
}
2009-07-11 01:50:37 +04:00
/* Do notify operations on the base_name. */
2012-03-09 17:47:43 +04:00
fullpath = talloc_asprintf (
talloc_tos ( ) , " %s/%s " , fsp - > conn - > connectpath ,
fsp - > fsp_name - > base_name ) ;
if ( fullpath = = NULL ) {
DEBUG ( 0 , ( " talloc_asprintf failed \n " ) ) ;
2009-04-09 13:40:08 +04:00
TALLOC_FREE ( fsp - > notify ) ;
2007-02-02 17:55:21 +03:00
return NT_STATUS_NO_MEMORY ;
}
2012-03-15 16:02:15 +04:00
/*
* Avoid / . at the end of the path name . notify can ' t deal with it .
*/
len = strlen ( fullpath ) ;
if ( len > 1 & & fullpath [ len - 1 ] = = ' . ' & & fullpath [ len - 2 ] = = ' / ' ) {
fullpath [ len - 2 ] = ' \0 ' ;
}
2012-04-04 16:51:43 +04:00
subdir_filter = recursive ? filter : 0 ;
2007-02-02 17:55:21 +03:00
2012-03-22 17:58:24 +04:00
if ( fsp - > conn - > sconn - > sys_notify_ctx ! = NULL ) {
void * sys_notify_handle = NULL ;
status = SMB_VFS_NOTIFY_WATCH (
fsp - > conn , fsp - > conn - > sconn - > sys_notify_ctx ,
2012-04-04 16:51:43 +04:00
fullpath , & filter , & subdir_filter ,
2012-03-26 14:46:11 +04:00
sys_notify_callback , fsp , & sys_notify_handle ) ;
2012-03-22 17:58:24 +04:00
if ( NT_STATUS_IS_OK ( status ) ) {
talloc_steal ( fsp - > notify , sys_notify_handle ) ;
}
}
2007-02-02 17:55:21 +03:00
2012-04-04 16:51:43 +04:00
if ( ( filter ! = 0 ) | | ( subdir_filter ! = 0 ) ) {
status = notify_add ( fsp - > conn - > sconn - > notify_ctx ,
fullpath , filter , subdir_filter ,
notify_callback , fsp ) ;
2012-03-22 17:58:24 +04:00
}
TALLOC_FREE ( fullpath ) ;
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 ,
2008-01-04 23:56:23 +03:00
uint32 max_param ,
uint32 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
2007-01-17 19:23:45 +03:00
DLIST_ADD_END ( fsp - > notify - > requests , request ,
struct notify_change_request * ) ;
2008-11-05 00:04:58 +03:00
map - > mid = request - > req - > mid ;
2009-06-30 12:17:38 +04:00
DLIST_ADD ( sconn - > smb1 . 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 ) ;
2009-06-30 12:17:38 +04:00
DLIST_REMOVE ( sconn - > smb1 . 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
}
/****************************************************************************
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
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
2010-06-12 15:20:17 +04:00
void remove_pending_change_notify_requests_by_mid (
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
2009-06-30 12:17:38 +04:00
for ( map = sconn - > smb1 . 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 ) {
return ;
}
2010-06-12 15:17:51 +04:00
change_notify_reply ( map - > req - > req ,
2009-06-30 17:01:00 +04:00
NT_STATUS_CANCELLED , 0 , NULL , map - > req - > reply_fn ) ;
2010-06-12 15:13:20 +04:00
change_notify_remove_request ( sconn , map - > req ) ;
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 ;
for ( map = sconn - > smb1 . notify_mid_maps ; map ; map = map - > next ) {
if ( map - > req - > req = = smbreq ) {
break ;
}
}
if ( map = = NULL ) {
return ;
}
2010-06-12 15:17:51 +04:00
change_notify_reply ( map - > req - > req ,
2009-08-15 12:07:00 +04:00
NT_STATUS_CANCELLED , 0 , NULL , map - > req - > reply_fn ) ;
2010-06-12 15:13:20 +04:00
change_notify_remove_request ( sconn , map - > req ) ;
2009-08-15 12:07:00 +04:00
}
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
}
2007-01-31 17:14:57 +03:00
void notify_fname ( connection_struct * conn , uint32 action , uint32 filter ,
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 ;
2013-12-06 18:34:05 +04:00
char * fullpath , * to_free ;
2013-12-14 13:45:42 +04:00
char tmpbuf [ PATH_MAX ] ;
2013-12-06 18:34:05 +04:00
ssize_t len ;
2007-01-17 19:23:45 +03:00
2008-11-18 23:45:42 +03:00
if ( path [ 0 ] = = ' . ' & & path [ 1 ] = = ' / ' ) {
path + = 2 ;
}
2013-12-06 18:34:05 +04:00
len = full_path_tos ( conn - > connectpath , path , tmpbuf , sizeof ( tmpbuf ) ,
& fullpath , & to_free ) ;
if ( len = = - 1 ) {
DEBUG ( 0 , ( " full_path_tos failed \n " ) ) ;
2009-06-23 02:26:56 +04:00
return ;
2009-04-14 22:39:14 +04:00
}
2012-03-21 15:18:09 +04:00
notify_trigger ( notify_ctx , action , filter , fullpath ) ;
2013-12-06 18:34:05 +04:00
TALLOC_FREE ( to_free ) ;
2007-01-17 19:23:45 +03:00
}
2007-02-02 17:55:21 +03:00
static void notify_fsp ( files_struct * fsp , uint32 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 ;
}
/*
* 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 , ' / ' , ' \\ ' ) ;
change - > name = tmp ;
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
}
2007-01-31 17:28:08 +03:00
char * notify_filter_string ( TALLOC_CTX * mem_ctx , uint32 filter )
{
char * result = NULL ;
result = talloc_strdup ( mem_ctx , " " ) ;
if ( filter & FILE_NOTIFY_CHANGE_FILE_NAME )
result = talloc_asprintf_append ( result , " FILE_NAME| " ) ;
if ( filter & FILE_NOTIFY_CHANGE_DIR_NAME )
result = talloc_asprintf_append ( result , " DIR_NAME| " ) ;
if ( filter & FILE_NOTIFY_CHANGE_ATTRIBUTES )
result = talloc_asprintf_append ( result , " ATTRIBUTES| " ) ;
if ( filter & FILE_NOTIFY_CHANGE_SIZE )
result = talloc_asprintf_append ( result , " SIZE| " ) ;
if ( filter & FILE_NOTIFY_CHANGE_LAST_WRITE )
result = talloc_asprintf_append ( result , " LAST_WRITE| " ) ;
if ( filter & FILE_NOTIFY_CHANGE_LAST_ACCESS )
result = talloc_asprintf_append ( result , " LAST_ACCESS| " ) ;
if ( filter & FILE_NOTIFY_CHANGE_CREATION )
result = talloc_asprintf_append ( result , " CREATION| " ) ;
if ( filter & FILE_NOTIFY_CHANGE_EA )
result = talloc_asprintf_append ( result , " EA| " ) ;
if ( filter & FILE_NOTIFY_CHANGE_SECURITY )
result = talloc_asprintf_append ( result , " SECURITY| " ) ;
if ( filter & FILE_NOTIFY_CHANGE_STREAM_NAME )
result = talloc_asprintf_append ( result , " STREAM_NAME| " ) ;
if ( filter & FILE_NOTIFY_CHANGE_STREAM_SIZE )
result = talloc_asprintf_append ( result , " STREAM_SIZE| " ) ;
if ( filter & FILE_NOTIFY_CHANGE_STREAM_WRITE )
result = talloc_asprintf_append ( result , " STREAM_WRITE| " ) ;
if ( result = = NULL ) return NULL ;
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 ;
}