s3-messages: make ndr_messaging.h part of messages.h.
[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    rewrtten completely to use new tdb code. Tridge, Dec '99
33
34    Added POSIX locking support. Jeremy Allison (jeremy@valinux.com), Apr. 2000.
35    Added Unix Extensions POSIX locking support. Jeremy Allison Mar 2006.
36 */
37
38 #include "includes.h"
39 #include "system/filesys.h"
40 #include "locking/proto.h"
41 #include "smbd/globals.h"
42 #include "dbwrap.h"
43 #include "../libcli/security/security.h"
44 #include "serverid.h"
45 #include "messages.h"
46
47 #undef DBGC_CLASS
48 #define DBGC_CLASS DBGC_LOCKING
49
50 #define NO_LOCKING_COUNT (-1)
51
52 /* the locking database handle */
53 static struct db_context *lock_db;
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 = sconn_server_id(fsp->conn->sconn);
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                         sconn_server_id(fsp->conn->sconn),
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                         sconn_server_id(fsp->conn->sconn),
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                         sconn_server_id(fsp->conn->sconn),
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                         sconn_server_id(fsp->conn->sconn),
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  Initialise the locking functions.
433 ****************************************************************************/
434
435 static bool locking_init_internal(bool read_only)
436 {
437         brl_init(read_only);
438
439         if (lock_db)
440                 return True;
441
442         lock_db = db_open(NULL, lock_path("locking.tdb"),
443                           lp_open_files_db_hash_size(),
444                           TDB_DEFAULT|TDB_VOLATILE|TDB_CLEAR_IF_FIRST|TDB_INCOMPATIBLE_HASH,
445                           read_only?O_RDONLY:O_RDWR|O_CREAT, 0644);
446
447         if (!lock_db) {
448                 DEBUG(0,("ERROR: Failed to initialise locking database\n"));
449                 return False;
450         }
451
452         if (!posix_locking_init(read_only))
453                 return False;
454
455         return True;
456 }
457
458 bool locking_init(void)
459 {
460         return locking_init_internal(false);
461 }
462
463 bool locking_init_readonly(void)
464 {
465         return locking_init_internal(true);
466 }
467
468 /*******************************************************************
469  Deinitialize the share_mode management.
470 ******************************************************************/
471
472 bool locking_end(void)
473 {
474         brl_shutdown();
475         TALLOC_FREE(lock_db);
476         return true;
477 }
478
479 /*******************************************************************
480  Form a static locking key for a dev/inode pair.
481 ******************************************************************/
482
483 static TDB_DATA locking_key(const struct file_id *id, struct file_id *tmp)
484 {
485         *tmp = *id;
486         return make_tdb_data((const uint8_t *)tmp, sizeof(*tmp));
487 }
488
489 /*******************************************************************
490  Print out a share mode.
491 ********************************************************************/
492
493 char *share_mode_str(TALLOC_CTX *ctx, int num, const struct share_mode_entry *e)
494 {
495         return talloc_asprintf(ctx, "share_mode_entry[%d]: %s "
496                  "pid = %s, share_access = 0x%x, private_options = 0x%x, "
497                  "access_mask = 0x%x, mid = 0x%llx, type= 0x%x, gen_id = %lu, "
498                  "uid = %u, flags = %u, file_id %s, name_hash = 0x%x",
499                  num,
500                  e->op_type == UNUSED_SHARE_MODE_ENTRY ? "UNUSED" : "",
501                  procid_str_static(&e->pid),
502                  e->share_access, e->private_options,
503                  e->access_mask, (unsigned long long)e->op_mid,
504                  e->op_type, e->share_file_id,
505                  (unsigned int)e->uid, (unsigned int)e->flags,
506                  file_id_string_tos(&e->id),
507                  (unsigned int)e->name_hash);
508 }
509
510 /*******************************************************************
511  Print out a share mode table.
512 ********************************************************************/
513
514 static void print_share_mode_table(struct locking_data *data)
515 {
516         int num_share_modes = data->u.s.num_share_mode_entries;
517         struct share_mode_entry *shares =
518                 (struct share_mode_entry *)(data + 1);
519         int i;
520
521         for (i = 0; i < num_share_modes; i++) {
522                 struct share_mode_entry entry;
523                 char *str;
524
525                 /*
526                  * We need to memcpy the entry here due to alignment
527                  * restrictions that are not met when directly accessing
528                  * shares[i]
529                  */
530
531                 memcpy(&entry, &shares[i], sizeof(struct share_mode_entry));
532                 str = share_mode_str(talloc_tos(), i, &entry);
533
534                 DEBUG(10,("print_share_mode_table: %s\n", str ? str : ""));
535                 TALLOC_FREE(str);
536         }
537 }
538
539 static int parse_delete_tokens_list(struct share_mode_lock *lck,
540                 struct locking_data *pdata,
541                 const TDB_DATA dbuf)
542 {
543         uint8_t *p = dbuf.dptr + sizeof(struct locking_data) +
544                         (lck->num_share_modes *
545                         sizeof(struct share_mode_entry));
546         uint8_t *end_ptr = dbuf.dptr + (dbuf.dsize - 2);
547         int delete_tokens_size = 0;
548         int i;
549
550         lck->delete_tokens = NULL;
551
552         for (i = 0; i < pdata->u.s.num_delete_token_entries; i++) {
553                 uint32_t token_len;
554                 struct delete_token_list *pdtl;
555
556                 if (end_ptr - p < (sizeof(uint32_t) + sizeof(uint32_t) +
557                                         sizeof(uid_t) + sizeof(gid_t))) {
558                         DEBUG(0,("parse_delete_tokens_list: "
559                                 "corrupt token list (%u)",
560                                 (unsigned int)(end_ptr - p)));
561                         smb_panic("corrupt token list");
562                         return -1;
563                 }
564
565                 memcpy(&token_len, p, sizeof(token_len));
566                 delete_tokens_size += token_len;
567
568                 if (p + token_len > end_ptr || token_len < sizeof(token_len) +
569                                                 sizeof(pdtl->name_hash) +
570                                                 sizeof(uid_t) +
571                                                 sizeof(gid_t)) {
572                         DEBUG(0,("parse_delete_tokens_list: "
573                                 "invalid token length (%u)\n",
574                                 (unsigned int)token_len ));
575                         smb_panic("invalid token length");
576                         return -1;
577                 }
578
579                 p += sizeof(token_len);
580
581                 pdtl = TALLOC_ZERO_P(lck, struct delete_token_list);
582                 if (pdtl == NULL) {
583                         DEBUG(0,("parse_delete_tokens_list: talloc failed"));
584                         return -1;
585                 }
586                 /* Copy out the name_hash. */
587                 memcpy(&pdtl->name_hash, p, sizeof(pdtl->name_hash));
588                 p += sizeof(pdtl->name_hash);
589
590                 pdtl->delete_token = TALLOC_ZERO_P(pdtl, struct security_unix_token);
591                 if (pdtl->delete_token == NULL) {
592                         DEBUG(0,("parse_delete_tokens_list: talloc failed"));
593                         return -1;
594                 }
595
596                 /* Copy out the uid and gid. */
597                 memcpy(&pdtl->delete_token->uid, p, sizeof(uid_t));
598                 p += sizeof(uid_t);
599                 memcpy(&pdtl->delete_token->gid, p, sizeof(gid_t));
600                 p += sizeof(gid_t);
601
602                 token_len -= (sizeof(token_len) + sizeof(pdtl->name_hash) +
603                                 sizeof(uid_t) + sizeof(gid_t));
604
605                 /* Any supplementary groups ? */
606                 if (token_len) {
607                         int j;
608
609                         if (token_len % sizeof(gid_t) != 0) {
610                                 DEBUG(0,("parse_delete_tokens_list: "
611                                         "corrupt group list (%u)",
612                                         (unsigned int)(token_len % sizeof(gid_t)) ));
613                                 smb_panic("corrupt group list");
614                                 return -1;
615                         }
616
617                         pdtl->delete_token->ngroups = token_len / sizeof(gid_t);
618                         pdtl->delete_token->groups = TALLOC_ARRAY(pdtl->delete_token, gid_t,
619                                                 pdtl->delete_token->ngroups);
620                         if (pdtl->delete_token->groups == NULL) {
621                                 DEBUG(0,("parse_delete_tokens_list: talloc failed"));
622                                 return -1;
623                         }
624
625                         for (j = 0; j < pdtl->delete_token->ngroups; j++) {
626                                 memcpy(&pdtl->delete_token->groups[j], p, sizeof(gid_t));
627                                 p += sizeof(gid_t);
628                         }
629                 }
630                 /* Add to the list. */
631                 DLIST_ADD(lck->delete_tokens, pdtl);
632         }
633
634         return delete_tokens_size;
635 }
636
637 /*******************************************************************
638  Get all share mode entries for a dev/inode pair.
639 ********************************************************************/
640
641 static bool parse_share_modes(const TDB_DATA dbuf, struct share_mode_lock *lck)
642 {
643         struct locking_data data;
644         int delete_tokens_size;
645         int i;
646
647         if (dbuf.dsize < sizeof(struct locking_data)) {
648                 smb_panic("parse_share_modes: buffer too short");
649         }
650
651         memcpy(&data, dbuf.dptr, sizeof(data));
652
653         lck->old_write_time = data.u.s.old_write_time;
654         lck->changed_write_time = data.u.s.changed_write_time;
655         lck->num_share_modes = data.u.s.num_share_mode_entries;
656
657         DEBUG(10, ("parse_share_modes: owrt: %s, "
658                    "cwrt: %s, ntok: %u, num_share_modes: %d\n",
659                    timestring(talloc_tos(),
660                               convert_timespec_to_time_t(lck->old_write_time)),
661                    timestring(talloc_tos(),
662                               convert_timespec_to_time_t(
663                                       lck->changed_write_time)),
664                    (unsigned int)data.u.s.num_delete_token_entries,
665                    lck->num_share_modes));
666
667         if ((lck->num_share_modes < 0) || (lck->num_share_modes > 1000000)) {
668                 DEBUG(0, ("invalid number of share modes: %d\n",
669                           lck->num_share_modes));
670                 smb_panic("parse_share_modes: invalid number of share modes");
671         }
672
673         lck->share_modes = NULL;
674         
675         if (lck->num_share_modes != 0) {
676
677                 if (dbuf.dsize < (sizeof(struct locking_data) +
678                                   (lck->num_share_modes *
679                                    sizeof(struct share_mode_entry)))) {
680                         smb_panic("parse_share_modes: buffer too short");
681                 }
682                                   
683                 lck->share_modes = (struct share_mode_entry *)
684                         TALLOC_MEMDUP(lck,
685                                       dbuf.dptr+sizeof(struct locking_data),
686                                       lck->num_share_modes *
687                                       sizeof(struct share_mode_entry));
688
689                 if (lck->share_modes == NULL) {
690                         smb_panic("parse_share_modes: talloc failed");
691                 }
692         }
693
694         /* Get any delete tokens. */
695         delete_tokens_size = parse_delete_tokens_list(lck, &data, dbuf);
696         if (delete_tokens_size < 0) {
697                 smb_panic("parse_share_modes: parse_delete_tokens_list failed");
698         }
699
700         /* Save off the associated service path and filename. */
701         lck->servicepath = (const char *)dbuf.dptr + sizeof(struct locking_data) +
702                 (lck->num_share_modes * sizeof(struct share_mode_entry)) +
703                 delete_tokens_size;
704
705         lck->base_name = (const char *)dbuf.dptr + sizeof(struct locking_data) +
706                 (lck->num_share_modes * sizeof(struct share_mode_entry)) +
707                 delete_tokens_size +
708                 strlen(lck->servicepath) + 1;
709
710         lck->stream_name = (const char *)dbuf.dptr + sizeof(struct locking_data) +
711                 (lck->num_share_modes * sizeof(struct share_mode_entry)) +
712                 delete_tokens_size +
713                 strlen(lck->servicepath) + 1 +
714                 strlen(lck->base_name) + 1;
715
716         /*
717          * Ensure that each entry has a real process attached.
718          */
719
720         for (i = 0; i < lck->num_share_modes; i++) {
721                 struct share_mode_entry *entry_p = &lck->share_modes[i];
722                 char *str = NULL;
723                 if (DEBUGLEVEL >= 10) {
724                         str = share_mode_str(NULL, i, entry_p);
725                 }
726                 DEBUG(10,("parse_share_modes: %s\n",
727                         str ? str : ""));
728                 if (!serverid_exists(&entry_p->pid)) {
729                         DEBUG(10,("parse_share_modes: deleted %s\n",
730                                 str ? str : ""));
731                         entry_p->op_type = UNUSED_SHARE_MODE_ENTRY;
732                         lck->modified = True;
733                 }
734                 TALLOC_FREE(str);
735         }
736
737         return True;
738 }
739
740 static TDB_DATA unparse_share_modes(const struct share_mode_lock *lck)
741 {
742         TDB_DATA result;
743         int num_valid = 0;
744         int i;
745         struct locking_data *data;
746         ssize_t offset;
747         ssize_t sp_len, bn_len, sn_len;
748         uint32_t delete_tokens_size = 0;
749         struct delete_token_list *pdtl = NULL;
750         uint32_t num_delete_token_entries = 0;
751
752         result.dptr = NULL;
753         result.dsize = 0;
754
755         for (i=0; i<lck->num_share_modes; i++) {
756                 if (!is_unused_share_mode_entry(&lck->share_modes[i])) {
757                         num_valid += 1;
758                 }
759         }
760
761         if (num_valid == 0) {
762                 return result;
763         }
764
765         sp_len = strlen(lck->servicepath);
766         bn_len = strlen(lck->base_name);
767         sn_len = lck->stream_name != NULL ? strlen(lck->stream_name) : 0;
768
769         for (pdtl = lck->delete_tokens; pdtl; pdtl = pdtl->next) {
770                 num_delete_token_entries++;
771                 delete_tokens_size += (sizeof(uint32_t) +
772                                 sizeof(uint32_t) +
773                                 sizeof(uid_t) +
774                                 sizeof(gid_t) +
775                                 pdtl->delete_token->ngroups*sizeof(gid_t));
776         }
777
778         result.dsize = sizeof(*data) +
779                 lck->num_share_modes * sizeof(struct share_mode_entry) +
780                 delete_tokens_size +
781                 sp_len + 1 +
782                 bn_len + 1 +
783                 sn_len + 1;
784         result.dptr = TALLOC_ARRAY(lck, uint8, result.dsize);
785
786         if (result.dptr == NULL) {
787                 smb_panic("talloc failed");
788         }
789
790         data = (struct locking_data *)result.dptr;
791         ZERO_STRUCTP(data);
792         data->u.s.num_share_mode_entries = lck->num_share_modes;
793         data->u.s.old_write_time = lck->old_write_time;
794         data->u.s.changed_write_time = lck->changed_write_time;
795         data->u.s.num_delete_token_entries = num_delete_token_entries;
796
797         DEBUG(10,("unparse_share_modes: owrt: %s cwrt: %s, ntok: %u, "
798                   "num: %d\n",
799                   timestring(talloc_tos(),
800                              convert_timespec_to_time_t(lck->old_write_time)),
801                   timestring(talloc_tos(),
802                              convert_timespec_to_time_t(
803                                      lck->changed_write_time)),
804                   (unsigned int)data->u.s.num_delete_token_entries,
805                   data->u.s.num_share_mode_entries));
806
807         memcpy(result.dptr + sizeof(*data), lck->share_modes,
808                sizeof(struct share_mode_entry)*lck->num_share_modes);
809         offset = sizeof(*data) +
810                 sizeof(struct share_mode_entry)*lck->num_share_modes;
811
812         /* Store any delete on close tokens. */
813         for (pdtl = lck->delete_tokens; pdtl; pdtl = pdtl->next) {
814                 struct security_unix_token *pdt = pdtl->delete_token;
815                 uint32_t token_size = sizeof(uint32_t) +
816                                         sizeof(uint32_t) +
817                                         sizeof(uid_t) +
818                                         sizeof(gid_t) +
819                                         (pdt->ngroups * sizeof(gid_t));
820                 uint8_t *p = result.dptr + offset;
821
822                 memcpy(p, &token_size, sizeof(uint32_t));
823                 p += sizeof(uint32_t);
824
825                 memcpy(p, &pdtl->name_hash, sizeof(uint32_t));
826                 p += sizeof(uint32_t);
827
828                 memcpy(p, &pdt->uid, sizeof(uid_t));
829                 p += sizeof(uid_t);
830
831                 memcpy(p, &pdt->gid, sizeof(gid_t));
832                 p += sizeof(gid_t);
833
834                 for (i = 0; i < pdt->ngroups; i++) {
835                         memcpy(p, &pdt->groups[i], sizeof(gid_t));
836                         p += sizeof(gid_t);
837                 }
838                 offset += token_size;
839         }
840
841         safe_strcpy((char *)result.dptr + offset, lck->servicepath,
842                     result.dsize - offset - 1);
843         offset += sp_len + 1;
844         safe_strcpy((char *)result.dptr + offset, lck->base_name,
845                     result.dsize - offset - 1);
846         offset += bn_len + 1;
847         safe_strcpy((char *)result.dptr + offset, lck->stream_name,
848                     result.dsize - offset - 1);
849
850         if (DEBUGLEVEL >= 10) {
851                 print_share_mode_table(data);
852         }
853
854         return result;
855 }
856
857 static int share_mode_lock_destructor(struct share_mode_lock *lck)
858 {
859         NTSTATUS status;
860         TDB_DATA data;
861
862         if (!lck->modified) {
863                 return 0;
864         }
865
866         data = unparse_share_modes(lck);
867
868         if (data.dptr == NULL) {
869                 if (!lck->fresh) {
870                         /* There has been an entry before, delete it */
871
872                         status = lck->record->delete_rec(lck->record);
873                         if (!NT_STATUS_IS_OK(status)) {
874                                 char *errmsg;
875
876                                 DEBUG(0, ("delete_rec returned %s\n",
877                                           nt_errstr(status)));
878
879                                 if (asprintf(&errmsg, "could not delete share "
880                                              "entry: %s\n",
881                                              nt_errstr(status)) == -1) {
882                                         smb_panic("could not delete share"
883                                                   "entry");
884                                 }
885                                 smb_panic(errmsg);
886                         }
887                 }
888                 goto done;
889         }
890
891         status = lck->record->store(lck->record, data, TDB_REPLACE);
892         if (!NT_STATUS_IS_OK(status)) {
893                 char *errmsg;
894
895                 DEBUG(0, ("store returned %s\n", nt_errstr(status)));
896
897                 if (asprintf(&errmsg, "could not store share mode entry: %s",
898                              nt_errstr(status)) == -1) {
899                         smb_panic("could not store share mode entry");
900                 }
901                 smb_panic(errmsg);
902         }
903
904  done:
905
906         return 0;
907 }
908
909 static bool fill_share_mode_lock(struct share_mode_lock *lck,
910                                  struct file_id id,
911                                  const char *servicepath,
912                                  const struct smb_filename *smb_fname,
913                                  TDB_DATA share_mode_data,
914                                  const struct timespec *old_write_time)
915 {
916         /* Ensure we set every field here as the destructor must be
917            valid even if parse_share_modes fails. */
918
919         lck->servicepath = NULL;
920         lck->base_name = NULL;
921         lck->stream_name = NULL;
922         lck->id = id;
923         lck->num_share_modes = 0;
924         lck->share_modes = NULL;
925         lck->delete_tokens = NULL;
926         ZERO_STRUCT(lck->old_write_time);
927         ZERO_STRUCT(lck->changed_write_time);
928         lck->fresh = False;
929         lck->modified = False;
930
931         lck->fresh = (share_mode_data.dptr == NULL);
932
933         if (lck->fresh) {
934                 bool has_stream;
935                 if (smb_fname == NULL || servicepath == NULL
936                     || old_write_time == NULL) {
937                         return False;
938                 }
939
940                 has_stream = smb_fname->stream_name != NULL;
941
942                 lck->base_name = talloc_strdup(lck, smb_fname->base_name);
943                 lck->stream_name = talloc_strdup(lck, smb_fname->stream_name);
944                 lck->servicepath = talloc_strdup(lck, servicepath);
945                 if (lck->base_name == NULL ||
946                     (has_stream && lck->stream_name == NULL) ||
947                     lck->servicepath == NULL) {
948                         DEBUG(0, ("talloc failed\n"));
949                         return False;
950                 }
951                 lck->old_write_time = *old_write_time;
952         } else {
953                 if (!parse_share_modes(share_mode_data, lck)) {
954                         DEBUG(0, ("Could not parse share modes\n"));
955                         return False;
956                 }
957         }
958
959         return True;
960 }
961
962 struct share_mode_lock *get_share_mode_lock(TALLOC_CTX *mem_ctx,
963                                             const struct file_id id,
964                                             const char *servicepath,
965                                             const struct smb_filename *smb_fname,
966                                             const struct timespec *old_write_time)
967 {
968         struct share_mode_lock *lck;
969         struct file_id tmp;
970         TDB_DATA key = locking_key(&id, &tmp);
971
972         if (!(lck = TALLOC_P(mem_ctx, struct share_mode_lock))) {
973                 DEBUG(0, ("talloc failed\n"));
974                 return NULL;
975         }
976
977         if (!(lck->record = lock_db->fetch_locked(lock_db, lck, key))) {
978                 DEBUG(3, ("Could not lock share entry\n"));
979                 TALLOC_FREE(lck);
980                 return NULL;
981         }
982
983         if (!fill_share_mode_lock(lck, id, servicepath, smb_fname,
984                                   lck->record->value, old_write_time)) {
985                 DEBUG(3, ("fill_share_mode_lock failed\n"));
986                 TALLOC_FREE(lck);
987                 return NULL;
988         }
989
990         talloc_set_destructor(lck, share_mode_lock_destructor);
991
992         return lck;
993 }
994
995 struct share_mode_lock *fetch_share_mode_unlocked(TALLOC_CTX *mem_ctx,
996                                                   const struct file_id id)
997 {
998         struct share_mode_lock *lck;
999         struct file_id tmp;
1000         TDB_DATA key = locking_key(&id, &tmp);
1001         TDB_DATA data;
1002
1003         if (!(lck = TALLOC_P(mem_ctx, struct share_mode_lock))) {
1004                 DEBUG(0, ("talloc failed\n"));
1005                 return NULL;
1006         }
1007
1008         if (lock_db->fetch(lock_db, lck, key, &data) == -1) {
1009                 DEBUG(3, ("Could not fetch share entry\n"));
1010                 TALLOC_FREE(lck);
1011                 return NULL;
1012         }
1013
1014         if (!fill_share_mode_lock(lck, id, NULL, NULL, data, NULL)) {
1015                 DEBUG(10, ("fetch_share_mode_unlocked: no share_mode record "
1016                            "around (file not open)\n"));
1017                 TALLOC_FREE(lck);
1018                 return NULL;
1019         }
1020
1021         return lck;
1022 }
1023
1024 /*******************************************************************
1025  Sets the service name and filename for rename.
1026  At this point we emit "file renamed" messages to all
1027  process id's that have this file open.
1028  Based on an initial code idea from SATOH Fumiyasu <fumiya@samba.gr.jp>
1029 ********************************************************************/
1030
1031 bool rename_share_filename(struct messaging_context *msg_ctx,
1032                         struct share_mode_lock *lck,
1033                         const char *servicepath,
1034                         uint32_t orig_name_hash,
1035                         uint32_t new_name_hash,
1036                         const struct smb_filename *smb_fname_dst)
1037 {
1038         size_t sp_len;
1039         size_t bn_len;
1040         size_t sn_len;
1041         size_t msg_len;
1042         char *frm = NULL;
1043         int i;
1044         bool strip_two_chars = false;
1045         bool has_stream = smb_fname_dst->stream_name != NULL;
1046
1047         DEBUG(10, ("rename_share_filename: servicepath %s newname %s\n",
1048                    servicepath, smb_fname_dst->base_name));
1049
1050         /*
1051          * rename_internal_fsp() and rename_internals() add './' to
1052          * head of newname if newname does not contain a '/'.
1053          */
1054         if (smb_fname_dst->base_name[0] &&
1055             smb_fname_dst->base_name[1] &&
1056             smb_fname_dst->base_name[0] == '.' &&
1057             smb_fname_dst->base_name[1] == '/') {
1058                 strip_two_chars = true;
1059         }
1060
1061         lck->servicepath = talloc_strdup(lck, servicepath);
1062         lck->base_name = talloc_strdup(lck, smb_fname_dst->base_name +
1063                                        (strip_two_chars ? 2 : 0));
1064         lck->stream_name = talloc_strdup(lck, smb_fname_dst->stream_name);
1065         if (lck->base_name == NULL ||
1066             (has_stream && lck->stream_name == NULL) ||
1067             lck->servicepath == NULL) {
1068                 DEBUG(0, ("rename_share_filename: talloc failed\n"));
1069                 return False;
1070         }
1071         lck->modified = True;
1072
1073         sp_len = strlen(lck->servicepath);
1074         bn_len = strlen(lck->base_name);
1075         sn_len = has_stream ? strlen(lck->stream_name) : 0;
1076
1077         msg_len = MSG_FILE_RENAMED_MIN_SIZE + sp_len + 1 + bn_len + 1 +
1078             sn_len + 1;
1079
1080         /* Set up the name changed message. */
1081         frm = TALLOC_ARRAY(lck, char, msg_len);
1082         if (!frm) {
1083                 return False;
1084         }
1085
1086         push_file_id_24(frm, &lck->id);
1087
1088         DEBUG(10,("rename_share_filename: msg_len = %u\n", (unsigned int)msg_len ));
1089
1090         safe_strcpy(&frm[24], lck->servicepath, sp_len);
1091         safe_strcpy(&frm[24 + sp_len + 1], lck->base_name, bn_len);
1092         safe_strcpy(&frm[24 + sp_len + 1 + bn_len + 1], lck->stream_name,
1093                     sn_len);
1094
1095         /* Send the messages. */
1096         for (i=0; i<lck->num_share_modes; i++) {
1097                 struct share_mode_entry *se = &lck->share_modes[i];
1098                 if (!is_valid_share_mode_entry(se)) {
1099                         continue;
1100                 }
1101
1102                 /* If this is a hardlink to the inode
1103                    with a different name, skip this. */
1104                 if (se->name_hash != orig_name_hash) {
1105                         continue;
1106                 }
1107
1108                 se->name_hash = new_name_hash;
1109
1110                 /* But not to ourselves... */
1111                 if (procid_is_me(&se->pid)) {
1112                         continue;
1113                 }
1114
1115                 DEBUG(10,("rename_share_filename: sending rename message to "
1116                           "pid %s file_id %s sharepath %s base_name %s "
1117                           "stream_name %s\n",
1118                           procid_str_static(&se->pid),
1119                           file_id_string_tos(&lck->id),
1120                           lck->servicepath, lck->base_name,
1121                         has_stream ? lck->stream_name : ""));
1122
1123                 messaging_send_buf(msg_ctx, se->pid, MSG_SMB_FILE_RENAME,
1124                                    (uint8 *)frm, msg_len);
1125         }
1126
1127         return True;
1128 }
1129
1130 void get_file_infos(struct file_id id,
1131                     uint32_t name_hash,
1132                     bool *delete_on_close,
1133                     struct timespec *write_time)
1134 {
1135         struct share_mode_lock *lck;
1136
1137         if (delete_on_close) {
1138                 *delete_on_close = false;
1139         }
1140
1141         if (write_time) {
1142                 ZERO_STRUCTP(write_time);
1143         }
1144
1145         if (!(lck = fetch_share_mode_unlocked(talloc_tos(), id))) {
1146                 return;
1147         }
1148
1149         if (delete_on_close) {
1150                 *delete_on_close = is_delete_on_close_set(lck, name_hash);
1151         }
1152
1153         if (write_time) {
1154                 struct timespec wt;
1155
1156                 wt = lck->changed_write_time;
1157                 if (null_timespec(wt)) {
1158                         wt = lck->old_write_time;
1159                 }
1160
1161                 *write_time = wt;
1162         }
1163
1164         TALLOC_FREE(lck);
1165 }
1166
1167 bool is_valid_share_mode_entry(const struct share_mode_entry *e)
1168 {
1169         int num_props = 0;
1170
1171         if (e->op_type == UNUSED_SHARE_MODE_ENTRY) {
1172                 /* cope with dead entries from the process not
1173                    existing. These should not be considered valid,
1174                    otherwise we end up doing zero timeout sharing
1175                    violation */
1176                 return False;
1177         }
1178
1179         num_props += ((e->op_type == NO_OPLOCK) ? 1 : 0);
1180         num_props += (EXCLUSIVE_OPLOCK_TYPE(e->op_type) ? 1 : 0);
1181         num_props += (LEVEL_II_OPLOCK_TYPE(e->op_type) ? 1 : 0);
1182
1183         SMB_ASSERT(num_props <= 1);
1184         return (num_props != 0);
1185 }
1186
1187 bool is_deferred_open_entry(const struct share_mode_entry *e)
1188 {
1189         return (e->op_type == DEFERRED_OPEN_ENTRY);
1190 }
1191
1192 bool is_unused_share_mode_entry(const struct share_mode_entry *e)
1193 {
1194         return (e->op_type == UNUSED_SHARE_MODE_ENTRY);
1195 }
1196
1197 /*******************************************************************
1198  Fill a share mode entry.
1199 ********************************************************************/
1200
1201 static void fill_share_mode_entry(struct share_mode_entry *e,
1202                                   files_struct *fsp,
1203                                   uid_t uid, uint64_t mid, uint16 op_type)
1204 {
1205         ZERO_STRUCTP(e);
1206         e->pid = sconn_server_id(fsp->conn->sconn);
1207         e->share_access = fsp->share_access;
1208         e->private_options = fsp->fh->private_options;
1209         e->access_mask = fsp->access_mask;
1210         e->op_mid = mid;
1211         e->op_type = op_type;
1212         e->time.tv_sec = fsp->open_time.tv_sec;
1213         e->time.tv_usec = fsp->open_time.tv_usec;
1214         e->id = fsp->file_id;
1215         e->share_file_id = fsp->fh->gen_id;
1216         e->uid = (uint32)uid;
1217         e->flags = fsp->posix_open ? SHARE_MODE_FLAG_POSIX_OPEN : 0;
1218         e->name_hash = fsp->name_hash;
1219 }
1220
1221 static void fill_deferred_open_entry(struct share_mode_entry *e,
1222                                      const struct timeval request_time,
1223                                      struct file_id id,
1224                                      struct server_id pid,
1225                                      uint64_t mid)
1226 {
1227         ZERO_STRUCTP(e);
1228         e->pid = pid;
1229         e->op_mid = mid;
1230         e->op_type = DEFERRED_OPEN_ENTRY;
1231         e->time.tv_sec = request_time.tv_sec;
1232         e->time.tv_usec = request_time.tv_usec;
1233         e->id = id;
1234         e->uid = (uint32)-1;
1235         e->flags = 0;
1236 }
1237
1238 static void add_share_mode_entry(struct share_mode_lock *lck,
1239                                  const struct share_mode_entry *entry)
1240 {
1241         int i;
1242
1243         for (i=0; i<lck->num_share_modes; i++) {
1244                 struct share_mode_entry *e = &lck->share_modes[i];
1245                 if (is_unused_share_mode_entry(e)) {
1246                         *e = *entry;
1247                         break;
1248                 }
1249         }
1250
1251         if (i == lck->num_share_modes) {
1252                 /* No unused entry found */
1253                 ADD_TO_ARRAY(lck, struct share_mode_entry, *entry,
1254                              &lck->share_modes, &lck->num_share_modes);
1255         }
1256         lck->modified = True;
1257 }
1258
1259 void set_share_mode(struct share_mode_lock *lck, files_struct *fsp,
1260                     uid_t uid, uint64_t mid, uint16 op_type)
1261 {
1262         struct share_mode_entry entry;
1263         fill_share_mode_entry(&entry, fsp, uid, mid, op_type);
1264         add_share_mode_entry(lck, &entry);
1265 }
1266
1267 void add_deferred_open(struct share_mode_lock *lck, uint64_t mid,
1268                        struct timeval request_time,
1269                        struct server_id pid, struct file_id id)
1270 {
1271         struct share_mode_entry entry;
1272         fill_deferred_open_entry(&entry, request_time, id, pid, mid);
1273         add_share_mode_entry(lck, &entry);
1274 }
1275
1276 /*******************************************************************
1277  Check if two share mode entries are identical, ignoring oplock 
1278  and mid info and desired_access. (Removed paranoia test - it's
1279  not automatically a logic error if they are identical. JRA.)
1280 ********************************************************************/
1281
1282 static bool share_modes_identical(struct share_mode_entry *e1,
1283                                   struct share_mode_entry *e2)
1284 {
1285         /* We used to check for e1->share_access == e2->share_access here
1286            as well as the other fields but 2 different DOS or FCB opens
1287            sharing the same share mode entry may validly differ in
1288            fsp->share_access field. */
1289
1290         return (procid_equal(&e1->pid, &e2->pid) &&
1291                 file_id_equal(&e1->id, &e2->id) &&
1292                 e1->share_file_id == e2->share_file_id );
1293 }
1294
1295 static bool deferred_open_identical(struct share_mode_entry *e1,
1296                                     struct share_mode_entry *e2)
1297 {
1298         return (procid_equal(&e1->pid, &e2->pid) &&
1299                 (e1->op_mid == e2->op_mid) &&
1300                 file_id_equal(&e1->id, &e2->id));
1301 }
1302
1303 static struct share_mode_entry *find_share_mode_entry(struct share_mode_lock *lck,
1304                                                       struct share_mode_entry *entry)
1305 {
1306         int i;
1307
1308         for (i=0; i<lck->num_share_modes; i++) {
1309                 struct share_mode_entry *e = &lck->share_modes[i];
1310                 if (is_valid_share_mode_entry(entry) &&
1311                     is_valid_share_mode_entry(e) &&
1312                     share_modes_identical(e, entry)) {
1313                         return e;
1314                 }
1315                 if (is_deferred_open_entry(entry) &&
1316                     is_deferred_open_entry(e) &&
1317                     deferred_open_identical(e, entry)) {
1318                         return e;
1319                 }
1320         }
1321         return NULL;
1322 }
1323
1324 /*******************************************************************
1325  Del the share mode of a file for this process. Return the number of
1326  entries left.
1327 ********************************************************************/
1328
1329 bool del_share_mode(struct share_mode_lock *lck, files_struct *fsp)
1330 {
1331         struct share_mode_entry entry, *e;
1332
1333         /* Don't care about the pid owner being correct here - just a search. */
1334         fill_share_mode_entry(&entry, fsp, (uid_t)-1, 0, NO_OPLOCK);
1335
1336         e = find_share_mode_entry(lck, &entry);
1337         if (e == NULL) {
1338                 return False;
1339         }
1340
1341         e->op_type = UNUSED_SHARE_MODE_ENTRY;
1342         lck->modified = True;
1343         return True;
1344 }
1345
1346 void del_deferred_open_entry(struct share_mode_lock *lck, uint64_t mid,
1347                              struct server_id pid)
1348 {
1349         struct share_mode_entry entry, *e;
1350
1351         fill_deferred_open_entry(&entry, timeval_zero(),
1352                                  lck->id, pid, mid);
1353
1354         e = find_share_mode_entry(lck, &entry);
1355         if (e == NULL) {
1356                 return;
1357         }
1358
1359         e->op_type = UNUSED_SHARE_MODE_ENTRY;
1360         lck->modified = True;
1361 }
1362
1363 /*******************************************************************
1364  Remove an oplock mid and mode entry from a share mode.
1365 ********************************************************************/
1366
1367 bool remove_share_oplock(struct share_mode_lock *lck, files_struct *fsp)
1368 {
1369         struct share_mode_entry entry, *e;
1370
1371         /* Don't care about the pid owner being correct here - just a search. */
1372         fill_share_mode_entry(&entry, fsp, (uid_t)-1, 0, NO_OPLOCK);
1373
1374         e = find_share_mode_entry(lck, &entry);
1375         if (e == NULL) {
1376                 return False;
1377         }
1378
1379         if (EXCLUSIVE_OPLOCK_TYPE(fsp->oplock_type)) {
1380                 /*
1381                  * Going from exclusive or batch,
1382                  * we always go through FAKE_LEVEL_II
1383                  * first.
1384                  */
1385                 e->op_type = FAKE_LEVEL_II_OPLOCK;
1386         } else {
1387                 e->op_type = NO_OPLOCK;
1388         }
1389         lck->modified = True;
1390         return True;
1391 }
1392
1393 /*******************************************************************
1394  Downgrade a oplock type from exclusive to level II.
1395 ********************************************************************/
1396
1397 bool downgrade_share_oplock(struct share_mode_lock *lck, files_struct *fsp)
1398 {
1399         struct share_mode_entry entry, *e;
1400
1401         /* Don't care about the pid owner being correct here - just a search. */
1402         fill_share_mode_entry(&entry, fsp, (uid_t)-1, 0, NO_OPLOCK);
1403
1404         e = find_share_mode_entry(lck, &entry);
1405         if (e == NULL) {
1406                 return False;
1407         }
1408
1409         e->op_type = LEVEL_II_OPLOCK;
1410         lck->modified = True;
1411         return True;
1412 }
1413
1414 /****************************************************************************
1415  Check if setting delete on close is allowed on this fsp.
1416 ****************************************************************************/
1417
1418 NTSTATUS can_set_delete_on_close(files_struct *fsp, uint32 dosmode)
1419 {
1420         /*
1421          * Only allow delete on close for writable files.
1422          */
1423
1424         if ((dosmode & aRONLY) &&
1425             !lp_delete_readonly(SNUM(fsp->conn))) {
1426                 DEBUG(10,("can_set_delete_on_close: file %s delete on close "
1427                           "flag set but file attribute is readonly.\n",
1428                           fsp_str_dbg(fsp)));
1429                 return NT_STATUS_CANNOT_DELETE;
1430         }
1431
1432         /*
1433          * Only allow delete on close for writable shares.
1434          */
1435
1436         if (!CAN_WRITE(fsp->conn)) {
1437                 DEBUG(10,("can_set_delete_on_close: file %s delete on "
1438                           "close flag set but write access denied on share.\n",
1439                           fsp_str_dbg(fsp)));
1440                 return NT_STATUS_ACCESS_DENIED;
1441         }
1442
1443         /*
1444          * Only allow delete on close for files/directories opened with delete
1445          * intent.
1446          */
1447
1448         if (!(fsp->access_mask & DELETE_ACCESS)) {
1449                 DEBUG(10,("can_set_delete_on_close: file %s delete on "
1450                           "close flag set but delete access denied.\n",
1451                           fsp_str_dbg(fsp)));
1452                 return NT_STATUS_ACCESS_DENIED;
1453         }
1454
1455         /* Don't allow delete on close for non-empty directories. */
1456         if (fsp->is_directory) {
1457                 SMB_ASSERT(!is_ntfs_stream_smb_fname(fsp->fsp_name));
1458                 return can_delete_directory(fsp->conn,
1459                                             fsp->fsp_name->base_name);
1460         }
1461
1462         return NT_STATUS_OK;
1463 }
1464
1465 /*************************************************************************
1466  Return a talloced copy of a struct security_unix_token. NULL on fail.
1467  (Should this be in locking.c.... ?).
1468 *************************************************************************/
1469
1470 static struct security_unix_token *copy_unix_token(TALLOC_CTX *ctx, const struct security_unix_token *tok)
1471 {
1472         struct security_unix_token *cpy;
1473
1474         cpy = TALLOC_P(ctx, struct security_unix_token);
1475         if (!cpy) {
1476                 return NULL;
1477         }
1478
1479         cpy->uid = tok->uid;
1480         cpy->gid = tok->gid;
1481         cpy->ngroups = tok->ngroups;
1482         if (tok->ngroups) {
1483                 /* Make this a talloc child of cpy. */
1484                 cpy->groups = TALLOC_ARRAY(cpy, gid_t, tok->ngroups);
1485                 if (!cpy->groups) {
1486                         return NULL;
1487                 }
1488                 memcpy(cpy->groups, tok->groups, tok->ngroups * sizeof(gid_t));
1489         }
1490         return cpy;
1491 }
1492
1493 /****************************************************************************
1494  Adds a delete on close token.
1495 ****************************************************************************/
1496
1497 static bool add_delete_on_close_token(struct share_mode_lock *lck,
1498                         uint32_t name_hash,
1499                         const struct security_unix_token *tok)
1500 {
1501         struct delete_token_list *dtl;
1502
1503         dtl = TALLOC_ZERO_P(lck, struct delete_token_list);
1504         if (dtl == NULL) {
1505                 return false;
1506         }
1507
1508         dtl->name_hash = name_hash;
1509         dtl->delete_token = copy_unix_token(lck, tok);
1510         if (dtl->delete_token == NULL) {
1511                 TALLOC_FREE(dtl);
1512                 return false;
1513         }
1514         DLIST_ADD(lck->delete_tokens, dtl);
1515         lck->modified = true;
1516         return true;
1517 }
1518
1519 /****************************************************************************
1520  Sets the delete on close flag over all share modes on this file.
1521  Modify the share mode entry for all files open
1522  on this device and inode to tell other smbds we have
1523  changed the delete on close flag. This will be noticed
1524  in the close code, the last closer will delete the file
1525  if flag is set.
1526  This makes a copy of any struct security_unix_token into the
1527  lck entry. This function is used when the lock is already granted.
1528 ****************************************************************************/
1529
1530 void set_delete_on_close_lck(files_struct *fsp,
1531                         struct share_mode_lock *lck,
1532                         bool delete_on_close,
1533                         const struct security_unix_token *tok)
1534 {
1535         struct delete_token_list *dtl;
1536         bool ret;
1537
1538         if (delete_on_close) {
1539                 SMB_ASSERT(tok != NULL);
1540         } else {
1541                 SMB_ASSERT(tok == NULL);
1542         }
1543
1544         for (dtl = lck->delete_tokens; dtl; dtl = dtl->next) {
1545                 if (dtl->name_hash == fsp->name_hash) {
1546                         lck->modified = true;
1547                         if (delete_on_close == false) {
1548                                 /* Delete this entry. */
1549                                 DLIST_REMOVE(lck->delete_tokens, dtl);
1550                                 TALLOC_FREE(dtl);
1551                                 return;
1552                         }
1553                         /* Replace this token with the
1554                            given tok. */
1555                         TALLOC_FREE(dtl->delete_token);
1556                         dtl->delete_token = copy_unix_token(dtl, tok);
1557                         SMB_ASSERT(dtl->delete_token != NULL);
1558                 }
1559         }
1560
1561         if (!delete_on_close) {
1562                 /* Nothing to delete - not found. */
1563                 return;
1564         }
1565
1566         ret = add_delete_on_close_token(lck, fsp->name_hash, tok);
1567         SMB_ASSERT(ret);
1568 }
1569
1570 bool set_delete_on_close(files_struct *fsp, bool delete_on_close, const struct security_unix_token *tok)
1571 {
1572         struct share_mode_lock *lck;
1573         
1574         DEBUG(10,("set_delete_on_close: %s delete on close flag for "
1575                   "fnum = %d, file %s\n",
1576                   delete_on_close ? "Adding" : "Removing", fsp->fnum,
1577                   fsp_str_dbg(fsp)));
1578
1579         lck = get_share_mode_lock(talloc_tos(), fsp->file_id, NULL, NULL,
1580                                   NULL);
1581         if (lck == NULL) {
1582                 return False;
1583         }
1584
1585         set_delete_on_close_lck(fsp, lck, delete_on_close,
1586                         delete_on_close ? tok : NULL);
1587
1588         if (fsp->is_directory) {
1589                 SMB_ASSERT(!is_ntfs_stream_smb_fname(fsp->fsp_name));
1590                 send_stat_cache_delete_message(fsp->conn->sconn->msg_ctx,
1591                                                fsp->fsp_name->base_name);
1592         }
1593
1594         TALLOC_FREE(lck);
1595
1596         fsp->delete_on_close = delete_on_close;
1597
1598         return True;
1599 }
1600
1601 const struct security_unix_token *get_delete_on_close_token(struct share_mode_lock *lck, uint32_t name_hash)
1602 {
1603         struct delete_token_list *dtl;
1604
1605         DEBUG(10,("get_delete_on_close_token: name_hash = 0x%x\n",
1606                         (unsigned int)name_hash ));
1607
1608         for (dtl = lck->delete_tokens; dtl; dtl = dtl->next) {
1609                 DEBUG(10,("get_delete_on_close_token: dtl->name_hash = 0x%x\n",
1610                                 (unsigned int)dtl->name_hash ));
1611                 if (dtl->name_hash == name_hash) {
1612                         return dtl->delete_token;
1613                 }
1614         }
1615         return NULL;
1616 }
1617
1618 bool is_delete_on_close_set(struct share_mode_lock *lck, uint32_t name_hash)
1619 {
1620         return (get_delete_on_close_token(lck, name_hash) != NULL);
1621 }
1622
1623 bool set_sticky_write_time(struct file_id fileid, struct timespec write_time)
1624 {
1625         struct share_mode_lock *lck;
1626
1627         DEBUG(5,("set_sticky_write_time: %s id=%s\n",
1628                  timestring(talloc_tos(),
1629                             convert_timespec_to_time_t(write_time)),
1630                  file_id_string_tos(&fileid)));
1631
1632         lck = get_share_mode_lock(NULL, fileid, NULL, NULL, NULL);
1633         if (lck == NULL) {
1634                 return False;
1635         }
1636
1637         if (timespec_compare(&lck->changed_write_time, &write_time) != 0) {
1638                 lck->modified = True;
1639                 lck->changed_write_time = write_time;
1640         }
1641
1642         TALLOC_FREE(lck);
1643         return True;
1644 }
1645
1646 bool set_write_time(struct file_id fileid, struct timespec write_time)
1647 {
1648         struct share_mode_lock *lck;
1649
1650         DEBUG(5,("set_write_time: %s id=%s\n",
1651                  timestring(talloc_tos(),
1652                             convert_timespec_to_time_t(write_time)),
1653                  file_id_string_tos(&fileid)));
1654
1655         lck = get_share_mode_lock(NULL, fileid, NULL, NULL, NULL);
1656         if (lck == NULL) {
1657                 return False;
1658         }
1659
1660         if (timespec_compare(&lck->old_write_time, &write_time) != 0) {
1661                 lck->modified = True;
1662                 lck->old_write_time = write_time;
1663         }
1664
1665         TALLOC_FREE(lck);
1666         return True;
1667 }
1668
1669
1670 struct forall_state {
1671         void (*fn)(const struct share_mode_entry *entry,
1672                    const char *sharepath,
1673                    const char *fname,
1674                    void *private_data);
1675         void *private_data;
1676 };
1677
1678 static int traverse_fn(struct db_record *rec, void *_state)
1679 {
1680         struct forall_state *state = (struct forall_state *)_state;
1681         struct locking_data *data;
1682         struct share_mode_entry *shares;
1683         const char *sharepath;
1684         const char *fname;
1685         const char *del_tokens;
1686         uint32_t total_del_token_size = 0;
1687         int i;
1688
1689         /* Ensure this is a locking_key record. */
1690         if (rec->key.dsize != sizeof(struct file_id))
1691                 return 0;
1692
1693         data = (struct locking_data *)rec->value.dptr;
1694         shares = (struct share_mode_entry *)(rec->value.dptr + sizeof(*data));
1695         del_tokens = (const char *)rec->value.dptr + sizeof(*data) +
1696                 data->u.s.num_share_mode_entries*sizeof(*shares);
1697
1698         for (i = 0; i < data->u.s.num_delete_token_entries; i++) {
1699                 uint32_t del_token_size;
1700                 memcpy(&del_token_size, del_tokens, sizeof(uint32_t));
1701                 total_del_token_size += del_token_size;
1702                 del_tokens += del_token_size;
1703         }
1704
1705         sharepath = (const char *)rec->value.dptr + sizeof(*data) +
1706                 data->u.s.num_share_mode_entries*sizeof(*shares) +
1707                 total_del_token_size;
1708         fname = (const char *)rec->value.dptr + sizeof(*data) +
1709                 data->u.s.num_share_mode_entries*sizeof(*shares) +
1710                 total_del_token_size +
1711                 strlen(sharepath) + 1;
1712
1713         for (i=0;i<data->u.s.num_share_mode_entries;i++) {
1714                 state->fn(&shares[i], sharepath, fname,
1715                           state->private_data);
1716         }
1717         return 0;
1718 }
1719
1720 /*******************************************************************
1721  Call the specified function on each entry under management by the
1722  share mode system.
1723 ********************************************************************/
1724
1725 int share_mode_forall(void (*fn)(const struct share_mode_entry *, const char *,
1726                                  const char *, void *),
1727                       void *private_data)
1728 {
1729         struct forall_state state;
1730
1731         if (lock_db == NULL)
1732                 return 0;
1733
1734         state.fn = fn;
1735         state.private_data = private_data;
1736
1737         return lock_db->traverse_read(lock_db, traverse_fn, (void *)&state);
1738 }