r16931: Change the underlying lock db to use 32-bit PIDs

not 16. This allows POSIX locks to be more easily
used. Get rid of one more use of a global variable,
global_smbpid. We can get rid of this if we remove
its use in smbd/open.c
Jeremy.

diff --git a/source/include/locking.h b/source/include/locking.h
index 13228c90a562ec3af8188413cfd120350a18fc94..983d59a853fffded14b08687e44c8058483a1fa7 100644 (file)
--- a/source/include/locking.h
+++ b/source/include/locking.h
@@ -33,9 +33,9 @@ enum brl_flavour {WINDOWS_LOCK = 0, POSIX_LOCK = 1};
    this client */
 
 struct lock_context {
-        uint16 smbpid;
-        uint16 tid;
-        struct process_id pid;
+       uint32 smbpid;
+       uint16 tid;
+       struct process_id pid;
 };
 
 /* The key used in the brlock database. */

diff --git a/source/locking/brlock.c b/source/locking/brlock.c
index aec0b48ceed28450f23c96f142754c85f885b56d..9c8a7a17ee6d96e807ac4f0e300bd224693ebd38 100644 (file)
--- a/source/locking/brlock.c
+++ b/source/locking/brlock.c
@@ -676,7 +676,7 @@ static NTSTATUS brl_lock_posix(struct byte_range_lock *br_lck,
 ****************************************************************************/
 
 NTSTATUS brl_lock(struct byte_range_lock *br_lck,
-               uint16 smbpid,
+               uint32 smbpid,
                struct process_id pid,
                br_off start,
                br_off size, 
@@ -1012,7 +1012,7 @@ static BOOL brl_unlock_posix(struct byte_range_lock *br_lck, const struct lock_s
 ****************************************************************************/
 
 BOOL brl_unlock(struct byte_range_lock *br_lck,
-               uint16 smbpid,
+               uint32 smbpid,
                struct process_id pid,
                br_off start,
                br_off size,
@@ -1042,7 +1042,7 @@ BOOL brl_unlock(struct byte_range_lock *br_lck,
 ****************************************************************************/
 
 BOOL brl_locktest(struct byte_range_lock *br_lck,
-               uint16 smbpid,
+               uint32 smbpid,
                struct process_id pid,
                br_off start,
                br_off size, 
@@ -1100,7 +1100,7 @@ BOOL brl_locktest(struct byte_range_lock *br_lck,
 ****************************************************************************/
 
 NTSTATUS brl_lockquery(struct byte_range_lock *br_lck,
-               uint16 *psmbpid,
+               uint32 *psmbpid,
                struct process_id pid,
                br_off *pstart,
                br_off *psize, 
@@ -1169,7 +1169,7 @@ NTSTATUS brl_lockquery(struct byte_range_lock *br_lck,
 ****************************************************************************/
 
 BOOL brl_remove_pending_lock(struct byte_range_lock *br_lck,
-               uint16 smbpid,
+               uint32 smbpid,
                struct process_id pid,
                br_off start,
                br_off size,

diff --git a/source/locking/locking.c b/source/locking/locking.c
index ba81a3ab0edd1af436760c0942d78dc42f39b29b..ac50c9b648fdb7be9eb938ae82a9c5d38c5176f8 100644 (file)
--- a/source/locking/locking.c
+++ b/source/locking/locking.c
@@ -37,7 +37,6 @@
 */
 
 #include "includes.h"
-uint16 global_smbpid;
 
 #undef DBGC_CLASS
 #define DBGC_CLASS DBGC_LOCKING
@@ -74,6 +73,7 @@ const char *lock_flav_name(enum brl_flavour lock_flav)
 ****************************************************************************/
 
 BOOL is_locked(files_struct *fsp,
+               uint32 smbpid,
                SMB_BIG_UINT count,
                SMB_BIG_UINT offset, 
                enum brl_type lock_type)
@@ -105,7 +105,7 @@ BOOL is_locked(files_struct *fsp,
                                return False;
                        }
                        ret = !brl_locktest(br_lck,
-                                       global_smbpid,
+                                       smbpid,
                                        procid_self(),
                                        offset,
                                        count,
@@ -119,7 +119,7 @@ BOOL is_locked(files_struct *fsp,
                        return False;
                }
                ret = !brl_locktest(br_lck,
-                               global_smbpid,
+                               smbpid,
                                procid_self(),
                                offset,
                                count,
@@ -141,7 +141,7 @@ BOOL is_locked(files_struct *fsp,
 ****************************************************************************/
 
 NTSTATUS query_lock(files_struct *fsp,
-                       uint16 *psmbpid,
+                       uint32 *psmbpid,
                        SMB_BIG_UINT *pcount,
                        SMB_BIG_UINT *poffset,
                        enum brl_type *plock_type,
@@ -180,7 +180,7 @@ NTSTATUS query_lock(files_struct *fsp,
 ****************************************************************************/
 
 NTSTATUS do_lock(files_struct *fsp,
-                       uint16 lock_pid,
+                       uint32 lock_pid,
                        SMB_BIG_UINT count,
                        SMB_BIG_UINT offset,
                        enum brl_type lock_type,
@@ -230,7 +230,7 @@ NTSTATUS do_lock(files_struct *fsp,
 ****************************************************************************/
 
 NTSTATUS do_lock_spin(files_struct *fsp,
-                       uint16 lock_pid,
+                       uint32 lock_pid,
                        SMB_BIG_UINT count,
                        SMB_BIG_UINT offset,
                        enum brl_type lock_type,
@@ -286,7 +286,7 @@ NTSTATUS do_lock_spin(files_struct *fsp,
 ****************************************************************************/
 
 NTSTATUS do_unlock(files_struct *fsp,
-                       uint16 lock_pid,
+                       uint32 lock_pid,
                        SMB_BIG_UINT count,
                        SMB_BIG_UINT offset,
                        enum brl_flavour lock_flav)

diff --git a/source/smbd/blocking.c b/source/smbd/blocking.c
index 6b47d0466bd8dd0fec84036e74ae56a8c9133c27..04ab01eb664fef7e2fec9ed2b2388d82223b80ac 100644 (file)
--- a/source/smbd/blocking.c
+++ b/source/smbd/blocking.c
@@ -34,7 +34,7 @@ typedef struct _blocking_lock_record {
        int lock_num;
        SMB_BIG_UINT offset;
        SMB_BIG_UINT count;
-       uint16 lock_pid;
+       uint32 lock_pid;
        enum brl_flavour lock_flav;
        enum brl_type lock_type;
        char *inbuf;
@@ -74,7 +74,7 @@ BOOL push_blocking_lock_request( char *inbuf, int length,
                files_struct *fsp,
                int lock_timeout,
                int lock_num,
-               uint16 lock_pid,
+               uint32 lock_pid,
                enum brl_type lock_type,
                enum brl_flavour lock_flav,
                SMB_BIG_UINT offset, SMB_BIG_UINT count)
@@ -236,7 +236,7 @@ static void reply_lockingX_error(blocking_lock_record *blr, NTSTATUS status)
        files_struct *fsp = blr->fsp;
        uint16 num_ulocks = SVAL(inbuf,smb_vwv6);
        SMB_BIG_UINT count = (SMB_BIG_UINT)0, offset = (SMB_BIG_UINT) 0;
-       uint16 lock_pid;
+       uint32 lock_pid;
        unsigned char locktype = CVAL(inbuf,smb_vwv3);
        BOOL large_file_format = (locktype & LOCKING_ANDX_LARGE_FILES);
        char *data;
@@ -344,7 +344,7 @@ static BOOL process_lockread(blocking_lock_record *blr)
        data = smb_buf(outbuf) + 3;
  
        status = do_lock_spin(fsp,
-                               SVAL(inbuf,smb_pid),
+                               (uint32)SVAL(inbuf,smb_pid),
                                (SMB_BIG_UINT)numtoread,
                                startpos,
                                READ_LOCK,
@@ -417,7 +417,7 @@ static BOOL process_lock(blocking_lock_record *blr)
 
        errno = 0;
        status = do_lock_spin(fsp,
-                               SVAL(inbuf,smb_pid),
+                               (uint32)SVAL(inbuf,smb_pid),
                                count,
                                offset,
                                WRITE_LOCK,
@@ -471,7 +471,7 @@ static BOOL process_lockingX(blocking_lock_record *blr)
        uint16 num_ulocks = SVAL(inbuf,smb_vwv6);
        uint16 num_locks = SVAL(inbuf,smb_vwv7);
        SMB_BIG_UINT count = (SMB_BIG_UINT)0, offset = (SMB_BIG_UINT)0;
-       uint16 lock_pid;
+       uint32 lock_pid;
        BOOL large_file_format = (locktype & LOCKING_ANDX_LARGE_FILES);
        char *data;
        BOOL my_lock_ctx = False;

diff --git a/source/smbd/process.c b/source/smbd/process.c
index bf4854890dea13f63e771c0ca7e4e19f12e8c00b..ce352adfd7d079f7c6d7d7a8f8790a15caf8d6a8 100644 (file)
--- a/source/smbd/process.c
+++ b/source/smbd/process.c
@@ -21,7 +21,7 @@
 
 #include "includes.h"
 
-extern uint16 global_smbpid;
+uint16 global_smbpid;
 extern int keepalive;
 extern struct auth_context *negprot_global_auth_context;
 extern int smb_echo_count;

diff --git a/source/smbd/reply.c b/source/smbd/reply.c
index aadcef6dc1f38810720a37704602d3f464e218bf..ff3c6832e4f33c1cd1eb047e8285166858b5dabf 100644 (file)
--- a/source/smbd/reply.c
+++ b/source/smbd/reply.c
@@ -2325,7 +2325,7 @@ int reply_readbraw(connection_struct *conn, char *inbuf, char *outbuf, int dum_s
        /* ensure we don't overrun the packet size */
        maxcount = MIN(65535,maxcount);
 
-       if (!is_locked(fsp,(SMB_BIG_UINT)maxcount,(SMB_BIG_UINT)startpos, READ_LOCK)) {
+       if (!is_locked(fsp,(uint32)SVAL(inbuf,smb_pid),(SMB_BIG_UINT)maxcount,(SMB_BIG_UINT)startpos, READ_LOCK)) {
                SMB_STRUCT_STAT st;
                SMB_OFF_T size = 0;
   
@@ -2397,7 +2397,7 @@ int reply_lockread(connection_struct *conn, char *inbuf,char *outbuf, int length
         */
        
        status = do_lock_spin(fsp,
-                               SVAL(inbuf,smb_pid), 
+                               (uint32)SVAL(inbuf,smb_pid), 
                                (SMB_BIG_UINT)numtoread,
                                (SMB_BIG_UINT)startpos,
                                WRITE_LOCK,
@@ -2504,7 +2504,7 @@ Returning short read of maximum allowed for compatibility with Windows 2000.\n",
 
        data = smb_buf(outbuf) + 3;
   
-       if (is_locked(fsp,(SMB_BIG_UINT)numtoread,(SMB_BIG_UINT)startpos, READ_LOCK)) {
+       if (is_locked(fsp,(uint32)SVAL(inbuf,smb_pid),(SMB_BIG_UINT)numtoread,(SMB_BIG_UINT)startpos, READ_LOCK)) {
                END_PROFILE(SMBread);
                return ERROR_DOS(ERRDOS,ERRlock);
        }
@@ -2711,7 +2711,7 @@ int reply_read_and_X(connection_struct *conn, char *inbuf,char *outbuf,int lengt
 
        }
 
-       if (is_locked(fsp,(SMB_BIG_UINT)smb_maxcnt,(SMB_BIG_UINT)startpos, READ_LOCK)) {
+       if (is_locked(fsp,(uint32)SVAL(inbuf,smb_pid),(SMB_BIG_UINT)smb_maxcnt,(SMB_BIG_UINT)startpos, READ_LOCK)) {
                END_PROFILE(SMBreadX);
                return ERROR_DOS(ERRDOS,ERRlock);
        }
@@ -2774,7 +2774,7 @@ int reply_writebraw(connection_struct *conn, char *inbuf,char *outbuf, int size,
        SCVAL(inbuf,smb_com,SMBwritec);
        SCVAL(outbuf,smb_com,SMBwritec);
 
-       if (is_locked(fsp,(SMB_BIG_UINT)tcount,(SMB_BIG_UINT)startpos, WRITE_LOCK)) {
+       if (is_locked(fsp,(uint32)SVAL(inbuf,smb_pid),(SMB_BIG_UINT)tcount,(SMB_BIG_UINT)startpos, WRITE_LOCK)) {
                END_PROFILE(SMBwritebraw);
                return(ERROR_DOS(ERRDOS,ERRlock));
        }
@@ -2895,7 +2895,7 @@ int reply_writeunlock(connection_struct *conn, char *inbuf,char *outbuf,
        startpos = IVAL_TO_SMB_OFF_T(inbuf,smb_vwv2);
        data = smb_buf(inbuf) + 3;
   
-       if (numtowrite && is_locked(fsp,(SMB_BIG_UINT)numtowrite,(SMB_BIG_UINT)startpos, WRITE_LOCK)) {
+       if (numtowrite && is_locked(fsp,(uint32)SVAL(inbuf,smb_pid),(SMB_BIG_UINT)numtowrite,(SMB_BIG_UINT)startpos, WRITE_LOCK)) {
                END_PROFILE(SMBwriteunlock);
                return ERROR_DOS(ERRDOS,ERRlock);
        }
@@ -2918,7 +2918,7 @@ int reply_writeunlock(connection_struct *conn, char *inbuf,char *outbuf,
 
        if (numtowrite) {
                status = do_unlock(fsp,
-                               SVAL(inbuf,smb_pid),
+                               (uint32)SVAL(inbuf,smb_pid),
                                (SMB_BIG_UINT)numtowrite, 
                                (SMB_BIG_UINT)startpos,
                                WINDOWS_LOCK);
@@ -2972,7 +2972,7 @@ int reply_write(connection_struct *conn, char *inbuf,char *outbuf,int size,int d
        startpos = IVAL_TO_SMB_OFF_T(inbuf,smb_vwv2);
        data = smb_buf(inbuf) + 3;
   
-       if (is_locked(fsp,(SMB_BIG_UINT)numtowrite,(SMB_BIG_UINT)startpos, WRITE_LOCK)) {
+       if (is_locked(fsp,(uint32)SVAL(inbuf,smb_pid),(SMB_BIG_UINT)numtowrite,(SMB_BIG_UINT)startpos, WRITE_LOCK)) {
                END_PROFILE(SMBwrite);
                return ERROR_DOS(ERRDOS,ERRlock);
        }
@@ -3087,7 +3087,7 @@ int reply_write_and_X(connection_struct *conn, char *inbuf,char *outbuf,int leng
 #endif /* LARGE_SMB_OFF_T */
        }
 
-       if (is_locked(fsp,(SMB_BIG_UINT)numtowrite,(SMB_BIG_UINT)startpos, WRITE_LOCK)) {
+       if (is_locked(fsp,(uint32)SVAL(inbuf,smb_pid),(SMB_BIG_UINT)numtowrite,(SMB_BIG_UINT)startpos, WRITE_LOCK)) {
                END_PROFILE(SMBwriteX);
                return ERROR_DOS(ERRDOS,ERRlock);
        }
@@ -3362,7 +3362,7 @@ int reply_writeclose(connection_struct *conn,
        mtime = srv_make_unix_date3(inbuf+smb_vwv4);
        data = smb_buf(inbuf) + 1;
   
-       if (numtowrite && is_locked(fsp,(SMB_BIG_UINT)numtowrite,(SMB_BIG_UINT)startpos, WRITE_LOCK)) {
+       if (numtowrite && is_locked(fsp,(uint32)SVAL(inbuf,smb_pid),(SMB_BIG_UINT)numtowrite,(SMB_BIG_UINT)startpos, WRITE_LOCK)) {
                END_PROFILE(SMBwriteclose);
                return ERROR_DOS(ERRDOS,ERRlock);
        }
@@ -3433,7 +3433,7 @@ int reply_lock(connection_struct *conn,
                 fsp->fh->fd, fsp->fnum, (double)offset, (double)count));
 
        status = do_lock_spin(fsp,
-                               SVAL(inbuf,smb_pid),
+                               (uint32)SVAL(inbuf,smb_pid),
                                count,
                                offset,
                                WRITE_LOCK,
@@ -3488,7 +3488,7 @@ int reply_unlock(connection_struct *conn, char *inbuf,char *outbuf, int size,
        offset = (SMB_BIG_UINT)IVAL(inbuf,smb_vwv3);
        
        status = do_unlock(fsp,
-                       SVAL(inbuf,smb_pid),
+                       (uint32)SVAL(inbuf,smb_pid),
                        count,
                        offset,
                        WINDOWS_LOCK);
@@ -5079,12 +5079,12 @@ int reply_setdir(connection_struct *conn, char *inbuf,char *outbuf, int dum_size
  Get a lock pid, dealing with large count requests.
 ****************************************************************************/
 
-uint16 get_lock_pid( char *data, int data_offset, BOOL large_file_format)
+uint32 get_lock_pid( char *data, int data_offset, BOOL large_file_format)
 {
        if(!large_file_format)
-               return SVAL(data,SMB_LPID_OFFSET(data_offset));
+               return (uint32)SVAL(data,SMB_LPID_OFFSET(data_offset));
        else
-               return SVAL(data,SMB_LARGE_LPID_OFFSET(data_offset));
+               return (uint32)SVAL(data,SMB_LARGE_LPID_OFFSET(data_offset));
 }
 
 /****************************************************************************
@@ -5221,7 +5221,7 @@ int reply_lockingX(connection_struct *conn, char *inbuf, char *outbuf,
        uint16 num_ulocks = SVAL(inbuf,smb_vwv6);
        uint16 num_locks = SVAL(inbuf,smb_vwv7);
        SMB_BIG_UINT count = 0, offset = 0;
-       uint16 lock_pid;
+       uint32 lock_pid;
        int32 lock_timeout = IVAL(inbuf,smb_vwv4);
        int i;
        char *data;
@@ -5517,7 +5517,7 @@ int reply_readbmpx(connection_struct *conn, char *inbuf,char *outbuf,int length,
        tcount = maxcount;
        total_read = 0;
 
-       if (is_locked(fsp,(SMB_BIG_UINT)maxcount,(SMB_BIG_UINT)startpos, READ_LOCK)) {
+       if (is_locked(fsp,(uint32)SVAL(inbuf,smb_pid),(SMB_BIG_UINT)maxcount,(SMB_BIG_UINT)startpos, READ_LOCK)) {
                END_PROFILE(SMBreadBmpx);
                return ERROR_DOS(ERRDOS,ERRlock);
        }
@@ -5649,7 +5649,7 @@ int reply_writebmpx(connection_struct *conn, char *inbuf,char *outbuf, int size,
                not an SMBwritebmpx - set this up now so we don't forget */
        SCVAL(outbuf,smb_com,SMBwritec);
 
-       if (is_locked(fsp,(SMB_BIG_UINT)tcount,(SMB_BIG_UINT)startpos,WRITE_LOCK)) {
+       if (is_locked(fsp,(uint32)SVAL(inbuf,smb_pid),(SMB_BIG_UINT)tcount,(SMB_BIG_UINT)startpos,WRITE_LOCK)) {
                END_PROFILE(SMBwriteBmpx);
                return(ERROR_DOS(ERRDOS,ERRlock));
        }

diff --git a/source/smbd/trans2.c b/source/smbd/trans2.c
index e4220c597f1f20da700a20563463d282fe185d54..1de1c39be4af3cd8030c2d6577326889482eab56 100644 (file)
--- a/source/smbd/trans2.c
+++ b/source/smbd/trans2.c
@@ -3566,7 +3566,7 @@ total_data=%u (should be %u)\n", (unsigned int)total_data, (unsigned int)IVAL(pd
                        NTSTATUS status = NT_STATUS_INVALID_LEVEL;
                        SMB_BIG_UINT count;
                        SMB_BIG_UINT offset;
-                       uint16 lock_pid;
+                       uint32 lock_pid;
                        enum brl_type lock_type;
 
                        if (total_data != POSIX_LOCK_DATA_SIZE) {
@@ -3587,7 +3587,7 @@ total_data=%u (should be %u)\n", (unsigned int)total_data, (unsigned int)IVAL(pd
                                        return ERROR_NT(NT_STATUS_INVALID_PARAMETER);
                        }
 
-                       lock_pid = (uint16)IVAL(pdata, POSIX_LOCK_PID_OFFSET);
+                       lock_pid = IVAL(pdata, POSIX_LOCK_PID_OFFSET);
 #if defined(HAVE_LONGLONG)
                        offset = (((SMB_BIG_UINT) IVAL(pdata,(POSIX_LOCK_START_OFFSET+4))) << 32) |
                                        ((SMB_BIG_UINT) IVAL(pdata,POSIX_LOCK_START_OFFSET));
@@ -4511,7 +4511,7 @@ size = %.0f, uid = %u, gid = %u, raw perms = 0%o\n",
                {
                        SMB_BIG_UINT count;
                        SMB_BIG_UINT offset;
-                       uint16 lock_pid;
+                       uint32 lock_pid;
                        BOOL lock_blocking;
                        enum brl_type lock_type;
                        BOOL my_lock_ctx;
@@ -4550,7 +4550,7 @@ size = %.0f, uid = %u, gid = %u, raw perms = 0%o\n",
                                return ERROR_NT(NT_STATUS_INVALID_PARAMETER);
                        }
 
-                       lock_pid = (uint16)IVAL(pdata, POSIX_LOCK_PID_OFFSET);
+                       lock_pid = IVAL(pdata, POSIX_LOCK_PID_OFFSET);
 #if defined(HAVE_LONGLONG)
                        offset = (((SMB_BIG_UINT) IVAL(pdata,(POSIX_LOCK_START_OFFSET+4))) << 32) |
                                        ((SMB_BIG_UINT) IVAL(pdata,POSIX_LOCK_START_OFFSET));