Fix many const compiler warnings.
[nivanova/samba-autobuild/.git] / source3 / smbd / blocking.c
1 /* 
2    Unix SMB/CIFS implementation.
3    Blocking Locking functions
4    Copyright (C) Jeremy Allison 1998-2003
5
6    This program is free software; you can redistribute it and/or modify
7    it under the terms of the GNU General Public License as published by
8    the Free Software Foundation; either version 3 of the License, or
9    (at your option) any later version.
10
11    This program is distributed in the hope that it will be useful,
12    but WITHOUT ANY WARRANTY; without even the implied warranty of
13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14    GNU General Public License for more details.
15
16    You should have received a copy of the GNU General Public License
17    along with this program.  If not, see <http://www.gnu.org/licenses/>.
18 */
19
20 #include "includes.h"
21 #include "smbd/smbd.h"
22 #include "smbd/globals.h"
23 #include "messages.h"
24
25 #undef DBGC_CLASS
26 #define DBGC_CLASS DBGC_LOCKING
27
28 /****************************************************************************
29  Determine if this is a secondary element of a chained SMB.
30   **************************************************************************/
31
32 static void received_unlock_msg(struct messaging_context *msg,
33                                 void *private_data,
34                                 uint32_t msg_type,
35                                 struct server_id server_id,
36                                 DATA_BLOB *data);
37
38 void brl_timeout_fn(struct event_context *event_ctx,
39                            struct timed_event *te,
40                            struct timeval now,
41                            void *private_data)
42 {
43         struct smbd_server_connection *sconn = talloc_get_type_abort(
44                 private_data, struct smbd_server_connection);
45
46         if (sconn->using_smb2) {
47                 SMB_ASSERT(sconn->smb2.locks.brl_timeout == te);
48                 TALLOC_FREE(sconn->smb2.locks.brl_timeout);
49         } else {
50                 SMB_ASSERT(sconn->smb1.locks.brl_timeout == te);
51                 TALLOC_FREE(sconn->smb1.locks.brl_timeout);
52         }
53
54         change_to_root_user();  /* TODO: Possibly run all timed events as
55                                  * root */
56
57         process_blocking_lock_queue(sconn);
58 }
59
60 /****************************************************************************
61  We need a version of timeval_min that treats zero timval as infinite.
62 ****************************************************************************/
63
64 struct timeval timeval_brl_min(const struct timeval *tv1,
65                                         const struct timeval *tv2)
66 {
67         if (timeval_is_zero(tv1)) {
68                 return *tv2;
69         }
70         if (timeval_is_zero(tv2)) {
71                 return *tv1;
72         }
73         return timeval_min(tv1, tv2);
74 }
75
76 /****************************************************************************
77  After a change to blocking_lock_queue, recalculate the timed_event for the
78  next processing.
79 ****************************************************************************/
80
81 static bool recalc_brl_timeout(struct smbd_server_connection *sconn)
82 {
83         struct blocking_lock_record *blr;
84         struct timeval next_timeout;
85         int max_brl_timeout = lp_parm_int(-1, "brl", "recalctime", 5);
86
87         TALLOC_FREE(sconn->smb1.locks.brl_timeout);
88
89         next_timeout = timeval_zero();
90
91         for (blr = sconn->smb1.locks.blocking_lock_queue; blr; blr = blr->next) {
92                 if (timeval_is_zero(&blr->expire_time)) {
93                         /*
94                          * If we're blocked on pid 0xFFFFFFFFFFFFFFFFLL this is
95                          * a POSIX lock, so calculate a timeout of
96                          * 10 seconds into the future.
97                          */
98                         if (blr->blocking_smblctx == 0xFFFFFFFFFFFFFFFFLL) {
99                                 struct timeval psx_to = timeval_current_ofs(10, 0);
100                                 next_timeout = timeval_brl_min(&next_timeout, &psx_to);
101                         }
102
103                         continue;
104                 }
105
106                 next_timeout = timeval_brl_min(&next_timeout, &blr->expire_time);
107         }
108
109         if (timeval_is_zero(&next_timeout)) {
110                 DEBUG(10, ("Next timeout = Infinite.\n"));
111                 return True;
112         }
113
114         /* 
115          to account for unclean shutdowns by clients we need a
116          maximum timeout that we use for checking pending locks. If
117          we have any pending locks at all, then check if the pending
118          lock can continue at least every brl:recalctime seconds
119          (default 5 seconds).
120
121          This saves us needing to do a message_send_all() in the
122          SIGCHLD handler in the parent daemon. That
123          message_send_all() caused O(n^2) work to be done when IP
124          failovers happened in clustered Samba, which could make the
125          entire system unusable for many minutes.
126         */
127
128         if (max_brl_timeout > 0) {
129                 struct timeval min_to = timeval_current_ofs(max_brl_timeout, 0);
130                 next_timeout = timeval_min(&next_timeout, &min_to);
131         }
132
133         if (DEBUGLVL(10)) {
134                 struct timeval cur, from_now;
135
136                 cur = timeval_current();
137                 from_now = timeval_until(&cur, &next_timeout);
138                 DEBUG(10, ("Next timeout = %d.%d seconds from now.\n",
139                     (int)from_now.tv_sec, (int)from_now.tv_usec));
140         }
141
142         sconn->smb1.locks.brl_timeout = event_add_timed(smbd_event_context(),
143                                                         NULL, next_timeout,
144                                                         brl_timeout_fn, sconn);
145         if (sconn->smb1.locks.brl_timeout == NULL) {
146                 return False;
147         }
148
149         return True;
150 }
151
152
153 /****************************************************************************
154  Function to push a blocking lock request onto the lock queue.
155 ****************************************************************************/
156
157 bool push_blocking_lock_request( struct byte_range_lock *br_lck,
158                 struct smb_request *req,
159                 files_struct *fsp,
160                 int lock_timeout,
161                 int lock_num,
162                 uint64_t smblctx,
163                 enum brl_type lock_type,
164                 enum brl_flavour lock_flav,
165                 uint64_t offset,
166                 uint64_t count,
167                 uint64_t blocking_smblctx)
168 {
169         struct smbd_server_connection *sconn = req->sconn;
170         struct blocking_lock_record *blr;
171         NTSTATUS status;
172
173         if (req->smb2req) {
174                 return push_blocking_lock_request_smb2(br_lck,
175                                 req,
176                                 fsp,
177                                 lock_timeout,
178                                 lock_num,
179                                 smblctx,
180                                 lock_type,
181                                 lock_flav,
182                                 offset,
183                                 count,
184                                 blocking_smblctx);
185         }
186
187         if(req_is_in_chain(req)) {
188                 DEBUG(0,("push_blocking_lock_request: cannot queue a chained request (currently).\n"));
189                 return False;
190         }
191
192         /*
193          * Now queue an entry on the blocking lock queue. We setup
194          * the expiration time here.
195          */
196
197         blr = talloc(NULL, struct blocking_lock_record);
198         if (blr == NULL) {
199                 DEBUG(0,("push_blocking_lock_request: Malloc fail !\n" ));
200                 return False;
201         }
202
203         blr->next = NULL;
204         blr->prev = NULL;
205
206         blr->fsp = fsp;
207         if (lock_timeout == -1) {
208                 blr->expire_time.tv_sec = 0;
209                 blr->expire_time.tv_usec = 0; /* Never expire. */
210         } else {
211                 blr->expire_time = timeval_current_ofs(lock_timeout/1000,
212                                         (lock_timeout % 1000) * 1000);
213         }
214         blr->lock_num = lock_num;
215         blr->smblctx = smblctx;
216         blr->blocking_smblctx = blocking_smblctx;
217         blr->lock_flav = lock_flav;
218         blr->lock_type = lock_type;
219         blr->offset = offset;
220         blr->count = count;
221       
222         /* Specific brl_lock() implementations can fill this in. */
223         blr->blr_private = NULL;
224
225         /* Add a pending lock record for this. */
226         status = brl_lock(req->sconn->msg_ctx,
227                         br_lck,
228                         smblctx,
229                         sconn_server_id(req->sconn),
230                         offset,
231                         count,
232                         lock_type == READ_LOCK ? PENDING_READ_LOCK : PENDING_WRITE_LOCK,
233                         blr->lock_flav,
234                         True,
235                         NULL,
236                         blr);
237
238         if (!NT_STATUS_IS_OK(status)) {
239                 DEBUG(0,("push_blocking_lock_request: failed to add PENDING_LOCK record.\n"));
240                 TALLOC_FREE(blr);
241                 return False;
242         }
243
244         SMB_PERFCOUNT_DEFER_OP(&req->pcd, &req->pcd);
245         blr->req = talloc_move(blr, &req);
246
247         DLIST_ADD_END(sconn->smb1.locks.blocking_lock_queue, blr, struct blocking_lock_record *);
248         recalc_brl_timeout(sconn);
249
250         /* Ensure we'll receive messages when this is unlocked. */
251         if (!sconn->smb1.locks.blocking_lock_unlock_state) {
252                 messaging_register(sconn->msg_ctx, NULL,
253                                    MSG_SMB_UNLOCK, received_unlock_msg);
254                 sconn->smb1.locks.blocking_lock_unlock_state = true;
255         }
256
257         DEBUG(3,("push_blocking_lock_request: lock request blocked with "
258                 "expiry time (%u sec. %u usec) (+%d msec) for fnum = %d, name = %s\n",
259                 (unsigned int)blr->expire_time.tv_sec,
260                 (unsigned int)blr->expire_time.tv_usec, lock_timeout,
261                 blr->fsp->fnum, fsp_str_dbg(blr->fsp)));
262
263         return True;
264 }
265
266 /****************************************************************************
267  Return a lockingX success SMB.
268 *****************************************************************************/
269
270 static void reply_lockingX_success(struct blocking_lock_record *blr)
271 {
272         reply_outbuf(blr->req, 2, 0);
273
274         /*
275          * As this message is a lockingX call we must handle
276          * any following chained message correctly.
277          * This is normally handled in construct_reply(),
278          * but as that calls switch_message, we can't use
279          * that here and must set up the chain info manually.
280          */
281
282         chain_reply(blr->req);
283         TALLOC_FREE(blr->req->outbuf);
284 }
285
286 /****************************************************************************
287  Return a generic lock fail error blocking call.
288 *****************************************************************************/
289
290 static void generic_blocking_lock_error(struct blocking_lock_record *blr, NTSTATUS status)
291 {
292         /* whenever a timeout is given w2k maps LOCK_NOT_GRANTED to
293            FILE_LOCK_CONFLICT! (tridge) */
294         if (NT_STATUS_EQUAL(status, NT_STATUS_LOCK_NOT_GRANTED)) {
295                 status = NT_STATUS_FILE_LOCK_CONFLICT;
296         }
297
298         if (NT_STATUS_EQUAL(status, NT_STATUS_FILE_LOCK_CONFLICT)) {
299                 /* Store the last lock error. */
300                 files_struct *fsp = blr->fsp;
301
302                 if (fsp) {
303                         fsp->last_lock_failure.context.smblctx = blr->smblctx;
304                         fsp->last_lock_failure.context.tid = fsp->conn->cnum;
305                         fsp->last_lock_failure.context.pid =
306                                 sconn_server_id(fsp->conn->sconn);
307                         fsp->last_lock_failure.start = blr->offset;
308                         fsp->last_lock_failure.size = blr->count;
309                         fsp->last_lock_failure.fnum = fsp->fnum;
310                         fsp->last_lock_failure.lock_type = READ_LOCK; /* Don't care. */
311                         fsp->last_lock_failure.lock_flav = blr->lock_flav;
312                 }
313         }
314
315         reply_nterror(blr->req, status);
316         if (!srv_send_smb(blr->req->sconn, (char *)blr->req->outbuf,
317                           true, blr->req->seqnum+1,
318                           blr->req->encrypted, NULL)) {
319                 exit_server_cleanly("generic_blocking_lock_error: srv_send_smb failed.");
320         }
321         TALLOC_FREE(blr->req->outbuf);
322 }
323
324 /****************************************************************************
325  Return a lock fail error for a lockingX call. Undo all the locks we have 
326  obtained first.
327 *****************************************************************************/
328
329 static void reply_lockingX_error(struct blocking_lock_record *blr, NTSTATUS status)
330 {
331         files_struct *fsp = blr->fsp;
332         uint16 num_ulocks = SVAL(blr->req->vwv+6, 0);
333         uint64_t count = (uint64_t)0, offset = (uint64_t) 0;
334         uint64_t smblctx;
335         unsigned char locktype = CVAL(blr->req->vwv+3, 0);
336         bool large_file_format = (locktype & LOCKING_ANDX_LARGE_FILES);
337         uint8_t *data;
338         int i;
339
340         data = discard_const_p(uint8_t, blr->req->buf)
341                 + ((large_file_format ? 20 : 10)*num_ulocks);
342
343         /* 
344          * Data now points at the beginning of the list
345          * of smb_lkrng structs.
346          */
347
348         /*
349          * Ensure we don't do a remove on the lock that just failed,
350          * as under POSIX rules, if we have a lock already there, we
351          * will delete it (and we shouldn't) .....
352          */
353
354         for(i = blr->lock_num - 1; i >= 0; i--) {
355                 bool err;
356
357                 smblctx = get_lock_pid( data, i, large_file_format);
358                 count = get_lock_count( data, i, large_file_format);
359                 offset = get_lock_offset( data, i, large_file_format, &err);
360
361                 /*
362                  * We know err cannot be set as if it was the lock
363                  * request would never have been queued. JRA.
364                  */
365
366                 do_unlock(fsp->conn->sconn->msg_ctx,
367                         fsp,
368                         smblctx,
369                         count,
370                         offset,
371                         WINDOWS_LOCK);
372         }
373
374         generic_blocking_lock_error(blr, status);
375 }
376
377 /****************************************************************************
378  Return a lock fail error.
379 *****************************************************************************/
380
381 static void blocking_lock_reply_error(struct blocking_lock_record *blr, NTSTATUS status)
382 {
383         DEBUG(10, ("Replying with error=%s. BLR = %p\n", nt_errstr(status), blr));
384
385         switch(blr->req->cmd) {
386         case SMBlockingX:
387                 reply_lockingX_error(blr, status);
388                 break;
389         case SMBtrans2:
390         case SMBtranss2:
391                 reply_nterror(blr->req, status);
392
393                 /*
394                  * construct_reply_common has done us the favor to pre-fill
395                  * the command field with SMBtranss2 which is wrong :-)
396                  */
397                 SCVAL(blr->req->outbuf,smb_com,SMBtrans2);
398
399                 if (!srv_send_smb(blr->req->sconn,
400                                   (char *)blr->req->outbuf,
401                                   true, blr->req->seqnum+1,
402                                   IS_CONN_ENCRYPTED(blr->fsp->conn),
403                                   NULL)) {
404                         exit_server_cleanly("blocking_lock_reply_error: "
405                                             "srv_send_smb failed.");
406                 }
407                 TALLOC_FREE(blr->req->outbuf);
408                 break;
409         default:
410                 DEBUG(0,("blocking_lock_reply_error: PANIC - unknown type on blocking lock queue - exiting.!\n"));
411                 exit_server("PANIC - unknown type on blocking lock queue");
412         }
413 }
414
415 /****************************************************************************
416  Attempt to finish off getting all pending blocking locks for a lockingX call.
417  Returns True if we want to be removed from the list.
418 *****************************************************************************/
419
420 static bool process_lockingX(struct blocking_lock_record *blr)
421 {
422         unsigned char locktype = CVAL(blr->req->vwv+3, 0);
423         files_struct *fsp = blr->fsp;
424         uint16 num_ulocks = SVAL(blr->req->vwv+6, 0);
425         uint16 num_locks = SVAL(blr->req->vwv+7, 0);
426         uint64_t count = (uint64_t)0, offset = (uint64_t)0;
427         uint64_t smblctx;
428         bool large_file_format = (locktype & LOCKING_ANDX_LARGE_FILES);
429         uint8_t *data;
430         NTSTATUS status = NT_STATUS_OK;
431
432         data = discard_const_p(uint8_t, blr->req->buf)
433                 + ((large_file_format ? 20 : 10)*num_ulocks);
434
435         /* 
436          * Data now points at the beginning of the list
437          * of smb_lkrng structs.
438          */
439
440         for(; blr->lock_num < num_locks; blr->lock_num++) {
441                 struct byte_range_lock *br_lck = NULL;
442                 bool err;
443
444                 smblctx = get_lock_pid( data, blr->lock_num, large_file_format);
445                 count = get_lock_count( data, blr->lock_num, large_file_format);
446                 offset = get_lock_offset( data, blr->lock_num, large_file_format, &err);
447
448                 /*
449                  * We know err cannot be set as if it was the lock
450                  * request would never have been queued. JRA.
451                  */
452                 errno = 0;
453                 br_lck = do_lock(fsp->conn->sconn->msg_ctx,
454                                 fsp,
455                                 smblctx,
456                                 count,
457                                 offset,
458                                 ((locktype & LOCKING_ANDX_SHARED_LOCK) ?
459                                         READ_LOCK : WRITE_LOCK),
460                                 WINDOWS_LOCK,
461                                 True,
462                                 &status,
463                                 &blr->blocking_smblctx,
464                                 blr);
465
466                 TALLOC_FREE(br_lck);
467
468                 if (NT_STATUS_IS_ERR(status)) {
469                         break;
470                 }
471         }
472
473         if(blr->lock_num == num_locks) {
474                 /*
475                  * Success - we got all the locks.
476                  */
477
478                 DEBUG(3,("process_lockingX file = %s, fnum=%d type=%d "
479                          "num_locks=%d\n", fsp_str_dbg(fsp), fsp->fnum,
480                          (unsigned int)locktype, num_locks));
481
482                 reply_lockingX_success(blr);
483                 return True;
484         }
485
486         if (!NT_STATUS_EQUAL(status,NT_STATUS_LOCK_NOT_GRANTED) &&
487             !NT_STATUS_EQUAL(status,NT_STATUS_FILE_LOCK_CONFLICT)) {
488                 /*
489                  * We have other than a "can't get lock"
490                  * error. Free any locks we had and return an error.
491                  * Return True so we get dequeued.
492                  */
493                 blocking_lock_reply_error(blr, status);
494                 return True;
495         }
496
497         /*
498          * Still can't get all the locks - keep waiting.
499          */
500
501         DEBUG(10,("process_lockingX: only got %d locks of %d needed for file %s, fnum = %d. \
502 Waiting....\n", 
503                  blr->lock_num, num_locks, fsp_str_dbg(fsp), fsp->fnum));
504
505         return False;
506 }
507
508 /****************************************************************************
509  Attempt to get the posix lock request from a SMBtrans2 call.
510  Returns True if we want to be removed from the list.
511 *****************************************************************************/
512
513 static bool process_trans2(struct blocking_lock_record *blr)
514 {
515         char params[2];
516         NTSTATUS status;
517         struct byte_range_lock *br_lck = do_lock(
518                                                 blr->fsp->conn->sconn->msg_ctx,
519                                                 blr->fsp,
520                                                 blr->smblctx,
521                                                 blr->count,
522                                                 blr->offset,
523                                                 blr->lock_type,
524                                                 blr->lock_flav,
525                                                 True,
526                                                 &status,
527                                                 &blr->blocking_smblctx,
528                                                 blr);
529         TALLOC_FREE(br_lck);
530
531         if (!NT_STATUS_IS_OK(status)) {
532                 if (ERROR_WAS_LOCK_DENIED(status)) {
533                         /* Still can't get the lock, just keep waiting. */
534                         return False;
535                 }       
536                 /*
537                  * We have other than a "can't get lock"
538                  * error. Send an error and return True so we get dequeued.
539                  */
540                 blocking_lock_reply_error(blr, status);
541                 return True;
542         }
543
544         /* We finally got the lock, return success. */
545
546         SSVAL(params,0,0);
547         /* Fake up max_data_bytes here - we know it fits. */
548         send_trans2_replies(blr->fsp->conn, blr->req, params, 2, NULL, 0, 0xffff);
549         return True;
550 }
551
552
553 /****************************************************************************
554  Process a blocking lock SMB.
555  Returns True if we want to be removed from the list.
556 *****************************************************************************/
557
558 static bool blocking_lock_record_process(struct blocking_lock_record *blr)
559 {
560         switch(blr->req->cmd) {
561                 case SMBlockingX:
562                         return process_lockingX(blr);
563                 case SMBtrans2:
564                 case SMBtranss2:
565                         return process_trans2(blr);
566                 default:
567                         DEBUG(0,("blocking_lock_record_process: PANIC - unknown type on blocking lock queue - exiting.!\n"));
568                         exit_server("PANIC - unknown type on blocking lock queue");
569         }
570         return False; /* Keep compiler happy. */
571 }
572
573 /****************************************************************************
574  Cancel entries by fnum from the blocking lock pending queue.
575  Called when a file is closed.
576 *****************************************************************************/
577
578 void cancel_pending_lock_requests_by_fid(files_struct *fsp,
579                         struct byte_range_lock *br_lck,
580                         enum file_close_type close_type)
581 {
582         struct smbd_server_connection *sconn = fsp->conn->sconn;
583         struct blocking_lock_record *blr, *blr_cancelled, *next = NULL;
584
585         if (sconn->using_smb2) {
586                 cancel_pending_lock_requests_by_fid_smb2(fsp,
587                                         br_lck,
588                                         close_type);
589                 return;
590         }
591
592         for(blr = sconn->smb1.locks.blocking_lock_queue; blr; blr = next) {
593                 unsigned char locktype = 0;
594
595                 next = blr->next;
596                 if (blr->fsp->fnum != fsp->fnum) {
597                         continue;
598                 }
599
600                 if (blr->req->cmd == SMBlockingX) {
601                         locktype = CVAL(blr->req->vwv+3, 0);
602                 }
603
604                 DEBUG(10, ("remove_pending_lock_requests_by_fid - removing "
605                            "request type %d for file %s fnum = %d\n",
606                            blr->req->cmd, fsp_str_dbg(fsp), fsp->fnum));
607
608                 blr_cancelled = blocking_lock_cancel_smb1(fsp,
609                                      blr->smblctx,
610                                      blr->offset,
611                                      blr->count,
612                                      blr->lock_flav,
613                                      locktype,
614                                      NT_STATUS_RANGE_NOT_LOCKED);
615
616                 SMB_ASSERT(blr_cancelled == blr);
617
618                 brl_lock_cancel(br_lck,
619                                 blr->smblctx,
620                                 sconn_server_id(sconn),
621                                 blr->offset,
622                                 blr->count,
623                                 blr->lock_flav,
624                                 blr);
625
626                 /* We're closing the file fsp here, so ensure
627                  * we don't have a dangling pointer. */
628                 blr->fsp = NULL;
629         }
630 }
631
632 /****************************************************************************
633  Delete entries by mid from the blocking lock pending queue. Always send reply.
634  Only called from the SMB1 cancel code.
635 *****************************************************************************/
636
637 void remove_pending_lock_requests_by_mid_smb1(
638         struct smbd_server_connection *sconn, uint64_t mid)
639 {
640         struct blocking_lock_record *blr, *next = NULL;
641
642         for(blr = sconn->smb1.locks.blocking_lock_queue; blr; blr = next) {
643                 files_struct *fsp;
644                 struct byte_range_lock *br_lck;
645
646                 next = blr->next;
647
648                 if (blr->req->mid != mid) {
649                         continue;
650                 }
651
652                 fsp = blr->fsp;
653                 br_lck = brl_get_locks(talloc_tos(), fsp);
654
655                 if (br_lck) {
656                         DEBUG(10, ("remove_pending_lock_requests_by_mid_smb1 - "
657                                    "removing request type %d for file %s fnum "
658                                    "= %d\n", blr->req->cmd, fsp_str_dbg(fsp),
659                                    fsp->fnum ));
660
661                         brl_lock_cancel(br_lck,
662                                         blr->smblctx,
663                                         sconn_server_id(sconn),
664                                         blr->offset,
665                                         blr->count,
666                                         blr->lock_flav,
667                                         blr);
668                         TALLOC_FREE(br_lck);
669                 }
670
671                 blocking_lock_reply_error(blr,NT_STATUS_FILE_LOCK_CONFLICT);
672                 DLIST_REMOVE(sconn->smb1.locks.blocking_lock_queue, blr);
673                 TALLOC_FREE(blr);
674         }
675 }
676
677 /****************************************************************************
678  Is this mid a blocking lock request on the queue ?
679  Currently only called from the SMB1 unix extensions POSIX lock code.
680 *****************************************************************************/
681
682 bool blocking_lock_was_deferred_smb1(
683         struct smbd_server_connection *sconn, uint64_t mid)
684 {
685         struct blocking_lock_record *blr, *next = NULL;
686
687         for(blr = sconn->smb1.locks.blocking_lock_queue; blr; blr = next) {
688                 next = blr->next;
689                 if(blr->req->mid == mid) {
690                         return True;
691                 }
692         }
693         return False;
694 }
695
696 /****************************************************************************
697   Set a flag as an unlock request affects one of our pending locks.
698 *****************************************************************************/
699
700 static void received_unlock_msg(struct messaging_context *msg,
701                                 void *private_data,
702                                 uint32_t msg_type,
703                                 struct server_id server_id,
704                                 DATA_BLOB *data)
705 {
706         struct smbd_server_connection *sconn;
707
708         sconn = msg_ctx_to_sconn(msg);
709         if (sconn == NULL) {
710                 DEBUG(1, ("could not find sconn\n"));
711                 return;
712         }
713
714         DEBUG(10,("received_unlock_msg\n"));
715         process_blocking_lock_queue(sconn);
716 }
717
718 /****************************************************************************
719  Process the blocking lock queue. Note that this is only called as root.
720 *****************************************************************************/
721
722 void process_blocking_lock_queue(struct smbd_server_connection *sconn)
723 {
724         struct timeval tv_curr = timeval_current();
725         struct blocking_lock_record *blr, *next = NULL;
726
727         if (sconn->using_smb2) {
728                 process_blocking_lock_queue_smb2(sconn, tv_curr);
729                 return;
730         }
731
732         /*
733          * Go through the queue and see if we can get any of the locks.
734          */
735
736         for (blr = sconn->smb1.locks.blocking_lock_queue; blr; blr = next) {
737
738                 next = blr->next;
739
740                 /*
741                  * Go through the remaining locks and try and obtain them.
742                  * The call returns True if all locks were obtained successfully
743                  * and False if we still need to wait.
744                  */
745
746                 DEBUG(10, ("Processing BLR = %p\n", blr));
747
748                 /* We use set_current_service so connections with
749                  * pending locks are not marked as idle.
750                  */
751
752                 set_current_service(blr->fsp->conn,
753                                 SVAL(blr->req->inbuf,smb_flg),
754                                 false);
755
756                 if(blocking_lock_record_process(blr)) {
757                         struct byte_range_lock *br_lck = brl_get_locks(
758                                 talloc_tos(), blr->fsp);
759
760                         DEBUG(10, ("BLR_process returned true: cancelling and "
761                             "removing lock. BLR = %p\n", blr));
762
763                         if (br_lck) {
764                                 brl_lock_cancel(br_lck,
765                                         blr->smblctx,
766                                         sconn_server_id(sconn),
767                                         blr->offset,
768                                         blr->count,
769                                         blr->lock_flav,
770                                         blr);
771                                 TALLOC_FREE(br_lck);
772                         }
773
774                         DLIST_REMOVE(sconn->smb1.locks.blocking_lock_queue, blr);
775                         TALLOC_FREE(blr);
776                         continue;
777                 }
778
779                 /*
780                  * We couldn't get the locks for this record on the list.
781                  * If the time has expired, return a lock error.
782                  */
783
784                 if (!timeval_is_zero(&blr->expire_time) && timeval_compare(&blr->expire_time, &tv_curr) <= 0) {
785                         struct byte_range_lock *br_lck = brl_get_locks(
786                                 talloc_tos(), blr->fsp);
787
788                         DEBUG(10, ("Lock timed out! BLR = %p\n", blr));
789
790                         /*
791                          * Lock expired - throw away all previously
792                          * obtained locks and return lock error.
793                          */
794
795                         if (br_lck) {
796                                 DEBUG(5,("process_blocking_lock_queue: "
797                                          "pending lock fnum = %d for file %s "
798                                          "timed out.\n", blr->fsp->fnum,
799                                          fsp_str_dbg(blr->fsp)));
800
801                                 brl_lock_cancel(br_lck,
802                                         blr->smblctx,
803                                         sconn_server_id(sconn),
804                                         blr->offset,
805                                         blr->count,
806                                         blr->lock_flav,
807                                         blr);
808                                 TALLOC_FREE(br_lck);
809                         }
810
811                         blocking_lock_reply_error(blr,NT_STATUS_FILE_LOCK_CONFLICT);
812                         DLIST_REMOVE(sconn->smb1.locks.blocking_lock_queue, blr);
813                         TALLOC_FREE(blr);
814                 }
815         }
816
817         recalc_brl_timeout(sconn);
818 }
819
820 /****************************************************************************
821  Handle a cancel message. Lock already moved onto the cancel queue.
822 *****************************************************************************/
823
824 #define MSG_BLOCKING_LOCK_CANCEL_SIZE (sizeof(struct blocking_lock_record *) + sizeof(NTSTATUS))
825
826 static void process_blocking_lock_cancel_message(struct messaging_context *ctx,
827                                                  void *private_data,
828                                                  uint32_t msg_type,
829                                                  struct server_id server_id,
830                                                  DATA_BLOB *data)
831 {
832         struct smbd_server_connection *sconn;
833         NTSTATUS err;
834         const char *msg = (const char *)data->data;
835         struct blocking_lock_record *blr;
836
837         if (data->data == NULL) {
838                 smb_panic("process_blocking_lock_cancel_message: null msg");
839         }
840
841         if (data->length != MSG_BLOCKING_LOCK_CANCEL_SIZE) {
842                 DEBUG(0, ("process_blocking_lock_cancel_message: "
843                           "Got invalid msg len %d\n", (int)data->length));
844                 smb_panic("process_blocking_lock_cancel_message: bad msg");
845         }
846
847         sconn = msg_ctx_to_sconn(ctx);
848         if (sconn == NULL) {
849                 DEBUG(1, ("could not find sconn\n"));
850                 return;
851         }
852
853         memcpy(&blr, msg, sizeof(blr));
854         memcpy(&err, &msg[sizeof(blr)], sizeof(NTSTATUS));
855
856         DEBUG(10,("process_blocking_lock_cancel_message: returning error %s\n",
857                 nt_errstr(err) ));
858
859         blocking_lock_reply_error(blr, err);
860         DLIST_REMOVE(sconn->smb1.locks.blocking_lock_cancelled_queue, blr);
861         TALLOC_FREE(blr);
862 }
863
864 /****************************************************************************
865  Send ourselves a blocking lock cancelled message. Handled asynchronously above.
866  Returns the blocking_lock_record that is being cancelled.
867  Only called from the SMB1 code.
868 *****************************************************************************/
869
870 struct blocking_lock_record *blocking_lock_cancel_smb1(files_struct *fsp,
871                         uint64_t smblctx,
872                         uint64_t offset,
873                         uint64_t count,
874                         enum brl_flavour lock_flav,
875                         unsigned char locktype,
876                         NTSTATUS err)
877 {
878         struct smbd_server_connection *sconn = fsp->conn->sconn;
879         char msg[MSG_BLOCKING_LOCK_CANCEL_SIZE];
880         struct blocking_lock_record *blr;
881
882         if (!sconn->smb1.locks.blocking_lock_cancel_state) {
883                 /* Register our message. */
884                 messaging_register(sconn->msg_ctx, NULL,
885                                    MSG_SMB_BLOCKING_LOCK_CANCEL,
886                                    process_blocking_lock_cancel_message);
887
888                 sconn->smb1.locks.blocking_lock_cancel_state = True;
889         }
890
891         for (blr = sconn->smb1.locks.blocking_lock_queue; blr; blr = blr->next) {
892                 if (fsp == blr->fsp &&
893                                 smblctx == blr->smblctx &&
894                                 offset == blr->offset &&
895                                 count == blr->count &&
896                                 lock_flav == blr->lock_flav) {
897                         break;
898                 }
899         }
900
901         if (!blr) {
902                 return NULL;
903         }
904
905         /* Check the flags are right. */
906         if (blr->req->cmd == SMBlockingX &&
907                 (locktype & LOCKING_ANDX_LARGE_FILES) !=
908                         (CVAL(blr->req->vwv+3, 0) & LOCKING_ANDX_LARGE_FILES)) {
909                 return NULL;
910         }
911
912         /* Move to cancelled queue. */
913         DLIST_REMOVE(sconn->smb1.locks.blocking_lock_queue, blr);
914         DLIST_ADD(sconn->smb1.locks.blocking_lock_cancelled_queue, blr);
915
916         /* Create the message. */
917         memcpy(msg, &blr, sizeof(blr));
918         memcpy(&msg[sizeof(blr)], &err, sizeof(NTSTATUS));
919
920         messaging_send_buf(sconn->msg_ctx, sconn_server_id(sconn),
921                            MSG_SMB_BLOCKING_LOCK_CANCEL,
922                            (uint8 *)&msg, sizeof(msg));
923
924         return blr;
925 }