r13192: Fix up alignment issues when printing share mode
[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-2000
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 */
37
38 #include "includes.h"
39 uint16 global_smbpid;
40
41 #undef DBGC_CLASS
42 #define DBGC_CLASS DBGC_LOCKING
43
44 /* the locking database handle */
45 static TDB_CONTEXT *tdb;
46
47 struct locking_data {
48         union {
49                 struct {
50                         int num_share_mode_entries;
51                         BOOL delete_on_close;
52                 } s;
53                 struct share_mode_entry dummy; /* Needed for alignment. */
54         } u;
55         /* the following two entries are implicit
56            struct share_mode_entry modes[num_share_mode_entries];
57            char file_name[];
58         */
59 };
60
61 /****************************************************************************
62  Debugging aid :-).
63 ****************************************************************************/
64
65 static const char *lock_type_name(enum brl_type lock_type)
66 {
67         return (lock_type == READ_LOCK) ? "READ" : "WRITE";
68 }
69
70 /****************************************************************************
71  Utility function called to see if a file region is locked.
72 ****************************************************************************/
73
74 BOOL is_locked(files_struct *fsp,connection_struct *conn,
75                SMB_BIG_UINT count,SMB_BIG_UINT offset, 
76                enum brl_type lock_type)
77 {
78         int snum = SNUM(conn);
79         int strict_locking = lp_strict_locking(snum);
80         BOOL ret;
81         
82         if (count == 0)
83                 return(False);
84
85         if (!lp_locking(snum) || !strict_locking)
86                 return(False);
87
88         if (strict_locking == Auto) {
89                 if  (EXCLUSIVE_OPLOCK_TYPE(fsp->oplock_type) && (lock_type == READ_LOCK || lock_type == WRITE_LOCK)) {
90                         DEBUG(10,("is_locked: optimisation - exclusive oplock on file %s\n", fsp->fsp_name ));
91                         ret = 0;
92                 } else if ((fsp->oplock_type == LEVEL_II_OPLOCK) &&
93                            (lock_type == READ_LOCK)) {
94                         DEBUG(10,("is_locked: optimisation - level II oplock on file %s\n", fsp->fsp_name ));
95                         ret = 0;
96                 } else {
97                         ret = !brl_locktest(fsp->dev, fsp->inode, fsp->fnum,
98                                      global_smbpid, procid_self(), conn->cnum, 
99                                      offset, count, lock_type);
100                 }
101         } else {
102                 ret = !brl_locktest(fsp->dev, fsp->inode, fsp->fnum,
103                                 global_smbpid, procid_self(), conn->cnum,
104                                 offset, count, lock_type);
105         }
106
107         DEBUG(10,("is_locked: brl start=%.0f len=%.0f %s for file %s\n",
108                         (double)offset, (double)count, ret ? "locked" : "unlocked",
109                         fsp->fsp_name ));
110
111         /*
112          * There is no lock held by an SMB daemon, check to
113          * see if there is a POSIX lock from a UNIX or NFS process.
114          */
115
116         if(!ret && lp_posix_locking(snum)) {
117                 ret = is_posix_locked(fsp, offset, count, lock_type);
118
119                 DEBUG(10,("is_locked: posix start=%.0f len=%.0f %s for file %s\n",
120                                 (double)offset, (double)count, ret ? "locked" : "unlocked",
121                                 fsp->fsp_name ));
122         }
123
124         return ret;
125 }
126
127 /****************************************************************************
128  Utility function called by locking requests.
129 ****************************************************************************/
130
131 static NTSTATUS do_lock(files_struct *fsp,connection_struct *conn, uint16 lock_pid,
132                  SMB_BIG_UINT count,SMB_BIG_UINT offset,enum brl_type lock_type, BOOL *my_lock_ctx)
133 {
134         NTSTATUS status = NT_STATUS_LOCK_NOT_GRANTED;
135
136         if (!lp_locking(SNUM(conn)))
137                 return NT_STATUS_OK;
138
139         /* NOTE! 0 byte long ranges ARE allowed and should be stored  */
140
141         DEBUG(10,("do_lock: lock type %s start=%.0f len=%.0f requested for file %s\n",
142                   lock_type_name(lock_type), (double)offset, (double)count, fsp->fsp_name ));
143
144         if (OPEN_FSP(fsp) && fsp->can_lock && (fsp->conn == conn)) {
145                 status = brl_lock(fsp->dev, fsp->inode, fsp->fnum,
146                                   lock_pid, procid_self(), conn->cnum, 
147                                   offset, count, 
148                                   lock_type, my_lock_ctx);
149
150                 if (NT_STATUS_IS_OK(status) && lp_posix_locking(SNUM(conn))) {
151
152                         /*
153                          * Try and get a POSIX lock on this range.
154                          * Note that this is ok if it is a read lock
155                          * overlapping on a different fd. JRA.
156                          */
157
158                         if (!set_posix_lock(fsp, offset, count, lock_type)) {
159                                 if (errno == EACCES || errno == EAGAIN)
160                                         status = NT_STATUS_FILE_LOCK_CONFLICT;
161                                 else
162                                         status = map_nt_error_from_unix(errno);
163
164                                 /*
165                                  * We failed to map - we must now remove the brl
166                                  * lock entry.
167                                  */
168                                 (void)brl_unlock(fsp->dev, fsp->inode, fsp->fnum,
169                                                                 lock_pid, procid_self(), conn->cnum, 
170                                                                 offset, count, False,
171                                                                 NULL, NULL);
172                         }
173                 }
174         }
175
176         return status;
177 }
178
179 /****************************************************************************
180  Utility function called by locking requests. This is *DISGUSTING*. It also
181  appears to be "What Windows Does" (tm). Andrew, ever wonder why Windows 2000
182  is so slow on the locking tests...... ? This is the reason. Much though I hate
183  it, we need this. JRA.
184 ****************************************************************************/
185
186 NTSTATUS do_lock_spin(files_struct *fsp,connection_struct *conn, uint16 lock_pid,
187                  SMB_BIG_UINT count,SMB_BIG_UINT offset,enum brl_type lock_type, BOOL *my_lock_ctx)
188 {
189         int j, maxj = lp_lock_spin_count();
190         int sleeptime = lp_lock_sleep_time();
191         NTSTATUS status, ret;
192
193         if (maxj <= 0)
194                 maxj = 1;
195
196         ret = NT_STATUS_OK; /* to keep dumb compilers happy */
197
198         for (j = 0; j < maxj; j++) {
199                 status = do_lock(fsp, conn, lock_pid, count, offset, lock_type, my_lock_ctx);
200                 if (!NT_STATUS_EQUAL(status, NT_STATUS_LOCK_NOT_GRANTED) &&
201                     !NT_STATUS_EQUAL(status, NT_STATUS_FILE_LOCK_CONFLICT)) {
202                         return status;
203                 }
204                 /* if we do fail then return the first error code we got */
205                 if (j == 0) {
206                         ret = status;
207                         /* Don't spin if we blocked ourselves. */
208                         if (*my_lock_ctx)
209                                 return ret;
210                 }
211                 if (sleeptime)
212                         sys_usleep(sleeptime);
213         }
214         return ret;
215 }
216
217 /* Struct passed to brl_unlock. */
218 struct posix_unlock_data_struct {
219         files_struct *fsp;
220         SMB_BIG_UINT offset;
221         SMB_BIG_UINT count;
222 };
223
224 /****************************************************************************
225  Function passed to brl_unlock to allow POSIX unlock to be done first.
226 ****************************************************************************/
227
228 static void posix_unlock(void *pre_data)
229 {
230         struct posix_unlock_data_struct *pdata = (struct posix_unlock_data_struct *)pre_data;
231
232         if (lp_posix_locking(SNUM(pdata->fsp->conn)))
233                 release_posix_lock(pdata->fsp, pdata->offset, pdata->count);
234 }
235
236 /****************************************************************************
237  Utility function called by unlocking requests.
238 ****************************************************************************/
239
240 NTSTATUS do_unlock(files_struct *fsp,connection_struct *conn, uint16 lock_pid,
241                    SMB_BIG_UINT count,SMB_BIG_UINT offset)
242 {
243         BOOL ok = False;
244         struct posix_unlock_data_struct posix_data;
245         
246         if (!lp_locking(SNUM(conn)))
247                 return NT_STATUS_OK;
248         
249         if (!OPEN_FSP(fsp) || !fsp->can_lock || (fsp->conn != conn)) {
250                 return NT_STATUS_INVALID_HANDLE;
251         }
252         
253         DEBUG(10,("do_unlock: unlock start=%.0f len=%.0f requested for file %s\n",
254                   (double)offset, (double)count, fsp->fsp_name ));
255
256         /*
257          * Remove the existing lock record from the tdb lockdb
258          * before looking at POSIX locks. If this record doesn't
259          * match then don't bother looking to remove POSIX locks.
260          */
261
262         posix_data.fsp = fsp;
263         posix_data.offset = offset;
264         posix_data.count = count;
265
266         ok = brl_unlock(fsp->dev, fsp->inode, fsp->fnum,
267                         lock_pid, procid_self(), conn->cnum, offset, count,
268                         False, posix_unlock, (void *)&posix_data);
269    
270         if (!ok) {
271                 DEBUG(10,("do_unlock: returning ERRlock.\n" ));
272                 return NT_STATUS_RANGE_NOT_LOCKED;
273         }
274         return NT_STATUS_OK;
275 }
276
277 /****************************************************************************
278  Remove any locks on this fd. Called from file_close().
279 ****************************************************************************/
280
281 void locking_close_file(files_struct *fsp)
282 {
283         struct process_id pid = procid_self();
284
285         if (!lp_locking(SNUM(fsp->conn)))
286                 return;
287
288         /*
289          * Just release all the brl locks, no need to release individually.
290          */
291
292         brl_close(fsp->dev, fsp->inode, pid, fsp->conn->cnum, fsp->fnum);
293
294         if(lp_posix_locking(SNUM(fsp->conn))) {
295
296                 /* 
297                  * Release all the POSIX locks.
298                  */
299                 posix_locking_close_file(fsp);
300
301         }
302 }
303
304 /****************************************************************************
305  Initialise the locking functions.
306 ****************************************************************************/
307
308 static int open_read_only;
309
310 BOOL locking_init(int read_only)
311 {
312         brl_init(read_only);
313
314         if (tdb)
315                 return True;
316
317         tdb = tdb_open_log(lock_path("locking.tdb"), 
318                         SMB_OPEN_DATABASE_TDB_HASH_SIZE, TDB_DEFAULT|(read_only?0x0:TDB_CLEAR_IF_FIRST), 
319                         read_only?O_RDONLY:O_RDWR|O_CREAT,
320                         0644);
321
322         if (!tdb) {
323                 DEBUG(0,("ERROR: Failed to initialise locking database\n"));
324                 return False;
325         }
326
327         if (!posix_locking_init(read_only))
328                 return False;
329
330         open_read_only = read_only;
331
332         return True;
333 }
334
335 /*******************************************************************
336  Deinitialize the share_mode management.
337 ******************************************************************/
338
339 BOOL locking_end(void)
340 {
341         BOOL ret = True;
342
343         brl_shutdown(open_read_only);
344         if (tdb) {
345                 if (tdb_close(tdb) != 0)
346                         ret = False;
347         }
348
349         return ret;
350 }
351
352 /*******************************************************************
353  Form a static locking key for a dev/inode pair.
354 ******************************************************************/
355
356 /* key and data records in the tdb locking database */
357 struct locking_key {
358         SMB_DEV_T dev;
359         SMB_INO_T ino;
360 };
361
362 /*******************************************************************
363  Form a static locking key for a dev/inode pair.
364 ******************************************************************/
365
366 static TDB_DATA locking_key(SMB_DEV_T dev, SMB_INO_T inode)
367 {
368         static struct locking_key key;
369         TDB_DATA kbuf;
370
371         memset(&key, '\0', sizeof(key));
372         key.dev = dev;
373         key.ino = inode;
374         kbuf.dptr = (char *)&key;
375         kbuf.dsize = sizeof(key);
376         return kbuf;
377 }
378
379 /*******************************************************************
380  Print out a share mode.
381 ********************************************************************/
382
383 char *share_mode_str(int num, struct share_mode_entry *e)
384 {
385         static pstring share_str;
386
387         slprintf(share_str, sizeof(share_str)-1, "share_mode_entry[%d]: %s "
388                  "pid = %s, share_access = 0x%x, private_options = 0x%x, "
389                  "access_mask = 0x%x, mid = 0x%x, type= 0x%x, file_id = %lu, "
390                  "dev = 0x%x, inode = %.0f",
391                  num,
392                  e->op_type == UNUSED_SHARE_MODE_ENTRY ? "UNUSED" : "",
393                  procid_str_static(&e->pid),
394                  e->share_access, e->private_options,
395                  e->access_mask, e->op_mid, e->op_type, e->share_file_id,
396                  (unsigned int)e->dev, (double)e->inode );
397
398         return share_str;
399 }
400
401 /*******************************************************************
402  Print out a share mode table.
403 ********************************************************************/
404
405 static void print_share_mode_table(struct locking_data *data)
406 {
407         int num_share_modes = data->u.s.num_share_mode_entries;
408         struct share_mode_entry *shares =
409                 (struct share_mode_entry *)(data + 1);
410         int i;
411
412         for (i = 0; i < num_share_modes; i++) {
413                 struct share_mode_entry entry;
414
415                 memcpy(&entry, &shares[i], sizeof(struct share_mode_entry));
416                 DEBUG(10,("print_share_mode_table: %s\n",
417                           share_mode_str(i, &entry)));
418         }
419 }
420
421 /*******************************************************************
422  Get all share mode entries for a dev/inode pair.
423 ********************************************************************/
424
425 static BOOL parse_share_modes(TDB_DATA dbuf, struct share_mode_lock *lck)
426 {
427         struct locking_data *data;
428         int i;
429
430         if (dbuf.dsize < sizeof(struct locking_data)) {
431                 DEBUG(0, ("parse_share_modes: buffer too short\n"));
432                 return False;
433         }
434
435         data = (struct locking_data *)dbuf.dptr;
436
437         lck->delete_on_close = data->u.s.delete_on_close;
438         lck->num_share_modes = data->u.s.num_share_mode_entries;
439
440         DEBUG(10, ("parse_share_modes: delete_on_close: %d, "
441                    "num_share_modes: %d\n", lck->delete_on_close,
442                    lck->num_share_modes));
443
444         if ((lck->num_share_modes < 0) || (lck->num_share_modes > 1000000)) {
445                 DEBUG(0, ("invalid number of share modes: %d\n",
446                           lck->num_share_modes));
447                 return False;
448         }
449
450         lck->share_modes = NULL;
451
452         if (lck->num_share_modes != 0) {
453
454                 if (dbuf.dsize < (sizeof(struct locking_data) +
455                                   (lck->num_share_modes *
456                                    sizeof(struct share_mode_entry)))) {
457                         DEBUG(0, ("parse_share_modes: buffer too short\n"));
458                         return False;
459                 }
460                                   
461                 lck->share_modes = talloc_memdup(lck, dbuf.dptr+sizeof(*data),
462                                                  lck->num_share_modes *
463                                                  sizeof(struct share_mode_entry));
464
465                 if (lck->share_modes == NULL) {
466                         DEBUG(0, ("talloc failed\n"));
467                         return False;
468                 }
469         }
470
471         /* Save off the associated service path and filename. */
472         lck->servicepath = talloc_strdup(lck, dbuf.dptr + sizeof(*data) +
473                                       (lck->num_share_modes *
474                                       sizeof(struct share_mode_entry)));
475
476         lck->filename = talloc_strdup(lck, dbuf.dptr + sizeof(*data) +
477                                       (lck->num_share_modes *
478                                       sizeof(struct share_mode_entry)) +
479                                       strlen(lck->servicepath) + 1 );
480
481         /*
482          * Ensure that each entry has a real process attached.
483          */
484
485         for (i = 0; i < lck->num_share_modes; i++) {
486                 struct share_mode_entry *entry_p = &lck->share_modes[i];
487                 DEBUG(10,("parse_share_modes: %s\n",
488                           share_mode_str(i, entry_p) ));
489                 if (!process_exists(entry_p->pid)) {
490                         DEBUG(10,("parse_share_modes: deleted %s\n",
491                                   share_mode_str(i, entry_p) ));
492                         entry_p->op_type = UNUSED_SHARE_MODE_ENTRY;
493                         lck->modified = True;
494                 }
495         }
496
497         return True;
498 }
499
500 static TDB_DATA unparse_share_modes(struct share_mode_lock *lck)
501 {
502         TDB_DATA result;
503         int num_valid = 0;
504         int i;
505         struct locking_data *data;
506         ssize_t offset;
507         ssize_t sp_len;
508
509         result.dptr = NULL;
510         result.dsize = 0;
511
512         for (i=0; i<lck->num_share_modes; i++) {
513                 if (!is_unused_share_mode_entry(&lck->share_modes[i])) {
514                         num_valid += 1;
515                 }
516         }
517
518         if (num_valid == 0) {
519                 return result;
520         }
521
522         sp_len = strlen(lck->servicepath);
523
524         result.dsize = sizeof(*data) +
525                 lck->num_share_modes * sizeof(struct share_mode_entry) +
526                 sp_len + 1 +
527                 strlen(lck->filename) + 1;
528         result.dptr = talloc_size(lck, result.dsize);
529
530         if (result.dptr == NULL) {
531                 smb_panic("talloc failed\n");
532         }
533
534         data = (struct locking_data *)result.dptr;
535         ZERO_STRUCTP(data);
536         data->u.s.num_share_mode_entries = lck->num_share_modes;
537         data->u.s.delete_on_close = lck->delete_on_close;
538         DEBUG(10, ("unparse_share_modes: del: %d, num: %d\n",
539                    data->u.s.delete_on_close,
540                    data->u.s.num_share_mode_entries));
541         memcpy(result.dptr + sizeof(*data), lck->share_modes,
542                sizeof(struct share_mode_entry)*lck->num_share_modes);
543         offset = sizeof(*data) +
544                 sizeof(struct share_mode_entry)*lck->num_share_modes;
545         safe_strcpy(result.dptr + offset, lck->servicepath,
546                     result.dsize - offset - 1);
547         offset += sp_len + 1;
548         safe_strcpy(result.dptr + offset, lck->filename,
549                     result.dsize - offset - 1);
550         print_share_mode_table(data);
551         return result;
552 }
553
554 static int share_mode_lock_destructor(void *p)
555 {
556         struct share_mode_lock *lck =
557                 talloc_get_type_abort(p, struct share_mode_lock);
558         TDB_DATA key = locking_key(lck->dev, lck->ino);
559         TDB_DATA data;
560
561         if (!lck->modified) {
562                 goto done;
563         }
564
565         data = unparse_share_modes(lck);
566
567         if (data.dptr == NULL) {
568                 if (!lck->fresh) {
569                         /* There has been an entry before, delete it */
570                         if (tdb_delete(tdb, key) == -1) {
571                                 smb_panic("Could not delete share entry\n");
572                         }
573                 }
574                 goto done;
575         }
576
577         if (tdb_store(tdb, key, data, TDB_REPLACE) == -1) {
578                 smb_panic("Could not store share mode entry\n");
579         }
580
581  done:
582         tdb_chainunlock(tdb, key);
583
584         return 0;
585 }
586
587 struct share_mode_lock *get_share_mode_lock(TALLOC_CTX *mem_ctx,
588                                                 SMB_DEV_T dev, SMB_INO_T ino,
589                                                 const char *servicepath,
590                                                 const char *fname)
591 {
592         struct share_mode_lock *lck;
593         TDB_DATA key = locking_key(dev, ino);
594         TDB_DATA data;
595
596         lck = TALLOC_P(mem_ctx, struct share_mode_lock);
597         if (lck == NULL) {
598                 DEBUG(0, ("talloc failed\n"));
599                 return NULL;
600         }
601
602         /* Ensure we set every field here as the destructor must be
603            valid even if parse_share_modes fails. */
604
605         lck->servicepath = NULL;
606         lck->filename = NULL;
607         lck->dev = dev;
608         lck->ino = ino;
609         lck->num_share_modes = 0;
610         lck->share_modes = NULL;
611         lck->delete_on_close = False;
612         lck->fresh = False;
613         lck->modified = False;
614
615         if (tdb_chainlock(tdb, key) != 0) {
616                 DEBUG(3, ("Could not lock share entry\n"));
617                 talloc_free(lck);
618                 return NULL;
619         }
620
621         /* We must set the destructor immediately after the chainlock
622            ensure the lock is cleaned up on any of the error return
623            paths below. */
624
625         talloc_set_destructor(lck, share_mode_lock_destructor);
626
627         data = tdb_fetch(tdb, key);
628         lck->fresh = (data.dptr == NULL);
629
630         if (lck->fresh) {
631
632                 if (fname == NULL || servicepath == NULL) {
633                         talloc_free(lck);
634                         return NULL;
635                 }
636                 lck->filename = talloc_strdup(lck, fname);
637                 lck->servicepath = talloc_strdup(lck, servicepath);
638                 if (lck->filename == NULL || lck->servicepath == NULL) {
639                         DEBUG(0, ("talloc failed\n"));
640                         talloc_free(lck);
641                         return NULL;
642                 }
643         } else {
644                 if (!parse_share_modes(data, lck)) {
645                         DEBUG(0, ("Could not parse share modes\n"));
646                         talloc_free(lck);
647                         SAFE_FREE(data.dptr);
648                         return NULL;
649                 }
650         }
651
652         SAFE_FREE(data.dptr);
653
654         return lck;
655 }
656
657 /*******************************************************************
658  Sets the service name and filename for rename.
659  At this point we emit "file renamed" messages to all
660  process id's that have this file open.
661  Based on an initial code idea from SATOH Fumiyasu <fumiya@samba.gr.jp>
662 ********************************************************************/
663
664 BOOL rename_share_filename(struct share_mode_lock *lck,
665                         const char *servicepath,
666                         const char *newname)
667 {
668         size_t sp_len;
669         size_t fn_len;
670         size_t msg_len;
671         char *frm = NULL;
672         int i;
673
674         if (!lck) {
675                 return False;
676         }
677
678         DEBUG(10, ("rename_share_filename: servicepath %s newname %s\n",
679                 servicepath, newname));
680
681         /*
682          * rename_internal_fsp() and rename_internals() add './' to
683          * head of newname if newname does not contain a '/'.
684          */
685         while (newname[0] && newname[1] && newname[0] == '.' && newname[1] == '/') {
686                 newname += 2;
687         }
688
689         lck->servicepath = talloc_strdup(lck, servicepath);
690         lck->filename = talloc_strdup(lck, newname);
691         if (lck->filename == NULL || lck->servicepath == NULL) {
692                 DEBUG(0, ("rename_share_filename: talloc failed\n"));
693                 return False;
694         }
695         lck->modified = True;
696
697         sp_len = strlen(lck->servicepath);
698         fn_len = strlen(lck->filename);
699
700         msg_len = MSG_FILE_RENAMED_MIN_SIZE + sp_len + 1 + fn_len + 1;
701
702         /* Set up the name changed message. */
703         frm = TALLOC(lck, msg_len);
704         if (!frm) {
705                 return False;
706         }
707
708         SDEV_T_VAL(frm,0,lck->dev);
709         SINO_T_VAL(frm,8,lck->ino);
710
711         DEBUG(10,("rename_share_filename: msg_len = %d\n", msg_len ));
712
713         safe_strcpy(&frm[16], lck->servicepath, sp_len);
714         safe_strcpy(&frm[16 + sp_len + 1], lck->filename, fn_len);
715
716         /* Send the messages. */
717         for (i=0; i<lck->num_share_modes; i++) {
718                 struct share_mode_entry *se = &lck->share_modes[i];
719                 if (!is_valid_share_mode_entry(se)) {
720                         continue;
721                 }
722                 /* But not to ourselves... */
723                 if (procid_is_me(&se->pid)) {
724                         continue;
725                 }
726
727                 DEBUG(10,("rename_share_filename: sending rename message to pid %u "
728                         "dev %x, inode  %.0f sharepath %s newname %s\n",
729                         (unsigned int)procid_to_pid(&se->pid),
730                         (unsigned int)lck->dev, (double)lck->ino,
731                         lck->servicepath, lck->filename ));
732
733                 become_root();
734                 message_send_pid(se->pid, MSG_SMB_FILE_RENAME,
735                                 frm, msg_len, True);
736                 unbecome_root();
737         }
738
739         return True;
740 }
741
742 BOOL get_delete_on_close_flag(SMB_DEV_T dev, SMB_INO_T inode)
743 {
744         BOOL result;
745         struct share_mode_lock *lck = get_share_mode_lock(NULL, dev, inode, NULL, NULL);
746         if (!lck) {
747                 return False;
748         }
749         result = lck->delete_on_close;
750         talloc_free(lck);
751         return result;
752 }
753
754 BOOL is_valid_share_mode_entry(const struct share_mode_entry *e)
755 {
756         int num_props = 0;
757
758         num_props += ((e->op_type == NO_OPLOCK) ? 1 : 0);
759         num_props += (EXCLUSIVE_OPLOCK_TYPE(e->op_type) ? 1 : 0);
760         num_props += (LEVEL_II_OPLOCK_TYPE(e->op_type) ? 1 : 0);
761
762         SMB_ASSERT(num_props <= 1);
763         return (num_props != 0);
764 }
765
766 BOOL is_deferred_open_entry(const struct share_mode_entry *e)
767 {
768         return (e->op_type == DEFERRED_OPEN_ENTRY);
769 }
770
771 BOOL is_unused_share_mode_entry(const struct share_mode_entry *e)
772 {
773         return (e->op_type == UNUSED_SHARE_MODE_ENTRY);
774 }
775
776 /*******************************************************************
777  Fill a share mode entry.
778 ********************************************************************/
779
780 static void fill_share_mode_entry(struct share_mode_entry *e,
781                                   files_struct *fsp,
782                                   uint16 mid, uint16 op_type)
783 {
784         ZERO_STRUCTP(e);
785         e->pid = procid_self();
786         e->share_access = fsp->share_access;
787         e->private_options = fsp->fh->private_options;
788         e->access_mask = fsp->access_mask;
789         e->op_mid = mid;
790         e->op_type = op_type;
791         e->time.tv_sec = fsp->open_time.tv_sec;
792         e->time.tv_usec = fsp->open_time.tv_usec;
793         e->share_file_id = fsp->file_id;
794         e->dev = fsp->dev;
795         e->inode = fsp->inode;
796 }
797
798 static void fill_deferred_open_entry(struct share_mode_entry *e,
799                                      const struct timeval request_time,
800                                      SMB_DEV_T dev, SMB_INO_T ino, uint16 mid)
801 {
802         ZERO_STRUCTP(e);
803         e->pid = procid_self();
804         e->op_mid = mid;
805         e->op_type = DEFERRED_OPEN_ENTRY;
806         e->time.tv_sec = request_time.tv_sec;
807         e->time.tv_usec = request_time.tv_usec;
808         e->dev = dev;
809         e->inode = ino;
810 }
811
812 static void add_share_mode_entry(struct share_mode_lock *lck,
813                                  const struct share_mode_entry *entry)
814 {
815         int i;
816
817         for (i=0; i<lck->num_share_modes; i++) {
818                 struct share_mode_entry *e = &lck->share_modes[i];
819                 if (is_unused_share_mode_entry(e)) {
820                         *e = *entry;
821                         break;
822                 }
823         }
824
825         if (i == lck->num_share_modes) {
826                 /* No unused entry found */
827                 ADD_TO_ARRAY(lck, struct share_mode_entry, *entry,
828                              &lck->share_modes, &lck->num_share_modes);
829         }
830         lck->modified = True;
831 }
832
833 void set_share_mode(struct share_mode_lock *lck, files_struct *fsp,
834                     uint16 mid, uint16 op_type)
835 {
836         struct share_mode_entry entry;
837         fill_share_mode_entry(&entry, fsp, mid, op_type);
838         add_share_mode_entry(lck, &entry);
839 }
840
841 void add_deferred_open(struct share_mode_lock *lck, uint16 mid,
842                        struct timeval request_time,
843                        SMB_DEV_T dev, SMB_INO_T ino)
844 {
845         struct share_mode_entry entry;
846         fill_deferred_open_entry(&entry, request_time, dev, ino, mid);
847         add_share_mode_entry(lck, &entry);
848 }
849
850 /*******************************************************************
851  Check if two share mode entries are identical, ignoring oplock 
852  and mid info and desired_access.
853 ********************************************************************/
854
855 static BOOL share_modes_identical(struct share_mode_entry *e1,
856                                   struct share_mode_entry *e2)
857 {
858 #if 1 /* JRA PARANOIA TEST - REMOVE LATER */
859         if (procid_equal(&e1->pid, &e2->pid) &&
860             e1->share_file_id == e2->share_file_id &&
861             e1->dev == e2->dev &&
862             e1->inode == e2->inode &&
863             (e1->share_access) != (e2->share_access)) {
864                 DEBUG(0,("PANIC: share_modes_identical: share_mode "
865                          "mismatch (e1 = 0x%x, e2 = 0x%x). Logic error.\n",
866                          (unsigned int)e1->share_access,
867                          (unsigned int)e2->share_access ));
868                 smb_panic("PANIC: share_modes_identical logic error.\n");
869         }
870 #endif
871
872         return (procid_equal(&e1->pid, &e2->pid) &&
873                 (e1->share_access) == (e2->share_access) &&
874                 e1->dev == e2->dev &&
875                 e1->inode == e2->inode &&
876                 e1->share_file_id == e2->share_file_id );
877 }
878
879 static BOOL deferred_open_identical(struct share_mode_entry *e1,
880                                     struct share_mode_entry *e2)
881 {
882         return (procid_equal(&e1->pid, &e2->pid) &&
883                 (e1->op_mid == e2->op_mid) &&
884                 (e1->dev == e2->dev) &&
885                 (e1->inode == e2->inode));
886 }
887
888 static struct share_mode_entry *find_share_mode_entry(struct share_mode_lock *lck,
889                                                       struct share_mode_entry *entry)
890 {
891         int i;
892
893         for (i=0; i<lck->num_share_modes; i++) {
894                 struct share_mode_entry *e = &lck->share_modes[i];
895                 if (is_valid_share_mode_entry(entry) &&
896                     is_valid_share_mode_entry(e) &&
897                     share_modes_identical(e, entry)) {
898                         return e;
899                 }
900                 if (is_deferred_open_entry(entry) &&
901                     is_deferred_open_entry(e) &&
902                     deferred_open_identical(e, entry)) {
903                         return e;
904                 }
905         }
906         return NULL;
907 }
908
909 /*******************************************************************
910  Del the share mode of a file for this process. Return the number of
911  entries left.
912 ********************************************************************/
913
914 BOOL del_share_mode(struct share_mode_lock *lck, files_struct *fsp)
915 {
916         struct share_mode_entry entry, *e;
917
918         fill_share_mode_entry(&entry, fsp, 0, 0);
919
920         e = find_share_mode_entry(lck, &entry);
921         if (e == NULL) {
922                 return False;
923         }
924
925         e->op_type = UNUSED_SHARE_MODE_ENTRY;
926         lck->modified = True;
927         return True;
928 }
929
930 void del_deferred_open_entry(struct share_mode_lock *lck, uint16 mid)
931 {
932         struct share_mode_entry entry, *e;
933
934         fill_deferred_open_entry(&entry, timeval_zero(),
935                                  lck->dev, lck->ino, mid);
936
937         e = find_share_mode_entry(lck, &entry);
938         if (e == NULL) {
939                 return;
940         }
941
942         e->op_type = UNUSED_SHARE_MODE_ENTRY;
943         lck->modified = True;
944 }
945
946 /*******************************************************************
947  Remove an oplock mid and mode entry from a share mode.
948 ********************************************************************/
949
950 BOOL remove_share_oplock(struct share_mode_lock *lck, files_struct *fsp)
951 {
952         struct share_mode_entry entry, *e;
953
954         fill_share_mode_entry(&entry, fsp, 0, 0);
955
956         e = find_share_mode_entry(lck, &entry);
957         if (e == NULL) {
958                 return False;
959         }
960
961         e->op_mid = 0;
962         e->op_type = NO_OPLOCK;
963         lck->modified = True;
964         return True;
965 }
966
967 /*******************************************************************
968  Downgrade a oplock type from exclusive to level II.
969 ********************************************************************/
970
971 BOOL downgrade_share_oplock(struct share_mode_lock *lck, files_struct *fsp)
972 {
973         struct share_mode_entry entry, *e;
974
975         fill_share_mode_entry(&entry, fsp, 0, 0);
976
977         e = find_share_mode_entry(lck, &entry);
978         if (e == NULL) {
979                 return False;
980         }
981
982         e->op_type = LEVEL_II_OPLOCK;
983         lck->modified = True;
984         return True;
985 }
986
987
988 /*******************************************************************
989  We've just told all the smbd's that our level2 or fake level2 has been
990  written to.
991 ********************************************************************/
992 BOOL remove_all_share_oplocks(struct share_mode_lock *lck, files_struct *fsp)
993 {
994         int i;
995         for (i=0; i<lck->num_share_modes; i++) {
996                 struct share_mode_entry *e = &lck->share_modes[i];
997                 if (!is_valid_share_mode_entry(e)) {
998                         continue;
999                 }
1000                 if (e->op_type == NO_OPLOCK) {
1001                         continue;
1002                 }
1003                 e->op_type = NO_OPLOCK;
1004                 lck->modified = True;
1005         }
1006         return True;
1007 }
1008
1009 /****************************************************************************
1010  Deal with the internal needs of setting the delete on close flag. Note that
1011  as the tdb locking is recursive, it is safe to call this from within 
1012  open_file_shared. JRA.
1013 ****************************************************************************/
1014
1015 NTSTATUS can_set_delete_on_close(files_struct *fsp, BOOL delete_on_close,
1016                                  uint32 dosmode)
1017 {
1018         if (!delete_on_close) {
1019                 return NT_STATUS_OK;
1020         }
1021
1022         /*
1023          * Only allow delete on close for writable files.
1024          */
1025
1026         if ((dosmode & aRONLY) &&
1027             !lp_delete_readonly(SNUM(fsp->conn))) {
1028                 DEBUG(10,("can_set_delete_on_close: file %s delete on close "
1029                           "flag set but file attribute is readonly.\n",
1030                           fsp->fsp_name ));
1031                 return NT_STATUS_CANNOT_DELETE;
1032         }
1033
1034         /*
1035          * Only allow delete on close for writable shares.
1036          */
1037
1038         if (!CAN_WRITE(fsp->conn)) {
1039                 DEBUG(10,("can_set_delete_on_close: file %s delete on "
1040                           "close flag set but write access denied on share.\n",
1041                           fsp->fsp_name ));
1042                 return NT_STATUS_ACCESS_DENIED;
1043         }
1044
1045         /*
1046          * Only allow delete on close for files/directories opened with delete
1047          * intent.
1048          */
1049
1050         if (!(fsp->access_mask & DELETE_ACCESS)) {
1051                 DEBUG(10,("can_set_delete_on_close: file %s delete on "
1052                           "close flag set but delete access denied.\n",
1053                           fsp->fsp_name ));
1054                 return NT_STATUS_ACCESS_DENIED;
1055         }
1056
1057         return NT_STATUS_OK;
1058 }
1059
1060 /****************************************************************************
1061  Sets the delete on close flag over all share modes on this file.
1062  Modify the share mode entry for all files open
1063  on this device and inode to tell other smbds we have
1064  changed the delete on close flag. This will be noticed
1065  in the close code, the last closer will delete the file
1066  if flag is set.
1067 ****************************************************************************/
1068
1069 BOOL set_delete_on_close(files_struct *fsp, BOOL delete_on_close)
1070 {
1071         struct share_mode_lock *lck;
1072         
1073         DEBUG(10,("set_delete_on_close: %s delete on close flag for "
1074                   "fnum = %d, file %s\n",
1075                   delete_on_close ? "Adding" : "Removing", fsp->fnum,
1076                   fsp->fsp_name ));
1077
1078         if (fsp->is_stat) {
1079                 return True;
1080         }
1081
1082         lck = get_share_mode_lock(NULL, fsp->dev, fsp->inode, NULL, NULL);
1083         if (lck == NULL) {
1084                 return False;
1085         }
1086         if (lck->delete_on_close != delete_on_close) {
1087                 lck->delete_on_close = delete_on_close;
1088                 lck->modified = True;
1089         }
1090
1091         talloc_free(lck);
1092         return True;
1093 }
1094
1095 static int traverse_fn(TDB_CONTEXT *the_tdb, TDB_DATA kbuf, TDB_DATA dbuf, 
1096                        void *state)
1097 {
1098         struct locking_data *data;
1099         struct share_mode_entry *shares;
1100         const char *sharepath;
1101         const char *fname;
1102         int i;
1103         void (*traverse_callback)(struct share_mode_entry *, const char *, const char *) = state;
1104
1105         /* Ensure this is a locking_key record. */
1106         if (kbuf.dsize != sizeof(struct locking_key))
1107                 return 0;
1108
1109         data = (struct locking_data *)dbuf.dptr;
1110         shares = (struct share_mode_entry *)(dbuf.dptr + sizeof(*data));
1111         sharepath = dbuf.dptr + sizeof(*data) +
1112                 data->u.s.num_share_mode_entries*sizeof(*shares);
1113         fname = dbuf.dptr + sizeof(*data) +
1114                 data->u.s.num_share_mode_entries*sizeof(*shares) +
1115                 strlen(sharepath) + 1;
1116
1117         for (i=0;i<data->u.s.num_share_mode_entries;i++) {
1118                 traverse_callback(&shares[i], sharepath, fname);
1119         }
1120         return 0;
1121 }
1122
1123 /*******************************************************************
1124  Call the specified function on each entry under management by the
1125  share mode system.
1126 ********************************************************************/
1127
1128 int share_mode_forall(void (*fn)(const struct share_mode_entry *, const char *, const char *))
1129 {
1130         if (tdb == NULL)
1131                 return 0;
1132         return tdb_traverse(tdb, traverse_fn, fn);
1133 }