r23784: use the GPLv3 boilerplate as recommended by the FSF and the license text
[vlendec/samba-autobuild/.git] / source3 / locking / posix.c
index 806018da8161d13ab474c2c80e1d68127f3b92a6..606f2086732513a693b99259f51d116827e5ba6d 100644 (file)
@@ -5,7 +5,7 @@
    
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
-   the Free Software Foundation; either version 2 of the License, or
+   the Free Software Foundation; either version 3 of the License, or
    (at your option) any later version.
    
    This program is distributed in the hope that it will be useful,
@@ -14,8 +14,7 @@
    GNU General Public License for more details.
    
    You should have received a copy of the GNU General Public License
-   along with this program; if not, write to the Free Software
-   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
    Revision History:
 
@@ -195,8 +194,8 @@ static BOOL posix_fcntl_lock(files_struct *fsp, int op, SMB_OFF_T offset, SMB_OF
 
                DEBUG(0,("posix_fcntl_lock: WARNING: lock request at offset %.0f, length %.0f returned\n",
                                        (double)offset,(double)count));
-               DEBUG(0,("an %s error. This can happen when using 64 bit lock offsets\n", strerror(errno)));
-               DEBUG(0,("on 32 bit NFS mounted file systems.\n"));
+               DEBUGADD(0,("an %s error. This can happen when using 64 bit lock offsets\n", strerror(errno)));
+               DEBUGADD(0,("on 32 bit NFS mounted file systems.\n"));
 
                /*
                 * If the offset is > 0x7FFFFFFF then this will cause problems on
@@ -240,8 +239,8 @@ static BOOL posix_fcntl_getlock(files_struct *fsp, SMB_OFF_T *poffset, SMB_OFF_T
 
                DEBUG(0,("posix_fcntl_getlock: WARNING: lock request at offset %.0f, length %.0f returned\n",
                                        (double)*poffset,(double)*pcount));
-               DEBUG(0,("an %s error. This can happen when using 64 bit lock offsets\n", strerror(errno)));
-               DEBUG(0,("on 32 bit NFS mounted file systems.\n"));
+               DEBUGADD(0,("an %s error. This can happen when using 64 bit lock offsets\n", strerror(errno)));
+               DEBUGADD(0,("on 32 bit NFS mounted file systems.\n"));
 
                /*
                 * If the offset is > 0x7FFFFFFF then this will cause problems on
@@ -318,29 +317,20 @@ BOOL is_posix_locked(files_struct *fsp,
 /* The key used in the in-memory POSIX databases. */
 
 struct lock_ref_count_key {
-       SMB_DEV_T device;
-       SMB_INO_T inode;
+       struct file_id id;
        char r;
 }; 
 
-struct fd_key {
-       SMB_DEV_T device;
-       SMB_INO_T inode;
-}; 
-
 /*******************************************************************
  Form a static locking key for a dev/inode pair for the fd array.
 ******************************************************************/
 
-static TDB_DATA fd_array_key(SMB_DEV_T dev, SMB_INO_T inode)
+static TDB_DATA fd_array_key(struct file_id id)
 {
-       static struct fd_key key;
+       static struct file_id key;
        TDB_DATA kbuf;
-
-       memset(&key, '\0', sizeof(key));
-       key.device = dev;
-       key.inode = inode;
-       kbuf.dptr = (char *)&key;
+       key = id;
+       kbuf.dptr = (uint8 *)&key;
        kbuf.dsize = sizeof(key);
        return kbuf;
 }
@@ -349,16 +339,15 @@ static TDB_DATA fd_array_key(SMB_DEV_T dev, SMB_INO_T inode)
  Form a static locking key for a dev/inode pair for the lock ref count
 ******************************************************************/
 
-static TDB_DATA locking_ref_count_key(SMB_DEV_T dev, SMB_INO_T inode)
+static TDB_DATA locking_ref_count_key(struct file_id id)
 {
        static struct lock_ref_count_key key;
        TDB_DATA kbuf;
 
        memset(&key, '\0', sizeof(key));
-       key.device = dev;
-       key.inode = inode;
+       key.id = id;
        key.r = 'r';
-       kbuf.dptr = (char *)&key;
+       kbuf.dptr = (uint8 *)&key;
        kbuf.dsize = sizeof(key);
        return kbuf;
 }
@@ -369,7 +358,7 @@ static TDB_DATA locking_ref_count_key(SMB_DEV_T dev, SMB_INO_T inode)
 
 static TDB_DATA fd_array_key_fsp(files_struct *fsp)
 {
-       return fd_array_key(fsp->dev, fsp->inode);
+       return fd_array_key(fsp->file_id);
 }
 
 /*******************************************************************
@@ -378,7 +367,7 @@ static TDB_DATA fd_array_key_fsp(files_struct *fsp)
 
 static TDB_DATA locking_ref_count_key_fsp(files_struct *fsp)
 {
-       return locking_ref_count_key(fsp->dev, fsp->inode);
+       return locking_ref_count_key(fsp->file_id);
 }
 
 /*******************************************************************
@@ -442,9 +431,9 @@ static void increment_windows_lock_ref_count(files_struct *fsp)
 
        dbuf = tdb_fetch(posix_pending_close_tdb, kbuf);
        if (dbuf.dptr == NULL) {
-               dbuf.dptr = (char *)SMB_MALLOC_P(int);
+               dbuf.dptr = (uint8 *)SMB_MALLOC_P(int);
                if (!dbuf.dptr) {
-                       smb_panic("increment_windows_lock_ref_count: malloc fail.\n");
+                       smb_panic("increment_windows_lock_ref_count: malloc fail");
                }
                memset(dbuf.dptr, '\0', sizeof(int));
                dbuf.dsize = sizeof(int);
@@ -455,7 +444,7 @@ static void increment_windows_lock_ref_count(files_struct *fsp)
        memcpy(dbuf.dptr, &lock_ref_count, sizeof(int));
        
        if (tdb_store(posix_pending_close_tdb, kbuf, dbuf, TDB_REPLACE) == -1) {
-               smb_panic("increment_windows_lock_ref_count: tdb_store_fail.\n");
+               smb_panic("increment_windows_lock_ref_count: tdb_store_fail");
        }
        SAFE_FREE(dbuf.dptr);
 
@@ -471,7 +460,7 @@ static void decrement_windows_lock_ref_count(files_struct *fsp)
 
        dbuf = tdb_fetch(posix_pending_close_tdb, kbuf);
        if (!dbuf.dptr) {
-               smb_panic("decrement_windows_lock_ref_count: logic error.\n");
+               smb_panic("decrement_windows_lock_ref_count: logic error");
        }
 
        memcpy(&lock_ref_count, dbuf.dptr, sizeof(int));
@@ -479,11 +468,11 @@ static void decrement_windows_lock_ref_count(files_struct *fsp)
        memcpy(dbuf.dptr, &lock_ref_count, sizeof(int));
 
        if (lock_ref_count < 0) {
-               smb_panic("decrement_windows_lock_ref_count: lock_count logic error.\n");
+               smb_panic("decrement_windows_lock_ref_count: lock_count logic error");
        }
 
        if (tdb_store(posix_pending_close_tdb, kbuf, dbuf, TDB_REPLACE) == -1) {
-               smb_panic("decrement_windows_lock_ref_count: tdb_store_fail.\n");
+               smb_panic("decrement_windows_lock_ref_count: tdb_store_fail");
        }
        SAFE_FREE(dbuf.dptr);
 
@@ -510,12 +499,12 @@ void reduce_windows_lock_ref_count(files_struct *fsp, unsigned int dcount)
        lock_ref_count -= dcount;
 
        if (lock_ref_count < 0) {
-               smb_panic("reduce_windows_lock_ref_count: lock_count logic error.\n");
+               smb_panic("reduce_windows_lock_ref_count: lock_count logic error");
        }
        memcpy(dbuf.dptr, &lock_ref_count, sizeof(int));
        
        if (tdb_store(posix_pending_close_tdb, kbuf, dbuf, TDB_REPLACE) == -1) {
-               smb_panic("reduce_windows_lock_ref_count: tdb_store_fail.\n");
+               smb_panic("reduce_windows_lock_ref_count: tdb_store_fail");
        }
        SAFE_FREE(dbuf.dptr);
 
@@ -573,16 +562,16 @@ static void add_fd_to_close_entry(files_struct *fsp)
 
        dbuf = tdb_fetch(posix_pending_close_tdb, kbuf);
 
-       dbuf.dptr = (char *)SMB_REALLOC(dbuf.dptr, dbuf.dsize + sizeof(int));
+       dbuf.dptr = (uint8 *)SMB_REALLOC(dbuf.dptr, dbuf.dsize + sizeof(int));
        if (!dbuf.dptr) {
-               smb_panic("add_fd_to_close_entry: Realloc fail !\n");
+               smb_panic("add_fd_to_close_entry: SMB_REALLOC failed");
        }
 
        memcpy(dbuf.dptr + dbuf.dsize, &fsp->fh->fd, sizeof(int));
        dbuf.dsize += sizeof(int);
 
        if (tdb_store(posix_pending_close_tdb, kbuf, dbuf, TDB_REPLACE) == -1) {
-               smb_panic("add_fd_to_close_entry: tdb_store_fail.\n");
+               smb_panic("add_fd_to_close_entry: tdb_store_fail");
        }
 
        DEBUG(10,("add_fd_to_close_entry: added fd %d file %s\n",
@@ -600,7 +589,7 @@ static void delete_close_entries(files_struct *fsp)
        TDB_DATA kbuf = fd_array_key_fsp(fsp);
 
        if (tdb_delete(posix_pending_close_tdb, kbuf) == -1) {
-               smb_panic("delete_close_entries: tdb_delete fail !\n");
+               smb_panic("delete_close_entries: tdb_delete failed");
        }
 }
 
@@ -636,7 +625,7 @@ static size_t get_posix_pending_close_entries(files_struct *fsp, int **entries)
  to delete all locks on this fsp before this function is called.
 ****************************************************************************/
 
-int fd_close_posix(struct connection_struct *conn, files_struct *fsp)
+NTSTATUS fd_close_posix(struct connection_struct *conn, files_struct *fsp)
 {
        int saved_errno = 0;
        int ret;
@@ -651,7 +640,7 @@ int fd_close_posix(struct connection_struct *conn, files_struct *fsp)
                 */
                ret = SMB_VFS_CLOSE(fsp,fsp->fh->fd);
                fsp->fh->fd = -1;
-               return ret;
+               return map_nt_error_from_unix(errno);
        }
 
        if (get_windows_lock_ref_count(fsp)) {
@@ -663,7 +652,7 @@ int fd_close_posix(struct connection_struct *conn, files_struct *fsp)
 
                add_fd_to_close_entry(fsp);
                fsp->fh->fd = -1;
-               return 0;
+               return NT_STATUS_OK;
        }
 
        /*
@@ -701,14 +690,18 @@ int fd_close_posix(struct connection_struct *conn, files_struct *fsp)
 
        ret = SMB_VFS_CLOSE(fsp,fsp->fh->fd);
 
-       if (saved_errno != 0) {
+       if (ret == 0 && saved_errno != 0) {
                errno = saved_errno;
                ret = -1;
        } 
 
        fsp->fh->fd = -1;
 
-       return ret;
+       if (ret == -1) {
+               return map_nt_error_from_unix(errno);
+       }
+
+       return NT_STATUS_OK;
 }
 
 /****************************************************************************
@@ -940,7 +933,7 @@ new: start=%.0f,size=%.0f\n", (double)l_curr->start, (double)l_curr->size,
                                pstring msg;
 
                                slprintf(msg, sizeof(msg)-1, "logic flaw in cases: l_curr: start = %.0f, size = %.0f : \
-lock: start = %.0f, size = %.0f\n", (double)l_curr->start, (double)l_curr->size, (double)lock->start, (double)lock->size );
+lock: start = %.0f, size = %.0f", (double)l_curr->start, (double)l_curr->size, (double)lock->start, (double)lock->size );
 
                                smb_panic(msg);
                        }