Raise the debug level from 1 to 5 in get_share_mode_lock_internal()
[kai/samba.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 "locking/proto.h"
41 #include "smbd/globals.h"
42 #include "dbwrap/dbwrap.h"
43 #include "dbwrap/dbwrap_open.h"
44 #include "../libcli/security/security.h"
45 #include "serverid.h"
46 #include "messages.h"
47 #include "util_tdb.h"
48 #include "../librpc/gen_ndr/ndr_open_files.h"
49
50 #undef DBGC_CLASS
51 #define DBGC_CLASS DBGC_LOCKING
52
53 #define NO_LOCKING_COUNT (-1)
54
55 /****************************************************************************
56  Debugging aids :-).
57 ****************************************************************************/
58
59 const char *lock_type_name(enum brl_type lock_type)
60 {
61         switch (lock_type) {
62                 case READ_LOCK:
63                         return "READ";
64                 case WRITE_LOCK:
65                         return "WRITE";
66                 case PENDING_READ_LOCK:
67                         return "PENDING_READ";
68                 case PENDING_WRITE_LOCK:
69                         return "PENDING_WRITE";
70                 default:
71                         return "other";
72         }
73 }
74
75 const char *lock_flav_name(enum brl_flavour lock_flav)
76 {
77         return (lock_flav == WINDOWS_LOCK) ? "WINDOWS_LOCK" : "POSIX_LOCK";
78 }
79
80 /****************************************************************************
81  Utility function called to see if a file region is locked.
82  Called in the read/write codepath.
83 ****************************************************************************/
84
85 void init_strict_lock_struct(files_struct *fsp,
86                                 uint64_t smblctx,
87                                 br_off start,
88                                 br_off size,
89                                 enum brl_type lock_type,
90                                 struct lock_struct *plock)
91 {
92         SMB_ASSERT(lock_type == READ_LOCK || lock_type == WRITE_LOCK);
93
94         plock->context.smblctx = smblctx;
95         plock->context.tid = fsp->conn->cnum;
96         plock->context.pid = messaging_server_id(fsp->conn->sconn->msg_ctx);
97         plock->start = start;
98         plock->size = size;
99         plock->fnum = fsp->fnum;
100         plock->lock_type = lock_type;
101         plock->lock_flav = lp_posix_cifsu_locktype(fsp);
102 }
103
104 bool strict_lock_default(files_struct *fsp, struct lock_struct *plock)
105 {
106         int strict_locking = lp_strict_locking(fsp->conn->params);
107         bool ret = False;
108
109         if (plock->size == 0) {
110                 return True;
111         }
112
113         if (!lp_locking(fsp->conn->params) || !strict_locking) {
114                 return True;
115         }
116
117         if (strict_locking == Auto) {
118                 if  (EXCLUSIVE_OPLOCK_TYPE(fsp->oplock_type) && (plock->lock_type == READ_LOCK || plock->lock_type == WRITE_LOCK)) {
119                         DEBUG(10,("is_locked: optimisation - exclusive oplock on file %s\n", fsp_str_dbg(fsp)));
120                         ret = True;
121                 } else if ((fsp->oplock_type == LEVEL_II_OPLOCK) &&
122                            (plock->lock_type == READ_LOCK)) {
123                         DEBUG(10,("is_locked: optimisation - level II oplock on file %s\n", fsp_str_dbg(fsp)));
124                         ret = True;
125                 } else {
126                         struct byte_range_lock *br_lck;
127
128                         br_lck = brl_get_locks_readonly(fsp);
129                         if (!br_lck) {
130                                 return True;
131                         }
132                         ret = brl_locktest(br_lck,
133                                         plock->context.smblctx,
134                                         plock->context.pid,
135                                         plock->start,
136                                         plock->size,
137                                         plock->lock_type,
138                                         plock->lock_flav);
139                 }
140         } else {
141                 struct byte_range_lock *br_lck;
142
143                 br_lck = brl_get_locks_readonly(fsp);
144                 if (!br_lck) {
145                         return True;
146                 }
147                 ret = brl_locktest(br_lck,
148                                 plock->context.smblctx,
149                                 plock->context.pid,
150                                 plock->start,
151                                 plock->size,
152                                 plock->lock_type,
153                                 plock->lock_flav);
154         }
155
156         DEBUG(10,("strict_lock_default: flavour = %s brl start=%.0f "
157                         "len=%.0f %s for fnum %d file %s\n",
158                         lock_flav_name(plock->lock_flav),
159                         (double)plock->start, (double)plock->size,
160                         ret ? "unlocked" : "locked",
161                         plock->fnum, fsp_str_dbg(fsp)));
162
163         return ret;
164 }
165
166 void strict_unlock_default(files_struct *fsp, struct lock_struct *plock)
167 {
168 }
169
170 /****************************************************************************
171  Find out if a lock could be granted - return who is blocking us if we can't.
172 ****************************************************************************/
173
174 NTSTATUS query_lock(files_struct *fsp,
175                         uint64_t *psmblctx,
176                         uint64_t *pcount,
177                         uint64_t *poffset,
178                         enum brl_type *plock_type,
179                         enum brl_flavour lock_flav)
180 {
181         struct byte_range_lock *br_lck = NULL;
182
183         if (!fsp->can_lock) {
184                 return fsp->is_directory ? NT_STATUS_INVALID_DEVICE_REQUEST : NT_STATUS_INVALID_HANDLE;
185         }
186
187         if (!lp_locking(fsp->conn->params)) {
188                 return NT_STATUS_OK;
189         }
190
191         br_lck = brl_get_locks_readonly(fsp);
192         if (!br_lck) {
193                 return NT_STATUS_NO_MEMORY;
194         }
195
196         return brl_lockquery(br_lck,
197                         psmblctx,
198                         messaging_server_id(fsp->conn->sconn->msg_ctx),
199                         poffset,
200                         pcount,
201                         plock_type,
202                         lock_flav);
203 }
204
205 static void increment_current_lock_count(files_struct *fsp,
206     enum brl_flavour lock_flav)
207 {
208         if (lock_flav == WINDOWS_LOCK &&
209             fsp->current_lock_count != NO_LOCKING_COUNT) {
210                 /* blocking ie. pending, locks also count here,
211                  * as this is an efficiency counter to avoid checking
212                  * the lock db. on close. JRA. */
213
214                 fsp->current_lock_count++;
215         } else {
216                 /* Notice that this has had a POSIX lock request.
217                  * We can't count locks after this so forget them.
218                  */
219                 fsp->current_lock_count = NO_LOCKING_COUNT;
220         }
221 }
222
223 static void decrement_current_lock_count(files_struct *fsp,
224     enum brl_flavour lock_flav)
225 {
226         if (lock_flav == WINDOWS_LOCK &&
227             fsp->current_lock_count != NO_LOCKING_COUNT) {
228                 SMB_ASSERT(fsp->current_lock_count > 0);
229                 fsp->current_lock_count--;
230         }
231 }
232
233 /****************************************************************************
234  Utility function called by locking requests.
235 ****************************************************************************/
236
237 struct byte_range_lock *do_lock(struct messaging_context *msg_ctx,
238                         files_struct *fsp,
239                         uint64_t smblctx,
240                         uint64_t count,
241                         uint64_t offset,
242                         enum brl_type lock_type,
243                         enum brl_flavour lock_flav,
244                         bool blocking_lock,
245                         NTSTATUS *perr,
246                         uint64_t *psmblctx,
247                         struct blocking_lock_record *blr)
248 {
249         struct byte_range_lock *br_lck = NULL;
250
251         /* silently return ok on print files as we don't do locking there */
252         if (fsp->print_file) {
253                 *perr = NT_STATUS_OK;
254                 return NULL;
255         }
256
257         if (!fsp->can_lock) {
258                 *perr = fsp->is_directory ? NT_STATUS_INVALID_DEVICE_REQUEST : NT_STATUS_INVALID_HANDLE;
259                 return NULL;
260         }
261
262         if (!lp_locking(fsp->conn->params)) {
263                 *perr = NT_STATUS_OK;
264                 return NULL;
265         }
266
267         /* NOTE! 0 byte long ranges ARE allowed and should be stored  */
268
269         DEBUG(10,("do_lock: lock flavour %s lock type %s start=%.0f len=%.0f "
270                 "blocking_lock=%s requested for fnum %d file %s\n",
271                 lock_flav_name(lock_flav), lock_type_name(lock_type),
272                 (double)offset, (double)count, blocking_lock ? "true" :
273                 "false", fsp->fnum, fsp_str_dbg(fsp)));
274
275         br_lck = brl_get_locks(talloc_tos(), fsp);
276         if (!br_lck) {
277                 *perr = NT_STATUS_NO_MEMORY;
278                 return NULL;
279         }
280
281         *perr = brl_lock(msg_ctx,
282                         br_lck,
283                         smblctx,
284                         messaging_server_id(fsp->conn->sconn->msg_ctx),
285                         offset,
286                         count,
287                         lock_type,
288                         lock_flav,
289                         blocking_lock,
290                         psmblctx,
291                         blr);
292
293         DEBUG(10, ("do_lock: returning status=%s\n", nt_errstr(*perr)));
294
295         increment_current_lock_count(fsp, lock_flav);
296         return br_lck;
297 }
298
299 /****************************************************************************
300  Utility function called by unlocking requests.
301 ****************************************************************************/
302
303 NTSTATUS do_unlock(struct messaging_context *msg_ctx,
304                         files_struct *fsp,
305                         uint64_t smblctx,
306                         uint64_t count,
307                         uint64_t offset,
308                         enum brl_flavour lock_flav)
309 {
310         bool ok = False;
311         struct byte_range_lock *br_lck = NULL;
312
313         if (!fsp->can_lock) {
314                 return fsp->is_directory ? NT_STATUS_INVALID_DEVICE_REQUEST : NT_STATUS_INVALID_HANDLE;
315         }
316
317         if (!lp_locking(fsp->conn->params)) {
318                 return NT_STATUS_OK;
319         }
320
321         DEBUG(10,("do_unlock: unlock start=%.0f len=%.0f requested for fnum %d file %s\n",
322                   (double)offset, (double)count, fsp->fnum,
323                   fsp_str_dbg(fsp)));
324
325         br_lck = brl_get_locks(talloc_tos(), fsp);
326         if (!br_lck) {
327                 return NT_STATUS_NO_MEMORY;
328         }
329
330         ok = brl_unlock(msg_ctx,
331                         br_lck,
332                         smblctx,
333                         messaging_server_id(fsp->conn->sconn->msg_ctx),
334                         offset,
335                         count,
336                         lock_flav);
337
338         TALLOC_FREE(br_lck);
339
340         if (!ok) {
341                 DEBUG(10,("do_unlock: returning ERRlock.\n" ));
342                 return NT_STATUS_RANGE_NOT_LOCKED;
343         }
344
345         decrement_current_lock_count(fsp, lock_flav);
346         return NT_STATUS_OK;
347 }
348
349 /****************************************************************************
350  Cancel any pending blocked locks.
351 ****************************************************************************/
352
353 NTSTATUS do_lock_cancel(files_struct *fsp,
354                         uint64 smblctx,
355                         uint64_t count,
356                         uint64_t offset,
357                         enum brl_flavour lock_flav,
358                         struct blocking_lock_record *blr)
359 {
360         bool ok = False;
361         struct byte_range_lock *br_lck = NULL;
362
363         if (!fsp->can_lock) {
364                 return fsp->is_directory ?
365                         NT_STATUS_INVALID_DEVICE_REQUEST : NT_STATUS_INVALID_HANDLE;
366         }
367
368         if (!lp_locking(fsp->conn->params)) {
369                 return NT_STATUS_DOS(ERRDOS, ERRcancelviolation);
370         }
371
372         DEBUG(10,("do_lock_cancel: cancel start=%.0f len=%.0f requested for fnum %d file %s\n",
373                   (double)offset, (double)count, fsp->fnum,
374                   fsp_str_dbg(fsp)));
375
376         br_lck = brl_get_locks(talloc_tos(), fsp);
377         if (!br_lck) {
378                 return NT_STATUS_NO_MEMORY;
379         }
380
381         ok = brl_lock_cancel(br_lck,
382                         smblctx,
383                         messaging_server_id(fsp->conn->sconn->msg_ctx),
384                         offset,
385                         count,
386                         lock_flav,
387                         blr);
388
389         TALLOC_FREE(br_lck);
390
391         if (!ok) {
392                 DEBUG(10,("do_lock_cancel: returning ERRcancelviolation.\n" ));
393                 return NT_STATUS_DOS(ERRDOS, ERRcancelviolation);
394         }
395
396         decrement_current_lock_count(fsp, lock_flav);
397         return NT_STATUS_OK;
398 }
399
400 /****************************************************************************
401  Remove any locks on this fd. Called from file_close().
402 ****************************************************************************/
403
404 void locking_close_file(struct messaging_context *msg_ctx,
405                         files_struct *fsp,
406                         enum file_close_type close_type)
407 {
408         struct byte_range_lock *br_lck;
409
410         if (!lp_locking(fsp->conn->params)) {
411                 return;
412         }
413
414         /* If we have not outstanding locks or pending
415          * locks then we don't need to look in the lock db.
416          */
417
418         if (fsp->current_lock_count == 0) {
419                 return;
420         }
421
422         br_lck = brl_get_locks(talloc_tos(),fsp);
423
424         if (br_lck) {
425                 cancel_pending_lock_requests_by_fid(fsp, br_lck, close_type);
426                 brl_close_fnum(msg_ctx, br_lck);
427                 TALLOC_FREE(br_lck);
428         }
429 }
430
431 /*******************************************************************
432  Print out a share mode.
433 ********************************************************************/
434
435 char *share_mode_str(TALLOC_CTX *ctx, int num, const struct share_mode_entry *e)
436 {
437         return talloc_asprintf(ctx, "share_mode_entry[%d]: "
438                  "pid = %s, share_access = 0x%x, private_options = 0x%x, "
439                  "access_mask = 0x%x, mid = 0x%llx, type= 0x%x, gen_id = %llu, "
440                  "uid = %u, flags = %u, file_id %s, name_hash = 0x%x",
441                  num,
442                  procid_str_static(&e->pid),
443                  e->share_access, e->private_options,
444                  e->access_mask, (unsigned long long)e->op_mid,
445                  e->op_type, (unsigned long long)e->share_file_id,
446                  (unsigned int)e->uid, (unsigned int)e->flags,
447                  file_id_string_tos(&e->id),
448                  (unsigned int)e->name_hash);
449 }
450
451 /*******************************************************************
452  Fetch a share mode where we know one MUST exist. This call reference
453  counts it internally to allow for nested lock fetches.
454 ********************************************************************/
455
456 struct share_mode_lock *get_existing_share_mode_lock(TALLOC_CTX *mem_ctx,
457                                                      const struct file_id id)
458 {
459         return get_share_mode_lock(mem_ctx, id, NULL, NULL, NULL);
460 }
461
462 /*******************************************************************
463  Sets the service name and filename for rename.
464  At this point we emit "file renamed" messages to all
465  process id's that have this file open.
466  Based on an initial code idea from SATOH Fumiyasu <fumiya@samba.gr.jp>
467 ********************************************************************/
468
469 bool rename_share_filename(struct messaging_context *msg_ctx,
470                         struct share_mode_lock *lck,
471                         const char *servicepath,
472                         uint32_t orig_name_hash,
473                         uint32_t new_name_hash,
474                         const struct smb_filename *smb_fname_dst)
475 {
476         struct share_mode_data *d = lck->data;
477         size_t sp_len;
478         size_t bn_len;
479         size_t sn_len;
480         size_t msg_len;
481         char *frm = NULL;
482         int i;
483         bool strip_two_chars = false;
484         bool has_stream = smb_fname_dst->stream_name != NULL;
485
486         DEBUG(10, ("rename_share_filename: servicepath %s newname %s\n",
487                    servicepath, smb_fname_dst->base_name));
488
489         /*
490          * rename_internal_fsp() and rename_internals() add './' to
491          * head of newname if newname does not contain a '/'.
492          */
493         if (smb_fname_dst->base_name[0] &&
494             smb_fname_dst->base_name[1] &&
495             smb_fname_dst->base_name[0] == '.' &&
496             smb_fname_dst->base_name[1] == '/') {
497                 strip_two_chars = true;
498         }
499
500         d->servicepath = talloc_strdup(d, servicepath);
501         d->base_name = talloc_strdup(d, smb_fname_dst->base_name +
502                                        (strip_two_chars ? 2 : 0));
503         d->stream_name = talloc_strdup(d, smb_fname_dst->stream_name);
504         if (d->base_name == NULL ||
505             (has_stream && d->stream_name == NULL) ||
506             d->servicepath == NULL) {
507                 DEBUG(0, ("rename_share_filename: talloc failed\n"));
508                 return False;
509         }
510         d->modified = True;
511
512         sp_len = strlen(d->servicepath);
513         bn_len = strlen(d->base_name);
514         sn_len = has_stream ? strlen(d->stream_name) : 0;
515
516         msg_len = MSG_FILE_RENAMED_MIN_SIZE + sp_len + 1 + bn_len + 1 +
517             sn_len + 1;
518
519         /* Set up the name changed message. */
520         frm = talloc_array(d, char, msg_len);
521         if (!frm) {
522                 return False;
523         }
524
525         push_file_id_24(frm, &d->id);
526
527         DEBUG(10,("rename_share_filename: msg_len = %u\n", (unsigned int)msg_len ));
528
529         strlcpy(&frm[24],
530                 d->servicepath ? d->servicepath : "",
531                 sp_len+1);
532         strlcpy(&frm[24 + sp_len + 1],
533                 d->base_name ? d->base_name : "",
534                 bn_len+1);
535         strlcpy(&frm[24 + sp_len + 1 + bn_len + 1],
536                 d->stream_name ? d->stream_name : "",
537                 sn_len+1);
538
539         /* Send the messages. */
540         for (i=0; i<d->num_share_modes; i++) {
541                 struct share_mode_entry *se = &d->share_modes[i];
542                 if (!is_valid_share_mode_entry(se)) {
543                         continue;
544                 }
545
546                 /* If this is a hardlink to the inode
547                    with a different name, skip this. */
548                 if (se->name_hash != orig_name_hash) {
549                         continue;
550                 }
551
552                 se->name_hash = new_name_hash;
553
554                 /* But not to ourselves... */
555                 if (procid_is_me(&se->pid)) {
556                         continue;
557                 }
558
559                 DEBUG(10,("rename_share_filename: sending rename message to "
560                           "pid %s file_id %s sharepath %s base_name %s "
561                           "stream_name %s\n",
562                           procid_str_static(&se->pid),
563                           file_id_string_tos(&d->id),
564                           d->servicepath, d->base_name,
565                         has_stream ? d->stream_name : ""));
566
567                 messaging_send_buf(msg_ctx, se->pid, MSG_SMB_FILE_RENAME,
568                                    (uint8 *)frm, msg_len);
569         }
570
571         return True;
572 }
573
574 void get_file_infos(struct file_id id,
575                     uint32_t name_hash,
576                     bool *delete_on_close,
577                     struct timespec *write_time)
578 {
579         struct share_mode_lock *lck;
580
581         if (delete_on_close) {
582                 *delete_on_close = false;
583         }
584
585         if (write_time) {
586                 ZERO_STRUCTP(write_time);
587         }
588
589         if (!(lck = fetch_share_mode_unlocked(talloc_tos(), id))) {
590                 return;
591         }
592
593         if (delete_on_close) {
594                 *delete_on_close = is_delete_on_close_set(lck, name_hash);
595         }
596
597         if (write_time) {
598                 struct timespec wt;
599
600                 wt = lck->data->changed_write_time;
601                 if (null_timespec(wt)) {
602                         wt = lck->data->old_write_time;
603                 }
604
605                 *write_time = wt;
606         }
607
608         TALLOC_FREE(lck);
609 }
610
611 bool is_valid_share_mode_entry(const struct share_mode_entry *e)
612 {
613         int num_props = 0;
614
615         num_props += ((e->op_type == NO_OPLOCK) ? 1 : 0);
616         num_props += (EXCLUSIVE_OPLOCK_TYPE(e->op_type) ? 1 : 0);
617         num_props += (LEVEL_II_OPLOCK_TYPE(e->op_type) ? 1 : 0);
618
619         SMB_ASSERT(num_props <= 1);
620         return (num_props != 0);
621 }
622
623 bool is_deferred_open_entry(const struct share_mode_entry *e)
624 {
625         return (e->op_type == DEFERRED_OPEN_ENTRY);
626 }
627
628 /*******************************************************************
629  Fill a share mode entry.
630 ********************************************************************/
631
632 static void fill_share_mode_entry(struct share_mode_entry *e,
633                                   files_struct *fsp,
634                                   uid_t uid, uint64_t mid, uint16 op_type)
635 {
636         ZERO_STRUCTP(e);
637         e->pid = messaging_server_id(fsp->conn->sconn->msg_ctx);
638         e->share_access = fsp->share_access;
639         e->private_options = fsp->fh->private_options;
640         e->access_mask = fsp->access_mask;
641         e->op_mid = mid;
642         e->op_type = op_type;
643         e->time.tv_sec = fsp->open_time.tv_sec;
644         e->time.tv_usec = fsp->open_time.tv_usec;
645         e->id = fsp->file_id;
646         e->share_file_id = fsp->fh->gen_id;
647         e->uid = (uint32)uid;
648         e->flags = fsp->posix_open ? SHARE_MODE_FLAG_POSIX_OPEN : 0;
649         e->name_hash = fsp->name_hash;
650 }
651
652 static void fill_deferred_open_entry(struct share_mode_entry *e,
653                                      const struct timeval request_time,
654                                      struct file_id id,
655                                      struct server_id pid,
656                                      uint64_t mid)
657 {
658         ZERO_STRUCTP(e);
659         e->pid = pid;
660         e->op_mid = mid;
661         e->op_type = DEFERRED_OPEN_ENTRY;
662         e->time.tv_sec = request_time.tv_sec;
663         e->time.tv_usec = request_time.tv_usec;
664         e->id = id;
665         e->uid = (uint32)-1;
666         e->flags = 0;
667 }
668
669 static void add_share_mode_entry(struct share_mode_data *d,
670                                  const struct share_mode_entry *entry)
671 {
672         ADD_TO_ARRAY(d, struct share_mode_entry, *entry,
673                      &d->share_modes, &d->num_share_modes);
674         d->modified = True;
675 }
676
677 void set_share_mode(struct share_mode_lock *lck, files_struct *fsp,
678                     uid_t uid, uint64_t mid, uint16 op_type)
679 {
680         struct share_mode_entry entry;
681         fill_share_mode_entry(&entry, fsp, uid, mid, op_type);
682         add_share_mode_entry(lck->data, &entry);
683 }
684
685 void add_deferred_open(struct share_mode_lock *lck, uint64_t mid,
686                        struct timeval request_time,
687                        struct server_id pid, struct file_id id)
688 {
689         struct share_mode_entry entry;
690         fill_deferred_open_entry(&entry, request_time, id, pid, mid);
691         add_share_mode_entry(lck->data, &entry);
692 }
693
694 /*******************************************************************
695  Check if two share mode entries are identical, ignoring oplock 
696  and mid info and desired_access. (Removed paranoia test - it's
697  not automatically a logic error if they are identical. JRA.)
698 ********************************************************************/
699
700 static bool share_modes_identical(struct share_mode_entry *e1,
701                                   struct share_mode_entry *e2)
702 {
703         /* We used to check for e1->share_access == e2->share_access here
704            as well as the other fields but 2 different DOS or FCB opens
705            sharing the same share mode entry may validly differ in
706            fsp->share_access field. */
707
708         return (procid_equal(&e1->pid, &e2->pid) &&
709                 file_id_equal(&e1->id, &e2->id) &&
710                 e1->share_file_id == e2->share_file_id );
711 }
712
713 static bool deferred_open_identical(struct share_mode_entry *e1,
714                                     struct share_mode_entry *e2)
715 {
716         return (procid_equal(&e1->pid, &e2->pid) &&
717                 (e1->op_mid == e2->op_mid) &&
718                 file_id_equal(&e1->id, &e2->id));
719 }
720
721 static struct share_mode_entry *find_share_mode_entry(struct share_mode_data *d,
722                                                       struct share_mode_entry *entry)
723 {
724         int i;
725
726         for (i=0; i<d->num_share_modes; i++) {
727                 struct share_mode_entry *e = &d->share_modes[i];
728                 if (is_valid_share_mode_entry(entry) &&
729                     is_valid_share_mode_entry(e) &&
730                     share_modes_identical(e, entry)) {
731                         return e;
732                 }
733                 if (is_deferred_open_entry(entry) &&
734                     is_deferred_open_entry(e) &&
735                     deferred_open_identical(e, entry)) {
736                         return e;
737                 }
738         }
739         return NULL;
740 }
741
742 /*******************************************************************
743  Del the share mode of a file for this process. Return the number of
744  entries left.
745 ********************************************************************/
746
747 bool del_share_mode(struct share_mode_lock *lck, files_struct *fsp)
748 {
749         struct share_mode_entry entry, *e;
750
751         /* Don't care about the pid owner being correct here - just a search. */
752         fill_share_mode_entry(&entry, fsp, (uid_t)-1, 0, NO_OPLOCK);
753
754         e = find_share_mode_entry(lck->data, &entry);
755         if (e == NULL) {
756                 return False;
757         }
758         *e = lck->data->share_modes[lck->data->num_share_modes-1];
759         lck->data->num_share_modes -= 1;
760         lck->data->modified = True;
761         return True;
762 }
763
764 void del_deferred_open_entry(struct share_mode_lock *lck, uint64_t mid,
765                              struct server_id pid)
766 {
767         struct share_mode_entry entry, *e;
768
769         fill_deferred_open_entry(&entry, timeval_zero(),
770                                  lck->data->id, pid, mid);
771
772         e = find_share_mode_entry(lck->data, &entry);
773         if (e == NULL) {
774                 return;
775         }
776         *e = lck->data->share_modes[lck->data->num_share_modes-1];
777         lck->data->num_share_modes -= 1;
778         lck->data->modified = True;
779 }
780
781 /*******************************************************************
782  Remove an oplock mid and mode entry from a share mode.
783 ********************************************************************/
784
785 bool remove_share_oplock(struct share_mode_lock *lck, files_struct *fsp)
786 {
787         struct share_mode_entry entry, *e;
788
789         /* Don't care about the pid owner being correct here - just a search. */
790         fill_share_mode_entry(&entry, fsp, (uid_t)-1, 0, NO_OPLOCK);
791
792         e = find_share_mode_entry(lck->data, &entry);
793         if (e == NULL) {
794                 return False;
795         }
796
797         if (EXCLUSIVE_OPLOCK_TYPE(e->op_type)) {
798                 /*
799                  * Going from exclusive or batch,
800                  * we always go through FAKE_LEVEL_II
801                  * first.
802                  */
803                 if (!EXCLUSIVE_OPLOCK_TYPE(fsp->oplock_type)) {
804                         smb_panic("remove_share_oplock: logic error");
805                 }
806                 e->op_type = FAKE_LEVEL_II_OPLOCK;
807         } else {
808                 e->op_type = NO_OPLOCK;
809         }
810         lck->data->modified = True;
811         return True;
812 }
813
814 /*******************************************************************
815  Downgrade a oplock type from exclusive to level II.
816 ********************************************************************/
817
818 bool downgrade_share_oplock(struct share_mode_lock *lck, files_struct *fsp)
819 {
820         struct share_mode_entry entry, *e;
821
822         /* Don't care about the pid owner being correct here - just a search. */
823         fill_share_mode_entry(&entry, fsp, (uid_t)-1, 0, NO_OPLOCK);
824
825         e = find_share_mode_entry(lck->data, &entry);
826         if (e == NULL) {
827                 return False;
828         }
829
830         e->op_type = LEVEL_II_OPLOCK;
831         lck->data->modified = True;
832         return True;
833 }
834
835 /*************************************************************************
836  Return a talloced copy of a struct security_unix_token. NULL on fail.
837  (Should this be in locking.c.... ?).
838 *************************************************************************/
839
840 static struct security_unix_token *copy_unix_token(TALLOC_CTX *ctx, const struct security_unix_token *tok)
841 {
842         struct security_unix_token *cpy;
843
844         cpy = talloc(ctx, struct security_unix_token);
845         if (!cpy) {
846                 return NULL;
847         }
848
849         cpy->uid = tok->uid;
850         cpy->gid = tok->gid;
851         cpy->ngroups = tok->ngroups;
852         if (tok->ngroups) {
853                 /* Make this a talloc child of cpy. */
854                 cpy->groups = (gid_t *)talloc_memdup(
855                         cpy, tok->groups, tok->ngroups * sizeof(gid_t));
856                 if (!cpy->groups) {
857                         TALLOC_FREE(cpy);
858                         return NULL;
859                 }
860         }
861         return cpy;
862 }
863
864 /****************************************************************************
865  Adds a delete on close token.
866 ****************************************************************************/
867
868 static bool add_delete_on_close_token(struct share_mode_data *d,
869                         uint32_t name_hash,
870                         const struct security_token *nt_tok,
871                         const struct security_unix_token *tok)
872 {
873         struct delete_token *tmp, *dtl;
874
875         tmp = talloc_realloc(d, d->delete_tokens, struct delete_token,
876                              d->num_delete_tokens+1);
877         if (tmp == NULL) {
878                 return false;
879         }
880         d->delete_tokens = tmp;
881         dtl = &d->delete_tokens[d->num_delete_tokens];
882
883         dtl->name_hash = name_hash;
884         dtl->delete_nt_token = dup_nt_token(d->delete_tokens, nt_tok);
885         if (dtl->delete_nt_token == NULL) {
886                 return false;
887         }
888         dtl->delete_token = copy_unix_token(d->delete_tokens, tok);
889         if (dtl->delete_token == NULL) {
890                 return false;
891         }
892         d->num_delete_tokens += 1;
893         d->modified = true;
894         return true;
895 }
896
897 /****************************************************************************
898  Sets the delete on close flag over all share modes on this file.
899  Modify the share mode entry for all files open
900  on this device and inode to tell other smbds we have
901  changed the delete on close flag. This will be noticed
902  in the close code, the last closer will delete the file
903  if flag is set.
904  This makes a copy of any struct security_unix_token into the
905  lck entry. This function is used when the lock is already granted.
906 ****************************************************************************/
907
908 void set_delete_on_close_lck(files_struct *fsp,
909                         struct share_mode_lock *lck,
910                         bool delete_on_close,
911                         const struct security_token *nt_tok,
912                         const struct security_unix_token *tok)
913 {
914         struct share_mode_data *d = lck->data;
915         int i;
916         bool ret;
917
918         if (delete_on_close) {
919                 SMB_ASSERT(nt_tok != NULL);
920                 SMB_ASSERT(tok != NULL);
921         } else {
922                 SMB_ASSERT(nt_tok == NULL);
923                 SMB_ASSERT(tok == NULL);
924         }
925
926         for (i=0; i<d->num_delete_tokens; i++) {
927                 struct delete_token *dt = &d->delete_tokens[i];
928                 if (dt->name_hash == fsp->name_hash) {
929                         d->modified = true;
930                         if (delete_on_close == false) {
931                                 /* Delete this entry. */
932                                 TALLOC_FREE(dt->delete_nt_token);
933                                 TALLOC_FREE(dt->delete_token);
934                                 *dt = d->delete_tokens[
935                                         d->num_delete_tokens-1];
936                                 d->num_delete_tokens -= 1;
937                         } else {
938                                 /* Replace this token with the
939                                    given tok. */
940                                 TALLOC_FREE(dt->delete_nt_token);
941                                 dt->delete_nt_token = dup_nt_token(dt, nt_tok);
942                                 SMB_ASSERT(dt->delete_nt_token != NULL);
943                                 TALLOC_FREE(dt->delete_token);
944                                 dt->delete_token = copy_unix_token(dt, tok);
945                                 SMB_ASSERT(dt->delete_token != NULL);
946                         }
947                         return;
948                 }
949         }
950
951         if (!delete_on_close) {
952                 /* Nothing to delete - not found. */
953                 return;
954         }
955
956         ret = add_delete_on_close_token(lck->data, fsp->name_hash, nt_tok, tok);
957         SMB_ASSERT(ret);
958 }
959
960 bool set_delete_on_close(files_struct *fsp, bool delete_on_close,
961                         const struct security_token *nt_tok,
962                         const struct security_unix_token *tok)
963 {
964         struct share_mode_lock *lck;
965
966         DEBUG(10,("set_delete_on_close: %s delete on close flag for "
967                   "fnum = %d, file %s\n",
968                   delete_on_close ? "Adding" : "Removing", fsp->fnum,
969                   fsp_str_dbg(fsp)));
970
971         lck = get_existing_share_mode_lock(talloc_tos(), fsp->file_id);
972         if (lck == NULL) {
973                 return False;
974         }
975
976         if (delete_on_close) {
977                 set_delete_on_close_lck(fsp, lck, true,
978                         nt_tok,
979                         tok);
980         } else {
981                 set_delete_on_close_lck(fsp, lck, false,
982                         NULL,
983                         NULL);
984         }
985
986         if (fsp->is_directory) {
987                 SMB_ASSERT(!is_ntfs_stream_smb_fname(fsp->fsp_name));
988                 send_stat_cache_delete_message(fsp->conn->sconn->msg_ctx,
989                                                fsp->fsp_name->base_name);
990         }
991
992         TALLOC_FREE(lck);
993
994         fsp->delete_on_close = delete_on_close;
995
996         return True;
997 }
998
999 /****************************************************************************
1000  Return the NT token and UNIX token if there's a match. Return true if
1001  found, false if not.
1002 ****************************************************************************/
1003
1004 bool get_delete_on_close_token(struct share_mode_lock *lck,
1005                                         uint32_t name_hash,
1006                                         const struct security_token **pp_nt_tok,
1007                                         const struct security_unix_token **pp_tok)
1008 {
1009         int i;
1010
1011         DEBUG(10,("get_delete_on_close_token: name_hash = 0x%x\n",
1012                         (unsigned int)name_hash ));
1013
1014         for (i=0; i<lck->data->num_delete_tokens; i++) {
1015                 struct delete_token *dt = &lck->data->delete_tokens[i];
1016                 DEBUG(10,("get_delete_on_close_token: dtl->name_hash = 0x%x\n",
1017                                 (unsigned int)dt->name_hash ));
1018                 if (dt->name_hash == name_hash) {
1019                         if (pp_nt_tok) {
1020                                 *pp_nt_tok = dt->delete_nt_token;
1021                         }
1022                         if (pp_tok) {
1023                                 *pp_tok =  dt->delete_token;
1024                         }
1025                         return true;
1026                 }
1027         }
1028         return false;
1029 }
1030
1031 bool is_delete_on_close_set(struct share_mode_lock *lck, uint32_t name_hash)
1032 {
1033         return get_delete_on_close_token(lck, name_hash, NULL, NULL);
1034 }
1035
1036 bool set_sticky_write_time(struct file_id fileid, struct timespec write_time)
1037 {
1038         struct share_mode_lock *lck;
1039
1040         DEBUG(5,("set_sticky_write_time: %s id=%s\n",
1041                  timestring(talloc_tos(),
1042                             convert_timespec_to_time_t(write_time)),
1043                  file_id_string_tos(&fileid)));
1044
1045         lck = get_existing_share_mode_lock(talloc_tos(), fileid);
1046         if (lck == NULL) {
1047                 return False;
1048         }
1049
1050         if (timespec_compare(&lck->data->changed_write_time, &write_time) != 0) {
1051                 lck->data->modified = True;
1052                 lck->data->changed_write_time = write_time;
1053         }
1054
1055         TALLOC_FREE(lck);
1056         return True;
1057 }
1058
1059 bool set_write_time(struct file_id fileid, struct timespec write_time)
1060 {
1061         struct share_mode_lock *lck;
1062
1063         DEBUG(5,("set_write_time: %s id=%s\n",
1064                  timestring(talloc_tos(),
1065                             convert_timespec_to_time_t(write_time)),
1066                  file_id_string_tos(&fileid)));
1067
1068         lck = get_existing_share_mode_lock(talloc_tos(), fileid);
1069         if (lck == NULL) {
1070                 return False;
1071         }
1072
1073         if (timespec_compare(&lck->data->old_write_time, &write_time) != 0) {
1074                 lck->data->modified = True;
1075                 lck->data->old_write_time = write_time;
1076         }
1077
1078         TALLOC_FREE(lck);
1079         return True;
1080 }