1998-08-19 05:49:57 +04:00
/*
2002-01-30 09:08:46 +03:00
Unix SMB / CIFS implementation .
1998-08-19 05:49:57 +04:00
Blocking Locking functions
2003-02-27 04:04:34 +03:00
Copyright ( C ) Jeremy Allison 1998 - 2003
2008-11-03 19:56:55 +03:00
1998-08-19 05:49:57 +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
1998-08-19 05:49:57 +04:00
( at your option ) any later version .
2008-11-03 19:56:55 +03:00
1998-08-19 05:49:57 +04:00
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 .
2008-11-03 19:56:55 +03:00
1998-08-19 05:49:57 +04:00
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/>.
1998-08-19 05:49:57 +04:00
*/
# include "includes.h"
2009-01-08 14:03:45 +03:00
# include "smbd/globals.h"
2010-05-05 03:39:16 +04:00
# include "librpc/gen_ndr/messaging.h"
2009-01-08 14:03:45 +03:00
2006-07-18 01:09:02 +04:00
# undef DBGC_CLASS
# define DBGC_CLASS DBGC_LOCKING
2001-10-02 08:29:50 +04:00
1998-08-19 05:49:57 +04:00
/****************************************************************************
1998-08-20 23:28:37 +04:00
Determine if this is a secondary element of a chained SMB .
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
2007-05-20 01:53:28 +04:00
static void received_unlock_msg ( struct messaging_context * msg ,
void * private_data ,
uint32_t msg_type ,
struct server_id server_id ,
DATA_BLOB * data ) ;
2007-03-20 00:52:27 +03:00
2010-05-01 08:03:20 +04:00
void brl_timeout_fn ( struct event_context * event_ctx ,
2007-03-20 00:52:27 +03:00
struct timed_event * te ,
2009-01-05 12:22:50 +03:00
struct timeval now ,
2007-03-20 00:52:27 +03:00
void * private_data )
{
2010-06-12 16:16:39 +04:00
struct smbd_server_connection * sconn = talloc_get_type_abort (
private_data , struct smbd_server_connection ) ;
2010-05-01 08:03:20 +04:00
2010-06-10 06:12:02 +04:00
if ( sconn - > using_smb2 ) {
2010-05-01 08:03:20 +04:00
SMB_ASSERT ( sconn - > smb2 . locks . brl_timeout = = te ) ;
TALLOC_FREE ( sconn - > smb2 . locks . brl_timeout ) ;
} else {
SMB_ASSERT ( sconn - > smb1 . locks . brl_timeout = = te ) ;
TALLOC_FREE ( sconn - > smb1 . locks . brl_timeout ) ;
}
2007-03-20 00:52:27 +03:00
change_to_root_user ( ) ; /* TODO: Possibly run all timed events as
* root */
process_blocking_lock_queue ( ) ;
}
2009-10-21 04:52:34 +04:00
/****************************************************************************
We need a version of timeval_min that treats zero timval as infinite .
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
2010-05-01 08:03:20 +04:00
struct timeval timeval_brl_min ( const struct timeval * tv1 ,
2009-10-21 04:52:34 +04:00
const struct timeval * tv2 )
{
if ( timeval_is_zero ( tv1 ) ) {
return * tv2 ;
}
if ( timeval_is_zero ( tv2 ) ) {
return * tv1 ;
}
return timeval_min ( tv1 , tv2 ) ;
}
2007-03-20 00:52:27 +03:00
/****************************************************************************
After a change to blocking_lock_queue , recalculate the timed_event for the
next processing .
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
2007-10-19 04:40:25 +04:00
static bool recalc_brl_timeout ( void )
2007-03-20 00:52:27 +03:00
{
2010-04-30 03:50:15 +04:00
struct smbd_server_connection * sconn = smbd_server_conn ;
2009-02-12 09:13:26 +03:00
struct blocking_lock_record * blr ;
2007-03-20 00:52:27 +03:00
struct timeval next_timeout ;
2010-02-06 07:59:43 +03:00
int max_brl_timeout = lp_parm_int ( - 1 , " brl " , " recalctime " , 5 ) ;
2007-03-20 00:52:27 +03:00
2010-04-30 03:50:15 +04:00
TALLOC_FREE ( sconn - > smb1 . locks . brl_timeout ) ;
2007-03-20 00:52:27 +03:00
2010-02-06 09:51:11 +03:00
next_timeout = timeval_zero ( ) ;
2007-03-20 00:52:27 +03:00
2010-04-30 03:50:15 +04:00
for ( blr = sconn - > smb1 . locks . blocking_lock_queue ; blr ; blr = blr - > next ) {
2009-02-10 08:51:29 +03:00
if ( timeval_is_zero ( & blr - > expire_time ) ) {
2007-05-20 00:57:12 +04:00
/*
2010-05-07 17:20:50 +04:00
* If we ' re blocked on pid 0xFFFFFFFFFFFFFFFFLL this is
2007-05-20 00:57:12 +04:00
* a POSIX lock , so calculate a timeout of
* 10 seconds into the future .
*/
2010-05-07 17:20:50 +04:00
if ( blr - > blocking_smblctx = = 0xFFFFFFFFFFFFFFFFLL ) {
2007-05-20 00:57:12 +04:00
struct timeval psx_to = timeval_current_ofs ( 10 , 0 ) ;
2009-10-21 04:52:34 +04:00
next_timeout = timeval_brl_min ( & next_timeout , & psx_to ) ;
2007-05-20 00:57:12 +04:00
}
2007-03-20 00:52:27 +03:00
continue ;
}
2009-10-21 04:52:34 +04:00
next_timeout = timeval_brl_min ( & next_timeout , & blr - > expire_time ) ;
2007-03-20 00:52:27 +03:00
}
if ( timeval_is_zero ( & next_timeout ) ) {
2009-02-10 08:51:29 +03:00
DEBUG ( 10 , ( " Next timeout = Infinite. \n " ) ) ;
2007-03-20 00:52:27 +03:00
return True ;
}
2010-02-06 07:59:43 +03:00
/*
to account for unclean shutdowns by clients we need a
maximum timeout that we use for checking pending locks . If
we have any pending locks at all , then check if the pending
lock can continue at least every brl : recalctime seconds
( default 5 seconds ) .
This saves us needing to do a message_send_all ( ) in the
SIGCHLD handler in the parent daemon . That
message_send_all ( ) caused O ( n ^ 2 ) work to be done when IP
failovers happened in clustered Samba , which could make the
entire system unusable for many minutes .
*/
if ( max_brl_timeout > 0 ) {
struct timeval min_to = timeval_current_ofs ( max_brl_timeout , 0 ) ;
2010-02-06 09:51:11 +03:00
next_timeout = timeval_min ( & next_timeout , & min_to ) ;
2010-02-06 07:59:43 +03:00
}
2009-02-10 08:51:29 +03:00
if ( DEBUGLVL ( 10 ) ) {
struct timeval cur , from_now ;
cur = timeval_current ( ) ;
from_now = timeval_until ( & cur , & next_timeout ) ;
DEBUG ( 10 , ( " Next timeout = %d.%d seconds from now. \n " ,
( int ) from_now . tv_sec , ( int ) from_now . tv_usec ) ) ;
}
2010-06-12 16:16:39 +04:00
sconn - > smb1 . locks . brl_timeout = event_add_timed ( smbd_event_context ( ) ,
NULL , next_timeout ,
brl_timeout_fn , sconn ) ;
if ( sconn - > smb1 . locks . brl_timeout = = NULL ) {
2007-03-20 00:52:27 +03:00
return False ;
}
return True ;
}
2003-02-27 04:04:34 +03:00
1998-08-20 23:28:37 +04:00
/****************************************************************************
Function to push a blocking lock request onto the lock queue .
1998-08-19 05:49:57 +04:00
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
2007-10-19 04:40:25 +04:00
bool push_blocking_lock_request ( struct byte_range_lock * br_lck ,
2008-11-04 20:05:17 +03:00
struct smb_request * req ,
2006-04-10 19:33:04 +04:00
files_struct * fsp ,
int lock_timeout ,
int lock_num ,
2010-05-07 17:20:50 +04:00
uint64_t smblctx ,
2006-04-10 19:33:04 +04:00
enum brl_type lock_type ,
enum brl_flavour lock_flav ,
2008-10-14 03:59:36 +04:00
uint64_t offset ,
uint64_t count ,
2010-05-07 17:20:50 +04:00
uint64_t blocking_smblctx )
1998-08-19 05:49:57 +04:00
{
2010-06-12 16:18:15 +04:00
struct smbd_server_connection * sconn = req - > sconn ;
2009-02-12 09:13:26 +03:00
struct blocking_lock_record * blr ;
2003-07-24 10:56:56 +04:00
NTSTATUS status ;
2010-04-09 09:15:55 +04:00
if ( req - > smb2req ) {
2010-04-10 06:26:34 +04:00
return push_blocking_lock_request_smb2 ( br_lck ,
2010-04-09 09:15:55 +04:00
req ,
fsp ,
lock_timeout ,
lock_num ,
2010-05-07 17:20:50 +04:00
smblctx ,
2010-04-09 09:15:55 +04:00
lock_type ,
lock_flav ,
offset ,
count ,
2010-05-07 17:20:50 +04:00
blocking_smblctx ) ;
2010-04-09 09:15:55 +04:00
}
2009-01-31 01:44:21 +03:00
if ( req_is_in_chain ( req ) ) {
2003-07-24 10:56:56 +04:00
DEBUG ( 0 , ( " push_blocking_lock_request: cannot queue a chained request (currently). \n " ) ) ;
return False ;
}
/*
* Now queue an entry on the blocking lock queue . We setup
* the expiration time here .
*/
2003-02-27 04:04:34 +03:00
2008-11-04 15:25:07 +03:00
blr = talloc ( NULL , struct blocking_lock_record ) ;
if ( blr = = NULL ) {
2003-07-24 10:56:56 +04:00
DEBUG ( 0 , ( " push_blocking_lock_request: Malloc fail ! \n " ) ) ;
return False ;
}
2006-04-10 19:33:04 +04:00
blr - > next = NULL ;
blr - > prev = NULL ;
blr - > fsp = fsp ;
2006-07-18 05:05:51 +04:00
if ( lock_timeout = = - 1 ) {
blr - > expire_time . tv_sec = 0 ;
blr - > expire_time . tv_usec = 0 ; /* Never expire. */
} else {
blr - > expire_time = timeval_current_ofs ( lock_timeout / 1000 ,
( lock_timeout % 1000 ) * 1000 ) ;
}
2003-07-24 10:56:56 +04:00
blr - > lock_num = lock_num ;
2010-05-07 17:20:50 +04:00
blr - > smblctx = smblctx ;
blr - > blocking_smblctx = blocking_smblctx ;
2006-04-10 19:33:04 +04:00
blr - > lock_flav = lock_flav ;
blr - > lock_type = lock_type ;
2003-07-24 10:56:56 +04:00
blr - > offset = offset ;
blr - > count = count ;
2009-02-10 08:51:29 +03:00
/* Specific brl_lock() implementations can fill this in. */
blr - > blr_private = NULL ;
2003-07-24 10:56:56 +04:00
/* Add a pending lock record for this. */
2009-02-10 08:51:29 +03:00
status = brl_lock ( smbd_messaging_context ( ) ,
br_lck ,
2010-05-07 17:20:50 +04:00
smblctx ,
2006-04-10 19:33:04 +04:00
procid_self ( ) ,
offset ,
count ,
2006-07-29 23:14:24 +04:00
lock_type = = READ_LOCK ? PENDING_READ_LOCK : PENDING_WRITE_LOCK ,
2006-04-10 19:33:04 +04:00
blr - > lock_flav ,
2010-02-13 02:42:50 +03:00
True ,
2009-02-10 08:51:29 +03:00
NULL ,
blr ) ;
2003-07-24 10:56:56 +04:00
if ( ! NT_STATUS_IS_OK ( status ) ) {
DEBUG ( 0 , ( " push_blocking_lock_request: failed to add PENDING_LOCK record. \n " ) ) ;
2008-11-04 15:25:07 +03:00
TALLOC_FREE ( blr ) ;
2003-07-24 10:56:56 +04:00
return False ;
}
2009-02-09 10:10:34 +03:00
SMB_PERFCOUNT_DEFER_OP ( & req - > pcd , & req - > pcd ) ;
2008-11-04 20:05:17 +03:00
blr - > req = talloc_move ( blr , & req ) ;
2010-04-30 03:50:15 +04:00
DLIST_ADD_END ( sconn - > smb1 . locks . blocking_lock_queue , blr , struct blocking_lock_record * ) ;
2007-03-20 00:52:27 +03:00
recalc_brl_timeout ( ) ;
2003-07-24 10:56:56 +04:00
/* Ensure we'll receive messages when this is unlocked. */
2010-04-30 03:50:15 +04:00
if ( ! sconn - > smb1 . locks . blocking_lock_unlock_state ) {
2007-05-20 01:53:28 +04:00
messaging_register ( smbd_messaging_context ( ) , NULL ,
MSG_SMB_UNLOCK , received_unlock_msg ) ;
2010-04-30 03:50:15 +04:00
sconn - > smb1 . locks . blocking_lock_unlock_state = true ;
2003-07-24 10:56:56 +04:00
}
1998-08-21 05:30:29 +04:00
2008-11-04 20:05:17 +03:00
DEBUG ( 3 , ( " push_blocking_lock_request: lock request blocked with "
2006-07-18 05:05:51 +04:00
" expiry time (%u sec. %u usec) (+%d msec) for fnum = %d, name = %s \n " ,
2008-11-04 20:05:17 +03:00
( unsigned int ) blr - > expire_time . tv_sec ,
2006-07-18 05:05:51 +04:00
( unsigned int ) blr - > expire_time . tv_usec , lock_timeout ,
2009-07-11 01:50:37 +04:00
blr - > fsp - > fnum , fsp_str_dbg ( blr - > fsp ) ) ) ;
1998-08-19 05:49:57 +04:00
2003-07-24 10:56:56 +04:00
return True ;
1998-08-19 05:49:57 +04:00
}
1998-08-20 23:28:37 +04:00
/****************************************************************************
Return a lockingX success SMB .
1998-08-19 05:49:57 +04:00
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
2009-02-12 09:13:26 +03:00
static void reply_lockingX_success ( struct blocking_lock_record * blr )
1998-08-19 05:49:57 +04:00
{
2008-11-04 20:05:17 +03:00
reply_outbuf ( blr - > req , 2 , 0 ) ;
1998-08-19 05:49:57 +04:00
2003-07-24 10:56:56 +04:00
/*
* As this message is a lockingX call we must handle
* any following chained message correctly .
* This is normally handled in construct_reply ( ) ,
* but as that calls switch_message , we can ' t use
* that here and must set up the chain info manually .
*/
1998-08-19 05:49:57 +04:00
2008-11-04 20:05:17 +03:00
chain_reply ( blr - > req ) ;
TALLOC_FREE ( blr - > req - > outbuf ) ;
1998-08-20 23:28:37 +04:00
}
/****************************************************************************
Return a generic lock fail error blocking call .
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
2009-02-12 09:13:26 +03:00
static void generic_blocking_lock_error ( struct blocking_lock_record * blr , NTSTATUS status )
1998-08-20 23:28:37 +04:00
{
2002-03-11 02:18:44 +03:00
/* whenever a timeout is given w2k maps LOCK_NOT_GRANTED to
FILE_LOCK_CONFLICT ! ( tridge ) */
if ( NT_STATUS_EQUAL ( status , NT_STATUS_LOCK_NOT_GRANTED ) ) {
status = NT_STATUS_FILE_LOCK_CONFLICT ;
}
2006-07-18 01:09:02 +04:00
if ( NT_STATUS_EQUAL ( status , NT_STATUS_FILE_LOCK_CONFLICT ) ) {
/* Store the last lock error. */
files_struct * fsp = blr - > fsp ;
2008-01-05 00:59:26 +03:00
if ( fsp ) {
2010-05-07 17:20:50 +04:00
fsp - > last_lock_failure . context . smblctx = blr - > smblctx ;
2008-01-05 00:59:26 +03:00
fsp - > last_lock_failure . context . tid = fsp - > conn - > cnum ;
fsp - > last_lock_failure . context . pid = procid_self ( ) ;
fsp - > last_lock_failure . start = blr - > offset ;
fsp - > last_lock_failure . size = blr - > count ;
fsp - > last_lock_failure . fnum = fsp - > fnum ;
fsp - > last_lock_failure . lock_type = READ_LOCK ; /* Don't care. */
fsp - > last_lock_failure . lock_flav = blr - > lock_flav ;
}
2006-07-18 01:09:02 +04:00
}
2008-11-04 20:05:17 +03:00
reply_nterror ( blr - > req , status ) ;
if ( ! srv_send_smb ( smbd_server_fd ( ) , ( char * ) blr - > req - > outbuf ,
2009-03-09 11:47:59 +03:00
true , blr - > req - > seqnum + 1 ,
2009-02-09 10:10:34 +03:00
blr - > req - > encrypted , NULL ) ) {
2008-01-04 23:56:23 +03:00
exit_server_cleanly ( " generic_blocking_lock_error: srv_send_smb failed. " ) ;
2006-07-18 01:09:02 +04:00
}
2008-11-04 20:05:17 +03:00
TALLOC_FREE ( blr - > req - > outbuf ) ;
1998-08-19 05:49:57 +04:00
}
/****************************************************************************
1998-08-20 23:28:37 +04:00
Return a lock fail error for a lockingX call . Undo all the locks we have
obtained first .
1998-08-19 05:49:57 +04:00
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
2009-02-12 09:13:26 +03:00
static void reply_lockingX_error ( struct blocking_lock_record * blr , NTSTATUS status )
1998-08-19 05:49:57 +04:00
{
2001-08-27 12:19:43 +04:00
files_struct * fsp = blr - > fsp ;
2008-11-04 20:05:17 +03:00
uint16 num_ulocks = SVAL ( blr - > req - > vwv + 6 , 0 ) ;
2008-10-14 03:59:36 +04:00
uint64_t count = ( uint64_t ) 0 , offset = ( uint64_t ) 0 ;
2010-05-07 17:20:50 +04:00
uint64_t smblctx ;
2008-11-04 20:05:17 +03:00
unsigned char locktype = CVAL ( blr - > req - > vwv + 3 , 0 ) ;
2007-10-19 04:40:25 +04:00
bool large_file_format = ( locktype & LOCKING_ANDX_LARGE_FILES ) ;
2008-11-01 19:22:15 +03:00
uint8_t * data ;
2001-08-27 12:19:43 +04:00
int i ;
2008-11-04 20:05:17 +03:00
data = ( uint8_t * ) blr - > req - > buf
2008-11-01 19:22:15 +03:00
+ ( ( large_file_format ? 20 : 10 ) * num_ulocks ) ;
2008-11-03 19:56:55 +03:00
2001-08-27 12:19:43 +04:00
/*
* Data now points at the beginning of the list
* of smb_lkrng structs .
*/
/*
* Ensure we don ' t do a remove on the lock that just failed ,
* as under POSIX rules , if we have a lock already there , we
* will delete it ( and we shouldn ' t ) . . . . .
*/
2008-11-03 19:56:55 +03:00
2001-08-27 12:19:43 +04:00
for ( i = blr - > lock_num - 1 ; i > = 0 ; i - - ) {
2007-10-19 04:40:25 +04:00
bool err ;
2008-11-03 19:56:55 +03:00
2010-05-07 17:20:50 +04:00
smblctx = get_lock_pid ( data , i , large_file_format ) ;
2001-08-27 12:19:43 +04:00
count = get_lock_count ( data , i , large_file_format ) ;
offset = get_lock_offset ( data , i , large_file_format , & err ) ;
2008-11-03 19:56:55 +03:00
2001-08-27 12:19:43 +04:00
/*
* We know err cannot be set as if it was the lock
* request would never have been queued . JRA .
*/
2008-11-03 19:56:55 +03:00
2007-05-14 17:01:28 +04:00
do_unlock ( smbd_messaging_context ( ) ,
fsp ,
2010-05-07 17:20:50 +04:00
smblctx ,
2006-04-10 19:33:04 +04:00
count ,
offset ,
WINDOWS_LOCK ) ;
2001-08-27 12:19:43 +04:00
}
2008-11-03 19:56:55 +03:00
2001-08-27 12:19:43 +04:00
generic_blocking_lock_error ( blr , status ) ;
1998-08-20 23:28:37 +04:00
}
/****************************************************************************
Return a lock fail error .
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
2009-02-12 09:13:26 +03:00
static void blocking_lock_reply_error ( struct blocking_lock_record * blr , NTSTATUS status )
1998-08-20 23:28:37 +04:00
{
2009-02-10 08:51:29 +03:00
DEBUG ( 10 , ( " Replying with error=%s. BLR = %p \n " , nt_errstr ( status ) , blr ) ) ;
2008-11-04 20:05:17 +03:00
switch ( blr - > req - > cmd ) {
2001-08-27 12:19:43 +04:00
case SMBlockingX :
reply_lockingX_error ( blr , status ) ;
break ;
2006-04-10 19:33:04 +04:00
case SMBtrans2 :
case SMBtranss2 :
2008-11-04 20:05:17 +03:00
reply_nterror ( blr - > req , status ) ;
/*
* construct_reply_common has done us the favor to pre - fill
* the command field with SMBtranss2 which is wrong : - )
*/
SCVAL ( blr - > req - > outbuf , smb_com , SMBtrans2 ) ;
if ( ! srv_send_smb ( smbd_server_fd ( ) ,
( char * ) blr - > req - > outbuf ,
2009-03-09 11:47:59 +03:00
true , blr - > req - > seqnum + 1 ,
2009-02-09 10:10:34 +03:00
IS_CONN_ENCRYPTED ( blr - > fsp - > conn ) ,
NULL ) ) {
2008-11-04 20:05:17 +03:00
exit_server_cleanly ( " blocking_lock_reply_error: "
" srv_send_smb failed. " ) ;
2006-04-10 19:33:04 +04:00
}
2008-11-04 20:05:17 +03:00
TALLOC_FREE ( blr - > req - > outbuf ) ;
break ;
2001-08-27 12:19:43 +04:00
default :
DEBUG ( 0 , ( " blocking_lock_reply_error: PANIC - unknown type on blocking lock queue - exiting.! \n " ) ) ;
exit_server ( " PANIC - unknown type on blocking lock queue " ) ;
}
1998-08-20 23:28:37 +04:00
}
/****************************************************************************
Attempt to finish off getting all pending blocking locks for a lockingX call .
Returns True if we want to be removed from the list .
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
2009-02-12 09:13:26 +03:00
static bool process_lockingX ( struct blocking_lock_record * blr )
1998-08-19 05:49:57 +04:00
{
2008-11-04 20:05:17 +03:00
unsigned char locktype = CVAL ( blr - > req - > vwv + 3 , 0 ) ;
2001-08-27 12:19:43 +04:00
files_struct * fsp = blr - > fsp ;
2008-11-04 20:05:17 +03:00
uint16 num_ulocks = SVAL ( blr - > req - > vwv + 6 , 0 ) ;
uint16 num_locks = SVAL ( blr - > req - > vwv + 7 , 0 ) ;
2008-10-14 03:59:36 +04:00
uint64_t count = ( uint64_t ) 0 , offset = ( uint64_t ) 0 ;
2010-05-07 17:20:50 +04:00
uint64_t smblctx ;
2007-10-19 04:40:25 +04:00
bool large_file_format = ( locktype & LOCKING_ANDX_LARGE_FILES ) ;
2008-11-01 19:22:15 +03:00
uint8_t * data ;
2001-08-27 21:52:23 +04:00
NTSTATUS status = NT_STATUS_OK ;
2001-08-27 12:19:43 +04:00
2008-11-04 20:05:17 +03:00
data = ( uint8_t * ) blr - > req - > buf
2008-11-01 19:22:15 +03:00
+ ( ( large_file_format ? 20 : 10 ) * num_ulocks ) ;
2001-08-27 12:19:43 +04:00
/*
* Data now points at the beginning of the list
* of smb_lkrng structs .
*/
2006-07-18 05:05:51 +04:00
2001-08-27 12:19:43 +04:00
for ( ; blr - > lock_num < num_locks ; blr - > lock_num + + ) {
2006-07-18 05:05:51 +04:00
struct byte_range_lock * br_lck = NULL ;
2007-10-19 04:40:25 +04:00
bool err ;
2001-08-27 12:19:43 +04:00
2010-05-07 17:20:50 +04:00
smblctx = get_lock_pid ( data , blr - > lock_num , large_file_format ) ;
2001-08-27 12:19:43 +04:00
count = get_lock_count ( data , blr - > lock_num , large_file_format ) ;
offset = get_lock_offset ( data , blr - > lock_num , large_file_format , & err ) ;
2008-11-03 19:56:55 +03:00
2001-08-27 12:19:43 +04:00
/*
* We know err cannot be set as if it was the lock
* request would never have been queued . JRA .
*/
errno = 0 ;
2007-05-14 17:01:28 +04:00
br_lck = do_lock ( smbd_messaging_context ( ) ,
fsp ,
2010-05-07 17:20:50 +04:00
smblctx ,
2006-04-10 19:33:04 +04:00
count ,
2010-05-07 17:20:50 +04:00
offset ,
2006-07-18 01:09:02 +04:00
( ( locktype & LOCKING_ANDX_SHARED_LOCK ) ?
READ_LOCK : WRITE_LOCK ) ,
2006-04-10 19:33:04 +04:00
WINDOWS_LOCK ,
2006-07-18 05:05:51 +04:00
True ,
2007-05-20 00:57:12 +04:00
& status ,
2010-05-07 17:20:50 +04:00
& blr - > blocking_smblctx ,
2009-02-10 08:51:29 +03:00
blr ) ;
2006-07-18 05:05:51 +04:00
TALLOC_FREE ( br_lck ) ;
2006-04-10 19:33:04 +04:00
if ( NT_STATUS_IS_ERR ( status ) ) {
break ;
}
2001-08-27 12:19:43 +04:00
}
if ( blr - > lock_num = = num_locks ) {
/*
* Success - we got all the locks .
*/
2008-11-03 19:56:55 +03:00
2009-07-11 01:50:37 +04:00
DEBUG ( 3 , ( " process_lockingX file = %s, fnum=%d type=%d "
" num_locks=%d \n " , fsp_str_dbg ( fsp ) , fsp - > fnum ,
( unsigned int ) locktype , num_locks ) ) ;
2001-08-27 12:19:43 +04:00
reply_lockingX_success ( blr ) ;
return True ;
2008-11-04 16:35:44 +03:00
}
2008-11-03 19:56:55 +03:00
2008-11-04 16:35:44 +03:00
if ( ! NT_STATUS_EQUAL ( status , NT_STATUS_LOCK_NOT_GRANTED ) & &
! NT_STATUS_EQUAL ( status , NT_STATUS_FILE_LOCK_CONFLICT ) ) {
/*
* We have other than a " can't get lock "
* error . Free any locks we had and return an error .
* Return True so we get dequeued .
*/
2001-08-27 12:19:43 +04:00
blocking_lock_reply_error ( blr , status ) ;
return True ;
}
/*
* Still can ' t get all the locks - keep waiting .
*/
2008-11-03 19:56:55 +03:00
2001-08-27 12:19:43 +04:00
DEBUG ( 10 , ( " process_lockingX: only got %d locks of %d needed for file %s, fnum = %d. \
Waiting . . . . \ n " ,
2009-07-11 01:50:37 +04:00
blr - > lock_num , num_locks , fsp_str_dbg ( fsp ) , fsp - > fnum ) ) ;
2008-11-03 19:56:55 +03:00
2001-08-27 12:19:43 +04:00
return False ;
1998-08-19 05:49:57 +04:00
}
2006-04-10 19:33:04 +04:00
/****************************************************************************
Attempt to get the posix lock request from a SMBtrans2 call .
Returns True if we want to be removed from the list .
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
2009-02-12 09:13:26 +03:00
static bool process_trans2 ( struct blocking_lock_record * blr )
2006-04-10 19:33:04 +04:00
{
char params [ 2 ] ;
NTSTATUS status ;
2007-05-14 17:01:28 +04:00
struct byte_range_lock * br_lck = do_lock ( smbd_messaging_context ( ) ,
blr - > fsp ,
2010-05-07 17:20:50 +04:00
blr - > smblctx ,
2006-07-18 05:05:51 +04:00
blr - > count ,
blr - > offset ,
blr - > lock_type ,
blr - > lock_flav ,
True ,
2007-05-20 00:57:12 +04:00
& status ,
2010-05-07 17:20:50 +04:00
& blr - > blocking_smblctx ,
2009-02-10 08:51:29 +03:00
blr ) ;
2006-07-18 05:05:51 +04:00
TALLOC_FREE ( br_lck ) ;
2006-04-10 19:33:04 +04:00
if ( ! NT_STATUS_IS_OK ( status ) ) {
if ( ERROR_WAS_LOCK_DENIED ( status ) ) {
/* Still can't get the lock, just keep waiting. */
return False ;
}
/*
* We have other than a " can't get lock "
* error . Send an error and return True so we get dequeued .
*/
blocking_lock_reply_error ( blr , status ) ;
return True ;
}
/* We finally got the lock, return success. */
2007-08-03 18:33:38 +04:00
2006-04-10 19:33:04 +04:00
SSVAL ( params , 0 , 0 ) ;
2006-08-14 20:53:14 +04:00
/* Fake up max_data_bytes here - we know it fits. */
2008-11-04 20:05:17 +03:00
send_trans2_replies ( blr - > fsp - > conn , blr - > req , params , 2 , NULL , 0 , 0xffff ) ;
2006-04-10 19:33:04 +04:00
return True ;
}
1998-08-20 23:28:37 +04:00
/****************************************************************************
Process a blocking lock SMB .
Returns True if we want to be removed from the list .
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
2009-02-12 09:13:26 +03:00
static bool blocking_lock_record_process ( struct blocking_lock_record * blr )
1998-08-20 23:28:37 +04:00
{
2008-11-04 20:05:17 +03:00
switch ( blr - > req - > cmd ) {
2003-07-24 10:56:56 +04:00
case SMBlockingX :
return process_lockingX ( blr ) ;
2006-04-10 19:33:04 +04:00
case SMBtrans2 :
case SMBtranss2 :
return process_trans2 ( blr ) ;
2003-07-24 10:56:56 +04:00
default :
DEBUG ( 0 , ( " blocking_lock_record_process: PANIC - unknown type on blocking lock queue - exiting.! \n " ) ) ;
exit_server ( " PANIC - unknown type on blocking lock queue " ) ;
}
return False ; /* Keep compiler happy. */
1998-08-20 23:28:37 +04:00
}
1998-08-19 05:49:57 +04:00
/****************************************************************************
2006-07-18 01:09:02 +04:00
Cancel entries by fnum from the blocking lock pending queue .
2010-04-30 04:08:12 +04:00
Called when a file is closed .
1998-08-19 05:49:57 +04:00
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
2010-05-07 12:20:26 +04:00
void cancel_pending_lock_requests_by_fid ( files_struct * fsp ,
struct byte_range_lock * br_lck ,
enum file_close_type close_type )
1998-08-19 05:49:57 +04:00
{
2010-04-30 03:50:15 +04:00
struct smbd_server_connection * sconn = smbd_server_conn ;
2009-02-10 08:51:29 +03:00
struct blocking_lock_record * blr , * blr_cancelled , * next = NULL ;
1998-08-19 05:49:57 +04:00
2010-06-10 06:12:02 +04:00
if ( sconn - > using_smb2 ) {
2010-05-07 12:20:26 +04:00
cancel_pending_lock_requests_by_fid_smb2 ( fsp ,
br_lck ,
close_type ) ;
2010-04-30 04:08:12 +04:00
return ;
}
2010-04-30 03:50:15 +04:00
for ( blr = sconn - > smb1 . locks . blocking_lock_queue ; blr ; blr = next ) {
2008-11-04 16:29:33 +03:00
unsigned char locktype = 0 ;
2004-08-21 04:43:21 +04:00
next = blr - > next ;
2008-11-04 16:29:33 +03:00
if ( blr - > fsp - > fnum ! = fsp - > fnum ) {
continue ;
}
2006-07-18 01:09:02 +04:00
2008-11-04 20:05:17 +03:00
if ( blr - > req - > cmd = = SMBlockingX ) {
locktype = CVAL ( blr - > req - > vwv + 3 , 0 ) ;
2008-11-04 16:29:33 +03:00
}
1998-08-21 05:30:29 +04:00
2008-11-04 18:57:31 +03:00
DEBUG ( 10 , ( " remove_pending_lock_requests_by_fid - removing "
" request type %d for file %s fnum = %d \n " ,
2009-07-11 01:50:37 +04:00
blr - > req - > cmd , fsp_str_dbg ( fsp ) , fsp - > fnum ) ) ;
2008-11-04 18:57:31 +03:00
2010-04-30 04:08:12 +04:00
blr_cancelled = blocking_lock_cancel_smb1 ( fsp ,
2010-05-07 17:20:50 +04:00
blr - > smblctx ,
2008-11-04 18:57:31 +03:00
blr - > offset ,
blr - > count ,
blr - > lock_flav ,
locktype ,
NT_STATUS_RANGE_NOT_LOCKED ) ;
2009-02-10 08:51:29 +03:00
SMB_ASSERT ( blr_cancelled = = blr ) ;
brl_lock_cancel ( br_lck ,
2010-05-07 17:20:50 +04:00
blr - > smblctx ,
2009-02-10 08:51:29 +03:00
procid_self ( ) ,
blr - > offset ,
blr - > count ,
blr - > lock_flav ,
blr ) ;
2008-11-04 16:29:33 +03:00
/* We're closing the file fsp here, so ensure
* we don ' t have a dangling pointer . */
blr - > fsp = NULL ;
2003-07-24 10:56:56 +04:00
}
1998-08-19 05:49:57 +04:00
}
/****************************************************************************
Delete entries by mid from the blocking lock pending queue . Always send reply .
2010-04-30 04:08:12 +04:00
Only called from the SMB1 cancel code .
1998-08-19 05:49:57 +04:00
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
2010-04-30 04:08:12 +04:00
void remove_pending_lock_requests_by_mid_smb1 ( uint64_t mid )
1998-08-19 05:49:57 +04:00
{
2010-04-30 03:50:15 +04:00
struct smbd_server_connection * sconn = smbd_server_conn ;
2009-02-12 09:13:26 +03:00
struct blocking_lock_record * blr , * next = NULL ;
1998-08-19 05:49:57 +04:00
2010-04-30 03:50:15 +04:00
for ( blr = sconn - > smb1 . locks . blocking_lock_queue ; blr ; blr = next ) {
2008-11-04 16:33:20 +03:00
files_struct * fsp ;
struct byte_range_lock * br_lck ;
2004-08-21 04:43:21 +04:00
next = blr - > next ;
1998-08-21 05:30:29 +04:00
2008-11-04 20:05:17 +03:00
if ( blr - > req - > mid ! = mid ) {
2008-11-04 16:33:20 +03:00
continue ;
}
fsp = blr - > fsp ;
br_lck = brl_get_locks ( talloc_tos ( ) , fsp ) ;
1998-08-21 05:30:29 +04:00
2008-11-04 16:33:20 +03:00
if ( br_lck ) {
2010-04-30 04:08:12 +04:00
DEBUG ( 10 , ( " remove_pending_lock_requests_by_mid_smb1 - "
2008-11-04 16:33:20 +03:00
" removing request type %d for file %s fnum "
2009-07-11 01:50:37 +04:00
" = %d \n " , blr - > req - > cmd , fsp_str_dbg ( fsp ) ,
2008-11-04 16:33:20 +03:00
fsp - > fnum ) ) ;
brl_lock_cancel ( br_lck ,
2010-05-07 17:20:50 +04:00
blr - > smblctx ,
2006-04-10 19:33:04 +04:00
procid_self ( ) ,
blr - > offset ,
blr - > count ,
2009-02-10 08:51:29 +03:00
blr - > lock_flav ,
blr ) ;
2008-11-04 16:33:20 +03:00
TALLOC_FREE ( br_lck ) ;
2003-07-24 10:56:56 +04:00
}
2008-11-04 16:33:20 +03:00
blocking_lock_reply_error ( blr , NT_STATUS_FILE_LOCK_CONFLICT ) ;
2010-04-30 03:50:15 +04:00
DLIST_REMOVE ( sconn - > smb1 . locks . blocking_lock_queue , blr ) ;
2008-11-04 16:33:20 +03:00
TALLOC_FREE ( blr ) ;
2003-07-24 10:56:56 +04:00
}
1998-08-19 05:49:57 +04:00
}
2007-01-30 23:49:37 +03:00
/****************************************************************************
Is this mid a blocking lock request on the queue ?
2010-04-30 04:08:12 +04:00
Currently only called from the SMB1 unix extensions POSIX lock code .
2007-01-30 23:49:37 +03:00
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
2010-04-30 04:08:12 +04:00
bool blocking_lock_was_deferred_smb1 ( uint64_t mid )
2007-01-30 23:49:37 +03:00
{
2010-04-30 03:50:15 +04:00
struct smbd_server_connection * sconn = smbd_server_conn ;
2009-02-12 09:13:26 +03:00
struct blocking_lock_record * blr , * next = NULL ;
2007-01-30 23:49:37 +03:00
2010-04-30 03:50:15 +04:00
for ( blr = sconn - > smb1 . locks . blocking_lock_queue ; blr ; blr = next ) {
2007-01-30 23:49:37 +03:00
next = blr - > next ;
2008-11-04 20:05:17 +03:00
if ( blr - > req - > mid = = mid ) {
2007-01-30 23:49:37 +03:00
return True ;
}
}
return False ;
}
2003-02-27 04:04:34 +03:00
/****************************************************************************
Set a flag as an unlock request affects one of our pending locks .
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
2007-05-20 01:53:28 +04:00
static void received_unlock_msg ( struct messaging_context * msg ,
void * private_data ,
uint32_t msg_type ,
struct server_id server_id ,
DATA_BLOB * data )
2003-02-27 04:04:34 +03:00
{
DEBUG ( 10 , ( " received_unlock_msg \n " ) ) ;
2006-07-18 05:05:51 +04:00
process_blocking_lock_queue ( ) ;
2003-02-27 04:04:34 +03:00
}
1998-08-19 05:49:57 +04:00
/****************************************************************************
Process the blocking lock queue . Note that this is only called as root .
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
2009-02-10 08:51:29 +03:00
void process_blocking_lock_queue ( void )
1998-08-19 05:49:57 +04:00
{
2010-04-30 03:50:15 +04:00
struct smbd_server_connection * sconn = smbd_server_conn ;
2010-05-06 19:22:13 +04:00
struct timeval tv_curr = timeval_current ( ) ;
2009-02-12 09:13:26 +03:00
struct blocking_lock_record * blr , * next = NULL ;
2003-07-24 10:56:56 +04:00
2010-06-10 06:12:02 +04:00
if ( sconn - > using_smb2 ) {
2010-05-06 19:22:13 +04:00
process_blocking_lock_queue_smb2 ( tv_curr ) ;
2010-05-05 17:09:03 +04:00
return ;
2010-05-01 08:03:20 +04:00
}
2003-07-24 10:56:56 +04:00
/*
* Go through the queue and see if we can get any of the locks .
*/
2010-04-30 03:50:15 +04:00
for ( blr = sconn - > smb1 . locks . blocking_lock_queue ; blr ; blr = next ) {
2003-07-24 10:56:56 +04:00
2004-08-21 04:43:21 +04:00
next = blr - > next ;
2007-08-30 00:49:09 +04:00
/*
* Go through the remaining locks and try and obtain them .
* The call returns True if all locks were obtained successfully
* and False if we still need to wait .
*/
2006-04-10 19:33:04 +04:00
2009-02-10 08:51:29 +03:00
DEBUG ( 10 , ( " Processing BLR = %p \n " , blr ) ) ;
2009-10-27 07:20:22 +03:00
/* We use set_current_service so connections with
* pending locks are not marked as idle .
*/
set_current_service ( blr - > fsp - > conn ,
SVAL ( blr - > req - > inbuf , smb_flg ) ,
false ) ;
2007-08-30 00:49:09 +04:00
if ( blocking_lock_record_process ( blr ) ) {
2008-11-05 21:16:06 +03:00
struct byte_range_lock * br_lck = brl_get_locks (
talloc_tos ( ) , blr - > fsp ) ;
2003-07-24 10:56:56 +04:00
2009-02-10 08:51:29 +03:00
DEBUG ( 10 , ( " BLR_process returned true: cancelling and "
" removing lock. BLR = %p \n " , blr ) ) ;
2006-04-10 19:33:04 +04:00
if ( br_lck ) {
2006-07-18 01:09:02 +04:00
brl_lock_cancel ( br_lck ,
2010-05-07 17:20:50 +04:00
blr - > smblctx ,
2006-04-10 19:33:04 +04:00
procid_self ( ) ,
blr - > offset ,
blr - > count ,
2009-02-10 08:51:29 +03:00
blr - > lock_flav ,
blr ) ;
2006-07-11 22:01:26 +04:00
TALLOC_FREE ( br_lck ) ;
2006-04-10 19:33:04 +04:00
}
2003-07-24 10:56:56 +04:00
2010-04-30 03:50:15 +04:00
DLIST_REMOVE ( sconn - > smb1 . locks . blocking_lock_queue , blr ) ;
2008-11-04 15:25:07 +03:00
TALLOC_FREE ( blr ) ;
2003-07-24 10:56:56 +04:00
continue ;
}
/*
2007-08-30 00:49:09 +04:00
* We couldn ' t get the locks for this record on the list .
* If the time has expired , return a lock error .
2003-07-24 10:56:56 +04:00
*/
2007-08-30 00:49:09 +04:00
if ( ! timeval_is_zero ( & blr - > expire_time ) & & timeval_compare ( & blr - > expire_time , & tv_curr ) < = 0 ) {
2008-11-05 21:16:06 +03:00
struct byte_range_lock * br_lck = brl_get_locks (
talloc_tos ( ) , blr - > fsp ) ;
2006-04-10 19:33:04 +04:00
2009-02-10 08:51:29 +03:00
DEBUG ( 10 , ( " Lock timed out! BLR = %p \n " , blr ) ) ;
2007-08-30 00:49:09 +04:00
/*
* Lock expired - throw away all previously
* obtained locks and return lock error .
*/
2006-04-10 19:33:04 +04:00
if ( br_lck ) {
2008-11-05 21:16:06 +03:00
DEBUG ( 5 , ( " process_blocking_lock_queue: "
" pending lock fnum = %d for file %s "
" timed out. \n " , blr - > fsp - > fnum ,
2009-07-11 01:50:37 +04:00
fsp_str_dbg ( blr - > fsp ) ) ) ;
2007-08-30 00:49:09 +04:00
2006-07-18 01:09:02 +04:00
brl_lock_cancel ( br_lck ,
2010-05-07 17:20:50 +04:00
blr - > smblctx ,
2006-04-10 19:33:04 +04:00
procid_self ( ) ,
blr - > offset ,
blr - > count ,
2009-02-10 08:51:29 +03:00
blr - > lock_flav ,
blr ) ;
2006-07-11 22:01:26 +04:00
TALLOC_FREE ( br_lck ) ;
2006-04-10 19:33:04 +04:00
}
2003-07-24 10:56:56 +04:00
2007-08-30 00:49:09 +04:00
blocking_lock_reply_error ( blr , NT_STATUS_FILE_LOCK_CONFLICT ) ;
2010-04-30 03:50:15 +04:00
DLIST_REMOVE ( sconn - > smb1 . locks . blocking_lock_queue , blr ) ;
2008-11-04 15:25:07 +03:00
TALLOC_FREE ( blr ) ;
2003-07-24 10:56:56 +04:00
}
}
2007-03-20 00:52:27 +03:00
2009-10-27 07:20:22 +03:00
recalc_brl_timeout ( ) ;
1998-08-19 05:49:57 +04:00
}
2006-07-18 01:09:02 +04:00
/****************************************************************************
Handle a cancel message . Lock already moved onto the cancel queue .
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
2009-02-12 09:13:26 +03:00
# define MSG_BLOCKING_LOCK_CANCEL_SIZE (sizeof(struct blocking_lock_record *) + sizeof(NTSTATUS))
2006-07-18 01:09:02 +04:00
2007-05-20 01:53:28 +04:00
static void process_blocking_lock_cancel_message ( struct messaging_context * ctx ,
void * private_data ,
uint32_t msg_type ,
struct server_id server_id ,
DATA_BLOB * data )
2006-07-18 01:09:02 +04:00
{
2010-04-30 03:50:15 +04:00
struct smbd_server_connection * sconn = smbd_server_conn ;
2006-07-18 01:09:02 +04:00
NTSTATUS err ;
2007-05-20 01:53:28 +04:00
const char * msg = ( const char * ) data - > data ;
2009-02-12 09:13:26 +03:00
struct blocking_lock_record * blr ;
2006-07-18 01:09:02 +04:00
2007-05-20 01:53:28 +04:00
if ( data - > data = = NULL ) {
2007-06-16 01:58:49 +04:00
smb_panic ( " process_blocking_lock_cancel_message: null msg " ) ;
2006-07-18 01:09:02 +04:00
}
2007-05-20 01:53:28 +04:00
if ( data - > length ! = MSG_BLOCKING_LOCK_CANCEL_SIZE ) {
2006-07-18 01:09:02 +04:00
DEBUG ( 0 , ( " process_blocking_lock_cancel_message: "
2007-05-20 01:53:28 +04:00
" Got invalid msg len %d \n " , ( int ) data - > length ) ) ;
2007-06-16 01:58:49 +04:00
smb_panic ( " process_blocking_lock_cancel_message: bad msg " ) ;
2006-07-18 01:09:02 +04:00
}
memcpy ( & blr , msg , sizeof ( blr ) ) ;
memcpy ( & err , & msg [ sizeof ( blr ) ] , sizeof ( NTSTATUS ) ) ;
DEBUG ( 10 , ( " process_blocking_lock_cancel_message: returning error %s \n " ,
nt_errstr ( err ) ) ) ;
blocking_lock_reply_error ( blr , err ) ;
2010-04-30 03:50:15 +04:00
DLIST_REMOVE ( sconn - > smb1 . locks . blocking_lock_cancelled_queue , blr ) ;
2008-11-04 15:25:07 +03:00
TALLOC_FREE ( blr ) ;
2006-07-18 01:09:02 +04:00
}
/****************************************************************************
Send ourselves a blocking lock cancelled message . Handled asynchronously above .
2009-02-10 08:51:29 +03:00
Returns the blocking_lock_record that is being cancelled .
2010-04-30 04:08:12 +04:00
Only called from the SMB1 code .
2006-07-18 01:09:02 +04:00
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
2010-04-30 04:08:12 +04:00
struct blocking_lock_record * blocking_lock_cancel_smb1 ( files_struct * fsp ,
2010-05-07 17:20:50 +04:00
uint64_t smblctx ,
2008-10-14 03:59:36 +04:00
uint64_t offset ,
uint64_t count ,
2006-07-18 01:09:02 +04:00
enum brl_flavour lock_flav ,
unsigned char locktype ,
NTSTATUS err )
{
2010-04-30 03:50:15 +04:00
struct smbd_server_connection * sconn = smbd_server_conn ;
2006-07-18 01:09:02 +04:00
char msg [ MSG_BLOCKING_LOCK_CANCEL_SIZE ] ;
2009-02-12 09:13:26 +03:00
struct blocking_lock_record * blr ;
2006-07-18 01:09:02 +04:00
2010-04-30 03:50:15 +04:00
if ( ! sconn - > smb1 . locks . blocking_lock_cancel_state ) {
2006-07-18 01:09:02 +04:00
/* Register our message. */
2007-05-20 01:53:28 +04:00
messaging_register ( smbd_messaging_context ( ) , NULL ,
MSG_SMB_BLOCKING_LOCK_CANCEL ,
process_blocking_lock_cancel_message ) ;
2006-07-18 01:09:02 +04:00
2010-04-30 03:50:15 +04:00
sconn - > smb1 . locks . blocking_lock_cancel_state = True ;
2006-07-18 01:09:02 +04:00
}
2010-04-30 03:50:15 +04:00
for ( blr = sconn - > smb1 . locks . blocking_lock_queue ; blr ; blr = blr - > next ) {
2006-07-18 01:09:02 +04:00
if ( fsp = = blr - > fsp & &
2010-05-07 17:20:50 +04:00
smblctx = = blr - > smblctx & &
2006-07-18 01:09:02 +04:00
offset = = blr - > offset & &
count = = blr - > count & &
lock_flav = = blr - > lock_flav ) {
break ;
}
}
if ( ! blr ) {
2009-02-10 08:51:29 +03:00
return NULL ;
2006-07-18 01:09:02 +04:00
}
/* Check the flags are right. */
2008-11-04 20:05:17 +03:00
if ( blr - > req - > cmd = = SMBlockingX & &
2006-07-18 01:09:02 +04:00
( locktype & LOCKING_ANDX_LARGE_FILES ) ! =
2008-11-04 20:05:17 +03:00
( CVAL ( blr - > req - > vwv + 3 , 0 ) & LOCKING_ANDX_LARGE_FILES ) ) {
2009-02-10 08:51:29 +03:00
return NULL ;
2006-07-18 01:09:02 +04:00
}
/* Move to cancelled queue. */
2010-04-30 03:50:15 +04:00
DLIST_REMOVE ( sconn - > smb1 . locks . blocking_lock_queue , blr ) ;
DLIST_ADD ( sconn - > smb1 . locks . blocking_lock_cancelled_queue , blr ) ;
2006-07-18 01:09:02 +04:00
/* Create the message. */
memcpy ( msg , & blr , sizeof ( blr ) ) ;
memcpy ( & msg [ sizeof ( blr ) ] , & err , sizeof ( NTSTATUS ) ) ;
2007-05-15 00:31:28 +04:00
messaging_send_buf ( smbd_messaging_context ( ) , procid_self ( ) ,
MSG_SMB_BLOCKING_LOCK_CANCEL ,
( uint8 * ) & msg , sizeof ( msg ) ) ;
2006-07-18 01:09:02 +04:00
2009-02-10 08:51:29 +03:00
return blr ;
2006-07-18 01:09:02 +04:00
}