X-Git-Url: http://git.samba.org/samba.git/?a=blobdiff_plain;f=source3%2Fsmbd%2Fblocking.c;h=3983a4cbdfbadeca884e7f7f80f6b155e5e95877;hb=d792569de6123562f929a3e18ce670d6296c98d5;hp=cec1581254333a2d94cddbd97479c907148b1ca2;hpb=61b2794968faa35dc91edce17e9b91e5366c3514;p=ira%2Fwip.git

diff --git a/source3/smbd/blocking.c b/source3/smbd/blocking.c
index cec15812543..3983a4cbdfb 100644
--- a/source3/smbd/blocking.c
+++ b/source3/smbd/blocking.c
@@ -1,8 +1,7 @@
 /* 
-   Unix SMB/Netbios implementation.
-   Version 1.9.
+   Unix SMB/CIFS implementation.
    Blocking Locking functions
-   Copyright (C) Jeremy Allison 1998
+   Copyright (C) Jeremy Allison 1998-2003
    
    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
@@ -20,7 +19,7 @@
 */
 
 #include "includes.h"
-extern int DEBUGLEVEL;
+
 extern char *OutBuffer;
 
 /****************************************************************************
@@ -29,13 +28,16 @@ extern char *OutBuffer;
 *****************************************************************************/
 
 typedef struct {
-  ubi_slNode msg_next;
-  int com_type;
-  files_struct *fsp;
-  time_t expire_time;
-  int lock_num;
-  char *inbuf;
-  int length;
+	ubi_slNode msg_next;
+	int com_type;
+	files_struct *fsp;
+	time_t expire_time;
+	int lock_num;
+	SMB_BIG_UINT offset;
+	SMB_BIG_UINT count;
+	uint16 lock_pid;
+	char *inbuf;
+	int length;
 } blocking_lock_record;
 
 static ubi_slList blocking_lock_queue = { NULL, (ubi_slNodePtr)&blocking_lock_queue, 0};
@@ -46,8 +48,8 @@ static ubi_slList blocking_lock_queue = { NULL, (ubi_slNodePtr)&blocking_lock_qu
 
 static void free_blocking_lock_record(blocking_lock_record *blr)
 {
-  SAFE_FREE(blr->inbuf);
-  SAFE_FREE(blr);
+	SAFE_FREE(blr->inbuf);
+	SAFE_FREE(blr);
 }
 
 /****************************************************************************
@@ -56,17 +58,17 @@ static void free_blocking_lock_record(blocking_lock_record *blr)
 
 static files_struct *get_fsp_from_pkt(char *inbuf)
 {
-  switch(CVAL(inbuf,smb_com)) {
-  case SMBlock:
-  case SMBlockread:
-    return file_fsp(inbuf,smb_vwv0);
-  case SMBlockingX:
-    return file_fsp(inbuf,smb_vwv2);
-  default:
-    DEBUG(0,("get_fsp_from_pkt: PANIC - unknown type on blocking lock queue - exiting.!\n"));
-    exit_server("PANIC - unknown type on blocking lock queue");
-  }
-  return NULL; /* Keep compiler happy. */
+	switch(CVAL(inbuf,smb_com)) {
+		case SMBlock:
+		case SMBlockread:
+			return file_fsp(inbuf,smb_vwv0);
+		case SMBlockingX:
+			return file_fsp(inbuf,smb_vwv2);
+		default:
+			DEBUG(0,("get_fsp_from_pkt: PANIC - unknown type on blocking lock queue - exiting.!\n"));
+			exit_server("PANIC - unknown type on blocking lock queue");
+	}
+	return NULL; /* Keep compiler happy. */
 }
 
 /****************************************************************************
@@ -75,53 +77,81 @@ static files_struct *get_fsp_from_pkt(char *inbuf)
 
 static BOOL in_chained_smb(void)
 {
-  return (chain_size != 0);
+	return (chain_size != 0);
 }
 
+static void received_unlock_msg(int msg_type, pid_t src, void *buf, size_t len);
+
 /****************************************************************************
  Function to push a blocking lock request onto the lock queue.
 ****************************************************************************/
 
