0e14a4ef0529b991950721f7fc9bb31560a8ca42
[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         struct GUID client_guid;
664         struct smb2_lease_key lease_key;
665         uint16_t op_type;
666         uint32_t lease_idx;
667         uint32_t i;
668
669         op_type = e->op_type;
670         e->op_type = NO_OPLOCK;
671
672         d->modified = true;
673
674         if (op_type != LEASE_OPLOCK) {
675                 return;
676         }
677
678         /*
679          * This used to reference a lease. If there's no other one referencing
680          * it, remove it.
681          */
682
683         lease_idx = e->lease_idx;
684         e->lease_idx = UINT32_MAX;
685
686         for (i=0; i<d->num_share_modes; i++) {
687                 struct share_mode_entry *e2 = &d->share_modes[i];
688
689                 if (e2->stale) {
690                         continue;
691                 }
692                 if (e == e2) {
693                         /* Not ourselves. */
694                         continue;
695                 }
696                 if (smb2_lease_equal(&e->client_guid,
697                                      &e->lease_key,
698                                      &e2->client_guid,
699                                      &e2->lease_key)) {
700                         break;
701                 }
702         }
703         if (i < d->num_share_modes) {
704                 /*
705                  * Found another one
706                  */
707                 return;
708         }
709
710         memcpy(&client_guid,
711                 &d->leases[lease_idx].client_guid,
712                 sizeof(client_guid));
713         lease_key = d->leases[lease_idx].lease_key;
714
715         d->num_leases -= 1;
716         d->leases[lease_idx] = d->leases[d->num_leases];
717
718         /*
719          * We changed the lease array. Fix all references to it.
720          */
721         for (i=0; i<d->num_share_modes; i++) {
722                 if (d->share_modes[i].lease_idx == d->num_leases) {
723                         d->share_modes[i].lease_idx = lease_idx;
724                 }
725         }
726
727         {
728                 NTSTATUS status;
729
730                 status = leases_db_del(&client_guid,
731                                         &lease_key,
732                                         &d->id);
733
734                 DEBUG(10, ("%s: leases_db_del returned %s\n", __func__,
735                            nt_errstr(status)));
736         }
737 }
738
739 /*
740  * In case d->share_modes[i] conflicts with something or otherwise is
741  * being used, we need to make sure the corresponding process still
742  * exists.
743  */
744 bool share_mode_stale_pid(struct share_mode_data *d, uint32_t idx)
745 {
746         struct server_id_buf tmp;
747         struct share_mode_entry *e;
748
749         if (idx > d->num_share_modes) {
750                 DBG_WARNING("Asking for index %"PRIu32", "
751                             "only %"PRIu32" around\n",
752                             idx,
753                             d->num_share_modes);
754                 return false;
755         }
756         e = &d->share_modes[idx];
757         if (e->stale) {
758                 /*
759                  * Checked before
760                  */
761                 return true;
762         }
763         if (serverid_exists(&e->pid)) {
764                 DBG_DEBUG("PID %s (index %"PRIu32" out of %"PRIu32") "
765                           "still exists\n",
766                           server_id_str_buf(e->pid, &tmp),
767                           idx,
768                           d->num_share_modes);
769                 return false;
770         }
771         DBG_DEBUG("PID %s (index %"PRIu32" out of %"PRIu32") "
772                   "does not exist anymore\n",
773                   server_id_str_buf(e->pid, &tmp),
774                   idx,
775                   d->num_share_modes);
776
777         e->stale = true;
778
779         if (d->num_delete_tokens != 0) {
780                 uint32_t i;
781
782                 for (i=0; i<d->num_share_modes; i++) {
783                         bool valid = !d->share_modes[i].stale;
784                         if (valid) {
785                                 break;
786                         }
787                 }
788
789                 if (i == d->num_share_modes) {
790                         /*
791                          * No valid (non-stale) share mode found, all
792                          * who might have set the delete token are
793                          * gone.
794                          */
795                         TALLOC_FREE(d->delete_tokens);
796                         d->num_delete_tokens = 0;
797                 }
798         }
799
800         remove_share_mode_lease(d, e);
801
802         d->modified = true;
803         return true;
804 }
805
806 void remove_stale_share_mode_entries(struct share_mode_data *d)
807 {
808         uint32_t i;
809
810         i = 0;
811         while (i < d->num_share_modes) {
812                 if (d->share_modes[i].stale) {
813                         struct share_mode_entry *m = d->share_modes;
814                         m[i] = m[d->num_share_modes-1];
815                         d->num_share_modes -= 1;
816                         continue;
817                 }
818                 i += 1;
819         }
820 }
821
822 bool set_share_mode(struct share_mode_lock *lck, struct files_struct *fsp,
823                     uid_t uid, uint64_t mid, uint16_t op_type,
824                     uint32_t lease_idx)
825 {
826         struct share_mode_data *d = lck->data;
827         struct share_mode_entry *tmp, *e;
828
829         if ((lease_idx != UINT32_MAX) &&
830             (lease_idx >= d->num_leases)) {
831                 return false;
832         }
833
834         tmp = talloc_realloc(d, d->share_modes, struct share_mode_entry,
835                              d->num_share_modes+1);
836         if (tmp == NULL) {
837                 return false;
838         }
839         d->share_modes = tmp;
840         e = &d->share_modes[d->num_share_modes];
841         d->num_share_modes += 1;
842         d->modified = true;
843
844         ZERO_STRUCTP(e);
845         e->pid = messaging_server_id(fsp->conn->sconn->msg_ctx);
846         e->share_access = fsp->share_access;
847         e->private_options = fsp->fh->private_options;
848         e->access_mask = fsp->access_mask;
849         e->op_mid = mid;
850         e->op_type = op_type;
851         e->lease_idx = lease_idx;
852         if (lease_idx != UINT32_MAX) {
853                 e->client_guid = lck->data->leases[lease_idx].client_guid;
854                 e->lease_key = lck->data->leases[lease_idx].lease_key;
855         }
856         e->time.tv_sec = fsp->open_time.tv_sec;
857         e->time.tv_usec = fsp->open_time.tv_usec;
858         e->share_file_id = fsp->fh->gen_id;
859         e->uid = (uint32_t)uid;
860         e->flags = (fsp->posix_flags & FSP_POSIX_FLAGS_OPEN) ?
861                 SHARE_MODE_FLAG_POSIX_OPEN : 0;
862         e->name_hash = fsp->name_hash;
863
864         return true;
865 }
866
867 struct share_mode_entry *find_share_mode_entry(
868         struct share_mode_lock *lck, files_struct *fsp)
869 {
870         struct share_mode_data *d = lck->data;
871         struct server_id pid;
872         uint32_t i;
873
874         pid = messaging_server_id(fsp->conn->sconn->msg_ctx);
875
876         for (i=0; i<d->num_share_modes; i++) {
877                 struct share_mode_entry *e = &d->share_modes[i];
878
879                 if (!is_valid_share_mode_entry(e)) {
880                         continue;
881                 }
882                 if (!serverid_equal(&pid, &e->pid)) {
883                         continue;
884                 }
885                 if (fsp->fh->gen_id != e->share_file_id) {
886                         continue;
887                 }
888                 return e;
889         }
890         return NULL;
891 }
892
893 /*******************************************************************
894  Del the share mode of a file for this process.
895 ********************************************************************/
896
897 bool del_share_mode(struct share_mode_lock *lck, files_struct *fsp)
898 {
899         struct share_mode_entry *e;
900
901         e = find_share_mode_entry(lck, fsp);
902         if (e == NULL) {
903                 return False;
904         }
905         remove_share_mode_lease(lck->data, e);
906         *e = lck->data->share_modes[lck->data->num_share_modes-1];
907         lck->data->num_share_modes -= 1;
908         lck->data->modified = True;
909         return True;
910 }
911
912 bool mark_share_mode_disconnected(struct share_mode_lock *lck,
913                                   struct files_struct *fsp)
914 {
915         struct share_mode_entry *e;
916
917         if (lck->data->num_share_modes != 1) {
918                 return false;
919         }
920
921         if (fsp->op == NULL) {
922                 return false;
923         }
924         if (!fsp->op->global->durable) {
925                 return false;
926         }
927
928         e = find_share_mode_entry(lck, fsp);
929         if (e == NULL) {
930                 return false;
931         }
932
933         DEBUG(10, ("Marking share mode entry disconnected for durable handle\n"));
934
935         server_id_set_disconnected(&e->pid);
936
937         /*
938          * On reopen the caller needs to check that
939          * the client comes with the correct handle.
940          */
941         e->share_file_id = fsp->op->global->open_persistent_id;
942
943         lck->data->modified = true;
944         return true;
945 }
946
947 /*******************************************************************
948  Remove an oplock mid and mode entry from a share mode.
949 ********************************************************************/
950
951 bool remove_share_oplock(struct share_mode_lock *lck, files_struct *fsp)
952 {
953         struct share_mode_data *d = lck->data;
954         struct share_mode_entry *e;
955
956         e = find_share_mode_entry(lck, fsp);
957         if (e == NULL) {
958                 return False;
959         }
960
961         remove_share_mode_lease(d, e);
962         d->modified = True;
963         return true;
964 }
965
966 /*******************************************************************
967  Downgrade a oplock type from exclusive to level II.
968 ********************************************************************/
969
970 bool downgrade_share_oplock(struct share_mode_lock *lck, files_struct *fsp)
971 {
972         struct share_mode_entry *e;
973
974         e = find_share_mode_entry(lck, fsp);
975         if (e == NULL) {
976                 return False;
977         }
978
979         e->op_type = LEVEL_II_OPLOCK;
980         lck->data->modified = True;
981         return True;
982 }
983
984 /****************************************************************************
985  Adds a delete on close token.
986 ****************************************************************************/
987
988 static bool add_delete_on_close_token(struct share_mode_data *d,
989                         uint32_t name_hash,
990                         const struct security_token *nt_tok,
991                         const struct security_unix_token *tok)
992 {
993         struct delete_token *tmp, *dtl;
994
995         tmp = talloc_realloc(d, d->delete_tokens, struct delete_token,
996                              d->num_delete_tokens+1);
997         if (tmp == NULL) {
998                 return false;
999         }
1000         d->delete_tokens = tmp;
1001         dtl = &d->delete_tokens[d->num_delete_tokens];
1002
1003         dtl->name_hash = name_hash;
1004         dtl->delete_nt_token = dup_nt_token(d->delete_tokens, nt_tok);
1005         if (dtl->delete_nt_token == NULL) {
1006                 return false;
1007         }
1008         dtl->delete_token = copy_unix_token(d->delete_tokens, tok);
1009         if (dtl->delete_token == NULL) {
1010                 return false;
1011         }
1012         d->num_delete_tokens += 1;
1013         d->modified = true;
1014         return true;
1015 }
1016
1017 void reset_delete_on_close_lck(files_struct *fsp,
1018                                struct share_mode_lock *lck)
1019 {
1020         struct share_mode_data *d = lck->data;
1021         uint32_t i;
1022
1023         for (i=0; i<d->num_delete_tokens; i++) {
1024                 struct delete_token *dt = &d->delete_tokens[i];
1025
1026                 if (dt->name_hash == fsp->name_hash) {
1027                         d->modified = true;
1028
1029                         /* Delete this entry. */
1030                         TALLOC_FREE(dt->delete_nt_token);
1031                         TALLOC_FREE(dt->delete_token);
1032                         *dt = d->delete_tokens[d->num_delete_tokens-1];
1033                         d->num_delete_tokens -= 1;
1034                 }
1035         }
1036 }
1037
1038 /****************************************************************************
1039  Sets the delete on close flag over all share modes on this file.
1040  Modify the share mode entry for all files open
1041  on this device and inode to tell other smbds we have
1042  changed the delete on close flag. This will be noticed
1043  in the close code, the last closer will delete the file
1044  if flag is set.
1045  This makes a copy of any struct security_unix_token into the
1046  lck entry. This function is used when the lock is already granted.
1047 ****************************************************************************/
1048
1049 void set_delete_on_close_lck(files_struct *fsp,
1050                         struct share_mode_lock *lck,
1051                         const struct security_token *nt_tok,
1052                         const struct security_unix_token *tok)
1053 {
1054         struct messaging_context *msg_ctx = fsp->conn->sconn->msg_ctx;
1055         struct share_mode_data *d = lck->data;
1056         uint32_t i;
1057         bool ret;
1058         DATA_BLOB fid_blob = {};
1059         enum ndr_err_code ndr_err;
1060
1061         SMB_ASSERT(nt_tok != NULL);
1062         SMB_ASSERT(tok != NULL);
1063
1064         for (i=0; i<d->num_delete_tokens; i++) {
1065                 struct delete_token *dt = &d->delete_tokens[i];
1066                 if (dt->name_hash == fsp->name_hash) {
1067                         d->modified = true;
1068
1069                         /* Replace this token with the given tok. */
1070                         TALLOC_FREE(dt->delete_nt_token);
1071                         dt->delete_nt_token = dup_nt_token(dt, nt_tok);
1072                         SMB_ASSERT(dt->delete_nt_token != NULL);
1073                         TALLOC_FREE(dt->delete_token);
1074                         dt->delete_token = copy_unix_token(dt, tok);
1075                         SMB_ASSERT(dt->delete_token != NULL);
1076
1077                         return;
1078                 }
1079         }
1080
1081         ret = add_delete_on_close_token(lck->data, fsp->name_hash, nt_tok, tok);
1082         SMB_ASSERT(ret);
1083
1084         ndr_err = ndr_push_struct_blob(&fid_blob, talloc_tos(), &fsp->file_id,
1085                                        (ndr_push_flags_fn_t)ndr_push_file_id);
1086         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1087                 DEBUG(10, ("ndr_push_file_id failed: %s\n",
1088                            ndr_errstr(ndr_err)));
1089         }
1090
1091         for (i=0; i<d->num_share_modes; i++) {
1092                 struct share_mode_entry *e = &d->share_modes[i];
1093                 NTSTATUS status;
1094
1095                 status = messaging_send(
1096                         msg_ctx, e->pid, MSG_SMB_NOTIFY_CANCEL_DELETED,
1097                         &fid_blob);
1098
1099                 if (!NT_STATUS_IS_OK(status)) {
1100                         struct server_id_buf tmp;
1101                         DEBUG(10, ("%s: messaging_send to %s returned %s\n",
1102                                    __func__, server_id_str_buf(e->pid, &tmp),
1103                                    nt_errstr(status)));
1104                 }
1105         }
1106
1107         TALLOC_FREE(fid_blob.data);
1108 }
1109
1110 bool set_delete_on_close(files_struct *fsp, bool delete_on_close,
1111                         const struct security_token *nt_tok,
1112                         const struct security_unix_token *tok)
1113 {
1114         struct share_mode_lock *lck;
1115
1116         DEBUG(10,("set_delete_on_close: %s delete on close flag for "
1117                   "%s, file %s\n",
1118                   delete_on_close ? "Adding" : "Removing", fsp_fnum_dbg(fsp),
1119                   fsp_str_dbg(fsp)));
1120
1121         lck = get_existing_share_mode_lock(talloc_tos(), fsp->file_id);
1122         if (lck == NULL) {
1123                 return False;
1124         }
1125
1126         if (delete_on_close) {
1127                 set_delete_on_close_lck(fsp, lck, nt_tok, tok);
1128         } else {
1129                 reset_delete_on_close_lck(fsp, lck);
1130         }
1131
1132         if (fsp->is_directory) {
1133                 SMB_ASSERT(!is_ntfs_stream_smb_fname(fsp->fsp_name));
1134                 send_stat_cache_delete_message(fsp->conn->sconn->msg_ctx,
1135                                                fsp->fsp_name->base_name);
1136         }
1137
1138         TALLOC_FREE(lck);
1139
1140         fsp->delete_on_close = delete_on_close;
1141
1142         return True;
1143 }
1144
1145 static struct delete_token *find_delete_on_close_token(
1146         struct share_mode_data *d, uint32_t name_hash)
1147 {
1148         uint32_t i;
1149
1150         DEBUG(10, ("find_delete_on_close_token: name_hash = 0x%x\n",
1151                    (unsigned int)name_hash));
1152
1153         for (i=0; i<d->num_delete_tokens; i++) {
1154                 struct delete_token *dt = &d->delete_tokens[i];
1155
1156                 DEBUG(10, ("find__delete_on_close_token: dt->name_hash = 0x%x\n",
1157                            (unsigned int)dt->name_hash ));
1158                 if (dt->name_hash == name_hash) {
1159                         return dt;
1160                 }
1161         }
1162         return NULL;
1163 }
1164
1165 /****************************************************************************
1166  Return the NT token and UNIX token if there's a match. Return true if
1167  found, false if not.
1168 ****************************************************************************/
1169
1170 bool get_delete_on_close_token(struct share_mode_lock *lck,
1171                                         uint32_t name_hash,
1172                                         const struct security_token **pp_nt_tok,
1173                                         const struct security_unix_token **pp_tok)
1174 {
1175         struct delete_token *dt;
1176
1177         dt = find_delete_on_close_token(lck->data, name_hash);
1178         if (dt == NULL) {
1179                 return false;
1180         }
1181         *pp_nt_tok = dt->delete_nt_token;
1182         *pp_tok =  dt->delete_token;
1183         return true;
1184 }
1185
1186 bool is_delete_on_close_set(struct share_mode_lock *lck, uint32_t name_hash)
1187 {
1188         return find_delete_on_close_token(lck->data, name_hash) != NULL;
1189 }
1190
1191 bool set_sticky_write_time(struct file_id fileid, struct timespec write_time)
1192 {
1193         struct share_mode_lock *lck;
1194
1195         DEBUG(5,("set_sticky_write_time: %s id=%s\n",
1196                  timestring(talloc_tos(),
1197                             convert_timespec_to_time_t(write_time)),
1198                  file_id_string_tos(&fileid)));
1199
1200         lck = get_existing_share_mode_lock(talloc_tos(), fileid);
1201         if (lck == NULL) {
1202                 return False;
1203         }
1204
1205         if (timespec_compare(&lck->data->changed_write_time, &write_time) != 0) {
1206                 lck->data->modified = True;
1207                 lck->data->changed_write_time = write_time;
1208         }
1209
1210         TALLOC_FREE(lck);
1211         return True;
1212 }
1213
1214 bool set_write_time(struct file_id fileid, struct timespec write_time)
1215 {
1216         struct share_mode_lock *lck;
1217
1218         DEBUG(5,("set_write_time: %s id=%s\n",
1219                  timestring(talloc_tos(),
1220                             convert_timespec_to_time_t(write_time)),
1221                  file_id_string_tos(&fileid)));
1222
1223         lck = get_existing_share_mode_lock(talloc_tos(), fileid);
1224         if (lck == NULL) {
1225                 return False;
1226         }
1227
1228         if (timespec_compare(&lck->data->old_write_time, &write_time) != 0) {
1229                 lck->data->modified = True;
1230                 lck->data->old_write_time = write_time;
1231         }
1232
1233         TALLOC_FREE(lck);
1234         return True;
1235 }
1236
1237 struct timespec get_share_mode_write_time(struct share_mode_lock *lck)
1238 {
1239         struct share_mode_data *d = lck->data;
1240
1241         if (!null_timespec(d->changed_write_time)) {
1242                 return d->changed_write_time;
1243         }
1244         return d->old_write_time;
1245 }
1246
1247 bool file_has_open_streams(files_struct *fsp)
1248 {
1249         struct share_mode_lock *lock = NULL;
1250         struct share_mode_data *d = NULL;
1251         uint32_t i;
1252
1253         lock = get_existing_share_mode_lock(talloc_tos(), fsp->file_id);
1254         if (lock == NULL) {
1255                 return false;
1256         }
1257         d = lock->data;
1258
1259         for (i = 0; i < d->num_share_modes; i++) {
1260                 struct share_mode_entry *e = &d->share_modes[i];
1261
1262                 if (share_mode_stale_pid(d, i)) {
1263                         continue;
1264                 }
1265
1266                 if (e->private_options &
1267                     NTCREATEX_OPTIONS_PRIVATE_STREAM_BASEOPEN)
1268                 {
1269                         TALLOC_FREE(lock);
1270                         return true;
1271                 }
1272         }
1273
1274         TALLOC_FREE(lock);
1275         return false;
1276 }