2 Unix SMB/CIFS implementation.
5 Copyright (C) Stefan Metzmacher 2009
6 Copyright (C) Jeremy Allison 2010
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program. If not, see <http://www.gnu.org/licenses/>.
23 #include "smbd/smbd.h"
24 #include "smbd/globals.h"
25 #include "../libcli/smb/smb_common.h"
26 #include "../lib/util/tevent_ntstatus.h"
29 struct smbd_smb2_lock_element
{
35 struct smbd_smb2_lock_state
{
36 struct smbd_smb2_request
*smb2req
;
37 struct smb_request
*smb1req
;
38 struct blocking_lock_record
*blr
;
40 struct smbd_lock_element
*locks
;
43 static void remove_pending_lock(struct smbd_smb2_lock_state
*state
,
44 struct blocking_lock_record
*blr
);
46 static struct tevent_req
*smbd_smb2_lock_send(TALLOC_CTX
*mem_ctx
,
47 struct tevent_context
*ev
,
48 struct smbd_smb2_request
*smb2req
,
49 struct files_struct
*in_fsp
,
50 uint16_t in_lock_count
,
51 struct smbd_smb2_lock_element
*in_locks
);
52 static NTSTATUS
smbd_smb2_lock_recv(struct tevent_req
*req
);
54 static void smbd_smb2_request_lock_done(struct tevent_req
*subreq
);
55 NTSTATUS
smbd_smb2_request_process_lock(struct smbd_smb2_request
*req
)
57 const uint8_t *inbody
;
58 uint16_t in_lock_count
;
59 uint64_t in_file_id_persistent
;
60 uint64_t in_file_id_volatile
;
61 struct files_struct
*in_fsp
;
62 struct smbd_smb2_lock_element
*in_locks
;
63 struct tevent_req
*subreq
;
64 const uint8_t *lock_buffer
;
68 status
= smbd_smb2_request_verify_sizes(req
, 0x30);
69 if (!NT_STATUS_IS_OK(status
)) {
70 return smbd_smb2_request_error(req
, status
);
72 inbody
= SMBD_SMB2_IN_BODY_PTR(req
);
74 in_lock_count
= CVAL(inbody
, 0x02);
75 /* 0x04 - 4 bytes reserved */
76 in_file_id_persistent
= BVAL(inbody
, 0x08);
77 in_file_id_volatile
= BVAL(inbody
, 0x10);
79 if (in_lock_count
< 1) {
80 return smbd_smb2_request_error(req
, NT_STATUS_INVALID_PARAMETER
);
83 if (((in_lock_count
- 1) * 0x18) > SMBD_SMB2_IN_DYN_LEN(req
)) {
84 return smbd_smb2_request_error(req
, NT_STATUS_INVALID_PARAMETER
);
87 in_locks
= talloc_array(req
, struct smbd_smb2_lock_element
,
89 if (in_locks
== NULL
) {
90 return smbd_smb2_request_error(req
, NT_STATUS_NO_MEMORY
);
94 lock_buffer
= inbody
+ 0x18;
96 in_locks
[l
].offset
= BVAL(lock_buffer
, 0x00);
97 in_locks
[l
].length
= BVAL(lock_buffer
, 0x08);
98 in_locks
[l
].flags
= IVAL(lock_buffer
, 0x10);
99 /* 0x14 - 4 reserved bytes */
101 lock_buffer
= SMBD_SMB2_IN_DYN_PTR(req
);
103 for (l
=1; l
< in_lock_count
; l
++) {
104 in_locks
[l
].offset
= BVAL(lock_buffer
, 0x00);
105 in_locks
[l
].length
= BVAL(lock_buffer
, 0x08);
106 in_locks
[l
].flags
= IVAL(lock_buffer
, 0x10);
107 /* 0x14 - 4 reserved bytes */
112 in_fsp
= file_fsp_smb2(req
, in_file_id_persistent
, in_file_id_volatile
);
113 if (in_fsp
== NULL
) {
114 return smbd_smb2_request_error(req
, NT_STATUS_FILE_CLOSED
);
117 subreq
= smbd_smb2_lock_send(req
, req
->sconn
->ev_ctx
,
121 if (subreq
== NULL
) {
122 return smbd_smb2_request_error(req
, NT_STATUS_NO_MEMORY
);
124 tevent_req_set_callback(subreq
, smbd_smb2_request_lock_done
, req
);
126 return smbd_smb2_request_pending_queue(req
, subreq
, 500);
129 static void smbd_smb2_request_lock_done(struct tevent_req
*subreq
)
131 struct smbd_smb2_request
*smb2req
= tevent_req_callback_data(subreq
,
132 struct smbd_smb2_request
);
135 NTSTATUS error
; /* transport error */
137 status
= smbd_smb2_lock_recv(subreq
);
139 if (!NT_STATUS_IS_OK(status
)) {
140 error
= smbd_smb2_request_error(smb2req
, status
);
141 if (!NT_STATUS_IS_OK(error
)) {
142 smbd_server_connection_terminate(smb2req
->sconn
,
149 outbody
= smbd_smb2_generate_outbody(smb2req
, 0x04);
150 if (outbody
.data
== NULL
) {
151 error
= smbd_smb2_request_error(smb2req
, NT_STATUS_NO_MEMORY
);
152 if (!NT_STATUS_IS_OK(error
)) {
153 smbd_server_connection_terminate(smb2req
->sconn
,
160 SSVAL(outbody
.data
, 0x00, 0x04); /* struct size */
161 SSVAL(outbody
.data
, 0x02, 0); /* reserved */
163 error
= smbd_smb2_request_done(smb2req
, outbody
, NULL
);
164 if (!NT_STATUS_IS_OK(error
)) {
165 smbd_server_connection_terminate(smb2req
->sconn
,
171 static struct tevent_req
*smbd_smb2_lock_send(TALLOC_CTX
*mem_ctx
,
172 struct tevent_context
*ev
,
173 struct smbd_smb2_request
*smb2req
,
174 struct files_struct
*fsp
,
175 uint16_t in_lock_count
,
176 struct smbd_smb2_lock_element
*in_locks
)
178 struct tevent_req
*req
;
179 struct smbd_smb2_lock_state
*state
;
180 struct smb_request
*smb1req
;
181 int32_t timeout
= -1;
182 bool isunlock
= false;
184 struct smbd_lock_element
*locks
;
188 req
= tevent_req_create(mem_ctx
, &state
,
189 struct smbd_smb2_lock_state
);
193 state
->smb2req
= smb2req
;
194 smb2req
->subreq
= req
; /* So we can find this when going async. */
196 smb1req
= smbd_smb2_fake_smb_request(smb2req
);
197 if (tevent_req_nomem(smb1req
, req
)) {
198 return tevent_req_post(req
, ev
);
200 state
->smb1req
= smb1req
;
202 DEBUG(10,("smbd_smb2_lock_send: %s - %s\n",
203 fsp_str_dbg(fsp
), fsp_fnum_dbg(fsp
)));
205 locks
= talloc_array(state
, struct smbd_lock_element
, in_lock_count
);
207 tevent_req_nterror(req
, NT_STATUS_NO_MEMORY
);
208 return tevent_req_post(req
, ev
);
211 switch (in_locks
[0].flags
) {
212 case SMB2_LOCK_FLAG_SHARED
:
213 case SMB2_LOCK_FLAG_EXCLUSIVE
:
214 if (in_lock_count
> 1) {
215 tevent_req_nterror(req
, NT_STATUS_INVALID_PARAMETER
);
216 return tevent_req_post(req
, ev
);
221 case SMB2_LOCK_FLAG_SHARED
|SMB2_LOCK_FLAG_FAIL_IMMEDIATELY
:
222 case SMB2_LOCK_FLAG_EXCLUSIVE
|SMB2_LOCK_FLAG_FAIL_IMMEDIATELY
:
226 case SMB2_LOCK_FLAG_UNLOCK
:
227 /* only the first lock gives the UNLOCK bit - see
234 tevent_req_nterror(req
, NT_STATUS_INVALID_PARAMETER
);
235 return tevent_req_post(req
, ev
);
238 if (!isunlock
&& (in_lock_count
> 1)) {
241 * 3.3.5.14.2 says we SHOULD fail with INVALID_PARAMETER if we
242 * have more than one lock and one of those is blocking.
245 for (i
=0; i
<in_lock_count
; i
++) {
246 uint32_t flags
= in_locks
[i
].flags
;
248 if ((flags
& SMB2_LOCK_FLAG_FAIL_IMMEDIATELY
) == 0) {
250 req
, NT_STATUS_INVALID_PARAMETER
);
251 return tevent_req_post(req
, ev
);
256 for (i
=0; i
<in_lock_count
; i
++) {
257 bool invalid
= false;
259 switch (in_locks
[i
].flags
) {
260 case SMB2_LOCK_FLAG_SHARED
:
261 case SMB2_LOCK_FLAG_EXCLUSIVE
:
268 case SMB2_LOCK_FLAG_SHARED
|SMB2_LOCK_FLAG_FAIL_IMMEDIATELY
:
269 case SMB2_LOCK_FLAG_EXCLUSIVE
|SMB2_LOCK_FLAG_FAIL_IMMEDIATELY
:
275 case SMB2_LOCK_FLAG_UNLOCK
:
277 tevent_req_nterror(req
,
278 NT_STATUS_INVALID_PARAMETER
);
279 return tevent_req_post(req
, ev
);
286 * If the first element was a UNLOCK
287 * we need to defer the error response
288 * to the backend, because we need to process
289 * all unlock elements before
294 tevent_req_nterror(req
, NT_STATUS_INVALID_PARAMETER
);
295 return tevent_req_post(req
, ev
);
298 locks
[i
].smblctx
= fsp
->op
->global
->open_persistent_id
;
299 locks
[i
].offset
= in_locks
[i
].offset
;
300 locks
[i
].count
= in_locks
[i
].length
;
302 if (in_locks
[i
].flags
& SMB2_LOCK_FLAG_EXCLUSIVE
) {
303 locks
[i
].brltype
= WRITE_LOCK
;
304 } else if (in_locks
[i
].flags
& SMB2_LOCK_FLAG_SHARED
) {
305 locks
[i
].brltype
= READ_LOCK
;
306 } else if (invalid
) {
308 * this is an invalid UNLOCK element
309 * and the backend needs to test for
310 * brltype != UNLOCK_LOCK and return
311 * NT_STATUS_INVALID_PARAMER
313 locks
[i
].brltype
= READ_LOCK
;
315 locks
[i
].brltype
= UNLOCK_LOCK
;
318 DEBUG(10,("smbd_smb2_lock_send: index %d offset=%llu, count=%llu, "
319 "smblctx = %llu type %d\n",
321 (unsigned long long)locks
[i
].offset
,
322 (unsigned long long)locks
[i
].count
,
323 (unsigned long long)locks
[i
].smblctx
,
324 (int)locks
[i
].brltype
));
327 state
->locks
= locks
;
328 state
->lock_count
= in_lock_count
;
331 status
= smbd_do_locking(smb1req
, fsp
,
340 status
= smbd_do_locking(smb1req
, fsp
,
349 if (!NT_STATUS_IS_OK(status
)) {
350 if (NT_STATUS_EQUAL(status
, NT_STATUS_FILE_LOCK_CONFLICT
)) {
351 status
= NT_STATUS_LOCK_NOT_GRANTED
;
353 tevent_req_nterror(req
, status
);
354 return tevent_req_post(req
, ev
);
361 tevent_req_done(req
);
362 return tevent_req_post(req
, ev
);
365 static NTSTATUS
smbd_smb2_lock_recv(struct tevent_req
*req
)
369 if (tevent_req_is_nterror(req
, &status
)) {
370 tevent_req_received(req
);
374 tevent_req_received(req
);
378 /****************************************************************
379 Cancel an outstanding blocking lock request.
380 *****************************************************************/
382 static bool smbd_smb2_lock_cancel(struct tevent_req
*req
)
384 struct smbd_smb2_request
*smb2req
= NULL
;
385 struct smbd_smb2_lock_state
*state
= tevent_req_data(req
,
386 struct smbd_smb2_lock_state
);
391 if (!state
->smb2req
) {
395 smb2req
= state
->smb2req
;
397 remove_pending_lock(state
, state
->blr
);
398 tevent_req_defer_callback(req
, smb2req
->sconn
->ev_ctx
);
401 * If the request is canceled because of logoff, tdis or close
402 * the status is NT_STATUS_RANGE_NOT_LOCKED instead of
403 * NT_STATUS_CANCELLED.
405 * Note that the close case is handled in
406 * cancel_pending_lock_requests_by_fid_smb2(SHUTDOWN_CLOSE)
409 if (!NT_STATUS_IS_OK(smb2req
->session
->status
)) {
410 tevent_req_nterror(req
, NT_STATUS_RANGE_NOT_LOCKED
);
414 if (!NT_STATUS_IS_OK(smb2req
->tcon
->status
)) {
415 tevent_req_nterror(req
, NT_STATUS_RANGE_NOT_LOCKED
);
419 tevent_req_nterror(req
, NT_STATUS_CANCELLED
);
423 /****************************************************************
424 Got a message saying someone unlocked a file. Re-schedule all
425 blocking lock requests as we don't know if anything overlapped.
426 *****************************************************************/
428 static void received_unlock_msg(struct messaging_context
*msg
,
431 struct server_id server_id
,
434 struct smbd_server_connection
*sconn
=
435 talloc_get_type_abort(private_data
,
436 struct smbd_server_connection
);
438 DEBUG(10,("received_unlock_msg (SMB2)\n"));
440 process_blocking_lock_queue_smb2(sconn
, timeval_current());
443 /****************************************************************
444 Function to get the blr on a pending record.
445 *****************************************************************/
447 struct blocking_lock_record
*get_pending_smb2req_blr(struct smbd_smb2_request
*smb2req
)
449 struct smbd_smb2_lock_state
*state
= NULL
;
450 const uint8_t *inhdr
;
455 if (smb2req
->subreq
== NULL
) {
458 if (!tevent_req_is_in_progress(smb2req
->subreq
)) {
461 inhdr
= SMBD_SMB2_IN_HDR_PTR(smb2req
);
462 if (SVAL(inhdr
, SMB2_HDR_OPCODE
) != SMB2_OP_LOCK
) {
465 state
= tevent_req_data(smb2req
->subreq
,
466 struct smbd_smb2_lock_state
);
472 /****************************************************************
473 Set up the next brl timeout.
474 *****************************************************************/
476 static bool recalc_smb2_brl_timeout(struct smbd_server_connection
*sconn
)
478 struct smbd_smb2_request
*smb2req
;
479 struct timeval next_timeout
= timeval_zero();
480 int max_brl_timeout
= lp_parm_int(-1, "brl", "recalctime", 5);
482 TALLOC_FREE(sconn
->smb2
.locks
.brl_timeout
);
484 for (smb2req
= sconn
->smb2
.requests
; smb2req
; smb2req
= smb2req
->next
) {
485 struct blocking_lock_record
*blr
=
486 get_pending_smb2req_blr(smb2req
);
490 if (timeval_is_zero(&blr
->expire_time
)) {
492 * If we're blocked on pid 0xFFFFFFFFFFFFFFFFLL this is
493 * a POSIX lock, so calculate a timeout of
494 * 10 seconds into the future.
496 if (blr
->blocking_smblctx
== 0xFFFFFFFFFFFFFFFFLL
) {
497 struct timeval psx_to
= timeval_current_ofs(10, 0);
498 next_timeout
= timeval_brl_min(&next_timeout
, &psx_to
);
504 next_timeout
= timeval_brl_min(&next_timeout
, &blr
->expire_time
);
507 if (timeval_is_zero(&next_timeout
)) {
508 DEBUG(10, ("recalc_smb2_brl_timeout:Next "
509 "timeout = Infinite.\n"));
514 * To account for unclean shutdowns by clients we need a
515 * maximum timeout that we use for checking pending locks. If
516 * we have any pending locks at all, then check if the pending
517 * lock can continue at least every brl:recalctime seconds
518 * (default 5 seconds).
520 * This saves us needing to do a message_send_all() in the
521 * SIGCHLD handler in the parent daemon. That
522 * message_send_all() caused O(n^2) work to be done when IP
523 * failovers happened in clustered Samba, which could make the
524 * entire system unusable for many minutes.
527 if (max_brl_timeout
> 0) {
528 struct timeval min_to
= timeval_current_ofs(max_brl_timeout
, 0);
529 next_timeout
= timeval_brl_min(&next_timeout
, &min_to
);
533 struct timeval cur
, from_now
;
535 cur
= timeval_current();
536 from_now
= timeval_until(&cur
, &next_timeout
);
537 DEBUG(10, ("recalc_smb2_brl_timeout: Next "
538 "timeout = %d.%d seconds from now.\n",
539 (int)from_now
.tv_sec
, (int)from_now
.tv_usec
));
542 sconn
->smb2
.locks
.brl_timeout
= tevent_add_timer(
548 if (!sconn
->smb2
.locks
.brl_timeout
) {
554 /****************************************************************
555 Get an SMB2 lock request to go async. lock_timeout should
557 *****************************************************************/
559 bool push_blocking_lock_request_smb2( struct byte_range_lock
*br_lck
,
560 struct smb_request
*smb1req
,
565 enum brl_type lock_type
,
566 enum brl_flavour lock_flav
,
569 uint64_t blocking_smblctx
)
571 struct smbd_server_connection
*sconn
= smb1req
->sconn
;
572 struct smbd_smb2_request
*smb2req
= smb1req
->smb2req
;
573 struct tevent_req
*req
= NULL
;
574 struct smbd_smb2_lock_state
*state
= NULL
;
575 struct blocking_lock_record
*blr
= NULL
;
576 NTSTATUS status
= NT_STATUS_OK
;
581 req
= smb2req
->subreq
;
585 if (!tevent_req_is_in_progress(smb2req
->subreq
)) {
588 state
= tevent_req_data(req
, struct smbd_smb2_lock_state
);
593 blr
= talloc_zero(state
, struct blocking_lock_record
);
599 if (lock_timeout
== -1) {
600 blr
->expire_time
.tv_sec
= 0;
601 blr
->expire_time
.tv_usec
= 0; /* Never expire. */
603 blr
->expire_time
= timeval_current_ofs_msec(lock_timeout
);
606 blr
->lock_num
= lock_num
;
607 blr
->smblctx
= smblctx
;
608 blr
->blocking_smblctx
= blocking_smblctx
;
609 blr
->lock_flav
= lock_flav
;
610 blr
->lock_type
= lock_type
;
611 blr
->offset
= offset
;
614 /* Specific brl_lock() implementations can fill this in. */
615 blr
->blr_private
= NULL
;
617 /* Add a pending lock record for this. */
618 status
= brl_lock(sconn
->msg_ctx
,
621 messaging_server_id(sconn
->msg_ctx
),
624 lock_type
== READ_LOCK
? PENDING_READ_LOCK
: PENDING_WRITE_LOCK
,
630 if (!NT_STATUS_IS_OK(status
)) {
631 DEBUG(0,("push_blocking_lock_request_smb2: "
632 "failed to add PENDING_LOCK record.\n"));
638 DEBUG(10,("push_blocking_lock_request_smb2: file %s timeout %d\n",
642 recalc_smb2_brl_timeout(sconn
);
644 /* Ensure we'll receive messages when this is unlocked. */
645 if (!sconn
->smb2
.locks
.blocking_lock_unlock_state
) {
646 messaging_register(sconn
->msg_ctx
, sconn
,
647 MSG_SMB_UNLOCK
, received_unlock_msg
);
648 sconn
->smb2
.locks
.blocking_lock_unlock_state
= true;
651 /* allow this request to be canceled */
652 tevent_req_set_cancel_fn(req
, smbd_smb2_lock_cancel
);
657 /****************************************************************
658 Remove a pending lock record under lock.
659 *****************************************************************/
661 static void remove_pending_lock(struct smbd_smb2_lock_state
*state
,
662 struct blocking_lock_record
*blr
)
664 struct byte_range_lock
*br_lck
= brl_get_locks(
667 DEBUG(10, ("remove_pending_lock: BLR = %p\n", blr
));
670 brl_lock_cancel(br_lck
,
672 messaging_server_id(blr
->fsp
->conn
->sconn
->msg_ctx
),
681 /****************************************************************
682 Re-proccess a blocking lock request.
683 This is equivalent to process_lockingX() inside smbd/blocking.c
684 *****************************************************************/
686 static void reprocess_blocked_smb2_lock(struct smbd_smb2_request
*smb2req
,
687 struct timeval tv_curr
)
689 NTSTATUS status
= NT_STATUS_UNSUCCESSFUL
;
690 struct blocking_lock_record
*blr
= NULL
;
691 struct smbd_smb2_lock_state
*state
= NULL
;
692 struct byte_range_lock
*br_lck
= NULL
;
693 struct smbd_lock_element
*e
= NULL
;
694 files_struct
*fsp
= NULL
;
696 if (!smb2req
->subreq
) {
699 state
= tevent_req_data(smb2req
->subreq
, struct smbd_smb2_lock_state
);
707 /* We can only have one blocked lock in SMB2. */
708 SMB_ASSERT(state
->lock_count
== 1);
709 SMB_ASSERT(blr
->lock_num
== 0);
711 /* Try and get the outstanding lock. */
712 e
= &state
->locks
[blr
->lock_num
];
714 br_lck
= do_lock(fsp
->conn
->sconn
->msg_ctx
,
723 &blr
->blocking_smblctx
,
728 if (NT_STATUS_IS_OK(status
)) {
730 * Success - we got the lock.
733 DEBUG(3,("reprocess_blocked_smb2_lock SUCCESS file = %s, "
734 "%s, num_locks=%d\n",
737 (int)state
->lock_count
));
739 remove_pending_lock(state
, blr
);
740 tevent_req_done(smb2req
->subreq
);
744 if (!NT_STATUS_EQUAL(status
,NT_STATUS_LOCK_NOT_GRANTED
) &&
745 !NT_STATUS_EQUAL(status
,NT_STATUS_FILE_LOCK_CONFLICT
)) {
747 * We have other than a "can't get lock"
748 * error. Return an error.
750 remove_pending_lock(state
, blr
);
751 tevent_req_nterror(smb2req
->subreq
, status
);
756 * We couldn't get the lock for this record.
757 * If the time has expired, return a lock error.
760 if (!timeval_is_zero(&blr
->expire_time
) &&
761 timeval_compare(&blr
->expire_time
, &tv_curr
) <= 0) {
762 remove_pending_lock(state
, blr
);
763 tevent_req_nterror(smb2req
->subreq
, NT_STATUS_LOCK_NOT_GRANTED
);
768 * Still can't get the lock - keep waiting.
771 DEBUG(10,("reprocess_blocked_smb2_lock: failed to get lock "
772 "for file %s, %s. Still waiting....\n",
779 /****************************************************************
780 Attempt to proccess all outstanding blocking locks pending on
782 *****************************************************************/
784 void process_blocking_lock_queue_smb2(
785 struct smbd_server_connection
*sconn
, struct timeval tv_curr
)
787 struct smbd_smb2_request
*smb2req
, *nextreq
;
789 for (smb2req
= sconn
->smb2
.requests
; smb2req
; smb2req
= nextreq
) {
790 const uint8_t *inhdr
;
792 nextreq
= smb2req
->next
;
794 if (smb2req
->subreq
== NULL
) {
795 /* This message has been processed. */
798 if (!tevent_req_is_in_progress(smb2req
->subreq
)) {
799 /* This message has been processed. */
803 inhdr
= SMBD_SMB2_IN_HDR_PTR(smb2req
);
804 if (SVAL(inhdr
, SMB2_HDR_OPCODE
) == SMB2_OP_LOCK
) {
805 reprocess_blocked_smb2_lock(smb2req
, tv_curr
);
809 recalc_smb2_brl_timeout(sconn
);
812 /****************************************************************************
813 Remove any locks on this fd. Called from file_close().
814 ****************************************************************************/
816 void cancel_pending_lock_requests_by_fid_smb2(files_struct
*fsp
,
817 struct byte_range_lock
*br_lck
,
818 enum file_close_type close_type
)
820 struct smbd_server_connection
*sconn
= fsp
->conn
->sconn
;
821 struct smbd_smb2_request
*smb2req
, *nextreq
;
823 for (smb2req
= sconn
->smb2
.requests
; smb2req
; smb2req
= nextreq
) {
824 struct smbd_smb2_lock_state
*state
= NULL
;
825 files_struct
*fsp_curr
= NULL
;
826 struct blocking_lock_record
*blr
= NULL
;
827 const uint8_t *inhdr
;
829 nextreq
= smb2req
->next
;
831 if (smb2req
->subreq
== NULL
) {
832 /* This message has been processed. */
835 if (!tevent_req_is_in_progress(smb2req
->subreq
)) {
836 /* This message has been processed. */
840 inhdr
= SMBD_SMB2_IN_HDR_PTR(smb2req
);
841 if (SVAL(inhdr
, SMB2_HDR_OPCODE
) != SMB2_OP_LOCK
) {
842 /* Not a lock call. */
846 state
= tevent_req_data(smb2req
->subreq
,
847 struct smbd_smb2_lock_state
);
849 /* Strange - is this even possible ? */
853 fsp_curr
= smb2req
->compat_chain_fsp
;
854 if (fsp_curr
== NULL
) {
855 /* Strange - is this even possible ? */
859 if (fsp_curr
!= fsp
) {
860 /* It's not our fid */
866 /* Remove the entries from the lock db. */
867 brl_lock_cancel(br_lck
,
869 messaging_server_id(sconn
->msg_ctx
),
875 /* Finally end the request. */
876 if (close_type
== SHUTDOWN_CLOSE
) {
877 tevent_req_done(smb2req
->subreq
);
879 tevent_req_nterror(smb2req
->subreq
,
880 NT_STATUS_RANGE_NOT_LOCKED
);