summaryrefslogtreecommitdiff
path: root/source3/locking
diff options
context:
space:
mode:
Diffstat (limited to 'source3/locking')
-rw-r--r--source3/locking/brlock.c56
-rw-r--r--source3/locking/locking.c52
-rw-r--r--source3/locking/posix.c30
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;
generated by cgit (git 2.34.1) at 2024-11-23 20:10:38 +0000