r21723: Make use of the per-hashchain "freelists"
[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 2 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, write to the Free Software
20    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
21
22    Revision History:
23
24    12 aug 96: Erik.Devriendt@te6.siemens.be
25    added support for shared memory implementation of share mode locking
26
27    May 1997. Jeremy Allison (jallison@whistle.com). Modified share mode
28    locking to deal with multiple share modes per open file.
29
30    September 1997. Jeremy Allison (jallison@whistle.com). Added oplock
31    support.
32
33    rewrtten completely to use new tdb code. Tridge, Dec '99
34
35    Added POSIX locking support. Jeremy Allison (jeremy@valinux.com), Apr. 2000.
36    Added Unix Extensions POSIX locking support. Jeremy Allison Mar 2006.
37 */
38
39 #include "includes.h"
40
41 #undef DBGC_CLASS
42 #define DBGC_CLASS DBGC_LOCKING
43
44 /* the locking database handle */
45 static TDB_CONTEXT *tdb;
46
47 /****************************************************************************
48  Debugging aids :-).
49 ****************************************************************************/
50
51 const char *lock_type_name(enum brl_type lock_type)
52 {
53         switch (lock_type) {
54                 case READ_LOCK:
55                         return "READ";
56                 case WRITE_LOCK:
57                         return "WRITE";
58                 case PENDING_READ_LOCK:
59                         return "PENDING_READ";
60                 case PENDING_WRITE_LOCK:
61                         return "PENDING_WRITE";
62                 default:
63                         return "other";
64         }
65 }
66
67 const char *lock_flav_name(enum brl_flavour lock_flav)
68 {
69         return (lock_flav == WINDOWS_LOCK) ? "WINDOWS_LOCK" : "POSIX_LOCK";
70 }
71
72 /****************************************************************************
73  Utility function called to see if a file region is locked.
74  Called in the read/write codepath.
75 ****************************************************************************/
76
77 BOOL is_locked(files_struct *fsp,
78                 uint32 smbpid,
79                 SMB_BIG_UINT count,
80                 SMB_BIG_UINT offset, 
81                 enum brl_type lock_type)
82 {
83         int strict_locking = lp_strict_locking(fsp->conn->params);
84         enum brl_flavour lock_flav = lp_posix_cifsu_locktype(fsp);
85         BOOL ret = True;
86         
87         if (count == 0) {
88                 return False;
89         }
90
91         if (!lp_locking(fsp->conn->params) || !strict_locking) {
92                 return False;
93         }
94
95         if (strict_locking == Auto) {
96                 if  (EXCLUSIVE_OPLOCK_TYPE(fsp->oplock_type) && (lock_type == READ_LOCK || lock_type == WRITE_LOCK)) {
97                         DEBUG(10,("is_locked: optimisation - exclusive oplock on file %s\n", fsp->fsp_name ));
98                         ret = False;
99                 } else if ((fsp->oplock_type == LEVEL_II_OPLOCK) &&
100                            (lock_type == READ_LOCK)) {
101                         DEBUG(10,("is_locked: optimisation - level II oplock on file %s\n", fsp->fsp_name ));
102                         ret = False;
103                 } else {
104                         struct byte_range_lock *br_lck = brl_get_locks_readonly(NULL, fsp);
105                         if (!br_lck) {
106                                 return False;
107                         }
108                         ret = !brl_locktest(br_lck,
109                                         smbpid,
110                                         procid_self(),
111                                         offset,
112                                         count,
113                                         lock_type,
114                                         lock_flav);
115                         TALLOC_FREE(br_lck);
116                 }
117         } else {
118                 struct byte_range_lock *br_lck = brl_get_locks_readonly(NULL, fsp);
119                 if (!br_lck) {
120                         return False;
121                 }
122                 ret = !brl_locktest(br_lck,
123                                 smbpid,
124                                 procid_self(),
125                                 offset,
126                                 count,
127                                 lock_type,
128                                 lock_flav);
129                 TALLOC_FREE(br_lck);
130         }
131
132         DEBUG(10,("is_locked: flavour = %s brl start=%.0f len=%.0f %s for fnum %d file %s\n",
133                         lock_flav_name(lock_flav),
134                         (double)offset, (double)count, ret ? "locked" : "unlocked",
135                         fsp->fnum, fsp->fsp_name ));
136
137         return ret;
138 }
139
140 /****************************************************************************
141  Find out if a lock could be granted - return who is blocking us if we can't.
142 ****************************************************************************/
143
144 NTSTATUS query_lock(files_struct *fsp,
145                         uint32 *psmbpid,
146                         SMB_BIG_UINT *pcount,
147                         SMB_BIG_UINT *poffset,
148                         enum brl_type *plock_type,
149                         enum brl_flavour lock_flav)
150 {
151         struct byte_range_lock *br_lck = NULL;
152         NTSTATUS status = NT_STATUS_LOCK_NOT_GRANTED;
153
154         if (!fsp->can_lock) {
155                 return fsp->is_directory ? NT_STATUS_INVALID_DEVICE_REQUEST : NT_STATUS_INVALID_HANDLE;
156         }
157
158         if (!lp_locking(fsp->conn->params)) {
159                 return NT_STATUS_OK;
160         }
161
162         br_lck = brl_get_locks_readonly(NULL, fsp);
163         if (!br_lck) {
164                 return NT_STATUS_NO_MEMORY;
165         }
166
167         status = brl_lockquery(br_lck,
168                         psmbpid,
169                         procid_self(),
170                         poffset,
171                         pcount,
172                         plock_type,
173                         lock_flav);
174
175         TALLOC_FREE(br_lck);
176         return status;
177 }
178
179 /****************************************************************************
180  Utility function called by locking requests.
181 ****************************************************************************/
182
183 struct byte_range_lock *do_lock(files_struct *fsp,
184                         uint32 lock_pid,
185                         SMB_BIG_UINT count,
186                         SMB_BIG_UINT offset,
187                         enum brl_type lock_type,
188                         enum brl_flavour lock_flav,
189                         BOOL blocking_lock,
190                         NTSTATUS *perr)
191 {
192         struct byte_range_lock *br_lck = NULL;
193
194         if (!fsp->can_lock) {
195                 *perr = fsp->is_directory ? NT_STATUS_INVALID_DEVICE_REQUEST : NT_STATUS_INVALID_HANDLE;
196                 return NULL;
197         }
198
199         if (!lp_locking(fsp->conn->params)) {
200                 *perr = NT_STATUS_OK;
201                 return NULL;
202         }
203
204         /* NOTE! 0 byte long ranges ARE allowed and should be stored  */
205
206         DEBUG(10,("do_lock: lock flavour %s lock type %s start=%.0f len=%.0f requested for fnum %d file %s\n",
207                 lock_flav_name(lock_flav), lock_type_name(lock_type),
208                 (double)offset, (double)count, fsp->fnum, fsp->fsp_name ));
209
210         br_lck = brl_get_locks(NULL, fsp);
211         if (!br_lck) {
212                 *perr = NT_STATUS_NO_MEMORY;
213                 return NULL;
214         }
215
216         *perr = brl_lock(br_lck,
217                         lock_pid,
218                         procid_self(),
219                         offset,
220                         count, 
221                         lock_type,
222                         lock_flav,
223                         blocking_lock);
224
225         return br_lck;
226 }
227
228 /****************************************************************************
229  Utility function called by unlocking requests.
230 ****************************************************************************/
231
232 NTSTATUS do_unlock(files_struct *fsp,
233                         uint32 lock_pid,
234                         SMB_BIG_UINT count,
235                         SMB_BIG_UINT offset,
236                         enum brl_flavour lock_flav)
237 {
238         BOOL ok = False;
239         struct byte_range_lock *br_lck = NULL;
240         
241         if (!fsp->can_lock) {
242                 return fsp->is_directory ? NT_STATUS_INVALID_DEVICE_REQUEST : NT_STATUS_INVALID_HANDLE;
243         }
244         
245         if (!lp_locking(fsp->conn->params)) {
246                 return NT_STATUS_OK;
247         }
248         
249         DEBUG(10,("do_unlock: unlock start=%.0f len=%.0f requested for fnum %d file %s\n",
250                   (double)offset, (double)count, fsp->fnum, fsp->fsp_name ));
251
252         br_lck = brl_get_locks(NULL, fsp);
253         if (!br_lck) {
254                 return NT_STATUS_NO_MEMORY;
255         }
256
257         ok = brl_unlock(br_lck,
258                         lock_pid,
259                         procid_self(),
260                         offset,
261                         count,
262                         lock_flav);
263    
264         TALLOC_FREE(br_lck);
265
266         if (!ok) {
267                 DEBUG(10,("do_unlock: returning ERRlock.\n" ));
268                 return NT_STATUS_RANGE_NOT_LOCKED;
269         }
270
271         return NT_STATUS_OK;
272 }
273
274 /****************************************************************************
275  Cancel any pending blocked locks.
276 ****************************************************************************/
277
278 NTSTATUS do_lock_cancel(files_struct *fsp,
279                         uint32 lock_pid,
280                         SMB_BIG_UINT count,
281                         SMB_BIG_UINT offset,
282                         enum brl_flavour lock_flav)
283 {
284         BOOL ok = False;
285         struct byte_range_lock *br_lck = NULL;
286         
287         if (!fsp->can_lock) {
288                 return fsp->is_directory ?
289                         NT_STATUS_INVALID_DEVICE_REQUEST : NT_STATUS_INVALID_HANDLE;
290         }
291         
292         if (!lp_locking(fsp->conn->params)) {
293                 return NT_STATUS_DOS(ERRDOS, ERRcancelviolation);
294         }
295
296         DEBUG(10,("do_lock_cancel: cancel start=%.0f len=%.0f requested for fnum %d file %s\n",
297                   (double)offset, (double)count, fsp->fnum, fsp->fsp_name ));
298
299         br_lck = brl_get_locks(NULL, fsp);
300         if (!br_lck) {
301                 return NT_STATUS_NO_MEMORY;
302         }
303
304         ok = brl_lock_cancel(br_lck,
305                         lock_pid,
306                         procid_self(),
307                         offset,
308                         count,
309                         lock_flav);
310    
311         TALLOC_FREE(br_lck);
312
313         if (!ok) {
314                 DEBUG(10,("do_lock_cancel: returning ERRcancelviolation.\n" ));
315                 return NT_STATUS_DOS(ERRDOS, ERRcancelviolation);
316         }
317
318         return NT_STATUS_OK;
319 }
320
321 /****************************************************************************
322  Remove any locks on this fd. Called from file_close().
323 ****************************************************************************/
324
325 void locking_close_file(files_struct *fsp)
326 {
327         struct byte_range_lock *br_lck;
328
329         if (!lp_locking(fsp->conn->params)) {
330                 return;
331         }
332
333         br_lck = brl_get_locks(NULL,fsp);
334
335         if (br_lck) {
336                 cancel_pending_lock_requests_by_fid(fsp, br_lck);
337                 brl_close_fnum(br_lck);
338                 TALLOC_FREE(br_lck);
339         }
340 }
341
342 /****************************************************************************
343  Initialise the locking functions.
344 ****************************************************************************/
345
346 static int open_read_only;
347
348 BOOL locking_init(int read_only)
349 {
350         brl_init(read_only);
351
352         if (tdb)
353                 return True;
354
355         tdb = tdb_open_log(lock_path("locking.tdb"), 
356                         lp_open_files_db_hash_size(),
357                         TDB_DEFAULT|(read_only?0x0:TDB_CLEAR_IF_FIRST), 
358                         read_only?O_RDONLY:O_RDWR|O_CREAT,
359                         0644);
360
361         if (!tdb) {
362                 DEBUG(0,("ERROR: Failed to initialise locking database\n"));
363                 return False;
364         }
365
366         /* Activate the per-hashchain freelist */
367         tdb_set_max_dead(tdb, 5);
368
369         if (!posix_locking_init(read_only))
370                 return False;
371
372         open_read_only = read_only;
373
374         return True;
375 }
376
377 /*******************************************************************
378  Deinitialize the share_mode management.
379 ******************************************************************/
380
381 BOOL locking_end(void)
382 {
383         BOOL ret = True;
384
385         brl_shutdown(open_read_only);
386         if (tdb) {
387                 if (tdb_close(tdb) != 0)
388                         ret = False;
389         }
390
391         return ret;
392 }
393
394 /*******************************************************************
395  Form a static locking key for a dev/inode pair.
396 ******************************************************************/
397
398 /* key and data records in the tdb locking database */
399 struct locking_key {
400         SMB_DEV_T dev;
401         SMB_INO_T ino;
402 };
403
404 /*******************************************************************
405  Form a static locking key for a dev/inode pair.
406 ******************************************************************/
407
408 static TDB_DATA locking_key(SMB_DEV_T dev, SMB_INO_T inode)
409 {
410         static struct locking_key key;
411         TDB_DATA kbuf;
412
413         memset(&key, '\0', sizeof(key));
414         key.dev = dev;
415         key.ino = inode;
416         kbuf.dptr = (char *)&key;
417         kbuf.dsize = sizeof(key);
418         return kbuf;
419 }
420
421 /*******************************************************************
422  Print out a share mode.
423 ********************************************************************/
424
425 char *share_mode_str(int num, struct share_mode_entry *e)
426 {
427         static pstring share_str;
428
429         slprintf(share_str, sizeof(share_str)-1, "share_mode_entry[%d]: %s "
430                  "pid = %s, share_access = 0x%x, private_options = 0x%x, "
431                  "access_mask = 0x%x, mid = 0x%x, type= 0x%x, file_id = %lu, "
432                  "uid = %u, flags = %u, dev = 0x%x, inode = %.0f",
433                  num,
434                  e->op_type == UNUSED_SHARE_MODE_ENTRY ? "UNUSED" : "",
435                  procid_str_static(&e->pid),
436                  e->share_access, e->private_options,
437                  e->access_mask, e->op_mid, e->op_type, e->share_file_id,
438                  (unsigned int)e->uid, (unsigned int)e->flags,
439                  (unsigned int)e->dev, (double)e->inode );
440
441         return share_str;
442 }
443
444 /*******************************************************************
445  Print out a share mode table.
446 ********************************************************************/
447
448 static void print_share_mode_table(struct locking_data *data)
449 {
450         int num_share_modes = data->u.s.num_share_mode_entries;
451         struct share_mode_entry *shares =
452                 (struct share_mode_entry *)(data + 1);
453         int i;
454
455         for (i = 0; i < num_share_modes; i++) {
456                 struct share_mode_entry entry;
457
458                 memcpy(&entry, &shares[i], sizeof(struct share_mode_entry));
459                 DEBUG(10,("print_share_mode_table: %s\n",
460                           share_mode_str(i, &entry)));
461         }
462 }
463
464 /*******************************************************************
465  Get all share mode entries for a dev/inode pair.
466 ********************************************************************/
467
468 static BOOL parse_share_modes(TDB_DATA dbuf, struct share_mode_lock *lck)
469 {
470         struct locking_data *data;
471         int i;
472
473         if (dbuf.dsize < sizeof(struct locking_data)) {
474                 smb_panic("PANIC: parse_share_modes: buffer too short.\n");
475         }
476
477         data = (struct locking_data *)dbuf.dptr;
478
479         lck->delete_on_close = data->u.s.delete_on_close;
480         lck->num_share_modes = data->u.s.num_share_mode_entries;
481
482         DEBUG(10, ("parse_share_modes: delete_on_close: %d, "
483                    "num_share_modes: %d\n",
484                 lck->delete_on_close,
485                 lck->num_share_modes));
486
487         if ((lck->num_share_modes < 0) || (lck->num_share_modes > 1000000)) {
488                 DEBUG(0, ("invalid number of share modes: %d\n",
489                           lck->num_share_modes));
490                 smb_panic("PANIC: invalid number of share modes");
491         }
492
493         lck->share_modes = NULL;
494         
495         if (lck->num_share_modes != 0) {
496
497                 if (dbuf.dsize < (sizeof(struct locking_data) +
498                                   (lck->num_share_modes *
499                                    sizeof(struct share_mode_entry)))) {
500                         smb_panic("PANIC: parse_share_modes: buffer too short.\n");
501                 }
502                                   
503                 lck->share_modes = (struct share_mode_entry *)
504                         talloc_memdup(lck, dbuf.dptr+sizeof(*data),
505                                       lck->num_share_modes *
506                                       sizeof(struct share_mode_entry));
507
508                 if (lck->share_modes == NULL) {
509                         smb_panic("talloc failed\n");
510                 }
511         }
512
513         /* Get any delete token. */
514         if (data->u.s.delete_token_size) {
515                 char *p = dbuf.dptr + sizeof(*data) +
516                                 (lck->num_share_modes *
517                                 sizeof(struct share_mode_entry));
518
519                 if ((data->u.s.delete_token_size < sizeof(uid_t) + sizeof(gid_t)) ||
520                                 ((data->u.s.delete_token_size - sizeof(uid_t)) % sizeof(gid_t)) != 0) {
521                         DEBUG(0, ("parse_share_modes: invalid token size %d\n",
522                                 data->u.s.delete_token_size));
523                         smb_panic("parse_share_modes: invalid token size\n");
524                 }
525
526                 lck->delete_token = TALLOC_P(lck, UNIX_USER_TOKEN);
527                 if (!lck->delete_token) {
528                         smb_panic("talloc failed\n");
529                 }
530
531                 /* Copy out the uid and gid. */
532                 memcpy(&lck->delete_token->uid, p, sizeof(uid_t));
533                 p += sizeof(uid_t);
534                 memcpy(&lck->delete_token->gid, p, sizeof(gid_t));
535                 p += sizeof(gid_t);
536
537                 /* Any supplementary groups ? */
538                 lck->delete_token->ngroups = (data->u.s.delete_token_size > (sizeof(uid_t) + sizeof(gid_t))) ?
539                                         ((data->u.s.delete_token_size -
540                                                 (sizeof(uid_t) + sizeof(gid_t)))/sizeof(gid_t)) : 0;
541
542                 if (lck->delete_token->ngroups) {
543                         /* Make this a talloc child of lck->delete_token. */
544                         lck->delete_token->groups = TALLOC_ARRAY(lck->delete_token, gid_t,
545                                                         lck->delete_token->ngroups);
546                         if (!lck->delete_token) {
547                                 smb_panic("talloc failed\n");
548                         }
549
550                         for (i = 0; i < lck->delete_token->ngroups; i++) {
551                                 memcpy(&lck->delete_token->groups[i], p, sizeof(gid_t));
552                                 p += sizeof(gid_t);
553                         }
554                 }
555
556         } else {
557                 lck->delete_token = NULL;
558         }
559
560         /* Save off the associated service path and filename. */
561         lck->servicepath = talloc_strdup(lck, dbuf.dptr + sizeof(*data) +
562                                         (lck->num_share_modes *
563                                         sizeof(struct share_mode_entry)) +
564                                         data->u.s.delete_token_size );
565         if (lck->servicepath == NULL) {
566                 smb_panic("talloc_strdup failed\n");
567         }
568
569         lck->filename = talloc_strdup(lck, dbuf.dptr + sizeof(*data) +
570                                         (lck->num_share_modes *
571                                         sizeof(struct share_mode_entry)) +
572                                         data->u.s.delete_token_size +
573                                         strlen(lck->servicepath) + 1 );
574         if (lck->filename == NULL) {
575                 smb_panic("talloc_strdup failed\n");
576         }
577
578         /*
579          * Ensure that each entry has a real process attached.
580          */
581
582         for (i = 0; i < lck->num_share_modes; i++) {
583                 struct share_mode_entry *entry_p = &lck->share_modes[i];
584                 DEBUG(10,("parse_share_modes: %s\n",
585                           share_mode_str(i, entry_p) ));
586                 if (!process_exists(entry_p->pid)) {
587                         DEBUG(10,("parse_share_modes: deleted %s\n",
588                                   share_mode_str(i, entry_p) ));
589                         entry_p->op_type = UNUSED_SHARE_MODE_ENTRY;
590                         lck->modified = True;
591                 }
592         }
593
594         return True;
595 }
596
597 static TDB_DATA unparse_share_modes(struct share_mode_lock *lck)
598 {
599         TDB_DATA result;
600         int num_valid = 0;
601         int i;
602         struct locking_data *data;
603         ssize_t offset;
604         ssize_t sp_len;
605         uint32 delete_token_size;
606
607         result.dptr = NULL;
608         result.dsize = 0;
609
610         for (i=0; i<lck->num_share_modes; i++) {
611                 if (!is_unused_share_mode_entry(&lck->share_modes[i])) {
612                         num_valid += 1;
613                 }
614         }
615
616         if (num_valid == 0) {
617                 return result;
618         }
619
620         sp_len = strlen(lck->servicepath);
621         delete_token_size = (lck->delete_token ?
622                         (sizeof(uid_t) + sizeof(gid_t) + (lck->delete_token->ngroups*sizeof(gid_t))) : 0);
623
624         result.dsize = sizeof(*data) +
625                 lck->num_share_modes * sizeof(struct share_mode_entry) +
626                 delete_token_size +
627                 sp_len + 1 +
628                 strlen(lck->filename) + 1;
629         result.dptr = TALLOC_ARRAY(lck, char, result.dsize);
630
631         if (result.dptr == NULL) {
632                 smb_panic("talloc failed\n");
633         }
634
635         data = (struct locking_data *)result.dptr;
636         ZERO_STRUCTP(data);
637         data->u.s.num_share_mode_entries = lck->num_share_modes;
638         data->u.s.delete_on_close = lck->delete_on_close;
639         data->u.s.delete_token_size = delete_token_size;
640         DEBUG(10, ("unparse_share_modes: del: %d, tok = %u, num: %d\n",
641                 data->u.s.delete_on_close,
642                 (unsigned int)data->u.s.delete_token_size,
643                 data->u.s.num_share_mode_entries));
644         memcpy(result.dptr + sizeof(*data), lck->share_modes,
645                sizeof(struct share_mode_entry)*lck->num_share_modes);
646         offset = sizeof(*data) +
647                 sizeof(struct share_mode_entry)*lck->num_share_modes;
648
649         /* Store any delete on close token. */
650         if (lck->delete_token) {
651                 char *p = result.dptr + offset;
652
653                 memcpy(p, &lck->delete_token->uid, sizeof(uid_t));
654                 p += sizeof(uid_t);
655
656                 memcpy(p, &lck->delete_token->gid, sizeof(gid_t));
657                 p += sizeof(gid_t);
658
659                 for (i = 0; i < lck->delete_token->ngroups; i++) {
660                         memcpy(p, &lck->delete_token->groups[i], sizeof(gid_t));
661                         p += sizeof(gid_t);
662                 }
663                 offset = p - result.dptr;
664         }
665
666         safe_strcpy(result.dptr + offset, lck->servicepath,
667                     result.dsize - offset - 1);
668         offset += sp_len + 1;
669         safe_strcpy(result.dptr + offset, lck->filename,
670                     result.dsize - offset - 1);
671
672         if (DEBUGLEVEL >= 10) {
673                 print_share_mode_table(data);
674         }
675
676         return result;
677 }
678
679 static int share_mode_lock_destructor(struct share_mode_lock *lck)
680 {
681         TDB_DATA key = locking_key(lck->dev, lck->ino);
682         TDB_DATA data;
683
684         if (!lck->modified) {
685                 goto done;
686         }
687
688         data = unparse_share_modes(lck);
689
690         if (data.dptr == NULL) {
691                 if (!lck->fresh) {
692                         /* There has been an entry before, delete it */
693                         if (tdb_delete(tdb, key) == -1) {
694                                 smb_panic("Could not delete share entry\n");
695                         }
696                 }
697                 goto done;
698         }
699
700         if (tdb_store(tdb, key, data, TDB_REPLACE) == -1) {
701                 smb_panic("Could not store share mode entry\n");
702         }
703
704  done:
705         tdb_chainunlock(tdb, key);
706
707         return 0;
708 }
709
710 struct share_mode_lock *get_share_mode_lock(TALLOC_CTX *mem_ctx,
711                                                 SMB_DEV_T dev, SMB_INO_T ino,
712                                                 const char *servicepath,
713                                                 const char *fname)
714 {
715         struct share_mode_lock *lck;
716         TDB_DATA key = locking_key(dev, ino);
717         TDB_DATA data;
718
719         lck = TALLOC_P(mem_ctx, struct share_mode_lock);
720         if (lck == NULL) {
721                 DEBUG(0, ("talloc failed\n"));
722                 return NULL;
723         }
724
725         /* Ensure we set every field here as the destructor must be
726            valid even if parse_share_modes fails. */
727
728         lck->servicepath = NULL;
729         lck->filename = NULL;
730         lck->dev = dev;
731         lck->ino = ino;
732         lck->num_share_modes = 0;
733         lck->share_modes = NULL;
734         lck->delete_token = NULL;
735         lck->delete_on_close = False;
736         lck->fresh = False;
737         lck->modified = False;
738
739         if (tdb_chainlock(tdb, key) != 0) {
740                 DEBUG(3, ("Could not lock share entry\n"));
741                 TALLOC_FREE(lck);
742                 return NULL;
743         }
744
745         /* We must set the destructor immediately after the chainlock
746            ensure the lock is cleaned up on any of the error return
747            paths below. */
748
749         talloc_set_destructor(lck, share_mode_lock_destructor);
750
751         data = tdb_fetch(tdb, key);
752         lck->fresh = (data.dptr == NULL);
753
754         if (lck->fresh) {
755
756                 if (fname == NULL || servicepath == NULL) {
757                         TALLOC_FREE(lck);
758                         return NULL;
759                 }
760                 lck->filename = talloc_strdup(lck, fname);
761                 lck->servicepath = talloc_strdup(lck, servicepath);
762                 if (lck->filename == NULL || lck->servicepath == NULL) {
763                         DEBUG(0, ("talloc failed\n"));
764                         TALLOC_FREE(lck);
765                         return NULL;
766                 }
767         } else {
768                 if (!parse_share_modes(data, lck)) {
769                         DEBUG(0, ("Could not parse share modes\n"));
770                         TALLOC_FREE(lck);
771                         SAFE_FREE(data.dptr);
772                         return NULL;
773                 }
774         }
775
776         SAFE_FREE(data.dptr);
777
778         return lck;
779 }
780
781 /*******************************************************************
782  Sets the service name and filename for rename.
783  At this point we emit "file renamed" messages to all
784  process id's that have this file open.
785  Based on an initial code idea from SATOH Fumiyasu <fumiya@samba.gr.jp>
786 ********************************************************************/
787
788 BOOL rename_share_filename(struct share_mode_lock *lck,
789                         const char *servicepath,
790                         const char *newname)
791 {
792         size_t sp_len;
793         size_t fn_len;
794         size_t msg_len;
795         char *frm = NULL;
796         int i;
797
798         if (!lck) {
799                 return False;
800         }
801
802         DEBUG(10, ("rename_share_filename: servicepath %s newname %s\n",
803                 servicepath, newname));
804
805         /*
806          * rename_internal_fsp() and rename_internals() add './' to
807          * head of newname if newname does not contain a '/'.
808          */
809         while (newname[0] && newname[1] && newname[0] == '.' && newname[1] == '/') {
810                 newname += 2;
811         }
812
813         lck->servicepath = talloc_strdup(lck, servicepath);
814         lck->filename = talloc_strdup(lck, newname);
815         if (lck->filename == NULL || lck->servicepath == NULL) {
816                 DEBUG(0, ("rename_share_filename: talloc failed\n"));
817                 return False;
818         }
819         lck->modified = True;
820
821         sp_len = strlen(lck->servicepath);
822         fn_len = strlen(lck->filename);
823
824         msg_len = MSG_FILE_RENAMED_MIN_SIZE + sp_len + 1 + fn_len + 1;
825
826         /* Set up the name changed message. */
827         frm = TALLOC_ARRAY(lck, char, msg_len);
828         if (!frm) {
829                 return False;
830         }
831
832         SDEV_T_VAL(frm,0,lck->dev);
833         SINO_T_VAL(frm,8,lck->ino);
834
835         DEBUG(10,("rename_share_filename: msg_len = %u\n", (unsigned int)msg_len ));
836
837         safe_strcpy(&frm[16], lck->servicepath, sp_len);
838         safe_strcpy(&frm[16 + sp_len + 1], lck->filename, fn_len);
839
840         /* Send the messages. */
841         for (i=0; i<lck->num_share_modes; i++) {
842                 struct share_mode_entry *se = &lck->share_modes[i];
843                 if (!is_valid_share_mode_entry(se)) {
844                         continue;
845                 }
846                 /* But not to ourselves... */
847                 if (procid_is_me(&se->pid)) {
848                         continue;
849                 }
850
851                 DEBUG(10,("rename_share_filename: sending rename message to pid %s "
852                         "dev %x, inode  %.0f sharepath %s newname %s\n",
853                         procid_str_static(&se->pid),
854                         (unsigned int)lck->dev, (double)lck->ino,
855                         lck->servicepath, lck->filename ));
856
857                 message_send_pid(se->pid, MSG_SMB_FILE_RENAME,
858                                 frm, msg_len, True);
859         }
860
861         return True;
862 }
863
864 static int pull_delete_on_close_flag(TDB_DATA key, TDB_DATA dbuf,
865                                      void *private_data)
866 {
867         BOOL *result = (BOOL *)private_data;
868         struct locking_data *data;
869
870         if (dbuf.dsize < sizeof(struct locking_data)) {
871                 smb_panic("PANIC: parse_share_modes: buffer too short.\n");
872         }
873
874         data = (struct locking_data *)dbuf.dptr;
875
876         *result = data->u.s.delete_on_close;
877         return 0;
878 }
879
880 BOOL get_delete_on_close_flag(SMB_DEV_T dev, SMB_INO_T inode)
881 {
882         TDB_DATA key = locking_key(dev, inode);
883         BOOL result = False;
884
885         tdb_parse_record(tdb, key, pull_delete_on_close_flag,
886                          (void *)&result);
887         return result;
888 }
889
890 BOOL is_valid_share_mode_entry(const struct share_mode_entry *e)
891 {
892         int num_props = 0;
893
894         num_props += ((e->op_type == NO_OPLOCK) ? 1 : 0);
895         num_props += (EXCLUSIVE_OPLOCK_TYPE(e->op_type) ? 1 : 0);
896         num_props += (LEVEL_II_OPLOCK_TYPE(e->op_type) ? 1 : 0);
897
898         SMB_ASSERT(num_props <= 1);
899         return (num_props != 0);
900 }
901
902 BOOL is_deferred_open_entry(const struct share_mode_entry *e)
903 {
904         return (e->op_type == DEFERRED_OPEN_ENTRY);
905 }
906
907 BOOL is_unused_share_mode_entry(const struct share_mode_entry *e)
908 {
909         return (e->op_type == UNUSED_SHARE_MODE_ENTRY);
910 }
911
912 /*******************************************************************
913  Fill a share mode entry.
914 ********************************************************************/
915
916 static void fill_share_mode_entry(struct share_mode_entry *e,
917                                   files_struct *fsp,
918                                   uid_t uid, uint16 mid, uint16 op_type)
919 {
920         ZERO_STRUCTP(e);
921         e->pid = procid_self();
922         e->share_access = fsp->share_access;
923         e->private_options = fsp->fh->private_options;
924         e->access_mask = fsp->access_mask;
925         e->op_mid = mid;
926         e->op_type = op_type;
927         e->time.tv_sec = fsp->open_time.tv_sec;
928         e->time.tv_usec = fsp->open_time.tv_usec;
929         e->dev = fsp->dev;
930         e->inode = fsp->inode;
931         e->share_file_id = fsp->fh->file_id;
932         e->uid = (uint32)uid;
933         e->flags = fsp->posix_open ? SHARE_MODE_FLAG_POSIX_OPEN : 0;
934 }
935
936 static void fill_deferred_open_entry(struct share_mode_entry *e,
937                                      const struct timeval request_time,
938                                      SMB_DEV_T dev, SMB_INO_T ino, uint16 mid)
939 {
940         ZERO_STRUCTP(e);
941         e->pid = procid_self();
942         e->op_mid = mid;
943         e->op_type = DEFERRED_OPEN_ENTRY;
944         e->time.tv_sec = request_time.tv_sec;
945         e->time.tv_usec = request_time.tv_usec;
946         e->dev = dev;
947         e->inode = ino;
948         e->uid = (uint32)-1;
949         e->flags = 0;
950 }
951
952 static void add_share_mode_entry(struct share_mode_lock *lck,
953                                  const struct share_mode_entry *entry)
954 {
955         int i;
956
957         for (i=0; i<lck->num_share_modes; i++) {
958                 struct share_mode_entry *e = &lck->share_modes[i];
959                 if (is_unused_share_mode_entry(e)) {
960                         *e = *entry;
961                         break;
962                 }
963         }
964
965         if (i == lck->num_share_modes) {
966                 /* No unused entry found */
967                 ADD_TO_ARRAY(lck, struct share_mode_entry, *entry,
968                              &lck->share_modes, &lck->num_share_modes);
969         }
970         lck->modified = True;
971 }
972
973 void set_share_mode(struct share_mode_lock *lck, files_struct *fsp,
974                         uid_t uid, uint16 mid, uint16 op_type)
975 {
976         struct share_mode_entry entry;
977         fill_share_mode_entry(&entry, fsp, uid, mid, op_type);
978         add_share_mode_entry(lck, &entry);
979 }
980
981 void add_deferred_open(struct share_mode_lock *lck, uint16 mid,
982                        struct timeval request_time,
983                        SMB_DEV_T dev, SMB_INO_T ino)
984 {
985         struct share_mode_entry entry;
986         fill_deferred_open_entry(&entry, request_time, dev, ino, mid);
987         add_share_mode_entry(lck, &entry);
988 }
989
990 /*******************************************************************
991  Check if two share mode entries are identical, ignoring oplock 
992  and mid info and desired_access. (Removed paranoia test - it's
993  not automatically a logic error if they are identical. JRA.)
994 ********************************************************************/
995
996 static BOOL share_modes_identical(struct share_mode_entry *e1,
997                                   struct share_mode_entry *e2)
998 {
999         /* We used to check for e1->share_access == e2->share_access here
1000            as well as the other fields but 2 different DOS or FCB opens
1001            sharing the same share mode entry may validly differ in
1002            fsp->share_access field. */
1003
1004         return (procid_equal(&e1->pid, &e2->pid) &&
1005                 e1->dev == e2->dev &&
1006                 e1->inode == e2->inode &&
1007                 e1->share_file_id == e2->share_file_id );
1008 }
1009
1010 static BOOL deferred_open_identical(struct share_mode_entry *e1,
1011                                     struct share_mode_entry *e2)
1012 {
1013         return (procid_equal(&e1->pid, &e2->pid) &&
1014                 (e1->op_mid == e2->op_mid) &&
1015                 (e1->dev == e2->dev) &&
1016                 (e1->inode == e2->inode));
1017 }
1018
1019 static struct share_mode_entry *find_share_mode_entry(struct share_mode_lock *lck,
1020                                                       struct share_mode_entry *entry)
1021 {
1022         int i;
1023
1024         for (i=0; i<lck->num_share_modes; i++) {
1025                 struct share_mode_entry *e = &lck->share_modes[i];
1026                 if (is_valid_share_mode_entry(entry) &&
1027                     is_valid_share_mode_entry(e) &&
1028                     share_modes_identical(e, entry)) {
1029                         return e;
1030                 }
1031                 if (is_deferred_open_entry(entry) &&
1032                     is_deferred_open_entry(e) &&
1033                     deferred_open_identical(e, entry)) {
1034                         return e;
1035                 }
1036         }
1037         return NULL;
1038 }
1039
1040 /*******************************************************************
1041  Del the share mode of a file for this process. Return the number of
1042  entries left.
1043 ********************************************************************/
1044
1045 BOOL del_share_mode(struct share_mode_lock *lck, files_struct *fsp)
1046 {
1047         struct share_mode_entry entry, *e;
1048
1049         /* Don't care about the pid owner being correct here - just a search. */
1050         fill_share_mode_entry(&entry, fsp, (uid_t)-1, 0, NO_OPLOCK);
1051
1052         e = find_share_mode_entry(lck, &entry);
1053         if (e == NULL) {
1054                 return False;
1055         }
1056
1057         e->op_type = UNUSED_SHARE_MODE_ENTRY;
1058         lck->modified = True;
1059         return True;
1060 }
1061
1062 void del_deferred_open_entry(struct share_mode_lock *lck, uint16 mid)
1063 {
1064         struct share_mode_entry entry, *e;
1065
1066         fill_deferred_open_entry(&entry, timeval_zero(),
1067                                  lck->dev, lck->ino, mid);
1068
1069         e = find_share_mode_entry(lck, &entry);
1070         if (e == NULL) {
1071                 return;
1072         }
1073
1074         e->op_type = UNUSED_SHARE_MODE_ENTRY;
1075         lck->modified = True;
1076 }
1077
1078 /*******************************************************************
1079  Remove an oplock mid and mode entry from a share mode.
1080 ********************************************************************/
1081
1082 BOOL remove_share_oplock(struct share_mode_lock *lck, files_struct *fsp)
1083 {
1084         struct share_mode_entry entry, *e;
1085
1086         /* Don't care about the pid owner being correct here - just a search. */
1087         fill_share_mode_entry(&entry, fsp, (uid_t)-1, 0, NO_OPLOCK);
1088
1089         e = find_share_mode_entry(lck, &entry);
1090         if (e == NULL) {
1091                 return False;
1092         }
1093
1094         e->op_mid = 0;
1095         e->op_type = NO_OPLOCK;
1096         lck->modified = True;
1097         return True;
1098 }
1099
1100 /*******************************************************************
1101  Downgrade a oplock type from exclusive to level II.
1102 ********************************************************************/
1103
1104 BOOL downgrade_share_oplock(struct share_mode_lock *lck, files_struct *fsp)
1105 {
1106         struct share_mode_entry entry, *e;
1107
1108         /* Don't care about the pid owner being correct here - just a search. */
1109         fill_share_mode_entry(&entry, fsp, (uid_t)-1, 0, NO_OPLOCK);
1110
1111         e = find_share_mode_entry(lck, &entry);
1112         if (e == NULL) {
1113                 return False;
1114         }
1115
1116         e->op_type = LEVEL_II_OPLOCK;
1117         lck->modified = True;
1118         return True;
1119 }
1120
1121 /****************************************************************************
1122  Deal with the internal needs of setting the delete on close flag. Note that
1123  as the tdb locking is recursive, it is safe to call this from within 
1124  open_file_ntcreate. JRA.
1125 ****************************************************************************/
1126
1127 NTSTATUS can_set_delete_on_close(files_struct *fsp, BOOL delete_on_close,
1128                                  uint32 dosmode)
1129 {
1130         if (!delete_on_close) {
1131                 return NT_STATUS_OK;
1132         }
1133
1134         /*
1135          * Only allow delete on close for writable files.
1136          */
1137
1138         if ((dosmode & aRONLY) &&
1139             !lp_delete_readonly(SNUM(fsp->conn))) {
1140                 DEBUG(10,("can_set_delete_on_close: file %s delete on close "
1141                           "flag set but file attribute is readonly.\n",
1142                           fsp->fsp_name ));
1143                 return NT_STATUS_CANNOT_DELETE;
1144         }
1145
1146         /*
1147          * Only allow delete on close for writable shares.
1148          */
1149
1150         if (!CAN_WRITE(fsp->conn)) {
1151                 DEBUG(10,("can_set_delete_on_close: file %s delete on "
1152                           "close flag set but write access denied on share.\n",
1153                           fsp->fsp_name ));
1154                 return NT_STATUS_ACCESS_DENIED;
1155         }
1156
1157         /*
1158          * Only allow delete on close for files/directories opened with delete
1159          * intent.
1160          */
1161
1162         if (!(fsp->access_mask & DELETE_ACCESS)) {
1163                 DEBUG(10,("can_set_delete_on_close: file %s delete on "
1164                           "close flag set but delete access denied.\n",
1165                           fsp->fsp_name ));
1166                 return NT_STATUS_ACCESS_DENIED;
1167         }
1168
1169         /* Don't allow delete on close for non-empty directories. */
1170         if (fsp->is_directory) {
1171                 return can_delete_directory(fsp->conn, fsp->fsp_name);
1172         }
1173
1174         return NT_STATUS_OK;
1175 }
1176
1177 /*************************************************************************
1178  Return a talloced copy of a UNIX_USER_TOKEN. NULL on fail.
1179  (Should this be in locking.c.... ?).
1180 *************************************************************************/
1181
1182 static UNIX_USER_TOKEN *copy_unix_token(TALLOC_CTX *ctx, UNIX_USER_TOKEN *tok)
1183 {
1184         UNIX_USER_TOKEN *cpy;
1185
1186         if (tok == NULL) {
1187                 return NULL;
1188         }
1189
1190         cpy = TALLOC_P(ctx, UNIX_USER_TOKEN);
1191         if (!cpy) {
1192                 return NULL;
1193         }
1194
1195         cpy->uid = tok->uid;
1196         cpy->gid = tok->gid;
1197         cpy->ngroups = tok->ngroups;
1198         if (tok->ngroups) {
1199                 /* Make this a talloc child of cpy. */
1200                 cpy->groups = TALLOC_ARRAY(cpy, gid_t, tok->ngroups);
1201                 if (!cpy->groups) {
1202                         return NULL;
1203                 }
1204                 memcpy(cpy->groups, tok->groups, tok->ngroups * sizeof(gid_t));
1205         }
1206         return cpy;
1207 }
1208
1209 /****************************************************************************
1210  Replace the delete on close token.
1211 ****************************************************************************/
1212
1213 void set_delete_on_close_token(struct share_mode_lock *lck, UNIX_USER_TOKEN *tok)
1214 {
1215         /* Ensure there's no token. */
1216         if (lck->delete_token) {
1217                 TALLOC_FREE(lck->delete_token); /* Also deletes groups... */
1218                 lck->delete_token = NULL;
1219         }
1220
1221         /* Copy the new token (can be NULL). */
1222         lck->delete_token = copy_unix_token(lck, tok);
1223         lck->modified = True;
1224 }
1225
1226 /****************************************************************************
1227  Sets the delete on close flag over all share modes on this file.
1228  Modify the share mode entry for all files open
1229  on this device and inode to tell other smbds we have
1230  changed the delete on close flag. This will be noticed
1231  in the close code, the last closer will delete the file
1232  if flag is set.
1233  This makes a copy of any UNIX_USER_TOKEN into the
1234  lck entry. This function is used when the lock is already granted.
1235 ****************************************************************************/
1236
1237 void set_delete_on_close_lck(struct share_mode_lock *lck, BOOL delete_on_close, UNIX_USER_TOKEN *tok)
1238 {
1239         if (lck->delete_on_close != delete_on_close) {
1240                 set_delete_on_close_token(lck, tok);
1241                 lck->delete_on_close = delete_on_close;
1242                 if (delete_on_close) {
1243                         SMB_ASSERT(lck->delete_token != NULL);
1244                 }
1245                 lck->modified = True;
1246         }
1247 }
1248
1249 BOOL set_delete_on_close(files_struct *fsp, BOOL delete_on_close, UNIX_USER_TOKEN *tok)
1250 {
1251         struct share_mode_lock *lck;
1252         
1253         DEBUG(10,("set_delete_on_close: %s delete on close flag for "
1254                   "fnum = %d, file %s\n",
1255                   delete_on_close ? "Adding" : "Removing", fsp->fnum,
1256                   fsp->fsp_name ));
1257
1258         if (fsp->is_stat) {
1259                 return True;
1260         }
1261
1262         lck = get_share_mode_lock(NULL, fsp->dev, fsp->inode, NULL, NULL);
1263         if (lck == NULL) {
1264                 return False;
1265         }
1266
1267         set_delete_on_close_lck(lck, delete_on_close, tok);
1268
1269         if (fsp->is_directory) {
1270                 send_stat_cache_delete_message(fsp->fsp_name);
1271         }
1272
1273         TALLOC_FREE(lck);
1274         return True;
1275 }
1276
1277 struct forall_state {
1278         void (*fn)(const struct share_mode_entry *entry,
1279                    const char *sharepath,
1280                    const char *fname,
1281                    void *private_data);
1282         void *private_data;
1283 };
1284
1285 static int traverse_fn(TDB_CONTEXT *the_tdb, TDB_DATA kbuf, TDB_DATA dbuf, 
1286                        void *_state)
1287 {
1288         struct forall_state *state = (struct forall_state *)_state;
1289         struct locking_data *data;
1290         struct share_mode_entry *shares;
1291         const char *sharepath;
1292         const char *fname;
1293         int i;
1294
1295         /* Ensure this is a locking_key record. */
1296         if (kbuf.dsize != sizeof(struct locking_key))
1297                 return 0;
1298
1299         data = (struct locking_data *)dbuf.dptr;
1300         shares = (struct share_mode_entry *)(dbuf.dptr + sizeof(*data));
1301         sharepath = dbuf.dptr + sizeof(*data) +
1302                 data->u.s.num_share_mode_entries*sizeof(*shares) +
1303                 data->u.s.delete_token_size;
1304         fname = dbuf.dptr + sizeof(*data) +
1305                 data->u.s.num_share_mode_entries*sizeof(*shares) +
1306                 data->u.s.delete_token_size +
1307                 strlen(sharepath) + 1;
1308
1309         for (i=0;i<data->u.s.num_share_mode_entries;i++) {
1310                 state->fn(&shares[i], sharepath, fname,
1311                           state->private_data);
1312         }
1313         return 0;
1314 }
1315
1316 /*******************************************************************
1317  Call the specified function on each entry under management by the
1318  share mode system.
1319 ********************************************************************/
1320
1321 int share_mode_forall(void (*fn)(const struct share_mode_entry *, const char *,
1322                                  const char *, void *),
1323                       void *private_data)
1324 {
1325         struct forall_state state;
1326
1327         if (tdb == NULL)
1328                 return 0;
1329
1330         state.fn = fn;
1331         state.private_data = private_data;
1332
1333         return tdb_traverse(tdb, traverse_fn, (void *)&state);
1334 }