RIP BOOL. Convert BOOL -> bool. I found a few interesting

bugs in various places whilst doing this (places that assumed
BOOL == int). I also need to fix the Samba4 pidl generation
(next checkin).
Jeremy.
(This used to be commit f35a266b3cbb3e5fa6a86be60f34fe340a3ca71f)

3 files changed, 69 insertions, 69 deletions

diff --git a/source3/locking/brlock.c b/source3/locking/brlock.c
index c148fa33f3..f821761cd7 100644
--- a/source3/locking/brlock.c
+++ b/source3/locking/brlock.c
@@ -59,7 +59,7 @@ static void print_lock_struct(unsigned int i, struct lock_struct *pls)
  See if two locking contexts are equal.
 ****************************************************************************/
 
-BOOL brl_same_context(const struct lock_context *ctx1, 
+bool brl_same_context(const struct lock_context *ctx1, 
 			     const struct lock_context *ctx2)
 {
 	return (procid_equal(&ctx1->pid, &ctx2->pid) &&
@@ -71,7 +71,7 @@ BOOL brl_same_context(const struct lock_context *ctx1,
  See if lck1 and lck2 overlap.
 ****************************************************************************/
 
-static BOOL brl_overlap(const struct lock_struct *lck1,
+static bool brl_overlap(const struct lock_struct *lck1,
                         const struct lock_struct *lck2)
 {
 	/* this extra check is not redundent - it copes with locks
@@ -93,7 +93,7 @@ static BOOL brl_overlap(const struct lock_struct *lck1,
  See if lock2 can be added when lock1 is in place.
 ****************************************************************************/
 
-static BOOL brl_conflict(const struct lock_struct *lck1, 
+static bool brl_conflict(const struct lock_struct *lck1, 
 			 const struct lock_struct *lck2)
 {
 	/* Ignore PENDING locks. */
@@ -119,7 +119,7 @@ static BOOL brl_conflict(const struct lock_struct *lck1,
  know already match.
 ****************************************************************************/
 
-static BOOL brl_conflict_posix(const struct lock_struct *lck1, 
+static bool brl_conflict_posix(const struct lock_struct *lck1, 
 			 	const struct lock_struct *lck2)
 {
 #if defined(DEVELOPER)
@@ -147,7 +147,7 @@ static BOOL brl_conflict_posix(const struct lock_struct *lck1,
 } 
 
 #if ZERO_ZERO
-static BOOL brl_conflict1(const struct lock_struct *lck1, 
+static bool brl_conflict1(const struct lock_struct *lck1, 
 			 const struct lock_struct *lck2)
 {
 	if (IS_PENDING_LOCK(lck1->lock_type) || IS_PENDING_LOCK(lck2->lock_type))
@@ -181,7 +181,7 @@ static BOOL brl_conflict1(const struct lock_struct *lck1,
  This is never used in the POSIX lock case.
 ****************************************************************************/
 
-static BOOL brl_conflict_other(const struct lock_struct *lck1, const struct lock_struct *lck2)
+static bool brl_conflict_other(const struct lock_struct *lck1, const struct lock_struct *lck2)
 {
 	if (IS_PENDING_LOCK(lck1->lock_type) || IS_PENDING_LOCK(lck2->lock_type))
 		return False;
@@ -213,7 +213,7 @@ static BOOL brl_conflict_other(const struct lock_struct *lck1, const struct lock
  Check if an unlock overlaps a pending lock.
 ****************************************************************************/
 
-static BOOL brl_pending_overlap(const struct lock_struct *lock, const struct lock_struct *pend_lock)
+static bool brl_pending_overlap(const struct lock_struct *lock, const struct lock_struct *pend_lock)
 {
 	if ((lock->start <= pend_lock->start) && (lock->start + lock->size > pend_lock->start))
 		return True;
@@ -228,7 +228,7 @@ static BOOL brl_pending_overlap(const struct lock_struct *lock, const struct loc
  app depends on this ?
 ****************************************************************************/
 
-static NTSTATUS brl_lock_failed(files_struct *fsp, const struct lock_struct *lock, BOOL blocking_lock)
+static NTSTATUS brl_lock_failed(files_struct *fsp, const struct lock_struct *lock, bool blocking_lock)
 {
 	if (lock->start >= 0xEF000000 && (lock->start >> 63) == 0) {
 		/* amazing the little things you learn with a test
@@ -310,7 +310,7 @@ static int lock_compare(const struct lock_struct *lck1,
 ****************************************************************************/
 
 static NTSTATUS brl_lock_windows(struct byte_range_lock *br_lck,
-			struct lock_struct *plock, BOOL blocking_lock)
+			struct lock_struct *plock, bool blocking_lock)
 {
 	unsigned int i;
 	files_struct *fsp = br_lck->fsp;
@@ -378,9 +378,9 @@ static NTSTATUS brl_lock_windows(struct byte_range_lock *br_lck,
 static unsigned int brlock_posix_split_merge(struct lock_struct *lck_arr,		/* Output array. */
 						const struct lock_struct *ex,		/* existing lock. */
 						const struct lock_struct *plock,	/* proposed lock. */
-						BOOL *lock_was_added)
+						bool *lock_was_added)
 {
-	BOOL lock_types_differ = (ex->lock_type != plock->lock_type);
+	bool lock_types_differ = (ex->lock_type != plock->lock_type);
 
 	/* We can't merge non-conflicting locks on different context - ignore fnum. */
 
@@ -594,8 +594,8 @@ static NTSTATUS brl_lock_posix(struct messaging_context *msg_ctx,
 	unsigned int i, count;
 	struct lock_struct *locks = br_lck->lock_data;
 	struct lock_struct *tp;
-	BOOL lock_was_added = False;
-	BOOL signal_pending_read = False;
+	bool lock_was_added = False;
+	bool signal_pending_read = False;
 
 	/* No zero-zero locks for POSIX. */
 	if (plock->start == 0 && plock->size == 0) {
@@ -741,7 +741,7 @@ NTSTATUS brl_lock(struct messaging_context *msg_ctx,
 		br_off size, 
 		enum brl_type lock_type,
 		enum brl_flavour lock_flav,
-		BOOL blocking_lock,
+		bool blocking_lock,
 		uint32 *psmbpid)
 {
 	NTSTATUS ret;
@@ -784,7 +784,7 @@ NTSTATUS brl_lock(struct messaging_context *msg_ctx,
  Unlock a range of bytes - Windows semantics.
 ****************************************************************************/
 
-static BOOL brl_unlock_windows(struct messaging_context *msg_ctx,
+static bool brl_unlock_windows(struct messaging_context *msg_ctx,
 			       struct byte_range_lock *br_lck,
 			       const struct lock_struct *plock)
 {
@@ -887,14 +887,14 @@ static BOOL brl_unlock_windows(struct messaging_context *msg_ctx,
  Unlock a range of bytes - POSIX semantics.
 ****************************************************************************/
 
-static BOOL brl_unlock_posix(struct messaging_context *msg_ctx,
+static bool brl_unlock_posix(struct messaging_context *msg_ctx,
 			     struct byte_range_lock *br_lck,
 			     const struct lock_struct *plock)
 {
 	unsigned int i, j, count;
 	struct lock_struct *tp;
 	struct lock_struct *locks = br_lck->lock_data;
-	BOOL overlap_found = False;
+	bool overlap_found = False;
 
 	/* No zero-zero locks for POSIX. */
 	if (plock->start == 0 && plock->size == 0) {
@@ -922,7 +922,7 @@ static BOOL brl_unlock_posix(struct messaging_context *msg_ctx,
 	for (i = 0; i < br_lck->num_locks; i++) {
 		struct lock_struct *lock = &locks[i];
 		struct lock_struct tmp_lock[3];
-		BOOL lock_was_added = False;
+		bool lock_was_added = False;
 		unsigned int tmp_count;
 
 		/* Only remove our own locks - ignore fnum. */
@@ -1056,7 +1056,7 @@ static BOOL brl_unlock_posix(struct messaging_context *msg_ctx,
  Unlock a range of bytes.
 ****************************************************************************/
 
-BOOL brl_unlock(struct messaging_context *msg_ctx,
+bool brl_unlock(struct messaging_context *msg_ctx,
 		struct byte_range_lock *br_lck,
 		uint32 smbpid,
 		struct server_id pid,
@@ -1087,7 +1087,7 @@ BOOL brl_unlock(struct messaging_context *msg_ctx,
  Returns True if the region required is currently unlocked, False if locked.
 ****************************************************************************/
 
-BOOL brl_locktest(struct byte_range_lock *br_lck,
+bool brl_locktest(struct byte_range_lock *br_lck,
 		uint32 smbpid,
 		struct server_id pid,
 		br_off start,
@@ -1095,7 +1095,7 @@ BOOL brl_locktest(struct byte_range_lock *br_lck,
 		enum brl_type lock_type,
 		enum brl_flavour lock_flav)
 {
-	BOOL ret = True;
+	bool ret = True;
 	unsigned int i;
 	struct lock_struct lock;
 	const struct lock_struct *locks = br_lck->lock_data;
@@ -1170,7 +1170,7 @@ NTSTATUS brl_lockquery(struct byte_range_lock *br_lck,
 	/* Make sure existing locks don't conflict */
 	for (i=0; i < br_lck->num_locks; i++) {
 		const struct lock_struct *exlock = &locks[i];
-		BOOL conflict = False;
+		bool conflict = False;
 
 		if (exlock->lock_flav == WINDOWS_LOCK) {
 			conflict = brl_conflict(exlock, &lock);
@@ -1193,7 +1193,7 @@ NTSTATUS brl_lockquery(struct byte_range_lock *br_lck,
 	 */
 
 	if(lp_posix_locking(fsp->conn->params)) {
-		BOOL ret = is_posix_locked(fsp, pstart, psize, plock_type, POSIX_LOCK);
+		bool ret = is_posix_locked(fsp, pstart, psize, plock_type, POSIX_LOCK);
 
 		DEBUG(10,("brl_lockquery: posix start=%.0f len=%.0f %s for fnum %d file %s\n",
 			(double)*pstart, (double)*psize, ret ? "locked" : "unlocked",
@@ -1213,7 +1213,7 @@ NTSTATUS brl_lockquery(struct byte_range_lock *br_lck,
  Remove a particular pending lock.
 ****************************************************************************/
 
-BOOL brl_lock_cancel(struct byte_range_lock *br_lck,
+bool brl_lock_cancel(struct byte_range_lock *br_lck,
 		uint32 smbpid,
 		struct server_id pid,
 		br_off start,
@@ -1274,7 +1274,7 @@ void brl_close_fnum(struct messaging_context *msg_ctx,
 	int num_deleted_windows_locks = 0;
 	struct lock_struct *locks = br_lck->lock_data;
 	struct server_id pid = procid_self();
-	BOOL unlock_individually = False;
+	bool unlock_individually = False;
 
 	if(lp_posix_locking(fsp->conn->params)) {
 
@@ -1339,7 +1339,7 @@ void brl_close_fnum(struct messaging_context *msg_ctx,
 
 	for (i=0; i < br_lck->num_locks; i++) {
 		struct lock_struct *lock = &locks[i];
-		BOOL del_this_lock = False;
+		bool del_this_lock = False;
 
 		if (lock->context.tid == tid && procid_equal(&lock->context.pid, &pid)) {
 			if ((lock->lock_flav == WINDOWS_LOCK) && (lock->fnum == fnum)) {
@@ -1397,7 +1397,7 @@ void brl_close_fnum(struct messaging_context *msg_ctx,
  Ensure this set of lock entries is valid.
 ****************************************************************************/
 
-static BOOL validate_lock_entries(unsigned int *pnum_entries, struct lock_struct **pplocks)
+static bool validate_lock_entries(unsigned int *pnum_entries, struct lock_struct **pplocks)
 {
 	unsigned int i;
 	unsigned int num_valid_entries = 0;
@@ -1591,7 +1591,7 @@ static int byte_range_lock_destructor(struct byte_range_lock *br_lck)
 ********************************************************************/
 
 static struct byte_range_lock *brl_get_locks_internal(TALLOC_CTX *mem_ctx,
-					files_struct *fsp, BOOL read_only)
+					files_struct *fsp, bool read_only)
 {
 	TDB_DATA key, data;
 	struct byte_range_lock *br_lck = TALLOC_P(mem_ctx, struct byte_range_lock);
diff --git a/source3/locking/locking.c b/source3/locking/locking.c
index 4d6265cc7c..aae297e031 100644
--- a/source3/locking/locking.c
+++ b/source3/locking/locking.c
@@ -75,7 +75,7 @@ const char *lock_flav_name(enum brl_flavour lock_flav)
  Called in the read/write codepath.
 ****************************************************************************/
 
-BOOL is_locked(files_struct *fsp,
+bool is_locked(files_struct *fsp,
 		uint32 smbpid,
 		SMB_BIG_UINT count,
 		SMB_BIG_UINT offset, 
@@ -83,7 +83,7 @@ BOOL is_locked(files_struct *fsp,
 {
 	int strict_locking = lp_strict_locking(fsp->conn->params);
 	enum brl_flavour lock_flav = lp_posix_cifsu_locktype(fsp);
-	BOOL ret = True;
+	bool ret = True;
 	
 	if (count == 0) {
 		return False;
@@ -188,7 +188,7 @@ struct byte_range_lock *do_lock(struct messaging_context *msg_ctx,
 			SMB_BIG_UINT offset,
 			enum brl_type lock_type,
 			enum brl_flavour lock_flav,
-			BOOL blocking_lock,
+			bool blocking_lock,
 			NTSTATUS *perr,
 			uint32 *plock_pid)
 {
@@ -255,7 +255,7 @@ NTSTATUS do_unlock(struct messaging_context *msg_ctx,
 			SMB_BIG_UINT offset,
 			enum brl_flavour lock_flav)
 {
-	BOOL ok = False;
+	bool ok = False;
 	struct byte_range_lock *br_lck = NULL;
 	
 	if (!fsp->can_lock) {
@@ -308,7 +308,7 @@ NTSTATUS do_lock_cancel(files_struct *fsp,
 			SMB_BIG_UINT offset,
 			enum brl_flavour lock_flav)
 {
-	BOOL ok = False;
+	bool ok = False;
 	struct byte_range_lock *br_lck = NULL;
 	
 	if (!fsp->can_lock) {
@@ -387,7 +387,7 @@ void locking_close_file(struct messaging_context *msg_ctx,
 
 static int open_read_only;
 
-BOOL locking_init(int read_only)
+bool locking_init(int read_only)
 {
 	brl_init(read_only);
 
@@ -417,7 +417,7 @@ BOOL locking_init(int read_only)
  Deinitialize the share_mode management.
 ******************************************************************/
 
-BOOL locking_end(void)
+bool locking_end(void)
 {
 	brl_shutdown(open_read_only);
 	if (lock_db) {
@@ -487,7 +487,7 @@ static void print_share_mode_table(struct locking_data *data)
  Get all share mode entries for a dev/inode pair.
 ********************************************************************/
 
-static BOOL parse_share_modes(TDB_DATA dbuf, struct share_mode_lock *lck)
+static bool parse_share_modes(TDB_DATA dbuf, struct share_mode_lock *lck)
 {
 	struct locking_data *data;
 	int i;
@@ -734,7 +734,7 @@ static int share_mode_lock_destructor(struct share_mode_lock *lck)
 	return 0;
 }
 
-static BOOL fill_share_mode_lock(struct share_mode_lock *lck,
+static bool fill_share_mode_lock(struct share_mode_lock *lck,
 				 struct file_id id,
 				 const char *servicepath,
 				 const char *fname,
@@ -844,7 +844,7 @@ struct share_mode_lock *fetch_share_mode_unlocked(TALLOC_CTX *mem_ctx,
  Based on an initial code idea from SATOH Fumiyasu <fumiya@samba.gr.jp>
 ********************************************************************/
 
-BOOL rename_share_filename(struct messaging_context *msg_ctx,
+bool rename_share_filename(struct messaging_context *msg_ctx,
 			struct share_mode_lock *lck,
 			const char *servicepath,
 			const char *newname)
@@ -916,9 +916,9 @@ BOOL rename_share_filename(struct messaging_context *msg_ctx,
 	return True;
 }
 
-BOOL get_delete_on_close_flag(struct file_id id)
+bool get_delete_on_close_flag(struct file_id id)
 {
-	BOOL result;
+	bool result;
 	struct share_mode_lock *lck;
   
 	if (!(lck = fetch_share_mode_unlocked(NULL, id, NULL, NULL))) {
@@ -929,7 +929,7 @@ BOOL get_delete_on_close_flag(struct file_id id)
 	return result;
 }
 
-BOOL is_valid_share_mode_entry(const struct share_mode_entry *e)
+bool is_valid_share_mode_entry(const struct share_mode_entry *e)
 {
 	int num_props = 0;
 
@@ -949,12 +949,12 @@ BOOL is_valid_share_mode_entry(const struct share_mode_entry *e)
 	return (num_props != 0);
 }
 
-BOOL is_deferred_open_entry(const struct share_mode_entry *e)
+bool is_deferred_open_entry(const struct share_mode_entry *e)
 {
 	return (e->op_type == DEFERRED_OPEN_ENTRY);
 }
 
-BOOL is_unused_share_mode_entry(const struct share_mode_entry *e)
+bool is_unused_share_mode_entry(const struct share_mode_entry *e)
 {
 	return (e->op_type == UNUSED_SHARE_MODE_ENTRY);
 }
@@ -1019,7 +1019,7 @@ static void add_share_mode_entry(struct share_mode_lock *lck,
 }
 
 void set_share_mode(struct share_mode_lock *lck, files_struct *fsp,
-			uid_t uid, uint16 mid, uint16 op_type, BOOL initial_delete_on_close_allowed)
+			uid_t uid, uint16 mid, uint16 op_type, bool initial_delete_on_close_allowed)
 {
 	struct share_mode_entry entry;
 	fill_share_mode_entry(&entry, fsp, uid, mid, op_type);
@@ -1044,7 +1044,7 @@ void add_deferred_open(struct share_mode_lock *lck, uint16 mid,
  not automatically a logic error if they are identical. JRA.)
 ********************************************************************/
 
-static BOOL share_modes_identical(struct share_mode_entry *e1,
+static bool share_modes_identical(struct share_mode_entry *e1,
 				  struct share_mode_entry *e2)
 {
 	/* We used to check for e1->share_access == e2->share_access here
@@ -1057,7 +1057,7 @@ static BOOL share_modes_identical(struct share_mode_entry *e1,
 		e1->share_file_id == e2->share_file_id );
 }
 
-static BOOL deferred_open_identical(struct share_mode_entry *e1,
+static bool deferred_open_identical(struct share_mode_entry *e1,
 				    struct share_mode_entry *e2)
 {
 	return (procid_equal(&e1->pid, &e2->pid) &&
@@ -1091,7 +1091,7 @@ static struct share_mode_entry *find_share_mode_entry(struct share_mode_lock *lc
  entries left.
 ********************************************************************/
 
-BOOL del_share_mode(struct share_mode_lock *lck, files_struct *fsp)
+bool del_share_mode(struct share_mode_lock *lck, files_struct *fsp)
 {
 	struct share_mode_entry entry, *e;
 
@@ -1128,7 +1128,7 @@ void del_deferred_open_entry(struct share_mode_lock *lck, uint16 mid)
  Remove an oplock mid and mode entry from a share mode.
 ********************************************************************/
 
-BOOL remove_share_oplock(struct share_mode_lock *lck, files_struct *fsp)
+bool remove_share_oplock(struct share_mode_lock *lck, files_struct *fsp)
 {
 	struct share_mode_entry entry, *e;
 
@@ -1150,7 +1150,7 @@ BOOL remove_share_oplock(struct share_mode_lock *lck, files_struct *fsp)
  Downgrade a oplock type from exclusive to level II.
 ********************************************************************/
 
-BOOL downgrade_share_oplock(struct share_mode_lock *lck, files_struct *fsp)
+bool downgrade_share_oplock(struct share_mode_lock *lck, files_struct *fsp)
 {
 	struct share_mode_entry entry, *e;
 
@@ -1173,7 +1173,7 @@ BOOL downgrade_share_oplock(struct share_mode_lock *lck, files_struct *fsp)
  open_file_ntcreate. JRA.
 ****************************************************************************/
 
-NTSTATUS can_set_delete_on_close(files_struct *fsp, BOOL delete_on_close,
+NTSTATUS can_set_delete_on_close(files_struct *fsp, bool delete_on_close,
 				 uint32 dosmode)
 {
 	if (!delete_on_close) {
@@ -1227,7 +1227,7 @@ NTSTATUS can_set_delete_on_close(files_struct *fsp, BOOL delete_on_close,
  Do we have an open file handle that created this entry ?
 ****************************************************************************/
 
-BOOL can_set_initial_delete_on_close(const struct share_mode_lock *lck)
+bool can_set_initial_delete_on_close(const struct share_mode_lock *lck)
 {
 	int i;
 
@@ -1299,7 +1299,7 @@ void set_delete_on_close_token(struct share_mode_lock *lck, UNIX_USER_TOKEN *tok
  lck entry. This function is used when the lock is already granted.
 ****************************************************************************/
 
-void set_delete_on_close_lck(struct share_mode_lock *lck, BOOL delete_on_close, UNIX_USER_TOKEN *tok)
+void set_delete_on_close_lck(struct share_mode_lock *lck, bool delete_on_close, UNIX_USER_TOKEN *tok)
 {
 	if (lck->delete_on_close != delete_on_close) {
 		set_delete_on_close_token(lck, tok);
@@ -1311,7 +1311,7 @@ void set_delete_on_close_lck(struct share_mode_lock *lck, BOOL delete_on_close,
 	}
 }
 
-BOOL set_delete_on_close(files_struct *fsp, BOOL delete_on_close, UNIX_USER_TOKEN *tok)
+bool set_delete_on_close(files_struct *fsp, bool delete_on_close, UNIX_USER_TOKEN *tok)
 {
 	struct share_mode_lock *lck;
 	
@@ -1343,7 +1343,7 @@ BOOL set_delete_on_close(files_struct *fsp, BOOL delete_on_close, UNIX_USER_TOKE
  Sets the allow initial delete on close flag for this share mode.
 ****************************************************************************/
 
-BOOL set_allow_initial_delete_on_close(struct share_mode_lock *lck, files_struct *fsp, BOOL delete_on_close)
+bool set_allow_initial_delete_on_close(struct share_mode_lock *lck, files_struct *fsp, bool delete_on_close)
 {
 	struct share_mode_entry entry, *e;
 
diff --git a/source3/locking/posix.c b/source3/locking/posix.c
index f7d70504b1..135e204f01 100644
--- a/source3/locking/posix.c
+++ b/source3/locking/posix.c
@@ -78,7 +78,7 @@ static const char *posix_lock_type_name(int lock_type)
  False if not.
 ****************************************************************************/
 
-static BOOL posix_lock_in_range(SMB_OFF_T *offset_out, SMB_OFF_T *count_out,
+static bool posix_lock_in_range(SMB_OFF_T *offset_out, SMB_OFF_T *count_out,
 				SMB_BIG_UINT u_offset, SMB_BIG_UINT u_count)
 {
 	SMB_OFF_T offset = (SMB_OFF_T)u_offset;
@@ -182,9 +182,9 @@ static BOOL posix_lock_in_range(SMB_OFF_T *offset_out, SMB_OFF_T *count_out,
  broken NFS implementations.
 ****************************************************************************/
 
-static BOOL posix_fcntl_lock(files_struct *fsp, int op, SMB_OFF_T offset, SMB_OFF_T count, int type)
+static bool posix_fcntl_lock(files_struct *fsp, int op, SMB_OFF_T offset, SMB_OFF_T count, int type)
 {
-	BOOL ret;
+	bool ret;
 
 	DEBUG(8,("posix_fcntl_lock %d %d %.0f %.0f %d\n",fsp->fh->fd,op,(double)offset,(double)count,type));
 
@@ -225,10 +225,10 @@ static BOOL posix_fcntl_lock(files_struct *fsp, int op, SMB_OFF_T offset, SMB_OF
  broken NFS implementations.
 ****************************************************************************/
 
-static BOOL posix_fcntl_getlock(files_struct *fsp, SMB_OFF_T *poffset, SMB_OFF_T *pcount, int *ptype)
+static bool posix_fcntl_getlock(files_struct *fsp, SMB_OFF_T *poffset, SMB_OFF_T *pcount, int *ptype)
 {
 	pid_t pid;
-	BOOL ret;
+	bool ret;
 
 	DEBUG(8,("posix_fcntl_getlock %d %.0f %.0f %d\n",
 		fsp->fh->fd,(double)*poffset,(double)*pcount,*ptype));
@@ -270,7 +270,7 @@ static BOOL posix_fcntl_getlock(files_struct *fsp, SMB_OFF_T *poffset, SMB_OFF_T
  region is locked, False otherwise.
 ****************************************************************************/
 
-BOOL is_posix_locked(files_struct *fsp,
+bool is_posix_locked(files_struct *fsp,
 			SMB_BIG_UINT *pu_offset,
 			SMB_BIG_UINT *pu_count,
 			enum brl_type *plock_type,
@@ -374,7 +374,7 @@ static TDB_DATA locking_ref_count_key_fsp(files_struct *fsp)
  Create the in-memory POSIX lock databases.
 ********************************************************************/
 
-BOOL posix_locking_init(int read_only)
+bool posix_locking_init(int read_only)
 {
 	if (posix_pending_close_tdb) {
 		return True;
@@ -396,7 +396,7 @@ BOOL posix_locking_init(int read_only)
  Delete the in-memory POSIX lock databases.
 ********************************************************************/
 
-BOOL posix_locking_end(void)
+bool posix_locking_end(void)
 {
 	if (posix_pending_close_tdb && tdb_close(posix_pending_close_tdb) != 0) {
 		return False;
@@ -951,7 +951,7 @@ lock: start = %.0f, size = %.0f", (double)l_curr->start, (double)l_curr->size, (
  lock could be granted, False if not.
 ****************************************************************************/
 
-BOOL set_posix_lock_windows_flavour(files_struct *fsp,
+bool set_posix_lock_windows_flavour(files_struct *fsp,
 			SMB_BIG_UINT u_offset,
 			SMB_BIG_UINT u_count,
 			enum brl_type lock_type,
@@ -963,7 +963,7 @@ BOOL set_posix_lock_windows_flavour(files_struct *fsp,
 	SMB_OFF_T offset;
 	SMB_OFF_T count;
 	int posix_lock_type = map_posix_lock_type(fsp,lock_type);
-	BOOL ret = True;
+	bool ret = True;
 	size_t lock_count;
 	TALLOC_CTX *l_ctx = NULL;
 	struct lock_list *llist = NULL;
@@ -1088,7 +1088,7 @@ BOOL set_posix_lock_windows_flavour(files_struct *fsp,
  lock could be released, False if not.
 ****************************************************************************/
 
-BOOL release_posix_lock_windows_flavour(files_struct *fsp,
+bool release_posix_lock_windows_flavour(files_struct *fsp,
 				SMB_BIG_UINT u_offset,
 				SMB_BIG_UINT u_count,
 				enum brl_type deleted_lock_type,
@@ -1098,7 +1098,7 @@ BOOL release_posix_lock_windows_flavour(files_struct *fsp,
 {
 	SMB_OFF_T offset;
 	SMB_OFF_T count;
-	BOOL ret = True;
+	bool ret = True;
 	TALLOC_CTX *ul_ctx = NULL;
 	struct lock_list *ulist = NULL;
 	struct lock_list *ul = NULL;
@@ -1211,7 +1211,7 @@ BOOL release_posix_lock_windows_flavour(files_struct *fsp,
  upper layer would have refused it.
 ****************************************************************************/
 
-BOOL set_posix_lock_posix_flavour(files_struct *fsp,
+bool set_posix_lock_posix_flavour(files_struct *fsp,
 			SMB_BIG_UINT u_offset,
 			SMB_BIG_UINT u_count,
 			enum brl_type lock_type,
@@ -1251,14 +1251,14 @@ BOOL set_posix_lock_posix_flavour(files_struct *fsp,
  have a different lock context.
 ****************************************************************************/
 
-BOOL release_posix_lock_posix_flavour(files_struct *fsp,
+bool release_posix_lock_posix_flavour(files_struct *fsp,
 				SMB_BIG_UINT u_offset,
 				SMB_BIG_UINT u_count,
 				const struct lock_context *lock_ctx,
 				const struct lock_struct *plocks,
 				int num_locks)
 {
-	BOOL ret = True;
+	bool ret = True;
 	SMB_OFF_T offset;
 	SMB_OFF_T count;
 	TALLOC_CTX *ul_ctx = NULL;