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