-BOOL push_blocking_lock_request( char *inbuf, int length, int lock_timeout, int lock_num)
+BOOL push_blocking_lock_request( char *inbuf, int length, int lock_timeout,
+		int lock_num, uint16 lock_pid, SMB_BIG_UINT offset, SMB_BIG_UINT count)
 {
-  blocking_lock_record *blr;
+	static BOOL set_lock_msg;
+	blocking_lock_record *blr;
+	BOOL my_lock_ctx = False;
+	NTSTATUS status;
 
-  if(in_chained_smb() ) {
-    DEBUG(0,("push_blocking_lock_request: cannot queue a chained request (currently).\n"));
-    return False;
-  }
+	if(in_chained_smb() ) {
+		DEBUG(0,("push_blocking_lock_request: cannot queue a chained request (currently).\n"));
+		return False;
+	}
 
-  /*
-   * Now queue an entry on the blocking lock queue. We setup
-   * the expiration time here.
-   */
+	/*
+	 * Now queue an entry on the blocking lock queue. We setup
+	 * the expiration time here.
+	 */
 
-  if((blr = (blocking_lock_record *)malloc(sizeof(blocking_lock_record))) == NULL) {
-    DEBUG(0,("push_blocking_lock_request: Malloc fail !\n" ));
-    return False;
-  }
+	if((blr = (blocking_lock_record *)malloc(sizeof(blocking_lock_record))) == NULL) {
+		DEBUG(0,("push_blocking_lock_request: Malloc fail !\n" ));
+		return False;
+	}
 
-  if((blr->inbuf = (char *)malloc(length)) == NULL) {
-    DEBUG(0,("push_blocking_lock_request: Malloc fail (2)!\n" ));
-    SAFE_FREE(blr);
-    return False;
-  }
+	if((blr->inbuf = (char *)malloc(length)) == NULL) {
+		DEBUG(0,("push_blocking_lock_request: Malloc fail (2)!\n" ));
+		SAFE_FREE(blr);
+		return False;
+	}
 
-  blr->com_type = CVAL(inbuf,smb_com);
-  blr->fsp = get_fsp_from_pkt(inbuf);
-  blr->expire_time = (lock_timeout == -1) ? (time_t)-1 : time(NULL) + (time_t)lock_timeout;
-  blr->lock_num = lock_num;
-  memcpy(blr->inbuf, inbuf, length);
-  blr->length = length;
+	blr->com_type = CVAL(inbuf,smb_com);
+	blr->fsp = get_fsp_from_pkt(inbuf);
+	blr->expire_time = (lock_timeout == -1) ? (time_t)-1 : time(NULL) + (time_t)lock_timeout;
+	blr->lock_num = lock_num;
+	blr->lock_pid = lock_pid;
+	blr->offset = offset;
+	blr->count = count;
+	memcpy(blr->inbuf, inbuf, length);
+	blr->length = length;
+
+	/* Add a pending lock record for this. */
+	status = brl_lock(blr->fsp->dev, blr->fsp->inode, blr->fsp->fnum,
+			lock_pid, sys_getpid(), blr->fsp->conn->cnum,
+			offset, count, PENDING_LOCK, &my_lock_ctx);
+
+	if (!NT_STATUS_IS_OK(status)) {
+		DEBUG(0,("push_blocking_lock_request: failed to add PENDING_LOCK record.\n"));
+		free_blocking_lock_record(blr);
+		return False;
+	}
 
-  ubi_slAddTail(&blocking_lock_queue, blr);
+	ubi_slAddTail(&blocking_lock_queue, blr);
 
+	/* Ensure we'll receive messages when this is unlocked. */
+	if (!set_lock_msg) {
+		message_register(MSG_SMB_UNLOCK, received_unlock_msg);
+		set_lock_msg = True;
+	}
 
-  DEBUG(3,("push_blocking_lock_request: lock request length=%d blocked with expiry time %d (+%d) \
+	DEBUG(3,("push_blocking_lock_request: lock request length=%d blocked with expiry time %d (+%d) \
 for fnum = %d, name = %s\n", length, (int)blr->expire_time, lock_timeout,
-        blr->fsp->fnum, blr->fsp->fsp_name ));
+		blr->fsp->fnum, blr->fsp->fsp_name ));
+
+	/* Push the MID of this packet on the signing queue. */
+	srv_defer_sign_response(SVAL(inbuf,smb_mid));
 
