?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
s3: Fix a 64-bit warning
[Samba/gebeck_regimport.git] / source3 / locking / locking.c
blob0c457b7a33dd444e211dfe83a1e26220fe230a7a
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 "locking/proto.h"
41 #include "smbd/globals.h"
42 #include "dbwrap/dbwrap.h"
43 #include "dbwrap/dbwrap_open.h"
44 #include "../libcli/security/security.h"
45 #include "serverid.h"
46 #include "messages.h"
47 #include "util_tdb.h"
48 #include "../librpc/gen_ndr/ndr_open_files.h"
49
50 #undef DBGC_CLASS
51 #define DBGC_CLASS DBGC_LOCKING
52
53 #define NO_LOCKING_COUNT (-1)
54
55 /* the locking database handle */
56 static struct db_context *lock_db;
57
58 /****************************************************************************
59 Debugging aids :-).
60 ****************************************************************************/
61
62 const char *lock_type_name(enum brl_type lock_type)
63 {
64 switch (lock_type) {
65 case READ_LOCK:
66 return "READ";
67 case WRITE_LOCK:
68 return "WRITE";
69 case PENDING_READ_LOCK:
70 return "PENDING_READ";
71 case PENDING_WRITE_LOCK:
72 return "PENDING_WRITE";
73 default:
74 return "other";
75 }
76 }
77
78 const char *lock_flav_name(enum brl_flavour lock_flav)
79 {
80 return (lock_flav == WINDOWS_LOCK) ? "WINDOWS_LOCK" : "POSIX_LOCK";
81 }
82
83 /****************************************************************************
84 Utility function called to see if a file region is locked.
85 Called in the read/write codepath.
86 ****************************************************************************/
87
88 void init_strict_lock_struct(files_struct *fsp,
89 uint64_t smblctx,
90 br_off start,
91 br_off size,
92 enum brl_type lock_type,
93 struct lock_struct *plock)
94 {
95 SMB_ASSERT(lock_type == READ_LOCK || lock_type == WRITE_LOCK);
96
97 plock->context.smblctx = smblctx;
98 plock->context.tid = fsp->conn->cnum;
99 plock->context.pid = messaging_server_id(fsp->conn->sconn->msg_ctx);
100 plock->start = start;
101 plock->size = size;
102 plock->fnum = fsp->fnum;
103 plock->lock_type = lock_type;
104 plock->lock_flav = lp_posix_cifsu_locktype(fsp);
105 }
106
107 bool strict_lock_default(files_struct *fsp, struct lock_struct *plock)
108 {
109 int strict_locking = lp_strict_locking(fsp->conn->params);
110 bool ret = False;
111
112 if (plock->size == 0) {
113 return True;
114 }
115
116 if (!lp_locking(fsp->conn->params) || !strict_locking) {
117 return True;
118 }
119
120 if (strict_locking == Auto) {
121 if (EXCLUSIVE_OPLOCK_TYPE(fsp->oplock_type) && (plock->lock_type == READ_LOCK || plock->lock_type == WRITE_LOCK)) {
122 DEBUG(10,("is_locked: optimisation - exclusive oplock on file %s\n", fsp_str_dbg(fsp)));
123 ret = True;
124 } else if ((fsp->oplock_type == LEVEL_II_OPLOCK) &&
125 (plock->lock_type == READ_LOCK)) {
126 DEBUG(10,("is_locked: optimisation - level II oplock on file %s\n", fsp_str_dbg(fsp)));
127 ret = True;
128 } else {
129 struct byte_range_lock *br_lck;
130
131 br_lck = brl_get_locks_readonly(fsp);
132 if (!br_lck) {
133 return True;
134 }
135 ret = brl_locktest(br_lck,
136 plock->context.smblctx,
137 plock->context.pid,
138 plock->start,
139 plock->size,
140 plock->lock_type,
141 plock->lock_flav);
142 }
143 } else {
144 struct byte_range_lock *br_lck;
145
146 br_lck = brl_get_locks_readonly(fsp);
147 if (!br_lck) {
148 return True;
149 }
150 ret = brl_locktest(br_lck,
151 plock->context.smblctx,
152 plock->context.pid,
153 plock->start,
154 plock->size,
155 plock->lock_type,
156 plock->lock_flav);
157 }
158
159 DEBUG(10,("strict_lock_default: flavour = %s brl start=%.0f "
160 "len=%.0f %s for fnum %d file %s\n",
161 lock_flav_name(plock->lock_flav),
162 (double)plock->start, (double)plock->size,
163 ret ? "unlocked" : "locked",
164 plock->fnum, fsp_str_dbg(fsp)));
165
166 return ret;
167 }
168
169 void strict_unlock_default(files_struct *fsp, struct lock_struct *plock)
170 {
171 }
172
173 /****************************************************************************
174 Find out if a lock could be granted - return who is blocking us if we can't.
175 ****************************************************************************/
176
177 NTSTATUS query_lock(files_struct *fsp,
178 uint64_t *psmblctx,
179 uint64_t *pcount,
180 uint64_t *poffset,
181 enum brl_type *plock_type,
182 enum brl_flavour lock_flav)
183 {
184 struct byte_range_lock *br_lck = NULL;
185
186 if (!fsp->can_lock) {
187 return fsp->is_directory ? NT_STATUS_INVALID_DEVICE_REQUEST : NT_STATUS_INVALID_HANDLE;
188 }
189
190 if (!lp_locking(fsp->conn->params)) {
191 return NT_STATUS_OK;
192 }
193
194 br_lck = brl_get_locks_readonly(fsp);
195 if (!br_lck) {
196 return NT_STATUS_NO_MEMORY;
197 }
198
199 return brl_lockquery(br_lck,
200 psmblctx,
201 messaging_server_id(fsp->conn->sconn->msg_ctx),
202 poffset,
203 pcount,
204 plock_type,
205 lock_flav);
206 }
207
208 static void increment_current_lock_count(files_struct *fsp,
209 enum brl_flavour lock_flav)
210 {
211 if (lock_flav == WINDOWS_LOCK &&
212 fsp->current_lock_count != NO_LOCKING_COUNT) {
213 /* blocking ie. pending, locks also count here,
214 * as this is an efficiency counter to avoid checking
215 * the lock db. on close. JRA. */
216
217 fsp->current_lock_count++;
218 } else {
219 /* Notice that this has had a POSIX lock request.
220 * We can't count locks after this so forget them.
221 */
222 fsp->current_lock_count = NO_LOCKING_COUNT;
223 }
224 }
225
226 static void decrement_current_lock_count(files_struct *fsp,
227 enum brl_flavour lock_flav)
228 {
229 if (lock_flav == WINDOWS_LOCK &&
230 fsp->current_lock_count != NO_LOCKING_COUNT) {
231 SMB_ASSERT(fsp->current_lock_count > 0);
232 fsp->current_lock_count--;
233 }
234 }
235
236 /****************************************************************************
237 Utility function called by locking requests.
238 ****************************************************************************/
239
240 struct byte_range_lock *do_lock(struct messaging_context *msg_ctx,
241 files_struct *fsp,
242 uint64_t smblctx,
243 uint64_t count,
244 uint64_t offset,
245 enum brl_type lock_type,
246 enum brl_flavour lock_flav,
247 bool blocking_lock,
248 NTSTATUS *perr,
249 uint64_t *psmblctx,
250 struct blocking_lock_record *blr)
251 {
252 struct byte_range_lock *br_lck = NULL;
253
254 /* silently return ok on print files as we don't do locking there */
255 if (fsp->print_file) {
256 *perr = NT_STATUS_OK;
257 return NULL;
258 }
259
260 if (!fsp->can_lock) {
261 *perr = fsp->is_directory ? NT_STATUS_INVALID_DEVICE_REQUEST : NT_STATUS_INVALID_HANDLE;
262 return NULL;
263 }
264
265 if (!lp_locking(fsp->conn->params)) {
266 *perr = NT_STATUS_OK;
267 return NULL;
268 }
269
270 /* NOTE! 0 byte long ranges ARE allowed and should be stored */
271
272 DEBUG(10,("do_lock: lock flavour %s lock type %s start=%.0f len=%.0f "
273 "blocking_lock=%s requested for fnum %d file %s\n",
274 lock_flav_name(lock_flav), lock_type_name(lock_type),
275 (double)offset, (double)count, blocking_lock ? "true" :
276 "false", fsp->fnum, fsp_str_dbg(fsp)));
277
278 br_lck = brl_get_locks(talloc_tos(), fsp);
279 if (!br_lck) {
280 *perr = NT_STATUS_NO_MEMORY;
281 return NULL;
282 }
283
284 *perr = brl_lock(msg_ctx,
285 br_lck,
286 smblctx,
287 messaging_server_id(fsp->conn->sconn->msg_ctx),
288 offset,
289 count,
290 lock_type,
291 lock_flav,
292 blocking_lock,
293 psmblctx,
294 blr);
295
296 DEBUG(10, ("do_lock: returning status=%s\n", nt_errstr(*perr)));
297
298 increment_current_lock_count(fsp, lock_flav);
299 return br_lck;
300 }
301
302 /****************************************************************************
303 Utility function called by unlocking requests.
304 ****************************************************************************/
305
306 NTSTATUS do_unlock(struct messaging_context *msg_ctx,
307 files_struct *fsp,
308 uint64_t smblctx,
309 uint64_t count,
310 uint64_t offset,
311 enum brl_flavour lock_flav)
312 {
313 bool ok = False;
314 struct byte_range_lock *br_lck = NULL;
315
316 if (!fsp->can_lock) {
317 return fsp->is_directory ? NT_STATUS_INVALID_DEVICE_REQUEST : NT_STATUS_INVALID_HANDLE;
318 }
319
320 if (!lp_locking(fsp->conn->params)) {
321 return NT_STATUS_OK;
322 }
323
324 DEBUG(10,("do_unlock: unlock start=%.0f len=%.0f requested for fnum %d file %s\n",
325 (double)offset, (double)count, fsp->fnum,
326 fsp_str_dbg(fsp)));
327
328 br_lck = brl_get_locks(talloc_tos(), fsp);
329 if (!br_lck) {
330 return NT_STATUS_NO_MEMORY;
331 }
332
333 ok = brl_unlock(msg_ctx,
334 br_lck,
335 smblctx,
336 messaging_server_id(fsp->conn->sconn->msg_ctx),
337 offset,
338 count,
339 lock_flav);
340
341 TALLOC_FREE(br_lck);
342
343 if (!ok) {
344 DEBUG(10,("do_unlock: returning ERRlock.\n" ));
345 return NT_STATUS_RANGE_NOT_LOCKED;
346 }
347
348 decrement_current_lock_count(fsp, lock_flav);
349 return NT_STATUS_OK;
350 }
351
352 /****************************************************************************
353 Cancel any pending blocked locks.
354 ****************************************************************************/
355
356 NTSTATUS do_lock_cancel(files_struct *fsp,
357 uint64 smblctx,
358 uint64_t count,
359 uint64_t offset,
360 enum brl_flavour lock_flav,
361 struct blocking_lock_record *blr)
362 {
363 bool ok = False;
364 struct byte_range_lock *br_lck = NULL;
365
366 if (!fsp->can_lock) {
367 return fsp->is_directory ?
368 NT_STATUS_INVALID_DEVICE_REQUEST : NT_STATUS_INVALID_HANDLE;
369 }
370
371 if (!lp_locking(fsp->conn->params)) {
372 return NT_STATUS_DOS(ERRDOS, ERRcancelviolation);
373 }
374
375 DEBUG(10,("do_lock_cancel: cancel start=%.0f len=%.0f requested for fnum %d file %s\n",
376 (double)offset, (double)count, fsp->fnum,
377 fsp_str_dbg(fsp)));
378
379 br_lck = brl_get_locks(talloc_tos(), fsp);
380 if (!br_lck) {
381 return NT_STATUS_NO_MEMORY;
382 }
383
384 ok = brl_lock_cancel(br_lck,
385 smblctx,
386 messaging_server_id(fsp->conn->sconn->msg_ctx),
387 offset,
388 count,
389 lock_flav,
390 blr);
391
392 TALLOC_FREE(br_lck);
393
394 if (!ok) {
395 DEBUG(10,("do_lock_cancel: returning ERRcancelviolation.\n" ));
396 return NT_STATUS_DOS(ERRDOS, ERRcancelviolation);
397 }
398
399 decrement_current_lock_count(fsp, lock_flav);
400 return NT_STATUS_OK;
401 }
402
403 /****************************************************************************
404 Remove any locks on this fd. Called from file_close().
405 ****************************************************************************/
406
407 void locking_close_file(struct messaging_context *msg_ctx,
408 files_struct *fsp,
409 enum file_close_type close_type)
410 {
411 struct byte_range_lock *br_lck;
412
413 if (!lp_locking(fsp->conn->params)) {
414 return;
415 }
416
417 /* If we have not outstanding locks or pending
418 * locks then we don't need to look in the lock db.
419 */
420
421 if (fsp->current_lock_count == 0) {
422 return;
423 }
424
425 br_lck = brl_get_locks(talloc_tos(),fsp);
426
427 if (br_lck) {
428 cancel_pending_lock_requests_by_fid(fsp, br_lck, close_type);
429 brl_close_fnum(msg_ctx, br_lck);
430 TALLOC_FREE(br_lck);
431 }
432 }
433
434 /****************************************************************************
435 Initialise the locking functions.
436 ****************************************************************************/
437
438 static bool locking_init_internal(bool read_only)
439 {
440 brl_init(read_only);
441
442 if (lock_db)
443 return True;
444
445 lock_db = db_open(NULL, lock_path("locking.tdb"),
446 lp_open_files_db_hash_size(),
447 TDB_DEFAULT|TDB_VOLATILE|TDB_CLEAR_IF_FIRST|TDB_INCOMPATIBLE_HASH,
448 read_only?O_RDONLY:O_RDWR|O_CREAT, 0644);
449
450 if (!lock_db) {
451 DEBUG(0,("ERROR: Failed to initialise locking database\n"));
452 return False;
453 }
454
455 if (!posix_locking_init(read_only))
456 return False;
457
458 return True;
459 }
460
461 bool locking_init(void)
462 {
463 return locking_init_internal(false);
464 }
465
466 bool locking_init_readonly(void)
467 {
468 return locking_init_internal(true);
469 }
470
471 /*******************************************************************
472 Deinitialize the share_mode management.
473 ******************************************************************/
474
475 bool locking_end(void)
476 {
477 brl_shutdown();
478 TALLOC_FREE(lock_db);
479 return true;
480 }
481
482 /*******************************************************************
483 Form a static locking key for a dev/inode pair.
484 ******************************************************************/
485
486 static TDB_DATA locking_key(const struct file_id *id, struct file_id *tmp)
487 {
488 *tmp = *id;
489 return make_tdb_data((const uint8_t *)tmp, sizeof(*tmp));
490 }
491
492 /*******************************************************************
493 Print out a share mode.
494 ********************************************************************/
495
496 char *share_mode_str(TALLOC_CTX *ctx, int num, const struct share_mode_entry *e)
497 {
498 return talloc_asprintf(ctx, "share_mode_entry[%d]: "
499 "pid = %s, share_access = 0x%x, private_options = 0x%x, "
500 "access_mask = 0x%x, mid = 0x%llx, type= 0x%x, gen_id = %llu, "
501 "uid = %u, flags = %u, file_id %s, name_hash = 0x%x",
502 num,
503 procid_str_static(&e->pid),
504 e->share_access, e->private_options,
505 e->access_mask, (unsigned long long)e->op_mid,
506 e->op_type, e->share_file_id,
507 (unsigned int)e->uid, (unsigned int)e->flags,
508 file_id_string_tos(&e->id),
509 (unsigned int)e->name_hash);
510 }
511
512 /*******************************************************************
513 Get all share mode entries for a dev/inode pair.
514 ********************************************************************/
515
516 static bool parse_share_modes(const TDB_DATA dbuf, struct share_mode_lock *lck)
517 {
518 int i;
519 struct server_id *pids;
520 bool *pid_exists;
521 enum ndr_err_code ndr_err;
522 DATA_BLOB blob;
523
524 blob.data = dbuf.dptr;
525 blob.length = dbuf.dsize;
526
527 ndr_err = ndr_pull_struct_blob(
528 &blob, lck, lck,
529 (ndr_pull_flags_fn_t)ndr_pull_share_mode_lock);
530 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
531 DEBUG(1, ("ndr_pull_share_mode_lock failed\n"));
532 return false;
533 }
534
535 lck->modified = false;
536
537 if (DEBUGLEVEL >= 10) {
538 DEBUG(10, ("parse_share_modes:\n"));
539 NDR_PRINT_DEBUG(share_mode_lock, lck);
540 }
541
542 /*
543 * Ensure that each entry has a real process attached.
544 */
545
546 pids = talloc_array(talloc_tos(), struct server_id,
547 lck->num_share_modes);
548 if (pids == NULL) {
549 smb_panic("parse_share_modes: talloc_array failed");
550 }
551 pid_exists = talloc_array(talloc_tos(), bool, lck->num_share_modes);
552 if (pid_exists == NULL) {
553 smb_panic("parse_share_modes: talloc_array failed");
554 }
555
556 for (i=0; i<lck->num_share_modes; i++) {
557 pids[i] = lck->share_modes[i].pid;
558 }
559
560 if (!serverids_exist(pids, lck->num_share_modes, pid_exists)) {
561 smb_panic("parse_share_modes: serverids_exist failed");
562 }
563
564 i = 0;
565 while (i < lck->num_share_modes) {
566 struct share_mode_entry *e = &lck->share_modes[i];
567 if (!pid_exists[i]) {
568 *e = lck->share_modes[lck->num_share_modes-1];
569 lck->num_share_modes -= 1;
570 lck->modified = True;
571 continue;
572 }
573 i += 1;
574 }
575 TALLOC_FREE(pid_exists);
576 TALLOC_FREE(pids);
577
578 return True;
579 }
580
581 static TDB_DATA unparse_share_modes(struct share_mode_lock *lck)
582 {
583 DATA_BLOB blob;
584 enum ndr_err_code ndr_err;
585
586 if (DEBUGLEVEL >= 10) {
587 DEBUG(10, ("unparse_share_modes:\n"));
588 NDR_PRINT_DEBUG(share_mode_lock, lck);
589 }
590
591 if (lck->num_share_modes == 0) {
592 DEBUG(10, ("No used share mode found\n"));
593 return make_tdb_data(NULL, 0);
594 }
595
596 ndr_err = ndr_push_struct_blob(
597 &blob, lck, lck,
598 (ndr_push_flags_fn_t)ndr_push_share_mode_lock);
599 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
600 smb_panic("ndr_push_share_mode_lock failed");
601 }
602
603 return make_tdb_data(blob.data, blob.length);
604 }
605
606 static int share_mode_lock_destructor(struct share_mode_lock *lck)
607 {
608 NTSTATUS status;
609 TDB_DATA data;
610
611 if (!lck->modified) {
612 return 0;
613 }
614
615 data = unparse_share_modes(lck);
616
617 if (data.dptr == NULL) {
618 if (!lck->fresh) {
619 /* There has been an entry before, delete it */
620
621 status = dbwrap_record_delete(lck->record);
622 if (!NT_STATUS_IS_OK(status)) {
623 char *errmsg;
624
625 DEBUG(0, ("delete_rec returned %s\n",
626 nt_errstr(status)));
627
628 if (asprintf(&errmsg, "could not delete share "
629 "entry: %s\n",
630 nt_errstr(status)) == -1) {
631 smb_panic("could not delete share"
632 "entry");
633 }
634 smb_panic(errmsg);
635 }
636 }
637 goto done;
638 }
639
640 status = dbwrap_record_store(lck->record, data, TDB_REPLACE);
641 if (!NT_STATUS_IS_OK(status)) {
642 char *errmsg;
643
644 DEBUG(0, ("store returned %s\n", nt_errstr(status)));
645
646 if (asprintf(&errmsg, "could not store share mode entry: %s",
647 nt_errstr(status)) == -1) {
648 smb_panic("could not store share mode entry");
649 }
650 smb_panic(errmsg);
651 }
652
653 done:
654
655 return 0;
656 }
657
658 static bool fill_share_mode_lock(struct share_mode_lock *lck,
659 struct file_id id,
660 const char *servicepath,
661 const struct smb_filename *smb_fname,
662 TDB_DATA share_mode_data,
663 const struct timespec *old_write_time)
664 {
665 bool fresh;
666
667 /* Ensure we set every field here as the destructor must be
668 valid even if parse_share_modes fails. */
669
670 lck->servicepath = NULL;
671 lck->base_name = NULL;
672 lck->stream_name = NULL;
673 lck->id = id;
674 lck->num_share_modes = 0;
675 lck->share_modes = NULL;
676 lck->num_delete_tokens = 0;
677 lck->delete_tokens = NULL;
678 ZERO_STRUCT(lck->old_write_time);
679 ZERO_STRUCT(lck->changed_write_time);
680
681 fresh = (share_mode_data.dptr == NULL);
682
683 if (fresh) {
684 bool has_stream;
685 if (smb_fname == NULL || servicepath == NULL
686 || old_write_time == NULL) {
687 return False;
688 }
689
690 has_stream = smb_fname->stream_name != NULL;
691
692 lck->base_name = talloc_strdup(lck, smb_fname->base_name);
693 lck->stream_name = talloc_strdup(lck, smb_fname->stream_name);
694 lck->servicepath = talloc_strdup(lck, servicepath);
695 if (lck->base_name == NULL ||
696 (has_stream && lck->stream_name == NULL) ||
697 lck->servicepath == NULL) {
698 DEBUG(0, ("talloc failed\n"));
699 return False;
700 }
701 lck->old_write_time = *old_write_time;
702 lck->modified = false;
703 } else {
704 if (!parse_share_modes(share_mode_data, lck)) {
705 DEBUG(0, ("Could not parse share modes\n"));
706 return False;
707 }
708 }
709 lck->fresh = fresh;
710
711 return True;
712 }
713
714 struct share_mode_lock *get_share_mode_lock(TALLOC_CTX *mem_ctx,
715 const struct file_id id,
716 const char *servicepath,
717 const struct smb_filename *smb_fname,
718 const struct timespec *old_write_time)
719 {
720 struct share_mode_lock *lck;
721 struct file_id tmp;
722 struct db_record *rec;
723 TDB_DATA key = locking_key(&id, &tmp);
724 TDB_DATA value;
725
726 if (!(lck = talloc(mem_ctx, struct share_mode_lock))) {
727 DEBUG(0, ("talloc failed\n"));
728 return NULL;
729 }
730
731 rec = dbwrap_fetch_locked(lock_db, lck, key);
732 if (rec == NULL) {
733 DEBUG(3, ("Could not lock share entry\n"));
734 TALLOC_FREE(lck);
735 return NULL;
736 }
737
738 value = dbwrap_record_get_value(rec);
739
740 if (!fill_share_mode_lock(lck, id, servicepath, smb_fname,
741 value, old_write_time)) {
742 DEBUG(3, ("fill_share_mode_lock failed\n"));
743 TALLOC_FREE(lck);
744 return NULL;
745 }
746
747 lck->record = rec;
748 talloc_set_destructor(lck, share_mode_lock_destructor);
749
750 return lck;
751 }
752
753 struct share_mode_lock *fetch_share_mode_unlocked(TALLOC_CTX *mem_ctx,
754 const struct file_id id)
755 {
756 struct share_mode_lock *lck;
757 struct file_id tmp;
758 TDB_DATA key = locking_key(&id, &tmp);
759 TDB_DATA data;
760 NTSTATUS status;
761
762 if (!(lck = talloc(mem_ctx, struct share_mode_lock))) {
763 DEBUG(0, ("talloc failed\n"));
764 return NULL;
765 }
766
767 status = dbwrap_fetch(lock_db, lck, key, &data);
768 if (!NT_STATUS_IS_OK(status)) {
769 DEBUG(3, ("Could not fetch share entry\n"));
770 TALLOC_FREE(lck);
771 return NULL;
772 }
773 if (data.dptr == NULL) {
774 TALLOC_FREE(lck);
775 return NULL;
776 }
777
778 if (!fill_share_mode_lock(lck, id, NULL, NULL, data, NULL)) {
779 DEBUG(10, ("fetch_share_mode_unlocked: no share_mode record "
780 "around (file not open)\n"));
781 TALLOC_FREE(lck);
782 return NULL;
783 }
784
785 return lck;
786 }
787
788 /*******************************************************************
789 Sets the service name and filename for rename.
790 At this point we emit "file renamed" messages to all
791 process id's that have this file open.
792 Based on an initial code idea from SATOH Fumiyasu <fumiya@samba.gr.jp>
793 ********************************************************************/
794
795 bool rename_share_filename(struct messaging_context *msg_ctx,
796 struct share_mode_lock *lck,
797 const char *servicepath,
798 uint32_t orig_name_hash,
799 uint32_t new_name_hash,
800 const struct smb_filename *smb_fname_dst)
801 {
802 size_t sp_len;
803 size_t bn_len;
804 size_t sn_len;
805 size_t msg_len;
806 char *frm = NULL;
807 int i;
808 bool strip_two_chars = false;
809 bool has_stream = smb_fname_dst->stream_name != NULL;
810
811 DEBUG(10, ("rename_share_filename: servicepath %s newname %s\n",
812 servicepath, smb_fname_dst->base_name));
813
814 /*
815 * rename_internal_fsp() and rename_internals() add './' to
816 * head of newname if newname does not contain a '/'.
817 */
818 if (smb_fname_dst->base_name[0] &&
819 smb_fname_dst->base_name[1] &&
820 smb_fname_dst->base_name[0] == '.' &&
821 smb_fname_dst->base_name[1] == '/') {
822 strip_two_chars = true;
823 }
824
825 lck->servicepath = talloc_strdup(lck, servicepath);
826 lck->base_name = talloc_strdup(lck, smb_fname_dst->base_name +
827 (strip_two_chars ? 2 : 0));
828 lck->stream_name = talloc_strdup(lck, smb_fname_dst->stream_name);
829 if (lck->base_name == NULL ||
830 (has_stream && lck->stream_name == NULL) ||
831 lck->servicepath == NULL) {
832 DEBUG(0, ("rename_share_filename: talloc failed\n"));
833 return False;
834 }
835 lck->modified = True;
836
837 sp_len = strlen(lck->servicepath);
838 bn_len = strlen(lck->base_name);
839 sn_len = has_stream ? strlen(lck->stream_name) : 0;
840
841 msg_len = MSG_FILE_RENAMED_MIN_SIZE + sp_len + 1 + bn_len + 1 +
842 sn_len + 1;
843
844 /* Set up the name changed message. */
845 frm = talloc_array(lck, char, msg_len);
846 if (!frm) {
847 return False;
848 }
849
850 push_file_id_24(frm, &lck->id);
851
852 DEBUG(10,("rename_share_filename: msg_len = %u\n", (unsigned int)msg_len ));
853
854 strlcpy(&frm[24],
855 lck->servicepath ? lck->servicepath : "",
856 sp_len+1);
857 strlcpy(&frm[24 + sp_len + 1],
858 lck->base_name ? lck->base_name : "",
859 bn_len+1);
860 strlcpy(&frm[24 + sp_len + 1 + bn_len + 1],
861 lck->stream_name ? lck->stream_name : "",
862 sn_len+1);
863
864 /* Send the messages. */
865 for (i=0; i<lck->num_share_modes; i++) {
866 struct share_mode_entry *se = &lck->share_modes[i];
867 if (!is_valid_share_mode_entry(se)) {
868 continue;
869 }
870
871 /* If this is a hardlink to the inode
872 with a different name, skip this. */
873 if (se->name_hash != orig_name_hash) {
874 continue;
875 }
876
877 se->name_hash = new_name_hash;
878
879 /* But not to ourselves... */
880 if (procid_is_me(&se->pid)) {
881 continue;
882 }
883
884 DEBUG(10,("rename_share_filename: sending rename message to "
885 "pid %s file_id %s sharepath %s base_name %s "
886 "stream_name %s\n",
887 procid_str_static(&se->pid),
888 file_id_string_tos(&lck->id),
889 lck->servicepath, lck->base_name,
890 has_stream ? lck->stream_name : ""));
891
892 messaging_send_buf(msg_ctx, se->pid, MSG_SMB_FILE_RENAME,
893 (uint8 *)frm, msg_len);
894 }
895
896 return True;
897 }
898
899 void get_file_infos(struct file_id id,
900 uint32_t name_hash,
901 bool *delete_on_close,
902 struct timespec *write_time)
903 {
904 struct share_mode_lock *lck;
905
906 if (delete_on_close) {
907 *delete_on_close = false;
908 }
909
910 if (write_time) {
911 ZERO_STRUCTP(write_time);
912 }
913
914 if (!(lck = fetch_share_mode_unlocked(talloc_tos(), id))) {
915 return;
916 }
917
918 if (delete_on_close) {
919 *delete_on_close = is_delete_on_close_set(lck, name_hash);
920 }
921
922 if (write_time) {
923 struct timespec wt;
924
925 wt = lck->changed_write_time;
926 if (null_timespec(wt)) {
927 wt = lck->old_write_time;
928 }
929
930 *write_time = wt;
931 }
932
933 TALLOC_FREE(lck);
934 }
935
936 bool is_valid_share_mode_entry(const struct share_mode_entry *e)
937 {
938 int num_props = 0;
939
940 num_props += ((e->op_type == NO_OPLOCK) ? 1 : 0);
941 num_props += (EXCLUSIVE_OPLOCK_TYPE(e->op_type) ? 1 : 0);
942 num_props += (LEVEL_II_OPLOCK_TYPE(e->op_type) ? 1 : 0);
943
944 SMB_ASSERT(num_props <= 1);
945 return (num_props != 0);
946 }
947
948 bool is_deferred_open_entry(const struct share_mode_entry *e)
949 {
950 return (e->op_type == DEFERRED_OPEN_ENTRY);
951 }
952
953 /*******************************************************************
954 Fill a share mode entry.
955 ********************************************************************/
956
957 static void fill_share_mode_entry(struct share_mode_entry *e,
958 files_struct *fsp,
959 uid_t uid, uint64_t mid, uint16 op_type)
960 {
961 ZERO_STRUCTP(e);
962 e->pid = messaging_server_id(fsp->conn->sconn->msg_ctx);
963 e->share_access = fsp->share_access;
964 e->private_options = fsp->fh->private_options;
965 e->access_mask = fsp->access_mask;
966 e->op_mid = mid;
967 e->op_type = op_type;
968 e->time.tv_sec = fsp->open_time.tv_sec;
969 e->time.tv_usec = fsp->open_time.tv_usec;
970 e->id = fsp->file_id;
971 e->share_file_id = fsp->fh->gen_id;
972 e->uid = (uint32)uid;
973 e->flags = fsp->posix_open ? SHARE_MODE_FLAG_POSIX_OPEN : 0;
974 e->name_hash = fsp->name_hash;
975 }
976
977 static void fill_deferred_open_entry(struct share_mode_entry *e,
978 const struct timeval request_time,
979 struct file_id id,
980 struct server_id pid,
981 uint64_t mid)
982 {
983 ZERO_STRUCTP(e);
984 e->pid = pid;
985 e->op_mid = mid;
986 e->op_type = DEFERRED_OPEN_ENTRY;
987 e->time.tv_sec = request_time.tv_sec;
988 e->time.tv_usec = request_time.tv_usec;
989 e->id = id;
990 e->uid = (uint32)-1;
991 e->flags = 0;
992 }
993
994 static void add_share_mode_entry(struct share_mode_lock *lck,
995 const struct share_mode_entry *entry)
996 {
997 ADD_TO_ARRAY(lck, struct share_mode_entry, *entry,
998 &lck->share_modes, &lck->num_share_modes);
999 lck->modified = True;
1000 }
1001
1002 void set_share_mode(struct share_mode_lock *lck, files_struct *fsp,
1003 uid_t uid, uint64_t mid, uint16 op_type)
1004 {
1005 struct share_mode_entry entry;
1006 fill_share_mode_entry(&entry, fsp, uid, mid, op_type);
1007 add_share_mode_entry(lck, &entry);
1008 }
1009
1010 void add_deferred_open(struct share_mode_lock *lck, uint64_t mid,
1011 struct timeval request_time,
1012 struct server_id pid, struct file_id id)
1013 {
1014 struct share_mode_entry entry;
1015 fill_deferred_open_entry(&entry, request_time, id, pid, mid);
1016 add_share_mode_entry(lck, &entry);
1017 }
1018
1019 /*******************************************************************
1020 Check if two share mode entries are identical, ignoring oplock
1021 and mid info and desired_access. (Removed paranoia test - it's
1022 not automatically a logic error if they are identical. JRA.)
1023 ********************************************************************/
1024
1025 static bool share_modes_identical(struct share_mode_entry *e1,
1026 struct share_mode_entry *e2)
1027 {
1028 /* We used to check for e1->share_access == e2->share_access here
1029 as well as the other fields but 2 different DOS or FCB opens
1030 sharing the same share mode entry may validly differ in
1031 fsp->share_access field. */
1032
1033 return (procid_equal(&e1->pid, &e2->pid) &&
1034 file_id_equal(&e1->id, &e2->id) &&
1035 e1->share_file_id == e2->share_file_id );
1036 }
1037
1038 static bool deferred_open_identical(struct share_mode_entry *e1,
1039 struct share_mode_entry *e2)
1040 {
1041 return (procid_equal(&e1->pid, &e2->pid) &&
1042 (e1->op_mid == e2->op_mid) &&
1043 file_id_equal(&e1->id, &e2->id));
1044 }
1045
1046 static struct share_mode_entry *find_share_mode_entry(struct share_mode_lock *lck,
1047 struct share_mode_entry *entry)
1048 {
1049 int i;
1050
1051 for (i=0; i<lck->num_share_modes; i++) {
1052 struct share_mode_entry *e = &lck->share_modes[i];
1053 if (is_valid_share_mode_entry(entry) &&
1054 is_valid_share_mode_entry(e) &&
1055 share_modes_identical(e, entry)) {
1056 return e;
1057 }
1058 if (is_deferred_open_entry(entry) &&
1059 is_deferred_open_entry(e) &&
1060 deferred_open_identical(e, entry)) {
1061 return e;
1062 }
1063 }
1064 return NULL;
1065 }
1066
1067 /*******************************************************************
1068 Del the share mode of a file for this process. Return the number of
1069 entries left.
1070 ********************************************************************/
1071
1072 bool del_share_mode(struct share_mode_lock *lck, files_struct *fsp)
1073 {
1074 struct share_mode_entry entry, *e;
1075
1076 /* Don't care about the pid owner being correct here - just a search. */
1077 fill_share_mode_entry(&entry, fsp, (uid_t)-1, 0, NO_OPLOCK);
1078
1079 e = find_share_mode_entry(lck, &entry);
1080 if (e == NULL) {
1081 return False;
1082 }
1083 *e = lck->share_modes[lck->num_share_modes-1];
1084 lck->num_share_modes -= 1;
1085 lck->modified = True;
1086 return True;
1087 }
1088
1089 void del_deferred_open_entry(struct share_mode_lock *lck, uint64_t mid,
1090 struct server_id pid)
1091 {
1092 struct share_mode_entry entry, *e;
1093
1094 fill_deferred_open_entry(&entry, timeval_zero(),
1095 lck->id, pid, mid);
1096
1097 e = find_share_mode_entry(lck, &entry);
1098 if (e == NULL) {
1099 return;
1100 }
1101 *e = lck->share_modes[lck->num_share_modes-1];
1102 lck->num_share_modes -= 1;
1103 lck->modified = True;
1104 }
1105
1106 /*******************************************************************
1107 Remove an oplock mid and mode entry from a share mode.
1108 ********************************************************************/
1109
1110 bool remove_share_oplock(struct share_mode_lock *lck, files_struct *fsp)
1111 {
1112 struct share_mode_entry entry, *e;
1113
1114 /* Don't care about the pid owner being correct here - just a search. */
1115 fill_share_mode_entry(&entry, fsp, (uid_t)-1, 0, NO_OPLOCK);
1116
1117 e = find_share_mode_entry(lck, &entry);
1118 if (e == NULL) {
1119 return False;
1120 }
1121
1122 if (EXCLUSIVE_OPLOCK_TYPE(e->op_type)) {
1123 /*
1124 * Going from exclusive or batch,
1125 * we always go through FAKE_LEVEL_II
1126 * first.
1127 */
1128 if (!EXCLUSIVE_OPLOCK_TYPE(fsp->oplock_type)) {
1129 smb_panic("remove_share_oplock: logic error");
1130 }
1131 e->op_type = FAKE_LEVEL_II_OPLOCK;
1132 } else {
1133 e->op_type = NO_OPLOCK;
1134 }
1135 lck->modified = True;
1136 return True;
1137 }
1138
1139 /*******************************************************************
1140 Downgrade a oplock type from exclusive to level II.
1141 ********************************************************************/
1142
1143 bool downgrade_share_oplock(struct share_mode_lock *lck, files_struct *fsp)
1144 {
1145 struct share_mode_entry entry, *e;
1146
1147 /* Don't care about the pid owner being correct here - just a search. */
1148 fill_share_mode_entry(&entry, fsp, (uid_t)-1, 0, NO_OPLOCK);
1149
1150 e = find_share_mode_entry(lck, &entry);
1151 if (e == NULL) {
1152 return False;
1153 }
1154
1155 e->op_type = LEVEL_II_OPLOCK;
1156 lck->modified = True;
1157 return True;
1158 }
1159
1160 /*************************************************************************
1161 Return a talloced copy of a struct security_unix_token. NULL on fail.
1162 (Should this be in locking.c.... ?).
1163 *************************************************************************/
1164
1165 static struct security_unix_token *copy_unix_token(TALLOC_CTX *ctx, const struct security_unix_token *tok)
1166 {
1167 struct security_unix_token *cpy;
1168
1169 cpy = talloc(ctx, struct security_unix_token);
1170 if (!cpy) {
1171 return NULL;
1172 }
1173
1174 cpy->uid = tok->uid;
1175 cpy->gid = tok->gid;
1176 cpy->ngroups = tok->ngroups;
1177 if (tok->ngroups) {
1178 /* Make this a talloc child of cpy. */
1179 cpy->groups = (gid_t *)talloc_memdup(
1180 cpy, tok->groups, tok->ngroups * sizeof(gid_t));
1181 if (!cpy->groups) {
1182 TALLOC_FREE(cpy);
1183 return NULL;
1184 }
1185 }
1186 return cpy;
1187 }
1188
1189 /****************************************************************************
1190 Adds a delete on close token.
1191 ****************************************************************************/
1192
1193 static bool add_delete_on_close_token(struct share_mode_lock *lck,
1194 uint32_t name_hash,
1195 const struct security_unix_token *tok)
1196 {
1197 struct delete_token *tmp, *dtl;
1198
1199 tmp = talloc_realloc(lck, lck->delete_tokens, struct delete_token,
1200 lck->num_delete_tokens+1);
1201 if (tmp == NULL) {
1202 return false;
1203 }
1204 lck->delete_tokens = tmp;
1205 dtl = &lck->delete_tokens[lck->num_delete_tokens];
1206
1207 dtl->name_hash = name_hash;
1208 dtl->delete_token = copy_unix_token(lck->delete_tokens, tok);
1209 if (dtl->delete_token == NULL) {
1210 return false;
1211 }
1212 lck->num_delete_tokens += 1;
1213 lck->modified = true;
1214 return true;
1215 }
1216
1217 /****************************************************************************
1218 Sets the delete on close flag over all share modes on this file.
1219 Modify the share mode entry for all files open
1220 on this device and inode to tell other smbds we have
1221 changed the delete on close flag. This will be noticed
1222 in the close code, the last closer will delete the file
1223 if flag is set.
1224 This makes a copy of any struct security_unix_token into the
1225 lck entry. This function is used when the lock is already granted.
1226 ****************************************************************************/
1227
1228 void set_delete_on_close_lck(files_struct *fsp,
1229 struct share_mode_lock *lck,
1230 bool delete_on_close,
1231 const struct security_unix_token *tok)
1232 {
1233 int i;
1234 bool ret;
1235
1236 if (delete_on_close) {
1237 SMB_ASSERT(tok != NULL);
1238 } else {
1239 SMB_ASSERT(tok == NULL);
1240 }
1241
1242 for (i=0; i<lck->num_delete_tokens; i++) {
1243 struct delete_token *dt = &lck->delete_tokens[i];
1244 if (dt->name_hash == fsp->name_hash) {
1245 lck->modified = true;
1246 if (delete_on_close == false) {
1247 /* Delete this entry. */
1248 TALLOC_FREE(dt->delete_token);
1249 *dt = lck->delete_tokens[
1250 lck->num_delete_tokens-1];
1251 lck->num_delete_tokens -= 1;
1252 return;
1253 }
1254 /* Replace this token with the
1255 given tok. */
1256 TALLOC_FREE(dt->delete_token);
1257 dt->delete_token = copy_unix_token(dt, tok);
1258 SMB_ASSERT(dt->delete_token != NULL);
1259 }
1260 }
1261
1262 if (!delete_on_close) {
1263 /* Nothing to delete - not found. */
1264 return;
1265 }
1266
1267 ret = add_delete_on_close_token(lck, fsp->name_hash, tok);
1268 SMB_ASSERT(ret);
1269 }
1270
1271 bool set_delete_on_close(files_struct *fsp, bool delete_on_close, const struct security_unix_token *tok)
1272 {
1273 struct share_mode_lock *lck;
1274
1275 DEBUG(10,("set_delete_on_close: %s delete on close flag for "
1276 "fnum = %d, file %s\n",
1277 delete_on_close ? "Adding" : "Removing", fsp->fnum,
1278 fsp_str_dbg(fsp)));
1279
1280 lck = get_share_mode_lock(talloc_tos(), fsp->file_id, NULL, NULL,
1281 NULL);
1282 if (lck == NULL) {
1283 return False;
1284 }
1285
1286 set_delete_on_close_lck(fsp, lck, delete_on_close,
1287 delete_on_close ? tok : NULL);
1288
1289 if (fsp->is_directory) {
1290 SMB_ASSERT(!is_ntfs_stream_smb_fname(fsp->fsp_name));
1291 send_stat_cache_delete_message(fsp->conn->sconn->msg_ctx,
1292 fsp->fsp_name->base_name);
1293 }
1294
1295 TALLOC_FREE(lck);
1296
1297 fsp->delete_on_close = delete_on_close;
1298
1299 return True;
1300 }
1301
1302 const struct security_unix_token *get_delete_on_close_token(struct share_mode_lock *lck, uint32_t name_hash)
1303 {
1304 int i;
1305
1306 DEBUG(10,("get_delete_on_close_token: name_hash = 0x%x\n",
1307 (unsigned int)name_hash ));
1308
1309 for (i=0; i<lck->num_delete_tokens; i++) {
1310 struct delete_token *dt = &lck->delete_tokens[i];
1311 DEBUG(10,("get_delete_on_close_token: dtl->name_hash = 0x%x\n",
1312 (unsigned int)dt->name_hash ));
1313 if (dt->name_hash == name_hash) {
1314 return dt->delete_token;
1315 }
1316 }
1317 return NULL;
1318 }
1319
1320 bool is_delete_on_close_set(struct share_mode_lock *lck, uint32_t name_hash)
1321 {
1322 return (get_delete_on_close_token(lck, name_hash) != NULL);
1323 }
1324
1325 bool set_sticky_write_time(struct file_id fileid, struct timespec write_time)
1326 {
1327 struct share_mode_lock *lck;
1328
1329 DEBUG(5,("set_sticky_write_time: %s id=%s\n",
1330 timestring(talloc_tos(),
1331 convert_timespec_to_time_t(write_time)),
1332 file_id_string_tos(&fileid)));
1333
1334 lck = get_share_mode_lock(talloc_tos(), fileid, NULL, NULL, NULL);
1335 if (lck == NULL) {
1336 return False;
1337 }
1338
1339 if (timespec_compare(&lck->changed_write_time, &write_time) != 0) {
1340 lck->modified = True;
1341 lck->changed_write_time = write_time;
1342 }
1343
1344 TALLOC_FREE(lck);
1345 return True;
1346 }
1347
1348 bool set_write_time(struct file_id fileid, struct timespec write_time)
1349 {
1350 struct share_mode_lock *lck;
1351
1352 DEBUG(5,("set_write_time: %s id=%s\n",
1353 timestring(talloc_tos(),
1354 convert_timespec_to_time_t(write_time)),
1355 file_id_string_tos(&fileid)));
1356
1357 lck = get_share_mode_lock(talloc_tos(), fileid, NULL, NULL, NULL);
1358 if (lck == NULL) {
1359 return False;
1360 }
1361
1362 if (timespec_compare(&lck->old_write_time, &write_time) != 0) {
1363 lck->modified = True;
1364 lck->old_write_time = write_time;
1365 }
1366
1367 TALLOC_FREE(lck);
1368 return True;
1369 }
1370
1371
1372 struct forall_state {
1373 void (*fn)(const struct share_mode_entry *entry,
1374 const char *sharepath,
1375 const char *fname,
1376 void *private_data);
1377 void *private_data;
1378 };
1379
1380 static int traverse_fn(struct db_record *rec, void *_state)
1381 {
1382 struct forall_state *state = (struct forall_state *)_state;
1383 uint32_t i;
1384 TDB_DATA key;
1385 TDB_DATA value;
1386 DATA_BLOB blob;
1387 enum ndr_err_code ndr_err;
1388 struct share_mode_lock *lck;
1389
1390 key = dbwrap_record_get_key(rec);
1391 value = dbwrap_record_get_value(rec);
1392
1393 /* Ensure this is a locking_key record. */
1394 if (key.dsize != sizeof(struct file_id))
1395 return 0;
1396
1397 lck = talloc(talloc_tos(), struct share_mode_lock);
1398 if (lck == NULL) {
1399 return 0;
1400 }
1401
1402 blob.data = value.dptr;
1403 blob.length = value.dsize;
1404
1405 ndr_err = ndr_pull_struct_blob(
1406 &blob, lck, lck,
1407 (ndr_pull_flags_fn_t)ndr_pull_share_mode_lock);
1408 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1409 DEBUG(1, ("ndr_pull_share_mode_lock failed\n"));
1410 return 0;
1411 }
1412 for (i=0; i<lck->num_share_modes; i++) {
1413 state->fn(&lck->share_modes[i],
1414 lck->servicepath, lck->base_name,
1415 state->private_data);
1416 }
1417 TALLOC_FREE(lck);
1418
1419 return 0;
1420 }
1421
1422 /*******************************************************************
1423 Call the specified function on each entry under management by the
1424 share mode system.
1425 ********************************************************************/
1426
1427 int share_mode_forall(void (*fn)(const struct share_mode_entry *, const char *,
1428 const char *, void *),
1429 void *private_data)
1430 {
1431 struct forall_state state;
1432 NTSTATUS status;
1433 int count;
1434
1435 if (lock_db == NULL)
1436 return 0;
1437
1438 state.fn = fn;
1439 state.private_data = private_data;
1440
1441 status = dbwrap_traverse_read(lock_db, traverse_fn, (void *)&state,
1442 &count);
1443
1444 if (!NT_STATUS_IS_OK(status)) {
1445 return -1;
1446 } else {
1447 return count;
1448 }
1449 }
reg import