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         SAFE_FREE(dbuf.dptr);
 543
 544         DEBUG(10,("get_windows_lock_count for file %s = %d\n",
 545                 fsp->fsp_name, lock_ref_count ));
 546         return lock_ref_count;
 547 }
 548
 549 /****************************************************************************
 550  Delete a lock_ref_count entry.
 551 ****************************************************************************/
 552
 553 static void delete_windows_lock_ref_count(files_struct *fsp)
 554 {
 555         TDB_DATA kbuf = locking_ref_count_key_fsp(fsp);
 556
 557         /* Not a bug if it doesn't exist - no locks were ever granted. */
 558         tdb_delete(posix_pending_close_tdb, kbuf);
 559         DEBUG(10,("delete_windows_lock_ref_count for file %s\n", fsp->fsp_name));
 560 }
 561
 562 /****************************************************************************
 563  Add an fd to the pending close tdb.
 564 ****************************************************************************/
 565
 566 static void add_fd_to_close_entry(files_struct *fsp)
 567 {
 568         TDB_DATA kbuf = fd_array_key_fsp(fsp);
 569         TDB_DATA dbuf;
 570
 571         dbuf.dptr = NULL;
 572         dbuf.dsize = 0;
 573
 574         dbuf = tdb_fetch(posix_pending_close_tdb, kbuf);
 575
 576         dbuf.dptr = (char *)SMB_REALLOC(dbuf.dptr, dbuf.dsize + sizeof(int));
 577         if (!dbuf.dptr) {
 578                 smb_panic("add_fd_to_close_entry: Realloc fail !\n");
 579         }
 580
 581         memcpy(dbuf.dptr + dbuf.dsize, &fsp->fh->fd, sizeof(int));
 582         dbuf.dsize += sizeof(int);
 583
 584         if (tdb_store(posix_pending_close_tdb, kbuf, dbuf, TDB_REPLACE) == -1) {
 585                 smb_panic("add_fd_to_close_entry: tdb_store_fail.\n");
 586         }
 587
 588         DEBUG(10,("add_fd_to_close_entry: added fd %d file %s\n",
 589                 fsp->fh->fd, fsp->fsp_name ));
 590
 591         SAFE_FREE(dbuf.dptr);
 592 }
 593
 594 /****************************************************************************
 595  Remove all fd entries for a specific dev/inode pair from the tdb.
 596 ****************************************************************************/
 597
 598 static void delete_close_entries(files_struct *fsp)
 599 {
 600         TDB_DATA kbuf = fd_array_key_fsp(fsp);
 601
 602         if (tdb_delete(posix_pending_close_tdb, kbuf) == -1) {
 603                 smb_panic("delete_close_entries: tdb_delete fail !\n");
 604         }
 605 }
 606
 607 /****************************************************************************
 608  Get the array of POSIX pending close records for an open fsp. Caller must
 609  free. Returns number of entries.
 610 ****************************************************************************/
 611
 612 static size_t get_posix_pending_close_entries(files_struct *fsp, int **entries)
 613 {
 614         TDB_DATA kbuf = fd_array_key_fsp(fsp);
 615         TDB_DATA dbuf;
 616         size_t count = 0;
 617
 618         *entries = NULL;
 619         dbuf.dptr = NULL;
 620
 621         dbuf = tdb_fetch(posix_pending_close_tdb, kbuf);
 622
 623         if (!dbuf.dptr) {
 624                 return 0;
 625         }
 626
 627         *entries = (int *)dbuf.dptr;
 628         count = (size_t)(dbuf.dsize / sizeof(int));
 629
 630         return count;
 631 }
 632
 633 /****************************************************************************
 634  Deal with pending closes needed by POSIX locking support.
 635  Note that posix_locking_close_file() is expected to have been called
 636  to delete all locks on this fsp before this function is called.
 637 ****************************************************************************/
 638
 639 int fd_close_posix(struct connection_struct *conn, files_struct *fsp)
 640 {
 641         int saved_errno = 0;
 642         int ret;
 643         int *fd_array = NULL;
 644         size_t count, i;
 645
 646         if (!lp_locking(SNUM(fsp->conn)) || !lp_posix_locking(SNUM(conn))) {
 647                 /*
 648                  * No locking or POSIX to worry about or we want POSIX semantics
 649                  * which will lose all locks on all fd's open on this dev/inode,
 650                  * just close.
 651                  */
 652                 ret = SMB_VFS_CLOSE(fsp,fsp->fh->fd);
 653                 fsp->fh->fd = -1;
 654                 return ret;
 655         }
 656
 657         if (get_windows_lock_ref_count(fsp)) {
 658
 659                 /*
 660                  * There are outstanding locks on this dev/inode pair on other fds.
 661                  * Add our fd to the pending close tdb and set fsp->fh->fd to -1.
 662                  */
 663
 664                 add_fd_to_close_entry(fsp);
 665                 fsp->fh->fd = -1;
 666                 return 0;
 667         }
 668
 669         /*
 670          * No outstanding locks. Get the pending close fd's
 671          * from the tdb and close them all.
 672          */
 673
 674         count = get_posix_pending_close_entries(fsp, &fd_array);
 675
 676         if (count) {
 677                 DEBUG(10,("fd_close_posix: doing close on %u fd's.\n", (unsigned int)count ));
 678
 679                 for(i = 0; i < count; i++) {
 680                         if (SMB_VFS_CLOSE(fsp,fd_array[i]) == -1) {
 681                                 saved_errno = errno;
 682                         }
 683                 }
 684
 685                 /*
 686                  * Delete all fd's stored in the tdb
 687                  * for this dev/inode pair.
 688                  */
 689
 690                 delete_close_entries(fsp);
 691         }
 692
 693         SAFE_FREE(fd_array);
 694
 695         /* Don't need a lock ref count on this dev/ino anymore. */
 696         delete_windows_lock_ref_count(fsp);
 697
 698         /*
 699          * Finally close the fd associated with this fsp.
 700          */
 701
 702         ret = SMB_VFS_CLOSE(fsp,fsp->fh->fd);
 703
 704         if (saved_errno != 0) {
 705                 errno = saved_errno;
 706                 ret = -1;
 707         }
 708
 709         fsp->fh->fd = -1;
 710
 711         return ret;
 712 }
 713
 714 /****************************************************************************
 715  Next - the functions that deal with the mapping CIFS Windows locks onto
 716  the underlying system POSIX locks.
 717 ****************************************************************************/
 718
 719 /*
 720  * Structure used when splitting a lock range
 721  * into a POSIX lock range. Doubly linked list.
 722  */
 723
 724 struct lock_list {
 725         struct lock_list *next;
 726         struct lock_list *prev;
 727         SMB_OFF_T start;
 728         SMB_OFF_T size;
 729 };
 730
 731 /****************************************************************************
 732  Create a list of lock ranges that don't overlap a given range. Used in calculating
 733  POSIX locks and unlocks. This is a difficult function that requires ASCII art to
 734  understand it :-).
 735 ****************************************************************************/
 736
 737 static struct lock_list *posix_lock_list(TALLOC_CTX *ctx,
 738                                                 struct lock_list *lhead,
 739                                                 const struct lock_context *lock_ctx, /* Lock context lhead belongs to. */
 740                                                 files_struct *fsp,
 741                                                 const struct lock_struct *plocks,
 742                                                 int num_locks)
 743 {
 744         int i;
 745
 746         /*
 747          * Check the current lock list on this dev/inode pair.
 748          * Quit if the list is deleted.
 749          */
 750
 751         DEBUG(10,("posix_lock_list: curr: start=%.0f,size=%.0f\n",
 752                 (double)lhead->start, (double)lhead->size ));
 753
 754         for (i=0; i<num_locks && lhead; i++) {
 755                 const struct lock_struct *lock = &plocks[i];
 756                 struct lock_list *l_curr;
 757
 758                 /* Ignore all but read/write locks. */
 759                 if (lock->lock_type != READ_LOCK && lock->lock_type != WRITE_LOCK) {
 760                         continue;
 761                 }
 762
 763                 /* Ignore locks not owned by this process. */
 764                 if (!procid_equal(&lock->context.pid, &lock_ctx->pid)) {
 765                         continue;
 766                 }
 767
 768                 /*
 769                  * Walk the lock list, checking for overlaps. Note that
 770                  * the lock list can expand within this loop if the current
 771                  * range being examined needs to be split.
 772                  */
 773
 774                 for (l_curr = lhead; l_curr;) {
 775
 776                         DEBUG(10,("posix_lock_list: lock: fnum=%d: start=%.0f,size=%.0f:type=%s", lock->fnum,
 777                                 (double)lock->start, (double)lock->size, posix_lock_type_name(lock->lock_type) ));
 778
 779                         if ( (l_curr->start >= (lock->start + lock->size)) ||
 780                                  (lock->start >= (l_curr->start + l_curr->size))) {
 781
 782                                 /* No overlap with existing lock - leave this range alone. */
 783 /*********************************************
 784                                              +---------+
 785                                              | l_curr  |
 786                                              +---------+
 787                                 +-------+
 788                                 | lock  |
 789                                 +-------+
 790 OR....
 791              +---------+
 792              |  l_curr |
 793              +---------+
 794 **********************************************/
 795
 796                                 DEBUG(10,(" no overlap case.\n" ));
 797
 798                                 l_curr = l_curr->next;
 799
 800                         } else if ( (l_curr->start >= lock->start) &&
 801                                                 (l_curr->start + l_curr->size <= lock->start + lock->size) ) {
 802
 803                                 /*
 804                                  * This range is completely overlapped by this existing lock range
 805                                  * and thus should have no effect. Delete it from the list.
 806                                  */
 807 /*********************************************
 808                 +---------+
 809                 |  l_curr |
 810                 +---------+
 811         +---------------------------+
 812         |       lock                |
 813         +---------------------------+
 814 **********************************************/
 815                                 /* Save the next pointer */
 816                                 struct lock_list *ul_next = l_curr->next;
 817
 818                                 DEBUG(10,(" delete case.\n" ));
 819
 820                                 DLIST_REMOVE(lhead, l_curr);
 821                                 if(lhead == NULL) {
 822                                         break; /* No more list... */
 823                                 }
 824
 825                                 l_curr = ul_next;
 826
 827                         } else if ( (l_curr->start >= lock->start) &&
 828                                                 (l_curr->start < lock->start + lock->size) &&
 829                                                 (l_curr->start + l_curr->size > lock->start + lock->size) ) {
 830
 831                                 /*
 832                                  * This range overlaps the existing lock range at the high end.
 833                                  * Truncate by moving start to existing range end and reducing size.
 834                                  */
 835 /*********************************************
 836                 +---------------+
 837                 |  l_curr       |
 838                 +---------------+
 839         +---------------+
 840         |    lock       |
 841         +---------------+
 842 BECOMES....
 843                         +-------+
 844                         | l_curr|
 845                         +-------+
 846 **********************************************/
 847
 848                                 l_curr->size = (l_curr->start + l_curr->size) - (lock->start + lock->size);
 849                                 l_curr->start = lock->start + lock->size;
 850
 851                                 DEBUG(10,(" truncate high case: start=%.0f,size=%.0f\n",
 852                                                                 (double)l_curr->start, (double)l_curr->size ));
 853
 854                                 l_curr = l_curr->next;
 855
 856                         } else if ( (l_curr->start < lock->start) &&
 857                                                 (l_curr->start + l_curr->size > lock->start) &&
 858                                                 (l_curr->start + l_curr->size <= lock->start + lock->size) ) {
 859
 860                                 /*
 861                                  * This range overlaps the existing lock range at the low end.
 862                                  * Truncate by reducing size.
 863                                  */
 864 /*********************************************
 865    +---------------+
 866    |  l_curr       |
 867    +---------------+
 868            +---------------+
 869            |    lock       |
 870            +---------------+
 871 BECOMES....
 872    +-------+
 873    | l_curr|
 874    +-------+
 875 **********************************************/
 876
 877                                 l_curr->size = lock->start - l_curr->start;
 878
 879                                 DEBUG(10,(" truncate low case: start=%.0f,size=%.0f\n",
 880                                                                 (double)l_curr->start, (double)l_curr->size ));
 881
 882                                 l_curr = l_curr->next;
 883
 884                         } else if ( (l_curr->start < lock->start) &&
 885                                                 (l_curr->start + l_curr->size > lock->start + lock->size) ) {
 886                                 /*
 887                                  * Worst case scenario. Range completely overlaps an existing
 888                                  * lock range. Split the request into two, push the new (upper) request
 889                                  * into the dlink list, and continue with the entry after l_new (as we
 890                                  * know that l_new will not overlap with this lock).
 891                                  */
 892 /*********************************************
 893         +---------------------------+
 894         |        l_curr             |
 895         +---------------------------+
 896                 +---------+
 897                 | lock    |
 898                 +---------+
 899 BECOMES.....
 900         +-------+         +---------+
 901         | l_curr|         | l_new   |
 902         +-------+         +---------+
 903 **********************************************/
 904                                 struct lock_list *l_new = TALLOC_P(ctx, struct lock_list);
 905
 906                                 if(l_new == NULL) {
 907                                         DEBUG(0,("posix_lock_list: talloc fail.\n"));
 908                                         return NULL; /* The talloc_destroy takes care of cleanup. */
 909                                 }
 910
 911                                 ZERO_STRUCTP(l_new);
 912                                 l_new->start = lock->start + lock->size;
 913                                 l_new->size = l_curr->start + l_curr->size - l_new->start;
 914
 915                                 /* Truncate the l_curr. */
 916                                 l_curr->size = lock->start - l_curr->start;
 917
 918                                 DEBUG(10,(" split case: curr: start=%.0f,size=%.0f \
 919 new: start=%.0f,size=%.0f\n", (double)l_curr->start, (double)l_curr->size,
 920                                                                 (double)l_new->start, (double)l_new->size ));
 921
 922                                 /*
 923                                  * Add into the dlink list after the l_curr point - NOT at lhead.
 924                                  * Note we can't use DLINK_ADD here as this inserts at the head of the given list.
 925                                  */
 926
 927                                 l_new->prev = l_curr;
 928                                 l_new->next = l_curr->next;
 929                                 l_curr->next = l_new;
 930
 931                                 /* And move after the link we added. */
 932                                 l_curr = l_new->next;
 933
 934                         } else {
 935
 936                                 /*
 937                                  * This logic case should never happen. Ensure this is the
 938                                  * case by forcing an abort.... Remove in production.
 939                                  */
 940                                 pstring msg;
 941
 942                                 slprintf(msg, sizeof(msg)-1, "logic flaw in cases: l_curr: start = %.0f, size = %.0f : \
 943 lock: start = %.0f, size = %.0f\n", (double)l_curr->start, (double)l_curr->size, (double)lock->start, (double)lock->size );
 944
 945                                 smb_panic(msg);
 946                         }
 947                 } /* end for ( l_curr = lhead; l_curr;) */
 948         } /* end for (i=0; i<num_locks && ul_head; i++) */
 949
 950         return lhead;
 951 }
 952
 953 /****************************************************************************
 954  POSIX function to acquire a lock. Returns True if the
 955  lock could be granted, False if not.
 956 ****************************************************************************/
 957
 958 BOOL set_posix_lock_windows_flavour(files_struct *fsp,
 959                         SMB_BIG_UINT u_offset,
 960                         SMB_BIG_UINT u_count,
 961                         enum brl_type lock_type,
 962                         const struct lock_context *lock_ctx,
 963                         const struct lock_struct *plocks,
 964                         int num_locks,
 965                         int *errno_ret)
 966 {
 967         SMB_OFF_T offset;
 968         SMB_OFF_T count;
 969         int posix_lock_type = map_posix_lock_type(fsp,lock_type);
 970         BOOL ret = True;
 971         size_t lock_count;
 972         TALLOC_CTX *l_ctx = NULL;
 973         struct lock_list *llist = NULL;
 974         struct lock_list *ll = NULL;
 975
 976         DEBUG(5,("set_posix_lock_windows_flavour: File %s, offset = %.0f, count = %.0f, type = %s\n",
 977                         fsp->fsp_name, (double)u_offset, (double)u_count, posix_lock_type_name(lock_type) ));
 978
 979         /*
 980          * If the requested lock won't fit in the POSIX range, we will
 981          * pretend it was successful.
 982          */
 983
 984         if(!posix_lock_in_range(&offset, &count, u_offset, u_count)) {
 985                 increment_windows_lock_ref_count(fsp);
 986                 return True;
 987         }
 988
 989         /*
 990          * Windows is very strange. It allows read locks to be overlayed
 991          * (even over a write lock), but leaves the write lock in force until the first
 992          * unlock. It also reference counts the locks. This means the following sequence :
 993          *
 994          * process1                                      process2
 995          * ------------------------------------------------------------------------
 996          * WRITE LOCK : start = 2, len = 10
 997          *                                            READ LOCK: start =0, len = 10 - FAIL
 998          * READ LOCK : start = 0, len = 14
 999          *                                            READ LOCK: start =0, len = 10 - FAIL
1000          * UNLOCK : start = 2, len = 10
1001          *                                            READ LOCK: start =0, len = 10 - OK
1002          *
1003          * Under POSIX, the same sequence in steps 1 and 2 would not be reference counted, but
1004          * would leave a single read lock over the 0-14 region.
1005          */
1006
1007         if ((l_ctx = talloc_init("set_posix_lock")) == NULL) {
1008                 DEBUG(0,("set_posix_lock_windows_flavour: unable to init talloc context.\n"));
1009                 return False;
1010         }
1011
1012         if ((ll = TALLOC_P(l_ctx, struct lock_list)) == NULL) {
1013                 DEBUG(0,("set_posix_lock_windows_flavour: unable to talloc unlock list.\n"));
1014                 talloc_destroy(l_ctx);
1015                 return False;
1016         }
1017
1018         /*
1019          * Create the initial list entry containing the
1020          * lock we want to add.
1021          */
1022
1023         ZERO_STRUCTP(ll);
1024         ll->start = offset;
1025         ll->size = count;
1026
1027         DLIST_ADD(llist, ll);
1028
1029         /*
1030          * The following call calculates if there are any
1031          * overlapping locks held by this process on
1032          * fd's open on the same file and splits this list
1033          * into a list of lock ranges that do not overlap with existing
1034          * POSIX locks.
1035          */
1036
1037         llist = posix_lock_list(l_ctx,
1038                                 llist,
1039                                 lock_ctx, /* Lock context llist belongs to. */
1040                                 fsp,
1041                                 plocks,
1042                                 num_locks);
1043
1044         /*
1045          * Add the POSIX locks on the list of ranges returned.
1046          * As the lock is supposed to be added atomically, we need to
1047          * back out all the locks if any one of these calls fail.
1048          */
1049
1050         for (lock_count = 0, ll = llist; ll; ll = ll->next, lock_count++) {
1051                 offset = ll->start;
1052                 count = ll->size;
1053
1054                 DEBUG(5,("set_posix_lock_windows_flavour: Real lock: Type = %s: offset = %.0f, count = %.0f\n",
1055                         posix_lock_type_name(posix_lock_type), (double)offset, (double)count ));
1056
1057                 if (!posix_fcntl_lock(fsp,SMB_F_SETLK,offset,count,posix_lock_type)) {
1058                         *errno_ret = errno;
1059                         DEBUG(5,("set_posix_lock_windows_flavour: Lock fail !: Type = %s: offset = %.0f, count = %.0f. Errno = %s\n",
1060                                 posix_lock_type_name(posix_lock_type), (double)offset, (double)count, strerror(errno) ));
1061                         ret = False;
1062                         break;
1063                 }
1064         }
1065
1066         if (!ret) {
1067
1068                 /*
1069                  * Back out all the POSIX locks we have on fail.
1070                  */
1071
1072                 for (ll = llist; lock_count; ll = ll->next, lock_count--) {
1073                         offset = ll->start;
1074                         count = ll->size;
1075
1076                         DEBUG(5,("set_posix_lock_windows_flavour: Backing out locks: Type = %s: offset = %.0f, count = %.0f\n",
1077                                 posix_lock_type_name(posix_lock_type), (double)offset, (double)count ));
1078
1079                         posix_fcntl_lock(fsp,SMB_F_SETLK,offset,count,F_UNLCK);
1080                 }
1081         } else {
1082                 /* Remember the number of Windows locks we have on this dev/ino pair. */
1083                 increment_windows_lock_ref_count(fsp);
1084         }
1085
1086         talloc_destroy(l_ctx);
1087         return ret;
1088 }
1089
1090 /****************************************************************************
1091  POSIX function to release a lock. Returns True if the
1092  lock could be released, False if not.
1093 ****************************************************************************/
1094
1095 BOOL release_posix_lock_windows_flavour(files_struct *fsp,
1096                                 SMB_BIG_UINT u_offset,
1097                                 SMB_BIG_UINT u_count,
1098                                 enum brl_type deleted_lock_type,
1099                                 const struct lock_context *lock_ctx,
1100                                 const struct lock_struct *plocks,
1101                                 int num_locks)
1102 {
1103         SMB_OFF_T offset;
1104         SMB_OFF_T count;
1105         BOOL ret = True;
1106         TALLOC_CTX *ul_ctx = NULL;
1107         struct lock_list *ulist = NULL;
1108         struct lock_list *ul = NULL;
1109
1110         DEBUG(5,("release_posix_lock_windows_flavour: File %s, offset = %.0f, count = %.0f\n",
1111                 fsp->fsp_name, (double)u_offset, (double)u_count ));
1112
1113         /* Remember the number of Windows locks we have on this dev/ino pair. */
1114         decrement_windows_lock_ref_count(fsp);
1115
1116         /*
1117          * If the requested lock won't fit in the POSIX range, we will
1118          * pretend it was successful.
1119          */
1120
1121         if(!posix_lock_in_range(&offset, &count, u_offset, u_count)) {
1122                 return True;
1123         }
1124
1125         if ((ul_ctx = talloc_init("release_posix_lock")) == NULL) {
1126                 DEBUG(0,("release_posix_lock_windows_flavour: unable to init talloc context.\n"));
1127                 return False;
1128         }
1129
1130         if ((ul = TALLOC_P(ul_ctx, struct lock_list)) == NULL) {
1131                 DEBUG(0,("release_posix_lock_windows_flavour: unable to talloc unlock list.\n"));
1132                 talloc_destroy(ul_ctx);
1133                 return False;
1134         }
1135
1136         /*
1137          * Create the initial list entry containing the
1138          * lock we want to remove.
1139          */
1140
1141         ZERO_STRUCTP(ul);
1142         ul->start = offset;
1143         ul->size = count;
1144
1145         DLIST_ADD(ulist, ul);
1146
1147         /*
1148          * The following call calculates if there are any
1149          * overlapping locks held by this process on
1150          * fd's open on the same file and creates a
1151          * list of unlock ranges that will allow
1152          * POSIX lock ranges to remain on the file whilst the
1153          * unlocks are performed.
1154          */
1155
1156         ulist = posix_lock_list(ul_ctx,
1157                                 ulist,
1158                                 lock_ctx, /* Lock context ulist belongs to. */
1159                                 fsp,
1160                                 plocks,
1161                                 num_locks);
1162
1163         /*
1164          * If there were any overlapped entries (list is > 1 or size or start have changed),
1165          * and the lock_type we just deleted from
1166          * the upper layer tdb was a write lock, then before doing the unlock we need to downgrade
1167          * the POSIX lock to a read lock. This allows any overlapping read locks
1168          * to be atomically maintained.
1169          */
1170
1171         if (deleted_lock_type == WRITE_LOCK &&
1172                         (!ulist || ulist->next != NULL || ulist->start != offset || ulist->size != count)) {
1173
1174                 DEBUG(5,("release_posix_lock_windows_flavour: downgrading lock to READ: offset = %.0f, count = %.0f\n",
1175                         (double)offset, (double)count ));
1176
1177                 if (!posix_fcntl_lock(fsp,SMB_F_SETLK,offset,count,F_RDLCK)) {
1178                         DEBUG(0,("release_posix_lock_windows_flavour: downgrade of lock failed with error %s !\n", strerror(errno) ));
1179                         talloc_destroy(ul_ctx);
1180                         return False;
1181                 }
1182         }
1183
1184         /*
1185          * Release the POSIX locks on the list of ranges returned.
1186          */
1187
1188         for(; ulist; ulist = ulist->next) {
1189                 offset = ulist->start;
1190                 count = ulist->size;
1191
1192                 DEBUG(5,("release_posix_lock_windows_flavour: Real unlock: offset = %.0f, count = %.0f\n",
1193                         (double)offset, (double)count ));
1194
1195                 if (!posix_fcntl_lock(fsp,SMB_F_SETLK,offset,count,F_UNLCK)) {
1196                         ret = False;
1197                 }
1198         }
1199
1200         talloc_destroy(ul_ctx);
1201         return ret;
1202 }
1203
1204 /****************************************************************************
1205  Next - the functions that deal with mapping CIFS POSIX locks onto
1206  the underlying system POSIX locks.
1207 ****************************************************************************/
1208
1209 /****************************************************************************
1210  POSIX function to acquire a lock. Returns True if the
1211  lock could be granted, False if not.
1212  As POSIX locks don't stack or conflict (they just overwrite)
1213  we can map the requested lock directly onto a system one. We
1214  know it doesn't conflict with locks on other contexts as the
1215  upper layer would have refused it.
1216 ****************************************************************************/
1217
1218 BOOL set_posix_lock_posix_flavour(files_struct *fsp,
1219                         SMB_BIG_UINT u_offset,
1220                         SMB_BIG_UINT u_count,
1221                         enum brl_type lock_type,
1222                         int *errno_ret)
1223 {
1224         SMB_OFF_T offset;
1225         SMB_OFF_T count;
1226         int posix_lock_type = map_posix_lock_type(fsp,lock_type);
1227
1228         DEBUG(5,("set_posix_lock_posix_flavour: File %s, offset = %.0f, count = %.0f, type = %s\n",
1229                         fsp->fsp_name, (double)u_offset, (double)u_count, posix_lock_type_name(lock_type) ));
1230
1231         /*
1232          * If the requested lock won't fit in the POSIX range, we will
1233          * pretend it was successful.
1234          */
1235
1236         if(!posix_lock_in_range(&offset, &count, u_offset, u_count)) {
1237                 return True;
1238         }
1239
1240         if (!posix_fcntl_lock(fsp,SMB_F_SETLK,offset,count,posix_lock_type)) {
1241                 *errno_ret = errno;
1242                 DEBUG(5,("set_posix_lock_posix_flavour: Lock fail !: Type = %s: offset = %.0f, count = %.0f. Errno = %s\n",
1243                         posix_lock_type_name(posix_lock_type), (double)offset, (double)count, strerror(errno) ));
1244                 return False;
1245         }
1246         return True;
1247 }
1248
1249 /****************************************************************************
1250  POSIX function to release a lock. Returns True if the
1251  lock could be released, False if not.
1252  We are given a complete lock state from the upper layer which is what the lock
1253  state should be after the unlock has already been done, so what
1254  we do is punch out holes in the unlock range where locks owned by this process
1255  have a different lock context.
1256 ****************************************************************************/
1257
1258 BOOL release_posix_lock_posix_flavour(files_struct *fsp,
1259                                 SMB_BIG_UINT u_offset,
1260                                 SMB_BIG_UINT u_count,
1261                                 const struct lock_context *lock_ctx,
1262                                 const struct lock_struct *plocks,
1263                                 int num_locks)
1264 {
1265         BOOL ret = True;
1266         SMB_OFF_T offset;
1267         SMB_OFF_T count;
1268         TALLOC_CTX *ul_ctx = NULL;
1269         struct lock_list *ulist = NULL;
1270         struct lock_list *ul = NULL;
1271
1272         DEBUG(5,("release_posix_lock_posix_flavour: File %s, offset = %.0f, count = %.0f\n",
1273                 fsp->fsp_name, (double)u_offset, (double)u_count ));
1274
1275         /*
1276          * If the requested lock won't fit in the POSIX range, we will
1277          * pretend it was successful.
1278          */
1279
1280         if(!posix_lock_in_range(&offset, &count, u_offset, u_count)) {
1281                 return True;
1282         }
1283
1284         if ((ul_ctx = talloc_init("release_posix_lock")) == NULL) {
1285                 DEBUG(0,("release_posix_lock_windows_flavour: unable to init talloc context.\n"));
1286                 return False;
1287         }
1288
1289         if ((ul = TALLOC_P(ul_ctx, struct lock_list)) == NULL) {
1290                 DEBUG(0,("release_posix_lock_windows_flavour: unable to talloc unlock list.\n"));
1291                 talloc_destroy(ul_ctx);
1292                 return False;
1293         }
1294
1295         /*
1296          * Create the initial list entry containing the
1297          * lock we want to remove.
1298          */
1299
1300         ZERO_STRUCTP(ul);
1301         ul->start = offset;
1302         ul->size = count;
1303
1304         DLIST_ADD(ulist, ul);
1305
1306         /*
1307          * Walk the given array creating a linked list
1308          * of unlock requests.
1309          */
1310
1311         ulist = posix_lock_list(ul_ctx,
1312                                 ulist,
1313                                 lock_ctx, /* Lock context ulist belongs to. */
1314                                 fsp,
1315                                 plocks,
1316                                 num_locks);
1317
1318         /*
1319          * Release the POSIX locks on the list of ranges returned.
1320          */
1321
1322         for(; ulist; ulist = ulist->next) {
1323                 offset = ulist->start;
1324                 count = ulist->size;
1325
1326                 DEBUG(5,("release_posix_lock_posix_flavour: Real unlock: offset = %.0f, count = %.0f\n",
1327                         (double)offset, (double)count ));
1328
1329                 if (!posix_fcntl_lock(fsp,SMB_F_SETLK,offset,count,F_UNLCK)) {
1330                         ret = False;
1331                 }
1332         }
1333
1334         talloc_destroy(ul_ctx);
1335         return ret;
1336 }