source3/locking/posix.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3    Locking functions
   4    Copyright (C) Jeremy Allison 1992-2006
   5
   6    This program is free software; you can redistribute it and/or modify
   7    it under the terms of the GNU General Public License as published by
   8    the Free Software Foundation; either version 2 of the License, or
   9    (at your option) any later version.
  10
  11    This program is distributed in the hope that it will be useful,
  12    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14    GNU General Public License for more details.
  15
  16    You should have received a copy of the GNU General Public License
  17    along with this program; if not, write to the Free Software
  18    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  19
  20    Revision History:
  21
  22    POSIX locking support. Jeremy Allison (jeremy@valinux.com), Apr. 2000.
  23 */
  24
  25 #include "includes.h"
  26
  27 #undef DBGC_CLASS
  28 #define DBGC_CLASS DBGC_LOCKING
  29
  30 /*
  31  * The pending close database handle.
  32  */
  33
  34 static TDB_CONTEXT *posix_pending_close_tdb;
  35
  36 /****************************************************************************
  37  First - the functions that deal with the underlying system locks - these
  38  functions are used no matter if we're mapping CIFS Windows locks or CIFS
  39  POSIX locks onto POSIX.
  40 ****************************************************************************/
  41
  42 /****************************************************************************
  43  Utility function to map a lock type correctly depending on the open
  44  mode of a file.
  45 ****************************************************************************/
  46
  47 static int map_posix_lock_type( files_struct *fsp, enum brl_type lock_type)
  48 {
  49         if((lock_type == WRITE_LOCK) && !fsp->can_write) {
  50                 /*
  51                  * Many UNIX's cannot get a write lock on a file opened read-only.
  52                  * Win32 locking semantics allow this.
  53                  * Do the best we can and attempt a read-only lock.
  54                  */
  55                 DEBUG(10,("map_posix_lock_type: Downgrading write lock to read due to read-only file.\n"));
  56                 return F_RDLCK;
  57         }
  58
  59         /*
  60          * This return should be the most normal, as we attempt
  61          * to always open files read/write.
  62          */
  63
  64         return (lock_type == READ_LOCK) ? F_RDLCK : F_WRLCK;
  65 }
  66
  67 /****************************************************************************
  68  Debugging aid :-).
  69 ****************************************************************************/
  70
  71 static const char *posix_lock_type_name(int lock_type)
  72 {
  73         return (lock_type == F_RDLCK) ? "READ" : "WRITE";
  74 }
  75
  76 /****************************************************************************
  77  Check to see if the given unsigned lock range is within the possible POSIX
  78  range. Modifies the given args to be in range if possible, just returns
  79  False if not.
  80 ****************************************************************************/
  81
  82 static BOOL posix_lock_in_range(SMB_OFF_T *offset_out, SMB_OFF_T *count_out,
  83                                 SMB_BIG_UINT u_offset, SMB_BIG_UINT u_count)
  84 {
  85         SMB_OFF_T offset = (SMB_OFF_T)u_offset;
  86         SMB_OFF_T count = (SMB_OFF_T)u_count;
  87
  88         /*
  89          * For the type of system we are, attempt to
  90          * find the maximum positive lock offset as an SMB_OFF_T.
  91          */
  92
  93 #if defined(MAX_POSITIVE_LOCK_OFFSET) /* Some systems have arbitrary limits. */
  94
  95         SMB_OFF_T max_positive_lock_offset = (MAX_POSITIVE_LOCK_OFFSET);
  96
  97 #elif defined(LARGE_SMB_OFF_T) && !defined(HAVE_BROKEN_FCNTL64_LOCKS)
  98
  99         /*
 100          * In this case SMB_OFF_T is 64 bits,
 101          * and the underlying system can handle 64 bit signed locks.
 102          */
 103
 104         SMB_OFF_T mask2 = ((SMB_OFF_T)0x4) << (SMB_OFF_T_BITS-4);
 105         SMB_OFF_T mask = (mask2<<1);
 106         SMB_OFF_T max_positive_lock_offset = ~mask;
 107
 108 #else /* !LARGE_SMB_OFF_T || HAVE_BROKEN_FCNTL64_LOCKS */
 109
 110         /*
 111          * In this case either SMB_OFF_T is 32 bits,
 112          * or the underlying system cannot handle 64 bit signed locks.
 113          * All offsets & counts must be 2^31 or less.
 114          */
 115
 116         SMB_OFF_T max_positive_lock_offset = 0x7FFFFFFF;
 117
 118 #endif /* !LARGE_SMB_OFF_T || HAVE_BROKEN_FCNTL64_LOCKS */
 119
 120         /*
 121          * POSIX locks of length zero mean lock to end-of-file.
 122          * Win32 locks of length zero are point probes. Ignore
 123          * any Win32 locks of length zero. JRA.
 124          */
 125
 126         if (count == (SMB_OFF_T)0) {
 127                 DEBUG(10,("posix_lock_in_range: count = 0, ignoring.\n"));
 128                 return False;
 129         }
 130
 131         /*
 132          * If the given offset was > max_positive_lock_offset then we cannot map this at all
 133          * ignore this lock.
 134          */
 135
 136         if (u_offset & ~((SMB_BIG_UINT)max_positive_lock_offset)) {
 137                 DEBUG(10,("posix_lock_in_range: (offset = %.0f) offset > %.0f and we cannot handle this. Ignoring lock.\n",
 138                                 (double)u_offset, (double)((SMB_BIG_UINT)max_positive_lock_offset) ));
 139                 return False;
 140         }
 141
 142         /*
 143          * We must truncate the count to less than max_positive_lock_offset.
 144          */
 145
 146         if (u_count & ~((SMB_BIG_UINT)max_positive_lock_offset)) {
 147                 count = max_positive_lock_offset;
 148         }
 149
 150         /*
 151          * Truncate count to end at max lock offset.
 152          */
 153
 154         if (offset + count < 0 || offset + count > max_positive_lock_offset) {
 155                 count = max_positive_lock_offset - offset;
 156         }
 157
 158         /*
 159          * If we ate all the count, ignore this lock.
 160          */
 161
 162         if (count == 0) {
 163                 DEBUG(10,("posix_lock_in_range: Count = 0. Ignoring lock u_offset = %.0f, u_count = %.0f\n",
 164                                 (double)u_offset, (double)u_count ));
 165                 return False;
 166         }
 167
 168         /*
 169          * The mapping was successful.
 170          */
 171
 172         DEBUG(10,("posix_lock_in_range: offset_out = %.0f, count_out = %.0f\n",
 173                         (double)offset, (double)count ));
 174
 175         *offset_out = offset;
 176         *count_out = count;
 177
 178         return True;
 179 }
 180
 181 /****************************************************************************
 182  Actual function that does POSIX locks. Copes with 64 -> 32 bit cruft and
 183  broken NFS implementations.
 184 ****************************************************************************/
 185
 186 static BOOL posix_fcntl_lock(files_struct *fsp, int op, SMB_OFF_T offset, SMB_OFF_T count, int type)
 187 {
 188         BOOL ret;
 189
 190         DEBUG(8,("posix_fcntl_lock %d %d %.0f %.0f %d\n",fsp->fh->fd,op,(double)offset,(double)count,type));
 191
 192         ret = SMB_VFS_LOCK(fsp,fsp->fh->fd,op,offset,count,type);
 193
 194         if (!ret && ((errno == EFBIG) || (errno == ENOLCK) || (errno ==  EINVAL))) {
 195
 196                 DEBUG(0,("posix_fcntl_lock: WARNING: lock request at offset %.0f, length %.0f returned\n",
 197                                         (double)offset,(double)count));
 198                 DEBUG(0,("an %s error. This can happen when using 64 bit lock offsets\n", strerror(errno)));
 199                 DEBUG(0,("on 32 bit NFS mounted file systems.\n"));
 200
 201                 /*
 202                  * If the offset is > 0x7FFFFFFF then this will cause problems on
 203                  * 32 bit NFS mounted filesystems. Just ignore it.
 204                  */
 205
 206                 if (offset & ~((SMB_OFF_T)0x7fffffff)) {
 207                         DEBUG(0,("Offset greater than 31 bits. Returning success.\n"));
 208                         return True;
 209                 }
 210
 211                 if (count & ~((SMB_OFF_T)0x7fffffff)) {
 212                         /* 32 bit NFS file system, retry with smaller offset */
 213                         DEBUG(0,("Count greater than 31 bits - retrying with 31 bit truncated length.\n"));
 214                         errno = 0;
 215                         count &= 0x7fffffff;
 216                         ret = SMB_VFS_LOCK(fsp,fsp->fh->fd,op,offset,count,type);
 217                 }
 218         }
 219
 220         DEBUG(8,("posix_fcntl_lock: Lock call %s\n", ret ? "successful" : "failed"));
 221         return ret;
 222 }
 223
 224 /****************************************************************************
 225  Actual function that gets POSIX locks. Copes with 64 -> 32 bit cruft and
 226  broken NFS implementations.
 227 ****************************************************************************/
 228
 229 static BOOL posix_fcntl_getlock(files_struct *fsp, SMB_OFF_T *poffset, SMB_OFF_T *pcount, int *ptype)
 230 {
 231         pid_t pid;
 232         BOOL ret;
 233
 234         DEBUG(8,("posix_fcntl_getlock %d %.0f %.0f %d\n",
 235                 fsp->fh->fd,(double)*poffset,(double)*pcount,*ptype));
 236
 237         ret = SMB_VFS_GETLOCK(fsp,fsp->fh->fd,poffset,pcount,ptype,&pid);
 238
 239         if (!ret && ((errno == EFBIG) || (errno == ENOLCK) || (errno ==  EINVAL))) {
 240
 241                 DEBUG(0,("posix_fcntl_getlock: WARNING: lock request at offset %.0f, length %.0f returned\n",
 242                                         (double)*poffset,(double)*pcount));
 243                 DEBUG(0,("an %s error. This can happen when using 64 bit lock offsets\n", strerror(errno)));
 244                 DEBUG(0,("on 32 bit NFS mounted file systems.\n"));
 245
 246                 /*
 247                  * If the offset is > 0x7FFFFFFF then this will cause problems on
 248                  * 32 bit NFS mounted filesystems. Just ignore it.
 249                  */
 250
 251                 if (*poffset & ~((SMB_OFF_T)0x7fffffff)) {
 252                         DEBUG(0,("Offset greater than 31 bits. Returning success.\n"));
 253                         return True;
 254                 }
 255
 256                 if (*pcount & ~((SMB_OFF_T)0x7fffffff)) {
 257                         /* 32 bit NFS file system, retry with smaller offset */
 258                         DEBUG(0,("Count greater than 31 bits - retrying with 31 bit truncated length.\n"));
 259                         errno = 0;
 260                         *pcount &= 0x7fffffff;
 261                         ret = SMB_VFS_GETLOCK(fsp,fsp->fh->fd,poffset,pcount,ptype,&pid);
 262                 }
 263         }
 264
 265         DEBUG(8,("posix_fcntl_getlock: Lock query call %s\n", ret ? "successful" : "failed"));
 266         return ret;
 267 }
 268
 269 /****************************************************************************
 270  POSIX function to see if a file region is locked. Returns True if the
 271  region is locked, False otherwise.
 272 ****************************************************************************/
 273
 274 BOOL is_posix_locked(files_struct *fsp,
 275                         SMB_BIG_UINT *pu_offset,
 276                         SMB_BIG_UINT *pu_count,
 277                         enum brl_type *plock_type,
 278                         enum brl_flavour lock_flav)
 279 {
 280         SMB_OFF_T offset;
 281         SMB_OFF_T count;
 282         int posix_lock_type = map_posix_lock_type(fsp,*plock_type);
 283
 284         DEBUG(10,("is_posix_locked: File %s, offset = %.0f, count = %.0f, type = %s\n",
 285                 fsp->fsp_name, (double)*pu_offset, (double)*pu_count, posix_lock_type_name(*plock_type) ));
 286
 287         /*
 288          * If the requested lock won't fit in the POSIX range, we will
 289          * never set it, so presume it is not locked.
 290          */
 291
 292         if(!posix_lock_in_range(&offset, &count, *pu_offset, *pu_count)) {
 293                 return False;
 294         }
 295
 296         if (!posix_fcntl_getlock(fsp,&offset,&count,&posix_lock_type)) {
 297                 return False;
 298         }
 299
 300         if (posix_lock_type == F_UNLCK) {
 301                 return False;
 302         }
 303
 304         if (lock_flav == POSIX_LOCK) {
 305                 /* Only POSIX lock queries need to know the details. */
 306                 *pu_offset = (SMB_BIG_UINT)offset;
 307                 *pu_count = (SMB_BIG_UINT)count;
 308                 *plock_type = (posix_lock_type == F_RDLCK) ? READ_LOCK : WRITE_LOCK;
 309         }
 310         return True;
 311 }
 312
 313 /****************************************************************************
 314  Next - the functions that deal with in memory database storing representations
 315  of either Windows CIFS locks or POSIX CIFS locks.
 316 ****************************************************************************/
 317
 318 /* The key used in the in-memory POSIX databases. */
 319
 320 struct lock_ref_count_key {
 321         SMB_DEV_T device;
 322         SMB_INO_T inode;
 323         char r;
 324 };
 325
 326 struct fd_key {
 327         SMB_DEV_T device;
 328         SMB_INO_T inode;
 329 };
 330
 331 /*******************************************************************
 332  Form a static locking key for a dev/inode pair for the fd array.
 333 ******************************************************************/
 334
 335 static TDB_DATA fd_array_key(SMB_DEV_T dev, SMB_INO_T inode)
 336 {
 337         static struct fd_key key;
 338         TDB_DATA kbuf;
 339
 340         memset(&key, '\0', sizeof(key));
 341         key.device = dev;
 342         key.inode = inode;
 343         kbuf.dptr = (char *)&key;
 344         kbuf.dsize = sizeof(key);
 345         return kbuf;
 346 }
 347
 348 /*******************************************************************
 349  Form a static locking key for a dev/inode pair for the lock ref count
 350 ******************************************************************/
 351
 352 static TDB_DATA locking_ref_count_key(SMB_DEV_T dev, SMB_INO_T inode)
 353 {
 354         static struct lock_ref_count_key key;
 355         TDB_DATA kbuf;
 356
 357         memset(&key, '\0', sizeof(key));
 358         key.device = dev;
 359         key.inode = inode;
 360         key.r = 'r';
 361         kbuf.dptr = (char *)&key;
 362         kbuf.dsize = sizeof(key);
 363         return kbuf;
 364 }
 365
 366 /*******************************************************************
 367  Convenience function to get an fd_array key from an fsp.
 368 ******************************************************************/
 369
 370 static TDB_DATA fd_array_key_fsp(files_struct *fsp)
 371 {
 372         return fd_array_key(fsp->dev, fsp->inode);
 373 }
 374
 375 /*******************************************************************
 376  Convenience function to get a lock ref count key from an fsp.
 377 ******************************************************************/
 378
 379 static TDB_DATA locking_ref_count_key_fsp(files_struct *fsp)
 380 {
 381         return locking_ref_count_key(fsp->dev, fsp->inode);
 382 }
 383
 384 /*******************************************************************
 385  Create the in-memory POSIX lock databases.
 386 ********************************************************************/
 387
 388 BOOL posix_locking_init(int read_only)
 389 {
 390         if (posix_pending_close_tdb) {
 391                 return True;
 392         }
 393
 394         if (!posix_pending_close_tdb) {
 395                 posix_pending_close_tdb = tdb_open_log(NULL, 0, TDB_INTERNAL,
 396                                                    read_only?O_RDONLY:(O_RDWR|O_CREAT), 0644);
 397         }
 398         if (!posix_pending_close_tdb) {
 399                 DEBUG(0,("Failed to open POSIX pending close database.\n"));
 400                 return False;
 401         }
 402
 403         return True;
 404 }
 405
 406 /*******************************************************************
 407  Delete the in-memory POSIX lock databases.
 408 ********************************************************************/
 409
 410 BOOL posix_locking_end(void)
 411 {
 412         if (posix_pending_close_tdb && tdb_close(posix_pending_close_tdb) != 0) {
 413                 return False;
 414         }
 415         return True;
 416 }
 417
 418 /****************************************************************************
 419  Next - the functions that deal with storing fd's that have outstanding
 420  POSIX locks when closed.
 421 ****************************************************************************/
 422
 423 /****************************************************************************
 424  The records in posix_pending_close_tdb are composed of an array of ints
 425  keyed by dev/ino pair.
 426  The first int is a reference count of the number of outstanding locks on
 427  all open fd's on this dev/ino pair. Any subsequent ints are the fd's that
 428  were open on this dev/ino pair that should have been closed, but can't as
 429  the lock ref count is non zero.
 430 ****************************************************************************/
 431
 432 /****************************************************************************
 433  Keep a reference count of the number of Windows locks open on this dev/ino
 434  pair. Creates entry if it doesn't exist.
 435 ****************************************************************************/
 436
 437 static void increment_windows_lock_ref_count(files_struct *fsp)
 438 {
 439         TDB_DATA kbuf = locking_ref_count_key_fsp(fsp);
 440         TDB_DATA dbuf;
 441         int lock_ref_count;
 442
 443         dbuf = tdb_fetch(posix_pending_close_tdb, kbuf);
 444         if (dbuf.dptr == NULL) {
 445                 dbuf.dptr = (char *)SMB_MALLOC_P(int);
 446                 if (!dbuf.dptr) {
 447                         smb_panic("increment_windows_lock_ref_count: malloc fail.\n");
 448                 }
 449                 memset(dbuf.dptr, '\0', sizeof(int));
 450                 dbuf.dsize = sizeof(int);
 451         }
 452
 453         memcpy(&lock_ref_count, dbuf.dptr, sizeof(int));
 454         lock_ref_count++;
 455         memcpy(dbuf.dptr, &lock_ref_count, sizeof(int));
 456
 457         if (tdb_store(posix_pending_close_tdb, kbuf, dbuf, TDB_REPLACE) == -1) {
 458                 smb_panic("increment_windows_lock_ref_count: tdb_store_fail.\n");
 459         }
 460         SAFE_FREE(dbuf.dptr);
 461
 462         DEBUG(10,("increment_windows_lock_ref_count for file now %s = %d\n",
 463                 fsp->fsp_name, lock_ref_count ));
 464 }
 465
 466 static void decrement_windows_lock_ref_count(files_struct *fsp)
 467 {
 468         TDB_DATA kbuf = locking_ref_count_key_fsp(fsp);
 469         TDB_DATA dbuf;
 470         int lock_ref_count;
 471
 472         dbuf = tdb_fetch(posix_pending_close_tdb, kbuf);
 473         if (!dbuf.dptr) {
 474                 smb_panic("decrement_windows_lock_ref_count: logic error.\n");
 475         }
 476
 477         memcpy(&lock_ref_count, dbuf.dptr, sizeof(int));
 478         lock_ref_count--;
 479         memcpy(dbuf.dptr, &lock_ref_count, sizeof(int));
 480
 481         if (lock_ref_count < 0) {
 482                 smb_panic("decrement_windows_lock_ref_count: lock_count logic error.\n");
 483         }
 484
 485         if (tdb_store(posix_pending_close_tdb, kbuf, dbuf, TDB_REPLACE) == -1) {
 486                 smb_panic("decrement_windows_lock_ref_count: tdb_store_fail.\n");
 487         }
 488         SAFE_FREE(dbuf.dptr);
 489
 490         DEBUG(10,("decrement_windows_lock_ref_count for file now %s = %d\n",
 491                 fsp->fsp_name, lock_ref_count ));
 492 }
 493
 494 /****************************************************************************
 495  Bulk delete - subtract as many locks as we've just deleted.
 496 ****************************************************************************/
 497
 498 void reduce_windows_lock_ref_count(files_struct *fsp, unsigned int dcount)
 499 {
 500         TDB_DATA kbuf = locking_ref_count_key_fsp(fsp);
 501         TDB_DATA dbuf;
 502         int lock_ref_count;
 503
 504         dbuf = tdb_fetch(posix_pending_close_tdb, kbuf);
 505         if (!dbuf.dptr) {
 506                 return;
 507         }
 508
 509         memcpy(&lock_ref_count, dbuf.dptr, sizeof(int));
 510         lock_ref_count -= dcount;
 511
 512         if (lock_ref_count < 0) {
 513                 smb_panic("reduce_windows_lock_ref_count: lock_count logic error.\n");
 514         }
 515         memcpy(dbuf.dptr, &lock_ref_count, sizeof(int));
 516
 517         if (tdb_store(posix_pending_close_tdb, kbuf, dbuf, TDB_REPLACE) == -1) {
 518                 smb_panic("reduce_windows_lock_ref_count: tdb_store_fail.\n");
 519         }
 520         SAFE_FREE(dbuf.dptr);
 521
 522         DEBUG(10,("reduce_windows_lock_ref_count for file now %s = %d\n",
 523                 fsp->fsp_name, lock_ref_count ));
 524 }
 525
 526 /****************************************************************************
 527  Fetch the lock ref count.
 528 ****************************************************************************/
 529
 530 static int get_windows_lock_ref_count(files_struct *fsp)
 531 {
 532         TDB_DATA kbuf = locking_ref_count_key_fsp(fsp);
 533         TDB_DATA dbuf;
 534         int lock_ref_count;
 535
 536         dbuf = tdb_fetch(posix_pending_close_tdb, kbuf);
 537         if (!dbuf.dptr) {
 538                 lock_ref_count = 0;
 539         } else {
 540                 memcpy(&lock_ref_count, dbuf.dptr, sizeof(int));
 541         }
 542
 543         DEBUG(10,("get_windows_lock_count for file %s = %d\n",
 544                 fsp->fsp_name, lock_ref_count ));
 545         return lock_ref_count;
 546 }
 547
 548 /****************************************************************************
 549  Delete a lock_ref_count entry.
 550 ****************************************************************************/
 551
 552 static void delete_windows_lock_ref_count(files_struct *fsp)
 553 {
 554         TDB_DATA kbuf = locking_ref_count_key_fsp(fsp);
 555
 556         /* Not a bug if it doesn't exist - no locks were ever granted. */
 557         tdb_delete(posix_pending_close_tdb, kbuf);
 558         DEBUG(10,("delete_windows_lock_ref_count for file %s\n", fsp->fsp_name));
 559 }
 560
 561 /****************************************************************************
 562  Add an fd to the pending close tdb.
 563 ****************************************************************************/
 564
 565 static void add_fd_to_close_entry(files_struct *fsp)
 566 {
 567         TDB_DATA kbuf = fd_array_key_fsp(fsp);
 568         TDB_DATA dbuf;
 569
 570         dbuf.dptr = NULL;
 571         dbuf.dsize = 0;
 572
 573         dbuf = tdb_fetch(posix_pending_close_tdb, kbuf);
 574
 575         dbuf.dptr = SMB_REALLOC(dbuf.dptr, dbuf.dsize + sizeof(int));
 576         if (!dbuf.dptr) {
 577                 smb_panic("add_fd_to_close_entry: Realloc fail !\n");
 578         }
 579
 580         memcpy(dbuf.dptr + dbuf.dsize, &fsp->fh->fd, sizeof(int));
 581         dbuf.dsize += sizeof(int);
 582
 583         if (tdb_store(posix_pending_close_tdb, kbuf, dbuf, TDB_REPLACE) == -1) {
 584                 smb_panic("add_fd_to_close_entry: tdb_store_fail.\n");
 585         }
 586
 587         DEBUG(10,("add_fd_to_close_entry: added fd %d file %s\n",
 588                 fsp->fh->fd, fsp->fsp_name ));
 589
 590         SAFE_FREE(dbuf.dptr);
 591 }
 592
 593 /****************************************************************************
 594  Remove all fd entries for a specific dev/inode pair from the tdb.
 595 ****************************************************************************/
 596
 597 static void delete_close_entries(files_struct *fsp)
 598 {
 599         TDB_DATA kbuf = fd_array_key_fsp(fsp);
 600
 601         if (tdb_delete(posix_pending_close_tdb, kbuf) == -1) {
 602                 smb_panic("delete_close_entries: tdb_delete fail !\n");
 603         }
 604 }
 605
 606 /****************************************************************************
 607  Get the array of POSIX pending close records for an open fsp. Caller must
 608  free. Returns number of entries.
 609 ****************************************************************************/
 610
 611 static size_t get_posix_pending_close_entries(files_struct *fsp, int **entries)
 612 {
 613         TDB_DATA kbuf = fd_array_key_fsp(fsp);
 614         TDB_DATA dbuf;
 615         size_t count = 0;
 616
 617         *entries = NULL;
 618         dbuf.dptr = NULL;
 619
 620         dbuf = tdb_fetch(posix_pending_close_tdb, kbuf);
 621
 622         if (!dbuf.dptr) {
 623                 return 0;
 624         }
 625
 626         *entries = (int *)dbuf.dptr;
 627         count = (size_t)(dbuf.dsize / sizeof(int));
 628
 629         return count;
 630 }
 631
 632 /****************************************************************************
 633  Deal with pending closes needed by POSIX locking support.
 634  Note that posix_locking_close_file() is expected to have been called
 635  to delete all locks on this fsp before this function is called.
 636 ****************************************************************************/
 637
 638 int fd_close_posix(struct connection_struct *conn, files_struct *fsp)
 639 {
 640         int saved_errno = 0;
 641         int ret;
 642         int *fd_array = NULL;
 643         size_t count, i;
 644
 645         if (!lp_locking(SNUM(fsp->conn)) || !lp_posix_locking(SNUM(conn)) || lp_posix_cifsu_locktype()) {
 646                 /*
 647                  * No locking or POSIX to worry about or we want POSIX semantics
 648                  * which will lose all locks on all fd's open on this dev/inode,
 649                  * just close.
 650                  */
 651                 ret = SMB_VFS_CLOSE(fsp,fsp->fh->fd);
 652                 fsp->fh->fd = -1;
 653                 return ret;
 654         }
 655
 656         if (get_windows_lock_ref_count(fsp)) {
 657
 658                 /*
 659                  * There are outstanding locks on this dev/inode pair on other fds.
 660                  * Add our fd to the pending close tdb and set fsp->fh->fd to -1.
 661                  */
 662
 663                 add_fd_to_close_entry(fsp);
 664                 fsp->fh->fd = -1;
 665                 return 0;
 666         }
 667
 668         /*
 669          * No outstanding locks. Get the pending close fd's
 670          * from the tdb and close them all.
 671          */
 672
 673         count = get_posix_pending_close_entries(fsp, &fd_array);
 674
 675         if (count) {
 676                 DEBUG(10,("fd_close_posix: doing close on %u fd's.\n", (unsigned int)count ));
 677
 678                 for(i = 0; i < count; i++) {
 679                         if (SMB_VFS_CLOSE(fsp,fd_array[i]) == -1) {
 680                                 saved_errno = errno;
 681                         }
 682                 }
 683
 684                 /*
 685                  * Delete all fd's stored in the tdb
 686                  * for this dev/inode pair.
 687                  */
 688
 689                 delete_close_entries(fsp);
 690         }
 691
 692         SAFE_FREE(fd_array);
 693
 694         /* Don't need a lock ref count on this dev/ino anymore. */
 695         delete_windows_lock_ref_count(fsp);
 696
 697         /*
 698          * Finally close the fd associated with this fsp.
 699          */
 700
 701         ret = SMB_VFS_CLOSE(fsp,fsp->fh->fd);
 702
 703         if (saved_errno != 0) {
 704                 errno = saved_errno;
 705                 ret = -1;
 706         }
 707
 708         fsp->fh->fd = -1;
 709
 710         return ret;
 711 }
 712
 713 /****************************************************************************
 714  Next - the functions that deal with the mapping CIFS Windows locks onto
 715  the underlying system POSIX locks.
 716 ****************************************************************************/
 717
 718 /*
 719  * Structure used when splitting a lock range
 720  * into a POSIX lock range. Doubly linked list.
 721  */
 722
 723 struct lock_list {
 724         struct lock_list *next;
 725         struct lock_list *prev;
 726         SMB_OFF_T start;
 727         SMB_OFF_T size;
 728 };
 729
 730 /****************************************************************************
 731  Create a list of lock ranges that don't overlap a given range. Used in calculating
 732  POSIX locks and unlocks. This is a difficult function that requires ASCII art to
 733  understand it :-).
 734 ****************************************************************************/
 735
 736 static struct lock_list *posix_lock_list(TALLOC_CTX *ctx,
 737                                                 struct lock_list *lhead,
 738                                                 const struct lock_context *lock_ctx, /* Lock context lhead belongs to. */
 739                                                 files_struct *fsp,
 740                                                 const struct lock_struct *plocks,
 741                                                 int num_locks)
 742 {
 743         int i;
 744
 745         /*
 746          * Check the current lock list on this dev/inode pair.
 747          * Quit if the list is deleted.
 748          */
 749
 750         DEBUG(10,("posix_lock_list: curr: start=%.0f,size=%.0f\n",
 751                 (double)lhead->start, (double)lhead->size ));
 752
 753         for (i=0; i<num_locks && lhead; i++) {
 754                 const struct lock_struct *lock = &plocks[i];
 755                 struct lock_list *l_curr;
 756
 757                 /* Ignore all but read/write locks. */
 758                 if (lock->lock_type != READ_LOCK && lock->lock_type != WRITE_LOCK) {
 759                         continue;
 760                 }
 761
 762                 /* Ignore locks not owned by this process. */
 763                 if (!procid_equal(&lock->context.pid, &lock_ctx->pid)) {
 764                         continue;
 765                 }
 766
 767                 /*
 768                  * Walk the lock list, checking for overlaps. Note that
 769                  * the lock list can expand within this loop if the current
 770                  * range being examined needs to be split.
 771                  */
 772
 773                 for (l_curr = lhead; l_curr;) {
 774
 775                         DEBUG(10,("posix_lock_list: lock: fnum=%d: start=%.0f,size=%.0f:type=%s", lock->fnum,
 776                                 (double)lock->start, (double)lock->size, posix_lock_type_name(lock->lock_type) ));
 777
 778                         if ( (l_curr->start >= (lock->start + lock->size)) ||
 779                                  (lock->start >= (l_curr->start + l_curr->size))) {
 780
 781                                 /* No overlap with existing lock - leave this range alone. */
 782 /*********************************************
 783                                              +---------+
 784                                              | l_curr  |
 785                                              +---------+
 786                                 +-------+
 787                                 | lock  |
 788                                 +-------+
 789 OR....
 790              +---------+
 791              |  l_curr |
 792              +---------+
 793 **********************************************/
 794
 795                                 DEBUG(10,(" no overlap case.\n" ));
 796
 797                                 l_curr = l_curr->next;
 798
 799                         } else if ( (l_curr->start >= lock->start) &&
 800                                                 (l_curr->start + l_curr->size <= lock->start + lock->size) ) {
 801
 802                                 /*
 803                                  * This range is completely overlapped by this existing lock range
 804                                  * and thus should have no effect. Delete it from the list.
 805                                  */
 806 /*********************************************
 807                 +---------+
 808                 |  l_curr |
 809                 +---------+
 810         +---------------------------+
 811         |       lock                |
 812         +---------------------------+
 813 **********************************************/
 814                                 /* Save the next pointer */
 815                                 struct lock_list *ul_next = l_curr->next;
 816
 817                                 DEBUG(10,(" delete case.\n" ));
 818
 819                                 DLIST_REMOVE(lhead, l_curr);
 820                                 if(lhead == NULL) {
 821                                         break; /* No more list... */
 822                                 }
 823
 824                                 l_curr = ul_next;
 825
 826                         } else if ( (l_curr->start >= lock->start) &&
 827                                                 (l_curr->start < lock->start + lock->size) &&
 828                                                 (l_curr->start + l_curr->size > lock->start + lock->size) ) {
 829
 830                                 /*
 831                                  * This range overlaps the existing lock range at the high end.
 832                                  * Truncate by moving start to existing range end and reducing size.
 833                                  */
 834 /*********************************************
 835                 +---------------+
 836                 |  l_curr       |
 837                 +---------------+
 838         +---------------+
 839         |    lock       |
 840         +---------------+
 841 BECOMES....
 842                         +-------+
 843                         | l_curr|
 844                         +-------+
 845 **********************************************/
 846
 847                                 l_curr->size = (l_curr->start + l_curr->size) - (lock->start + lock->size);
 848                                 l_curr->start = lock->start + lock->size;
 849
 850                                 DEBUG(10,(" truncate high case: start=%.0f,size=%.0f\n",
 851                                                                 (double)l_curr->start, (double)l_curr->size ));
 852
 853                                 l_curr = l_curr->next;
 854
 855                         } else if ( (l_curr->start < lock->start) &&
 856                                                 (l_curr->start + l_curr->size > lock->start) &&
 857                                                 (l_curr->start + l_curr->size <= lock->start + lock->size) ) {
 858
 859                                 /*
 860                                  * This range overlaps the existing lock range at the low end.
 861                                  * Truncate by reducing size.
 862                                  */
 863 /*********************************************
 864    +---------------+
 865    |  l_curr       |
 866    +---------------+
 867            +---------------+
 868            |    lock       |
 869            +---------------+
 870 BECOMES....
 871    +-------+
 872    | l_curr|
 873    +-------+
 874 **********************************************/
 875
 876                                 l_curr->size = lock->start - l_curr->start;
 877
 878                                 DEBUG(10,(" truncate low case: start=%.0f,size=%.0f\n",
 879                                                                 (double)l_curr->start, (double)l_curr->size ));
 880
 881                                 l_curr = l_curr->next;
 882
 883                         } else if ( (l_curr->start < lock->start) &&
 884                                                 (l_curr->start + l_curr->size > lock->start + lock->size) ) {
 885                                 /*
 886                                  * Worst case scenario. Range completely overlaps an existing
 887                                  * lock range. Split the request into two, push the new (upper) request
 888                                  * into the dlink list, and continue with the entry after l_new (as we
 889                                  * know that l_new will not overlap with this lock).
 890                                  */
 891 /*********************************************
 892         +---------------------------+
 893         |        l_curr             |
 894         +---------------------------+
 895                 +---------+
 896                 | lock    |
 897                 +---------+
 898 BECOMES.....
 899         +-------+         +---------+
 900         | l_curr|         | l_new   |
 901         +-------+         +---------+
 902 **********************************************/
 903                                 struct lock_list *l_new = TALLOC_P(ctx, struct lock_list);
 904
 905                                 if(l_new == NULL) {
 906                                         DEBUG(0,("posix_lock_list: talloc fail.\n"));
 907                                         return NULL; /* The talloc_destroy takes care of cleanup. */
 908                                 }
 909
 910                                 ZERO_STRUCTP(l_new);
 911                                 l_new->start = lock->start + lock->size;
 912                                 l_new->size = l_curr->start + l_curr->size - l_new->start;
 913
 914                                 /* Truncate the l_curr. */
 915                                 l_curr->size = lock->start - l_curr->start;
 916
 917                                 DEBUG(10,(" split case: curr: start=%.0f,size=%.0f \
 918 new: start=%.0f,size=%.0f\n", (double)l_curr->start, (double)l_curr->size,
 919                                                                 (double)l_new->start, (double)l_new->size ));
 920
 921                                 /*
 922                                  * Add into the dlink list after the l_curr point - NOT at lhead.
 923                                  * Note we can't use DLINK_ADD here as this inserts at the head of the given list.
 924                                  */
 925
 926                                 l_new->prev = l_curr;
 927                                 l_new->next = l_curr->next;
 928                                 l_curr->next = l_new;
 929
 930                                 /* And move after the link we added. */
 931                                 l_curr = l_new->next;
 932
 933                         } else {
 934
 935                                 /*
 936                                  * This logic case should never happen. Ensure this is the
 937                                  * case by forcing an abort.... Remove in production.
 938                                  */
 939                                 pstring msg;
 940
 941                                 slprintf(msg, sizeof(msg)-1, "logic flaw in cases: l_curr: start = %.0f, size = %.0f : \
 942 lock: start = %.0f, size = %.0f\n", (double)l_curr->start, (double)l_curr->size, (double)lock->start, (double)lock->size );
 943
 944                                 smb_panic(msg);
 945                         }
 946                 } /* end for ( l_curr = lhead; l_curr;) */
 947         } /* end for (i=0; i<num_locks && ul_head; i++) */
 948
 949         return lhead;
 950 }
 951
 952 /****************************************************************************
 953  POSIX function to acquire a lock. Returns True if the
 954  lock could be granted, False if not.
 955 ****************************************************************************/
 956
 957 BOOL set_posix_lock_windows_flavour(files_struct *fsp,
 958                         SMB_BIG_UINT u_offset,
 959                         SMB_BIG_UINT u_count,
 960                         enum brl_type lock_type,
 961                         const struct lock_context *lock_ctx,
 962                         const struct lock_struct *plocks,
 963                         int num_locks,
 964                         int *errno_ret)
 965 {
 966         SMB_OFF_T offset;
 967         SMB_OFF_T count;
 968         int posix_lock_type = map_posix_lock_type(fsp,lock_type);
 969         BOOL ret = True;
 970         size_t lock_count;
 971         TALLOC_CTX *l_ctx = NULL;
 972         struct lock_list *llist = NULL;
 973         struct lock_list *ll = NULL;
 974
 975         DEBUG(5,("set_posix_lock_windows_flavour: File %s, offset = %.0f, count = %.0f, type = %s\n",
 976                         fsp->fsp_name, (double)u_offset, (double)u_count, posix_lock_type_name(lock_type) ));
 977
 978         /*
 979          * If the requested lock won't fit in the POSIX range, we will
 980          * pretend it was successful.
 981          */
 982
 983         if(!posix_lock_in_range(&offset, &count, u_offset, u_count)) {
 984                 increment_windows_lock_ref_count(fsp);
 985                 return True;
 986         }
 987
 988         /*
 989          * Windows is very strange. It allows read locks to be overlayed
 990          * (even over a write lock), but leaves the write lock in force until the first
 991          * unlock. It also reference counts the locks. This means the following sequence :
 992          *
 993          * process1                                      process2
 994          * ------------------------------------------------------------------------
 995          * WRITE LOCK : start = 2, len = 10
 996          *                                            READ LOCK: start =0, len = 10 - FAIL
 997          * READ LOCK : start = 0, len = 14
 998          *                                            READ LOCK: start =0, len = 10 - FAIL
 999          * UNLOCK : start = 2, len = 10
1000          *                                            READ LOCK: start =0, len = 10 - OK
1001          *
1002          * Under POSIX, the same sequence in steps 1 and 2 would not be reference counted, but
1003          * would leave a single read lock over the 0-14 region.
1004          */
1005
1006         if ((l_ctx = talloc_init("set_posix_lock")) == NULL) {
1007                 DEBUG(0,("set_posix_lock_windows_flavour: unable to init talloc context.\n"));
1008                 return False;
1009         }
1010
1011         if ((ll = TALLOC_P(l_ctx, struct lock_list)) == NULL) {
1012                 DEBUG(0,("set_posix_lock_windows_flavour: unable to talloc unlock list.\n"));
1013                 talloc_destroy(l_ctx);
1014                 return False;
1015         }
1016
1017         /*
1018          * Create the initial list entry containing the
1019          * lock we want to add.
1020          */
1021
1022         ZERO_STRUCTP(ll);
1023         ll->start = offset;
1024         ll->size = count;
1025
1026         DLIST_ADD(llist, ll);
1027
1028         /*
1029          * The following call calculates if there are any
1030          * overlapping locks held by this process on
1031          * fd's open on the same file and splits this list
1032          * into a list of lock ranges that do not overlap with existing
1033          * POSIX locks.
1034          */
1035
1036         llist = posix_lock_list(l_ctx,
1037                                 llist,
1038                                 lock_ctx, /* Lock context llist belongs to. */
1039                                 fsp,
1040                                 plocks,
1041                                 num_locks);
1042
1043         /*
1044          * Add the POSIX locks on the list of ranges returned.
1045          * As the lock is supposed to be added atomically, we need to
1046          * back out all the locks if any one of these calls fail.
1047          */
1048
1049         for (lock_count = 0, ll = llist; ll; ll = ll->next, lock_count++) {
1050                 offset = ll->start;
1051                 count = ll->size;
1052
1053                 DEBUG(5,("set_posix_lock_windows_flavour: Real lock: Type = %s: offset = %.0f, count = %.0f\n",
1054                         posix_lock_type_name(posix_lock_type), (double)offset, (double)count ));
1055
1056                 if (!posix_fcntl_lock(fsp,SMB_F_SETLK,offset,count,posix_lock_type)) {
1057                         *errno_ret = errno;
1058                         DEBUG(5,("set_posix_lock_windows_flavour: Lock fail !: Type = %s: offset = %.0f, count = %.0f. Errno = %s\n",
1059                                 posix_lock_type_name(posix_lock_type), (double)offset, (double)count, strerror(errno) ));
1060                         ret = False;
1061                         break;
1062                 }
1063         }
1064
1065         if (!ret) {
1066
1067                 /*
1068                  * Back out all the POSIX locks we have on fail.
1069                  */
1070
1071                 for (ll = llist; lock_count; ll = ll->next, lock_count--) {
1072                         offset = ll->start;
1073                         count = ll->size;
1074
1075                         DEBUG(5,("set_posix_lock_windows_flavour: Backing out locks: Type = %s: offset = %.0f, count = %.0f\n",
1076                                 posix_lock_type_name(posix_lock_type), (double)offset, (double)count ));
1077
1078                         posix_fcntl_lock(fsp,SMB_F_SETLK,offset,count,F_UNLCK);
1079                 }
1080         } else {
1081                 /* Remember the number of Windows locks we have on this dev/ino pair. */
1082                 increment_windows_lock_ref_count(fsp);
1083         }
1084
1085         talloc_destroy(l_ctx);
1086         return ret;
1087 }
1088
1089 /****************************************************************************
1090  POSIX function to release a lock. Returns True if the
1091  lock could be released, False if not.
1092 ****************************************************************************/
1093
1094 BOOL release_posix_lock_windows_flavour(files_struct *fsp,
1095                                 SMB_BIG_UINT u_offset,
1096                                 SMB_BIG_UINT u_count,
1097                                 enum brl_type deleted_lock_type,
1098                                 const struct lock_context *lock_ctx,
1099                                 const struct lock_struct *plocks,
1100                                 int num_locks)
1101 {
1102         SMB_OFF_T offset;
1103         SMB_OFF_T count;
1104         BOOL ret = True;
1105         TALLOC_CTX *ul_ctx = NULL;
1106         struct lock_list *ulist = NULL;
1107         struct lock_list *ul = NULL;
1108
1109         DEBUG(5,("release_posix_lock_windows_flavour: File %s, offset = %.0f, count = %.0f\n",
1110                 fsp->fsp_name, (double)u_offset, (double)u_count ));
1111
1112         /* Remember the number of Windows locks we have on this dev/ino pair. */
1113         decrement_windows_lock_ref_count(fsp);
1114
1115         /*
1116          * If the requested lock won't fit in the POSIX range, we will
1117          * pretend it was successful.
1118          */
1119
1120         if(!posix_lock_in_range(&offset, &count, u_offset, u_count)) {
1121                 return True;
1122         }
1123
1124         if ((ul_ctx = talloc_init("release_posix_lock")) == NULL) {
1125                 DEBUG(0,("release_posix_lock_windows_flavour: unable to init talloc context.\n"));
1126                 return False;
1127         }
1128
1129         if ((ul = TALLOC_P(ul_ctx, struct lock_list)) == NULL) {
1130                 DEBUG(0,("release_posix_lock_windows_flavour: unable to talloc unlock list.\n"));
1131                 talloc_destroy(ul_ctx);
1132                 return False;
1133         }
1134
1135         /*
1136          * Create the initial list entry containing the
1137          * lock we want to remove.
1138          */
1139
1140         ZERO_STRUCTP(ul);
1141         ul->start = offset;
1142         ul->size = count;
1143
1144         DLIST_ADD(ulist, ul);
1145
1146         /*
1147          * The following call calculates if there are any
1148          * overlapping locks held by this process on
1149          * fd's open on the same file and creates a
1150          * list of unlock ranges that will allow
1151          * POSIX lock ranges to remain on the file whilst the
1152          * unlocks are performed.
1153          */
1154
1155         ulist = posix_lock_list(ul_ctx,
1156                                 ulist,
1157                                 lock_ctx, /* Lock context ulist belongs to. */
1158                                 fsp,
1159                                 plocks,
1160                                 num_locks);
1161
1162         /*
1163          * If there were any overlapped entries (list is > 1 or size or start have changed),
1164          * and the lock_type we just deleted from
1165          * the upper layer tdb was a write lock, then before doing the unlock we need to downgrade
1166          * the POSIX lock to a read lock. This allows any overlapping read locks
1167          * to be atomically maintained.
1168          */
1169
1170         if (deleted_lock_type == WRITE_LOCK &&
1171                         (!ulist || ulist->next != NULL || ulist->start != offset || ulist->size != count)) {
1172
1173                 DEBUG(5,("release_posix_lock_windows_flavour: downgrading lock to READ: offset = %.0f, count = %.0f\n",
1174                         (double)offset, (double)count ));
1175
1176                 if (!posix_fcntl_lock(fsp,SMB_F_SETLK,offset,count,F_RDLCK)) {
1177                         DEBUG(0,("release_posix_lock_windows_flavour: downgrade of lock failed with error %s !\n", strerror(errno) ));
1178                         talloc_destroy(ul_ctx);
1179                         return False;
1180                 }
1181         }
1182
1183         /*
1184          * Release the POSIX locks on the list of ranges returned.
1185          */
1186
1187         for(; ulist; ulist = ulist->next) {
1188                 offset = ulist->start;
1189                 count = ulist->size;
1190
1191                 DEBUG(5,("release_posix_lock_windows_flavour: Real unlock: offset = %.0f, count = %.0f\n",
1192                         (double)offset, (double)count ));
1193
1194                 if (!posix_fcntl_lock(fsp,SMB_F_SETLK,offset,count,F_UNLCK)) {
1195                         ret = False;
1196                 }
1197         }
1198
1199         talloc_destroy(ul_ctx);
1200         return ret;
1201 }
1202
1203 /****************************************************************************
1204  Next - the functions that deal with mapping CIFS POSIX locks onto
1205  the underlying system POSIX locks.
1206 ****************************************************************************/
1207
1208 /****************************************************************************
1209  POSIX function to acquire a lock. Returns True if the
1210  lock could be granted, False if not.
1211  As POSIX locks don't stack or conflict (they just overwrite)
1212  we can map the requested lock directly onto a system one. We
1213  know it doesn't conflict with locks on other contexts as the
1214  upper layer would have refused it.
1215 ****************************************************************************/
1216
1217 BOOL set_posix_lock_posix_flavour(files_struct *fsp,
1218                         SMB_BIG_UINT u_offset,
1219                         SMB_BIG_UINT u_count,
1220                         enum brl_type lock_type,
1221                         int *errno_ret)
1222 {
1223         SMB_OFF_T offset;
1224         SMB_OFF_T count;
1225         int posix_lock_type = map_posix_lock_type(fsp,lock_type);
1226
1227         DEBUG(5,("set_posix_lock_posix_flavour: File %s, offset = %.0f, count = %.0f, type = %s\n",
1228                         fsp->fsp_name, (double)u_offset, (double)u_count, posix_lock_type_name(lock_type) ));
1229
1230         /*
1231          * If the requested lock won't fit in the POSIX range, we will
1232          * pretend it was successful.
1233          */
1234
1235         if(!posix_lock_in_range(&offset, &count, u_offset, u_count)) {
1236                 return True;
1237         }
1238
1239         if (!posix_fcntl_lock(fsp,SMB_F_SETLK,offset,count,posix_lock_type)) {
1240                 *errno_ret = errno;
1241                 DEBUG(5,("set_posix_lock_posix_flavour: Lock fail !: Type = %s: offset = %.0f, count = %.0f. Errno = %s\n",
1242                         posix_lock_type_name(posix_lock_type), (double)offset, (double)count, strerror(errno) ));
1243                 return False;
1244         }
1245         return True;
1246 }
1247
1248 /****************************************************************************
1249  POSIX function to release a lock. Returns True if the
1250  lock could be released, False if not.
1251  We are given a complete lock state from the upper layer which is what the lock
1252  state should be after the unlock has already been done, so what
1253  we do is punch out holes in the unlock range where locks owned by this process
1254  have a different lock context.
1255 ****************************************************************************/
1256
1257 BOOL release_posix_lock_posix_flavour(files_struct *fsp,
1258                                 SMB_BIG_UINT u_offset,
1259                                 SMB_BIG_UINT u_count,
1260                                 const struct lock_context *lock_ctx,
1261                                 const struct lock_struct *plocks,
1262                                 int num_locks)
1263 {
1264         BOOL ret = True;
1265         SMB_OFF_T offset;
1266         SMB_OFF_T count;
1267         TALLOC_CTX *ul_ctx = NULL;
1268         struct lock_list *ulist = NULL;
1269         struct lock_list *ul = NULL;
1270
1271         DEBUG(5,("release_posix_lock_posix_flavour: File %s, offset = %.0f, count = %.0f\n",
1272                 fsp->fsp_name, (double)u_offset, (double)u_count ));
1273
1274         /*
1275          * If the requested lock won't fit in the POSIX range, we will
1276          * pretend it was successful.
1277          */
1278
1279         if(!posix_lock_in_range(&offset, &count, u_offset, u_count)) {
1280                 return True;
1281         }
1282
1283         if ((ul_ctx = talloc_init("release_posix_lock")) == NULL) {
1284                 DEBUG(0,("release_posix_lock_windows_flavour: unable to init talloc context.\n"));
1285                 return False;
1286         }
1287
1288         if ((ul = TALLOC_P(ul_ctx, struct lock_list)) == NULL) {
1289                 DEBUG(0,("release_posix_lock_windows_flavour: unable to talloc unlock list.\n"));
1290                 talloc_destroy(ul_ctx);
1291                 return False;
1292         }
1293
1294         /*
1295          * Create the initial list entry containing the
1296          * lock we want to remove.
1297          */
1298
1299         ZERO_STRUCTP(ul);
1300         ul->start = offset;
1301         ul->size = count;
1302
1303         DLIST_ADD(ulist, ul);
1304
1305         /*
1306          * Walk the given array creating a linked list
1307          * of unlock requests.
1308          */
1309
1310         ulist = posix_lock_list(ul_ctx,
1311                                 ulist,
1312                                 lock_ctx, /* Lock context ulist belongs to. */
1313                                 fsp,
1314                                 plocks,
1315                                 num_locks);
1316
1317         /*
1318          * Release the POSIX locks on the list of ranges returned.
1319          */
1320
1321         for(; ulist; ulist = ulist->next) {
1322                 offset = ulist->start;
1323                 count = ulist->size;
1324
1325                 DEBUG(5,("release_posix_lock_posix_flavour: Real unlock: offset = %.0f, count = %.0f\n",
1326                         (double)offset, (double)count ));
1327
1328                 if (!posix_fcntl_lock(fsp,SMB_F_SETLK,offset,count,F_UNLCK)) {
1329                         ret = False;
1330                 }
1331         }
1332
1333         talloc_destroy(ul_ctx);
1334         return True;
1335 }