Whitespace cleanup.

Jeremy.
(This used to be commit 3052172d2bfe9d787777525e90816394aac2dd54)

1 files changed, 1035 insertions, 1037 deletions

diff --git a/source3/rpc_server/srv_spoolss_nt.c b/source3/rpc_server/srv_spoolss_nt.c
index d49731272f..f18c120a9f 100644
--- a/source3/rpc_server/srv_spoolss_nt.c
+++ b/source3/rpc_server/srv_spoolss_nt.c
@@ -50,7 +50,7 @@ static Printer_entry *printers_list;
 typedef struct _counter_printer_0 {
 	struct _counter_printer_0 *next;
 	struct _counter_printer_0 *prev;
-	
+
 	int snum;
 	uint32 counter;
 } counter_printer_0;
@@ -139,7 +139,7 @@ static void srv_spoolss_replycloseprinter(int snum, POLICY_HND *handle)
 {
 	WERROR result;
 
-	/* 
+	/*
 	 * Tell the specific printing tdb we no longer want messages for this printer
 	 * by deregistering our PID.
 	 */
@@ -154,7 +154,7 @@ static void srv_spoolss_replycloseprinter(int snum, POLICY_HND *handle)
 	}
 
 	result = rpccli_spoolss_reply_close_printer(notify_cli_pipe, notify_cli_pipe->cli->mem_ctx, handle);
-	
+
 	if (!W_ERROR_IS_OK(result))
 		DEBUG(0,("srv_spoolss_replycloseprinter: reply_close_printer failed [%s].\n",
 			dos_errstr(result)));
@@ -206,10 +206,10 @@ static void free_printer_entry(void *ptr)
 	free_spool_notify_option(&Printer->notify.option);
 	Printer->notify.option=NULL;
 	Printer->notify.client_connected=False;
-	
+
 	free_nt_devicemode( &Printer->nt_devmode );
 	free_a_printer( &Printer->printer_info, 2 );
-	
+
 	talloc_destroy( Printer->ctx );
 
 	/* Remove from the internal list. */
@@ -279,7 +279,7 @@ static bool close_printer_handle(pipes_struct *p, POLICY_HND *hnd)
 	close_policy_hnd(p, hnd);
 
 	return True;
-}	
+}
 
 /****************************************************************************
  Delete a printer given a handle.
@@ -291,46 +291,46 @@ WERROR delete_printer_hook( NT_USER_TOKEN *token, const char *sharename )
 	int ret;
 	SE_PRIV se_printop = SE_PRINT_OPERATOR;
 	bool is_print_op = False;
-		
+
 	/* can't fail if we don't try */
-	
+
 	if ( !*cmd )
 		return WERR_OK;
-		
+
 	pstr_sprintf(command, "%s \"%s\"", cmd, sharename);
 
 	if ( token )
 		is_print_op = user_has_privileges( token, &se_printop );
-	
+
 	DEBUG(10,("Running [%s]\n", command));
 
 	/********** BEGIN SePrintOperatorPrivlege BLOCK **********/
-	
+
 	if ( is_print_op )
 		become_root();
-		
+
 	if ( (ret = smbrun(command, NULL)) == 0 ) {
 		/* Tell everyone we updated smb.conf. */
 		message_send_all(smbd_messaging_context(),
 				 MSG_SMB_CONF_UPDATED, NULL, 0, NULL);
 	}
-		
+
 	if ( is_print_op )
 		unbecome_root();
 
 	/********** END SePrintOperatorPrivlege BLOCK **********/
-	
+
 	DEBUGADD(10,("returned [%d]\n", ret));
 
-	if (ret != 0) 
+	if (ret != 0)
 		return WERR_BADFID; /* What to return here? */
 
 	/* go ahead and re-read the services immediately */
 	reload_services( False );
-	
+
 	if ( lp_servicenumber( sharename )  < 0 )
 		return WERR_ACCESS_DENIED;
-		
+
 	return WERR_OK;
 }
 
@@ -347,7 +347,7 @@ static WERROR delete_printer_handle(pipes_struct *p, POLICY_HND *hnd)
 		return WERR_BADFID;
 	}
 
-	/* 
+	/*
 	 * It turns out that Windows allows delete printer on a handle
 	 * opened by an admin user, then used on a pipe handle created
 	 * by an anonymous user..... but they're working on security.... riiight !
@@ -358,10 +358,10 @@ static WERROR delete_printer_handle(pipes_struct *p, POLICY_HND *hnd)
 		DEBUG(3, ("delete_printer_handle: denied by handle\n"));
 		return WERR_ACCESS_DENIED;
 	}
-	
-	/* this does not need a become root since the access check has been 
+
+	/* this does not need a become root since the access check has been
 	   done on the handle already */
