source: vendor/3.6.0/source3/smbd/smb2_lock.c

Last change on this file was 740, checked in by Silvan Scherrer, 13 years ago

Samba Server: update vendor to 3.6.0
File size: 24.9 KB
Line 
1/*
2 Unix SMB/CIFS implementation.
3 Core SMB2 server
4
5 Copyright (C) Stefan Metzmacher 2009
6 Copyright (C) Jeremy Allison 2010
7
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.
12
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.
17
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/>.
20*/
21
22#include "includes.h"
23#include "smbd/smbd.h"
24#include "smbd/globals.h"
25#include "../libcli/smb/smb_common.h"
26#include "../lib/util/tevent_ntstatus.h"
27#include "messages.h"
28
29struct smbd_smb2_lock_element {
30 uint64_t offset;
31 uint64_t length;
32 uint32_t flags;
33};
34
35struct smbd_smb2_lock_state {
36 struct smbd_smb2_request *smb2req;
37 struct smb_request *smb1req;
38 struct blocking_lock_record *blr;
39 uint16_t lock_count;
40 struct smbd_lock_element *locks;
41};
42
43static void remove_pending_lock(struct smbd_smb2_lock_state *state,
44 struct blocking_lock_record *blr);
45
46static struct tevent_req *smbd_smb2_lock_send(TALLOC_CTX *mem_ctx,
47 struct tevent_context *ev,
48 struct smbd_smb2_request *smb2req,
49 uint32_t in_smbpid,
50 uint64_t in_file_id_volatile,
51 uint16_t in_lock_count,
52 struct smbd_smb2_lock_element *in_locks);
53static NTSTATUS smbd_smb2_lock_recv(struct tevent_req *req);
54
55static void smbd_smb2_request_lock_done(struct tevent_req *subreq);
56NTSTATUS smbd_smb2_request_process_lock(struct smbd_smb2_request *req)
57{
58 const uint8_t *inhdr;
59 const uint8_t *inbody;
60 const int i = req->current_idx;
61 size_t expected_body_size = 0x30;
62 size_t body_size;
63 uint32_t in_smbpid;
64 uint16_t in_lock_count;
65 uint64_t in_file_id_persistent;
66 uint64_t in_file_id_volatile;
67 struct smbd_smb2_lock_element *in_locks;
68 struct tevent_req *subreq;
69 const uint8_t *lock_buffer;
70 uint16_t l;
71
72 inhdr = (const uint8_t *)req->in.vector[i+0].iov_base;
73 if (req->in.vector[i+1].iov_len != (expected_body_size & 0xFFFFFFFE)) {
74 return smbd_smb2_request_error(req, NT_STATUS_INVALID_PARAMETER);
75 }
76
77 inbody = (const uint8_t *)req->in.vector[i+1].iov_base;
78
79 body_size = SVAL(inbody, 0x00);
80 if (body_size != expected_body_size) {
81 return smbd_smb2_request_error(req, NT_STATUS_INVALID_PARAMETER);
82 }
83
84 in_smbpid = IVAL(inhdr, SMB2_HDR_PID);
85
86 in_lock_count = CVAL(inbody, 0x02);
87 /* 0x04 - 4 bytes reserved */
88 in_file_id_persistent = BVAL(inbody, 0x08);
89 in_file_id_volatile = BVAL(inbody, 0x10);
90
91 if (in_lock_count < 1) {
92 return smbd_smb2_request_error(req, NT_STATUS_INVALID_PARAMETER);
93 }
94
95 if (((in_lock_count - 1) * 0x18) > req->in.vector[i+2].iov_len) {
96 return smbd_smb2_request_error(req, NT_STATUS_INVALID_PARAMETER);
97 }
98
99 if (req->compat_chain_fsp) {
100 /* skip check */
101 } else if (in_file_id_persistent != in_file_id_volatile) {
102 return smbd_smb2_request_error(req, NT_STATUS_FILE_CLOSED);
103 }
104
105 in_locks = talloc_array(req, struct smbd_smb2_lock_element,
106 in_lock_count);
107 if (in_locks == NULL) {
108 return smbd_smb2_request_error(req, NT_STATUS_NO_MEMORY);
109 }
110
111 l = 0;
112 lock_buffer = inbody + 0x18;
113
114 in_locks[l].offset = BVAL(lock_buffer, 0x00);
115 in_locks[l].length = BVAL(lock_buffer, 0x08);
116 in_locks[l].flags = IVAL(lock_buffer, 0x10);
117 /* 0x14 - 4 reserved bytes */
118
119 lock_buffer = (const uint8_t *)req->in.vector[i+2].iov_base;
120
121 for (l=1; l < in_lock_count; l++) {
122 in_locks[l].offset = BVAL(lock_buffer, 0x00);
123 in_locks[l].length = BVAL(lock_buffer, 0x08);
124 in_locks[l].flags = IVAL(lock_buffer, 0x10);
125 /* 0x14 - 4 reserved bytes */
126
127 lock_buffer += 0x18;
128 }
129
130 subreq = smbd_smb2_lock_send(req,
131 req->sconn->smb2.event_ctx,
132 req,
133 in_smbpid,
134 in_file_id_volatile,
135 in_lock_count,
136 in_locks);
137 if (subreq == NULL) {
138 return smbd_smb2_request_error(req, NT_STATUS_NO_MEMORY);
139 }
140 tevent_req_set_callback(subreq, smbd_smb2_request_lock_done, req);
141
142 return smbd_smb2_request_pending_queue(req, subreq);
143}
144
145static void smbd_smb2_request_lock_done(struct tevent_req *subreq)
146{
147 struct smbd_smb2_request *smb2req = tevent_req_callback_data(subreq,
148 struct smbd_smb2_request);
149 DATA_BLOB outbody;
150 NTSTATUS status;
151 NTSTATUS error; /* transport error */
152
153 if (smb2req->cancelled) {
154 const uint8_t *inhdr = (const uint8_t *)
155 smb2req->in.vector[smb2req->current_idx].iov_base;
156 uint64_t mid = BVAL(inhdr, SMB2_HDR_MESSAGE_ID);
157 struct smbd_smb2_lock_state *state;
158
159 DEBUG(10,("smbd_smb2_request_lock_done: cancelled mid %llu\n",
160 (unsigned long long)mid ));
161
162 state = tevent_req_data(smb2req->subreq,
163 struct smbd_smb2_lock_state);
164
165 SMB_ASSERT(state);
166 SMB_ASSERT(state->blr);
167
168 remove_pending_lock(state, state->blr);
169
170 error = smbd_smb2_request_error(smb2req, NT_STATUS_CANCELLED);
171 if (!NT_STATUS_IS_OK(error)) {
172 smbd_server_connection_terminate(smb2req->sconn,
173 nt_errstr(error));
174 return;
175 }
176 return;
177 }
178
179 status = smbd_smb2_lock_recv(subreq);
180 TALLOC_FREE(subreq);
181 if (!NT_STATUS_IS_OK(status)) {
182 error = smbd_smb2_request_error(smb2req, status);
183 if (!NT_STATUS_IS_OK(error)) {
184 smbd_server_connection_terminate(smb2req->sconn,
185 nt_errstr(error));
186 return;
187 }
188 return;
189 }
190
191 outbody = data_blob_talloc(smb2req->out.vector, NULL, 0x04);
192 if (outbody.data == NULL) {
193 error = smbd_smb2_request_error(smb2req, NT_STATUS_NO_MEMORY);
194 if (!NT_STATUS_IS_OK(error)) {
195 smbd_server_connection_terminate(smb2req->sconn,
196 nt_errstr(error));
197 return;
198 }
199 return;
200 }
201
202 SSVAL(outbody.data, 0x00, 0x04); /* struct size */
203 SSVAL(outbody.data, 0x02, 0); /* reserved */
204
205 error = smbd_smb2_request_done(smb2req, outbody, NULL);
206 if (!NT_STATUS_IS_OK(error)) {
207 smbd_server_connection_terminate(smb2req->sconn,
208 nt_errstr(error));
209 return;
210 }
211}
212
213static struct tevent_req *smbd_smb2_lock_send(TALLOC_CTX *mem_ctx,
214 struct tevent_context *ev,
215 struct smbd_smb2_request *smb2req,
216 uint32_t in_smbpid,
217 uint64_t in_file_id_volatile,
218 uint16_t in_lock_count,
219 struct smbd_smb2_lock_element *in_locks)
220{
221 struct tevent_req *req;
222 struct smbd_smb2_lock_state *state;
223 struct smb_request *smb1req;
224 connection_struct *conn = smb2req->tcon->compat_conn;
225 files_struct *fsp;
226 int32_t timeout = -1;
227 bool isunlock = false;
228 uint16_t i;
229 struct smbd_lock_element *locks;
230 NTSTATUS status;
231 bool async = false;
232
233 req = tevent_req_create(mem_ctx, &state,
234 struct smbd_smb2_lock_state);
235 if (req == NULL) {
236 return NULL;
237 }
238 state->smb2req = smb2req;
239 smb2req->subreq = req; /* So we can find this when going async. */
240
241 smb1req = smbd_smb2_fake_smb_request(smb2req);
242 if (tevent_req_nomem(smb1req, req)) {
243 return tevent_req_post(req, ev);
244 }
245 state->smb1req = smb1req;
246
247 DEBUG(10,("smbd_smb2_lock_send: file_id[0x%016llX]\n",
248 (unsigned long long)in_file_id_volatile));
249
250 fsp = file_fsp(smb1req, (uint16_t)in_file_id_volatile);
251 if (fsp == NULL) {
252 tevent_req_nterror(req, NT_STATUS_FILE_CLOSED);
253 return tevent_req_post(req, ev);
254 }
255 if (conn != fsp->conn) {
256 tevent_req_nterror(req, NT_STATUS_FILE_CLOSED);
257 return tevent_req_post(req, ev);
258 }
259 if (smb2req->session->vuid != fsp->vuid) {
260 tevent_req_nterror(req, NT_STATUS_FILE_CLOSED);
261 return tevent_req_post(req, ev);
262 }
263
264 locks = talloc_array(state, struct smbd_lock_element, in_lock_count);
265 if (locks == NULL) {
266 tevent_req_nterror(req, NT_STATUS_NO_MEMORY);
267 return tevent_req_post(req, ev);
268 }
269
270 switch (in_locks[0].flags) {
271 case SMB2_LOCK_FLAG_SHARED:
272 case SMB2_LOCK_FLAG_EXCLUSIVE:
273 if (in_lock_count > 1) {
274 tevent_req_nterror(req, NT_STATUS_INVALID_PARAMETER);
275 return tevent_req_post(req, ev);
276 }
277 timeout = -1;
278 break;
279
280 case SMB2_LOCK_FLAG_SHARED|SMB2_LOCK_FLAG_FAIL_IMMEDIATELY:
281 case SMB2_LOCK_FLAG_EXCLUSIVE|SMB2_LOCK_FLAG_FAIL_IMMEDIATELY:
282 timeout = 0;
283 break;
284
285 case SMB2_LOCK_FLAG_UNLOCK:
286 /* only the first lock gives the UNLOCK bit - see
287 MS-SMB2 3.3.5.14 */
288 isunlock = true;
289 timeout = 0;
290 break;
291
292 default:
293 tevent_req_nterror(req, NT_STATUS_INVALID_PARAMETER);
294 return tevent_req_post(req, ev);
295 }
296
297 for (i=0; i<in_lock_count; i++) {
298 bool invalid = false;
299
300 switch (in_locks[i].flags) {
301 case SMB2_LOCK_FLAG_SHARED:
302 case SMB2_LOCK_FLAG_EXCLUSIVE:
303 if (isunlock) {
304 invalid = true;
305 break;
306 }
307 if (i > 0) {
308 tevent_req_nterror(req,
309 NT_STATUS_INVALID_PARAMETER);
310 return tevent_req_post(req, ev);
311 }
312 break;
313
314 case SMB2_LOCK_FLAG_SHARED|SMB2_LOCK_FLAG_FAIL_IMMEDIATELY:
315 case SMB2_LOCK_FLAG_EXCLUSIVE|SMB2_LOCK_FLAG_FAIL_IMMEDIATELY:
316 if (isunlock) {
317 invalid = true;
318 }
319 break;
320
321 case SMB2_LOCK_FLAG_UNLOCK:
322 if (!isunlock) {
323 tevent_req_nterror(req,
324 NT_STATUS_INVALID_PARAMETER);
325 return tevent_req_post(req, ev);
326 }
327 break;
328
329 default:
330 if (isunlock) {
331 /*
332 * is the first element was a UNLOCK
333 * we need to deferr the error response
334 * to the backend, because we need to process
335 * all unlock elements before
336 */
337 invalid = true;
338 break;
339 }
340 tevent_req_nterror(req, NT_STATUS_INVALID_PARAMETER);
341 return tevent_req_post(req, ev);
342 }
343
344 locks[i].smblctx = in_file_id_volatile;
345 locks[i].offset = in_locks[i].offset;
346 locks[i].count = in_locks[i].length;
347
348 if (in_locks[i].flags & SMB2_LOCK_FLAG_EXCLUSIVE) {
349 locks[i].brltype = WRITE_LOCK;
350 } else if (in_locks[i].flags & SMB2_LOCK_FLAG_SHARED) {
351 locks[i].brltype = READ_LOCK;
352 } else if (invalid) {
353 /*
354 * this is an invalid UNLOCK element
355 * and the backend needs to test for
356 * brltype != UNLOCK_LOCK and return
357 * NT_STATUS_INVALID_PARAMER
358 */
359 locks[i].brltype = READ_LOCK;
360 } else {
361 locks[i].brltype = UNLOCK_LOCK;
362 }
363
364 DEBUG(10,("smbd_smb2_lock_send: index %d offset=%llu, count=%llu, "
365 "smblctx = %llu type %d\n",
366 i,
367 (unsigned long long)locks[i].offset,
368 (unsigned long long)locks[i].count,
369 (unsigned long long)locks[i].smblctx,
370 (int)locks[i].brltype ));
371 }
372
373 state->locks = locks;
374 state->lock_count = in_lock_count;
375
376 if (isunlock) {
377 status = smbd_do_locking(smb1req, fsp,
378 0,
379 timeout,
380 in_lock_count,
381 locks,
382 0,
383 NULL,
384 &async);
385 } else {
386 status = smbd_do_locking(smb1req, fsp,
387 0,
388 timeout,
389 0,
390 NULL,
391 in_lock_count,
392 locks,
393 &async);
394 }
395 if (!NT_STATUS_IS_OK(status)) {
396 if (NT_STATUS_EQUAL(status, NT_STATUS_FILE_LOCK_CONFLICT)) {
397 status = NT_STATUS_LOCK_NOT_GRANTED;
398 }
399 tevent_req_nterror(req, status);
400 return tevent_req_post(req, ev);
401 }
402
403 if (async) {
404 return req;
405 }
406
407 tevent_req_done(req);
408 return tevent_req_post(req, ev);
409}
410
411static NTSTATUS smbd_smb2_lock_recv(struct tevent_req *req)
412{
413 NTSTATUS status;
414
415 if (tevent_req_is_nterror(req, &status)) {
416 tevent_req_received(req);
417 return status;
418 }
419
420 tevent_req_received(req);
421 return NT_STATUS_OK;
422}
423
424/****************************************************************
425 Cancel an outstanding blocking lock request.
426*****************************************************************/
427
428static bool smbd_smb2_lock_cancel(struct tevent_req *req)
429{
430 struct smbd_smb2_request *smb2req = NULL;
431 struct smbd_smb2_lock_state *state = tevent_req_data(req,
432 struct smbd_smb2_lock_state);
433 if (!state) {
434 return false;
435 }
436
437 if (!state->smb2req) {
438 return false;
439 }
440
441 smb2req = state->smb2req;
442 smb2req->cancelled = true;
443
444 tevent_req_done(req);
445 return true;
446}
447
448/****************************************************************
449 Got a message saying someone unlocked a file. Re-schedule all
450 blocking lock requests as we don't know if anything overlapped.
451*****************************************************************/
452
453static void received_unlock_msg(struct messaging_context *msg,
454 void *private_data,
455 uint32_t msg_type,
456 struct server_id server_id,
457 DATA_BLOB *data)
458{
459 struct smbd_server_connection *sconn;
460
461 DEBUG(10,("received_unlock_msg (SMB2)\n"));
462
463 sconn = msg_ctx_to_sconn(msg);
464 if (sconn == NULL) {
465 DEBUG(1, ("could not find sconn\n"));
466 return;
467 }
468 process_blocking_lock_queue_smb2(sconn, timeval_current());
469}
470
471/****************************************************************
472 Function to get the blr on a pending record.
473*****************************************************************/
474
475struct blocking_lock_record *get_pending_smb2req_blr(struct smbd_smb2_request *smb2req)
476{
477 struct smbd_smb2_lock_state *state = NULL;
478 const uint8_t *inhdr;
479
480 if (!smb2req) {
481 return NULL;
482 }
483 if (smb2req->subreq == NULL) {
484 return NULL;
485 }
486 if (!tevent_req_is_in_progress(smb2req->subreq)) {
487 return NULL;
488 }
489 inhdr = (const uint8_t *)smb2req->in.vector[smb2req->current_idx].iov_base;
490 if (SVAL(inhdr, SMB2_HDR_OPCODE) != SMB2_OP_LOCK) {
491 return NULL;
492 }
493 state = tevent_req_data(smb2req->subreq,
494 struct smbd_smb2_lock_state);
495 if (!state) {
496 return NULL;
497 }
498 return state->blr;
499}
500/****************************************************************
501 Set up the next brl timeout.
502*****************************************************************/
503
504static bool recalc_smb2_brl_timeout(struct smbd_server_connection *sconn)
505{
506 struct smbd_smb2_request *smb2req;
507 struct timeval next_timeout = timeval_zero();
508 int max_brl_timeout = lp_parm_int(-1, "brl", "recalctime", 5);
509
510 TALLOC_FREE(sconn->smb2.locks.brl_timeout);
511
512 for (smb2req = sconn->smb2.requests; smb2req; smb2req = smb2req->next) {
513 struct blocking_lock_record *blr =
514 get_pending_smb2req_blr(smb2req);
515 if (!blr) {
516 continue;
517 }
518 if (timeval_is_zero(&blr->expire_time)) {
519 /*
520 * If we're blocked on pid 0xFFFFFFFFFFFFFFFFLL this is
521 * a POSIX lock, so calculate a timeout of
522 * 10 seconds into the future.
523 */
524 if (blr->blocking_smblctx == 0xFFFFFFFFFFFFFFFFLL) {
525 struct timeval psx_to = timeval_current_ofs(10, 0);
526 next_timeout = timeval_brl_min(&next_timeout, &psx_to);
527 }
528
529 continue;
530 }
531
532 next_timeout = timeval_brl_min(&next_timeout, &blr->expire_time);
533 }
534
535 if (timeval_is_zero(&next_timeout)) {
536 DEBUG(10, ("recalc_smb2_brl_timeout:Next "
537 "timeout = Infinite.\n"));
538 return true;
539 }
540
541 /*
542 * To account for unclean shutdowns by clients we need a
543 * maximum timeout that we use for checking pending locks. If
544 * we have any pending locks at all, then check if the pending
545 * lock can continue at least every brl:recalctime seconds
546 * (default 5 seconds).
547 *
548 * This saves us needing to do a message_send_all() in the
549 * SIGCHLD handler in the parent daemon. That
550 * message_send_all() caused O(n^2) work to be done when IP
551 * failovers happened in clustered Samba, which could make the
552 * entire system unusable for many minutes.
553 */
554
555 if (max_brl_timeout > 0) {
556 struct timeval min_to = timeval_current_ofs(max_brl_timeout, 0);
557 next_timeout = timeval_brl_min(&next_timeout, &min_to);
558 }
559
560 if (DEBUGLVL(10)) {
561 struct timeval cur, from_now;
562
563 cur = timeval_current();
564 from_now = timeval_until(&cur, &next_timeout);
565 DEBUG(10, ("recalc_smb2_brl_timeout: Next "
566 "timeout = %d.%d seconds from now.\n",
567 (int)from_now.tv_sec, (int)from_now.tv_usec));
568 }
569
570 sconn->smb2.locks.brl_timeout = event_add_timed(
571 smbd_event_context(),
572 NULL,
573 next_timeout,
574 brl_timeout_fn,
575 NULL);
576 if (!sconn->smb2.locks.brl_timeout) {
577 return false;
578 }
579 return true;
580}
581
582/****************************************************************
583 Get an SMB2 lock reqeust to go async. lock_timeout should
584 always be -1 here.
585*****************************************************************/
586
587bool push_blocking_lock_request_smb2( struct byte_range_lock *br_lck,
588 struct smb_request *smb1req,
589 files_struct *fsp,
590 int lock_timeout,
591 int lock_num,
592 uint64_t smblctx,
593 enum brl_type lock_type,
594 enum brl_flavour lock_flav,
595 uint64_t offset,
596 uint64_t count,
597 uint64_t blocking_smblctx)
598{
599 struct smbd_server_connection *sconn = smb1req->sconn;
600 struct smbd_smb2_request *smb2req = smb1req->smb2req;
601 struct tevent_req *req = NULL;
602 struct smbd_smb2_lock_state *state = NULL;
603 struct blocking_lock_record *blr = NULL;
604 NTSTATUS status = NT_STATUS_OK;
605
606 if (!smb2req) {
607 return false;
608 }
609 req = smb2req->subreq;
610 if (!req) {
611 return false;
612 }
613 if (!tevent_req_is_in_progress(smb2req->subreq)) {
614 return false;
615 }
616 state = tevent_req_data(req, struct smbd_smb2_lock_state);
617 if (!state) {
618 return false;
619 }
620
621 blr = talloc_zero(state, struct blocking_lock_record);
622 if (!blr) {
623 return false;
624 }
625 blr->fsp = fsp;
626
627 if (lock_timeout == -1) {
628 blr->expire_time.tv_sec = 0;
629 blr->expire_time.tv_usec = 0; /* Never expire. */
630 } else {
631 blr->expire_time = timeval_current_ofs(
632 lock_timeout/1000,
633 (lock_timeout % 1000) * 1000);
634 }
635
636 blr->lock_num = lock_num;
637 blr->smblctx = smblctx;
638 blr->blocking_smblctx = blocking_smblctx;
639 blr->lock_flav = lock_flav;
640 blr->lock_type = lock_type;
641 blr->offset = offset;
642 blr->count = count;
643
644 /* Specific brl_lock() implementations can fill this in. */
645 blr->blr_private = NULL;
646
647 /* Add a pending lock record for this. */
648 status = brl_lock(sconn->msg_ctx,
649 br_lck,
650 smblctx,
651 sconn_server_id(sconn),
652 offset,
653 count,
654 lock_type == READ_LOCK ? PENDING_READ_LOCK : PENDING_WRITE_LOCK,
655 blr->lock_flav,
656 true,
657 NULL,
658 blr);
659
660 if (!NT_STATUS_IS_OK(status)) {
661 DEBUG(0,("push_blocking_lock_request_smb2: "
662 "failed to add PENDING_LOCK record.\n"));
663 TALLOC_FREE(blr);
664 return false;
665 }
666 state->blr = blr;
667
668 DEBUG(10,("push_blocking_lock_request_smb2: file %s timeout %d\n",
669 fsp_str_dbg(fsp),
670 lock_timeout ));
671
672 recalc_smb2_brl_timeout(sconn);
673
674 /* Ensure we'll receive messages when this is unlocked. */
675 if (!sconn->smb2.locks.blocking_lock_unlock_state) {
676 messaging_register(sconn->msg_ctx, NULL,
677 MSG_SMB_UNLOCK, received_unlock_msg);
678 sconn->smb2.locks.blocking_lock_unlock_state = true;
679 }
680
681 /* allow this request to be canceled */
682 tevent_req_set_cancel_fn(req, smbd_smb2_lock_cancel);
683
684 return true;
685}
686
687/****************************************************************
688 Remove a pending lock record under lock.
689*****************************************************************/
690
691static void remove_pending_lock(struct smbd_smb2_lock_state *state,
692 struct blocking_lock_record *blr)
693{
694 int i;
695 struct byte_range_lock *br_lck = brl_get_locks(
696 state, blr->fsp);
697
698 DEBUG(10, ("remove_pending_lock: BLR = %p\n", blr));
699
700 if (br_lck) {
701 brl_lock_cancel(br_lck,
702 blr->smblctx,
703 sconn_server_id(blr->fsp->conn->sconn),
704 blr->offset,
705 blr->count,
706 blr->lock_flav,
707 blr);
708 TALLOC_FREE(br_lck);
709 }
710
711 /* Remove the locks we already got. */
712
713 for(i = blr->lock_num - 1; i >= 0; i--) {
714 struct smbd_lock_element *e = &state->locks[i];
715
716 do_unlock(blr->fsp->conn->sconn->msg_ctx,
717 blr->fsp,
718 e->smblctx,
719 e->count,
720 e->offset,
721 WINDOWS_LOCK);
722 }
723}
724
725/****************************************************************
726 Re-proccess a blocking lock request.
727 This is equivalent to process_lockingX() inside smbd/blocking.c
728*****************************************************************/
729
730static void reprocess_blocked_smb2_lock(struct smbd_smb2_request *smb2req,
731 struct timeval tv_curr)
732{
733 NTSTATUS status = NT_STATUS_UNSUCCESSFUL;
734 struct blocking_lock_record *blr = NULL;
735 struct smbd_smb2_lock_state *state = NULL;
736 files_struct *fsp = NULL;
737
738 if (!smb2req->subreq) {
739 return;
740 }
741 state = tevent_req_data(smb2req->subreq, struct smbd_smb2_lock_state);
742 if (!state) {
743 return;
744 }
745
746 blr = state->blr;
747 fsp = blr->fsp;
748
749 /* Try and finish off getting all the outstanding locks. */
750
751 for (; blr->lock_num < state->lock_count; blr->lock_num++) {
752 struct byte_range_lock *br_lck = NULL;
753 struct smbd_lock_element *e = &state->locks[blr->lock_num];
754
755 br_lck = do_lock(fsp->conn->sconn->msg_ctx,
756 fsp,
757 e->smblctx,
758 e->count,
759 e->offset,
760 e->brltype,
761 WINDOWS_LOCK,
762 true,
763 &status,
764 &blr->blocking_smblctx,
765 blr);
766
767 TALLOC_FREE(br_lck);
768
769 if (NT_STATUS_IS_ERR(status)) {
770 break;
771 }
772 }
773
774 if(blr->lock_num == state->lock_count) {
775 /*
776 * Success - we got all the locks.
777 */
778
779 DEBUG(3,("reprocess_blocked_smb2_lock SUCCESS file = %s, "
780 "fnum=%d num_locks=%d\n",
781 fsp_str_dbg(fsp),
782 fsp->fnum,
783 (int)state->lock_count));
784
785 tevent_req_done(smb2req->subreq);
786 return;
787 }
788
789 if (!NT_STATUS_EQUAL(status,NT_STATUS_LOCK_NOT_GRANTED) &&
790 !NT_STATUS_EQUAL(status,NT_STATUS_FILE_LOCK_CONFLICT)) {
791 /*
792 * We have other than a "can't get lock"
793 * error. Return an error.
794 */
795 remove_pending_lock(state, blr);
796 tevent_req_nterror(smb2req->subreq, status);
797 return;
798 }
799
800 /*
801 * We couldn't get the locks for this record on the list.
802 * If the time has expired, return a lock error.
803 */
804
805 if (!timeval_is_zero(&blr->expire_time) &&
806 timeval_compare(&blr->expire_time, &tv_curr) <= 0) {
807 remove_pending_lock(state, blr);
808 tevent_req_nterror(smb2req->subreq, NT_STATUS_LOCK_NOT_GRANTED);
809 return;
810 }
811
812 /*
813 * Still can't get all the locks - keep waiting.
814 */
815
816 DEBUG(10,("reprocess_blocked_smb2_lock: only got %d locks of %d needed "
817 "for file %s, fnum = %d. Still waiting....\n",
818 (int)blr->lock_num,
819 (int)state->lock_count,
820 fsp_str_dbg(fsp),
821 (int)fsp->fnum));
822
823 return;
824
825}
826
827/****************************************************************
828 Attempt to proccess all outstanding blocking locks pending on
829 the request queue.
830*****************************************************************/
831
832void process_blocking_lock_queue_smb2(
833 struct smbd_server_connection *sconn, struct timeval tv_curr)
834{
835 struct smbd_smb2_request *smb2req, *nextreq;
836
837 for (smb2req = sconn->smb2.requests; smb2req; smb2req = nextreq) {
838 const uint8_t *inhdr;
839
840 nextreq = smb2req->next;
841
842 if (smb2req->subreq == NULL) {
843 /* This message has been processed. */
844 continue;
845 }
846 if (!tevent_req_is_in_progress(smb2req->subreq)) {
847 /* This message has been processed. */
848 continue;
849 }
850
851 inhdr = (const uint8_t *)smb2req->in.vector[smb2req->current_idx].iov_base;
852 if (SVAL(inhdr, SMB2_HDR_OPCODE) == SMB2_OP_LOCK) {
853 reprocess_blocked_smb2_lock(smb2req, tv_curr);
854 }
855 }
856
857 recalc_smb2_brl_timeout(sconn);
858}
859
860/****************************************************************************
861 Remove any locks on this fd. Called from file_close().
862****************************************************************************/
863
864void cancel_pending_lock_requests_by_fid_smb2(files_struct *fsp,
865 struct byte_range_lock *br_lck,
866 enum file_close_type close_type)
867{
868 struct smbd_server_connection *sconn = fsp->conn->sconn;
869 struct smbd_smb2_request *smb2req, *nextreq;
870
871 for (smb2req = sconn->smb2.requests; smb2req; smb2req = nextreq) {
872 struct smbd_smb2_lock_state *state = NULL;
873 files_struct *fsp_curr = NULL;
874 int i = smb2req->current_idx;
875 uint64_t in_file_id_volatile;
876 struct blocking_lock_record *blr = NULL;
877 const uint8_t *inhdr;
878 const uint8_t *inbody;
879
880 nextreq = smb2req->next;
881
882 if (smb2req->subreq == NULL) {
883 /* This message has been processed. */
884 continue;
885 }
886 if (!tevent_req_is_in_progress(smb2req->subreq)) {
887 /* This message has been processed. */
888 continue;
889 }
890
891 inhdr = (const uint8_t *)smb2req->in.vector[i].iov_base;
892 if (SVAL(inhdr, SMB2_HDR_OPCODE) != SMB2_OP_LOCK) {
893 /* Not a lock call. */
894 continue;
895 }
896
897 inbody = (const uint8_t *)smb2req->in.vector[i+1].iov_base;
898 in_file_id_volatile = BVAL(inbody, 0x10);
899
900 state = tevent_req_data(smb2req->subreq,
901 struct smbd_smb2_lock_state);
902 if (!state) {
903 /* Strange - is this even possible ? */
904 continue;
905 }
906
907 fsp_curr = file_fsp(state->smb1req, (uint16_t)in_file_id_volatile);
908 if (fsp_curr == NULL) {
909 /* Strange - is this even possible ? */
910 continue;
911 }
912
913 if (fsp_curr != fsp) {
914 /* It's not our fid */
915 continue;
916 }
917
918 blr = state->blr;
919
920 /* Remove the entries from the lock db. */
921 brl_lock_cancel(br_lck,
922 blr->smblctx,
923 sconn_server_id(sconn),
924 blr->offset,
925 blr->count,
926 blr->lock_flav,
927 blr);
928
929 /* Finally end the request. */
930 if (close_type == SHUTDOWN_CLOSE) {
931 tevent_req_done(smb2req->subreq);
932 } else {
933 tevent_req_nterror(smb2req->subreq,
934 NT_STATUS_RANGE_NOT_LOCKED);
935 }
936 }
937}
Note: See TracBrowser for help on using the repository browser.