?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
CVE-2013-4476: lib-util: add file_check_permissions()
[Samba.git] / source3 / locking / locking.c
blobbe2c92dfbd1ddb711bfc5d26e1f4916f041e499d
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 %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)));
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 %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)));
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 %s file %s\n",
322 (double)offset, (double)count, fsp_fnum_dbg(fsp),
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 %s file %s\n",
373 (double)offset, (double)count, fsp_fnum_dbg(fsp),
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 struct server_id self_pid = messaging_server_id(msg_ctx);
486
487 DEBUG(10, ("rename_share_filename: servicepath %s newname %s\n",
488 servicepath, smb_fname_dst->base_name));
489
490 /*
491 * rename_internal_fsp() and rename_internals() add './' to
492 * head of newname if newname does not contain a '/'.
493 */
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;
499 }
500
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"));
509 return False;
510 }
511 d->modified = True;
512
513 sp_len = strlen(d->servicepath);
514 bn_len = strlen(d->base_name);
515 sn_len = has_stream ? strlen(d->stream_name) : 0;
516
517 msg_len = MSG_FILE_RENAMED_MIN_SIZE + sp_len + 1 + bn_len + 1 +
518 sn_len + 1;
519
520 /* Set up the name changed message. */
521 frm = talloc_array(d, char, msg_len);
522 if (!frm) {
523 return False;
524 }
525
526 push_file_id_24(frm, &d->id);
527
528 DEBUG(10,("rename_share_filename: msg_len = %u\n", (unsigned int)msg_len ));
529
530 strlcpy(&frm[24],
531 d->servicepath ? d->servicepath : "",
532 sp_len+1);
533 strlcpy(&frm[24 + sp_len + 1],
534 d->base_name ? d->base_name : "",
535 bn_len+1);
536 strlcpy(&frm[24 + sp_len + 1 + bn_len + 1],
537 d->stream_name ? d->stream_name : "",
538 sn_len+1);
539
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)) {
544 continue;
545 }
546
547 /* If this is a hardlink to the inode
548 with a different name, skip this. */
549 if (se->name_hash != orig_name_hash) {
550 continue;
551 }
552
553 se->name_hash = new_name_hash;
554
555 /* But not to ourselves... */
556 if (serverid_equal(&se->pid, &self_pid)) {
557 continue;
558 }
559
560 if (share_mode_stale_pid(d, i)) {
561 continue;
562 }
563
564 DEBUG(10,("rename_share_filename: sending rename message to "
565 "pid %s file_id %s sharepath %s base_name %s "
566 "stream_name %s\n",
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 : ""));
571
572 messaging_send_buf(msg_ctx, se->pid, MSG_SMB_FILE_RENAME,
573 (uint8 *)frm, msg_len);
574 }
575
576 return True;
577 }
578
579 void get_file_infos(struct file_id id,
580 uint32_t name_hash,
581 bool *delete_on_close,
582 struct timespec *write_time)
583 {
584 struct share_mode_lock *lck;
585
586 if (delete_on_close) {
587 *delete_on_close = false;
588 }
589
590 if (write_time) {
591 ZERO_STRUCTP(write_time);
592 }
593
594 if (!(lck = fetch_share_mode_unlocked(talloc_tos(), id))) {
595 return;
596 }
597
598 if (delete_on_close) {
599 *delete_on_close = is_delete_on_close_set(lck, name_hash);
600 }
601
602 if (write_time) {
603 struct timespec wt;
604
605 wt = lck->data->changed_write_time;
606 if (null_timespec(wt)) {
607 wt = lck->data->old_write_time;
608 }
609
610 *write_time = wt;
611 }
612
613 TALLOC_FREE(lck);
614 }
615
616 bool is_valid_share_mode_entry(const struct share_mode_entry *e)
617 {
618 int num_props = 0;
619
620 if (e->stale) {
621 return false;
622 }
623
624 num_props += ((e->op_type == NO_OPLOCK) ? 1 : 0);
625 num_props += (EXCLUSIVE_OPLOCK_TYPE(e->op_type) ? 1 : 0);
626 num_props += (LEVEL_II_OPLOCK_TYPE(e->op_type) ? 1 : 0);
627
628 if ((num_props > 1) && serverid_exists(&e->pid)) {
629 smb_panic("Invalid share mode entry");
630 }
631 return (num_props != 0);
632 }
633
634 bool is_deferred_open_entry(const struct share_mode_entry *e)
635 {
636 return (e->op_type == DEFERRED_OPEN_ENTRY);
637 }
638
639 /*
640 * In case d->share_modes[i] conflicts with something or otherwise is
641 * being used, we need to make sure the corresponding process still
642 * exists.
643 */
644 bool share_mode_stale_pid(struct share_mode_data *d, unsigned idx)
645 {
646 struct share_mode_entry *e;
647
648 if (idx > d->num_share_modes) {
649 DEBUG(1, ("Asking for index %u, only %u around\n",
650 idx, (unsigned)d->num_share_modes));
651 return false;
652 }
653 e = &d->share_modes[idx];
654 if (serverid_exists(&e->pid)) {
655 DEBUG(10, ("PID %s (index %u out of %u) still exists\n",
656 procid_str_static(&e->pid), idx,
657 (unsigned)d->num_share_modes));
658 return false;
659 }
660 DEBUG(10, ("PID %s (index %u out of %u) does not exist anymore\n",
661 procid_str_static(&e->pid), idx,
662 (unsigned)d->num_share_modes));
663
664 e->stale = true;
665
666 if (d->num_delete_tokens != 0) {
667 uint32_t i, num_stale;
668
669 /*
670 * We cannot have any delete tokens
671 * if there are no valid share modes.
672 */
673
674 num_stale = 0;
675
676 for (i=0; i<d->num_share_modes; i++) {
677 if (d->share_modes[i].stale) {
678 num_stale += 1;
679 }
680 }
681
682 if (num_stale == d->num_share_modes) {
683 /*
684 * No non-stale share mode found
685 */
686 TALLOC_FREE(d->delete_tokens);
687 d->num_delete_tokens = 0;
688 }
689 }
690
691 d->modified = true;
692 return true;
693 }
694
695 /*******************************************************************
696 Fill a share mode entry.
697 ********************************************************************/
698
699 static void fill_share_mode_entry(struct share_mode_entry *e,
700 files_struct *fsp,
701 uid_t uid, uint64_t mid, uint16 op_type)
702 {
703 ZERO_STRUCTP(e);
704 e->pid = messaging_server_id(fsp->conn->sconn->msg_ctx);
705 e->share_access = fsp->share_access;
706 e->private_options = fsp->fh->private_options;
707 e->access_mask = fsp->access_mask;
708 e->op_mid = mid;
709 e->op_type = op_type;
710 e->time.tv_sec = fsp->open_time.tv_sec;
711 e->time.tv_usec = fsp->open_time.tv_usec;
712 e->id = fsp->file_id;
713 e->share_file_id = fsp->fh->gen_id;
714 e->uid = (uint32)uid;
715 e->flags = fsp->posix_open ? SHARE_MODE_FLAG_POSIX_OPEN : 0;
716 e->name_hash = fsp->name_hash;
717 }
718
719 static void fill_deferred_open_entry(struct share_mode_entry *e,
720 const struct timeval request_time,
721 struct file_id id,
722 struct server_id pid,
723 uint64_t mid)
724 {
725 ZERO_STRUCTP(e);
726 e->pid = pid;
727 e->op_mid = mid;
728 e->op_type = DEFERRED_OPEN_ENTRY;
729 e->time.tv_sec = request_time.tv_sec;
730 e->time.tv_usec = request_time.tv_usec;
731 e->id = id;
732 e->uid = (uint32)-1;
733 e->flags = 0;
734 }
735
736 static void add_share_mode_entry(struct share_mode_data *d,
737 const struct share_mode_entry *entry)
738 {
739 ADD_TO_ARRAY(d, struct share_mode_entry, *entry,
740 &d->share_modes, &d->num_share_modes);
741 d->modified = True;
742 }
743
744 void set_share_mode(struct share_mode_lock *lck, files_struct *fsp,
745 uid_t uid, uint64_t mid, uint16 op_type)
746 {
747 struct share_mode_entry entry;
748 fill_share_mode_entry(&entry, fsp, uid, mid, op_type);
749 add_share_mode_entry(lck->data, &entry);
750 }
751
752 void add_deferred_open(struct share_mode_lock *lck, uint64_t mid,
753 struct timeval request_time,
754 struct server_id pid, struct file_id id)
755 {
756 struct share_mode_entry entry;
757 fill_deferred_open_entry(&entry, request_time, id, pid, mid);
758 add_share_mode_entry(lck->data, &entry);
759 }
760
761 /*******************************************************************
762 Check if two share mode entries are identical, ignoring oplock
763 and mid info and desired_access. (Removed paranoia test - it's
764 not automatically a logic error if they are identical. JRA.)
765 ********************************************************************/
766
767 static bool share_modes_identical(struct share_mode_entry *e1,
768 struct share_mode_entry *e2)
769 {
770 /* We used to check for e1->share_access == e2->share_access here
771 as well as the other fields but 2 different DOS or FCB opens
772 sharing the same share mode entry may validly differ in
773 fsp->share_access field. */
774
775 return (serverid_equal(&e1->pid, &e2->pid) &&
776 file_id_equal(&e1->id, &e2->id) &&
777 e1->share_file_id == e2->share_file_id );
778 }
779
780 static bool deferred_open_identical(struct share_mode_entry *e1,
781 struct share_mode_entry *e2)
782 {
783 return (serverid_equal(&e1->pid, &e2->pid) &&
784 (e1->op_mid == e2->op_mid) &&
785 file_id_equal(&e1->id, &e2->id));
786 }
787
788 static struct share_mode_entry *find_share_mode_entry(struct share_mode_data *d,
789 struct share_mode_entry *entry)
790 {
791 int i;
792
793 for (i=0; i<d->num_share_modes; i++) {
794 struct share_mode_entry *e = &d->share_modes[i];
795 if (is_valid_share_mode_entry(entry) &&
796 is_valid_share_mode_entry(e) &&
797 share_modes_identical(e, entry)) {
798 return e;
799 }
800 if (is_deferred_open_entry(entry) &&
801 is_deferred_open_entry(e) &&
802 deferred_open_identical(e, entry)) {
803 return e;
804 }
805 }
806 return NULL;
807 }
808
809 /*******************************************************************
810 Del the share mode of a file for this process. Return the number of
811 entries left.
812 ********************************************************************/
813
814 bool del_share_mode(struct share_mode_lock *lck, files_struct *fsp)
815 {
816 struct share_mode_entry entry, *e;
817
818 /* Don't care about the pid owner being correct here - just a search. */
819 fill_share_mode_entry(&entry, fsp, (uid_t)-1, 0, NO_OPLOCK);
820
821 e = find_share_mode_entry(lck->data, &entry);
822 if (e == NULL) {
823 return False;
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 return True;
829 }
830
831 bool mark_share_mode_disconnected(struct share_mode_lock *lck,
832 struct files_struct *fsp)
833 {
834 struct share_mode_entry entry, *e;
835
836 if (lck->data->num_share_modes != 1) {
837 return false;
838 }
839
840 if (fsp->op == NULL) {
841 return false;
842 }
843 if (!fsp->op->global->durable) {
844 return false;
845 }
846
847 /* Don't care about the pid owner being correct here - just a search. */
848 fill_share_mode_entry(&entry, fsp, (uid_t)-1, 0, NO_OPLOCK);
849
850 e = find_share_mode_entry(lck->data, &entry);
851 if (e == NULL) {
852 return false;
853 }
854
855 DEBUG(10, ("Marking share mode entry disconnected for durable handle\n"));
856
857 server_id_set_disconnected(&e->pid);
858
859 /*
860 * On reopen the caller needs to check that
861 * the client comes with the correct handle.
862 */
863 e->share_file_id = fsp->op->global->open_persistent_id;
864
865 lck->data->modified = true;
866 return true;
867 }
868
869 void del_deferred_open_entry(struct share_mode_lock *lck, uint64_t mid,
870 struct server_id pid)
871 {
872 struct share_mode_entry entry, *e;
873
874 fill_deferred_open_entry(&entry, timeval_zero(),
875 lck->data->id, pid, mid);
876
877 e = find_share_mode_entry(lck->data, &entry);
878 if (e == NULL) {
879 return;
880 }
881 *e = lck->data->share_modes[lck->data->num_share_modes-1];
882 lck->data->num_share_modes -= 1;
883 lck->data->modified = True;
884 }
885
886 /*******************************************************************
887 Remove an oplock mid and mode entry from a share mode.
888 ********************************************************************/
889
890 bool remove_share_oplock(struct share_mode_lock *lck, files_struct *fsp)
891 {
892 struct share_mode_entry entry, *e;
893
894 /* Don't care about the pid owner being correct here - just a search. */
895 fill_share_mode_entry(&entry, fsp, (uid_t)-1, 0, NO_OPLOCK);
896
897 e = find_share_mode_entry(lck->data, &entry);
898 if (e == NULL) {
899 return False;
900 }
901
902 if (EXCLUSIVE_OPLOCK_TYPE(e->op_type)) {
903 /*
904 * Going from exclusive or batch,
905 * we always go through FAKE_LEVEL_II
906 * first.
907 */
908 if (!EXCLUSIVE_OPLOCK_TYPE(fsp->oplock_type)) {
909 smb_panic("remove_share_oplock: logic error");
910 }
911 e->op_type = FAKE_LEVEL_II_OPLOCK;
912 } else {
913 e->op_type = NO_OPLOCK;
914 }
915 lck->data->modified = True;
916 return True;
917 }
918
919 /*******************************************************************
920 Downgrade a oplock type from exclusive to level II.
921 ********************************************************************/
922
923 bool downgrade_share_oplock(struct share_mode_lock *lck, files_struct *fsp)
924 {
925 struct share_mode_entry entry, *e;
926
927 /* Don't care about the pid owner being correct here - just a search. */
928 fill_share_mode_entry(&entry, fsp, (uid_t)-1, 0, NO_OPLOCK);
929
930 e = find_share_mode_entry(lck->data, &entry);
931 if (e == NULL) {
932 return False;
933 }
934
935 e->op_type = LEVEL_II_OPLOCK;
936 lck->data->modified = True;
937 return True;
938 }
939
940 /****************************************************************************
941 Adds a delete on close token.
942 ****************************************************************************/
943
944 static bool add_delete_on_close_token(struct share_mode_data *d,
945 uint32_t name_hash,
946 const struct security_token *nt_tok,
947 const struct security_unix_token *tok)
948 {
949 struct delete_token *tmp, *dtl;
950
951 tmp = talloc_realloc(d, d->delete_tokens, struct delete_token,
952 d->num_delete_tokens+1);
953 if (tmp == NULL) {
954 return false;
955 }
956 d->delete_tokens = tmp;
957 dtl = &d->delete_tokens[d->num_delete_tokens];
958
959 dtl->name_hash = name_hash;
960 dtl->delete_nt_token = dup_nt_token(d->delete_tokens, nt_tok);
961 if (dtl->delete_nt_token == NULL) {
962 return false;
963 }
964 dtl->delete_token = copy_unix_token(d->delete_tokens, tok);
965 if (dtl->delete_token == NULL) {
966 return false;
967 }
968 d->num_delete_tokens += 1;
969 d->modified = true;
970 return true;
971 }
972
973 /****************************************************************************
974 Sets the delete on close flag over all share modes on this file.
975 Modify the share mode entry for all files open
976 on this device and inode to tell other smbds we have
977 changed the delete on close flag. This will be noticed
978 in the close code, the last closer will delete the file
979 if flag is set.
980 This makes a copy of any struct security_unix_token into the
981 lck entry. This function is used when the lock is already granted.
982 ****************************************************************************/
983
984 void set_delete_on_close_lck(files_struct *fsp,
985 struct share_mode_lock *lck,
986 bool delete_on_close,
987 const struct security_token *nt_tok,
988 const struct security_unix_token *tok)
989 {
990 struct share_mode_data *d = lck->data;
991 int i;
992 bool ret;
993
994 if (delete_on_close) {
995 SMB_ASSERT(nt_tok != NULL);
996 SMB_ASSERT(tok != NULL);
997 } else {
998 SMB_ASSERT(nt_tok == NULL);
999 SMB_ASSERT(tok == NULL);
1000 }
1001
1002 for (i=0; i<d->num_delete_tokens; i++) {
1003 struct delete_token *dt = &d->delete_tokens[i];
1004 if (dt->name_hash == fsp->name_hash) {
1005 d->modified = true;
1006 if (delete_on_close == false) {
1007 /* Delete this entry. */
1008 TALLOC_FREE(dt->delete_nt_token);
1009 TALLOC_FREE(dt->delete_token);
1010 *dt = d->delete_tokens[
1011 d->num_delete_tokens-1];
1012 d->num_delete_tokens -= 1;
1013 } else {
1014 /* Replace this token with the
1015 given tok. */
1016 TALLOC_FREE(dt->delete_nt_token);
1017 dt->delete_nt_token = dup_nt_token(dt, nt_tok);
1018 SMB_ASSERT(dt->delete_nt_token != NULL);
1019 TALLOC_FREE(dt->delete_token);
1020 dt->delete_token = copy_unix_token(dt, tok);
1021 SMB_ASSERT(dt->delete_token != NULL);
1022 }
1023 return;
1024 }
1025 }
1026
1027 if (!delete_on_close) {
1028 /* Nothing to delete - not found. */
1029 return;
1030 }
1031
1032 ret = add_delete_on_close_token(lck->data, fsp->name_hash, nt_tok, tok);
1033 SMB_ASSERT(ret);
1034 }
1035
1036 bool set_delete_on_close(files_struct *fsp, bool delete_on_close,
1037 const struct security_token *nt_tok,
1038 const struct security_unix_token *tok)
1039 {
1040 struct share_mode_lock *lck;
1041
1042 DEBUG(10,("set_delete_on_close: %s delete on close flag for "
1043 "%s, file %s\n",
1044 delete_on_close ? "Adding" : "Removing", fsp_fnum_dbg(fsp),
1045 fsp_str_dbg(fsp)));
1046
1047 lck = get_existing_share_mode_lock(talloc_tos(), fsp->file_id);
1048 if (lck == NULL) {
1049 return False;
1050 }
1051
1052 if (delete_on_close) {
1053 set_delete_on_close_lck(fsp, lck, true,
1054 nt_tok,
1055 tok);
1056 } else {
1057 set_delete_on_close_lck(fsp, lck, false,
1058 NULL,
1059 NULL);
1060 }
1061
1062 if (fsp->is_directory) {
1063 SMB_ASSERT(!is_ntfs_stream_smb_fname(fsp->fsp_name));
1064 send_stat_cache_delete_message(fsp->conn->sconn->msg_ctx,
1065 fsp->fsp_name->base_name);
1066 }
1067
1068 TALLOC_FREE(lck);
1069
1070 fsp->delete_on_close = delete_on_close;
1071
1072 return True;
1073 }
1074
1075 static struct delete_token *find_delete_on_close_token(
1076 struct share_mode_data *d, uint32_t name_hash)
1077 {
1078 uint32_t i;
1079
1080 DEBUG(10, ("find_delete_on_close_token: name_hash = 0x%x\n",
1081 (unsigned int)name_hash));
1082
1083 for (i=0; i<d->num_delete_tokens; i++) {
1084 struct delete_token *dt = &d->delete_tokens[i];
1085
1086 DEBUG(10, ("find__delete_on_close_token: dt->name_hash = 0x%x\n",
1087 (unsigned int)dt->name_hash ));
1088 if (dt->name_hash == name_hash) {
1089 return dt;
1090 }
1091 }
1092 return NULL;
1093 }
1094
1095 /****************************************************************************
1096 Return the NT token and UNIX token if there's a match. Return true if
1097 found, false if not.
1098 ****************************************************************************/
1099
1100 bool get_delete_on_close_token(struct share_mode_lock *lck,
1101 uint32_t name_hash,
1102 const struct security_token **pp_nt_tok,
1103 const struct security_unix_token **pp_tok)
1104 {
1105 struct delete_token *dt;
1106
1107 dt = find_delete_on_close_token(lck->data, name_hash);
1108 if (dt == NULL) {
1109 return false;
1110 }
1111 *pp_nt_tok = dt->delete_nt_token;
1112 *pp_tok = dt->delete_token;
1113 return true;
1114 }
1115
1116 bool is_delete_on_close_set(struct share_mode_lock *lck, uint32_t name_hash)
1117 {
1118 return find_delete_on_close_token(lck->data, name_hash) != NULL;
1119 }
1120
1121 bool set_sticky_write_time(struct file_id fileid, struct timespec write_time)
1122 {
1123 struct share_mode_lock *lck;
1124
1125 DEBUG(5,("set_sticky_write_time: %s id=%s\n",
1126 timestring(talloc_tos(),
1127 convert_timespec_to_time_t(write_time)),
1128 file_id_string_tos(&fileid)));
1129
1130 lck = get_existing_share_mode_lock(talloc_tos(), fileid);
1131 if (lck == NULL) {
1132 return False;
1133 }
1134
1135 if (timespec_compare(&lck->data->changed_write_time, &write_time) != 0) {
1136 lck->data->modified = True;
1137 lck->data->changed_write_time = write_time;
1138 }
1139
1140 TALLOC_FREE(lck);
1141 return True;
1142 }
1143
1144 bool set_write_time(struct file_id fileid, struct timespec write_time)
1145 {
1146 struct share_mode_lock *lck;
1147
1148 DEBUG(5,("set_write_time: %s id=%s\n",
1149 timestring(talloc_tos(),
1150 convert_timespec_to_time_t(write_time)),
1151 file_id_string_tos(&fileid)));
1152
1153 lck = get_existing_share_mode_lock(talloc_tos(), fileid);
1154 if (lck == NULL) {
1155 return False;
1156 }
1157
1158 if (timespec_compare(&lck->data->old_write_time, &write_time) != 0) {
1159 lck->data->modified = True;
1160 lck->data->old_write_time = write_time;
1161 }
1162
1163 TALLOC_FREE(lck);
1164 return True;
1165 }
Samba GIT mirror