-	   
+
 	if (del_a_printer( Printer->sharename ) != 0) {
 		DEBUG(3,("Error deleting printer %s\n", Printer->sharename));
 		return WERR_BADFID;
@@ -378,15 +378,15 @@ static bool get_printer_snum(pipes_struct *p, POLICY_HND *hnd, int *number,
 			     struct share_params **params)
 {
 	Printer_entry *Printer = find_printer_index_by_hnd(p, hnd);
-		
+
 	if (!Printer) {
 		DEBUG(2,("get_printer_snum: Invalid handle (%s:%u:%u)\n", OUR_HANDLE(hnd)));
 		return False;
 	}
-	
+
 	switch (Printer->printer_type) {
-		case SPLHND_PRINTER:		
-			DEBUG(4,("short name:%s\n", Printer->sharename));			
+		case SPLHND_PRINTER:
+			DEBUG(4,("short name:%s\n", Printer->sharename));
 			*number = print_queue_snum(Printer->sharename);
 			return (*number != -1);
 		case SPLHND_SERVER:
@@ -413,7 +413,7 @@ static bool set_printer_hnd_printertype(Printer_entry *Printer, char *handlename
 	/* it's a print server */
 	if (*handlename=='\\' && *(handlename+1)=='\\' && !strchr_m(handlename+2, '\\')) {
 		DEBUGADD(4,("Printer is a print server\n"));
-		Printer->printer_type = SPLHND_SERVER;		
+		Printer->printer_type = SPLHND_SERVER;
 	}
 	/* it's a printer (set_printer_hnd_name() will handle port monitors */
 	else {
@@ -425,9 +425,9 @@ static bool set_printer_hnd_printertype(Printer_entry *Printer, char *handlename
 }
 
 /****************************************************************************
- Set printer handle name..  Accept names like \\server, \\server\printer, 
+ Set printer handle name..  Accept names like \\server, \\server\printer,
  \\server\SHARE, & "\\server\,XcvMonitor Standard TCP/IP Port"    See
- the MSDN docs regarding OpenPrinter() for details on the XcvData() and 
+ the MSDN docs regarding OpenPrinter() for details on the XcvData() and
  XcvDataPort() interface.
 ****************************************************************************/
 
@@ -441,7 +441,7 @@ static bool set_printer_hnd_name(Printer_entry *Printer, char *handlename)
 	bool found=False;
 	NT_PRINTER_INFO_LEVEL *printer = NULL;
 	WERROR result;
-	
+
 	DEBUG(4,("Setting printer name=%s (len=%lu)\n", handlename, (unsigned long)strlen(handlename)));
 
 	aprinter = handlename;
@@ -455,14 +455,14 @@ static bool set_printer_hnd_name(Printer_entry *Printer, char *handlename)
 	else {
 		servername = "";
 	}
-	
+
 	/* save the servername to fill in replies on this handle */
-	
+
 	if ( !is_myname_or_ipaddr( servername ) )
 		return False;
 
 	fstrcpy( Printer->servername, servername );
-	
+
 	if ( Printer->printer_type == SPLHND_SERVER )
 		return True;
 
@@ -470,9 +470,9 @@ static bool set_printer_hnd_name(Printer_entry *Printer, char *handlename)
 		return False;
 
 	DEBUGADD(5, ("searching for [%s]\n", aprinter ));
-	
+
 	/* check for the Port Monitor Interface */
-	
+
 	if ( strequal( aprinter, SPL_XCV_MONITOR_TCPMON ) ) {
 		Printer->printer_type = SPLHND_PORTMON_TCP;
 		fstrcpy(sname, SPL_XCV_MONITOR_TCPMON);
@@ -484,12 +484,12 @@ static bool set_printer_hnd_name(Printer_entry *Printer, char *handlename)
 		found = True;
 	}
 
-	/* Search all sharenames first as this is easier than pulling 
+	/* Search all sharenames first as this is easier than pulling
 	   the printer_info_2 off of disk. Don't use find_service() since
 	   that calls out to map_username() */
-	
+
 	/* do another loop to look for printernames */
-	
+
 	for (snum=0; !found && snum<n_services; snum++) {
 
 		/* no point going on if this is not a printer */
@@ -505,7 +505,7 @@ static bool set_printer_hnd_name(Printer_entry *Printer, char *handlename)
 
 		/* no point looking up the printer object if
 		   we aren't allowing printername != sharename */
-		
+
 		if ( lp_force_printername(snum) )
 			continue;
 
@@ -518,7 +518,7 @@ static bool set_printer_hnd_name(Printer_entry *Printer, char *handlename)
 				sname, dos_errstr(result)));
 			continue;
 		}
-		
+
 		/* printername is always returned as \\server\printername */
 		if ( !(printername = strchr_m(&printer->info_2->printername[2], '\\')) ) {
 			DEBUG(0,("set_printer_hnd_name: info2->printername in wrong format! [%s]\n",
@@ -526,17 +526,17 @@ static bool set_printer_hnd_name(Printer_entry *Printer, char *handlename)
 			free_a_printer( &printer, 2);
 			continue;
 		}
-		
+
 		printername++;
-		
+
 		if ( strequal(printername, aprinter) ) {
 			free_a_printer( &printer, 2);
 			found = True;
 			break;
 		}
-		
+
 		DEBUGADD(10, ("printername: %s\n", printername));
-		
+
 		free_a_printer( &printer, 2);
 	}
 
@@ -546,7 +546,7 @@ static bool set_printer_hnd_name(Printer_entry *Printer, char *handlename)
 		DEBUGADD(4,("Printer not found\n"));
 		return False;
 	}
-	
+
 	DEBUGADD(4,("set_printer_hnd_name: Printer found: %s -> %s\n", aprinter, sname));
 
 	fstrcpy(Printer->sharename, sname);
@@ -568,28 +568,28 @@ static bool open_printer_hnd(pipes_struct *p, POLICY_HND *hnd, char *name, uint3
 		return False;
 
 	ZERO_STRUCTP(new_printer);
-	
+
 	if (!create_policy_hnd(p, hnd, free_printer_entry, new_printer)) {
 		SAFE_FREE(new_printer);
 		return False;
 	}
-	
+
 	/* Add to the internal list. */
 	DLIST_ADD(printers_list, new_printer);
-	
+
 	new_printer->notify.option=NULL;
-				
+
 	if ( !(new_printer->ctx = talloc_init("Printer Entry [%p]", hnd)) ) {
 		DEBUG(0,("open_printer_hnd: talloc_init() failed!\n"));
 		close_printer_handle(p, hnd);
 		return False;
 	}
-	
+
 	if (!set_printer_hnd_printertype(new_printer, name)) {
 		close_printer_handle(p, hnd);
 		return False;
 	}
-	
+
 	if (!set_printer_hnd_name(new_printer, name)) {
 		close_printer_handle(p, hnd);
 		return False;
@@ -619,10 +619,10 @@ static bool is_monitoring_event(Printer_entry *p, uint16 notify_type,
 	SPOOL_NOTIFY_OPTION *option = p->notify.option;
 	uint32 i, j;
 
-	/* 
+	/*
 	 * Flags should always be zero when the change notify
 	 * is registered by the client's spooler.  A user Win32 app
-	 * might use the flags though instead of the NOTIFY_OPTION_INFO 
+	 * might use the flags though instead of the NOTIFY_OPTION_INFO
 	 * --jerry
 	 */
 
@@ -635,24 +635,24 @@ static bool is_monitoring_event(Printer_entry *p, uint16 notify_type,
 			p->notify.flags, notify_type, notify_field);
 
 	for (i = 0; i < option->count; i++) {
-		
+
 		/* Check match for notify_type */
-		
+
 		if (option->ctr.type[i].type != notify_type)
 			continue;
 
 		/* Check match for field */
-		
+
 		for (j = 0; j < option->ctr.type[i].count; j++) {
 			if (option->ctr.type[i].fields[j] == notify_field) {
 				return True;
 			}
 		}
 	}
-	
+
 	DEBUG(10, ("Open handle for \\\\%s\\%s is not monitoring 0x%02x/0x%02x\n",
 		   p->servername, p->sharename, notify_type, notify_field));
-	
+
 	return False;
 }
 
@@ -671,7 +671,7 @@ static void notify_string(struct spoolss_notify_msg *msg,
 			  TALLOC_CTX *mem_ctx)
 {
 	UNISTR2 unistr;
-	
+
 	/* The length of the message includes the trailing \0 */
 
 	init_unistr2(&unistr, msg->notify.data, UNI_STR_TERMINATE);
@@ -683,7 +683,7 @@ static void notify_string(struct spoolss_notify_msg *msg,
 		data->notify_data.data.length = 0;
 		return;
 	}
-	
+
 	memcpy(data->notify_data.data.string, unistr.buffer, msg->len * 2);
 }
 
@@ -791,21 +791,21 @@ static struct notify2_message_table job_notify_table[] = {
 /***********************************************************************
  Allocate talloc context for container object
  **********************************************************************/
- 
+
 static void notify_msg_ctr_init( SPOOLSS_NOTIFY_MSG_CTR *ctr )
 {
 	if ( !ctr )
 		return;
 
 	ctr->ctx = talloc_init("notify_msg_ctr_init %p", ctr);
-		
+
 	return;
 }
 
 /***********************************************************************
  release all allocated memory and zero out structure
  **********************************************************************/
- 
+
 static void notify_msg_ctr_destroy( SPOOLSS_NOTIFY_MSG_CTR *ctr )
 {
 	if ( !ctr )
@@ -813,34 +813,34 @@ static void notify_msg_ctr_destroy( SPOOLSS_NOTIFY_MSG_CTR *ctr )
 
 	if ( ctr->ctx )
 		talloc_destroy(ctr->ctx);
-		
+
 	ZERO_STRUCTP(ctr);
-		
+
 	return;
 }
 
 /***********************************************************************
  **********************************************************************/
- 
+
 static TALLOC_CTX* notify_ctr_getctx( SPOOLSS_NOTIFY_MSG_CTR *ctr )
 {
 	if ( !ctr )
 		return NULL;
-		
+
 	return ctr->ctx;
 }
 
 /***********************************************************************
  **********************************************************************/
- 
+
 static SPOOLSS_NOTIFY_MSG_GROUP* notify_ctr_getgroup( SPOOLSS_NOTIFY_MSG_CTR *ctr, uint32 idx )
 {
 	if ( !ctr || !ctr->msg_groups )
 		return NULL;
-	
+
 	if ( idx >= ctr->num_groups )
 		return NULL;
-		
+
 	return &ctr->msg_groups[idx];
 
 }
@@ -848,38 +848,38 @@ static SPOOLSS_NOTIFY_MSG_GROUP* notify_ctr_getgroup( SPOOLSS_NOTIFY_MSG_CTR *ct
 /***********************************************************************
  How many groups of change messages do we have ?
  **********************************************************************/
- 
+
 static int notify_msg_ctr_numgroups( SPOOLSS_NOTIFY_MSG_CTR *ctr )
 {
 	if ( !ctr )
 		return 0;
-		
+
 	return ctr->num_groups;
 }
 
 /***********************************************************************
  Add a SPOOLSS_NOTIFY_MSG_CTR to the correct group
  **********************************************************************/
- 
+
 static int notify_msg_ctr_addmsg( SPOOLSS_NOTIFY_MSG_CTR *ctr, SPOOLSS_NOTIFY_MSG *msg )
 {
 	SPOOLSS_NOTIFY_MSG_GROUP	*groups = NULL;
 	SPOOLSS_NOTIFY_MSG_GROUP	*msg_grp = NULL;
 	SPOOLSS_NOTIFY_MSG		*msg_list = NULL;
 	int				i, new_slot;
-	
+
 	if ( !ctr || !msg )
 		return 0;
-	
+
 	/* loop over all groups looking for a matching printer name */
-	
+
 	for ( i=0; i<ctr->num_groups; i++ ) {
 		if ( strcmp(ctr->msg_groups[i].printername, msg->printer) == 0 )
 			break;
 	}
-	
+
 	/* add a new group? */
-	
+
 	if ( i == ctr->num_groups ) {
 		ctr->num_groups++;
 
@@ -890,37 +890,37 @@ static int notify_msg_ctr_addmsg( SPOOLSS_NOTIFY_MSG_CTR *ctr, SPOOLSS_NOTIFY_MS
 		ctr->msg_groups = groups;
 
 		/* clear the new entry and set the printer name */
-		
+
 		ZERO_STRUCT( ctr->msg_groups[ctr->num_groups-1] );
 		fstrcpy( ctr->msg_groups[ctr->num_groups-1].printername, msg->printer );
 	}
-	
+
 	/* add the change messages; 'i' is the correct index now regardless */
-	
+
 	msg_grp = &ctr->msg_groups[i];
-	
+
 	msg_grp->num_msgs++;
-	
+
 	if ( !(msg_list = TALLOC_REALLOC_ARRAY( ctr->ctx, msg_grp->msgs, SPOOLSS_NOTIFY_MSG, msg_grp->num_msgs )) ) {
 		DEBUG(0,("notify_msg_ctr_addmsg: talloc_realloc() failed for new message [%d]!\n", msg_grp->num_msgs));
 		return 0;
 	}
 	msg_grp->msgs = msg_list;
-	
+
 	new_slot = msg_grp->num_msgs-1;
 	memcpy( &msg_grp->msgs[new_slot], msg, sizeof(SPOOLSS_NOTIFY_MSG) );
-	
+
 	/* need to allocate own copy of data */
-	
-	if ( msg->len != 0 ) 
+
+	if ( msg->len != 0 )
 		msg_grp->msgs[new_slot].notify.data = (char *)
 			TALLOC_MEMDUP( ctr->ctx, msg->notify.data, msg->len );
-	
+
 	return ctr->num_groups;
 }
 
 /***********************************************************************
- Send a change notication message on all handles which have a call 
+ Send a change notication message on all handles which have a call
  back registered
  **********************************************************************/
 
@@ -931,23 +931,23 @@ static void send_notify2_changes( SPOOLSS_NOTIFY_MSG_CTR *ctr, uint32 idx )
 	SPOOLSS_NOTIFY_MSG_GROUP *msg_group = notify_ctr_getgroup( ctr, idx );
 	SPOOLSS_NOTIFY_MSG       *messages;
 	int			 sending_msg_count;
-	
+
 	if ( !msg_group ) {
 		DEBUG(5,("send_notify2_changes() called with no msg group!\n"));
 		return;
 	}
-	
+
 	messages = msg_group->msgs;
-	
+
 	if ( !messages ) {
 		DEBUG(5,("send_notify2_changes() called with no messages!\n"));
 		return;
 	}
-	
+
 	DEBUG(8,("send_notify2_changes: Enter...[%s]\n", msg_group->printername));
-	
+
 	/* loop over all printers */
-	
+
 	for (p = printers_list; p; p = p->next) {
 		SPOOL_NOTIFY_INFO_DATA *data;
 		uint32	data_len = 0;
@@ -961,7 +961,7 @@ static void send_notify2_changes( SPOOLSS_NOTIFY_MSG_CTR *ctr, uint32 idx )
 
 		DEBUG(10,("Client connected! [\\\\%s\\%s]\n", p->servername, p->sharename));
 
-		/* For this printer?  Print servers always receive 
+		/* For this printer?  Print servers always receive
                    notifications. */
 
 		if ( ( p->printer_type == SPLHND_PRINTER )  &&
@@ -969,40 +969,40 @@ static void send_notify2_changes( SPOOLSS_NOTIFY_MSG_CTR *ctr, uint32 idx )
 			continue;
 
 		DEBUG(10,("Our printer\n"));
-		
+
 		/* allocate the max entries possible */
-		
+
 		data = TALLOC_ARRAY( mem_ctx, SPOOL_NOTIFY_INFO_DATA, msg_group->num_msgs);
 		if (!data) {
 			return;
 		}
 
 		ZERO_STRUCTP(data);
-		
+
 		/* build the array of change notifications */
-		
+
 		sending_msg_count = 0;
-		
+
 		for ( i=0; i<msg_group->num_msgs; i++ ) {
 			SPOOLSS_NOTIFY_MSG	*msg = &messages[i];
-			
+
 			/* Are we monitoring this event? */
 
 			if (!is_monitoring_event(p, msg->type, msg->field))
 				continue;
 
 			sending_msg_count++;
-			
-			
+
+
 			DEBUG(10,("process_notify2_message: Sending message type [0x%x] field [0x%2x] for printer [%s]\n",
 				msg->type, msg->field, p->sharename));
 
-			/* 
-			 * if the is a printer notification handle and not a job notification 
+			/*
+			 * if the is a printer notification handle and not a job notification
 			 * type, then set the id to 0.  Other wise just use what was specified
-			 * in the message.  
+			 * in the message.
 			 *
-			 * When registering change notification on a print server handle 
+			 * When registering change notification on a print server handle
 			 * we always need to send back the id (snum) matching the printer
 			 * for which the change took place.  For change notify registered
 			 * on a printer handle, this does not matter and the id should be 0.
@@ -1034,7 +1034,7 @@ static void send_notify2_changes( SPOOLSS_NOTIFY_MSG_CTR *ctr, uint32 idx )
 				if ( printer_notify_table[msg->field].fn )
 					printer_notify_table[msg->field].fn(msg, &data[data_len], mem_ctx);
 				break;
-			
+
 			case JOB_NOTIFY_TYPE:
 				if ( job_notify_table[msg->field].fn )
 					job_notify_table[msg->field].fn(msg, &data[data_len], mem_ctx);
@@ -1049,11 +1049,11 @@ static void send_notify2_changes( SPOOLSS_NOTIFY_MSG_CTR *ctr, uint32 idx )
 		}
 
 		if ( sending_msg_count ) {
-			rpccli_spoolss_rrpcn( notify_cli_pipe, mem_ctx, &p->notify.client_hnd, 
+			rpccli_spoolss_rrpcn( notify_cli_pipe, mem_ctx, &p->notify.client_hnd,
 					data_len, data, p->notify.change, 0 );
 		}
 	}
-	
+
 done:
 	DEBUG(8,("send_notify2_changes: Exit...\n"));
 	return;
@@ -1072,7 +1072,7 @@ static bool notify2_unpack_msg( SPOOLSS_NOTIFY_MSG *msg, struct timeval *tv, voi
 
 	offset += tdb_unpack((uint8 *)buf + offset, len - offset, "f",
 			     msg->printer);
-	
+
 	offset += tdb_unpack((uint8 *)buf + offset, len - offset, "ddddddd",
 				&tv_sec, &tv_usec,
 				&msg->type, &msg->field, &msg->id, &msg->len, &msg->flags);
@@ -1081,7 +1081,7 @@ static bool notify2_unpack_msg( SPOOLSS_NOTIFY_MSG *msg, struct timeval *tv, voi
 		tdb_unpack((uint8 *)buf + offset, len - offset, "dd",
 			   &msg->notify.value[0], &msg->notify.value[1]);
 	else
-		tdb_unpack((uint8 *)buf + offset, len - offset, "B", 
+		tdb_unpack((uint8 *)buf + offset, len - offset, "B",
 			   &msg->len, &msg->notify.data);
 
 	DEBUG(3, ("notify2_unpack_msg: got NOTIFY2 message for printer %s, jobid %u type %d, field 0x%02x, flags 0x%04x\n",
@@ -1121,7 +1121,7 @@ static void receive_notify2_message_list(struct messaging_context *msg,
 		DEBUG(0,("receive_notify2_message_list: bad message format (len < 4)!\n"));
 		return;
 	}
-	
+
 	msg_count = IVAL(buf, 0);
 	msg_ptr = buf + 4;
 
@@ -1133,17 +1133,17 @@ static void receive_notify2_message_list(struct messaging_context *msg,
 	}
 
 	/* initialize the container */
-	
+
 	ZERO_STRUCT( messages );
 	notify_msg_ctr_init( &messages );
-	
-	/* 
+
+	/*
 	 * build message groups for each printer identified
 	 * in a change_notify msg.  Remember that a PCN message
 	 * includes the handle returned for the srv_spoolss_replyopenprinter()
 	 * call.  Therefore messages are grouped according to printer handle.
 	 */
-	 
+
 	for ( i=0; i<msg_count; i++ ) {
 		struct timeval msg_tv;
 
@@ -1159,36 +1159,36 @@ static void receive_notify2_message_list(struct messaging_context *msg,
 			DEBUG(0,("receive_notify2_message_list: bad message format (bad len) !\n"));
 			return;
 		}
-		
+
 		/* unpack messages */
-		
+
 		ZERO_STRUCT( notify );
 		notify2_unpack_msg( &notify, &msg_tv, msg_ptr, msg_len );
 		msg_ptr += msg_len;
 
 		/* add to correct list in container */
-		
+
 		notify_msg_ctr_addmsg( &messages, &notify );
-		
+
 		/* free memory that might have been allocated by notify2_unpack_msg() */
-		
+
 		if ( notify.len != 0 )
 			SAFE_FREE( notify.notify.data );
 	}
-	
+
 	/* process each group of messages */
-	
+
 	num_groups = notify_msg_ctr_numgroups( &messages );
 	for ( i=0; i<num_groups; i++ )
 		send_notify2_changes( &messages, i );
-	
-	
+
+
 	/* cleanup */
-		
+
 	DEBUG(10,("receive_notify2_message_list: processed %u messages\n", (uint32)msg_count ));
-		
+
 	notify_msg_ctr_destroy( &messages );
-	
+
 	return;
 }
 
@@ -1197,17 +1197,17 @@ static void receive_notify2_message_list(struct messaging_context *msg,
  so we can upgrade the information for each printer bound to this
  driver
  ********************************************************************/
- 
+
 static bool srv_spoolss_drv_upgrade_printer(char* drivername)
 {
 	int len = strlen(drivername);
-	
+
 	if (!len)
 		return False;
 
 	DEBUG(10,("srv_spoolss_drv_upgrade_printer: Sending message about driver upgrade [%s]\n",
 		drivername));
-		
+
 	messaging_send_buf(smbd_messaging_context(), procid_self(),
 			   MSG_PRINTER_DRVUPGRADE,
 			   (uint8 *)drivername, len+1);
@@ -1217,9 +1217,9 @@ static bool srv_spoolss_drv_upgrade_printer(char* drivername)
 
 /**********************************************************************
  callback to receive a MSG_PRINTER_DRVUPGRADE message and interate
- over all printers, upgrading ones as necessary 
+ over all printers, upgrading ones as necessary
  **********************************************************************/
- 
+
 void do_drv_upgrade_printer(struct messaging_context *msg,
 			    void *private_data,
 			    uint32_t msg_type,
@@ -1230,47 +1230,47 @@ void do_drv_upgrade_printer(struct messaging_context *msg,
 	int snum;
 	int n_services = lp_numservices();
 	size_t len;
-	
+
 	len = MIN(data->length,sizeof(drivername)-1);
 	strncpy(drivername, (const char *)data->data, len);
-	
+
 	DEBUG(10,("do_drv_upgrade_printer: Got message for new driver [%s]\n", drivername ));
 
 	/* Iterate the printer list */
-	
+
 	for (snum=0; snum<n_services; snum++)
 	{
-		if (lp_snum_ok(snum) && lp_print_ok(snum) ) 
+		if (lp_snum_ok(snum) && lp_print_ok(snum) )
 		{
 			WERROR result;
 			NT_PRINTER_INFO_LEVEL *printer = NULL;
-			
+
 			result = get_a_printer(NULL, &printer, 2, lp_const_servicename(snum));
 			if (!W_ERROR_IS_OK(result))
 				continue;
-				
-			if (printer && printer->info_2 && !strcmp(drivername, printer->info_2->drivername)) 
+
+			if (printer && printer->info_2 && !strcmp(drivername, printer->info_2->drivername))
 			{
 				DEBUG(6,("Updating printer [%s]\n", printer->info_2->printername));
-				
+
 				/* all we care about currently is the change_id */
-				
+
 				result = mod_a_printer(printer, 2);
 				if (!W_ERROR_IS_OK(result)) {
-					DEBUG(3,("do_drv_upgrade_printer: mod_a_printer() failed with status [%s]\n", 
+					DEBUG(3,("do_drv_upgrade_printer: mod_a_printer() failed with status [%s]\n",
 						dos_errstr(result)));
 				}
 			}
-			
-			free_a_printer(&printer, 2);			
+
+			free_a_printer(&printer, 2);
 		}
 	}
-	
-	/* all done */	
+
+	/* all done */
 }
 
 /********************************************************************
- Update the cache for all printq's with a registered client 
+ Update the cache for all printq's with a registered client
  connection
  ********************************************************************/
 
@@ -1278,21 +1278,21 @@ void update_monitored_printq_cache( void )
 {
 	Printer_entry *printer = printers_list;
 	int snum;
-	
-	/* loop through all printers and update the cache where 
+
+	/* loop through all printers and update the cache where
 	   client_connected == True */
-	while ( printer ) 
+	while ( printer )
 	{
-		if ( (printer->printer_type == SPLHND_PRINTER) 
-			&& printer->notify.client_connected ) 
+		if ( (printer->printer_type == SPLHND_PRINTER)
+			&& printer->notify.client_connected )
 		{
 			snum = print_queue_snum(printer->sharename);
 			print_queue_status( snum, NULL, NULL );
 		}
-		
+
 		printer = printer->next;
 	}
-	
+
 	return;
 }
 /********************************************************************
@@ -1300,17 +1300,17 @@ void update_monitored_printq_cache( void )
  so we can upgrade the information for each printer bound to this
  driver
  ********************************************************************/
- 
+
 static bool srv_spoolss_reset_printerdata(char* drivername)
 {
 	int len = strlen(drivername);
-	
+
 	if (!len)
 		return False;
 
 	DEBUG(10,("srv_spoolss_reset_printerdata: Sending message about resetting printerdata [%s]\n",
 		drivername));
-		
+
 	messaging_send_buf(smbd_messaging_context(), procid_self(),
 			   MSG_PRINTERDATA_INIT_RESET,
 			   (uint8 *)drivername, len+1);
@@ -1320,9 +1320,9 @@ static bool srv_spoolss_reset_printerdata(char* drivername)
 
 /**********************************************************************
  callback to receive a MSG_PRINTERDATA_INIT_RESET message and interate
- over all printers, resetting printer data as neessary 
+ over all printers, resetting printer data as neessary
  **********************************************************************/
- 
+
 void reset_all_printerdata(struct messaging_context *msg,
 			   void *private_data,
 			   uint32_t msg_type,
@@ -1333,52 +1333,52 @@ void reset_all_printerdata(struct messaging_context *msg,
 	int snum;
 	int n_services = lp_numservices();
 	size_t len;
-	
+
 	len = MIN( data->length, sizeof(drivername)-1 );
 	strncpy( drivername, (const char *)data->data, len );
-	
+
 	DEBUG(10,("reset_all_printerdata: Got message for new driver [%s]\n", drivername ));
 
 	/* Iterate the printer list */
-	
+
 	for ( snum=0; snum<n_services; snum++ )
 	{
-		if ( lp_snum_ok(snum) && lp_print_ok(snum) ) 
+		if ( lp_snum_ok(snum) && lp_print_ok(snum) )
 		{
 			WERROR result;
 			NT_PRINTER_INFO_LEVEL *printer = NULL;
-			
+
 			result = get_a_printer( NULL, &printer, 2, lp_const_servicename(snum) );
 			if ( !W_ERROR_IS_OK(result) )
 				continue;
-				
-			/* 
-			 * if the printer is bound to the driver, 
-			 * then reset to the new driver initdata 
+
+			/*
+			 * if the printer is bound to the driver,
+			 * then reset to the new driver initdata
 			 */
-			
-			if ( printer && printer->info_2 && !strcmp(drivername, printer->info_2->drivername) ) 
+
+			if ( printer && printer->info_2 && !strcmp(drivername, printer->info_2->drivername) )
 			{
 				DEBUG(6,("reset_all_printerdata: Updating printer [%s]\n", printer->info_2->printername));
-				
+
 				if ( !set_driver_init(printer, 2) ) {
 					DEBUG(5,("reset_all_printerdata: Error resetting printer data for printer [%s], driver [%s]!\n",
 						printer->info_2->printername, printer->info_2->drivername));
-				}	
-				
+				}
+
 				result = mod_a_printer( printer, 2 );
 				if ( !W_ERROR_IS_OK(result) ) {
-					DEBUG(3,("reset_all_printerdata: mod_a_printer() failed!  (%s)\n", 
+					DEBUG(3,("reset_all_printerdata: mod_a_printer() failed!  (%s)\n",
 						get_dos_error_msg(result)));
 				}
 			}
-			
+
 			free_a_printer( &printer, 2 );
 		}
 	}
-	
-	/* all done */	
-	
+
+	/* all done */
+
 	return;
 }
 
@@ -1393,17 +1393,17 @@ static DEVICEMODE* dup_devicemode(TALLOC_CTX *ctx, DEVICEMODE *devmode)
 
 	if (!devmode)
 		return NULL;
-		
+
 	DEBUG (8,("dup_devmode\n"));
-	
+
 	/* bulk copy first */
-	
+
 	d = (DEVICEMODE *)TALLOC_MEMDUP(ctx, devmode, sizeof(DEVICEMODE));
 	if (!d)
 		return NULL;
-		
+
 	/* dup the pointer members separately */
-	
+
 	len = unistrlen(devmode->devicename.buffer);
 	if (len != -1) {
 		d->devicename.buffer = TALLOC_ARRAY(ctx, uint16, len);
@@ -1413,7 +1413,7 @@ static DEVICEMODE* dup_devicemode(TALLOC_CTX *ctx, DEVICEMODE *devmode)
 		if (unistrcpy(d->devicename.buffer, devmode->devicename.buffer) != len)
 			return NULL;
 	}
-		
+
 
 	len = unistrlen(devmode->formname.buffer);
 	if (len != -1) {
@@ -1430,7 +1430,7 @@ static DEVICEMODE* dup_devicemode(TALLOC_CTX *ctx, DEVICEMODE *devmode)
 						devmode->driverextra);
 		if (!d->dev_private) {
 			return NULL;
-		}	
+		}
 	} else {
 		d->dev_private = NULL;
 	}
@@ -1441,12 +1441,12 @@ static void copy_devmode_ctr(TALLOC_CTX *ctx, DEVMODE_CTR *new_ctr, DEVMODE_CTR
 {
 	if (!new_ctr || !ctr)
 		return;
-		
+
 	DEBUG(8,("copy_devmode_ctr\n"));
-	
+
 	new_ctr->size = ctr->size;
 	new_ctr->devmode_ptr = ctr->devmode_ptr;
-	
+
 	if(ctr->devmode_ptr)
 		new_ctr->devmode = dup_devicemode(ctx, ctr->devmode);
 }
@@ -1455,21 +1455,21 @@ static void copy_printer_default(TALLOC_CTX *ctx, PRINTER_DEFAULT *new_def, PRIN
 {
 	if (!new_def || !def)
 		return;
-	
+
 	DEBUG(8,("copy_printer_defaults\n"));
-	
+
 	new_def->datatype_ptr = def->datatype_ptr;
-	
+
 	if (def->datatype_ptr)
 		copy_unistr2(&new_def->datatype, &def->datatype);
-	
+
 	copy_devmode_ctr(ctx, &new_def->devmode_cont, &def->devmode_cont);
-	
+
 	new_def->access_required = def->access_required;
 }
 
 /********************************************************************
- * Convert a SPOOL_Q_OPEN_PRINTER structure to a 
+ * Convert a SPOOL_Q_OPEN_PRINTER structure to a
  * SPOOL_Q_OPEN_PRINTER_EX structure
  ********************************************************************/
 
@@ -1479,14 +1479,14 @@ static WERROR convert_to_openprinterex(TALLOC_CTX *ctx, SPOOL_Q_OPEN_PRINTER_EX
 		return WERR_OK;
 
 	DEBUG(8,("convert_to_openprinterex\n"));
-				
+
 	if ( q_u->printername ) {
 		q_u_ex->printername = TALLOC_ZERO_P( ctx, UNISTR2 );
 		if (q_u_ex->printername == NULL)
 			return WERR_NOMEM;
 		copy_unistr2(q_u_ex->printername, q_u->printername);
 	}
-	
+
 	copy_printer_default(ctx, &q_u_ex->printer_default, &q_u->printer_default);
 
 	return WERR_OK;
@@ -1502,25 +1502,25 @@ WERROR _spoolss_open_printer(pipes_struct *p, SPOOL_Q_OPEN_PRINTER *q_u, SPOOL_R
 {
 	SPOOL_Q_OPEN_PRINTER_EX q_u_ex;
 	SPOOL_R_OPEN_PRINTER_EX r_u_ex;
-	
+
 	if (!q_u || !r_u)
 		return WERR_NOMEM;
-	
+
 	ZERO_STRUCT(q_u_ex);
 	ZERO_STRUCT(r_u_ex);
-	
+
 	/* convert the OpenPrinter() call to OpenPrinterEx() */
-	
+
 	r_u_ex.status = convert_to_openprinterex(p->mem_ctx, &q_u_ex, q_u);
 	if (!W_ERROR_IS_OK(r_u_ex.status))
 		return r_u_ex.status;
-	
+
 	r_u_ex.status = _spoolss_open_printer_ex(p, &q_u_ex, &r_u_ex);
-	
+
 	/* convert back to OpenPrinter() */
-	
+
 	memcpy(r_u, &r_u_ex, sizeof(*r_u));
-	
+
 	return r_u->status;
 }
 
@@ -1548,7 +1548,7 @@ WERROR _spoolss_open_printer_ex( pipes_struct *p, SPOOL_Q_OPEN_PRINTER_EX *q_u,
 
 	if (!open_printer_hnd(p, handle, name, 0))
 		return WERR_INVALID_PRINTER_NAME;
-	
+
 	Printer=find_printer_index_by_hnd(p, handle);
 	if ( !Printer ) {
 		DEBUG(0,(" _spoolss_open_printer_ex: logic error.  Can't find printer "
@@ -1572,16 +1572,16 @@ WERROR _spoolss_open_printer_ex( pipes_struct *p, SPOOL_Q_OPEN_PRINTER_EX *q_u,
 	 *
 	 * Note: this test needs code to check access rights here too. Jeremy
 	 * could you look at this?
-	 * 
+	 *
 	 * Second case: the user is opening a printer:
 	 * NT doesn't let us connect to a printer if the connecting user
 	 * doesn't have print permission.
-	 * 
+	 *
 	 * Third case: user is opening a Port Monitor
 	 * access checks same as opening a handle to the print server.
 	 */
 
-	switch (Printer->printer_type ) 
+	switch (Printer->printer_type )
 	{
 	case SPLHND_SERVER:
 	case SPLHND_PORTMON_TCP:
@@ -1591,10 +1591,10 @@ WERROR _spoolss_open_printer_ex( pipes_struct *p, SPOOL_Q_OPEN_PRINTER_EX *q_u,
 		snum = -1;
 
 		/* Map standard access rights to object specific access rights */
-		
-		se_map_standard(&printer_default->access_required, 
+
+		se_map_standard(&printer_default->access_required,
 				&printserver_std_mapping);
-	
+
 		/* Deny any object specific bits that don't apply to print
 		   servers (i.e printer and job specific bits) */
 
@@ -1609,7 +1609,7 @@ WERROR _spoolss_open_printer_ex( pipes_struct *p, SPOOL_Q_OPEN_PRINTER_EX *q_u,
 
 		/* Allow admin access */
 
-		if ( printer_default->access_required & SERVER_ACCESS_ADMINISTER ) 
+		if ( printer_default->access_required & SERVER_ACCESS_ADMINISTER )
 		{
 			SE_PRIV se_printop = SE_PRINT_OPERATOR;
 
@@ -1620,7 +1620,7 @@ WERROR _spoolss_open_printer_ex( pipes_struct *p, SPOOL_Q_OPEN_PRINTER_EX *q_u,
 
 			/* if the user is not root, doesn't have SE_PRINT_OPERATOR privilege,
 			   and not a printer admin, then fail */
-			
+
 			if ((p->pipe_user.ut.uid != 0) &&
 			    !user_has_privileges(p->pipe_user.nt_user_token,
 						 &se_printop ) &&
@@ -1631,7 +1631,7 @@ WERROR _spoolss_open_printer_ex( pipes_struct *p, SPOOL_Q_OPEN_PRINTER_EX *q_u,
 				close_printer_handle(p, handle);
 				return WERR_ACCESS_DENIED;
 			}
-			
+
 			printer_default->access_required = SERVER_ACCESS_ADMINISTER;
 		}
 		else
@@ -1639,9 +1639,9 @@ WERROR _spoolss_open_printer_ex( pipes_struct *p, SPOOL_Q_OPEN_PRINTER_EX *q_u,
 			printer_default->access_required = SERVER_ACCESS_ENUMERATE;
 		}
 
-		DEBUG(4,("Setting print server access = %s\n", (printer_default->access_required == SERVER_ACCESS_ADMINISTER) 
+		DEBUG(4,("Setting print server access = %s\n", (printer_default->access_required == SERVER_ACCESS_ADMINISTER)
 			? "SERVER_ACCESS_ADMINISTER" : "SERVER_ACCESS_ENUMERATE" ));
-			
+
 		/* We fall through to return WERR_OK */
 		break;
 
@@ -1655,7 +1655,7 @@ WERROR _spoolss_open_printer_ex( pipes_struct *p, SPOOL_Q_OPEN_PRINTER_EX *q_u,
 		}
 
 		se_map_standard(&printer_default->access_required, &printer_std_mapping);
-		
+
 		/* map an empty access mask to the minimum access mask */
 		if (printer_default->access_required == 0x0)
 			printer_default->access_required = PRINTER_ACCESS_USE;
@@ -1663,18 +1663,18 @@ WERROR _spoolss_open_printer_ex( pipes_struct *p, SPOOL_Q_OPEN_PRINTER_EX *q_u,
 		/*
 		 * If we are not serving the printer driver for this printer,
 		 * map PRINTER_ACCESS_ADMINISTER to PRINTER_ACCESS_USE.  This
-		 * will keep NT clients happy  --jerry	
+		 * will keep NT clients happy  --jerry
 		 */
-		 
-		if (lp_use_client_driver(snum) 
+
+		if (lp_use_client_driver(snum)
 			&& (printer_default->access_required & PRINTER_ACCESS_ADMINISTER))
 		{
 			printer_default->access_required = PRINTER_ACCESS_USE;
 		}
 
 		/* check smb.conf parameters and the the sec_desc */
-		
-		if ( !check_access(smbd_server_fd(), lp_hostsallow(snum), lp_hostsdeny(snum)) ) {    
+
+		if ( !check_access(smbd_server_fd(), lp_hostsallow(snum), lp_hostsdeny(snum)) ) {
 			DEBUG(3, ("access DENIED (hosts allow/deny) for printer open\n"));
 			return WERR_ACCESS_DENIED;
 		}
@@ -1699,7 +1699,7 @@ WERROR _spoolss_open_printer_ex( pipes_struct *p, SPOOL_Q_OPEN_PRINTER_EX *q_u,
 		else
 			printer_default->access_required = PRINTER_ACCESS_USE;
 
-		DEBUG(4,("Setting printer access = %s\n", (printer_default->access_required == PRINTER_ACCESS_ADMINISTER) 
+		DEBUG(4,("Setting printer access = %s\n", (printer_default->access_required == PRINTER_ACCESS_ADMINISTER)
 			? "PRINTER_ACCESS_ADMINISTER" : "PRINTER_ACCESS_USE" ));
 
 		break;
@@ -1708,26 +1708,26 @@ WERROR _spoolss_open_printer_ex( pipes_struct *p, SPOOL_Q_OPEN_PRINTER_EX *q_u,
 		/* sanity check to prevent programmer error */
 		return WERR_BADFID;
 	}
-	
+
 	Printer->access_granted = printer_default->access_required;
-	
-	/* 
+
+	/*
 	 * If the client sent a devmode in the OpenPrinter() call, then
 	 * save it here in case we get a job submission on this handle
 	 */
-	
+
 	 if ( (Printer->printer_type != SPLHND_SERVER)
 	 	&& q_u->printer_default.devmode_cont.devmode_ptr )
-	 { 
+	 {
 	 	convert_devicemode( Printer->sharename, q_u->printer_default.devmode_cont.devmode,
 			&Printer->nt_devmode );
 	 }
 
 #if 0	/* JERRY -- I'm doubtful this is really effective */
-	/* HACK ALERT!!! Sleep for 1/3 of a second to try trigger a LAN/WAN 
+	/* HACK ALERT!!! Sleep for 1/3 of a second to try trigger a LAN/WAN
 	   optimization in Windows 2000 clients  --jerry */
 
-	if ( (printer_default->access_required == PRINTER_ACCESS_ADMINISTER) 
+	if ( (printer_default->access_required == PRINTER_ACCESS_ADMINISTER)
 		&& (RA_WIN2K == get_remote_arch()) )
 	{
 		DEBUG(10,("_spoolss_open_printer_ex: Enabling LAN/WAN hack for Win2k clients.\n"));
@@ -1748,8 +1748,8 @@ static bool convert_printer_info(const SPOOL_PRINTER_INFO_LEVEL *uni,
 
 	switch (level) {
 		case 2:
-			/* allocate memory if needed.  Messy because 
-			   convert_printer_info is used to update an existing 
+			/* allocate memory if needed.  Messy because
+			   convert_printer_info is used to update an existing
 			   printer or build a new one */
 
 			if ( !printer->info_2 ) {
@@ -1801,7 +1801,7 @@ bool convert_devicemode(const char *printername, const DEVICEMODE *devmode,
 	 * Ensure nt_devmode is a valid pointer
 	 * as we will be overwriting it.
 	 */
-		
+
 	if (nt_devmode == NULL) {
 		DEBUG(5, ("convert_devicemode: allocating a generic devmode\n"));
 		if ((nt_devmode = construct_nt_devicemode(printername)) == NULL)
@@ -1875,7 +1875,7 @@ static WERROR _spoolss_enddocprinter_internal(pipes_struct *p, POLICY_HND *handl
 		DEBUG(2,("_spoolss_enddocprinter_internal: Invalid handle (%s:%u:%u)\n", OUR_HANDLE(handle)));
 		return WERR_BADFID;
 	}
-	
+
 	if (!get_printer_snum(p, handle, &snum, NULL))
 		return WERR_BADFID;
 
@@ -1900,9 +1900,9 @@ WERROR _spoolss_closeprinter(pipes_struct *p, SPOOL_Q_CLOSEPRINTER *q_u, SPOOL_R
 		_spoolss_enddocprinter_internal(p, handle);          /* print job was not closed */
 
 	if (!close_printer_handle(p, handle))
-		return WERR_BADFID;	
-		
-	/* clear the returned printer handle.  Observed behavior 
+		return WERR_BADFID;
+
+	/* clear the returned printer handle.  Observed behavior
 	   from Win2k server.  Don't think this really matters.
 	   Previous code just copied the value of the closed
 	   handle.    --jerry */
@@ -1944,23 +1944,23 @@ static int get_version_id (char * arch)
 {
 	int i;
 	struct table_node archi_table[]= {
- 
+
 	        {"Windows 4.0",          "WIN40",       0 },
 	        {"Windows NT x86",       "W32X86",      2 },
-	        {"Windows NT R4000",     "W32MIPS",     2 },	
+	        {"Windows NT R4000",     "W32MIPS",     2 },
 	        {"Windows NT Alpha_AXP", "W32ALPHA",    2 },
 	        {"Windows NT PowerPC",   "W32PPC",      2 },
 		{"Windows IA64",         "IA64",        3 },
 		{"Windows x64",          "x64",         3 },
 	        {NULL,                   "",            -1 }
 	};
- 
+
 	for (i=0; archi_table[i].long_archi != NULL; i++)
 	{
 		if (strcmp(arch, archi_table[i].long_archi) == 0)
 			return (archi_table[i].version);
         }
-	
+
 	return -1;
 }
 
@@ -1977,34 +1977,34 @@ WERROR _spoolss_deleteprinterdriver(pipes_struct *p, SPOOL_Q_DELETEPRINTERDRIVER
 	int				version;
 	WERROR				status;
 	WERROR				status_win2k = WERR_ACCESS_DENIED;
-	SE_PRIV                         se_printop = SE_PRINT_OPERATOR;	
-	
+	SE_PRIV                         se_printop = SE_PRINT_OPERATOR;
+
 	/* if the user is not root, doesn't have SE_PRINT_OPERATOR privilege,
 	   and not a printer admin, then fail */
-			
-	if ( (p->pipe_user.ut.uid != 0) 
-		&& !user_has_privileges(p->pipe_user.nt_user_token, &se_printop ) 
-		&& !token_contains_name_in_list( uidtoname(p->pipe_user.ut.uid), 
-		    NULL, p->pipe_user.nt_user_token, lp_printer_admin(-1)) ) 
+
+	if ( (p->pipe_user.ut.uid != 0)
+		&& !user_has_privileges(p->pipe_user.nt_user_token, &se_printop )
+		&& !token_contains_name_in_list( uidtoname(p->pipe_user.ut.uid),
+		    NULL, p->pipe_user.nt_user_token, lp_printer_admin(-1)) )
 	{
 		return WERR_ACCESS_DENIED;
 	}
 
 	unistr2_to_ascii(driver, &q_u->driver, sizeof(driver));
 	unistr2_to_ascii(arch,   &q_u->arch,   sizeof(arch));
-	
+
 	/* check that we have a valid driver name first */
-	
-	if ((version=get_version_id(arch)) == -1) 
+
+	if ((version=get_version_id(arch)) == -1)
 		return WERR_INVALID_ENVIRONMENT;
-				
+
 	ZERO_STRUCT(info);
 	ZERO_STRUCT(info_win2k);
-	
-	if (!W_ERROR_IS_OK(get_a_printer_driver(&info, 3, driver, arch, version))) 
+
+	if (!W_ERROR_IS_OK(get_a_printer_driver(&info, 3, driver, arch, version)))
 	{
 		/* try for Win2k driver if "Windows NT x86" */
-		
+
 		if ( version == 2 ) {
 			version = 3;
 			if (!W_ERROR_IS_OK(get_a_printer_driver(&info, 3, driver, arch, version))) {
@@ -2017,24 +2017,24 @@ WERROR _spoolss_deleteprinterdriver(pipes_struct *p, SPOOL_Q_DELETEPRINTERDRIVER
 			status = WERR_UNKNOWN_PRINTER_DRIVER;
 			goto done;
 		}
-		
+
 	}
-	
+
 	if (printer_driver_in_use(info.info_3)) {
 		status = WERR_PRINTER_DRIVER_IN_USE;
 		goto done;
 	}
-	
+
 	if ( version == 2 )
-	{		
+	{
 		if (W_ERROR_IS_OK(get_a_printer_driver(&info_win2k, 3, driver, arch, 3)))
 		{
 			/* if we get to here, we now have 2 driver info structures to remove */
 			/* remove the Win2k driver first*/
-		
+
 			status_win2k = delete_printer_driver(info_win2k.info_3, &p->pipe_user, 3, False );
 			free_a_printer_driver( info_win2k, 3 );
-		
+
 			/* this should not have failed---if it did, report to client */
 			if ( !W_ERROR_IS_OK(status_win2k) )
 			{
@@ -2043,14 +2043,14 @@ WERROR _spoolss_deleteprinterdriver(pipes_struct *p, SPOOL_Q_DELETEPRINTERDRIVER
 			}
 		}
 	}
-	
+
 	status = delete_printer_driver(info.info_3, &p->pipe_user, version, False);
-	
+
 	/* if at least one of the deletes succeeded return OK */
-	
+
 	if ( W_ERROR_IS_OK(status) || W_ERROR_IS_OK(status_win2k) )
 		status = WERR_OK;
-	
+
 done:
 	free_a_printer_driver( info, 3 );
 
@@ -2072,19 +2072,19 @@ WERROR _spoolss_deleteprinterdriverex(pipes_struct *p, SPOOL_Q_DELETEPRINTERDRIV
 	bool				delete_files;
 	WERROR				status;
 	WERROR				status_win2k = WERR_ACCESS_DENIED;
-	SE_PRIV                         se_printop = SE_PRINT_OPERATOR;	
-	
+	SE_PRIV                         se_printop = SE_PRINT_OPERATOR;
+
 	/* if the user is not root, doesn't have SE_PRINT_OPERATOR privilege,
 	   and not a printer admin, then fail */
-			
-	if ( (p->pipe_user.ut.uid != 0) 
-		&& !user_has_privileges(p->pipe_user.nt_user_token, &se_printop ) 
-		&& !token_contains_name_in_list( uidtoname(p->pipe_user.ut.uid), 
-		    NULL, p->pipe_user.nt_user_token, lp_printer_admin(-1)) ) 
+
+	if ( (p->pipe_user.ut.uid != 0)
+		&& !user_has_privileges(p->pipe_user.nt_user_token, &se_printop )
+		&& !token_contains_name_in_list( uidtoname(p->pipe_user.ut.uid),
+		    NULL, p->pipe_user.nt_user_token, lp_printer_admin(-1)) )
 	{
 		return WERR_ACCESS_DENIED;
 	}
-	
+
 	unistr2_to_ascii(driver, &q_u->driver, sizeof(driver));
 	unistr2_to_ascii(arch,   &q_u->arch,   sizeof(arch));
 
@@ -2093,84 +2093,84 @@ WERROR _spoolss_deleteprinterdriverex(pipes_struct *p, SPOOL_Q_DELETEPRINTERDRIV
 		/* this is what NT returns */
 		return WERR_INVALID_ENVIRONMENT;
 	}
-	
+
 	if ( flags & DPD_DELETE_SPECIFIC_VERSION )
 		version = q_u->version;
-		
+
 	ZERO_STRUCT(info);
 	ZERO_STRUCT(info_win2k);
-		
+
 	status = get_a_printer_driver(&info, 3, driver, arch, version);
-	
-	if ( !W_ERROR_IS_OK(status) ) 
+
+	if ( !W_ERROR_IS_OK(status) )
 	{
-		/* 
-		 * if the client asked for a specific version, 
+		/*
+		 * if the client asked for a specific version,
 		 * or this is something other than Windows NT x86,
-		 * then we've failed 
+		 * then we've failed
 		 */
-		
+
 		if ( (flags&DPD_DELETE_SPECIFIC_VERSION) || (version !=2) )
 			goto done;
-			
+
 		/* try for Win2k driver if "Windows NT x86" */
-		
+
 		version = 3;
 		if (!W_ERROR_IS_OK(get_a_printer_driver(&info, 3, driver, arch, version))) {
 			status = WERR_UNKNOWN_PRINTER_DRIVER;
 			goto done;
 		}
 	}
-		
+
 	if ( printer_driver_in_use(info.info_3) ) {
 		status = WERR_PRINTER_DRIVER_IN_USE;
 		goto done;
 	}
-	
-	/* 
-	 * we have a couple of cases to consider. 
+
+	/*
+	 * we have a couple of cases to consider.
 	 * (1) Are any files in use?  If so and DPD_DELTE_ALL_FILE is set,
-	 *     then the delete should fail if **any** files overlap with 
-	 *     other drivers 
+	 *     then the delete should fail if **any** files overlap with
+	 *     other drivers
 	 * (2) If DPD_DELTE_UNUSED_FILES is sert, then delete all
-	 *     non-overlapping files 
+	 *     non-overlapping files
 	 * (3) If neither DPD_DELTE_ALL_FILE nor DPD_DELTE_ALL_FILES
 	 *     is set, the do not delete any files
 	 * Refer to MSDN docs on DeletePrinterDriverEx() for details.
 	 */
-	
+
 	delete_files = flags & (DPD_DELETE_ALL_FILES|DPD_DELETE_UNUSED_FILES);
-	
+
 	/* fail if any files are in use and DPD_DELETE_ALL_FILES is set */
-		
+
 	if ( delete_files && printer_driver_files_in_use(info.info_3) & (flags&DPD_DELETE_ALL_FILES) ) {
 		/* no idea of the correct error here */
-		status = WERR_ACCESS_DENIED;	
+		status = WERR_ACCESS_DENIED;
 		goto done;
 	}
 
-			
+
 	/* also check for W32X86/3 if necessary; maybe we already have? */
-		
+
 	if ( (version == 2) && ((flags&DPD_DELETE_SPECIFIC_VERSION) != DPD_DELETE_SPECIFIC_VERSION)  ) {
-		if (W_ERROR_IS_OK(get_a_printer_driver(&info_win2k, 3, driver, arch, 3))) 
+		if (W_ERROR_IS_OK(get_a_printer_driver(&info_win2k, 3, driver, arch, 3)))
 		{
-			
+
 			if ( delete_files && printer_driver_files_in_use(info_win2k.info_3) & (flags&DPD_DELETE_ALL_FILES) ) {
 				/* no idea of the correct error here */
 				free_a_printer_driver( info_win2k, 3 );
-				status = WERR_ACCESS_DENIED;	
+				status = WERR_ACCESS_DENIED;
 				goto done;
 			}
-		
+
 			/* if we get to here, we now have 2 driver info structures to remove */
 			/* remove the Win2k driver first*/
-		
+
 			status_win2k = delete_printer_driver(info_win2k.info_3, &p->pipe_user, 3, delete_files);
 			free_a_printer_driver( info_win2k, 3 );
-				
+
 			/* this should not have failed---if it did, report to client */
-				
+
 			if ( !W_ERROR_IS_OK(status_win2k) )
 				goto done;
 		}
@@ -2182,7 +2182,7 @@ WERROR _spoolss_deleteprinterdriverex(pipes_struct *p, SPOOL_Q_DELETEPRINTERDRIV
 		status = WERR_OK;
 done:
 	free_a_printer_driver( info, 3 );
-	
+
 	return status;
 }
 
@@ -2191,28 +2191,28 @@ done:
  Internal routine for retreiving printerdata
  ***************************************************************************/
 
-static WERROR get_printer_dataex( TALLOC_CTX *ctx, NT_PRINTER_INFO_LEVEL *printer, 
-                                  const char *key, const char *value, uint32 *type, uint8 **data, 
+static WERROR get_printer_dataex( TALLOC_CTX *ctx, NT_PRINTER_INFO_LEVEL *printer,
+                                  const char *key, const char *value, uint32 *type, uint8 **data,
 				  uint32 *needed, uint32 in_size  )
 {
 	REGISTRY_VALUE 		*val;
 	uint32			size;
 	int			data_len;
-	
+
 	if ( !(val = get_printer_data( printer->info_2, key, value)) )
 		return WERR_BADFILE;
-	
+
 	*type = regval_type( val );
 
 	DEBUG(5,("get_printer_dataex: allocating %d\n", in_size));
 
 	size = regval_size( val );
-	
+
 	/* copy the min(in_size, len) */
-	
+
 	if ( in_size ) {
 		data_len = (size > in_size) ? in_size : size*sizeof(uint8);
-		
+
 		/* special case for 0 length values */
 		if ( data_len ) {
 			if ( (*data  = (uint8 *)TALLOC_MEMDUP(ctx, regval_data_p(val), data_len)) == NULL )
@@ -2227,7 +2227,7 @@ static WERROR get_printer_dataex( TALLOC_CTX *ctx, NT_PRINTER_INFO_LEVEL *printe
 		*data = NULL;
 
 	*needed = size;
-	
+
 	DEBUG(5,("get_printer_dataex: copy done\n"));
 
 	return WERR_OK;
@@ -2246,7 +2246,7 @@ static WERROR delete_printer_dataex( NT_PRINTER_INFO_LEVEL *printer, const char
  Internal routine for storing printerdata
  ***************************************************************************/
 
-WERROR set_printer_dataex( NT_PRINTER_INFO_LEVEL *printer, const char *key, const char *value, 
+WERROR set_printer_dataex( NT_PRINTER_INFO_LEVEL *printer, const char *key, const char *value,
                                   uint32 type, uint8 *data, int real_len  )
 {
 	/* the registry objects enforce uniqueness based on value name */
@@ -2259,11 +2259,11 @@ WERROR set_printer_dataex( NT_PRINTER_INFO_LEVEL *printer, const char *key, cons
 ********************************************************************/
 
 static WERROR getprinterdata_printer_server(TALLOC_CTX *ctx, fstring value, uint32 *type, uint8 **data, uint32 *needed, uint32 in_size)
-{		
+{
 	int i;
-	
+
 	DEBUG(8,("getprinterdata_printer_server:%s\n", value));
-		
+
 	if (!StrCaseCmp(value, "W3SvcInstalled")) {
 		*type = REG_DWORD;
 		if ( !(*data = TALLOC_ARRAY(ctx, uint8, sizeof(uint32) )) )
@@ -2278,7 +2278,7 @@ static WERROR getprinterdata_printer_server(TALLOC_CTX *ctx, fstring value, uint
 		if ( !(*data = TALLOC_ARRAY(ctx, uint8, sizeof(uint32) )) )
 			return WERR_NOMEM;
 		SIVAL(*data, 0, 0x00);
-		*needed = 0x4;			
+		*needed = 0x4;
 		return WERR_OK;
 	}
 
@@ -2288,7 +2288,7 @@ static WERROR getprinterdata_printer_server(TALLOC_CTX *ctx, fstring value, uint
 			return WERR_NOMEM;
 		/* formally was 0x1b */
 		SIVAL(*data, 0, 0x0);
-		*needed = 0x4;			
+		*needed = 0x4;
 		return WERR_OK;
 	}
 
@@ -2315,7 +2315,7 @@ static WERROR getprinterdata_printer_server(TALLOC_CTX *ctx, fstring value, uint
 			SIVAL(*data, 0, 2);
 		else
 			SIVAL(*data, 0, 3);
-		
+
 		*needed = 0x4;
 		return WERR_OK;
 	}
@@ -2347,9 +2347,9 @@ static WERROR getprinterdata_printer_server(TALLOC_CTX *ctx, fstring value, uint
 		SIVAL(*data, 4, 5);		/* Windows 2000 == 5.0 */
 		SIVAL(*data, 8, 0);
 		SIVAL(*data, 12, 2195);		/* build */
-		
+
 		/* leave extra string empty */
-		
+
 		return WERR_OK;
 	}
 
@@ -2357,30 +2357,30 @@ static WERROR getprinterdata_printer_server(TALLOC_CTX *ctx, fstring value, uint
    	if (!StrCaseCmp(value, "DefaultSpoolDirectory")) {
 		const char *string="C:\\PRINTERS";
 		*type = REG_SZ;
-		*needed = 2*(strlen(string)+1);		
+		*needed = 2*(strlen(string)+1);
 		if((*data  = (uint8 *)TALLOC(ctx, (*needed > in_size) ? *needed:in_size )) == NULL)
 			return WERR_NOMEM;
 		memset(*data, 0, (*needed > in_size) ? *needed:in_size);
-		
+
 		/* it's done by hand ready to go on the wire */
 		for (i=0; i<strlen(string); i++) {
 			(*data)[2*i]=string[i];
 			(*data)[2*i+1]='\0';
-		}			
+		}
 		return WERR_OK;
 	}
 
-	if (!StrCaseCmp(value, "Architecture")) {			
+	if (!StrCaseCmp(value, "Architecture")) {
 		const char *string="Windows NT x86";
 		*type = REG_SZ;
-		*needed = 2*(strlen(string)+1);	
+		*needed = 2*(strlen(string)+1);
 		if((*data  = (uint8 *)TALLOC(ctx, (*needed > in_size) ? *needed:in_size )) == NULL)
 			return WERR_NOMEM;
 		memset(*data, 0, (*needed > in_size) ? *needed:in_size);
 		for (i=0; i<strlen(string); i++) {
 			(*data)[2*i]=string[i];
 			(*data)[2*i+1]='\0';
-		}			
+		}
 		return WERR_OK;
 	}
 
@@ -2389,7 +2389,7 @@ static WERROR getprinterdata_printer_server(TALLOC_CTX *ctx, fstring value, uint
 		if ( !(*data = TALLOC_ARRAY(ctx, uint8, sizeof(uint32) )) )
 			return WERR_NOMEM;
 
-		/* only show the publish check box if we are a 
+		/* only show the publish check box if we are a
 		   memeber of a AD domain */
 
 		if ( lp_security() == SEC_ADS )
@@ -2440,7 +2440,7 @@ WERROR _spoolss_getprinterdata(pipes_struct *p, SPOOL_Q_GETPRINTERDATA *q_u, SPO
 	Printer_entry 	*Printer = find_printer_index_by_hnd(p, handle);
 	NT_PRINTER_INFO_LEVEL 	*printer = NULL;
 	int		snum = 0;
-	
+
 	/*
 	 * Reminder: when it's a string, the length is in BYTES
 	 * even if UNICODE is negociated.
@@ -2451,20 +2451,20 @@ WERROR _spoolss_getprinterdata(pipes_struct *p, SPOOL_Q_GETPRINTERDATA *q_u, SPO
 	*out_size = in_size;
 
 	/* in case of problem, return some default values */
-	
+
 	*needed = 0;
 	*type   = 0;
-	
+
 	DEBUG(4,("_spoolss_getprinterdata\n"));
-	
+
 	if ( !Printer ) {
 		DEBUG(2,("_spoolss_getprinterdata: Invalid handle (%s:%u:%u).\n", OUR_HANDLE(handle)));
 		status = WERR_BADFID;
 		goto done;
 	}
-	
+
 	unistr2_to_ascii(value, valuename, sizeof(value));
-	
+
 	if ( Printer->printer_type == SPLHND_SERVER )
 		status = getprinterdata_printer_server( p->mem_ctx, value, type, data, needed, *out_size );
 	else
@@ -2496,30 +2496,30 @@ WERROR _spoolss_getprinterdata(pipes_struct *p, SPOOL_Q_GETPRINTERDATA *q_u, SPO
 
 	if (*needed > *out_size)
 		status = WERR_MORE_DATA;
-	
+
 done:
-	if ( !W_ERROR_IS_OK(status) ) 
+	if ( !W_ERROR_IS_OK(status) )
 	{
 		DEBUG(5, ("error %d: allocating %d\n", W_ERROR_V(status),*out_size));
-		
+
 		/* reply this param doesn't exist */
-		
+
 		if ( *out_size ) {
 			if((*data=(uint8 *)TALLOC_ZERO_ARRAY(p->mem_ctx, uint8, *out_size)) == NULL) {
-				if ( printer ) 
+				if ( printer )
 					free_a_printer( &printer, 2 );
 				return WERR_NOMEM;
-			} 
+			}
 		} else {
 			*data = NULL;
 		}
 	}
-	
+
 	/* cleanup & exit */
 
 	if ( printer )
 		free_a_printer( &printer, 2 );
-	
+
 	return status;
 }
 
@@ -2554,7 +2554,7 @@ static bool spoolss_connect_to_client(struct rpc_pipe_client **pp_pipe,
 
 	/* setup the connection */
 
-	ret = cli_full_connection( &the_cli, global_myname(), remote_machine, 
+	ret = cli_full_connection( &the_cli, global_myname(), remote_machine,
 		&rm_addr, 0, "IPC$", "IPC",
 		"", /* username */
 		"", /* domain */
@@ -2562,17 +2562,17 @@ static bool spoolss_connect_to_client(struct rpc_pipe_client **pp_pipe,
 		0, lp_client_signing(), NULL );
 
 	if ( !NT_STATUS_IS_OK( ret ) ) {
-		DEBUG(2,("spoolss_connect_to_client: connection to [%s] failed!\n", 
+		DEBUG(2,("spoolss_connect_to_client: connection to [%s] failed!\n",
 			remote_machine ));
 		return False;
-	}	
-		
+	}
+
 	if ( the_cli->protocol != PROTOCOL_NT1 ) {
 		DEBUG(0,("spoolss_connect_to_client: machine %s didn't negotiate NT protocol.\n", remote_machine));
 		cli_shutdown(the_cli);
 		return False;
 	}
-    
+
 	/*
 	 * Ok - we have an anonymous connection to the IPC$ share.
 	 * Now start the NT Domain stuff :-).
@@ -2583,7 +2583,7 @@ static bool spoolss_connect_to_client(struct rpc_pipe_client **pp_pipe,
 			remote_machine, nt_errstr(ret)));
 		cli_shutdown(the_cli);
 		return False;
-	} 
+	}
 
 	/* make sure to save the cli_state pointer.  Keep its own talloc_ctx */
 
@@ -2596,8 +2596,8 @@ static bool spoolss_connect_to_client(struct rpc_pipe_client **pp_pipe,
  Connect to the client.
 ****************************************************************************/
 
-static bool srv_spoolss_replyopenprinter(int snum, const char *printer, 
-					uint32 localprinter, uint32 type, 
+static bool srv_spoolss_replyopenprinter(int snum, const char *printer,
+					uint32 localprinter, uint32 type,
 					POLICY_HND *handle, struct sockaddr_storage *client_ss)
 {
 	WERROR result;
@@ -2613,7 +2613,7 @@ static bool srv_spoolss_replyopenprinter(int snum, const char *printer,
 
 		if ( !spoolss_connect_to_client( &notify_cli_pipe, client_ss, unix_printer ))
 			return False;
-			
+
 		messaging_register(smbd_messaging_context(), NULL,
 				   MSG_PRINTER_NOTIFY2,
 				   receive_notify2_message_list);
@@ -2622,7 +2622,7 @@ static bool srv_spoolss_replyopenprinter(int snum, const char *printer,
 		register_message_flags( True, FLAG_MSG_PRINT_NOTIFY );
 	}
 
-	/* 
+	/*
 	 * Tell the specific printing tdb we want messages for this printer
 	 * by registering our PID.
 	 */
@@ -2632,14 +2632,14 @@ static bool srv_spoolss_replyopenprinter(int snum, const char *printer,
 
 	smb_connections++;
 
-	result = rpccli_spoolss_reply_open_printer(notify_cli_pipe, notify_cli_pipe->cli->mem_ctx, printer, localprinter, 
+	result = rpccli_spoolss_reply_open_printer(notify_cli_pipe, notify_cli_pipe->cli->mem_ctx, printer, localprinter,
 			type, handle);
-			
+
 	if (!W_ERROR_IS_OK(result))
 		DEBUG(5,("srv_spoolss_reply_open_printer: Client RPC returned [%s]\n",
 			dos_errstr(result)));
 
-	return (W_ERROR_IS_OK(result));	
+	return (W_ERROR_IS_OK(result));
 }
 
 /********************************************************************
@@ -2647,7 +2647,7 @@ static bool srv_spoolss_replyopenprinter(int snum, const char *printer,
  * ReplyFindFirstPrinterChangeNotifyEx
  *
  * before replying OK: status=0 a rpc call is made to the workstation
- * asking ReplyOpenPrinter 
+ * asking ReplyOpenPrinter
  *
  * in fact ReplyOpenPrinter is the changenotify equivalent on the spoolss pipe
  * called from api_spoolss_rffpcnex
@@ -2682,7 +2682,7 @@ WERROR _spoolss_rffpcnex(pipes_struct *p, SPOOL_Q_RFFPCNEX *q_u, SPOOL_R_RFFPCNE
 
 	Printer->notify.option=dup_spool_notify_option(option);
 
-	unistr2_to_ascii(Printer->notify.localmachine, localmachine, 
+	unistr2_to_ascii(Printer->notify.localmachine, localmachine,
 		       sizeof(Printer->notify.localmachine));
 
 	/* Connect to the client machine and send a ReplyOpenPrinter */
@@ -2713,11 +2713,11 @@ WERROR _spoolss_rffpcnex(pipes_struct *p, SPOOL_Q_RFFPCNEX *q_u, SPOOL_R_RFFPCNE
  * fill a notify_info_data with the servername
  ********************************************************************/
 
-void spoolss_notify_server_name(int snum, 
-				       SPOOL_NOTIFY_INFO_DATA *data, 
+void spoolss_notify_server_name(int snum,
+				       SPOOL_NOTIFY_INFO_DATA *data,
 				       print_queue_struct *queue,
 				       NT_PRINTER_INFO_LEVEL *printer,
-				       TALLOC_CTX *mem_ctx) 
+				       TALLOC_CTX *mem_ctx)
 {
 	pstring temp;
 	uint32 len;
@@ -2731,7 +2731,7 @@ void spoolss_notify_server_name(int snum,
 			data->notify_data.data.length = 0;
 			return;
 		}
-	
+
 		memcpy(data->notify_data.data.string, temp, len);
 	} else {
 		data->notify_data.data.string = NULL;
@@ -2742,15 +2742,15 @@ void spoolss_notify_server_name(int snum,
  * fill a notify_info_data with the printername (not including the servername).
  ********************************************************************/
 
-void spoolss_notify_printer_name(int snum, 
-					SPOOL_NOTIFY_INFO_DATA *data, 
+void spoolss_notify_printer_name(int snum,
+					SPOOL_NOTIFY_INFO_DATA *data,
 					print_queue_struct *queue,
 					NT_PRINTER_INFO_LEVEL *printer,
 					TALLOC_CTX *mem_ctx)
 {
 	pstring temp;
 	uint32 len;
-		
+
 	/* the notify name should not contain the \\server\ part */
 	char *p = strrchr(printer->info_2->printername, '\\');
 
@@ -2779,8 +2779,8 @@ void spoolss_notify_printer_name(int snum,
  * fill a notify_info_data with the servicename
  ********************************************************************/
 
-void spoolss_notify_share_name(int snum, 
-				      SPOOL_NOTIFY_INFO_DATA *data, 
+void spoolss_notify_share_name(int snum,
+				      SPOOL_NOTIFY_INFO_DATA *data,
 				      print_queue_struct *queue,
 				      NT_PRINTER_INFO_LEVEL *printer,
 				      TALLOC_CTX *mem_ctx)
@@ -2801,15 +2801,15 @@ void spoolss_notify_share_name(int snum,
 	} else {
 		data->notify_data.data.string = NULL;
 	}
-	
+
 }
 
 /*******************************************************************
  * fill a notify_info_data with the port name
  ********************************************************************/
 
-void spoolss_notify_port_name(int snum, 
-				     SPOOL_NOTIFY_INFO_DATA *data, 
+void spoolss_notify_port_name(int snum,
+				     SPOOL_NOTIFY_INFO_DATA *data,
 				     print_queue_struct *queue,
 				     NT_PRINTER_INFO_LEVEL *printer,
 				     TALLOC_CTX *mem_ctx)
@@ -2824,12 +2824,12 @@ void spoolss_notify_port_name(int snum,
 	data->notify_data.data.length = len;
 	if (len) {
 		data->notify_data.data.string = (uint16 *)TALLOC(mem_ctx, len);
-	
+
 		if (!data->notify_data.data.string) {
 			data->notify_data.data.length = 0;
 			return;
 		}
-	
+
 		memcpy(data->notify_data.data.string, temp, len);
 	} else {
 		data->notify_data.data.string = NULL;
@@ -2841,7 +2841,7 @@ void spoolss_notify_port_name(int snum,
  * but it doesn't exist, have to see what to do
  ********************************************************************/
 
-void spoolss_notify_driver_name(int snum, 
+void spoolss_notify_driver_name(int snum,
 				       SPOOL_NOTIFY_INFO_DATA *data,
 				       print_queue_struct *queue,
 				       NT_PRINTER_INFO_LEVEL *printer,
@@ -2855,12 +2855,12 @@ void spoolss_notify_driver_name(int snum,
 	data->notify_data.data.length = len;
 	if (len) {
 		data->notify_data.data.string = (uint16 *)TALLOC(mem_ctx, len);
-	
+
 		if (!data->notify_data.data.string) {
 			data->notify_data.data.length = 0;
 			return;
 		}
-	
+
 		memcpy(data->notify_data.data.string, temp, len);
 	} else {
 		data->notify_data.data.string = NULL;
@@ -2871,7 +2871,7 @@ void spoolss_notify_driver_name(int snum,
  * fill a notify_info_data with the comment
  ********************************************************************/
 
-void spoolss_notify_comment(int snum, 
+void spoolss_notify_comment(int snum,
 				   SPOOL_NOTIFY_INFO_DATA *data,
 				   print_queue_struct *queue,
 				   NT_PRINTER_INFO_LEVEL *printer,
@@ -2888,12 +2888,12 @@ void spoolss_notify_comment(int snum,
 	data->notify_data.data.length = len;
 	if (len) {
 		data->notify_data.data.string = (uint16 *)TALLOC(mem_ctx, len);
-	
+
 		if (!data->notify_data.data.string) {
 			data->notify_data.data.length = 0;
 			return;
 		}
-	
+
 		memcpy(data->notify_data.data.string, temp, len);
 	} else {
 		data->notify_data.data.string = NULL;
@@ -2905,7 +2905,7 @@ void spoolss_notify_comment(int snum,
  * location = "Room 1, floor 2, building 3"
  ********************************************************************/
 
-void spoolss_notify_location(int snum, 
+void spoolss_notify_location(int snum,
 				    SPOOL_NOTIFY_INFO_DATA *data,
 				    print_queue_struct *queue,
 				    NT_PRINTER_INFO_LEVEL *printer,
@@ -2919,12 +2919,12 @@ void spoolss_notify_location(int snum,
 	data->notify_data.data.length = len;
 	if (len) {
 		data->notify_data.data.string = (uint16 *)TALLOC(mem_ctx, len);
-	
+
 		if (!data->notify_data.data.string) {
 			data->notify_data.data.length = 0;
 			return;
 		}
-	
+
 		memcpy(data->notify_data.data.string, temp, len);
 	} else {
 		data->notify_data.data.string = NULL;
@@ -2936,7 +2936,7 @@ void spoolss_notify_location(int snum,
  * jfm:xxxx don't to it for know but that's a real problem !!!
  ********************************************************************/
 
-static void spoolss_notify_devmode(int snum, 
+static void spoolss_notify_devmode(int snum,
 				   SPOOL_NOTIFY_INFO_DATA *data,
 				   print_queue_struct *queue,
 				   NT_PRINTER_INFO_LEVEL *printer,
@@ -2951,8 +2951,8 @@ static void spoolss_notify_devmode(int snum,
  * fill a notify_info_data with the separator file name
  ********************************************************************/
 
-void spoolss_notify_sepfile(int snum, 
-				   SPOOL_NOTIFY_INFO_DATA *data, 
+void spoolss_notify_sepfile(int snum,
+				   SPOOL_NOTIFY_INFO_DATA *data,
 				   print_queue_struct *queue,
 				   NT_PRINTER_INFO_LEVEL *printer,
 				   TALLOC_CTX *mem_ctx)
@@ -2965,12 +2965,12 @@ void spoolss_notify_sepfile(int snum,
 	data->notify_data.data.length = len;
 	if (len) {
 		data->notify_data.data.string = (uint16 *)TALLOC(mem_ctx, len);
-	
+
 		if (!data->notify_data.data.string) {
 			data->notify_data.data.length = 0;
 			return;
 		}
-	
+
 		memcpy(data->notify_data.data.string, temp, len);
 	} else {
 		data->notify_data.data.string = NULL;
@@ -2982,7 +2982,7 @@ void spoolss_notify_sepfile(int snum,
  * jfm:xxxx return always winprint to indicate we don't do anything to it
  ********************************************************************/
 
-void spoolss_notify_print_processor(int snum, 
+void spoolss_notify_print_processor(int snum,
 					   SPOOL_NOTIFY_INFO_DATA *data,
 					   print_queue_struct *queue,
 					   NT_PRINTER_INFO_LEVEL *printer,
@@ -2996,12 +2996,12 @@ void spoolss_notify_print_processor(int snum,
 	data->notify_data.data.length = len;
 	if (len) {
 		data->notify_data.data.string = (uint16 *)TALLOC(mem_ctx, len);
-	
+
 		if (!data->notify_data.data.string) {
 			data->notify_data.data.length = 0;
 			return;
 		}
-	
+
 		memcpy(data->notify_data.data.string, temp, len);
 	} else {
 		data->notify_data.data.string = NULL;
@@ -3013,7 +3013,7 @@ void spoolss_notify_print_processor(int snum,
  * jfm:xxxx send an empty string
  ********************************************************************/
 
-void spoolss_notify_parameters(int snum, 
+void spoolss_notify_parameters(int snum,
 				      SPOOL_NOTIFY_INFO_DATA *data,
 				      print_queue_struct *queue,
 				      NT_PRINTER_INFO_LEVEL *printer,
@@ -3027,12 +3027,12 @@ void spoolss_notify_parameters(int snum,
 	data->notify_data.data.length = len;
 	if (len) {
 		data->notify_data.data.string = (uint16 *)TALLOC(mem_ctx, len);
-	
+
 		if (!data->notify_data.data.string) {
 			data->notify_data.data.length = 0;
 			return;
 		}
-	
+
 		memcpy(data->notify_data.data.string, temp, len);
 	} else {
 		data->notify_data.data.string = NULL;
@@ -3044,7 +3044,7 @@ void spoolss_notify_parameters(int snum,
  * jfm:xxxx always send RAW as data type
  ********************************************************************/
 
-void spoolss_notify_datatype(int snum, 
+void spoolss_notify_datatype(int snum,
 				    SPOOL_NOTIFY_INFO_DATA *data,
 				    print_queue_struct *queue,
 				    NT_PRINTER_INFO_LEVEL *printer,
@@ -3058,12 +3058,12 @@ void spoolss_notify_datatype(int snum,
 	data->notify_data.data.length = len;
 	if (len) {
 		data->notify_data.data.string = (uint16 *)TALLOC(mem_ctx, len);
-	
+
 		if (!data->notify_data.data.string) {
 			data->notify_data.data.length = 0;
 			return;
 		}
-	
+
 		memcpy(data->notify_data.data.string, temp, len);
 	} else {
 		data->notify_data.data.string = NULL;
@@ -3076,7 +3076,7 @@ void spoolss_notify_datatype(int snum,
  * have to implement security before !
  ********************************************************************/
 
-static void spoolss_notify_security_desc(int snum, 
+static void spoolss_notify_security_desc(int snum,
 					 SPOOL_NOTIFY_INFO_DATA *data,
 					 print_queue_struct *queue,
 					 NT_PRINTER_INFO_LEVEL *printer,
@@ -3091,7 +3091,7 @@ static void spoolss_notify_security_desc(int snum,
  * jfm:xxxx a samba printer is always shared
  ********************************************************************/
 
-void spoolss_notify_attributes(int snum, 
+void spoolss_notify_attributes(int snum,
 				      SPOOL_NOTIFY_INFO_DATA *data,
 				      print_queue_struct *queue,
 				      NT_PRINTER_INFO_LEVEL *printer,
@@ -3105,7 +3105,7 @@ void spoolss_notify_attributes(int snum,
  * fill a notify_info_data with the priority
  ********************************************************************/
 
-static void spoolss_notify_priority(int snum, 
+static void spoolss_notify_priority(int snum,
 				    SPOOL_NOTIFY_INFO_DATA *data,
 				    print_queue_struct *queue,
 				    NT_PRINTER_INFO_LEVEL *printer,
@@ -3119,7 +3119,7 @@ static void spoolss_notify_priority(int snum,
  * fill a notify_info_data with the default priority
  ********************************************************************/
 
-static void spoolss_notify_default_priority(int snum, 
+static void spoolss_notify_default_priority(int snum,
 					    SPOOL_NOTIFY_INFO_DATA *data,
 					    print_queue_struct *queue,
 					    NT_PRINTER_INFO_LEVEL *printer,
@@ -3133,7 +3133,7 @@ static void spoolss_notify_default_priority(int snum,
  * fill a notify_info_data with the start time
  ********************************************************************/
 
-static void spoolss_notify_start_time(int snum, 
+static void spoolss_notify_start_time(int snum,
 				      SPOOL_NOTIFY_INFO_DATA *data,
 				      print_queue_struct *queue,
 				      NT_PRINTER_INFO_LEVEL *printer,
@@ -3147,7 +3147,7 @@ static void spoolss_notify_start_time(int snum,
  * fill a notify_info_data with the until time
  ********************************************************************/
 
-static void spoolss_notify_until_time(int snum, 
+static void spoolss_notify_until_time(int snum,
 				      SPOOL_NOTIFY_INFO_DATA *data,
 				      print_queue_struct *queue,
 				      NT_PRINTER_INFO_LEVEL *printer,
@@ -3161,7 +3161,7 @@ static void spoolss_notify_until_time(int snum,
  * fill a notify_info_data with the status
  ********************************************************************/
 
-static void spoolss_notify_status(int snum, 
+static void spoolss_notify_status(int snum,
 				  SPOOL_NOTIFY_INFO_DATA *data,
 				  print_queue_struct *queue,
 				  NT_PRINTER_INFO_LEVEL *printer,
@@ -3178,10 +3178,10 @@ static void spoolss_notify_status(int snum,
  * fill a notify_info_data with the number of jobs queued
  ********************************************************************/
 
-void spoolss_notify_cjobs(int snum, 
+void spoolss_notify_cjobs(int snum,
 				 SPOOL_NOTIFY_INFO_DATA *data,
 				 print_queue_struct *queue,
-				 NT_PRINTER_INFO_LEVEL *printer, 
+				 NT_PRINTER_INFO_LEVEL *printer,
 				 TALLOC_CTX *mem_ctx)
 {
 	data->notify_data.value[0] = print_queue_length(snum, NULL);
@@ -3192,7 +3192,7 @@ void spoolss_notify_cjobs(int snum,
  * fill a notify_info_data with the average ppm
  ********************************************************************/
 
-static void spoolss_notify_average_ppm(int snum, 
+static void spoolss_notify_average_ppm(int snum,
 				       SPOOL_NOTIFY_INFO_DATA *data,
 				       print_queue_struct *queue,
 				       NT_PRINTER_INFO_LEVEL *printer,
@@ -3208,7 +3208,7 @@ static void spoolss_notify_average_ppm(int snum,
  * fill a notify_info_data with username
  ********************************************************************/
 
-static void spoolss_notify_username(int snum, 
+static void spoolss_notify_username(int snum,
 				    SPOOL_NOTIFY_INFO_DATA *data,
 				    print_queue_struct *queue,
 				    NT_PRINTER_INFO_LEVEL *printer,
@@ -3222,12 +3222,12 @@ static void spoolss_notify_username(int snum,
 	data->notify_data.data.length = len;
 	if (len) {
 		data->notify_data.data.string = (uint16 *)TALLOC(mem_ctx, len);
-	
+
 		if (!data->notify_data.data.string) {
 			data->notify_data.data.length = 0;
 			return;
 		}
-	
+
 		memcpy(data->notify_data.data.string, temp, len);
 	} else {
 		data->notify_data.data.string = NULL;
@@ -3238,7 +3238,7 @@ static void spoolss_notify_username(int snum,
  * fill a notify_info_data with job status
  ********************************************************************/
 
-static void spoolss_notify_job_status(int snum, 
+static void spoolss_notify_job_status(int snum,
 				      SPOOL_NOTIFY_INFO_DATA *data,
 				      print_queue_struct *queue,
 				      NT_PRINTER_INFO_LEVEL *printer,
@@ -3252,7 +3252,7 @@ static void spoolss_notify_job_status(int snum,
  * fill a notify_info_data with job name
  ********************************************************************/
 
-static void spoolss_notify_job_name(int snum, 
+static void spoolss_notify_job_name(int snum,
 				    SPOOL_NOTIFY_INFO_DATA *data,
 				    print_queue_struct *queue,
 				    NT_PRINTER_INFO_LEVEL *printer,
@@ -3266,12 +3266,12 @@ static void spoolss_notify_job_name(int snum,
 	data->notify_data.data.length = len;
 	if (len) {
 		data->notify_data.data.string = (uint16 *)TALLOC(mem_ctx, len);
-	
+
 		if (!data->notify_data.data.string) {
 			data->notify_data.data.length = 0;
 			return;
 		}
-	
+
 		memcpy(data->notify_data.data.string, temp, len);
 	} else {
 		data->notify_data.data.string = NULL;
@@ -3282,10 +3282,10 @@ static void spoolss_notify_job_name(int snum,
  * fill a notify_info_data with job status
  ********************************************************************/
 
-static void spoolss_notify_job_status_string(int snum, 
+static void spoolss_notify_job_status_string(int snum,
 					     SPOOL_NOTIFY_INFO_DATA *data,
 					     print_queue_struct *queue,
-					     NT_PRINTER_INFO_LEVEL *printer, 
+					     NT_PRINTER_INFO_LEVEL *printer,
 					     TALLOC_CTX *mem_ctx)
 {
 	/*
@@ -3320,12 +3320,12 @@ static void spoolss_notify_job_status_string(int snum,
 	data->notify_data.data.length = len;
 	if (len) {
 		data->notify_data.data.string = (uint16 *)TALLOC(mem_ctx, len);
-	
+
 		if (!data->notify_data.data.string) {
 			data->notify_data.data.length = 0;
 			return;
 		}
-	
+
 		memcpy(data->notify_data.data.string, temp, len);
 	} else {
 		data->notify_data.data.string = NULL;
@@ -3336,7 +3336,7 @@ static void spoolss_notify_job_status_string(int snum,
  * fill a notify_info_data with job time
  ********************************************************************/
 
-static void spoolss_notify_job_time(int snum, 
+static void spoolss_notify_job_time(int snum,
 				    SPOOL_NOTIFY_INFO_DATA *data,
 				    print_queue_struct *queue,
 				    NT_PRINTER_INFO_LEVEL *printer,
@@ -3350,7 +3350,7 @@ static void spoolss_notify_job_time(int snum,
  * fill a notify_info_data with job size
  ********************************************************************/
 
-static void spoolss_notify_job_size(int snum, 
+static void spoolss_notify_job_size(int snum,
 				    SPOOL_NOTIFY_INFO_DATA *data,
 				    print_queue_struct *queue,
 				    NT_PRINTER_INFO_LEVEL *printer,
@@ -3390,7 +3390,7 @@ static void spoolss_notify_pages_printed(int snum,
  Fill a notify_info_data with job position.
  ********************************************************************/
 
-static void spoolss_notify_job_position(int snum, 
+static void spoolss_notify_job_position(int snum,
 					SPOOL_NOTIFY_INFO_DATA *data,
 					print_queue_struct *queue,
 					NT_PRINTER_INFO_LEVEL *printer,
@@ -3404,7 +3404,7 @@ static void spoolss_notify_job_position(int snum,
  Fill a notify_info_data with submitted time.
  ********************************************************************/
 
-static void spoolss_notify_submitted_time(int snum, 
+static void spoolss_notify_submitted_time(int snum,
 					  SPOOL_NOTIFY_INFO_DATA *data,
 					  print_queue_struct *queue,
 					  NT_PRINTER_INFO_LEVEL *printer,
@@ -3426,11 +3426,11 @@ static void spoolss_notify_submitted_time(int snum,
 		data->notify_data.data.length = 0;
 		return;
 	}
-	
+
 	make_systemtime(&st, t);
 
 	/*
-	 * Systemtime must be linearized as a set of UINT16's. 
+	 * Systemtime must be linearized as a set of UINT16's.
 	 * Fix from Benjamin (Bj) Kuit bj@it.uts.edu.au
 	 */
 
@@ -3538,7 +3538,7 @@ static uint32 size_of_notify_info_data(uint16 type, uint16 field)
 
 				case NOTIFY_POINTER:
 					return 4;
-					
+
 				case NOTIFY_SECDESC:
 					return 5;
 			}
@@ -3571,7 +3571,7 @@ static uint32 type_of_notify_info_data(uint16 type, uint16 field)
 ****************************************************************************/
 
 static bool search_notify(uint16 type, uint16 field, int *value)
-{	
+{
 	int i;
 
 	for (i = 0; notify_info_data_table[i].type != PRINT_TABLE_END; i++) {
@@ -3582,8 +3582,8 @@ static bool search_notify(uint16 type, uint16 field, int *value)
 			return True;
 		}
 	}
-	
-	return False;	
+
+	return False;
 }
 
 /****************************************************************************
@@ -3610,7 +3610,7 @@ void construct_info_data(SPOOL_NOTIFY_INFO_DATA *info_data, uint16 type, uint16
 static bool construct_notify_printer_info(Printer_entry *print_hnd, SPOOL_NOTIFY_INFO *info, int
 					  snum, SPOOL_NOTIFY_OPTION_TYPE
 					  *option_type, uint32 id,
-					  TALLOC_CTX *mem_ctx) 
+					  TALLOC_CTX *mem_ctx)
 {
 	int field_num,j;
 	uint16 type;
@@ -3625,13 +3625,13 @@ static bool construct_notify_printer_info(Printer_entry *print_hnd, SPOOL_NOTIFY
 	DEBUG(4,("construct_notify_printer_info: Notify type: [%s], number of notify info: [%d] on printer: [%s]\n",
 		(option_type->type==PRINTER_NOTIFY_TYPE?"PRINTER_NOTIFY_TYPE":"JOB_NOTIFY_TYPE"),
 		option_type->count, lp_servicename(snum)));
-	
+
 	if (!W_ERROR_IS_OK(get_a_printer(print_hnd, &printer, 2, lp_const_servicename(snum))))
 		return False;
 
 	for(field_num=0; field_num<option_type->count; field_num++) {
 		field = option_type->fields[field_num];
-		
+
 		DEBUG(4,("construct_notify_printer_info: notify [%d]: type [%x], field [%x]\n", field_num, type, field));
 
 		if (!search_notify(type, field, &j) )
@@ -3671,16 +3671,16 @@ static bool construct_notify_jobs_info(print_queue_struct *queue,
 				       NT_PRINTER_INFO_LEVEL *printer,
 				       int snum, SPOOL_NOTIFY_OPTION_TYPE
 				       *option_type, uint32 id,
-				       TALLOC_CTX *mem_ctx) 
+				       TALLOC_CTX *mem_ctx)
 {
 	int field_num,j;
 	uint16 type;
 	uint16 field;
 
 	SPOOL_NOTIFY_INFO_DATA *current_data;
-	
+
 	DEBUG(4,("construct_notify_jobs_info\n"));
-	
+
 	type = option_type->type;
 
 	DEBUGADD(4,("Notify type: [%s], number of notify info: [%d]\n",
@@ -3739,7 +3739,7 @@ static bool construct_notify_jobs_info(print_queue_struct *queue,
  *
  ********************************************************************/
 
-static WERROR printserver_notify_info(pipes_struct *p, POLICY_HND *hnd, 
+static WERROR printserver_notify_info(pipes_struct *p, POLICY_HND *hnd,
 				      SPOOL_NOTIFY_INFO *info,
 				      TALLOC_CTX *mem_ctx)
 {
@@ -3751,7 +3751,7 @@ static WERROR printserver_notify_info(pipes_struct *p, POLICY_HND *hnd,
 	SPOOL_NOTIFY_OPTION_TYPE *option_type;
 
 	DEBUG(4,("printserver_notify_info\n"));
-	
+
 	if (!Printer)
 		return WERR_BADFID;
 
@@ -3760,7 +3760,7 @@ static WERROR printserver_notify_info(pipes_struct *p, POLICY_HND *hnd,
 	info->data=NULL;
 	info->count=0;
 
-	/* a bug in xp sp2 rc2 causes it to send a fnpcn request without 
+	/* a bug in xp sp2 rc2 causes it to send a fnpcn request without
 	   sending a ffpcn() request first */
 
 	if ( !option )
@@ -3768,18 +3768,18 @@ static WERROR printserver_notify_info(pipes_struct *p, POLICY_HND *hnd,
 
 	for (i=0; i<option->count; i++) {
 		option_type=&(option->ctr.type[i]);
-		
+
 		if (option_type->type!=PRINTER_NOTIFY_TYPE)
 			continue;
-		
+
 		for (snum=0; snum<n_services; snum++)
 		{
 			if ( lp_browseable(snum) && lp_snum_ok(snum) && lp_print_ok(snum) )
 				construct_notify_printer_info ( Printer, info, snum, option_type, snum, mem_ctx );
 		}
 	}
-			
-#if 0			
+
+#if 0
 	/*
 	 * Debugging information, don't delete.
 	 */
@@ -3787,14 +3787,14 @@ static WERROR printserver_notify_info(pipes_struct *p, POLICY_HND *hnd,
 	DEBUG(1,("dumping the NOTIFY_INFO\n"));
 	DEBUGADD(1,("info->version:[%d], info->flags:[%d], info->count:[%d]\n", info->version, info->flags, info->count));
 	DEBUGADD(1,("num\ttype\tfield\tres\tid\tsize\tenc_type\n"));
-	
+
 	for (i=0; i<info->count; i++) {
 		DEBUGADD(1,("[%d]\t[%d]\t[%d]\t[%d]\t[%d]\t[%d]\t[%d]\n",
 		i, info->data[i].type, info->data[i].field, info->data[i].reserved,
 		info->data[i].id, info->data[i].size, info->data[i].enc_type));
 	}
 #endif
-	
+
 	return WERR_OK;
 }
 
@@ -3816,7 +3816,7 @@ static WERROR printer_notify_info(pipes_struct *p, POLICY_HND *hnd, SPOOL_NOTIFY
 	int count,j;
 	print_queue_struct *queue=NULL;
 	print_status_struct status;
-	
+
 	DEBUG(4,("printer_notify_info\n"));
 
 	if (!Printer)
@@ -3828,7 +3828,7 @@ static WERROR printer_notify_info(pipes_struct *p, POLICY_HND *hnd, SPOOL_NOTIFY
 	info->data=NULL;
 	info->count=0;
 
-	/* a bug in xp sp2 rc2 causes it to send a fnpcn request without 
+	/* a bug in xp sp2 rc2 causes it to send a fnpcn request without
 	   sending a ffpcn() request first */
 
 	if ( !option )
@@ -3838,15 +3838,15 @@ static WERROR printer_notify_info(pipes_struct *p, POLICY_HND *hnd, SPOOL_NOTIFY
 
 	for (i=0; i<option->count; i++) {
 		option_type=&option->ctr.type[i];
-		
+
 		switch ( option_type->type ) {
 		case PRINTER_NOTIFY_TYPE:
-			if(construct_notify_printer_info(Printer, info, snum, 
+			if(construct_notify_printer_info(Printer, info, snum,
 							 option_type, id,
-							 mem_ctx))  
+							 mem_ctx))
 				id--;
 			break;
-			
+
 		case JOB_NOTIFY_TYPE: {
 			NT_PRINTER_INFO_LEVEL *printer = NULL;
 
@@ -3860,18 +3860,18 @@ static WERROR printer_notify_info(pipes_struct *p, POLICY_HND *hnd, SPOOL_NOTIFY
 							   printer, snum,
 							   option_type,
 							   queue[j].job,
-							   mem_ctx); 
+							   mem_ctx);
 			}
 
 			free_a_printer(&printer, 2);
-			
+
 		done:
 			SAFE_FREE(queue);
 			break;
 		}
 		}
 	}
-	
+
 	/*
 	 * Debugging information, don't delete.
 	 */
@@ -3879,7 +3879,7 @@ static WERROR printer_notify_info(pipes_struct *p, POLICY_HND *hnd, SPOOL_NOTIFY
 	DEBUG(1,("dumping the NOTIFY_INFO\n"));
 	DEBUGADD(1,("info->version:[%d], info->flags:[%d], info->count:[%d]\n", info->version, info->flags, info->count));
 	DEBUGADD(1,("num\ttype\tfield\tres\tid\tsize\tenc_type\n"));
-	
+
 	for (i=0; i<info->count; i++) {
 		DEBUGADD(1,("[%d]\t[%d]\t[%d]\t[%d]\t[%d]\t[%d]\t[%d]\n",
 		i, info->data[i].type, info->data[i].field, info->data[i].reserved,
@@ -3913,13 +3913,13 @@ WERROR _spoolss_rfnpcnex( pipes_struct *p, SPOOL_Q_RFNPCNEX *q_u, SPOOL_R_RFNPCN
 	DEBUG(4,("Printer type %x\n",Printer->printer_type));
 
 	/*
-	 * 	We are now using the change value, and 
+	 * 	We are now using the change value, and
 	 *	I should check for PRINTER_NOTIFY_OPTIONS_REFRESH but as
 	 *	I don't have a global notification system, I'm sending back all the
 	 *	informations even when _NOTHING_ has changed.
 	 */
 
-	/* We need to keep track of the change value to send back in 
+	/* We need to keep track of the change value to send back in
            RRPCN replies otherwise our updates are ignored. */
 
 	Printer->notify.fnpcn = True;
@@ -3930,19 +3930,19 @@ WERROR _spoolss_rfnpcnex( pipes_struct *p, SPOOL_Q_RFNPCNEX *q_u, SPOOL_R_RFNPCN
 	}
 
 	/* just ignore the SPOOL_NOTIFY_OPTION */
-	
+
 	switch (Printer->printer_type) {
 		case SPLHND_SERVER:
 			result = printserver_notify_info(p, handle, info, p->mem_ctx);
 			break;
-			
+
 		case SPLHND_PRINTER:
 			result = printer_notify_info(p, handle, info, p->mem_ctx);
 			break;
 	}
-	
+
 	Printer->notify.fnpcn = False;
-	
+
 done:
 	return result;
 }
@@ -3962,13 +3962,13 @@ static bool construct_printer_info_0(Printer_entry *print_hnd, PRINTER_INFO_0 *p
 	struct tm *t;
 	time_t setuptime;
 	print_status_struct status;
-	
+
 	if (!W_ERROR_IS_OK(get_a_printer(print_hnd, &ntprinter, 2, lp_const_servicename(snum))))
 		return False;
 
 	count = print_queue_length(snum, &status);
 
-	/* check if we already have a counter for this printer */	
+	/* check if we already have a counter for this printer */
 	for(session_counter = counter_list; session_counter; session_counter = session_counter->next) {
 		if (session_counter->snum == snum)
 			break;
@@ -3985,23 +3985,23 @@ static bool construct_printer_info_0(Printer_entry *print_hnd, PRINTER_INFO_0 *p
 		session_counter->counter=0;
 		DLIST_ADD(counter_list, session_counter);
 	}
-	
+
 	/* increment it */
 	session_counter->counter++;
-	
+
 	/* JFM:
 	 * the global_counter should be stored in a TDB as it's common to all the clients
 	 * and should be zeroed on samba startup
 	 */
 	global_counter=session_counter->counter;
-	
+
 	pstrcpy(chaine,ntprinter->info_2->printername);
 
 	init_unistr(&printer->printername, chaine);
-	
+
 	slprintf(chaine,sizeof(chaine)-1,"\\\\%s", get_server_name(print_hnd));
 	init_unistr(&printer->servername, chaine);
-	
+
 	printer->cjobs = count;
 	printer->total_jobs = 0;
 	printer->total_bytes = 0;
@@ -4020,11 +4020,11 @@ static bool construct_printer_info_0(Printer_entry *print_hnd, PRINTER_INFO_0 *p
 
 	printer->global_counter = global_counter;
 	printer->total_pages = 0;
-	
+
 	/* in 2.2 we reported ourselves as 0x0004 and 0x0565 */
 	printer->major_version = 0x0005; 	/* NT 5 */
 	printer->build_version = 0x0893; 	/* build 2195 */
-	
+
 	printer->unknown7 = 0x1;
 	printer->unknown8 = 0x0;
 	printer->unknown9 = 0x0;
@@ -4048,9 +4048,9 @@ static bool construct_printer_info_0(Printer_entry *print_hnd, PRINTER_INFO_0 *p
 	printer->unknown27 = 0;
 	printer->unknown28 = 0;
 	printer->unknown29 = 0;
-	
+
 	free_a_printer(&ntprinter,2);
-	return (True);	
+	return (True);
 }
 
 /********************************************************************
@@ -4078,12 +4078,12 @@ static bool construct_printer_info_1(Printer_entry *print_hnd, uint32 flags, PRI
 		slprintf(chaine,sizeof(chaine)-1,"%s,%s,%s", ntprinter->info_2->printername,
 			ntprinter->info_2->drivername, ntprinter->info_2->comment);
 	}
-		
+
 	slprintf(chaine2,sizeof(chaine)-1,"%s", ntprinter->info_2->printername);
 
 	init_unistr(&printer->description, chaine);
-	init_unistr(&printer->name, chaine2);	
-	
+	init_unistr(&printer->name, chaine2);
+
 	free_a_printer(&ntprinter,2);
 
 	return True;
@@ -4099,12 +4099,12 @@ static void free_dev_mode(DEVICEMODE *dev)
 		return;
 
 	SAFE_FREE(dev->dev_private);
-	SAFE_FREE(dev);	
+	SAFE_FREE(dev);
 }
 
 
 /****************************************************************************
- Convert an NT_DEVICEMODE to a DEVICEMODE structure.  Both pointers 
+ Convert an NT_DEVICEMODE to a DEVICEMODE structure.  Both pointers
  should be valid upon entry
 ****************************************************************************/
 
@@ -4112,7 +4112,7 @@ static bool convert_nt_devicemode( DEVICEMODE *devmode, NT_DEVICEMODE *ntdevmode
 {
 	if ( !devmode || !ntdevmode )
 		return False;
-		
+
 	init_unistr(&devmode->devicename, ntdevmode->devicename);
 
 	init_unistr(&devmode->formname, ntdevmode->formname);
@@ -4122,8 +4122,8 @@ static bool convert_nt_devicemode( DEVICEMODE *devmode, NT_DEVICEMODE *ntdevmode
 	devmode->size             = ntdevmode->size;
 	devmode->driverextra      = ntdevmode->driverextra;
 	devmode->fields           = ntdevmode->fields;
-				
-	devmode->orientation      = ntdevmode->orientation;	
+
+	devmode->orientation      = ntdevmode->orientation;
 	devmode->papersize        = ntdevmode->papersize;
 	devmode->paperlength      = ntdevmode->paperlength;
 	devmode->paperwidth       = ntdevmode->paperwidth;
@@ -4145,7 +4145,7 @@ static bool convert_nt_devicemode( DEVICEMODE *devmode, NT_DEVICEMODE *ntdevmode
 		if ((devmode->dev_private=(uint8 *)memdup(ntdevmode->nt_dev_private, ntdevmode->driverextra)) == NULL)
 			return False;
 	}
-	
+
 	return True;
 }
 
@@ -4157,12 +4157,12 @@ DEVICEMODE *construct_dev_mode(const char *servicename)
 {
 	NT_PRINTER_INFO_LEVEL 	*printer = NULL;
 	DEVICEMODE 		*devmode = NULL;
-	
+
 	DEBUG(7,("construct_dev_mode\n"));
-	
+
 	DEBUGADD(8,("getting printer characteristics\n"));
 
-	if (!W_ERROR_IS_OK(get_a_printer(NULL, &printer, 2, servicename))) 
+	if (!W_ERROR_IS_OK(get_a_printer(NULL, &printer, 2, servicename)))
 		return NULL;
 
 	if ( !printer->info_2->devmode ) {
@@ -4175,8 +4175,8 @@ DEVICEMODE *construct_dev_mode(const char *servicename)
 		goto done;
 	}
 
-	ZERO_STRUCTP(devmode);	
-	
+	ZERO_STRUCTP(devmode);
+
 	DEBUGADD(8,("loading DEVICEMODE\n"));
 
 	if ( !convert_nt_devicemode( devmode, printer->info_2->devmode ) ) {
@@ -4204,46 +4204,46 @@ static bool construct_printer_info_2(Printer_entry *print_hnd, PRINTER_INFO_2 *p
 
 	if (!W_ERROR_IS_OK(get_a_printer(print_hnd, &ntprinter, 2, lp_const_servicename(snum))))
 		return False;
-		
+
 	count = print_queue_length(snum, &status);
 
 	init_unistr(&printer->servername, ntprinter->info_2->servername); /* servername*/
 	init_unistr(&printer->printername, ntprinter->info_2->printername);				/* printername*/
 	init_unistr(&printer->sharename, lp_servicename(snum));			/* sharename */
-	init_unistr(&printer->portname, ntprinter->info_2->portname);			/* port */	
+	init_unistr(&printer->portname, ntprinter->info_2->portname);			/* port */
 	init_unistr(&printer->drivername, ntprinter->info_2->drivername);	/* drivername */
 
 	if (*ntprinter->info_2->comment == '\0')
-		init_unistr(&printer->comment, lp_comment(snum));			/* comment */	
+		init_unistr(&printer->comment, lp_comment(snum));			/* comment */
 	else
 		init_unistr(&printer->comment, ntprinter->info_2->comment); /* saved comment. */
 
-	init_unistr(&printer->location, ntprinter->info_2->location);		/* location */	
+	init_unistr(&printer->location, ntprinter->info_2->location);		/* location */
 	init_unistr(&printer->sepfile, ntprinter->info_2->sepfile);		/* separator file */
 	init_unistr(&printer->printprocessor, ntprinter->info_2->printprocessor);/* print processor */
-	init_unistr(&printer->datatype, ntprinter->info_2->datatype);		/* datatype */	
-	init_unistr(&printer->parameters, ntprinter->info_2->parameters);	/* parameters (of print processor) */	
+	init_unistr(&printer->datatype, ntprinter->info_2->datatype);		/* datatype */
+	init_unistr(&printer->parameters, ntprinter->info_2->parameters);	/* parameters (of print processor) */
 
 	printer->attributes = ntprinter->info_2->attributes;
 
-	printer->priority = ntprinter->info_2->priority;				/* priority */	
+	printer->priority = ntprinter->info_2->priority;				/* priority */
 	printer->defaultpriority = ntprinter->info_2->default_priority;		/* default priority */
 	printer->starttime = ntprinter->info_2->starttime;			/* starttime */
 	printer->untiltime = ntprinter->info_2->untiltime;			/* untiltime */
 	printer->status = nt_printq_status(status.status);			/* status */
 	printer->cjobs = count;							/* jobs */
 	printer->averageppm = ntprinter->info_2->averageppm;			/* average pages per minute */
-			
+
 	if ( !(printer->devmode = construct_dev_mode(
 		       lp_const_servicename(snum))) )
 		DEBUG(8, ("Returning NULL Devicemode!\n"));
 
 	printer->secdesc = NULL;
 
-	if ( ntprinter->info_2->secdesc_buf 
-		&& ntprinter->info_2->secdesc_buf->sd_size != 0 ) 
+	if ( ntprinter->info_2->secdesc_buf
+		&& ntprinter->info_2->secdesc_buf->sd_size != 0 )
 	{
-		/* don't use talloc_steal() here unless you do a deep steal of all 
+		/* don't use talloc_steal() here unless you do a deep steal of all
 		   the SEC_DESC members */
 
 		printer->secdesc = dup_sec_desc( talloc_tos(),
@@ -4276,11 +4276,11 @@ static bool construct_printer_info_3(Printer_entry *print_hnd, PRINTER_INFO_3 **
 	}
 
 	ZERO_STRUCTP(printer);
-	
+
 	/* These are the components of the SD we are returning. */
 
 	if (ntprinter->info_2->secdesc_buf && ntprinter->info_2->secdesc_buf->sd_size != 0) {
-		/* don't use talloc_steal() here unless you do a deep steal of all 
+		/* don't use talloc_steal() here unless you do a deep steal of all
 		   the SEC_DESC members */
 
 		printer->secdesc = dup_sec_desc( talloc_tos(),
@@ -4304,7 +4304,7 @@ static bool construct_printer_info_4(Printer_entry *print_hnd, PRINTER_INFO_4 *p
 
 	if (!W_ERROR_IS_OK(get_a_printer(print_hnd, &ntprinter, 2, lp_const_servicename(snum))))
 		return False;
-		
+
 	init_unistr(&printer->printername, ntprinter->info_2->printername);				/* printername*/
 	init_unistr(&printer->servername, ntprinter->info_2->servername); /* servername*/
 	printer->attributes = ntprinter->info_2->attributes;
@@ -4324,9 +4324,9 @@ static bool construct_printer_info_5(Printer_entry *print_hnd, PRINTER_INFO_5 *p
 
 	if (!W_ERROR_IS_OK(get_a_printer(print_hnd, &ntprinter, 2, lp_const_servicename(snum))))
 		return False;
-		
+
 	init_unistr(&printer->printername, ntprinter->info_2->printername);
-	init_unistr(&printer->portname, ntprinter->info_2->portname); 
+	init_unistr(&printer->portname, ntprinter->info_2->portname);
 	printer->attributes = ntprinter->info_2->attributes;
 
 	/* these two are not used by NT+ according to MSDN */
@@ -4359,7 +4359,7 @@ static bool construct_printer_info_6(Printer_entry *print_hnd,
 	count = print_queue_length(snum, &status);
 
 	printer->status = nt_printq_status(status.status);
-		
+
 	free_a_printer(&ntprinter, 2);
 
 	return True;
@@ -4373,8 +4373,8 @@ static bool construct_printer_info_6(Printer_entry *print_hnd,
 static bool construct_printer_info_7(Printer_entry *print_hnd, PRINTER_INFO_7 *printer, int snum)
 {
 	char *guid_str = NULL;
-	struct GUID guid; 
-	
+	struct GUID guid;
+
 	if (is_printer_published(print_hnd, snum, &guid)) {
 		asprintf(&guid_str, "{%s}",
 			 smb_uuid_string(talloc_tos(), guid));
@@ -4401,8 +4401,8 @@ static WERROR enum_all_printers_info_1(uint32 flags, RPC_BUFFER *buffer, uint32
 	PRINTER_INFO_1 *printers=NULL;
 	PRINTER_INFO_1 current_prt;
 	WERROR result = WERR_OK;
-	
-	DEBUG(4,("enum_all_printers_info_1\n"));	
+
+	DEBUG(4,("enum_all_printers_info_1\n"));
 
 	for (snum=0; snum<n_services; snum++) {
 		if (lp_browseable(snum) && lp_snum_ok(snum) && lp_print_ok(snum) ) {
@@ -4414,15 +4414,15 @@ static WERROR enum_all_printers_info_1(uint32 flags, RPC_BUFFER *buffer, uint32
 					*returned=0;
 					return WERR_NOMEM;
 				}
-				DEBUG(4,("ReAlloced memory for [%d] PRINTER_INFO_1\n", *returned));		
+				DEBUG(4,("ReAlloced memory for [%d] PRINTER_INFO_1\n", *returned));
 
 				memcpy(&printers[*returned], &current_prt, sizeof(PRINTER_INFO_1));
 				(*returned)++;
 			}
 		}
 	}
-		
-	/* check the required size. */	
+
+	/* check the required size. */
 	for (i=0; i<*returned; i++)
 		(*needed) += spoolss_size_printer_info_1(&printers[i]);
 
@@ -4438,7 +4438,7 @@ static WERROR enum_all_printers_info_1(uint32 flags, RPC_BUFFER *buffer, uint32
 
 	/* fill the buffer with the structures */
 	for (i=0; i<*returned; i++)
-		smb_io_printer_info_1("", buffer, &printers[i], 0);	
+		smb_io_printer_info_1("", buffer, &printers[i], 0);
 
 out:
 	/* clear memory */
@@ -4457,8 +4457,8 @@ out:
 
 static WERROR enum_all_printers_info_1_local(RPC_BUFFER *buffer, uint32 offered, uint32 *needed, uint32 *returned)
 {
-	DEBUG(4,("enum_all_printers_info_1_local\n"));	
-	
+	DEBUG(4,("enum_all_printers_info_1_local\n"));
+
 	return enum_all_printers_info_1(PRINTER_ENUM_ICON8, buffer, offered, needed, returned);
 }
 
@@ -4469,12 +4469,12 @@ static WERROR enum_all_printers_info_1_local(RPC_BUFFER *buffer, uint32 offered,
 static WERROR enum_all_printers_info_1_name(fstring name, RPC_BUFFER *buffer, uint32 offered, uint32 *needed, uint32 *returned)
 {
 	char *s = name;
-	
-	DEBUG(4,("enum_all_printers_info_1_name\n"));	
-	
+
+	DEBUG(4,("enum_all_printers_info_1_name\n"));
+
 	if ((name[0] == '\\') && (name[1] == '\\'))
 		s = name + 2;
-		
+
 	if (is_myname_or_ipaddr(s)) {
 		return enum_all_printers_info_1(PRINTER_ENUM_ICON8, buffer, offered, needed, returned);
 	}
@@ -4493,32 +4493,32 @@ static WERROR enum_all_printers_info_1_remote(fstring name, RPC_BUFFER *buffer,
 	fstring printername;
 	fstring desc;
 	fstring comment;
-	DEBUG(4,("enum_all_printers_info_1_remote\n"));	
+	DEBUG(4,("enum_all_printers_info_1_remote\n"));
 	WERROR result = WERR_OK;
 
 	/* JFM: currently it's more a place holder than anything else.
 	 * In the spooler world there is a notion of server registration.
 	 * the print servers are registered on the PDC (in the same domain)
 	 *
-	 * We should have a TDB here. The registration is done thru an 
+	 * We should have a TDB here. The registration is done thru an
 	 * undocumented RPC call.
 	 */
-	
+
 	if((printer=SMB_MALLOC_P(PRINTER_INFO_1)) == NULL)
 		return WERR_NOMEM;
 
 	*returned=1;
-	
-	slprintf(printername, sizeof(printername)-1,"Windows NT Remote Printers!!\\\\%s", name);		
+
+	slprintf(printername, sizeof(printername)-1,"Windows NT Remote Printers!!\\\\%s", name);
 	slprintf(desc, sizeof(desc)-1,"%s", name);
 	slprintf(comment, sizeof(comment)-1, "Logged on Domain");
 
 	init_unistr(&printer->description, desc);
-	init_unistr(&printer->name, printername);	
+	init_unistr(&printer->name, printername);
 	init_unistr(&printer->comment, comment);
 	printer->flags=PRINTER_ENUM_ICON3|PRINTER_ENUM_CONTAINER;
-		
-	/* check the required size. */	
+
+	/* check the required size. */
 	*needed += spoolss_size_printer_info_1(printer);
 
 	if (*needed > offered) {
@@ -4532,7 +4532,7 @@ static WERROR enum_all_printers_info_1_remote(fstring name, RPC_BUFFER *buffer,
 	}
 
 	/* fill the buffer with the structures */
-	smb_io_printer_info_1("", buffer, printer, 0);	
+	smb_io_printer_info_1("", buffer, printer, 0);
 
 out:
 	/* clear memory */
@@ -4554,15 +4554,15 @@ static WERROR enum_all_printers_info_1_network(fstring name, RPC_BUFFER *buffer,
 {
 	char *s = name;
 
-	DEBUG(4,("enum_all_printers_info_1_network\n"));	
-	
+	DEBUG(4,("enum_all_printers_info_1_network\n"));
+
 	/* If we respond to a enum_printers level 1 on our name with flags
 	   set to PRINTER_ENUM_REMOTE with a list of printers then these
 	   printers incorrectly appear in the APW browse list.
 	   Specifically the printers for the server appear at the workgroup
 	   level where all the other servers in the domain are
 	   listed. Windows responds to this call with a
-	   WERR_CAN_NOT_COMPLETE so we should do the same. */ 
+	   WERR_CAN_NOT_COMPLETE so we should do the same. */
 
 	if (name[0] == '\\' && name[1] == '\\')
 		 s = name + 2;
@@ -4593,7 +4593,7 @@ static WERROR enum_all_printers_info_2(RPC_BUFFER *buffer, uint32 offered, uint3
 	for (snum=0; snum<n_services; snum++) {
 		if (lp_browseable(snum) && lp_snum_ok(snum) && lp_print_ok(snum) ) {
 			DEBUG(4,("Found a printer in smb.conf: %s[%x]\n", lp_servicename(snum), snum));
-				
+
 			if (construct_printer_info_2(NULL, &current_prt, snum)) {
 				if ( !(printers=SMB_REALLOC_ARRAY(printers, PRINTER_INFO_2, *returned +1)) ) {
 					DEBUG(2,("enum_all_printers_info_2: failed to enlarge printers buffer!\n"));
@@ -4601,7 +4601,7 @@ static WERROR enum_all_printers_info_2(RPC_BUFFER *buffer, uint32 offered, uint3
 					return WERR_NOMEM;
 				}
 
-				DEBUG(4,("ReAlloced memory for [%d] PRINTER_INFO_2\n", *returned + 1));		
+				DEBUG(4,("ReAlloced memory for [%d] PRINTER_INFO_2\n", *returned + 1));
 
 				memcpy(&printers[*returned], &current_prt, sizeof(PRINTER_INFO_2));
 
@@ -4609,11 +4609,11 @@ static WERROR enum_all_printers_info_2(RPC_BUFFER *buffer, uint32 offered, uint3
 			}
 		}
 	}
-	
-	/* check the required size. */	
-	for (i=0; i<*returned; i++) 
+
+	/* check the required size. */
+	for (i=0; i<*returned; i++)
 		(*needed) += spoolss_size_printer_info_2(&printers[i]);
-	
+
 	if (*needed > offered) {
 		result = WERR_INSUFFICIENT_BUFFER;
 		goto out;
@@ -4626,12 +4626,12 @@ static WERROR enum_all_printers_info_2(RPC_BUFFER *buffer, uint32 offered, uint3
 
 	/* fill the buffer with the structures */
 	for (i=0; i<*returned; i++)
-		smb_io_printer_info_2("", buffer, &(printers[i]), 0);	
-	
+		smb_io_printer_info_2("", buffer, &(printers[i]), 0);
+
 out:
 	/* clear memory */
 
-	for (i=0; i<*returned; i++) 
+	for (i=0; i<*returned; i++)
 		free_devmode(printers[i].devmode);
 
 	SAFE_FREE(printers);
@@ -4727,7 +4727,7 @@ WERROR _spoolss_enumprinters( pipes_struct *p, SPOOL_Q_ENUMPRINTERS *q_u, SPOOL_
 	uint32 *returned = &r_u->returned;
 
 	fstring name;
-	
+
 	/* that's an [in out] buffer */
 
 	if (!q_u->buffer && (offered!=0)) {
@@ -4741,7 +4741,7 @@ WERROR _spoolss_enumprinters( pipes_struct *p, SPOOL_Q_ENUMPRINTERS *q_u, SPOOL_
 
 	*needed=0;
 	*returned=0;
-	
+
 	/*
 	 * Level 1:
 	 *	    flags==PRINTER_ENUM_NAME
@@ -4784,8 +4784,8 @@ static WERROR getprinter_level_0(Printer_entry *print_hnd, int snum, RPC_BUFFER
 		return WERR_NOMEM;
 
 	construct_printer_info_0(print_hnd, printer, snum);
-	
-	/* check the required size. */	
+
+	/* check the required size. */
 	*needed += spoolss_size_printer_info_0(printer);
 
 	if (*needed > offered) {
@@ -4799,8 +4799,8 @@ static WERROR getprinter_level_0(Printer_entry *print_hnd, int snum, RPC_BUFFER
 	}
 
 	/* fill the buffer with the structures */
-	smb_io_printer_info_0("", buffer, printer, 0);	
-	
+	smb_io_printer_info_0("", buffer, printer, 0);
+
 out:
 	/* clear memory */
 
@@ -4821,8 +4821,8 @@ static WERROR getprinter_level_1(Printer_entry *print_hnd, int snum, RPC_BUFFER
 		return WERR_NOMEM;
 
 	construct_printer_info_1(print_hnd, PRINTER_ENUM_ICON8, printer, snum);
-	
-	/* check the required size. */	
+
+	/* check the required size. */
 	*needed += spoolss_size_printer_info_1(printer);
 
 	if (*needed > offered) {
@@ -4836,13 +4836,13 @@ static WERROR getprinter_level_1(Printer_entry *print_hnd, int snum, RPC_BUFFER
 	}
 
 	/* fill the buffer with the structures */
-	smb_io_printer_info_1("", buffer, printer, 0);	
-	
+	smb_io_printer_info_1("", buffer, printer, 0);
+
 out:
 	/* clear memory */
 	SAFE_FREE(printer);
 
-	return result;	
+	return result;
 }
 
 /****************************************************************************
@@ -4855,12 +4855,12 @@ static WERROR getprinter_level_2(Printer_entry *print_hnd, int snum, RPC_BUFFER
 
 	if((printer=SMB_MALLOC_P(PRINTER_INFO_2))==NULL)
 		return WERR_NOMEM;
-	
+
 	construct_printer_info_2(print_hnd, printer, snum);
-	
-	/* check the required size. */	
+
+	/* check the required size. */
 	*needed += spoolss_size_printer_info_2(printer);
-	
+
 	if (*needed > offered) {
 		result = WERR_INSUFFICIENT_BUFFER;
 		goto out;
@@ -4872,14 +4872,14 @@ static WERROR getprinter_level_2(Printer_entry *print_hnd, int snum, RPC_BUFFER
 	}
 
 	/* fill the buffer with the structures */
-	if (!smb_io_printer_info_2("", buffer, printer, 0)) 
+	if (!smb_io_printer_info_2("", buffer, printer, 0))
 		result = WERR_NOMEM;
-	
+
 out:
 	/* clear memory */
 	free_printer_info_2(printer);
 
-	return result;	
+	return result;
 }
 
 /****************************************************************************
@@ -4892,8 +4892,8 @@ static WERROR getprinter_level_3(Printer_entry *print_hnd, int snum, RPC_BUFFER
 
 	if (!construct_printer_info_3(print_hnd, &printer, snum))
 		return WERR_NOMEM;
-	
-	/* check the required size. */	
+
+	/* check the required size. */
 	*needed += spoolss_size_printer_info_3(printer);
 
 	if (*needed > offered) {
@@ -4907,13 +4907,13 @@ static WERROR getprinter_level_3(Printer_entry *print_hnd, int snum, RPC_BUFFER
 	}
 
 	/* fill the buffer with the structures */
-	smb_io_printer_info_3("", buffer, printer, 0);	
-	
+	smb_io_printer_info_3("", buffer, printer, 0);
+
 out:
 	/* clear memory */
 	free_printer_info_3(printer);
-	
-	return result;	
+
+	return result;
 }
 
 /****************************************************************************
@@ -4931,8 +4931,8 @@ static WERROR getprinter_level_4(Printer_entry *print_hnd, int snum, RPC_BUFFER
 		SAFE_FREE(printer);
 		return WERR_NOMEM;
 	}
-	
-	/* check the required size. */	
+
+	/* check the required size. */
 	*needed += spoolss_size_printer_info_4(printer);
 
 	if (*needed > offered) {
@@ -4946,13 +4946,13 @@ static WERROR getprinter_level_4(Printer_entry *print_hnd, int snum, RPC_BUFFER
 	}
 
 	/* fill the buffer with the structures */
-	smb_io_printer_info_4("", buffer, printer, 0);	
-	
+	smb_io_printer_info_4("", buffer, printer, 0);
+
 out:
 	/* clear memory */
 	free_printer_info_4(printer);
-	
-	return result;	
+
+	return result;
 }
 
 /****************************************************************************
@@ -4970,8 +4970,8 @@ static WERROR getprinter_level_5(Printer_entry *print_hnd, int snum, RPC_BUFFER
 		free_printer_info_5(printer);
 		return WERR_NOMEM;
 	}
-	
-	/* check the required size. */	
+
+	/* check the required size. */
 	*needed += spoolss_size_printer_info_5(printer);
 
 	if (*needed > offered) {
@@ -4985,13 +4985,13 @@ static WERROR getprinter_level_5(Printer_entry *print_hnd, int snum, RPC_BUFFER
 	}
 
 	/* fill the buffer with the structures */
-	smb_io_printer_info_5("", buffer, printer, 0);	
-	
+	smb_io_printer_info_5("", buffer, printer, 0);
+
 out:
 	/* clear memory */
 	free_printer_info_5(printer);
-	
-	return result;	
+
+	return result;
 }
 
 static WERROR getprinter_level_6(Printer_entry *print_hnd,
@@ -5025,13 +5025,13 @@ static WERROR getprinter_level_6(Printer_entry *print_hnd,
 	}
 
 	/* fill the buffer with the structures */
-	smb_io_printer_info_6("", buffer, printer, 0);	
-	
+	smb_io_printer_info_6("", buffer, printer, 0);
+
 out:
 	/* clear memory */
 	free_printer_info_6(printer);
-	
-	return result;	
+
+	return result;
 }
 
 static WERROR getprinter_level_7(Printer_entry *print_hnd, int snum, RPC_BUFFER *buffer, uint32 offered, uint32 *needed)
@@ -5044,8 +5044,8 @@ static WERROR getprinter_level_7(Printer_entry *print_hnd, int snum, RPC_BUFFER
 
 	if (!construct_printer_info_7(print_hnd, printer, snum))
 		return WERR_NOMEM;
-	
-	/* check the required size. */	
+
+	/* check the required size. */
 	*needed += spoolss_size_printer_info_7(printer);
 
 	if (*needed > offered) {
@@ -5060,13 +5060,13 @@ static WERROR getprinter_level_7(Printer_entry *print_hnd, int snum, RPC_BUFFER
 	}
 
 	/* fill the buffer with the structures */
-	smb_io_printer_info_7("", buffer, printer, 0);	
-	
+	smb_io_printer_info_7("", buffer, printer, 0);
+
 out:
 	/* clear memory */
 	free_printer_info_7(printer);
-	
-	return result;	
+
+	return result;
 }
 
 /****************************************************************************
@@ -5102,22 +5102,22 @@ WERROR _spoolss_getprinter(pipes_struct *p, SPOOL_Q_GETPRINTER *q_u, SPOOL_R_GET
 		return getprinter_level_0(Printer, snum, buffer, offered, needed);
 	case 1:
 		return getprinter_level_1(Printer, snum, buffer, offered, needed);
-	case 2:		
+	case 2:
 		return getprinter_level_2(Printer, snum, buffer, offered, needed);
-	case 3:		
+	case 3:
 		return getprinter_level_3(Printer, snum, buffer, offered, needed);
-	case 4:		
+	case 4:
 		return getprinter_level_4(Printer, snum, buffer, offered, needed);
-	case 5:		
+	case 5:
 		return getprinter_level_5(Printer, snum, buffer, offered, needed);
-	case 6:		
+	case 6:
 		return getprinter_level_6(Printer, snum, buffer, offered, needed);
 	case 7:
 		return getprinter_level_7(Printer, snum, buffer, offered, needed);
 	}
 	return WERR_UNKNOWN_LEVEL;
-}	
-		
+}
+
 /********************************************************************
  * fill a DRIVER_INFO_1 struct
  ********************************************************************/
@@ -5132,7 +5132,7 @@ static void fill_printer_driver_info_1(DRIVER_INFO_1 *info, NT_PRINTER_DRIVER_IN
  ********************************************************************/
 
 static WERROR construct_printer_driver_info_1(DRIVER_INFO_1 *info, int snum, fstring servername, fstring architecture, uint32 version)
-{	
+{
 	NT_PRINTER_INFO_LEVEL *printer = NULL;
 	NT_PRINTER_DRIVER_INFO_LEVEL driver;
 
@@ -5179,10 +5179,10 @@ static void fill_printer_driver_info_2(DRIVER_INFO_2 *info, NT_PRINTER_DRIVER_IN
 		init_unistr( &info->datafile, temp );
 	} else
 		init_unistr( &info->datafile, "" );
-	
+
 	if (strlen(driver.info_3->configfile)) {
 		slprintf(temp, sizeof(temp)-1, "\\\\%s%s", servername, driver.info_3->configfile);
-		init_unistr( &info->configfile, temp );	
+		init_unistr( &info->configfile, temp );
 	} else
 		init_unistr( &info->configfile, "" );
 }
@@ -5231,52 +5231,52 @@ static uint32 init_unistr_array(uint16 **uni_array, fstring *char_array, const c
 	DEBUG(6,("init_unistr_array\n"));
 	*uni_array=NULL;
 
-	while (True) 
+	while (True)
 	{
 		if ( !char_array )
 			v = "";
-		else 
+		else
 		{
 			v = char_array[i];
-			if (!v) 
+			if (!v)
 				v = ""; /* hack to handle null lists */
 		}
-		
-		/* hack to allow this to be used in places other than when generating 
+
+		/* hack to allow this to be used in places other than when generating
 		   the list of dependent files */
-		   
+		
 		if ( servername )
 			slprintf( line, sizeof(line)-1, "\\\\%s%s", servername, v );
 		else
 			pstrcpy( line, v );
-			
+
 		DEBUGADD(6,("%d:%s:%lu\n", i, line, (unsigned long)strlen(line)));
 
 		/* add one extra unit16 for the second terminating NULL */
-		
+
 		if ( (*uni_array=SMB_REALLOC_ARRAY(*uni_array, uint16, j+1+strlen(line)+2)) == NULL ) {
 			DEBUG(2,("init_unistr_array: Realloc error\n" ));
 			return 0;
 		}
 
-		if ( !strlen(v) ) 
+		if ( !strlen(v) )
 			break;
-		
+
 		j += (rpcstr_push((*uni_array+j), line, sizeof(uint16)*strlen(line)+2, STR_TERMINATE) / sizeof(uint16));
 		i++;
 	}
-	
+
 	if (*uni_array) {
 		/* special case for ""; we need to add both NULL's here */
 		if (!j)
-			(*uni_array)[j++]=0x0000;	
+			(*uni_array)[j++]=0x0000;
 		(*uni_array)[j]=0x0000;
 	}
-	
+
 	DEBUGADD(6,("last one:done\n"));
 
 	/* return size of array in uint16's */
-		
+
 	return j+1;
 }
 
@@ -5293,15 +5293,15 @@ static void fill_printer_driver_info_3(DRIVER_INFO_3 *info, NT_PRINTER_DRIVER_IN
 
 	info->version=driver.info_3->cversion;
 
-	init_unistr( &info->name, driver.info_3->name );	
+	init_unistr( &info->name, driver.info_3->name );
 	init_unistr( &info->architecture, driver.info_3->environment );
 
 	if (strlen(driver.info_3->driverpath)) {
-		slprintf(temp, sizeof(temp)-1, "\\\\%s%s", servername, driver.info_3->driverpath);		
+		slprintf(temp, sizeof(temp)-1, "\\\\%s%s", servername, driver.info_3->driverpath);
 		init_unistr( &info->driverpath, temp );
 	} else
 		init_unistr( &info->driverpath, "" );
-    
+
 	if (strlen(driver.info_3->datafile)) {
 		slprintf(temp, sizeof(temp)-1, "\\\\%s%s", servername, driver.info_3->datafile);
 		init_unistr( &info->datafile, temp );
@@ -5310,7 +5310,7 @@ static void fill_printer_driver_info_3(DRIVER_INFO_3 *info, NT_PRINTER_DRIVER_IN
 
 	if (strlen(driver.info_3->configfile)) {
 		slprintf(temp, sizeof(temp)-1, "\\\\%s%s", servername, driver.info_3->configfile);
-		init_unistr( &info->configfile, temp );	
+		init_unistr( &info->configfile, temp );
 	} else
 		init_unistr( &info->configfile, "" );
 
@@ -5333,7 +5333,7 @@ static void fill_printer_driver_info_3(DRIVER_INFO_3 *info, NT_PRINTER_DRIVER_IN
  ********************************************************************/
 
 static WERROR construct_printer_driver_info_3(DRIVER_INFO_3 *info, int snum, fstring servername, fstring architecture, uint32 version)
-{	
+{
 	NT_PRINTER_INFO_LEVEL *printer = NULL;
 	NT_PRINTER_DRIVER_INFO_LEVEL driver;
 	WERROR status;
@@ -5344,13 +5344,13 @@ static WERROR construct_printer_driver_info_3(DRIVER_INFO_3 *info, int snum, fst
 	if (!W_ERROR_IS_OK(status))
 		return WERR_INVALID_PRINTER_NAME;
 
-	status=get_a_printer_driver(&driver, 3, printer->info_2->drivername, architecture, version);	
+	status=get_a_printer_driver(&driver, 3, printer->info_2->drivername, architecture, version);
 	DEBUG(8,("construct_printer_driver_info_3: status: %s\n", dos_errstr(status)));
 
 #if 0	/* JERRY */
 
-	/* 
-	 * I put this code in during testing.  Helpful when commenting out the 
+	/*
+	 * I put this code in during testing.  Helpful when commenting out the
 	 * support for DRIVER_INFO_6 in regards to win2k.  Not needed in general
 	 * as win2k always queries the driver using an infor level of 6.
 	 * I've left it in (but ifdef'd out) because I'll probably
@@ -5364,7 +5364,7 @@ static WERROR construct_printer_driver_info_3(DRIVER_INFO_3 *info, int snum, fst
 		if (version == 3) {
 			/* Yes - try again with a WinNT driver. */
 			version = 2;
-			status=get_a_printer_driver(&driver, 3, printer->info_2->drivername, architecture, version);	
+			status=get_a_printer_driver(&driver, 3, printer->info_2->drivername, architecture, version);
 			DEBUG(8,("construct_printer_driver_info_3: status: %s\n", dos_errstr(status)));
 		}
 #endif
@@ -5373,11 +5373,11 @@ static WERROR construct_printer_driver_info_3(DRIVER_INFO_3 *info, int snum, fst
 			free_a_printer(&printer,2);
 			return WERR_UNKNOWN_PRINTER_DRIVER;
 		}
-		
+
 #if 0	/* JERRY */
 	}
 #endif
-	
+
 
 	fill_printer_driver_info_3(info, driver, servername);
 
@@ -5401,11 +5401,11 @@ static void fill_printer_driver_info_6(DRIVER_INFO_6 *info, NT_PRINTER_DRIVER_IN
 
 	info->version=driver.info_3->cversion;
 
-	init_unistr( &info->name, driver.info_3->name );	
+	init_unistr( &info->name, driver.info_3->name );
 	init_unistr( &info->architecture, driver.info_3->environment );
 
 	if (strlen(driver.info_3->driverpath)) {
-		slprintf(temp, sizeof(temp)-1, "\\\\%s%s", servername, driver.info_3->driverpath);		
+		slprintf(temp, sizeof(temp)-1, "\\\\%s%s", servername, driver.info_3->driverpath);
 		init_unistr( &info->driverpath, temp );
 	} else
 		init_unistr( &info->driverpath, "" );
@@ -5418,7 +5418,7 @@ static void fill_printer_driver_info_6(DRIVER_INFO_6 *info, NT_PRINTER_DRIVER_IN
 
 	if (strlen(driver.info_3->configfile)) {
 		slprintf(temp, sizeof(temp)-1, "\\\\%s%s", servername, driver.info_3->configfile);
-		init_unistr( &info->configfile, temp );	
+		init_unistr( &info->configfile, temp );
 	} else
 		init_unistr( &info->configfile, "" );
 
@@ -5427,7 +5427,7 @@ static void fill_printer_driver_info_6(DRIVER_INFO_6 *info, NT_PRINTER_DRIVER_IN
 		init_unistr( &info->helpfile, temp );
 	} else
 		init_unistr( &info->helpfile, "" );
-	
+
 	init_unistr( &info->monitorname, driver.info_3->monitorname );
 	init_unistr( &info->defaultdatatype, driver.info_3->defaultdatatype );
 
@@ -5454,27 +5454,27 @@ static void fill_printer_driver_info_6(DRIVER_INFO_6 *info, NT_PRINTER_DRIVER_IN
  * fill a printer_info_6 struct
  ********************************************************************/
 
-static WERROR construct_printer_driver_info_6(DRIVER_INFO_6 *info, int snum, 
+static WERROR construct_printer_driver_info_6(DRIVER_INFO_6 *info, int snum,
               fstring servername, fstring architecture, uint32 version)
-{	
+{
 	NT_PRINTER_INFO_LEVEL 		*printer = NULL;
 	NT_PRINTER_DRIVER_INFO_LEVEL 	driver;
 	WERROR 				status;
-	
+
 	ZERO_STRUCT(driver);
 
 	status=get_a_printer(NULL, &printer, 2, lp_const_servicename(snum) );
-	
+
 	DEBUG(8,("construct_printer_driver_info_6: status: %s\n", dos_errstr(status)));
-	
+
 	if (!W_ERROR_IS_OK(status))
 		return WERR_INVALID_PRINTER_NAME;
 
 	status = get_a_printer_driver(&driver, 3, printer->info_2->drivername, architecture, version);
-		
+
 	DEBUG(8,("construct_printer_driver_info_6: status: %s\n", dos_errstr(status)));
-	
-	if (!W_ERROR_IS_OK(status)) 
+
+	if (!W_ERROR_IS_OK(status))
 	{
 		/*
 		 * Is this a W2k client ?
@@ -5487,7 +5487,7 @@ static WERROR construct_printer_driver_info_6(DRIVER_INFO_6 *info, int snum,
 
 		/* Yes - try again with a WinNT driver. */
 		version = 2;
-		status=get_a_printer_driver(&driver, 3, printer->info_2->drivername, architecture, version);	
+		status=get_a_printer_driver(&driver, 3, printer->info_2->drivername, architecture, version);
 		DEBUG(8,("construct_printer_driver_info_6: status: %s\n", dos_errstr(status)));
 		if (!W_ERROR_IS_OK(status)) {
 			free_a_printer(&printer,2);
@@ -5526,15 +5526,15 @@ static WERROR getprinterdriver2_level1(fstring servername, fstring architecture,
 {
 	DRIVER_INFO_1 *info=NULL;
 	WERROR result;
-	
+
 	if((info=SMB_MALLOC_P(DRIVER_INFO_1)) == NULL)
 		return WERR_NOMEM;
-	
+
 	result = construct_printer_driver_info_1(info, snum, servername, architecture, version);
-	if (!W_ERROR_IS_OK(result)) 
+	if (!W_ERROR_IS_OK(result))
 		goto out;
 
-	/* check the required size. */	
+	/* check the required size. */
 	*needed += spoolss_size_printer_driver_info_1(info);
 
 	if (*needed > offered) {
@@ -5548,7 +5548,7 @@ static WERROR getprinterdriver2_level1(fstring servername, fstring architecture,
 	}
 
 	/* fill the buffer with the structures */
-	smb_io_printer_driver_info_1("", buffer, info, 0);	
+	smb_io_printer_driver_info_1("", buffer, info, 0);
 
 out:
 	/* clear memory */
@@ -5564,29 +5564,29 @@ static WERROR getprinterdriver2_level2(fstring servername, fstring architecture,
 {
 	DRIVER_INFO_2 *info=NULL;
 	WERROR result;
-	
+
 	if((info=SMB_MALLOC_P(DRIVER_INFO_2)) == NULL)
 		return WERR_NOMEM;
-	
+
 	result = construct_printer_driver_info_2(info, snum, servername, architecture, version);
-	if (!W_ERROR_IS_OK(result)) 
+	if (!W_ERROR_IS_OK(result))
 		goto out;
 
-	/* check the required size. */	
+	/* check the required size. */
 	*needed += spoolss_size_printer_driver_info_2(info);
 
 	if (*needed > offered) {
 		result = WERR_INSUFFICIENT_BUFFER;
 		goto out;
 	}
-	
+
 	if (!rpcbuf_alloc_size(buffer, *needed)) {
 		result = WERR_NOMEM;
 		goto out;
 	}
 
 	/* fill the buffer with the structures */
-	smb_io_printer_driver_info_2("", buffer, info, 0);	
+	smb_io_printer_driver_info_2("", buffer, info, 0);
 
 out:
 	/* clear memory */
@@ -5609,7 +5609,7 @@ static WERROR getprinterdriver2_level3(fstring servername, fstring architecture,
 	if (!W_ERROR_IS_OK(result))
 		goto out;
 
-	/* check the required size. */	
+	/* check the required size. */
 	*needed += spoolss_size_printer_driver_info_3(&info);
 
 	if (*needed > offered) {
@@ -5642,17 +5642,17 @@ static WERROR getprinterdriver2_level6(fstring servername, fstring architecture,
 	ZERO_STRUCT(info);
 
 	result = construct_printer_driver_info_6(&info, snum, servername, architecture, version);
-	if (!W_ERROR_IS_OK(result)) 
+	if (!W_ERROR_IS_OK(result))
 		goto out;
 
-	/* check the required size. */	
+	/* check the required size. */
 	*needed += spoolss_size_printer_driver_info_6(&info);
 
 	if (*needed > offered) {
 		result = WERR_INSUFFICIENT_BUFFER;
 		goto out;
 	}
-	
+
 	if (!rpcbuf_alloc_size(buffer, *needed)) {
 		result = WERR_NOMEM;
 		goto out;
@@ -5723,8 +5723,8 @@ WERROR _spoolss_getprinterdriver2(pipes_struct *p, SPOOL_Q_GETPRINTERDRIVER2 *q_
 	case 6:
 		return getprinterdriver2_level6(servername, architecture, clientmajorversion, snum, buffer, offered, needed);
 #if 0	/* JERRY */
-	case 101: 
-		/* apparently this call is the equivalent of 
+	case 101:
+		/* apparently this call is the equivalent of
 		   EnumPrinterDataEx() for the DsDriver key */
 		break;
 #endif
@@ -5765,7 +5765,7 @@ WERROR _spoolss_endpageprinter(pipes_struct *p, SPOOL_Q_ENDPAGEPRINTER *q_u, SPO
 		DEBUG(2,("_spoolss_endpageprinter: Invalid handle (%s:%u:%u).\n",OUR_HANDLE(handle)));
 		return WERR_BADFID;
 	}
-	
+
 	if (!get_printer_snum(p, handle, &snum, NULL))
 		return WERR_BADFID;
 
@@ -5805,22 +5805,22 @@ WERROR _spoolss_startdocprinter(pipes_struct *p, SPOOL_Q_STARTDOCPRINTER *q_u, S
 	 *
 	 * So I add checks like in NT Server ...
 	 */
-	
+
 	if (info_1->p_datatype != 0) {
 		unistr2_to_ascii(datatype, &info_1->datatype, sizeof(datatype));
 		if (strcmp(datatype, "RAW") != 0) {
 			(*jobid)=0;
 			return WERR_INVALID_DATATYPE;
-		}		
-	}		
-	
+		}
+	}
+
 	/* get the share number of the printer */
 	if (!get_printer_snum(p, handle, &snum, NULL)) {
 		return WERR_BADFID;
 	}
 
 	unistr2_to_ascii(jobname, &info_1->docname, sizeof(jobname));
-	
+
 	Printer->jobid = print_job_start(&p->pipe_user, snum, jobname, Printer->nt_devmode);
 
 	/* An error occured in print_job_start() so return an appropriate
@@ -5829,7 +5829,7 @@ WERROR _spoolss_startdocprinter(pipes_struct *p, SPOOL_Q_STARTDOCPRINTER *q_u, S
 	if (Printer->jobid == -1) {
 		return map_werror_from_unix(errno);
 	}
-	
+
 	Printer->document_started=True;
 	(*jobid) = Printer->jobid;
 
@@ -5860,7 +5860,7 @@ WERROR _spoolss_writeprinter(pipes_struct *p, SPOOL_Q_WRITEPRINTER *q_u, SPOOL_R
 	uint32 *buffer_written = &q_u->buffer_size2;
 	int snum;
 	Printer_entry *Printer = find_printer_index_by_hnd(p, handle);
-	
+
 	if (!Printer) {
 		DEBUG(2,("_spoolss_writeprinter: Invalid handle (%s:%u:%u)\n",OUR_HANDLE(handle)));
 		r_u->buffer_written = q_u->buffer_size2;
@@ -5942,17 +5942,17 @@ WERROR _spoolss_abortprinter(pipes_struct *p, SPOOL_Q_ABORTPRINTER *q_u, SPOOL_R
 	Printer_entry 	*Printer = find_printer_index_by_hnd(p, handle);
 	int		snum;
 	WERROR 		errcode = WERR_OK;
-	
+
 	if (!Printer) {
 		DEBUG(2,("_spoolss_abortprinter: Invalid handle (%s:%u:%u)\n",OUR_HANDLE(handle)));
 		return WERR_BADFID;
 	}
-	
+
 	if (!get_printer_snum(p, handle, &snum, NULL))
 		return WERR_BADFID;
-	
-	print_job_delete( &p->pipe_user, snum, Printer->jobid, &errcode );	
-	
+
+	print_job_delete( &p->pipe_user, snum, Printer->jobid, &errcode );
+
 	return errcode;
 }
 
@@ -5978,7 +5978,7 @@ static WERROR update_printer_sec(POLICY_HND *handle, uint32 level,
 		result = WERR_BADFID;
 		goto done;
 	}
-	
+
 	if (!secdesc_ctr) {
 		DEBUG(10,("update_printer_sec: secdesc_ctr is NULL !\n"));
 		result = WERR_INVALID_PARAM;
@@ -6006,7 +6006,7 @@ static WERROR update_printer_sec(POLICY_HND *handle, uint32 level,
 		int i;
 
 		the_acl = old_secdesc_ctr->sd->dacl;
-		DEBUG(10, ("old_secdesc_ctr for %s has %d aces:\n", 
+		DEBUG(10, ("old_secdesc_ctr for %s has %d aces:\n",
 			   PRINTERNAME(snum), the_acl->num_aces));
 
 		for (i = 0; i < the_acl->num_aces; i++) {
@@ -6014,22 +6014,22 @@ static WERROR update_printer_sec(POLICY_HND *handle, uint32 level,
 
 			sid_to_string(sid_str, &the_acl->aces[i].trustee);
 
-			DEBUG(10, ("%s 0x%08x\n", sid_str, 
+			DEBUG(10, ("%s 0x%08x\n", sid_str,
 				  the_acl->aces[i].access_mask));
 		}
 
 		the_acl = secdesc_ctr->sd->dacl;
 
 		if (the_acl) {
-			DEBUG(10, ("secdesc_ctr for %s has %d aces:\n", 
+			DEBUG(10, ("secdesc_ctr for %s has %d aces:\n",
 				   PRINTERNAME(snum), the_acl->num_aces));
 
 			for (i = 0; i < the_acl->num_aces; i++) {
 				fstring sid_str;
-				
+
 				sid_to_string(sid_str, &the_acl->aces[i].trustee);
-				
-				DEBUG(10, ("%s 0x%08x\n", sid_str, 
+
+				DEBUG(10, ("%s 0x%08x\n", sid_str,
 					   the_acl->aces[i].access_mask));
 			}
 		} else {
@@ -6058,9 +6058,9 @@ static WERROR update_printer_sec(POLICY_HND *handle, uint32 level,
 /********************************************************************
  Canonicalize printer info from a client
 
- ATTN: It does not matter what we set the servername to hear 
- since we do the necessary work in get_a_printer() to set it to 
- the correct value based on what the client sent in the 
+ ATTN: It does not matter what we set the servername to hear
+ since we do the necessary work in get_a_printer() to set it to
+ the correct value based on what the client sent in the
  _spoolss_open_printer_ex().
  ********************************************************************/
 
@@ -6068,16 +6068,16 @@ static bool check_printer_ok(NT_PRINTER_INFO_LEVEL_2 *info, int snum)
 {
 	fstring printername;
 	const char *p;
-	
+
 	DEBUG(5,("check_printer_ok: servername=%s printername=%s sharename=%s "
 		"portname=%s drivername=%s comment=%s location=%s\n",
-		info->servername, info->printername, info->sharename, 
+		info->servername, info->printername, info->sharename,
 		info->portname, info->drivername, info->comment, info->location));
 
 	/* we force some elements to "correct" values */
 	slprintf(info->servername, sizeof(info->servername)-1, "\\\\%s", global_myname());
 	fstrcpy(info->sharename, lp_servicename(snum));
-	
+
 	/* check to see if we allow printername != sharename */
 
 	if ( lp_force_printername(snum) ) {
@@ -6086,23 +6086,23 @@ static bool check_printer_ok(NT_PRINTER_INFO_LEVEL_2 *info, int snum)
 	} else {
 
 		/* make sure printername is in \\server\printername format */
-	
+
 		fstrcpy( printername, info->printername );
 		p = printername;
 		if ( printername[0] == '\\' && printername[1] == '\\' ) {
 			if ( (p = strchr_m( &printername[2], '\\' )) != NULL )
 				p++;
 		}
-		
+
 		slprintf(info->printername, sizeof(info->printername)-1, "\\\\%s\\%s",
 			 global_myname(), p );
 	}
 
 	info->attributes |= PRINTER_ATTRIBUTE_SAMBA;
 	info->attributes &= ~PRINTER_ATTRIBUTE_NOT_SAMBA;
-	
-	
-	
+
+
+
 	return True;
 }
 
@@ -6121,7 +6121,7 @@ WERROR add_port_hook(NT_USER_TOKEN *token, const char *portname, const char *uri
 	if ( !*cmd ) {
 		return WERR_ACCESS_DENIED;
 	}
-		
+
 	slprintf(command, sizeof(command)-1, "%s \"%s\" \"%s\"", cmd, portname, uri );
 
 	if ( token )
@@ -6133,7 +6133,7 @@ WERROR add_port_hook(NT_USER_TOKEN *token, const char *portname, const char *uri
 
 	if ( is_print_op )
 		become_root();
-	
+
 	ret = smbrun(command, &fd);
 
 	if ( is_print_op )
@@ -6148,7 +6148,7 @@ WERROR add_port_hook(NT_USER_TOKEN *token, const char *portname, const char *uri
 			close(fd);
 		return WERR_ACCESS_DENIED;
 	}
-	
+
 	return WERR_OK;
 }
 
@@ -6170,7 +6170,7 @@ bool add_printer_hook(NT_USER_TOKEN *token, NT_PRINTER_INFO_LEVEL *printer)
 	standard_sub_basic(current_user_info.smb_name,
 			   current_user_info.domain,
 			   remote_machine,sizeof(remote_machine));
-	
+
 	slprintf(command, sizeof(command)-1, "%s \"%s\" \"%s\" \"%s\" \"%s\" \"%s\" \"%s\" \"%s\"",
 			cmd, printer->info_2->printername, printer->info_2->sharename,
 			printer->info_2->portname, printer->info_2->drivername,
@@ -6185,7 +6185,7 @@ bool add_printer_hook(NT_USER_TOKEN *token, NT_PRINTER_INFO_LEVEL *printer)
 
 	if ( is_print_op )
 		become_root();
-	
+
 	if ( (ret = smbrun(command, &fd)) == 0 ) {
 		/* Tell everyone we updated smb.conf. */
 		message_send_all(smbd_messaging_context(),
@@ -6296,7 +6296,7 @@ static WERROR update_printer(pipes_struct *p, POLICY_HND *handle, uint32 level,
 		goto done;
 	}
 
-	/* FIXME!!! If the driver has changed we really should verify that 
+	/* FIXME!!! If the driver has changed we really should verify that
 	   it is installed before doing much else   --jerry */
 
 	/* Check calling user has permission to update printer description */
@@ -6309,8 +6309,8 @@ static WERROR update_printer(pipes_struct *p, POLICY_HND *handle, uint32 level,
 
 	/* Call addprinter hook */
 	/* Check changes to see if this is really needed */
-	
-	if ( *lp_addprinter_cmd() 
+
+	if ( *lp_addprinter_cmd()
 		&& (!strequal(printer->info_2->drivername, old_printer->info_2->drivername)
 			|| !strequal(printer->info_2->comment, old_printer->info_2->comment)
 			|| !strequal(printer->info_2->portname, old_printer->info_2->portname)
@@ -6323,7 +6323,7 @@ static WERROR update_printer(pipes_struct *p, POLICY_HND *handle, uint32 level,
 			goto done;
 		}
 	}
-	
+
 	/*
 	 * When a *new* driver is bound to a printer, the drivername is used to
 	 * lookup previously saved driver initialization info, which is then
@@ -6331,21 +6331,21 @@ static WERROR update_printer(pipes_struct *p, POLICY_HND *handle, uint32 level,
 	 */
 	if (!strequal(printer->info_2->drivername, old_printer->info_2->drivername))
 	{
-		if (!set_driver_init(printer, 2)) 
+		if (!set_driver_init(printer, 2))
 		{
 			DEBUG(5,("update_printer: Error restoring driver initialization data for driver [%s]!\n",
 				printer->info_2->drivername));
 		}
-		
+
 		DEBUG(10,("update_printer: changing driver [%s]!  Sending event!\n",
 			printer->info_2->drivername));
-			
+
 		notify_printer_driver(snum, printer->info_2->drivername);
 	}
 
-	/* 
-	 * flag which changes actually occured.  This is a small subset of 
-	 * all the possible changes.  We also have to update things in the 
+	/*
+	 * flag which changes actually occured.  This is a small subset of
+	 * all the possible changes.  We also have to update things in the
 	 * DsSpooler key.
 	 */
 
@@ -6367,12 +6367,12 @@ static WERROR update_printer(pipes_struct *p, POLICY_HND *handle, uint32 level,
 
 	if (!strequal(printer->info_2->printername, old_printer->info_2->printername)) {
 		char *pname;
-		
+
 		if ( (pname = strchr_m( printer->info_2->printername+2, '\\' )) != NULL )
 			pname++;
 		else
 			pname = printer->info_2->printername;
-			
+
 
 		init_unistr2( &buffer, pname, UNI_STR_TERMINATE);
 		set_printer_dataex( printer, SPOOL_DSSPOOLER_KEY, "printerName",
@@ -6380,7 +6380,7 @@ static WERROR update_printer(pipes_struct *p, POLICY_HND *handle, uint32 level,
 
 		notify_printer_printername( snum, pname );
 	}
-	
+
 	if (!strequal(printer->info_2->portname, old_printer->info_2->portname)) {
 		init_unistr2( &buffer, printer->info_2->portname, UNI_STR_TERMINATE);
 		set_printer_dataex( printer, SPOOL_DSSPOOLER_KEY, "portName",
@@ -6396,10 +6396,10 @@ static WERROR update_printer(pipes_struct *p, POLICY_HND *handle, uint32 level,
 
 		notify_printer_location(snum, printer->info_2->location);
 	}
-	
+
 	/* here we need to update some more DsSpooler keys */
 	/* uNCName, serverName, shortServerName */
-	
+
 	init_unistr2( &buffer, global_myname(), UNI_STR_TERMINATE);
 	set_printer_dataex( printer, SPOOL_DSSPOOLER_KEY, "serverName",
 		REG_SZ, (uint8*)buffer.buffer, buffer.uni_str_len*2 );
@@ -6446,9 +6446,9 @@ static WERROR publish_or_unpublish_printer(pipes_struct *p, POLICY_HND *handle,
 
 	if (!get_printer_snum(p, handle, &snum, NULL))
 		return WERR_BADFID;
-	
+
 	nt_printer_publish(Printer, snum, info7->action);
-	
+
 	return WERR_OK;
 #else
 	return WERR_UNKNOWN_LEVEL;
@@ -6468,19 +6468,19 @@ WERROR _spoolss_setprinter(pipes_struct *p, SPOOL_Q_SETPRINTER *q_u, SPOOL_R_SET
 	WERROR result;
 
 	Printer_entry *Printer = find_printer_index_by_hnd(p, handle);
-	
+
 	if (!Printer) {
 		DEBUG(2,("_spoolss_setprinter: Invalid handle (%s:%u:%u)\n", OUR_HANDLE(handle)));
 		return WERR_BADFID;
 	}
 
-	/* check the level */	
+	/* check the level */
 	switch (level) {
 		case 0:
 			return control_printer(handle, command, p);
 		case 2:
 			result = update_printer(p, handle, level, info, devmode_ctr.devmode);
-			if (!W_ERROR_IS_OK(result)) 
+			if (!W_ERROR_IS_OK(result))
 				return result;
 			if (secdesc_ctr)
 				result = update_printer_sec(handle, level, info, p, secdesc_ctr);
@@ -6502,7 +6502,7 @@ WERROR _spoolss_fcpn(pipes_struct *p, SPOOL_Q_FCPN *q_u, SPOOL_R_FCPN *r_u)
 {
 	POLICY_HND *handle = &q_u->handle;
 	Printer_entry *Printer= find_printer_index_by_hnd(p, handle);
-	
+
 	if (!Printer) {
 		DEBUG(2,("_spoolss_fcpn: Invalid handle (%s:%u:%u)\n", OUR_HANDLE(handle)));
 		return WERR_BADFID;
@@ -6555,14 +6555,14 @@ WERROR _spoolss_addjob(pipes_struct *p, SPOOL_Q_ADDJOB *q_u, SPOOL_R_ADDJOB *r_u
 ****************************************************************************/
 
 static void fill_job_info_1(JOB_INFO_1 *job_info, const print_queue_struct *queue,
-                            int position, int snum, 
+                            int position, int snum,
                             const NT_PRINTER_INFO_LEVEL *ntprinter)
 {
 	struct tm *t;
-	
+
 	t=gmtime(&queue->time);
 
-	job_info->jobid=queue->job;	
+	job_info->jobid=queue->job;
 	init_unistr(&job_info->printername, lp_servicename(snum));
 	init_unistr(&job_info->machinename, ntprinter->info_2->servername);
 	init_unistr(&job_info->username, queue->fs_user);
@@ -6582,7 +6582,7 @@ static void fill_job_info_1(JOB_INFO_1 *job_info, const print_queue_struct *queu
 ****************************************************************************/
 
 static bool fill_job_info_2(JOB_INFO_2 *job_info, const print_queue_struct *queue,
-                            int position, int snum, 
+                            int position, int snum,
 			    const NT_PRINTER_INFO_LEVEL *ntprinter,
 			    DEVICEMODE *devmode)
 {
@@ -6591,9 +6591,9 @@ static bool fill_job_info_2(JOB_INFO_2 *job_info, const print_queue_struct *queu
 	t=gmtime(&queue->time);
 
 	job_info->jobid=queue->job;
-	
+
 	init_unistr(&job_info->printername, ntprinter->info_2->printername);
-	
+
 	init_unistr(&job_info->machinename, ntprinter->info_2->servername);
 	init_unistr(&job_info->username, queue->fs_user);
 	init_unistr(&job_info->document, queue->fs_file);
@@ -6603,7 +6603,7 @@ static bool fill_job_info_2(JOB_INFO_2 *job_info, const print_queue_struct *queu
 	init_unistr(&job_info->parameters, "");
 	init_unistr(&job_info->drivername, ntprinter->info_2->drivername);
 	init_unistr(&job_info->text_status, "");
-	
+
 /* and here the security descriptor */
 
 	job_info->status=nt_printj_status(queue->status);
@@ -6634,17 +6634,17 @@ static WERROR enumjobs_level1(const print_queue_struct *queue, int snum,
 	JOB_INFO_1 *info;
 	int i;
 	WERROR result = WERR_OK;
-	
+
 	info=SMB_MALLOC_ARRAY(JOB_INFO_1,*returned);
 	if (info==NULL) {
 		*returned=0;
 		return WERR_NOMEM;
 	}
-	
+
 	for (i=0; i<*returned; i++)
 		fill_job_info_1( &info[i], &queue[i], i, snum, ntprinter );
 
-	/* check the required size. */	
+	/* check the required size. */
 	for (i=0; i<*returned; i++)
 		(*needed) += spoolss_size_job_info_1(&info[i]);
 
@@ -6660,7 +6660,7 @@ static WERROR enumjobs_level1(const print_queue_struct *queue, int snum,
 
 	/* fill the buffer with the structures */
 	for (i=0; i<*returned; i++)
-		smb_io_job_info_1("", buffer, &info[i], 0);	
+		smb_io_job_info_1("", buffer, &info[i], 0);
 
 out:
 	/* clear memory */
@@ -6685,20 +6685,20 @@ static WERROR enumjobs_level2(const print_queue_struct *queue, int snum,
 	int i;
 	WERROR result = WERR_OK;
 	DEVICEMODE *devmode = NULL;
-	
+
 	if ( !(info = SMB_MALLOC_ARRAY(JOB_INFO_2,*returned)) ) {
 		*returned=0;
 		return WERR_NOMEM;
 	}
-		
+
 	/* this should not be a failure condition if the devmode is NULL */
-	
+
 	devmode = construct_dev_mode(lp_const_servicename(snum));
 
 	for (i=0; i<*returned; i++)
 		fill_job_info_2(&(info[i]), &queue[i], i, snum, ntprinter, devmode);
 
-	/* check the required size. */	
+	/* check the required size. */
 	for (i=0; i<*returned; i++)
 		(*needed) += spoolss_size_job_info_2(&info[i]);
 
@@ -6714,7 +6714,7 @@ static WERROR enumjobs_level2(const print_queue_struct *queue, int snum,
 
 	/* fill the buffer with the structures */
 	for (i=0; i<*returned; i++)
-		smb_io_job_info_2("", buffer, &info[i], 0);	
+		smb_io_job_info_2("", buffer, &info[i], 0);
 
 out:
 	free_devmode(devmode);
@@ -6732,7 +6732,7 @@ out:
 ****************************************************************************/
 
 WERROR _spoolss_enumjobs( pipes_struct *p, SPOOL_Q_ENUMJOBS *q_u, SPOOL_R_ENUMJOBS *r_u)
-{	
+{
 	POLICY_HND *handle = &q_u->handle;
 	uint32 level = q_u->level;
 	RPC_BUFFER *buffer = NULL;
@@ -6760,14 +6760,14 @@ WERROR _spoolss_enumjobs( pipes_struct *p, SPOOL_Q_ENUMJOBS *q_u, SPOOL_R_ENUMJO
 	*returned=0;
 
 	/* lookup the printer snum and tdb entry */
-	
+
 	if (!get_printer_snum(p, handle, &snum, NULL))
 		return WERR_BADFID;
 
 	wret = get_a_printer(NULL, &ntprinter, 2, lp_servicename(snum));
 	if ( !W_ERROR_IS_OK(wret) )
 		return wret;
-	
+
 	*returned = print_queue_status(snum, &queue, &prt_status);
 	DEBUGADD(4,("count:[%d], status:[%d], [%s]\n", *returned, prt_status.status, prt_status.message));
 
@@ -6789,7 +6789,7 @@ WERROR _spoolss_enumjobs( pipes_struct *p, SPOOL_Q_ENUMJOBS *q_u, SPOOL_R_ENUMJO
 		wret = WERR_UNKNOWN_LEVEL;
 		break;
 	}
-	
+
 	SAFE_FREE(queue);
 	free_a_printer( &ntprinter, 2 );
 	return wret;
@@ -6814,7 +6814,7 @@ WERROR _spoolss_setjob(pipes_struct *p, SPOOL_Q_SETJOB *q_u, SPOOL_R_SETJOB *r_u
 
 	int snum;
 	WERROR errcode = WERR_BADFUNC;
-		
+
 	if (!get_printer_snum(p, handle, &snum, NULL)) {
 		return WERR_BADFID;
 	}
@@ -6833,7 +6833,7 @@ WERROR _spoolss_setjob(pipes_struct *p, SPOOL_Q_SETJOB *q_u, SPOOL_R_SETJOB *r_u
 	case JOB_CONTROL_PAUSE:
 		if (print_job_pause(&p->pipe_user, snum, jobid, &errcode)) {
 			errcode = WERR_OK;
-		}		
+		}
 		break;
 	case JOB_CONTROL_RESTART:
 	case JOB_CONTROL_RESUME:
@@ -6886,21 +6886,21 @@ static WERROR enumprinterdrivers_level1(fstring servername, fstring architecture
 			WERROR status;
 			DEBUGADD(5,("\tdriver: [%s]\n", list[i]));
 			ZERO_STRUCT(driver);
-			status = get_a_printer_driver(&driver, 3, list[i], 
+			status = get_a_printer_driver(&driver, 3, list[i],
 						      architecture, version);
 			if (!W_ERROR_IS_OK(status)) {
 				SAFE_FREE(list);
 				SAFE_FREE(driver_info_1);
 				return status;
 			}
-			fill_printer_driver_info_1(&driver_info_1[*returned+i], driver, servername, architecture );		
+			fill_printer_driver_info_1(&driver_info_1[*returned+i], driver, servername, architecture );
 			free_a_printer_driver(driver, 3);
-		}	
+		}
 
 		*returned+=ndrivers;
 		SAFE_FREE(list);
 	}
-	
+
 	/* check the required size. */
 	for (i=0; i<*returned; i++) {
 		DEBUGADD(6,("adding driver [%d]'s size\n",i));
@@ -6913,7 +6913,7 @@ static WERROR enumprinterdrivers_level1(fstring servername, fstring architecture
 	}
 
 	if (!rpcbuf_alloc_size(buffer, *needed)) {
-		result = WERR_NOMEM;	
+		result = WERR_NOMEM;
 		goto out;
 	}
 
@@ -6965,27 +6965,27 @@ static WERROR enumprinterdrivers_level2(fstring servername, fstring architecture
 				return WERR_NOMEM;
 			}
 		}
-		
+
 		for (i=0; i<ndrivers; i++) {
 			WERROR status;
 
 			DEBUGADD(5,("\tdriver: [%s]\n", list[i]));
 			ZERO_STRUCT(driver);
-			status = get_a_printer_driver(&driver, 3, list[i], 
+			status = get_a_printer_driver(&driver, 3, list[i],
 						      architecture, version);
 			if (!W_ERROR_IS_OK(status)) {
 				SAFE_FREE(list);
 				SAFE_FREE(driver_info_2);
 				return status;
 			}
-			fill_printer_driver_info_2(&driver_info_2[*returned+i], driver, servername);		
+			fill_printer_driver_info_2(&driver_info_2[*returned+i], driver, servername);
 			free_a_printer_driver(driver, 3);
-		}	
+		}
 
 		*returned+=ndrivers;
 		SAFE_FREE(list);
 	}
-	
+
 	/* check the required size. */
 	for (i=0; i<*returned; i++) {
 		DEBUGADD(6,("adding driver [%d]'s size\n",i));
@@ -6998,7 +6998,7 @@ static WERROR enumprinterdrivers_level2(fstring servername, fstring architecture
 	}
 
 	if (!rpcbuf_alloc_size(buffer, *needed)) {
-		result = WERR_NOMEM;	
+		result = WERR_NOMEM;
 		goto out;
 	}
 
@@ -7056,16 +7056,16 @@ static WERROR enumprinterdrivers_level3(fstring servername, fstring architecture
 
 			DEBUGADD(5,("\tdriver: [%s]\n", list[i]));
 			ZERO_STRUCT(driver);
-			status = get_a_printer_driver(&driver, 3, list[i], 
+			status = get_a_printer_driver(&driver, 3, list[i],
 						      architecture, version);
 			if (!W_ERROR_IS_OK(status)) {
 				SAFE_FREE(list);
 				SAFE_FREE(driver_info_3);
 				return status;
 			}
-			fill_printer_driver_info_3(&driver_info_3[*returned+i], driver, servername);		
+			fill_printer_driver_info_3(&driver_info_3[*returned+i], driver, servername);
 			free_a_printer_driver(driver, 3);
-		}	
+		}
 
 		*returned+=ndrivers;
 		SAFE_FREE(list);
@@ -7083,7 +7083,7 @@ static WERROR enumprinterdrivers_level3(fstring servername, fstring architecture
 	}
 
 	if (!rpcbuf_alloc_size(buffer, *needed)) {
-		result = WERR_NOMEM;	
+		result = WERR_NOMEM;
 		goto out;
 	}
 
@@ -7099,7 +7099,7 @@ out:
 	}
 
 	SAFE_FREE(driver_info_3);
-	
+
 	if ( !W_ERROR_IS_OK(result) )
 		*returned = 0;
 
@@ -7131,7 +7131,7 @@ WERROR _spoolss_enumprinterdrivers( pipes_struct *p, SPOOL_Q_ENUMPRINTERDRIVERS
 	buffer = r_u->buffer;
 
 	DEBUG(4,("_spoolss_enumprinterdrivers\n"));
-	
+
 	*needed   = 0;
 	*returned = 0;
 
@@ -7165,9 +7165,9 @@ static void fill_form_1(FORM_1 *form, nt_forms_struct *list)
 	form->left=list->left;
 	form->top=list->top;
 	form->right=list->right;
-	form->bottom=list->bottom;	
+	form->bottom=list->bottom;
 }
-	
+
 /****************************************************************************
 ****************************************************************************/
 
@@ -7225,14 +7225,14 @@ WERROR _spoolss_enumforms(pipes_struct *p, SPOOL_Q_ENUMFORMS *q_u, SPOOL_R_ENUMF
 			DEBUGADD(6,("Filling form number [%d]\n",i));
 			fill_form_1(&forms_1[i], &builtinlist[i]);
 		}
-		
+
 		SAFE_FREE(builtinlist);
 
 		for (; i<*numofforms; i++) {
 			DEBUGADD(6,("Filling form number [%d]\n",i));
 			fill_form_1(&forms_1[i], &list[i-numbuiltinforms]);
 		}
-		
+
 		SAFE_FREE(list);
 
 		/* check the required size. */
@@ -7245,14 +7245,14 @@ WERROR _spoolss_enumforms(pipes_struct *p, SPOOL_Q_ENUMFORMS *q_u, SPOOL_R_ENUMF
 			buffer_size += spoolss_size_form_1(&forms_1[i]);
 		}
 
-		*needed=buffer_size;		
-		
+		*needed=buffer_size;
+
 		if (*needed > offered) {
 			SAFE_FREE(forms_1);
 			*numofforms=0;
 			return WERR_INSUFFICIENT_BUFFER;
 		}
-	
+
 		if (!rpcbuf_alloc_size(buffer, buffer_size)){
 			SAFE_FREE(forms_1);
 			*numofforms=0;
@@ -7272,7 +7272,7 @@ WERROR _spoolss_enumforms(pipes_struct *p, SPOOL_Q_ENUMFORMS *q_u, SPOOL_R_ENUMF
 		SAFE_FREE(forms_1);
 
 		return WERR_OK;
-			
+
 	default:
 		SAFE_FREE(list);
 		SAFE_FREE(builtinlist);
@@ -7340,7 +7340,7 @@ WERROR _spoolss_getform(pipes_struct *p, SPOOL_Q_GETFORM *q_u, SPOOL_R_GETFORM *
 					break;
 				}
 			}
-			
+
 			SAFE_FREE(list);
 			if (i == numofforms) {
 				return WERR_BADFID;
@@ -7349,8 +7349,8 @@ WERROR _spoolss_getform(pipes_struct *p, SPOOL_Q_GETFORM *q_u, SPOOL_R_GETFORM *
 		/* check the required size. */
 
 		*needed=spoolss_size_form_1(&form_1);
-		
-		if (*needed > offered) 
+
+		if (*needed > offered)
 			return WERR_INSUFFICIENT_BUFFER;
 
 		if (!rpcbuf_alloc_size(buffer, buffer_size))
@@ -7361,7 +7361,7 @@ WERROR _spoolss_getform(pipes_struct *p, SPOOL_Q_GETFORM *q_u, SPOOL_R_GETFORM *
 		smb_io_form_1("", buffer, &form_1, 0);
 
 		return WERR_OK;
-			
+
 	default:
 		SAFE_FREE(list);
 		return WERR_UNKNOWN_LEVEL;
@@ -7377,7 +7377,7 @@ static void fill_port_1(PORT_INFO_1 *port, const char *name)
 }
 
 /****************************************************************************
- TODO: This probably needs distinguish between TCP/IP and Local ports 
+ TODO: This probably needs distinguish between TCP/IP and Local ports
  somehow.
 ****************************************************************************/
 
@@ -7387,7 +7387,7 @@ static void fill_port_2(PORT_INFO_2 *port, const char *name)
 	init_unistr(&port->monitor_name, "Local Monitor");
 	init_unistr(&port->description, SPL_LOCAL_PORT );
 	port->port_type=PORT_TYPE_WRITE;
-	port->reserved=0x0;	
+	port->reserved=0x0;
 }
 
 
@@ -7408,7 +7408,7 @@ WERROR enumports_hook( int *count, char ***lines )
 	*lines = NULL;
 
 	/* if no hook then just fill in the default port */
-	
+
 	if ( !*cmd ) {
 		if (!(qlines = SMB_MALLOC_ARRAY( char*, 2 ))) {
 			return WERR_NOMEM;
@@ -7422,7 +7422,7 @@ WERROR enumports_hook( int *count, char ***lines )
 	}
 	else {
 		/* we have a valid enumport command */
-		
+
 		slprintf(command, sizeof(command)-1, "%s \"%d\"", cmd, 1);
 
 		DEBUG(10,("Running [%s]\n", command));
@@ -7440,7 +7440,7 @@ WERROR enumports_hook( int *count, char ***lines )
 		DEBUGADD(10,("Lines returned = [%d]\n", numlines));
 		close(fd);
 	}
-	
+
 	*count = numlines;
 	*lines = qlines;
 
@@ -7464,10 +7464,10 @@ static WERROR enumports_level_1(RPC_BUFFER *buffer, uint32 offered, uint32 *need
 		file_lines_free(qlines);
 		return result;
 	}
-	
+
 	if(numlines) {
 		if((ports=SMB_MALLOC_ARRAY( PORT_INFO_1, numlines )) == NULL) {
-			DEBUG(10,("Returning WERR_NOMEM [%s]\n", 
+			DEBUG(10,("Returning WERR_NOMEM [%s]\n",
 				  dos_errstr(WERR_NOMEM)));
 			file_lines_free(qlines);
 			return WERR_NOMEM;
@@ -7487,7 +7487,7 @@ static WERROR enumports_level_1(RPC_BUFFER *buffer, uint32 offered, uint32 *need
 		DEBUGADD(6,("adding port [%d]'s size\n", i));
 		*needed += spoolss_size_port_info_1(&ports[i]);
 	}
-		
+
 	if (*needed > offered) {
 		result = WERR_INSUFFICIENT_BUFFER;
 		goto out;
@@ -7530,7 +7530,7 @@ static WERROR enumports_level_2(RPC_BUFFER *buffer, uint32 offered, uint32 *need
 		file_lines_free(qlines);
 		return result;
 	}
-	
+
 	if(numlines) {
 		if((ports=SMB_MALLOC_ARRAY( PORT_INFO_2, numlines)) == NULL) {
 			file_lines_free(qlines);
@@ -7552,7 +7552,7 @@ static WERROR enumports_level_2(RPC_BUFFER *buffer, uint32 offered, uint32 *need
 		DEBUGADD(6,("adding port [%d]'s size\n", i));
 		*needed += spoolss_size_port_info_2(&ports[i]);
 	}
-		
+
 	if (*needed > offered) {
 		result = WERR_INSUFFICIENT_BUFFER;
 		goto out;
@@ -7600,10 +7600,10 @@ WERROR _spoolss_enumports( pipes_struct *p, SPOOL_Q_ENUMPORTS *q_u, SPOOL_R_ENUM
 	buffer = r_u->buffer;
 
 	DEBUG(4,("_spoolss_enumports\n"));
-	
+
 	*returned=0;
 	*needed=0;
-	
+
 	switch (level) {
 	case 1:
 		return enumports_level_1(buffer, offered, needed, returned);
@@ -7642,12 +7642,12 @@ static WERROR spoolss_addprinterex_level_2( pipes_struct *p, const UNISTR2 *uni_
 	/* check to see if the printer already exists */
 
 	if ((snum = print_queue_snum(printer->info_2->sharename)) != -1) {
-		DEBUG(5, ("spoolss_addprinterex_level_2: Attempted to add a printer named [%s] when one already existed!\n", 
+		DEBUG(5, ("spoolss_addprinterex_level_2: Attempted to add a printer named [%s] when one already existed!\n",
 			printer->info_2->sharename));
 		free_a_printer(&printer, 2);
 		return WERR_PRINTER_ALREADY_EXISTS;
 	}
-	
+
 	/* FIXME!!!  smbd should check to see if the driver is installed before
 	   trying to add a printer like this  --jerry */
 
@@ -7663,13 +7663,13 @@ static WERROR spoolss_addprinterex_level_2( pipes_struct *p, const UNISTR2 *uni_
 			printer->info_2->sharename ));
 	}
 
-	/* use our primary netbios name since get_a_printer() will convert 
+	/* use our primary netbios name since get_a_printer() will convert
 	   it to what the client expects on a case by case basis */
 
 	slprintf(name, sizeof(name)-1, "\\\\%s\\%s", global_myname(),
              printer->info_2->sharename);
 
-	
+
 	if ((snum = print_queue_snum(printer->info_2->sharename)) == -1) {
 		free_a_printer(&printer,2);
 		return WERR_ACCESS_DENIED;
@@ -7678,9 +7678,9 @@ static WERROR spoolss_addprinterex_level_2( pipes_struct *p, const UNISTR2 *uni_
 	/* you must be a printer admin to add a new printer */
 	if (!print_access_check(NULL, snum, PRINTER_ACCESS_ADMINISTER)) {
 		free_a_printer(&printer,2);
-		return WERR_ACCESS_DENIED;		
+		return WERR_ACCESS_DENIED;
 	}
-	
+
 	/*
 	 * Do sanity check on the requested changes for Samba.
 	 */
@@ -7692,7 +7692,7 @@ static WERROR spoolss_addprinterex_level_2( pipes_struct *p, const UNISTR2 *uni_
 
 	/*
 	 * When a printer is created, the drivername bound to the printer is used
-	 * to lookup previously saved driver initialization info, which is then 
+	 * to lookup previously saved driver initialization info, which is then
 	 * bound to the new printer, simulating what happens in the Windows arch.
 	 */
 
@@ -7700,7 +7700,7 @@ static WERROR spoolss_addprinterex_level_2( pipes_struct *p, const UNISTR2 *uni_
 	{
 		set_driver_init(printer, 2);
 	}
-	else 
+	else
 	{
 		/* A valid devmode was included, convert and link it
 		*/
@@ -7793,13 +7793,13 @@ WERROR _spoolss_addprinterdriver(pipes_struct *p, SPOOL_Q_ADDPRINTERDRIVER *q_u,
 		goto done;
 	}
 
-	/* 
+	/*
 	 * I think this is where he DrvUpgradePrinter() hook would be
 	 * be called in a driver's interface DLL on a Windows NT 4.0/2k
 	 * server.  Right now, we just need to send ourselves a message
-	 * to update each printer bound to this driver.   --jerry	
+	 * to update each printer bound to this driver.   --jerry
 	 */
-	 
+	
 	if (!srv_spoolss_drv_upgrade_printer(driver_name)) {
 		DEBUG(0,("_spoolss_addprinterdriver: Failed to send message about upgrading driver [%s]!\n",
 			driver_name));
@@ -7825,11 +7825,11 @@ WERROR _spoolss_addprinterdriver(pipes_struct *p, SPOOL_Q_ADDPRINTERDRIVER *q_u,
 		/*
 		 * 9x printer driver - never delete init data
 		*/
-		case 0: 
+		case 0:
 			DEBUG(10,("_spoolss_addprinterdriver: init data not deleted for 9x driver [%s]\n",
 					driver_name));
 			break;
-		
+
 		/*
 		 * Nt or 2k (compatiblity mode) printer driver - only delete init data if
 		 * there is no 2k/Xp driver init data for this driver name.
@@ -7849,7 +7849,7 @@ WERROR _spoolss_addprinterdriver(pipes_struct *p, SPOOL_Q_ADDPRINTERDRIVER *q_u,
 				 * a 2k/Xp driver was found, don't delete init data because Nt driver will use it.
 				*/
 				free_a_printer_driver(driver1,3);
-				DEBUG(10,("_spoolss_addprinterdriver: init data not deleted for Nt driver [%s]\n", 
+				DEBUG(10,("_spoolss_addprinterdriver: init data not deleted for Nt driver [%s]\n",
 						driver_name));
 			}
 		}
@@ -7858,7 +7858,7 @@ WERROR _spoolss_addprinterdriver(pipes_struct *p, SPOOL_Q_ADDPRINTERDRIVER *q_u,
 		/*
 		 * 2k or Xp printer driver - always delete init data
 		*/
-		case 3:	
+		case 3:
 			if (!del_driver_init(driver_name))
 				DEBUG(6,("_spoolss_addprinterdriver: del_driver_init(%s) 2k/Xp failed!\n", driver_name));
 			break;
@@ -7868,7 +7868,7 @@ WERROR _spoolss_addprinterdriver(pipes_struct *p, SPOOL_Q_ADDPRINTERDRIVER *q_u,
 			break;
  	}
 
-	
+
 done:
 	free_a_printer_driver(driver, level);
 	return err;
@@ -7882,15 +7882,15 @@ WERROR _spoolss_addprinterdriverex(pipes_struct *p, SPOOL_Q_ADDPRINTERDRIVEREX *
 {
 	SPOOL_Q_ADDPRINTERDRIVER q_u_local;
 	SPOOL_R_ADDPRINTERDRIVER r_u_local;
-	
-	/* 
+
+	/*
 	 * we only support the semantics of AddPrinterDriver()
 	 * i.e. only copy files that are newer than existing ones
 	 */
-	
+
 	if ( q_u->copy_flags != APD_COPY_NEW_FILES )
 		return WERR_ACCESS_DENIED;
-	
+
 	ZERO_STRUCT(q_u_local);
 	ZERO_STRUCT(r_u_local);
 
@@ -7899,7 +7899,7 @@ WERROR _spoolss_addprinterdriverex(pipes_struct *p, SPOOL_Q_ADDPRINTERDRIVEREX *
 	copy_unistr2(&q_u_local.server_name, &q_u->server_name);
 	q_u_local.level = q_u->level;
 	memcpy( &q_u_local.info, &q_u->info, sizeof(SPOOL_PRINTER_DRIVER_INFO_LEVEL) );
-	
+
 	return _spoolss_addprinterdriver( p, &q_u_local, &r_u_local );
 }
 
@@ -7919,7 +7919,7 @@ static WERROR getprinterdriverdir_level_1(UNISTR2 *name, UNISTR2 *uni_environmen
 	pstring path;
 	pstring long_archi;
 	fstring servername;
-	char *pservername; 
+	char *pservername;
 	const char *short_archi;
 	DRIVER_DIRECTORY_1 *info=NULL;
 	WERROR result = WERR_OK;
@@ -7933,8 +7933,8 @@ static WERROR getprinterdriverdir_level_1(UNISTR2 *name, UNISTR2 *uni_environmen
 	pservername = servername;
 	if ( *pservername == '\\' && strlen(servername)>2 ) {
 		pservername += 2;
-	} 
-	
+	}
+
 	if ( !is_myname_or_ipaddr( pservername ) )
 		return WERR_INVALID_PARAM;
 
@@ -7949,7 +7949,7 @@ static WERROR getprinterdriverdir_level_1(UNISTR2 *name, UNISTR2 *uni_environmen
 	DEBUG(4,("printer driver directory: [%s]\n", path));
 
 	fill_driverdir_1(info, path);
-	
+
 	*needed += spoolss_size_driverdir_info_1(info);
 
 	if (*needed > offered) {
@@ -7966,7 +7966,7 @@ static WERROR getprinterdriverdir_level_1(UNISTR2 *name, UNISTR2 *uni_environmen
 
 out:
 	SAFE_FREE(info);
-	
+
 	return result;
 }
 
@@ -8002,7 +8002,7 @@ WERROR _spoolss_getprinterdriverdirectory(pipes_struct *p, SPOOL_Q_GETPRINTERDRI
 		return WERR_UNKNOWN_LEVEL;
 	}
 }
-	
+
 /****************************************************************************
 ****************************************************************************/
 
@@ -8021,7 +8021,7 @@ WERROR _spoolss_enumprinterdata(pipes_struct *p, SPOOL_Q_ENUMPRINTERDATA *q_u, S
 	uint32 *out_data_len 	 = &r_u->realdatasize;
 
 	NT_PRINTER_INFO_LEVEL *printer = NULL;
-	
+
 	uint32 		biggest_valuesize;
 	uint32 		biggest_datasize;
 	uint32 		data_len;
@@ -8032,7 +8032,7 @@ WERROR _spoolss_enumprinterdata(pipes_struct *p, SPOOL_Q_ENUMPRINTERDATA *q_u, S
 	NT_PRINTER_DATA *p_data;
 	int		i, key_index, num_values;
 	int		name_length;
-	
+
 	*out_type = 0;
 
 	*out_max_data_len = 0;
@@ -8048,12 +8048,12 @@ WERROR _spoolss_enumprinterdata(pipes_struct *p, SPOOL_Q_ENUMPRINTERDATA *q_u, S
 
 	if (!get_printer_snum(p,handle, &snum, NULL))
 		return WERR_BADFID;
-	
+
 	result = get_a_printer(Printer, &printer, 2, lp_const_servicename(snum));
 	if (!W_ERROR_IS_OK(result))
 		return result;
-		
-	p_data = printer->info_2->data;	
+
+	p_data = printer->info_2->data;
 	key_index = lookup_printerkey( p_data, SPOOL_PRINTERDATA_KEY );
 
 	result = WERR_OK;
@@ -8063,34 +8063,34 @@ WERROR _spoolss_enumprinterdata(pipes_struct *p, SPOOL_Q_ENUMPRINTERDATA *q_u, S
 	 *
 	 * cf: MSDN EnumPrinterData remark section
 	 */
-	 
-	if ( !in_value_len && !in_data_len && (key_index != -1) ) 
+
+	if ( !in_value_len && !in_data_len && (key_index != -1) )
 	{
 		DEBUGADD(6,("Activating NT mega-hack to find sizes\n"));
 
 		biggest_valuesize = 0;
 		biggest_datasize  = 0;
-				
+
 		num_values = regval_ctr_numvals( p_data->keys[key_index].values );
-	
+
 		for ( i=0; i<num_values; i++ )
 		{
 			val = regval_ctr_specific_value( p_data->keys[key_index].values, i );
-			
+
 			name_length = strlen(val->valuename);
-			if ( strlen(val->valuename) > biggest_valuesize ) 
+			if ( strlen(val->valuename) > biggest_valuesize )
 				biggest_valuesize = name_length;
-				
+
 			if ( val->size > biggest_datasize )
 				biggest_datasize = val->size;
-				
-			DEBUG(6,("current values: [%d], [%d]\n", biggest_valuesize, 
+
+			DEBUG(6,("current values: [%d], [%d]\n", biggest_valuesize,
 				biggest_datasize));
 		}
 
-		/* the value is an UNICODE string but real_value_size is the length 
+		/* the value is an UNICODE string but real_value_size is the length
 		   in bytes including the trailing 0 */
-		   
+
 		*out_value_len = 2 * (1+biggest_valuesize);
 		*out_data_len  = biggest_datasize;
 
@@ -8098,23 +8098,23 @@ WERROR _spoolss_enumprinterdata(pipes_struct *p, SPOOL_Q_ENUMPRINTERDATA *q_u, S
 
 		goto done;
 	}
-	
+
 	/*
 	 * the value len is wrong in NT sp3
 	 * that's the number of bytes not the number of unicode chars
 	 */
-	
+
 	if ( key_index != -1 )
 		val = regval_ctr_specific_value( p_data->keys[key_index].values, idx );
 
-	if ( !val ) 
+	if ( !val )
 	{
 
 		/* out_value should default to "" or else NT4 has
 		   problems unmarshalling the response */
 
 		*out_max_value_len=(in_value_len/sizeof(uint16));
-		
+
 		if (in_value_len) {
 			if((*out_value=(uint16 *)TALLOC_ZERO(p->mem_ctx, in_value_len*sizeof(uint8))) == NULL)
 			{
@@ -8128,12 +8128,12 @@ WERROR _spoolss_enumprinterdata(pipes_struct *p, SPOOL_Q_ENUMPRINTERDATA *q_u, S
 		}
 
 		/* the data is counted in bytes */
-		
+
 		*out_max_data_len = in_data_len;
 		*out_data_len     = in_data_len;
-		
+
 		/* only allocate when given a non-zero data_len */
-		
+
 		if ( in_data_len && ((*data_out=(uint8 *)TALLOC_ZERO(p->mem_ctx, in_data_len*sizeof(uint8))) == NULL) )
 		{
 			result = WERR_NOMEM;
@@ -8142,7 +8142,7 @@ WERROR _spoolss_enumprinterdata(pipes_struct *p, SPOOL_Q_ENUMPRINTERDATA *q_u, S
 
 		result = WERR_NO_MORE_ITEMS;
 	}
-	else 
+	else
 	{
 		/*
 		 * the value is:
@@ -8152,16 +8152,16 @@ WERROR _spoolss_enumprinterdata(pipes_struct *p, SPOOL_Q_ENUMPRINTERDATA *q_u, S
 		 *
 		 * take a pause *before* coding not *during* coding
 		 */
-	
+
 		/* name */
 		*out_max_value_len=(in_value_len/sizeof(uint16));
 		if (in_value_len) {
-			if ( (*out_value = (uint16 *)TALLOC_ZERO(p->mem_ctx, in_value_len*sizeof(uint8))) == NULL ) 
+			if ( (*out_value = (uint16 *)TALLOC_ZERO(p->mem_ctx, in_value_len*sizeof(uint8))) == NULL )
 			{
 				result = WERR_NOMEM;
 				goto done;
 			}
-	
+
 			*out_value_len = (uint32)rpcstr_push((char *)*out_value, regval_name(val), (size_t)in_value_len, 0);
 		} else {
 			*out_value = NULL;
@@ -8169,13 +8169,13 @@ WERROR _spoolss_enumprinterdata(pipes_struct *p, SPOOL_Q_ENUMPRINTERDATA *q_u, S
 		}
 
 		/* type */
-		
+
 		*out_type = regval_type( val );
 
 		/* data - counted in bytes */
 
 		*out_max_data_len = in_data_len;
-		if ( in_data_len && (*data_out = (uint8 *)TALLOC_ZERO(p->mem_ctx, in_data_len*sizeof(uint8))) == NULL) 
+		if ( in_data_len && (*data_out = (uint8 *)TALLOC_ZERO(p->mem_ctx, in_data_len*sizeof(uint8))) == NULL)
 		{
 			result = WERR_NOMEM;
 			goto done;
@@ -8207,7 +8207,7 @@ WERROR _spoolss_setprinterdata( pipes_struct *p, SPOOL_Q_SETPRINTERDATA *q_u, SP
 	WERROR 			status = WERR_OK;
 	Printer_entry 		*Printer=find_printer_index_by_hnd(p, handle);
 	fstring			valuename;
-	
+
 	DEBUG(5,("spoolss_setprinterdata\n"));
 
 	if (!Printer) {
@@ -8223,15 +8223,15 @@ WERROR _spoolss_setprinterdata( pipes_struct *p, SPOOL_Q_SETPRINTERDATA *q_u, SP
 	if (!get_printer_snum(p,handle, &snum, NULL))
 		return WERR_BADFID;
 
-	/* 
-	 * Access check : NT returns "access denied" if you make a 
+	/*
+	 * Access check : NT returns "access denied" if you make a
 	 * SetPrinterData call without the necessary privildge.
 	 * we were originally returning OK if nothing changed
 	 * which made Win2k issue **a lot** of SetPrinterData
 	 * when connecting to a printer  --jerry
 	 */
 
-	if (Printer->access_granted != PRINTER_ACCESS_ADMINISTER) 
+	if (Printer->access_granted != PRINTER_ACCESS_ADMINISTER)
 	{
 		DEBUG(3, ("_spoolss_setprinterdata: change denied by handle access permissions\n"));
 		status = WERR_ACCESS_DENIED;
@@ -8243,22 +8243,22 @@ WERROR _spoolss_setprinterdata( pipes_struct *p, SPOOL_Q_SETPRINTERDATA *q_u, SP
 		return status;
 
 	unistr2_to_ascii(valuename, value, sizeof(valuename));
-	
+
 	/*
 	 * When client side code sets a magic printer data key, detect it and save
 	 * the current printer data and the magic key's data (its the DEVMODE) for
 	 * future printer/driver initializations.
 	 */
-	if ( (type == REG_BINARY) && strequal( valuename, PHANTOM_DEVMODE_KEY)) 
+	if ( (type == REG_BINARY) && strequal( valuename, PHANTOM_DEVMODE_KEY))
 	{
 		/* Set devmode and printer initialization info */
 		status = save_driver_init( printer, 2, data, real_len );
-	
+
 		srv_spoolss_reset_printerdata( printer->info_2->drivername );
 	}
-	else 
+	else
 	{
-	status = set_printer_dataex( printer, SPOOL_PRINTERDATA_KEY, valuename, 
+	status = set_printer_dataex( printer, SPOOL_PRINTERDATA_KEY, valuename,
 					type, data, real_len );
 		if ( W_ERROR_IS_OK(status) )
 			status = mod_a_printer(printer, 2);
@@ -8278,7 +8278,7 @@ WERROR _spoolss_resetprinter(pipes_struct *p, SPOOL_Q_RESETPRINTER *q_u, SPOOL_R
 	POLICY_HND 	*handle = &q_u->handle;
 	Printer_entry 	*Printer=find_printer_index_by_hnd(p, handle);
 	int 		snum;
-	
+
 	DEBUG(5,("_spoolss_resetprinter\n"));
 
 	/*
@@ -8286,7 +8286,7 @@ WERROR _spoolss_resetprinter(pipes_struct *p, SPOOL_Q_RESETPRINTER *q_u, SPOOL_R
 	 * This call really doesn't mean anything to us because we only
 	 * support RAW printing.   --jerry
 	 */
-	 
+
 	if (!Printer) {
 		DEBUG(2,("_spoolss_resetprinter: Invalid handle (%s:%u:%u).\n", OUR_HANDLE(handle)));
 		return WERR_BADFID;
@@ -8296,7 +8296,7 @@ WERROR _spoolss_resetprinter(pipes_struct *p, SPOOL_Q_RESETPRINTER *q_u, SPOOL_R
 		return WERR_BADFID;
 
 
-	/* blindly return success */	
+	/* blindly return success */
 	return WERR_OK;
 }
 
@@ -8314,9 +8314,9 @@ WERROR _spoolss_deleteprinterdata(pipes_struct *p, SPOOL_Q_DELETEPRINTERDATA *q_
 	WERROR 		status = WERR_OK;
 	Printer_entry 	*Printer=find_printer_index_by_hnd(p, handle);
 	pstring		valuename;
-	
+
 	DEBUG(5,("spoolss_deleteprinterdata\n"));
-	
+
 	if (!Printer) {
 		DEBUG(2,("_spoolss_deleteprinterdata: Invalid handle (%s:%u:%u).\n", OUR_HANDLE(handle)));
 		return WERR_BADFID;
@@ -8337,7 +8337,7 @@ WERROR _spoolss_deleteprinterdata(pipes_struct *p, SPOOL_Q_DELETEPRINTERDATA *q_
 	unistr2_to_ascii(valuename, value, sizeof(valuename));
 
 	status = delete_printer_dataex( printer, SPOOL_PRINTERDATA_KEY, valuename );
-	
+
 	if ( W_ERROR_IS_OK(status) )
 		mod_a_printer( printer, 2 );
 
@@ -8368,15 +8368,15 @@ WERROR _spoolss_addform( pipes_struct *p, SPOOL_Q_ADDFORM *q_u, SPOOL_R_ADDFORM
 		DEBUG(2,("_spoolss_addform: Invalid handle (%s:%u:%u).\n", OUR_HANDLE(handle)));
 		return WERR_BADFID;
 	}
-	
-	
+
+
 	/* forms can be added on printer of on the print server handle */
-	
+
 	if ( Printer->printer_type == SPLHND_PRINTER )
 	{
 		if (!get_printer_snum(p,handle, &snum, NULL))
 	                return WERR_BADFID;
-	 
+
 		status = get_a_printer(Printer, &printer, 2, lp_const_servicename(snum));
         	if (!W_ERROR_IS_OK(status))
 			goto done;
@@ -8387,30 +8387,30 @@ WERROR _spoolss_addform( pipes_struct *p, SPOOL_Q_ADDFORM *q_u, SPOOL_R_ADDFORM
 		status = WERR_ACCESS_DENIED;
 		goto done;
 	}
-	
+
 	/* can't add if builtin */
-	
+
 	if (get_a_builtin_ntform(&form->name,&tmpForm)) {
 		status = WERR_ALREADY_EXISTS;
 		goto done;
 	}
 
 	count = get_ntforms(&list);
-	
+
 	if(!add_a_form(&list, form, &count)) {
 		status =  WERR_NOMEM;
 		goto done;
 	}
-	
+
 	write_ntforms(&list, count);
-	
+
 	/*
 	 * ChangeID must always be set if this is a printer
 	 */
-	 
+
 	if ( Printer->printer_type == SPLHND_PRINTER )
 		status = mod_a_printer(printer, 2);
-	
+
 done:
 	if ( printer )
 		free_a_printer(&printer, 2);
@@ -8442,12 +8442,12 @@ WERROR _spoolss_deleteform( pipes_struct *p, SPOOL_Q_DELETEFORM *q_u, SPOOL_R_DE
 	}
 
 	/* forms can be deleted on printer of on the print server handle */
-	
+
 	if ( Printer->printer_type == SPLHND_PRINTER )
 	{
 		if (!get_printer_snum(p,handle, &snum, NULL))
 	                return WERR_BADFID;
-	 
+
 		status = get_a_printer(Printer, &printer, 2, lp_const_servicename(snum));
         	if (!W_ERROR_IS_OK(status))
 			goto done;
@@ -8460,24 +8460,24 @@ WERROR _spoolss_deleteform( pipes_struct *p, SPOOL_Q_DELETEFORM *q_u, SPOOL_R_DE
 	}
 
 	/* can't delete if builtin */
-	
+
 	if (get_a_builtin_ntform(form_name,&tmpForm)) {
 		status = WERR_INVALID_PARAM;
 		goto done;
 	}
 
 	count = get_ntforms(&list);
-	
+
 	if ( !delete_a_form(&list, form_name, &count, &status ))
 		goto done;
 
 	/*
 	 * ChangeID must always be set if this is a printer
 	 */
-	 
+
 	if ( Printer->printer_type == SPLHND_PRINTER )
 		status = mod_a_printer(printer, 2);
-	
+
 done:
 	if ( printer )
 		free_a_printer(&printer, 2);
@@ -8510,12 +8510,12 @@ WERROR _spoolss_setform(pipes_struct *p, SPOOL_Q_SETFORM *q_u, SPOOL_R_SETFORM *
 	}
 
 	/* forms can be modified on printer of on the print server handle */
-	
+
 	if ( Printer->printer_type == SPLHND_PRINTER )
 	{
 		if (!get_printer_snum(p,handle, &snum, NULL))
 	                return WERR_BADFID;
-	 
+
 		status = get_a_printer(Printer, &printer, 2, lp_const_servicename(snum));
         	if (!W_ERROR_IS_OK(status))
 			goto done;
@@ -8540,11 +8540,11 @@ WERROR _spoolss_setform(pipes_struct *p, SPOOL_Q_SETFORM *q_u, SPOOL_R_SETFORM *
 	/*
 	 * ChangeID must always be set if this is a printer
 	 */
-	 
+
 	if ( Printer->printer_type == SPLHND_PRINTER )
 		status = mod_a_printer(printer, 2);
-	
-	
+
+
 done:
 	if ( printer )
 		free_a_printer(&printer, 2);
@@ -8561,12 +8561,12 @@ static WERROR enumprintprocessors_level_1(RPC_BUFFER *buffer, uint32 offered, ui
 {
 	PRINTPROCESSOR_1 *info_1=NULL;
 	WERROR result = WERR_OK;
-	
+
 	if((info_1 = SMB_MALLOC_P(PRINTPROCESSOR_1)) == NULL)
 		return WERR_NOMEM;
 
 	(*returned) = 0x1;
-	
+
 	init_unistr(&info_1->name, "winprint");
 
 	*needed += spoolss_size_printprocessor_info_1(info_1);
@@ -8620,10 +8620,10 @@ WERROR _spoolss_enumprintprocessors(pipes_struct *p, SPOOL_Q_ENUMPRINTPROCESSORS
 	 * Just reply with "winprint", to keep NT happy
 	 * and I can use my nice printer checker.
 	 */
-	
+
 	*returned=0;
 	*needed=0;
-	
+
 	switch (level) {
 	case 1:
 		return enumprintprocessors_level_1(buffer, offered, needed, returned);
@@ -8640,12 +8640,12 @@ static WERROR enumprintprocdatatypes_level_1(RPC_BUFFER *buffer, uint32 offered,
 {
 	PRINTPROCDATATYPE_1 *info_1=NULL;
 	WERROR result = WERR_OK;
-	
+
 	if((info_1 = SMB_MALLOC_P(PRINTPROCDATATYPE_1)) == NULL)
 		return WERR_NOMEM;
 
 	(*returned) = 0x1;
-	
+
 	init_unistr(&info_1->name, "RAW");
 
 	*needed += spoolss_size_printprocdatatype_info_1(info_1);
@@ -8692,10 +8692,10 @@ WERROR _spoolss_enumprintprocdatatypes(pipes_struct *p, SPOOL_Q_ENUMPRINTPROCDAT
 	buffer = r_u->buffer;
 
  	DEBUG(5,("_spoolss_enumprintprocdatatypes\n"));
-	
+
 	*returned=0;
 	*needed=0;
-	
+
 	switch (level) {
 	case 1:
 		return enumprintprocdatatypes_level_1(buffer, offered, needed, returned);
@@ -8713,19 +8713,19 @@ static WERROR enumprintmonitors_level_1(RPC_BUFFER *buffer, uint32 offered, uint
 	PRINTMONITOR_1 *info_1;
 	WERROR result = WERR_OK;
 	int i;
-	
+
 	if((info_1 = SMB_MALLOC_ARRAY(PRINTMONITOR_1, 2)) == NULL)
 		return WERR_NOMEM;
 
 	*returned = 2;
-	
-	init_unistr(&(info_1[0].name), SPL_LOCAL_PORT ); 
+
+	init_unistr(&(info_1[0].name), SPL_LOCAL_PORT );
 	init_unistr(&(info_1[1].name), SPL_TCPIP_PORT );
 
 	for ( i=0; i<*returned; i++ ) {
 		*needed += spoolss_size_printmonitor_info_1(&info_1[i]);
 	}
-	
+
 	if (*needed > offered) {
 		result = WERR_INSUFFICIENT_BUFFER;
 		goto out;
@@ -8758,16 +8758,16 @@ static WERROR enumprintmonitors_level_2(RPC_BUFFER *buffer, uint32 offered, uint
 	PRINTMONITOR_2 *info_2;
 	WERROR result = WERR_OK;
 	int i;
-	
+
 	if((info_2 = SMB_MALLOC_ARRAY(PRINTMONITOR_2, 2)) == NULL)
 		return WERR_NOMEM;
 
 	*returned = 2;
-	
+
 	init_unistr( &(info_2[0].name), SPL_LOCAL_PORT );
 	init_unistr( &(info_2[0].environment), "Windows NT X86" );
 	init_unistr( &(info_2[0].dll_name), "localmon.dll" );
-	
+
 	init_unistr( &(info_2[1].name), SPL_TCPIP_PORT );
 	init_unistr( &(info_2[1].environment), "Windows NT X86" );
 	init_unistr( &(info_2[1].dll_name), "tcpmon.dll" );
@@ -8775,7 +8775,7 @@ static WERROR enumprintmonitors_level_2(RPC_BUFFER *buffer, uint32 offered, uint
 	for ( i=0; i<*returned; i++ ) {
 		*needed += spoolss_size_printmonitor_info_2(&info_2[i]);
 	}
-	
+
 	if (*needed > offered) {
 		result = WERR_INSUFFICIENT_BUFFER;
 		goto out;
@@ -8795,7 +8795,7 @@ out:
 
 	if ( !W_ERROR_IS_OK(result) )
 		*returned = 0;
-	
+
 	return result;
 }
 
@@ -8827,10 +8827,10 @@ WERROR _spoolss_enumprintmonitors(pipes_struct *p, SPOOL_Q_ENUMPRINTMONITORS *q_
 	 * Just reply with "Local Port", to keep NT happy
 	 * and I can use my nice printer checker.
 	 */
-	
+
 	*returned=0;
 	*needed=0;
-	
+
 	switch (level) {
 	case 1:
 		return enumprintmonitors_level_1(buffer, offered, needed, returned);
@@ -8846,7 +8846,7 @@ WERROR _spoolss_enumprintmonitors(pipes_struct *p, SPOOL_Q_ENUMPRINTMONITORS *q_
 
 static WERROR getjob_level_1(print_queue_struct **queue, int count, int snum,
                              NT_PRINTER_INFO_LEVEL *ntprinter,
-                             uint32 jobid, RPC_BUFFER *buffer, uint32 offered, 
+                             uint32 jobid, RPC_BUFFER *buffer, uint32 offered,
 			     uint32 *needed)
 {
 	int i=0;
@@ -8859,20 +8859,20 @@ static WERROR getjob_level_1(print_queue_struct **queue, int count, int snum,
 	if (info_1 == NULL) {
 		return WERR_NOMEM;
 	}
-		
-	for (i=0; i<count && found==False; i++) { 
+
+	for (i=0; i<count && found==False; i++) {
 		if ((*queue)[i].job==(int)jobid)
 			found=True;
 	}
-	
+
 	if (found==False) {
 		SAFE_FREE(info_1);
 		/* NT treats not found as bad param... yet another bad choice */
 		return WERR_INVALID_PARAM;
 	}
-	
+
 	fill_job_info_1( info_1, &((*queue)[i-1]), i, snum, ntprinter );
-	
+
 	*needed += spoolss_size_job_info_1(info_1);
 
 	if (*needed > offered) {
@@ -8896,9 +8896,9 @@ out:
 /****************************************************************************
 ****************************************************************************/
 
-static WERROR getjob_level_2(print_queue_struct **queue, int count, int snum, 
+static WERROR getjob_level_2(print_queue_struct **queue, int count, int snum,
                              NT_PRINTER_INFO_LEVEL *ntprinter,
-                             uint32 jobid, RPC_BUFFER *buffer, uint32 offered, 
+                             uint32 jobid, RPC_BUFFER *buffer, uint32 offered,
 			     uint32 *needed)
 {
 	int 		i = 0;
@@ -8913,25 +8913,25 @@ static WERROR getjob_level_2(print_queue_struct **queue, int count, int snum,
 
 	ZERO_STRUCTP(info_2);
 
-	for ( i=0; i<count && found==False; i++ ) 
+	for ( i=0; i<count && found==False; i++ )
 	{
 		if ((*queue)[i].job == (int)jobid)
 			found = True;
 	}
-	
+
 	if ( !found ) {
 		/* NT treats not found as bad param... yet another bad
 		   choice */
 		result = WERR_INVALID_PARAM;
 		goto done;
 	}
-	
-	/* 
-	 * if the print job does not have a DEVMODE associated with it, 
+
+	/*
+	 * if the print job does not have a DEVMODE associated with it,
 	 * just use the one for the printer. A NULL devicemode is not
 	 *  a failure condition
 	 */
-	 
+
 	if ( !(nt_devmode=print_job_devmode( lp_const_servicename(snum), jobid )) )
 		devmode = construct_dev_mode(lp_const_servicename(snum));
 	else {
@@ -8940,9 +8940,9 @@ static WERROR getjob_level_2(print_queue_struct **queue, int count, int snum,
 			convert_nt_devicemode( devmode, nt_devmode );
 		}
 	}
-	
+
 	fill_job_info_2(info_2, &((*queue)[i-1]), i, snum, ntprinter, devmode);
-	
+
 	*needed += spoolss_size_job_info_2(info_2);
 
 	if (*needed > offered) {
@@ -8958,7 +8958,7 @@ static WERROR getjob_level_2(print_queue_struct **queue, int count, int snum,
 	smb_io_job_info_2("", buffer, info_2, 0);
 
 	result = WERR_OK;
-	
+
  done:
 	/* Cleanup allocated memory */
 
@@ -8996,44 +8996,44 @@ WERROR _spoolss_getjob( pipes_struct *p, SPOOL_Q_GETJOB *q_u, SPOOL_R_GETJOB *r_
 	buffer = r_u->buffer;
 
 	DEBUG(5,("spoolss_getjob\n"));
-	
+
 	*needed = 0;
-	
+
 	if (!get_printer_snum(p, handle, &snum, NULL))
 		return WERR_BADFID;
-	
+
 	wstatus = get_a_printer(NULL, &ntprinter, 2, lp_servicename(snum));
 	if ( !W_ERROR_IS_OK(wstatus) )
 		return wstatus;
-		
+
 	count = print_queue_status(snum, &queue, &prt_status);
-	
+
 	DEBUGADD(4,("count:[%d], prt_status:[%d], [%s]\n",
 	             count, prt_status.status, prt_status.message));
-		
+
 	switch ( level ) {
 	case 1:
-			wstatus = getjob_level_1(&queue, count, snum, ntprinter, jobid, 
+			wstatus = getjob_level_1(&queue, count, snum, ntprinter, jobid,
 				buffer, offered, needed);
 			break;
 	case 2:
-			wstatus = getjob_level_2(&queue, count, snum, ntprinter, jobid, 
+			wstatus = getjob_level_2(&queue, count, snum, ntprinter, jobid,
 				buffer, offered, needed);
 			break;
 	default:
 			wstatus = WERR_UNKNOWN_LEVEL;
 			break;
 	}
-	
+
 	SAFE_FREE(queue);
 	free_a_printer( &ntprinter, 2 );
-	
+
 	return wstatus;
 }
 
 /********************************************************************
  spoolss_getprinterdataex
- 
+
  From MSDN documentation of GetPrinterDataEx: pass request
  to GetPrinterData if key is "PrinterDriverData".
  ********************************************************************/
@@ -9047,9 +9047,9 @@ WERROR _spoolss_getprinterdataex(pipes_struct *p, SPOOL_Q_GETPRINTERDATAEX *q_u,
 	uint8 		**data = &r_u->data;
 	uint32 		*needed = &r_u->needed;
 	fstring 	keyname, valuename;
-	
+
 	Printer_entry 	*Printer = find_printer_index_by_hnd(p, handle);
-	
+
 	NT_PRINTER_INFO_LEVEL 	*printer = NULL;
 	int 			snum = 0;
 	WERROR 			status = WERR_OK;
@@ -9058,12 +9058,12 @@ WERROR _spoolss_getprinterdataex(pipes_struct *p, SPOOL_Q_GETPRINTERDATAEX *q_u,
 
         unistr2_to_ascii(keyname, &q_u->keyname, sizeof(keyname));
         unistr2_to_ascii(valuename, &q_u->valuename, sizeof(valuename));
-	
-	DEBUG(10, ("_spoolss_getprinterdataex: key => [%s], value => [%s]\n", 
+
+	DEBUG(10, ("_spoolss_getprinterdataex: key => [%s], value => [%s]\n",
 		keyname, valuename));
 
 	/* in case of problem, return some default values */
-	
+
 	*needed   = 0;
 	*type     = 0;
 	*out_size = in_size;
@@ -9081,7 +9081,7 @@ WERROR _spoolss_getprinterdataex(pipes_struct *p, SPOOL_Q_GETPRINTERDATAEX *q_u,
 		status = WERR_INVALID_PARAM;
 		goto done;
 	}
-	
+
 	if ( !get_printer_snum(p,handle, &snum, NULL) )
 		return WERR_BADFID;
 
@@ -9094,29 +9094,29 @@ WERROR _spoolss_getprinterdataex(pipes_struct *p, SPOOL_Q_GETPRINTERDATAEX *q_u,
 		status = WERR_INVALID_PARAM;
 		goto done;
 	}
-	
+
 	if ( lookup_printerkey( printer->info_2->data, keyname ) == -1 ) {
 		DEBUG(4,("_spoolss_getprinterdataex: Invalid keyname [%s]\n", keyname ));
 		free_a_printer( &printer, 2 );
 		status = WERR_BADFILE;
 		goto done;
 	}
-	
+
 	/* When given a new keyname, we should just create it */
 
 	status = get_printer_dataex( p->mem_ctx, printer, keyname, valuename, type, data, needed, in_size );
-	
+
 	if (*needed > *out_size)
 		status = WERR_MORE_DATA;
 
 done:
-	if ( !W_ERROR_IS_OK(status) ) 
+	if ( !W_ERROR_IS_OK(status) )
 	{
 		DEBUG(5, ("error: allocating %d\n", *out_size));
-		
+
 		/* reply this param doesn't exist */
-		
-		if ( *out_size ) 
+
+		if ( *out_size )
 		{
 			if( (*data=(uint8 *)TALLOC_ZERO(p->mem_ctx, *out_size*sizeof(uint8))) == NULL ) {
 				status = WERR_NOMEM;
@@ -9126,10 +9126,10 @@ done:
 			*data = NULL;
 		}
 	}
-	
+
 	if ( printer )
 	free_a_printer( &printer, 2 );
-	
+
 	return status;
 }
 
@@ -9139,7 +9139,7 @@ done:
 
 WERROR _spoolss_setprinterdataex(pipes_struct *p, SPOOL_Q_SETPRINTERDATAEX *q_u, SPOOL_R_SETPRINTERDATAEX *r_u)
 {
-	POLICY_HND 		*handle = &q_u->handle; 
+	POLICY_HND 		*handle = &q_u->handle;
 	uint32 			type = q_u->type;
 	uint8 			*data = q_u->data;
 	uint32 			real_len = q_u->real_len;
@@ -9151,7 +9151,7 @@ WERROR _spoolss_setprinterdataex(pipes_struct *p, SPOOL_Q_SETPRINTERDATAEX *q_u,
 	fstring			valuename;
 	fstring			keyname;
 	char			*oid_string;
-	
+
 	DEBUG(4,("_spoolss_setprinterdataex\n"));
 
         /* From MSDN documentation of SetPrinterDataEx: pass request to
@@ -9170,15 +9170,15 @@ WERROR _spoolss_setprinterdataex(pipes_struct *p, SPOOL_Q_SETPRINTERDATAEX *q_u,
 	if ( !get_printer_snum(p,handle, &snum, NULL) )
 		return WERR_BADFID;
 
-	/* 
-	 * Access check : NT returns "access denied" if you make a 
+	/*
+	 * Access check : NT returns "access denied" if you make a
 	 * SetPrinterData call without the necessary privildge.
 	 * we were originally returning OK if nothing changed
 	 * which made Win2k issue **a lot** of SetPrinterData
 	 * when connecting to a printer  --jerry
 	 */
 
-	if (Printer->access_granted != PRINTER_ACCESS_ADMINISTER) 
+	if (Printer->access_granted != PRINTER_ACCESS_ADMINISTER)
 	{
 		DEBUG(3, ("_spoolss_setprinterdataex: change denied by handle access permissions\n"));
 		return WERR_ACCESS_DENIED;
@@ -9190,9 +9190,9 @@ WERROR _spoolss_setprinterdataex(pipes_struct *p, SPOOL_Q_SETPRINTERDATAEX *q_u,
 
         unistr2_to_ascii( valuename, &q_u->value, sizeof(valuename));
         unistr2_to_ascii( keyname, &q_u->key, sizeof(keyname));
-	
+
 	/* check for OID in valuename */
-	
+
 	if ( (oid_string = strchr( valuename, ',' )) != NULL )
 	{
 		*oid_string = '\0';
@@ -9200,31 +9200,31 @@ WERROR _spoolss_setprinterdataex(pipes_struct *p, SPOOL_Q_SETPRINTERDATAEX *q_u,
 	}
 
 	/* save the registry data */
-	
-	status = set_printer_dataex( printer, keyname, valuename, type, data, real_len ); 
-	
+
+	status = set_printer_dataex( printer, keyname, valuename, type, data, real_len );
+
 	if ( W_ERROR_IS_OK(status) )
 	{
 		/* save the OID if one was specified */
 		if ( oid_string ) {
 			fstrcat( keyname, "\\" );
 			fstrcat( keyname, SPOOL_OID_KEY );
-		
-			/* 
-			 * I'm not checking the status here on purpose.  Don't know 
-			 * if this is right, but I'm returning the status from the 
-			 * previous set_printer_dataex() call.  I have no idea if 
+
+			/*
+			 * I'm not checking the status here on purpose.  Don't know
+			 * if this is right, but I'm returning the status from the
+			 * previous set_printer_dataex() call.  I have no idea if
 			 * this is right.    --jerry
 			 */
-		 
-			set_printer_dataex( printer, keyname, valuename, 
+
+			set_printer_dataex( printer, keyname, valuename,
 			                    REG_SZ, (uint8 *)oid_string,
 					    strlen(oid_string)+1 );
 		}
-	
+
 		status = mod_a_printer(printer, 2);
 	}
-		
+
 	free_a_printer(&printer, 2);
 
 	return status;
@@ -9246,9 +9246,9 @@ WERROR _spoolss_deleteprinterdataex(pipes_struct *p, SPOOL_Q_DELETEPRINTERDATAEX
 	WERROR 		status = WERR_OK;
 	Printer_entry 	*Printer=find_printer_index_by_hnd(p, handle);
 	pstring		valuename, keyname;
-	
+
 	DEBUG(5,("spoolss_deleteprinterdataex\n"));
-	
+
 	if (!Printer) {
 		DEBUG(2,("_spoolss_deleteprinterdata: Invalid handle (%s:%u:%u).\n", OUR_HANDLE(handle)));
 		return WERR_BADFID;
@@ -9273,7 +9273,7 @@ WERROR _spoolss_deleteprinterdataex(pipes_struct *p, SPOOL_Q_DELETEPRINTERDATAEX
 
 	if ( W_ERROR_IS_OK(status) )
 		mod_a_printer( printer, 2 );
-		
+
 	free_a_printer(&printer, 2);
 
 	return status;
@@ -9297,8 +9297,8 @@ WERROR _spoolss_enumprinterkey(pipes_struct *p, SPOOL_Q_ENUMPRINTERKEY *q_u, SPO
 	NT_PRINTER_INFO_LEVEL 	*printer = NULL;
 	int 		snum = 0;
 	WERROR		status = WERR_BADFILE;
-	
-	
+
+
 	DEBUG(4,("_spoolss_enumprinterkey\n"));
 
 	if (!Printer) {
@@ -9312,9 +9312,9 @@ WERROR _spoolss_enumprinterkey(pipes_struct *p, SPOOL_Q_ENUMPRINTERKEY *q_u, SPO
 	status = get_a_printer(Printer, &printer, 2, lp_const_servicename(snum));
 	if (!W_ERROR_IS_OK(status))
 		return status;
-		
+
 	/* get the list of subkey names */
-	
+
 	unistr2_to_ascii(key, &q_u->key, sizeof(key));
 	data = printer->info_2->data;
 
@@ -9338,16 +9338,16 @@ WERROR _spoolss_enumprinterkey(pipes_struct *p, SPOOL_Q_ENUMPRINTERKEY *q_u, SPO
 		status = WERR_NOMEM;
 		goto done;
 	}
-			
+
 	status = WERR_OK;
 
-	if ( q_u->size < r_u->needed ) 
+	if ( q_u->size < r_u->needed )
 		status = WERR_MORE_DATA;
 
 done:
 	free_a_printer( &printer, 2 );
 	SAFE_FREE( keynames );
-	
+
         return status;
 }
 
@@ -9363,19 +9363,19 @@ WERROR _spoolss_deleteprinterkey(pipes_struct *p, SPOOL_Q_DELETEPRINTERKEY *q_u,
 	NT_PRINTER_INFO_LEVEL 	*printer = NULL;
 	int 			snum=0;
 	WERROR			status;
-	
+
 	DEBUG(5,("spoolss_deleteprinterkey\n"));
-	
+
 	if (!Printer) {
 		DEBUG(2,("_spoolss_deleteprinterkey: Invalid handle (%s:%u:%u).\n", OUR_HANDLE(handle)));
 		return WERR_BADFID;
 	}
 
 	/* if keyname == NULL, return error */
-	
+
 	if ( !q_u->keyname.buffer )
 		return WERR_INVALID_PARAM;
-		
+
 	if (!get_printer_snum(p, handle, &snum, NULL))
 		return WERR_BADFID;
 
@@ -9387,18 +9387,18 @@ WERROR _spoolss_deleteprinterkey(pipes_struct *p, SPOOL_Q_DELETEPRINTERKEY *q_u,
 	status = get_a_printer(Printer, &printer, 2, lp_const_servicename(snum));
 	if (!W_ERROR_IS_OK(status))
 		return status;
-	
+
 	/* delete the key and all subneys */
-	
+
         unistr2_to_ascii(key, &q_u->keyname, sizeof(key));
- 
-	status = delete_all_printer_data( printer->info_2, key );	
+
+	status = delete_all_printer_data( printer->info_2, key );
 
 	if ( W_ERROR_IS_OK(status) )
 		status = mod_a_printer(printer, 2);
-	
+
 	free_a_printer( &printer, 2 );
-	
+
 	return status;
 }
 
@@ -9409,9 +9409,9 @@ WERROR _spoolss_deleteprinterkey(pipes_struct *p, SPOOL_Q_DELETEPRINTERKEY *q_u,
 
 WERROR _spoolss_enumprinterdataex(pipes_struct *p, SPOOL_Q_ENUMPRINTERDATAEX *q_u, SPOOL_R_ENUMPRINTERDATAEX *r_u)
 {
-	POLICY_HND	*handle = &q_u->handle; 
+	POLICY_HND	*handle = &q_u->handle;
 	uint32 		in_size = q_u->size;
-	uint32 		num_entries, 
+	uint32 		num_entries,
 			needed;
 	NT_PRINTER_INFO_LEVEL 	*printer = NULL;
 	PRINTER_ENUM_VALUES	*enum_values = NULL;
@@ -9425,7 +9425,7 @@ WERROR _spoolss_enumprinterdataex(pipes_struct *p, SPOOL_Q_ENUMPRINTERDATAEX *q_
 	REGISTRY_VALUE	*val;
 	char		*value_name;
 	uint32		data_len;
-	
+
 
 	DEBUG(4,("_spoolss_enumprinterdataex\n"));
 
@@ -9434,13 +9434,13 @@ WERROR _spoolss_enumprinterdataex(pipes_struct *p, SPOOL_Q_ENUMPRINTERDATAEX *q_
 		return WERR_BADFID;
 	}
 
-	/* 
-	 * first check for a keyname of NULL or "".  Win2k seems to send 
+	/*
+	 * first check for a keyname of NULL or "".  Win2k seems to send
 	 * this a lot and we should send back WERR_INVALID_PARAM
 	 * no need to spend time looking up the printer in this case.
 	 * --jerry
 	 */
-	 
+
 	unistr2_to_ascii(key, &q_u->key, sizeof(key));
 	if ( !strlen(key) ) {
 		result = WERR_INVALID_PARAM;
@@ -9448,19 +9448,19 @@ WERROR _spoolss_enumprinterdataex(pipes_struct *p, SPOOL_Q_ENUMPRINTERDATAEX *q_
 	}
 
 	/* get the printer off of disk */
-	
+
 	if (!get_printer_snum(p,handle, &snum, NULL))
 		return WERR_BADFID;
-	
+
 	ZERO_STRUCT(printer);
 	result = get_a_printer(Printer, &printer, 2, lp_const_servicename(snum));
 	if (!W_ERROR_IS_OK(result))
 		return result;
-	
+
 	/* now look for a match on the key name */
-	
+
 	p_data = printer->info_2->data;
-	
+
 	unistr2_to_ascii(key, &q_u->key, sizeof(key));
 	if ( (key_index = lookup_printerkey( p_data, key)) == -1  )
 	{
@@ -9468,12 +9468,12 @@ WERROR _spoolss_enumprinterdataex(pipes_struct *p, SPOOL_Q_ENUMPRINTERDATAEX *q_
 		result = WERR_INVALID_PARAM;
 		goto done;
 	}
-	
+
 	result = WERR_OK;
 	needed = 0;
-	
+
 	/* allocate the memory for the array of pointers -- if necessary */
-	
+
 	num_entries = regval_ctr_numvals( p_data->keys[key_index].values );
 	if ( num_entries )
 	{
@@ -9487,31 +9487,31 @@ WERROR _spoolss_enumprinterdataex(pipes_struct *p, SPOOL_Q_ENUMPRINTERDATAEX *q_
 
 		memset( enum_values, 0x0, num_entries*sizeof(PRINTER_ENUM_VALUES) );
 	}
-		
-	/* 
-	 * loop through all params and build the array to pass 
-	 * back to the  client 
+
+	/*
+	 * loop through all params and build the array to pass
+	 * back to the  client
 	 */
-	 
+
 	for ( i=0; i<num_entries; i++ )
 	{
 		/* lookup the registry value */
-		
+
 		val = regval_ctr_specific_value( p_data->keys[key_index].values, i );
 		DEBUG(10,("retrieved value number [%d] [%s]\n", i, regval_name(val) ));
 
 		/* copy the data */
-		
+
 		value_name = regval_name( val );
 		init_unistr( &enum_values[i].valuename, value_name );
 		enum_values[i].value_len = (strlen(value_name)+1) * 2;
 		enum_values[i].type      = regval_type( val );
-		
+
 		data_len = regval_size( val );
 		if ( data_len ) {
-			if ( !(enum_values[i].data = (uint8 *)TALLOC_MEMDUP(p->mem_ctx, regval_data_p(val), data_len)) ) 
+			if ( !(enum_values[i].data = (uint8 *)TALLOC_MEMDUP(p->mem_ctx, regval_data_p(val), data_len)) )
 			{
-				DEBUG(0,("TALLOC_MEMDUP failed to allocate memory [data_len=%d] for data!\n", 
+				DEBUG(0,("TALLOC_MEMDUP failed to allocate memory [data_len=%d] for data!\n",
 					data_len ));
 				result = WERR_NOMEM;
 				goto done;
@@ -9520,12 +9520,12 @@ WERROR _spoolss_enumprinterdataex(pipes_struct *p, SPOOL_Q_ENUMPRINTERDATAEX *q_
 		enum_values[i].data_len = data_len;
 
 		/* keep track of the size of the array in bytes */
-		
+
 		needed += spoolss_size_printer_enum_values(&enum_values[i]);
 	}
-	
+
 	/* housekeeping information in the reply */
-	
+
 	/* Fix from Martin Zielinski <mz@seh.de> - ensure
 	 * the hand marshalled container size is a multiple
 	 * of 4 bytes for RPC alignment.
@@ -9542,17 +9542,17 @@ WERROR _spoolss_enumprinterdataex(pipes_struct *p, SPOOL_Q_ENUMPRINTERDATAEX *q_
 		result = WERR_MORE_DATA;
 		goto done;
 	}
-		
+
 	/* copy data into the reply */
-	
+
 	r_u->ctr.size        	= r_u->needed;
 
 	r_u->ctr.size_of_array 	= r_u->returned;
 	r_u->ctr.values 	= enum_values;
-	
-	
-		
-done:	
+
+
+
+done:
 	if ( printer )
 	free_a_printer(&printer, 2);
 
@@ -9567,10 +9567,10 @@ static void fill_printprocessordirectory_1(PRINTPROCESSOR_DIRECTORY_1 *info, cha
 	init_unistr(&info->name, name);
 }
 
-static WERROR getprintprocessordirectory_level_1(UNISTR2 *name, 
-						 UNISTR2 *environment, 
-						 RPC_BUFFER *buffer, 
-						 uint32 offered, 
+static WERROR getprintprocessordirectory_level_1(UNISTR2 *name,
+						 UNISTR2 *environment,
+						 RPC_BUFFER *buffer,
+						 uint32 offered,
 						 uint32 *needed)
 {
 	pstring path;
@@ -9589,7 +9589,7 @@ static WERROR getprintprocessordirectory_level_1(UNISTR2 *name,
 	pstrcpy(path, "C:\\WINNT\\System32\\spool\\PRTPROCS\\W32X86");
 
 	fill_printprocessordirectory_1(info, path);
-	
+
 	*needed += spoolss_size_printprocessordirectory_info_1(info);
 
 	if (*needed > offered) {
@@ -9606,7 +9606,7 @@ static WERROR getprintprocessordirectory_level_1(UNISTR2 *name,
 
 out:
 	SAFE_FREE(info);
-	
+
 	return result;
 }
 
@@ -9628,7 +9628,7 @@ WERROR _spoolss_getprintprocessordirectory(pipes_struct *p, SPOOL_Q_GETPRINTPROC
 	buffer = r_u->buffer;
 
  	DEBUG(5,("_spoolss_getprintprocessordirectory\n"));
-	
+
 	*needed=0;
 
 	switch(level) {
@@ -9647,21 +9647,21 @@ WERROR _spoolss_getprintprocessordirectory(pipes_struct *p, SPOOL_Q_GETPRINTPROC
  Streams the monitor UI DLL name in UNICODE
 *******************************************************************/
 
-static WERROR xcvtcp_monitorui( NT_USER_TOKEN *token, RPC_BUFFER *in, 
+static WERROR xcvtcp_monitorui( NT_USER_TOKEN *token, RPC_BUFFER *in,
                                 RPC_BUFFER *out, uint32 *needed )
 {
 	const char *dllname = "tcpmonui.dll";
-	
+
 	*needed = (strlen(dllname)+1) * 2;
-	
+
 	if ( rpcbuf_get_size(out) < *needed ) {
-		return WERR_INSUFFICIENT_BUFFER;		
+		return WERR_INSUFFICIENT_BUFFER;
 	}
-	
+
 	if ( !make_monitorui_buf( out, dllname ) ) {
 		return WERR_NOMEM;
 	}
-	
+
 	return WERR_OK;
 }
 
@@ -9669,7 +9669,7 @@ static WERROR xcvtcp_monitorui( NT_USER_TOKEN *token, RPC_BUFFER *in,
  Create a new TCP/IP port
 *******************************************************************/
 
-static WERROR xcvtcp_addport( NT_USER_TOKEN *token, RPC_BUFFER *in, 
+static WERROR xcvtcp_addport( NT_USER_TOKEN *token, RPC_BUFFER *in,
                               RPC_BUFFER *out, uint32 *needed )
 {
 	NT_PORT_DATA_1 port1;
@@ -9693,7 +9693,7 @@ static WERROR xcvtcp_addport( NT_USER_TOKEN *token, RPC_BUFFER *in,
 	case PORT_PROTOCOL_LPR:
 		pstr_sprintf( device_uri, "lpr://%s/%s", port1.hostaddr, port1.queue );
 		break;
-	
+
 	default:
 		return WERR_UNKNOWN_PORT;
 	}
@@ -9710,19 +9710,19 @@ struct xcv_api_table xcvtcp_cmds[] = {
 	{ NULL,		NULL }
 };
 
-static WERROR process_xcvtcp_command( NT_USER_TOKEN *token, const char *command, 
-                                      RPC_BUFFER *inbuf, RPC_BUFFER *outbuf, 
+static WERROR process_xcvtcp_command( NT_USER_TOKEN *token, const char *command,
+                                      RPC_BUFFER *inbuf, RPC_BUFFER *outbuf,
                                       uint32 *needed )
 {
 	int i;
-	
+
 	DEBUG(10,("process_xcvtcp_command: Received command \"%s\"\n", command));
-	
+
 	for ( i=0; xcvtcp_cmds[i].name; i++ ) {
 		if ( strcmp( command, xcvtcp_cmds[i].name ) == 0 )
 			return xcvtcp_cmds[i].fn( token, inbuf, outbuf, needed );
 	}
-	
+
 	return WERR_BADFUNC;
 }
 
@@ -9730,21 +9730,21 @@ static WERROR process_xcvtcp_command( NT_USER_TOKEN *token, const char *command,
 *******************************************************************/
 #if 0 	/* don't support management using the "Local Port" monitor */
 
-static WERROR xcvlocal_monitorui( NT_USER_TOKEN *token, RPC_BUFFER *in, 
+static WERROR xcvlocal_monitorui( NT_USER_TOKEN *token, RPC_BUFFER *in,
                                   RPC_BUFFER *out, uint32 *needed )
 {
 	const char *dllname = "localui.dll";
-	
+
 	*needed = (strlen(dllname)+1) * 2;
-	
+
 	if ( rpcbuf_get_size(out) < *needed ) {
-		return WERR_INSUFFICIENT_BUFFER;		
+		return WERR_INSUFFICIENT_BUFFER;
 	}
-	
+
 	if ( !make_monitorui_buf( out, dllname )) {
 		return WERR_NOMEM;
 	}
-	
+
 	return WERR_OK;
 }
 
@@ -9766,12 +9766,12 @@ struct xcv_api_table xcvlocal_cmds[] = {
 /*******************************************************************
 *******************************************************************/
 
-static WERROR process_xcvlocal_command( NT_USER_TOKEN *token, const char *command, 
-                                        RPC_BUFFER *inbuf, RPC_BUFFER *outbuf, 
+static WERROR process_xcvlocal_command( NT_USER_TOKEN *token, const char *command,
+                                        RPC_BUFFER *inbuf, RPC_BUFFER *outbuf,
 					uint32 *needed )
 {
 	int i;
-	
+
 	DEBUG(10,("process_xcvlocal_command: Received command \"%s\"\n", command));
 
 	for ( i=0; xcvlocal_cmds[i].name; i++ ) {
@@ -9785,7 +9785,7 @@ static WERROR process_xcvlocal_command( NT_USER_TOKEN *token, const char *comman
 *******************************************************************/
 
 WERROR _spoolss_xcvdataport(pipes_struct *p, SPOOL_Q_XCVDATAPORT *q_u, SPOOL_R_XCVDATAPORT *r_u)
-{	
+{
 	Printer_entry *Printer = find_printer_index_by_hnd(p, &q_u->handle);
 	fstring command;
 
@@ -9795,39 +9795,37 @@ WERROR _spoolss_xcvdataport(pipes_struct *p, SPOOL_Q_XCVDATAPORT *q_u, SPOOL_R_X
 	}
 
 	/* Has to be a handle to the TCP/IP port monitor */
-	
+
 	if ( !(Printer->printer_type & (SPLHND_PORTMON_LOCAL|SPLHND_PORTMON_TCP)) ) {
 		DEBUG(2,("_spoolss_xcvdataport: Call only valid for Port Monitors\n"));
 		return WERR_BADFID;
 	}
-	
+
 	/* requires administrative access to the server */
-	
+
 	if ( !(Printer->access_granted & SERVER_ACCESS_ADMINISTER) ) {
 		DEBUG(2,("_spoolss_xcvdataport: denied by handle permissions.\n"));
 		return WERR_ACCESS_DENIED;
 	}
 
-	/* Get the command name.  There's numerous commands supported by the 
+	/* Get the command name.  There's numerous commands supported by the
 	   TCPMON interface. */
-	
-	rpcstr_pull(command, q_u->dataname.buffer, sizeof(command), 
+
+	rpcstr_pull(command, q_u->dataname.buffer, sizeof(command),
 		q_u->dataname.uni_str_len*2, 0);
-		
+
 	/* Allocate the outgoing buffer */
-	
+
 	rpcbuf_init( &r_u->outdata, q_u->offered, p->mem_ctx );
-	
+
 	switch ( Printer->printer_type ) {
 	case SPLHND_PORTMON_TCP:
-		return process_xcvtcp_command( p->pipe_user.nt_user_token, command, 
+		return process_xcvtcp_command( p->pipe_user.nt_user_token, command,
 			&q_u->indata, &r_u->outdata, &r_u->needed );
 	case SPLHND_PORTMON_LOCAL:
-		return process_xcvlocal_command( p->pipe_user.nt_user_token, command, 
+		return process_xcvlocal_command( p->pipe_user.nt_user_token, command,
 			&q_u->indata, &r_u->outdata, &r_u->needed );
 	}
 
 	return WERR_INVALID_PRINT_MONITOR;
 }
-
-