smbd: Fix blank line endings

3 files changed, 31 insertions, 31 deletions

diff --git a/source3/include/locking.h b/source3/include/locking.h
index 32593af181..627908ce74 100644
--- a/source3/include/locking.h
+++ b/source3/include/locking.h
@@ -1,19 +1,19 @@
-/* 
+/*
    Unix SMB/CIFS implementation.
    SMB parameters and setup, plus a whole lot more.
-   
+
    Copyright (C) Jeremy Allison   2006
-   
+
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 3 of the License, or
    (at your option) any later version.
-   
+
    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.
-   
+
    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
@@ -57,7 +57,7 @@ struct byte_range_lock {
 	struct db_record *record;
 };
 
-/* Internal structure in brlock.tdb. 
+/* Internal structure in brlock.tdb.
    The data in brlock records is an unsorted linear array of these
    records.  It is unnecessary to store the count as tdb provides the
    size of the record */
diff --git a/source3/locking/brlock.c b/source3/locking/brlock.c
index 865aaca1b4..eeff76a78e 100644
--- a/source3/locking/brlock.c
+++ b/source3/locking/brlock.c
@@ -1,4 +1,4 @@
-/* 
+/*
    Unix SMB/CIFS implementation.
    byte range locking code
    Updated to handle range splits/merges.
@@ -67,7 +67,7 @@ static void print_lock_struct(unsigned int i, const 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 (serverid_equal(&ctx1->pid, &ctx2->pid) &&
@@ -102,7 +102,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. */
@@ -123,7 +123,7 @@ static bool brl_conflict(const struct lock_struct *lck1,
 	}
 
 	return brl_overlap(lck1, lck2);
-} 
+}
 
 /****************************************************************************
  See if lock2 can be added when lock1 is in place - when both locks are POSIX
@@ -131,7 +131,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)
@@ -156,10 +156,10 @@ static bool brl_conflict_posix(const struct lock_struct *lck1,
 	/* One is read, the other write, or the context is different,
 	   do they overlap ? */
 	return brl_overlap(lck1, lck2);
-} 
+}
 
 #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))
@@ -184,7 +184,7 @@ static bool brl_conflict1(const struct lock_struct *lck1,
 	}
 
 	return True;
-} 
+}
 #endif
 
 /****************************************************************************
@@ -198,7 +198,7 @@ static bool brl_conflict_other(const struct lock_struct *lck1, const struct lock
 	if (IS_PENDING_LOCK(lck1->lock_type) || IS_PENDING_LOCK(lck2->lock_type))
 		return False;
 
-	if (lck1->lock_type == READ_LOCK && lck2->lock_type == READ_LOCK) 
+	if (lck1->lock_type == READ_LOCK && lck2->lock_type == READ_LOCK)
 		return False;
 
 	/* POSIX flavour locks never conflict here - this is only called
@@ -219,7 +219,7 @@ static bool brl_conflict_other(const struct lock_struct *lck1, const struct lock
 	}
 
 	return brl_overlap(lck1, lck2);
-} 
+}
 
 /****************************************************************************
  Check if an unlock overlaps a pending lock.
@@ -314,7 +314,7 @@ void brl_shutdown(void)
  Compare two locks for sorting.
 ****************************************************************************/
 
