a97d8d44930379344fd5140ee3ebfe1db006ebe6
[gd/samba-autobuild/.git] / source3 / locking / share_mode_lock.c
1 /*
2    Unix SMB/CIFS implementation.
3    Locking functions
4    Copyright (C) Andrew Tridgell 1992-2000
5    Copyright (C) Jeremy Allison 1992-2006
6    Copyright (C) Volker Lendecke 2005
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    Revision History:
22
23    12 aug 96: Erik.Devriendt@te6.siemens.be
24    added support for shared memory implementation of share mode locking
25
26    May 1997. Jeremy Allison (jallison@whistle.com). Modified share mode
27    locking to deal with multiple share modes per open file.
28
29    September 1997. Jeremy Allison (jallison@whistle.com). Added oplock
30    support.
31
32    rewritten completely to use new tdb code. Tridge, Dec '99
33
34    Added POSIX locking support. Jeremy Allison (jeremy@valinux.com), Apr. 2000.
35    Added Unix Extensions POSIX locking support. Jeremy Allison Mar 2006.
36 */
37
38 #include "includes.h"
39 #include "system/filesys.h"
40 #include "lib/util/server_id.h"
41 #include "locking/proto.h"
42 #include "smbd/globals.h"
43 #include "dbwrap/dbwrap.h"
44 #include "dbwrap/dbwrap_open.h"
45 #include "../libcli/security/security.h"
46 #include "serverid.h"
47 #include "messages.h"
48 #include "util_tdb.h"
49 #include "../librpc/gen_ndr/ndr_open_files.h"
50 #include "source3/lib/dbwrap/dbwrap_watch.h"
51 #include "locking/leases_db.h"
52 #include "../lib/util/memcache.h"
53 #include "lib/util/tevent_ntstatus.h"
54
55 #undef DBGC_CLASS
56 #define DBGC_CLASS DBGC_LOCKING
57
58 #define NO_LOCKING_COUNT (-1)
59
60 /* the locking database handle */
61 static struct db_context *lock_db;
62
63 static bool locking_init_internal(bool read_only)
64 {
65         struct db_context *backend;
66         char *db_path;
67
68         brl_init(read_only);
69
70         if (lock_db)
71                 return True;
72
73         db_path = lock_path(talloc_tos(), "locking.tdb");
74         if (db_path == NULL) {
75                 return false;
76         }
77
78         backend = db_open(NULL, db_path,
79                           SMB_OPEN_DATABASE_TDB_HASH_SIZE,
80                           TDB_DEFAULT|TDB_VOLATILE|TDB_CLEAR_IF_FIRST|TDB_INCOMPATIBLE_HASH,
81                           read_only?O_RDONLY:O_RDWR|O_CREAT, 0644,
82                           DBWRAP_LOCK_ORDER_1, DBWRAP_FLAG_NONE);
83         TALLOC_FREE(db_path);
84         if (!backend) {
85                 DEBUG(0,("ERROR: Failed to initialise locking database\n"));
86                 return False;
87         }
88
89         lock_db = db_open_watched(NULL, &backend, global_messaging_context());
90         if (lock_db == NULL) {
91                 DBG_ERR("db_open_watched failed\n");
92                 TALLOC_FREE(backend);
93                 return false;
94         }
95
96         if (!posix_locking_init(read_only)) {
97                 TALLOC_FREE(lock_db);
98                 return False;
99         }
100
101         return True;
102 }
103
104 bool locking_init(void)
105 {
106         return locking_init_internal(false);
107 }
108
109 bool locking_init_readonly(void)
110 {
111         return locking_init_internal(true);
112 }
113
114 /*******************************************************************
115  Deinitialize the share_mode management.
116 ******************************************************************/
117
118 bool locking_end(void)
119 {
120         brl_shutdown();
121         TALLOC_FREE(lock_db);
122         return true;
123 }
124
125 /*******************************************************************
126  Form a static locking key for a dev/inode pair.
127 ******************************************************************/
128
129 static TDB_DATA locking_key(const struct file_id *id)
130 {
131         return make_tdb_data((const uint8_t *)id, sizeof(*id));
132 }
133
134 /*******************************************************************
135  Share mode cache utility functions that store/delete/retrieve
136  entries from memcache.
137
138  For now share the statcache (global cache) memory space. If
139  a lock record gets orphaned (which shouldn't happen as we're
140  using the same locking_key data as lookup) it will eventually
141  fall out of the cache via the normal LRU trim mechanism. If
142  necessary we can always make this a separate (smaller) cache.
143 ******************************************************************/
144
145 static DATA_BLOB memcache_key(const struct file_id *id)
146 {
147         return data_blob_const((const void *)id, sizeof(*id));
148 }
149
150 static void share_mode_memcache_delete(struct share_mode_data *d)
151 {
152         const DATA_BLOB key = memcache_key(&d->id);
153
154         DBG_DEBUG("deleting entry for file %s seq %"PRIx64" key %s\n",
155                   d->base_name,
156                   d->sequence_number,
157                   file_id_string(talloc_tos(), &d->id));
158
159         memcache_delete(NULL,
160                         SHARE_MODE_LOCK_CACHE,
161                         key);
162 }
163
164 static void share_mode_memcache_store(struct share_mode_data *d)
165 {
166         const DATA_BLOB key = memcache_key(&d->id);
167
168         DBG_DEBUG("stored entry for file %s seq %"PRIx64" key %s\n",
169                   d->base_name,
170                   d->sequence_number,
171                   file_id_string(talloc_tos(), &d->id));
172
173         /* Ensure everything stored in the cache is pristine. */
174         d->modified = false;
175         d->fresh = false;
176
177         /*
178          * Ensure the memory going into the cache
179          * doesn't have a destructor so it can be
180          * cleanly freed by share_mode_memcache_delete().
181          */
182         talloc_set_destructor(d, NULL);
183
184         /* Cache will own d after this call. */
185         memcache_add_talloc(NULL,
186                         SHARE_MODE_LOCK_CACHE,
187                         key,
188                         &d);
189 }
190
191 /*
192  * NB. We use ndr_pull_hyper on a stack-created
193  * struct ndr_pull with no talloc allowed, as we
194  * need this to be really fast as an ndr-peek into
195  * the first 8 bytes of the blob.
196  */
197
198 static enum ndr_err_code get_blob_sequence_number(DATA_BLOB *blob,
199                                                 uint64_t *pseq)
200 {
201         struct ndr_pull ndr = {.data = blob->data, .data_size = blob->length};
202         NDR_CHECK(ndr_pull_hyper(&ndr, NDR_SCALARS, pseq));
203         return NDR_ERR_SUCCESS;
204 }
205
206 static int share_mode_data_nofree_destructor(struct share_mode_data *d)
207 {
208         return -1;
209 }
210
211 static struct share_mode_data *share_mode_memcache_fetch(TALLOC_CTX *mem_ctx,
212                                         const TDB_DATA id_key,
213                                         DATA_BLOB *blob)
214 {
215         enum ndr_err_code ndr_err;
216         struct share_mode_data *d;
217         uint64_t sequence_number;
218         void *ptr;
219         struct file_id id;
220         DATA_BLOB key;
221
222         /* Ensure this is a locking_key record. */
223         if (id_key.dsize != sizeof(id)) {
224                 return NULL;
225         }
226
227         memcpy(&id, id_key.dptr, id_key.dsize);
228         key = memcache_key(&id);
229
230         ptr = memcache_lookup_talloc(NULL,
231                         SHARE_MODE_LOCK_CACHE,
232                         key);
233         if (ptr == NULL) {
234                 DEBUG(10,("failed to find entry for key %s\n",
235                         file_id_string(mem_ctx, &id)));
236                 return NULL;
237         }
238         /* sequence number key is at start of blob. */
239         ndr_err = get_blob_sequence_number(blob, &sequence_number);
240         if (ndr_err != NDR_ERR_SUCCESS) {
241                 /* Bad blob. Remove entry. */
242                 DEBUG(10,("bad blob %u key %s\n",
243                         (unsigned int)ndr_err,
244                         file_id_string(mem_ctx, &id)));
245                 memcache_delete(NULL,
246                         SHARE_MODE_LOCK_CACHE,
247                         key);
248                 return NULL;
249         }
250
251         d = (struct share_mode_data *)ptr;
252         if (d->sequence_number != sequence_number) {
253                 DBG_DEBUG("seq changed (cached %"PRIx64") (new %"PRIx64") "
254                           "for key %s\n",
255                           d->sequence_number,
256                           sequence_number,
257                           file_id_string(mem_ctx, &id));
258                 /* Cache out of date. Remove entry. */
259                 memcache_delete(NULL,
260                         SHARE_MODE_LOCK_CACHE,
261                         key);
262                 return NULL;
263         }
264
265         /* Move onto mem_ctx. */
266         d = talloc_move(mem_ctx, &ptr);
267
268         /*
269          * Now we own d, prevent the cache from freeing it
270          * when we delete the entry.
271          */
272         talloc_set_destructor(d, share_mode_data_nofree_destructor);
273
274         /* Remove from the cache. We own it now. */
275         memcache_delete(NULL,
276                         SHARE_MODE_LOCK_CACHE,
277                         key);
278
279         /* And reset the destructor to none. */
280         talloc_set_destructor(d, NULL);
281
282         DBG_DEBUG("fetched entry for file %s seq %"PRIx64" key %s\n",
283                   d->base_name,
284                   d->sequence_number,
285                   file_id_string(mem_ctx, &id));
286
287         return d;
288 }
289
290 /*******************************************************************
291  Get all share mode entries for a dev/inode pair.
292 ********************************************************************/
293
294 static struct share_mode_data *parse_share_modes(TALLOC_CTX *mem_ctx,
295                                                 const TDB_DATA key,
296                                                 const TDB_DATA dbuf)
297 {
298         struct share_mode_data *d;
299         enum ndr_err_code ndr_err;
300         DATA_BLOB blob;
301
302         blob.data = dbuf.dptr;
303         blob.length = dbuf.dsize;
304
305         /* See if we already have a cached copy of this key. */
306         d = share_mode_memcache_fetch(mem_ctx, key, &blob);
307         if (d != NULL) {
308                 return d;
309         }
310
311         d = talloc(mem_ctx, struct share_mode_data);
312         if (d == NULL) {
313                 DEBUG(0, ("talloc failed\n"));
314                 goto fail;
315         }
316
317         ndr_err = ndr_pull_struct_blob_all(
318                 &blob, d, d, (ndr_pull_flags_fn_t)ndr_pull_share_mode_data);
319         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
320                 DEBUG(1, ("ndr_pull_share_mode_lock failed: %s\n",
321                           ndr_errstr(ndr_err)));
322                 goto fail;
323         }
324
325         if (DEBUGLEVEL >= 10) {
326                 DEBUG(10, ("parse_share_modes:\n"));
327                 NDR_PRINT_DEBUG(share_mode_data, d);
328         }
329
330         return d;
331 fail:
332         TALLOC_FREE(d);
333         return NULL;
334 }
335
336 /*******************************************************************
337  Create a storable data blob from a modified share_mode_data struct.
338 ********************************************************************/
339
340 static TDB_DATA unparse_share_modes(struct share_mode_data *d)
341 {
342         DATA_BLOB blob;
343         enum ndr_err_code ndr_err;
344
345         if (DEBUGLEVEL >= 10) {
346                 DEBUG(10, ("unparse_share_modes:\n"));
347                 NDR_PRINT_DEBUG(share_mode_data, d);
348         }
349
350         share_mode_memcache_delete(d);
351
352         /* Update the sequence number. */
353         d->sequence_number += 1;
354
355         remove_stale_share_mode_entries(d);
356
357         if (d->num_share_modes == 0) {
358                 DEBUG(10, ("No used share mode found\n"));
359                 return make_tdb_data(NULL, 0);
360         }
361
362         ndr_err = ndr_push_struct_blob(
363                 &blob, d, d, (ndr_push_flags_fn_t)ndr_push_share_mode_data);
364         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
365                 smb_panic("ndr_push_share_mode_lock failed");
366         }
367
368         return make_tdb_data(blob.data, blob.length);
369 }
370
371 /*******************************************************************
372  If modified, store the share_mode_data back into the database.
373 ********************************************************************/
374
375 static int share_mode_data_destructor(struct share_mode_data *d)
376 {
377         NTSTATUS status;
378         TDB_DATA data;
379
380         if (!d->modified) {
381                 return 0;
382         }
383
384         data = unparse_share_modes(d);
385
386         if (data.dptr == NULL) {
387                 if (!d->fresh) {
388                         /* There has been an entry before, delete it */
389
390                         status = dbwrap_record_delete(d->record);
391                         if (!NT_STATUS_IS_OK(status)) {
392                                 char *errmsg;
393
394                                 DEBUG(0, ("delete_rec returned %s\n",
395                                           nt_errstr(status)));
396
397                                 if (asprintf(&errmsg, "could not delete share "
398                                              "entry: %s\n",
399                                              nt_errstr(status)) == -1) {
400                                         smb_panic("could not delete share"
401                                                   "entry");
402                                 }
403                                 smb_panic(errmsg);
404                         }
405                 }
406                 /*
407                  * Nothing to store in cache - allow the normal
408                  * release of record lock and memory free.
409                  */
410                 return 0;
411         }
412
413         status = dbwrap_record_store(d->record, data, TDB_REPLACE);
414         if (!NT_STATUS_IS_OK(status)) {
415                 char *errmsg;
416
417                 DEBUG(0, ("store returned %s\n", nt_errstr(status)));
418
419                 if (asprintf(&errmsg, "could not store share mode entry: %s",
420                              nt_errstr(status)) == -1) {
421                         smb_panic("could not store share mode entry");
422                 }
423                 smb_panic(errmsg);
424         }
425
426         /*
427          * Release the record lock before putting in the cache.
428          */
429         TALLOC_FREE(d->record);
430
431         /*
432          * Release the dptr as well before reparenting to NULL
433          * (in-memory cache) context.
434          */
435         TALLOC_FREE(data.dptr);
436         /*
437          * Reparent d into the in-memory cache so it can be reused if the
438          * sequence number matches. See parse_share_modes()
439          * for details.
440          */
441
442         share_mode_memcache_store(d);
443         return -1;
444 }
445
446 /*******************************************************************
447  Allocate a new share_mode_data struct, mark it unmodified.
448  fresh is set to note that currently there is no database entry.
449 ********************************************************************/
450
451 static struct share_mode_data *fresh_share_mode_lock(
452         TALLOC_CTX *mem_ctx, const char *servicepath,
453         const struct smb_filename *smb_fname,
454         const struct timespec *old_write_time)
455 {
456         struct share_mode_data *d;
457
458         if ((servicepath == NULL) || (smb_fname == NULL) ||
459             (old_write_time == NULL)) {
460                 return NULL;
461         }
462
463         d = talloc_zero(mem_ctx, struct share_mode_data);
464         if (d == NULL) {
465                 goto fail;
466         }
467         /* New record - new sequence number. */
468         generate_random_buffer((uint8_t *)&d->sequence_number, 8);
469
470         d->base_name = talloc_strdup(d, smb_fname->base_name);
471         if (d->base_name == NULL) {
472                 goto fail;
473         }
474         if (smb_fname->stream_name != NULL) {
475                 d->stream_name = talloc_strdup(d, smb_fname->stream_name);
476                 if (d->stream_name == NULL) {
477                         goto fail;
478                 }
479         }
480         d->servicepath = talloc_strdup(d, servicepath);
481         if (d->servicepath == NULL) {
482                 goto fail;
483         }
484         d->old_write_time = *old_write_time;
485         d->modified = false;
486         d->fresh = true;
487         return d;
488 fail:
489         DEBUG(0, ("talloc failed\n"));
490         TALLOC_FREE(d);
491         return NULL;
492 }
493
494 /*******************************************************************
495  Either fetch a share mode from the database, or allocate a fresh
496  one if the record doesn't exist.
497 ********************************************************************/
498
499 static struct share_mode_lock *get_share_mode_lock_internal(
500         TALLOC_CTX *mem_ctx, struct file_id id,
501         const char *servicepath, const struct smb_filename *smb_fname,
502         const struct timespec *old_write_time)
503 {
504         struct share_mode_lock *lck;
505         struct share_mode_data *d;
506         struct db_record *rec;
507         TDB_DATA key = locking_key(&id);
508         TDB_DATA value;
509
510         rec = dbwrap_fetch_locked(lock_db, mem_ctx, key);
511         if (rec == NULL) {
512                 DEBUG(3, ("Could not lock share entry\n"));
513                 return NULL;
514         }
515
516         value = dbwrap_record_get_value(rec);
517
518         if (value.dptr == NULL) {
519                 d = fresh_share_mode_lock(mem_ctx, servicepath, smb_fname,
520                                           old_write_time);
521         } else {
522                 d = parse_share_modes(mem_ctx, key, value);
523         }
524
525         if (d == NULL) {
526                 DEBUG(5, ("get_share_mode_lock_internal: "
527                         "Could not get share mode lock\n"));
528                 TALLOC_FREE(rec);
529                 return NULL;
530         }
531         d->id = id;
532         d->record = talloc_move(d, &rec);
533         talloc_set_destructor(d, share_mode_data_destructor);
534
535         lck = talloc(mem_ctx, struct share_mode_lock);
536         if (lck == NULL) {
537                 DEBUG(1, ("talloc failed\n"));
538                 TALLOC_FREE(d);
539                 return NULL;
540         }
541         lck->data = talloc_move(lck, &d);
542         return lck;
543 }
544
545 /*
546  * We can only ever have one share mode locked. Users of
547  * get_share_mode_lock never see this, it will be refcounted by
548  * talloc_reference.
549  */
550 static struct share_mode_lock *the_lock;
551
552 static int the_lock_destructor(struct share_mode_lock *l)
553 {
554         the_lock = NULL;
555         return 0;
556 }
557
558 /*******************************************************************
559  Get a share_mode_lock, Reference counted to allow nested calls.
560 ********************************************************************/
561
562 struct share_mode_lock *get_share_mode_lock(
563         TALLOC_CTX *mem_ctx,
564         struct file_id id,
565         const char *servicepath,
566         const struct smb_filename *smb_fname,
567         const struct timespec *old_write_time)
568 {
569         struct share_mode_lock *lck;
570
571         lck = talloc(mem_ctx, struct share_mode_lock);
572         if (lck == NULL) {
573                 DEBUG(1, ("talloc failed\n"));
574                 return NULL;
575         }
576
577         if (the_lock == NULL) {
578                 the_lock = get_share_mode_lock_internal(
579                         lck, id, servicepath, smb_fname, old_write_time);
580                 if (the_lock == NULL) {
581                         goto fail;
582                 }
583                 talloc_set_destructor(the_lock, the_lock_destructor);
584         } else {
585                 if (!file_id_equal(&the_lock->data->id, &id)) {
586                         DEBUG(1, ("Can not lock two share modes "
587                                   "simultaneously\n"));
588                         goto fail;
589                 }
590                 if (talloc_reference(lck, the_lock) == NULL) {
591                         DEBUG(1, ("talloc_reference failed\n"));
592                         goto fail;
593                 }
594         }
595         lck->data = the_lock->data;
596         return lck;
597 fail:
598         TALLOC_FREE(lck);
599         return NULL;
600 }
601
602 struct fetch_share_mode_unlocked_state {
603         TALLOC_CTX *mem_ctx;
604         struct share_mode_lock *lck;
605 };
606
607 static void fetch_share_mode_unlocked_parser(
608         TDB_DATA key, TDB_DATA data, void *private_data)
609 {
610         struct fetch_share_mode_unlocked_state *state = private_data;
611
612         if (data.dsize == 0) {
613                 /* Likely a ctdb tombstone record, ignore it */
614                 return;
615         }
616
617         state->lck = talloc(state->mem_ctx, struct share_mode_lock);
618         if (state->lck == NULL) {
619                 DEBUG(0, ("talloc failed\n"));
620                 return;
621         }
622
623         state->lck->data = parse_share_modes(state->lck, key, data);
624 }
625
626 /*******************************************************************
627  Get a share_mode_lock without locking the database or reference
628  counting. Used by smbstatus to display existing share modes.
629 ********************************************************************/
630
631 struct share_mode_lock *fetch_share_mode_unlocked(TALLOC_CTX *mem_ctx,
632                                                   struct file_id id)
633 {
634         struct fetch_share_mode_unlocked_state state = { .mem_ctx = mem_ctx };
635         TDB_DATA key = locking_key(&id);
636         NTSTATUS status;
637
638         status = dbwrap_parse_record(
639                 lock_db, key, fetch_share_mode_unlocked_parser, &state);
640         if (!NT_STATUS_IS_OK(status)) {
641                 return NULL;
642         }
643         return state.lck;
644 }
645
646 static void fetch_share_mode_done(struct tevent_req *subreq);
647
648 struct fetch_share_mode_state {
649         struct file_id id;
650         TDB_DATA key;
651         struct fetch_share_mode_unlocked_state parser_state;
652         enum dbwrap_req_state req_state;
653 };
654
655 /**
656  * @brief Get a share_mode_lock without locking or refcounting
657  *
658  * This can be used in a clustered Samba environment where the async dbwrap
659  * request is sent over a socket to the local ctdbd. If the send queue is full
660  * and the caller was issuing multiple async dbwrap requests in a loop, the
661  * caller knows it's probably time to stop sending requests for now and try
662  * again later.
663  *
664  * @param[in]  mem_ctx The talloc memory context to use.
665  *
666  * @param[in]  ev      The event context to work on.
667  *
668  * @param[in]  id      The file id for the locking.tdb key
669  *
670  * @param[out] queued  This boolean out parameter tells the caller whether the
671  *                     async request is blocked in a full send queue:
672  *
673  *                     false := request is dispatched
674  *
675  *                     true  := send queue is full, request waiting to be
676  *                              dispatched
677  *
678  * @return             The new async request, NULL on error.
679  **/
680 struct tevent_req *fetch_share_mode_send(TALLOC_CTX *mem_ctx,
681                                          struct tevent_context *ev,
682                                          struct file_id id,
683                                          bool *queued)
684 {
685         struct tevent_req *req = NULL;
686         struct fetch_share_mode_state *state = NULL;
687         struct tevent_req *subreq = NULL;
688
689         *queued = false;
690
691         req = tevent_req_create(mem_ctx, &state,
692                                 struct fetch_share_mode_state);
693         if (req == NULL) {
694                 return NULL;
695         }
696
697         state->id = id;
698         state->key = locking_key(&state->id);
699         state->parser_state.mem_ctx = state;
700
701         subreq = dbwrap_parse_record_send(state,
702                                           ev,
703                                           lock_db,
704                                           state->key,
705                                           fetch_share_mode_unlocked_parser,
706                                           &state->parser_state,
707                                           &state->req_state);
708         if (tevent_req_nomem(subreq, req)) {
709                 return tevent_req_post(req, ev);
710         }
711         tevent_req_set_callback(subreq, fetch_share_mode_done, req);
712
713         if (state->req_state < DBWRAP_REQ_DISPATCHED) {
714                 *queued = true;
715         }
716         return req;
717 }
718
719 static void fetch_share_mode_done(struct tevent_req *subreq)
720 {
721         struct tevent_req *req = tevent_req_callback_data(
722                 subreq, struct tevent_req);
723         NTSTATUS status;
724
725         status = dbwrap_parse_record_recv(subreq);
726         TALLOC_FREE(subreq);
727         if (tevent_req_nterror(req, status)) {
728                 return;
729         }
730
731         tevent_req_done(req);
732         return;
733 }
734
735 NTSTATUS fetch_share_mode_recv(struct tevent_req *req,
736                                TALLOC_CTX *mem_ctx,
737                                struct share_mode_lock **_lck)
738 {
739         struct fetch_share_mode_state *state = tevent_req_data(
740                 req, struct fetch_share_mode_state);
741         struct share_mode_lock *lck = NULL;
742
743         NTSTATUS status;
744
745         if (tevent_req_is_nterror(req, &status)) {
746                 tevent_req_received(req);
747                 return status;
748         }
749
750         if (state->parser_state.lck->data == NULL) {
751                 tevent_req_received(req);
752                 return NT_STATUS_NOT_FOUND;
753         }
754
755         lck = talloc_move(mem_ctx, &state->parser_state.lck);
756
757         if (DEBUGLEVEL >= 10) {
758                 DBG_DEBUG("share_mode_data:\n");
759                 NDR_PRINT_DEBUG(share_mode_data, lck->data);
760         }
761
762         *_lck = lck;
763         tevent_req_received(req);
764         return NT_STATUS_OK;
765 }
766
767 struct share_mode_forall_state {
768         int (*fn)(struct file_id fid, const struct share_mode_data *data,
769                   void *private_data);
770         void *private_data;
771 };
772
773 static int share_mode_traverse_fn(struct db_record *rec, void *_state)
774 {
775         struct share_mode_forall_state *state =
776                 (struct share_mode_forall_state *)_state;
777         TDB_DATA key;
778         TDB_DATA value;
779         DATA_BLOB blob;
780         enum ndr_err_code ndr_err;
781         struct share_mode_data *d;
782         struct file_id fid;
783         int ret;
784
785         key = dbwrap_record_get_key(rec);
786         value = dbwrap_record_get_value(rec);
787
788         /* Ensure this is a locking_key record. */
789         if (key.dsize != sizeof(fid)) {
790                 return 0;
791         }
792         memcpy(&fid, key.dptr, sizeof(fid));
793
794         d = talloc(talloc_tos(), struct share_mode_data);
795         if (d == NULL) {
796                 return 0;
797         }
798
799         blob.data = value.dptr;
800         blob.length = value.dsize;
801
802         ndr_err = ndr_pull_struct_blob_all(
803                 &blob, d, d, (ndr_pull_flags_fn_t)ndr_pull_share_mode_data);
804         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
805                 DEBUG(1, ("ndr_pull_share_mode_lock failed\n"));
806                 return 0;
807         }
808
809         if (DEBUGLEVEL > 10) {
810                 DEBUG(11, ("parse_share_modes:\n"));
811                 NDR_PRINT_DEBUG(share_mode_data, d);
812         }
813
814         ret = state->fn(fid, d, state->private_data);
815
816         TALLOC_FREE(d);
817         return ret;
818 }
819
820 int share_mode_forall(int (*fn)(struct file_id fid,
821                                 const struct share_mode_data *data,
822                                 void *private_data),
823                       void *private_data)
824 {
825         struct share_mode_forall_state state = {
826                 .fn = fn,
827                 .private_data = private_data
828         };
829         NTSTATUS status;
830         int count;
831
832         if (lock_db == NULL) {
833                 return 0;
834         }
835
836         status = dbwrap_traverse_read(lock_db, share_mode_traverse_fn,
837                                       &state, &count);
838         if (!NT_STATUS_IS_OK(status)) {
839                 return -1;
840         }
841
842         return count;
843 }
844
845 struct share_entry_forall_state {
846         int (*fn)(struct file_id fid,
847                   const struct share_mode_data *data,
848                   const struct share_mode_entry *entry,
849                   void *private_data);
850         void *private_data;
851 };
852
853 static int share_entry_traverse_fn(struct file_id fid,
854                                    const struct share_mode_data *data,
855                                    void *private_data)
856 {
857         struct share_entry_forall_state *state = private_data;
858         uint32_t i;
859
860         for (i=0; i<data->num_share_modes; i++) {
861                 int ret;
862
863                 ret = state->fn(fid,
864                                 data,
865                                 &data->share_modes[i],
866                                 state->private_data);
867                 if (ret != 0) {
868                         return ret;
869                 }
870         }
871
872         return 0;
873 }
874
875 /*******************************************************************
876  Call the specified function on each entry under management by the
877  share mode system.
878 ********************************************************************/
879
880 int share_entry_forall(int (*fn)(struct file_id fid,
881                                  const struct share_mode_data *data,
882                                  const struct share_mode_entry *entry,
883                                  void *private_data),
884                       void *private_data)
885 {
886         struct share_entry_forall_state state = {
887                 .fn = fn, .private_data = private_data };
888
889         return share_mode_forall(share_entry_traverse_fn, &state);
890 }
891
892 bool share_mode_cleanup_disconnected(struct file_id fid,
893                                      uint64_t open_persistent_id)
894 {
895         bool ret = false;
896         TALLOC_CTX *frame = talloc_stackframe();
897         unsigned n;
898         struct share_mode_data *data;
899         struct share_mode_lock *lck;
900         bool ok;
901
902         lck = get_existing_share_mode_lock(frame, fid);
903         if (lck == NULL) {
904                 DEBUG(5, ("share_mode_cleanup_disconnected: "
905                           "Could not fetch share mode entry for %s\n",
906                           file_id_string(frame, &fid)));
907                 goto done;
908         }
909         data = lck->data;
910
911         for (n=0; n < data->num_share_modes; n++) {
912                 struct share_mode_entry *entry = &data->share_modes[n];
913
914                 if (!server_id_is_disconnected(&entry->pid)) {
915                         struct server_id_buf tmp;
916                         DEBUG(5, ("share_mode_cleanup_disconnected: "
917                                   "file (file-id='%s', servicepath='%s', "
918                                   "base_name='%s%s%s') "
919                                   "is used by server %s ==> do not cleanup\n",
920                                   file_id_string(frame, &fid),
921                                   data->servicepath,
922                                   data->base_name,
923                                   (data->stream_name == NULL)
924                                   ? "" : "', stream_name='",
925                                   (data->stream_name == NULL)
926                                   ? "" : data->stream_name,
927                                   server_id_str_buf(entry->pid, &tmp)));
928                         goto done;
929                 }
930                 if (open_persistent_id != entry->share_file_id) {
931                         DBG_INFO("entry for file "
932                                  "(file-id='%s', servicepath='%s', "
933                                  "base_name='%s%s%s') "
934                                  "has share_file_id %"PRIu64" but expected "
935                                  "%"PRIu64"==> do not cleanup\n",
936                                  file_id_string(frame, &fid),
937                                  data->servicepath,
938                                  data->base_name,
939                                  (data->stream_name == NULL)
940                                  ? "" : "', stream_name='",
941                                  (data->stream_name == NULL)
942                                  ? "" : data->stream_name,
943                                  entry->share_file_id,
944                                  open_persistent_id);
945                         goto done;
946                 }
947         }
948
949         for (n=0; n < data->num_leases; n++) {
950                 struct share_mode_lease *l = &data->leases[n];
951                 NTSTATUS status;
952
953                 status = leases_db_del(&l->client_guid, &l->lease_key, &fid);
954
955                 DEBUG(10, ("%s: leases_db_del returned %s\n", __func__,
956                            nt_errstr(status)));
957         }
958
959         ok = brl_cleanup_disconnected(fid, open_persistent_id);
960         if (!ok) {
961                 DBG_DEBUG("failed to clean up byte range locks associated "
962                           "with file (file-id='%s', servicepath='%s', "
963                           "base_name='%s%s%s') and open_persistent_id %"PRIu64" "
964                           "==> do not cleanup\n",
965                           file_id_string(frame, &fid),
966                           data->servicepath,
967                           data->base_name,
968                           (data->stream_name == NULL)
969                           ? "" : "', stream_name='",
970                           (data->stream_name == NULL)
971                           ? "" : data->stream_name,
972                           open_persistent_id);
973                 goto done;
974         }
975
976         DBG_DEBUG("cleaning up %u entries for file "
977                   "(file-id='%s', servicepath='%s', "
978                   "base_name='%s%s%s') "
979                   "from open_persistent_id %"PRIu64"\n",
980                   data->num_share_modes,
981                   file_id_string(frame, &fid),
982                   data->servicepath,
983                   data->base_name,
984                   (data->stream_name == NULL)
985                   ? "" : "', stream_name='",
986                   (data->stream_name == NULL)
987                   ? "" : data->stream_name,
988                   open_persistent_id);
989
990         data->num_share_modes = 0;
991         data->num_leases = 0;
992         data->modified = true;
993
994         ret = true;
995 done:
996         talloc_free(frame);
997         return ret;
998 }