Remove whitespace, no code changes.

Guenther
(This used to be commit d752d52f1a4b75d7d4934da66566bc62e14caf27)

2 files changed, 265 insertions, 265 deletions

diff --git a/source3/rpc_server/srv_svcctl_nt.c b/source3/rpc_server/srv_svcctl_nt.c
index ac45d8bf75..11b7ab6ca2 100644
--- a/source3/rpc_server/srv_svcctl_nt.c
+++ b/source3/rpc_server/srv_svcctl_nt.c
@@ -1,22 +1,22 @@
-/* 
+/*
  *  Unix SMB/CIFS implementation.
  *  RPC Pipe client / server routines
  *
  *  Copyright (C) Marcin Krzysztof Porwit           2005.
- * 
+ *
  *  Largely Rewritten (Again) by:
  *  Copyright (C) Gerald (Jerry) Carter             2005.
- *  
+ *
  *  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/>.
  */
@@ -63,42 +63,42 @@ bool init_service_op_table( void )
 	const char **service_list = lp_svcctl_list();
 	int num_services = SVCCTL_NUM_INTERNAL_SERVICES + str_list_count( service_list );
 	int i;
-	
+
 	if ( !(svcctl_ops = TALLOC_ARRAY( NULL, struct service_control_op, num_services+1)) ) {
 		DEBUG(0,("init_service_op_table: talloc() failed!\n"));
 		return False;
 	}
 
 	/* services listed in smb.conf get the rc.init interface */
-	
+
 	for ( i=0; service_list && service_list[i]; i++ ) {
 		svcctl_ops[i].name = talloc_strdup( svcctl_ops, service_list[i] );
 		svcctl_ops[i].ops  = &rcinit_svc_ops;
 	}
-	
+
 	/* add builtin services */
-	
+
 	svcctl_ops[i].name = talloc_strdup( svcctl_ops, "Spooler" );
 	svcctl_ops[i].ops  = &spoolss_svc_ops;
 	i++;
-	
+
 	svcctl_ops[i].name = talloc_strdup( svcctl_ops, "NETLOGON" );
 	svcctl_ops[i].ops  = &netlogon_svc_ops;
 	i++;
-	
+
 	svcctl_ops[i].name = talloc_strdup( svcctl_ops, "RemoteRegistry" );
 	svcctl_ops[i].ops  = &winreg_svc_ops;
 	i++;
-	
+
 	svcctl_ops[i].name = talloc_strdup( svcctl_ops, "WINS" );
 	svcctl_ops[i].ops  = &wins_svc_ops;
 	i++;
-	
+
 	/* NULL terminate the array */
-	
+
 	svcctl_ops[i].name = NULL;
 	svcctl_ops[i].ops  = NULL;
-	
+
 	return True;
 }
 
@@ -119,7 +119,7 @@ static struct service_control_op* find_service_by_name( const char *name )
 /********************************************************************
 ********************************************************************/
 