-  return True;
+	return True;
 }
 
 /****************************************************************************
@@ -134,7 +164,7 @@ static void send_blocking_reply(char *outbuf, int outsize)
 		smb_setlen(outbuf,outsize - 4);
 
 	if (!send_smb(smbd_server_fd(),outbuf))
-		exit_server("send_blocking_reply: send_smb failed.\n");
+		exit_server("send_blocking_reply: send_smb failed.");
 }
 
 /****************************************************************************
@@ -143,27 +173,27 @@ static void send_blocking_reply(char *outbuf, int outsize)
 
 static void reply_lockingX_success(blocking_lock_record *blr)
 {
-  char *outbuf = OutBuffer;
-  int bufsize = BUFFER_SIZE;
-  char *inbuf = blr->inbuf;
-  int outsize = 0;
+	char *outbuf = OutBuffer;
+	int bufsize = BUFFER_SIZE;
+	char *inbuf = blr->inbuf;
+	int outsize = 0;
 
-  construct_reply_common(inbuf, outbuf);
-  set_message(outbuf,2,0,True);
+	construct_reply_common(inbuf, outbuf);
+	set_message(outbuf,2,0,True);
 
-  /*
-   * As this message is a lockingX call we must handle
-   * any following chained message correctly.
-   * This is normally handled in construct_reply(),
-   * but as that calls switch_message, we can't use
-   * that here and must set up the chain info manually.
-   */
+	/*
+	 * As this message is a lockingX call we must handle
+	 * any following chained message correctly.
+	 * This is normally handled in construct_reply(),
+	 * but as that calls switch_message, we can't use
+	 * that here and must set up the chain info manually.
+	 */
 
-  outsize = chain_reply(inbuf,outbuf,blr->length,bufsize);
+	outsize = chain_reply(inbuf,outbuf,blr->length,bufsize);
 
-  outsize += chain_size;
+	outsize += chain_size;
 
-  send_blocking_reply(outbuf,outsize);
+	send_blocking_reply(outbuf,outsize);
 }
 
 /****************************************************************************
@@ -176,9 +206,15 @@ static void generic_blocking_lock_error(blocking_lock_record *blr, NTSTATUS stat
 	char *inbuf = blr->inbuf;
 	construct_reply_common(inbuf, outbuf);
 
+	/* whenever a timeout is given w2k maps LOCK_NOT_GRANTED to
+	   FILE_LOCK_CONFLICT! (tridge) */
+	if (NT_STATUS_EQUAL(status, NT_STATUS_LOCK_NOT_GRANTED)) {
+		status = NT_STATUS_FILE_LOCK_CONFLICT;
+	}
+
 	ERROR_NT(status);
 	if (!send_smb(smbd_server_fd(),outbuf))
-		exit_server("generic_blocking_lock_error: send_smb failed.\n");
+		exit_server("generic_blocking_lock_error: send_smb failed.");
 }
 
 /****************************************************************************
@@ -262,24 +298,25 @@ static BOOL process_lockread(blocking_lock_record *blr)
 	ssize_t nread = -1;
 	char *data, *p;
 	int outsize = 0;
-	SMB_OFF_T startpos;
+	SMB_BIG_UINT startpos;
 	size_t numtoread;
 	NTSTATUS status;
 	connection_struct *conn = conn_find(SVAL(inbuf,smb_tid));
 	files_struct *fsp = blr->fsp;
+	BOOL my_lock_ctx = False;
 
 	numtoread = SVAL(inbuf,smb_vwv1);
-	startpos = IVAL(inbuf,smb_vwv2);
+	startpos = (SMB_BIG_UINT)IVAL(inbuf,smb_vwv2);
 	
 	numtoread = MIN(BUFFER_SIZE-outsize,numtoread);
 	data = smb_buf(outbuf) + 3;
  
-	status = do_lock( fsp, conn, SVAL(inbuf,smb_pid), (SMB_BIG_UINT)numtoread, 
-			  (SMB_BIG_UINT)startpos, READ_LOCK);
+	status = do_lock_spin( fsp, conn, SVAL(inbuf,smb_pid), (SMB_BIG_UINT)numtoread, startpos, READ_LOCK, &my_lock_ctx);
 	if (NT_STATUS_V(status)) {
-		if ((errno != EACCES) && (errno != EAGAIN)) {
+		if (!NT_STATUS_EQUAL(status,NT_STATUS_LOCK_NOT_GRANTED) &&
+			!NT_STATUS_EQUAL(status,NT_STATUS_FILE_LOCK_CONFLICT)) {
 			/*
-			 * We have other than a "can't get lock" POSIX
+			 * We have other than a "can't get lock"
 			 * error. Send an error.
 			 * Return True so we get dequeued.
 			 */
