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
the Free Software Foundation ; either version 2 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 , write to the Free Software
Foundation , Inc . , 675 Mass Ave , Cambridge , MA 0213 9 , USA .
*/
# include "includes.h"
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 */
char request_buf [ smb_size ] ;
uint32 filter ;
uint32 current_bufsize ;
struct notify_mid_map * mid_map ;
void * backend_data ;
} ;
static void notify_fsp ( files_struct * fsp , uint32 action , const char * name ) ;
2007-01-17 19:23:45 +03:00
static struct notify_mid_map * notify_changes_by_mid ;
2000-06-12 09:32:28 +04:00
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 ;
uint16 mid ;
} ;
2007-01-21 14:49:00 +03:00
static BOOL notify_marshall_changes ( int num_changes ,
2007-01-17 19:23:45 +03:00
struct notify_change * changes ,
prs_struct * ps )
{
int i ;
UNISTR uni_name ;
for ( i = 0 ; i < num_changes ; i + + ) {
struct notify_change * c = & changes [ i ] ;
size_t namelen ;
uint32 u32_tmp ; /* Temp arg to prs_uint32 to avoid
* signed / unsigned issues */
namelen = convert_string_allocate (
NULL , CH_UNIX , CH_UTF16LE , c - > name , strlen ( c - > name ) + 1 ,
& uni_name . buffer , True ) ;
if ( ( namelen = = - 1 ) | | ( uni_name . buffer = = NULL ) ) {
goto fail ;
}
namelen - = 2 ; /* Dump NULL termination */
/*
* Offset to next entry , only if there is one
*/
u32_tmp = ( i = = num_changes - 1 ) ? 0 : namelen + 12 ;
if ( ! prs_uint32 ( " offset " , ps , 1 , & u32_tmp ) ) goto fail ;
u32_tmp = c - > action ;
if ( ! prs_uint32 ( " action " , ps , 1 , & u32_tmp ) ) goto fail ;
u32_tmp = namelen ;
if ( ! prs_uint32 ( " namelen " , ps , 1 , & u32_tmp ) ) goto fail ;
if ( ! prs_unistr ( " name " , ps , 1 , & uni_name ) ) goto fail ;
/*
* Not NULL terminated , decrease by the 2 UCS2 \ 0 chars
*/
prs_set_offset ( ps , prs_offset ( ps ) - 2 ) ;
SAFE_FREE ( uni_name . buffer ) ;
}
return True ;
fail :
SAFE_FREE ( uni_name . buffer ) ;
return False ;
}
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
2007-01-17 21:26:37 +03:00
static void change_notify_reply_packet ( const char * request_buf ,
NTSTATUS error_code )
2000-06-12 09:32:28 +04:00
{
2007-04-20 02:40:32 +04:00
const char * inbuf = request_buf ;
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
char outbuf [ smb_size + 38 ] ;
2000-06-12 09:32:28 +04:00
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
memset ( outbuf , ' \0 ' , sizeof ( outbuf ) ) ;
2007-01-17 19:23:45 +03:00
construct_reply_common ( request_buf , outbuf ) ;
2000-06-12 09:32:28 +04:00
2001-08-27 12:19:43 +04:00
ERROR_NT ( error_code ) ;
2000-06-12 09:32:28 +04:00
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
/*
* Seems NT needs a transact command with an error code
* in it . This is a longer packet than a simple error .
*/
2007-04-20 02:40:32 +04:00
set_message ( inbuf , outbuf , 18 , 0 , False ) ;
2000-06-12 09:32:28 +04:00
2005-06-28 02:53:56 +04:00
show_msg ( outbuf ) ;
2001-06-09 05:38:54 +04:00
if ( ! send_smb ( smbd_server_fd ( ) , outbuf ) )
2007-01-17 21:26:37 +03:00
exit_server_cleanly ( " change_notify_reply_packet: send_smb "
" failed. " ) ;
2000-06-12 09:32:28 +04:00
}
2007-06-12 23:59:38 +04:00
void change_notify_reply ( const char * request_buf ,
2007-02-02 17:55:21 +03:00
struct notify_change_buf * notify_buf )
2007-01-17 19:23:45 +03:00
{
char * outbuf = NULL ;
prs_struct ps ;
2007-06-12 23:59:38 +04:00
size_t buflen ;
2007-01-17 19:23:45 +03:00
2007-02-02 17:55:21 +03:00
if ( notify_buf - > num_changes = = - 1 ) {
2007-01-21 14:49:00 +03:00
change_notify_reply_packet ( request_buf , NT_STATUS_OK ) ;
return ;
}
2007-01-17 19:23:45 +03:00
if ( ! prs_init ( & ps , 0 , NULL , False )
2007-02-02 17:55:21 +03:00
| | ! notify_marshall_changes ( notify_buf - > num_changes ,
notify_buf - > changes , & ps ) ) {
2007-01-17 19:23:45 +03:00
change_notify_reply_packet ( request_buf , NT_STATUS_NO_MEMORY ) ;
goto done ;
}
2007-06-12 23:59:38 +04:00
buflen = smb_size + 38 + prs_offset ( & ps ) + 4 /* padding */ ;
2007-01-17 19:23:45 +03:00
if ( ! ( outbuf = SMB_MALLOC_ARRAY ( char , buflen ) ) ) {
change_notify_reply_packet ( request_buf , NT_STATUS_NO_MEMORY ) ;
goto done ;
}
construct_reply_common ( request_buf , outbuf ) ;
2007-04-20 02:40:32 +04:00
if ( send_nt_replies ( request_buf , outbuf , buflen , NT_STATUS_OK , prs_data_p ( & ps ) ,
2007-01-17 19:23:45 +03:00
prs_offset ( & ps ) , NULL , 0 ) = = - 1 ) {
exit_server ( " change_notify_reply_packet: send_smb failed. " ) ;
}
done :
SAFE_FREE ( outbuf ) ;
prs_mem_free ( & ps ) ;
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 ;
DEBUG ( 10 , ( " notify_callback called for %s \n " , fsp - > fsp_name ) ) ;
notify_fsp ( fsp , e - > action , e - > path ) ;
}
NTSTATUS change_notify_create ( struct files_struct * fsp , uint32 filter ,
BOOL recursive )
{
char * fullpath ;
struct notify_entry e ;
NTSTATUS status ;
SMB_ASSERT ( fsp - > notify = = NULL ) ;
if ( ! ( fsp - > notify = TALLOC_ZERO_P ( NULL , struct notify_change_buf ) ) ) {
DEBUG ( 0 , ( " talloc failed \n " ) ) ;
return NT_STATUS_NO_MEMORY ;
}
if ( asprintf ( & fullpath , " %s/%s " , fsp - > conn - > connectpath ,
fsp - > fsp_name ) = = - 1 ) {
DEBUG ( 0 , ( " asprintf failed \n " ) ) ;
return NT_STATUS_NO_MEMORY ;
}
e . path = fullpath ;
e . filter = filter ;
e . subdir_filter = 0 ;
if ( recursive ) {
e . subdir_filter = filter ;
}
status = notify_add ( fsp - > conn - > notify_ctx , & e , notify_callback , fsp ) ;
SAFE_FREE ( fullpath ) ;
return status ;
2007-01-17 19:23:45 +03:00
}
2007-06-12 23:59:38 +04:00
NTSTATUS change_notify_add_request ( const char * inbuf ,
2007-01-31 17:42:56 +03:00
uint32 filter , BOOL recursive ,
struct files_struct * fsp )
2007-01-17 19:23:45 +03:00
{
struct notify_change_request * request = NULL ;
struct notify_mid_map * map = NULL ;
if ( ! ( request = SMB_MALLOC_P ( struct notify_change_request ) )
| | ! ( map = SMB_MALLOC_P ( struct notify_mid_map ) ) ) {
SAFE_FREE ( request ) ;
return NT_STATUS_NO_MEMORY ;
}
request - > mid_map = map ;
map - > req = request ;
memcpy ( request - > request_buf , inbuf , sizeof ( request - > request_buf ) ) ;
2007-02-02 17:55:21 +03:00
request - > current_bufsize = 0 ;
2007-01-17 19:23:45 +03:00
request - > filter = filter ;
request - > fsp = fsp ;
2007-01-31 17:42:56 +03:00
request - > backend_data = NULL ;
2007-01-21 14:49:00 +03:00
2007-01-17 19:23:45 +03:00
DLIST_ADD_END ( fsp - > notify - > requests , request ,
struct notify_change_request * ) ;
map - > mid = SVAL ( inbuf , smb_mid ) ;
DLIST_ADD ( notify_changes_by_mid , map ) ;
2001-10-19 12:37:32 +04:00
2007-01-17 19:23:45 +03:00
/* Push the MID of this packet on the signing queue. */
srv_defer_sign_response ( SVAL ( inbuf , smb_mid ) ) ;
return NT_STATUS_OK ;
}
static void change_notify_remove_request ( 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 ) ;
DLIST_REMOVE ( notify_changes_by_mid , req - > mid_map ) ;
SAFE_FREE ( req - > mid_map ) ;
2007-01-21 14:49:00 +03:00
TALLOC_FREE ( req - > backend_data ) ;
2007-01-17 19:23:45 +03:00
SAFE_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
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
2007-01-17 19:23:45 +03:00
void remove_pending_change_notify_requests_by_mid ( uint16 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
2007-01-17 19:23:45 +03:00
for ( map = notify_changes_by_mid ; map ; map = map - > next ) {
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 ;
}
change_notify_reply_packet ( map - > req - > request_buf , NT_STATUS_CANCELLED ) ;
change_notify_remove_request ( map - > req ) ;
}
/****************************************************************************
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 ) {
change_notify_reply_packet (
fsp - > notify - > requests - > request_buf , status ) ;
change_notify_remove_request ( fsp - > notify - > requests ) ;
}
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
{
2007-01-31 17:42:56 +03:00
char * fullpath ;
2007-01-17 19:23:45 +03:00
2007-01-31 17:42:56 +03:00
if ( asprintf ( & fullpath , " %s/%s " , conn - > connectpath , path ) = = - 1 ) {
DEBUG ( 0 , ( " asprintf failed \n " ) ) ;
2007-01-17 19:23:45 +03:00
return ;
}
2007-01-31 17:42:56 +03:00
notify_trigger ( conn - > notify_ctx , action , filter , fullpath ) ;
SAFE_FREE ( fullpath ) ;
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
{
struct notify_change * 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
* guard against a DoS here .
2007-01-21 14:49:00 +03:00
*/
TALLOC_FREE ( fsp - > notify - > changes ) ;
fsp - > notify - > num_changes = - 1 ;
return ;
}
if ( fsp - > notify - > num_changes = = - 1 ) {
return ;
}
2007-01-17 19:23:45 +03:00
if ( ! ( changes = TALLOC_REALLOC_ARRAY (
fsp - > notify , fsp - > notify - > changes ,
struct notify_change , fsp - > notify - > num_changes + 1 ) ) ) {
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 ?
*/
change_notify_reply ( fsp - > notify - > requests - > request_buf ,
2007-02-02 17:55:21 +03:00
fsp - > notify ) ;
2007-01-31 17:42:56 +03:00
change_notify_remove_request ( 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 ;
}
2007-02-01 16:36:02 +03:00
struct sys_notify_context * sys_notify_context_create ( connection_struct * conn ,
2007-01-31 16:47:37 +03:00
TALLOC_CTX * mem_ctx ,
struct event_context * ev )
{
struct sys_notify_context * ctx ;
if ( ! ( ctx = TALLOC_P ( mem_ctx , struct sys_notify_context ) ) ) {
DEBUG ( 0 , ( " talloc failed \n " ) ) ;
return NULL ;
}
ctx - > ev = ev ;
2007-02-01 16:36:02 +03:00
ctx - > conn = conn ;
2007-01-31 16:47:37 +03:00
ctx - > private_data = NULL ;
return ctx ;
}
NTSTATUS sys_notify_watch ( struct sys_notify_context * ctx ,
struct notify_entry * e ,
void ( * callback ) ( struct sys_notify_context * ctx ,
void * private_data ,
struct notify_event * ev ) ,
void * private_data , void * handle )
{
2007-02-01 16:36:02 +03:00
return SMB_VFS_NOTIFY_WATCH ( ctx - > conn , ctx , e , callback , private_data ,
handle ) ;
2007-01-31 16:47:37 +03:00
}