libX11 xserver fontconfig mesa pixman xkbcomp xkeyboard-config git update

23 Mar 2012

1 files changed, 797 insertions, 847 deletions

diff --git a/xorg-server/os/xdmcp.c b/xorg-server/os/xdmcp.c
index 77f02da91..87f04b455 100644
--- a/xorg-server/os/xdmcp.c
+++ b/xorg-server/os/xdmcp.c
@@ -62,27 +62,29 @@
 
 static const char *defaultDisplayClass = COMPILEDDISPLAYCLASS;
 
-static int		    xdmcpSocket, sessionSocket;
-static xdmcp_states	    state;
+static int xdmcpSocket, sessionSocket;
+static xdmcp_states state;
+
 #if defined(IPv6) && defined(AF_INET6)
-static int		    xdmcpSocket6;
+static int xdmcpSocket6;
 static struct sockaddr_storage req_sockaddr;
 #else
-static struct sockaddr_in   req_sockaddr;
+static struct sockaddr_in req_sockaddr;
 #endif
-static int		    req_socklen;
-static CARD32		    SessionID;
-static CARD32		    timeOutTime;
-static int		    timeOutRtx;
-static CARD32		    defaultKeepaliveDormancy = XDM_DEF_DORMANCY;
-static CARD32		    keepaliveDormancy = XDM_DEF_DORMANCY;
-static CARD16		    DisplayNumber;
-static xdmcp_states	    XDM_INIT_STATE = XDM_OFF;
+static int req_socklen;
+static CARD32 SessionID;
+static CARD32 timeOutTime;
+static int timeOutRtx;
+static CARD32 defaultKeepaliveDormancy = XDM_DEF_DORMANCY;
+static CARD32 keepaliveDormancy = XDM_DEF_DORMANCY;
+static CARD16 DisplayNumber;
+static xdmcp_states XDM_INIT_STATE = XDM_OFF;
+
 #ifdef HASXDMAUTH
-static char		    *xdmAuthCookie;
+static char *xdmAuthCookie;
 #endif
 
-static XdmcpBuffer	    buffer;
+static XdmcpBuffer buffer;
 
 #if defined(IPv6) && defined(AF_INET6)
 
@@ -113,8 +115,8 @@ static struct addrinfo *mgrAddrFirst;
 
 #endif
 
-static SOCKADDR_TYPE		ManagerAddress;
-static SOCKADDR_TYPE		FromAddress;
+static SOCKADDR_TYPE ManagerAddress;
+static SOCKADDR_TYPE FromAddress;
 
 #ifdef SOCKLEN_FIELD
 #define ManagerAddressLen	SOCKLEN_FIELD(ManagerAddress)
@@ -125,67 +127,61 @@ static SOCKLEN_TYPE ManagerAddressLen, FromAddressLen;
 
 #if defined(IPv6) && defined(AF_INET6)
 static struct multicastinfo {
-    struct multicastinfo	*next;
-    struct addrinfo		*ai;
-    int				 hops;
+    struct multicastinfo *next;
+    struct addrinfo *ai;
+    int hops;
 } *mcastlist;
 #endif
 
-static void XdmcpAddHost(
-    const struct sockaddr    *from,
-    int			fromlen,
-    ARRAY8Ptr		AuthenticationName,
-    ARRAY8Ptr		hostname,
-    ARRAY8Ptr		status);
+static void XdmcpAddHost(const struct sockaddr *from,
+                         int fromlen,
+                         ARRAY8Ptr AuthenticationName,
+                         ARRAY8Ptr hostname, ARRAY8Ptr status);
 
-static void XdmcpSelectHost(
-    const struct sockaddr *host_sockaddr,
-    int			host_len,
-    ARRAY8Ptr		AuthenticationName);
+static void XdmcpSelectHost(const struct sockaddr *host_sockaddr,
+                            int host_len, ARRAY8Ptr AuthenticationName);
 
 static void get_xdmcp_sock(void);
 
 static void send_query_msg(void);
 
-static void recv_willing_msg(
-    struct sockaddr * /*from*/,
-    int /*fromlen*/,
-    unsigned /*length*/);
+static void recv_willing_msg(struct sockaddr * /*from */ ,
+                             int /*fromlen */ ,
+                             unsigned /*length */ );
 
 static void send_request_msg(void);
 
-static void recv_accept_msg(unsigned /*length*/);
+static void recv_accept_msg(unsigned /*length */ );
 
-static void recv_decline_msg(unsigned /*length*/);
+static void recv_decline_msg(unsigned /*length */ );
 
 static void send_manage_msg(void);
 
-static void recv_refuse_msg(unsigned /*length*/);
+static void recv_refuse_msg(unsigned /*length */ );
 
-static void recv_failed_msg(unsigned /*length*/);
+static void recv_failed_msg(unsigned /*length */ );
 
 static void send_keepalive_msg(void);
 
-static void recv_alive_msg(unsigned /*length*/);
+static void recv_alive_msg(unsigned /*length */ );
 
-static void XdmcpFatal(
-    const char * /*type*/,
-    ARRAY8Ptr /*status*/);
- 
-static void XdmcpWarning(const char * /*str*/);
+static void XdmcpFatal(const char * /*type */ ,
+                       ARRAY8Ptr /*status */ );
 
-static void get_manager_by_name(
-    int /*argc*/,
-    char ** /*argv*/,
-    int /*i*/);
+static void XdmcpWarning(const char * /*str */ );
 
-static void get_fromaddr_by_name(int /*argc*/, char ** /*argv*/, int /*i*/);
+static void get_manager_by_name(int /*argc */ ,
+                                char ** /*argv */ ,
+                                int /*i */ );
+
+static void get_fromaddr_by_name(int /*argc */ , char ** /*argv */ ,
+                                 int /*i */ );
 
 #if defined(IPv6) && defined(AF_INET6)
-static int get_mcast_options(int /*argc*/, char ** /*argv*/, int /*i*/);
+static int get_mcast_options(int /*argc */ , char ** /*argv */ , int /*i */ );
 #endif
 
-static void receive_packet(int /*socketfd*/);
+static void receive_packet(int /*socketfd */ );
 
 static void send_packet(void);
 
@@ -193,15 +189,13 @@ static void timeout(void);
 
 static void restart(void);
 
-static void XdmcpBlockHandler(
-    pointer /*data*/,
-    struct timeval ** /*wt*/,
-    pointer /*LastSelectMask*/);
+static void XdmcpBlockHandler(pointer /*data */ ,
+                              struct timeval ** /*wt */ ,
+                              pointer /*LastSelectMask */ );
 
-static void XdmcpWakeupHandler(
-    pointer /*data*/,
-    int /*i*/,
-    pointer /*LastSelectMask*/);
+static void XdmcpWakeupHandler(pointer /*data */ ,
+                               int /*i */ ,
+                               pointer /*LastSelectMask */ );
 
 /*
  * Register the Manufacturer display ID
@@ -210,23 +204,23 @@ static void XdmcpWakeupHandler(
 static ARRAY8 ManufacturerDisplayID;
 
 static void
-XdmcpRegisterManufacturerDisplayID (const char *name, int length)
+XdmcpRegisterManufacturerDisplayID(const char *name, int length)
 {
-    int	    i;
+    int i;
 
-    XdmcpDisposeARRAY8 (&ManufacturerDisplayID);
-    if (!XdmcpAllocARRAY8 (&ManufacturerDisplayID, length))
-	return;
+    XdmcpDisposeARRAY8(&ManufacturerDisplayID);
+    if (!XdmcpAllocARRAY8(&ManufacturerDisplayID, length))
+        return;
     for (i = 0; i < length; i++)
-	ManufacturerDisplayID.data[i] = (CARD8) name[i];
+        ManufacturerDisplayID.data[i] = (CARD8) name[i];
 }
 
-static unsigned short	xdm_udp_port = XDM_UDP_PORT;
-static Bool	OneSession = FALSE;
-static const char 	*xdm_from = NULL;
+static unsigned short xdm_udp_port = XDM_UDP_PORT;
+static Bool OneSession = FALSE;
+static const char *xdm_from = NULL;
 
 void
-XdmcpUseMsg (void)
+XdmcpUseMsg(void)
 {
     ErrorF("-query host-name       contact named host for XDMCP\n");
     ErrorF("-broadcast             broadcast for XDMCP\n");
@@ -235,7 +229,8 @@ XdmcpUseMsg (void)
 #endif
     ErrorF("-indirect host-name    contact named host for indirect XDMCP\n");
     ErrorF("-port port-num         UDP port number to send messages to\n");
-    ErrorF("-from local-address    specify the local address to connect from\n");
+    ErrorF
+        ("-from local-address    specify the local address to connect from\n");
     ErrorF("-once                  Terminate server after one session\n");
     ErrorF("-class display-class   specify display class to send in manage\n");
 #ifdef HASXDMAUTH
@@ -244,71 +239,71 @@ XdmcpUseMsg (void)
     ErrorF("-displayID display-id  manufacturer display ID for request\n");
 }
 
-int 
+int
 XdmcpOptions(int argc, char **argv, int i)
 {
     if (strcmp(argv[i], "-query") == 0) {
-	get_manager_by_name(argc, argv, i++);
-	XDM_INIT_STATE = XDM_QUERY;
-	AccessUsingXdmcp ();
-	return i + 1;
+        get_manager_by_name(argc, argv, i++);
+        XDM_INIT_STATE = XDM_QUERY;
+        AccessUsingXdmcp();
+        return i + 1;
     }
     if (strcmp(argv[i], "-broadcast") == 0) {
-	XDM_INIT_STATE = XDM_BROADCAST;
-	AccessUsingXdmcp ();
-	return i + 1;
+        XDM_INIT_STATE = XDM_BROADCAST;
+        AccessUsingXdmcp();
+        return i + 1;
     }
 #if defined(IPv6) && defined(AF_INET6)
     if (strcmp(argv[i], "-multicast") == 0) {
-	i = get_mcast_options(argc, argv, ++i);
-	XDM_INIT_STATE = XDM_MULTICAST;
-	AccessUsingXdmcp ();
-	return i + 1;
+        i = get_mcast_options(argc, argv, ++i);
+        XDM_INIT_STATE = XDM_MULTICAST;
+        AccessUsingXdmcp();
+        return i + 1;
     }
 #endif
     if (strcmp(argv[i], "-indirect") == 0) {
-	get_manager_by_name(argc, argv, i++);
-	XDM_INIT_STATE = XDM_INDIRECT;
-	AccessUsingXdmcp ();
-	return i + 1;
+        get_manager_by_name(argc, argv, i++);
+        XDM_INIT_STATE = XDM_INDIRECT;
+        AccessUsingXdmcp();
+        return i + 1;
     }
     if (strcmp(argv[i], "-port") == 0) {
-        if (++i == argc)  {
-	    FatalError("Xserver: missing port number in command line\n");
-	}
-	xdm_udp_port = (unsigned short) atoi(argv[i]);
-	return i + 1;
+        if (++i == argc) {
+            FatalError("Xserver: missing port number in command line\n");
+        }
+        xdm_udp_port = (unsigned short) atoi(argv[i]);
+        return i + 1;
     }
     if (strcmp(argv[i], "-from") == 0) {
-	get_fromaddr_by_name(argc, argv, ++i);
-	return i + 1;
+        get_fromaddr_by_name(argc, argv, ++i);
+        return i + 1;
     }
     if (strcmp(argv[i], "-once") == 0) {
-	OneSession = TRUE;
-	return i + 1;
+        OneSession = TRUE;
+        return i + 1;
     }
     if (strcmp(argv[i], "-class") == 0) {
-        if (++i == argc)  {
-	    FatalError("Xserver: missing class name in command line\n");
-	}
-	defaultDisplayClass = argv[i];
-	return i + 1;
+        if (++i == argc) {
+            FatalError("Xserver: missing class name in command line\n");
+        }
+        defaultDisplayClass = argv[i];
+        return i + 1;
     }
 #ifdef HASXDMAUTH
     if (strcmp(argv[i], "-cookie") == 0) {
-        if (++i == argc)  {
-	    FatalError("Xserver: missing cookie data in command line\n");
-	}
-	xdmAuthCookie = argv[i];
-	return i + 1;
+        if (++i == argc) {
+            FatalError("Xserver: missing cookie data in command line\n");
+        }
+        xdmAuthCookie = argv[i];
+        return i + 1;
     }
 #endif
     if (strcmp(argv[i], "-displayID") == 0) {
-        if (++i == argc)  {
-	    FatalError("Xserver: missing displayID in command line\n");
-	}
-	XdmcpRegisterManufacturerDisplayID (argv[i], strlen (argv[i]));
-	return i + 1;
+        if (++i == argc) {
+            FatalError("Xserver: missing displayID in command line\n");
+        }
+        XdmcpRegisterManufacturerDisplayID(argv[i], strlen(argv[i]));
+        return i + 1;
     }
     return i;
 }
@@ -319,7 +314,6 @@ XdmcpOptions(int argc, char **argv, int i)
  * state machine.
  */
 
