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