?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
s3: Simplify get_delete_on_close_token more
[Samba/gebeck_regimport.git] / source3 / locking / locking.c
blob5da759573728d8e64b2b658eb90f1e327ea76305
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 /****************************************************************************
56 Debugging aids :-).
57 ****************************************************************************/
58
59 const char *lock_type_name(enum brl_type lock_type)
60 {
61 switch (lock_type) {
62 case READ_LOCK:
63 return "READ";
64 case WRITE_LOCK:
65 return "WRITE";
66 case PENDING_READ_LOCK:
67 return "PENDING_READ";
68 case PENDING_WRITE_LOCK:
69 return "PENDING_WRITE";
70 default:
71 return "other";
72 }
73 }
74
75 const char *lock_flav_name(enum brl_flavour lock_flav)
76 {
77 return (lock_flav == WINDOWS_LOCK) ? "WINDOWS_LOCK" : "POSIX_LOCK";
78 }
79
80 /****************************************************************************
81 Utility function called to see if a file region is locked.
82 Called in the read/write codepath.
83 ****************************************************************************/
84
85 void init_strict_lock_struct(files_struct *fsp,
86 uint64_t smblctx,
87 br_off start,
88 br_off size,
89 enum brl_type lock_type,
90 struct lock_struct *plock)
91 {
92 SMB_ASSERT(lock_type == READ_LOCK || lock_type == WRITE_LOCK);
93
94 plock->context.smblctx = smblctx;
95 plock->context.tid = fsp->conn->cnum;
96 plock->context.pid = messaging_server_id(fsp->conn->sconn->msg_ctx);
97 plock->start = start;
98 plock->size = size;
99 plock->fnum = fsp->fnum;
100 plock->lock_type = lock_type;
101 plock->lock_flav = lp_posix_cifsu_locktype(fsp);
102 }
103
104 bool strict_lock_default(files_struct *fsp, struct lock_struct *plock)
105 {
106 int strict_locking = lp_strict_locking(fsp->conn->params);
107 bool ret = False;
108
109 if (plock->size == 0) {
110 return True;
111 }
112
113 if (!lp_locking(fsp->conn->params) || !strict_locking) {
114 return True;
115 }
116
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)));
120 ret = True;
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)));
124 ret = True;
125 } else {
126 struct byte_range_lock *br_lck;
127
128 br_lck = brl_get_locks_readonly(fsp);
129 if (!br_lck) {
130 return True;
131 }
132 ret = brl_locktest(br_lck,
133 plock->context.smblctx,
134 plock->context.pid,
135 plock->start,
136 plock->size,
137 plock->lock_type,
138 plock->lock_flav);
139 }
140 } else {
141 struct byte_range_lock *br_lck;
142
143 br_lck = brl_get_locks_readonly(fsp);
144 if (!br_lck) {
145 return True;
146 }
147 ret = brl_locktest(br_lck,
148 plock->context.smblctx,
149 plock->context.pid,
150 plock->start,
151 plock->size,
152 plock->lock_type,
153 plock->lock_flav);
154 }
155
156 DEBUG(10,("strict_lock_default: flavour = %s brl start=%.0f "
157 "len=%.0f %s for fnum %d file %s\n",
158 lock_flav_name(plock->lock_flav),
159 (double)plock->start, (double)plock->size,
160 ret ? "unlocked" : "locked",
161 plock->fnum, fsp_str_dbg(fsp)));
162
163 return ret;
164 }
165
166 void strict_unlock_default(files_struct *fsp, struct lock_struct *plock)
167 {
168 }
169
170 /****************************************************************************
171 Find out if a lock could be granted - return who is blocking us if we can't.
172 ****************************************************************************/
173
174 NTSTATUS query_lock(files_struct *fsp,
175 uint64_t *psmblctx,
176 uint64_t *pcount,
177 uint64_t *poffset,
178 enum brl_type *plock_type,
179 enum brl_flavour lock_flav)
180 {
181 struct byte_range_lock *br_lck = NULL;
182
183 if (!fsp->can_lock) {
184 return fsp->is_directory ? NT_STATUS_INVALID_DEVICE_REQUEST : NT_STATUS_INVALID_HANDLE;
185 }
186
187 if (!lp_locking(fsp->conn->params)) {
188 return NT_STATUS_OK;
189 }
190
191 br_lck = brl_get_locks_readonly(fsp);
192 if (!br_lck) {
193 return NT_STATUS_NO_MEMORY;
194 }
195
196 return brl_lockquery(br_lck,
197 psmblctx,
198 messaging_server_id(fsp->conn->sconn->msg_ctx),
199 poffset,
200 pcount,
201 plock_type,
202 lock_flav);
203 }
204
205 static void increment_current_lock_count(files_struct *fsp,
206 enum brl_flavour lock_flav)
207 {
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. */
213
214 fsp->current_lock_count++;
215 } else {
216 /* Notice that this has had a POSIX lock request.
217 * We can't count locks after this so forget them.
218 */
219 fsp->current_lock_count = NO_LOCKING_COUNT;
220 }
221 }
222
223 static void decrement_current_lock_count(files_struct *fsp,
224 enum brl_flavour lock_flav)
225 {
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--;
230 }
231 }
232
233 /****************************************************************************
234 Utility function called by locking requests.
235 ****************************************************************************/
236
237 struct byte_range_lock *do_lock(struct messaging_context *msg_ctx,
238 files_struct *fsp,
239 uint64_t smblctx,
240 uint64_t count,
241 uint64_t offset,
242 enum brl_type lock_type,
243 enum brl_flavour lock_flav,
244 bool blocking_lock,
245 NTSTATUS *perr,
246 uint64_t *psmblctx,
247 struct blocking_lock_record *blr)
248 {
249 struct byte_range_lock *br_lck = NULL;
250
251 /* silently return ok on print files as we don't do locking there */
252 if (fsp->print_file) {
253 *perr = NT_STATUS_OK;
254 return NULL;
255 }
256
257 if (!fsp->can_lock) {
258 *perr = fsp->is_directory ? NT_STATUS_INVALID_DEVICE_REQUEST : NT_STATUS_INVALID_HANDLE;
259 return NULL;
260 }
261
262 if (!lp_locking(fsp->conn->params)) {
263 *perr = NT_STATUS_OK;
264 return NULL;
265 }
266
267 /* NOTE! 0 byte long ranges ARE allowed and should be stored */
268
269 DEBUG(10,("do_lock: lock flavour %s lock type %s start=%.0f len=%.0f "
270 "blocking_lock=%s requested for fnum %d 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, fsp_str_dbg(fsp)));
274
275 br_lck = brl_get_locks(talloc_tos(), fsp);
276 if (!br_lck) {
277 *perr = NT_STATUS_NO_MEMORY;
278 return NULL;
279 }
280
281 *perr = brl_lock(msg_ctx,
282 br_lck,
283 smblctx,
284 messaging_server_id(fsp->conn->sconn->msg_ctx),
285 offset,
286 count,
287 lock_type,
288 lock_flav,
289 blocking_lock,
290 psmblctx,
291 blr);
292
293 DEBUG(10, ("do_lock: returning status=%s\n", nt_errstr(*perr)));
294
295 increment_current_lock_count(fsp, lock_flav);
296 return br_lck;
297 }
298
299 /****************************************************************************
300 Utility function called by unlocking requests.
301 ****************************************************************************/
302
303 NTSTATUS do_unlock(struct messaging_context *msg_ctx,
304 files_struct *fsp,
305 uint64_t smblctx,
306 uint64_t count,
307 uint64_t offset,
308 enum brl_flavour lock_flav)
309 {
310 bool ok = False;
311 struct byte_range_lock *br_lck = NULL;
312
313 if (!fsp->can_lock) {
314 return fsp->is_directory ? NT_STATUS_INVALID_DEVICE_REQUEST : NT_STATUS_INVALID_HANDLE;
315 }
316
317 if (!lp_locking(fsp->conn->params)) {
318 return NT_STATUS_OK;
319 }
320
321 DEBUG(10,("do_unlock: unlock start=%.0f len=%.0f requested for fnum %d file %s\n",
322 (double)offset, (double)count, fsp->fnum,
323 fsp_str_dbg(fsp)));
324
325 br_lck = brl_get_locks(talloc_tos(), fsp);
326 if (!br_lck) {
327 return NT_STATUS_NO_MEMORY;
328 }
329
330 ok = brl_unlock(msg_ctx,
331 br_lck,
332 smblctx,
333 messaging_server_id(fsp->conn->sconn->msg_ctx),
334 offset,
335 count,
336 lock_flav);
337
338 TALLOC_FREE(br_lck);
339
340 if (!ok) {
341 DEBUG(10,("do_unlock: returning ERRlock.\n" ));
342 return NT_STATUS_RANGE_NOT_LOCKED;
343 }
344
345 decrement_current_lock_count(fsp, lock_flav);
346 return NT_STATUS_OK;
347 }
348
349 /****************************************************************************
350 Cancel any pending blocked locks.
351 ****************************************************************************/
352
353 NTSTATUS do_lock_cancel(files_struct *fsp,
354 uint64 smblctx,
355 uint64_t count,
356 uint64_t offset,
357 enum brl_flavour lock_flav,
358 struct blocking_lock_record *blr)
359 {
360 bool ok = False;
361 struct byte_range_lock *br_lck = NULL;
362
363 if (!fsp->can_lock) {
364 return fsp->is_directory ?
365 NT_STATUS_INVALID_DEVICE_REQUEST : NT_STATUS_INVALID_HANDLE;
366 }
367
368 if (!lp_locking(fsp->conn->params)) {
369 return NT_STATUS_DOS(ERRDOS, ERRcancelviolation);
370 }
371
372 DEBUG(10,("do_lock_cancel: cancel start=%.0f len=%.0f requested for fnum %d file %s\n",
373 (double)offset, (double)count, fsp->fnum,
374 fsp_str_dbg(fsp)));
375
376 br_lck = brl_get_locks(talloc_tos(), fsp);
377 if (!br_lck) {
378 return NT_STATUS_NO_MEMORY;
379 }
380
381 ok = brl_lock_cancel(br_lck,
382 smblctx,
383 messaging_server_id(fsp->conn->sconn->msg_ctx),
384 offset,
385 count,
386 lock_flav,
387 blr);
388
389 TALLOC_FREE(br_lck);
390
391 if (!ok) {
392 DEBUG(10,("do_lock_cancel: returning ERRcancelviolation.\n" ));
393 return NT_STATUS_DOS(ERRDOS, ERRcancelviolation);
394 }
395
396 decrement_current_lock_count(fsp, lock_flav);
397 return NT_STATUS_OK;
398 }
399
400 /****************************************************************************
401 Remove any locks on this fd. Called from file_close().
402 ****************************************************************************/
403
404 void locking_close_file(struct messaging_context *msg_ctx,
405 files_struct *fsp,
406 enum file_close_type close_type)
407 {
408 struct byte_range_lock *br_lck;
409
410 if (!lp_locking(fsp->conn->params)) {
411 return;
412 }
413
414 /* If we have not outstanding locks or pending
415 * locks then we don't need to look in the lock db.
416 */
417
418 if (fsp->current_lock_count == 0) {
419 return;
420 }
421
422 br_lck = brl_get_locks(talloc_tos(),fsp);
423
424 if (br_lck) {
425 cancel_pending_lock_requests_by_fid(fsp, br_lck, close_type);
426 brl_close_fnum(msg_ctx, br_lck);
427 TALLOC_FREE(br_lck);
428 }
429 }
430
431 /*******************************************************************
432 Print out a share mode.
433 ********************************************************************/
434
435 char *share_mode_str(TALLOC_CTX *ctx, int num, const struct share_mode_entry *e)
436 {
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",
441 num,
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);
449 }
450
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 ********************************************************************/
455
456 struct share_mode_lock *get_existing_share_mode_lock(TALLOC_CTX *mem_ctx,
457 const struct file_id id)
458 {
459 return get_share_mode_lock(mem_ctx, id, NULL, NULL, NULL);
460 }
461
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 ********************************************************************/
468
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)
475 {
476 struct share_mode_data *d = lck->data;
477 size_t sp_len;
478 size_t bn_len;
479 size_t sn_len;
480 size_t msg_len;
481 char *frm = NULL;
482 int i;
483 bool strip_two_chars = false;
484 bool has_stream = smb_fname_dst->stream_name != NULL;
485
486 DEBUG(10, ("rename_share_filename: servicepath %s newname %s\n",
487 servicepath, smb_fname_dst->base_name));
488
489 /*
490 * rename_internal_fsp() and rename_internals() add './' to
491 * head of newname if newname does not contain a '/'.
492 */
493 if (smb_fname_dst->base_name[0] &&
494 smb_fname_dst->base_name[1] &&
495 smb_fname_dst->base_name[0] == '.' &&
496 smb_fname_dst->base_name[1] == '/') {
497 strip_two_chars = true;
498 }
499
500 d->servicepath = talloc_strdup(d, servicepath);
501 d->base_name = talloc_strdup(d, smb_fname_dst->base_name +
502 (strip_two_chars ? 2 : 0));
503 d->stream_name = talloc_strdup(d, smb_fname_dst->stream_name);
504 if (d->base_name == NULL ||
505 (has_stream && d->stream_name == NULL) ||
506 d->servicepath == NULL) {
507 DEBUG(0, ("rename_share_filename: talloc failed\n"));
508 return False;
509 }
510 d->modified = True;
511
512 sp_len = strlen(d->servicepath);
513 bn_len = strlen(d->base_name);
514 sn_len = has_stream ? strlen(d->stream_name) : 0;
515
516 msg_len = MSG_FILE_RENAMED_MIN_SIZE + sp_len + 1 + bn_len + 1 +
517 sn_len + 1;
518
519 /* Set up the name changed message. */
520 frm = talloc_array(d, char, msg_len);
521 if (!frm) {
522 return False;
523 }
524
525 push_file_id_24(frm, &d->id);
526
527 DEBUG(10,("rename_share_filename: msg_len = %u\n", (unsigned int)msg_len ));
528
529 strlcpy(&frm[24],
530 d->servicepath ? d->servicepath : "",
531 sp_len+1);
532 strlcpy(&frm[24 + sp_len + 1],
533 d->base_name ? d->base_name : "",
534 bn_len+1);
535 strlcpy(&frm[24 + sp_len + 1 + bn_len + 1],
536 d->stream_name ? d->stream_name : "",
537 sn_len+1);
538
539 /* Send the messages. */
540 for (i=0; i<d->num_share_modes; i++) {
541 struct share_mode_entry *se = &d->share_modes[i];
542 if (!is_valid_share_mode_entry(se)) {
543 continue;
544 }
545
546 /* If this is a hardlink to the inode
547 with a different name, skip this. */
548 if (se->name_hash != orig_name_hash) {
549 continue;
550 }
551
552 se->name_hash = new_name_hash;
553
554 /* But not to ourselves... */
555 if (procid_is_me(&se->pid)) {
556 continue;
557 }
558
559 if (share_mode_stale_pid(d, i)) {
560 continue;
561 }
562
563 DEBUG(10,("rename_share_filename: sending rename message to "
564 "pid %s file_id %s sharepath %s base_name %s "
565 "stream_name %s\n",
566 procid_str_static(&se->pid),
567 file_id_string_tos(&d->id),
568 d->servicepath, d->base_name,
569 has_stream ? d->stream_name : ""));
570
571 messaging_send_buf(msg_ctx, se->pid, MSG_SMB_FILE_RENAME,
572 (uint8 *)frm, msg_len);
573 }
574
575 return True;
576 }
577
578 void get_file_infos(struct file_id id,
579 uint32_t name_hash,
580 bool *delete_on_close,
581 struct timespec *write_time)
582 {
583 struct share_mode_lock *lck;
584
585 if (delete_on_close) {
586 *delete_on_close = false;
587 }
588
589 if (write_time) {
590 ZERO_STRUCTP(write_time);
591 }
592
593 if (!(lck = fetch_share_mode_unlocked(talloc_tos(), id))) {
594 return;
595 }
596
597 if (delete_on_close) {
598 *delete_on_close = is_delete_on_close_set(lck, name_hash);
599 }
600
601 if (write_time) {
602 struct timespec wt;
603
604 wt = lck->data->changed_write_time;
605 if (null_timespec(wt)) {
606 wt = lck->data->old_write_time;
607 }
608
609 *write_time = wt;
610 }
611
612 TALLOC_FREE(lck);
613 }
614
615 bool is_valid_share_mode_entry(const struct share_mode_entry *e)
616 {
617 int num_props = 0;
618
619 num_props += ((e->op_type == NO_OPLOCK) ? 1 : 0);
620 num_props += (EXCLUSIVE_OPLOCK_TYPE(e->op_type) ? 1 : 0);
621 num_props += (LEVEL_II_OPLOCK_TYPE(e->op_type) ? 1 : 0);
622
623 if ((num_props > 1) && serverid_exists(&e->pid)) {
624 smb_panic("Invalid share mode entry");
625 }
626 return (num_props != 0);
627 }
628
629 bool is_deferred_open_entry(const struct share_mode_entry *e)
630 {
631 return (e->op_type == DEFERRED_OPEN_ENTRY);
632 }
633
634 /*
635 * In case d->share_modes[i] conflicts with something or otherwise is
636 * being used, we need to make sure the corresponding process still
637 * exists. This routine checks it and potentially removes the entry
638 * from d->share_modes. Modifies d->num_share_modes, watch out in
639 * routines iterating over that array.
640 */
641 bool share_mode_stale_pid(struct share_mode_data *d, unsigned i)
642 {
643 struct share_mode_entry *e;
644
645 if (i > d->num_share_modes) {
646 DEBUG(1, ("Asking for index %u, only %u around\n",
647 i, (unsigned)d->num_share_modes));
648 return false;
649 }
650 e = &d->share_modes[i];
651 if (serverid_exists(&e->pid)) {
652 DEBUG(10, ("PID %s (index %u out of %u) still exists\n",
653 procid_str_static(&e->pid), i,
654 (unsigned)d->num_share_modes));
655 return false;
656 }
657 DEBUG(10, ("PID %s (index %u out of %u) does not exist anymore\n",
658 procid_str_static(&e->pid), i,
659 (unsigned)d->num_share_modes));
660 *e = d->share_modes[d->num_share_modes-1];
661 d->num_share_modes -= 1;
662
663 if (d->num_share_modes == 0 &&
664 d->num_delete_tokens) {
665 /*
666 * We cannot have any delete tokens
667 * if there are no valid share modes.
668 */
669 TALLOC_FREE(d->delete_tokens);
670 d->num_delete_tokens = 0;
671 }
672
673 d->modified = true;
674 return true;
675 }
676
677 /*******************************************************************
678 Fill a share mode entry.
679 ********************************************************************/
680
681 static void fill_share_mode_entry(struct share_mode_entry *e,
682 files_struct *fsp,
683 uid_t uid, uint64_t mid, uint16 op_type)
684 {
685 ZERO_STRUCTP(e);
686 e->pid = messaging_server_id(fsp->conn->sconn->msg_ctx);
687 e->share_access = fsp->share_access;
688 e->private_options = fsp->fh->private_options;
689 e->access_mask = fsp->access_mask;
690 e->op_mid = mid;
691 e->op_type = op_type;
692 e->time.tv_sec = fsp->open_time.tv_sec;
693 e->time.tv_usec = fsp->open_time.tv_usec;
694 e->id = fsp->file_id;
695 e->share_file_id = fsp->fh->gen_id;
696 e->uid = (uint32)uid;
697 e->flags = fsp->posix_open ? SHARE_MODE_FLAG_POSIX_OPEN : 0;
698 e->name_hash = fsp->name_hash;
699 }
700
701 static void fill_deferred_open_entry(struct share_mode_entry *e,
702 const struct timeval request_time,
703 struct file_id id,
704 struct server_id pid,
705 uint64_t mid)
706 {
707 ZERO_STRUCTP(e);
708 e->pid = pid;
709 e->op_mid = mid;
710 e->op_type = DEFERRED_OPEN_ENTRY;
711 e->time.tv_sec = request_time.tv_sec;
712 e->time.tv_usec = request_time.tv_usec;
713 e->id = id;
714 e->uid = (uint32)-1;
715 e->flags = 0;
716 }
717
718 static void add_share_mode_entry(struct share_mode_data *d,
719 const struct share_mode_entry *entry)
720 {
721 ADD_TO_ARRAY(d, struct share_mode_entry, *entry,
722 &d->share_modes, &d->num_share_modes);
723 d->modified = True;
724 }
725
726 void set_share_mode(struct share_mode_lock *lck, files_struct *fsp,
727 uid_t uid, uint64_t mid, uint16 op_type)
728 {
729 struct share_mode_entry entry;
730 fill_share_mode_entry(&entry, fsp, uid, mid, op_type);
731 add_share_mode_entry(lck->data, &entry);
732 }
733
734 void add_deferred_open(struct share_mode_lock *lck, uint64_t mid,
735 struct timeval request_time,
736 struct server_id pid, struct file_id id)
737 {
738 struct share_mode_entry entry;
739 fill_deferred_open_entry(&entry, request_time, id, pid, mid);
740 add_share_mode_entry(lck->data, &entry);
741 }
742
743 /*******************************************************************
744 Check if two share mode entries are identical, ignoring oplock
745 and mid info and desired_access. (Removed paranoia test - it's
746 not automatically a logic error if they are identical. JRA.)
747 ********************************************************************/
748
749 static bool share_modes_identical(struct share_mode_entry *e1,
750 struct share_mode_entry *e2)
751 {
752 /* We used to check for e1->share_access == e2->share_access here
753 as well as the other fields but 2 different DOS or FCB opens
754 sharing the same share mode entry may validly differ in
755 fsp->share_access field. */
756
757 return (procid_equal(&e1->pid, &e2->pid) &&
758 file_id_equal(&e1->id, &e2->id) &&
759 e1->share_file_id == e2->share_file_id );
760 }
761
762 static bool deferred_open_identical(struct share_mode_entry *e1,
763 struct share_mode_entry *e2)
764 {
765 return (procid_equal(&e1->pid, &e2->pid) &&
766 (e1->op_mid == e2->op_mid) &&
767 file_id_equal(&e1->id, &e2->id));
768 }
769
770 static struct share_mode_entry *find_share_mode_entry(struct share_mode_data *d,
771 struct share_mode_entry *entry)
772 {
773 int i;
774
775 for (i=0; i<d->num_share_modes; i++) {
776 struct share_mode_entry *e = &d->share_modes[i];
777 if (is_valid_share_mode_entry(entry) &&
778 is_valid_share_mode_entry(e) &&
779 share_modes_identical(e, entry)) {
780 return e;
781 }
782 if (is_deferred_open_entry(entry) &&
783 is_deferred_open_entry(e) &&
784 deferred_open_identical(e, entry)) {
785 return e;
786 }
787 }
788 return NULL;
789 }
790
791 /*******************************************************************
792 Del the share mode of a file for this process. Return the number of
793 entries left.
794 ********************************************************************/
795
796 bool del_share_mode(struct share_mode_lock *lck, files_struct *fsp)
797 {
798 struct share_mode_entry entry, *e;
799
800 /* Don't care about the pid owner being correct here - just a search. */
801 fill_share_mode_entry(&entry, fsp, (uid_t)-1, 0, NO_OPLOCK);
802
803 e = find_share_mode_entry(lck->data, &entry);
804 if (e == NULL) {
805 return False;
806 }
807 *e = lck->data->share_modes[lck->data->num_share_modes-1];
808 lck->data->num_share_modes -= 1;
809 lck->data->modified = True;
810 return True;
811 }
812
813 void del_deferred_open_entry(struct share_mode_lock *lck, uint64_t mid,
814 struct server_id pid)
815 {
816 struct share_mode_entry entry, *e;
817
818 fill_deferred_open_entry(&entry, timeval_zero(),
819 lck->data->id, pid, mid);
820
821 e = find_share_mode_entry(lck->data, &entry);
822 if (e == NULL) {
823 return;
824 }
825 *e = lck->data->share_modes[lck->data->num_share_modes-1];
826 lck->data->num_share_modes -= 1;
827 lck->data->modified = True;
828 }
829
830 /*******************************************************************
831 Remove an oplock mid and mode entry from a share mode.
832 ********************************************************************/
833
834 bool remove_share_oplock(struct share_mode_lock *lck, files_struct *fsp)
835 {
836 struct share_mode_entry entry, *e;
837
838 /* Don't care about the pid owner being correct here - just a search. */
839 fill_share_mode_entry(&entry, fsp, (uid_t)-1, 0, NO_OPLOCK);
840
841 e = find_share_mode_entry(lck->data, &entry);
842 if (e == NULL) {
843 return False;
844 }
845
846 if (EXCLUSIVE_OPLOCK_TYPE(e->op_type)) {
847 /*
848 * Going from exclusive or batch,
849 * we always go through FAKE_LEVEL_II
850 * first.
851 */
852 if (!EXCLUSIVE_OPLOCK_TYPE(fsp->oplock_type)) {
853 smb_panic("remove_share_oplock: logic error");
854 }
855 e->op_type = FAKE_LEVEL_II_OPLOCK;
856 } else {
857 e->op_type = NO_OPLOCK;
858 }
859 lck->data->modified = True;
860 return True;
861 }
862
863 /*******************************************************************
864 Downgrade a oplock type from exclusive to level II.
865 ********************************************************************/
866
867 bool downgrade_share_oplock(struct share_mode_lock *lck, files_struct *fsp)
868 {
869 struct share_mode_entry entry, *e;
870
871 /* Don't care about the pid owner being correct here - just a search. */
872 fill_share_mode_entry(&entry, fsp, (uid_t)-1, 0, NO_OPLOCK);
873
874 e = find_share_mode_entry(lck->data, &entry);
875 if (e == NULL) {
876 return False;
877 }
878
879 e->op_type = LEVEL_II_OPLOCK;
880 lck->data->modified = True;
881 return True;
882 }
883
884 /*************************************************************************
885 Return a talloced copy of a struct security_unix_token. NULL on fail.
886 (Should this be in locking.c.... ?).
887 *************************************************************************/
888
889 static struct security_unix_token *copy_unix_token(TALLOC_CTX *ctx, const struct security_unix_token *tok)
890 {
891 struct security_unix_token *cpy;
892
893 cpy = talloc(ctx, struct security_unix_token);
894 if (!cpy) {
895 return NULL;
896 }
897
898 cpy->uid = tok->uid;
899 cpy->gid = tok->gid;
900 cpy->ngroups = tok->ngroups;
901 if (tok->ngroups) {
902 /* Make this a talloc child of cpy. */
903 cpy->groups = (gid_t *)talloc_memdup(
904 cpy, tok->groups, tok->ngroups * sizeof(gid_t));
905 if (!cpy->groups) {
906 TALLOC_FREE(cpy);
907 return NULL;
908 }
909 }
910 return cpy;
911 }
912
913 /****************************************************************************
914 Adds a delete on close token.
915 ****************************************************************************/
916
917 static bool add_delete_on_close_token(struct share_mode_data *d,
918 uint32_t name_hash,
919 const struct security_token *nt_tok,
920 const struct security_unix_token *tok)
921 {
922 struct delete_token *tmp, *dtl;
923
924 tmp = talloc_realloc(d, d->delete_tokens, struct delete_token,
925 d->num_delete_tokens+1);
926 if (tmp == NULL) {
927 return false;
928 }
929 d->delete_tokens = tmp;
930 dtl = &d->delete_tokens[d->num_delete_tokens];
931
932 dtl->name_hash = name_hash;
933 dtl->delete_nt_token = dup_nt_token(d->delete_tokens, nt_tok);
934 if (dtl->delete_nt_token == NULL) {
935 return false;
936 }
937 dtl->delete_token = copy_unix_token(d->delete_tokens, tok);
938 if (dtl->delete_token == NULL) {
939 return false;
940 }
941 d->num_delete_tokens += 1;
942 d->modified = true;
943 return true;
944 }
945
946 /****************************************************************************
947 Sets the delete on close flag over all share modes on this file.
948 Modify the share mode entry for all files open
949 on this device and inode to tell other smbds we have
950 changed the delete on close flag. This will be noticed
951 in the close code, the last closer will delete the file
952 if flag is set.
953 This makes a copy of any struct security_unix_token into the
954 lck entry. This function is used when the lock is already granted.
955 ****************************************************************************/
956
957 void set_delete_on_close_lck(files_struct *fsp,
958 struct share_mode_lock *lck,
959 bool delete_on_close,
960 const struct security_token *nt_tok,
961 const struct security_unix_token *tok)
962 {
963 struct share_mode_data *d = lck->data;
964 int i;
965 bool ret;
966
967 if (delete_on_close) {
968 SMB_ASSERT(nt_tok != NULL);
969 SMB_ASSERT(tok != NULL);
970 } else {
971 SMB_ASSERT(nt_tok == NULL);
972 SMB_ASSERT(tok == NULL);
973 }
974
975 for (i=0; i<d->num_delete_tokens; i++) {
976 struct delete_token *dt = &d->delete_tokens[i];
977 if (dt->name_hash == fsp->name_hash) {
978 d->modified = true;
979 if (delete_on_close == false) {
980 /* Delete this entry. */
981 TALLOC_FREE(dt->delete_nt_token);
982 TALLOC_FREE(dt->delete_token);
983 *dt = d->delete_tokens[
984 d->num_delete_tokens-1];
985 d->num_delete_tokens -= 1;
986 } else {
987 /* Replace this token with the
988 given tok. */
989 TALLOC_FREE(dt->delete_nt_token);
990 dt->delete_nt_token = dup_nt_token(dt, nt_tok);
991 SMB_ASSERT(dt->delete_nt_token != NULL);
992 TALLOC_FREE(dt->delete_token);
993 dt->delete_token = copy_unix_token(dt, tok);
994 SMB_ASSERT(dt->delete_token != NULL);
995 }
996 return;
997 }
998 }
999
1000 if (!delete_on_close) {
1001 /* Nothing to delete - not found. */
1002 return;
1003 }
1004
1005 ret = add_delete_on_close_token(lck->data, fsp->name_hash, nt_tok, tok);
1006 SMB_ASSERT(ret);
1007 }
1008
1009 bool set_delete_on_close(files_struct *fsp, bool delete_on_close,
1010 const struct security_token *nt_tok,
1011 const struct security_unix_token *tok)
1012 {
1013 struct share_mode_lock *lck;
1014
1015 DEBUG(10,("set_delete_on_close: %s delete on close flag for "
1016 "fnum = %d, file %s\n",
1017 delete_on_close ? "Adding" : "Removing", fsp->fnum,
1018 fsp_str_dbg(fsp)));
1019
1020 lck = get_existing_share_mode_lock(talloc_tos(), fsp->file_id);
1021 if (lck == NULL) {
1022 return False;
1023 }
1024
1025 if (delete_on_close) {
1026 set_delete_on_close_lck(fsp, lck, true,
1027 nt_tok,
1028 tok);
1029 } else {
1030 set_delete_on_close_lck(fsp, lck, false,
1031 NULL,
1032 NULL);
1033 }
1034
1035 if (fsp->is_directory) {
1036 SMB_ASSERT(!is_ntfs_stream_smb_fname(fsp->fsp_name));
1037 send_stat_cache_delete_message(fsp->conn->sconn->msg_ctx,
1038 fsp->fsp_name->base_name);
1039 }
1040
1041 TALLOC_FREE(lck);
1042
1043 fsp->delete_on_close = delete_on_close;
1044
1045 return True;
1046 }
1047
1048 static struct delete_token *find_delete_on_close_token(
1049 struct share_mode_data *d, uint32_t name_hash)
1050 {
1051 uint32_t i;
1052
1053 DEBUG(10, ("find_delete_on_close_token: name_hash = 0x%x\n",
1054 (unsigned int)name_hash));
1055
1056 for (i=0; i<d->num_delete_tokens; i++) {
1057 struct delete_token *dt = &d->delete_tokens[i];
1058
1059 DEBUG(10, ("find__delete_on_close_token: dt->name_hash = 0x%x\n",
1060 (unsigned int)dt->name_hash ));
1061 if (dt->name_hash == name_hash) {
1062 return dt;
1063 }
1064 }
1065 return NULL;
1066 }
1067
1068 /****************************************************************************
1069 Return the NT token and UNIX token if there's a match. Return true if
1070 found, false if not.
1071 ****************************************************************************/
1072
1073 bool get_delete_on_close_token(struct share_mode_lock *lck,
1074 uint32_t name_hash,
1075 const struct security_token **pp_nt_tok,
1076 const struct security_unix_token **pp_tok)
1077 {
1078 struct delete_token *dt;
1079
1080 dt = find_delete_on_close_token(lck->data, name_hash);
1081 if (dt == NULL) {
1082 return false;
1083 }
1084 *pp_nt_tok = dt->delete_nt_token;
1085 *pp_tok = dt->delete_token;
1086 return true;
1087 }
1088
1089 bool is_delete_on_close_set(struct share_mode_lock *lck, uint32_t name_hash)
1090 {
1091 return find_delete_on_close_token(lck->data, name_hash) != NULL;
1092 }
1093
1094 bool set_sticky_write_time(struct file_id fileid, struct timespec write_time)
1095 {
1096 struct share_mode_lock *lck;
1097
1098 DEBUG(5,("set_sticky_write_time: %s id=%s\n",
1099 timestring(talloc_tos(),
1100 convert_timespec_to_time_t(write_time)),
1101 file_id_string_tos(&fileid)));
1102
1103 lck = get_existing_share_mode_lock(talloc_tos(), fileid);
1104 if (lck == NULL) {
1105 return False;
1106 }
1107
1108 if (timespec_compare(&lck->data->changed_write_time, &write_time) != 0) {
1109 lck->data->modified = True;
1110 lck->data->changed_write_time = write_time;
1111 }
1112
1113 TALLOC_FREE(lck);
1114 return True;
1115 }
1116
1117 bool set_write_time(struct file_id fileid, struct timespec write_time)
1118 {
1119 struct share_mode_lock *lck;
1120
1121 DEBUG(5,("set_write_time: %s id=%s\n",
1122 timestring(talloc_tos(),
1123 convert_timespec_to_time_t(write_time)),
1124 file_id_string_tos(&fileid)));
1125
1126 lck = get_existing_share_mode_lock(talloc_tos(), fileid);
1127 if (lck == NULL) {
1128 return False;
1129 }
1130
1131 if (timespec_compare(&lck->data->old_write_time, &write_time) != 0) {
1132 lck->data->modified = True;
1133 lck->data->old_write_time = write_time;
1134 }
1135
1136 TALLOC_FREE(lck);
1137 return True;
1138 }
reg import