-
 /*
  * Save all broadcast addresses away so BroadcastQuery
  * packets get sent everywhere
@@ -328,22 +322,23 @@ XdmcpOptions(int argc, char **argv, int i)
 #define MAX_BROADCAST	10
 
 /* This stays sockaddr_in since IPv6 doesn't support broadcast */
-static struct sockaddr_in   BroadcastAddresses[MAX_BROADCAST];
-static int		    NumBroadcastAddresses;
+static struct sockaddr_in BroadcastAddresses[MAX_BROADCAST];
+static int NumBroadcastAddresses;
 
 void
-XdmcpRegisterBroadcastAddress (const struct sockaddr_in *addr)
+XdmcpRegisterBroadcastAddress(const struct sockaddr_in *addr)
 {
-    struct sockaddr_in	*bcast;
+    struct sockaddr_in *bcast;
+
     if (NumBroadcastAddresses >= MAX_BROADCAST)
-	return;
+        return;
     bcast = &BroadcastAddresses[NumBroadcastAddresses++];
-    memset(bcast, 0, sizeof (struct sockaddr_in));
+    memset(bcast, 0, sizeof(struct sockaddr_in));
 #ifdef BSD44SOCKETS
     bcast->sin_len = addr->sin_len;
 #endif
     bcast->sin_family = addr->sin_family;
-    bcast->sin_port = htons (xdm_udp_port);
+    bcast->sin_port = htons(xdm_udp_port);
     bcast->sin_addr = addr->sin_addr;
 }
 
@@ -353,59 +348,59 @@ XdmcpRegisterBroadcastAddress (const struct sockaddr_in *addr)
  * the specified authentication type
  */
 
-static ARRAYofARRAY8	AuthenticationNames, AuthenticationDatas;
+static ARRAYofARRAY8 AuthenticationNames, AuthenticationDatas;
 typedef struct _AuthenticationFuncs {
-    ValidatorFunc    Validator;
-    GeneratorFunc    Generator;
-    AddAuthorFunc    AddAuth;
+    ValidatorFunc Validator;
+    GeneratorFunc Generator;
+    AddAuthorFunc AddAuth;
 } AuthenticationFuncsRec, *AuthenticationFuncsPtr;
 
-static AuthenticationFuncsPtr	AuthenticationFuncsList;
+static AuthenticationFuncsPtr AuthenticationFuncsList;
 
 void