-static int lock_compare(const struct lock_struct *lck1, 
+static int lock_compare(const struct lock_struct *lck1,
 			 const struct lock_struct *lck2)
 {
 	if (lck1->start != lck2->start) {
@@ -354,7 +354,7 @@ NTSTATUS brl_lock_windows_default(struct byte_range_lock *br_lck,
 			return brl_lock_failed(fsp,plock,blocking_lock);
 		}
 #if ZERO_ZERO
-		if (plock->start == 0 && plock->size == 0 && 
+		if (plock->start == 0 && plock->size == 0 &&
 				locks[i].size == 0) {
 			break;
 		}
@@ -913,7 +913,7 @@ NTSTATUS brl_lock(struct messaging_context *msg_ctx,
 		uint64_t smblctx,
 		struct server_id pid,
 		br_off start,
-		br_off size, 
+		br_off size,
 		enum brl_type lock_type,
 		enum brl_flavour lock_flav,
 		bool blocking_lock,
@@ -1031,7 +1031,7 @@ bool brl_unlock_windows_default(struct messaging_context *msg_ctx,
 
 	/* Actually delete the lock. */
 	if (i < br_lck->num_locks - 1) {
-		memmove(&locks[i], &locks[i+1], 
+		memmove(&locks[i], &locks[i+1],
 			sizeof(*locks)*((br_lck->num_locks-1) - i));
 	}
 
@@ -1234,7 +1234,7 @@ bool smb_vfs_call_brl_unlock_windows(struct vfs_handle_struct *handle,
 				     const struct lock_struct *plock)
 {
 	VFS_FIND(brl_unlock_windows);
-	return handle->fns->brl_unlock_windows_fn(handle, msg_ctx, br_lck, 
+	return handle->fns->brl_unlock_windows_fn(handle, msg_ctx, br_lck,
 						  plock);
 }
 
@@ -1278,7 +1278,7 @@ bool brl_locktest(struct byte_range_lock *br_lck,
 		uint64_t smblctx,
 		struct server_id pid,
 		br_off start,
-		br_off size, 
+		br_off size,
 		enum brl_type lock_type,
 		enum brl_flavour lock_flav)
 {
@@ -1336,7 +1336,7 @@ NTSTATUS brl_lockquery(struct byte_range_lock *br_lck,
 		uint64_t *psmblctx,
 		struct server_id pid,
 		br_off *pstart,
-		br_off *psize, 
+		br_off *psize,
 		enum brl_type *plock_type,
 		enum brl_flavour lock_flav)
 {
@@ -1361,7 +1361,7 @@ NTSTATUS brl_lockquery(struct byte_range_lock *br_lck,
 
 		if (exlock->lock_flav == WINDOWS_LOCK) {
 			conflict = brl_conflict(exlock, &lock);
-		} else {	
+		} else {
 			conflict = brl_conflict_posix(exlock, &lock);
 		}
 
@@ -1468,7 +1468,7 @@ bool brl_lock_cancel_default(struct byte_range_lock *br_lck,
 
 	if (i < br_lck->num_locks - 1) {
 		/* Found this particular pending lock - delete it */
-		memmove(&locks[i], &locks[i+1], 
+		memmove(&locks[i], &locks[i+1],
 			sizeof(*locks)*((br_lck->num_locks-1) - i));
 	}
 
diff --git a/source3/smbd/blocking.c b/source3/smbd/blocking.c
index 5f6dda318e..5d198fc1f2 100644
--- a/source3/smbd/blocking.c
+++ b/source3/smbd/blocking.c
@@ -111,7 +111,7 @@ static bool recalc_brl_timeout(struct smbd_server_connection *sconn)
 		return True;
 	}
 
-	/* 
+	/*
 	 to account for unclean shutdowns by clients we need a
 	 maximum timeout that we use for checking pending locks. If
 	 we have any pending locks at all, then check if the pending
@@ -217,7 +217,7 @@ bool push_blocking_lock_request( struct byte_range_lock *br_lck,
 	blr->lock_type = lock_type;
 	blr->offset = offset;
 	blr->count = count;
-      
+
 	/* Specific brl_lock() implementations can fill this in. */
 	blr->blr_private = NULL;
 
@@ -332,7 +332,7 @@ static void generic_blocking_lock_error(struct blocking_lock_record *blr, NTSTAT
 }
 
 /****************************************************************************
- Return a lock fail error for a lockingX call. Undo all the locks we have 
+ Return a lock fail error for a lockingX call. Undo all the locks we have
  obtained first.
 *****************************************************************************/
 
@@ -350,7 +350,7 @@ static void undo_locks_obtained(struct blocking_lock_record *blr)
 	data = discard_const_p(uint8_t, blr->req->buf)
 		+ ((large_file_format ? 20 : 10)*num_ulocks);
 
-	/* 
+	/*
 	 * Data now points at the beginning of the list
 	 * of smb_lkrng structs.
 	 */
@@ -449,7 +449,7 @@ static bool process_lockingX(struct blocking_lock_record *blr)
 	data = discard_const_p(uint8_t, blr->req->buf)
 		+ ((large_file_format ? 20 : 10)*num_ulocks);
 
-	/* 
+	/*
 	 * Data now points at the beginning of the list
 	 * of smb_lkrng structs.
 	 */
@@ -550,7 +550,7 @@ static bool process_trans2(struct blocking_lock_record *blr)
 		if (ERROR_WAS_LOCK_DENIED(status)) {
 			/* Still can't get the lock, just keep waiting. */
 			return False;
-		}	
+		}
 		/*
 		 * We have other than a "can't get lock"
 		 * error. Send an error and return True so we get dequeued.