Imported nx-X11-3.1.0-1.tar.gznx-X11/3.1.0-1

Summary: Imported nx-X11-3.1.0-1.tar.gz
Keywords:

Imported nx-X11-3.1.0-1.tar.gz
into Git repository

1 files changed, 1681 insertions, 0 deletions

diff --git a/nx-X11/programs/Xserver/os/xdmcp.c.X.original b/nx-X11/programs/Xserver/os/xdmcp.c.X.original
new file mode 100644
index 000000000..19a62a56b
--- /dev/null
+++ b/nx-X11/programs/Xserver/os/xdmcp.c.X.original
@@ -0,0 +1,1681 @@
+/* $XdotOrg: xc/programs/Xserver/os/xdmcp.c,v 1.10 2005/07/03 08:53:52 daniels Exp $ */
+/* $Xorg: xdmcp.c,v 1.4 2001/01/31 13:37:19 pookie Exp $ */
+/*
+ * Copyright 1989 Network Computing Devices, Inc., Mountain View, California.
+ *
+ * Permission to use, copy, modify, and distribute this software and its
+ * documentation for any purpose and without fee is hereby granted, provided
+ * that the above copyright notice appear in all copies and that both that
+ * copyright notice and this permission notice appear in supporting
+ * documentation, and that the name of N.C.D. not be used in advertising or
+ * publicity pertaining to distribution of the software without specific,
+ * written prior permission.  N.C.D. makes no representations about the
+ * suitability of this software for any purpose.  It is provided "as is"
+ * without express or implied warranty.
+ *
+ */
+/* $XFree86: xc/programs/Xserver/os/xdmcp.c,v 3.31 2003/12/30 21:24:32 herrb Exp $ */
+
+#ifdef HAVE_DIX_CONFIG_H
+#include <dix-config.h>
+#endif
+
+#ifdef WIN32
+#include <X11/Xwinsock.h>
+#endif
+
+#include <X11/Xos.h>
+
+#if !defined(WIN32)
+#ifndef Lynx
+#include <sys/param.h>
+#include <sys/socket.h>
+#else
+#include <socket.h>
+#endif
+#include <netinet/in.h>
+#include <netdb.h>
+#endif
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <X11/X.h>
+#include <X11/Xmd.h>
+#include "misc.h"
+#include <X11/Xpoll.h>
+#include "osdep.h"
+#include "input.h"
+#include "dixstruct.h"
+#include "opaque.h"
+
+#if defined(DGUX)
+#include <net/net_ioctl.h>
+#include <sys/ioctl.h>
+#endif
+
+#ifdef STREAMSCONN
+#include <tiuser.h>
+#include <netconfig.h>
+#include <netdir.h>
+#endif
+
+#ifdef XDMCP
+#undef REQUEST
+
+#ifdef XDMCP_NO_IPV6
+#undef IPv6
+#endif
+
+#include <X11/Xdmcp.h>
+
+#define X_INCLUDE_NETDB_H
+#include <X11/Xos_r.h>
+
+extern char *defaultDisplayClass;
+
+static int		    xdmcpSocket, sessionSocket;
+static xdmcp_states	    state;
+#if defined(IPv6) && defined(AF_INET6)
+static int		    xdmcpSocket6;
+static struct sockaddr_storage req_sockaddr;
+#else
+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;
+#ifdef HASXDMAUTH
+static char		    *xdmAuthCookie;
+#endif
+
+static XdmcpBuffer	    buffer;
+
+#if defined(IPv6) && defined(AF_INET6)
+
+static struct addrinfo *mgrAddr;
+static struct addrinfo *mgrAddrFirst;
+
+#define SOCKADDR_TYPE		struct sockaddr_storage
+#define SOCKADDR_FAMILY(s)	((struct sockaddr *)&(s))->sa_family
+
+#ifdef BSD44SOCKETS
+#define SOCKLEN_FIELD(s)	((struct sockaddr *)&(s))->sa_len
+#define SOCKLEN_TYPE 		unsigned char
+#else
+#define SOCKLEN_TYPE 		unsigned int
+#endif
+
+#else
+
+#define SOCKADDR_TYPE		struct sockaddr_in
+#define SOCKADDR_FAMILY(s)	(s).sin_family
+
+#ifdef BSD44SOCKETS
+#define SOCKLEN_FIELD(s)	(s).sin_len
+#define SOCKLEN_TYPE		unsigned char
+#else
+#define SOCKLEN_TYPE		size_t
+#endif
+
+#endif
+
+static SOCKADDR_TYPE		ManagerAddress;
+static SOCKADDR_TYPE		FromAddress;
+
+#ifdef SOCKLEN_FIELD
+#define ManagerAddressLen	SOCKLEN_FIELD(ManagerAddress)
+#define FromAddressLen		SOCKLEN_FIELD(FromAddress)
+#else
+static SOCKLEN_TYPE ManagerAddressLen, FromAddressLen;
+#endif
+
+#if defined(IPv6) && defined(AF_INET6)
+static struct multicastinfo {
+    struct multicastinfo	*next;
+    struct addrinfo		*ai;
+    int				 hops;
+} *mcastlist;
+#endif
+
+static void XdmcpAddHost(
+    struct sockaddr    *from,
+    int			fromlen,
+    ARRAY8Ptr		AuthenticationName,
+    ARRAY8Ptr		hostname,
+    ARRAY8Ptr		status);
+
+static void XdmcpSelectHost(
+    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 send_request_msg(void);
+
+static void recv_accept_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_failed_msg(unsigned /*length*/);
+
+static void send_keepalive_msg(void);
+
+static void recv_alive_msg(unsigned /*length*/);
+
+static void XdmcpFatal(
+    char * /*type*/,
+    ARRAY8Ptr /*status*/);
+ 
+static void XdmcpWarning(char * /*str*/);
+
+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*/);
+#endif
+
+static void receive_packet(int /*socketfd*/);
+
+static void send_packet(void);
+
+extern void XdmcpDeadSession(char * /*reason*/);
+
+static void timeout(void);
+
+static void restart(void);
+
+static void XdmcpBlockHandler(
+    pointer /*data*/,
+    struct timeval ** /*wt*/,
+    pointer /*LastSelectMask*/);
+
+static void XdmcpWakeupHandler(
+    pointer /*data*/,
+    int /*i*/,
+    pointer /*LastSelectMask*/);
+
+void XdmcpRegisterManufacturerDisplayID(
+    char    * /*name*/,
+    int	    /*length*/);
+
+
+static unsigned short	xdm_udp_port = XDM_UDP_PORT;
+static Bool	OneSession = FALSE;
+static const char 	*xdm_from = NULL;
+
+void
+XdmcpUseMsg (void)
+{
+    ErrorF("-query host-name       contact named host for XDMCP\n");
+    ErrorF("-broadcast             broadcast for XDMCP\n");
+#if defined(IPv6) && defined(AF_INET6)
+    ErrorF("-multicast [addr [hops]] IPv6 multicast for XDMCP\n");
+#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("-once                  Terminate server after one session\n");
+    ErrorF("-class display-class   specify display class to send in manage\n");
+#ifdef HASXDMAUTH
+    ErrorF("-cookie xdm-auth-bits  specify the magic cookie for XDMCP\n");
+#endif
+    ErrorF("-displayID display-id  manufacturer display ID for request\n");
+}
+
+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);
+    }
+    if (strcmp(argv[i], "-broadcast") == 0) {
+	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);
+    }
+#endif
+    if (strcmp(argv[i], "-indirect") == 0) {
+	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 (strcmp(argv[i], "-from") == 0) {
+	get_fromaddr_by_name(argc, argv, ++i);
+	return (i + 1);
+    }
+    if (strcmp(argv[i], "-once") == 0) {
+	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);
+    }
+#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);
+    }
+#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);
+    }
+    return (i);
+}
+
+/*
+ * This section is a collection of routines for
+ * registering server-specific data with the XDMCP
+ * state machine.
+ */
+
+
+/*
+ * Save all broadcast addresses away so BroadcastQuery
+ * packets get sent everywhere
+ */
+
+#define MAX_BROADCAST	10
+
+/* This stays sockaddr_in since IPv6 doesn't support broadcast */
+static struct sockaddr_in   BroadcastAddresses[MAX_BROADCAST];
+static int		    NumBroadcastAddresses;
+
+void
+XdmcpRegisterBroadcastAddress (struct sockaddr_in *addr)
+{
+    struct sockaddr_in	*bcast;
+    if (NumBroadcastAddresses >= MAX_BROADCAST)
+	return;
+    bcast = &BroadcastAddresses[NumBroadcastAddresses++];
+    bzero (bcast, 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_addr = addr->sin_addr;
+}
+
+/*
+ * Each authentication type is registered here; Validator
+ * will be called to check all access attempts using
+ * the specified authentication type
+ */
+
+static ARRAYofARRAY8	AuthenticationNames, AuthenticationDatas;
+typedef struct _AuthenticationFuncs {
+    ValidatorFunc    Validator;
+    GeneratorFunc    Generator;
+    AddAuthorFunc    AddAuth;
+} AuthenticationFuncsRec, *AuthenticationFuncsPtr;
+
+static AuthenticationFuncsPtr	AuthenticationFuncsList;
+
+void
+XdmcpRegisterAuthentication (
+    char    *name,
+    int	    namelen,
+    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;
+    }
+    for (i = 0; i < namelen; 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 = (AuthenticationFuncsPtr) xalloc (
+			(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;
+    xfree (AuthenticationFuncsList);
+    AuthenticationFuncsList = newFuncs;
+    AuthenticationNames.data[AuthenticationNames.length-1] = AuthenticationName;
+    AuthenticationDatas.data[AuthenticationDatas.length-1] = AuthenticationData;
+}
+
+/*
+ * Select the authentication type to be used; this is
+ * set by the manager of the host to be connected to.
+ */
+
+ARRAY8		noAuthenticationName = {(CARD16) 0, (CARD8Ptr) 0};
+ARRAY8		noAuthenticationData = {(CARD16) 0, (CARD8Ptr) 0};
+ARRAY8Ptr	AuthenticationName = &noAuthenticationName;
+ARRAY8Ptr	AuthenticationData = &noAuthenticationData;
+AuthenticationFuncsPtr	AuthenticationFuncs;
+
+void
+XdmcpSetAuthentication (ARRAY8Ptr name)
+{
+    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;
+	}
+}
+
+/*
+ * Register the host address for the display
+ */
+
+static ARRAY16		ConnectionTypes;
+static ARRAYofARRAY8	ConnectionAddresses;
+static long		xdmcpGeneration;
+
+void
+XdmcpRegisterConnection (
+    int	    type,
+    char    *address,
+    int	    addrlen)
+{
+    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 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];
+	    } 
+#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((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;
+	}
+    }
+    newAddress = (CARD8 *) xalloc (addrlen * sizeof (CARD8));
+    if (!newAddress)
+	return;
+    if (!XdmcpReallocARRAY16 (&ConnectionTypes, ConnectionTypes.length + 1))
+    {
+	xfree (newAddress);
+	return;
+    }
+    if (!XdmcpReallocARRAYofARRAY8 (&ConnectionAddresses,
+				    ConnectionAddresses.length +  1))
+    {
+	xfree (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;
+}
+
+/*
+ * Register an Authorization Name.  XDMCP advertises this list
+ * to the manager.
+ */
+
+static ARRAYofARRAY8	AuthorizationNames;
+
+void
+XdmcpRegisterAuthorizations (void)
+{
+    XdmcpDisposeARRAYofARRAY8 (&AuthorizationNames);
+    RegisterAuthorizations ();
+}
+
+void
+XdmcpRegisterAuthorization (char *name, int namelen)
+{
+    ARRAY8  authName;
+    int	    i;
+
+    authName.data = (CARD8 *) xalloc (namelen * sizeof (CARD8));
+    if (!authName.data)
+	return;
+    if (!XdmcpReallocARRAYofARRAY8 (&AuthorizationNames, AuthorizationNames.length +1))
+    {
+	xfree (authName.data);
+	return;
+    }
+    for (i = 0; i < namelen; i++)
+	authName.data[i] = (CARD8) name[i];
+    authName.length = namelen;
+    AuthorizationNames.data[AuthorizationNames.length-1] = authName;
+}
+
+/*
+ * Register the DisplayClass string
+ */
+
+ARRAY8	DisplayClass;
+
+void
+XdmcpRegisterDisplayClass (char *name, int length)
+{
+    int	    i;
+
+    XdmcpDisposeARRAY8 (&DisplayClass);
+    if (!XdmcpAllocARRAY8 (&DisplayClass, length))
+	return;
+    for (i = 0; i < length; i++)
+	DisplayClass.data[i] = (CARD8) name[i];
+}
+
+/*
+ * Register the Manufacturer display ID
+ */
+
+ARRAY8 ManufacturerDisplayID;
+
+void
+XdmcpRegisterManufacturerDisplayID (char *name, int length)
+{
+    int	    i;
+
+    XdmcpDisposeARRAY8 (&ManufacturerDisplayID);
+    if (!XdmcpAllocARRAY8 (&ManufacturerDisplayID, length))
+	return;
+    for (i = 0; i < length; i++)
+	ManufacturerDisplayID.data[i] = (CARD8) name[i];
+}
+
+/* 
+ * initialize XDMCP; create the socket, compute the display
+ * number, set up the state machine
+ */
+
+void 
+XdmcpInit(void)
+{
+    state = XDM_INIT_STATE;
+#ifdef HASXDMAUTH
+    if (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();
+    }
+}
+
+void
+XdmcpReset (void)
+{
+    state = XDM_INIT_STATE;
+    if (state != XDM_OFF)
+    {
+	RegisterBlockAndWakeupHandlers (XdmcpBlockHandler, XdmcpWakeupHandler,
+				        (pointer) 0);
+    	timeOutRtx = 0;
+    	send_packet();
+    }
+}
+
+/*
+ * Called whenever a new connection is created; notices the
+ * first connection and saves it to terminate the session
+ * when it is closed
+ */
+
+void
+XdmcpOpenDisplay(int sock)
+{
+    if (state != XDM_AWAIT_MANAGE_RESPONSE)
+	return;
+    state = XDM_RUN_SESSION;
+    sessionSocket = sock;
+}
+
+void 
+XdmcpCloseDisplay(int sock)
+{
+    if ((state != XDM_RUN_SESSION && state != XDM_AWAIT_ALIVE_RESPONSE)
+	|| sessionSocket != sock)
+	    return;
+    state = XDM_INIT_STATE;
+    if (OneSession)
+	dispatchException |= DE_TERMINATE;
+    else
+	dispatchException |= DE_RESET;
+    isItTimeToYield = TRUE;
+}
+
+/*
+ * called before going to sleep, this routine
+ * may modify the timeout value about to be sent
+ * to select; in this way XDMCP can do appropriate things
+ * dynamically while starting up
+ */
+
+/*ARGSUSED*/
+static void
+XdmcpBlockHandler(
+    pointer	    data,   /* unused */
+    struct timeval  **wt,
+    pointer	    pReadmask)
+{
+    fd_set *LastSelectMask = (fd_set*)pReadmask;
+    CARD32 millisToGo;
+
+    if (state == XDM_OFF)
+	return;
+    FD_SET(xdmcpSocket, LastSelectMask);
+#if defined(IPv6) && defined(AF_INET6)
+    if (xdmcpSocket6 >= 0)
+	FD_SET(xdmcpSocket6, LastSelectMask);
+#endif
+    if (timeOutTime == 0)
+	return;
+    millisToGo = timeOutTime - GetTimeInMillis();
+    if ((int) millisToGo < 0)
+	millisToGo = 0;
+    AdjustWaitForDelay (wt, millisToGo);
+}
+
+/*
+ * called after select returns; this routine will
+ * recognise when XDMCP packets await and
+ * process them appropriately
+ */
+
+/*ARGSUSED*/
+static void
+XdmcpWakeupHandler(
+    pointer data,   /* unused */
+    int	    i,
+    pointer pReadmask)
+{
+    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);
+	} 
+#if defined(IPv6) && defined(AF_INET6)
+	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;
+    }
+    else if (timeOutTime && (int) (GetTimeInMillis() - timeOutTime) >= 0)
+    {
+    	if (state == XDM_RUN_SESSION)
+    	{
+	    state = XDM_KEEPALIVE;
+	    send_packet();
+    	}
+    	else
+	    timeout();
+    }
+}
+
+/*
+ * This routine should be called from the routine that drives the
+ * user's host menu when the user selects a host
+ */
+
+static void
+XdmcpSelectHost(
+    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);
+    send_packet();
+}
+
+/*
+ * !!! this routine should be replaced by a routine that adds
+ * the host to the user's host menu. the current version just
+ * selects the first host to respond with willing message.
+ */
+
+/*ARGSUSED*/
+static void
+XdmcpAddHost(
+    struct sockaddr    *from,
+    int			fromlen,
+    ARRAY8Ptr		AuthenticationName,
+    ARRAY8Ptr		hostname,
+    ARRAY8Ptr		status)
+{
+    XdmcpSelectHost(from, fromlen, AuthenticationName);
+}
+
+/*
+ * A message is queued on the socket; read it and
+ * do the appropriate thing
+ */
+
+ARRAY8	UnwillingMessage = { (CARD8) 14, (CARD8 *) "Host unwilling" };
+
+static void
+receive_packet(int socketfd)
+{
+#if defined(IPv6) && defined(AF_INET6)
+    struct sockaddr_storage from;
+#else
+    struct sockaddr_in from;
+#endif
+    int fromlen = sizeof(from);
+    XdmcpHeader	header;
+
+    /* read message off socket */
+    if (!XdmcpFill (socketfd, &buffer, (XdmcpNetaddr) &from, &fromlen))
+	return;
+
+    /* reset retransmission backoff */
+    timeOutRtx = 0;
+
+    if (!XdmcpReadHeader (&buffer, &header))
+	return;
+
+    if (header.version != XDM_PROTOCOL_VERSION)
+	return;
+
+    switch (header.opcode) {
+    case WILLING:
+	recv_willing_msg((struct sockaddr *) &from, fromlen, header.length);
+	break;
+    case UNWILLING:
+	XdmcpFatal("Manager unwilling", &UnwillingMessage);
+	break;
+    case ACCEPT:
+	recv_accept_msg(header.length);
+	break;
+    case DECLINE:
+	recv_decline_msg(header.length);
+	break;
+    case REFUSE:
+	recv_refuse_msg(header.length);
+	break;
+    case FAILED:
+	recv_failed_msg(header.length);
+	break;
+    case ALIVE:
+	recv_alive_msg(header.length);
+	break;
+    }
+}
+
+/*
+ * send the appropriate message given the current state
+ */
+
+static void
+send_packet(void)
+{
+    int rtx;
+    switch (state) {
+    case XDM_QUERY:
+    case XDM_BROADCAST:
+    case XDM_INDIRECT:
+#if defined(IPv6)  && defined(AF_INET6)
+    case XDM_MULTICAST:
+#endif
+	send_query_msg();
+	break;
+    case XDM_START_CONNECTION:
+	send_request_msg();
+	break;
+    case XDM_MANAGE:
+	send_manage_msg();
+	break;
+    case XDM_KEEPALIVE:
+	send_keepalive_msg();
+	break;
+    default:
+	break;
+    }
+    rtx = (XDM_MIN_RTX << timeOutRtx);
+    if (rtx > XDM_MAX_RTX)
+	rtx = XDM_MAX_RTX;
+    timeOutTime = GetTimeInMillis() + rtx * 1000;
+}
+
+/*
+ * The session is declared dead for some reason; too many
+ * timeouts, or Keepalive failure.
+ */
+
+void
+XdmcpDeadSession (char *reason)
+{
+    ErrorF ("XDM: %s, declaring session dead\n", reason);
+    state = XDM_INIT_STATE;
+    isItTimeToYield = TRUE;
+    dispatchException |= DE_RESET;
+    timeOutTime = 0;
+    timeOutRtx = 0;
+    send_packet();
+}
+
+/*
+ * Timeout waiting for an XDMCP response.
+ */
+
+static void
+timeout(void)
+{
+    timeOutRtx++;
+    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. */
+        if (OneSession) {
+	    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;
+	}
+#ifndef SIN6_LEN
+	ManagerAddressLen = mgrAddr->ai_addrlen;
+#endif
+	memcpy(&ManagerAddress, mgrAddr->ai_addr, mgrAddr->ai_addrlen);
+    }
+#endif
+
+    switch (state) {
+    case XDM_COLLECT_QUERY:
+	state = XDM_QUERY;
+	break;
+    case XDM_COLLECT_BROADCAST_QUERY:
+	state = XDM_BROADCAST;
+	break;
+#if defined(IPv6) && defined(AF_INET6)
+    case XDM_COLLECT_MULTICAST_QUERY:
+	state = XDM_MULTICAST;
+	break;
+#endif
+    case XDM_COLLECT_INDIRECT_QUERY:
+	state = XDM_INDIRECT;
+	break;
+    case XDM_AWAIT_REQUEST_RESPONSE:
+	state = XDM_START_CONNECTION;
+	break;
+    case XDM_AWAIT_MANAGE_RESPONSE:
+	state = XDM_MANAGE;
+	break;
+    case XDM_AWAIT_ALIVE_RESPONSE:
+	state = XDM_KEEPALIVE;
+	break;
+    default:
+	break;
+    }
+    send_packet();
+}
+
+static void
+restart(void)
+{
+    state = XDM_INIT_STATE;
+    timeOutRtx = 0;
+    send_packet();
+}
+
+int
+XdmcpCheckAuthentication (
+    ARRAY8Ptr	Name,
+    ARRAY8Ptr	Data,
+    int	packet_type)
+{
+    return (XdmcpARRAY8Equal (Name, AuthenticationName) &&
+	    (AuthenticationName->length == 0 ||
+	     (*AuthenticationFuncs->Validator) (AuthenticationData, Data, packet_type)));
+}
+
+int
+XdmcpAddAuthorization (
+    ARRAY8Ptr	name,
+    ARRAY8Ptr	data)
+{
+    AddAuthorFunc AddAuth;
+
+    if (AuthenticationFuncs && AuthenticationFuncs->AddAuth)
+	AddAuth = AuthenticationFuncs->AddAuth;
+    else
+	AddAuth = AddAuthorization;
+    return (*AddAuth) ((unsigned short)name->length,
+		       (char *)name->data,
+		       (unsigned short)data->length,
+		       (char *)data->data);
+}
+
+/*
+ * from here to the end of this file are routines private
+ * to the state machine.
+ */
+
+static void
+get_xdmcp_sock(void)
+{
+#ifdef STREAMSCONN
+    struct netconfig *nconf;
+
+    if ((xdmcpSocket = t_open("/dev/udp", O_RDWR, 0)) < 0) {
+	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;
+    }
+
+    /*
+     * 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( 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");
+#endif
+    if ((xdmcpSocket = socket(AF_INET, SOCK_DGRAM, 0)) < 0)
+	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 */
+    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);
+	}
+    }
+#endif /* STREAMSCONN */
+}
+
+static void
+send_query_msg(void)
+{
+    XdmcpHeader	header;
+    Bool	broadcast = FALSE;
+#if defined(IPv6) && defined(AF_INET6)
+    Bool	multicast = FALSE;
+#endif
+    int		i;
+    int 	socketfd = xdmcpSocket;
+
+    header.version = XDM_PROTOCOL_VERSION;
+    switch(state){
+    case XDM_QUERY:
+	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;
+#if defined(IPv6) && defined(AF_INET6)
+    case XDM_MULTICAST:
+	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;
+    default:
+	break;
+    }
+    header.length = 1;
+    for (i = 0; i < AuthenticationNames.length; i++)
+	header.length += 2 + AuthenticationNames.data[i].length;
+
+    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));
+    }
+#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;
+	    }
+	}
+    }
+#endif
+    else
+    {
+#if defined(IPv6) && defined(AF_INET6)
+	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)
+{
+    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 defined(IPv6) && defined(AF_INET6)
+	    case XDM_COLLECT_MULTICAST_QUERY:
+#endif
+	    case XDM_COLLECT_INDIRECT_QUERY:
+	    	XdmcpAddHost(from, fromlen, &authenticationName, &hostname, &status);
+	    	break;
+	    default:
+		break;
+    	    }
+    	}
+    }
+    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;
+#if defined(IPv6) && defined(AF_INET6)
+    case AF_INET6:	XdmcpConnectionType=FamilyInternet6; break;
+#endif
+    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 */
+    for (i = 0; i < ConnectionAddresses.length; i++)
+	length += 2 + ConnectionAddresses.data[i].length;
+    authenticationData.length = 0;
+    authenticationData.data = 0;
+    if (AuthenticationFuncs)
+    {
+	(*AuthenticationFuncs->Generator) (AuthenticationData,
+					   &authenticationData,
+ 					   REQUEST);
+    }
+    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 */
+    header.length = length;
+
+    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);
+#if defined(IPv6) && defined(AF_INET6)
+    if (SOCKADDR_FAMILY(req_sockaddr) == AF_INET6)
+	socketfd = xdmcpSocket6;
+#endif
+    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;
+
+    if (state != XDM_AWAIT_REQUEST_RESPONSE)
+	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();
+    	}
+    }
+    XdmcpDisposeARRAY8 (&AcceptAuthenticationName);
+    XdmcpDisposeARRAY8 (&AcceptAuthenticationData);
+    XdmcpDisposeARRAY8 (&AcceptAuthorizationName);
+    XdmcpDisposeARRAY8 (&AcceptAuthorizationData);
+}
+
+static void
+recv_decline_msg(unsigned length)
+{
+    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);
+    	}
+    }
+    XdmcpDisposeARRAY8 (&status);
+    XdmcpDisposeARRAY8 (&DeclineAuthenticationName);
+    XdmcpDisposeARRAY8 (&DeclineAuthenticationData);
+}
+
+static void
+send_manage_msg(void)
+{
+    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);
+    state = XDM_AWAIT_MANAGE_RESPONSE;
+#if defined(IPv6) && defined(AF_INET6)
+    if (SOCKADDR_FAMILY(req_sockaddr) == AF_INET6)
+	socketfd = xdmcpSocket6;
+#endif
+    XdmcpFlush (socketfd, &buffer, (XdmcpNetaddr) &req_sockaddr, req_socklen);
+}
+
+static void
+recv_refuse_msg(unsigned length)
+{
+    CARD32  RefusedSessionID;
+
+    if (state != XDM_AWAIT_MANAGE_RESPONSE)
+	return;
+    if (length != 4)
+	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;
+
+    if (state != XDM_AWAIT_MANAGE_RESPONSE)
+	return;
+    status.data = 0;
+    if (XdmcpReadCARD32 (&buffer, &FailedSessionID) &&
+	XdmcpReadARRAY8 (&buffer, &status))
+    {
+    	if (length == 6 + status.length &&
+	    SessionID == FailedSessionID)
+	{
+	    XdmcpFatal ("Session failed", &status);
+	}
+    }
+    XdmcpDisposeARRAY8 (&status);
+}
+
+static void
+send_keepalive_msg(void)
+{
+    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);
+
+    state = XDM_AWAIT_ALIVE_RESPONSE;
+#if defined(IPv6) && defined(AF_INET6)
+    if (SOCKADDR_FAMILY(req_sockaddr) == AF_INET6)
+	socketfd = xdmcpSocket6;
+#endif
+    XdmcpFlush (socketfd, &buffer, (XdmcpNetaddr) &req_sockaddr, req_socklen);
+}
+
+static void
+recv_alive_msg (unsigned length)
+{
+    CARD8   SessionRunning;
+    CARD32  AliveSessionID;
+
+    if (state != XDM_AWAIT_ALIVE_RESPONSE)
+	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");
+    	}
+    }
+}
+
+static  void
+XdmcpFatal (
+    char	*type,
+    ARRAY8Ptr	status)
+{
+    FatalError ("XDMCP fatal error: %s %*.*s\n", type,
+	   status->length, status->length, status->data);
+}
+
+static  void
+XdmcpWarning(char *str)
+{
+    ErrorF("XDMCP warning: %s\n", str);
+}
+
+static void
+get_addr_by_name(
+    char *	argtype,
+    char *	namestr,
+    int		port,
+    int		socktype,
+    SOCKADDR_TYPE *addr,
+    SOCKLEN_TYPE *addrlen
+#if defined(IPv6) && defined(AF_INET6)
+      ,
+    struct addrinfo **aip,
+    struct addrinfo **aifirstp
+#endif
+    )
+{
+#if defined(IPv6) && defined(AF_INET6)
+    struct addrinfo *ai;
+    struct addrinfo hints;
+    char portstr[6];
+    char *pport = portstr;
+    int gaierr;
+
+    bzero(&hints, sizeof(hints));
+    hints.ai_socktype = socktype;
+
+    if (port == 0) {
+	pport = NULL;
+    } else if (port > 0 && port < 65535) {
+	sprintf(portstr, "%d", port);
+    } else {
+	FatalError("Xserver: port out of range: %d\n", port);
+    }
+
+    if (*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);
+    }    
+#else
+    struct hostent *hep;
+#ifdef XTHREADS_NEEDS_BYNAMEPARAMS
+    _Xgethostbynameparams hparams;
+#endif
+#if defined(WIN32) && (defined(TCPCONN) || defined(DNETCONN))
+    _XSERVTransWSAStartup(); 
+#endif
+    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);
+    }
+    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)
+{
+
+    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
+#if defined(IPv6) && defined(AF_INET6)
+      , &mgrAddr, &mgrAddrFirst
+#endif
+	);
+}
+
+
+static void
+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");
+    }
+    get_addr_by_name("-from", argv[i], 0, 0, &FromAddress, &FromAddressLen
+#if defined(IPv6) && defined(AF_INET6)
+      , &ai, &aifirst
+#endif
+	);
+    xdm_from = argv[i];
+}
+
+
+#if defined(IPv6) && defined(AF_INET6)
+static int
+get_mcast_options(argc, argv, i)
+    int	    argc, i;
+    char    **argv;
+{
+    char *address = XDM_DEFAULT_MCAST_ADDR6;
+    int hopcount = 1;
+    struct addrinfo hints;
+    char portstr[6];
+    int gaierr;
+    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);
+	    }
+	}
+    }
+
+    if (xdm_udp_port > 0 && xdm_udp_port < 65535) {
+	sprintf(portstr, "%d", xdm_udp_port);
+    } else {
+	FatalError("Xserver: port out of range: %d\n", xdm_udp_port);
+    }
+    bzero(&hints, 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);
+    }    
+    return i;
+}
+#endif
+
+#else
+static int xdmcp_non_empty; /* avoid complaint by ranlib */
+#endif /* XDMCP */