astyle fixes

13 files changed, 1454 insertions, 249 deletions

diff --git a/bus.c b/bus.c
index b3ac833..bf3ef02 100644
--- a/bus.c
+++ b/bus.c
@@ -357,7 +357,7 @@ static unsigned gpio_pins[] = {	GPIO0_X + 22,	// i.e., GPIO0_22
                                 GPIO1_X + 14,
                                 GPIO0_X + 27,
                                 GPIO1_X + 12,
-				GPIO2_X + 1
+                                GPIO2_X + 1
                               };
 
 
@@ -391,7 +391,7 @@ void bus_init()
 		gpio_changedirection(gpio_pins[POWER_FAIL], false);
 
 		// reset the TNT4882 chip
-        	bus_setpin(RST_GPIB, 0);
+		bus_setpin(RST_GPIB, 0);
 		g_usleep(10);
 		bus_setpin(RST_GPIB, 1);
 		g_usleep(10);
diff --git a/device-functions.c b/device-functions.c
index 203af45..a804879 100644
--- a/device-functions.c
+++ b/device-functions.c
@@ -2723,8 +2723,8 @@ int Set_VI_Control(int parameter,int channel,float new_ampl,int *point_found,int
 			if (max2 > max1) {
 				max1 = max2;
 			}
-			if ((use_ampl * use_atten) > 
-			    (globals.Flash.atten_percent_max_ampl[channel] * max1)) {
+			if ((use_ampl * use_atten) >
+			                (globals.Flash.atten_percent_max_ampl[channel] * max1)) {
 				continue;
 			}
 		}
diff --git a/flash.c b/flash.c
index 1282eff..6379d3b 100644
--- a/flash.c
+++ b/flash.c
@@ -31,7 +31,7 @@
 
 // flash writing queue bits
 #define MAXQUEUEDJOBS 1 // This makes the queue a little bit pointless
-						// but you might want to queue a few more
+// but you might want to queue a few more
 
 typedef struct {
 	FlashStruct *mem;
@@ -347,7 +347,8 @@ void writeUserBlockNow(FlashStruct *mem, int addr, int numbytes)
 	g_static_mutex_unlock (&mutex);
 }
 
-void writeUserBlock(FlashStruct *mem, int addr, int numbytes) {
+void writeUserBlock(FlashStruct *mem, int addr, int numbytes)
+{
 	if (alive) {
 		g_mutex_lock(&writermutex);
 		if (g_async_queue_length(userflashwritequeue) >= MAXQUEUEDJOBS) {
@@ -770,7 +771,7 @@ static void initFlashValues(FlashStruct *mem)
 		mem->use_high_ampl_ranges_for_high_pw_ranges[i]=0;
 		mem->couple_first_N_pw_ranges_to_ampl_ranges[i]=0;
 
-		for (j=0;j<max_attens;j++) {
+		for (j=0; j<max_attens; j++) {
 			mem->attenuators[i][j] = 0.0;
 		}
 
@@ -817,16 +818,16 @@ static void initFlashValues(FlashStruct *mem)
 
 }
 
-static gpointer userflashwritethreadfunc(gpointer data) {
+static gpointer userflashwritethreadfunc(gpointer data)
+{
 
 	//printf("userflash write thread start\n");
 	while (alive || g_async_queue_length(userflashwritequeue) > 0) { // make sure the last job in the queue gets written
-		if (g_async_queue_length(userflashwritequeue) == 0){ // go into a sleep
+		if (g_async_queue_length(userflashwritequeue) == 0) { // go into a sleep
 			g_mutex_lock(&writermutex);
 			g_cond_wait(&writerwakeup, &writermutex);
 			g_mutex_unlock(&writermutex);
-		}
-		else {
+		} else {
 			userflashjob* job = (userflashjob*) g_async_queue_pop(userflashwritequeue);
 			if (job != NULL ) {
 				// process job
@@ -850,7 +851,8 @@ static gpointer userflashwritethreadfunc(gpointer data) {
 	return NULL ;
 }
 
-void startFlashWriterThread(){
+void startFlashWriterThread()
+{
 	alive= true;
 	userflashwritequeue = g_async_queue_new();
 	userflashwritethread = g_thread_create(userflashwritethreadfunc, NULL, true, NULL);
@@ -890,7 +892,8 @@ void initFlash(FlashStruct *mem, gboolean reset_to_defaults, int starting_locati
 	}
 }
 
-void stopFlashWriterThread(){
+void stopFlashWriterThread()
+{
 	alive = false;
 	g_cond_broadcast(&writerwakeup);
 	g_thread_join(userflashwritethread); // block until the write thread is totally finished.
diff --git a/globals.c b/globals.c
index f216697..d2a5eea 100644
--- a/globals.c
+++ b/globals.c
@@ -19,7 +19,7 @@ GlobalStruct globals = {
 	.Registers.pending_output_message = NULL,
 
 	.VxiLocks.locked_network_server = NO_SERVER_LOCKED,
-	
+
 	.MenuStatus.Nonstd_Display = YES
 };
 
diff --git a/globals.h b/globals.h
index ca50fdf..ebf7f4e 100644
--- a/globals.h
+++ b/globals.h
@@ -695,21 +695,21 @@ typedef struct {
 	char use_high_ampl_ranges_for_high_pw_ranges[max_channels];	/* addr 10066 - for AVMP-4 */
 
 	char couple_first_N_pw_ranges_to_ampl_ranges[max_channels];	// addr 10068
-									// for example, if N = 2 (as for AVR-E3-B-R5-N-M5)
-									//		PG A = pw range  0, ampl range 0
-									//		PG B = pw range  1, ampl range 1
-									//		PG C = pw range 2+, ampl range 2
+	// for example, if N = 2 (as for AVR-E3-B-R5-N-M5)
+	//		PG A = pw range  0, ampl range 0
+	//		PG B = pw range  1, ampl range 1
+	//		PG C = pw range 2+, ampl range 2
 
 	float attenuators[max_channels][max_attens];			// addr 10070
-									// smallest attenuators first
-									// value = magnitude of attenuation.
-									// for example, for 20 dB, use 10.0
-									//              for 15 dB, use 5.62
-									//		for 10 dB, use 3.16
+	// smallest attenuators first
+	// value = magnitude of attenuation.
+	// for example, for 20 dB, use 10.0
+	//              for 15 dB, use 5.62
+	//		for 10 dB, use 3.16
 
 	float atten_percent_max_ampl[max_channels];			// addr 10134 - normally 0.93
-									// don't use higher ampls in AVPs,
-									// where PW shifts near max ampl
+	// don't use higher ampls in AVPs,
+	// where PW shifts near max ampl
 
 	char spare_end;
 
@@ -773,9 +773,9 @@ typedef struct {
 
 // These flags are NOT reset by Main_Rst, and default to 0
 typedef struct {
-        int shutdown_started;
-        int flash_write_in_progress;
-        int startup_complete;
+	int shutdown_started;
+	int flash_write_in_progress;
+	int startup_complete;
 } SysFlagStruct;
 
 
diff --git a/gpib.c b/gpib.c
index 46b1e14..4eeaa9b 100644
--- a/gpib.c
+++ b/gpib.c
@@ -589,9 +589,9 @@ static unsigned long int TNT_DATA_COUNT()
 
 static void TNT_Out(int reg, unsigned int byte)
 {
-        if (!globals.HWDetect.gpib) {
-                return;
-        }
+	if (!globals.HWDetect.gpib) {
+		return;
+	}
 
 	bus_writebyte ((uint8_t) (TNT_Port + reg), (uint8_t) byte);
 }
@@ -599,9 +599,9 @@ static void TNT_Out(int reg, unsigned int byte)
 
 static unsigned char TNT_In(int reg)
 {
-        if (!globals.HWDetect.gpib) {
-                return (unsigned char) 0;
-        }
+	if (!globals.HWDetect.gpib) {
+		return (unsigned char) 0;
+	}
 
 	return (unsigned char) bus_readbyte ((uint8_t) (TNT_Port + reg));
 }
diff --git a/instr-daemon.c b/instr-daemon.c
index e71b5f2..19536d3 100644
--- a/instr-daemon.c
+++ b/instr-daemon.c
@@ -190,7 +190,8 @@ handler (GThreadedSocketService *service,
 
 extern void vxi_main ();
 
-static gpointer vxithreadfunc (gpointer data){
+static gpointer vxithreadfunc (gpointer data)
+{
 	vxi_main ();
 	return NULL;
 }
@@ -292,8 +293,9 @@ int main(int argc, char **argv)
 
 	if (globals.Flash.vxi_enabled) {
 		GThread *vxithread =g_thread_create(vxithreadfunc, NULL, FALSE, NULL);
-		if(vxithread == NULL)
+		if(vxithread == NULL) {
 			printf("Couldn't create vxi thread\n");
+		}
 	}
 
 	g_main_loop_run (loop);
@@ -416,7 +418,7 @@ static gboolean periodic_poll (void)
 		// or is currently handling a command
 
 		if ((globals.VxiLocks.locked_network_server == NO_SERVER_LOCKED) &&
-		    (globals.VxiLocks.command_in_progress == FALSE)) {
+		                (globals.VxiLocks.command_in_progress == FALSE)) {
 
 			// tell VXI servers that the 4882 subsystem is busy
 			globals.VxiLocks.command_in_progress = TRUE;
diff --git a/string_utils.c b/string_utils.c
index 77765d2..7fba9bb 100644
--- a/string_utils.c
+++ b/string_utils.c
@@ -155,12 +155,12 @@ gchar* conditional_regex_replace (gboolean do_it, gchar* in_string, gchar* regex
 	gchar *out;
 
 	if (do_it) {
-	        GRegex *regex = g_regex_new (regex_string, 0, 0, NULL);
-        	out = g_regex_replace_literal (regex, in_string, -1, 0, replace_with, 0, NULL);
-	        g_regex_unref (regex);
+		GRegex *regex = g_regex_new (regex_string, 0, 0, NULL);
+		out = g_regex_replace_literal (regex, in_string, -1, 0, replace_with, 0, NULL);
+		g_regex_unref (regex);
 	} else {
 		out = g_strdup (in_string);
 	}
 
-        return out;
+	return out;
 }
diff --git a/vxi11.h b/vxi11.h
index 5e8fa4f..093b6ae 120000..100644
--- a/vxi11.h
+++ b/vxi11.h
@@ -1 +1,342 @@
-libvxi11client/vxi11.h
\ No newline at end of file
+/*
+ * Please do not edit this file.
+ * It was generated using rpcgen.
+ */
+
+#ifndef _VXI11_H_RPCGEN
+#define _VXI11_H_RPCGEN
+
+#include <rpc/rpc.h>
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+	typedef long Device_Link;
+
+	enum Device_AddrFamily {
+	        DEVICE_TCP = 0,
+	        DEVICE_UDP = 1,
+	};
+	typedef enum Device_AddrFamily Device_AddrFamily;
+
+	typedef long Device_Flags;
+
+	typedef long Device_ErrorCode;
+
+	struct Device_Error {
+		Device_ErrorCode error;
+	};
+	typedef struct Device_Error Device_Error;
+
+	struct Create_LinkParms {
+		long clientId;
+		bool_t lockDevice;
+		u_long lock_timeout;
+		char *device;
+	};
+	typedef struct Create_LinkParms Create_LinkParms;
+
+	struct Create_LinkResp {
+		Device_ErrorCode error;
+		Device_Link lid;
+		u_short abortPort;
+		u_long maxRecvSize;
+	};
+	typedef struct Create_LinkResp Create_LinkResp;
+
+	struct Device_WriteParms {
+		Device_Link lid;
+		u_long io_timeout;
+		u_long lock_timeout;
+		Device_Flags flags;
+		struct {
+			u_int data_len;
+			char *data_val;
+		} data;
+	};
+	typedef struct Device_WriteParms Device_WriteParms;
+
+	struct Device_WriteResp {
+		Device_ErrorCode error;
+		u_long size;
+	};
+	typedef struct Device_WriteResp Device_WriteResp;
+
+	struct Device_ReadParms {
+		Device_Link lid;
+		u_long requestSize;
+		u_long io_timeout;
+		u_long lock_timeout;
+		Device_Flags flags;
+		char termChar;
+	};
+	typedef struct Device_ReadParms Device_ReadParms;
+
+	struct Device_ReadResp {
+		Device_ErrorCode error;
+		long reason;
+		struct {
+			u_int data_len;
+			char *data_val;
+		} data;
+	};
+	typedef struct Device_ReadResp Device_ReadResp;
+
+	struct Device_ReadStbResp {
+		Device_ErrorCode error;
+		u_char stb;
+	};
+	typedef struct Device_ReadStbResp Device_ReadStbResp;
+
+	struct Device_GenericParms {
+		Device_Link lid;
+		Device_Flags flags;
+		u_long lock_timeout;
+		u_long io_timeout;
+	};
+	typedef struct Device_GenericParms Device_GenericParms;
+
+	struct Device_RemoteFunc {
+		u_long hostAddr;
+		u_long hostPort;
+		u_long progNum;
+		u_long progVers;
+		Device_AddrFamily progFamily;
+	};
+	typedef struct Device_RemoteFunc Device_RemoteFunc;
+
+	struct Device_EnableSrqParms {
+		Device_Link lid;
+		bool_t enable;
+		struct {
+			u_int handle_len;
+			char *handle_val;
+		} handle;
+	};
+	typedef struct Device_EnableSrqParms Device_EnableSrqParms;
+
+	struct Device_LockParms {
+		Device_Link lid;
+		Device_Flags flags;
+		u_long lock_timeout;
+	};
+	typedef struct Device_LockParms Device_LockParms;
+
+	struct Device_DocmdParms {
+		Device_Link lid;
+		Device_Flags flags;
+		u_long io_timeout;
+		u_long lock_timeout;
+		long cmd;
+		bool_t network_order;
+		long datasize;
+		struct {
+			u_int data_in_len;
+			char *data_in_val;
+		} data_in;
+	};
+	typedef struct Device_DocmdParms Device_DocmdParms;
+
+	struct Device_DocmdResp {
+		Device_ErrorCode error;
+		struct {
+			u_int data_out_len;
+			char *data_out_val;
+		} data_out;
+	};
+	typedef struct Device_DocmdResp Device_DocmdResp;
+
+	struct Device_SrqParms {
+		struct {
+			u_int handle_len;
+			char *handle_val;
+		} handle;
+	};
+	typedef struct Device_SrqParms Device_SrqParms;
+
+#define DEVICE_ASYNC 0x0607B0
+#define DEVICE_ASYNC_VERSION 1
+
+#if defined(__STDC__) || defined(__cplusplus)
+#define device_abort 1
+	extern  Device_Error * device_abort_1(Device_Link *, CLIENT *);
+	extern  Device_Error * device_abort_1_svc(Device_Link *, struct svc_req *);
+	extern int device_async_1_freeresult (SVCXPRT *, xdrproc_t, caddr_t);
+
+#else /* K&R C */
+#define device_abort 1
+	extern  Device_Error * device_abort_1();
+	extern  Device_Error * device_abort_1_svc();
+	extern int device_async_1_freeresult ();
+#endif /* K&R C */
+
+#define DEVICE_CORE 0x0607AF
+#define DEVICE_CORE_VERSION 1
+
+#if defined(__STDC__) || defined(__cplusplus)
+#define create_link 10
+	extern  Create_LinkResp * create_link_1(Create_LinkParms *, CLIENT *);
+	extern  Create_LinkResp * create_link_1_svc(Create_LinkParms *, struct svc_req *);
+#define device_write 11
+	extern  Device_WriteResp * device_write_1(Device_WriteParms *, CLIENT *);
+	extern  Device_WriteResp * device_write_1_svc(Device_WriteParms *, struct svc_req *);
+#define device_read 12
+	extern  Device_ReadResp * device_read_1(Device_ReadParms *, CLIENT *);
+	extern  Device_ReadResp * device_read_1_svc(Device_ReadParms *, struct svc_req *);
+#define device_readstb 13
+	extern  Device_ReadStbResp * device_readstb_1(Device_GenericParms *, CLIENT *);
+	extern  Device_ReadStbResp * device_readstb_1_svc(Device_GenericParms *, struct svc_req *);
+#define device_trigger 14
+	extern  Device_Error * device_trigger_1(Device_GenericParms *, CLIENT *);
+	extern  Device_Error * device_trigger_1_svc(Device_GenericParms *, struct svc_req *);
+#define device_clear 15
+	extern  Device_Error * device_clear_1(Device_GenericParms *, CLIENT *);
+	extern  Device_Error * device_clear_1_svc(Device_GenericParms *, struct svc_req *);
+#define device_remote 16
+	extern  Device_Error * device_remote_1(Device_GenericParms *, CLIENT *);
+	extern  Device_Error * device_remote_1_svc(Device_GenericParms *, struct svc_req *);
+#define device_local 17
+	extern  Device_Error * device_local_1(Device_GenericParms *, CLIENT *);
+	extern  Device_Error * device_local_1_svc(Device_GenericParms *, struct svc_req *);
+#define device_lock 18
+	extern  Device_Error * device_lock_1(Device_LockParms *, CLIENT *);
+	extern  Device_Error * device_lock_1_svc(Device_LockParms *, struct svc_req *);
+#define device_unlock 19
+	extern  Device_Error * device_unlock_1(Device_Link *, CLIENT *);
+	extern  Device_Error * device_unlock_1_svc(Device_Link *, struct svc_req *);
+#define device_enable_srq 20
+	extern  Device_Error * device_enable_srq_1(Device_EnableSrqParms *, CLIENT *);
+	extern  Device_Error * device_enable_srq_1_svc(Device_EnableSrqParms *, struct svc_req *);
+#define device_docmd 22
+	extern  Device_DocmdResp * device_docmd_1(Device_DocmdParms *, CLIENT *);
+	extern  Device_DocmdResp * device_docmd_1_svc(Device_DocmdParms *, struct svc_req *);
+#define destroy_link 23
+	extern  Device_Error * destroy_link_1(Device_Link *, CLIENT *);
+	extern  Device_Error * destroy_link_1_svc(Device_Link *, struct svc_req *);
+#define create_intr_chan 25
+	extern  Device_Error * create_intr_chan_1(Device_RemoteFunc *, CLIENT *);
+	extern  Device_Error * create_intr_chan_1_svc(Device_RemoteFunc *, struct svc_req *);
+#define destroy_intr_chan 26
+	extern  Device_Error * destroy_intr_chan_1(void *, CLIENT *);
+	extern  Device_Error * destroy_intr_chan_1_svc(void *, struct svc_req *);
+	extern int device_core_1_freeresult (SVCXPRT *, xdrproc_t, caddr_t);
+
+#else /* K&R C */
+#define create_link 10
+	extern  Create_LinkResp * create_link_1();
+	extern  Create_LinkResp * create_link_1_svc();
+#define device_write 11
+	extern  Device_WriteResp * device_write_1();
+	extern  Device_WriteResp * device_write_1_svc();
+#define device_read 12
+	extern  Device_ReadResp * device_read_1();
+	extern  Device_ReadResp * device_read_1_svc();
+#define device_readstb 13
+	extern  Device_ReadStbResp * device_readstb_1();
+	extern  Device_ReadStbResp * device_readstb_1_svc();
+#define device_trigger 14
+	extern  Device_Error * device_trigger_1();
+	extern  Device_Error * device_trigger_1_svc();
+#define device_clear 15
+	extern  Device_Error * device_clear_1();
+	extern  Device_Error * device_clear_1_svc();
+#define device_remote 16
+	extern  Device_Error * device_remote_1();
+	extern  Device_Error * device_remote_1_svc();
+#define device_local 17
+	extern  Device_Error * device_local_1();
+	extern  Device_Error * device_local_1_svc();
+#define device_lock 18
+	extern  Device_Error * device_lock_1();
+	extern  Device_Error * device_lock_1_svc();
+#define device_unlock 19
+	extern  Device_Error * device_unlock_1();
+	extern  Device_Error * device_unlock_1_svc();
+#define device_enable_srq 20
+	extern  Device_Error * device_enable_srq_1();
+	extern  Device_Error * device_enable_srq_1_svc();
+#define device_docmd 22
+	extern  Device_DocmdResp * device_docmd_1();
+	extern  Device_DocmdResp * device_docmd_1_svc();
+#define destroy_link 23
+	extern  Device_Error * destroy_link_1();
+	extern  Device_Error * destroy_link_1_svc();
+#define create_intr_chan 25
+	extern  Device_Error * create_intr_chan_1();
+	extern  Device_Error * create_intr_chan_1_svc();
+#define destroy_intr_chan 26
+	extern  Device_Error * destroy_intr_chan_1();
+	extern  Device_Error * destroy_intr_chan_1_svc();
+	extern int device_core_1_freeresult ();
+#endif /* K&R C */
+
+#define DEVICE_INTR 0x0607B1
+#define DEVICE_INTR_VERSION 1
+
+#if defined(__STDC__) || defined(__cplusplus)
+#define device_intr_srq 30
+	extern  void * device_intr_srq_1(Device_SrqParms *, CLIENT *);
+	extern  void * device_intr_srq_1_svc(Device_SrqParms *, struct svc_req *);
+	extern int device_intr_1_freeresult (SVCXPRT *, xdrproc_t, caddr_t);
+
+#else /* K&R C */
+#define device_intr_srq 30
+	extern  void * device_intr_srq_1();
+	extern  void * device_intr_srq_1_svc();
+	extern int device_intr_1_freeresult ();
+#endif /* K&R C */
+
+	/* the xdr functions */
+
+#if defined(__STDC__) || defined(__cplusplus)
+	extern  bool_t xdr_Device_Link (XDR *, Device_Link*);
+	extern  bool_t xdr_Device_AddrFamily (XDR *, Device_AddrFamily*);
+	extern  bool_t xdr_Device_Flags (XDR *, Device_Flags*);
+	extern  bool_t xdr_Device_ErrorCode (XDR *, Device_ErrorCode*);
+	extern  bool_t xdr_Device_Error (XDR *, Device_Error*);
+	extern  bool_t xdr_Create_LinkParms (XDR *, Create_LinkParms*);
+	extern  bool_t xdr_Create_LinkResp (XDR *, Create_LinkResp*);
+	extern  bool_t xdr_Device_WriteParms (XDR *, Device_WriteParms*);
+	extern  bool_t xdr_Device_WriteResp (XDR *, Device_WriteResp*);
+	extern  bool_t xdr_Device_ReadParms (XDR *, Device_ReadParms*);
+	extern  bool_t xdr_Device_ReadResp (XDR *, Device_ReadResp*);
+	extern  bool_t xdr_Device_ReadStbResp (XDR *, Device_ReadStbResp*);
+	extern  bool_t xdr_Device_GenericParms (XDR *, Device_GenericParms*);
+	extern  bool_t xdr_Device_RemoteFunc (XDR *, Device_RemoteFunc*);
+	extern  bool_t xdr_Device_EnableSrqParms (XDR *, Device_EnableSrqParms*);
+	extern  bool_t xdr_Device_LockParms (XDR *, Device_LockParms*);
+	extern  bool_t xdr_Device_DocmdParms (XDR *, Device_DocmdParms*);
+	extern  bool_t xdr_Device_DocmdResp (XDR *, Device_DocmdResp*);
+	extern  bool_t xdr_Device_SrqParms (XDR *, Device_SrqParms*);
+
+#else /* K&R C */
+	extern bool_t xdr_Device_Link ();
+	extern bool_t xdr_Device_AddrFamily ();
+	extern bool_t xdr_Device_Flags ();
+	extern bool_t xdr_Device_ErrorCode ();
+	extern bool_t xdr_Device_Error ();
+	extern bool_t xdr_Create_LinkParms ();
+	extern bool_t xdr_Create_LinkResp ();
+	extern bool_t xdr_Device_WriteParms ();
+	extern bool_t xdr_Device_WriteResp ();
+	extern bool_t xdr_Device_ReadParms ();
+	extern bool_t xdr_Device_ReadResp ();
+	extern bool_t xdr_Device_ReadStbResp ();
+	extern bool_t xdr_Device_GenericParms ();
+	extern bool_t xdr_Device_RemoteFunc ();
+	extern bool_t xdr_Device_EnableSrqParms ();
+	extern bool_t xdr_Device_LockParms ();
+	extern bool_t xdr_Device_DocmdParms ();
+	extern bool_t xdr_Device_DocmdResp ();
+	extern bool_t xdr_Device_SrqParms ();
+
+#endif /* K&R C */
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* !_VXI11_H_RPCGEN */
diff --git a/vxi11_clnt.c b/vxi11_clnt.c
index 320589b..9c7e29f 120000..100644
--- a/vxi11_clnt.c
+++ b/vxi11_clnt.c
@@ -1 +1,265 @@
-libvxi11client/vxi11_clnt.c
\ No newline at end of file
+/*
+ * Please do not edit this file.
+ * It was generated using rpcgen.
+ */
+
+#include <memory.h> /* for memset */
+#include "vxi11.h"
+
+/* Default timeout can be changed using clnt_control() */
+static struct timeval TIMEOUT = { 25, 0 };
+
+Device_Error *
+device_abort_1(Device_Link *argp, CLIENT *clnt)
+{
+	static Device_Error clnt_res;
+
+	memset((char *)&clnt_res, 0, sizeof(clnt_res));
+	if (clnt_call (clnt, device_abort,
+	                (xdrproc_t) xdr_Device_Link, (caddr_t) argp,
+	                (xdrproc_t) xdr_Device_Error, (caddr_t) &clnt_res,
+	                TIMEOUT) != RPC_SUCCESS) {
+		return (NULL);
+	}
+	return (&clnt_res);
+}
+
+Create_LinkResp *
+create_link_1(Create_LinkParms *argp, CLIENT *clnt)
+{
+	static Create_LinkResp clnt_res;
+
+	memset((char *)&clnt_res, 0, sizeof(clnt_res));
+	if (clnt_call (clnt, create_link,
+	                (xdrproc_t) xdr_Create_LinkParms, (caddr_t) argp,
+	                (xdrproc_t) xdr_Create_LinkResp, (caddr_t) &clnt_res,
+	                TIMEOUT) != RPC_SUCCESS) {
+		return (NULL);
+	}
+	return (&clnt_res);
+}
+
+Device_WriteResp *
+device_write_1(Device_WriteParms *argp, CLIENT *clnt)
+{
+	static Device_WriteResp clnt_res;
+
+	memset((char *)&clnt_res, 0, sizeof(clnt_res));
+	if (clnt_call (clnt, device_write,
+	                (xdrproc_t) xdr_Device_WriteParms, (caddr_t) argp,
+	                (xdrproc_t) xdr_Device_WriteResp, (caddr_t) &clnt_res,
+	                TIMEOUT) != RPC_SUCCESS) {
+		return (NULL);
+	}
+	return (&clnt_res);
+}
+
+Device_ReadResp *
+device_read_1(Device_ReadParms *argp, CLIENT *clnt)
+{
+	static Device_ReadResp clnt_res;
+
+	memset((char *)&clnt_res, 0, sizeof(clnt_res));
+	if (clnt_call (clnt, device_read,
+	                (xdrproc_t) xdr_Device_ReadParms, (caddr_t) argp,
+	                (xdrproc_t) xdr_Device_ReadResp, (caddr_t) &clnt_res,
+	                TIMEOUT) != RPC_SUCCESS) {
+		return (NULL);
+	}
+	return (&clnt_res);
+}
+
+Device_ReadStbResp *
+device_readstb_1(Device_GenericParms *argp, CLIENT *clnt)
+{
+	static Device_ReadStbResp clnt_res;
+
+	memset((char *)&clnt_res, 0, sizeof(clnt_res));
+	if (clnt_call (clnt, device_readstb,
+	                (xdrproc_t) xdr_Device_GenericParms, (caddr_t) argp,
+	                (xdrproc_t) xdr_Device_ReadStbResp, (caddr_t) &clnt_res,
+	                TIMEOUT) != RPC_SUCCESS) {
+		return (NULL);
+	}
+	return (&clnt_res);
+}
+
+Device_Error *
+device_trigger_1(Device_GenericParms *argp, CLIENT *clnt)
+{
+	static Device_Error clnt_res;
+
+	memset((char *)&clnt_res, 0, sizeof(clnt_res));
+	if (clnt_call (clnt, device_trigger,
+	                (xdrproc_t) xdr_Device_GenericParms, (caddr_t) argp,
+	                (xdrproc_t) xdr_Device_Error, (caddr_t) &clnt_res,
+	                TIMEOUT) != RPC_SUCCESS) {
+		return (NULL);
+	}
+	return (&clnt_res);
+}
+
+Device_Error *
+device_clear_1(Device_GenericParms *argp, CLIENT *clnt)
+{
+	static Device_Error clnt_res;
+
+	memset((char *)&clnt_res, 0, sizeof(clnt_res));
+	if (clnt_call (clnt, device_clear,
+	                (xdrproc_t) xdr_Device_GenericParms, (caddr_t) argp,
+	                (xdrproc_t) xdr_Device_Error, (caddr_t) &clnt_res,
+	                TIMEOUT) != RPC_SUCCESS) {
+		return (NULL);
+	}
+	return (&clnt_res);
+}
+
+Device_Error *
+device_remote_1(Device_GenericParms *argp, CLIENT *clnt)
+{
+	static Device_Error clnt_res;
+
+	memset((char *)&clnt_res, 0, sizeof(clnt_res));
+	if (clnt_call (clnt, device_remote,
+	                (xdrproc_t) xdr_Device_GenericParms, (caddr_t) argp,
+	                (xdrproc_t) xdr_Device_Error, (caddr_t) &clnt_res,
+	                TIMEOUT) != RPC_SUCCESS) {
+		return (NULL);
+	}
+	return (&clnt_res);
+}
+
+Device_Error *
+device_local_1(Device_GenericParms *argp, CLIENT *clnt)
+{
+	static Device_Error clnt_res;
+
+	memset((char *)&clnt_res, 0, sizeof(clnt_res));
+	if (clnt_call (clnt, device_local,
+	                (xdrproc_t) xdr_Device_GenericParms, (caddr_t) argp,
+	                (xdrproc_t) xdr_Device_Error, (caddr_t) &clnt_res,
+	                TIMEOUT) != RPC_SUCCESS) {
+		return (NULL);
+	}
+	return (&clnt_res);
+}
+
+Device_Error *
+device_lock_1(Device_LockParms *argp, CLIENT *clnt)
+{
+	static Device_Error clnt_res;
+
+	memset((char *)&clnt_res, 0, sizeof(clnt_res));
+	if (clnt_call (clnt, device_lock,
+	                (xdrproc_t) xdr_Device_LockParms, (caddr_t) argp,
+	                (xdrproc_t) xdr_Device_Error, (caddr_t) &clnt_res,
+	                TIMEOUT) != RPC_SUCCESS) {
+		return (NULL);
+	}
+	return (&clnt_res);
+}
+
+Device_Error *
+device_unlock_1(Device_Link *argp, CLIENT *clnt)
+{
+	static Device_Error clnt_res;
+
+	memset((char *)&clnt_res, 0, sizeof(clnt_res));
+	if (clnt_call (clnt, device_unlock,
+	                (xdrproc_t) xdr_Device_Link, (caddr_t) argp,
+	                (xdrproc_t) xdr_Device_Error, (caddr_t) &clnt_res,
+	                TIMEOUT) != RPC_SUCCESS) {
+		return (NULL);
+	}
+	return (&clnt_res);
+}
+
+Device_Error *
+device_enable_srq_1(Device_EnableSrqParms *argp, CLIENT *clnt)
+{
+	static Device_Error clnt_res;
+
+	memset((char *)&clnt_res, 0, sizeof(clnt_res));
+	if (clnt_call (clnt, device_enable_srq,
+	                (xdrproc_t) xdr_Device_EnableSrqParms, (caddr_t) argp,
+	                (xdrproc_t) xdr_Device_Error, (caddr_t) &clnt_res,
+	                TIMEOUT) != RPC_SUCCESS) {
+		return (NULL);
+	}
+	return (&clnt_res);
+}
+
+Device_DocmdResp *
+device_docmd_1(Device_DocmdParms *argp, CLIENT *clnt)
+{
+	static Device_DocmdResp clnt_res;
+
+	memset((char *)&clnt_res, 0, sizeof(clnt_res));
+	if (clnt_call (clnt, device_docmd,
+	                (xdrproc_t) xdr_Device_DocmdParms, (caddr_t) argp,
+	                (xdrproc_t) xdr_Device_DocmdResp, (caddr_t) &clnt_res,
+	                TIMEOUT) != RPC_SUCCESS) {
+		return (NULL);
+	}
+	return (&clnt_res);
+}
+
+Device_Error *
+destroy_link_1(Device_Link *argp, CLIENT *clnt)
+{
+	static Device_Error clnt_res;
+
+	memset((char *)&clnt_res, 0, sizeof(clnt_res));
+	if (clnt_call (clnt, destroy_link,
+	                (xdrproc_t) xdr_Device_Link, (caddr_t) argp,
+	                (xdrproc_t) xdr_Device_Error, (caddr_t) &clnt_res,
+	                TIMEOUT) != RPC_SUCCESS) {
+		return (NULL);
+	}
+	return (&clnt_res);
+}
+
+Device_Error *
+create_intr_chan_1(Device_RemoteFunc *argp, CLIENT *clnt)
+{
+	static Device_Error clnt_res;
+
+	memset((char *)&clnt_res, 0, sizeof(clnt_res));
+	if (clnt_call (clnt, create_intr_chan,
+	                (xdrproc_t) xdr_Device_RemoteFunc, (caddr_t) argp,
+	                (xdrproc_t) xdr_Device_Error, (caddr_t) &clnt_res,
+	                TIMEOUT) != RPC_SUCCESS) {
+		return (NULL);
+	}
+	return (&clnt_res);
+}
+
+Device_Error *
+destroy_intr_chan_1(void *argp, CLIENT *clnt)
+{
+	static Device_Error clnt_res;
+
+	memset((char *)&clnt_res, 0, sizeof(clnt_res));
+	if (clnt_call (clnt, destroy_intr_chan,
+	                (xdrproc_t) xdr_void, (caddr_t) argp,
+	                (xdrproc_t) xdr_Device_Error, (caddr_t) &clnt_res,
+	                TIMEOUT) != RPC_SUCCESS) {
+		return (NULL);
+	}
+	return (&clnt_res);
+}
+
+void *
+device_intr_srq_1(Device_SrqParms *argp, CLIENT *clnt)
+{
+	static char clnt_res;
+
+	memset((char *)&clnt_res, 0, sizeof(clnt_res));
+	if (clnt_call (clnt, device_intr_srq,
+	                (xdrproc_t) xdr_Device_SrqParms, (caddr_t) argp,
+	                (xdrproc_t) xdr_void, (caddr_t) &clnt_res,
+	                TIMEOUT) != RPC_SUCCESS) {
+		return (NULL);
+	}
+	return ((void *)&clnt_res);
+}
diff --git a/vxi11_server.c b/vxi11_server.c
index 878f4aa..c5024a7 100644
--- a/vxi11_server.c
+++ b/vxi11_server.c
@@ -56,11 +56,13 @@ static ActiveLink* links[MAX_SESSIONS] = { NULL };
 
 static void freelink(ActiveLink* link);
 
-static void touchlink(int lid) {
+static void touchlink(int lid)
+{
 	g_get_current_time(&(links[lid]->lastactivity));
 }
 
-static bool isValidLink(int linkid) {
+static bool isValidLink(int linkid)
+{
 	if (linkid > MAX_SESSIONS - 1) {
 #ifdef DEBUG
 		printf("Crazy link id %d\n", linkid);
@@ -71,7 +73,8 @@ static bool isValidLink(int linkid) {
 }
 
 // test if a link has expired, this is to avoid dead locks
-static bool linkexpired(ActiveLink* link) {
+static bool linkexpired(ActiveLink* link)
+{
 	GTimeVal cutoff;
 	g_get_current_time(&cutoff);
 	g_time_val_add(&cutoff, -LINKLONGSINCEDEADTIMEOUT);
@@ -81,29 +84,33 @@ static bool linkexpired(ActiveLink* link) {
 #endif
 		freelink(link);
 		return true;
-	}
-	else
+	} else {
 		return false;
+	}
 }
 
 // locking wrappers
 
-static void lock(int lid) {
+static void lock(int lid)
+{
 	globals.VxiLocks.locked_network_server = lid;
 }
 
-static void unlock() {
+static void unlock()
+{
 	globals.VxiLocks.locked_network_server = NO_SERVER_LOCKED;
 }
 
-static bool haveLock(int lid) {
+static bool haveLock(int lid)
+{
 	return globals.VxiLocks.locked_network_server == lid;
 }
 
-static bool isLocked() {
-	if (globals.VxiLocks.locked_network_server == NO_SERVER_LOCKED)
+static bool isLocked()
+{
+	if (globals.VxiLocks.locked_network_server == NO_SERVER_LOCKED) {
 		return false;
-	else {
+	} else {
 		ActiveLink* link = links[globals.VxiLocks.locked_network_server];
 		return !(linkexpired(link));
 	}
@@ -112,15 +119,18 @@ static bool isLocked() {
 #define FLAG_WAITLOCK 1
 
 // todo
-static bool waitForLock(Device_Flags flags, long timeout) {
-	if (!(flags & FLAG_WAITLOCK))
+static bool waitForLock(Device_Flags flags, long timeout)
+{
+	if (!(flags & FLAG_WAITLOCK)) {
 		return false;
+	}
 	return false;
 }
 
 //
 
-static void freelink(ActiveLink* link) {
+static void freelink(ActiveLink* link)
+{
 	links[link->lid] = NULL;
 	globals.Remote.vxi_connections--;
 
@@ -142,7 +152,8 @@ static void freelink(ActiveLink* link) {
 	g_free(link);
 }
 
-void vxi11_deadsocketcallback(int socket) {
+void vxi11_deadsocketcallback(int socket)
+{
 	int linkid;
 	for (linkid = 0; linkid < SIZEOFARRAY(links); linkid++) {
 		if (links[linkid] != NULL ) {
@@ -156,10 +167,12 @@ void vxi11_deadsocketcallback(int socket) {
 	}
 }
 
-static bool waitforio(long timeout) {
+static bool waitforio(long timeout)
+{
 	do {
-		if (!globals.VxiLocks.command_in_progress)
+		if (!globals.VxiLocks.command_in_progress) {
 			return true;
+		}
 		usleep(250);
 		timeout -= 250;
 	} while (timeout < 0);
@@ -170,14 +183,15 @@ static bool waitforio(long timeout) {
 }
 
 Device_Error *
-device_abort_1_svc(Device_Link *argp, struct svc_req *rqstp) {
+device_abort_1_svc(Device_Link *argp, struct svc_req *rqstp)
+{
 	static Device_Error result;
 #ifdef DEBUG
 	printf("device_abort_1_svc()\n");
 #endif
-	if (!isValidLink(*argp))
+	if (!isValidLink(*argp)) {
 		result.error = ERR_INVALIDLINKINDENTIFIER;
-	else {
+	} else {
 		links[*argp]->aborted = true;
 		result.error = 0;
 	}
@@ -185,7 +199,8 @@ device_abort_1_svc(Device_Link *argp, struct svc_req *rqstp) {
 }
 
 Create_LinkResp *
-create_link_1_svc(Create_LinkParms *argp, struct svc_req *rqstp) {
+create_link_1_svc(Create_LinkParms *argp, struct svc_req *rqstp)
+{
 	static Create_LinkResp result;
 	memset(&result, 0, sizeof(result));
 #ifdef DEBUG
@@ -193,20 +208,18 @@ create_link_1_svc(Create_LinkParms *argp, struct svc_req *rqstp) {
 #endif
 	if (globals.Remote.vxi_connections == MAX_SESSIONS) {
 		result.error = ERR_OUTOFRESOURCES;
-	}
-	else if (argp->lockDevice && isLocked() && !waitForLock(FLAG_WAITLOCK, argp->lock_timeout)) {
+	} else if (argp->lockDevice && isLocked() && !waitForLock(FLAG_WAITLOCK, argp->lock_timeout)) {
 		result.error = ERR_DEVICELOCKEDBYANOTHERLINK;
-	}
-	else {
+	} else {
 		ActiveLink* link = g_malloc(sizeof(ActiveLink));
 		if (link == NULL ) {
 			result.error = ERR_OUTOFRESOURCES;
-		}
-		else {
+		} else {
 			int linkid;
 			for (linkid = 0; linkid < SIZEOFARRAY(links); linkid++) {
-				if (links[linkid] != NULL ) // clean up any dead links
+				if (links[linkid] != NULL ) { // clean up any dead links
 					linkexpired(links[linkid]);
+				}
 				if (links[linkid] == NULL ) {
 					links[linkid] = link;
 					break;
@@ -239,29 +252,32 @@ create_link_1_svc(Create_LinkParms *argp, struct svc_req *rqstp) {
 }
 
 Device_WriteResp *
-device_write_1_svc(Device_WriteParms *argp, struct svc_req *rqstp) {
+device_write_1_svc(Device_WriteParms *argp, struct svc_req *rqstp)
+{
 	static Device_WriteResp result;
 	memset(&result, 0, sizeof(result));
 #ifdef DEBUG
 	printf("device_write_1_svc()\n");
 #endif
-	if (!isValidLink(argp->lid))
+	if (!isValidLink(argp->lid)) {
 		result.error = ERR_INVALIDLINKINDENTIFIER;
-	else if (isLocked() && !haveLock(argp->lid) && !waitForLock(argp->flags, argp->lock_timeout))
+	} else if (isLocked() && !haveLock(argp->lid) && !waitForLock(argp->flags, argp->lock_timeout)) {
 		result.error = ERR_DEVICELOCKEDBYANOTHERLINK;
-	else if (!waitforio(argp->io_timeout))
+	} else if (!waitforio(argp->io_timeout)) {
 		result.error = ERR_IOTIMEOUT;
-	else {
+	} else {
 		touchlink(argp->lid);
 		links[argp->lid]->aborted = false;
 		gchar* str = NULL;
-		if (argp->data.data_val != NULL )
+		if (argp->data.data_val != NULL ) {
 			str = g_strndup(argp->data.data_val, argp->data.data_len);
+		}
 		if (str != NULL ) {
 #ifdef DEBUG
 			int n;
-			for (n = 0; str[n] != '\0'; n++)
+			for (n = 0; str[n] != '\0'; n++) {
 				printf("%02x ", (unsigned char) str[n]);
+			}
 			printf("\n");
 			printf("got <<%s>> (reported length %d)on link %d.\n", str, (int) argp->data.data_len, (int) argp->lid);
 #endif
@@ -275,26 +291,27 @@ device_write_1_svc(Device_WriteParms *argp, struct svc_req *rqstp) {
 }
 
 Device_ReadResp *
-device_read_1_svc(Device_ReadParms *argp, struct svc_req *rqstp) {
+device_read_1_svc(Device_ReadParms *argp, struct svc_req *rqstp)
+{
 	static Device_ReadResp result;
 #ifdef DEBUG
 	printf("device_read_1_svc()\n");
 #endif
 
 // this free's the data from the last call
-	if (result.data.data_val != NULL )
+	if (result.data.data_val != NULL ) {
 		g_free(result.data.data_val);
+	}
 
 	memset(&result, 0, sizeof(result));
 
-	if (!isValidLink(argp->lid))
+	if (!isValidLink(argp->lid)) {
 		result.error = ERR_INVALIDLINKINDENTIFIER;
-	else if (isLocked() && !haveLock(argp->lid) && !waitForLock(argp->flags, argp->lock_timeout))
+	} else if (isLocked() && !haveLock(argp->lid) && !waitForLock(argp->flags, argp->lock_timeout)) {
 		result.error = ERR_DEVICELOCKEDBYANOTHERLINK;
-	else if (!waitforio(argp->io_timeout)) {
+	} else if (!waitforio(argp->io_timeout)) {
 		result.error = ERR_IOTIMEOUT;
-	}
-	else {
+	} else {
 		touchlink(argp->lid);
 		if (globals.Registers.pending_output_message != NULL ) {
 			result.data.data_len = strlen(globals.Registers.pending_output_message);
@@ -304,9 +321,9 @@ device_read_1_svc(Device_ReadParms *argp, struct svc_req *rqstp) {
 #ifdef DEBUG
 			printf("sending ---%s---\n", result.data.data_val);
 #endif
-		}
-		else
+		} else {
 			result.data.data_val = NULL;
+		}
 
 		if (links[argp->lid]->aborted) {
 			result.error = ERR_ABORT;
@@ -319,17 +336,18 @@ device_read_1_svc(Device_ReadParms *argp, struct svc_req *rqstp) {
 }
 
 Device_ReadStbResp *
-device_readstb_1_svc(Device_GenericParms *argp, struct svc_req *rqstp) {
+device_readstb_1_svc(Device_GenericParms *argp, struct svc_req *rqstp)
+{
 	static Device_ReadStbResp result;
 	memset(&result, 0, sizeof(result));
 #ifdef DEBUG
 	printf("device_readstb_1_svc()\n");
 #endif
-	if (!isValidLink(argp->lid))
+	if (!isValidLink(argp->lid)) {
 		result.error = ERR_INVALIDLINKINDENTIFIER;
-	else if (isLocked() && !haveLock(argp->lid) && !waitForLock(argp->flags, argp->lock_timeout))
+	} else if (isLocked() && !haveLock(argp->lid) && !waitForLock(argp->flags, argp->lock_timeout)) {
 		result.error = ERR_DEVICELOCKEDBYANOTHERLINK;
-	else {
+	} else {
 		touchlink(argp->lid);
 		result.stb = GPIB_and_VXI_get_STB();
 	}
@@ -337,16 +355,17 @@ device_readstb_1_svc(Device_GenericParms *argp, struct svc_req *rqstp) {
 }
 
 Device_Error *
-device_trigger_1_svc(Device_GenericParms *argp, struct svc_req *rqstp) {
+device_trigger_1_svc(Device_GenericParms *argp, struct svc_req *rqstp)
+{
 	static Device_Error result;
 #ifdef DEBUG
 	printf("device_trigger_1_svc()\n");
 #endif
-	if (!isValidLink(argp->lid))
+	if (!isValidLink(argp->lid)) {
 		result.error = ERR_INVALIDLINKINDENTIFIER;
-	else if (isLocked() && !haveLock(argp->lid) && !waitForLock(argp->flags, argp->lock_timeout))
+	} else if (isLocked() && !haveLock(argp->lid) && !waitForLock(argp->flags, argp->lock_timeout)) {
 		result.error = ERR_DEVICELOCKEDBYANOTHERLINK;
-	else {
+	} else {
 		touchlink(argp->lid);
 		result.error = ERR_OPERATIONNOTSUPPORTED;
 	}
@@ -354,16 +373,17 @@ device_trigger_1_svc(Device_GenericParms *argp, struct svc_req *rqstp) {
 }
 
 Device_Error *
-device_clear_1_svc(Device_GenericParms *argp, struct svc_req *rqstp) {
+device_clear_1_svc(Device_GenericParms *argp, struct svc_req *rqstp)
+{
 	static Device_Error result;
 #ifdef DEBUG
 	printf("device_clear_1_svc()\n");
 #endif
-	if (!isValidLink(argp->lid))
+	if (!isValidLink(argp->lid)) {
 		result.error = ERR_INVALIDLINKINDENTIFIER;
-	else if (isLocked() && !haveLock(argp->lid) && !waitForLock(argp->flags, argp->lock_timeout))
+	} else if (isLocked() && !haveLock(argp->lid) && !waitForLock(argp->flags, argp->lock_timeout)) {
 		result.error = ERR_DEVICELOCKEDBYANOTHERLINK;
-	else {
+	} else {
 		touchlink(argp->lid);
 		result.error = 0;
 		GPIB_and_VXI_device_clear();
@@ -372,19 +392,20 @@ device_clear_1_svc(Device_GenericParms *argp, struct svc_req *rqstp) {
 }
 
 Device_Error *
-device_remote_1_svc(Device_GenericParms *argp, struct svc_req *rqstp) {
+device_remote_1_svc(Device_GenericParms *argp, struct svc_req *rqstp)
+{
 	static Device_Error result;
 #ifdef DEBUG
 	printf("device_remote_1_svc()\n");
 #endif
-	if (!isValidLink(argp->lid))
+	if (!isValidLink(argp->lid)) {
 		result.error = ERR_INVALIDLINKINDENTIFIER;
-	else if (isLocked() && !haveLock(argp->lid) && !waitForLock(argp->flags, argp->lock_timeout))
+	} else if (isLocked() && !haveLock(argp->lid) && !waitForLock(argp->flags, argp->lock_timeout)) {
 		result.error = ERR_DEVICELOCKEDBYANOTHERLINK;
-	else {
-		if (isLocked() && !haveLock(argp->lid))
+	} else {
+		if (isLocked() && !haveLock(argp->lid)) {
 			result.error = ERR_DEVICELOCKEDBYANOTHERLINK;
-		else {
+		} else {
 			touchlink(argp->lid);
 			result.error = 0;
 			globals.Remote.vxi_panel_lock = 1;
@@ -394,19 +415,20 @@ device_remote_1_svc(Device_GenericParms *argp, struct svc_req *rqstp) {
 }
 
 Device_Error *
-device_local_1_svc(Device_GenericParms *argp, struct svc_req *rqstp) {
+device_local_1_svc(Device_GenericParms *argp, struct svc_req *rqstp)
+{
 	static Device_Error result;
 #ifdef DEBUG
 	printf("device_local_1_svc()\n");
 #endif
-	if (!isValidLink(argp->lid))
+	if (!isValidLink(argp->lid)) {
 		result.error = ERR_INVALIDLINKINDENTIFIER;
-	else if (isLocked() && !haveLock(argp->lid) && !waitForLock(argp->flags, argp->lock_timeout))
+	} else if (isLocked() && !haveLock(argp->lid) && !waitForLock(argp->flags, argp->lock_timeout)) {
 		result.error = ERR_DEVICELOCKEDBYANOTHERLINK;
-	else {
-		if (isLocked() && !haveLock(argp->lid))
+	} else {
+		if (isLocked() && !haveLock(argp->lid)) {
 			result.error = ERR_DEVICELOCKEDBYANOTHERLINK;
-		else {
+		} else {
 			touchlink(argp->lid);
 			result.error = 0;
 			globals.Remote.vxi_panel_lock = 0;
@@ -416,21 +438,21 @@ device_local_1_svc(Device_GenericParms *argp, struct svc_req *rqstp) {
 }
 
 Device_Error *
-device_lock_1_svc(Device_LockParms *argp, struct svc_req *rqstp) {
+device_lock_1_svc(Device_LockParms *argp, struct svc_req *rqstp)
+{
 	static Device_Error result;
 #ifdef DEBUG
 	printf("device_lock_1_svc()\n");
 #endif
-	if (!isValidLink(argp->lid))
+	if (!isValidLink(argp->lid)) {
 		result.error = ERR_INVALIDLINKINDENTIFIER;
-	else {
+	} else {
 		if (isLocked(argp->lid)) {
 			result.error = ERR_DEVICELOCKEDBYANOTHERLINK;
 			if (haveLock(argp->lid)) {
 				// maybe do something here to warn about a device trying to lock multiple times?
 			}
-		}
-		else {
+		} else {
 			touchlink(argp->lid);
 			lock(argp->lid);
 			result.error = 0;
@@ -440,17 +462,18 @@ device_lock_1_svc(Device_LockParms *argp, struct svc_req *rqstp) {
 }
 
 Device_Error *
-device_unlock_1_svc(Device_Link *argp, struct svc_req *rqstp) {
+device_unlock_1_svc(Device_Link *argp, struct svc_req *rqstp)
+{
 	static Device_Error result;
 #ifdef DEBUG
 	printf("device_unlock_1_svc()\n");
 #endif
-	if (!isValidLink(*argp))
+	if (!isValidLink(*argp)) {
 		result.error = ERR_INVALIDLINKINDENTIFIER;
-	else {
-		if (!isLocked(*argp) || !haveLock(*argp))
+	} else {
+		if (!isLocked(*argp) || !haveLock(*argp)) {
 			result.error = ERR_NOLOCKHELDBYTHISLINK;
-		else {
+		} else {
 			touchlink(*argp);
 			result.error = 0;
 			unlock();
@@ -459,7 +482,8 @@ device_unlock_1_svc(Device_Link *argp, struct svc_req *rqstp) {
 	return &result;
 }
 
-void vxi11_fireinterrupt() {
+void vxi11_fireinterrupt()
+{
 #ifdef DEBUG
 	printf("vxi11_fireinterrupt()\n");
 #endif
@@ -472,14 +496,15 @@ void vxi11_fireinterrupt() {
 }
 
 Device_Error *
-device_enable_srq_1_svc(Device_EnableSrqParms *argp, struct svc_req *rqstp) {
+device_enable_srq_1_svc(Device_EnableSrqParms *argp, struct svc_req *rqstp)
+{
 	static Device_Error result;
 #ifdef DEBUG
 	printf("device_enable_srq_1_svc()\n");
 #endif
-	if (!isValidLink(argp->lid))
+	if (!isValidLink(argp->lid)) {
 		result.error = ERR_INVALIDLINKINDENTIFIER;
-	else {
+	} else {
 		touchlink(argp->lid);
 		if (inthandler != NULL ) {
 			g_free(inthandler);
@@ -506,17 +531,18 @@ device_enable_srq_1_svc(Device_EnableSrqParms *argp, struct svc_req *rqstp) {
 }
 
 Device_DocmdResp *
-device_docmd_1_svc(Device_DocmdParms *argp, struct svc_req *rqstp) {
+device_docmd_1_svc(Device_DocmdParms *argp, struct svc_req *rqstp)
+{
 	static Device_DocmdResp result;
 	memset(&result, 0, sizeof(result));
 #ifdef DEBUG
 	printf("device_docmd_1_svc()\n");
 #endif
-	if (!isValidLink(argp->lid))
+	if (!isValidLink(argp->lid)) {
 		result.error = ERR_INVALIDLINKINDENTIFIER;
-	else if (isLocked() && !haveLock(argp->lid) && !waitForLock(argp->flags, argp->lock_timeout))
+	} else if (isLocked() && !haveLock(argp->lid) && !waitForLock(argp->flags, argp->lock_timeout)) {
 		result.error = ERR_DEVICELOCKEDBYANOTHERLINK;
-	else {
+	} else {
 		touchlink(argp->lid);
 		result.error = ERR_OPERATIONNOTSUPPORTED;
 	}
@@ -524,15 +550,16 @@ device_docmd_1_svc(Device_DocmdParms *argp, struct svc_req *rqstp) {
 }
 
 Device_Error *
-destroy_link_1_svc(Device_Link *argp, struct svc_req *rqstp) {
+destroy_link_1_svc(Device_Link *argp, struct svc_req *rqstp)
+{
 	static Device_Error result;
 #ifdef DEBUG
 	printf("destroy_link_1_svc()\n");
 #endif
 	int lid = *argp;
-	if (!isValidLink(lid))
+	if (!isValidLink(lid)) {
 		result.error = ERR_INVALIDLINKINDENTIFIER;
-	else {
+	} else {
 		freelink(links[lid]);
 		result.error = 0;
 	}
@@ -541,7 +568,8 @@ destroy_link_1_svc(Device_Link *argp, struct svc_req *rqstp) {
 }
 
 Device_Error *
-create_intr_chan_1_svc(Device_RemoteFunc *argp, struct svc_req *rqstp) {
+create_intr_chan_1_svc(Device_RemoteFunc *argp, struct svc_req *rqstp)
+{
 	static Device_Error result;
 
 	in_port_t port = htons(argp->hostPort);
@@ -569,15 +597,14 @@ create_intr_chan_1_svc(Device_RemoteFunc *argp, struct svc_req *rqstp) {
 		}
 	}
 
-	if (argp->progFamily != DEVICE_TCP || argp->progNum != DEVICE_INTR || argp->progVers != DEVICE_INTR_VERSION)
+	if (argp->progFamily != DEVICE_TCP || argp->progNum != DEVICE_INTR || argp->progVers != DEVICE_INTR_VERSION) {
 		result.error = ERR_OPERATIONNOTSUPPORTED;
-	else if (intclient != NULL ) {
+	} else if (intclient != NULL ) {
 #ifdef DEBUG
 		printf("Not creating interrupt channel, already exists\n");
 #endif
 		result.error = ERR_CHANNELALREADYESTABLISHED;
-	}
-	else {
+	} else {
 		struct sockaddr_in clientaddr;
 		clientaddr.sin_family = AF_INET;
 		clientaddr.sin_port = port;
@@ -589,8 +616,7 @@ create_intr_chan_1_svc(Device_RemoteFunc *argp, struct svc_req *rqstp) {
 			printf("Couldn't create interrupt channel client\n");
 #endif
 			result.error = ERR_CHANNELNOTESTABLISHED;
-		}
-		else {
+		} else {
 			intclient = clnt;
 			result.error = 0;
 #ifdef DEBUG
@@ -602,15 +628,15 @@ create_intr_chan_1_svc(Device_RemoteFunc *argp, struct svc_req *rqstp) {
 }
 
 Device_Error *
-destroy_intr_chan_1_svc(void *argp, struct svc_req *rqstp) {
+destroy_intr_chan_1_svc(void *argp, struct svc_req *rqstp)
+{
 	static Device_Error result;
 #ifdef DEBUG
 	printf("destroy_intr_chan_1_svc()\n");
 #endif
 	if (intclient == NULL ) {
 		result.error = ERR_CHANNELNOTESTABLISHED;
-	}
-	else {
+	} else {
 		clnt_destroy(intclient);
 		intclient = NULL;
 		result.error = 0;
diff --git a/vxi11_svc.c b/vxi11_svc.c
index e5c4b38..3ead3b1 100644
--- a/vxi11_svc.c
+++ b/vxi11_svc.c
@@ -17,7 +17,8 @@
 #define SIG_PF void(*)(int)
 #endif
 
-static void device_async_1(struct svc_req *rqstp, register SVCXPRT *transp) {
+static void device_async_1(struct svc_req *rqstp, register SVCXPRT *transp)
+{
 	union {
 		Device_Link device_abort_1_arg;
 	} argument;
@@ -26,19 +27,19 @@ static void device_async_1(struct svc_req *rqstp, register SVCXPRT *transp) {
 	char *(*local)(char *, struct svc_req *);
 
 	switch (rqstp->rq_proc) {
-		case NULLPROC:
-			(void) svc_sendreply(transp, (xdrproc_t) xdr_void, (char *) NULL);
-			return;
-
-		case device_abort:
-			_xdr_argument = (xdrproc_t) xdr_Device_Link;
-			_xdr_result = (xdrproc_t) xdr_Device_Error;
-			local = (char *(*)(char *, struct svc_req *)) device_abort_1_svc;
-			break;
+	case NULLPROC:
+		(void) svc_sendreply(transp, (xdrproc_t) xdr_void, (char *) NULL);
+		return;
 
-		default:
-			svcerr_noproc(transp);
-			return;
+	case device_abort:
+		_xdr_argument = (xdrproc_t) xdr_Device_Link;
+		_xdr_result = (xdrproc_t) xdr_Device_Error;
+		local = (char *(*)(char *, struct svc_req *)) device_abort_1_svc;
+		break;
+
+	default:
+		svcerr_noproc(transp);
+		return;
 	}
 	memset((char *) &argument, 0, sizeof(argument));
 	if (!svc_getargs(transp, (xdrproc_t) _xdr_argument, (caddr_t) &argument)) {
@@ -56,7 +57,8 @@ static void device_async_1(struct svc_req *rqstp, register SVCXPRT *transp) {
 	return;
 }
 
-static void device_core_1(struct svc_req *rqstp, register SVCXPRT *transp) {
+static void device_core_1(struct svc_req *rqstp, register SVCXPRT *transp)
+{
 	union {
 		Create_LinkParms create_link_1_arg;
 		Device_WriteParms device_write_1_arg;
@@ -78,103 +80,103 @@ static void device_core_1(struct svc_req *rqstp, register SVCXPRT *transp) {
 	char *(*local)(char *, struct svc_req *);
 
 	switch (rqstp->rq_proc) {
-		case NULLPROC:
-			(void) svc_sendreply(transp, (xdrproc_t) xdr_void, (char *) NULL);
-			return;
-
-		case create_link:
-			_xdr_argument = (xdrproc_t) xdr_Create_LinkParms;
-			_xdr_result = (xdrproc_t) xdr_Create_LinkResp;
-			local = (char *(*)(char *, struct svc_req *)) create_link_1_svc;
-			break;
+	case NULLPROC:
+		(void) svc_sendreply(transp, (xdrproc_t) xdr_void, (char *) NULL);
+		return;
 
-		case device_write:
-			_xdr_argument = (xdrproc_t) xdr_Device_WriteParms;
-			_xdr_result = (xdrproc_t) xdr_Device_WriteResp;
-			local = (char *(*)(char *, struct svc_req *)) device_write_1_svc;
-			break;
+	case create_link:
+		_xdr_argument = (xdrproc_t) xdr_Create_LinkParms;
+		_xdr_result = (xdrproc_t) xdr_Create_LinkResp;
+		local = (char *(*)(char *, struct svc_req *)) create_link_1_svc;
+		break;
 
-		case device_read:
-			_xdr_argument = (xdrproc_t) xdr_Device_ReadParms;
-			_xdr_result = (xdrproc_t) xdr_Device_ReadResp;
-			local = (char *(*)(char *, struct svc_req *)) device_read_1_svc;
-			break;
+	case device_write:
+		_xdr_argument = (xdrproc_t) xdr_Device_WriteParms;
+		_xdr_result = (xdrproc_t) xdr_Device_WriteResp;
+		local = (char *(*)(char *, struct svc_req *)) device_write_1_svc;
+		break;
 
-		case device_readstb:
-			_xdr_argument = (xdrproc_t) xdr_Device_GenericParms;
-			_xdr_result = (xdrproc_t) xdr_Device_ReadStbResp;
-			local = (char *(*)(char *, struct svc_req *)) device_readstb_1_svc;
-			break;
+	case device_read:
+		_xdr_argument = (xdrproc_t) xdr_Device_ReadParms;
+		_xdr_result = (xdrproc_t) xdr_Device_ReadResp;
+		local = (char *(*)(char *, struct svc_req *)) device_read_1_svc;
+		break;
 
-		case device_trigger:
-			_xdr_argument = (xdrproc_t) xdr_Device_GenericParms;
-			_xdr_result = (xdrproc_t) xdr_Device_Error;
-			local = (char *(*)(char *, struct svc_req *)) device_trigger_1_svc;
-			break;
+	case device_readstb:
+		_xdr_argument = (xdrproc_t) xdr_Device_GenericParms;
+		_xdr_result = (xdrproc_t) xdr_Device_ReadStbResp;
+		local = (char *(*)(char *, struct svc_req *)) device_readstb_1_svc;
+		break;
 
-		case device_clear:
-			_xdr_argument = (xdrproc_t) xdr_Device_GenericParms;
-			_xdr_result = (xdrproc_t) xdr_Device_Error;
-			local = (char *(*)(char *, struct svc_req *)) device_clear_1_svc;
-			break;
+	case device_trigger:
+		_xdr_argument = (xdrproc_t) xdr_Device_GenericParms;
+		_xdr_result = (xdrproc_t) xdr_Device_Error;
+		local = (char *(*)(char *, struct svc_req *)) device_trigger_1_svc;
+		break;
 
-		case device_remote:
-			_xdr_argument = (xdrproc_t) xdr_Device_GenericParms;
-			_xdr_result = (xdrproc_t) xdr_Device_Error;
-			local = (char *(*)(char *, struct svc_req *)) device_remote_1_svc;
-			break;
+	case device_clear:
+		_xdr_argument = (xdrproc_t) xdr_Device_GenericParms;
+		_xdr_result = (xdrproc_t) xdr_Device_Error;
+		local = (char *(*)(char *, struct svc_req *)) device_clear_1_svc;
+		break;
 
-		case device_local:
-			_xdr_argument = (xdrproc_t) xdr_Device_GenericParms;
-			_xdr_result = (xdrproc_t) xdr_Device_Error;
-			local = (char *(*)(char *, struct svc_req *)) device_local_1_svc;
-			break;
+	case device_remote:
+		_xdr_argument = (xdrproc_t) xdr_Device_GenericParms;
+		_xdr_result = (xdrproc_t) xdr_Device_Error;
+		local = (char *(*)(char *, struct svc_req *)) device_remote_1_svc;
+		break;
 
-		case device_lock:
-			_xdr_argument = (xdrproc_t) xdr_Device_LockParms;
-			_xdr_result = (xdrproc_t) xdr_Device_Error;
-			local = (char *(*)(char *, struct svc_req *)) device_lock_1_svc;
-			break;
+	case device_local:
+		_xdr_argument = (xdrproc_t) xdr_Device_GenericParms;
+		_xdr_result = (xdrproc_t) xdr_Device_Error;
+		local = (char *(*)(char *, struct svc_req *)) device_local_1_svc;
+		break;
 
-		case device_unlock:
-			_xdr_argument = (xdrproc_t) xdr_Device_Link;
-			_xdr_result = (xdrproc_t) xdr_Device_Error;
-			local = (char *(*)(char *, struct svc_req *)) device_unlock_1_svc;
-			break;
+	case device_lock:
+		_xdr_argument = (xdrproc_t) xdr_Device_LockParms;
+		_xdr_result = (xdrproc_t) xdr_Device_Error;
+		local = (char *(*)(char *, struct svc_req *)) device_lock_1_svc;
+		break;
 
-		case device_enable_srq:
-			_xdr_argument = (xdrproc_t) xdr_Device_EnableSrqParms;
-			_xdr_result = (xdrproc_t) xdr_Device_Error;
-			local = (char *(*)(char *, struct svc_req *)) device_enable_srq_1_svc;
-			break;
+	case device_unlock:
+		_xdr_argument = (xdrproc_t) xdr_Device_Link;
+		_xdr_result = (xdrproc_t) xdr_Device_Error;
+		local = (char *(*)(char *, struct svc_req *)) device_unlock_1_svc;
+		break;
 
-		case device_docmd:
-			_xdr_argument = (xdrproc_t) xdr_Device_DocmdParms;
-			_xdr_result = (xdrproc_t) xdr_Device_DocmdResp;
-			local = (char *(*)(char *, struct svc_req *)) device_docmd_1_svc;
-			break;
+	case device_enable_srq:
+		_xdr_argument = (xdrproc_t) xdr_Device_EnableSrqParms;
+		_xdr_result = (xdrproc_t) xdr_Device_Error;
+		local = (char *(*)(char *, struct svc_req *)) device_enable_srq_1_svc;
+		break;
 
-		case destroy_link:
-			_xdr_argument = (xdrproc_t) xdr_Device_Link;
-			_xdr_result = (xdrproc_t) xdr_Device_Error;
-			local = (char *(*)(char *, struct svc_req *)) destroy_link_1_svc;
-			break;
+	case device_docmd:
+		_xdr_argument = (xdrproc_t) xdr_Device_DocmdParms;
+		_xdr_result = (xdrproc_t) xdr_Device_DocmdResp;
+		local = (char *(*)(char *, struct svc_req *)) device_docmd_1_svc;
+		break;
 
-		case create_intr_chan:
-			_xdr_argument = (xdrproc_t) xdr_Device_RemoteFunc;
-			_xdr_result = (xdrproc_t) xdr_Device_Error;
-			local = (char *(*)(char *, struct svc_req *)) create_intr_chan_1_svc;
-			break;
+	case destroy_link:
+		_xdr_argument = (xdrproc_t) xdr_Device_Link;
+		_xdr_result = (xdrproc_t) xdr_Device_Error;
+		local = (char *(*)(char *, struct svc_req *)) destroy_link_1_svc;
+		break;
 
-		case destroy_intr_chan:
-			_xdr_argument = (xdrproc_t) xdr_void;
-			_xdr_result = (xdrproc_t) xdr_Device_Error;
-			local = (char *(*)(char *, struct svc_req *)) destroy_intr_chan_1_svc;
-			break;
+	case create_intr_chan:
+		_xdr_argument = (xdrproc_t) xdr_Device_RemoteFunc;
+		_xdr_result = (xdrproc_t) xdr_Device_Error;
+		local = (char *(*)(char *, struct svc_req *)) create_intr_chan_1_svc;
+		break;
 
-		default:
-			svcerr_noproc(transp);
-			return;
+	case destroy_intr_chan:
+		_xdr_argument = (xdrproc_t) xdr_void;
+		_xdr_result = (xdrproc_t) xdr_Device_Error;
+		local = (char *(*)(char *, struct svc_req *)) destroy_intr_chan_1_svc;
+		break;
+
+	default:
+		svcerr_noproc(transp);
+		return;
 	}
 	memset((char *) &argument, 0, sizeof(argument));
 	if (!svc_getargs(transp, (xdrproc_t) _xdr_argument, (caddr_t) &argument)) {
@@ -192,7 +194,8 @@ static void device_core_1(struct svc_req *rqstp, register SVCXPRT *transp) {
 	return;
 }
 
-void vxi_main() {
+void vxi_main()
+{
 
 	printf("VXI service started\n");
 
@@ -235,8 +238,9 @@ void vxi_main() {
 
 	while (1) {
 		int max_pollfd = svc_max_pollfd;
-		if (max_pollfd == 0 && svc_pollfd == NULL)
+		if (max_pollfd == 0 && svc_pollfd == NULL) {
 			break;
+		}
 
 		if (last_max_pollfd != max_pollfd) {
 			struct pollfd *new_pollfd = realloc(my_pollfd, sizeof(struct pollfd) * max_pollfd);
@@ -258,18 +262,19 @@ void vxi_main() {
 		j = poll(my_pollfd, max_pollfd, VXI11_DEFAULT_TIMEOUT);
 
 		for (i = 0; i < max_pollfd; i++) {
-			if (my_pollfd[i].revents & POLLRDHUP)
+			if (my_pollfd[i].revents & POLLRDHUP) {
 				vxi11_deadsocketcallback(my_pollfd[i].fd);
+			}
 		}
 
 		switch (j) {
-			case -1:
-				break;
-			case 0:
-				continue;
-			default:
-				svc_getreq_poll(my_pollfd, i);
-				continue;
+		case -1:
+			break;
+		case 0:
+			continue;
+		default:
+			svc_getreq_poll(my_pollfd, i);
+			continue;
 		}
 		break;
 	}
diff --git a/vxi11_xdr.c b/vxi11_xdr.c
index e6cf799..c65c9db 120000..100644
--- a/vxi11_xdr.c
+++ b/vxi11_xdr.c
@@ -1 +1,565 @@
-libvxi11client/vxi11_xdr.c
\ No newline at end of file
+/*
+ * Please do not edit this file.
+ * It was generated using rpcgen.
+ */
+
+#include "vxi11.h"
+
+bool_t
+xdr_Device_Link (XDR *xdrs, Device_Link *objp)
+{
+	register int32_t *buf;
+
+	if (!xdr_long (xdrs, objp)) {
+		return FALSE;
+	}
+	return TRUE;
+}
+
+bool_t
+xdr_Device_AddrFamily (XDR *xdrs, Device_AddrFamily *objp)
+{
+	register int32_t *buf;
+
+	if (!xdr_enum (xdrs, (enum_t *) objp)) {
+		return FALSE;
+	}
+	return TRUE;
+}
+
+bool_t
+xdr_Device_Flags (XDR *xdrs, Device_Flags *objp)
+{
+	register int32_t *buf;
+
+	if (!xdr_long (xdrs, objp)) {
+		return FALSE;
+	}
+	return TRUE;
+}
+
+bool_t
+xdr_Device_ErrorCode (XDR *xdrs, Device_ErrorCode *objp)
+{
+	register int32_t *buf;
+
+	if (!xdr_long (xdrs, objp)) {
+		return FALSE;
+	}
+	return TRUE;
+}
+
+bool_t
+xdr_Device_Error (XDR *xdrs, Device_Error *objp)
+{
+	register int32_t *buf;
+
+	if (!xdr_Device_ErrorCode (xdrs, &objp->error)) {
+		return FALSE;
+	}
+	return TRUE;
+}
+
+bool_t
+xdr_Create_LinkParms (XDR *xdrs, Create_LinkParms *objp)
+{
+	register int32_t *buf;
+
+
+	if (xdrs->x_op == XDR_ENCODE) {
+		buf = XDR_INLINE (xdrs, 3 * BYTES_PER_XDR_UNIT);
+		if (buf == NULL) {
+			if (!xdr_long (xdrs, &objp->clientId)) {
+				return FALSE;
+			}
+			if (!xdr_bool (xdrs, &objp->lockDevice)) {
+				return FALSE;
+			}
+			if (!xdr_u_long (xdrs, &objp->lock_timeout)) {
+				return FALSE;
+			}
+
+		} else {
+			IXDR_PUT_LONG(buf, objp->clientId);
+			IXDR_PUT_BOOL(buf, objp->lockDevice);
+			IXDR_PUT_U_LONG(buf, objp->lock_timeout);
+		}
+		if (!xdr_string (xdrs, &objp->device, ~0)) {
+			return FALSE;
+		}
+		return TRUE;
+	} else if (xdrs->x_op == XDR_DECODE) {
+		buf = XDR_INLINE (xdrs, 3 * BYTES_PER_XDR_UNIT);
+		if (buf == NULL) {
+			if (!xdr_long (xdrs, &objp->clientId)) {
+				return FALSE;
+			}
+			if (!xdr_bool (xdrs, &objp->lockDevice)) {
+				return FALSE;
+			}
+			if (!xdr_u_long (xdrs, &objp->lock_timeout)) {
+				return FALSE;
+			}
+
+		} else {
+			objp->clientId = IXDR_GET_LONG(buf);
+			objp->lockDevice = IXDR_GET_BOOL(buf);
+			objp->lock_timeout = IXDR_GET_U_LONG(buf);
+		}
+		if (!xdr_string (xdrs, &objp->device, ~0)) {
+			return FALSE;
+		}
+		return TRUE;
+	}
+
+	if (!xdr_long (xdrs, &objp->clientId)) {
+		return FALSE;
+	}
+	if (!xdr_bool (xdrs, &objp->lockDevice)) {
+		return FALSE;
+	}
+	if (!xdr_u_long (xdrs, &objp->lock_timeout)) {
+		return FALSE;
+	}
+	if (!xdr_string (xdrs, &objp->device, ~0)) {
+		return FALSE;
+	}
+	return TRUE;
+}
+
+bool_t
+xdr_Create_LinkResp (XDR *xdrs, Create_LinkResp *objp)
+{
+	register int32_t *buf;
+
+	if (!xdr_Device_ErrorCode (xdrs, &objp->error)) {
+		return FALSE;
+	}
+	if (!xdr_Device_Link (xdrs, &objp->lid)) {
+		return FALSE;
+	}
+	if (!xdr_u_short (xdrs, &objp->abortPort)) {
+		return FALSE;
+	}
+	if (!xdr_u_long (xdrs, &objp->maxRecvSize)) {
+		return FALSE;
+	}
+	return TRUE;
+}
+
+bool_t
+xdr_Device_WriteParms (XDR *xdrs, Device_WriteParms *objp)
+{
+	register int32_t *buf;
+
+	if (!xdr_Device_Link (xdrs, &objp->lid)) {
+		return FALSE;
+	}
+	if (!xdr_u_long (xdrs, &objp->io_timeout)) {
+		return FALSE;
+	}
+	if (!xdr_u_long (xdrs, &objp->lock_timeout)) {
+		return FALSE;
+	}
+	if (!xdr_Device_Flags (xdrs, &objp->flags)) {
+		return FALSE;
+	}
+	if (!xdr_bytes (xdrs, (char **)&objp->data.data_val, (u_int *) &objp->data.data_len, ~0)) {
+		return FALSE;
+	}
+	return TRUE;
+}
+
+bool_t
+xdr_Device_WriteResp (XDR *xdrs, Device_WriteResp *objp)
+{
+	register int32_t *buf;
+
+	if (!xdr_Device_ErrorCode (xdrs, &objp->error)) {
+		return FALSE;
+	}
+	if (!xdr_u_long (xdrs, &objp->size)) {
+		return FALSE;
+	}
+	return TRUE;
+}
+
+bool_t
+xdr_Device_ReadParms (XDR *xdrs, Device_ReadParms *objp)
+{
+	register int32_t *buf;
+
+
+	if (xdrs->x_op == XDR_ENCODE) {
+		if (!xdr_Device_Link (xdrs, &objp->lid)) {
+			return FALSE;
+		}
+		buf = XDR_INLINE (xdrs, 3 * BYTES_PER_XDR_UNIT);
+		if (buf == NULL) {
+			if (!xdr_u_long (xdrs, &objp->requestSize)) {
+				return FALSE;
+			}
+			if (!xdr_u_long (xdrs, &objp->io_timeout)) {
+				return FALSE;
+			}
+			if (!xdr_u_long (xdrs, &objp->lock_timeout)) {
+				return FALSE;
+			}
+
+		} else {
+			IXDR_PUT_U_LONG(buf, objp->requestSize);
+			IXDR_PUT_U_LONG(buf, objp->io_timeout);
+			IXDR_PUT_U_LONG(buf, objp->lock_timeout);
+		}
+		if (!xdr_Device_Flags (xdrs, &objp->flags)) {
+			return FALSE;
+		}
+		if (!xdr_char (xdrs, &objp->termChar)) {
+			return FALSE;
+		}
+		return TRUE;
+	} else if (xdrs->x_op == XDR_DECODE) {
+		if (!xdr_Device_Link (xdrs, &objp->lid)) {
+			return FALSE;
+		}
+		buf = XDR_INLINE (xdrs, 3 * BYTES_PER_XDR_UNIT);
+		if (buf == NULL) {
+			if (!xdr_u_long (xdrs, &objp->requestSize)) {
+				return FALSE;
+			}
+			if (!xdr_u_long (xdrs, &objp->io_timeout)) {
+				return FALSE;
+			}
+			if (!xdr_u_long (xdrs, &objp->lock_timeout)) {
+				return FALSE;
+			}
+
+		} else {
+			objp->requestSize = IXDR_GET_U_LONG(buf);
+			objp->io_timeout = IXDR_GET_U_LONG(buf);
+			objp->lock_timeout = IXDR_GET_U_LONG(buf);
+		}
+		if (!xdr_Device_Flags (xdrs, &objp->flags)) {
+			return FALSE;
+		}
+		if (!xdr_char (xdrs, &objp->termChar)) {
+			return FALSE;
+		}
+		return TRUE;
+	}
+
+	if (!xdr_Device_Link (xdrs, &objp->lid)) {
+		return FALSE;
+	}
+	if (!xdr_u_long (xdrs, &objp->requestSize)) {
+		return FALSE;
+	}
+	if (!xdr_u_long (xdrs, &objp->io_timeout)) {
+		return FALSE;
+	}
+	if (!xdr_u_long (xdrs, &objp->lock_timeout)) {
+		return FALSE;
+	}
+	if (!xdr_Device_Flags (xdrs, &objp->flags)) {
+		return FALSE;
+	}
+	if (!xdr_char (xdrs, &objp->termChar)) {
+		return FALSE;
+	}
+	return TRUE;
+}
+
+bool_t
+xdr_Device_ReadResp (XDR *xdrs, Device_ReadResp *objp)
+{
+	register int32_t *buf;
+
+	if (!xdr_Device_ErrorCode (xdrs, &objp->error)) {
+		return FALSE;
+	}
+	if (!xdr_long (xdrs, &objp->reason)) {
+		return FALSE;
+	}
+	if (!xdr_bytes (xdrs, (char **)&objp->data.data_val, (u_int *) &objp->data.data_len, ~0)) {
+		return FALSE;
+	}
+	return TRUE;
+}
+
+bool_t
+xdr_Device_ReadStbResp (XDR *xdrs, Device_ReadStbResp *objp)
+{
+	register int32_t *buf;
+
+	if (!xdr_Device_ErrorCode (xdrs, &objp->error)) {
+		return FALSE;
+	}
+	if (!xdr_u_char (xdrs, &objp->stb)) {
+		return FALSE;
+	}
+	return TRUE;
+}
+
+bool_t
+xdr_Device_GenericParms (XDR *xdrs, Device_GenericParms *objp)
+{
+	register int32_t *buf;
+
+	if (!xdr_Device_Link (xdrs, &objp->lid)) {
+		return FALSE;
+	}
+	if (!xdr_Device_Flags (xdrs, &objp->flags)) {
+		return FALSE;
+	}
+	if (!xdr_u_long (xdrs, &objp->lock_timeout)) {
+		return FALSE;
+	}
+	if (!xdr_u_long (xdrs, &objp->io_timeout)) {
+		return FALSE;
+	}
+	return TRUE;
+}
+
+bool_t
+xdr_Device_RemoteFunc (XDR *xdrs, Device_RemoteFunc *objp)
+{
+	register int32_t *buf;
+
+
+	if (xdrs->x_op == XDR_ENCODE) {
+		buf = XDR_INLINE (xdrs, 4 * BYTES_PER_XDR_UNIT);
+		if (buf == NULL) {
+			if (!xdr_u_long (xdrs, &objp->hostAddr)) {
+				return FALSE;
+			}
+			if (!xdr_u_long (xdrs, &objp->hostPort)) {
+				return FALSE;
+			}
+			if (!xdr_u_long (xdrs, &objp->progNum)) {
+				return FALSE;
+			}
+			if (!xdr_u_long (xdrs, &objp->progVers)) {
+				return FALSE;
+			}
+
+		} else {
+			IXDR_PUT_U_LONG(buf, objp->hostAddr);
+			IXDR_PUT_U_LONG(buf, objp->hostPort);
+			IXDR_PUT_U_LONG(buf, objp->progNum);
+			IXDR_PUT_U_LONG(buf, objp->progVers);
+		}
+		if (!xdr_Device_AddrFamily (xdrs, &objp->progFamily)) {
+			return FALSE;
+		}
+		return TRUE;
+	} else if (xdrs->x_op == XDR_DECODE) {
+		buf = XDR_INLINE (xdrs, 4 * BYTES_PER_XDR_UNIT);
+		if (buf == NULL) {
+			if (!xdr_u_long (xdrs, &objp->hostAddr)) {
+				return FALSE;
+			}
+			if (!xdr_u_long (xdrs, &objp->hostPort)) {
+				return FALSE;
+			}
+			if (!xdr_u_long (xdrs, &objp->progNum)) {
+				return FALSE;
+			}
+			if (!xdr_u_long (xdrs, &objp->progVers)) {
+				return FALSE;
+			}
+
+		} else {
+			objp->hostAddr = IXDR_GET_U_LONG(buf);
+			objp->hostPort = IXDR_GET_U_LONG(buf);
+			objp->progNum = IXDR_GET_U_LONG(buf);
+			objp->progVers = IXDR_GET_U_LONG(buf);
+		}
+		if (!xdr_Device_AddrFamily (xdrs, &objp->progFamily)) {
+			return FALSE;
+		}
+		return TRUE;
+	}
+
+	if (!xdr_u_long (xdrs, &objp->hostAddr)) {
+		return FALSE;
+	}
+	if (!xdr_u_long (xdrs, &objp->hostPort)) {
+		return FALSE;
+	}
+	if (!xdr_u_long (xdrs, &objp->progNum)) {
+		return FALSE;
+	}
+	if (!xdr_u_long (xdrs, &objp->progVers)) {
+		return FALSE;
+	}
+	if (!xdr_Device_AddrFamily (xdrs, &objp->progFamily)) {
+		return FALSE;
+	}
+	return TRUE;
+}
+
+bool_t
+xdr_Device_EnableSrqParms (XDR *xdrs, Device_EnableSrqParms *objp)
+{
+	register int32_t *buf;
+
+	if (!xdr_Device_Link (xdrs, &objp->lid)) {
+		return FALSE;
+	}
+	if (!xdr_bool (xdrs, &objp->enable)) {
+		return FALSE;
+	}
+	if (!xdr_bytes (xdrs, (char **)&objp->handle.handle_val, (u_int *) &objp->handle.handle_len, 40)) {
+		return FALSE;
+	}
+	return TRUE;
+}
+
+bool_t
+xdr_Device_LockParms (XDR *xdrs, Device_LockParms *objp)
+{
+	register int32_t *buf;
+
+	if (!xdr_Device_Link (xdrs, &objp->lid)) {
+		return FALSE;
+	}
+	if (!xdr_Device_Flags (xdrs, &objp->flags)) {
+		return FALSE;
+	}
+	if (!xdr_u_long (xdrs, &objp->lock_timeout)) {
+		return FALSE;
+	}
+	return TRUE;
+}
+
+bool_t
+xdr_Device_DocmdParms (XDR *xdrs, Device_DocmdParms *objp)
+{
+	register int32_t *buf;
+
+
+	if (xdrs->x_op == XDR_ENCODE) {
+		if (!xdr_Device_Link (xdrs, &objp->lid)) {
+			return FALSE;
+		}
+		if (!xdr_Device_Flags (xdrs, &objp->flags)) {
+			return FALSE;
+		}
+		buf = XDR_INLINE (xdrs, 5 * BYTES_PER_XDR_UNIT);
+		if (buf == NULL) {
+			if (!xdr_u_long (xdrs, &objp->io_timeout)) {
+				return FALSE;
+			}
+			if (!xdr_u_long (xdrs, &objp->lock_timeout)) {
+				return FALSE;
+			}
+			if (!xdr_long (xdrs, &objp->cmd)) {
+				return FALSE;
+			}
+			if (!xdr_bool (xdrs, &objp->network_order)) {
+				return FALSE;
+			}
+			if (!xdr_long (xdrs, &objp->datasize)) {
+				return FALSE;
+			}
+
+		} else {
+			IXDR_PUT_U_LONG(buf, objp->io_timeout);
+			IXDR_PUT_U_LONG(buf, objp->lock_timeout);
+			IXDR_PUT_LONG(buf, objp->cmd);
+			IXDR_PUT_BOOL(buf, objp->network_order);
+			IXDR_PUT_LONG(buf, objp->datasize);
+		}
+		if (!xdr_bytes (xdrs, (char **)&objp->data_in.data_in_val, (u_int *) &objp->data_in.data_in_len, ~0)) {
+			return FALSE;
+		}
+		return TRUE;
+	} else if (xdrs->x_op == XDR_DECODE) {
+		if (!xdr_Device_Link (xdrs, &objp->lid)) {
+			return FALSE;
+		}
+		if (!xdr_Device_Flags (xdrs, &objp->flags)) {
+			return FALSE;
+		}
+		buf = XDR_INLINE (xdrs, 5 * BYTES_PER_XDR_UNIT);
+		if (buf == NULL) {
+			if (!xdr_u_long (xdrs, &objp->io_timeout)) {
+				return FALSE;
+			}
+			if (!xdr_u_long (xdrs, &objp->lock_timeout)) {
+				return FALSE;
+			}
+			if (!xdr_long (xdrs, &objp->cmd)) {
+				return FALSE;
+			}
+			if (!xdr_bool (xdrs, &objp->network_order)) {
+				return FALSE;
+			}
+			if (!xdr_long (xdrs, &objp->datasize)) {
+				return FALSE;
+			}
+
+		} else {
+			objp->io_timeout = IXDR_GET_U_LONG(buf);
+			objp->lock_timeout = IXDR_GET_U_LONG(buf);
+			objp->cmd = IXDR_GET_LONG(buf);
+			objp->network_order = IXDR_GET_BOOL(buf);
+			objp->datasize = IXDR_GET_LONG(buf);
+		}
+		if (!xdr_bytes (xdrs, (char **)&objp->data_in.data_in_val, (u_int *) &objp->data_in.data_in_len, ~0)) {
+			return FALSE;
+		}
+		return TRUE;
+	}
+
+	if (!xdr_Device_Link (xdrs, &objp->lid)) {
+		return FALSE;
+	}
+	if (!xdr_Device_Flags (xdrs, &objp->flags)) {
+		return FALSE;
+	}
+	if (!xdr_u_long (xdrs, &objp->io_timeout)) {
+		return FALSE;
+	}
+	if (!xdr_u_long (xdrs, &objp->lock_timeout)) {
+		return FALSE;
+	}
+	if (!xdr_long (xdrs, &objp->cmd)) {
+		return FALSE;
+	}
+	if (!xdr_bool (xdrs, &objp->network_order)) {
+		return FALSE;
+	}
+	if (!xdr_long (xdrs, &objp->datasize)) {
+		return FALSE;
+	}
+	if (!xdr_bytes (xdrs, (char **)&objp->data_in.data_in_val, (u_int *) &objp->data_in.data_in_len, ~0)) {
+		return FALSE;
+	}
+	return TRUE;
+}
+
+bool_t
+xdr_Device_DocmdResp (XDR *xdrs, Device_DocmdResp *objp)
+{
+	register int32_t *buf;
+
+	if (!xdr_Device_ErrorCode (xdrs, &objp->error)) {
+		return FALSE;
+	}
+	if (!xdr_bytes (xdrs, (char **)&objp->data_out.data_out_val, (u_int *) &objp->data_out.data_out_len, ~0)) {
+		return FALSE;
+	}
+	return TRUE;
+}
+
+bool_t
+xdr_Device_SrqParms (XDR *xdrs, Device_SrqParms *objp)
+{
+	register int32_t *buf;
+
+	if (!xdr_bytes (xdrs, (char **)&objp->handle.handle_val, (u_int *) &objp->handle.handle_len, ~0)) {
+		return FALSE;
+	}
+	return TRUE;
+}