-XdmcpRegisterAuthentication (
-    const char    *name,
-    int	    namelen,
-    const char    *data,
-    int	    datalen,
-    ValidatorFunc Validator,
-    GeneratorFunc Generator,
-    AddAuthorFunc AddAuth)
+XdmcpRegisterAuthentication(const char *name,
+                            int namelen,
+                            const char *data,
+                            int datalen,
+                            ValidatorFunc Validator,
+                            GeneratorFunc Generator, AddAuthorFunc AddAuth)
 {
-    int	    i;
-    ARRAY8  AuthenticationName, AuthenticationData;
-    static AuthenticationFuncsPtr	newFuncs;
-
-    if (!XdmcpAllocARRAY8 (&AuthenticationName, namelen))
-	return;
-    if (!XdmcpAllocARRAY8 (&AuthenticationData, datalen))
-    {
-	XdmcpDisposeARRAY8 (&AuthenticationName);
-	return;
+    int i;
+    ARRAY8 AuthenticationName, AuthenticationData;
+    static AuthenticationFuncsPtr newFuncs;
+
+    if (!XdmcpAllocARRAY8(&AuthenticationName, namelen))
+        return;
+    if (!XdmcpAllocARRAY8(&AuthenticationData, datalen)) {
+        XdmcpDisposeARRAY8(&AuthenticationName);
+        return;
     }
     for (i = 0; i < namelen; i++)
-	AuthenticationName.data[i] = name[i];
+        AuthenticationName.data[i] = name[i];
     for (i = 0; i < datalen; i++)
-	AuthenticationData.data[i] = data[i];
-    if (!(XdmcpReallocARRAYofARRAY8 (&AuthenticationNames,
-				     AuthenticationNames.length + 1) &&
-	  XdmcpReallocARRAYofARRAY8 (&AuthenticationDatas,
-				     AuthenticationDatas.length + 1) &&
-	  (newFuncs = malloc((AuthenticationNames.length + 1) * sizeof (AuthenticationFuncsRec)))))
-    {
-	XdmcpDisposeARRAY8 (&AuthenticationName);
-	XdmcpDisposeARRAY8 (&AuthenticationData);
-	return;
+        AuthenticationData.data[i] = data[i];
+    if (!(XdmcpReallocARRAYofARRAY8(&AuthenticationNames,
+                                    AuthenticationNames.length + 1) &&
+          XdmcpReallocARRAYofARRAY8(&AuthenticationDatas,
+                                    AuthenticationDatas.length + 1) &&
+          (newFuncs =
+           malloc((AuthenticationNames.length +
+                   1) * sizeof(AuthenticationFuncsRec))))) {
+        XdmcpDisposeARRAY8(&AuthenticationName);
+        XdmcpDisposeARRAY8(&AuthenticationData);
+        return;
     }
     for (i = 0; i < AuthenticationNames.length - 1; i++)
-	newFuncs[i] = AuthenticationFuncsList[i];
-    newFuncs[AuthenticationNames.length-1].Validator = Validator;
-    newFuncs[AuthenticationNames.length-1].Generator = Generator;
-    newFuncs[AuthenticationNames.length-1].AddAuth = AddAuth;
+        newFuncs[i] = AuthenticationFuncsList[i];
+    newFuncs[AuthenticationNames.length - 1].Validator = Validator;
+    newFuncs[AuthenticationNames.length - 1].Generator = Generator;
+    newFuncs[AuthenticationNames.length - 1].AddAuth = AddAuth;
     free(AuthenticationFuncsList);
     AuthenticationFuncsList = newFuncs;
-    AuthenticationNames.data[AuthenticationNames.length-1] = AuthenticationName;
-    AuthenticationDatas.data[AuthenticationDatas.length-1] = AuthenticationData;
+    AuthenticationNames.data[AuthenticationNames.length - 1] =
+        AuthenticationName;
+    AuthenticationDatas.data[AuthenticationDatas.length - 1] =
+        AuthenticationData;
 }
 
 /*
@@ -413,104 +408,103 @@ XdmcpRegisterAuthentication (
  * set by the manager of the host to be connected to.
  */
 
-static ARRAY8		noAuthenticationName = {(CARD16) 0, (CARD8Ptr) 0};
-static ARRAY8		noAuthenticationData = {(CARD16) 0, (CARD8Ptr) 0};
-static ARRAY8Ptr	AuthenticationName = &noAuthenticationName;
-static ARRAY8Ptr	AuthenticationData = &noAuthenticationData;
-static AuthenticationFuncsPtr	AuthenticationFuncs;
+static ARRAY8 noAuthenticationName = { (CARD16) 0, (CARD8Ptr) 0 };
+static ARRAY8 noAuthenticationData = { (CARD16) 0, (CARD8Ptr) 0 };
+
+static ARRAY8Ptr AuthenticationName = &noAuthenticationName;
+static ARRAY8Ptr AuthenticationData = &noAuthenticationData;
+static AuthenticationFuncsPtr AuthenticationFuncs;
 
 static void
-XdmcpSetAuthentication (const ARRAY8Ptr name)
+XdmcpSetAuthentication(const ARRAY8Ptr name)
 {
-    int	i;
+    int i;
 
     for (i = 0; i < AuthenticationNames.length; i++)
-	if (XdmcpARRAY8Equal (&AuthenticationNames.data[i], name))
-	{
-	    AuthenticationName = &AuthenticationNames.data[i];
-	    AuthenticationData = &AuthenticationDatas.data[i];
-	    AuthenticationFuncs = &AuthenticationFuncsList[i];
-	    break;
-	}
+        if (XdmcpARRAY8Equal(&AuthenticationNames.data[i], name)) {
+            AuthenticationName = &AuthenticationNames.data[i];
+            AuthenticationData = &AuthenticationDatas.data[i];
+            AuthenticationFuncs = &AuthenticationFuncsList[i];
+            break;
+        }
 }
 
 /*
  * Register the host address for the display
  */
 
-static ARRAY16		ConnectionTypes;
-static ARRAYofARRAY8	ConnectionAddresses;
-static long		xdmcpGeneration;
+static ARRAY16 ConnectionTypes;
+static ARRAYofARRAY8 ConnectionAddresses;
+static long xdmcpGeneration;
 
 void
-XdmcpRegisterConnection (
-    int	    type,
-    const char    *address,
-    int	    addrlen)
+XdmcpRegisterConnection(int type, const char *address, int addrlen)
 {
-    int	    i;
-    CARD8   *newAddress;
-
-    if (xdmcpGeneration != serverGeneration)
-    {
-	XdmcpDisposeARRAY16 (&ConnectionTypes);
-	XdmcpDisposeARRAYofARRAY8 (&ConnectionAddresses);
-	xdmcpGeneration = serverGeneration;
+    int i;
+    CARD8 *newAddress;
+
+    if (xdmcpGeneration != serverGeneration) {
+        XdmcpDisposeARRAY16(&ConnectionTypes);
+        XdmcpDisposeARRAYofARRAY8(&ConnectionAddresses);
+        xdmcpGeneration = serverGeneration;
     }
-    if (xdm_from != NULL) {	/* Only register the requested address */
-	const void *regAddr = address;
-	const void *fromAddr = NULL;
-	int regAddrlen = addrlen;
-
-	if (addrlen == sizeof(struct in_addr)) {
-	    if (SOCKADDR_FAMILY(FromAddress) == AF_INET) {
-		fromAddr = &((struct sockaddr_in *)&FromAddress)->sin_addr;
-	    } 
+    if (xdm_from != NULL) {     /* Only register the requested address */
+        const void *regAddr = address;
+        const void *fromAddr = NULL;
+        int regAddrlen = addrlen;
+
+        if (addrlen == sizeof(struct in_addr)) {
+            if (SOCKADDR_FAMILY(FromAddress) == AF_INET) {
+                fromAddr = &((struct sockaddr_in *) &FromAddress)->sin_addr;
+            }
 #if defined(IPv6) && defined(AF_INET6)
-	    else if ((SOCKADDR_FAMILY(FromAddress) == AF_INET6) &&
-	      IN6_IS_ADDR_V4MAPPED(
-		  &((struct sockaddr_in6 *)&FromAddress)->sin6_addr)) {
-		fromAddr = &((struct sockaddr_in6 *)&FromAddress)->sin6_addr.s6_addr[12];
-	    } 
+            else if ((SOCKADDR_FAMILY(FromAddress) == AF_INET6) &&
+                     IN6_IS_ADDR_V4MAPPED(&
+                                          ((struct sockaddr_in6 *)
+                                           &FromAddress)->sin6_addr)) {
+                fromAddr =
+                    &((struct sockaddr_in6 *) &FromAddress)->sin6_addr.
+                    s6_addr[12];
+            }
 #endif
-	}
+        }
 #if defined(IPv6) && defined(AF_INET6)
-	else if (addrlen == sizeof(struct in6_addr)) {
-	    if (SOCKADDR_FAMILY(FromAddress) == AF_INET6) {
-		fromAddr = &((struct sockaddr_in6 *)&FromAddress)->sin6_addr;
-	    } else if ((SOCKADDR_FAMILY(FromAddress) == AF_INET) &&
-	      IN6_IS_ADDR_V4MAPPED((const struct in6_addr *) address)) {
-		fromAddr = &((struct sockaddr_in *)&FromAddress)->sin_addr;
-		regAddr = &((struct sockaddr_in6 *)&address)->sin6_addr.s6_addr[12];
-		regAddrlen = sizeof(struct in_addr);
-	    }
-	}
+        else if (addrlen == sizeof(struct in6_addr)) {
+            if (SOCKADDR_FAMILY(FromAddress) == AF_INET6) {
+                fromAddr = &((struct sockaddr_in6 *) &FromAddress)->sin6_addr;
+            }
+            else if ((SOCKADDR_FAMILY(FromAddress) == AF_INET) &&
+                     IN6_IS_ADDR_V4MAPPED((const struct in6_addr *) address)) {
+                fromAddr = &((struct sockaddr_in *) &FromAddress)->sin_addr;
+                regAddr =
+                    &((struct sockaddr_in6 *) &address)->sin6_addr.s6_addr[12];
+                regAddrlen = sizeof(struct in_addr);
+            }
+        }
 #endif
-	if (!fromAddr || memcmp(regAddr, fromAddr, regAddrlen) != 0) {
-	    return;
-	}
+        if (!fromAddr || memcmp(regAddr, fromAddr, regAddrlen) != 0) {
+            return;
+        }
     }
     if (ConnectionAddresses.length + 1 == 256)
-	return;
-    newAddress = malloc(addrlen * sizeof (CARD8));
+        return;
+    newAddress = malloc(addrlen * sizeof(CARD8));
     if (!newAddress)
-	return;
-    if (!XdmcpReallocARRAY16 (&ConnectionTypes, ConnectionTypes.length + 1))
-    {
-	free(newAddress);
-	return;
+        return;
+    if (!XdmcpReallocARRAY16(&ConnectionTypes, ConnectionTypes.length + 1)) {
+        free(newAddress);
+        return;
     }
-    if (!XdmcpReallocARRAYofARRAY8 (&ConnectionAddresses,
-				    ConnectionAddresses.length +  1))
-    {
-	free(newAddress);
-	return;
+    if (!XdmcpReallocARRAYofARRAY8(&ConnectionAddresses,
+                                   ConnectionAddresses.length + 1)) {
+        free(newAddress);
+        return;
     }
     ConnectionTypes.data[ConnectionTypes.length - 1] = (CARD16) type;
     for (i = 0; i < addrlen; i++)
-	newAddress[i] = address[i];
-    ConnectionAddresses.data[ConnectionAddresses.length-1].data = newAddress;
-    ConnectionAddresses.data[ConnectionAddresses.length-1].length = addrlen;
+        newAddress[i] = address[i];
+    ConnectionAddresses.data[ConnectionAddresses.length - 1].data = newAddress;
+    ConnectionAddresses.data[ConnectionAddresses.length - 1].length = addrlen;
 }
 
 /*
@@ -518,51 +512,51 @@ XdmcpRegisterConnection (
  * to the manager.
  */
 
-static ARRAYofARRAY8	AuthorizationNames;
+static ARRAYofARRAY8 AuthorizationNames;
 
 void
-XdmcpRegisterAuthorizations (void)
+XdmcpRegisterAuthorizations(void)
 {
-    XdmcpDisposeARRAYofARRAY8 (&AuthorizationNames);
-    RegisterAuthorizations ();
+    XdmcpDisposeARRAYofARRAY8(&AuthorizationNames);
+    RegisterAuthorizations();
 }
 
 void
-XdmcpRegisterAuthorization (const char *name, int namelen)
+XdmcpRegisterAuthorization(const char *name, int namelen)
 {
-    ARRAY8  authName;
-    int	    i;
+    ARRAY8 authName;
+    int i;
 
-    authName.data = malloc(namelen * sizeof (CARD8));
+    authName.data = malloc(namelen * sizeof(CARD8));
     if (!authName.data)
-	return;
-    if (!XdmcpReallocARRAYofARRAY8 (&AuthorizationNames, AuthorizationNames.length +1))
-    {
-	free(authName.data);
-	return;
+        return;
+    if (!XdmcpReallocARRAYofARRAY8
+        (&AuthorizationNames, AuthorizationNames.length + 1)) {
+        free(authName.data);
+        return;
     }
     for (i = 0; i < namelen; i++)
-	authName.data[i] = (CARD8) name[i];
+        authName.data[i] = (CARD8) name[i];
     authName.length = namelen;
-    AuthorizationNames.data[AuthorizationNames.length-1] = authName;
+    AuthorizationNames.data[AuthorizationNames.length - 1] = authName;
 }
 
 /*
  * Register the DisplayClass string
  */
 
-static ARRAY8	DisplayClass;
+static ARRAY8 DisplayClass;
 
 static void
-XdmcpRegisterDisplayClass (const char *name, int length)
+XdmcpRegisterDisplayClass(const char *name, int length)
 {
-    int	    i;
+    int i;
 
-    XdmcpDisposeARRAY8 (&DisplayClass);
-    if (!XdmcpAllocARRAY8 (&DisplayClass, length))
-	return;
+    XdmcpDisposeARRAY8(&DisplayClass);
+    if (!XdmcpAllocARRAY8(&DisplayClass, length))
+        return;
     for (i = 0; i < length; i++)
-	DisplayClass.data[i] = (CARD8) name[i];
+        DisplayClass.data[i] = (CARD8) name[i];
 }
 
 /* 
@@ -570,38 +564,37 @@ XdmcpRegisterDisplayClass (const char *name, int length)
  * number, set up the state machine
  */
 
-void 
+void
 XdmcpInit(void)
 {
     state = XDM_INIT_STATE;
 #ifdef HASXDMAUTH
     if (xdmAuthCookie)
-	XdmAuthenticationInit (xdmAuthCookie, strlen (xdmAuthCookie));
+        XdmAuthenticationInit(xdmAuthCookie, strlen(xdmAuthCookie));
 #endif
-    if (state != XDM_OFF)
-    {
-	XdmcpRegisterAuthorizations();
-	XdmcpRegisterDisplayClass (defaultDisplayClass, strlen (defaultDisplayClass));
-	AccessUsingXdmcp();
-	RegisterBlockAndWakeupHandlers (XdmcpBlockHandler, XdmcpWakeupHandler,
-				        (pointer) 0);
-    	timeOutRtx = 0;
-    	DisplayNumber = (CARD16) atoi(display);
-    	get_xdmcp_sock();
-    	send_packet();
+    if (state != XDM_OFF) {
+        XdmcpRegisterAuthorizations();
+        XdmcpRegisterDisplayClass(defaultDisplayClass,
+                                  strlen(defaultDisplayClass));
+        AccessUsingXdmcp();
+        RegisterBlockAndWakeupHandlers(XdmcpBlockHandler, XdmcpWakeupHandler,
+                                       (pointer) 0);
+        timeOutRtx = 0;
+        DisplayNumber = (CARD16) atoi(display);
+        get_xdmcp_sock();
+        send_packet();
     }
 }
 
 void
-XdmcpReset (void)
+XdmcpReset(void)
 {
     state = XDM_INIT_STATE;
-    if (state != XDM_OFF)
-    {
-	RegisterBlockAndWakeupHandlers (XdmcpBlockHandler, XdmcpWakeupHandler,
-				        (pointer) 0);
-    	timeOutRtx = 0;
-    	send_packet();
+    if (state != XDM_OFF) {
+        RegisterBlockAndWakeupHandlers(XdmcpBlockHandler, XdmcpWakeupHandler,
+                                       (pointer) 0);
+        timeOutRtx = 0;
+        send_packet();
     }
 }
 
@@ -615,22 +608,22 @@ void
 XdmcpOpenDisplay(int sock)
 {
     if (state != XDM_AWAIT_MANAGE_RESPONSE)
-	return;
+        return;
     state = XDM_RUN_SESSION;
     sessionSocket = sock;
 }
 
-void 
+void
 XdmcpCloseDisplay(int sock)
 {
     if ((state != XDM_RUN_SESSION && state != XDM_AWAIT_ALIVE_RESPONSE)
-	|| sessionSocket != sock)
-	    return;
+        || sessionSocket != sock)
+        return;
     state = XDM_INIT_STATE;
     if (OneSession)
-	dispatchException |= DE_TERMINATE;
+        dispatchException |= DE_TERMINATE;
     else
-	dispatchException |= DE_RESET;
+        dispatchException |= DE_RESET;
     isItTimeToYield = TRUE;
 }
 
@@ -641,29 +634,26 @@ XdmcpCloseDisplay(int sock)
  * dynamically while starting up
  */
 
-/*ARGSUSED*/
-static void
-XdmcpBlockHandler(
-    pointer	    data,   /* unused */
-    struct timeval  **wt,
-    pointer	    pReadmask)
+ /*ARGSUSED*/ static void
+XdmcpBlockHandler(pointer data, /* unused */
+                  struct timeval **wt, pointer pReadmask)
 {
-    fd_set *LastSelectMask = (fd_set*)pReadmask;
+    fd_set *LastSelectMask = (fd_set *) pReadmask;
     CARD32 millisToGo;
 
     if (state == XDM_OFF)
-	return;
+        return;
     FD_SET(xdmcpSocket, LastSelectMask);
 #if defined(IPv6) && defined(AF_INET6)
     if (xdmcpSocket6 >= 0)
-	FD_SET(xdmcpSocket6, LastSelectMask);
+        FD_SET(xdmcpSocket6, LastSelectMask);
 #endif
     if (timeOutTime == 0)
-	return;
+        return;
     millisToGo = timeOutTime - GetTimeInMillis();
     if ((int) millisToGo < 0)
-	millisToGo = 0;
-    AdjustWaitForDelay (wt, millisToGo);
+        millisToGo = 0;
+    AdjustWaitForDelay(wt, millisToGo);
 }
 
 /*
@@ -672,52 +662,43 @@ XdmcpBlockHandler(
  * process them appropriately
  */
 
-/*ARGSUSED*/
-static void
-XdmcpWakeupHandler(
-    pointer data,   /* unused */
-    int	    i,
-    pointer pReadmask)
+ /*ARGSUSED*/ static void
+XdmcpWakeupHandler(pointer data,        /* unused */
+                   int i, pointer pReadmask)
 {
-    fd_set* LastSelectMask = (fd_set*)pReadmask;
-    fd_set   devicesReadable;
+    fd_set *LastSelectMask = (fd_set *) pReadmask;
+    fd_set devicesReadable;
 
     if (state == XDM_OFF)
-	return;
-    if (i > 0)
-    {
-	if (FD_ISSET(xdmcpSocket, LastSelectMask))
-	{
-	    receive_packet(xdmcpSocket);
-	    FD_CLR(xdmcpSocket, LastSelectMask);
-	} 
+        return;
+    if (i > 0) {
+        if (FD_ISSET(xdmcpSocket, LastSelectMask)) {
+            receive_packet(xdmcpSocket);
+            FD_CLR(xdmcpSocket, LastSelectMask);
+        }
 #if defined(IPv6) && defined(AF_INET6)
-	if (xdmcpSocket6 >= 0 && FD_ISSET(xdmcpSocket6, LastSelectMask))
-	{
-	    receive_packet(xdmcpSocket6);
-	    FD_CLR(xdmcpSocket6, LastSelectMask);
-	} 
+        if (xdmcpSocket6 >= 0 && FD_ISSET(xdmcpSocket6, LastSelectMask)) {
+            receive_packet(xdmcpSocket6);
+            FD_CLR(xdmcpSocket6, LastSelectMask);
+        }
 #endif
-	XFD_ANDSET(&devicesReadable, LastSelectMask, &EnabledDevices);
-	if (XFD_ANYSET(&devicesReadable))
-	{
-	    if (state == XDM_AWAIT_USER_INPUT)
-		restart();
-	    else if (state == XDM_RUN_SESSION)
-		keepaliveDormancy = defaultKeepaliveDormancy;
-	}
-	if (XFD_ANYSET(&AllClients) && state == XDM_RUN_SESSION)
-	    timeOutTime = GetTimeInMillis() +  keepaliveDormancy * 1000;
+        XFD_ANDSET(&devicesReadable, LastSelectMask, &EnabledDevices);
+        if (XFD_ANYSET(&devicesReadable)) {
+            if (state == XDM_AWAIT_USER_INPUT)
+                restart();
+            else if (state == XDM_RUN_SESSION)
+                keepaliveDormancy = defaultKeepaliveDormancy;
+        }
+        if (XFD_ANYSET(&AllClients) && state == XDM_RUN_SESSION)
+            timeOutTime = GetTimeInMillis() + keepaliveDormancy * 1000;
     }
-    else if (timeOutTime && (int) (GetTimeInMillis() - timeOutTime) >= 0)
-    {
-    	if (state == XDM_RUN_SESSION)
-    	{
-	    state = XDM_KEEPALIVE;
-	    send_packet();
-    	}
-    	else
-	    timeout();
+    else if (timeOutTime && (int) (GetTimeInMillis() - timeOutTime) >= 0) {
+        if (state == XDM_RUN_SESSION) {
+            state = XDM_KEEPALIVE;
+            send_packet();
+        }
+        else
+            timeout();
     }
 }
 
@@ -727,15 +708,13 @@ XdmcpWakeupHandler(
  */
 
 static void
-XdmcpSelectHost(
-    const struct sockaddr	*host_sockaddr,
-    int			host_len,
-    ARRAY8Ptr		AuthenticationName)
+XdmcpSelectHost(const struct sockaddr *host_sockaddr,
+                int host_len, ARRAY8Ptr AuthenticationName)
 {
     state = XDM_START_CONNECTION;
     memmove(&req_sockaddr, host_sockaddr, host_len);
     req_socklen = host_len;
-    XdmcpSetAuthentication (AuthenticationName);
+    XdmcpSetAuthentication(AuthenticationName);
     send_packet();
 }
 
@@ -745,14 +724,10 @@ XdmcpSelectHost(
  * selects the first host to respond with willing message.
  */
 
-/*ARGSUSED*/
-static void
-XdmcpAddHost(
-    const struct sockaddr    *from,
-    int			fromlen,
-    ARRAY8Ptr		AuthenticationName,
-    ARRAY8Ptr		hostname,
-    ARRAY8Ptr		status)
+ /*ARGSUSED*/ static void
+XdmcpAddHost(const struct sockaddr *from,
+             int fromlen,
+             ARRAY8Ptr AuthenticationName, ARRAY8Ptr hostname, ARRAY8Ptr status)
 {
     XdmcpSelectHost(from, fromlen, AuthenticationName);
 }
@@ -762,7 +737,7 @@ XdmcpAddHost(
  * do the appropriate thing
  */
 
-static ARRAY8	UnwillingMessage = { (CARD8) 14, (CARD8 *) "Host unwilling" };
+static ARRAY8 UnwillingMessage = { (CARD8) 14, (CARD8 *) "Host unwilling" };
 
 static void
 receive_packet(int socketfd)
@@ -773,43 +748,43 @@ receive_packet(int socketfd)
     struct sockaddr_in from;
 #endif
     int fromlen = sizeof(from);
-    XdmcpHeader	header;
+    XdmcpHeader header;
 
     /* read message off socket */
-    if (!XdmcpFill (socketfd, &buffer, (XdmcpNetaddr) &from, &fromlen))
-	return;
+    if (!XdmcpFill(socketfd, &buffer, (XdmcpNetaddr) & from, &fromlen))
+        return;
 
     /* reset retransmission backoff */
     timeOutRtx = 0;
 
-    if (!XdmcpReadHeader (&buffer, &header))
-	return;
+    if (!XdmcpReadHeader(&buffer, &header))
+        return;
 
     if (header.version != XDM_PROTOCOL_VERSION)
-	return;
+        return;
 
     switch (header.opcode) {
     case WILLING:
-	recv_willing_msg((struct sockaddr *) &from, fromlen, header.length);
-	break;
+        recv_willing_msg((struct sockaddr *) &from, fromlen, header.length);
+        break;
     case UNWILLING:
-	XdmcpFatal("Manager unwilling", &UnwillingMessage);
-	break;
+        XdmcpFatal("Manager unwilling", &UnwillingMessage);
+        break;
     case ACCEPT:
-	recv_accept_msg(header.length);
-	break;
+        recv_accept_msg(header.length);
+        break;
     case DECLINE:
-	recv_decline_msg(header.length);
-	break;
+        recv_decline_msg(header.length);
+        break;
     case REFUSE:
-	recv_refuse_msg(header.length);
-	break;
+        recv_refuse_msg(header.length);
+        break;
     case FAILED:
-	recv_failed_msg(header.length);
-	break;
+        recv_failed_msg(header.length);
+        break;
     case ALIVE:
-	recv_alive_msg(header.length);
-	break;
+        recv_alive_msg(header.length);
+        break;
     }
 }
 
@@ -821,6 +796,7 @@ static void
 send_packet(void)
 {
     int rtx;
+
     switch (state) {
     case XDM_QUERY:
     case XDM_BROADCAST:
@@ -828,23 +804,23 @@ send_packet(void)
 #if defined(IPv6)  && defined(AF_INET6)
     case XDM_MULTICAST:
 #endif
-	send_query_msg();
-	break;
+        send_query_msg();
+        break;
     case XDM_START_CONNECTION:
-	send_request_msg();
-	break;
+        send_request_msg();
+        break;
     case XDM_MANAGE:
-	send_manage_msg();
-	break;
+        send_manage_msg();
+        break;
     case XDM_KEEPALIVE:
-	send_keepalive_msg();
-	break;
+        send_keepalive_msg();
+        break;
     default:
-	break;
+        break;
     }
     rtx = (XDM_MIN_RTX << timeOutRtx);
     if (rtx > XDM_MAX_RTX)
-	rtx = XDM_MAX_RTX;
+        rtx = XDM_MAX_RTX;
     timeOutTime = GetTimeInMillis() + rtx * 1000;
 }
 
@@ -854,9 +830,9 @@ send_packet(void)
  */
 
 static void
-XdmcpDeadSession (const char *reason)
+XdmcpDeadSession(const char *reason)
 {
-    ErrorF ("XDM: %s, declaring session dead\n", reason);
+    ErrorF("XDM: %s, declaring session dead\n", reason);
     state = XDM_INIT_STATE;
     isItTimeToYield = TRUE;
     dispatchException |= DE_RESET;
@@ -873,67 +849,65 @@ static void
 timeout(void)
 {
     timeOutRtx++;
-    if (state == XDM_AWAIT_ALIVE_RESPONSE && timeOutRtx >= XDM_KA_RTX_LIMIT )
-    {
-	XdmcpDeadSession ("too many keepalive retransmissions");
-	return;
+    if (state == XDM_AWAIT_ALIVE_RESPONSE && timeOutRtx >= XDM_KA_RTX_LIMIT) {
+        XdmcpDeadSession("too many keepalive retransmissions");
+        return;
     }
-    else if (timeOutRtx >= XDM_RTX_LIMIT)
-    {
-	/* Quit if "-once" specified, otherwise reset and try again. */
+    else if (timeOutRtx >= XDM_RTX_LIMIT) {
+        /* Quit if "-once" specified, otherwise reset and try again. */
         if (OneSession) {
-	    dispatchException |= DE_TERMINATE;
-	    ErrorF("XDM: too many retransmissions\n");
-	} else { 
-	    XdmcpDeadSession("too many retransmissions");
-	}
-	return;
+            dispatchException |= DE_TERMINATE;
+            ErrorF("XDM: too many retransmissions\n");
+        }
+        else {
+            XdmcpDeadSession("too many retransmissions");
+        }
+        return;
     }
 
 #if defined(IPv6) && defined(AF_INET6)
     if (state == XDM_COLLECT_QUERY || state == XDM_COLLECT_INDIRECT_QUERY) {
-	/* Try next address */
-	for (mgrAddr = mgrAddr->ai_next; ; mgrAddr = mgrAddr->ai_next) {
-	    if (mgrAddr == NULL) {
-		mgrAddr = mgrAddrFirst;
-	    }
-	    if (mgrAddr->ai_family == AF_INET 
-	      || mgrAddr->ai_family == AF_INET6)
-		break;
-	}
+        /* Try next address */
+        for (mgrAddr = mgrAddr->ai_next;; mgrAddr = mgrAddr->ai_next) {
+            if (mgrAddr == NULL) {
+                mgrAddr = mgrAddrFirst;
+            }
+            if (mgrAddr->ai_family == AF_INET || mgrAddr->ai_family == AF_INET6)
+                break;
+        }
 #ifndef SIN6_LEN
-	ManagerAddressLen = mgrAddr->ai_addrlen;
+        ManagerAddressLen = mgrAddr->ai_addrlen;
 #endif
-	memcpy(&ManagerAddress, mgrAddr->ai_addr, mgrAddr->ai_addrlen);
+        memcpy(&ManagerAddress, mgrAddr->ai_addr, mgrAddr->ai_addrlen);
     }
 #endif
 
     switch (state) {
     case XDM_COLLECT_QUERY:
-	state = XDM_QUERY;
-	break;
+        state = XDM_QUERY;
+        break;
     case XDM_COLLECT_BROADCAST_QUERY:
-	state = XDM_BROADCAST;
-	break;
+        state = XDM_BROADCAST;
+        break;
 #if defined(IPv6) && defined(AF_INET6)
     case XDM_COLLECT_MULTICAST_QUERY:
-	state = XDM_MULTICAST;
-	break;
+        state = XDM_MULTICAST;
+        break;
 #endif
     case XDM_COLLECT_INDIRECT_QUERY:
-	state = XDM_INDIRECT;
-	break;
+        state = XDM_INDIRECT;
+        break;
     case XDM_AWAIT_REQUEST_RESPONSE:
-	state = XDM_START_CONNECTION;
-	break;
+        state = XDM_START_CONNECTION;
+        break;
     case XDM_AWAIT_MANAGE_RESPONSE:
-	state = XDM_MANAGE;
-	break;
+        state = XDM_MANAGE;
+        break;
     case XDM_AWAIT_ALIVE_RESPONSE:
-	state = XDM_KEEPALIVE;
-	break;
+        state = XDM_KEEPALIVE;
+        break;
     default:
-	break;
+        break;
     }
     send_packet();
 }
@@ -947,26 +921,26 @@ restart(void)
 }
 
 static int
-XdmcpCheckAuthentication (ARRAY8Ptr Name, ARRAY8Ptr Data, int packet_type)
+XdmcpCheckAuthentication(ARRAY8Ptr Name, ARRAY8Ptr Data, int packet_type)
 {
-    return (XdmcpARRAY8Equal (Name, AuthenticationName) &&
-	    (AuthenticationName->length == 0 ||
-	     (*AuthenticationFuncs->Validator) (AuthenticationData, Data, packet_type)));
+    return (XdmcpARRAY8Equal(Name, AuthenticationName) &&
+            (AuthenticationName->length == 0 ||
+             (*AuthenticationFuncs->Validator) (AuthenticationData, Data,
+                                                packet_type)));
 }
 
 static int
-XdmcpAddAuthorization (ARRAY8Ptr name, ARRAY8Ptr data)
+XdmcpAddAuthorization(ARRAY8Ptr name, ARRAY8Ptr data)
 {
     AddAuthorFunc AddAuth;
 
     if (AuthenticationFuncs && AuthenticationFuncs->AddAuth)
-	AddAuth = AuthenticationFuncs->AddAuth;
+        AddAuth = AuthenticationFuncs->AddAuth;
     else
-	AddAuth = AddAuthorization;
-    return (*AddAuth) ((unsigned short)name->length,
-		       (char *)name->data,
-		       (unsigned short)data->length,
-		       (char *)data->data);
+        AddAuth = AddAuthorization;
+    return (*AddAuth) ((unsigned short) name->length,
+                       (char *) name->data,
+                       (unsigned short) data->length, (char *) data->data);
 }
 
 /*
@@ -981,498 +955,476 @@ get_xdmcp_sock(void)
     struct netconfig *nconf;
 
     if ((xdmcpSocket = t_open("/dev/udp", O_RDWR, 0)) < 0) {
-	XdmcpWarning("t_open() of /dev/udp failed");
-	return;
+        XdmcpWarning("t_open() of /dev/udp failed");
+        return;
     }
 
-    if( t_bind(xdmcpSocket,NULL,NULL) < 0 ) {
-	XdmcpWarning("UDP socket creation failed");
-	t_error("t_bind(xdmcpSocket) failed" );
-	t_close(xdmcpSocket);
-	return;
+    if (t_bind(xdmcpSocket, NULL, NULL) < 0) {
+        XdmcpWarning("UDP socket creation failed");
+        t_error("t_bind(xdmcpSocket) failed");
+        t_close(xdmcpSocket);
+        return;
     }
 
     /*
      * This part of the code looks contrived. It will actually fit in nicely
      * when the CLTS part of Xtrans is implemented.
      */
- 
-    if( (nconf=getnetconfigent("udp")) == NULL ) {
-	XdmcpWarning("UDP socket creation failed: getnetconfigent()");
-	t_unbind(xdmcpSocket);
-	t_close(xdmcpSocket);
-	return;
+
+    if ((nconf = getnetconfigent("udp")) == NULL) {
+        XdmcpWarning("UDP socket creation failed: getnetconfigent()");
+        t_unbind(xdmcpSocket);
+        t_close(xdmcpSocket);
+        return;
     }
- 
-    if( netdir_options(nconf, ND_SET_BROADCAST, xdmcpSocket, NULL) ) {
-	XdmcpWarning("UDP set broadcast option failed: netdir_options()");
-	freenetconfigent(nconf);
-	t_unbind(xdmcpSocket);
-	t_close(xdmcpSocket);
-	return;
+
+    if (netdir_options(nconf, ND_SET_BROADCAST, xdmcpSocket, NULL)) {
+        XdmcpWarning("UDP set broadcast option failed: netdir_options()");
+        freenetconfigent(nconf);
+        t_unbind(xdmcpSocket);
+        t_close(xdmcpSocket);
+        return;
     }
- 
+
     freenetconfigent(nconf);
 #else
     int soopts = 1;
 
 #if defined(IPv6) && defined(AF_INET6)
     if ((xdmcpSocket6 = socket(AF_INET6, SOCK_DGRAM, 0)) < 0)
-	XdmcpWarning("INET6 UDP socket creation failed");
+        XdmcpWarning("INET6 UDP socket creation failed");
 #endif
     if ((xdmcpSocket = socket(AF_INET, SOCK_DGRAM, 0)) < 0)
-	XdmcpWarning("UDP socket creation failed");
+        XdmcpWarning("UDP socket creation failed");
 #ifdef SO_BROADCAST
-    else if (setsockopt(xdmcpSocket, SOL_SOCKET, SO_BROADCAST, (char *)&soopts,
-	sizeof(soopts)) < 0)
-	    XdmcpWarning("UDP set broadcast socket-option failed");
-#endif /* SO_BROADCAST */
+    else if (setsockopt(xdmcpSocket, SOL_SOCKET, SO_BROADCAST, (char *) &soopts,
+                        sizeof(soopts)) < 0)
+        XdmcpWarning("UDP set broadcast socket-option failed");
+#endif                          /* SO_BROADCAST */
     if (xdmcpSocket >= 0 && xdm_from != NULL) {
-	if (bind(xdmcpSocket, (struct sockaddr *)&FromAddress, 
-		 FromAddressLen) < 0) {
-	    FatalError("Xserver: failed to bind to -from address: %s\n", xdm_from);
-	}
+        if (bind(xdmcpSocket, (struct sockaddr *) &FromAddress,
+                 FromAddressLen) < 0) {
+            FatalError("Xserver: failed to bind to -from address: %s\n",
+                       xdm_from);
+        }
     }
-#endif /* STREAMSCONN */
+#endif                          /* STREAMSCONN */
 }
 
 static void
 send_query_msg(void)
 {
-    XdmcpHeader	header;
-    Bool	broadcast = FALSE;
+    XdmcpHeader header;
+    Bool broadcast = FALSE;
+
 #if defined(IPv6) && defined(AF_INET6)
-    Bool	multicast = FALSE;
+    Bool multicast = FALSE;
 #endif
-    int		i;
-    int 	socketfd = xdmcpSocket;
+    int i;
+    int socketfd = xdmcpSocket;
 
     header.version = XDM_PROTOCOL_VERSION;
-    switch(state){
+    switch (state) {
     case XDM_QUERY:
-	header.opcode = (CARD16) QUERY; 
-	state = XDM_COLLECT_QUERY;
-	break;
+        header.opcode = (CARD16) QUERY;
+        state = XDM_COLLECT_QUERY;
+        break;
     case XDM_BROADCAST:
-	header.opcode = (CARD16) BROADCAST_QUERY;
-	state = XDM_COLLECT_BROADCAST_QUERY;
-	broadcast = TRUE;
-	break;
+        header.opcode = (CARD16) BROADCAST_QUERY;
+        state = XDM_COLLECT_BROADCAST_QUERY;
+        broadcast = TRUE;
+        break;
 #if defined(IPv6) && defined(AF_INET6)
     case XDM_MULTICAST:
-	header.opcode = (CARD16) BROADCAST_QUERY;
-	state = XDM_COLLECT_MULTICAST_QUERY;
-	multicast = TRUE;
-	break;
+        header.opcode = (CARD16) BROADCAST_QUERY;
+        state = XDM_COLLECT_MULTICAST_QUERY;
+        multicast = TRUE;
+        break;
 #endif
     case XDM_INDIRECT:
-	header.opcode = (CARD16) INDIRECT_QUERY;
-	state = XDM_COLLECT_INDIRECT_QUERY;
-	break;
+        header.opcode = (CARD16) INDIRECT_QUERY;
+        state = XDM_COLLECT_INDIRECT_QUERY;
+        break;
     default:
-	break;
+        break;
     }
     header.length = 1;
     for (i = 0; i < AuthenticationNames.length; i++)
-	header.length += 2 + AuthenticationNames.data[i].length;
+        header.length += 2 + AuthenticationNames.data[i].length;
 
-    XdmcpWriteHeader (&buffer, &header);
-    XdmcpWriteARRAYofARRAY8 (&buffer, &AuthenticationNames);
-    if (broadcast)
-    {
-	int i;
+    XdmcpWriteHeader(&buffer, &header);
+    XdmcpWriteARRAYofARRAY8(&buffer, &AuthenticationNames);
+    if (broadcast) {
+        int i;
 
-	for (i = 0; i < NumBroadcastAddresses; i++)
-	    XdmcpFlush (xdmcpSocket, &buffer, (XdmcpNetaddr) &BroadcastAddresses[i],
-			sizeof (struct sockaddr_in));
+        for (i = 0; i < NumBroadcastAddresses; i++)
+            XdmcpFlush(xdmcpSocket, &buffer,
+                       (XdmcpNetaddr) & BroadcastAddresses[i],
+                       sizeof(struct sockaddr_in));
     }
 #if defined(IPv6) && defined(AF_INET6)
-    else if (multicast)
-    {
-	struct multicastinfo *mcl;
-	struct addrinfo *ai;
-
-	for (mcl = mcastlist; mcl != NULL; mcl = mcl->next) {
-	    for (ai = mcl->ai ; ai != NULL; ai = ai->ai_next) {
-		if (ai->ai_family == AF_INET) {
-		    unsigned char hopflag = (unsigned char) mcl->hops;
-		    socketfd = xdmcpSocket;
-		    setsockopt(socketfd, IPPROTO_IP, IP_MULTICAST_TTL,
-		      &hopflag, sizeof(hopflag));
-		} else if (ai->ai_family == AF_INET6) {
-		    int hopflag6 = mcl->hops;
-		    socketfd = xdmcpSocket6;
-		    setsockopt(socketfd, IPPROTO_IPV6, IPV6_MULTICAST_HOPS,
-		      &hopflag6, sizeof(hopflag6));
-		} else {
-		    continue;
-		}
-		XdmcpFlush (socketfd, &buffer, 
-		  	    (XdmcpNetaddr) ai->ai_addr, ai->ai_addrlen);
-		break;
-	    }
-	}
+    else if (multicast) {
+        struct multicastinfo *mcl;
+        struct addrinfo *ai;
+
+        for (mcl = mcastlist; mcl != NULL; mcl = mcl->next) {
+            for (ai = mcl->ai; ai != NULL; ai = ai->ai_next) {
+                if (ai->ai_family == AF_INET) {
+                    unsigned char hopflag = (unsigned char) mcl->hops;
+
+                    socketfd = xdmcpSocket;
+                    setsockopt(socketfd, IPPROTO_IP, IP_MULTICAST_TTL,
+                               &hopflag, sizeof(hopflag));
+                }
+                else if (ai->ai_family == AF_INET6) {
+                    int hopflag6 = mcl->hops;
+
+                    socketfd = xdmcpSocket6;
+                    setsockopt(socketfd, IPPROTO_IPV6, IPV6_MULTICAST_HOPS,
+                               &hopflag6, sizeof(hopflag6));
+                }
+                else {
+                    continue;
+                }
+                XdmcpFlush(socketfd, &buffer,
+                           (XdmcpNetaddr) ai->ai_addr, ai->ai_addrlen);
+                break;
+            }
+        }
     }
 #endif
-    else
-    {
+    else {
 #if defined(IPv6) && defined(AF_INET6)
-	if (SOCKADDR_FAMILY(ManagerAddress) == AF_INET6)
-	    socketfd = xdmcpSocket6;
-#endif	
-	XdmcpFlush (socketfd, &buffer, (XdmcpNetaddr) &ManagerAddress,
-		    ManagerAddressLen);
+        if (SOCKADDR_FAMILY(ManagerAddress) == AF_INET6)
+            socketfd = xdmcpSocket6;
+#endif
+        XdmcpFlush(socketfd, &buffer, (XdmcpNetaddr) & ManagerAddress,
+                   ManagerAddressLen);
     }
 }
 
 static void
-recv_willing_msg(
-    struct sockaddr	*from,
-    int			fromlen,
-    unsigned		length)
+recv_willing_msg(struct sockaddr *from, int fromlen, unsigned length)
 {
-    ARRAY8	authenticationName;
-    ARRAY8	hostname;
-    ARRAY8	status;
+    ARRAY8 authenticationName;
+    ARRAY8 hostname;
+    ARRAY8 status;
 
     authenticationName.data = 0;
     hostname.data = 0;
     status.data = 0;
-    if (XdmcpReadARRAY8 (&buffer, &authenticationName) &&
-	XdmcpReadARRAY8 (&buffer, &hostname) &&
-	XdmcpReadARRAY8 (&buffer, &status))
-    {
-    	if (length == 6 + authenticationName.length +
-		      hostname.length + status.length)
-    	{
-	    switch (state)
-	    {
-	    case XDM_COLLECT_QUERY:
-	    	XdmcpSelectHost(from, fromlen, &authenticationName);
-	    	break;
-	    case XDM_COLLECT_BROADCAST_QUERY:
+    if (XdmcpReadARRAY8(&buffer, &authenticationName) &&
+        XdmcpReadARRAY8(&buffer, &hostname) &&
+        XdmcpReadARRAY8(&buffer, &status)) {
+        if (length == 6 + authenticationName.length +
+            hostname.length + status.length) {
+            switch (state) {
+            case XDM_COLLECT_QUERY:
+                XdmcpSelectHost(from, fromlen, &authenticationName);
+                break;
+            case XDM_COLLECT_BROADCAST_QUERY:
 #if defined(IPv6) && defined(AF_INET6)
-	    case XDM_COLLECT_MULTICAST_QUERY:
+            case XDM_COLLECT_MULTICAST_QUERY:
 #endif
-	    case XDM_COLLECT_INDIRECT_QUERY:
-	    	XdmcpAddHost(from, fromlen, &authenticationName, &hostname, &status);
-	    	break;
-	    default:
-		break;
-    	    }
-    	}
+            case XDM_COLLECT_INDIRECT_QUERY:
+                XdmcpAddHost(from, fromlen, &authenticationName, &hostname,
+                             &status);
+                break;
+            default:
+                break;
+            }
+        }
     }
-    XdmcpDisposeARRAY8 (&authenticationName);
-    XdmcpDisposeARRAY8 (&hostname);
-    XdmcpDisposeARRAY8 (&status);
+    XdmcpDisposeARRAY8(&authenticationName);
+    XdmcpDisposeARRAY8(&hostname);
+    XdmcpDisposeARRAY8(&status);
 }
 
 static void
 send_request_msg(void)
 {
-    XdmcpHeader	    header;
-    int		    length;
-    int		    i;
-    CARD16	    XdmcpConnectionType;
-    ARRAY8	    authenticationData;
-    int		    socketfd = xdmcpSocket;
-
-    switch (SOCKADDR_FAMILY(ManagerAddress))
-    {
-    case AF_INET:	XdmcpConnectionType=FamilyInternet; break;
+    XdmcpHeader header;
+    int length;
+    int i;
+    CARD16 XdmcpConnectionType;
+    ARRAY8 authenticationData;
+    int socketfd = xdmcpSocket;
+
+    switch (SOCKADDR_FAMILY(ManagerAddress)) {
+    case AF_INET:
+        XdmcpConnectionType = FamilyInternet;
+        break;
 #if defined(IPv6) && defined(AF_INET6)
-    case AF_INET6:	XdmcpConnectionType=FamilyInternet6; break;
+    case AF_INET6:
+        XdmcpConnectionType = FamilyInternet6;
+        break;
 #endif
-    default:		XdmcpConnectionType=0xffff; break;
+    default:
+        XdmcpConnectionType = 0xffff;
+        break;
     }
 
     header.version = XDM_PROTOCOL_VERSION;
     header.opcode = (CARD16) REQUEST;
 
-    length = 2;					    /* display number */
-    length += 1 + 2 * ConnectionTypes.length;	    /* connection types */
-    length += 1;				    /* connection addresses */
+    length = 2;                 /* display number */
+    length += 1 + 2 * ConnectionTypes.length;   /* connection types */
+    length += 1;                /* connection addresses */
     for (i = 0; i < ConnectionAddresses.length; i++)
-	length += 2 + ConnectionAddresses.data[i].length;
+        length += 2 + ConnectionAddresses.data[i].length;
     authenticationData.length = 0;
     authenticationData.data = 0;
-    if (AuthenticationFuncs)
-    {
-	(*AuthenticationFuncs->Generator) (AuthenticationData,
-					   &authenticationData,
- 					   REQUEST);
+    if (AuthenticationFuncs) {
+        (*AuthenticationFuncs->Generator) (AuthenticationData,
+                                           &authenticationData, REQUEST);
     }
-    length += 2 + AuthenticationName->length;	    /* authentication name */
-    length += 2 + authenticationData.length;	    /* authentication data */
-    length += 1;				    /* authorization names */
+    length += 2 + AuthenticationName->length;   /* authentication name */
+    length += 2 + authenticationData.length;    /* authentication data */
+    length += 1;                /* authorization names */
     for (i = 0; i < AuthorizationNames.length; i++)
-	length += 2 + AuthorizationNames.data[i].length;
-    length += 2 + ManufacturerDisplayID.length;	    /* display ID */
+        length += 2 + AuthorizationNames.data[i].length;
+    length += 2 + ManufacturerDisplayID.length; /* display ID */
     header.length = length;
 
-    if (!XdmcpWriteHeader (&buffer, &header))
-    {
-	XdmcpDisposeARRAY8 (&authenticationData);
-	return;
+    if (!XdmcpWriteHeader(&buffer, &header)) {
+        XdmcpDisposeARRAY8(&authenticationData);
+        return;
     }
-    XdmcpWriteCARD16 (&buffer, DisplayNumber);
-    XdmcpWriteCARD8 (&buffer, ConnectionTypes.length);
-
-    /* The connection array is send reordered, so that connections of	*/
-    /* the same address type as the XDMCP manager connection are send	*/
-    /* first. This works around a bug in xdm. mario@klebsch.de 		*/
-    for (i = 0; i < (int)ConnectionTypes.length; i++)
-	if (ConnectionTypes.data[i]==XdmcpConnectionType)
-	    XdmcpWriteCARD16 (&buffer, ConnectionTypes.data[i]);
-    for (i = 0; i < (int)ConnectionTypes.length; i++)
-	if (ConnectionTypes.data[i]!=XdmcpConnectionType)
-	    XdmcpWriteCARD16 (&buffer, ConnectionTypes.data[i]);
-
-    XdmcpWriteCARD8 (&buffer, ConnectionAddresses.length);
-    for (i = 0; i < (int)ConnectionAddresses.length; i++)
-	if ( (i<ConnectionTypes.length) && 
-	     (ConnectionTypes.data[i]==XdmcpConnectionType) )
-	    XdmcpWriteARRAY8 (&buffer, &ConnectionAddresses.data[i]);
-    for (i = 0; i < (int)ConnectionAddresses.length; i++)
-	if ( (i>=ConnectionTypes.length) ||
-	     (ConnectionTypes.data[i]!=XdmcpConnectionType) )
-	    XdmcpWriteARRAY8 (&buffer, &ConnectionAddresses.data[i]);
-
-    XdmcpWriteARRAY8 (&buffer, AuthenticationName);
-    XdmcpWriteARRAY8 (&buffer, &authenticationData);
-    XdmcpDisposeARRAY8 (&authenticationData);
-    XdmcpWriteARRAYofARRAY8 (&buffer, &AuthorizationNames);
-    XdmcpWriteARRAY8 (&buffer, &ManufacturerDisplayID);
+    XdmcpWriteCARD16(&buffer, DisplayNumber);
+    XdmcpWriteCARD8(&buffer, ConnectionTypes.length);
+
+    /* The connection array is send reordered, so that connections of   */
+    /* the same address type as the XDMCP manager connection are send   */
+    /* first. This works around a bug in xdm. mario@klebsch.de          */
+    for (i = 0; i < (int) ConnectionTypes.length; i++)
+        if (ConnectionTypes.data[i] == XdmcpConnectionType)
+            XdmcpWriteCARD16(&buffer, ConnectionTypes.data[i]);
+    for (i = 0; i < (int) ConnectionTypes.length; i++)
+        if (ConnectionTypes.data[i] != XdmcpConnectionType)
+            XdmcpWriteCARD16(&buffer, ConnectionTypes.data[i]);
+
+    XdmcpWriteCARD8(&buffer, ConnectionAddresses.length);
+    for (i = 0; i < (int) ConnectionAddresses.length; i++)
+        if ((i < ConnectionTypes.length) &&
+            (ConnectionTypes.data[i] == XdmcpConnectionType))
+            XdmcpWriteARRAY8(&buffer, &ConnectionAddresses.data[i]);
+    for (i = 0; i < (int) ConnectionAddresses.length; i++)
+        if ((i >= ConnectionTypes.length) ||
+            (ConnectionTypes.data[i] != XdmcpConnectionType))
+            XdmcpWriteARRAY8(&buffer, &ConnectionAddresses.data[i]);
+
+    XdmcpWriteARRAY8(&buffer, AuthenticationName);
+    XdmcpWriteARRAY8(&buffer, &authenticationData);
+    XdmcpDisposeARRAY8(&authenticationData);
+    XdmcpWriteARRAYofARRAY8(&buffer, &AuthorizationNames);
+    XdmcpWriteARRAY8(&buffer, &ManufacturerDisplayID);
 #if defined(IPv6) && defined(AF_INET6)
     if (SOCKADDR_FAMILY(req_sockaddr) == AF_INET6)
-	socketfd = xdmcpSocket6;
+        socketfd = xdmcpSocket6;
 #endif
-    if (XdmcpFlush (socketfd, &buffer, 
-			(XdmcpNetaddr) &req_sockaddr, req_socklen))
-	state = XDM_AWAIT_REQUEST_RESPONSE;
+    if (XdmcpFlush(socketfd, &buffer,
+                   (XdmcpNetaddr) & req_sockaddr, req_socklen))
+        state = XDM_AWAIT_REQUEST_RESPONSE;
 }
 
 static void
 recv_accept_msg(unsigned length)
 {
-    CARD32  AcceptSessionID;
-    ARRAY8  AcceptAuthenticationName, AcceptAuthenticationData;
-    ARRAY8  AcceptAuthorizationName, AcceptAuthorizationData;
+    CARD32 AcceptSessionID;
+    ARRAY8 AcceptAuthenticationName, AcceptAuthenticationData;
+    ARRAY8 AcceptAuthorizationName, AcceptAuthorizationData;
 
     if (state != XDM_AWAIT_REQUEST_RESPONSE)
-	return;
+        return;
     AcceptAuthenticationName.data = 0;
     AcceptAuthenticationData.data = 0;
     AcceptAuthorizationName.data = 0;
     AcceptAuthorizationData.data = 0;
-    if (XdmcpReadCARD32 (&buffer, &AcceptSessionID) &&
-	XdmcpReadARRAY8 (&buffer, &AcceptAuthenticationName) &&
-	XdmcpReadARRAY8 (&buffer, &AcceptAuthenticationData) &&
-	XdmcpReadARRAY8 (&buffer, &AcceptAuthorizationName) &&
-	XdmcpReadARRAY8 (&buffer, &AcceptAuthorizationData))
-    {
-    	if (length == 12 + AcceptAuthenticationName.length +
-		      	   AcceptAuthenticationData.length +
-		      	   AcceptAuthorizationName.length +
- 		      	   AcceptAuthorizationData.length)
-    	{
-	    if (!XdmcpCheckAuthentication (&AcceptAuthenticationName,
-				      &AcceptAuthenticationData, ACCEPT))
-	    {
-		XdmcpFatal ("Authentication Failure", &AcceptAuthenticationName);
-	    }
-	    /* permit access control manipulations from this host */
-	    AugmentSelf (&req_sockaddr, req_socklen);
-	    /* if the authorization specified in the packet fails
-	     * to be acceptable, enable the local addresses
-	     */
-	    if (!XdmcpAddAuthorization (&AcceptAuthorizationName,
-					&AcceptAuthorizationData))
-	    {
-		AddLocalHosts ();
-	    }
-	    SessionID = AcceptSessionID;
-    	    state = XDM_MANAGE;
-    	    send_packet();
-    	}
+    if (XdmcpReadCARD32(&buffer, &AcceptSessionID) &&
+        XdmcpReadARRAY8(&buffer, &AcceptAuthenticationName) &&
+        XdmcpReadARRAY8(&buffer, &AcceptAuthenticationData) &&
+        XdmcpReadARRAY8(&buffer, &AcceptAuthorizationName) &&
+        XdmcpReadARRAY8(&buffer, &AcceptAuthorizationData)) {
+        if (length == 12 + AcceptAuthenticationName.length +
+            AcceptAuthenticationData.length +
+            AcceptAuthorizationName.length + AcceptAuthorizationData.length) {
+            if (!XdmcpCheckAuthentication(&AcceptAuthenticationName,
+                                          &AcceptAuthenticationData, ACCEPT)) {
+                XdmcpFatal("Authentication Failure", &AcceptAuthenticationName);
+            }
+            /* permit access control manipulations from this host */
+            AugmentSelf(&req_sockaddr, req_socklen);
+            /* if the authorization specified in the packet fails
+             * to be acceptable, enable the local addresses
+             */
+            if (!XdmcpAddAuthorization(&AcceptAuthorizationName,
+                                       &AcceptAuthorizationData)) {
+                AddLocalHosts();
+            }
+            SessionID = AcceptSessionID;
+            state = XDM_MANAGE;
+            send_packet();
+        }
     }
-    XdmcpDisposeARRAY8 (&AcceptAuthenticationName);
-    XdmcpDisposeARRAY8 (&AcceptAuthenticationData);
-    XdmcpDisposeARRAY8 (&AcceptAuthorizationName);
-    XdmcpDisposeARRAY8 (&AcceptAuthorizationData);
+    XdmcpDisposeARRAY8(&AcceptAuthenticationName);
+    XdmcpDisposeARRAY8(&AcceptAuthenticationData);
+    XdmcpDisposeARRAY8(&AcceptAuthorizationName);
+    XdmcpDisposeARRAY8(&AcceptAuthorizationData);
 }
 
 static void
 recv_decline_msg(unsigned length)
 {
-    ARRAY8  status, DeclineAuthenticationName, DeclineAuthenticationData;
+    ARRAY8 status, DeclineAuthenticationName, DeclineAuthenticationData;
 
     status.data = 0;
     DeclineAuthenticationName.data = 0;
     DeclineAuthenticationData.data = 0;
-    if (XdmcpReadARRAY8 (&buffer, &status) &&
-	XdmcpReadARRAY8 (&buffer, &DeclineAuthenticationName) &&
-	XdmcpReadARRAY8 (&buffer, &DeclineAuthenticationData))
-    {
-    	if (length == 6 + status.length +
-		      	  DeclineAuthenticationName.length +
- 		      	  DeclineAuthenticationData.length &&
-	    XdmcpCheckAuthentication (&DeclineAuthenticationName,
-				      &DeclineAuthenticationData, DECLINE))
-    	{
-	    XdmcpFatal ("Session declined", &status);
-    	}
+    if (XdmcpReadARRAY8(&buffer, &status) &&
+        XdmcpReadARRAY8(&buffer, &DeclineAuthenticationName) &&
+        XdmcpReadARRAY8(&buffer, &DeclineAuthenticationData)) {
+        if (length == 6 + status.length +
+            DeclineAuthenticationName.length +
+            DeclineAuthenticationData.length &&
+            XdmcpCheckAuthentication(&DeclineAuthenticationName,
+                                     &DeclineAuthenticationData, DECLINE)) {
+            XdmcpFatal("Session declined", &status);
+        }
     }
-    XdmcpDisposeARRAY8 (&status);
-    XdmcpDisposeARRAY8 (&DeclineAuthenticationName);
-    XdmcpDisposeARRAY8 (&DeclineAuthenticationData);
+    XdmcpDisposeARRAY8(&status);
+    XdmcpDisposeARRAY8(&DeclineAuthenticationName);
+    XdmcpDisposeARRAY8(&DeclineAuthenticationData);
 }
 
 static void
 send_manage_msg(void)
 {
-    XdmcpHeader	header;
+    XdmcpHeader header;
     int socketfd = xdmcpSocket;
 
     header.version = XDM_PROTOCOL_VERSION;
     header.opcode = (CARD16) MANAGE;
     header.length = 8 + DisplayClass.length;
 
-    if (!XdmcpWriteHeader (&buffer, &header))
-	return;
-    XdmcpWriteCARD32 (&buffer, SessionID);
-    XdmcpWriteCARD16 (&buffer, DisplayNumber);
-    XdmcpWriteARRAY8 (&buffer, &DisplayClass);
+    if (!XdmcpWriteHeader(&buffer, &header))
+        return;
+    XdmcpWriteCARD32(&buffer, SessionID);
+    XdmcpWriteCARD16(&buffer, DisplayNumber);
+    XdmcpWriteARRAY8(&buffer, &DisplayClass);
     state = XDM_AWAIT_MANAGE_RESPONSE;
 #if defined(IPv6) && defined(AF_INET6)
     if (SOCKADDR_FAMILY(req_sockaddr) == AF_INET6)
-	socketfd = xdmcpSocket6;
+        socketfd = xdmcpSocket6;
 #endif
-    XdmcpFlush (socketfd, &buffer, (XdmcpNetaddr) &req_sockaddr, req_socklen);
+    XdmcpFlush(socketfd, &buffer, (XdmcpNetaddr) & req_sockaddr, req_socklen);
 }
 
 static void
 recv_refuse_msg(unsigned length)
 {
-    CARD32  RefusedSessionID;
+    CARD32 RefusedSessionID;
 
     if (state != XDM_AWAIT_MANAGE_RESPONSE)
-	return;
+        return;
     if (length != 4)
-	return;
-    if (XdmcpReadCARD32 (&buffer, &RefusedSessionID))
-    {
-	if (RefusedSessionID == SessionID)
-	{
-    	    state = XDM_START_CONNECTION;
-    	    send_packet();
-	}
+        return;
+    if (XdmcpReadCARD32(&buffer, &RefusedSessionID)) {
+        if (RefusedSessionID == SessionID) {
+            state = XDM_START_CONNECTION;
+            send_packet();
+        }
     }
 }
 
 static void
 recv_failed_msg(unsigned length)
 {
-    CARD32  FailedSessionID;
-    ARRAY8  status;
+    CARD32 FailedSessionID;
+    ARRAY8 status;
 
     if (state != XDM_AWAIT_MANAGE_RESPONSE)
-	return;
+        return;
     status.data = 0;
-    if (XdmcpReadCARD32 (&buffer, &FailedSessionID) &&
-	XdmcpReadARRAY8 (&buffer, &status))
-    {
-    	if (length == 6 + status.length &&
-	    SessionID == FailedSessionID)
-	{
-	    XdmcpFatal ("Session failed", &status);
-	}
+    if (XdmcpReadCARD32(&buffer, &FailedSessionID) &&
+        XdmcpReadARRAY8(&buffer, &status)) {
+        if (length == 6 + status.length && SessionID == FailedSessionID) {
+            XdmcpFatal("Session failed", &status);
+        }
     }
-    XdmcpDisposeARRAY8 (&status);
+    XdmcpDisposeARRAY8(&status);
 }
 
 static void
 send_keepalive_msg(void)
 {
-    XdmcpHeader	header;
+    XdmcpHeader header;
     int socketfd = xdmcpSocket;
 
     header.version = XDM_PROTOCOL_VERSION;
     header.opcode = (CARD16) KEEPALIVE;
     header.length = 6;
 
-    XdmcpWriteHeader (&buffer, &header);
-    XdmcpWriteCARD16 (&buffer, DisplayNumber);
-    XdmcpWriteCARD32 (&buffer, SessionID);
+    XdmcpWriteHeader(&buffer, &header);
+    XdmcpWriteCARD16(&buffer, DisplayNumber);
+    XdmcpWriteCARD32(&buffer, SessionID);
 
     state = XDM_AWAIT_ALIVE_RESPONSE;
 #if defined(IPv6) && defined(AF_INET6)
     if (SOCKADDR_FAMILY(req_sockaddr) == AF_INET6)
-	socketfd = xdmcpSocket6;
+        socketfd = xdmcpSocket6;
 #endif
-    XdmcpFlush (socketfd, &buffer, (XdmcpNetaddr) &req_sockaddr, req_socklen);
+    XdmcpFlush(socketfd, &buffer, (XdmcpNetaddr) & req_sockaddr, req_socklen);
 }
 
 static void
-recv_alive_msg (unsigned length)
+recv_alive_msg(unsigned length)
 {
-    CARD8   SessionRunning;
-    CARD32  AliveSessionID;
+    CARD8 SessionRunning;
+    CARD32 AliveSessionID;
 
     if (state != XDM_AWAIT_ALIVE_RESPONSE)
-	return;
+        return;
     if (length != 5)
-	return;
-    if (XdmcpReadCARD8 (&buffer, &SessionRunning) &&
-	XdmcpReadCARD32 (&buffer, &AliveSessionID))
-    {
-    	if (SessionRunning && AliveSessionID == SessionID)
-    	{
-	    /* backoff dormancy period */
-	    state = XDM_RUN_SESSION;
-	    if ((GetTimeInMillis() - lastDeviceEventTime.milliseconds) >
-		keepaliveDormancy * 1000)
-	    {
-		keepaliveDormancy <<= 1;
-		if (keepaliveDormancy > XDM_MAX_DORMANCY)
-		    keepaliveDormancy = XDM_MAX_DORMANCY;
-	    }
-	    timeOutTime = GetTimeInMillis() + keepaliveDormancy * 1000;
-    	}
-	else
-    	{
-	    XdmcpDeadSession ("Alive response indicates session dead");
-    	}
+        return;
+    if (XdmcpReadCARD8(&buffer, &SessionRunning) &&
+        XdmcpReadCARD32(&buffer, &AliveSessionID)) {
+        if (SessionRunning && AliveSessionID == SessionID) {
+            /* backoff dormancy period */
+            state = XDM_RUN_SESSION;
+            if ((GetTimeInMillis() - lastDeviceEventTime[XIAllDevices].milliseconds) >
+                keepaliveDormancy * 1000) {
+                keepaliveDormancy <<= 1;
+                if (keepaliveDormancy > XDM_MAX_DORMANCY)
+                    keepaliveDormancy = XDM_MAX_DORMANCY;
+            }
+            timeOutTime = GetTimeInMillis() + keepaliveDormancy * 1000;
+        }
+        else {
+            XdmcpDeadSession("Alive response indicates session dead");
+        }
     }
 }
 
-static  void
-XdmcpFatal (
-    const char	*type,
-    ARRAY8Ptr	status)
+static void
+XdmcpFatal(const char *type, ARRAY8Ptr status)
 {
-    FatalError ("XDMCP fatal error: %s %*.*s\n", type,
-	   status->length, status->length, status->data);
+    FatalError("XDMCP fatal error: %s %*.*s\n", type,
+               status->length, status->length, status->data);
 }
 
-static  void
+static void
 XdmcpWarning(const char *str)
 {
     ErrorF("XDMCP warning: %s\n", str);
 }
 
 static void
-get_addr_by_name(
-    const char *argtype,
-    const char *namestr,
-    int		port,
-    int		socktype,
-    SOCKADDR_TYPE *addr,
-    SOCKLEN_TYPE *addrlen
+get_addr_by_name(const char *argtype,
+                 const char *namestr,
+                 int port,
+                 int socktype, SOCKADDR_TYPE * addr, SOCKLEN_TYPE * addrlen
 #if defined(IPv6) && defined(AF_INET6)
-      ,
-    struct addrinfo **aip,
-    struct addrinfo **aifirstp
+                 , struct addrinfo **aip, struct addrinfo **aifirstp
 #endif
     )
 {
@@ -1487,108 +1439,102 @@ get_addr_by_name(
     hints.ai_socktype = socktype;
 
     if (port == 0) {
-	pport = NULL;
-    } else if (port > 0 && port < 65535) {
-	snprintf(portstr, sizeof(portstr), "%d", port);
-    } else {
-	FatalError("Xserver: port out of range: %d\n", port);
+        pport = NULL;
+    }
+    else if (port > 0 && port < 65535) {
+        snprintf(portstr, sizeof(portstr), "%d", port);
+    }
+    else {
+        FatalError("Xserver: port out of range: %d\n", port);
     }
 
     if (*aifirstp != NULL) {
-	freeaddrinfo(*aifirstp);	
-	*aifirstp = NULL;
+        freeaddrinfo(*aifirstp);
+        *aifirstp = NULL;
     }
 
     if ((gaierr = getaddrinfo(namestr, pport, &hints, aifirstp)) == 0) {
-	for (ai = *aifirstp; ai != NULL; ai = ai->ai_next) {
-	    if (ai->ai_family == AF_INET || ai->ai_family == AF_INET6)
-		break;
-	}
-	if ((ai == NULL) || (ai->ai_addrlen > sizeof(SOCKADDR_TYPE))) {
-	    FatalError ("Xserver: %s host %s not on supported network type\n", 
-	      argtype, namestr);
-	} else {
-	    *aip = ai;
-	    *addrlen = ai->ai_addrlen;
-	    memcpy(addr, ai->ai_addr, ai->ai_addrlen);
-	}
-    } else {
-	FatalError("Xserver: %s: %s %s\n", gai_strerror(gaierr), argtype, namestr);
-    }    
+        for (ai = *aifirstp; ai != NULL; ai = ai->ai_next) {
+            if (ai->ai_family == AF_INET || ai->ai_family == AF_INET6)
+                break;
+        }
+        if ((ai == NULL) || (ai->ai_addrlen > sizeof(SOCKADDR_TYPE))) {
+            FatalError("Xserver: %s host %s not on supported network type\n",
+                       argtype, namestr);
+        }
+        else {
+            *aip = ai;
+            *addrlen = ai->ai_addrlen;
+            memcpy(addr, ai->ai_addr, ai->ai_addrlen);
+        }
+    }
+    else {
+        FatalError("Xserver: %s: %s %s\n", gai_strerror(gaierr), argtype,
+                   namestr);
+    }
 #else
     struct hostent *hep;
+
 #ifdef XTHREADS_NEEDS_BYNAMEPARAMS
     _Xgethostbynameparams hparams;
 #endif
 #if defined(WIN32) && defined(TCPCONN)
-    _XSERVTransWSAStartup(); 
+    _XSERVTransWSAStartup();
 #endif
-    if (!(hep = _XGethostbyname(namestr, hparams)))
-    {
-	FatalError("Xserver: %s unknown host: %s\n", argtype, namestr);
+    if (!(hep = _XGethostbyname(namestr, hparams))) {
+        FatalError("Xserver: %s unknown host: %s\n", argtype, namestr);
     }
-    if (hep->h_length == sizeof (struct in_addr))
-    {
-	memmove(&addr->sin_addr, hep->h_addr, hep->h_length);
-	*addrlen = sizeof(struct sockaddr_in);
-	addr->sin_family = AF_INET;
-	addr->sin_port = htons (port);
+    if (hep->h_length == sizeof(struct in_addr)) {
+        memmove(&addr->sin_addr, hep->h_addr, hep->h_length);
+        *addrlen = sizeof(struct sockaddr_in);
+        addr->sin_family = AF_INET;
+        addr->sin_port = htons(port);
     }
-    else
-    {
-	FatalError("Xserver: %s host on strange network %s\n", argtype, namestr);
+    else {
+        FatalError("Xserver: %s host on strange network %s\n", argtype,
+                   namestr);
     }
 #endif
 }
 
 static void
-get_manager_by_name(
-    int	    argc,
-    char    **argv,
-    int	    i)
+get_manager_by_name(int argc, char **argv, int i)
 {
 
-    if ((i + 1) == argc)
-    {
-	FatalError("Xserver: missing %s host name in command line\n", argv[i]);
+    if ((i + 1) == argc) {
+        FatalError("Xserver: missing %s host name in command line\n", argv[i]);
     }
 
-    get_addr_by_name(argv[i], argv[i+1], xdm_udp_port, SOCK_DGRAM, 
-      &ManagerAddress, &ManagerAddressLen
+    get_addr_by_name(argv[i], argv[i + 1], xdm_udp_port, SOCK_DGRAM,
+                     &ManagerAddress, &ManagerAddressLen
 #if defined(IPv6) && defined(AF_INET6)
-      , &mgrAddr, &mgrAddrFirst
+                     , &mgrAddr, &mgrAddrFirst
 #endif
-	);
+        );
 }
 
-
 static void
-get_fromaddr_by_name(
-    int	    argc,
-    char    **argv,
-    int	    i)
+get_fromaddr_by_name(int argc, char **argv, int i)
 {
 #if defined(IPv6) && defined(AF_INET6)
     struct addrinfo *ai = NULL;
     struct addrinfo *aifirst = NULL;
 #endif
-    if (i == argc)
-    {
-	FatalError("Xserver: missing -from host name in command line\n");
+    if (i == argc) {
+        FatalError("Xserver: missing -from host name in command line\n");
     }
     get_addr_by_name("-from", argv[i], 0, 0, &FromAddress, &FromAddressLen
 #if defined(IPv6) && defined(AF_INET6)
-      , &ai, &aifirst
+                     , &ai, &aifirst
 #endif
-	);
+        );
 #if defined(IPv6) && defined(AF_INET6)
     if (aifirst != NULL)
-	freeaddrinfo(aifirst);
+        freeaddrinfo(aifirst);
 #endif
     xdm_from = argv[i];
 }
 
-
 #if defined(IPv6) && defined(AF_INET6)
 static int
 get_mcast_options(int argc, char **argv, int i)
@@ -1601,61 +1547,65 @@ get_mcast_options(int argc, char **argv, int i)
     struct addrinfo *ai, *firstai;
 
     if ((i < argc) && (argv[i][0] != '-') && (argv[i][0] != '+')) {
-	address = argv[i++];
-	if ((i < argc) && (argv[i][0] != '-') && (argv[i][0] != '+')) {
-	    hopcount = strtol(argv[i++], NULL, 10);
-	    if ((hopcount < 1) || (hopcount > 255)) {
-		FatalError("Xserver: multicast hop count out of range: %d\n",
-		  hopcount);
-	    }
-	}
+        address = argv[i++];
+        if ((i < argc) && (argv[i][0] != '-') && (argv[i][0] != '+')) {
+            hopcount = strtol(argv[i++], NULL, 10);
+            if ((hopcount < 1) || (hopcount > 255)) {
+                FatalError("Xserver: multicast hop count out of range: %d\n",
+                           hopcount);
+            }
+        }
     }
 
     if (xdm_udp_port > 0 && xdm_udp_port < 65535) {
-	snprintf(portstr, sizeof(portstr), "%d", xdm_udp_port);
-    } else {
-	FatalError("Xserver: port out of range: %d\n", xdm_udp_port);
+        snprintf(portstr, sizeof(portstr), "%d", xdm_udp_port);
+    }
+    else {
+        FatalError("Xserver: port out of range: %d\n", xdm_udp_port);
     }
     memset(&hints, 0, sizeof(hints));
     hints.ai_socktype = SOCK_DGRAM;
 
     if ((gaierr = getaddrinfo(address, portstr, &hints, &firstai)) == 0) {
-	for (ai = firstai; ai != NULL; ai = ai->ai_next) {
-	    if (((ai->ai_family == AF_INET) && 
-	      	IN_MULTICAST(((struct sockaddr_in *) ai->ai_addr)
-							  ->sin_addr.s_addr))
-		|| ((ai->ai_family == AF_INET6) && 
-		  IN6_IS_ADDR_MULTICAST(&((struct sockaddr_in6 *) ai->ai_addr)
-							    ->sin6_addr)))
-		break;
-	}
-	if (ai == NULL) {
-	    FatalError ("Xserver: address not supported multicast type %s\n", 
-	      address);
-	} else {
-	    struct multicastinfo	*mcastinfo, *mcl;
-	    
-	    mcastinfo = malloc(sizeof(struct multicastinfo));
-	    mcastinfo->next = NULL;
-	    mcastinfo->ai = firstai;
-	    mcastinfo->hops = hopcount;
-
-	    if (mcastlist == NULL) {
-		mcastlist = mcastinfo;
-	    } else {
-		for (mcl = mcastlist; mcl->next != NULL; mcl = mcl->next) {
-		    /* Do nothing  - just find end of list */
-		}
-		mcl->next = mcastinfo;
-	    }
-	}
-    } else {
-	FatalError("Xserver: %s: %s\n", gai_strerror(gaierr), address);
-    }    
+        for (ai = firstai; ai != NULL; ai = ai->ai_next) {
+            if (((ai->ai_family == AF_INET) &&
+                 IN_MULTICAST(((struct sockaddr_in *) ai->ai_addr)
+                              ->sin_addr.s_addr))
+                || ((ai->ai_family == AF_INET6) &&
+                    IN6_IS_ADDR_MULTICAST(&((struct sockaddr_in6 *) ai->ai_addr)
+                                          ->sin6_addr)))
+                break;
+        }
+        if (ai == NULL) {
+            FatalError("Xserver: address not supported multicast type %s\n",
+                       address);
+        }
+        else {
+            struct multicastinfo *mcastinfo, *mcl;
+
+            mcastinfo = malloc(sizeof(struct multicastinfo));
+            mcastinfo->next = NULL;
+            mcastinfo->ai = firstai;
+            mcastinfo->hops = hopcount;
+
+            if (mcastlist == NULL) {
+                mcastlist = mcastinfo;
+            }
+            else {
+                for (mcl = mcastlist; mcl->next != NULL; mcl = mcl->next) {
+                    /* Do nothing  - just find end of list */
+                }
+                mcl->next = mcastinfo;
+            }
+        }
+    }
+    else {
+        FatalError("Xserver: %s: %s\n", gai_strerror(gaierr), address);
+    }
     return i;
 }
 #endif
 
 #else
-static int xdmcp_non_empty; /* avoid complaint by ranlib */
-#endif /* XDMCP */
+static int xdmcp_non_empty;     /* avoid complaint by ranlib */
+#endif                          /* XDMCP */