@@ -331,21 +368,22 @@ static BOOL process_lock(blocking_lock_record *blr)
 	char *outbuf = OutBuffer;
 	char *inbuf = blr->inbuf;
 	int outsize;
-	SMB_OFF_T count = 0, offset = 0;
+	SMB_BIG_UINT count = (SMB_BIG_UINT)0, offset = (SMB_BIG_UINT)0;
 	NTSTATUS status;
 	connection_struct *conn = conn_find(SVAL(inbuf,smb_tid));
 	files_struct *fsp = blr->fsp;
+	BOOL my_lock_ctx = False;
 
-	count = IVAL(inbuf,smb_vwv1);
-	offset = IVAL(inbuf,smb_vwv3);
+	count = IVAL_TO_SMB_OFF_T(inbuf,smb_vwv1);
+	offset = IVAL_TO_SMB_OFF_T(inbuf,smb_vwv3);
 
 	errno = 0;
-	status = do_lock(fsp, conn, SVAL(inbuf,smb_pid), (SMB_BIG_UINT)count, 
-			 (SMB_BIG_UINT)offset, WRITE_LOCK);
+	status = do_lock_spin(fsp, conn, SVAL(inbuf,smb_pid), count, offset, WRITE_LOCK, &my_lock_ctx);
 	if (NT_STATUS_IS_ERR(status)) {
-		if((errno != EACCES) && (errno != EAGAIN)) {
+		if (!NT_STATUS_EQUAL(status,NT_STATUS_LOCK_NOT_GRANTED) &&
+			!NT_STATUS_EQUAL(status,NT_STATUS_FILE_LOCK_CONFLICT)) {
 			/*
-			 * We have other than a "can't get lock" POSIX
+			 * We have other than a "can't get lock"
 			 * error. Send an error.
 			 * Return True so we get dequeued.
 			 */
@@ -391,6 +429,7 @@ static BOOL process_lockingX(blocking_lock_record *blr)
 	uint16 lock_pid;
 	BOOL large_file_format = (locktype & LOCKING_ANDX_LARGE_FILES);
 	char *data;
+	BOOL my_lock_ctx = False;
 	NTSTATUS status = NT_STATUS_OK;
 
 	data = smb_buf(inbuf) + ((large_file_format ? 20 : 10)*num_ulocks);
@@ -412,8 +451,8 @@ static BOOL process_lockingX(blocking_lock_record *blr)
 		 * request would never have been queued. JRA.
 		 */
 		errno = 0;
-		status = do_lock(fsp,conn,lock_pid,count,offset, 
-				 ((locktype & 1) ? READ_LOCK : WRITE_LOCK));
+		status = do_lock_spin(fsp,conn,lock_pid,count,offset, 
+				 ((locktype & 1) ? READ_LOCK : WRITE_LOCK), &my_lock_ctx);
 		if (NT_STATUS_IS_ERR(status)) break;
 	}
 
@@ -427,12 +466,13 @@ static BOOL process_lockingX(blocking_lock_record *blr)
 
 		reply_lockingX_success(blr);
 		return True;
-	} else if ((errno != EACCES) && (errno != EAGAIN)) {
-		/*
-		 * We have other than a "can't get lock" POSIX
-		 * error. Free any locks we had and return an error.
-		 * Return True so we get dequeued.
-		 */
+	} else if (!NT_STATUS_EQUAL(status,NT_STATUS_LOCK_NOT_GRANTED) &&
+			!NT_STATUS_EQUAL(status,NT_STATUS_FILE_LOCK_CONFLICT)) {
+			/*
+			 * We have other than a "can't get lock"
+			 * error. Free any locks we had and return an error.
+			 * Return True so we get dequeued.
+			 */
 		
 		blocking_lock_reply_error(blr, status);
 		return True;
@@ -456,18 +496,18 @@ Waiting....\n",
 
 static BOOL blocking_lock_record_process(blocking_lock_record *blr)
 {
-  switch(blr->com_type) {
-  case SMBlock:
-    return process_lock(blr);
-  case SMBlockread:
-    return process_lockread(blr);
-  case SMBlockingX:
-    return process_lockingX(blr);
-  default:
-    DEBUG(0,("blocking_lock_record_process: PANIC - unknown type on blocking lock queue - exiting.!\n"));
-    exit_server("PANIC - unknown type on blocking lock queue");
-  }
-  return False; /* Keep compiler happy. */
+	switch(blr->com_type) {
+		case SMBlock:
+			return process_lock(blr);
+		case SMBlockread:
+			return process_lockread(blr);
+		case SMBlockingX:
+			return process_lockingX(blr);
+		default:
+			DEBUG(0,("blocking_lock_record_process: PANIC - unknown type on blocking lock queue - exiting.!\n"));
+			exit_server("PANIC - unknown type on blocking lock queue");
+	}
+	return False; /* Keep compiler happy. */
 }
 
 /****************************************************************************
@@ -476,23 +516,27 @@ static BOOL blocking_lock_record_process(blocking_lock_record *blr)
 
 void remove_pending_lock_requests_by_fid(files_struct *fsp)
 {
-  blocking_lock_record *blr = (blocking_lock_record *)ubi_slFirst( &blocking_lock_queue );
-  blocking_lock_record *prev = NULL;
+	blocking_lock_record *blr = (blocking_lock_record *)ubi_slFirst( &blocking_lock_queue );
+	blocking_lock_record *prev = NULL;
 
-  while(blr != NULL) {
-    if(blr->fsp->fnum == fsp->fnum) {
+	while(blr != NULL) {
+		if(blr->fsp->fnum == fsp->fnum) {
 
-      DEBUG(10,("remove_pending_lock_requests_by_fid - removing request type %d for \
+			DEBUG(10,("remove_pending_lock_requests_by_fid - removing request type %d for \
 file %s fnum = %d\n", blr->com_type, fsp->fsp_name, fsp->fnum ));
 
-      free_blocking_lock_record((blocking_lock_record *)ubi_slRemNext( &blocking_lock_queue, prev));
-      blr = (blocking_lock_record *)(prev ? ubi_slNext(prev) : ubi_slFirst(&blocking_lock_queue));
-      continue;
-    }
+			brl_unlock(blr->fsp->dev, blr->fsp->inode, blr->fsp->fnum,
+				blr->lock_pid, sys_getpid(), blr->fsp->conn->cnum,
+				blr->offset, blr->count, True, NULL, NULL);
 
-    prev = blr;
-    blr = (blocking_lock_record *)ubi_slNext(blr);
-  }
+			free_blocking_lock_record((blocking_lock_record *)ubi_slRemNext( &blocking_lock_queue, prev));
+			blr = (blocking_lock_record *)(prev ? ubi_slNext(prev) : ubi_slFirst(&blocking_lock_queue));
+			continue;
+		}
+
+		prev = blr;
+		blr = (blocking_lock_record *)ubi_slNext(blr);
+	}
 }
 
 /****************************************************************************
@@ -501,35 +545,68 @@ file %s fnum = %d\n", blr->com_type, fsp->fsp_name, fsp->fnum ));
 
 void remove_pending_lock_requests_by_mid(int mid)
 {
-  blocking_lock_record *blr = (blocking_lock_record *)ubi_slFirst( &blocking_lock_queue );
-  blocking_lock_record *prev = NULL;
+	blocking_lock_record *blr = (blocking_lock_record *)ubi_slFirst( &blocking_lock_queue );
+	blocking_lock_record *prev = NULL;
 
-  while(blr != NULL) {
-    if(SVAL(blr->inbuf,smb_mid) == mid) {
-      files_struct *fsp = blr->fsp;
+	while(blr != NULL) {
+		if(SVAL(blr->inbuf,smb_mid) == mid) {
+			files_struct *fsp = blr->fsp;
 
-      DEBUG(10,("remove_pending_lock_requests_by_mid - removing request type %d for \
+			DEBUG(10,("remove_pending_lock_requests_by_mid - removing request type %d for \
 file %s fnum = %d\n", blr->com_type, fsp->fsp_name, fsp->fnum ));
 
-      blocking_lock_reply_error(blr,NT_STATUS_CANCELLED);
-      free_blocking_lock_record((blocking_lock_record *)ubi_slRemNext( &blocking_lock_queue, prev));
-      blr = (blocking_lock_record *)(prev ? ubi_slNext(prev) : ubi_slFirst(&blocking_lock_queue));
-      continue;
-    }
+			blocking_lock_reply_error(blr,NT_STATUS_FILE_LOCK_CONFLICT);
+			brl_unlock(blr->fsp->dev, blr->fsp->inode, blr->fsp->fnum,
+				blr->lock_pid, sys_getpid(), blr->fsp->conn->cnum,
+				blr->offset, blr->count, True, NULL, NULL);
+			free_blocking_lock_record((blocking_lock_record *)ubi_slRemNext( &blocking_lock_queue, prev));
+			blr = (blocking_lock_record *)(prev ? ubi_slNext(prev) : ubi_slFirst(&blocking_lock_queue));
+			continue;
+		}
 
-    prev = blr;
-    blr = (blocking_lock_record *)ubi_slNext(blr);
-  }
+		prev = blr;
+		blr = (blocking_lock_record *)ubi_slNext(blr);
+	}
 }
 
 /****************************************************************************
- Return True if the blocking lock queue has entries.
+  Set a flag as an unlock request affects one of our pending locks.
 *****************************************************************************/
 
-BOOL blocking_locks_pending(void)
+static void received_unlock_msg(int msg_type, pid_t src, void *buf, size_t len)
 {
-  blocking_lock_record *blr = (blocking_lock_record *)ubi_slFirst( &blocking_lock_queue );
-  return (blr == NULL ? False : True);
+	DEBUG(10,("received_unlock_msg\n"));
+	process_blocking_lock_queue(time(NULL));
+}
+
+/****************************************************************************
+ Return the number of seconds to the next blocking locks timeout, or default_timeout
+*****************************************************************************/
+
+unsigned blocking_locks_timeout(unsigned default_timeout)
+{
+	unsigned timeout = default_timeout;
+	time_t t;
+	blocking_lock_record *blr = (blocking_lock_record *)ubi_slFirst(&blocking_lock_queue);
+
+	/* note that we avoid the time() syscall if there are no blocking locks */
+	if (!blr)
+		return timeout;
+
+	t = time(NULL);
+
+	while (blr) {
+		if ((blr->expire_time != (time_t)-1) &&
+					(timeout > (blr->expire_time - t))) {
+			timeout = blr->expire_time - t;
+		}
+		blr = (blocking_lock_record *)ubi_slNext(blr);
+	}
+
+	if (timeout < 1)
+		timeout = 1;
+
+	return timeout;
 }
 
 /****************************************************************************
@@ -538,93 +615,112 @@ BOOL blocking_locks_pending(void)
 
 void process_blocking_lock_queue(time_t t)
 {
-  blocking_lock_record *blr = (blocking_lock_record *)ubi_slFirst( &blocking_lock_queue );
-  blocking_lock_record *prev = NULL;
-
-  if(blr == NULL)
-    return;
-
-  /*
-   * Go through the queue and see if we can get any of the locks.
-   */
-
-  while(blr != NULL) {
-    connection_struct *conn = NULL;
-    uint16 vuid;
-    files_struct *fsp = NULL;
-
-    /*
-     * Ensure we don't have any old chain_fsp values
-     * sitting around....
-     */
-    chain_size = 0;
-    file_chain_reset();
-    fsp = blr->fsp;
-
-    conn = conn_find(SVAL(blr->inbuf,smb_tid));
-    vuid = (lp_security() == SEC_SHARE) ? UID_FIELD_INVALID :
-                  SVAL(blr->inbuf,smb_uid);
-
-    DEBUG(5,("process_blocking_lock_queue: examining pending lock fnum = %d for file %s\n",
-          fsp->fnum, fsp->fsp_name ));
-
-    if((blr->expire_time != -1) && (blr->expire_time > t)) {
-      /*
-       * Lock expired - throw away all previously
-       * obtained locks and return lock error.
-       */
-      DEBUG(5,("process_blocking_lock_queue: pending lock fnum = %d for file %s timed out.\n",
-          fsp->fnum, fsp->fsp_name ));
-
-      blocking_lock_reply_error(blr,NT_STATUS_ACCESS_DENIED);
-      free_blocking_lock_record((blocking_lock_record *)ubi_slRemNext( &blocking_lock_queue, prev));
-      blr = (blocking_lock_record *)(prev ? ubi_slNext(prev) : ubi_slFirst(&blocking_lock_queue));
-      continue;
-    }
-
-    if(!become_user(conn,vuid)) {
-      DEBUG(0,("process_blocking_lock_queue: Unable to become user vuid=%d.\n",
-            vuid ));
-      /*
-       * Remove the entry and return an error to the client.
-       */
-      blocking_lock_reply_error(blr,NT_STATUS_ACCESS_DENIED);
-      free_blocking_lock_record((blocking_lock_record *)ubi_slRemNext( &blocking_lock_queue, prev));
-      blr = (blocking_lock_record *)(prev ? ubi_slNext(prev) : ubi_slFirst(&blocking_lock_queue));
-      continue;
-    }
-
-    if(!become_service(conn,True)) {
-      DEBUG(0,("process_blocking_lock_queue: Unable to become service Error was %s.\n", strerror(errno) ));
-      /*
-       * Remove the entry and return an error to the client.
-       */
-      blocking_lock_reply_error(blr,NT_STATUS_ACCESS_DENIED);
-      free_blocking_lock_record((blocking_lock_record *)ubi_slRemNext( &blocking_lock_queue, prev));
-      blr = (blocking_lock_record *)(prev ? ubi_slNext(prev) : ubi_slFirst(&blocking_lock_queue));
-      unbecome_user();
-      continue;
-    }
-
-    /*
-     * Go through the remaining locks and try and obtain them.
-     * The call returns True if all locks were obtained successfully
-     * and False if we still need to wait.
-     */
-
-    if(blocking_lock_record_process(blr)) {
-      free_blocking_lock_record((blocking_lock_record *)ubi_slRemNext( &blocking_lock_queue, prev));
-      blr = (blocking_lock_record *)(prev ? ubi_slNext(prev) : ubi_slFirst(&blocking_lock_queue));
-      unbecome_user();
-      continue;
-    }
-
-    unbecome_user();
-
-    /*
-     * Move to the next in the list.
-     */
-    prev = blr;
-    blr = (blocking_lock_record *)ubi_slNext(blr);
-  }
+	blocking_lock_record *blr = (blocking_lock_record *)ubi_slFirst( &blocking_lock_queue );
+	blocking_lock_record *prev = NULL;
+
+	if(blr == NULL)
+		return;
+
+	/*
+	 * Go through the queue and see if we can get any of the locks.
+	 */
+
+	while(blr != NULL) {
+		connection_struct *conn = NULL;
+		uint16 vuid;
+		files_struct *fsp = NULL;
+
+		/*
+		 * Ensure we don't have any old chain_fsp values
+		 * sitting around....
+		 */
+		chain_size = 0;
+		file_chain_reset();
+		fsp = blr->fsp;
+
+		conn = conn_find(SVAL(blr->inbuf,smb_tid));
+		vuid = (lp_security() == SEC_SHARE) ? UID_FIELD_INVALID :
+				SVAL(blr->inbuf,smb_uid);
+
+		DEBUG(5,("process_blocking_lock_queue: examining pending lock fnum = %d for file %s\n",
+			fsp->fnum, fsp->fsp_name ));
+
+		if((blr->expire_time != -1) && (blr->expire_time <= t)) {
+			/*
+			 * Lock expired - throw away all previously
+			 * obtained locks and return lock error.
+			 */
+			DEBUG(5,("process_blocking_lock_queue: pending lock fnum = %d for file %s timed out.\n",
+				fsp->fnum, fsp->fsp_name ));
+
+			brl_unlock(fsp->dev, fsp->inode, fsp->fnum,
+				blr->lock_pid, sys_getpid(), conn->cnum,
+				blr->offset, blr->count, True, NULL, NULL);
+
+			blocking_lock_reply_error(blr,NT_STATUS_FILE_LOCK_CONFLICT);
+			free_blocking_lock_record((blocking_lock_record *)ubi_slRemNext( &blocking_lock_queue, prev));
+			blr = (blocking_lock_record *)(prev ? ubi_slNext(prev) : ubi_slFirst(&blocking_lock_queue));
+			continue;
+		}
+
+		if(!change_to_user(conn,vuid)) {
+			DEBUG(0,("process_blocking_lock_queue: Unable to become user vuid=%d.\n",
+				vuid ));
+			/*
+			 * Remove the entry and return an error to the client.
+			 */
+			blocking_lock_reply_error(blr,NT_STATUS_ACCESS_DENIED);
+
+			brl_unlock(fsp->dev, fsp->inode, fsp->fnum,
+					blr->lock_pid, sys_getpid(), conn->cnum,
+					blr->offset, blr->count, True, NULL, NULL);
+
+			free_blocking_lock_record((blocking_lock_record *)ubi_slRemNext( &blocking_lock_queue, prev));
+			blr = (blocking_lock_record *)(prev ? ubi_slNext(prev) : ubi_slFirst(&blocking_lock_queue));
+			continue;
+		}
+
+		if(!set_current_service(conn,SVAL(blr->inbuf,smb_flg),True)) {
+			DEBUG(0,("process_blocking_lock_queue: Unable to become service Error was %s.\n", strerror(errno) ));
+			/*
+			 * Remove the entry and return an error to the client.
+			 */
+			blocking_lock_reply_error(blr,NT_STATUS_ACCESS_DENIED);
+
+			brl_unlock(fsp->dev, fsp->inode, fsp->fnum,
+					blr->lock_pid, sys_getpid(), conn->cnum,
+					blr->offset, blr->count, True, NULL, NULL);
+
+			free_blocking_lock_record((blocking_lock_record *)ubi_slRemNext( &blocking_lock_queue, prev));
+			blr = (blocking_lock_record *)(prev ? ubi_slNext(prev) : ubi_slFirst(&blocking_lock_queue));
+			change_to_root_user();
+			continue;
+		}
+
+		/*
+		 * Go through the remaining locks and try and obtain them.
+		 * The call returns True if all locks were obtained successfully
+		 * and False if we still need to wait.
+		 */
+
+		if(blocking_lock_record_process(blr)) {
+
+			brl_unlock(fsp->dev, fsp->inode, fsp->fnum,
+					blr->lock_pid, sys_getpid(), conn->cnum,
+					blr->offset, blr->count, True, NULL, NULL);
+
+			free_blocking_lock_record((blocking_lock_record *)ubi_slRemNext( &blocking_lock_queue, prev));
+			blr = (blocking_lock_record *)(prev ? ubi_slNext(prev) : ubi_slFirst(&blocking_lock_queue));
+			change_to_root_user();
+			continue;
+		}
+
+		change_to_root_user();
+
+		/*
+		 * Move to the next in the list.
+		 */
+		prev = blr;
+		blr = (blocking_lock_record *)ubi_slNext(blr);
+	}
 }