smbd: Use share_mode_entry's lease data in remove_share_mode_lease()
[ambi/samba-autobuild/.git] / source3 / locking / locking.c
1 /* 
2    Unix SMB/CIFS implementation.
3    Locking functions
4    Copyright (C) Andrew Tridgell 1992-2000
5    Copyright (C) Jeremy Allison 1992-2006
6    Copyright (C) Volker Lendecke 2005
7
8    This program is free software; you can redistribute it and/or modify
9    it under the terms of the GNU General Public License as published by
10    the Free Software Foundation; either version 3 of the License, or
11    (at your option) any later version.
12
13    This program is distributed in the hope that it will be useful,
14    but WITHOUT ANY WARRANTY; without even the implied warranty of
15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16    GNU General Public License for more details.
17
18    You should have received a copy of the GNU General Public License
19    along with this program.  If not, see <http://www.gnu.org/licenses/>.
20
21    Revision History:
22
23    12 aug 96: Erik.Devriendt@te6.siemens.be
24    added support for shared memory implementation of share mode locking
25
26    May 1997. Jeremy Allison (jallison@whistle.com). Modified share mode
27    locking to deal with multiple share modes per open file.
28
29    September 1997. Jeremy Allison (jallison@whistle.com). Added oplock
30    support.
31
32    rewritten completely to use new tdb code. Tridge, Dec '99
33
34    Added POSIX locking support. Jeremy Allison (jeremy@valinux.com), Apr. 2000.
35    Added Unix Extensions POSIX locking support. Jeremy Allison Mar 2006.
36 */
37
38 #include "includes.h"
39 #include "system/filesys.h"
40 #include "lib/util/server_id.h"
41 #include "locking/proto.h"
42 #include "smbd/globals.h"
43 #include "dbwrap/dbwrap.h"
44 #include "dbwrap/dbwrap_open.h"
45 #include "../libcli/security/security.h"
46 #include "serverid.h"
47 #include "messages.h"
48 #include "util_tdb.h"
49 #include "../librpc/gen_ndr/ndr_open_files.h"
50 #include "librpc/gen_ndr/ndr_file_id.h"
51 #include "locking/leases_db.h"
52
53 #undef DBGC_CLASS
54 #define DBGC_CLASS DBGC_LOCKING
55
56 #define NO_LOCKING_COUNT (-1)
57
58 /****************************************************************************
59  Debugging aids :-).
60 ****************************************************************************/
61
62 const char *lock_type_name(enum brl_type lock_type)
63 {
64         switch (lock_type) {
65                 case READ_LOCK:
66                         return "READ";
67                 case WRITE_LOCK:
68                         return "WRITE";
69                 case PENDING_READ_LOCK:
70                         return "PENDING_READ";
71                 case PENDING_WRITE_LOCK:
72                         return "PENDING_WRITE";
73                 default:
74                         return "other";
75         }
76 }
77
78 const char *lock_flav_name(enum brl_flavour lock_flav)
79 {
80         return (lock_flav == WINDOWS_LOCK) ? "WINDOWS_LOCK" : "POSIX_LOCK";
81 }
82
83 /****************************************************************************
84  Utility function called to see if a file region is locked.
85  Called in the read/write codepath.
86 ****************************************************************************/
87
88 void init_strict_lock_struct(files_struct *fsp,
89                                 uint64_t smblctx,
90                                 br_off start,
91                                 br_off size,
92                                 enum brl_type lock_type,
93                                 struct lock_struct *plock)
94 {
95         SMB_ASSERT(lock_type == READ_LOCK || lock_type == WRITE_LOCK);
96
97         plock->context.smblctx = smblctx;
98         plock->context.tid = fsp->conn->cnum;
99         plock->context.pid = messaging_server_id(fsp->conn->sconn->msg_ctx);
100         plock->start = start;
101         plock->size = size;
102         plock->fnum = fsp->fnum;
103         plock->lock_type = lock_type;
104         plock->lock_flav = lp_posix_cifsu_locktype(fsp);
105 }
106
107 bool strict_lock_check_default(files_struct *fsp, struct lock_struct *plock)
108 {
109         struct byte_range_lock *br_lck;
110         int strict_locking = lp_strict_locking(fsp->conn->params);
111         bool ret = False;
112
113         if (plock->size == 0) {
114                 return True;
115         }
116
117         if (!lp_locking(fsp->conn->params) || !strict_locking) {
118                 return True;
119         }
120
121         if (strict_locking == Auto) {
122                 uint32_t lease_type = fsp_lease_type(fsp);
123
124                 if ((lease_type & SMB2_LEASE_READ) &&
125                      (plock->lock_type == READ_LOCK))
126                 {
127                         DBG_DEBUG("optimisation - read lease on file %s\n",
128                                   fsp_str_dbg(fsp));
129                         return true;
130                 }
131
132                 if ((lease_type & SMB2_LEASE_WRITE) &&
133                      (plock->lock_type == WRITE_LOCK))
134                 {
135                         DBG_DEBUG("optimisation - write lease on file %s\n",
136                                   fsp_str_dbg(fsp));
137                         return true;
138                 }
139         }
140
141         br_lck = brl_get_locks_readonly(fsp);
142         if (!br_lck) {
143                 return true;
144         }
145         ret = brl_locktest(br_lck, plock);
146
147         if (!ret) {
148                 /*
149                  * We got a lock conflict. Retry with rw locks to enable
150                  * autocleanup. This is the slow path anyway.
151                  */
152                 br_lck = brl_get_locks(talloc_tos(), fsp);
153                 if (br_lck == NULL) {
154                         return true;
155                 }
156                 ret = brl_locktest(br_lck, plock);
157                 TALLOC_FREE(br_lck);
158         }
159
160         DEBUG(10, ("strict_lock_default: flavour = %s brl start=%ju "
161                    "len=%ju %s for fnum %ju file %s\n",
162                    lock_flav_name(plock->lock_flav),
163                    (uintmax_t)plock->start, (uintmax_t)plock->size,
164                    ret ? "unlocked" : "locked",
165                    (uintmax_t)plock->fnum, fsp_str_dbg(fsp)));
166
167         return ret;
168 }
169
170 /****************************************************************************
171  Find out if a lock could be granted - return who is blocking us if we can't.
172 ****************************************************************************/
173
174 NTSTATUS query_lock(files_struct *fsp,
175                         uint64_t *psmblctx,
176                         uint64_t *pcount,
177                         uint64_t *poffset,
178                         enum brl_type *plock_type,
179                         enum brl_flavour lock_flav)
180 {
181         struct byte_range_lock *br_lck = NULL;
182
183         if (!fsp->can_lock) {
184                 return fsp->is_directory ? NT_STATUS_INVALID_DEVICE_REQUEST : NT_STATUS_INVALID_HANDLE;
185         }
186
187         if (!lp_locking(fsp->conn->params)) {
188                 return NT_STATUS_OK;
189         }
190
191         br_lck = brl_get_locks_readonly(fsp);
192         if (!br_lck) {
193                 return NT_STATUS_NO_MEMORY;
194         }
195
196         return brl_lockquery(br_lck,
197                         psmblctx,
198                         messaging_server_id(fsp->conn->sconn->msg_ctx),
199                         poffset,
200                         pcount,
201                         plock_type,
202                         lock_flav);
203 }
204
205 static void increment_current_lock_count(files_struct *fsp,
206     enum brl_flavour lock_flav)
207 {
208         if (lock_flav == WINDOWS_LOCK &&
209             fsp->current_lock_count != NO_LOCKING_COUNT) {
210                 /* blocking ie. pending, locks also count here,
211                  * as this is an efficiency counter to avoid checking
212                  * the lock db. on close. JRA. */
213
214                 fsp->current_lock_count++;
215         } else {
216                 /* Notice that this has had a POSIX lock request.
217                  * We can't count locks after this so forget them.
218                  */
219                 fsp->current_lock_count = NO_LOCKING_COUNT;
220         }
221 }
222
223 static void decrement_current_lock_count(files_struct *fsp,
224     enum brl_flavour lock_flav)
225 {
226         if (lock_flav == WINDOWS_LOCK &&
227             fsp->current_lock_count != NO_LOCKING_COUNT) {
228                 SMB_ASSERT(fsp->current_lock_count > 0);
229                 fsp->current_lock_count--;
230         }
231 }
232
233 /****************************************************************************
234  Utility function called by locking requests.
235 ****************************************************************************/
236
237 struct byte_range_lock *do_lock(struct messaging_context *msg_ctx,
238                         files_struct *fsp,
239                         uint64_t smblctx,
240                         uint64_t count,
241                         uint64_t offset,
242                         enum brl_type lock_type,
243                         enum brl_flavour lock_flav,
244                         bool blocking_lock,
245                         NTSTATUS *perr,
246                         uint64_t *psmblctx)
247 {
248         struct byte_range_lock *br_lck = NULL;
249
250         /* silently return ok on print files as we don't do locking there */
251         if (fsp->print_file) {
252                 *perr = NT_STATUS_OK;
253                 return NULL;
254         }
255
256         if (!fsp->can_lock) {
257                 *perr = fsp->is_directory ? NT_STATUS_INVALID_DEVICE_REQUEST : NT_STATUS_INVALID_HANDLE;
258                 return NULL;
259         }
260
261         if (!lp_locking(fsp->conn->params)) {
262                 *perr = NT_STATUS_OK;
263                 return NULL;
264         }
265
266         /* NOTE! 0 byte long ranges ARE allowed and should be stored  */
267
268         DEBUG(10,("do_lock: lock flavour %s lock type %s start=%ju len=%ju "
269                 "blocking_lock=%s requested for %s file %s\n",
270                 lock_flav_name(lock_flav), lock_type_name(lock_type),
271                 (uintmax_t)offset, (uintmax_t)count, blocking_lock ? "true" :
272                 "false", fsp_fnum_dbg(fsp), fsp_str_dbg(fsp)));
273
274         br_lck = brl_get_locks(talloc_tos(), fsp);
275         if (!br_lck) {
276                 *perr = NT_STATUS_NO_MEMORY;
277                 return NULL;
278         }
279
280         *perr = brl_lock(msg_ctx,
281                         br_lck,
282                         smblctx,
283                         messaging_server_id(fsp->conn->sconn->msg_ctx),
284                         offset,
285                         count,
286                         lock_type,
287                         lock_flav,
288                         blocking_lock,
289                         psmblctx);
290
291         DEBUG(10, ("do_lock: returning status=%s\n", nt_errstr(*perr)));
292
293         increment_current_lock_count(fsp, lock_flav);
294         return br_lck;
295 }
296
297 /****************************************************************************
298  Utility function called by unlocking requests.
299 ****************************************************************************/
300
301 NTSTATUS do_unlock(struct messaging_context *msg_ctx,
302                         files_struct *fsp,
303                         uint64_t smblctx,
304                         uint64_t count,
305                         uint64_t offset,
306                         enum brl_flavour lock_flav)
307 {
308         bool ok = False;
309         struct byte_range_lock *br_lck = NULL;
310
311         if (!fsp->can_lock) {
312                 return fsp->is_directory ? NT_STATUS_INVALID_DEVICE_REQUEST : NT_STATUS_INVALID_HANDLE;
313         }
314
315         if (!lp_locking(fsp->conn->params)) {
316                 return NT_STATUS_OK;
317         }
318
319         DEBUG(10, ("do_unlock: unlock start=%ju len=%ju requested for %s file "
320                    "%s\n", (uintmax_t)offset, (uintmax_t)count,
321                    fsp_fnum_dbg(fsp), fsp_str_dbg(fsp)));
322
323         br_lck = brl_get_locks(talloc_tos(), fsp);
324         if (!br_lck) {
325                 return NT_STATUS_NO_MEMORY;
326         }
327
328         ok = brl_unlock(msg_ctx,
329                         br_lck,
330                         smblctx,
331                         messaging_server_id(fsp->conn->sconn->msg_ctx),
332                         offset,
333                         count,
334                         lock_flav);
335
336         TALLOC_FREE(br_lck);
337
338         if (!ok) {
339                 DEBUG(10,("do_unlock: returning ERRlock.\n" ));
340                 return NT_STATUS_RANGE_NOT_LOCKED;
341         }
342
343         decrement_current_lock_count(fsp, lock_flav);
344         return NT_STATUS_OK;
345 }
346
347 /****************************************************************************
348  Cancel any pending blocked locks.
349 ****************************************************************************/
350
351 NTSTATUS do_lock_cancel(files_struct *fsp,
352                         uint64_t smblctx,
353                         uint64_t count,
354                         uint64_t offset,
355                         enum brl_flavour lock_flav)
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=%ju len=%ju requested for "
370                    "%s file %s\n", (uintmax_t)offset, (uintmax_t)count,
371                    fsp_fnum_dbg(fsp), 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                         messaging_server_id(fsp->conn->sconn->msg_ctx),
381                         offset,
382                         count,
383                         lock_flav);
384
385         TALLOC_FREE(br_lck);
386
387         if (!ok) {
388                 DEBUG(10,("do_lock_cancel: returning ERRcancelviolation.\n" ));
389                 return NT_STATUS_DOS(ERRDOS, ERRcancelviolation);
390         }
391
392         decrement_current_lock_count(fsp, lock_flav);
393         return NT_STATUS_OK;
394 }
395
396 /****************************************************************************
397  Remove any locks on this fd. Called from file_close().
398 ****************************************************************************/
399
400 void locking_close_file(struct messaging_context *msg_ctx,
401                         files_struct *fsp,
402                         enum file_close_type close_type)
403 {
404         struct byte_range_lock *br_lck;
405
406         if (!lp_locking(fsp->conn->params)) {
407                 return;
408         }
409
410         /* If we have no outstanding locks or pending
411          * locks then we don't need to look in the lock db.
412          */
413
414         if (fsp->current_lock_count == 0) {
415                 return;
416         }
417
418         br_lck = brl_get_locks(talloc_tos(),fsp);
419
420         if (br_lck) {
421                 cancel_pending_lock_requests_by_fid(fsp, br_lck, close_type);
422                 brl_close_fnum(msg_ctx, br_lck);
423                 TALLOC_FREE(br_lck);
424         }
425 }
426
427 /*******************************************************************
428  Print out a share mode.
429 ********************************************************************/
430
431 char *share_mode_str(TALLOC_CTX *ctx, int num,
432                      const struct file_id *id,
433                      const struct share_mode_entry *e)
434 {
435         struct server_id_buf tmp;
436
437         return talloc_asprintf(ctx, "share_mode_entry[%d]: "
438                  "pid = %s, share_access = 0x%x, private_options = 0x%x, "
439                  "access_mask = 0x%x, mid = 0x%llx, type= 0x%x, gen_id = %llu, "
440                  "uid = %u, flags = %u, file_id %s, name_hash = 0x%x",
441                  num,
442                  server_id_str_buf(e->pid, &tmp),
443                  e->share_access, e->private_options,
444                  e->access_mask, (unsigned long long)e->op_mid,
445                  e->op_type, (unsigned long long)e->share_file_id,
446                  (unsigned int)e->uid, (unsigned int)e->flags,
447                  file_id_string_tos(id),
448                  (unsigned int)e->name_hash);
449 }
450
451 /*******************************************************************
452  Fetch a share mode where we know one MUST exist. This call reference
453  counts it internally to allow for nested lock fetches.
454 ********************************************************************/
455
456 struct share_mode_lock *get_existing_share_mode_lock(TALLOC_CTX *mem_ctx,
457                                                      const struct file_id id)
458 {
459         return get_share_mode_lock(mem_ctx, id, NULL, NULL, NULL);
460 }
461
462 /*******************************************************************
463  Sets the service name and filename for rename.
464  At this point we emit "file renamed" messages to all
465  process id's that have this file open.
466  Based on an initial code idea from SATOH Fumiyasu <fumiya@samba.gr.jp>
467 ********************************************************************/
468
469 bool rename_share_filename(struct messaging_context *msg_ctx,
470                         struct share_mode_lock *lck,
471                         struct file_id id,
472                         const char *servicepath,
473                         uint32_t orig_name_hash,
474                         uint32_t new_name_hash,
475                         const struct smb_filename *smb_fname_dst)
476 {
477         struct share_mode_data *d = lck->data;
478         size_t sp_len;
479         size_t bn_len;
480         size_t sn_len;
481         size_t msg_len;
482         char *frm = NULL;
483         uint32_t i;
484         bool strip_two_chars = false;
485         bool has_stream = smb_fname_dst->stream_name != NULL;
486         struct server_id self_pid = messaging_server_id(msg_ctx);
487
488         DEBUG(10, ("rename_share_filename: servicepath %s newname %s\n",
489                    servicepath, smb_fname_dst->base_name));
490
491         /*
492          * rename_internal_fsp() and rename_internals() add './' to
493          * head of newname if newname does not contain a '/'.
494          */
495         if (smb_fname_dst->base_name[0] &&
496             smb_fname_dst->base_name[1] &&
497             smb_fname_dst->base_name[0] == '.' &&
498             smb_fname_dst->base_name[1] == '/') {
499                 strip_two_chars = true;
500         }
501
502         d->servicepath = talloc_strdup(d, servicepath);
503         d->base_name = talloc_strdup(d, smb_fname_dst->base_name +
504                                        (strip_two_chars ? 2 : 0));
505         d->stream_name = talloc_strdup(d, smb_fname_dst->stream_name);
506         if (d->base_name == NULL ||
507             (has_stream && d->stream_name == NULL) ||
508             d->servicepath == NULL) {
509                 DEBUG(0, ("rename_share_filename: talloc failed\n"));
510                 return False;
511         }
512         d->modified = True;
513
514         sp_len = strlen(d->servicepath);
515         bn_len = strlen(d->base_name);
516         sn_len = has_stream ? strlen(d->stream_name) : 0;
517
518         msg_len = MSG_FILE_RENAMED_MIN_SIZE + sp_len + 1 + bn_len + 1 +
519             sn_len + 1;
520
521         /* Set up the name changed message. */
522         frm = talloc_array(d, char, msg_len);
523         if (!frm) {
524                 return False;
525         }
526
527         push_file_id_24(frm, &id);
528
529         DEBUG(10,("rename_share_filename: msg_len = %u\n", (unsigned int)msg_len ));
530
531         strlcpy(&frm[24],
532                 d->servicepath ? d->servicepath : "",
533                 sp_len+1);
534         strlcpy(&frm[24 + sp_len + 1],
535                 d->base_name ? d->base_name : "",
536                 bn_len+1);
537         strlcpy(&frm[24 + sp_len + 1 + bn_len + 1],
538                 d->stream_name ? d->stream_name : "",
539                 sn_len+1);
540
541         /* Send the messages. */
542         for (i=0; i<d->num_share_modes; i++) {
543                 struct share_mode_entry *se = &d->share_modes[i];
544                 struct server_id_buf tmp;
545
546                 if (!is_valid_share_mode_entry(se)) {
547                         continue;
548                 }
549
550                 /* If this is a hardlink to the inode
551                    with a different name, skip this. */
552                 if (se->name_hash != orig_name_hash) {
553                         continue;
554                 }
555
556                 se->name_hash = new_name_hash;
557
558                 /* But not to ourselves... */
559                 if (serverid_equal(&se->pid, &self_pid)) {
560                         continue;
561                 }
562
563                 if (share_mode_stale_pid(d, i)) {
564                         continue;
565                 }
566
567                 DEBUG(10,("rename_share_filename: sending rename message to "
568                           "pid %s file_id %s sharepath %s base_name %s "
569                           "stream_name %s\n",
570                           server_id_str_buf(se->pid, &tmp),
571                           file_id_string_tos(&id),
572                           d->servicepath, d->base_name,
573                         has_stream ? d->stream_name : ""));
574
575                 messaging_send_buf(msg_ctx, se->pid, MSG_SMB_FILE_RENAME,
576                                    (uint8_t *)frm, msg_len);
577         }
578
579         for (i=0; i<d->num_leases; i++) {
580                 /* Update the filename in leases_db. */
581                 NTSTATUS status;
582                 struct share_mode_lease *l;
583
584                 l = &d->leases[i];
585
586                 status = leases_db_rename(&l->client_guid,
587                                         &l->lease_key,
588                                         &id,
589                                         d->servicepath,
590                                         d->base_name,
591                                         d->stream_name);
592                 if (!NT_STATUS_IS_OK(status)) {
593                         /* Any error recovery possible here ? */
594                         DEBUG(1,("Failed to rename lease key for "
595                                 "renamed file %s:%s. %s\n",
596                                 d->base_name,
597                                 d->stream_name,
598                                 nt_errstr(status)));
599                         continue;
600                 }
601         }
602
603         return True;
604 }
605
606 void get_file_infos(struct file_id id,
607                     uint32_t name_hash,
608                     bool *delete_on_close,
609                     struct timespec *write_time)
610 {
611         struct share_mode_lock *lck;
612
613         if (delete_on_close) {
614                 *delete_on_close = false;
615         }
616
617         if (write_time) {
618                 ZERO_STRUCTP(write_time);
619         }
620
621         if (!(lck = fetch_share_mode_unlocked(talloc_tos(), id))) {
622                 return;
623         }
624
625         if (delete_on_close) {
626                 *delete_on_close = is_delete_on_close_set(lck, name_hash);
627         }
628
629         if (write_time) {
630                 *write_time = get_share_mode_write_time(lck);
631         }
632
633         TALLOC_FREE(lck);
634 }
635
636 bool is_valid_share_mode_entry(const struct share_mode_entry *e)
637 {
638         int num_props = 0;
639
640         if (e->stale) {
641                 return false;
642         }
643
644         num_props += ((e->op_type == NO_OPLOCK) ? 1 : 0);
645         num_props += (EXCLUSIVE_OPLOCK_TYPE(e->op_type) ? 1 : 0);
646         num_props += (LEVEL_II_OPLOCK_TYPE(e->op_type) ? 1 : 0);
647         num_props += (e->op_type == LEASE_OPLOCK);
648
649         if ((num_props > 1) && serverid_exists(&e->pid)) {
650                 smb_panic("Invalid share mode entry");
651         }
652         return (num_props != 0);
653 }
654
655 /*
656  * See if we need to remove a lease being referred to by a
657  * share mode that is being marked stale or deleted.
658  */
659
660 static void remove_share_mode_lease(struct share_mode_data *d,
661                                     struct share_mode_entry *e)
662 {
663         uint16_t op_type;
664         uint32_t lease_idx;
665         uint32_t i;
666
667         op_type = e->op_type;
668         e->op_type = NO_OPLOCK;
669
670         d->modified = true;
671
672         if (op_type != LEASE_OPLOCK) {
673                 return;
674         }
675
676         /*
677          * This used to reference a lease. If there's no other one referencing
678          * it, remove it.
679          */
680
681         lease_idx = e->lease_idx;
682         e->lease_idx = UINT32_MAX;
683
684         for (i=0; i<d->num_share_modes; i++) {
685                 struct share_mode_entry *e2 = &d->share_modes[i];
686
687                 if (e2->stale) {
688                         continue;
689                 }
690                 if (e == e2) {
691                         /* Not ourselves. */
692                         continue;
693                 }
694                 if (smb2_lease_equal(&e->client_guid,
695                                      &e->lease_key,
696                                      &e2->client_guid,
697                                      &e2->lease_key)) {
698                         break;
699                 }
700         }
701         if (i < d->num_share_modes) {
702                 /*
703                  * Found another one
704                  */
705                 return;
706         }
707
708         d->num_leases -= 1;
709         d->leases[lease_idx] = d->leases[d->num_leases];
710
711         /*
712          * We changed the lease array. Fix all references to it.
713          */
714         for (i=0; i<d->num_share_modes; i++) {
715                 if (d->share_modes[i].lease_idx == d->num_leases) {
716                         d->share_modes[i].lease_idx = lease_idx;
717                 }
718         }
719
720         {
721                 NTSTATUS status;
722
723                 status = leases_db_del(&e->client_guid,
724                                        &e->lease_key,
725                                        &d->id);
726
727                 DEBUG(10, ("%s: leases_db_del returned %s\n", __func__,
728                            nt_errstr(status)));
729         }
730 }
731
732 /*
733  * In case d->share_modes[i] conflicts with something or otherwise is
734  * being used, we need to make sure the corresponding process still
735  * exists.
736  */
737 bool share_mode_stale_pid(struct share_mode_data *d, uint32_t idx)
738 {
739         struct server_id_buf tmp;
740         struct share_mode_entry *e;
741
742         if (idx > d->num_share_modes) {
743                 DBG_WARNING("Asking for index %"PRIu32", "
744                             "only %"PRIu32" around\n",
745                             idx,
746                             d->num_share_modes);
747                 return false;
748         }
749         e = &d->share_modes[idx];
750         if (e->stale) {
751                 /*
752                  * Checked before
753                  */
754                 return true;
755         }
756         if (serverid_exists(&e->pid)) {
757                 DBG_DEBUG("PID %s (index %"PRIu32" out of %"PRIu32") "
758                           "still exists\n",
759                           server_id_str_buf(e->pid, &tmp),
760                           idx,
761                           d->num_share_modes);
762                 return false;
763         }
764         DBG_DEBUG("PID %s (index %"PRIu32" out of %"PRIu32") "
765                   "does not exist anymore\n",
766                   server_id_str_buf(e->pid, &tmp),
767                   idx,
768                   d->num_share_modes);
769
770         e->stale = true;
771
772         if (d->num_delete_tokens != 0) {
773                 uint32_t i;
774
775                 for (i=0; i<d->num_share_modes; i++) {
776                         bool valid = !d->share_modes[i].stale;
777                         if (valid) {
778                                 break;
779                         }
780                 }
781
782                 if (i == d->num_share_modes) {
783                         /*
784                          * No valid (non-stale) share mode found, all
785                          * who might have set the delete token are
786                          * gone.
787                          */
788                         TALLOC_FREE(d->delete_tokens);
789                         d->num_delete_tokens = 0;
790                 }
791         }
792
793         remove_share_mode_lease(d, e);
794
795         d->modified = true;
796         return true;
797 }
798
799 void remove_stale_share_mode_entries(struct share_mode_data *d)
800 {
801         uint32_t i;
802
803         i = 0;
804         while (i < d->num_share_modes) {
805                 if (d->share_modes[i].stale) {
806                         struct share_mode_entry *m = d->share_modes;
807                         m[i] = m[d->num_share_modes-1];
808                         d->num_share_modes -= 1;
809                         continue;
810                 }
811                 i += 1;
812         }
813 }
814
815 bool set_share_mode(struct share_mode_lock *lck, struct files_struct *fsp,
816                     uid_t uid, uint64_t mid, uint16_t op_type,
817                     uint32_t lease_idx)
818 {
819         struct share_mode_data *d = lck->data;
820         struct share_mode_entry *tmp, *e;
821
822         if ((lease_idx != UINT32_MAX) &&
823             (lease_idx >= d->num_leases)) {
824                 return false;
825         }
826
827         tmp = talloc_realloc(d, d->share_modes, struct share_mode_entry,
828                              d->num_share_modes+1);
829         if (tmp == NULL) {
830                 return false;
831         }
832         d->share_modes = tmp;
833         e = &d->share_modes[d->num_share_modes];
834         d->num_share_modes += 1;
835         d->modified = true;
836
837         ZERO_STRUCTP(e);
838         e->pid = messaging_server_id(fsp->conn->sconn->msg_ctx);
839         e->share_access = fsp->share_access;
840         e->private_options = fsp->fh->private_options;
841         e->access_mask = fsp->access_mask;
842         e->op_mid = mid;
843         e->op_type = op_type;
844         e->lease_idx = lease_idx;
845         if (lease_idx != UINT32_MAX) {
846                 e->client_guid = lck->data->leases[lease_idx].client_guid;
847                 e->lease_key = lck->data->leases[lease_idx].lease_key;
848         }
849         e->time.tv_sec = fsp->open_time.tv_sec;
850         e->time.tv_usec = fsp->open_time.tv_usec;
851         e->share_file_id = fsp->fh->gen_id;
852         e->uid = (uint32_t)uid;
853         e->flags = (fsp->posix_flags & FSP_POSIX_FLAGS_OPEN) ?
854                 SHARE_MODE_FLAG_POSIX_OPEN : 0;
855         e->name_hash = fsp->name_hash;
856
857         return true;
858 }
859
860 struct share_mode_entry *find_share_mode_entry(
861         struct share_mode_lock *lck, files_struct *fsp)
862 {
863         struct share_mode_data *d = lck->data;
864         struct server_id pid;
865         uint32_t i;
866
867         pid = messaging_server_id(fsp->conn->sconn->msg_ctx);
868
869         for (i=0; i<d->num_share_modes; i++) {
870                 struct share_mode_entry *e = &d->share_modes[i];
871
872                 if (!is_valid_share_mode_entry(e)) {
873                         continue;
874                 }
875                 if (!serverid_equal(&pid, &e->pid)) {
876                         continue;
877                 }
878                 if (fsp->fh->gen_id != e->share_file_id) {
879                         continue;
880                 }
881                 return e;
882         }
883         return NULL;
884 }
885
886 /*******************************************************************
887  Del the share mode of a file for this process.
888 ********************************************************************/
889
890 bool del_share_mode(struct share_mode_lock *lck, files_struct *fsp)
891 {
892         struct share_mode_entry *e;
893
894         e = find_share_mode_entry(lck, fsp);
895         if (e == NULL) {
896                 return False;
897         }
898         remove_share_mode_lease(lck->data, e);
899         *e = lck->data->share_modes[lck->data->num_share_modes-1];
900         lck->data->num_share_modes -= 1;
901         lck->data->modified = True;
902         return True;
903 }
904
905 bool mark_share_mode_disconnected(struct share_mode_lock *lck,
906                                   struct files_struct *fsp)
907 {
908         struct share_mode_entry *e;
909
910         if (lck->data->num_share_modes != 1) {
911                 return false;
912         }
913
914         if (fsp->op == NULL) {
915                 return false;
916         }
917         if (!fsp->op->global->durable) {
918                 return false;
919         }
920
921         e = find_share_mode_entry(lck, fsp);
922         if (e == NULL) {
923                 return false;
924         }
925
926         DEBUG(10, ("Marking share mode entry disconnected for durable handle\n"));
927
928         server_id_set_disconnected(&e->pid);
929
930         /*
931          * On reopen the caller needs to check that
932          * the client comes with the correct handle.
933          */
934         e->share_file_id = fsp->op->global->open_persistent_id;
935
936         lck->data->modified = true;
937         return true;
938 }
939
940 /*******************************************************************
941  Remove an oplock mid and mode entry from a share mode.
942 ********************************************************************/
943
944 bool remove_share_oplock(struct share_mode_lock *lck, files_struct *fsp)
945 {
946         struct share_mode_data *d = lck->data;
947         struct share_mode_entry *e;
948
949         e = find_share_mode_entry(lck, fsp);
950         if (e == NULL) {
951                 return False;
952         }
953
954         remove_share_mode_lease(d, e);
955         d->modified = True;
956         return true;
957 }
958
959 /*******************************************************************
960  Downgrade a oplock type from exclusive to level II.
961 ********************************************************************/
962
963 bool downgrade_share_oplock(struct share_mode_lock *lck, files_struct *fsp)
964 {
965         struct share_mode_entry *e;
966
967         e = find_share_mode_entry(lck, fsp);
968         if (e == NULL) {
969                 return False;
970         }
971
972         e->op_type = LEVEL_II_OPLOCK;
973         lck->data->modified = True;
974         return True;
975 }
976
977 /****************************************************************************
978  Adds a delete on close token.
979 ****************************************************************************/
980
981 static bool add_delete_on_close_token(struct share_mode_data *d,
982                         uint32_t name_hash,
983                         const struct security_token *nt_tok,
984                         const struct security_unix_token *tok)
985 {
986         struct delete_token *tmp, *dtl;
987
988         tmp = talloc_realloc(d, d->delete_tokens, struct delete_token,
989                              d->num_delete_tokens+1);
990         if (tmp == NULL) {
991                 return false;
992         }
993         d->delete_tokens = tmp;
994         dtl = &d->delete_tokens[d->num_delete_tokens];
995
996         dtl->name_hash = name_hash;
997         dtl->delete_nt_token = dup_nt_token(d->delete_tokens, nt_tok);
998         if (dtl->delete_nt_token == NULL) {
999                 return false;
1000         }
1001         dtl->delete_token = copy_unix_token(d->delete_tokens, tok);
1002         if (dtl->delete_token == NULL) {
1003                 return false;
1004         }
1005         d->num_delete_tokens += 1;
1006         d->modified = true;
1007         return true;
1008 }
1009
1010 void reset_delete_on_close_lck(files_struct *fsp,
1011                                struct share_mode_lock *lck)
1012 {
1013         struct share_mode_data *d = lck->data;
1014         uint32_t i;
1015
1016         for (i=0; i<d->num_delete_tokens; i++) {
1017                 struct delete_token *dt = &d->delete_tokens[i];
1018
1019                 if (dt->name_hash == fsp->name_hash) {
1020                         d->modified = true;
1021
1022                         /* Delete this entry. */
1023                         TALLOC_FREE(dt->delete_nt_token);
1024                         TALLOC_FREE(dt->delete_token);
1025                         *dt = d->delete_tokens[d->num_delete_tokens-1];
1026                         d->num_delete_tokens -= 1;
1027                 }
1028         }
1029 }
1030
1031 /****************************************************************************
1032  Sets the delete on close flag over all share modes on this file.
1033  Modify the share mode entry for all files open
1034  on this device and inode to tell other smbds we have
1035  changed the delete on close flag. This will be noticed
1036  in the close code, the last closer will delete the file
1037  if flag is set.
1038  This makes a copy of any struct security_unix_token into the
1039  lck entry. This function is used when the lock is already granted.
1040 ****************************************************************************/
1041
1042 void set_delete_on_close_lck(files_struct *fsp,
1043                         struct share_mode_lock *lck,
1044                         const struct security_token *nt_tok,
1045                         const struct security_unix_token *tok)
1046 {
1047         struct messaging_context *msg_ctx = fsp->conn->sconn->msg_ctx;
1048         struct share_mode_data *d = lck->data;
1049         uint32_t i;
1050         bool ret;
1051         DATA_BLOB fid_blob = {};
1052         enum ndr_err_code ndr_err;
1053
1054         SMB_ASSERT(nt_tok != NULL);
1055         SMB_ASSERT(tok != NULL);
1056
1057         for (i=0; i<d->num_delete_tokens; i++) {
1058                 struct delete_token *dt = &d->delete_tokens[i];
1059                 if (dt->name_hash == fsp->name_hash) {
1060                         d->modified = true;
1061
1062                         /* Replace this token with the given tok. */
1063                         TALLOC_FREE(dt->delete_nt_token);
1064                         dt->delete_nt_token = dup_nt_token(dt, nt_tok);
1065                         SMB_ASSERT(dt->delete_nt_token != NULL);
1066                         TALLOC_FREE(dt->delete_token);
1067                         dt->delete_token = copy_unix_token(dt, tok);
1068                         SMB_ASSERT(dt->delete_token != NULL);
1069
1070                         return;
1071                 }
1072         }
1073
1074         ret = add_delete_on_close_token(lck->data, fsp->name_hash, nt_tok, tok);
1075         SMB_ASSERT(ret);
1076
1077         ndr_err = ndr_push_struct_blob(&fid_blob, talloc_tos(), &fsp->file_id,
1078                                        (ndr_push_flags_fn_t)ndr_push_file_id);
1079         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1080                 DEBUG(10, ("ndr_push_file_id failed: %s\n",
1081                            ndr_errstr(ndr_err)));
1082         }
1083
1084         for (i=0; i<d->num_share_modes; i++) {
1085                 struct share_mode_entry *e = &d->share_modes[i];
1086                 NTSTATUS status;
1087
1088                 status = messaging_send(
1089                         msg_ctx, e->pid, MSG_SMB_NOTIFY_CANCEL_DELETED,
1090                         &fid_blob);
1091
1092                 if (!NT_STATUS_IS_OK(status)) {
1093                         struct server_id_buf tmp;
1094                         DEBUG(10, ("%s: messaging_send to %s returned %s\n",
1095                                    __func__, server_id_str_buf(e->pid, &tmp),
1096                                    nt_errstr(status)));
1097                 }
1098         }
1099
1100         TALLOC_FREE(fid_blob.data);
1101 }
1102
1103 bool set_delete_on_close(files_struct *fsp, bool delete_on_close,
1104                         const struct security_token *nt_tok,
1105                         const struct security_unix_token *tok)
1106 {
1107         struct share_mode_lock *lck;
1108
1109         DEBUG(10,("set_delete_on_close: %s delete on close flag for "
1110                   "%s, file %s\n",
1111                   delete_on_close ? "Adding" : "Removing", fsp_fnum_dbg(fsp),
1112                   fsp_str_dbg(fsp)));
1113
1114         lck = get_existing_share_mode_lock(talloc_tos(), fsp->file_id);
1115         if (lck == NULL) {
1116                 return False;
1117         }
1118
1119         if (delete_on_close) {
1120                 set_delete_on_close_lck(fsp, lck, nt_tok, tok);
1121         } else {
1122                 reset_delete_on_close_lck(fsp, lck);
1123         }
1124
1125         if (fsp->is_directory) {
1126                 SMB_ASSERT(!is_ntfs_stream_smb_fname(fsp->fsp_name));
1127                 send_stat_cache_delete_message(fsp->conn->sconn->msg_ctx,
1128                                                fsp->fsp_name->base_name);
1129         }
1130
1131         TALLOC_FREE(lck);
1132
1133         fsp->delete_on_close = delete_on_close;
1134
1135         return True;
1136 }
1137
1138 static struct delete_token *find_delete_on_close_token(
1139         struct share_mode_data *d, uint32_t name_hash)
1140 {
1141         uint32_t i;
1142
1143         DEBUG(10, ("find_delete_on_close_token: name_hash = 0x%x\n",
1144                    (unsigned int)name_hash));
1145
1146         for (i=0; i<d->num_delete_tokens; i++) {
1147                 struct delete_token *dt = &d->delete_tokens[i];
1148
1149                 DEBUG(10, ("find__delete_on_close_token: dt->name_hash = 0x%x\n",
1150                            (unsigned int)dt->name_hash ));
1151                 if (dt->name_hash == name_hash) {
1152                         return dt;
1153                 }
1154         }
1155         return NULL;
1156 }
1157
1158 /****************************************************************************
1159  Return the NT token and UNIX token if there's a match. Return true if
1160  found, false if not.
1161 ****************************************************************************/
1162
1163 bool get_delete_on_close_token(struct share_mode_lock *lck,
1164                                         uint32_t name_hash,
1165                                         const struct security_token **pp_nt_tok,
1166                                         const struct security_unix_token **pp_tok)
1167 {
1168         struct delete_token *dt;
1169
1170         dt = find_delete_on_close_token(lck->data, name_hash);
1171         if (dt == NULL) {
1172                 return false;
1173         }
1174         *pp_nt_tok = dt->delete_nt_token;
1175         *pp_tok =  dt->delete_token;
1176         return true;
1177 }
1178
1179 bool is_delete_on_close_set(struct share_mode_lock *lck, uint32_t name_hash)
1180 {
1181         return find_delete_on_close_token(lck->data, name_hash) != NULL;
1182 }
1183
1184 bool set_sticky_write_time(struct file_id fileid, struct timespec write_time)
1185 {
1186         struct share_mode_lock *lck;
1187
1188         DEBUG(5,("set_sticky_write_time: %s id=%s\n",
1189                  timestring(talloc_tos(),
1190                             convert_timespec_to_time_t(write_time)),
1191                  file_id_string_tos(&fileid)));
1192
1193         lck = get_existing_share_mode_lock(talloc_tos(), fileid);
1194         if (lck == NULL) {
1195                 return False;
1196         }
1197
1198         if (timespec_compare(&lck->data->changed_write_time, &write_time) != 0) {
1199                 lck->data->modified = True;
1200                 lck->data->changed_write_time = write_time;
1201         }
1202
1203         TALLOC_FREE(lck);
1204         return True;
1205 }
1206
1207 bool set_write_time(struct file_id fileid, struct timespec write_time)
1208 {
1209         struct share_mode_lock *lck;
1210
1211         DEBUG(5,("set_write_time: %s id=%s\n",
1212                  timestring(talloc_tos(),
1213                             convert_timespec_to_time_t(write_time)),
1214                  file_id_string_tos(&fileid)));
1215
1216         lck = get_existing_share_mode_lock(talloc_tos(), fileid);
1217         if (lck == NULL) {
1218                 return False;
1219         }
1220
1221         if (timespec_compare(&lck->data->old_write_time, &write_time) != 0) {
1222                 lck->data->modified = True;
1223                 lck->data->old_write_time = write_time;
1224         }
1225
1226         TALLOC_FREE(lck);
1227         return True;
1228 }
1229
1230 struct timespec get_share_mode_write_time(struct share_mode_lock *lck)
1231 {
1232         struct share_mode_data *d = lck->data;
1233
1234         if (!null_timespec(d->changed_write_time)) {
1235                 return d->changed_write_time;
1236         }
1237         return d->old_write_time;
1238 }
1239
1240 bool file_has_open_streams(files_struct *fsp)
1241 {
1242         struct share_mode_lock *lock = NULL;
1243         struct share_mode_data *d = NULL;
1244         uint32_t i;
1245
1246         lock = get_existing_share_mode_lock(talloc_tos(), fsp->file_id);
1247         if (lock == NULL) {
1248                 return false;
1249         }
1250         d = lock->data;
1251
1252         for (i = 0; i < d->num_share_modes; i++) {
1253                 struct share_mode_entry *e = &d->share_modes[i];
1254
1255                 if (share_mode_stale_pid(d, i)) {
1256                         continue;
1257                 }
1258
1259                 if (e->private_options &
1260                     NTCREATEX_OPTIONS_PRIVATE_STREAM_BASEOPEN)
1261                 {
1262                         TALLOC_FREE(lock);
1263                         return true;
1264                 }
1265         }
1266
1267         TALLOC_FREE(lock);
1268         return false;
1269 }