2 Unix SMB/CIFS implementation.
4 Copyright (C) Andrew Tridgell 1992-2000
5 Copyright (C) Jeremy Allison 1992-2006
6 Copyright (C) Volker Lendecke 2005
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program. If not, see <http://www.gnu.org/licenses/>.
23 12 aug 96: Erik.Devriendt@te6.siemens.be
24 added support for shared memory implementation of share mode locking
26 May 1997. Jeremy Allison (jallison@whistle.com). Modified share mode
27 locking to deal with multiple share modes per open file.
29 September 1997. Jeremy Allison (jallison@whistle.com). Added oplock
32 rewritten completely to use new tdb code. Tridge, Dec '99
34 Added POSIX locking support. Jeremy Allison (jeremy@valinux.com), Apr. 2000.
35 Added Unix Extensions POSIX locking support. Jeremy Allison Mar 2006.
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"
48 #include "../librpc/gen_ndr/ndr_open_files.h"
51 #define DBGC_CLASS DBGC_LOCKING
53 #define NO_LOCKING_COUNT (-1)
55 /****************************************************************************
57 ****************************************************************************/
59 const char *lock_type_name(enum brl_type lock_type
)
66 case PENDING_READ_LOCK
:
67 return "PENDING_READ";
68 case PENDING_WRITE_LOCK
:
69 return "PENDING_WRITE";
75 const char *lock_flav_name(enum brl_flavour lock_flav
)
77 return (lock_flav
== WINDOWS_LOCK
) ? "WINDOWS_LOCK" : "POSIX_LOCK";
80 /****************************************************************************
81 Utility function called to see if a file region is locked.
82 Called in the read/write codepath.
83 ****************************************************************************/
85 void init_strict_lock_struct(files_struct
*fsp
,
89 enum brl_type lock_type
,
90 struct lock_struct
*plock
)
92 SMB_ASSERT(lock_type
== READ_LOCK
|| lock_type
== WRITE_LOCK
);
94 plock
->context
.smblctx
= smblctx
;
95 plock
->context
.tid
= fsp
->conn
->cnum
;
96 plock
->context
.pid
= messaging_server_id(fsp
->conn
->sconn
->msg_ctx
);
99 plock
->fnum
= fsp
->fnum
;
100 plock
->lock_type
= lock_type
;
101 plock
->lock_flav
= lp_posix_cifsu_locktype(fsp
);
104 bool strict_lock_default(files_struct
*fsp
, struct lock_struct
*plock
)
106 int strict_locking
= lp_strict_locking(fsp
->conn
->params
);
109 if (plock
->size
== 0) {
113 if (!lp_locking(fsp
->conn
->params
) || !strict_locking
) {
117 if (strict_locking
== Auto
) {
118 if (EXCLUSIVE_OPLOCK_TYPE(fsp
->oplock_type
) && (plock
->lock_type
== READ_LOCK
|| plock
->lock_type
== WRITE_LOCK
)) {
119 DEBUG(10,("is_locked: optimisation - exclusive oplock on file %s\n", fsp_str_dbg(fsp
)));
121 } else if ((fsp
->oplock_type
== LEVEL_II_OPLOCK
) &&
122 (plock
->lock_type
== READ_LOCK
)) {
123 DEBUG(10,("is_locked: optimisation - level II oplock on file %s\n", fsp_str_dbg(fsp
)));
126 struct byte_range_lock
*br_lck
;
128 br_lck
= brl_get_locks_readonly(fsp
);
132 ret
= brl_locktest(br_lck
,
133 plock
->context
.smblctx
,
141 struct byte_range_lock
*br_lck
;
143 br_lck
= brl_get_locks_readonly(fsp
);
147 ret
= brl_locktest(br_lck
,
148 plock
->context
.smblctx
,
156 DEBUG(10,("strict_lock_default: flavour = %s brl start=%.0f "
157 "len=%.0f %s for fnum %llu file %s\n",
158 lock_flav_name(plock
->lock_flav
),
159 (double)plock
->start
, (double)plock
->size
,
160 ret
? "unlocked" : "locked",
161 (unsigned long long)plock
->fnum
, fsp_str_dbg(fsp
)));
166 void strict_unlock_default(files_struct
*fsp
, struct lock_struct
*plock
)
170 /****************************************************************************
171 Find out if a lock could be granted - return who is blocking us if we can't.
172 ****************************************************************************/
174 NTSTATUS
query_lock(files_struct
*fsp
,
178 enum brl_type
*plock_type
,
179 enum brl_flavour lock_flav
)
181 struct byte_range_lock
*br_lck
= NULL
;
183 if (!fsp
->can_lock
) {
184 return fsp
->is_directory
? NT_STATUS_INVALID_DEVICE_REQUEST
: NT_STATUS_INVALID_HANDLE
;
187 if (!lp_locking(fsp
->conn
->params
)) {
191 br_lck
= brl_get_locks_readonly(fsp
);
193 return NT_STATUS_NO_MEMORY
;
196 return brl_lockquery(br_lck
,
198 messaging_server_id(fsp
->conn
->sconn
->msg_ctx
),
205 static void increment_current_lock_count(files_struct
*fsp
,
206 enum brl_flavour lock_flav
)
208 if (lock_flav
== WINDOWS_LOCK
&&
209 fsp
->current_lock_count
!= NO_LOCKING_COUNT
) {
210 /* blocking ie. pending, locks also count here,
211 * as this is an efficiency counter to avoid checking
212 * the lock db. on close. JRA. */
214 fsp
->current_lock_count
++;
216 /* Notice that this has had a POSIX lock request.
217 * We can't count locks after this so forget them.
219 fsp
->current_lock_count
= NO_LOCKING_COUNT
;
223 static void decrement_current_lock_count(files_struct
*fsp
,
224 enum brl_flavour lock_flav
)
226 if (lock_flav
== WINDOWS_LOCK
&&
227 fsp
->current_lock_count
!= NO_LOCKING_COUNT
) {
228 SMB_ASSERT(fsp
->current_lock_count
> 0);
229 fsp
->current_lock_count
--;
233 /****************************************************************************
234 Utility function called by locking requests.
235 ****************************************************************************/
237 struct byte_range_lock
*do_lock(struct messaging_context
*msg_ctx
,
242 enum brl_type lock_type
,
243 enum brl_flavour lock_flav
,
247 struct blocking_lock_record
*blr
)
249 struct byte_range_lock
*br_lck
= NULL
;
251 /* silently return ok on print files as we don't do locking there */
252 if (fsp
->print_file
) {
253 *perr
= NT_STATUS_OK
;
257 if (!fsp
->can_lock
) {
258 *perr
= fsp
->is_directory
? NT_STATUS_INVALID_DEVICE_REQUEST
: NT_STATUS_INVALID_HANDLE
;
262 if (!lp_locking(fsp
->conn
->params
)) {
263 *perr
= NT_STATUS_OK
;
267 /* NOTE! 0 byte long ranges ARE allowed and should be stored */
269 DEBUG(10,("do_lock: lock flavour %s lock type %s start=%.0f len=%.0f "
270 "blocking_lock=%s requested for %s file %s\n",
271 lock_flav_name(lock_flav
), lock_type_name(lock_type
),
272 (double)offset
, (double)count
, blocking_lock
? "true" :
273 "false", fsp_fnum_dbg(fsp
), fsp_str_dbg(fsp
)));
275 br_lck
= brl_get_locks(talloc_tos(), fsp
);
277 *perr
= NT_STATUS_NO_MEMORY
;
281 *perr
= brl_lock(msg_ctx
,
284 messaging_server_id(fsp
->conn
->sconn
->msg_ctx
),
293 DEBUG(10, ("do_lock: returning status=%s\n", nt_errstr(*perr
)));
295 increment_current_lock_count(fsp
, lock_flav
);
299 /****************************************************************************
300 Utility function called by unlocking requests.
301 ****************************************************************************/
303 NTSTATUS
do_unlock(struct messaging_context
*msg_ctx
,
308 enum brl_flavour lock_flav
)
311 struct byte_range_lock
*br_lck
= NULL
;
313 if (!fsp
->can_lock
) {
314 return fsp
->is_directory
? NT_STATUS_INVALID_DEVICE_REQUEST
: NT_STATUS_INVALID_HANDLE
;
317 if (!lp_locking(fsp
->conn
->params
)) {
321 DEBUG(10,("do_unlock: unlock start=%.0f len=%.0f requested for %s file %s\n",
322 (double)offset
, (double)count
, fsp_fnum_dbg(fsp
),
325 br_lck
= brl_get_locks(talloc_tos(), fsp
);
327 return NT_STATUS_NO_MEMORY
;
330 ok
= brl_unlock(msg_ctx
,
333 messaging_server_id(fsp
->conn
->sconn
->msg_ctx
),
341 DEBUG(10,("do_unlock: returning ERRlock.\n" ));
342 return NT_STATUS_RANGE_NOT_LOCKED
;
345 decrement_current_lock_count(fsp
, lock_flav
);
349 /****************************************************************************
350 Cancel any pending blocked locks.
351 ****************************************************************************/
353 NTSTATUS
do_lock_cancel(files_struct
*fsp
,
357 enum brl_flavour lock_flav
,
358 struct blocking_lock_record
*blr
)
361 struct byte_range_lock
*br_lck
= NULL
;
363 if (!fsp
->can_lock
) {
364 return fsp
->is_directory
?
365 NT_STATUS_INVALID_DEVICE_REQUEST
: NT_STATUS_INVALID_HANDLE
;
368 if (!lp_locking(fsp
->conn
->params
)) {
369 return NT_STATUS_DOS(ERRDOS
, ERRcancelviolation
);
372 DEBUG(10,("do_lock_cancel: cancel start=%.0f len=%.0f requested for %s file %s\n",
373 (double)offset
, (double)count
, fsp_fnum_dbg(fsp
),
376 br_lck
= brl_get_locks(talloc_tos(), fsp
);
378 return NT_STATUS_NO_MEMORY
;
381 ok
= brl_lock_cancel(br_lck
,
383 messaging_server_id(fsp
->conn
->sconn
->msg_ctx
),
392 DEBUG(10,("do_lock_cancel: returning ERRcancelviolation.\n" ));
393 return NT_STATUS_DOS(ERRDOS
, ERRcancelviolation
);
396 decrement_current_lock_count(fsp
, lock_flav
);
400 /****************************************************************************
401 Remove any locks on this fd. Called from file_close().
402 ****************************************************************************/
404 void locking_close_file(struct messaging_context
*msg_ctx
,
406 enum file_close_type close_type
)
408 struct byte_range_lock
*br_lck
;
410 if (!lp_locking(fsp
->conn
->params
)) {
414 /* If we have not outstanding locks or pending
415 * locks then we don't need to look in the lock db.
418 if (fsp
->current_lock_count
== 0) {
422 br_lck
= brl_get_locks(talloc_tos(),fsp
);
425 cancel_pending_lock_requests_by_fid(fsp
, br_lck
, close_type
);
426 brl_close_fnum(msg_ctx
, br_lck
);
431 /*******************************************************************
432 Print out a share mode.
433 ********************************************************************/
435 char *share_mode_str(TALLOC_CTX
*ctx
, int num
, const struct share_mode_entry
*e
)
437 return talloc_asprintf(ctx
, "share_mode_entry[%d]: "
438 "pid = %s, share_access = 0x%x, private_options = 0x%x, "
439 "access_mask = 0x%x, mid = 0x%llx, type= 0x%x, gen_id = %llu, "
440 "uid = %u, flags = %u, file_id %s, name_hash = 0x%x",
442 procid_str_static(&e
->pid
),
443 e
->share_access
, e
->private_options
,
444 e
->access_mask
, (unsigned long long)e
->op_mid
,
445 e
->op_type
, (unsigned long long)e
->share_file_id
,
446 (unsigned int)e
->uid
, (unsigned int)e
->flags
,
447 file_id_string_tos(&e
->id
),
448 (unsigned int)e
->name_hash
);
451 /*******************************************************************
452 Fetch a share mode where we know one MUST exist. This call reference
453 counts it internally to allow for nested lock fetches.
454 ********************************************************************/
456 struct share_mode_lock
*get_existing_share_mode_lock(TALLOC_CTX
*mem_ctx
,
457 const struct file_id id
)
459 return get_share_mode_lock(mem_ctx
, id
, NULL
, NULL
, NULL
);
462 /*******************************************************************
463 Sets the service name and filename for rename.
464 At this point we emit "file renamed" messages to all
465 process id's that have this file open.
466 Based on an initial code idea from SATOH Fumiyasu <fumiya@samba.gr.jp>
467 ********************************************************************/
469 bool rename_share_filename(struct messaging_context
*msg_ctx
,
470 struct share_mode_lock
*lck
,
471 const char *servicepath
,
472 uint32_t orig_name_hash
,
473 uint32_t new_name_hash
,
474 const struct smb_filename
*smb_fname_dst
)
476 struct share_mode_data
*d
= lck
->data
;
483 bool strip_two_chars
= false;
484 bool has_stream
= smb_fname_dst
->stream_name
!= NULL
;
485 struct server_id self_pid
= messaging_server_id(msg_ctx
);
487 DEBUG(10, ("rename_share_filename: servicepath %s newname %s\n",
488 servicepath
, smb_fname_dst
->base_name
));
491 * rename_internal_fsp() and rename_internals() add './' to
492 * head of newname if newname does not contain a '/'.
494 if (smb_fname_dst
->base_name
[0] &&
495 smb_fname_dst
->base_name
[1] &&
496 smb_fname_dst
->base_name
[0] == '.' &&
497 smb_fname_dst
->base_name
[1] == '/') {
498 strip_two_chars
= true;
501 d
->servicepath
= talloc_strdup(d
, servicepath
);
502 d
->base_name
= talloc_strdup(d
, smb_fname_dst
->base_name
+
503 (strip_two_chars
? 2 : 0));
504 d
->stream_name
= talloc_strdup(d
, smb_fname_dst
->stream_name
);
505 if (d
->base_name
== NULL
||
506 (has_stream
&& d
->stream_name
== NULL
) ||
507 d
->servicepath
== NULL
) {
508 DEBUG(0, ("rename_share_filename: talloc failed\n"));
513 sp_len
= strlen(d
->servicepath
);
514 bn_len
= strlen(d
->base_name
);
515 sn_len
= has_stream
? strlen(d
->stream_name
) : 0;
517 msg_len
= MSG_FILE_RENAMED_MIN_SIZE
+ sp_len
+ 1 + bn_len
+ 1 +
520 /* Set up the name changed message. */
521 frm
= talloc_array(d
, char, msg_len
);
526 push_file_id_24(frm
, &d
->id
);
528 DEBUG(10,("rename_share_filename: msg_len = %u\n", (unsigned int)msg_len
));
531 d
->servicepath
? d
->servicepath
: "",
533 strlcpy(&frm
[24 + sp_len
+ 1],
534 d
->base_name
? d
->base_name
: "",
536 strlcpy(&frm
[24 + sp_len
+ 1 + bn_len
+ 1],
537 d
->stream_name
? d
->stream_name
: "",
540 /* Send the messages. */
541 for (i
=0; i
<d
->num_share_modes
; i
++) {
542 struct share_mode_entry
*se
= &d
->share_modes
[i
];
543 if (!is_valid_share_mode_entry(se
)) {
547 /* If this is a hardlink to the inode
548 with a different name, skip this. */
549 if (se
->name_hash
!= orig_name_hash
) {
553 se
->name_hash
= new_name_hash
;
555 /* But not to ourselves... */
556 if (serverid_equal(&se
->pid
, &self_pid
)) {
560 if (share_mode_stale_pid(d
, i
)) {
564 DEBUG(10,("rename_share_filename: sending rename message to "
565 "pid %s file_id %s sharepath %s base_name %s "
567 procid_str_static(&se
->pid
),
568 file_id_string_tos(&d
->id
),
569 d
->servicepath
, d
->base_name
,
570 has_stream
? d
->stream_name
: ""));
572 messaging_send_buf(msg_ctx
, se
->pid
, MSG_SMB_FILE_RENAME
,
573 (uint8
*)frm
, msg_len
);
579 void get_file_infos(struct file_id id
,
581 bool *delete_on_close
,
582 struct timespec
*write_time
)
584 struct share_mode_lock
*lck
;
586 if (delete_on_close
) {
587 *delete_on_close
= false;
591 ZERO_STRUCTP(write_time
);
594 if (!(lck
= fetch_share_mode_unlocked(talloc_tos(), id
))) {
598 if (delete_on_close
) {
599 *delete_on_close
= is_delete_on_close_set(lck
, name_hash
);
605 wt
= lck
->data
->changed_write_time
;
606 if (null_timespec(wt
)) {
607 wt
= lck
->data
->old_write_time
;
616 bool is_valid_share_mode_entry(const struct share_mode_entry
*e
)
620 num_props
+= ((e
->op_type
== NO_OPLOCK
) ? 1 : 0);
621 num_props
+= (EXCLUSIVE_OPLOCK_TYPE(e
->op_type
) ? 1 : 0);
622 num_props
+= (LEVEL_II_OPLOCK_TYPE(e
->op_type
) ? 1 : 0);
624 if ((num_props
> 1) && serverid_exists(&e
->pid
)) {
625 smb_panic("Invalid share mode entry");
627 return (num_props
!= 0);
630 bool is_deferred_open_entry(const struct share_mode_entry
*e
)
632 return (e
->op_type
== DEFERRED_OPEN_ENTRY
);
636 * In case d->share_modes[i] conflicts with something or otherwise is
637 * being used, we need to make sure the corresponding process still
638 * exists. This routine checks it and potentially removes the entry
639 * from d->share_modes. Modifies d->num_share_modes, watch out in
640 * routines iterating over that array.
642 bool share_mode_stale_pid(struct share_mode_data
*d
, unsigned i
)
644 struct share_mode_entry
*e
;
646 if (i
> d
->num_share_modes
) {
647 DEBUG(1, ("Asking for index %u, only %u around\n",
648 i
, (unsigned)d
->num_share_modes
));
651 e
= &d
->share_modes
[i
];
652 if (serverid_exists(&e
->pid
)) {
653 DEBUG(10, ("PID %s (index %u out of %u) still exists\n",
654 procid_str_static(&e
->pid
), i
,
655 (unsigned)d
->num_share_modes
));
658 DEBUG(10, ("PID %s (index %u out of %u) does not exist anymore\n",
659 procid_str_static(&e
->pid
), i
,
660 (unsigned)d
->num_share_modes
));
661 *e
= d
->share_modes
[d
->num_share_modes
-1];
662 d
->num_share_modes
-= 1;
664 if (d
->num_share_modes
== 0 &&
665 d
->num_delete_tokens
) {
667 * We cannot have any delete tokens
668 * if there are no valid share modes.
670 TALLOC_FREE(d
->delete_tokens
);
671 d
->num_delete_tokens
= 0;
678 /*******************************************************************
679 Fill a share mode entry.
680 ********************************************************************/
682 static void fill_share_mode_entry(struct share_mode_entry
*e
,
684 uid_t uid
, uint64_t mid
, uint16 op_type
)
687 e
->pid
= messaging_server_id(fsp
->conn
->sconn
->msg_ctx
);
688 e
->share_access
= fsp
->share_access
;
689 e
->private_options
= fsp
->fh
->private_options
;
690 e
->access_mask
= fsp
->access_mask
;
692 e
->op_type
= op_type
;
693 e
->time
.tv_sec
= fsp
->open_time
.tv_sec
;
694 e
->time
.tv_usec
= fsp
->open_time
.tv_usec
;
695 e
->id
= fsp
->file_id
;
696 e
->share_file_id
= fsp
->fh
->gen_id
;
697 e
->uid
= (uint32
)uid
;
698 e
->flags
= fsp
->posix_open
? SHARE_MODE_FLAG_POSIX_OPEN
: 0;
699 e
->name_hash
= fsp
->name_hash
;
702 static void fill_deferred_open_entry(struct share_mode_entry
*e
,
703 const struct timeval request_time
,
705 struct server_id pid
,
711 e
->op_type
= DEFERRED_OPEN_ENTRY
;
712 e
->time
.tv_sec
= request_time
.tv_sec
;
713 e
->time
.tv_usec
= request_time
.tv_usec
;
719 static void add_share_mode_entry(struct share_mode_data
*d
,
720 const struct share_mode_entry
*entry
)
722 ADD_TO_ARRAY(d
, struct share_mode_entry
, *entry
,
723 &d
->share_modes
, &d
->num_share_modes
);
727 void set_share_mode(struct share_mode_lock
*lck
, files_struct
*fsp
,
728 uid_t uid
, uint64_t mid
, uint16 op_type
)
730 struct share_mode_entry entry
;
731 fill_share_mode_entry(&entry
, fsp
, uid
, mid
, op_type
);
732 add_share_mode_entry(lck
->data
, &entry
);
735 void add_deferred_open(struct share_mode_lock
*lck
, uint64_t mid
,
736 struct timeval request_time
,
737 struct server_id pid
, struct file_id id
)
739 struct share_mode_entry entry
;
740 fill_deferred_open_entry(&entry
, request_time
, id
, pid
, mid
);
741 add_share_mode_entry(lck
->data
, &entry
);
744 /*******************************************************************
745 Check if two share mode entries are identical, ignoring oplock
746 and mid info and desired_access. (Removed paranoia test - it's
747 not automatically a logic error if they are identical. JRA.)
748 ********************************************************************/
750 static bool share_modes_identical(struct share_mode_entry
*e1
,
751 struct share_mode_entry
*e2
)
753 /* We used to check for e1->share_access == e2->share_access here
754 as well as the other fields but 2 different DOS or FCB opens
755 sharing the same share mode entry may validly differ in
756 fsp->share_access field. */
758 return (serverid_equal(&e1
->pid
, &e2
->pid
) &&
759 file_id_equal(&e1
->id
, &e2
->id
) &&
760 e1
->share_file_id
== e2
->share_file_id
);
763 static bool deferred_open_identical(struct share_mode_entry
*e1
,
764 struct share_mode_entry
*e2
)
766 return (serverid_equal(&e1
->pid
, &e2
->pid
) &&
767 (e1
->op_mid
== e2
->op_mid
) &&
768 file_id_equal(&e1
->id
, &e2
->id
));
771 static struct share_mode_entry
*find_share_mode_entry(struct share_mode_data
*d
,
772 struct share_mode_entry
*entry
)
776 for (i
=0; i
<d
->num_share_modes
; i
++) {
777 struct share_mode_entry
*e
= &d
->share_modes
[i
];
778 if (is_valid_share_mode_entry(entry
) &&
779 is_valid_share_mode_entry(e
) &&
780 share_modes_identical(e
, entry
)) {
783 if (is_deferred_open_entry(entry
) &&
784 is_deferred_open_entry(e
) &&
785 deferred_open_identical(e
, entry
)) {
792 /*******************************************************************
793 Del the share mode of a file for this process. Return the number of
795 ********************************************************************/
797 bool del_share_mode(struct share_mode_lock
*lck
, files_struct
*fsp
)
799 struct share_mode_entry entry
, *e
;
801 /* Don't care about the pid owner being correct here - just a search. */
802 fill_share_mode_entry(&entry
, fsp
, (uid_t
)-1, 0, NO_OPLOCK
);
804 e
= find_share_mode_entry(lck
->data
, &entry
);
808 *e
= lck
->data
->share_modes
[lck
->data
->num_share_modes
-1];
809 lck
->data
->num_share_modes
-= 1;
810 lck
->data
->modified
= True
;
814 void del_deferred_open_entry(struct share_mode_lock
*lck
, uint64_t mid
,
815 struct server_id pid
)
817 struct share_mode_entry entry
, *e
;
819 fill_deferred_open_entry(&entry
, timeval_zero(),
820 lck
->data
->id
, pid
, mid
);
822 e
= find_share_mode_entry(lck
->data
, &entry
);
826 *e
= lck
->data
->share_modes
[lck
->data
->num_share_modes
-1];
827 lck
->data
->num_share_modes
-= 1;
828 lck
->data
->modified
= True
;
831 /*******************************************************************
832 Remove an oplock mid and mode entry from a share mode.
833 ********************************************************************/
835 bool remove_share_oplock(struct share_mode_lock
*lck
, files_struct
*fsp
)
837 struct share_mode_entry entry
, *e
;
839 /* Don't care about the pid owner being correct here - just a search. */
840 fill_share_mode_entry(&entry
, fsp
, (uid_t
)-1, 0, NO_OPLOCK
);
842 e
= find_share_mode_entry(lck
->data
, &entry
);
847 if (EXCLUSIVE_OPLOCK_TYPE(e
->op_type
)) {
849 * Going from exclusive or batch,
850 * we always go through FAKE_LEVEL_II
853 if (!EXCLUSIVE_OPLOCK_TYPE(fsp
->oplock_type
)) {
854 smb_panic("remove_share_oplock: logic error");
856 e
->op_type
= FAKE_LEVEL_II_OPLOCK
;
858 e
->op_type
= NO_OPLOCK
;
860 lck
->data
->modified
= True
;
864 /*******************************************************************
865 Downgrade a oplock type from exclusive to level II.
866 ********************************************************************/
868 bool downgrade_share_oplock(struct share_mode_lock
*lck
, files_struct
*fsp
)
870 struct share_mode_entry entry
, *e
;
872 /* Don't care about the pid owner being correct here - just a search. */
873 fill_share_mode_entry(&entry
, fsp
, (uid_t
)-1, 0, NO_OPLOCK
);
875 e
= find_share_mode_entry(lck
->data
, &entry
);
880 e
->op_type
= LEVEL_II_OPLOCK
;
881 lck
->data
->modified
= True
;
885 /*************************************************************************
886 Return a talloced copy of a struct security_unix_token. NULL on fail.
887 (Should this be in locking.c.... ?).
888 *************************************************************************/
890 static struct security_unix_token
*copy_unix_token(TALLOC_CTX
*ctx
, const struct security_unix_token
*tok
)
892 struct security_unix_token
*cpy
;
894 cpy
= talloc(ctx
, struct security_unix_token
);
901 cpy
->ngroups
= tok
->ngroups
;
903 /* Make this a talloc child of cpy. */
904 cpy
->groups
= (gid_t
*)talloc_memdup(
905 cpy
, tok
->groups
, tok
->ngroups
* sizeof(gid_t
));
914 /****************************************************************************
915 Adds a delete on close token.
916 ****************************************************************************/
918 static bool add_delete_on_close_token(struct share_mode_data
*d
,
920 const struct security_token
*nt_tok
,
921 const struct security_unix_token
*tok
)
923 struct delete_token
*tmp
, *dtl
;
925 tmp
= talloc_realloc(d
, d
->delete_tokens
, struct delete_token
,
926 d
->num_delete_tokens
+1);
930 d
->delete_tokens
= tmp
;
931 dtl
= &d
->delete_tokens
[d
->num_delete_tokens
];
933 dtl
->name_hash
= name_hash
;
934 dtl
->delete_nt_token
= dup_nt_token(d
->delete_tokens
, nt_tok
);
935 if (dtl
->delete_nt_token
== NULL
) {
938 dtl
->delete_token
= copy_unix_token(d
->delete_tokens
, tok
);
939 if (dtl
->delete_token
== NULL
) {
942 d
->num_delete_tokens
+= 1;
947 /****************************************************************************
948 Sets the delete on close flag over all share modes on this file.
949 Modify the share mode entry for all files open
950 on this device and inode to tell other smbds we have
951 changed the delete on close flag. This will be noticed
952 in the close code, the last closer will delete the file
954 This makes a copy of any struct security_unix_token into the
955 lck entry. This function is used when the lock is already granted.
956 ****************************************************************************/
958 void set_delete_on_close_lck(files_struct
*fsp
,
959 struct share_mode_lock
*lck
,
960 bool delete_on_close
,
961 const struct security_token
*nt_tok
,
962 const struct security_unix_token
*tok
)
964 struct share_mode_data
*d
= lck
->data
;
968 if (delete_on_close
) {
969 SMB_ASSERT(nt_tok
!= NULL
);
970 SMB_ASSERT(tok
!= NULL
);
972 SMB_ASSERT(nt_tok
== NULL
);
973 SMB_ASSERT(tok
== NULL
);
976 for (i
=0; i
<d
->num_delete_tokens
; i
++) {
977 struct delete_token
*dt
= &d
->delete_tokens
[i
];
978 if (dt
->name_hash
== fsp
->name_hash
) {
980 if (delete_on_close
== false) {
981 /* Delete this entry. */
982 TALLOC_FREE(dt
->delete_nt_token
);
983 TALLOC_FREE(dt
->delete_token
);
984 *dt
= d
->delete_tokens
[
985 d
->num_delete_tokens
-1];
986 d
->num_delete_tokens
-= 1;
988 /* Replace this token with the
990 TALLOC_FREE(dt
->delete_nt_token
);
991 dt
->delete_nt_token
= dup_nt_token(dt
, nt_tok
);
992 SMB_ASSERT(dt
->delete_nt_token
!= NULL
);
993 TALLOC_FREE(dt
->delete_token
);
994 dt
->delete_token
= copy_unix_token(dt
, tok
);
995 SMB_ASSERT(dt
->delete_token
!= NULL
);
1001 if (!delete_on_close
) {
1002 /* Nothing to delete - not found. */
1006 ret
= add_delete_on_close_token(lck
->data
, fsp
->name_hash
, nt_tok
, tok
);
1010 bool set_delete_on_close(files_struct
*fsp
, bool delete_on_close
,
1011 const struct security_token
*nt_tok
,
1012 const struct security_unix_token
*tok
)
1014 struct share_mode_lock
*lck
;
1016 DEBUG(10,("set_delete_on_close: %s delete on close flag for "
1018 delete_on_close
? "Adding" : "Removing", fsp_fnum_dbg(fsp
),
1021 lck
= get_existing_share_mode_lock(talloc_tos(), fsp
->file_id
);
1026 if (delete_on_close
) {
1027 set_delete_on_close_lck(fsp
, lck
, true,
1031 set_delete_on_close_lck(fsp
, lck
, false,
1036 if (fsp
->is_directory
) {
1037 SMB_ASSERT(!is_ntfs_stream_smb_fname(fsp
->fsp_name
));
1038 send_stat_cache_delete_message(fsp
->conn
->sconn
->msg_ctx
,
1039 fsp
->fsp_name
->base_name
);
1044 fsp
->delete_on_close
= delete_on_close
;
1049 static struct delete_token
*find_delete_on_close_token(
1050 struct share_mode_data
*d
, uint32_t name_hash
)
1054 DEBUG(10, ("find_delete_on_close_token: name_hash = 0x%x\n",
1055 (unsigned int)name_hash
));
1057 for (i
=0; i
<d
->num_delete_tokens
; i
++) {
1058 struct delete_token
*dt
= &d
->delete_tokens
[i
];
1060 DEBUG(10, ("find__delete_on_close_token: dt->name_hash = 0x%x\n",
1061 (unsigned int)dt
->name_hash
));
1062 if (dt
->name_hash
== name_hash
) {
1069 /****************************************************************************
1070 Return the NT token and UNIX token if there's a match. Return true if
1071 found, false if not.
1072 ****************************************************************************/
1074 bool get_delete_on_close_token(struct share_mode_lock
*lck
,
1076 const struct security_token
**pp_nt_tok
,
1077 const struct security_unix_token
**pp_tok
)
1079 struct delete_token
*dt
;
1081 dt
= find_delete_on_close_token(lck
->data
, name_hash
);
1085 *pp_nt_tok
= dt
->delete_nt_token
;
1086 *pp_tok
= dt
->delete_token
;
1090 bool is_delete_on_close_set(struct share_mode_lock
*lck
, uint32_t name_hash
)
1092 return find_delete_on_close_token(lck
->data
, name_hash
) != NULL
;
1095 bool set_sticky_write_time(struct file_id fileid
, struct timespec write_time
)
1097 struct share_mode_lock
*lck
;
1099 DEBUG(5,("set_sticky_write_time: %s id=%s\n",
1100 timestring(talloc_tos(),
1101 convert_timespec_to_time_t(write_time
)),
1102 file_id_string_tos(&fileid
)));
1104 lck
= get_existing_share_mode_lock(talloc_tos(), fileid
);
1109 if (timespec_compare(&lck
->data
->changed_write_time
, &write_time
) != 0) {
1110 lck
->data
->modified
= True
;
1111 lck
->data
->changed_write_time
= write_time
;
1118 bool set_write_time(struct file_id fileid
, struct timespec write_time
)
1120 struct share_mode_lock
*lck
;
1122 DEBUG(5,("set_write_time: %s id=%s\n",
1123 timestring(talloc_tos(),
1124 convert_timespec_to_time_t(write_time
)),
1125 file_id_string_tos(&fileid
)));
1127 lck
= get_existing_share_mode_lock(talloc_tos(), fileid
);
1132 if (timespec_compare(&lck
->data
->old_write_time
, &write_time
) != 0) {
1133 lck
->data
->modified
= True
;
1134 lck
->data
->old_write_time
= write_time
;