-static NTSTATUS svcctl_access_check( SEC_DESC *sec_desc, NT_USER_TOKEN *token, 
+static NTSTATUS svcctl_access_check( SEC_DESC *sec_desc, NT_USER_TOKEN *token,
                                      uint32 access_desired, uint32 *access_granted )
 {
 	NTSTATUS result;
@@ -128,7 +128,7 @@ static NTSTATUS svcctl_access_check( SEC_DESC *sec_desc, NT_USER_TOKEN *token,
 		DEBUG(5,("svcctl_access_check: using root's token\n"));
 		token = get_root_nt_token();
 	}
-	
+
 	se_access_check( sec_desc, token, access_desired, access_granted, &result );
 
 	return result;
@@ -139,7 +139,7 @@ static NTSTATUS svcctl_access_check( SEC_DESC *sec_desc, NT_USER_TOKEN *token,
 
 static SEC_DESC* construct_scm_sd( TALLOC_CTX *ctx )
 {
-	SEC_ACE ace[2];	
+	SEC_ACE ace[2];
 	SEC_ACCESS mask;
 	size_t i = 0;
 	SEC_DESC *sd;
@@ -147,18 +147,18 @@ static SEC_DESC* construct_scm_sd( TALLOC_CTX *ctx )
 	size_t sd_size;
 
 	/* basic access for Everyone */
-	
+
 	init_sec_access(&mask, SC_MANAGER_READ_ACCESS );
 	init_sec_ace(&ace[i++], &global_sid_World, SEC_ACE_TYPE_ACCESS_ALLOWED, mask, 0);
-	
+
 	/* Full Access 'BUILTIN\Administrators' */
-	
+
 	init_sec_access(&mask,SC_MANAGER_ALL_ACCESS );
 	init_sec_ace(&ace[i++], &global_sid_Builtin_Administrators, SEC_ACE_TYPE_ACCESS_ALLOWED, mask, 0);
-	
-	
+
+
 	/* create the security descriptor */
-	
+
 	if ( !(acl = make_sec_acl(ctx, NT4_ACL_REVISION, i, ace)) )
 		return NULL;
 
@@ -173,7 +173,7 @@ static SEC_DESC* construct_scm_sd( TALLOC_CTX *ctx )
 /******************************************************************
  free() function for REGISTRY_KEY
  *****************************************************************/
- 
+
 static void free_service_handle_info(void *ptr)
 {
 	TALLOC_FREE( ptr );
@@ -197,21 +197,21 @@ static SERVICE_INFO *find_service_info_by_hnd(pipes_struct *p, POLICY_HND *hnd)
 
 /******************************************************************
  *****************************************************************/
- 
+
 static WERROR create_open_service_handle( pipes_struct *p, POLICY_HND *handle, uint32 type,
                                           const char *service, uint32 access_granted )
 {
 	SERVICE_INFO *info = NULL;
 	WERROR result = WERR_OK;
 	struct service_control_op *s_op;
-	
+
 	if ( !(info = TALLOC_ZERO_P( NULL, SERVICE_INFO )) )
 		return WERR_NOMEM;
 
 	/* the Service Manager has a NULL name */
-	
+
 	info->type = SVC_HANDLE_IS_SCM;
-	
+
 	switch ( type ) {
 	case SVC_HANDLE_IS_SCM:
 		info->type = SVC_HANDLE_IS_SCM;
@@ -220,17 +220,17 @@ static WERROR create_open_service_handle( pipes_struct *p, POLICY_HND *handle, u
 	case SVC_HANDLE_IS_DBLOCK:
 		info->type = SVC_HANDLE_IS_DBLOCK;
 		break;
-		
+
 	case SVC_HANDLE_IS_SERVICE:
 		info->type = SVC_HANDLE_IS_SERVICE;
-		
+
 		/* lookup the SERVICE_CONTROL_OPS */
 
 		if ( !(s_op = find_service_by_name( service )) ) {
 			result = WERR_NO_SUCH_SERVICE;
 			goto done;
 		}
-		
+
 		info->ops = s_op->ops;
 
 		if ( !(info->name  = talloc_strdup( info, s_op->name )) ) {
@@ -244,15 +244,15 @@ static WERROR create_open_service_handle( pipes_struct *p, POLICY_HND *handle, u
 		goto done;
 	}
 
-	info->access_granted = access_granted;	
-	
+	info->access_granted = access_granted;
+
 	/* store the SERVICE_INFO and create an open handle */
-	
+
 	if ( !create_policy_hnd( p, handle, free_service_handle_info, info ) ) {
 		result = WERR_ACCESS_DENIED;
 		goto done;
 	}
-		
+
 done:
 	if ( !W_ERROR_IS_OK(result) )
 		free_service_handle_info( info );
@@ -268,17 +268,17 @@ WERROR _svcctl_open_scmanager(pipes_struct *p, SVCCTL_Q_OPEN_SCMANAGER *q_u, SVC
 	SEC_DESC *sec_desc;
 	uint32 access_granted = 0;
 	NTSTATUS status;
-	
+
 	/* perform access checks */
-	
+
 	if ( !(sec_desc = construct_scm_sd( p->mem_ctx )) )
 		return WERR_NOMEM;
-		
+
 	se_map_generic( &q_u->access, &scm_generic_map );
 	status = svcctl_access_check( sec_desc, p->pipe_user.nt_user_token, q_u->access, &access_granted );
 	if ( !NT_STATUS_IS_OK(status) )
 		return ntstatus_to_werror( status );
-		
+
 	return create_open_service_handle( p, &r_u->handle, SVC_HANDLE_IS_SCM, NULL, access_granted );
 }
 
@@ -307,7 +307,7 @@ WERROR _svcctl_open_service(pipes_struct *p, SVCCTL_Q_OPEN_SERVICE *q_u, SVCCTL_
 	if ( !find_service_info_by_hnd( p, &q_u->handle ) )
 		return WERR_BADFID;
 
-	/* perform access checks.  Use the root token in order to ensure that we 
+	/* perform access checks.  Use the root token in order to ensure that we
 	   retrieve the security descriptor */
 
 	if ( !(sec_desc = svcctl_get_secdesc( p->mem_ctx, service, get_root_nt_token() )) )
@@ -329,7 +329,7 @@ WERROR _svcctl_CloseServiceHandle(pipes_struct *p, struct svcctl_CloseServiceHan
 	if ( !close_policy_hnd( p, r->in.handle ) )
 		return  WERR_BADFID;
 
-	return WERR_OK;	
+	return WERR_OK;
 }
 
 /********************************************************************
@@ -340,14 +340,14 @@ WERROR _svcctl_get_display_name(pipes_struct *p, SVCCTL_Q_GET_DISPLAY_NAME *q_u,
 	fstring service;
 	const char *display_name;
 	SERVICE_INFO *info = find_service_info_by_hnd( p, &q_u->handle );
-	
+
 	/* can only use an SCM handle here */
-	
+
 	if ( !info || (info->type != SVC_HANDLE_IS_SCM) )
 		return WERR_BADFID;
-		
+
 	rpcstr_pull(service, q_u->servicename.buffer, sizeof(service), q_u->servicename.uni_str_len*2, 0);
-	
+
 	display_name = svcctl_lookup_dispname(p->mem_ctx, service, p->pipe_user.nt_user_token );
 	init_svcctl_r_get_display_name( r_u, display_name ? display_name : "");
 
@@ -360,15 +360,15 @@ WERROR _svcctl_get_display_name(pipes_struct *p, SVCCTL_Q_GET_DISPLAY_NAME *q_u,
 WERROR _svcctl_query_status(pipes_struct *p, SVCCTL_Q_QUERY_STATUS *q_u, SVCCTL_R_QUERY_STATUS *r_u)
 {
 	SERVICE_INFO *info = find_service_info_by_hnd( p, &q_u->handle );
-	
+
 	/* perform access checks */
 
 	if ( !info || (info->type != SVC_HANDLE_IS_SERVICE) )
 		return WERR_BADFID;
-		
+
 	if ( !(info->access_granted & SC_RIGHT_SVC_QUERY_STATUS) )
 		return WERR_ACCESS_DENIED;
-		
+
 	/* try the service specific status call */
 
 	return info->ops->service_status( info->name, &r_u->svc_status );
@@ -383,7 +383,7 @@ static int enumerate_status( TALLOC_CTX *ctx, ENUM_SERVICES_STATUS **status, NT_
 	int i;
 	ENUM_SERVICES_STATUS *st;
 	const char *display_name;
-	
+
 	/* just count */
 	while ( svcctl_ops[num_services].name )
 		num_services++;
@@ -392,16 +392,16 @@ static int enumerate_status( TALLOC_CTX *ctx, ENUM_SERVICES_STATUS **status, NT_
 		DEBUG(0,("enumerate_status: talloc() failed!\n"));
 		return -1;
 	}
-	
+
 	for ( i=0; i<num_services; i++ ) {
 		init_unistr( &st[i].servicename, svcctl_ops[i].name );
-		
+
 		display_name = svcctl_lookup_dispname(ctx, svcctl_ops[i].name, token );
 		init_unistr( &st[i].displayname, display_name ? display_name : "");
-		
+
 		svcctl_ops[i].ops->service_status( svcctl_ops[i].name, &st[i].status );
 	}
-	
+
 	*status = st;
 
 	return num_services;
@@ -419,12 +419,12 @@ WERROR _svcctl_enum_services_status(pipes_struct *p, SVCCTL_Q_ENUM_SERVICES_STAT
 	WERROR result = WERR_OK;
 	SERVICE_INFO *info = find_service_info_by_hnd( p, &q_u->handle );
 	NT_USER_TOKEN *token = p->pipe_user.nt_user_token;
-	
+
 	/* perform access checks */
 
 	if ( !info || (info->type != SVC_HANDLE_IS_SCM) )
 		return WERR_BADFID;
-		
+
 	if ( !(info->access_granted & SC_RIGHT_MGR_ENUMERATE_SERVICE) ) {
 		return WERR_ACCESS_DENIED;
 	}
@@ -469,15 +469,15 @@ WERROR _svcctl_enum_services_status(pipes_struct *p, SVCCTL_Q_ENUM_SERVICES_STAT
 WERROR _svcctl_start_service(pipes_struct *p, SVCCTL_Q_START_SERVICE *q_u, SVCCTL_R_START_SERVICE *r_u)
 {
 	SERVICE_INFO *info = find_service_info_by_hnd( p, &q_u->handle );
-	
+
 	/* perform access checks */
 
 	if ( !info || (info->type != SVC_HANDLE_IS_SERVICE) )
 		return WERR_BADFID;
-	
+
 	if ( !(info->access_granted & SC_RIGHT_SVC_START) )
 		return WERR_ACCESS_DENIED;
-		
+
 	return info->ops->start_service( info->name );
 }
 
@@ -487,28 +487,28 @@ WERROR _svcctl_start_service(pipes_struct *p, SVCCTL_Q_START_SERVICE *q_u, SVCCT
 WERROR _svcctl_control_service(pipes_struct *p, SVCCTL_Q_CONTROL_SERVICE *q_u, SVCCTL_R_CONTROL_SERVICE *r_u)
 {
 	SERVICE_INFO *info = find_service_info_by_hnd( p, &q_u->handle );
-	
+
 	/* perform access checks */
-	
+
 	if ( !info || (info->type != SVC_HANDLE_IS_SERVICE) )
-		return WERR_BADFID;	
-	
+		return WERR_BADFID;
+
 	switch ( q_u->control ) {
 	case SVCCTL_CONTROL_STOP:
 		if ( !(info->access_granted & SC_RIGHT_SVC_STOP) )
 			return WERR_ACCESS_DENIED;
-			
+
 		return info->ops->stop_service( info->name, &r_u->svc_status );
-		
+
 	case SVCCTL_CONTROL_INTERROGATE:
 		if ( !(info->access_granted & SC_RIGHT_SVC_QUERY_STATUS) )
 			return WERR_ACCESS_DENIED;
-			
+
 		return info->ops->service_status( info->name, &r_u->svc_status );
 	}
-	
+
 	/* default control action */
-	
+
 	return WERR_ACCESS_DENIED;
 }
 
@@ -518,22 +518,22 @@ WERROR _svcctl_control_service(pipes_struct *p, SVCCTL_Q_CONTROL_SERVICE *q_u, S
 WERROR _svcctl_enum_dependent_services( pipes_struct *p, SVCCTL_Q_ENUM_DEPENDENT_SERVICES *q_u, SVCCTL_R_ENUM_DEPENDENT_SERVICES *r_u )
 {
 	SERVICE_INFO *info = find_service_info_by_hnd( p, &q_u->handle );
-	
+
 	/* perform access checks */
 
 	if ( !info || (info->type != SVC_HANDLE_IS_SERVICE) )
-		return WERR_BADFID;	
-	
+		return WERR_BADFID;
+
 	if ( !(info->access_granted & SC_RIGHT_SVC_ENUMERATE_DEPENDENTS) )
 		return WERR_ACCESS_DENIED;
-			
-	/* we have to set the outgoing buffer size to the same as the 
+
+	/* we have to set the outgoing buffer size to the same as the
 	   incoming buffer size (even in the case of failure */
 
 	rpcbuf_init( &r_u->buffer, q_u->buffer_size, p->mem_ctx );
-				
+
 	r_u->needed      = q_u->buffer_size;
-	
+
 	/* no dependent services...basically a stub function */
 	r_u->returned    = 0;
 
@@ -547,21 +547,21 @@ WERROR _svcctl_query_service_status_ex( pipes_struct *p, SVCCTL_Q_QUERY_SERVICE_
 {
 	SERVICE_INFO *info = find_service_info_by_hnd( p, &q_u->handle );
 	uint32 buffer_size;
-	
+
 	/* perform access checks */
 
 	if ( !info || (info->type != SVC_HANDLE_IS_SERVICE) )
-		return WERR_BADFID;	
-	
+		return WERR_BADFID;
+
 	if ( !(info->access_granted & SC_RIGHT_SVC_QUERY_STATUS) )
 		return WERR_ACCESS_DENIED;
 
-	/* we have to set the outgoing buffer size to the same as the 
+	/* we have to set the outgoing buffer size to the same as the
 	   incoming buffer size (even in the case of failure) */
 
 	rpcbuf_init( &r_u->buffer, q_u->buffer_size, p->mem_ctx );
 	r_u->needed = q_u->buffer_size;
-	
+
 	switch ( q_u->level ) {
 		case SVC_STATUS_PROCESS_INFO:
 		{
@@ -576,18 +576,18 @@ WERROR _svcctl_query_service_status_ex( pipes_struct *p, SVCCTL_Q_QUERY_SERVICE_
 	                buffer_size = sizeof(SERVICE_STATUS_PROCESS);
 			break;
 		}
-			
+
 		default:
-			return WERR_UNKNOWN_LEVEL; 
+			return WERR_UNKNOWN_LEVEL;
 	}
 
-	
+
         buffer_size += buffer_size % 4;
 	r_u->needed = (buffer_size > q_u->buffer_size) ? buffer_size : q_u->buffer_size;
 
-        if (buffer_size > q_u->buffer_size ) 
+        if (buffer_size > q_u->buffer_size )
                 return WERR_MORE_DATA;
-	
+
 	return WERR_OK;
 }
 
@@ -600,12 +600,12 @@ static WERROR fill_svc_config( TALLOC_CTX *ctx, const char *name, SERVICE_CONFIG
 	REGISTRY_VALUE *val;
 
 	/* retrieve the registry values for this service */
-	
+
 	if ( !(values = svcctl_fetch_regvalues( name, token )) )
 		return WERR_REG_CORRUPT;
-	
+
 	/* now fill in the individual values */
-		
+
 	config->displayname = TALLOC_ZERO_P( ctx, UNISTR2 );
 	if ( (val = regval_ctr_getvalue( values, "DisplayName" )) != NULL )
 		init_unistr2( config->displayname, regval_sz( val ), UNI_STR_TERMINATE );
@@ -613,23 +613,23 @@ static WERROR fill_svc_config( TALLOC_CTX *ctx, const char *name, SERVICE_CONFIG
 		init_unistr2( config->displayname, name, UNI_STR_TERMINATE );
 
 	if ( (val = regval_ctr_getvalue( values, "ObjectName" )) != NULL ) {
-		config->startname = TALLOC_ZERO_P( ctx, UNISTR2 );		
+		config->startname = TALLOC_ZERO_P( ctx, UNISTR2 );
 		init_unistr2( config->startname, regval_sz( val ), UNI_STR_TERMINATE );
 	}
-		
+
 	if ( (val = regval_ctr_getvalue( values, "ImagePath" )) != NULL ) {
-		config->executablepath = TALLOC_ZERO_P( ctx, UNISTR2 );		
+		config->executablepath = TALLOC_ZERO_P( ctx, UNISTR2 );
 		init_unistr2( config->executablepath, regval_sz( val ), UNI_STR_TERMINATE );
 	}
 
 	/* a few hard coded values */
 	/* loadordergroup and dependencies are empty */
-	
+
 	config->tag_id           = 0x00000000;			/* unassigned loadorder group */
 	config->service_type     = SVCCTL_WIN32_OWN_PROC;
 	config->error_control    = SVCCTL_SVC_ERROR_NORMAL;
 
-	/* set the start type.  NetLogon and WINS are disabled to prevent 
+	/* set the start type.  NetLogon and WINS are disabled to prevent
 	   the client from showing the "Start" button (if of course the services
 	   are not running */
 
@@ -639,7 +639,7 @@ static WERROR fill_svc_config( TALLOC_CTX *ctx, const char *name, SERVICE_CONFIG
 		config->start_type = SVCCTL_DISABLED;
 	else
 		config->start_type = SVCCTL_DEMAND_START;
-	
+
 
 	TALLOC_FREE( values );
 
@@ -654,24 +654,24 @@ WERROR _svcctl_query_service_config( pipes_struct *p, SVCCTL_Q_QUERY_SERVICE_CON
 	SERVICE_INFO *info = find_service_info_by_hnd( p, &q_u->handle );
 	uint32 buffer_size;
 	WERROR wresult;
-	
+
 	/* perform access checks */
 
 	if ( !info || (info->type != SVC_HANDLE_IS_SERVICE) )
-		return WERR_BADFID;	
-	
+		return WERR_BADFID;
+
 	if ( !(info->access_granted & SC_RIGHT_SVC_QUERY_CONFIG) )
 		return WERR_ACCESS_DENIED;
 
-	/* we have to set the outgoing buffer size to the same as the 
+	/* we have to set the outgoing buffer size to the same as the
 	   incoming buffer size (even in the case of failure */
 
 	r_u->needed      = q_u->buffer_size;
-	
+
 	wresult = fill_svc_config( p->mem_ctx, info->name, &r_u->config, p->pipe_user.nt_user_token );
 	if ( !W_ERROR_IS_OK(wresult) )
 		return wresult;
-	
+
 	buffer_size = svcctl_sizeof_service_config( &r_u->config );
 	r_u->needed = (buffer_size > q_u->buffer_size) ? buffer_size : q_u->buffer_size;
 
@@ -679,7 +679,7 @@ WERROR _svcctl_query_service_config( pipes_struct *p, SVCCTL_Q_QUERY_SERVICE_CON
 		ZERO_STRUCTP( &r_u->config );
                 return WERR_INSUFFICIENT_BUFFER;
 	}
-		
+
 	return WERR_OK;
 }
 
@@ -755,17 +755,17 @@ WERROR _svcctl_query_service_config2( pipes_struct *p, SVCCTL_Q_QUERY_SERVICE_CO
 WERROR _svcctl_lock_service_db( pipes_struct *p, SVCCTL_Q_LOCK_SERVICE_DB *q_u, SVCCTL_R_LOCK_SERVICE_DB *r_u )
 {
 	SERVICE_INFO *info = find_service_info_by_hnd( p, &q_u->handle );
-	
+
 	/* perform access checks */
 
 	if ( !info || (info->type != SVC_HANDLE_IS_SCM) )
-		return WERR_BADFID;	
-	
+		return WERR_BADFID;
+
 	if ( !(info->access_granted & SC_RIGHT_MGR_LOCK) )
 		return WERR_ACCESS_DENIED;
 
 	/* Just open a handle.  Doesn't actually lock anything */
-	
+
 	return create_open_service_handle( p, &r_u->h_lock, SVC_HANDLE_IS_DBLOCK, NULL, 0 );
 ;
 }
@@ -779,8 +779,8 @@ WERROR _svcctl_unlock_service_db( pipes_struct *p, SVCCTL_Q_UNLOCK_SERVICE_DB *q
 
 
 	if ( !info || (info->type != SVC_HANDLE_IS_DBLOCK) )
-		return WERR_BADFID;	
-		
+		return WERR_BADFID;
+
 	return close_policy_hnd( p, &q_u->h_lock) ? WERR_OK : WERR_BADFID;
 }
 
@@ -796,7 +796,7 @@ WERROR _svcctl_query_service_sec( pipes_struct *p, SVCCTL_Q_QUERY_SERVICE_SEC *q
 	/* only support the SCM and individual services */
 
 	if ( !info || !(info->type & (SVC_HANDLE_IS_SERVICE|SVC_HANDLE_IS_SCM)) )
-		return WERR_BADFID;	
+		return WERR_BADFID;
 
 	/* check access reights (according to MSDN) */
 
@@ -824,7 +824,7 @@ WERROR _svcctl_query_service_sec( pipes_struct *p, SVCCTL_Q_QUERY_SERVICE_SEC *q
 
 	if ( !sec_io_desc("", &sec_desc, &r_u->buffer.prs, 0 ) )
 		return WERR_NOMEM;
-		
+
 	return WERR_OK;
 }
 
@@ -843,37 +843,37 @@ WERROR _svcctl_set_service_sec( pipes_struct *p, SVCCTL_Q_SET_SERVICE_SEC *q_u,
 	/* can't set the security de4scriptor on the ServiceControlManager */
 
 	if ( info->type == SVC_HANDLE_IS_SCM )
-		return WERR_ACCESS_DENIED;	
+		return WERR_ACCESS_DENIED;
 
 	/* check the access on the open handle */
-	
+
 	switch ( q_u->security_flags ) {
 		case DACL_SECURITY_INFORMATION:
 			required_access = STD_RIGHT_WRITE_DAC_ACCESS;
 			break;
-			
+
 		case OWNER_SECURITY_INFORMATION:
 		case GROUP_SECURITY_INFORMATION:
 			required_access = STD_RIGHT_WRITE_OWNER_ACCESS;
 			break;
-			
+
 		case SACL_SECURITY_INFORMATION:
 			return WERR_INVALID_PARAM;
 		default:
 			return WERR_INVALID_PARAM;
 	}
-	
+
 	if ( !(info->access_granted & required_access) )
 		return WERR_ACCESS_DENIED;
-	
+
 	/* read the security descfriptor */
-		
+
 	if ( !sec_io_desc("", &sec_desc, &q_u->buffer.prs, 0 ) )
 		return WERR_NOMEM;
-		
+
 	/* store the new SD */
 
-	if ( !svcctl_set_secdesc( p->mem_ctx, info->name, sec_desc, p->pipe_user.nt_user_token ) ) 
+	if ( !svcctl_set_secdesc( p->mem_ctx, info->name, sec_desc, p->pipe_user.nt_user_token ) )
 		return WERR_ACCESS_DENIED;
 
 	return WERR_OK;
@@ -883,258 +883,258 @@ WERROR _svcctl_set_service_sec( pipes_struct *p, SVCCTL_Q_SET_SERVICE_SEC *q_u,
 WERROR _svcctl_ControlService(pipes_struct *p, struct svcctl_ControlService *r)
 {
 	p->rng_fault_state = True;
-	return WERR_NOT_SUPPORTED;	
+	return WERR_NOT_SUPPORTED;
 }
 
 WERROR _svcctl_DeleteService(pipes_struct *p, struct svcctl_DeleteService *r)
 {
 	p->rng_fault_state = True;
-	return WERR_NOT_SUPPORTED;	
+	return WERR_NOT_SUPPORTED;
 }
 
 WERROR _svcctl_LockServiceDatabase(pipes_struct *p, struct svcctl_LockServiceDatabase *r)
 {
 	p->rng_fault_state = True;
-	return WERR_NOT_SUPPORTED;	
+	return WERR_NOT_SUPPORTED;
 }
 
 WERROR _svcctl_QueryServiceObjectSecurity(pipes_struct *p, struct svcctl_QueryServiceObjectSecurity *r)
 {
 	p->rng_fault_state = True;
-	return WERR_NOT_SUPPORTED;	
+	return WERR_NOT_SUPPORTED;
 }
 
 WERROR _svcctl_SetServiceObjectSecurity(pipes_struct *p, struct svcctl_SetServiceObjectSecurity *r)
 {
 	p->rng_fault_state = True;
-	return WERR_NOT_SUPPORTED;	
+	return WERR_NOT_SUPPORTED;
 }
 
 WERROR _svcctl_QueryServiceStatus(pipes_struct *p, struct svcctl_QueryServiceStatus *r)
 {
 	p->rng_fault_state = True;
-	return WERR_NOT_SUPPORTED;	
+	return WERR_NOT_SUPPORTED;
 }
 
 WERROR _svcctl_SetServiceStatus(pipes_struct *p, struct svcctl_SetServiceStatus *r)
 {
 	p->rng_fault_state = True;
-	return WERR_NOT_SUPPORTED;	
+	return WERR_NOT_SUPPORTED;
 }
 
 WERROR _svcctl_UnlockServiceDatabase(pipes_struct *p, struct svcctl_UnlockServiceDatabase *r)
 {
 	p->rng_fault_state = True;
-	return WERR_NOT_SUPPORTED;	
+	return WERR_NOT_SUPPORTED;
 }
 
 WERROR _svcctl_NotifyBootConfigStatus(pipes_struct *p, struct svcctl_NotifyBootConfigStatus *r)
 {
 	p->rng_fault_state = True;
-	return WERR_NOT_SUPPORTED;	
+	return WERR_NOT_SUPPORTED;
 }
 
 WERROR _svcctl_SCSetServiceBitsW(pipes_struct *p, struct svcctl_SCSetServiceBitsW *r)
 {
 	p->rng_fault_state = True;
-	return WERR_NOT_SUPPORTED;	
+	return WERR_NOT_SUPPORTED;
 }
 
 WERROR _svcctl_ChangeServiceConfigW(pipes_struct *p, struct svcctl_ChangeServiceConfigW *r)
 {
 	p->rng_fault_state = True;
-	return WERR_NOT_SUPPORTED;	
+	return WERR_NOT_SUPPORTED;
 }
 
 WERROR _svcctl_CreateServiceW(pipes_struct *p, struct svcctl_CreateServiceW *r)
 {
 	p->rng_fault_state = True;
-	return WERR_NOT_SUPPORTED;	
+	return WERR_NOT_SUPPORTED;
 }
 
 WERROR _svcctl_EnumDependentServicesW(pipes_struct *p, struct svcctl_EnumDependentServicesW *r)
 {
 	p->rng_fault_state = True;
-	return WERR_NOT_SUPPORTED;	
+	return WERR_NOT_SUPPORTED;
 }
 
 WERROR _svcctl_EnumServicesStatusW(pipes_struct *p, struct svcctl_EnumServicesStatusW *r)
 {
 	p->rng_fault_state = True;
-	return WERR_NOT_SUPPORTED;	
+	return WERR_NOT_SUPPORTED;
 }
 
 WERROR _svcctl_OpenSCManagerW(pipes_struct *p, struct svcctl_OpenSCManagerW *r)
 {
 	p->rng_fault_state = True;
-	return WERR_NOT_SUPPORTED;	
+	return WERR_NOT_SUPPORTED;
 }
 
 WERROR _svcctl_OpenServiceW(pipes_struct *p, struct svcctl_OpenServiceW *r)
 {
 	p->rng_fault_state = True;
-	return WERR_NOT_SUPPORTED;	
+	return WERR_NOT_SUPPORTED;
 }
 
 WERROR _svcctl_QueryServiceConfigW(pipes_struct *p, struct svcctl_QueryServiceConfigW *r)
 {
 	p->rng_fault_state = True;
-	return WERR_NOT_SUPPORTED;	
+	return WERR_NOT_SUPPORTED;
 }
 
 WERROR _svcctl_QueryServiceLockStatusW(pipes_struct *p, struct svcctl_QueryServiceLockStatusW *r)
 {
 	p->rng_fault_state = True;
-	return WERR_NOT_SUPPORTED;	
+	return WERR_NOT_SUPPORTED;
 }
 
 WERROR _svcctl_StartServiceW(pipes_struct *p, struct svcctl_StartServiceW *r)
 {
 	p->rng_fault_state = True;
-	return WERR_NOT_SUPPORTED;	
+	return WERR_NOT_SUPPORTED;
 }
 
 WERROR _svcctl_GetServiceDisplayNameW(pipes_struct *p, struct svcctl_GetServiceDisplayNameW *r)
 {
 	p->rng_fault_state = True;
-	return WERR_NOT_SUPPORTED;	
+	return WERR_NOT_SUPPORTED;
 }
 
 WERROR _svcctl_GetServiceKeyNameW(pipes_struct *p, struct svcctl_GetServiceKeyNameW *r)
 {
 	p->rng_fault_state = True;
-	return WERR_NOT_SUPPORTED;	
+	return WERR_NOT_SUPPORTED;
 }
 
 WERROR _svcctl_SCSetServiceBitsA(pipes_struct *p, struct svcctl_SCSetServiceBitsA *r)
 {
 	p->rng_fault_state = True;
-	return WERR_NOT_SUPPORTED;	
+	return WERR_NOT_SUPPORTED;
 }
 
 WERROR _svcctl_ChangeServiceConfigA(pipes_struct *p, struct svcctl_ChangeServiceConfigA *r)
 {
 	p->rng_fault_state = True;
-	return WERR_NOT_SUPPORTED;	
+	return WERR_NOT_SUPPORTED;
 }
 
 WERROR _svcctl_CreateServiceA(pipes_struct *p, struct svcctl_CreateServiceA *r)
 {
 	p->rng_fault_state = True;
-	return WERR_NOT_SUPPORTED;	
+	return WERR_NOT_SUPPORTED;
 }
 
 WERROR _svcctl_EnumDependentServicesA(pipes_struct *p, struct svcctl_EnumDependentServicesA *r)
 {
 	p->rng_fault_state = True;
-	return WERR_NOT_SUPPORTED;	
+	return WERR_NOT_SUPPORTED;
 }
 
 WERROR _svcctl_EnumServicesStatusA(pipes_struct *p, struct svcctl_EnumServicesStatusA *r)
 {
 	p->rng_fault_state = True;
-	return WERR_NOT_SUPPORTED;	
+	return WERR_NOT_SUPPORTED;
 }
 
 WERROR _svcctl_OpenSCManagerA(pipes_struct *p, struct svcctl_OpenSCManagerA *r)
 {
 	p->rng_fault_state = True;
-	return WERR_NOT_SUPPORTED;	
+	return WERR_NOT_SUPPORTED;
 }
 
 WERROR _svcctl_OpenServiceA(pipes_struct *p, struct svcctl_OpenServiceA *r)
 {
 	p->rng_fault_state = True;
-	return WERR_NOT_SUPPORTED;	
+	return WERR_NOT_SUPPORTED;
 }
 
 WERROR _svcctl_QueryServiceConfigA(pipes_struct *p, struct svcctl_QueryServiceConfigA *r)
 {
 	p->rng_fault_state = True;
-	return WERR_NOT_SUPPORTED;	
+	return WERR_NOT_SUPPORTED;
 }
 
 WERROR _svcctl_QueryServiceLockStatusA(pipes_struct *p, struct svcctl_QueryServiceLockStatusA *r)
 {
 	p->rng_fault_state = True;
-	return WERR_NOT_SUPPORTED;	
+	return WERR_NOT_SUPPORTED;
 }
 
 WERROR _svcctl_StartServiceA(pipes_struct *p, struct svcctl_StartServiceA *r)
 {
 	p->rng_fault_state = True;
-	return WERR_NOT_SUPPORTED;	
+	return WERR_NOT_SUPPORTED;
 }
 
 WERROR _svcctl_GetServiceDisplayNameA(pipes_struct *p, struct svcctl_GetServiceDisplayNameA *r)
 {
 	p->rng_fault_state = True;
-	return WERR_NOT_SUPPORTED;	
+	return WERR_NOT_SUPPORTED;
 }
 
 WERROR _svcctl_GetServiceKeyNameA(pipes_struct *p, struct svcctl_GetServiceKeyNameA *r)
 {
 	p->rng_fault_state = True;
-	return WERR_NOT_SUPPORTED;	
+	return WERR_NOT_SUPPORTED;
 }
 
 WERROR _svcctl_GetCurrentGroupeStateW(pipes_struct *p, struct svcctl_GetCurrentGroupeStateW *r)
 {
 	p->rng_fault_state = True;
-	return WERR_NOT_SUPPORTED;	
+	return WERR_NOT_SUPPORTED;
 }
 
 WERROR _svcctl_EnumServiceGroupW(pipes_struct *p, struct svcctl_EnumServiceGroupW *r)
 {
 	p->rng_fault_state = True;
-	return WERR_NOT_SUPPORTED;	
+	return WERR_NOT_SUPPORTED;
 }
 
 WERROR _svcctl_ChangeServiceConfig2A(pipes_struct *p, struct svcctl_ChangeServiceConfig2A *r)
 {
 	p->rng_fault_state = True;
-	return WERR_NOT_SUPPORTED;	
+	return WERR_NOT_SUPPORTED;
 }
 
 WERROR _svcctl_ChangeServiceConfig2W(pipes_struct *p, struct svcctl_ChangeServiceConfig2W *r)
 {
 	p->rng_fault_state = True;
-	return WERR_NOT_SUPPORTED;	
+	return WERR_NOT_SUPPORTED;
 }
 
 WERROR _svcctl_QueryServiceConfig2A(pipes_struct *p, struct svcctl_QueryServiceConfig2A *r)
 {
 	p->rng_fault_state = True;
-	return WERR_NOT_SUPPORTED;	
+	return WERR_NOT_SUPPORTED;
 }
 
 WERROR _svcctl_QueryServiceConfig2W(pipes_struct *p, struct svcctl_QueryServiceConfig2W *r)
 {
 	p->rng_fault_state = True;
-	return WERR_NOT_SUPPORTED;	
+	return WERR_NOT_SUPPORTED;
 }
 
 WERROR _svcctl_QueryServiceStatusEx(pipes_struct *p, struct svcctl_QueryServiceStatusEx *r)
 {
 	p->rng_fault_state = True;
-	return WERR_NOT_SUPPORTED;	
+	return WERR_NOT_SUPPORTED;
 }
 
 WERROR _EnumServicesStatusExA(pipes_struct *p, struct EnumServicesStatusExA *r)
 {
 	p->rng_fault_state = True;
-	return WERR_NOT_SUPPORTED;	
+	return WERR_NOT_SUPPORTED;
 }
 
 WERROR _EnumServicesStatusExW(pipes_struct *p, struct EnumServicesStatusExW *r)
 {
 	p->rng_fault_state = True;
-	return WERR_NOT_SUPPORTED;	
+	return WERR_NOT_SUPPORTED;
 }
 
 WERROR _svcctl_SCSendTSMessage(pipes_struct *p, struct svcctl_SCSendTSMessage *r)
 {
 	p->rng_fault_state = True;
-	return WERR_NOT_SUPPORTED;	
+	return WERR_NOT_SUPPORTED;
 }
 
diff --git a/source3/utils/net_rpc_service.c b/source3/utils/net_rpc_service.c
index a70ecf3c72..5ad907e8a6 100644
--- a/source3/utils/net_rpc_service.c
+++ b/source3/utils/net_rpc_service.c
@@ -1,21 +1,21 @@
-/* 
-   Samba Unix/Linux SMB client library 
-   Distributed SMB/CIFS Server Management Utility 
+/*
+   Samba Unix/Linux SMB client library
+   Distributed SMB/CIFS Server Management Utility
    Copyright (C) Gerald (Jerry) Carter          2005
 
    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/>.  */
- 
+
 #include "includes.h"
 #include "utils/net.h"
 
@@ -24,7 +24,7 @@
 ********************************************************************/
 
 static WERROR query_service_state(struct rpc_pipe_client *pipe_hnd,
-				TALLOC_CTX *mem_ctx, 
+				TALLOC_CTX *mem_ctx,
 				POLICY_HND *hSCM,
 				const char *service,
 				uint32 *state )
@@ -32,10 +32,10 @@ static WERROR query_service_state(struct rpc_pipe_client *pipe_hnd,
 	POLICY_HND hService;
 	SERVICE_STATUS service_status;
 	WERROR result = WERR_GENERAL_FAILURE;
-	
+
 	/* now cycle until the status is actually 'watch_state' */
-	
-	result = rpccli_svcctl_open_service(pipe_hnd, mem_ctx, hSCM, &hService, 
+
+	result = rpccli_svcctl_open_service(pipe_hnd, mem_ctx, hSCM, &hService,
 		service, SC_RIGHT_SVC_QUERY_STATUS );
 
 	if ( !W_ERROR_IS_OK(result) ) {
@@ -47,9 +47,9 @@ static WERROR query_service_state(struct rpc_pipe_client *pipe_hnd,
 	if ( W_ERROR_IS_OK(result) ) {
 		*state = service_status.state;
 	}
-	
+
 	rpccli_svcctl_CloseServiceHandle(pipe_hnd, mem_ctx, &hService, NULL);
-	
+
 	return result;
 }
 
@@ -57,17 +57,17 @@ static WERROR query_service_state(struct rpc_pipe_client *pipe_hnd,
 ********************************************************************/
 
 static WERROR watch_service_state(struct rpc_pipe_client *pipe_hnd,
-				TALLOC_CTX *mem_ctx, 
+				TALLOC_CTX *mem_ctx,
 				POLICY_HND *hSCM,
-				const char *service, 
+				const char *service,
 				uint32 watch_state,
 				uint32 *final_state )
 {
 	uint32 i;
 	uint32 state = 0;
 	WERROR result = WERR_GENERAL_FAILURE;
-	
-	
+
+
 	i = 0;
 	while ( (state != watch_state ) && i<30 ) {
 		/* get the status */
@@ -76,15 +76,15 @@ static WERROR watch_service_state(struct rpc_pipe_client *pipe_hnd,
 		if ( !W_ERROR_IS_OK(result) ) {
 			break;
 		}
-		
+
 		d_printf(".");
 		i++;
 		sys_usleep( 100 );
 	}
 	d_printf("\n");
-	
+
 	*final_state = state;
-	
+
 	return result;
 }
 
@@ -92,9 +92,9 @@ static WERROR watch_service_state(struct rpc_pipe_client *pipe_hnd,
 ********************************************************************/
 
 static WERROR control_service(struct rpc_pipe_client *pipe_hnd,
-				TALLOC_CTX *mem_ctx, 
+				TALLOC_CTX *mem_ctx,
 				POLICY_HND *hSCM,
-				const char *service, 
+				const char *service,
 				uint32 control,
 				uint32 watch_state )
 {
@@ -102,47 +102,47 @@ static WERROR control_service(struct rpc_pipe_client *pipe_hnd,
 	WERROR result = WERR_GENERAL_FAILURE;
 	SERVICE_STATUS service_status;
 	uint32 state = 0;
-	
+
 	/* Open the Service */
-	
-	result = rpccli_svcctl_open_service(pipe_hnd, mem_ctx, hSCM, &hService, 
+
+	result = rpccli_svcctl_open_service(pipe_hnd, mem_ctx, hSCM, &hService,
 		service, (SC_RIGHT_SVC_STOP|SC_RIGHT_SVC_PAUSE_CONTINUE) );
 
 	if ( !W_ERROR_IS_OK(result) ) {
 		d_fprintf(stderr, "Failed to open service.  [%s]\n", dos_errstr(result));
 		goto done;
 	}
-	
+
 	/* get the status */
 
-	result = rpccli_svcctl_control_service(pipe_hnd, mem_ctx, &hService, 
+	result = rpccli_svcctl_control_service(pipe_hnd, mem_ctx, &hService,
 		control, &service_status  );
-		
+
 	if ( !W_ERROR_IS_OK(result) ) {
 		d_fprintf(stderr, "Control service request failed.  [%s]\n", dos_errstr(result));
 		goto done;
 	}
-	
+
 	/* loop -- checking the state until we are where we want to be */
-	
+
 	result = watch_service_state(pipe_hnd, mem_ctx, hSCM, service, watch_state, &state );
-		
+
 	d_printf("%s service is %s.\n", service, svc_status_string(state));
 
-done:	
+done:
 	rpccli_svcctl_CloseServiceHandle(pipe_hnd, mem_ctx, &hService, NULL);
-		
+
 	return result;
-}	
+}
 
 /********************************************************************
 ********************************************************************/
 
 static NTSTATUS rpc_service_list_internal(const DOM_SID *domain_sid,
-					const char *domain_name, 
+					const char *domain_name,
 					struct cli_state *cli,
 					struct rpc_pipe_client *pipe_hnd,
-					TALLOC_CTX *mem_ctx, 
+					TALLOC_CTX *mem_ctx,
 					int argc,
 					const char **argv )
 {
@@ -153,7 +153,7 @@ static NTSTATUS rpc_service_list_internal(const DOM_SID *domain_sid,
 	fstring displayname;
 	uint32 num_services = 0;
 	int i;
-	
+
 	if (argc != 0 ) {
 		d_printf("Usage: net rpc service list\n");
 		return NT_STATUS_OK;
@@ -164,39 +164,39 @@ static NTSTATUS rpc_service_list_internal(const DOM_SID *domain_sid,
 		d_fprintf(stderr, "Failed to open Service Control Manager.  [%s]\n", dos_errstr(result));
 		return werror_to_ntstatus(result);
 	}
-	
+
 	result = rpccli_svcctl_enumerate_services(pipe_hnd, mem_ctx, &hSCM, SVCCTL_TYPE_WIN32,
 		SVCCTL_STATE_ALL, &num_services, &services );
-	
+
 	if ( !W_ERROR_IS_OK(result) ) {
 		d_fprintf(stderr, "Failed to enumerate services.  [%s]\n", dos_errstr(result));
 		goto done;
 	}
-	
+
 	if ( num_services == 0 )
 		d_printf("No services returned\n");
-	
+
 	for ( i=0; i<num_services; i++ ) {
 		rpcstr_pull( servicename, services[i].servicename.buffer, sizeof(servicename), -1, STR_TERMINATE );
 		rpcstr_pull( displayname, services[i].displayname.buffer, sizeof(displayname), -1, STR_TERMINATE );
-		
+
 		d_printf("%-20s    \"%s\"\n", servicename, displayname);
 	}
 
-done:	
+done:
 	rpccli_svcctl_CloseServiceHandle(pipe_hnd, mem_ctx, &hSCM, NULL);
-		
+
 	return werror_to_ntstatus(result);
-}	
+}
 
 /********************************************************************
 ********************************************************************/
 
 static NTSTATUS rpc_service_status_internal(const DOM_SID *domain_sid,
-						const char *domain_name, 
+						const char *domain_name,
 						struct cli_state *cli,
 						struct rpc_pipe_client *pipe_hnd,
-						TALLOC_CTX *mem_ctx, 
+						TALLOC_CTX *mem_ctx,
 						int argc,
 						const char **argv )
 {
@@ -206,7 +206,7 @@ static NTSTATUS rpc_service_status_internal(const DOM_SID *domain_sid,
 	SERVICE_STATUS service_status;
 	SERVICE_CONFIG config;
 	fstring ascii_string;
-	
+
 	if (argc != 1 ) {
 		d_printf("Usage: net rpc service status <service>\n");
 		return NT_STATUS_OK;
@@ -215,23 +215,23 @@ static NTSTATUS rpc_service_status_internal(const DOM_SID *domain_sid,
 	fstrcpy( servicename, argv[0] );
 
 	/* Open the Service Control Manager */
-	
+
 	result = rpccli_svcctl_open_scm(pipe_hnd, mem_ctx, &hSCM, SC_RIGHT_MGR_ENUMERATE_SERVICE  );
 	if ( !W_ERROR_IS_OK(result) ) {
 		d_fprintf(stderr, "Failed to open Service Control Manager.  [%s]\n", dos_errstr(result));
 		return werror_to_ntstatus(result);
 	}
-	
+
 	/* Open the Service */
-	
-	result = rpccli_svcctl_open_service(pipe_hnd, mem_ctx, &hSCM, &hService, servicename, 
+
+	result = rpccli_svcctl_open_service(pipe_hnd, mem_ctx, &hSCM, &hService, servicename,
 		(SC_RIGHT_SVC_QUERY_STATUS|SC_RIGHT_SVC_QUERY_CONFIG) );
 
 	if ( !W_ERROR_IS_OK(result) ) {
 		d_fprintf(stderr, "Failed to open service.  [%s]\n", dos_errstr(result));
 		goto done;
 	}
-	
+
 	/* get the status */
 
 	result = rpccli_svcctl_query_status(pipe_hnd, mem_ctx, &hService, &service_status  );
@@ -239,7 +239,7 @@ static NTSTATUS rpc_service_status_internal(const DOM_SID *domain_sid,
 		d_fprintf(stderr, "Query status request failed.  [%s]\n", dos_errstr(result));
 		goto done;
 	}
-	
+
 	d_printf("%s service is %s.\n", servicename, svc_status_string(service_status.state));
 
 	/* get the config */
@@ -284,28 +284,28 @@ static NTSTATUS rpc_service_status_internal(const DOM_SID *domain_sid,
 		d_printf("\tDisplay Name         = %s\n", ascii_string);
 	}
 
-done:	
+done:
         rpccli_svcctl_CloseServiceHandle(pipe_hnd, mem_ctx, &hService, NULL);
 	rpccli_svcctl_CloseServiceHandle(pipe_hnd, mem_ctx, &hSCM, NULL);
 
 	return werror_to_ntstatus(result);
-}	
+}
 
 /********************************************************************
 ********************************************************************/
 
 static NTSTATUS rpc_service_stop_internal(const DOM_SID *domain_sid,
-					const char *domain_name, 
+					const char *domain_name,
 					struct cli_state *cli,
 					struct rpc_pipe_client *pipe_hnd,
-					TALLOC_CTX *mem_ctx, 
+					TALLOC_CTX *mem_ctx,
 					int argc,
 					const char **argv )
 {
 	POLICY_HND hSCM;
 	WERROR result = WERR_GENERAL_FAILURE;
 	fstring servicename;
-	
+
 	if (argc != 1 ) {
 		d_printf("Usage: net rpc service status <service>\n");
 		return NT_STATUS_OK;
@@ -314,36 +314,36 @@ static NTSTATUS rpc_service_stop_internal(const DOM_SID *domain_sid,
 	fstrcpy( servicename, argv[0] );
 
 	/* Open the Service Control Manager */
-	
+
 	result = rpccli_svcctl_open_scm(pipe_hnd, mem_ctx, &hSCM, SC_RIGHT_MGR_ENUMERATE_SERVICE  );
 	if ( !W_ERROR_IS_OK(result) ) {
 		d_fprintf(stderr, "Failed to open Service Control Manager.  [%s]\n", dos_errstr(result));
 		return werror_to_ntstatus(result);
 	}
-	
-	result = control_service(pipe_hnd, mem_ctx, &hSCM, servicename, 
+
+	result = control_service(pipe_hnd, mem_ctx, &hSCM, servicename,
 		SVCCTL_CONTROL_STOP, SVCCTL_STOPPED );
-		
+
 	rpccli_svcctl_CloseServiceHandle(pipe_hnd, mem_ctx, &hSCM, NULL);
-		
+
 	return werror_to_ntstatus(result);
-}	
+}
 
 /********************************************************************
 ********************************************************************/
 
 static NTSTATUS rpc_service_pause_internal(const DOM_SID *domain_sid,
-					const char *domain_name, 
+					const char *domain_name,
 					struct cli_state *cli,
 					struct rpc_pipe_client *pipe_hnd,
-					TALLOC_CTX *mem_ctx, 
+					TALLOC_CTX *mem_ctx,
 					int argc,
 					const char **argv )
 {
 	POLICY_HND hSCM;
 	WERROR result = WERR_GENERAL_FAILURE;
 	fstring servicename;
-	
+
 	if (argc != 1 ) {
 		d_printf("Usage: net rpc service status <service>\n");
 		return NT_STATUS_OK;
@@ -352,36 +352,36 @@ static NTSTATUS rpc_service_pause_internal(const DOM_SID *domain_sid,
 	fstrcpy( servicename, argv[0] );
 
 	/* Open the Service Control Manager */
-	
+
 	result = rpccli_svcctl_open_scm(pipe_hnd, mem_ctx, &hSCM, SC_RIGHT_MGR_ENUMERATE_SERVICE  );
 	if ( !W_ERROR_IS_OK(result) ) {
 		d_fprintf(stderr, "Failed to open Service Control Manager.  [%s]\n", dos_errstr(result));
 		return werror_to_ntstatus(result);
 	}
-	
-	result = control_service(pipe_hnd, mem_ctx, &hSCM, servicename, 
+
+	result = control_service(pipe_hnd, mem_ctx, &hSCM, servicename,
 		SVCCTL_CONTROL_PAUSE, SVCCTL_PAUSED );
-		
+
 	rpccli_svcctl_CloseServiceHandle(pipe_hnd, mem_ctx, &hSCM, NULL);
-		
+
 	return werror_to_ntstatus(result);
-}	
+}
 
 /********************************************************************
 ********************************************************************/
 
 static NTSTATUS rpc_service_resume_internal(const DOM_SID *domain_sid,
-					const char *domain_name, 
+					const char *domain_name,
 					struct cli_state *cli,
 					struct rpc_pipe_client *pipe_hnd,
-					TALLOC_CTX *mem_ctx, 
+					TALLOC_CTX *mem_ctx,
 					int argc,
 					const char **argv )
 {
 	POLICY_HND hSCM;
 	WERROR result = WERR_GENERAL_FAILURE;
 	fstring servicename;
-	
+
 	if (argc != 1 ) {
 		d_printf("Usage: net rpc service status <service>\n");
 		return NT_STATUS_OK;
@@ -390,29 +390,29 @@ static NTSTATUS rpc_service_resume_internal(const DOM_SID *domain_sid,
 	fstrcpy( servicename, argv[0] );
 
 	/* Open the Service Control Manager */
-	
+
 	result = rpccli_svcctl_open_scm(pipe_hnd, mem_ctx, &hSCM, SC_RIGHT_MGR_ENUMERATE_SERVICE  );
 	if ( !W_ERROR_IS_OK(result) ) {
 		d_fprintf(stderr, "Failed to open Service Control Manager.  [%s]\n", dos_errstr(result));
 		return werror_to_ntstatus(result);
 	}
-	
-	result = control_service(pipe_hnd, mem_ctx, &hSCM, servicename, 
+
+	result = control_service(pipe_hnd, mem_ctx, &hSCM, servicename,
 		SVCCTL_CONTROL_CONTINUE, SVCCTL_RUNNING );
-		
+
 	rpccli_svcctl_CloseServiceHandle(pipe_hnd, mem_ctx, &hSCM, NULL);
-		
+
 	return werror_to_ntstatus(result);
-}	
+}
 
 /********************************************************************
 ********************************************************************/
 
 static NTSTATUS rpc_service_start_internal(const DOM_SID *domain_sid,
-					const char *domain_name, 
+					const char *domain_name,
 					struct cli_state *cli,
 					struct rpc_pipe_client *pipe_hnd,
-					TALLOC_CTX *mem_ctx, 
+					TALLOC_CTX *mem_ctx,
 					int argc,
 					const char **argv )
 {
@@ -420,7 +420,7 @@ static NTSTATUS rpc_service_start_internal(const DOM_SID *domain_sid,
 	WERROR result = WERR_GENERAL_FAILURE;
 	fstring servicename;
 	uint32 state = 0;
-	
+
 	if (argc != 1 ) {
 		d_printf("Usage: net rpc service status <service>\n");
 		return NT_STATUS_OK;
@@ -429,23 +429,23 @@ static NTSTATUS rpc_service_start_internal(const DOM_SID *domain_sid,
 	fstrcpy( servicename, argv[0] );
 
 	/* Open the Service Control Manager */
-	
+
 	result = rpccli_svcctl_open_scm( pipe_hnd, mem_ctx, &hSCM, SC_RIGHT_MGR_ENUMERATE_SERVICE  );
 	if ( !W_ERROR_IS_OK(result) ) {
 		d_fprintf(stderr, "Failed to open Service Control Manager.  [%s]\n", dos_errstr(result));
 		return werror_to_ntstatus(result);
 	}
-	
+
 	/* Open the Service */
-	
-	result = rpccli_svcctl_open_service(pipe_hnd, mem_ctx, &hSCM, &hService, 
+
+	result = rpccli_svcctl_open_service(pipe_hnd, mem_ctx, &hSCM, &hService,
 		servicename, SC_RIGHT_SVC_START );
 
 	if ( !W_ERROR_IS_OK(result) ) {
 		d_fprintf(stderr, "Failed to open service.  [%s]\n", dos_errstr(result));
 		goto done;
 	}
-	
+
 	/* get the status */
 
 	result = rpccli_svcctl_start_service(pipe_hnd, mem_ctx, &hService, NULL, 0 );
@@ -453,15 +453,15 @@ static NTSTATUS rpc_service_start_internal(const DOM_SID *domain_sid,
 		d_fprintf(stderr, "Query status request failed.  [%s]\n", dos_errstr(result));
 		goto done;
 	}
-	
+
 	result = watch_service_state(pipe_hnd, mem_ctx, &hSCM, servicename, SVCCTL_RUNNING, &state  );
-	
+
 	if ( W_ERROR_IS_OK(result) && (state == SVCCTL_RUNNING) )
 		d_printf("Successfully started service: %s\n", servicename );
 	else
 		d_fprintf(stderr, "Failed to start service: %s [%s]\n", servicename, dos_errstr(result) );
-	
-done:	
+
+done:
 	rpccli_svcctl_CloseServiceHandle(pipe_hnd, mem_ctx, &hService, NULL);
 	rpccli_svcctl_CloseServiceHandle(pipe_hnd, mem_ctx, &hSCM, NULL);
 
@@ -473,7 +473,7 @@ done:
 
 static int rpc_service_list( int argc, const char **argv )
 {
-	return run_rpc_command( NULL, PI_SVCCTL, 0, 
+	return run_rpc_command( NULL, PI_SVCCTL, 0,
 		rpc_service_list_internal, argc, argv );
 }
 
@@ -482,7 +482,7 @@ static int rpc_service_list( int argc, const char **argv )
 
 static int rpc_service_start( int argc, const char **argv )
 {
-	return run_rpc_command( NULL, PI_SVCCTL, 0, 
+	return run_rpc_command( NULL, PI_SVCCTL, 0,
 		rpc_service_start_internal, argc, argv );
 }
 
@@ -491,7 +491,7 @@ static int rpc_service_start( int argc, const char **argv )
 
 static int rpc_service_stop( int argc, const char **argv )
 {
-	return run_rpc_command( NULL, PI_SVCCTL, 0, 
+	return run_rpc_command( NULL, PI_SVCCTL, 0,
 		rpc_service_stop_internal, argc, argv );
 }
 
@@ -500,7 +500,7 @@ static int rpc_service_stop( int argc, const char **argv )
 
 static int rpc_service_resume( int argc, const char **argv )
 {
-	return run_rpc_command( NULL, PI_SVCCTL, 0, 
+	return run_rpc_command( NULL, PI_SVCCTL, 0,
 		rpc_service_resume_internal, argc, argv );
 }
 
@@ -509,7 +509,7 @@ static int rpc_service_resume( int argc, const char **argv )
 
 static int rpc_service_pause( int argc, const char **argv )
 {
-	return run_rpc_command( NULL, PI_SVCCTL, 0, 
+	return run_rpc_command( NULL, PI_SVCCTL, 0,
 		rpc_service_pause_internal, argc, argv );
 }
 
@@ -518,7 +518,7 @@ static int rpc_service_pause( int argc, const char **argv )
 
 static int rpc_service_status( int argc, const char **argv )
 {
-	return run_rpc_command( NULL, PI_SVCCTL, 0, 
+	return run_rpc_command( NULL, PI_SVCCTL, 0,
 		rpc_service_status_internal, argc, argv );
 }
 
@@ -533,14 +533,14 @@ static int net_help_service( int argc, const char **argv )
 	d_printf("net rpc service pause <service>    Pause a service\n");
 	d_printf("net rpc service resume <service>   Resume a paused service\n");
 	d_printf("net rpc service status <service>   View the current status of a service\n");
-	
+
 	return -1;
 }
 
 /********************************************************************
 ********************************************************************/
 
-int net_rpc_service(int argc, const char **argv) 
+int net_rpc_service(int argc, const char **argv)
 {
 	struct functable func[] = {
 		{"list", rpc_service_list},
@@ -551,9 +551,9 @@ int net_rpc_service(int argc, const char **argv)
 		{"status", rpc_service_status},
 		{NULL, NULL}
 	};
-	
+
 	if ( argc )
 		return net_run_function( argc, argv, func, net_help_service );
-		
+
 	return net_help_service( argc, argv );
 }