Convert nx-X11/lib/ build flow from imake to autotools.

20 files changed, 17982 insertions, 0 deletions

diff --git a/nx-X11/lib/include/Makefile.am b/nx-X11/lib/include/Makefile.am
new file mode 100644
index 000000000..9272e3cf5
--- /dev/null
+++ b/nx-X11/lib/include/Makefile.am
@@ -0,0 +1,32 @@
+NULL =
+
+x11includedir=${includedir}/nx-X11
+x11include_HEADERS=		\
+	X11/XKBlib.h		\
+	X11/Xcms.h		\
+	X11/Xlib.h		\
+	X11/Xlibint.h		\
+	X11/Xlocale.h		\
+	X11/Xresource.h		\
+	X11/Xutil.h		\
+	X11/cursorfont.h	\
+	X11/Xregion.h		\
+	X11/ImUtil.h		\
+	$(NULL)
+
+nodist_x11include_HEADERS=\
+	X11/XlibConf.h
+
+xtransincludedir=${includedir}/nx-X11/Xtrans
+xtransinclude_HEADERS =		\
+	xtrans/Xtransint.h	\
+	xtrans/Xtrans.h		\
+	xtrans/Xtranslcl.c	\
+	xtrans/transport.c	\
+	xtrans/Xtrans.c		\
+	xtrans/Xtranssock.c	\
+	xtrans/Xtransutil.c	\
+        $(NULL)
+
+EXTRA_DIST = \
+	X11/XlibConf.h.in
diff --git a/nx-X11/lib/include/X11/.gitignore b/nx-X11/lib/include/X11/.gitignore
new file mode 100644
index 000000000..be3bc6cfb
--- /dev/null
+++ b/nx-X11/lib/include/X11/.gitignore
@@ -0,0 +1 @@
+XlibConf.h
diff --git a/nx-X11/lib/include/X11/ImUtil.h b/nx-X11/lib/include/X11/ImUtil.h
new file mode 100644
index 000000000..a8b95eead
--- /dev/null
+++ b/nx-X11/lib/include/X11/ImUtil.h
@@ -0,0 +1,31 @@
+
+#if !defined(_X11_IMUTIL_H_) && !defined(_IM_UTIL_H_)
+#define _X11_IMUTIL_H_
+#define _IMUTIL_H_
+
+extern int
+_XGetScanlinePad(
+    Display *dpy,
+    int depth);
+
+extern int
+_XGetBitsPerPixel(
+ Display *dpy,
+ int depth);
+
+extern int
+_XSetImage(
+    XImage *srcimg,
+    register XImage *dstimg,
+    register int x,
+    register int y);
+
+extern int
+_XReverse_Bytes(
+    register unsigned char *bpt,
+    register int nb);
+extern void
+_XInitImageFuncPtrs(
+    register XImage *image);
+
+#endif /* !defined(_X11_IMUTIL_H_) && !defined(_IM_UTIL_H_) */
diff --git a/nx-X11/lib/include/X11/XKBlib.h b/nx-X11/lib/include/X11/XKBlib.h
new file mode 100644
index 000000000..dd2841e9a
--- /dev/null
+++ b/nx-X11/lib/include/X11/XKBlib.h
@@ -0,0 +1,1150 @@
+/************************************************************
+Copyright (c) 1993 by Silicon Graphics Computer Systems, Inc.
+
+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 Silicon Graphics not be
+used in advertising or publicity pertaining to distribution
+of the software without specific prior written permission.
+Silicon Graphics makes no representation about the suitability
+of this software for any purpose. It is provided "as is"
+without any express or implied warranty.
+
+SILICON GRAPHICS DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS
+SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS FOR A PARTICULAR PURPOSE. IN NO EVENT SHALL SILICON
+GRAPHICS BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL
+DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
+DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
+OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION  WITH
+THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+********************************************************/
+
+#if !defined(_X11_XKBLIB_H_) && !defined(_XKBLIB_H_)
+#define _X11_XKBLIB_H_
+#define _XKBLIB_H_
+
+#include <nx-X11/Xlib.h>
+#include <nx-X11/extensions/XKBstr.h>
+
+typedef struct _XkbAnyEvent {
+	int 		type;		/* XkbAnyEvent */
+	unsigned long 	serial;		/* # of last req processed by server */
+	Bool 		send_event;	/* is this from a SendEvent request? */
+	Display *	display;	/* Display the event was read from */
+	Time 		time;		/* milliseconds */
+	int 		xkb_type;	/* XKB event minor code */
+	unsigned int 	device;		/* device ID */
+} XkbAnyEvent;
+
+typedef struct _XkbNewKeyboardNotify {
+	int 		type;		/* XkbAnyEvent */
+	unsigned long 	serial;		/* of last req processed by server */
+	Bool 		send_event;	/* is this from a SendEvent request? */
+	Display *	display;	/* Display the event was read from */
+	Time 		time;		/* milliseconds */
+	int 		xkb_type;	/* XkbNewKeyboardNotify */
+	int	 	device;		/* device ID */
+	int	 	old_device;	/* device ID of previous keyboard */
+	int	 	min_key_code;	/* minimum key code */
+	int		max_key_code;	/* maximum key code */
+	int	 	old_min_key_code;/* min key code of previous kbd */
+	int		old_max_key_code;/* max key code of previous kbd */
+	unsigned int	changed;	/* changed aspects of the keyboard */
+	char	 	req_major;	/* major and minor opcode of req */
+	char	 	req_minor;	/* that caused change, if applicable */
+} XkbNewKeyboardNotifyEvent;
+
+typedef struct _XkbMapNotifyEvent {
+	int 		type;		/* XkbAnyEvent */
+	unsigned long 	serial;		/* of last req processed by server */
+	Bool 		send_event;	/* is this from a SendEvent request */
+	Display *	display;	/* Display the event was read from */
+	Time 		time;		/* milliseconds */
+	int 		xkb_type;	/* XkbMapNotify */
+	int 		device;		/* device ID */
+	unsigned int 	changed;	/* fields which have been changed */
+	unsigned int 	flags;		/* reserved */
+	int 		first_type;	/* first changed key type */
+	int 		num_types;	/* number of changed key types */
+	KeyCode		min_key_code;
+	KeyCode		max_key_code;
+	KeyCode		first_key_sym;
+	KeyCode		first_key_act;
+	KeyCode		first_key_behavior;
+	KeyCode		first_key_explicit;
+	KeyCode		first_modmap_key;
+	KeyCode		first_vmodmap_key;
+	int		num_key_syms;
+	int		num_key_acts;
+	int		num_key_behaviors;
+	int		num_key_explicit;
+	int 		num_modmap_keys;
+	int 		num_vmodmap_keys;
+	unsigned int 	vmods;		/* mask of changed virtual mods */
+} XkbMapNotifyEvent;
+
+typedef struct _XkbStateNotifyEvent {
+	int 		type;		/* XkbAnyEvent */
+	unsigned long 	serial;		/* # of last req processed by server */
+	Bool 		send_event;	/* is this from a SendEvent request? */
+	Display *	display;	/* Display the event was read from */
+	Time 		time;		/* milliseconds */
+	int 		xkb_type;	/* XkbStateNotify */
+	int 		device;		/* device ID */
+	unsigned int 	changed;	/* mask of changed state components */
+	int 		group;		/* keyboard group */
+	int 		base_group;	/* base keyboard group */
+	int 		latched_group;	/* latched keyboard group */
+	int 		locked_group;	/* locked keyboard group */
+	unsigned int	mods;		/* modifier state */
+	unsigned int 	base_mods;	/* base modifier state */
+	unsigned int	latched_mods;	/* latched modifiers */
+	unsigned int	locked_mods;	/* locked modifiers */
+	int 		compat_state;	/* compatibility state */
+	unsigned char	grab_mods;	/* mods used for grabs */
+	unsigned char	compat_grab_mods;/* grab mods for non-XKB clients */
+	unsigned char	lookup_mods;	/* mods sent to clients */
+	unsigned char	compat_lookup_mods; /* mods sent to non-XKB clients */
+	int 		ptr_buttons;	/* pointer button state */
+	KeyCode		keycode;	/* keycode that caused the change */
+	char 		event_type;	/* KeyPress or KeyRelease */
+	char 		req_major;	/* Major opcode of request */
+	char 		req_minor;	/* Minor opcode of request */
+} XkbStateNotifyEvent;
+
+typedef struct _XkbControlsNotify {
+	int 		type;		/* XkbAnyEvent */
+	unsigned long 	serial;		/* of last req processed by server */
+	Bool 		send_event;	/* is this from a SendEvent request? */
+	Display *	display;	/* Display the event was read from */
+	Time 		time;		/* milliseconds */
+	int 		xkb_type;	/* XkbControlsNotify */
+	int 		device;		/* device ID */
+	unsigned int	changed_ctrls;	/* controls with changed sub-values */
+	unsigned int 	enabled_ctrls;	/* controls currently enabled */
+	unsigned int	enabled_ctrl_changes;/* controls just {en,dis}abled */
+	int 		num_groups;	/* total groups on keyboard */
+	KeyCode		keycode;	/* key that caused change or 0 */
+	char 		event_type;	/* type of event that caused change */
+	char 		req_major;	/* if keycode==0, major and minor */
+	char 		req_minor;	/* opcode of req that caused change */
+} XkbControlsNotifyEvent;
+
+typedef struct _XkbIndicatorNotify {
+	int 		type;		/* XkbAnyEvent */
+	unsigned long 	serial;		/* of last req processed by server */
+	Bool 		send_event;	/* is this from a SendEvent request? */
+	Display *	display;	/* Display the event was read from */
+	Time 		time;		/* milliseconds */
+	int 		xkb_type;	/* XkbIndicatorNotify */
+	int 		device;		/* device ID */
+	unsigned int	changed;	/* indicators with new state or map */
+	unsigned int	state;	 	/* current state of all indicators */
+} XkbIndicatorNotifyEvent;
+
+typedef struct _XkbNamesNotify {
+	int 		type;		/* XkbAnyEvent */
+	unsigned long 	serial;		/* of last req processed by server */
+	Bool 		send_event;	/* is this from a SendEvent request? */
+	Display *	display;	/* Display the event was read from */
+	Time 		time;		/* milliseconds */
+	int 		xkb_type;	/* XkbNamesNotify */
+	int	 	device;		/* device ID */
+	unsigned int 	changed;	/* names that have changed */
+	int	 	first_type;	/* first key type with new name */
+	int	 	num_types;	/* number of key types with new names */
+	int	 	first_lvl;	/* first key type new new level names */
+	int	 	num_lvls;	/* # of key types w/new level names */
+	int	 	num_aliases;	/* total number of key aliases*/
+	int	 	num_radio_groups;/* total number of radio groups */
+	unsigned int 	changed_vmods;	/* virtual modifiers with new names */
+	unsigned int 	changed_groups;	/* groups with new names */
+	unsigned int 	changed_indicators;/* indicators with new names */
+	int		first_key;	/* first key with new name */
+	int		num_keys;	/* number of keys with new names */
+} XkbNamesNotifyEvent;
+
+typedef struct _XkbCompatMapNotify {
+	int 		type;		/* XkbAnyEvent */
+	unsigned long 	serial;		/* of last req processed by server */
+	Bool 		send_event;	/* is this from a SendEvent request? */
+	Display *	display;	/* Display the event was read from */
+	Time 		time;		/* milliseconds */
+	int 		xkb_type;	/* XkbCompatMapNotify */
+	int	 	device;		/* device ID */
+	unsigned int 	changed_groups; /* groups with new compat maps */
+	int	 	first_si;	/* first new symbol interp */
+	int	 	num_si;		/* number of new symbol interps */
+	int	 	num_total_si;	/* total # of symbol interps */
+} XkbCompatMapNotifyEvent;
+
+typedef struct _XkbBellNotify {
+	int 		type;		/* XkbAnyEvent */
+	unsigned long 	serial;		/* of last req processed by server */
+	Bool 		send_event;	/* is this from a SendEvent request? */
+	Display *	display;	/* Display the event was read from */
+	Time 		time;		/* milliseconds */
+	int 		xkb_type;	/* XkbBellNotify */
+	int	 	device;		/* device ID */
+	int	 	percent;	/* requested volume as a % of maximum */
+	int	 	pitch;		/* requested pitch in Hz */
+	int	 	duration;	/* requested duration in useconds */
+	int	 	bell_class;	/* (input extension) feedback class */
+	int	 	bell_id;	/* (input extension) ID of feedback */
+	Atom 		name;		/* "name" of requested bell */
+	Window 		window;		/* window associated with event */
+	Bool		event_only;	/* "event only" requested */
+} XkbBellNotifyEvent;
+
+typedef struct _XkbActionMessage {
+	int 		type;		/* XkbAnyEvent */
+	unsigned long 	serial;		/* of last req processed by server */
+	Bool 		send_event;	/* is this from a SendEvent request? */
+	Display *	display;	/* Display the event was read from */
+	Time 		time;		/* milliseconds */
+	int 		xkb_type;	/* XkbActionMessage */
+	int	 	device;		/* device ID */
+	KeyCode		keycode;	/* key that generated the event */
+	Bool 		press;		/* true if act caused by key press */
+	Bool 		key_event_follows;/* true if key event also generated */
+	int		group;		/* effective group */
+	unsigned int	mods;		/* effective mods */
+	char 		message[XkbActionMessageLength+1];
+					/* message -- leave space for NUL */
+} XkbActionMessageEvent;
+
+typedef struct _XkbAccessXNotify {
+	int 		type;		/* XkbAnyEvent */
+	unsigned long 	serial;		/* of last req processed by server */
+	Bool 		send_event;	/* is this from a SendEvent request? */
+	Display *	display;	/* Display the event was read from */
+	Time 		time;		/* milliseconds */
+	int 		xkb_type;	/* XkbAccessXNotify */
+	int	 	device;		/* device ID */
+	int	 	detail;		/* XkbAXN_* */
+	int	 	keycode;	/* key of event */
+	int	 	sk_delay;	/* current slow keys delay */
+	int		debounce_delay;	/* current debounce delay */
+} XkbAccessXNotifyEvent;
+
+typedef struct _XkbExtensionDeviceNotify {
+	int 		type;		/* XkbAnyEvent */
+	unsigned long 	serial;		/* of last req processed by server */
+	Bool 		send_event;	/* is this from a SendEvent request? */
+	Display *	display;	/* Display the event was read from */
+	Time 		time;		/* milliseconds */
+	int 		xkb_type;	/* XkbExtensionDeviceNotify */
+	int	 	device;		/* device ID */
+	unsigned int	reason;		/* reason for the event */
+	unsigned int	supported;	/* mask of supported features */
+	unsigned int	unsupported;	/* mask of unsupported features */
+					/* that some app tried to use */
+	int	 	first_btn;	/* first button that changed */
+	int	 	num_btns;	/* range of buttons changed */
+	unsigned int	leds_defined;   /* indicators with names or maps */
+	unsigned int	led_state;	/* current state of the indicators */
+	int		led_class;	/* feedback class for led changes */
+	int		led_id;   	/* feedback id for led changes */
+} XkbExtensionDeviceNotifyEvent;
+
+typedef union _XkbEvent {
+	int				type;
+	XkbAnyEvent			any;
+	XkbNewKeyboardNotifyEvent	new_kbd;
+	XkbMapNotifyEvent		map;
+	XkbStateNotifyEvent		state;
+	XkbControlsNotifyEvent		ctrls;
+	XkbIndicatorNotifyEvent 	indicators;
+	XkbNamesNotifyEvent		names;
+	XkbCompatMapNotifyEvent		compat;
+	XkbBellNotifyEvent		bell;
+	XkbActionMessageEvent		message;
+	XkbAccessXNotifyEvent		accessx;
+	XkbExtensionDeviceNotifyEvent 	device;
+	XEvent				core;
+} XkbEvent;
+
+typedef struct	_XkbKbdDpyState	XkbKbdDpyStateRec,*XkbKbdDpyStatePtr;
+
+	/* XkbOpenDisplay error codes */
+#define	XkbOD_Success		0
+#define	XkbOD_BadLibraryVersion	1
+#define	XkbOD_ConnectionRefused	2
+#define	XkbOD_NonXkbServer	3
+#define	XkbOD_BadServerVersion	4
+
+	/* Values for XlibFlags */
+#define	XkbLC_ForceLatin1Lookup		(1<<0)
+#define	XkbLC_ConsumeLookupMods		(1<<1)
+#define	XkbLC_AlwaysConsumeShiftAndLock (1<<2)
+#define	XkbLC_IgnoreNewKeyboards	(1<<3)
+#define	XkbLC_ControlFallback		(1<<4)
+#define	XkbLC_ConsumeKeysOnComposeFail	(1<<29)
+#define	XkbLC_ComposeLED		(1<<30)
+#define	XkbLC_BeepOnComposeFail		(1<<31)
+
+#define	XkbLC_AllComposeControls	(0xc0000000)
+#define	XkbLC_AllControls		(0xc000001f)
+
+_XFUNCPROTOBEGIN
+
+extern	Bool	XkbIgnoreExtension(
+	Bool			/* ignore */
+);
+
+extern	Display *XkbOpenDisplay(
+	char *			/* name */,
+	int *			/* ev_rtrn */,
+	int *			/* err_rtrn */,
+	int *			/* major_rtrn */,
+	int *			/* minor_rtrn */,
+	int *			/* reason */
+);
+
+extern	Bool	XkbQueryExtension(
+	Display *		/* dpy */,
+	int *			/* opcodeReturn */,
+	int *			/* eventBaseReturn */,
+	int *			/* errorBaseReturn */,
+	int *			/* majorRtrn */,
+	int *			/* minorRtrn */
+);
+
+extern	Bool	XkbUseExtension(
+	Display *		/* dpy */,
+	int *			/* major_rtrn */,
+	int *			/* minor_rtrn */
+);
+
+extern	Bool	XkbLibraryVersion(
+	int *			/* libMajorRtrn */,
+	int *			/* libMinorRtrn */
+);
+
+extern	unsigned int	XkbSetXlibControls(
+	Display*		/* dpy */,
+	unsigned int		/* affect */,
+	unsigned int		/* values */
+);
+
+extern	unsigned int	XkbGetXlibControls(
+	Display*		/* dpy */
+);
+
+extern	unsigned int	XkbXlibControlsImplemented(void);
+
+typedef	Atom	(*XkbInternAtomFunc)(
+	Display *		/* dpy */,
+	_Xconst char *		/* name */,
+	Bool			/* only_if_exists */
+);
+
+typedef char *	(*XkbGetAtomNameFunc)(
+	Display *		/* dpy */,
+	Atom			/* atom */
+);
+
+extern void		XkbSetAtomFuncs(
+	XkbInternAtomFunc	/* getAtom */,
+	XkbGetAtomNameFunc	/* getName */
+);
+
+extern	KeySym XkbKeycodeToKeysym(
+		Display *	/* dpy */,
+#if NeedWidePrototypes
+		 unsigned int 	/* kc */,
+#else
+		 KeyCode 	/* kc */,
+#endif
+		 int 		/* group */,
+		 int		/* level */
+);
+
+extern	unsigned int	XkbKeysymToModifiers(
+    Display *			/* dpy */,
+    KeySym 			/* ks */
+);
+
+extern	Bool		XkbLookupKeySym(
+    Display *			/* dpy */,
+    KeyCode 			/* keycode */,
+    unsigned int 		/* modifiers */,
+    unsigned int *		/* modifiers_return */,
+    KeySym *			/* keysym_return */
+);
+
+extern	int		XkbLookupKeyBinding(
+    Display *			/* dpy */,
+    KeySym 			/* sym_rtrn */,
+    unsigned int 		/* mods */,
+    char *			/* buffer */,
+    int 			/* nbytes */,
+    int * 			/* extra_rtrn */
+);
+
+extern	Bool		XkbTranslateKeyCode(
+    XkbDescPtr			/* xkb */,
+    KeyCode 			/* keycode */,
+    unsigned int 		/* modifiers */,
+    unsigned int *		/* modifiers_return */,
+    KeySym *			/* keysym_return */
+);
+
+extern	int		XkbTranslateKeySym(
+    Display *			/* dpy */,
+    register KeySym *		/* sym_return */,
+    unsigned int 		/* modifiers */,
+    char *			/* buffer */,
+    int 			/* nbytes */,
+    int *			/* extra_rtrn */
+);
+
+extern	Bool	XkbSetAutoRepeatRate(
+	Display *		/* dpy */,
+	unsigned int		/* deviceSpec */,
+	unsigned int		/* delay */,
+	unsigned int		/* interval */
+);
+
+extern	Bool	XkbGetAutoRepeatRate(
+	Display *		/* dpy */,
+	unsigned int		/* deviceSpec */,
+	unsigned int *		/* delayRtrn */,
+	unsigned int *		/* intervalRtrn */
+);
+
+extern	Bool	XkbChangeEnabledControls(
+	Display *		/* dpy */,
+	unsigned int		/* deviceSpec */,
+	unsigned int		/* affect */,
+	unsigned int		/* values */
+);
+
+extern	Bool	XkbDeviceBell(
+	Display *		/* dpy */,
+	Window			/* win */,
+	int			/* deviceSpec */,
+	int			/* bellClass */,
+	int			/* bellID */,
+	int			/* percent */,
+	Atom			/* name */
+);
+
+extern	Bool	XkbForceDeviceBell(
+	Display *		/* dpy */,
+	int			/* deviceSpec */,
+	int			/* bellClass */,
+	int			/* bellID */,
+	int			/* percent */
+);
+
+extern	Bool	XkbDeviceBellEvent(
+	Display *		/* dpy */,
+	Window			/* win */,
+	int			/* deviceSpec */,
+	int			/* bellClass */,
+	int			/* bellID */,
+	int			/* percent */,
+	Atom			/* name */
+);
+
+extern	Bool	XkbBell(
+	Display *		/* dpy */,
+	Window			/* win */,
+	int			/* percent */,
+	Atom			/* name */
+);
+
+extern	Bool	XkbForceBell(
+	Display *		/* dpy */,
+	int			/* percent */
+);
+
+extern	Bool	XkbBellEvent(
+	Display *		/* dpy */,
+	Window			/* win */,
+	int			/* percent */,
+	Atom			/* name */
+);
+
+extern	Bool	XkbSelectEvents(
+	Display *		/* dpy */,
+	unsigned int		/* deviceID */,
+	unsigned int 		/* affect */,
+	unsigned int 		/* values */
+);
+
+extern	Bool	XkbSelectEventDetails(
+	Display *		/* dpy */,
+	unsigned int 		/* deviceID */,
+	unsigned int 		/* eventType */,
+	unsigned long 		/* affect */,
+	unsigned long 		/* details */
+);
+
+extern	void	XkbNoteMapChanges(
+    XkbMapChangesPtr		/* old */,
+    XkbMapNotifyEvent	*	/* new */,
+    unsigned int	 	/* wanted */
+);
+
+extern	void	XkbNoteNameChanges(
+    XkbNameChangesPtr		/* old */,
+    XkbNamesNotifyEvent	*	/* new */,
+    unsigned int	 	/* wanted */
+);
+
+extern	Status	XkbGetIndicatorState(
+	Display *		/* dpy */,
+	unsigned int		/* deviceSpec */,
+	unsigned int *		/* pStateRtrn */
+);
+
+extern	Status	XkbGetDeviceIndicatorState(
+	Display *		/* dpy */,
+	unsigned int		/* deviceSpec */,
+	unsigned int		/* ledClass */,
+	unsigned int		/* ledID */,
+	unsigned int *		/* pStateRtrn */
+);
+
+extern	Status	 XkbGetIndicatorMap(
+	Display *		/* dpy */,
+	unsigned long		/* which */,
+	XkbDescPtr		/* desc */
+);
+
+extern	Bool	 XkbSetIndicatorMap(
+	Display *		/* dpy */,
+	unsigned long 		/* which */,
+	XkbDescPtr		/* desc */
+);
+
+#define	XkbNoteIndicatorMapChanges(o,n,w) \
+				((o)->map_changes|=((n)->map_changes&(w)))
+#define	XkbNoteIndicatorStateChanges(o,n,w)\
+				((o)->state_changes|=((n)->state_changes&(w)))
+#define	XkbGetIndicatorMapChanges(d,x,c) \
+				(XkbGetIndicatorMap((d),(c)->map_changes,x))
+#define	XkbChangeIndicatorMaps(d,x,c) \
+				(XkbSetIndicatorMap((d),(c)->map_changes,x))
+
+extern	Bool	XkbGetNamedIndicator(
+	Display *		/* dpy */,
+	Atom			/* name */,
+	int *			/* pNdxRtrn */,
+	Bool *			/* pStateRtrn */,
+	XkbIndicatorMapPtr	/* pMapRtrn */,
+	Bool *			/* pRealRtrn */
+);
+
+extern	Bool	XkbGetNamedDeviceIndicator(
+	Display *		/* dpy */,
+	unsigned int		/* deviceSpec */,
+	unsigned int		/* ledClass */,
+	unsigned int		/* ledID */,
+	Atom			/* name */,
+	int *			/* pNdxRtrn */,
+	Bool *			/* pStateRtrn */,
+	XkbIndicatorMapPtr	/* pMapRtrn */,
+	Bool *			/* pRealRtrn */
+);
+
+extern	Bool	XkbSetNamedIndicator(
+	Display *		/* dpy */,
+	Atom			/* name */,
+	Bool			/* changeState */,
+	Bool 			/* state */,
+	Bool			/* createNewMap */,
+	XkbIndicatorMapPtr	/* pMap */
+);
+
+extern	Bool	XkbSetNamedDeviceIndicator(
+	Display *		/* dpy */,
+	unsigned int		/* deviceSpec */,
+	unsigned int		/* ledClass */,
+	unsigned int		/* ledID */,
+	Atom			/* name */,
+	Bool			/* changeState */,
+	Bool 			/* state */,
+	Bool			/* createNewMap */,
+	XkbIndicatorMapPtr	/* pMap */
+);
+
+extern	Bool	XkbLockModifiers(
+	Display *		/* dpy */,
+	unsigned int 		/* deviceSpec */,
+	unsigned int 		/* affect */,
+	unsigned int 		/* values */
+);
+
+extern	Bool	XkbLatchModifiers(
+	Display *		/* dpy */,
+	unsigned int 		/* deviceSpec */,
+	unsigned int 		/* affect */,
+	unsigned int 		/* values */
+);
+
+extern	Bool	XkbLockGroup(
+	Display *		/* dpy */,
+	unsigned int 		/* deviceSpec */,
+	unsigned int 		/* group */
+);
+
+extern	Bool	XkbLatchGroup(
+	Display *		/* dpy */,
+	unsigned int 		/* deviceSpec */,
+	unsigned int 		/* group */
+);
+
+extern	Bool	XkbSetServerInternalMods(
+	Display *		/* dpy */,
+	unsigned int 		/* deviceSpec */,
+	unsigned int 		/* affectReal */,
+	unsigned int 		/* realValues */,
+	unsigned int		/* affectVirtual */,
+	unsigned int		/* virtualValues */
+);
+
+extern	Bool	XkbSetIgnoreLockMods(
+	Display *		/* dpy */,
+	unsigned int 		/* deviceSpec */,
+	unsigned int 		/* affectReal */,
+	unsigned int 		/* realValues */,
+	unsigned int		/* affectVirtual */,
+	unsigned int		/* virtualValues */
+);
+
+
+extern	Bool	XkbVirtualModsToReal(
+	XkbDescPtr		/* xkb */,
+	unsigned int		/* virtual_mask */,
+	unsigned int *		/* mask_rtrn */
+);
+
+extern	Bool	XkbComputeEffectiveMap(
+	XkbDescPtr 		/* xkb */,
+	XkbKeyTypePtr		/* type */,
+	unsigned char *		/* map_rtrn */
+);
+
+extern	Status XkbInitCanonicalKeyTypes(
+    XkbDescPtr			/* xkb */,
+    unsigned int		/* which */,
+    int				/* keypadVMod */
+);
+
+extern	XkbDescPtr XkbAllocKeyboard(
+	void
+);
+
+extern	void	XkbFreeKeyboard(
+	XkbDescPtr		/* xkb */,
+	unsigned int		/* which */,
+	Bool			/* freeDesc */
+);
+
+extern	Status XkbAllocClientMap(
+	XkbDescPtr		/* xkb */,
+	unsigned int		/* which */,
+	unsigned int		/* nTypes */
+);
+
+extern	Status XkbAllocServerMap(
+	XkbDescPtr		/* xkb */,
+	unsigned int		/* which */,
+	unsigned int		/* nActions */
+);
+
+extern	void	XkbFreeClientMap(
+    XkbDescPtr			/* xkb */,
+    unsigned int		/* what */,
+    Bool			/* freeMap */
+);
+
+extern	void	XkbFreeServerMap(
+    XkbDescPtr			/* xkb */,
+    unsigned int		/* what */,
+    Bool			/* freeMap */
+);
+
+extern	XkbKeyTypePtr	XkbAddKeyType(
+    XkbDescPtr			/* xkb */,
+    Atom			/* name */,
+    int				/* map_count */,
+    Bool			/* want_preserve */,
+    int				/* num_lvls */
+);
+
+extern	Status XkbAllocIndicatorMaps(
+	XkbDescPtr		/* xkb */
+);
+
+extern	void XkbFreeIndicatorMaps(
+    XkbDescPtr			/* xkb */
+);
+
+extern	XkbDescPtr XkbGetMap(
+	Display *		/* dpy */,
+	unsigned int 		/* which */,
+	unsigned int 		/* deviceSpec */
+);
+
+extern	Status	XkbGetUpdatedMap(
+	Display *		/* dpy */,
+	unsigned int 		/* which */,
+	XkbDescPtr		/* desc */
+);
+
+extern	Status	XkbGetMapChanges(
+    Display *			/* dpy */,
+    XkbDescPtr			/* xkb */,
+    XkbMapChangesPtr		/* changes */
+);
+
+
+extern	Status	XkbRefreshKeyboardMapping(
+    XkbMapNotifyEvent *		/* event */
+);
+
+extern	Status	XkbGetKeyTypes(
+    Display *			/* dpy */,
+    unsigned int		/* first */,
+    unsigned int 		/* num */,
+    XkbDescPtr			/* xkb */
+);
+
+extern	Status	XkbGetKeySyms(
+    Display *			/* dpy */,
+    unsigned int		/* first */,
+    unsigned int		/* num */,
+    XkbDescPtr			/* xkb */
+);
+
+extern	Status	XkbGetKeyActions(
+    Display *			/* dpy */,
+    unsigned int 		/* first */,
+    unsigned int 		/* num */,
+    XkbDescPtr			/* xkb */
+);
+
+extern	Status	XkbGetKeyBehaviors(
+	Display *		/* dpy */,
+	unsigned int 		/* firstKey */,
+	unsigned int		/* nKeys */,
+	XkbDescPtr		/* desc */
+);
+
+extern	Status	XkbGetVirtualMods(
+	Display *		/* dpy */,
+	unsigned int 		/* which */,
+	XkbDescPtr		/* desc */
+);
+
+extern	Status	XkbGetKeyExplicitComponents(
+	Display *		/* dpy */,
+	unsigned int 		/* firstKey */,
+	unsigned int		/* nKeys */,
+	XkbDescPtr		/* desc */
+);
+
+extern	Status	XkbGetKeyModifierMap(
+	Display *		/* dpy */,
+	unsigned int 		/* firstKey */,
+	unsigned int		/* nKeys */,
+	XkbDescPtr		/* desc */
+);
+
+extern	Status	XkbGetKeyVirtualModMap(
+	Display *		/* dpy */,
+	unsigned int		/* first */,
+	unsigned int		/* num */,
+	XkbDescPtr		/* xkb */
+);
+
+extern	Status	XkbAllocControls(
+	XkbDescPtr		/* xkb */,
+	unsigned int		/* which*/
+);
+
+extern	void	XkbFreeControls(
+	XkbDescPtr		/* xkb */,
+	unsigned int		/* which */,
+	Bool			/* freeMap */
+);
+
+extern	Status	XkbGetControls(
+	Display *		/* dpy */,
+	unsigned long		/* which */,
+	XkbDescPtr		/* desc */
+);
+
+extern	Bool	XkbSetControls(
+	Display *		/* dpy */,
+	unsigned long		/* which */,
+	XkbDescPtr		/* desc */
+);
+
+extern	void	XkbNoteControlsChanges(
+    XkbControlsChangesPtr	/* old */,
+    XkbControlsNotifyEvent *	/* new */,
+    unsigned int	 	/* wanted */
+);
+
+#define	XkbGetControlsChanges(d,x,c)	XkbGetControls(d,(c)->changed_ctrls,x)
+#define	XkbChangeControls(d,x,c)	XkbSetControls(d,(c)->changed_ctrls,x)
+
+extern	Status	XkbAllocCompatMap(
+    XkbDescPtr			/* xkb */,
+    unsigned int		/* which */,
+    unsigned int		/* nInterpret */
+);
+
+extern	void	XkbFreeCompatMap(
+    XkbDescPtr			/* xkb */,
+    unsigned int		/* which */,
+    Bool			/* freeMap */
+);
+
+extern Status XkbGetCompatMap(
+	Display *		/* dpy */,
+	unsigned int 		/* which */,
+	XkbDescPtr 		/* xkb */
+);
+
+extern Bool XkbSetCompatMap(
+	Display *		/* dpy */,
+	unsigned int 		/* which */,
+	XkbDescPtr 		/* xkb */,
+	Bool			/* updateActions */
+);
+
+extern	XkbSymInterpretPtr XkbAddSymInterpret(
+	XkbDescPtr		/* xkb */,
+	XkbSymInterpretPtr	/* si */,
+	Bool			/* updateMap */,
+	XkbChangesPtr		/* changes */
+);
+
+extern	Status XkbAllocNames(
+	XkbDescPtr		/* xkb */,
+	unsigned int		/* which */,
+	int			/* nTotalRG */,
+	int			/* nTotalAliases */
+);
+
+extern	Status	XkbGetNames(
+	Display *		/* dpy */,
+	unsigned int		/* which */,
+	XkbDescPtr		/* desc */
+);
+
+extern	Bool	XkbSetNames(
+	Display *		/* dpy */,
+	unsigned int		/* which */,
+	unsigned int		/* firstType */,
+	unsigned int		/* nTypes */,
+	XkbDescPtr		/* desc */
+);
+
+extern	Bool	XkbChangeNames(
+	Display *		/* dpy */,
+	XkbDescPtr		/* xkb */,
+	XkbNameChangesPtr	/* changes */
+);
+
+extern	void XkbFreeNames(
+	XkbDescPtr		/* xkb */,
+	unsigned int		/* which */,
+	Bool			/* freeMap */
+);
+
+
+extern	Status	XkbGetState(
+	Display *		/* dpy */,
+	unsigned int 		/* deviceSpec */,
+	XkbStatePtr		/* rtrnState */
+);
+
+extern	Bool	XkbSetMap(
+	Display *		/* dpy */,
+	unsigned int		/* which */,
+	XkbDescPtr		/* desc */
+);
+
+extern	Bool	XkbChangeMap(
+	Display*		/* dpy */,
+	XkbDescPtr		/* desc */,
+	XkbMapChangesPtr	/* changes */
+);
+
+extern	Bool	XkbSetDetectableAutoRepeat(
+	Display *		/* dpy */,
+	Bool			/* detectable */,
+	Bool *			/* supported */
+);
+
+extern	Bool	XkbGetDetectableAutoRepeat(
+	Display *		/* dpy */,
+	Bool *			/* supported */
+);
+
+extern	Bool	XkbSetAutoResetControls(
+    Display *			/* dpy */,
+    unsigned int 		/* changes */,
+    unsigned int *		/* auto_ctrls */,
+    unsigned int *		/* auto_values */
+);
+
+extern	Bool	XkbGetAutoResetControls(
+    Display *			/* dpy */,
+    unsigned int *		/* auto_ctrls */,
+    unsigned int *		/* auto_ctrl_values */
+);
+
+extern	Bool	XkbSetPerClientControls(
+    Display *			/* dpy */,
+    unsigned int		/* change */,
+    unsigned int *		/* values */
+);
+
+extern	Bool	XkbGetPerClientControls(
+    Display *			/* dpy */,
+    unsigned int *		/* ctrls */
+);
+
+extern Status XkbCopyKeyType(
+    XkbKeyTypePtr	/* from */,
+    XkbKeyTypePtr	/* into */
+);
+
+extern Status XkbCopyKeyTypes(
+    XkbKeyTypePtr	/* from */,
+    XkbKeyTypePtr	/* into */,
+    int			/* num_types */
+);
+
+extern	Status	XkbResizeKeyType(
+    XkbDescPtr		/* xkb */,
+    int			/* type_ndx */,
+    int			/* map_count */,
+    Bool		/* want_preserve */,
+    int			/* new_num_lvls */
+);
+
+extern	KeySym *XkbResizeKeySyms(
+	XkbDescPtr		/* desc */,
+	int 			/* forKey */,
+	int 			/* symsNeeded */
+);
+
+extern	XkbAction *XkbResizeKeyActions(
+	XkbDescPtr		/* desc */,
+	int 			/* forKey */,
+	int 			/* actsNeeded */
+);
+
+extern	Status XkbChangeTypesOfKey(
+	XkbDescPtr		/* xkb */,
+	int 			/* key */,
+	int			/* num_groups */,
+	unsigned int		/* groups */,
+	int *			/* newTypes */,
+	XkbMapChangesPtr	/* pChanges */
+);
+
+extern  Status   XkbChangeKeycodeRange(
+	XkbDescPtr		/* xkb */,
+	int			/* minKC */,
+	int			/* maxKC */,
+	XkbChangesPtr		/* changes */
+);
+
+/***====================================================================***/
+
+extern	XkbComponentListPtr	XkbListComponents(
+	Display *		/* dpy */,
+	unsigned int		/* deviceSpec */,
+	XkbComponentNamesPtr	/* ptrns */,
+	int *			/* max_inout */
+);
+
+extern	void XkbFreeComponentList(
+	XkbComponentListPtr	/* list */
+);
+
+extern	XkbDescPtr XkbGetKeyboard(
+	Display *		/* dpy */,
+	unsigned int 		/* which */,
+	unsigned int 		/* deviceSpec */
+);
+
+extern XkbDescPtr XkbGetKeyboardByName(
+    Display *			/* dpy */,
+    unsigned int		/* deviceSpec */,
+    XkbComponentNamesPtr	/* names */,
+    unsigned int 		/* want */,
+    unsigned int 		/* need */,
+    Bool			/* load */
+);
+
+/***====================================================================***/
+
+extern	int	XkbKeyTypesForCoreSymbols(	/* returns # of groups */
+    XkbDescPtr	/* xkb */,			/* keyboard device */
+    int		/* map_width */,		/* width of core KeySym array */
+    KeySym *	/* core_syms */,		/* always mapWidth symbols */
+    unsigned int	/* protected */,	/* explicit key types */
+    int *	/* types_inout */,		/* always four type indices */
+    KeySym * 	/* xkb_syms_rtrn */		/* must have enough space */
+);
+
+extern	Bool	XkbApplyCompatMapToKey(	/* False only on error */
+    XkbDescPtr		/* xkb */,		/* keymap to be edited */
+    KeyCode		/* key */,		/* key to be updated */
+    XkbChangesPtr	/* changes */		/* resulting changes to map */
+);
+
+extern	Bool	XkbUpdateMapFromCore( /* False only on error */
+    XkbDescPtr		/* xkb */,		/* XKB keyboard to be edited */
+    KeyCode		/* first_key */,	/* first changed key */
+    int			/* num_keys */, 	/* number of changed keys */
+    int			/* map_width */,	/* width of core keymap */
+    KeySym *		/* core_keysyms */,	/* symbols from core keymap */
+    XkbChangesPtr	/* changes */		/* resulting changes */
+);
+
+/***====================================================================***/
+
+extern	XkbDeviceLedInfoPtr	XkbAddDeviceLedInfo(
+	XkbDeviceInfoPtr	/* devi */,
+	unsigned int		/* ledClass */,
+	unsigned int		/* ledId */
+);
+
+extern	Status			XkbResizeDeviceButtonActions(
+	XkbDeviceInfoPtr	/* devi */,
+	unsigned int		/* newTotal */
+);
+
+extern	XkbDeviceInfoPtr	XkbAllocDeviceInfo(
+	unsigned int		/* deviceSpec */,
+	unsigned int		/* nButtons */,
+	unsigned int		/* szLeds */
+);
+
+extern	void XkbFreeDeviceInfo(
+	XkbDeviceInfoPtr	/* devi */,
+	unsigned int		/* which */,
+	Bool			/* freeDevI */
+);
+
+extern	void	XkbNoteDeviceChanges(
+    XkbDeviceChangesPtr			/* old */,
+    XkbExtensionDeviceNotifyEvent *	/* new */,
+    unsigned int	 		/* wanted */
+);
+
+extern	XkbDeviceInfoPtr XkbGetDeviceInfo(
+	Display *		/* dpy */,
+	unsigned int 		/* which */,
+	unsigned int		/* deviceSpec */,
+	unsigned int		/* ledClass */,
+	unsigned int		/* ledID */
+);
+
+extern	Status	XkbGetDeviceInfoChanges(
+	Display *		/* dpy */,
+	XkbDeviceInfoPtr	/* devi */,
+	XkbDeviceChangesPtr 	/* changes */
+);
+
+extern	Status	XkbGetDeviceButtonActions(
+	Display *		/* dpy */,
+	XkbDeviceInfoPtr	/* devi */,
+	Bool			/* all */,
+	unsigned int		/* first */,
+	unsigned int		/* nBtns */
+);
+
+extern	Status	XkbGetDeviceLedInfo(
+	Display *		/* dpy */,
+	XkbDeviceInfoPtr	/* devi */,
+	unsigned int		/* ledClass (class, XIDflt, XIAll) */,
+	unsigned int		/* ledId (id, XIDflt, XIAll) */,
+	unsigned int		/* which (XkbXI_Indicator{Names,Map}Mask */
+);
+
+extern	Bool	XkbSetDeviceInfo(
+	Display *		/* dpy */,
+	unsigned int		/* which */,
+	XkbDeviceInfoPtr	/* devi */
+);
+
+extern	Bool	XkbChangeDeviceInfo(
+	Display*		/* dpy */,
+	XkbDeviceInfoPtr	/* desc */,
+	XkbDeviceChangesPtr	/* changes */
+);
+
+extern  Bool XkbSetDeviceLedInfo(
+	Display *		/* dpy */,
+	XkbDeviceInfoPtr	/* devi */,
+	unsigned int 		/* ledClass */,
+	unsigned int		/* ledID */,
+	unsigned int		/* which */
+);
+
+extern	Bool XkbSetDeviceButtonActions(
+	Display *		/* dpy */,
+	XkbDeviceInfoPtr	/* devi */,
+	unsigned int		/* first */,
+	unsigned int		/* nBtns */
+);
+
+/***====================================================================***/
+
+extern	char	XkbToControl(
+	char		/* c */
+);
+
+/***====================================================================***/
+
+extern	Bool XkbSetDebuggingFlags(
+    Display *		/* dpy */,
+    unsigned int	/* mask */,
+    unsigned int	/* flags */,
+    char *		/* msg */,
+    unsigned int	/* ctrls_mask */,
+    unsigned int	/* ctrls */,
+    unsigned int *	/* rtrn_flags */,
+    unsigned int *	/* rtrn_ctrls */
+);
+
+extern	Bool XkbApplyVirtualModChanges(
+   XkbDescPtr		/* xkb */,
+   unsigned int		/* changed */,
+   XkbChangesPtr	/* changes */
+);
+
+extern Bool XkbUpdateActionVirtualMods(
+	XkbDescPtr		/* xkb */,
+	XkbAction *		/* act */,
+	unsigned int		/* changed */
+);
+
+extern void XkbUpdateKeyTypeVirtualMods(
+	XkbDescPtr		/* xkb */,
+	XkbKeyTypePtr		/* type */,
+	unsigned int		/* changed */,
+	XkbChangesPtr		/* changes */
+);
+
+_XFUNCPROTOEND
+
+#endif /* !defined(_X11_XKBLIB_H_) && !defined(_XKBLIB_H_) */
diff --git a/nx-X11/lib/include/X11/Xcms.h b/nx-X11/lib/include/X11/Xcms.h
new file mode 100644
index 000000000..3b0410533
--- /dev/null
+++ b/nx-X11/lib/include/X11/Xcms.h
@@ -0,0 +1,816 @@
+
+/*
+ * Code and supporting documentation (c) Copyright 1990 1991 Tektronix, Inc.
+ * 	All Rights Reserved
+ *
+ * This file is a component of an X Window System-specific implementation
+ * of Xcms based on the TekColor Color Management System.  Permission is
+ * hereby granted to use, copy, modify, sell, and otherwise distribute this
+ * software and its documentation for any purpose and without fee, provided
+ * that this copyright, permission, and disclaimer notice is reproduced in
+ * all copies of this software and in supporting documentation.  TekColor
+ * is a trademark of Tektronix, Inc.
+ *
+ * Tektronix makes no representation about the suitability of this software
+ * for any purpose.  It is provided "as is" and with all faults.
+ *
+ * TEKTRONIX DISCLAIMS ALL WARRANTIES APPLICABLE TO THIS SOFTWARE,
+ * INCLUDING THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+ * PARTICULAR PURPOSE.  IN NO EVENT SHALL TEKTRONIX BE LIABLE FOR ANY
+ * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER
+ * RESULTING FROM LOSS OF USE, DATA, OR PROFITS, WHETHER IN AN ACTION OF
+ * CONTRACT, NEGLIGENCE, OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
+ * CONNECTION WITH THE USE OR THE PERFORMANCE OF THIS SOFTWARE.
+ *
+ *
+ *	DESCRIPTION
+ *		Public include file for X Color Management System
+ */
+#if !defined(_X11_XCMS_H_) && !defined(_XCMS_H_)
+#define _X11_XCMS_H_
+#define _XCMS_H_
+
+#include <nx-X11/Xlib.h>
+
+/* The Xcms structs are full of implicit padding to properly align members.
+   We can't clean that up without breaking ABI, so tell clang not to bother
+   complaining about it. */
+#ifdef __clang__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wpadded"
+#endif
+
+    /*
+     * XCMS Status Values
+     */
+#define XcmsFailure			0
+#define XcmsSuccess			1
+#define XcmsSuccessWithCompression	2
+
+    /*
+     * Color Space Format ID's
+     *    Color Space ID's are of XcmsColorFormat type.
+     *
+     *    bit 31
+     *	    0 == Device-Independent
+     *	    1 == Device-Dependent
+     *
+     *    bit 30:
+     *	    0 == Registered with X Consortium
+     *	    1 == Unregistered
+     */
+#define XcmsUndefinedFormat	(XcmsColorFormat)0x00000000
+#define XcmsCIEXYZFormat	(XcmsColorFormat)0x00000001
+#define XcmsCIEuvYFormat	(XcmsColorFormat)0x00000002
+#define XcmsCIExyYFormat	(XcmsColorFormat)0x00000003
+#define XcmsCIELabFormat	(XcmsColorFormat)0x00000004
+#define XcmsCIELuvFormat	(XcmsColorFormat)0x00000005
+#define XcmsTekHVCFormat	(XcmsColorFormat)0x00000006
+#define XcmsRGBFormat		(XcmsColorFormat)0x80000000
+#define XcmsRGBiFormat		(XcmsColorFormat)0x80000001
+
+    /*
+     * State of XcmsPerScrnInfo
+     */
+#define XcmsInitNone		0x00	/* no initialization attempted */
+#define XcmsInitSuccess		0x01	/* initialization successful */
+#define XcmsInitFailure		0xff	/* failure, use defaults */
+
+#define DisplayOfCCC(ccc)		((ccc)->dpy)
+#define ScreenNumberOfCCC(ccc)		((ccc)->screenNumber)
+#define VisualOfCCC(ccc)		((ccc)->visual)
+#define ClientWhitePointOfCCC(ccc)	(&(ccc)->clientWhitePt)
+#define ScreenWhitePointOfCCC(ccc)	(&(ccc)->pPerScrnInfo->screenWhitePt)
+#define FunctionSetOfCCC(ccc)		((ccc)->pPerScrnInfo->functionSet)
+
+typedef unsigned long XcmsColorFormat;	/* Color Space Format ID */
+
+typedef double XcmsFloat;
+
+    /*
+     * Device RGB
+     */
+typedef struct {
+    unsigned short red;		/* scaled from 0x0000 to 0xffff */
+    unsigned short green;	/* scaled from 0x0000 to 0xffff */
+    unsigned short blue;	/* scaled from 0x0000 to 0xffff */
+} XcmsRGB;
+
+    /*
+     * RGB Intensity
+     */
+typedef struct {
+    XcmsFloat red;	/* 0.0 - 1.0 */
+    XcmsFloat green;	/* 0.0 - 1.0 */
+    XcmsFloat blue;	/* 0.0 - 1.0 */
+} XcmsRGBi;
+
+    /*
+     * CIE XYZ
+     */
+typedef struct {
+    XcmsFloat X;
+    XcmsFloat Y;
+    XcmsFloat Z;
+} XcmsCIEXYZ;
+
+    /*
+     * CIE u'v'Y
+     */
+typedef struct {
+    XcmsFloat u_prime;		/* 0.0 - 1.0 */
+    XcmsFloat v_prime;		/* 0.0 - 1.0 */
+    XcmsFloat Y;		/* 0.0 - 1.0 */
+} XcmsCIEuvY;
+
+    /*
+     * CIE xyY
+     */
+typedef struct {
+    XcmsFloat x;		/* 0.0 - 1.0 */
+    XcmsFloat y;		/* 0.0 - 1.0 */
+    XcmsFloat Y;		/* 0.0 - 1.0 */
+} XcmsCIExyY;
+
+    /*
+     * CIE L*a*b*
+     */
+typedef struct {
+    XcmsFloat L_star;		/* 0.0 - 100.0 */
+    XcmsFloat a_star;
+    XcmsFloat b_star;
+} XcmsCIELab;
+
+    /*
+     * CIE L*u*v*
+     */
+typedef struct {
+    XcmsFloat L_star;		/* 0.0 - 100.0 */
+    XcmsFloat u_star;
+    XcmsFloat v_star;
+} XcmsCIELuv;
+
+    /*
+     * TekHVC
+     */
+typedef struct {
+    XcmsFloat H;		/* 0.0 - 360.0 */
+    XcmsFloat V;		/* 0.0 - 100.0 */
+    XcmsFloat C;		/* 0.0 - 100.0 */
+} XcmsTekHVC;
+
+    /*
+     * PAD
+     */
+typedef struct {
+    XcmsFloat pad0;
+    XcmsFloat pad1;
+    XcmsFloat pad2;
+    XcmsFloat pad3;
+} XcmsPad;
+
+
+    /*
+     * XCMS Color Structure
+     */
+typedef struct {
+    union {
+	XcmsRGB RGB;
+	XcmsRGBi RGBi;
+	XcmsCIEXYZ CIEXYZ;
+	XcmsCIEuvY CIEuvY;
+	XcmsCIExyY CIExyY;
+	XcmsCIELab CIELab;
+	XcmsCIELuv CIELuv;
+	XcmsTekHVC TekHVC;
+	XcmsPad Pad;
+    } spec;			/* the color specification	*/
+    unsigned long pixel;	/* pixel value (as needed)	*/
+    XcmsColorFormat	format;		/* the specification format	*/
+} XcmsColor;
+
+
+    /*
+     * XCMS Per Screen related data
+     */
+
+typedef struct _XcmsPerScrnInfo {
+    XcmsColor	screenWhitePt;	/* Screen White point */
+    XPointer	functionSet;	/* pointer to Screen Color Characterization */
+				/*      Function Set structure		*/
+    XPointer	screenData;	/* pointer to corresponding Screen Color*/
+				/*	Characterization Data		*/
+    unsigned char state;   /* XcmsInitNone, XcmsInitSuccess, XcmsInitFailure */
+    char	pad[3];
+} XcmsPerScrnInfo;
+
+typedef struct _XcmsCCC *XcmsCCC;
+
+typedef Status (*XcmsCompressionProc)(		/* Gamut Compression Proc */
+    XcmsCCC		/* ccc */,
+    XcmsColor*		/* colors_in_out */,
+    unsigned int	/* ncolors */,
+    unsigned int	/* index */,
+    Bool*		/* compression_flags_return */
+);
+
+typedef Status (*XcmsWhiteAdjustProc)(	 	/* White Point Adjust Proc */
+    XcmsCCC		/* ccc */,
+    XcmsColor*		/* initial_white_point*/,
+    XcmsColor*		/* target_white_point*/,
+    XcmsColorFormat	/* target_format */,
+    XcmsColor*		/* colors_in_out */,
+    unsigned int	/* ncolors */,
+    Bool*		/* compression_flags_return */
+);
+
+    /*
+     * XCMS Color Conversion Context
+     */
+typedef struct _XcmsCCC {
+    Display	*dpy;			/* X Display */
+    int		screenNumber;		/* X screen number */
+    Visual	*visual;		/* X Visual */
+    XcmsColor	clientWhitePt;		/* Client White Point */
+    XcmsCompressionProc	gamutCompProc;	/* Gamut Compression Function */
+    XPointer	gamutCompClientData;	/* Gamut Comp Func Client Data */
+    XcmsWhiteAdjustProc	whitePtAdjProc;	/* White Point Adjustment Function */
+    XPointer	whitePtAdjClientData;	/* White Pt Adj Func Client Data */
+    XcmsPerScrnInfo *pPerScrnInfo;	/* pointer to per screen information */
+					/*  associated with the above display */
+					/*  screenNumber */
+} XcmsCCCRec;
+
+typedef Status (*XcmsScreenInitProc)(	/* Screen Initialization Proc */
+    Display*		/* dpy */,
+    int			/* screen_number */,
+    XcmsPerScrnInfo*	/* screen_info */
+);
+
+typedef void (*XcmsScreenFreeProc)(
+    XPointer		/* screenData */
+);
+
+    /*
+     * Function List Pointer -- pointer to an array of function pointers.
+     *    The end of list is indicated by a NULL pointer.
+     */
+/*
+ * XXX:  The use of the XcmsConversionProc type is broken.  The
+ *       device-independent colour conversion code uses it as:
+
+typedef Status (*XcmsConversionProc)(XcmsCCC, XcmsColor *, XcmsColor *,
+				     unsigned int);
+
+ *       while the device-dependent code uses it as:
+
+typedef Status (*XcmsConversionProc)(XcmsCCC, XcmsColor *, unsigned int,
+				     Bool *);
+
+ *       Until this is reworked, it's probably best to leave it unprotoized.
+ *       The code works regardless.
+ */
+typedef Status (*XcmsDDConversionProc)( /* using device-dependent version */
+    XcmsCCC             /* ccc */,
+    XcmsColor*          /* pcolors_in_out */,
+    unsigned int        /* ncolors */,
+    Bool*               /* pCompressed */
+    );
+
+typedef Status (*XcmsDIConversionProc)( /* using device-independent version */
+    XcmsCCC             /* ccc */,
+    XcmsColor*          /* white_point */,
+    XcmsColor*          /* pcolors_in_out */,
+    unsigned int        /* ncolors */
+    );
+
+typedef XcmsDIConversionProc XcmsConversionProc;
+typedef XcmsConversionProc *XcmsFuncListPtr;
+
+typedef int (*XcmsParseStringProc)(	/* Color String Parsing Proc */
+    char*		/* color_string */,
+    XcmsColor*		/* color_return */
+);
+
+    /*
+     * Color Space -- per Color Space related data (Device-Independent
+     *    or Device-Dependent)
+     */
+typedef struct _XcmsColorSpace {
+    const char *prefix;		/* Prefix of string format.		*/
+    XcmsColorFormat id;		/* Format ID number.			*/
+    XcmsParseStringProc parseString;
+				/* String format parsing function	*/
+    XcmsFuncListPtr to_CIEXYZ;	/* Pointer to an array of function 	*/
+				/*   pointers such that when the	*/
+				/*   functions are executed in sequence	*/
+				/*   will convert a XcmsColor structure	*/
+				/*   from this color space to CIEXYZ	*/
+				/*   space.				*/
+    XcmsFuncListPtr from_CIEXYZ;/* Pointer to an array of function 	*/
+				/*   pointers such that when the	*/
+				/*   functions are executed in sequence	*/
+				/*   will convert a XcmsColor structure	*/
+				/*   from CIEXYZ space to this color	*/
+				/*   space.				*/
+    int inverse_flag;		/* If 1, indicates that for 0 <= i < n	*/
+				/*   where n is the number of function	*/
+				/*   pointers in the lists to_CIEXYZ	*/
+				/*   and from_CIEXYZ; for each function */
+				/*   to_CIEXYZ[i] its inverse function	*/
+				/*   is from_CIEXYZ[n - i].		*/
+
+} XcmsColorSpace;
+
+    /*
+     * Screen Color Characterization Function Set -- per device class
+     *    color space conversion functions.
+     */
+typedef struct _XcmsFunctionSet {
+    XcmsColorSpace **DDColorSpaces;
+				/* Pointer to an array of pointers to	*/
+				/*   Device-DEPENDENT color spaces	*/
+				/*   understood by this SCCFuncSet.	*/
+    XcmsScreenInitProc screenInitProc;
+				/* Screen initialization function that	*/
+				/*   reads Screen Color Characterization*/
+				/*   Data off properties on the screen's*/
+				/*   root window.			*/
+    XcmsScreenFreeProc screenFreeProc;
+				/* Function that frees the SCCData	*/
+				/*   structures.			*/
+} XcmsFunctionSet;
+
+_XFUNCPROTOBEGIN
+
+extern Status XcmsAddColorSpace (
+    XcmsColorSpace*	/* pColorSpace */
+);
+
+extern Status XcmsAddFunctionSet (
+    XcmsFunctionSet*	/* functionSet */
+);
+
+extern Status XcmsAllocColor (
+    Display*		/* dpy */,
+    Colormap		/* colormap */,
+    XcmsColor*		/* color_in_out */,
+    XcmsColorFormat		/* result_format */
+);
+
+extern Status XcmsAllocNamedColor (
+    Display*		/* dpy */,
+    Colormap		/* colormap */,
+    _Xconst char*	/* color_string */,
+    XcmsColor*		/* color_scrn_return */,
+    XcmsColor*		/* color_exact_return */,
+    XcmsColorFormat		/* result_format */
+);
+
+extern XcmsCCC XcmsCCCOfColormap (
+    Display*		/* dpy */,
+    Colormap		/* colormap */
+);
+
+extern Status XcmsCIELabClipab(
+    XcmsCCC		/* ccc */,
+    XcmsColor*		/* colors_in_out */,
+    unsigned int	/* ncolors */,
+    unsigned int	/* index */,
+    Bool*		/* compression_flags_return */
+);
+
+extern Status XcmsCIELabClipL(
+    XcmsCCC		/* ccc */,
+    XcmsColor*		/* colors_in_out */,
+    unsigned int	/* ncolors */,
+    unsigned int	/* index */,
+    Bool*		/* compression_flags_return */
+);
+
+extern Status XcmsCIELabClipLab(
+    XcmsCCC		/* ccc */,
+    XcmsColor*		/* colors_in_out */,
+    unsigned int	/* ncolors */,
+    unsigned int	/* index */,
+    Bool*		/* compression_flags_return */
+);
+
+extern Status XcmsCIELabQueryMaxC (
+    XcmsCCC		/* ccc */,
+    XcmsFloat		/* hue_angle */,
+    XcmsFloat		/* L_star */,
+    XcmsColor*		/* color_return */
+);
+
+extern Status XcmsCIELabQueryMaxL (
+    XcmsCCC		/* ccc */,
+    XcmsFloat		/* hue_angle */,
+    XcmsFloat		/* chroma */,
+    XcmsColor*		/* color_return */
+);
+
+extern Status XcmsCIELabQueryMaxLC (
+    XcmsCCC		/* ccc */,
+    XcmsFloat		/* hue_angle */,
+    XcmsColor*		/* color_return */
+);
+
+extern Status XcmsCIELabQueryMinL (
+    XcmsCCC		/* ccc */,
+    XcmsFloat		/* hue_angle */,
+    XcmsFloat		/* chroma */,
+    XcmsColor*		/* color_return */
+);
+
+extern Status XcmsCIELabToCIEXYZ (
+    XcmsCCC		/* ccc */,
+    XcmsColor*		/* white_point */,
+    XcmsColor*		/* colors */,
+    unsigned int	/* ncolors */
+);
+
+extern Status XcmsCIELabWhiteShiftColors(
+    XcmsCCC		/* ccc */,
+    XcmsColor*		/* initial_white_point*/,
+    XcmsColor*		/* target_white_point*/,
+    XcmsColorFormat	/* target_format */,
+    XcmsColor*		/* colors_in_out */,
+    unsigned int	/* ncolors */,
+    Bool*		/* compression_flags_return */
+);
+
+extern Status XcmsCIELuvClipL(
+    XcmsCCC		/* ccc */,
+    XcmsColor*		/* colors_in_out */,
+    unsigned int	/* ncolors */,
+    unsigned int	/* index */,
+    Bool*		/* compression_flags_return */
+);
+
+extern Status XcmsCIELuvClipLuv(
+    XcmsCCC		/* ccc */,
+    XcmsColor*		/* colors_in_out */,
+    unsigned int	/* ncolors */,
+    unsigned int	/* index */,
+    Bool*		/* compression_flags_return */
+);
+
+extern Status XcmsCIELuvClipuv(
+    XcmsCCC		/* ccc */,
+    XcmsColor*		/* colors_in_out */,
+    unsigned int	/* ncolors */,
+    unsigned int	/* index */,
+    Bool*		/* compression_flags_return */
+);
+
+extern Status XcmsCIELuvQueryMaxC (
+    XcmsCCC		/* ccc */,
+    XcmsFloat		/* hue_angle */,
+    XcmsFloat		/* L_star */,
+    XcmsColor*		/* color_return */
+);
+
+extern Status XcmsCIELuvQueryMaxL (
+    XcmsCCC		/* ccc */,
+    XcmsFloat		/* hue_angle */,
+    XcmsFloat		/* chroma */,
+    XcmsColor*		/* color_return */
+);
+
+extern Status XcmsCIELuvQueryMaxLC (
+    XcmsCCC		/* ccc */,
+    XcmsFloat		/* hue_angle */,
+    XcmsColor*		/* color_return */
+);
+
+extern Status XcmsCIELuvQueryMinL (
+    XcmsCCC		/* ccc */,
+    XcmsFloat		/* hue_angle */,
+    XcmsFloat		/* chroma */,
+    XcmsColor*		/* color_return */
+);
+
+extern Status XcmsCIELuvToCIEuvY (
+    XcmsCCC		/* ccc */,
+    XcmsColor*		/* white_point */,
+    XcmsColor*		/* colors */,
+    unsigned int	/* ncolors */
+);
+
+extern Status XcmsCIELuvWhiteShiftColors(
+    XcmsCCC		/* ccc */,
+    XcmsColor*		/* initial_white_point*/,
+    XcmsColor*		/* target_white_point*/,
+    XcmsColorFormat	/* target_format */,
+    XcmsColor*		/* colors_in_out */,
+    unsigned int	/* ncolors */,
+    Bool*		/* compression_flags_return */
+);
+
+extern Status XcmsCIEXYZToCIELab (
+    XcmsCCC		/* ccc */,
+    XcmsColor*		/* white_point */,
+    XcmsColor*		/* colors */,
+    unsigned int	/* ncolors */
+);
+
+extern Status XcmsCIEXYZToCIEuvY (
+    XcmsCCC		/* ccc */,
+    XcmsColor*		/* white_point */,
+    XcmsColor*		/* colors */,
+    unsigned int	/* ncolors */
+);
+
+extern Status XcmsCIEXYZToCIExyY (
+    XcmsCCC		/* ccc */,
+    XcmsColor*		/* white_point */,
+    XcmsColor*		/* colors */,
+    unsigned int	/* ncolors */
+);
+
+extern Status XcmsCIEXYZToRGBi (
+    XcmsCCC		/* ccc */,
+    XcmsColor*		/* colors */,
+    unsigned int	/* ncolors */,
+    Bool*		/* compression_flags_return */
+);
+
+extern Status XcmsCIEuvYToCIELuv (
+    XcmsCCC		/* ccc */,
+    XcmsColor*		/* white_point */,
+    XcmsColor*		/* colors */,
+    unsigned int	/* ncolors */
+);
+
+extern Status XcmsCIEuvYToCIEXYZ (
+    XcmsCCC		/* ccc */,
+    XcmsColor*		/* white_point */,
+    XcmsColor*		/* colors */,
+    unsigned int	/* ncolors */
+);
+
+extern Status XcmsCIEuvYToTekHVC (
+    XcmsCCC		/* ccc */,
+    XcmsColor*		/* white_point */,
+    XcmsColor*		/* colors */,
+    unsigned int	/* ncolors */
+);
+
+extern Status XcmsCIExyYToCIEXYZ (
+    XcmsCCC		/* ccc */,
+    XcmsColor*		/* white_point */,
+    XcmsColor*		/* colors */,
+    unsigned int	/* ncolors */
+);
+
+extern XcmsColor *XcmsClientWhitePointOfCCC (
+    XcmsCCC		/* ccc */
+);
+
+extern Status XcmsConvertColors (
+    XcmsCCC		/* ccc */,
+    XcmsColor*		/* colorArry_in_out */,
+    unsigned int	/* nColors */,
+    XcmsColorFormat		/* targetFormat */,
+    Bool*		/* compArry_return */
+);
+
+extern XcmsCCC XcmsCreateCCC (
+    Display*		/* dpy */,
+    int			/* screenNumber */,
+    Visual*		/* visual */,
+    XcmsColor*		/* clientWhitePt */,
+    XcmsCompressionProc /* gamutCompProc */,
+    XPointer		/* gamutCompClientData */,
+    XcmsWhiteAdjustProc	/* whitePtAdjProc */,
+    XPointer		/* whitePtAdjClientData */
+);
+
+extern XcmsCCC XcmsDefaultCCC (
+    Display*		/* dpy */,
+    int			/* screenNumber */
+);
+
+extern Display *XcmsDisplayOfCCC (
+    XcmsCCC		/* ccc */
+);
+
+extern XcmsColorFormat XcmsFormatOfPrefix (
+    char*		/* prefix */
+);
+
+extern void XcmsFreeCCC (
+    XcmsCCC		/* ccc */
+);
+
+extern Status XcmsLookupColor (
+    Display*		/* dpy */,
+    Colormap		/* colormap */,
+    _Xconst char*	/* color_string */,
+    XcmsColor*		/* pColor_exact_in_out */,
+    XcmsColor*		/* pColor_scrn_in_out */,
+    XcmsColorFormat		/* result_format */
+);
+
+extern char *XcmsPrefixOfFormat (
+    XcmsColorFormat		/* id */
+);
+
+extern Status XcmsQueryBlack (
+    XcmsCCC		/* ccc */,
+    XcmsColorFormat	/* target_format */,
+    XcmsColor*		/* color_return */
+);
+
+extern Status XcmsQueryBlue (
+    XcmsCCC		/* ccc */,
+    XcmsColorFormat	/* target_format */,
+    XcmsColor*		/* color_return */
+);
+
+extern Status XcmsQueryColor (
+    Display*		/* dpy */,
+    Colormap		/* colormap */,
+    XcmsColor*		/* pColor_in_out */,
+    XcmsColorFormat		/* result_format */
+);
+
+extern Status XcmsQueryColors (
+    Display*		/* dpy */,
+    Colormap		/* colormap */,
+    XcmsColor*		/* colorArry_in_out */,
+    unsigned int	/* nColors */,
+    XcmsColorFormat	/* result_format */
+);
+
+extern Status XcmsQueryGreen (
+    XcmsCCC		/* ccc */,
+    XcmsColorFormat	/* target_format */,
+    XcmsColor*		/* color_return */
+);
+
+extern Status XcmsQueryRed (
+    XcmsCCC		/* ccc */,
+    XcmsColorFormat	/* target_format */,
+    XcmsColor*		/* color_return */
+);
+
+extern Status XcmsQueryWhite (
+    XcmsCCC		/* ccc */,
+    XcmsColorFormat	/* target_format */,
+    XcmsColor*		/* color_return */
+);
+
+extern Status XcmsRGBiToCIEXYZ (
+    XcmsCCC		/* ccc */,
+    XcmsColor*		/* colors */,
+    unsigned int	/* ncolors */,
+    Bool*		/* compression_flags_return */
+);
+
+extern Status XcmsRGBiToRGB (
+    XcmsCCC		/* ccc */,
+    XcmsColor*		/* colors */,
+    unsigned int	/* ncolors */,
+    Bool*		/* compression_flags_return */
+);
+
+extern Status XcmsRGBToRGBi (
+    XcmsCCC		/* ccc */,
+    XcmsColor*		/* colors */,
+    unsigned int	/* ncolors */,
+    Bool*		/* compression_flags_return */
+);
+
+extern int XcmsScreenNumberOfCCC (
+    XcmsCCC		/* ccc */
+);
+
+extern XcmsColor *XcmsScreenWhitePointOfCCC (
+    XcmsCCC		/* ccc */
+);
+
+extern XcmsCCC XcmsSetCCCOfColormap(
+    Display*		/* dpy */,
+    Colormap		/* colormap */,
+    XcmsCCC		/* ccc */
+);
+
+extern XcmsCompressionProc XcmsSetCompressionProc (
+    XcmsCCC		/* ccc */,
+    XcmsCompressionProc	/* compression_proc */,
+    XPointer		/* client_data */
+);
+
+extern XcmsWhiteAdjustProc XcmsSetWhiteAdjustProc (
+    XcmsCCC		/* ccc */,
+    XcmsWhiteAdjustProc	/* white_adjust_proc */,
+    XPointer		/* client_data */
+);
+
+extern Status XcmsSetWhitePoint (
+    XcmsCCC		/* ccc */,
+    XcmsColor*		/* color */
+);
+
+extern Status XcmsStoreColor (
+    Display*		/* dpy */,
+    Colormap		/* colormap */,
+    XcmsColor*		/* pColor_in */
+);
+
+extern Status XcmsStoreColors (
+    Display*		/* dpy */,
+    Colormap		/* colormap */,
+    XcmsColor*		/* colorArry_in */,
+    unsigned int	/* nColors */,
+    Bool*		/* compArry_return */
+);
+
+extern Status XcmsTekHVCClipC(
+    XcmsCCC		/* ccc */,
+    XcmsColor*		/* colors_in_out */,
+    unsigned int	/* ncolors */,
+    unsigned int	/* index */,
+    Bool*		/* compression_flags_return */
+);
+
+extern Status XcmsTekHVCClipV(
+    XcmsCCC		/* ccc */,
+    XcmsColor*		/* colors_in_out */,
+    unsigned int	/* ncolors */,
+    unsigned int	/* index */,
+    Bool*		/* compression_flags_return */
+);
+
+extern Status XcmsTekHVCClipVC(
+    XcmsCCC		/* ccc */,
+    XcmsColor*		/* colors_in_out */,
+    unsigned int	/* ncolors */,
+    unsigned int	/* index */,
+    Bool*		/* compression_flags_return */
+);
+
+extern Status XcmsTekHVCQueryMaxC (
+    XcmsCCC		/* ccc */,
+    XcmsFloat		/* hue */,
+    XcmsFloat		/* value */,
+    XcmsColor*		/* color_return */
+);
+
+extern Status XcmsTekHVCQueryMaxV (
+    XcmsCCC		/* ccc */,
+    XcmsFloat		/* hue */,
+    XcmsFloat		/* chroma */,
+    XcmsColor*		/* color_return */
+);
+
+extern Status XcmsTekHVCQueryMaxVC (
+    XcmsCCC		/* ccc */,
+    XcmsFloat		/* hue */,
+    XcmsColor*		/* color_return */
+);
+
+extern Status XcmsTekHVCQueryMaxVSamples (
+    XcmsCCC		/* ccc */,
+    XcmsFloat		/* hue */,
+    XcmsColor*		/* colors_return */,
+    unsigned int	/* nsamples */
+);
+
+extern Status XcmsTekHVCQueryMinV (
+    XcmsCCC		/* ccc */,
+    XcmsFloat		/* hue */,
+    XcmsFloat		/* chroma */,
+    XcmsColor*		/* color_return */
+);
+
+extern Status XcmsTekHVCToCIEuvY (
+    XcmsCCC		/* ccc */,
+    XcmsColor*		/* white_point */,
+    XcmsColor*		/* colors */,
+    unsigned int	/* ncolors */
+);
+
+extern Status XcmsTekHVCWhiteShiftColors(
+    XcmsCCC		/* ccc */,
+    XcmsColor*		/* initial_white_point*/,
+    XcmsColor*		/* target_white_point*/,
+    XcmsColorFormat	/* target_format */,
+    XcmsColor*		/* colors_in_out */,
+    unsigned int	/* ncolors */,
+    Bool*		/* compression_flags_return */
+);
+
+extern Visual *XcmsVisualOfCCC (
+    XcmsCCC		/* ccc */
+);
+
+#ifdef __clang__
+#pragma clang diagnostic pop
+#endif
+
+_XFUNCPROTOEND
+
+#endif /* !defined(_X11_XCMS_H_) && !defined(_XCMS_H_) */
diff --git a/nx-X11/lib/include/X11/Xlib.h b/nx-X11/lib/include/X11/Xlib.h
new file mode 100644
index 000000000..362fdb69e
--- /dev/null
+++ b/nx-X11/lib/include/X11/Xlib.h
@@ -0,0 +1,4036 @@
+/*
+
+Copyright 1985, 1986, 1987, 1991, 1998  The Open Group
+
+Permission to use, copy, modify, distribute, and sell this software and its
+documentation for any purpose is hereby granted without fee, provided that
+the above copyright notice appear in all copies and that both that
+copyright notice and this permission notice appear in supporting
+documentation.
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
+AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+Except as contained in this notice, the name of The Open Group shall not be
+used in advertising or otherwise to promote the sale, use or other dealings
+in this Software without prior written authorization from The Open Group.
+
+*/
+
+
+/*
+ *	Xlib.h - Header definition and support file for the C subroutine
+ *	interface library (Xlib) to the X Window System Protocol (V11).
+ *	Structures and symbols starting with "_" are private to the library.
+ */
+#if !defined(_X11_XLIB_H_) && !defined(_XLIB_H_)
+#define _X11_XLIB_H_
+#define _XLIB_H_
+
+#define XlibSpecificationRelease 6
+
+#include <sys/types.h>
+
+#if defined(__SCO__) || defined(__UNIXWARE__)
+#include <stdint.h>
+#endif
+
+#include <nx-X11/X.h>
+
+/* applications should not depend on these two headers being included! */
+#include <nx-X11/Xfuncproto.h>
+#include <nx-X11/Xosdefs.h>
+
+#ifndef X_WCHAR
+#include <stddef.h>
+#else
+/* replace this with #include or typedef appropriate for your system */
+typedef unsigned long wchar_t;
+#endif
+
+
+extern int
+_Xmblen(
+    char *str,
+    int len
+    );
+
+/* API mentioning "UTF8" or "utf8" is an XFree86 extension, introduced in
+   November 2000. Its presence is indicated through the following macro. */
+#define X_HAVE_UTF8_STRING 1
+
+/* The Xlib structs are full of implicit padding to properly align members.
+   We can't clean that up without breaking ABI, so tell clang not to bother
+   complaining about it. */
+#ifdef __clang__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wpadded"
+#endif
+
+typedef char *XPointer;
+
+#define Bool int
+#define Status int
+#define True 1
+#define False 0
+
+#define QueuedAlready 0
+#define QueuedAfterReading 1
+#define QueuedAfterFlush 2
+
+#define ConnectionNumber(dpy) 	(((_XPrivDisplay)(dpy))->fd)
+#define RootWindow(dpy, scr) 	(ScreenOfDisplay(dpy,scr)->root)
+#define DefaultScreen(dpy) 	(((_XPrivDisplay)(dpy))->default_screen)
+#define DefaultRootWindow(dpy) 	(ScreenOfDisplay(dpy,DefaultScreen(dpy))->root)
+#define DefaultVisual(dpy, scr) (ScreenOfDisplay(dpy,scr)->root_visual)
+#define DefaultGC(dpy, scr) 	(ScreenOfDisplay(dpy,scr)->default_gc)
+#define BlackPixel(dpy, scr) 	(ScreenOfDisplay(dpy,scr)->black_pixel)
+#define WhitePixel(dpy, scr) 	(ScreenOfDisplay(dpy,scr)->white_pixel)
+#define AllPlanes 		((unsigned long)~0L)
+#define QLength(dpy) 		(((_XPrivDisplay)(dpy))->qlen)
+#define DisplayWidth(dpy, scr) 	(ScreenOfDisplay(dpy,scr)->width)
+#define DisplayHeight(dpy, scr) (ScreenOfDisplay(dpy,scr)->height)
+#define DisplayWidthMM(dpy, scr)(ScreenOfDisplay(dpy,scr)->mwidth)
+#define DisplayHeightMM(dpy, scr)(ScreenOfDisplay(dpy,scr)->mheight)
+#define DisplayPlanes(dpy, scr) (ScreenOfDisplay(dpy,scr)->root_depth)
+#define DisplayCells(dpy, scr) 	(DefaultVisual(dpy,scr)->map_entries)
+#define ScreenCount(dpy) 	(((_XPrivDisplay)(dpy))->nscreens)
+#define ServerVendor(dpy) 	(((_XPrivDisplay)(dpy))->vendor)
+#define ProtocolVersion(dpy) 	(((_XPrivDisplay)(dpy))->proto_major_version)
+#define ProtocolRevision(dpy) 	(((_XPrivDisplay)(dpy))->proto_minor_version)
+#define VendorRelease(dpy) 	(((_XPrivDisplay)(dpy))->release)
+#define DisplayString(dpy) 	(((_XPrivDisplay)(dpy))->display_name)
+#define DefaultDepth(dpy, scr) 	(ScreenOfDisplay(dpy,scr)->root_depth)
+#define DefaultColormap(dpy, scr)(ScreenOfDisplay(dpy,scr)->cmap)
+#define BitmapUnit(dpy) 	(((_XPrivDisplay)(dpy))->bitmap_unit)
+#define BitmapBitOrder(dpy) 	(((_XPrivDisplay)(dpy))->bitmap_bit_order)
+#define BitmapPad(dpy) 		(((_XPrivDisplay)(dpy))->bitmap_pad)
+#define ImageByteOrder(dpy) 	(((_XPrivDisplay)(dpy))->byte_order)
+#define NextRequest(dpy)	(((_XPrivDisplay)(dpy))->request + 1)
+#define LastKnownRequestProcessed(dpy)	(((_XPrivDisplay)(dpy))->last_request_read)
+
+/* macros for screen oriented applications (toolkit) */
+#define ScreenOfDisplay(dpy, scr)(&((_XPrivDisplay)(dpy))->screens[scr])
+#define DefaultScreenOfDisplay(dpy) ScreenOfDisplay(dpy,DefaultScreen(dpy))
+#define DisplayOfScreen(s)	((s)->display)
+#define RootWindowOfScreen(s)	((s)->root)
+#define BlackPixelOfScreen(s)	((s)->black_pixel)
+#define WhitePixelOfScreen(s)	((s)->white_pixel)
+#define DefaultColormapOfScreen(s)((s)->cmap)
+#define DefaultDepthOfScreen(s)	((s)->root_depth)
+#define DefaultGCOfScreen(s)	((s)->default_gc)
+#define DefaultVisualOfScreen(s)((s)->root_visual)
+#define WidthOfScreen(s)	((s)->width)
+#define HeightOfScreen(s)	((s)->height)
+#define WidthMMOfScreen(s)	((s)->mwidth)
+#define HeightMMOfScreen(s)	((s)->mheight)
+#define PlanesOfScreen(s)	((s)->root_depth)
+#define CellsOfScreen(s)	(DefaultVisualOfScreen((s))->map_entries)
+#define MinCmapsOfScreen(s)	((s)->min_maps)
+#define MaxCmapsOfScreen(s)	((s)->max_maps)
+#define DoesSaveUnders(s)	((s)->save_unders)
+#define DoesBackingStore(s)	((s)->backing_store)
+#define EventMaskOfScreen(s)	((s)->root_input_mask)
+
+/*
+ * Extensions need a way to hang private data on some structures.
+ */
+typedef struct _XExtData {
+	int number;		/* number returned by XRegisterExtension */
+	struct _XExtData *next;	/* next item on list of data for structure */
+	int (*free_private)(	/* called to free private storage */
+	struct _XExtData *extension
+	);
+	XPointer private_data;	/* data private to this extension. */
+} XExtData;
+
+/*
+ * This file contains structures used by the extension mechanism.
+ */
+typedef struct {		/* public to extension, cannot be changed */
+	int extension;		/* extension number */
+	int major_opcode;	/* major op-code assigned by server */
+	int first_event;	/* first event number for the extension */
+	int first_error;	/* first error number for the extension */
+} XExtCodes;
+
+/*
+ * Data structure for retrieving info about pixmap formats.
+ */
+
+typedef struct {
+    int depth;
+    int bits_per_pixel;
+    int scanline_pad;
+} XPixmapFormatValues;
+
+
+/*
+ * Data structure for setting graphics context.
+ */
+typedef struct {
+	int function;		/* logical operation */
+	unsigned long plane_mask;/* plane mask */
+	unsigned long foreground;/* foreground pixel */
+	unsigned long background;/* background pixel */
+	int line_width;		/* line width */
+	int line_style;	 	/* LineSolid, LineOnOffDash, LineDoubleDash */
+	int cap_style;	  	/* CapNotLast, CapButt,
+				   CapRound, CapProjecting */
+	int join_style;	 	/* JoinMiter, JoinRound, JoinBevel */
+	int fill_style;	 	/* FillSolid, FillTiled,
+				   FillStippled, FillOpaeueStippled */
+	int fill_rule;	  	/* EvenOddRule, WindingRule */
+	int arc_mode;		/* ArcChord, ArcPieSlice */
+	Pixmap tile;		/* tile pixmap for tiling operations */
+	Pixmap stipple;		/* stipple 1 plane pixmap for stipping */
+	int ts_x_origin;	/* offset for tile or stipple operations */
+	int ts_y_origin;
+        Font font;	        /* default text font for text operations */
+	int subwindow_mode;     /* ClipByChildren, IncludeInferiors */
+	Bool graphics_exposures;/* boolean, should exposures be generated */
+	int clip_x_origin;	/* origin for clipping */
+	int clip_y_origin;
+	Pixmap clip_mask;	/* bitmap clipping; other calls for rects */
+	int dash_offset;	/* patterned/dashed line information */
+	char dashes;
+} XGCValues;
+
+/*
+ * Graphics context.  The contents of this structure are implementation
+ * dependent.  A GC should be treated as opaque by application code.
+ */
+
+typedef struct _XGC
+#ifdef XLIB_ILLEGAL_ACCESS
+{
+    XExtData *ext_data;	/* hook for extension to hang data */
+    GContext gid;	/* protocol ID for graphics context */
+    /* there is more to this structure, but it is private to Xlib */
+}
+#endif
+*GC;
+
+/*
+ * Visual structure; contains information about colormapping possible.
+ */
+typedef struct {
+	XExtData *ext_data;	/* hook for extension to hang data */
+	VisualID visualid;	/* visual id of this visual */
+#if defined(__cplusplus) || defined(c_plusplus)
+	int c_class;		/* C++ class of screen (monochrome, etc.) */
+#else
+	int class;		/* class of screen (monochrome, etc.) */
+#endif
+	unsigned long red_mask, green_mask, blue_mask;	/* mask values */
+	int bits_per_rgb;	/* log base 2 of distinct color values */
+	int map_entries;	/* color map entries */
+} Visual;
+
+/*
+ * Depth structure; contains information for each possible depth.
+ */
+typedef struct {
+	int depth;		/* this depth (Z) of the depth */
+	int nvisuals;		/* number of Visual types at this depth */
+	Visual *visuals;	/* list of visuals possible at this depth */
+} Depth;
+
+/*
+ * Information about the screen.  The contents of this structure are
+ * implementation dependent.  A Screen should be treated as opaque
+ * by application code.
+ */
+
+struct _XDisplay;		/* Forward declare before use for C++ */
+
+typedef struct {
+	XExtData *ext_data;	/* hook for extension to hang data */
+	struct _XDisplay *display;/* back pointer to display structure */
+	Window root;		/* Root window id. */
+	int width, height;	/* width and height of screen */
+	int mwidth, mheight;	/* width and height of  in millimeters */
+	int ndepths;		/* number of depths possible */
+	Depth *depths;		/* list of allowable depths on the screen */
+	int root_depth;		/* bits per pixel */
+	Visual *root_visual;	/* root visual */
+	GC default_gc;		/* GC for the root root visual */
+	Colormap cmap;		/* default color map */
+	unsigned long white_pixel;
+	unsigned long black_pixel;	/* White and Black pixel values */
+	int max_maps, min_maps;	/* max and min color maps */
+	int backing_store;	/* Never, WhenMapped, Always */
+	Bool save_unders;
+	long root_input_mask;	/* initial root input mask */
+} Screen;
+
+/*
+ * Format structure; describes ZFormat data the screen will understand.
+ */
+typedef struct {
+	XExtData *ext_data;	/* hook for extension to hang data */
+	int depth;		/* depth of this image format */
+	int bits_per_pixel;	/* bits/pixel at this depth */
+	int scanline_pad;	/* scanline must padded to this multiple */
+} ScreenFormat;
+
+/*
+ * Data structure for setting window attributes.
+ */
+typedef struct {
+    Pixmap background_pixmap;	/* background or None or ParentRelative */
+    unsigned long background_pixel;	/* background pixel */
+    Pixmap border_pixmap;	/* border of the window */
+    unsigned long border_pixel;	/* border pixel value */
+    int bit_gravity;		/* one of bit gravity values */
+    int win_gravity;		/* one of the window gravity values */
+    int backing_store;		/* NotUseful, WhenMapped, Always */
+    unsigned long backing_planes;/* planes to be preseved if possible */
+    unsigned long backing_pixel;/* value to use in restoring planes */
+    Bool save_under;		/* should bits under be saved? (popups) */
+    long event_mask;		/* set of events that should be saved */
+    long do_not_propagate_mask;	/* set of events that should not propagate */
+    Bool override_redirect;	/* boolean value for override-redirect */
+    Colormap colormap;		/* color map to be associated with window */
+    Cursor cursor;		/* cursor to be displayed (or None) */
+} XSetWindowAttributes;
+
+typedef struct {
+    int x, y;			/* location of window */
+    int width, height;		/* width and height of window */
+    int border_width;		/* border width of window */
+    int depth;          	/* depth of window */
+    Visual *visual;		/* the associated visual structure */
+    Window root;        	/* root of screen containing window */
+#if defined(__cplusplus) || defined(c_plusplus)
+    int c_class;		/* C++ InputOutput, InputOnly*/
+#else
+    int class;			/* InputOutput, InputOnly*/
+#endif
+    int bit_gravity;		/* one of bit gravity values */
+    int win_gravity;		/* one of the window gravity values */
+    int backing_store;		/* NotUseful, WhenMapped, Always */
+    unsigned long backing_planes;/* planes to be preserved if possible */
+    unsigned long backing_pixel;/* value to be used when restoring planes */
+    Bool save_under;		/* boolean, should bits under be saved? */
+    Colormap colormap;		/* color map to be associated with window */
+    Bool map_installed;		/* boolean, is color map currently installed*/
+    int map_state;		/* IsUnmapped, IsUnviewable, IsViewable */
+    long all_event_masks;	/* set of events all people have interest in*/
+    long your_event_mask;	/* my event mask */
+    long do_not_propagate_mask; /* set of events that should not propagate */
+    Bool override_redirect;	/* boolean value for override-redirect */
+    Screen *screen;		/* back pointer to correct screen */
+} XWindowAttributes;
+
+/*
+ * Data structure for host setting; getting routines.
+ *
+ */
+
+typedef struct {
+	int family;		/* for example FamilyInternet */
+	int length;		/* length of address, in bytes */
+	char *address;		/* pointer to where to find the bytes */
+} XHostAddress;
+
+/*
+ * Data structure for ServerFamilyInterpreted addresses in host routines
+ */
+typedef struct {
+	int typelength;		/* length of type string, in bytes */
+	int valuelength;	/* length of value string, in bytes */
+	char *type;		/* pointer to where to find the type string */
+	char *value;		/* pointer to where to find the address */
+} XServerInterpretedAddress;
+
+/*
+ * Data structure for "image" data, used by image manipulation routines.
+ */
+typedef struct _XImage {
+    int width, height;		/* size of image */
+    int xoffset;		/* number of pixels offset in X direction */
+    int format;			/* XYBitmap, XYPixmap, ZPixmap */
+    char *data;			/* pointer to image data */
+    int byte_order;		/* data byte order, LSBFirst, MSBFirst */
+    int bitmap_unit;		/* quant. of scanline 8, 16, 32 */
+    int bitmap_bit_order;	/* LSBFirst, MSBFirst */
+    int bitmap_pad;		/* 8, 16, 32 either XY or ZPixmap */
+    int depth;			/* depth of image */
+    int bytes_per_line;		/* accelarator to next line */
+    int bits_per_pixel;		/* bits per pixel (ZPixmap) */
+    unsigned long red_mask;	/* bits in z arrangment */
+    unsigned long green_mask;
+    unsigned long blue_mask;
+    XPointer obdata;		/* hook for the object routines to hang on */
+    struct funcs {		/* image manipulation routines */
+	struct _XImage *(*create_image)(
+		struct _XDisplay* /* display */,
+		Visual*		/* visual */,
+		unsigned int	/* depth */,
+		int		/* format */,
+		int		/* offset */,
+		char*		/* data */,
+		unsigned int	/* width */,
+		unsigned int	/* height */,
+		int		/* bitmap_pad */,
+		int		/* bytes_per_line */);
+	int (*destroy_image)        (struct _XImage *);
+	unsigned long (*get_pixel)  (struct _XImage *, int, int);
+	int (*put_pixel)            (struct _XImage *, int, int, unsigned long);
+	struct _XImage *(*sub_image)(struct _XImage *, int, int, unsigned int, unsigned int);
+	int (*add_pixel)            (struct _XImage *, long);
+	} f;
+} XImage;
+
+/*
+ * Data structure for XReconfigureWindow
+ */
+typedef struct {
+    int x, y;
+    int width, height;
+    int border_width;
+    Window sibling;
+    int stack_mode;
+} XWindowChanges;
+
+/*
+ * Data structure used by color operations
+ */
+typedef struct {
+	unsigned long pixel;
+	unsigned short red, green, blue;
+	char flags;  /* do_red, do_green, do_blue */
+	char pad;
+} XColor;
+
+/*
+ * Data structures for graphics operations.  On most machines, these are
+ * congruent with the wire protocol structures, so reformatting the data
+ * can be avoided on these architectures.
+ */
+typedef struct {
+    short x1, y1, x2, y2;
+} XSegment;
+
+typedef struct {
+    short x, y;
+} XPoint;
+
+typedef struct {
+    short x, y;
+    unsigned short width, height;
+} XRectangle;
+
+typedef struct {
+    short x, y;
+    unsigned short width, height;
+    short angle1, angle2;
+} XArc;
+
+
+/* Data structure for XChangeKeyboardControl */
+
+typedef struct {
+        int key_click_percent;
+        int bell_percent;
+        int bell_pitch;
+        int bell_duration;
+        int led;
+        int led_mode;
+        int key;
+        int auto_repeat_mode;   /* On, Off, Default */
+} XKeyboardControl;
+
+/* Data structure for XGetKeyboardControl */
+
+typedef struct {
+        int key_click_percent;
+	int bell_percent;
+	unsigned int bell_pitch, bell_duration;
+	unsigned long led_mask;
+	int global_auto_repeat;
+	char auto_repeats[32];
+} XKeyboardState;
+
+/* Data structure for XGetMotionEvents.  */
+
+typedef struct {
+        Time time;
+	short x, y;
+} XTimeCoord;
+
+/* Data structure for X{Set,Get}ModifierMapping */
+
+typedef struct {
+ 	int max_keypermod;	/* The server's max # of keys per modifier */
+ 	KeyCode *modifiermap;	/* An 8 by max_keypermod array of modifiers */
+} XModifierKeymap;
+
+
+/*
+ * Display datatype maintaining display specific data.
+ * The contents of this structure are implementation dependent.
+ * A Display should be treated as opaque by application code.
+ */
+#ifndef XLIB_ILLEGAL_ACCESS
+typedef struct _XDisplay Display;
+#endif
+
+struct _XPrivate;		/* Forward declare before use for C++ */
+struct _XrmHashBucketRec;
+
+typedef struct
+#ifdef XLIB_ILLEGAL_ACCESS
+_XDisplay
+#endif
+{
+	XExtData *ext_data;	/* hook for extension to hang data */
+	struct _XPrivate *private1;
+	int fd;			/* Network socket. */
+	int private2;
+	int proto_major_version;/* major version of server's X protocol */
+	int proto_minor_version;/* minor version of servers X protocol */
+	char *vendor;		/* vendor of the server hardware */
+        XID private3;
+	XID private4;
+	XID private5;
+	int private6;
+	XID (*resource_alloc)(	/* allocator function */
+		struct _XDisplay*
+	);
+	int byte_order;		/* screen byte order, LSBFirst, MSBFirst */
+	int bitmap_unit;	/* padding and data requirements */
+	int bitmap_pad;		/* padding requirements on bitmaps */
+	int bitmap_bit_order;	/* LeastSignificant or MostSignificant */
+	int nformats;		/* number of pixmap formats in list */
+	ScreenFormat *pixmap_format;	/* pixmap format list */
+	int private8;
+	int release;		/* release of the server */
+	struct _XPrivate *private9, *private10;
+	int qlen;		/* Length of input event queue */
+	unsigned long last_request_read; /* seq number of last event read */
+	unsigned long request;	/* sequence number of last request. */
+	XPointer private11;
+	XPointer private12;
+	XPointer private13;
+	XPointer private14;
+	unsigned max_request_size; /* maximum number 32 bit words in request*/
+	struct _XrmHashBucketRec *db;
+	int (*private15)(
+		struct _XDisplay*
+		);
+	char *display_name;	/* "host:display" string used on this connect*/
+	int default_screen;	/* default screen for operations */
+	int nscreens;		/* number of screens on this server*/
+	Screen *screens;	/* pointer to list of screens */
+	unsigned long motion_buffer;	/* size of motion buffer */
+	unsigned long private16;
+	int min_keycode;	/* minimum defined keycode */
+	int max_keycode;	/* maximum defined keycode */
+	XPointer private17;
+	XPointer private18;
+	int private19;
+	char *xdefaults;	/* contents of defaults from server */
+	/* there is more to this structure, but it is private to Xlib */
+}
+#ifdef XLIB_ILLEGAL_ACCESS
+Display,
+#endif
+*_XPrivDisplay;
+
+#undef _XEVENT_
+#ifndef _XEVENT_
+/*
+ * Definitions of specific events.
+ */
+typedef struct {
+	int type;		/* of event */
+	unsigned long serial;	/* # of last request processed by server */
+	Bool send_event;	/* true if this came from a SendEvent request */
+	Display *display;	/* Display the event was read from */
+	Window window;	        /* "event" window it is reported relative to */
+	Window root;	        /* root window that the event occurred on */
+	Window subwindow;	/* child window */
+	Time time;		/* milliseconds */
+	int x, y;		/* pointer x, y coordinates in event window */
+	int x_root, y_root;	/* coordinates relative to root */
+	unsigned int state;	/* key or button mask */
+	unsigned int keycode;	/* detail */
+	Bool same_screen;	/* same screen flag */
+} XKeyEvent;
+typedef XKeyEvent XKeyPressedEvent;
+typedef XKeyEvent XKeyReleasedEvent;
+
+typedef struct {
+	int type;		/* of event */
+	unsigned long serial;	/* # of last request processed by server */
+	Bool send_event;	/* true if this came from a SendEvent request */
+	Display *display;	/* Display the event was read from */
+	Window window;	        /* "event" window it is reported relative to */
+	Window root;	        /* root window that the event occurred on */
+	Window subwindow;	/* child window */
+	Time time;		/* milliseconds */
+	int x, y;		/* pointer x, y coordinates in event window */
+	int x_root, y_root;	/* coordinates relative to root */
+	unsigned int state;	/* key or button mask */
+	unsigned int button;	/* detail */
+	Bool same_screen;	/* same screen flag */
+} XButtonEvent;
+typedef XButtonEvent XButtonPressedEvent;
+typedef XButtonEvent XButtonReleasedEvent;
+
+typedef struct {
+	int type;		/* of event */
+	unsigned long serial;	/* # of last request processed by server */
+	Bool send_event;	/* true if this came from a SendEvent request */
+	Display *display;	/* Display the event was read from */
+	Window window;	        /* "event" window reported relative to */
+	Window root;	        /* root window that the event occurred on */
+	Window subwindow;	/* child window */
+	Time time;		/* milliseconds */
+	int x, y;		/* pointer x, y coordinates in event window */
+	int x_root, y_root;	/* coordinates relative to root */
+	unsigned int state;	/* key or button mask */
+	char is_hint;		/* detail */
+	Bool same_screen;	/* same screen flag */
+} XMotionEvent;
+typedef XMotionEvent XPointerMovedEvent;
+
+typedef struct {
+	int type;		/* of event */
+	unsigned long serial;	/* # of last request processed by server */
+	Bool send_event;	/* true if this came from a SendEvent request */
+	Display *display;	/* Display the event was read from */
+	Window window;	        /* "event" window reported relative to */
+	Window root;	        /* root window that the event occurred on */
+	Window subwindow;	/* child window */
+	Time time;		/* milliseconds */
+	int x, y;		/* pointer x, y coordinates in event window */
+	int x_root, y_root;	/* coordinates relative to root */
+	int mode;		/* NotifyNormal, NotifyGrab, NotifyUngrab */
+	int detail;
+	/*
+	 * NotifyAncestor, NotifyVirtual, NotifyInferior,
+	 * NotifyNonlinear,NotifyNonlinearVirtual
+	 */
+	Bool same_screen;	/* same screen flag */
+	Bool focus;		/* boolean focus */
+	unsigned int state;	/* key or button mask */
+} XCrossingEvent;
+typedef XCrossingEvent XEnterWindowEvent;
+typedef XCrossingEvent XLeaveWindowEvent;
+
+typedef struct {
+	int type;		/* FocusIn or FocusOut */
+	unsigned long serial;	/* # of last request processed by server */
+	Bool send_event;	/* true if this came from a SendEvent request */
+	Display *display;	/* Display the event was read from */
+	Window window;		/* window of event */
+	int mode;		/* NotifyNormal, NotifyWhileGrabbed,
+				   NotifyGrab, NotifyUngrab */
+	int detail;
+	/*
+	 * NotifyAncestor, NotifyVirtual, NotifyInferior,
+	 * NotifyNonlinear,NotifyNonlinearVirtual, NotifyPointer,
+	 * NotifyPointerRoot, NotifyDetailNone
+	 */
+} XFocusChangeEvent;
+typedef XFocusChangeEvent XFocusInEvent;
+typedef XFocusChangeEvent XFocusOutEvent;
+
+/* generated on EnterWindow and FocusIn  when KeyMapState selected */
+typedef struct {
+	int type;
+	unsigned long serial;	/* # of last request processed by server */
+	Bool send_event;	/* true if this came from a SendEvent request */
+	Display *display;	/* Display the event was read from */
+	Window window;
+	char key_vector[32];
+} XKeymapEvent;
+
+typedef struct {
+	int type;
+	unsigned long serial;	/* # of last request processed by server */
+	Bool send_event;	/* true if this came from a SendEvent request */
+	Display *display;	/* Display the event was read from */
+	Window window;
+	int x, y;
+	int width, height;
+	int count;		/* if non-zero, at least this many more */
+} XExposeEvent;
+
+typedef struct {
+	int type;
+	unsigned long serial;	/* # of last request processed by server */
+	Bool send_event;	/* true if this came from a SendEvent request */
+	Display *display;	/* Display the event was read from */
+	Drawable drawable;
+	int x, y;
+	int width, height;
+	int count;		/* if non-zero, at least this many more */
+	int major_code;		/* core is CopyArea or CopyPlane */
+	int minor_code;		/* not defined in the core */
+} XGraphicsExposeEvent;
+
+typedef struct {
+	int type;
+	unsigned long serial;	/* # of last request processed by server */
+	Bool send_event;	/* true if this came from a SendEvent request */
+	Display *display;	/* Display the event was read from */
+	Drawable drawable;
+	int major_code;		/* core is CopyArea or CopyPlane */
+	int minor_code;		/* not defined in the core */
+} XNoExposeEvent;
+
+typedef struct {
+	int type;
+	unsigned long serial;	/* # of last request processed by server */
+	Bool send_event;	/* true if this came from a SendEvent request */
+	Display *display;	/* Display the event was read from */
+	Window window;
+	int state;		/* Visibility state */
+} XVisibilityEvent;
+
+typedef struct {
+	int type;
+	unsigned long serial;	/* # of last request processed by server */
+	Bool send_event;	/* true if this came from a SendEvent request */
+	Display *display;	/* Display the event was read from */
+	Window parent;		/* parent of the window */
+	Window window;		/* window id of window created */
+	int x, y;		/* window location */
+	int width, height;	/* size of window */
+	int border_width;	/* border width */
+	Bool override_redirect;	/* creation should be overridden */
+} XCreateWindowEvent;
+
+typedef struct {
+	int type;
+	unsigned long serial;	/* # of last request processed by server */
+	Bool send_event;	/* true if this came from a SendEvent request */
+	Display *display;	/* Display the event was read from */
+	Window event;
+	Window window;
+} XDestroyWindowEvent;
+
+typedef struct {
+	int type;
+	unsigned long serial;	/* # of last request processed by server */
+	Bool send_event;	/* true if this came from a SendEvent request */
+	Display *display;	/* Display the event was read from */
+	Window event;
+	Window window;
+	Bool from_configure;
+} XUnmapEvent;
+
+typedef struct {
+	int type;
+	unsigned long serial;	/* # of last request processed by server */
+	Bool send_event;	/* true if this came from a SendEvent request */
+	Display *display;	/* Display the event was read from */
+	Window event;
+	Window window;
+	Bool override_redirect;	/* boolean, is override set... */
+} XMapEvent;
+
+typedef struct {
+	int type;
+	unsigned long serial;	/* # of last request processed by server */
+	Bool send_event;	/* true if this came from a SendEvent request */
+	Display *display;	/* Display the event was read from */
+	Window parent;
+	Window window;
+} XMapRequestEvent;
+
+typedef struct {
+	int type;
+	unsigned long serial;	/* # of last request processed by server */
+	Bool send_event;	/* true if this came from a SendEvent request */
+	Display *display;	/* Display the event was read from */
+	Window event;
+	Window window;
+	Window parent;
+	int x, y;
+	Bool override_redirect;
+} XReparentEvent;
+
+typedef struct {
+	int type;
+	unsigned long serial;	/* # of last request processed by server */
+	Bool send_event;	/* true if this came from a SendEvent request */
+	Display *display;	/* Display the event was read from */
+	Window event;
+	Window window;
+	int x, y;
+	int width, height;
+	int border_width;
+	Window above;
+	Bool override_redirect;
+} XConfigureEvent;
+
+typedef struct {
+	int type;
+	unsigned long serial;	/* # of last request processed by server */
+	Bool send_event;	/* true if this came from a SendEvent request */
+	Display *display;	/* Display the event was read from */
+	Window event;
+	Window window;
+	int x, y;
+} XGravityEvent;
+
+typedef struct {
+	int type;
+	unsigned long serial;	/* # of last request processed by server */
+	Bool send_event;	/* true if this came from a SendEvent request */
+	Display *display;	/* Display the event was read from */
+	Window window;
+	int width, height;
+} XResizeRequestEvent;
+
+typedef struct {
+	int type;
+	unsigned long serial;	/* # of last request processed by server */
+	Bool send_event;	/* true if this came from a SendEvent request */
+	Display *display;	/* Display the event was read from */
+	Window parent;
+	Window window;
+	int x, y;
+	int width, height;
+	int border_width;
+	Window above;
+	int detail;		/* Above, Below, TopIf, BottomIf, Opposite */
+	unsigned long value_mask;
+} XConfigureRequestEvent;
+
+typedef struct {
+	int type;
+	unsigned long serial;	/* # of last request processed by server */
+	Bool send_event;	/* true if this came from a SendEvent request */
+	Display *display;	/* Display the event was read from */
+	Window event;
+	Window window;
+	int place;		/* PlaceOnTop, PlaceOnBottom */
+} XCirculateEvent;
+
+typedef struct {
+	int type;
+	unsigned long serial;	/* # of last request processed by server */
+	Bool send_event;	/* true if this came from a SendEvent request */
+	Display *display;	/* Display the event was read from */
+	Window parent;
+	Window window;
+	int place;		/* PlaceOnTop, PlaceOnBottom */
+} XCirculateRequestEvent;
+
+typedef struct {
+	int type;
+	unsigned long serial;	/* # of last request processed by server */
+	Bool send_event;	/* true if this came from a SendEvent request */
+	Display *display;	/* Display the event was read from */
+	Window window;
+	Atom atom;
+	Time time;
+	int state;		/* NewValue, Deleted */
+} XPropertyEvent;
+
+typedef struct {
+	int type;
+	unsigned long serial;	/* # of last request processed by server */
+	Bool send_event;	/* true if this came from a SendEvent request */
+	Display *display;	/* Display the event was read from */
+	Window window;
+	Atom selection;
+	Time time;
+} XSelectionClearEvent;
+
+typedef struct {
+	int type;
+	unsigned long serial;	/* # of last request processed by server */
+	Bool send_event;	/* true if this came from a SendEvent request */
+	Display *display;	/* Display the event was read from */
+	Window owner;
+	Window requestor;
+	Atom selection;
+	Atom target;
+	Atom property;
+	Time time;
+} XSelectionRequestEvent;
+
+typedef struct {
+	int type;
+	unsigned long serial;	/* # of last request processed by server */
+	Bool send_event;	/* true if this came from a SendEvent request */
+	Display *display;	/* Display the event was read from */
+	Window requestor;
+	Atom selection;
+	Atom target;
+	Atom property;		/* ATOM or None */
+	Time time;
+} XSelectionEvent;
+
+typedef struct {
+	int type;
+	unsigned long serial;	/* # of last request processed by server */
+	Bool send_event;	/* true if this came from a SendEvent request */
+	Display *display;	/* Display the event was read from */
+	Window window;
+	Colormap colormap;	/* COLORMAP or None */
+#if defined(__cplusplus) || defined(c_plusplus)
+	Bool c_new;		/* C++ */
+#else
+	Bool new;
+#endif
+	int state;		/* ColormapInstalled, ColormapUninstalled */
+} XColormapEvent;
+
+typedef struct {
+	int type;
+	unsigned long serial;	/* # of last request processed by server */
+	Bool send_event;	/* true if this came from a SendEvent request */
+	Display *display;	/* Display the event was read from */
+	Window window;
+	Atom message_type;
+	int format;
+	union {
+		char b[20];
+		short s[10];
+		long l[5];
+		} data;
+} XClientMessageEvent;
+
+typedef struct {
+	int type;
+	unsigned long serial;	/* # of last request processed by server */
+	Bool send_event;	/* true if this came from a SendEvent request */
+	Display *display;	/* Display the event was read from */
+	Window window;		/* unused */
+	int request;		/* one of MappingModifier, MappingKeyboard,
+				   MappingPointer */
+	int first_keycode;	/* first keycode */
+	int count;		/* defines range of change w. first_keycode*/
+} XMappingEvent;
+
+typedef struct {
+	int type;
+	Display *display;	/* Display the event was read from */
+	XID resourceid;		/* resource id */
+	unsigned long serial;	/* serial number of failed request */
+	unsigned char error_code;	/* error code of failed request */
+	unsigned char request_code;	/* Major op-code of failed request */
+	unsigned char minor_code;	/* Minor op-code of failed request */
+} XErrorEvent;
+
+typedef struct {
+	int type;
+	unsigned long serial;	/* # of last request processed by server */
+	Bool send_event;	/* true if this came from a SendEvent request */
+	Display *display;/* Display the event was read from */
+	Window window;	/* window on which event was requested in event mask */
+} XAnyEvent;
+
+
+/***************************************************************
+ *
+ * GenericEvent.  This event is the standard event for all newer extensions.
+ */
+
+typedef struct
+    {
+    int            type;         /* of event. Always GenericEvent */
+    unsigned long  serial;       /* # of last request processed */
+    Bool           send_event;   /* true if from SendEvent request */
+    Display        *display;     /* Display the event was read from */
+    int            extension;    /* major opcode of extension that caused the event */
+    int            evtype;       /* actual event type. */
+    } XGenericEvent;
+
+typedef struct {
+    int            type;         /* of event. Always GenericEvent */
+    unsigned long  serial;       /* # of last request processed */
+    Bool           send_event;   /* true if from SendEvent request */
+    Display        *display;     /* Display the event was read from */
+    int            extension;    /* major opcode of extension that caused the event */
+    int            evtype;       /* actual event type. */
+    unsigned int   cookie;
+    void           *data;
+} XGenericEventCookie;
+
+/*
+ * this union is defined so Xlib can always use the same sized
+ * event structure internally, to avoid memory fragmentation.
+ */
+typedef union _XEvent {
+        int type;		/* must not be changed; first element */
+	XAnyEvent xany;
+	XKeyEvent xkey;
+	XButtonEvent xbutton;
+	XMotionEvent xmotion;
+	XCrossingEvent xcrossing;
+	XFocusChangeEvent xfocus;
+	XExposeEvent xexpose;
+	XGraphicsExposeEvent xgraphicsexpose;
+	XNoExposeEvent xnoexpose;
+	XVisibilityEvent xvisibility;
+	XCreateWindowEvent xcreatewindow;
+	XDestroyWindowEvent xdestroywindow;
+	XUnmapEvent xunmap;
+	XMapEvent xmap;
+	XMapRequestEvent xmaprequest;
+	XReparentEvent xreparent;
+	XConfigureEvent xconfigure;
+	XGravityEvent xgravity;
+	XResizeRequestEvent xresizerequest;
+	XConfigureRequestEvent xconfigurerequest;
+	XCirculateEvent xcirculate;
+	XCirculateRequestEvent xcirculaterequest;
+	XPropertyEvent xproperty;
+	XSelectionClearEvent xselectionclear;
+	XSelectionRequestEvent xselectionrequest;
+	XSelectionEvent xselection;
+	XColormapEvent xcolormap;
+	XClientMessageEvent xclient;
+	XMappingEvent xmapping;
+	XErrorEvent xerror;
+	XKeymapEvent xkeymap;
+	XGenericEvent xgeneric;
+	XGenericEventCookie xcookie;
+	long pad[24];
+} XEvent;
+#endif
+
+#define XAllocID(dpy) ((*((_XPrivDisplay)(dpy))->resource_alloc)((dpy)))
+
+/*
+ * per character font metric information.
+ */
+typedef struct {
+    short	lbearing;	/* origin to left edge of raster */
+    short	rbearing;	/* origin to right edge of raster */
+    short	width;		/* advance to next char's origin */
+    short	ascent;		/* baseline to top edge of raster */
+    short	descent;	/* baseline to bottom edge of raster */
+    unsigned short attributes;	/* per char flags (not predefined) */
+} XCharStruct;
+
+/*
+ * To allow arbitrary information with fonts, there are additional properties
+ * returned.
+ */
+typedef struct {
+    Atom name;
+    unsigned long card32;
+} XFontProp;
+
+typedef struct {
+    XExtData	*ext_data;	/* hook for extension to hang data */
+    Font        fid;            /* Font id for this font */
+    unsigned	direction;	/* hint about direction the font is painted */
+    unsigned	min_char_or_byte2;/* first character */
+    unsigned	max_char_or_byte2;/* last character */
+    unsigned	min_byte1;	/* first row that exists */
+    unsigned	max_byte1;	/* last row that exists */
+    Bool	all_chars_exist;/* flag if all characters have non-zero size*/
+    unsigned	default_char;	/* char to print for undefined character */
+    int         n_properties;   /* how many properties there are */
+    XFontProp	*properties;	/* pointer to array of additional properties*/
+    XCharStruct	min_bounds;	/* minimum bounds over all existing char*/
+    XCharStruct	max_bounds;	/* maximum bounds over all existing char*/
+    XCharStruct	*per_char;	/* first_char to last_char information */
+    int		ascent;		/* log. extent above baseline for spacing */
+    int		descent;	/* log. descent below baseline for spacing */
+} XFontStruct;
+
+/*
+ * PolyText routines take these as arguments.
+ */
+typedef struct {
+    char *chars;		/* pointer to string */
+    int nchars;			/* number of characters */
+    int delta;			/* delta between strings */
+    Font font;			/* font to print it in, None don't change */
+} XTextItem;
+
+typedef struct {		/* normal 16 bit characters are two bytes */
+    unsigned char byte1;
+    unsigned char byte2;
+} XChar2b;
+
+typedef struct {
+    XChar2b *chars;		/* two byte characters */
+    int nchars;			/* number of characters */
+    int delta;			/* delta between strings */
+    Font font;			/* font to print it in, None don't change */
+} XTextItem16;
+
+
+typedef union { Display *display;
+		GC gc;
+		Visual *visual;
+		Screen *screen;
+		ScreenFormat *pixmap_format;
+		XFontStruct *font; } XEDataObject;
+
+typedef struct {
+    XRectangle      max_ink_extent;
+    XRectangle      max_logical_extent;
+} XFontSetExtents;
+
+/* unused:
+typedef void (*XOMProc)();
+ */
+
+typedef struct _XOM *XOM;
+typedef struct _XOC *XOC, *XFontSet;
+
+typedef struct {
+    char           *chars;
+    int             nchars;
+    int             delta;
+    XFontSet        font_set;
+} XmbTextItem;
+
+typedef struct {
+    wchar_t        *chars;
+    int             nchars;
+    int             delta;
+    XFontSet        font_set;
+} XwcTextItem;
+
+#define XNRequiredCharSet "requiredCharSet"
+#define XNQueryOrientation "queryOrientation"
+#define XNBaseFontName "baseFontName"
+#define XNOMAutomatic "omAutomatic"
+#define XNMissingCharSet "missingCharSet"
+#define XNDefaultString "defaultString"
+#define XNOrientation "orientation"
+#define XNDirectionalDependentDrawing "directionalDependentDrawing"
+#define XNContextualDrawing "contextualDrawing"
+#define XNFontInfo "fontInfo"
+
+typedef struct {
+    int charset_count;
+    char **charset_list;
+} XOMCharSetList;
+
+typedef enum {
+    XOMOrientation_LTR_TTB,
+    XOMOrientation_RTL_TTB,
+    XOMOrientation_TTB_LTR,
+    XOMOrientation_TTB_RTL,
+    XOMOrientation_Context
+} XOrientation;
+
+typedef struct {
+    int num_orientation;
+    XOrientation *orientation;	/* Input Text description */
+} XOMOrientation;
+
+typedef struct {
+    int num_font;
+    XFontStruct **font_struct_list;
+    char **font_name_list;
+} XOMFontInfo;
+
+typedef struct _XIM *XIM;
+typedef struct _XIC *XIC;
+
+typedef void (*XIMProc)(
+    XIM,
+    XPointer,
+    XPointer
+);
+
+typedef Bool (*XICProc)(
+    XIC,
+    XPointer,
+    XPointer
+);
+
+typedef void (*XIDProc)(
+    Display*,
+    XPointer,
+    XPointer
+);
+
+typedef unsigned long XIMStyle;
+
+typedef struct {
+    unsigned short count_styles;
+    XIMStyle *supported_styles;
+} XIMStyles;
+
+#define XIMPreeditArea		0x0001L
+#define XIMPreeditCallbacks	0x0002L
+#define XIMPreeditPosition	0x0004L
+#define XIMPreeditNothing	0x0008L
+#define XIMPreeditNone		0x0010L
+#define XIMStatusArea		0x0100L
+#define XIMStatusCallbacks	0x0200L
+#define XIMStatusNothing	0x0400L
+#define XIMStatusNone		0x0800L
+
+#define XNVaNestedList "XNVaNestedList"
+#define XNQueryInputStyle "queryInputStyle"
+#define XNClientWindow "clientWindow"
+#define XNInputStyle "inputStyle"
+#define XNFocusWindow "focusWindow"
+#define XNResourceName "resourceName"
+#define XNResourceClass "resourceClass"
+#define XNGeometryCallback "geometryCallback"
+#define XNDestroyCallback "destroyCallback"
+#define XNFilterEvents "filterEvents"
+#define XNPreeditStartCallback "preeditStartCallback"
+#define XNPreeditDoneCallback "preeditDoneCallback"
+#define XNPreeditDrawCallback "preeditDrawCallback"
+#define XNPreeditCaretCallback "preeditCaretCallback"
+#define XNPreeditStateNotifyCallback "preeditStateNotifyCallback"
+#define XNPreeditAttributes "preeditAttributes"
+#define XNStatusStartCallback "statusStartCallback"
+#define XNStatusDoneCallback "statusDoneCallback"
+#define XNStatusDrawCallback "statusDrawCallback"
+#define XNStatusAttributes "statusAttributes"
+#define XNArea "area"
+#define XNAreaNeeded "areaNeeded"
+#define XNSpotLocation "spotLocation"
+#define XNColormap "colorMap"
+#define XNStdColormap "stdColorMap"
+#define XNForeground "foreground"
+#define XNBackground "background"
+#define XNBackgroundPixmap "backgroundPixmap"
+#define XNFontSet "fontSet"
+#define XNLineSpace "lineSpace"
+#define XNCursor "cursor"
+
+#define XNQueryIMValuesList "queryIMValuesList"
+#define XNQueryICValuesList "queryICValuesList"
+#define XNVisiblePosition "visiblePosition"
+#define XNR6PreeditCallback "r6PreeditCallback"
+#define XNStringConversionCallback "stringConversionCallback"
+#define XNStringConversion "stringConversion"
+#define XNResetState "resetState"
+#define XNHotKey "hotKey"
+#define XNHotKeyState "hotKeyState"
+#define XNPreeditState "preeditState"
+#define XNSeparatorofNestedList "separatorofNestedList"
+
+#define XBufferOverflow		-1
+#define XLookupNone		1
+#define XLookupChars		2
+#define XLookupKeySym		3
+#define XLookupBoth		4
+
+typedef void *XVaNestedList;
+
+typedef struct {
+    XPointer client_data;
+    XIMProc callback;
+} XIMCallback;
+
+typedef struct {
+    XPointer client_data;
+    XICProc callback;
+} XICCallback;
+
+typedef unsigned long XIMFeedback;
+
+#define XIMReverse		1L
+#define XIMUnderline		(1L<<1)
+#define XIMHighlight		(1L<<2)
+#define XIMPrimary	 	(1L<<5)
+#define XIMSecondary		(1L<<6)
+#define XIMTertiary	 	(1L<<7)
+#define XIMVisibleToForward 	(1L<<8)
+#define XIMVisibleToBackword 	(1L<<9)
+#define XIMVisibleToCenter 	(1L<<10)
+
+typedef struct _XIMText {
+    unsigned short length;
+    XIMFeedback *feedback;
+    Bool encoding_is_wchar;
+    union {
+	char *multi_byte;
+	wchar_t *wide_char;
+    } string;
+} XIMText;
+
+typedef	unsigned long	 XIMPreeditState;
+
+#define	XIMPreeditUnKnown	0L
+#define	XIMPreeditEnable	1L
+#define	XIMPreeditDisable	(1L<<1)
+
+typedef	struct	_XIMPreeditStateNotifyCallbackStruct {
+    XIMPreeditState state;
+} XIMPreeditStateNotifyCallbackStruct;
+
+typedef	unsigned long	 XIMResetState;
+
+#define	XIMInitialState		1L
+#define	XIMPreserveState	(1L<<1)
+
+typedef unsigned long XIMStringConversionFeedback;
+
+#define	XIMStringConversionLeftEdge	(0x00000001)
+#define	XIMStringConversionRightEdge	(0x00000002)
+#define	XIMStringConversionTopEdge	(0x00000004)
+#define	XIMStringConversionBottomEdge	(0x00000008)
+#define	XIMStringConversionConcealed	(0x00000010)
+#define	XIMStringConversionWrapped	(0x00000020)
+
+typedef struct _XIMStringConversionText {
+    unsigned short length;
+    XIMStringConversionFeedback *feedback;
+    Bool encoding_is_wchar;
+    union {
+	char *mbs;
+	wchar_t *wcs;
+    } string;
+} XIMStringConversionText;
+
+typedef	unsigned short	XIMStringConversionPosition;
+
+typedef	unsigned short	XIMStringConversionType;
+
+#define	XIMStringConversionBuffer	(0x0001)
+#define	XIMStringConversionLine		(0x0002)
+#define	XIMStringConversionWord		(0x0003)
+#define	XIMStringConversionChar		(0x0004)
+
+typedef	unsigned short	XIMStringConversionOperation;
+
+#define	XIMStringConversionSubstitution	(0x0001)
+#define	XIMStringConversionRetrieval	(0x0002)
+
+typedef enum {
+    XIMForwardChar, XIMBackwardChar,
+    XIMForwardWord, XIMBackwardWord,
+    XIMCaretUp, XIMCaretDown,
+    XIMNextLine, XIMPreviousLine,
+    XIMLineStart, XIMLineEnd,
+    XIMAbsolutePosition,
+    XIMDontChange
+} XIMCaretDirection;
+
+typedef struct _XIMStringConversionCallbackStruct {
+    XIMStringConversionPosition position;
+    XIMCaretDirection direction;
+    XIMStringConversionOperation operation;
+    unsigned short factor;
+    XIMStringConversionText *text;
+} XIMStringConversionCallbackStruct;
+
+typedef struct _XIMPreeditDrawCallbackStruct {
+    int caret;		/* Cursor offset within pre-edit string */
+    int chg_first;	/* Starting change position */
+    int chg_length;	/* Length of the change in character count */
+    XIMText *text;
+} XIMPreeditDrawCallbackStruct;
+
+typedef enum {
+    XIMIsInvisible,	/* Disable caret feedback */
+    XIMIsPrimary,	/* UI defined caret feedback */
+    XIMIsSecondary	/* UI defined caret feedback */
+} XIMCaretStyle;
+
+typedef struct _XIMPreeditCaretCallbackStruct {
+    int position;		 /* Caret offset within pre-edit string */
+    XIMCaretDirection direction; /* Caret moves direction */
+    XIMCaretStyle style;	 /* Feedback of the caret */
+} XIMPreeditCaretCallbackStruct;
+
+typedef enum {
+    XIMTextType,
+    XIMBitmapType
+} XIMStatusDataType;
+
+typedef struct _XIMStatusDrawCallbackStruct {
+    XIMStatusDataType type;
+    union {
+	XIMText *text;
+	Pixmap  bitmap;
+    } data;
+} XIMStatusDrawCallbackStruct;
+
+typedef struct _XIMHotKeyTrigger {
+    KeySym	 keysym;
+    int		 modifier;
+    int		 modifier_mask;
+} XIMHotKeyTrigger;
+
+typedef struct _XIMHotKeyTriggers {
+    int			 num_hot_key;
+    XIMHotKeyTrigger	*key;
+} XIMHotKeyTriggers;
+
+typedef	unsigned long	 XIMHotKeyState;
+
+#define	XIMHotKeyStateON	(0x0001L)
+#define	XIMHotKeyStateOFF	(0x0002L)
+
+typedef struct {
+    unsigned short count_values;
+    char **supported_values;
+} XIMValuesList;
+
+_XFUNCPROTOBEGIN
+
+#if defined(WIN32) && !defined(_XLIBINT_)
+#define _Xdebug (*_Xdebug_p)
+#endif
+
+extern int _Xdebug;
+
+extern XFontStruct *XLoadQueryFont(
+    Display*		/* display */,
+    _Xconst char*	/* name */
+);
+
+extern XFontStruct *XQueryFont(
+    Display*		/* display */,
+    XID			/* font_ID */
+);
+
+
+extern XTimeCoord *XGetMotionEvents(
+    Display*		/* display */,
+    Window		/* w */,
+    Time		/* start */,
+    Time		/* stop */,
+    int*		/* nevents_return */
+);
+
+extern XModifierKeymap *XDeleteModifiermapEntry(
+    XModifierKeymap*	/* modmap */,
+#if NeedWidePrototypes
+    unsigned int	/* keycode_entry */,
+#else
+    KeyCode		/* keycode_entry */,
+#endif
+    int			/* modifier */
+);
+
+extern XModifierKeymap	*XGetModifierMapping(
+    Display*		/* display */
+);
+
+extern XModifierKeymap	*XInsertModifiermapEntry(
+    XModifierKeymap*	/* modmap */,
+#if NeedWidePrototypes
+    unsigned int	/* keycode_entry */,
+#else
+    KeyCode		/* keycode_entry */,
+#endif
+    int			/* modifier */
+);
+
+extern XModifierKeymap *XNewModifiermap(
+    int			/* max_keys_per_mod */
+);
+
+extern XImage *XCreateImage(
+    Display*		/* display */,
+    Visual*		/* visual */,
+    unsigned int	/* depth */,
+    int			/* format */,
+    int			/* offset */,
+    char*		/* data */,
+    unsigned int	/* width */,
+    unsigned int	/* height */,
+    int			/* bitmap_pad */,
+    int			/* bytes_per_line */
+);
+extern Status XInitImage(
+    XImage*		/* image */
+);
+extern XImage *XGetImage(
+    Display*		/* display */,
+    Drawable		/* d */,
+    int			/* x */,
+    int			/* y */,
+    unsigned int	/* width */,
+    unsigned int	/* height */,
+    unsigned long	/* plane_mask */,
+    int			/* format */
+);
+extern XImage *XGetSubImage(
+    Display*		/* display */,
+    Drawable		/* d */,
+    int			/* x */,
+    int			/* y */,
+    unsigned int	/* width */,
+    unsigned int	/* height */,
+    unsigned long	/* plane_mask */,
+    int			/* format */,
+    XImage*		/* dest_image */,
+    int			/* dest_x */,
+    int			/* dest_y */
+);
+
+/*
+ * X function declarations.
+ */
+extern Display *XOpenDisplay(
+    _Xconst char*	/* display_name */
+);
+
+extern void XrmInitialize(
+    void
+);
+
+extern char *XFetchBytes(
+    Display*		/* display */,
+    int*		/* nbytes_return */
+);
+extern char *XFetchBuffer(
+    Display*		/* display */,
+    int*		/* nbytes_return */,
+    int			/* buffer */
+);
+extern char *XGetAtomName(
+    Display*		/* display */,
+    Atom		/* atom */
+);
+extern Status XGetAtomNames(
+    Display*		/* dpy */,
+    Atom*		/* atoms */,
+    int			/* count */,
+    char**		/* names_return */
+);
+extern char *XGetDefault(
+    Display*		/* display */,
+    _Xconst char*	/* program */,
+    _Xconst char*	/* option */
+);
+extern char *XDisplayName(
+    _Xconst char*	/* string */
+);
+extern char *XKeysymToString(
+    KeySym		/* keysym */
+);
+
+extern int (*XSynchronize(
+    Display*		/* display */,
+    Bool		/* onoff */
+))(
+    Display*		/* display */
+);
+extern int (*XSetAfterFunction(
+    Display*		/* display */,
+    int (*) (
+	     Display*	/* display */
+            )		/* procedure */
+))(
+    Display*		/* display */
+);
+extern Atom XInternAtom(
+    Display*		/* display */,
+    _Xconst char*	/* atom_name */,
+    Bool		/* only_if_exists */
+);
+extern Status XInternAtoms(
+    Display*		/* dpy */,
+    char**		/* names */,
+    int			/* count */,
+    Bool		/* onlyIfExists */,
+    Atom*		/* atoms_return */
+);
+extern Colormap XCopyColormapAndFree(
+    Display*		/* display */,
+    Colormap		/* colormap */
+);
+extern Colormap XCreateColormap(
+    Display*		/* display */,
+    Window		/* w */,
+    Visual*		/* visual */,
+    int			/* alloc */
+);
+extern Cursor XCreatePixmapCursor(
+    Display*		/* display */,
+    Pixmap		/* source */,
+    Pixmap		/* mask */,
+    XColor*		/* foreground_color */,
+    XColor*		/* background_color */,
+    unsigned int	/* x */,
+    unsigned int	/* y */
+);
+extern Cursor XCreateGlyphCursor(
+    Display*		/* display */,
+    Font		/* source_font */,
+    Font		/* mask_font */,
+    unsigned int	/* source_char */,
+    unsigned int	/* mask_char */,
+    XColor _Xconst *	/* foreground_color */,
+    XColor _Xconst *	/* background_color */
+);
+extern Cursor XCreateFontCursor(
+    Display*		/* display */,
+    unsigned int	/* shape */
+);
+extern Font XLoadFont(
+    Display*		/* display */,
+    _Xconst char*	/* name */
+);
+extern GC XCreateGC(
+    Display*		/* display */,
+    Drawable		/* d */,
+    unsigned long	/* valuemask */,
+    XGCValues*		/* values */
+);
+extern GContext XGContextFromGC(
+    GC			/* gc */
+);
+extern void XFlushGC(
+    Display*		/* display */,
+    GC			/* gc */
+);
+extern Pixmap XCreatePixmap(
+    Display*		/* display */,
+    Drawable		/* d */,
+    unsigned int	/* width */,
+    unsigned int	/* height */,
+    unsigned int	/* depth */
+);
+extern Pixmap XCreateBitmapFromData(
+    Display*		/* display */,
+    Drawable		/* d */,
+    _Xconst char*	/* data */,
+    unsigned int	/* width */,
+    unsigned int	/* height */
+);
+extern Pixmap XCreatePixmapFromBitmapData(
+    Display*		/* display */,
+    Drawable		/* d */,
+    char*		/* data */,
+    unsigned int	/* width */,
+    unsigned int	/* height */,
+    unsigned long	/* fg */,
+    unsigned long	/* bg */,
+    unsigned int	/* depth */
+);
+extern Window XCreateSimpleWindow(
+    Display*		/* display */,
+    Window		/* parent */,
+    int			/* x */,
+    int			/* y */,
+    unsigned int	/* width */,
+    unsigned int	/* height */,
+    unsigned int	/* border_width */,
+    unsigned long	/* border */,
+    unsigned long	/* background */
+);
+extern Window XGetSelectionOwner(
+    Display*		/* display */,
+    Atom		/* selection */
+);
+extern Window XCreateWindow(
+    Display*		/* display */,
+    Window		/* parent */,
+    int			/* x */,
+    int			/* y */,
+    unsigned int	/* width */,
+    unsigned int	/* height */,
+    unsigned int	/* border_width */,
+    int			/* depth */,
+    unsigned int	/* class */,
+    Visual*		/* visual */,
+    unsigned long	/* valuemask */,
+    XSetWindowAttributes*	/* attributes */
+);
+extern Colormap *XListInstalledColormaps(
+    Display*		/* display */,
+    Window		/* w */,
+    int*		/* num_return */
+);
+extern char **XListFonts(
+    Display*		/* display */,
+    _Xconst char*	/* pattern */,
+    int			/* maxnames */,
+    int*		/* actual_count_return */
+);
+extern char **XListFontsWithInfo(
+    Display*		/* display */,
+    _Xconst char*	/* pattern */,
+    int			/* maxnames */,
+    int*		/* count_return */,
+    XFontStruct**	/* info_return */
+);
+extern char **XGetFontPath(
+    Display*		/* display */,
+    int*		/* npaths_return */
+);
+extern char **XListExtensions(
+    Display*		/* display */,
+    int*		/* nextensions_return */
+);
+extern Atom *XListProperties(
+    Display*		/* display */,
+    Window		/* w */,
+    int*		/* num_prop_return */
+);
+extern XHostAddress *XListHosts(
+    Display*		/* display */,
+    int*		/* nhosts_return */,
+    Bool*		/* state_return */
+);
+
+/* this is marked as_X_DEPRECATED in Xorg's upstream libX11 but NX
+   needs it for performance reasons. Should be moved into the
+   server. */
+extern KeySym XKeycodeToKeysym(
+    Display*		/* display */,
+#if NeedWidePrototypes
+    unsigned int	/* keycode */,
+#else
+    KeyCode		/* keycode */,
+#endif
+    int			/* index */
+);
+extern KeySym XLookupKeysym(
+    XKeyEvent*		/* key_event */,
+    int			/* index */
+);
+extern KeySym *XGetKeyboardMapping(
+    Display*		/* display */,
+#if NeedWidePrototypes
+    unsigned int	/* first_keycode */,
+#else
+    KeyCode		/* first_keycode */,
+#endif
+    int			/* keycode_count */,
+    int*		/* keysyms_per_keycode_return */
+);
+extern KeySym XStringToKeysym(
+    _Xconst char*	/* string */
+);
+extern long XMaxRequestSize(
+    Display*		/* display */
+);
+extern long XExtendedMaxRequestSize(
+    Display*		/* display */
+);
+extern char *XResourceManagerString(
+    Display*		/* display */
+);
+extern char *XScreenResourceString(
+	Screen*		/* screen */
+);
+extern unsigned long XDisplayMotionBufferSize(
+    Display*		/* display */
+);
+extern VisualID XVisualIDFromVisual(
+    Visual*		/* visual */
+);
+
+/* multithread routines */
+
+extern Status XInitThreads(
+    void
+);
+
+extern void XLockDisplay(
+    Display*		/* display */
+);
+
+extern void XUnlockDisplay(
+    Display*		/* display */
+);
+
+/* routines for dealing with extensions */
+
+extern XExtCodes *XInitExtension(
+    Display*		/* display */,
+    _Xconst char*	/* name */
+);
+
+extern XExtCodes *XAddExtension(
+    Display*		/* display */
+);
+extern XExtData *XFindOnExtensionList(
+    XExtData**		/* structure */,
+    int			/* number */
+);
+extern XExtData **XEHeadOfExtensionList(
+    XEDataObject	/* object */
+);
+
+/* these are routines for which there are also macros */
+extern Window XRootWindow(
+    Display*		/* display */,
+    int			/* screen_number */
+);
+extern Window XDefaultRootWindow(
+    Display*		/* display */
+);
+extern Window XRootWindowOfScreen(
+    Screen*		/* screen */
+);
+extern Visual *XDefaultVisual(
+    Display*		/* display */,
+    int			/* screen_number */
+);
+extern Visual *XDefaultVisualOfScreen(
+    Screen*		/* screen */
+);
+extern GC XDefaultGC(
+    Display*		/* display */,
+    int			/* screen_number */
+);
+extern GC XDefaultGCOfScreen(
+    Screen*		/* screen */
+);
+extern unsigned long XBlackPixel(
+    Display*		/* display */,
+    int			/* screen_number */
+);
+extern unsigned long XWhitePixel(
+    Display*		/* display */,
+    int			/* screen_number */
+);
+extern unsigned long XAllPlanes(
+    void
+);
+extern unsigned long XBlackPixelOfScreen(
+    Screen*		/* screen */
+);
+extern unsigned long XWhitePixelOfScreen(
+    Screen*		/* screen */
+);
+extern unsigned long XNextRequest(
+    Display*		/* display */
+);
+extern unsigned long XLastKnownRequestProcessed(
+    Display*		/* display */
+);
+extern char *XServerVendor(
+    Display*		/* display */
+);
+extern char *XDisplayString(
+    Display*		/* display */
+);
+extern Colormap XDefaultColormap(
+    Display*		/* display */,
+    int			/* screen_number */
+);
+extern Colormap XDefaultColormapOfScreen(
+    Screen*		/* screen */
+);
+extern Display *XDisplayOfScreen(
+    Screen*		/* screen */
+);
+extern Screen *XScreenOfDisplay(
+    Display*		/* display */,
+    int			/* screen_number */
+);
+extern Screen *XDefaultScreenOfDisplay(
+    Display*		/* display */
+);
+extern long XEventMaskOfScreen(
+    Screen*		/* screen */
+);
+
+extern int XScreenNumberOfScreen(
+    Screen*		/* screen */
+);
+
+typedef int (*XErrorHandler) (	    /* WARNING, this type not in Xlib spec */
+    Display*		/* display */,
+    XErrorEvent*	/* error_event */
+);
+
+extern XErrorHandler XSetErrorHandler (
+    XErrorHandler	/* handler */
+);
+
+
+typedef int (*XIOErrorHandler) (    /* WARNING, this type not in Xlib spec */
+    Display*		/* display */
+);
+
+extern XIOErrorHandler XSetIOErrorHandler (
+    XIOErrorHandler	/* handler */
+);
+
+
+extern XPixmapFormatValues *XListPixmapFormats(
+    Display*		/* display */,
+    int*		/* count_return */
+);
+extern int *XListDepths(
+    Display*		/* display */,
+    int			/* screen_number */,
+    int*		/* count_return */
+);
+
+/* ICCCM routines for things that don't require special include files; */
+/* other declarations are given in Xutil.h                             */
+extern Status XReconfigureWMWindow(
+    Display*		/* display */,
+    Window		/* w */,
+    int			/* screen_number */,
+    unsigned int	/* mask */,
+    XWindowChanges*	/* changes */
+);
+
+extern Status XGetWMProtocols(
+    Display*		/* display */,
+    Window		/* w */,
+    Atom**		/* protocols_return */,
+    int*		/* count_return */
+);
+extern Status XSetWMProtocols(
+    Display*		/* display */,
+    Window		/* w */,
+    Atom*		/* protocols */,
+    int			/* count */
+);
+extern Status XIconifyWindow(
+    Display*		/* display */,
+    Window		/* w */,
+    int			/* screen_number */
+);
+extern Status XWithdrawWindow(
+    Display*		/* display */,
+    Window		/* w */,
+    int			/* screen_number */
+);
+extern Status XGetCommand(
+    Display*		/* display */,
+    Window		/* w */,
+    char***		/* argv_return */,
+    int*		/* argc_return */
+);
+extern Status XGetWMColormapWindows(
+    Display*		/* display */,
+    Window		/* w */,
+    Window**		/* windows_return */,
+    int*		/* count_return */
+);
+extern Status XSetWMColormapWindows(
+    Display*		/* display */,
+    Window		/* w */,
+    Window*		/* colormap_windows */,
+    int			/* count */
+);
+extern void XFreeStringList(
+    char**		/* list */
+);
+extern int XSetTransientForHint(
+    Display*		/* display */,
+    Window		/* w */,
+    Window		/* prop_window */
+);
+
+/* The following are given in alphabetical order */
+
+extern int XActivateScreenSaver(
+    Display*		/* display */
+);
+
+extern int XAddHost(
+    Display*		/* display */,
+    XHostAddress*	/* host */
+);
+
+extern int XAddHosts(
+    Display*		/* display */,
+    XHostAddress*	/* hosts */,
+    int			/* num_hosts */
+);
+
+extern int XAddToExtensionList(
+    struct _XExtData**	/* structure */,
+    XExtData*		/* ext_data */
+);
+
+extern int XAddToSaveSet(
+    Display*		/* display */,
+    Window		/* w */
+);
+
+extern Status XAllocColor(
+    Display*		/* display */,
+    Colormap		/* colormap */,
+    XColor*		/* screen_in_out */
+);
+
+extern Status XAllocColorCells(
+    Display*		/* display */,
+    Colormap		/* colormap */,
+    Bool	        /* contig */,
+    unsigned long*	/* plane_masks_return */,
+    unsigned int	/* nplanes */,
+    unsigned long*	/* pixels_return */,
+    unsigned int 	/* npixels */
+);
+
+extern Status XAllocColorPlanes(
+    Display*		/* display */,
+    Colormap		/* colormap */,
+    Bool		/* contig */,
+    unsigned long*	/* pixels_return */,
+    int			/* ncolors */,
+    int			/* nreds */,
+    int			/* ngreens */,
+    int			/* nblues */,
+    unsigned long*	/* rmask_return */,
+    unsigned long*	/* gmask_return */,
+    unsigned long*	/* bmask_return */
+);
+
+extern Status XAllocNamedColor(
+    Display*		/* display */,
+    Colormap		/* colormap */,
+    _Xconst char*	/* color_name */,
+    XColor*		/* screen_def_return */,
+    XColor*		/* exact_def_return */
+);
+
+extern int XAllowEvents(
+    Display*		/* display */,
+    int			/* event_mode */,
+    Time		/* time */
+);
+
+extern int XAutoRepeatOff(
+    Display*		/* display */
+);
+
+extern int XAutoRepeatOn(
+    Display*		/* display */
+);
+
+extern int XBell(
+    Display*		/* display */,
+    int			/* percent */
+);
+
+extern int XBitmapBitOrder(
+    Display*		/* display */
+);
+
+extern int XBitmapPad(
+    Display*		/* display */
+);
+
+extern int XBitmapUnit(
+    Display*		/* display */
+);
+
+extern int XCellsOfScreen(
+    Screen*		/* screen */
+);
+
+extern int XChangeActivePointerGrab(
+    Display*		/* display */,
+    unsigned int	/* event_mask */,
+    Cursor		/* cursor */,
+    Time		/* time */
+);
+
+extern int XChangeGC(
+    Display*		/* display */,
+    GC			/* gc */,
+    unsigned long	/* valuemask */,
+    XGCValues*		/* values */
+);
+
+extern int XChangeKeyboardControl(
+    Display*		/* display */,
+    unsigned long	/* value_mask */,
+    XKeyboardControl*	/* values */
+);
+
+extern int XChangeKeyboardMapping(
+    Display*		/* display */,
+    int			/* first_keycode */,
+    int			/* keysyms_per_keycode */,
+    KeySym*		/* keysyms */,
+    int			/* num_codes */
+);
+
+extern int XChangePointerControl(
+    Display*		/* display */,
+    Bool		/* do_accel */,
+    Bool		/* do_threshold */,
+    int			/* accel_numerator */,
+    int			/* accel_denominator */,
+    int			/* threshold */
+);
+
+extern int XChangeProperty(
+    Display*		/* display */,
+    Window		/* w */,
+    Atom		/* property */,
+    Atom		/* type */,
+    int			/* format */,
+    int			/* mode */,
+    _Xconst unsigned char*	/* data */,
+    int			/* nelements */
+);
+
+extern int XChangeSaveSet(
+    Display*		/* display */,
+    Window		/* w */,
+    int			/* change_mode */
+);
+
+extern int XChangeWindowAttributes(
+    Display*		/* display */,
+    Window		/* w */,
+    unsigned long	/* valuemask */,
+    XSetWindowAttributes* /* attributes */
+);
+
+extern Bool XCheckIfEvent(
+    Display*		/* display */,
+    XEvent*		/* event_return */,
+    Bool (*) (
+	       Display*			/* display */,
+               XEvent*			/* event */,
+               XPointer			/* arg */
+             )		/* predicate */,
+    XPointer		/* arg */
+);
+
+#ifdef NX_TRANS_SOCKET
+
+/*
+ * This is just like XCheckIfEvent() but doesn't
+ * flush the output buffer if it can't read new
+ * events.
+ */
+
+extern Bool XCheckIfEventNoFlush(
+    Display*		/* display */,
+    XEvent*		/* event_return */,
+    Bool (*) (
+	       Display*			/* display */,
+               XEvent*			/* event */,
+               XPointer			/* arg */
+             )		/* predicate */,
+    XPointer		/* arg */
+);
+
+#endif
+
+extern Bool XCheckMaskEvent(
+    Display*		/* display */,
+    long		/* event_mask */,
+    XEvent*		/* event_return */
+);
+
+extern Bool XCheckTypedEvent(
+    Display*		/* display */,
+    int			/* event_type */,
+    XEvent*		/* event_return */
+);
+
+extern Bool XCheckTypedWindowEvent(
+    Display*		/* display */,
+    Window		/* w */,
+    int			/* event_type */,
+    XEvent*		/* event_return */
+);
+
+extern Bool XCheckWindowEvent(
+    Display*		/* display */,
+    Window		/* w */,
+    long		/* event_mask */,
+    XEvent*		/* event_return */
+);
+
+extern int XCirculateSubwindows(
+    Display*		/* display */,
+    Window		/* w */,
+    int			/* direction */
+);
+
+extern int XCirculateSubwindowsDown(
+    Display*		/* display */,
+    Window		/* w */
+);
+
+extern int XCirculateSubwindowsUp(
+    Display*		/* display */,
+    Window		/* w */
+);
+
+extern int XClearArea(
+    Display*		/* display */,
+    Window		/* w */,
+    int			/* x */,
+    int			/* y */,
+    unsigned int	/* width */,
+    unsigned int	/* height */,
+    Bool		/* exposures */
+);
+
+extern int XClearWindow(
+    Display*		/* display */,
+    Window		/* w */
+);
+
+extern int XCloseDisplay(
+    Display*		/* display */
+);
+
+extern int XConfigureWindow(
+    Display*		/* display */,
+    Window		/* w */,
+    unsigned int	/* value_mask */,
+    XWindowChanges*	/* values */
+);
+
+extern int XConnectionNumber(
+    Display*		/* display */
+);
+
+extern int XConvertSelection(
+    Display*		/* display */,
+    Atom		/* selection */,
+    Atom 		/* target */,
+    Atom		/* property */,
+    Window		/* requestor */,
+    Time		/* time */
+);
+
+extern int XCopyArea(
+    Display*		/* display */,
+    Drawable		/* src */,
+    Drawable		/* dest */,
+    GC			/* gc */,
+    int			/* src_x */,
+    int			/* src_y */,
+    unsigned int	/* width */,
+    unsigned int	/* height */,
+    int			/* dest_x */,
+    int			/* dest_y */
+);
+
+extern int XCopyGC(
+    Display*		/* display */,
+    GC			/* src */,
+    unsigned long	/* valuemask */,
+    GC			/* dest */
+);
+
+extern int XCopyPlane(
+    Display*		/* display */,
+    Drawable		/* src */,
+    Drawable		/* dest */,
+    GC			/* gc */,
+    int			/* src_x */,
+    int			/* src_y */,
+    unsigned int	/* width */,
+    unsigned int	/* height */,
+    int			/* dest_x */,
+    int			/* dest_y */,
+    unsigned long	/* plane */
+);
+
+extern int XDefaultDepth(
+    Display*		/* display */,
+    int			/* screen_number */
+);
+
+extern int XDefaultDepthOfScreen(
+    Screen*		/* screen */
+);
+
+extern int XDefaultScreen(
+    Display*		/* display */
+);
+
+extern int XDefineCursor(
+    Display*		/* display */,
+    Window		/* w */,
+    Cursor		/* cursor */
+);
+
+extern int XDeleteProperty(
+    Display*		/* display */,
+    Window		/* w */,
+    Atom		/* property */
+);
+
+extern int XDestroyWindow(
+    Display*		/* display */,
+    Window		/* w */
+);
+
+extern int XDestroySubwindows(
+    Display*		/* display */,
+    Window		/* w */
+);
+
+extern int XDoesBackingStore(
+    Screen*		/* screen */
+);
+
+extern Bool XDoesSaveUnders(
+    Screen*		/* screen */
+);
+
+extern int XDisableAccessControl(
+    Display*		/* display */
+);
+
+
+extern int XDisplayCells(
+    Display*		/* display */,
+    int			/* screen_number */
+);
+
+extern int XDisplayHeight(
+    Display*		/* display */,
+    int			/* screen_number */
+);
+
+extern int XDisplayHeightMM(
+    Display*		/* display */,
+    int			/* screen_number */
+);
+
+extern int XDisplayKeycodes(
+    Display*		/* display */,
+    int*		/* min_keycodes_return */,
+    int*		/* max_keycodes_return */
+);
+
+extern int XDisplayPlanes(
+    Display*		/* display */,
+    int			/* screen_number */
+);
+
+extern int XDisplayWidth(
+    Display*		/* display */,
+    int			/* screen_number */
+);
+
+extern int XDisplayWidthMM(
+    Display*		/* display */,
+    int			/* screen_number */
+);
+
+extern int XDrawArc(
+    Display*		/* display */,
+    Drawable		/* d */,
+    GC			/* gc */,
+    int			/* x */,
+    int			/* y */,
+    unsigned int	/* width */,
+    unsigned int	/* height */,
+    int			/* angle1 */,
+    int			/* angle2 */
+);
+
+extern int XDrawArcs(
+    Display*		/* display */,
+    Drawable		/* d */,
+    GC			/* gc */,
+    XArc*		/* arcs */,
+    int			/* narcs */
+);
+
+extern int XDrawImageString(
+    Display*		/* display */,
+    Drawable		/* d */,
+    GC			/* gc */,
+    int			/* x */,
+    int			/* y */,
+    _Xconst char*	/* string */,
+    int			/* length */
+);
+
+extern int XDrawImageString16(
+    Display*		/* display */,
+    Drawable		/* d */,
+    GC			/* gc */,
+    int			/* x */,
+    int			/* y */,
+    _Xconst XChar2b*	/* string */,
+    int			/* length */
+);
+
+extern int XDrawLine(
+    Display*		/* display */,
+    Drawable		/* d */,
+    GC			/* gc */,
+    int			/* x1 */,
+    int			/* y1 */,
+    int			/* x2 */,
+    int			/* y2 */
+);
+
+extern int XDrawLines(
+    Display*		/* display */,
+    Drawable		/* d */,
+    GC			/* gc */,
+    XPoint*		/* points */,
+    int			/* npoints */,
+    int			/* mode */
+);
+
+extern int XDrawPoint(
+    Display*		/* display */,
+    Drawable		/* d */,
+    GC			/* gc */,
+    int			/* x */,
+    int			/* y */
+);
+
+extern int XDrawPoints(
+    Display*		/* display */,
+    Drawable		/* d */,
+    GC			/* gc */,
+    XPoint*		/* points */,
+    int			/* npoints */,
+    int			/* mode */
+);
+
+extern int XDrawRectangle(
+    Display*		/* display */,
+    Drawable		/* d */,
+    GC			/* gc */,
+    int			/* x */,
+    int			/* y */,
+    unsigned int	/* width */,
+    unsigned int	/* height */
+);
+
+extern int XDrawRectangles(
+    Display*		/* display */,
+    Drawable		/* d */,
+    GC			/* gc */,
+    XRectangle*		/* rectangles */,
+    int			/* nrectangles */
+);
+
+extern int XDrawSegments(
+    Display*		/* display */,
+    Drawable		/* d */,
+    GC			/* gc */,
+    XSegment*		/* segments */,
+    int			/* nsegments */
+);
+
+extern int XDrawString(
+    Display*		/* display */,
+    Drawable		/* d */,
+    GC			/* gc */,
+    int			/* x */,
+    int			/* y */,
+    _Xconst char*	/* string */,
+    int			/* length */
+);
+
+extern int XDrawString16(
+    Display*		/* display */,
+    Drawable		/* d */,
+    GC			/* gc */,
+    int			/* x */,
+    int			/* y */,
+    _Xconst XChar2b*	/* string */,
+    int			/* length */
+);
+
+extern int XDrawText(
+    Display*		/* display */,
+    Drawable		/* d */,
+    GC			/* gc */,
+    int			/* x */,
+    int			/* y */,
+    XTextItem*		/* items */,
+    int			/* nitems */
+);
+
+extern int XDrawText16(
+    Display*		/* display */,
+    Drawable		/* d */,
+    GC			/* gc */,
+    int			/* x */,
+    int			/* y */,
+    XTextItem16*	/* items */,
+    int			/* nitems */
+);
+
+extern int XEnableAccessControl(
+    Display*		/* display */
+);
+
+extern int XEventsQueued(
+    Display*		/* display */,
+    int			/* mode */
+);
+
+extern Status XFetchName(
+    Display*		/* display */,
+    Window		/* w */,
+    char**		/* window_name_return */
+);
+
+extern int XFillArc(
+    Display*		/* display */,
+    Drawable		/* d */,
+    GC			/* gc */,
+    int			/* x */,
+    int			/* y */,
+    unsigned int	/* width */,
+    unsigned int	/* height */,
+    int			/* angle1 */,
+    int			/* angle2 */
+);
+
+extern int XFillArcs(
+    Display*		/* display */,
+    Drawable		/* d */,
+    GC			/* gc */,
+    XArc*		/* arcs */,
+    int			/* narcs */
+);
+
+extern int XFillPolygon(
+    Display*		/* display */,
+    Drawable		/* d */,
+    GC			/* gc */,
+    XPoint*		/* points */,
+    int			/* npoints */,
+    int			/* shape */,
+    int			/* mode */
+);
+
+extern int XFillRectangle(
+    Display*		/* display */,
+    Drawable		/* d */,
+    GC			/* gc */,
+    int			/* x */,
+    int			/* y */,
+    unsigned int	/* width */,
+    unsigned int	/* height */
+);
+
+extern int XFillRectangles(
+    Display*		/* display */,
+    Drawable		/* d */,
+    GC			/* gc */,
+    XRectangle*		/* rectangles */,
+    int			/* nrectangles */
+);
+
+extern int XFlush(
+    Display*		/* display */
+);
+
+extern int XForceScreenSaver(
+    Display*		/* display */,
+    int			/* mode */
+);
+
+extern int XFree(
+    void*		/* data */
+);
+
+extern int XFreeColormap(
+    Display*		/* display */,
+    Colormap		/* colormap */
+);
+
+extern int XFreeColors(
+    Display*		/* display */,
+    Colormap		/* colormap */,
+    unsigned long*	/* pixels */,
+    int			/* npixels */,
+    unsigned long	/* planes */
+);
+
+extern int XFreeCursor(
+    Display*		/* display */,
+    Cursor		/* cursor */
+);
+
+extern int XFreeExtensionList(
+    char**		/* list */
+);
+
+extern int XFreeFont(
+    Display*		/* display */,
+    XFontStruct*	/* font_struct */
+);
+
+extern int XFreeFontInfo(
+    char**		/* names */,
+    XFontStruct*	/* free_info */,
+    int			/* actual_count */
+);
+
+extern int XFreeFontNames(
+    char**		/* list */
+);
+
+extern int XFreeFontPath(
+    char**		/* list */
+);
+
+extern int XFreeGC(
+    Display*		/* display */,
+    GC			/* gc */
+);
+
+extern int XFreeModifiermap(
+    XModifierKeymap*	/* modmap */
+);
+
+extern int XFreePixmap(
+    Display*		/* display */,
+    Pixmap		/* pixmap */
+);
+
+extern int XGeometry(
+    Display*		/* display */,
+    int			/* screen */,
+    _Xconst char*	/* position */,
+    _Xconst char*	/* default_position */,
+    unsigned int	/* bwidth */,
+    unsigned int	/* fwidth */,
+    unsigned int	/* fheight */,
+    int			/* xadder */,
+    int			/* yadder */,
+    int*		/* x_return */,
+    int*		/* y_return */,
+    int*		/* width_return */,
+    int*		/* height_return */
+);
+
+extern int XGetErrorDatabaseText(
+    Display*		/* display */,
+    _Xconst char*	/* name */,
+    _Xconst char*	/* message */,
+    _Xconst char*	/* default_string */,
+    char*		/* buffer_return */,
+    int			/* length */
+);
+
+extern int XGetErrorText(
+    Display*		/* display */,
+    int			/* code */,
+    char*		/* buffer_return */,
+    int			/* length */
+);
+
+extern Bool XGetFontProperty(
+    XFontStruct*	/* font_struct */,
+    Atom		/* atom */,
+    unsigned long*	/* value_return */
+);
+
+extern Status XGetGCValues(
+    Display*		/* display */,
+    GC			/* gc */,
+    unsigned long	/* valuemask */,
+    XGCValues*		/* values_return */
+);
+
+extern Status XGetGeometry(
+    Display*		/* display */,
+    Drawable		/* d */,
+    Window*		/* root_return */,
+    int*		/* x_return */,
+    int*		/* y_return */,
+    unsigned int*	/* width_return */,
+    unsigned int*	/* height_return */,
+    unsigned int*	/* border_width_return */,
+    unsigned int*	/* depth_return */
+);
+
+extern Status XGetIconName(
+    Display*		/* display */,
+    Window		/* w */,
+    char**		/* icon_name_return */
+);
+
+extern int XGetInputFocus(
+    Display*		/* display */,
+    Window*		/* focus_return */,
+    int*		/* revert_to_return */
+);
+
+extern int XGetKeyboardControl(
+    Display*		/* display */,
+    XKeyboardState*	/* values_return */
+);
+
+extern int XGetPointerControl(
+    Display*		/* display */,
+    int*		/* accel_numerator_return */,
+    int*		/* accel_denominator_return */,
+    int*		/* threshold_return */
+);
+
+extern int XGetPointerMapping(
+    Display*		/* display */,
+    unsigned char*	/* map_return */,
+    int			/* nmap */
+);
+
+extern int XGetScreenSaver(
+    Display*		/* display */,
+    int*		/* timeout_return */,
+    int*		/* interval_return */,
+    int*		/* prefer_blanking_return */,
+    int*		/* allow_exposures_return */
+);
+
+extern Status XGetTransientForHint(
+    Display*		/* display */,
+    Window		/* w */,
+    Window*		/* prop_window_return */
+);
+
+extern int XGetWindowProperty(
+    Display*		/* display */,
+    Window		/* w */,
+    Atom		/* property */,
+    long		/* long_offset */,
+    long		/* long_length */,
+    Bool		/* delete */,
+    Atom		/* req_type */,
+    Atom*		/* actual_type_return */,
+    int*		/* actual_format_return */,
+    unsigned long*	/* nitems_return */,
+    unsigned long*	/* bytes_after_return */,
+    unsigned char**	/* prop_return */
+);
+
+extern Status XGetWindowAttributes(
+    Display*		/* display */,
+    Window		/* w */,
+    XWindowAttributes*	/* window_attributes_return */
+);
+
+extern int XGrabButton(
+    Display*		/* display */,
+    unsigned int	/* button */,
+    unsigned int	/* modifiers */,
+    Window		/* grab_window */,
+    Bool		/* owner_events */,
+    unsigned int	/* event_mask */,
+    int			/* pointer_mode */,
+    int			/* keyboard_mode */,
+    Window		/* confine_to */,
+    Cursor		/* cursor */
+);
+
+extern int XGrabKey(
+    Display*		/* display */,
+    int			/* keycode */,
+    unsigned int	/* modifiers */,
+    Window		/* grab_window */,
+    Bool		/* owner_events */,
+    int			/* pointer_mode */,
+    int			/* keyboard_mode */
+);
+
+extern int XGrabKeyboard(
+    Display*		/* display */,
+    Window		/* grab_window */,
+    Bool		/* owner_events */,
+    int			/* pointer_mode */,
+    int			/* keyboard_mode */,
+    Time		/* time */
+);
+
+extern int XGrabPointer(
+    Display*		/* display */,
+    Window		/* grab_window */,
+    Bool		/* owner_events */,
+    unsigned int	/* event_mask */,
+    int			/* pointer_mode */,
+    int			/* keyboard_mode */,
+    Window		/* confine_to */,
+    Cursor		/* cursor */,
+    Time		/* time */
+);
+
+extern int XGrabServer(
+    Display*		/* display */
+);
+
+extern int XHeightMMOfScreen(
+    Screen*		/* screen */
+);
+
+extern int XHeightOfScreen(
+    Screen*		/* screen */
+);
+
+extern int XIfEvent(
+    Display*		/* display */,
+    XEvent*		/* event_return */,
+    Bool (*) (
+	       Display*			/* display */,
+               XEvent*			/* event */,
+               XPointer			/* arg */
+             )		/* predicate */,
+    XPointer		/* arg */
+);
+
+extern int XImageByteOrder(
+    Display*		/* display */
+);
+
+extern int XInstallColormap(
+    Display*		/* display */,
+    Colormap		/* colormap */
+);
+
+extern KeyCode XKeysymToKeycode(
+    Display*		/* display */,
+    KeySym		/* keysym */
+);
+
+extern int XKillClient(
+    Display*		/* display */,
+    XID			/* resource */
+);
+
+extern Status XLookupColor(
+    Display*		/* display */,
+    Colormap		/* colormap */,
+    _Xconst char*	/* color_name */,
+    XColor*		/* exact_def_return */,
+    XColor*		/* screen_def_return */
+);
+
+extern int XLowerWindow(
+    Display*		/* display */,
+    Window		/* w */
+);
+
+extern int XMapRaised(
+    Display*		/* display */,
+    Window		/* w */
+);
+
+extern int XMapSubwindows(
+    Display*		/* display */,
+    Window		/* w */
+);
+
+extern int XMapWindow(
+    Display*		/* display */,
+    Window		/* w */
+);
+
+extern int XMaskEvent(
+    Display*		/* display */,
+    long		/* event_mask */,
+    XEvent*		/* event_return */
+);
+
+extern int XMaxCmapsOfScreen(
+    Screen*		/* screen */
+);
+
+extern int XMinCmapsOfScreen(
+    Screen*		/* screen */
+);
+
+extern int XMoveResizeWindow(
+    Display*		/* display */,
+    Window		/* w */,
+    int			/* x */,
+    int			/* y */,
+    unsigned int	/* width */,
+    unsigned int	/* height */
+);
+
+extern int XMoveWindow(
+    Display*		/* display */,
+    Window		/* w */,
+    int			/* x */,
+    int			/* y */
+);
+
+extern int XNextEvent(
+    Display*		/* display */,
+    XEvent*		/* event_return */
+);
+
+extern int XNoOp(
+    Display*		/* display */
+);
+
+extern Status XParseColor(
+    Display*		/* display */,
+    Colormap		/* colormap */,
+    _Xconst char*	/* spec */,
+    XColor*		/* exact_def_return */
+);
+
+extern int XParseGeometry(
+    _Xconst char*	/* parsestring */,
+    int*		/* x_return */,
+    int*		/* y_return */,
+    unsigned int*	/* width_return */,
+    unsigned int*	/* height_return */
+);
+
+extern int XPeekEvent(
+    Display*		/* display */,
+    XEvent*		/* event_return */
+);
+
+extern int XPeekIfEvent(
+    Display*		/* display */,
+    XEvent*		/* event_return */,
+    Bool (*) (
+	       Display*		/* display */,
+               XEvent*		/* event */,
+               XPointer		/* arg */
+             )		/* predicate */,
+    XPointer		/* arg */
+);
+
+extern int XPending(
+    Display*		/* display */
+);
+
+extern int XPlanesOfScreen(
+    Screen*		/* screen */
+);
+
+extern int XProtocolRevision(
+    Display*		/* display */
+);
+
+extern int XProtocolVersion(
+    Display*		/* display */
+);
+
+
+extern int XPutBackEvent(
+    Display*		/* display */,
+    XEvent*		/* event */
+);
+
+extern int XPutImage(
+    Display*		/* display */,
+    Drawable		/* d */,
+    GC			/* gc */,
+    XImage*		/* image */,
+    int			/* src_x */,
+    int			/* src_y */,
+    int			/* dest_x */,
+    int			/* dest_y */,
+    unsigned int	/* width */,
+    unsigned int	/* height */
+);
+
+extern int XQLength(
+    Display*		/* display */
+);
+
+extern Status XQueryBestCursor(
+    Display*		/* display */,
+    Drawable		/* d */,
+    unsigned int        /* width */,
+    unsigned int	/* height */,
+    unsigned int*	/* width_return */,
+    unsigned int*	/* height_return */
+);
+
+extern Status XQueryBestSize(
+    Display*		/* display */,
+    int			/* class */,
+    Drawable		/* which_screen */,
+    unsigned int	/* width */,
+    unsigned int	/* height */,
+    unsigned int*	/* width_return */,
+    unsigned int*	/* height_return */
+);
+
+extern Status XQueryBestStipple(
+    Display*		/* display */,
+    Drawable		/* which_screen */,
+    unsigned int	/* width */,
+    unsigned int	/* height */,
+    unsigned int*	/* width_return */,
+    unsigned int*	/* height_return */
+);
+
+extern Status XQueryBestTile(
+    Display*		/* display */,
+    Drawable		/* which_screen */,
+    unsigned int	/* width */,
+    unsigned int	/* height */,
+    unsigned int*	/* width_return */,
+    unsigned int*	/* height_return */
+);
+
+extern int XQueryColor(
+    Display*		/* display */,
+    Colormap		/* colormap */,
+    XColor*		/* def_in_out */
+);
+
+extern int XQueryColors(
+    Display*		/* display */,
+    Colormap		/* colormap */,
+    XColor*		/* defs_in_out */,
+    int			/* ncolors */
+);
+
+extern Bool XQueryExtension(
+    Display*		/* display */,
+    _Xconst char*	/* name */,
+    int*		/* major_opcode_return */,
+    int*		/* first_event_return */,
+    int*		/* first_error_return */
+);
+
+extern int XQueryKeymap(
+    Display*		/* display */,
+    char [32]		/* keys_return */
+);
+
+extern Bool XQueryPointer(
+    Display*		/* display */,
+    Window		/* w */,
+    Window*		/* root_return */,
+    Window*		/* child_return */,
+    int*		/* root_x_return */,
+    int*		/* root_y_return */,
+    int*		/* win_x_return */,
+    int*		/* win_y_return */,
+    unsigned int*       /* mask_return */
+);
+
+extern int XQueryTextExtents(
+    Display*		/* display */,
+    XID			/* font_ID */,
+    _Xconst char*	/* string */,
+    int			/* nchars */,
+    int*		/* direction_return */,
+    int*		/* font_ascent_return */,
+    int*		/* font_descent_return */,
+    XCharStruct*	/* overall_return */
+);
+
+extern int XQueryTextExtents16(
+    Display*		/* display */,
+    XID			/* font_ID */,
+    _Xconst XChar2b*	/* string */,
+    int			/* nchars */,
+    int*		/* direction_return */,
+    int*		/* font_ascent_return */,
+    int*		/* font_descent_return */,
+    XCharStruct*	/* overall_return */
+);
+
+extern Status XQueryTree(
+    Display*		/* display */,
+    Window		/* w */,
+    Window*		/* root_return */,
+    Window*		/* parent_return */,
+    Window**		/* children_return */,
+    unsigned int*	/* nchildren_return */
+);
+
+extern int XRaiseWindow(
+    Display*		/* display */,
+    Window		/* w */
+);
+
+extern int XReadBitmapFile(
+    Display*		/* display */,
+    Drawable 		/* d */,
+    _Xconst char*	/* filename */,
+    unsigned int*	/* width_return */,
+    unsigned int*	/* height_return */,
+    Pixmap*		/* bitmap_return */,
+    int*		/* x_hot_return */,
+    int*		/* y_hot_return */
+);
+
+extern int XReadBitmapFileData(
+    _Xconst char*	/* filename */,
+    unsigned int*	/* width_return */,
+    unsigned int*	/* height_return */,
+    unsigned char**	/* data_return */,
+    int*		/* x_hot_return */,
+    int*		/* y_hot_return */
+);
+
+extern int XRebindKeysym(
+    Display*		/* display */,
+    KeySym		/* keysym */,
+    KeySym*		/* list */,
+    int			/* mod_count */,
+    _Xconst unsigned char*	/* string */,
+    int			/* bytes_string */
+);
+
+extern int XRecolorCursor(
+    Display*		/* display */,
+    Cursor		/* cursor */,
+    XColor*		/* foreground_color */,
+    XColor*		/* background_color */
+);
+
+extern int XRefreshKeyboardMapping(
+    XMappingEvent*	/* event_map */
+);
+
+extern int XRemoveFromSaveSet(
+    Display*		/* display */,
+    Window		/* w */
+);
+
+extern int XRemoveHost(
+    Display*		/* display */,
+    XHostAddress*	/* host */
+);
+
+extern int XRemoveHosts(
+    Display*		/* display */,
+    XHostAddress*	/* hosts */,
+    int			/* num_hosts */
+);
+
+extern int XReparentWindow(
+    Display*		/* display */,
+    Window		/* w */,
+    Window		/* parent */,
+    int			/* x */,
+    int			/* y */
+);
+
+extern int XResetScreenSaver(
+    Display*		/* display */
+);
+
+extern int XResizeWindow(
+    Display*		/* display */,
+    Window		/* w */,
+    unsigned int	/* width */,
+    unsigned int	/* height */
+);
+
+extern int XRestackWindows(
+    Display*		/* display */,
+    Window*		/* windows */,
+    int			/* nwindows */
+);
+
+extern int XRotateBuffers(
+    Display*		/* display */,
+    int			/* rotate */
+);
+
+extern int XRotateWindowProperties(
+    Display*		/* display */,
+    Window		/* w */,
+    Atom*		/* properties */,
+    int			/* num_prop */,
+    int			/* npositions */
+);
+
+extern int XScreenCount(
+    Display*		/* display */
+);
+
+extern int XSelectInput(
+    Display*		/* display */,
+    Window		/* w */,
+    long		/* event_mask */
+);
+
+extern Status XSendEvent(
+    Display*		/* display */,
+    Window		/* w */,
+    Bool		/* propagate */,
+    long		/* event_mask */,
+    XEvent*		/* event_send */
+);
+
+extern int XSetAccessControl(
+    Display*		/* display */,
+    int			/* mode */
+);
+
+extern int XSetArcMode(
+    Display*		/* display */,
+    GC			/* gc */,
+    int			/* arc_mode */
+);
+
+extern int XSetBackground(
+    Display*		/* display */,
+    GC			/* gc */,
+    unsigned long	/* background */
+);
+
+extern int XSetClipMask(
+    Display*		/* display */,
+    GC			/* gc */,
+    Pixmap		/* pixmap */
+);
+
+extern int XSetClipOrigin(
+    Display*		/* display */,
+    GC			/* gc */,
+    int			/* clip_x_origin */,
+    int			/* clip_y_origin */
+);
+
+extern int XSetClipRectangles(
+    Display*		/* display */,
+    GC			/* gc */,
+    int			/* clip_x_origin */,
+    int			/* clip_y_origin */,
+    XRectangle*		/* rectangles */,
+    int			/* n */,
+    int			/* ordering */
+);
+
+extern int XSetCloseDownMode(
+    Display*		/* display */,
+    int			/* close_mode */
+);
+
+extern int XSetCommand(
+    Display*		/* display */,
+    Window		/* w */,
+    char**		/* argv */,
+    int			/* argc */
+);
+
+extern int XSetDashes(
+    Display*		/* display */,
+    GC			/* gc */,
+    int			/* dash_offset */,
+    _Xconst char*	/* dash_list */,
+    int			/* n */
+);
+
+extern int XSetFillRule(
+    Display*		/* display */,
+    GC			/* gc */,
+    int			/* fill_rule */
+);
+
+extern int XSetFillStyle(
+    Display*		/* display */,
+    GC			/* gc */,
+    int			/* fill_style */
+);
+
+extern int XSetFont(
+    Display*		/* display */,
+    GC			/* gc */,
+    Font		/* font */
+);
+
+extern int XSetFontPath(
+    Display*		/* display */,
+    char**		/* directories */,
+    int			/* ndirs */
+);
+
+extern int XSetForeground(
+    Display*		/* display */,
+    GC			/* gc */,
+    unsigned long	/* foreground */
+);
+
+extern int XSetFunction(
+    Display*		/* display */,
+    GC			/* gc */,
+    int			/* function */
+);
+
+extern int XSetGraphicsExposures(
+    Display*		/* display */,
+    GC			/* gc */,
+    Bool		/* graphics_exposures */
+);
+
+extern int XSetIconName(
+    Display*		/* display */,
+    Window		/* w */,
+    _Xconst char*	/* icon_name */
+);
+
+extern int XSetInputFocus(
+    Display*		/* display */,
+    Window		/* focus */,
+    int			/* revert_to */,
+    Time		/* time */
+);
+
+extern int XSetLineAttributes(
+    Display*		/* display */,
+    GC			/* gc */,
+    unsigned int	/* line_width */,
+    int			/* line_style */,
+    int			/* cap_style */,
+    int			/* join_style */
+);
+
+extern int XSetModifierMapping(
+    Display*		/* display */,
+    XModifierKeymap*	/* modmap */
+);
+
+extern int XSetPlaneMask(
+    Display*		/* display */,
+    GC			/* gc */,
+    unsigned long	/* plane_mask */
+);
+
+extern int XSetPointerMapping(
+    Display*		/* display */,
+    _Xconst unsigned char*	/* map */,
+    int			/* nmap */
+);
+
+extern int XSetScreenSaver(
+    Display*		/* display */,
+    int			/* timeout */,
+    int			/* interval */,
+    int			/* prefer_blanking */,
+    int			/* allow_exposures */
+);
+
+extern int XSetSelectionOwner(
+    Display*		/* display */,
+    Atom	        /* selection */,
+    Window		/* owner */,
+    Time		/* time */
+);
+
+extern int XSetState(
+    Display*		/* display */,
+    GC			/* gc */,
+    unsigned long 	/* foreground */,
+    unsigned long	/* background */,
+    int			/* function */,
+    unsigned long	/* plane_mask */
+);
+
+extern int XSetStipple(
+    Display*		/* display */,
+    GC			/* gc */,
+    Pixmap		/* stipple */
+);
+
+extern int XSetSubwindowMode(
+    Display*		/* display */,
+    GC			/* gc */,
+    int			/* subwindow_mode */
+);
+
+extern int XSetTSOrigin(
+    Display*		/* display */,
+    GC			/* gc */,
+    int			/* ts_x_origin */,
+    int			/* ts_y_origin */
+);
+
+extern int XSetTile(
+    Display*		/* display */,
+    GC			/* gc */,
+    Pixmap		/* tile */
+);
+
+extern int XSetWindowBackground(
+    Display*		/* display */,
+    Window		/* w */,
+    unsigned long	/* background_pixel */
+);
+
+extern int XSetWindowBackgroundPixmap(
+    Display*		/* display */,
+    Window		/* w */,
+    Pixmap		/* background_pixmap */
+);
+
+extern int XSetWindowBorder(
+    Display*		/* display */,
+    Window		/* w */,
+    unsigned long	/* border_pixel */
+);
+
+extern int XSetWindowBorderPixmap(
+    Display*		/* display */,
+    Window		/* w */,
+    Pixmap		/* border_pixmap */
+);
+
+extern int XSetWindowBorderWidth(
+    Display*		/* display */,
+    Window		/* w */,
+    unsigned int	/* width */
+);
+
+extern int XSetWindowColormap(
+    Display*		/* display */,
+    Window		/* w */,
+    Colormap		/* colormap */
+);
+
+extern int XStoreBuffer(
+    Display*		/* display */,
+    _Xconst char*	/* bytes */,
+    int			/* nbytes */,
+    int			/* buffer */
+);
+
+extern int XStoreBytes(
+    Display*		/* display */,
+    _Xconst char*	/* bytes */,
+    int			/* nbytes */
+);
+
+extern int XStoreColor(
+    Display*		/* display */,
+    Colormap		/* colormap */,
+    XColor*		/* color */
+);
+
+extern int XStoreColors(
+    Display*		/* display */,
+    Colormap		/* colormap */,
+    XColor*		/* color */,
+    int			/* ncolors */
+);
+
+extern int XStoreName(
+    Display*		/* display */,
+    Window		/* w */,
+    _Xconst char*	/* window_name */
+);
+
+extern int XStoreNamedColor(
+    Display*		/* display */,
+    Colormap		/* colormap */,
+    _Xconst char*	/* color */,
+    unsigned long	/* pixel */,
+    int			/* flags */
+);
+
+extern int XSync(
+    Display*		/* display */,
+    Bool		/* discard */
+);
+
+extern int XTextExtents(
+    XFontStruct*	/* font_struct */,
+    _Xconst char*	/* string */,
+    int			/* nchars */,
+    int*		/* direction_return */,
+    int*		/* font_ascent_return */,
+    int*		/* font_descent_return */,
+    XCharStruct*	/* overall_return */
+);
+
+extern int XTextExtents16(
+    XFontStruct*	/* font_struct */,
+    _Xconst XChar2b*	/* string */,
+    int			/* nchars */,
+    int*		/* direction_return */,
+    int*		/* font_ascent_return */,
+    int*		/* font_descent_return */,
+    XCharStruct*	/* overall_return */
+);
+
+extern int XTextWidth(
+    XFontStruct*	/* font_struct */,
+    _Xconst char*	/* string */,
+    int			/* count */
+);
+
+extern int XTextWidth16(
+    XFontStruct*	/* font_struct */,
+    _Xconst XChar2b*	/* string */,
+    int			/* count */
+);
+
+extern Bool XTranslateCoordinates(
+    Display*		/* display */,
+    Window		/* src_w */,
+    Window		/* dest_w */,
+    int			/* src_x */,
+    int			/* src_y */,
+    int*		/* dest_x_return */,
+    int*		/* dest_y_return */,
+    Window*		/* child_return */
+);
+
+extern int XUndefineCursor(
+    Display*		/* display */,
+    Window		/* w */
+);
+
+extern int XUngrabButton(
+    Display*		/* display */,
+    unsigned int	/* button */,
+    unsigned int	/* modifiers */,
+    Window		/* grab_window */
+);
+
+extern int XUngrabKey(
+    Display*		/* display */,
+    int			/* keycode */,
+    unsigned int	/* modifiers */,
+    Window		/* grab_window */
+);
+
+extern int XUngrabKeyboard(
+    Display*		/* display */,
+    Time		/* time */
+);
+
+extern int XUngrabPointer(
+    Display*		/* display */,
+    Time		/* time */
+);
+
+extern int XUngrabServer(
+    Display*		/* display */
+);
+
+extern int XUninstallColormap(
+    Display*		/* display */,
+    Colormap		/* colormap */
+);
+
+extern int XUnloadFont(
+    Display*		/* display */,
+    Font		/* font */
+);
+
+extern int XUnmapSubwindows(
+    Display*		/* display */,
+    Window		/* w */
+);
+
+extern int XUnmapWindow(
+    Display*		/* display */,
+    Window		/* w */
+);
+
+extern int XVendorRelease(
+    Display*		/* display */
+);
+
+extern int XWarpPointer(
+    Display*		/* display */,
+    Window		/* src_w */,
+    Window		/* dest_w */,
+    int			/* src_x */,
+    int			/* src_y */,
+    unsigned int	/* src_width */,
+    unsigned int	/* src_height */,
+    int			/* dest_x */,
+    int			/* dest_y */
+);
+
+extern int XWidthMMOfScreen(
+    Screen*		/* screen */
+);
+
+extern int XWidthOfScreen(
+    Screen*		/* screen */
+);
+
+extern int XWindowEvent(
+    Display*		/* display */,
+    Window		/* w */,
+    long		/* event_mask */,
+    XEvent*		/* event_return */
+);
+
+extern int XWriteBitmapFile(
+    Display*		/* display */,
+    _Xconst char*	/* filename */,
+    Pixmap		/* bitmap */,
+    unsigned int	/* width */,
+    unsigned int	/* height */,
+    int			/* x_hot */,
+    int			/* y_hot */
+);
+
+extern Bool XSupportsLocale (void);
+
+extern char *XSetLocaleModifiers(
+    const char*		/* modifier_list */
+);
+
+extern XOM XOpenOM(
+    Display*			/* display */,
+    struct _XrmHashBucketRec*	/* rdb */,
+    _Xconst char*		/* res_name */,
+    _Xconst char*		/* res_class */
+);
+
+extern Status XCloseOM(
+    XOM			/* om */
+);
+
+extern char *XSetOMValues(
+    XOM			/* om */,
+    ...
+) _X_SENTINEL(0);
+
+extern char *XGetOMValues(
+    XOM			/* om */,
+    ...
+) _X_SENTINEL(0);
+
+extern Display *XDisplayOfOM(
+    XOM			/* om */
+);
+
+extern char *XLocaleOfOM(
+    XOM			/* om */
+);
+
+extern XOC XCreateOC(
+    XOM			/* om */,
+    ...
+) _X_SENTINEL(0);
+
+extern void XDestroyOC(
+    XOC			/* oc */
+);
+
+extern XOM XOMOfOC(
+    XOC			/* oc */
+);
+
+extern char *XSetOCValues(
+    XOC			/* oc */,
+    ...
+) _X_SENTINEL(0);
+
+extern char *XGetOCValues(
+    XOC			/* oc */,
+    ...
+) _X_SENTINEL(0);
+
+extern XFontSet XCreateFontSet(
+    Display*		/* display */,
+    _Xconst char*	/* base_font_name_list */,
+    char***		/* missing_charset_list */,
+    int*		/* missing_charset_count */,
+    char**		/* def_string */
+);
+
+extern void XFreeFontSet(
+    Display*		/* display */,
+    XFontSet		/* font_set */
+);
+
+extern int XFontsOfFontSet(
+    XFontSet		/* font_set */,
+    XFontStruct***	/* font_struct_list */,
+    char***		/* font_name_list */
+);
+
+extern char *XBaseFontNameListOfFontSet(
+    XFontSet		/* font_set */
+);
+
+extern char *XLocaleOfFontSet(
+    XFontSet		/* font_set */
+);
+
+extern Bool XContextDependentDrawing(
+    XFontSet		/* font_set */
+);
+
+extern Bool XDirectionalDependentDrawing(
+    XFontSet		/* font_set */
+);
+
+extern Bool XContextualDrawing(
+    XFontSet		/* font_set */
+);
+
+extern XFontSetExtents *XExtentsOfFontSet(
+    XFontSet		/* font_set */
+);
+
+extern int XmbTextEscapement(
+    XFontSet		/* font_set */,
+    _Xconst char*	/* text */,
+    int			/* bytes_text */
+);
+
+extern int XwcTextEscapement(
+    XFontSet		/* font_set */,
+    _Xconst wchar_t*	/* text */,
+    int			/* num_wchars */
+);
+
+extern int Xutf8TextEscapement(
+    XFontSet		/* font_set */,
+    _Xconst char*	/* text */,
+    int			/* bytes_text */
+);
+
+extern int XmbTextExtents(
+    XFontSet		/* font_set */,
+    _Xconst char*	/* text */,
+    int			/* bytes_text */,
+    XRectangle*		/* overall_ink_return */,
+    XRectangle*		/* overall_logical_return */
+);
+
+extern int XwcTextExtents(
+    XFontSet		/* font_set */,
+    _Xconst wchar_t*	/* text */,
+    int			/* num_wchars */,
+    XRectangle*		/* overall_ink_return */,
+    XRectangle*		/* overall_logical_return */
+);
+
+extern int Xutf8TextExtents(
+    XFontSet		/* font_set */,
+    _Xconst char*	/* text */,
+    int			/* bytes_text */,
+    XRectangle*		/* overall_ink_return */,
+    XRectangle*		/* overall_logical_return */
+);
+
+extern Status XmbTextPerCharExtents(
+    XFontSet		/* font_set */,
+    _Xconst char*	/* text */,
+    int			/* bytes_text */,
+    XRectangle*		/* ink_extents_buffer */,
+    XRectangle*		/* logical_extents_buffer */,
+    int			/* buffer_size */,
+    int*		/* num_chars */,
+    XRectangle*		/* overall_ink_return */,
+    XRectangle*		/* overall_logical_return */
+);
+
+extern Status XwcTextPerCharExtents(
+    XFontSet		/* font_set */,
+    _Xconst wchar_t*	/* text */,
+    int			/* num_wchars */,
+    XRectangle*		/* ink_extents_buffer */,
+    XRectangle*		/* logical_extents_buffer */,
+    int			/* buffer_size */,
+    int*		/* num_chars */,
+    XRectangle*		/* overall_ink_return */,
+    XRectangle*		/* overall_logical_return */
+);
+
+extern Status Xutf8TextPerCharExtents(
+    XFontSet		/* font_set */,
+    _Xconst char*	/* text */,
+    int			/* bytes_text */,
+    XRectangle*		/* ink_extents_buffer */,
+    XRectangle*		/* logical_extents_buffer */,
+    int			/* buffer_size */,
+    int*		/* num_chars */,
+    XRectangle*		/* overall_ink_return */,
+    XRectangle*		/* overall_logical_return */
+);
+
+extern void XmbDrawText(
+    Display*		/* display */,
+    Drawable		/* d */,
+    GC			/* gc */,
+    int			/* x */,
+    int			/* y */,
+    XmbTextItem*	/* text_items */,
+    int			/* nitems */
+);
+
+extern void XwcDrawText(
+    Display*		/* display */,
+    Drawable		/* d */,
+    GC			/* gc */,
+    int			/* x */,
+    int			/* y */,
+    XwcTextItem*	/* text_items */,
+    int			/* nitems */
+);
+
+extern void Xutf8DrawText(
+    Display*		/* display */,
+    Drawable		/* d */,
+    GC			/* gc */,
+    int			/* x */,
+    int			/* y */,
+    XmbTextItem*	/* text_items */,
+    int			/* nitems */
+);
+
+extern void XmbDrawString(
+    Display*		/* display */,
+    Drawable		/* d */,
+    XFontSet		/* font_set */,
+    GC			/* gc */,
+    int			/* x */,
+    int			/* y */,
+    _Xconst char*	/* text */,
+    int			/* bytes_text */
+);
+
+extern void XwcDrawString(
+    Display*		/* display */,
+    Drawable		/* d */,
+    XFontSet		/* font_set */,
+    GC			/* gc */,
+    int			/* x */,
+    int			/* y */,
+    _Xconst wchar_t*	/* text */,
+    int			/* num_wchars */
+);
+
+extern void Xutf8DrawString(
+    Display*		/* display */,
+    Drawable		/* d */,
+    XFontSet		/* font_set */,
+    GC			/* gc */,
+    int			/* x */,
+    int			/* y */,
+    _Xconst char*	/* text */,
+    int			/* bytes_text */
+);
+
+extern void XmbDrawImageString(
+    Display*		/* display */,
+    Drawable		/* d */,
+    XFontSet		/* font_set */,
+    GC			/* gc */,
+    int			/* x */,
+    int			/* y */,
+    _Xconst char*	/* text */,
+    int			/* bytes_text */
+);
+
+extern void XwcDrawImageString(
+    Display*		/* display */,
+    Drawable		/* d */,
+    XFontSet		/* font_set */,
+    GC			/* gc */,
+    int			/* x */,
+    int			/* y */,
+    _Xconst wchar_t*	/* text */,
+    int			/* num_wchars */
+);
+
+extern void Xutf8DrawImageString(
+    Display*		/* display */,
+    Drawable		/* d */,
+    XFontSet		/* font_set */,
+    GC			/* gc */,
+    int			/* x */,
+    int			/* y */,
+    _Xconst char*	/* text */,
+    int			/* bytes_text */
+);
+
+extern XIM XOpenIM(
+    Display*			/* dpy */,
+    struct _XrmHashBucketRec*	/* rdb */,
+    char*			/* res_name */,
+    char*			/* res_class */
+);
+
+extern Status XCloseIM(
+    XIM /* im */
+);
+
+extern char *XGetIMValues(
+    XIM /* im */, ...
+) _X_SENTINEL(0);
+
+extern char *XSetIMValues(
+    XIM /* im */, ...
+) _X_SENTINEL(0);
+
+extern Display *XDisplayOfIM(
+    XIM /* im */
+);
+
+extern char *XLocaleOfIM(
+    XIM /* im*/
+);
+
+extern XIC XCreateIC(
+    XIM /* im */, ...
+) _X_SENTINEL(0);
+
+extern void XDestroyIC(
+    XIC /* ic */
+);
+
+extern void XSetICFocus(
+    XIC /* ic */
+);
+
+extern void XUnsetICFocus(
+    XIC /* ic */
+);
+
+extern wchar_t *XwcResetIC(
+    XIC /* ic */
+);
+
+extern char *XmbResetIC(
+    XIC /* ic */
+);
+
+extern char *Xutf8ResetIC(
+    XIC /* ic */
+);
+
+extern char *XSetICValues(
+    XIC /* ic */, ...
+) _X_SENTINEL(0);
+
+extern char *XGetICValues(
+    XIC /* ic */, ...
+) _X_SENTINEL(0);
+
+extern XIM XIMOfIC(
+    XIC /* ic */
+);
+
+extern Bool XFilterEvent(
+    XEvent*	/* event */,
+    Window	/* window */
+);
+
+extern int XmbLookupString(
+    XIC			/* ic */,
+    XKeyPressedEvent*	/* event */,
+    char*		/* buffer_return */,
+    int			/* bytes_buffer */,
+    KeySym*		/* keysym_return */,
+    Status*		/* status_return */
+);
+
+extern int XwcLookupString(
+    XIC			/* ic */,
+    XKeyPressedEvent*	/* event */,
+    wchar_t*		/* buffer_return */,
+    int			/* wchars_buffer */,
+    KeySym*		/* keysym_return */,
+    Status*		/* status_return */
+);
+
+extern int Xutf8LookupString(
+    XIC			/* ic */,
+    XKeyPressedEvent*	/* event */,
+    char*		/* buffer_return */,
+    int			/* bytes_buffer */,
+    KeySym*		/* keysym_return */,
+    Status*		/* status_return */
+);
+
+extern XVaNestedList XVaCreateNestedList(
+    int /*unused*/, ...
+) _X_SENTINEL(0);
+
+/* internal connections for IMs */
+
+extern Bool XRegisterIMInstantiateCallback(
+    Display*			/* dpy */,
+    struct _XrmHashBucketRec*	/* rdb */,
+    char*			/* res_name */,
+    char*			/* res_class */,
+    XIDProc			/* callback */,
+    XPointer			/* client_data */
+);
+
+extern Bool XUnregisterIMInstantiateCallback(
+    Display*			/* dpy */,
+    struct _XrmHashBucketRec*	/* rdb */,
+    char*			/* res_name */,
+    char*			/* res_class */,
+    XIDProc			/* callback */,
+    XPointer			/* client_data */
+);
+
+typedef void (*XConnectionWatchProc)(
+    Display*			/* dpy */,
+    XPointer			/* client_data */,
+    int				/* fd */,
+    Bool			/* opening */,	 /* open or close flag */
+    XPointer*			/* watch_data */ /* open sets, close uses */
+);
+
+
+extern Status XInternalConnectionNumbers(
+    Display*			/* dpy */,
+    int**			/* fd_return */,
+    int*			/* count_return */
+);
+
+extern void XProcessInternalConnection(
+    Display*			/* dpy */,
+    int				/* fd */
+);
+
+extern Status XAddConnectionWatch(
+    Display*			/* dpy */,
+    XConnectionWatchProc	/* callback */,
+    XPointer			/* client_data */
+);
+
+extern void XRemoveConnectionWatch(
+    Display*			/* dpy */,
+    XConnectionWatchProc	/* callback */,
+    XPointer			/* client_data */
+);
+
+extern void XSetAuthorization(
+    char *			/* name */,
+    int				/* namelen */,
+    char *			/* data */,
+    int				/* datalen */
+);
+
+extern int _Xmbtowc(
+    wchar_t *			/* wstr */,
+    char *			/* str */,
+    int				/* len */
+);
+
+extern int _Xwctomb(
+    char *			/* str */,
+    wchar_t			/* wc */
+);
+
+extern Bool XGetEventData(
+    Display*			/* dpy */,
+    XGenericEventCookie*	/* cookie*/
+);
+
+extern void XFreeEventData(
+    Display*			/* dpy */,
+    XGenericEventCookie*	/* cookie*/
+);
+
+#ifdef __clang__
+#pragma clang diagnostic pop
+#endif
+
+_XFUNCPROTOEND
+
+#endif /* #if !defined(_X11_XLIB_H_) && !defined(_XLIB_H_) */
diff --git a/nx-X11/lib/include/X11/XlibConf.h.in b/nx-X11/lib/include/X11/XlibConf.h.in
new file mode 100644
index 000000000..8f36ac1d9
--- /dev/null
+++ b/nx-X11/lib/include/X11/XlibConf.h.in
@@ -0,0 +1,37 @@
+/*
+ * Copyright © 2005 Keith Packard
+ *
+ * Permission to use, copy, modify, distribute, and sell this software and its
+ * documentation for any purpose is hereby granted without fee, 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 Keith Packard not be used in
+ * advertising or publicity pertaining to distribution of the software without
+ * specific, written prior permission.  Keith Packard makes no
+ * representations about the suitability of this software for any purpose.  It
+ * is provided "as is" without express or implied warranty.
+ *
+ * KEITH PACKARD DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
+ * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
+ * EVENT SHALL KEITH PACKARD BE LIABLE FOR ANY SPECIAL, INDIRECT OR
+ * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
+ * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+ * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+ * PERFORMANCE OF THIS SOFTWARE.
+ */
+
+#ifndef _XLIBCONF_H_
+#define _XLIBCONF_H_
+/*
+ * This header file exports defines necessary to correctly
+ * use Xlibint.h both inside Xlib and by external libraries
+ * such as extensions.
+ */
+
+/* Threading support? */
+#undef XTHREADS
+
+/* Use multi-threaded libc functions? */
+#undef XUSE_MTSAFE_API
+
+#endif /* _XLIBCONF_H_ */
diff --git a/nx-X11/lib/include/X11/Xlibint.h b/nx-X11/lib/include/X11/Xlibint.h
new file mode 100644
index 000000000..b325182e3
--- /dev/null
+++ b/nx-X11/lib/include/X11/Xlibint.h
@@ -0,0 +1,1361 @@
+/**************************************************************************/
+/*                                                                        */
+/* Copyright (c) 2001, 2011 NoMachine (http://www.nomachine.com)          */
+/* Copyright (c) 2008-2014 Oleksandr Shneyder <o.shneyder@phoca-gmbh.de>  */
+/* Copyright (c) 2011-2016 Mike Gabriel <mike.gabriel@das-netzwerkteam.de>*/
+/* Copyright (c) 2014-2016 Mihai Moldovan <ionic@ionic.de>                */
+/* Copyright (c) 2014-2016 Ulrich Sibiller <uli42@gmx.de>                 */
+/* Copyright (c) 2015-2016 Qindel Group (http://www.qindel.com)           */
+/*                                                                        */
+/* nx-X11, NX protocol compression and NX extensions to this software     */
+/* are copyright of the aforementioned persons and companies.             */
+/*                                                                        */
+/* Redistribution and use of the present software is allowed according    */
+/* to terms specified in the file LICENSE which comes in the source       */
+/* distribution.                                                          */
+/*                                                                        */
+/* All rights reserved.                                                   */
+/*                                                                        */
+/* NOTE: This software has received contributions from various other      */
+/* contributors, only the core maintainers and supporters are listed as   */
+/* copyright holders. Please contact us, if you feel you should be listed */
+/* as copyright holder, as well.                                          */
+/*                                                                        */
+/**************************************************************************/
+
+/*
+
+Copyright 1984, 1985, 1987, 1989, 1998  The Open Group
+
+Permission to use, copy, modify, distribute, and sell this software and its
+documentation for any purpose is hereby granted without fee, provided that
+the above copyright notice appear in all copies and that both that
+copyright notice and this permission notice appear in supporting
+documentation.
+
+The above copyright notice and this permission notice shall be included
+in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR
+OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.
+
+Except as contained in this notice, the name of The Open Group shall
+not be used in advertising or otherwise to promote the sale, use or
+other dealings in this Software without prior written authorization
+from The Open Group.
+
+*/
+
+#if !defined(_X11_XLIBINT_H_) && !defined(_XLIBINT_H_)
+#define _X11_XLIBINT_H_
+#define _XLIBINT_H_
+
+/*
+ *	Xlibint.h - Header definition and support file for the internal
+ *	support routines used by the C subroutine interface
+ *	library (Xlib) to the X Window System.
+ *
+ *	Warning, there be dragons here....
+ */
+
+#include <nx-X11/Xlib.h>
+#include <nx-X11/Xproto.h>		/* to declare xEvent */
+#include <nx-X11/XlibConf.h>	/* for configured options like XTHREADS */
+
+/* The Xlib structs are full of implicit padding to properly align members.
+   We can't clean that up without breaking ABI, so tell clang not to bother
+   complaining about it. */
+#ifdef __clang__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wpadded"
+#endif
+
+#ifdef NX_TRANS_SOCKET
+
+#include <nx/NXvars.h>
+
+#define _XGetIOError(dpy) \
+    (dpy -> flags & XlibDisplayIOError)
+
+#endif
+
+#ifdef WIN32
+#define _XFlush _XFlushIt
+#endif
+
+struct _XGC
+{
+    XExtData *ext_data;	/* hook for extension to hang data */
+    GContext gid;	/* protocol ID for graphics context */
+    Bool rects;		/* boolean: TRUE if clipmask is list of rectangles */
+    Bool dashes;	/* boolean: TRUE if dash-list is really a list */
+    unsigned long dirty;/* cache dirty bits */
+    XGCValues values;	/* shadow structure of values */
+};
+
+struct _XDisplay
+{
+	XExtData *ext_data;	/* hook for extension to hang data */
+	struct _XFreeFuncs *free_funcs; /* internal free functions */
+	int fd;			/* Network socket. */
+	int conn_checker;         /* ugly thing used by _XEventsQueued */
+	int proto_major_version;/* maj. version of server's X protocol */
+	int proto_minor_version;/* minor version of server's X protocol */
+	char *vendor;		/* vendor of the server hardware */
+        XID resource_base;	/* resource ID base */
+	XID resource_mask;	/* resource ID mask bits */
+	XID resource_id;	/* allocator current ID */
+	int resource_shift;	/* allocator shift to correct bits */
+	XID (*resource_alloc)(	/* allocator function */
+		struct _XDisplay*
+		);
+	int byte_order;		/* screen byte order, LSBFirst, MSBFirst */
+	int bitmap_unit;	/* padding and data requirements */
+	int bitmap_pad;		/* padding requirements on bitmaps */
+	int bitmap_bit_order;	/* LeastSignificant or MostSignificant */
+	int nformats;		/* number of pixmap formats in list */
+	ScreenFormat *pixmap_format;	/* pixmap format list */
+	int vnumber;		/* Xlib's X protocol version number. */
+	int release;		/* release of the server */
+	struct _XSQEvent *head, *tail;	/* Input event queue. */
+	int qlen;		/* Length of input event queue */
+	unsigned long last_request_read; /* seq number of last event read */
+	unsigned long request;	/* sequence number of last request. */
+	char *last_req;		/* beginning of last request, or dummy */
+	char *buffer;		/* Output buffer starting address. */
+	char *bufptr;		/* Output buffer index pointer. */
+	char *bufmax;		/* Output buffer maximum+1 address. */
+	unsigned max_request_size; /* maximum number 32 bit words in request*/
+	struct _XrmHashBucketRec *db;
+	int (*synchandler)(	/* Synchronization handler */
+		struct _XDisplay*
+		);
+	char *display_name;	/* "host:display" string used on this connect*/
+	int default_screen;	/* default screen for operations */
+	int nscreens;		/* number of screens on this server*/
+	Screen *screens;	/* pointer to list of screens */
+	unsigned long motion_buffer;	/* size of motion buffer */
+	volatile unsigned long flags;	   /* internal connection flags */
+	int min_keycode;	/* minimum defined keycode */
+	int max_keycode;	/* maximum defined keycode */
+	KeySym *keysyms;	/* This server's keysyms */
+	XModifierKeymap *modifiermap;	/* This server's modifier keymap */
+	int keysyms_per_keycode;/* number of rows */
+	char *xdefaults;	/* contents of defaults from server */
+	char *scratch_buffer;	/* place to hang scratch buffer */
+	unsigned long scratch_length;	/* length of scratch buffer */
+	int ext_number;		/* extension number on this display */
+	struct _XExten *ext_procs; /* extensions initialized on this display */
+	/*
+	 * the following can be fixed size, as the protocol defines how
+	 * much address space is available.
+	 * While this could be done using the extension vector, there
+	 * may be MANY events processed, so a search through the extension
+	 * list to find the right procedure for each event might be
+	 * expensive if many extensions are being used.
+	 */
+	Bool (*event_vec[128])(	/* vector for wire to event */
+		Display *	/* dpy */,
+		XEvent *	/* re */,
+		xEvent *	/* event */
+		);
+	Status (*wire_vec[128])( /* vector for event to wire */
+		Display *	/* dpy */,
+		XEvent *	/* re */,
+		xEvent *	/* event */
+		);
+	KeySym lock_meaning;	   /* for XLookupString */
+	struct _XLockInfo *lock;   /* multi-thread state, display lock */
+	struct _XInternalAsync *async_handlers; /* for internal async */
+	unsigned long bigreq_size; /* max size of big requests */
+	struct _XLockPtrs *lock_fns; /* pointers to threads functions */
+	void (*idlist_alloc)(	   /* XID list allocator function */
+		Display *	/* dpy */,
+		XID *		/* ids */,
+		int		/* count */
+		);
+	/* things above this line should not move, for binary compatibility */
+	struct _XKeytrans *key_bindings; /* for XLookupString */
+	Font cursor_font;	   /* for XCreateFontCursor */
+	struct _XDisplayAtoms *atoms; /* for XInternAtom */
+	unsigned int mode_switch;  /* keyboard group modifiers */
+	unsigned int num_lock;  /* keyboard numlock modifiers */
+	struct _XContextDB *context_db; /* context database */
+	Bool (**error_vec)(	/* vector for wire to error */
+		Display     *	/* display */,
+		XErrorEvent *	/* he */,
+		xError      *	/* we */
+		);
+	/*
+	 * Xcms information
+	 */
+	struct {
+	   XPointer defaultCCCs;  /* pointer to an array of default XcmsCCC */
+	   XPointer clientCmaps;  /* pointer to linked list of XcmsCmapRec */
+	   XPointer perVisualIntensityMaps;
+				  /* linked list of XcmsIntensityMap */
+	} cms;
+	struct _XIMFilter *im_filters;
+	struct _XSQEvent *qfree; /* unallocated event queue elements */
+	unsigned long next_event_serial_num; /* inserted into next queue elt */
+	struct _XExten *flushes; /* Flush hooks */
+	struct _XConnectionInfo *im_fd_info; /* _XRegisterInternalConnection */
+	int im_fd_length;	/* number of im_fd_info */
+	struct _XConnWatchInfo *conn_watchers; /* XAddConnectionWatch */
+	int watcher_count;	/* number of conn_watchers */
+	XPointer filedes;	/* struct pollfd cache for _XWaitForReadable */
+	int (*savedsynchandler)( /* user synchandler when Xlib usurps */
+		Display *	/* dpy */
+		);
+	XID resource_max;	/* allocator max ID */
+	int xcmisc_opcode;	/* major opcode for XC-MISC */
+	struct _XkbInfoRec *xkb_info; /* XKB info */
+	struct _XtransConnInfo *trans_conn; /* transport connection object */
+	struct _X11XCBPrivate *xcb; /* XCB glue private data */
+
+	/* Generic event cookie handling */
+	unsigned int next_cookie; /* next event cookie */
+	/* vector for wire to generic event, index is (extension - 128) */
+	Bool (*generic_event_vec[128])(
+		Display *	/* dpy */,
+		XGenericEventCookie *	/* Xlib event */,
+		xEvent *	/* wire event */);
+	/* vector for event copy, index is (extension - 128) */
+	Bool (*generic_event_copy_vec[128])(
+		Display *	/* dpy */,
+		XGenericEventCookie *	/* in */,
+		XGenericEventCookie *   /* out*/);
+	void *cookiejar;  /* cookie events returned but not claimed */
+};
+
+#define XAllocIDs(dpy,ids,n) (*(dpy)->idlist_alloc)(dpy,ids,n)
+
+#ifndef _XEVENT_
+/*
+ * _QEvent datatype for use in input queueing.
+ */
+typedef struct _XSQEvent
+{
+    struct _XSQEvent *next;
+    XEvent event;
+    unsigned long qserial_num;	/* so multi-threaded code can find new ones */
+} _XQEvent;
+#endif
+
+#include <nx-X11/Xproto.h>
+#include <errno.h>
+#define _XBCOPYFUNC _Xbcopy
+#include <nx-X11/Xfuncs.h>
+#include <nx-X11/Xosdefs.h>
+
+/* Utek leaves kernel macros around in include files (bleah) */
+#ifdef dirty
+#undef dirty
+#endif
+
+#include <stdlib.h>
+#include <string.h>
+
+#include <nx-X11/Xfuncproto.h>
+
+_XFUNCPROTOBEGIN
+
+/*
+ * The following definitions can be used for locking requests in multi-threaded
+ * address spaces.
+ */
+#ifdef XTHREADS
+/* Author: Stephen Gildea, MIT X Consortium
+ *
+ * declarations for C Threads locking
+ */
+
+typedef struct _LockInfoRec *LockInfoPtr;
+
+/* interfaces for locking.c */
+struct _XLockPtrs {
+    /* used by all, including extensions; do not move */
+    void (*lock_display)(
+		Display *dpy
+#if defined(XTHREADS_WARN) || defined(XTHREADS_FILE_LINE)
+		, char *file
+		, int line
+#endif
+	);
+    void (*unlock_display)(
+		Display *dpy
+#if defined(XTHREADS_WARN) || defined(XTHREADS_FILE_LINE)
+		, char *file
+		, int line
+#endif
+	);
+};
+
+#if defined(WIN32) && !defined(_XLIBINT_)
+#define _XCreateMutex_fn (*_XCreateMutex_fn_p)
+#define _XFreeMutex_fn (*_XFreeMutex_fn_p)
+#define _XLockMutex_fn (*_XLockMutex_fn_p)
+#define _XUnlockMutex_fn (*_XUnlockMutex_fn_p)
+#define _Xglobal_lock (*_Xglobal_lock_p)
+#endif
+
+/* in XlibInt.c */
+extern void (*_XCreateMutex_fn)(
+    LockInfoPtr /* lock */
+);
+extern void (*_XFreeMutex_fn)(
+    LockInfoPtr /* lock */
+);
+extern void (*_XLockMutex_fn)(
+    LockInfoPtr	/* lock */
+#if defined(XTHREADS_WARN) || defined(XTHREADS_FILE_LINE)
+    , char * /* file */
+    , int /* line */
+#endif
+);
+extern void (*_XUnlockMutex_fn)(
+    LockInfoPtr	/* lock */
+#if defined(XTHREADS_WARN) || defined(XTHREADS_FILE_LINE)
+    , char * /* file */
+    , int /* line */
+#endif
+);
+
+extern LockInfoPtr _Xglobal_lock;
+
+#if defined(XTHREADS_WARN) || defined(XTHREADS_FILE_LINE)
+#define LockDisplay(d)	     if ((d)->lock_fns) (*(d)->lock_fns->lock_display)((d),__FILE__,__LINE__)
+#define UnlockDisplay(d)     if ((d)->lock_fns) (*(d)->lock_fns->unlock_display)((d),__FILE__,__LINE__)
+#define _XLockMutex(lock)		if (_XLockMutex_fn) (*_XLockMutex_fn)(lock,__FILE__,__LINE__)
+#define _XUnlockMutex(lock)	if (_XUnlockMutex_fn) (*_XUnlockMutex_fn)(lock,__FILE__,__LINE__)
+#else
+/* used everywhere, so must be fast if not using threads */
+#define LockDisplay(d)	     if ((d)->lock_fns) (*(d)->lock_fns->lock_display)(d)
+#define UnlockDisplay(d)     if ((d)->lock_fns) (*(d)->lock_fns->unlock_display)(d)
+#define _XLockMutex(lock)		if (_XLockMutex_fn) (*_XLockMutex_fn)(lock)
+#define _XUnlockMutex(lock)	if (_XUnlockMutex_fn) (*_XUnlockMutex_fn)(lock)
+#endif
+#define _XCreateMutex(lock)	if (_XCreateMutex_fn) (*_XCreateMutex_fn)(lock);
+#define _XFreeMutex(lock)	if (_XFreeMutex_fn) (*_XFreeMutex_fn)(lock);
+
+#else /* XTHREADS */
+#define LockDisplay(dis)
+#define _XLockMutex(lock)
+#define _XUnlockMutex(lock)
+#define UnlockDisplay(dis)
+#define _XCreateMutex(lock)
+#define _XFreeMutex(lock)
+#endif
+
+#define Xfree(ptr) free((ptr))
+
+/*
+ * Note that some machines do not return a valid pointer for malloc(0), in
+ * which case we provide an alternate under the control of the
+ * define MALLOC_0_RETURNS_NULL.  This is necessary because some
+ * Xlib code expects malloc(0) to return a valid pointer to storage.
+ */
+#if defined(MALLOC_0_RETURNS_NULL) || defined(__clang_analyzer__)
+
+# define Xmalloc(size) malloc(((size) == 0 ? 1 : (size)))
+# define Xrealloc(ptr, size) realloc((ptr), ((size) == 0 ? 1 : (size)))
+# define Xcalloc(nelem, elsize) calloc(((nelem) == 0 ? 1 : (nelem)), (elsize))
+
+#else
+
+# define Xmalloc(size) malloc((size))
+# define Xrealloc(ptr, size) realloc((ptr), (size))
+# define Xcalloc(nelem, elsize) calloc((nelem), (elsize))
+
+#endif
+
+#include <stddef.h>
+
+#define LOCKED 1
+#define UNLOCKED 0
+
+#ifdef NX_TRANS_SOCKET
+#ifndef BUFSIZE                         /* Output buffer size is configurable  */
+#define BUFSIZE 8192                    /* but this is still used for reading. */
+#endif
+#else
+#ifndef BUFSIZE
+#define BUFSIZE 2048			/* X output buffer size. */
+#endif
+#endif
+#ifndef PTSPERBATCH
+#define PTSPERBATCH 1024		/* point batching */
+#endif
+#ifndef WLNSPERBATCH
+#define WLNSPERBATCH 50			/* wide line batching */
+#endif
+#ifndef ZLNSPERBATCH
+#define ZLNSPERBATCH 1024		/* thin line batching */
+#endif
+#ifndef WRCTSPERBATCH
+#define WRCTSPERBATCH 10		/* wide line rectangle batching */
+#endif
+#ifndef ZRCTSPERBATCH
+#define ZRCTSPERBATCH 256		/* thin line rectangle batching */
+#endif
+#ifndef FRCTSPERBATCH
+#define FRCTSPERBATCH 256		/* filled rectangle batching */
+#endif
+#ifndef FARCSPERBATCH
+#define FARCSPERBATCH 256		/* filled arc batching */
+#endif
+#ifndef CURSORFONT
+#define CURSORFONT "cursor"		/* standard cursor fonts */
+#endif
+
+/*
+ * Display flags
+ */
+#define XlibDisplayIOError	(1L << 0)
+#define XlibDisplayClosing	(1L << 1)
+#define XlibDisplayNoXkb	(1L << 2)
+#define XlibDisplayPrivSync	(1L << 3)
+#define XlibDisplayProcConni	(1L << 4) /* in _XProcessInternalConnection */
+#define XlibDisplayReadEvents	(1L << 5) /* in _XReadEvents */
+#define XlibDisplayReply	(1L << 5) /* in _XReply */
+#define XlibDisplayWriting	(1L << 6) /* in _XFlushInt, _XSend */
+#define XlibDisplayDfltRMDB     (1L << 7) /* mark if RM db from XGetDefault */
+
+/*
+ * X Protocol packetizing macros.
+ */
+
+/* Leftover from CRAY support - was defined empty on all non-Cray systems */
+#define WORD64ALIGN
+
+/**
+ * Return a len-sized request buffer for the request type. This function may
+ * flush the output queue.
+ *
+ * @param dpy The display connection
+ * @param type The request type
+ * @param len Length of the request in bytes
+ *
+ * @returns A pointer to the request buffer with a few default values
+ * initialized.
+ */
+extern void *_XGetRequest(Display *dpy, CARD8 type, size_t len);
+
+/* GetReqSized is the same as GetReq but allows the caller to specify the
+ * size in bytes. 'sz' must be a multiple of 4! */
+
+#define GetReqSized(name, sz, req) \
+	req = (x##name##Req *) _XGetRequest(dpy, X_##name, sz)
+
+/*
+ * GetReq - Get the next available X request packet in the buffer and
+ * return it.
+ *
+ * "name" is the name of the request, e.g. CreatePixmap, OpenFont, etc.
+ * "req" is the name of the request pointer.
+ *
+ */
+
+#define GetReq(name, req) \
+	GetReqSized(name, SIZEOF(x##name##Req), req)
+
+/* GetReqExtra is the same as GetReq, but allocates "n" additional
+   bytes after the request. "n" must be a multiple of 4!  */
+
+#define GetReqExtra(name, n, req) \
+	GetReqSized(name, SIZEOF(x##name##Req) + n, req)
+
+/*
+ * GetResReq is for those requests that have a resource ID
+ * (Window, Pixmap, GContext, etc.) as their single argument.
+ * "rid" is the name of the resource.
+ */
+
+#define GetResReq(name, rid, req) \
+	req = (xResourceReq *) _XGetRequest(dpy, X_##name, SIZEOF(xResourceReq)); \
+	req->id = (rid)
+
+/*
+ * GetEmptyReq is for those requests that have no arguments
+ * at all.
+ */
+#define GetEmptyReq(name, req) \
+	req = (xReq *) _XGetRequest(dpy, X_##name, SIZEOF(xReq))
+
+/*
+ * MakeBigReq sets the CARD16 "req->length" to 0 and inserts a new CARD32
+ * length, after req->length, before the data in the request. The new length
+ * includes the "n" extra 32-bit words.
+ *
+ * Do not use MakeBigReq if there is no data already in the request.
+ * req->length must already be >= 2.
+ */
+#ifdef LONG64
+#define MakeBigReq(req,n) \
+    { \
+    CARD64 _BRdat; \
+    CARD32 _BRlen = req->length - 1; \
+    req->length = 0; \
+    _BRdat = ((CARD32 *)req)[_BRlen]; \
+    memmove(((char *)req) + 8, ((char *)req) + 4, (_BRlen - 1) << 2); \
+    ((CARD32 *)req)[1] = _BRlen + n + 2; \
+    Data32(dpy, &_BRdat, 4); \
+    }
+#else
+#define MakeBigReq(req,n) \
+    { \
+    CARD32 _BRdat; \
+    CARD32 _BRlen = req->length - 1; \
+    req->length = 0; \
+    _BRdat = ((CARD32 *)req)[_BRlen]; \
+    memmove(((char *)req) + 8, ((char *)req) + 4, (_BRlen - 1) << 2); \
+    ((CARD32 *)req)[1] = _BRlen + n + 2; \
+    Data32(dpy, &_BRdat, 4); \
+    }
+#endif
+
+/*
+ * SetReqLen increases the count of 32-bit words in the request by "n",
+ * or by "badlen" if "n" is too large.
+ *
+ * Do not use SetReqLen if "req" does not already have data after the
+ * xReq header. req->length must already be >= 2.
+ */
+#ifndef __clang_analyzer__
+#define SetReqLen(req,n,badlen) \
+    if ((req->length + n) > (unsigned)65535) { \
+	if (dpy->bigreq_size) { \
+	    MakeBigReq(req,n) \
+	} else { \
+	    n = badlen; \
+	    req->length += n; \
+	} \
+    } else \
+	req->length += n
+#else
+#define SetReqLen(req,n,badlen) \
+    req->length += n
+#endif
+
+#define SyncHandle() \
+	if (dpy->synchandler) (*dpy->synchandler)(dpy)
+
+extern void _XFlushGCCache(Display *dpy, GC gc);
+#define FlushGC(dpy, gc) \
+	if ((gc)->dirty) _XFlushGCCache((dpy), (gc))
+/*
+ * Data - Place data in the buffer and pad the end to provide
+ * 32 bit word alignment.  Transmit if the buffer fills.
+ *
+ * "dpy" is a pointer to a Display.
+ * "data" is a pointer to a data buffer.
+ * "len" is the length of the data buffer.
+ */
+#ifndef DataRoutineIsProcedure
+#define Data(dpy, data, len) {\
+	if (dpy->bufptr + (len) <= dpy->bufmax) {\
+		memcpy(dpy->bufptr, data, (int)len);\
+		dpy->bufptr += ((len) + 3) & ~3;\
+	} else\
+		_XSend(dpy, data, len);\
+	}
+#endif /* DataRoutineIsProcedure */
+
+
+/* Allocate bytes from the buffer.  No padding is done, so if
+ * the length is not a multiple of 4, the caller must be
+ * careful to leave the buffer aligned after sending the
+ * current request.
+ *
+ * "type" is the type of the pointer being assigned to.
+ * "ptr" is the pointer being assigned to.
+ * "n" is the number of bytes to allocate.
+ *
+ * Example:
+ *    xTextElt *elt;
+ *    BufAlloc (xTextElt *, elt, nbytes)
+ */
+
+#define BufAlloc(type, ptr, n) \
+    if (dpy->bufptr + (n) > dpy->bufmax) \
+        _XFlush (dpy); \
+    ptr = (type) dpy->bufptr; \
+    memset(ptr, '\0', n); \
+    dpy->bufptr += (n);
+
+#define Data16(dpy, data, len) Data((dpy), (_Xconst char *)(data), (len))
+#define _XRead16Pad(dpy, data, len) _XReadPad((dpy), (char *)(data), (len))
+#define _XRead16(dpy, data, len) _XRead((dpy), (char *)(data), (len))
+#ifdef LONG64
+#define Data32(dpy, data, len) _XData32(dpy, (_Xconst long *)data, len)
+extern int _XData32(
+	     Display *dpy,
+             register _Xconst long *data,
+	     unsigned len
+);
+extern void _XRead32(
+	     Display *dpy,
+	     register long *data,
+	     long len
+);
+#else
+#define Data32(dpy, data, len) Data((dpy), (_Xconst char *)(data), (len))
+#define _XRead32(dpy, data, len) _XRead((dpy), (char *)(data), (len))
+#endif
+
+#define PackData16(dpy,data,len) Data16 (dpy, data, len)
+#define PackData32(dpy,data,len) Data32 (dpy, data, len)
+
+/* Xlib manual is bogus */
+#define PackData(dpy,data,len) PackData16 (dpy, data, len)
+
+#define min(a,b) (((a) < (b)) ? (a) : (b))
+#define max(a,b) (((a) > (b)) ? (a) : (b))
+
+#define CI_NONEXISTCHAR(cs) (((cs)->width == 0) && \
+			     (((cs)->rbearing|(cs)->lbearing| \
+			       (cs)->ascent|(cs)->descent) == 0))
+
+/*
+ * CI_GET_CHAR_INFO_1D - return the charinfo struct for the indicated 8bit
+ * character.  If the character is in the column and exists, then return the
+ * appropriate metrics (note that fonts with common per-character metrics will
+ * return min_bounds).  If none of these hold true, try again with the default
+ * char.
+ */
+#define CI_GET_CHAR_INFO_1D(fs,col,def,cs) \
+{ \
+    cs = def; \
+    if (col >= fs->min_char_or_byte2 && col <= fs->max_char_or_byte2) { \
+	if (fs->per_char == NULL) { \
+	    cs = &fs->min_bounds; \
+	} else { \
+	    cs = &fs->per_char[(col - fs->min_char_or_byte2)]; \
+	    if (CI_NONEXISTCHAR(cs)) cs = def; \
+	} \
+    } \
+}
+
+#define CI_GET_DEFAULT_INFO_1D(fs,cs) \
+  CI_GET_CHAR_INFO_1D (fs, fs->default_char, NULL, cs)
+
+
+
+/*
+ * CI_GET_CHAR_INFO_2D - return the charinfo struct for the indicated row and
+ * column.  This is used for fonts that have more than row zero.
+ */
+#define CI_GET_CHAR_INFO_2D(fs,row,col,def,cs) \
+{ \
+    cs = def; \
+    if (row >= fs->min_byte1 && row <= fs->max_byte1 && \
+	col >= fs->min_char_or_byte2 && col <= fs->max_char_or_byte2) { \
+	if (fs->per_char == NULL) { \
+	    cs = &fs->min_bounds; \
+	} else { \
+	    cs = &fs->per_char[((row - fs->min_byte1) * \
+			        (fs->max_char_or_byte2 - \
+				 fs->min_char_or_byte2 + 1)) + \
+			       (col - fs->min_char_or_byte2)]; \
+	    if (CI_NONEXISTCHAR(cs)) cs = def; \
+        } \
+    } \
+}
+
+#define CI_GET_DEFAULT_INFO_2D(fs,cs) \
+{ \
+    unsigned int r = (fs->default_char >> 8); \
+    unsigned int c = (fs->default_char & 0xff); \
+    CI_GET_CHAR_INFO_2D (fs, r, c, NULL, cs); \
+}
+
+
+/* srcvar must be a variable for large architecture version */
+#define OneDataCard32(dpy,dstaddr,srcvar) \
+  { *(CARD32 *)(dstaddr) = (srcvar); }
+
+
+typedef struct _XInternalAsync {
+    struct _XInternalAsync *next;
+    /*
+     * handler arguments:
+     * rep is the generic reply that caused this handler
+     * to be invoked.  It must also be passed to _XGetAsyncReply.
+     * buf and len are opaque values that must be passed to
+     * _XGetAsyncReply or _XGetAsyncData.
+     * data is the closure stored in this struct.
+     * The handler returns True iff it handled this reply.
+     */
+    Bool (*handler)(
+		    Display*	/* dpy */,
+		    xReply*	/* rep */,
+		    char*	/* buf */,
+		    int		/* len */,
+		    XPointer	/* data */
+		    );
+    XPointer data;
+} _XAsyncHandler;
+
+typedef struct _XAsyncEState {
+    unsigned long min_sequence_number;
+    unsigned long max_sequence_number;
+    unsigned char error_code;
+    unsigned char major_opcode;
+    unsigned short minor_opcode;
+    unsigned char last_error_received;
+    int error_count;
+} _XAsyncErrorState;
+
+extern void _XDeqAsyncHandler(Display *dpy, _XAsyncHandler *handler);
+#define DeqAsyncHandler(dpy,handler) { \
+    if (dpy->async_handlers == (handler)) \
+	dpy->async_handlers = (handler)->next; \
+    else \
+	_XDeqAsyncHandler(dpy, handler); \
+    }
+
+typedef void (*FreeFuncType) (
+    Display*	/* display */
+);
+
+typedef int (*FreeModmapType) (
+    XModifierKeymap*	/* modmap */
+);
+
+/*
+ * This structure is private to the library.
+ */
+typedef struct _XFreeFuncs {
+    FreeFuncType atoms;		/* _XFreeAtomTable */
+    FreeModmapType modifiermap;	/* XFreeModifiermap */
+    FreeFuncType key_bindings;	/* _XFreeKeyBindings */
+    FreeFuncType context_db;	/* _XFreeContextDB */
+    FreeFuncType defaultCCCs;	/* _XcmsFreeDefaultCCCs */
+    FreeFuncType clientCmaps;	/* _XcmsFreeClientCmaps */
+    FreeFuncType intensityMaps;	/* _XcmsFreeIntensityMaps */
+    FreeFuncType im_filters;	/* _XFreeIMFilters */
+    FreeFuncType xkb;		/* _XkbFreeInfo */
+} _XFreeFuncRec;
+
+/* types for InitExt.c */
+typedef int (*CreateGCType) (
+    Display*	/* display */,
+    GC		/* gc */,
+    XExtCodes*	/* codes */
+);
+
+typedef int (*CopyGCType)(
+    Display*	/* display */,
+    GC		/* gc */,
+    XExtCodes*	/* codes */
+);
+
+typedef int (*FlushGCType) (
+    Display*	/* display */,
+    GC		/* gc */,
+    XExtCodes*	/* codes */
+);
+
+typedef int (*FreeGCType) (
+    Display*	/* display */,
+    GC		/* gc */,
+    XExtCodes*	/* codes */
+);
+
+typedef int (*CreateFontType) (
+    Display*	/* display */,
+    XFontStruct* /* fs */,
+    XExtCodes*	/* codes */
+);
+
+typedef int (*FreeFontType) (
+    Display*	/* display */,
+    XFontStruct* /* fs */,
+    XExtCodes*	/* codes */
+);
+
+typedef int (*CloseDisplayType) (
+    Display*	/* display */,
+    XExtCodes*	/* codes */
+);
+
+typedef int (*ErrorType) (
+    Display*	/* display */,
+    xError*	/* err */,
+    XExtCodes*	/* codes */,
+    int*	/* ret_code */
+);
+
+typedef char* (*ErrorStringType) (
+    Display*	/* display */,
+    int		/* code */,
+    XExtCodes*	/* codes */,
+    char*	/* buffer */,
+    int		/* nbytes */
+);
+
+typedef void (*PrintErrorType)(
+    Display*	/* display */,
+    XErrorEvent* /* ev */,
+    void*	/* fp */
+);
+
+typedef void (*BeforeFlushType)(
+    Display*	/* display */,
+    XExtCodes*	/* codes */,
+    _Xconst char* /* data */,
+    long	/* len */
+);
+
+/*
+ * This structure is private to the library.
+ */
+typedef struct _XExten {		/* private to extension mechanism */
+	struct _XExten *next;		/* next in list */
+	XExtCodes codes;		/* public information, all extension told */
+	CreateGCType create_GC;		/* routine to call when GC created */
+	CopyGCType copy_GC;		/* routine to call when GC copied */
+	FlushGCType flush_GC;		/* routine to call when GC flushed */
+	FreeGCType free_GC;		/* routine to call when GC freed */
+	CreateFontType create_Font;	/* routine to call when Font created */
+	FreeFontType free_Font;		/* routine to call when Font freed */
+	CloseDisplayType close_display;	/* routine to call when connection closed */
+	ErrorType error;		/* who to call when an error occurs */
+	ErrorStringType error_string;	/* routine to supply error string */
+	char *name;			/* name of this extension */
+	PrintErrorType error_values;	/* routine to supply error values */
+	BeforeFlushType before_flush;	/* routine to call when sending data */
+	struct _XExten *next_flush;	/* next in list of those with flushes */
+} _XExtension;
+
+/* Temporary definition until we can depend on an xproto release with it */
+#ifdef _X_COLD
+# define _XLIB_COLD _X_COLD
+#elif defined(__GNUC__) && ((__GNUC__ * 100 + __GNUC_MINOR__) >= 403) /* 4.3+ */
+# define _XLIB_COLD __attribute__((__cold__))
+#else
+# define _XLIB_COLD /* nothing */
+#endif
+
+/* extension hooks */
+
+#ifdef DataRoutineIsProcedure
+extern void Data(Display *dpy, char *data, long len);
+#endif
+extern int _XError(
+    Display*	/* dpy */,
+    xError*	/* rep */
+);
+extern int _XIOError(
+    Display*	/* dpy */
+#ifdef NX_TRANS_SOCKET
+);
+#else
+) _X_NORETURN;
+#endif /* NX_TRANS_SOCKET */
+
+extern int (*_XIOErrorFunction)(
+    Display*	/* dpy */
+);
+extern int (*_XErrorFunction)(
+    Display*		/* dpy */,
+    XErrorEvent*	/* error_event */
+);
+extern void _XEatData(
+    Display*		/* dpy */,
+    unsigned long	/* n */
+) _XLIB_COLD;
+extern void _XEatDataWords(
+    Display*		/* dpy */,
+    unsigned long	/* n */
+) _XLIB_COLD;
+#if defined(__SUNPRO_C) /* Studio compiler alternative to "cold" attribute */
+# pragma rarely_called(_XEatData, _XEatDataWords)
+#endif
+extern char *_XAllocScratch(
+    Display*		/* dpy */,
+    unsigned long	/* nbytes */
+);
+extern char *_XAllocTemp(
+    Display*		/* dpy */,
+    unsigned long	/* nbytes */
+);
+extern void _XFreeTemp(
+    Display*		/* dpy */,
+    char*		/* buf */,
+    unsigned long	/* nbytes */
+);
+extern Visual *_XVIDtoVisual(
+    Display*	/* dpy */,
+    VisualID	/* id */
+);
+extern unsigned long _XSetLastRequestRead(
+    Display*		/* dpy */,
+    xGenericReply*	/* rep */
+);
+extern int _XGetHostname(
+    char*	/* buf */,
+    int		/* maxlen */
+);
+extern Screen *_XScreenOfWindow(
+    Display*	/* dpy */,
+    Window	/* w */
+);
+extern Bool _XAsyncErrorHandler(
+    Display*	/* dpy */,
+    xReply*	/* rep */,
+    char*	/* buf */,
+    int		/* len */,
+    XPointer	/* data */
+);
+extern char *_XGetAsyncReply(
+    Display*	/* dpy */,
+    char*	/* replbuf */,
+    xReply*	/* rep */,
+    char*	/* buf */,
+    int		/* len */,
+    int		/* extra */,
+    Bool	/* discard */
+);
+extern void _XGetAsyncData(
+    Display*	/* dpy */,
+    char *	/* data */,
+    char *	/* buf */,
+    int		/* len */,
+    int		/* skip */,
+    int		/* datalen */,
+    int		/* discardtotal */
+);
+extern void _XFlush(
+    Display*	/* dpy */
+);
+extern int _XEventsQueued(
+    Display*	/* dpy */,
+    int 	/* mode */
+);
+extern void _XReadEvents(
+    Display*	/* dpy */
+);
+extern int _XRead(
+    Display*	/* dpy */,
+    char*	/* data */,
+    long	/* size */
+);
+extern void _XReadPad(
+    Display*	/* dpy */,
+    char*	/* data */,
+    long	/* size */
+);
+extern void _XSend(
+    Display*		/* dpy */,
+    _Xconst char*	/* data */,
+    long		/* size */
+);
+extern Status _XReply(
+    Display*	/* dpy */,
+    xReply*	/* rep */,
+    int		/* extra */,
+    Bool	/* discard */
+);
+extern void _XEnq(
+    Display*	/* dpy */,
+    xEvent*	/* event */
+);
+extern void _XDeq(
+    Display*	/* dpy */,
+    _XQEvent*	/* prev */,
+    _XQEvent*	/* qelt */
+);
+
+extern Bool _XUnknownWireEvent(
+    Display*	/* dpy */,
+    XEvent*	/* re */,
+    xEvent*	/* event */
+);
+
+extern Bool _XUnknownWireEventCookie(
+    Display*	/* dpy */,
+    XGenericEventCookie*	/* re */,
+    xEvent*	/* event */
+);
+
+extern Bool _XUnknownCopyEventCookie(
+    Display*	/* dpy */,
+    XGenericEventCookie*	/* in */,
+    XGenericEventCookie*	/* out */
+);
+
+extern Status _XUnknownNativeEvent(
+    Display*	/* dpy */,
+    XEvent*	/* re */,
+    xEvent*	/* event */
+);
+
+extern Bool _XWireToEvent(Display *dpy, XEvent *re, xEvent *event);
+extern Bool _XDefaultWireError(Display *display, XErrorEvent *he, xError *we);
+extern Bool _XPollfdCacheInit(Display *dpy);
+extern void _XPollfdCacheAdd(Display *dpy, int fd);
+extern void _XPollfdCacheDel(Display *dpy, int fd);
+extern XID _XAllocID(Display *dpy);
+extern void _XAllocIDs(Display *dpy, XID *ids, int count);
+
+extern int _XFreeExtData(
+    XExtData*	/* extension */
+);
+
+extern int (*XESetCreateGC(
+    Display*		/* display */,
+    int			/* extension */,
+    int (*) (
+	      Display*			/* display */,
+	      GC			/* gc */,
+	      XExtCodes*		/* codes */
+	    )		/* proc */
+))(
+    Display*, GC, XExtCodes*
+);
+
+extern int (*XESetCopyGC(
+    Display*		/* display */,
+    int			/* extension */,
+    int (*) (
+	      Display*			/* display */,
+              GC			/* gc */,
+              XExtCodes*		/* codes */
+            )		/* proc */
+))(
+    Display*, GC, XExtCodes*
+);
+
+extern int (*XESetFlushGC(
+    Display*		/* display */,
+    int			/* extension */,
+    int (*) (
+	      Display*			/* display */,
+              GC			/* gc */,
+              XExtCodes*		/* codes */
+            )		/* proc */
+))(
+    Display*, GC, XExtCodes*
+);
+
+extern int (*XESetFreeGC(
+    Display*		/* display */,
+    int			/* extension */,
+    int (*) (
+	      Display*			/* display */,
+              GC			/* gc */,
+              XExtCodes*		/* codes */
+            )		/* proc */
+))(
+    Display*, GC, XExtCodes*
+);
+
+extern int (*XESetCreateFont(
+    Display*		/* display */,
+    int			/* extension */,
+    int (*) (
+	      Display*			/* display */,
+              XFontStruct*		/* fs */,
+              XExtCodes*		/* codes */
+            )		/* proc */
+))(
+    Display*, XFontStruct*, XExtCodes*
+);
+
+extern int (*XESetFreeFont(
+    Display*		/* display */,
+    int			/* extension */,
+    int (*) (
+	      Display*			/* display */,
+              XFontStruct*		/* fs */,
+              XExtCodes*		/* codes */
+            )		/* proc */
+))(
+    Display*, XFontStruct*, XExtCodes*
+);
+
+extern int (*XESetCloseDisplay(
+    Display*		/* display */,
+    int			/* extension */,
+    int (*) (
+	      Display*			/* display */,
+              XExtCodes*		/* codes */
+            )		/* proc */
+))(
+    Display*, XExtCodes*
+);
+
+extern int (*XESetError(
+    Display*		/* display */,
+    int			/* extension */,
+    int (*) (
+	      Display*			/* display */,
+              xError*			/* err */,
+              XExtCodes*		/* codes */,
+              int*			/* ret_code */
+            )		/* proc */
+))(
+    Display*, xError*, XExtCodes*, int*
+);
+
+extern char* (*XESetErrorString(
+    Display*		/* display */,
+    int			/* extension */,
+    char* (*) (
+	        Display*		/* display */,
+                int			/* code */,
+                XExtCodes*		/* codes */,
+                char*			/* buffer */,
+                int			/* nbytes */
+              )		/* proc */
+))(
+    Display*, int, XExtCodes*, char*, int
+);
+
+extern void (*XESetPrintErrorValues (
+    Display*		/* display */,
+    int			/* extension */,
+    void (*)(
+	      Display*			/* display */,
+	      XErrorEvent*		/* ev */,
+	      void*			/* fp */
+	     )		/* proc */
+))(
+    Display*, XErrorEvent*, void*
+);
+
+extern Bool (*XESetWireToEvent(
+    Display*		/* display */,
+    int			/* event_number */,
+    Bool (*) (
+	       Display*			/* display */,
+               XEvent*			/* re */,
+               xEvent*			/* event */
+             )		/* proc */
+))(
+    Display*, XEvent*, xEvent*
+);
+
+extern Bool (*XESetWireToEventCookie(
+    Display*		/* display */,
+    int			/* extension */,
+    Bool (*) (
+	       Display*			/* display */,
+               XGenericEventCookie*	/* re */,
+               xEvent*			/* event */
+             )		/* proc */
+))(
+    Display*, XGenericEventCookie*, xEvent*
+);
+
+extern Bool (*XESetCopyEventCookie(
+    Display*		/* display */,
+    int			/* extension */,
+    Bool (*) (
+	       Display*			/* display */,
+               XGenericEventCookie*	/* in */,
+               XGenericEventCookie*	/* out */
+             )		/* proc */
+))(
+    Display*, XGenericEventCookie*, XGenericEventCookie*
+);
+
+
+extern Status (*XESetEventToWire(
+    Display*		/* display */,
+    int			/* event_number */,
+    Status (*) (
+	      Display*			/* display */,
+              XEvent*			/* re */,
+              xEvent*			/* event */
+            )		/* proc */
+))(
+    Display*, XEvent*, xEvent*
+);
+
+extern Bool (*XESetWireToError(
+    Display*		/* display */,
+    int			/* error_number */,
+    Bool (*) (
+	       Display*			/* display */,
+	       XErrorEvent*		/* he */,
+	       xError*			/* we */
+            )		/* proc */
+))(
+    Display*, XErrorEvent*, xError*
+);
+
+extern void (*XESetBeforeFlush(
+    Display*		/* display */,
+    int			/* error_number */,
+    void (*) (
+	       Display*			/* display */,
+	       XExtCodes*		/* codes */,
+	       _Xconst char*		/* data */,
+	       long			/* len */
+            )		/* proc */
+))(
+    Display*, XExtCodes*, _Xconst char*, long
+);
+
+/* internal connections for IMs */
+
+typedef void (*_XInternalConnectionProc)(
+    Display*			/* dpy */,
+    int				/* fd */,
+    XPointer			/* call_data */
+);
+
+
+extern Status _XRegisterInternalConnection(
+    Display*			/* dpy */,
+    int				/* fd */,
+    _XInternalConnectionProc	/* callback */,
+    XPointer			/* call_data */
+);
+
+extern void _XUnregisterInternalConnection(
+    Display*			/* dpy */,
+    int				/* fd */
+);
+
+extern void _XProcessInternalConnection(
+    Display*			/* dpy */,
+    struct _XConnectionInfo*	/* conn_info */
+);
+
+/* Display structure has pointers to these */
+
+struct _XConnectionInfo {	/* info from _XRegisterInternalConnection */
+    int fd;
+    _XInternalConnectionProc read_callback;
+    XPointer call_data;
+    XPointer *watch_data;	/* set/used by XConnectionWatchProc */
+    struct _XConnectionInfo *next;
+};
+
+struct _XConnWatchInfo {	/* info from XAddConnectionWatch */
+    XConnectionWatchProc fn;
+    XPointer client_data;
+    struct _XConnWatchInfo *next;
+};
+
+extern int _XTextHeight(
+    XFontStruct*	/* font_struct */,
+    _Xconst char*	/* string */,
+    int			/* count */
+);
+
+extern int _XTextHeight16(
+    XFontStruct*	/* font_struct */,
+    _Xconst XChar2b*	/* string */,
+    int			/* count */
+);
+
+#if defined(WIN32)
+
+extern int _XOpenFile(
+    _Xconst char*	/* path */,
+    int			/* flags */
+);
+
+extern int _XOpenFileMode(
+    _Xconst char*	/* path */,
+    int			/* flags */,
+    mode_t              /* mode */
+);
+
+extern void* _XFopenFile(
+    _Xconst char*	/* path */,
+    _Xconst char*	/* mode */
+);
+
+extern int _XAccessFile(
+    _Xconst char*	/* path */
+);
+#else
+#define _XOpenFile(path,flags) open(path,flags)
+#define _XOpenFileMode(path,flags,mode) open(path,flags,mode)
+#define _XFopenFile(path,mode) fopen(path,mode)
+#endif
+
+/* EvToWire.c */
+extern Status _XEventToWire(Display *dpy, XEvent *re, xEvent *event);
+
+extern int _XF86LoadQueryLocaleFont(
+    Display*		/* dpy */,
+    _Xconst char*	/* name*/,
+    XFontStruct**	/* xfp*/,
+    Font*		/* fidp */
+);
+
+extern void _XProcessWindowAttributes (
+    register Display *dpy,
+    xChangeWindowAttributesReq *req,
+    register unsigned long valuemask,
+    register XSetWindowAttributes *attributes);
+
+extern int _XDefaultError(
+        Display *dpy,
+        XErrorEvent *event);
+
+extern int _XDefaultIOError(
+        Display *dpy);
+
+extern void _XSetClipRectangles (
+    register Display *dpy,
+    GC gc,
+    int clip_x_origin, int clip_y_origin,
+    XRectangle *rectangles,
+    int n,
+    int ordering);
+
+Status _XGetWindowAttributes(
+    register Display *dpy,
+    Window w,
+    XWindowAttributes *attr);
+
+int _XPutBackEvent (
+    register Display *dpy,
+    register XEvent *event);
+
+extern Bool _XIsEventCookie(
+        Display *dpy,
+        XEvent *ev);
+
+extern void _XFreeEventCookies(
+        Display *dpy);
+
+extern void _XStoreEventCookie(
+        Display *dpy,
+        XEvent *ev);
+
+extern Bool _XFetchEventCookie(
+        Display *dpy,
+        XGenericEventCookie *ev);
+
+extern Bool _XCopyEventCookie(
+        Display *dpy,
+        XGenericEventCookie *in,
+        XGenericEventCookie *out);
+
+/* lcFile.c */
+
+extern void xlocaledir(
+    char *buf,
+    int buf_len
+);
+
+#ifdef __clang__
+#pragma clang diagnostic pop
+#endif
+
+_XFUNCPROTOEND
+
+#endif /* !defined(_X11_XLIBINT_H_) && !defined(_XLIBINT_H_) */
diff --git a/nx-X11/lib/include/X11/Xlocale.h b/nx-X11/lib/include/X11/Xlocale.h
new file mode 100644
index 000000000..4ac9bac30
--- /dev/null
+++ b/nx-X11/lib/include/X11/Xlocale.h
@@ -0,0 +1,38 @@
+/*
+
+Copyright 1991, 1998  The Open Group
+
+Permission to use, copy, modify, distribute, and sell this software and its
+documentation for any purpose is hereby granted without fee, provided that
+the above copyright notice appear in all copies and that both that
+copyright notice and this permission notice appear in supporting
+documentation.
+
+The above copyright notice and this permission notice shall be included
+in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR
+OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.
+
+Except as contained in this notice, the name of The Open Group shall
+not be used in advertising or otherwise to promote the sale, use or
+other dealings in this Software without prior written authorization
+from The Open Group.
+
+*/
+
+#if !defined(_X11_XLOCALE_H_) && !defined(_XLOCALE_H_)
+#define _X11_XLOCALE_H_
+#define _XLOCALE_H_
+
+#include <nx-X11/Xfuncproto.h>
+#include <nx-X11/Xosdefs.h>
+
+#include <locale.h>
+
+#endif /* !defined(_X11_XLOCALE_H_) && !defined(_XLOCALE_H_) */
diff --git a/nx-X11/lib/include/X11/Xregion.h b/nx-X11/lib/include/X11/Xregion.h
new file mode 100644
index 000000000..4f55af82f
--- /dev/null
+++ b/nx-X11/lib/include/X11/Xregion.h
@@ -0,0 +1,191 @@
+/************************************************************************
+
+Copyright 1987, 1998  The Open Group
+
+Permission to use, copy, modify, distribute, and sell this software and its
+documentation for any purpose is hereby granted without fee, provided that
+the above copyright notice appear in all copies and that both that
+copyright notice and this permission notice appear in supporting
+documentation.
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
+AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+Except as contained in this notice, the name of The Open Group shall not be
+used in advertising or otherwise to promote the sale, use or other dealings
+in this Software without prior written authorization from The Open Group.
+
+
+Copyright 1987 by Digital Equipment Corporation, Maynard, Massachusetts.
+
+                        All Rights Reserved
+
+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 Digital not be
+used in advertising or publicity pertaining to distribution of the
+software without specific, written prior permission.
+
+DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
+ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
+DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
+ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
+WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
+ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
+SOFTWARE.
+
+************************************************************************/
+
+#if !defined(_X11_XREGION_H_) && !defined(_XREGION_H)
+#define _X11_XREGION_H_
+#define _XREGION_H
+
+typedef struct {
+    short x1, x2, y1, y2;
+} Box, BOX, BoxRec, *BoxPtr;
+
+typedef struct {
+    short x, y, width, height;
+}RECTANGLE, RectangleRec, *RectanglePtr;
+
+#define TRUE 1
+#define FALSE 0
+#define MAXSHORT 32767
+#define MINSHORT -MAXSHORT
+#ifndef MAX
+#define MAX(a,b) (((a) > (b)) ? (a) : (b))
+#endif
+#ifndef MIN
+#define MIN(a,b) (((a) < (b)) ? (a) : (b))
+#endif
+
+
+/*
+ *   clip region
+ */
+
+typedef struct _XRegion {
+    long size;
+    long numRects;
+    BOX *rects;
+    BOX extents;
+} REGION;
+
+/* Xutil.h contains the declaration:
+ * typedef struct _XRegion *Region;
+ */
+
+/*  1 if two BOXs overlap.
+ *  0 if two BOXs do not overlap.
+ *  Remember, x2 and y2 are not in the region
+ */
+#define EXTENTCHECK(r1, r2) \
+	((r1)->x2 > (r2)->x1 && \
+	 (r1)->x1 < (r2)->x2 && \
+	 (r1)->y2 > (r2)->y1 && \
+	 (r1)->y1 < (r2)->y2)
+
+/*
+ *  update region extents
+ */
+#define EXTENTS(r,idRect){\
+            if((r)->x1 < (idRect)->extents.x1)\
+              (idRect)->extents.x1 = (r)->x1;\
+            if((r)->y1 < (idRect)->extents.y1)\
+              (idRect)->extents.y1 = (r)->y1;\
+            if((r)->x2 > (idRect)->extents.x2)\
+              (idRect)->extents.x2 = (r)->x2;\
+            if((r)->y2 > (idRect)->extents.y2)\
+              (idRect)->extents.y2 = (r)->y2;\
+        }
+
+/*
+ *   Check to see if there is enough memory in the present region.
+ */
+#define MEMCHECK(reg, rect, firstrect){\
+        if ((reg)->numRects >= ((reg)->size - 1)){\
+          BoxPtr tmpRect = Xrealloc ((firstrect), \
+                                     (2 * (sizeof(BOX)) * ((reg)->size))); \
+          if (tmpRect == NULL) \
+            return(0);\
+          (firstrect) = tmpRect; \
+          (reg)->size *= 2;\
+          (rect) = &(firstrect)[(reg)->numRects];\
+         }\
+       }
+
+/*  this routine checks to see if the previous rectangle is the same
+ *  or subsumes the new rectangle to add.
+ */
+
+#define CHECK_PREVIOUS(Reg, R, Rx1, Ry1, Rx2, Ry2)\
+               (!(((Reg)->numRects > 0)&&\
+                  ((R-1)->y1 == (Ry1)) &&\
+                  ((R-1)->y2 == (Ry2)) &&\
+                  ((R-1)->x1 <= (Rx1)) &&\
+                  ((R-1)->x2 >= (Rx2))))
+
+/*  add a rectangle to the given Region */
+#define ADDRECT(reg, r, rx1, ry1, rx2, ry2){\
+    if (((rx1) < (rx2)) && ((ry1) < (ry2)) &&\
+        CHECK_PREVIOUS((reg), (r), (rx1), (ry1), (rx2), (ry2))){\
+              (r)->x1 = (rx1);\
+              (r)->y1 = (ry1);\
+              (r)->x2 = (rx2);\
+              (r)->y2 = (ry2);\
+              EXTENTS((r), (reg));\
+              (reg)->numRects++;\
+              (r)++;\
+            }\
+        }
+
+
+
+/*  add a rectangle to the given Region */
+#define ADDRECTNOX(reg, r, rx1, ry1, rx2, ry2){\
+            if ((rx1 < rx2) && (ry1 < ry2) &&\
+                CHECK_PREVIOUS((reg), (r), (rx1), (ry1), (rx2), (ry2))){\
+              (r)->x1 = (rx1);\
+              (r)->y1 = (ry1);\
+              (r)->x2 = (rx2);\
+              (r)->y2 = (ry2);\
+              (reg)->numRects++;\
+              (r)++;\
+            }\
+        }
+
+#define EMPTY_REGION(pReg) pReg->numRects = 0
+
+#define REGION_NOT_EMPTY(pReg) pReg->numRects
+
+#define INBOX(r, x, y) \
+      ( ( ((r).x2 >  x)) && \
+        ( ((r).x1 <= x)) && \
+        ( ((r).y2 >  y)) && \
+        ( ((r).y1 <= y)) )
+
+/*
+ * number of points to buffer before sending them off
+ * to scanlines() :  Must be an even number
+ */
+#define NUMPTSTOBUFFER 200
+
+/*
+ * used to allocate buffers for points and link
+ * the buffers together
+ */
+typedef struct _POINTBLOCK {
+    XPoint pts[NUMPTSTOBUFFER];
+    struct _POINTBLOCK *next;
+} POINTBLOCK;
+
+#endif /* !defined(_X11_XREGION_H_) && !defined(_XREGION_H) */
diff --git a/nx-X11/lib/include/X11/Xresource.h b/nx-X11/lib/include/X11/Xresource.h
new file mode 100644
index 000000000..f3977a209
--- /dev/null
+++ b/nx-X11/lib/include/X11/Xresource.h
@@ -0,0 +1,359 @@
+
+/***********************************************************
+
+Copyright 1987, 1988, 1998  The Open Group
+
+Permission to use, copy, modify, distribute, and sell this software and its
+documentation for any purpose is hereby granted without fee, provided that
+the above copyright notice appear in all copies and that both that
+copyright notice and this permission notice appear in supporting
+documentation.
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
+AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+Except as contained in this notice, the name of The Open Group shall not be
+used in advertising or otherwise to promote the sale, use or other dealings
+in this Software without prior written authorization from The Open Group.
+
+
+Copyright 1987, 1988 by Digital Equipment Corporation, Maynard, Massachusetts.
+
+                        All Rights Reserved
+
+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 Digital not be
+used in advertising or publicity pertaining to distribution of the
+software without specific, written prior permission.
+
+DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
+ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
+DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
+ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
+WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
+ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
+SOFTWARE.
+
+******************************************************************/
+
+#if !defined(_X11_XRESOURCE_H_) && !defined(_XRESOURCE_H_)
+#define _X11_XRESOURCE_H_
+#define _XRESOURCE_H_
+
+#ifndef _XP_PRINT_SERVER_
+#include <nx-X11/Xlib.h>
+#endif
+
+/****************************************************************
+ ****************************************************************
+ ***                                                          ***
+ ***                                                          ***
+ ***          X Resource Manager Intrinsics                   ***
+ ***                                                          ***
+ ***                                                          ***
+ ****************************************************************
+ ****************************************************************/
+
+_XFUNCPROTOBEGIN
+
+/****************************************************************
+ *
+ * Memory Management
+ *
+ ****************************************************************/
+
+extern char *Xpermalloc(
+    unsigned int	/* size */
+);
+
+/****************************************************************
+ *
+ * Quark Management
+ *
+ ****************************************************************/
+
+typedef int       XrmQuark, *XrmQuarkList;
+#define NULLQUARK ((XrmQuark) 0)
+
+typedef char *XrmString;
+#define NULLSTRING ((XrmString) 0)
+
+/* find quark for string, create new quark if none already exists */
+extern XrmQuark XrmStringToQuark(
+    _Xconst char* 	/* string */
+);
+
+extern XrmQuark XrmPermStringToQuark(
+    _Xconst char* 	/* string */
+);
+
+/* find string for quark */
+extern XrmString XrmQuarkToString(
+    XrmQuark 		/* quark */
+);
+
+extern XrmQuark XrmUniqueQuark(
+    void
+);
+
+#define XrmStringsEqual(a1, a2) (strcmp(a1, a2) == 0)
+
+
+/****************************************************************
+ *
+ * Conversion of Strings to Lists
+ *
+ ****************************************************************/
+
+typedef enum {XrmBindTightly, XrmBindLoosely} XrmBinding, *XrmBindingList;
+
+extern void XrmStringToQuarkList(
+    _Xconst char*	/* string */,
+    XrmQuarkList	/* quarks_return */
+);
+
+extern void XrmStringToBindingQuarkList(
+    _Xconst char*	/* string */,
+    XrmBindingList	/* bindings_return */,
+    XrmQuarkList	/* quarks_return */
+);
+
+/****************************************************************
+ *
+ * Name and Class lists.
+ *
+ ****************************************************************/
+
+typedef XrmQuark     XrmName;
+typedef XrmQuarkList XrmNameList;
+#define XrmNameToString(name)		XrmQuarkToString(name)
+#define XrmStringToName(string)		XrmStringToQuark(string)
+#define XrmStringToNameList(str, name)	XrmStringToQuarkList(str, name)
+
+typedef XrmQuark     XrmClass;
+typedef XrmQuarkList XrmClassList;
+#define XrmClassToString(c_class)	XrmQuarkToString(c_class)
+#define XrmStringToClass(c_class)	XrmStringToQuark(c_class)
+#define XrmStringToClassList(str,c_class) XrmStringToQuarkList(str, c_class)
+
+
+
+/****************************************************************
+ *
+ * Resource Representation Types and Values
+ *
+ ****************************************************************/
+
+typedef XrmQuark     XrmRepresentation;
+#define XrmStringToRepresentation(string)   XrmStringToQuark(string)
+#define	XrmRepresentationToString(type)   XrmQuarkToString(type)
+
+typedef struct {
+    unsigned int    size;
+    XPointer	    addr;
+} XrmValue, *XrmValuePtr;
+
+
+/****************************************************************
+ *
+ * Resource Manager Functions
+ *
+ ****************************************************************/
+
+typedef struct _XrmHashBucketRec *XrmHashBucket;
+typedef XrmHashBucket *XrmHashTable;
+typedef XrmHashTable XrmSearchList[];
+typedef struct _XrmHashBucketRec *XrmDatabase;
+
+
+extern void XrmDestroyDatabase(
+    XrmDatabase		/* database */
+);
+
+extern void XrmQPutResource(
+    XrmDatabase*	/* database */,
+    XrmBindingList	/* bindings */,
+    XrmQuarkList	/* quarks */,
+    XrmRepresentation	/* type */,
+    XrmValue*		/* value */
+);
+
+extern void XrmPutResource(
+    XrmDatabase*	/* database */,
+    _Xconst char*	/* specifier */,
+    _Xconst char*	/* type */,
+    XrmValue*		/* value */
+);
+
+extern void XrmQPutStringResource(
+    XrmDatabase*	/* database */,
+    XrmBindingList      /* bindings */,
+    XrmQuarkList	/* quarks */,
+    _Xconst char*	/* value */
+);
+
+extern void XrmPutStringResource(
+    XrmDatabase*	/* database */,
+    _Xconst char*	/* specifier */,
+    _Xconst char*	/* value */
+);
+
+extern void XrmPutLineResource(
+    XrmDatabase*	/* database */,
+    _Xconst char*	/* line */
+);
+
+extern Bool XrmQGetResource(
+    XrmDatabase		/* database */,
+    XrmNameList		/* quark_name */,
+    XrmClassList	/* quark_class */,
+    XrmRepresentation*	/* quark_type_return */,
+    XrmValue*		/* value_return */
+);
+
+extern Bool XrmGetResource(
+    XrmDatabase		/* database */,
+    _Xconst char*	/* str_name */,
+    _Xconst char*	/* str_class */,
+    char**		/* str_type_return */,
+    XrmValue*		/* value_return */
+);
+
+extern Bool XrmQGetSearchList(
+    XrmDatabase		/* database */,
+    XrmNameList		/* names */,
+    XrmClassList	/* classes */,
+    XrmSearchList	/* list_return */,
+    int			/* list_length */
+);
+
+extern Bool XrmQGetSearchResource(
+    XrmSearchList	/* list */,
+    XrmName		/* name */,
+    XrmClass		/* class */,
+    XrmRepresentation*	/* type_return */,
+    XrmValue*		/* value_return */
+);
+
+/****************************************************************
+ *
+ * Resource Database Management
+ *
+ ****************************************************************/
+
+#ifndef _XP_PRINT_SERVER_
+
+extern void XrmSetDatabase(
+    Display*		/* display */,
+    XrmDatabase		/* database */
+);
+
+extern XrmDatabase XrmGetDatabase(
+    Display*		/* display */
+);
+
+#endif /* !_XP_PRINT_SERVER_ */
+
+extern XrmDatabase XrmGetFileDatabase(
+    _Xconst char*	/* filename */
+);
+
+extern Status XrmCombineFileDatabase(
+    _Xconst char* 	/* filename */,
+    XrmDatabase*	/* target */,
+    Bool		/* override */
+);
+
+extern XrmDatabase XrmGetStringDatabase(
+    _Xconst char*	/* data */  /*  null terminated string */
+);
+
+extern void XrmPutFileDatabase(
+    XrmDatabase		/* database */,
+    _Xconst char*	/* filename */
+);
+
+extern void XrmMergeDatabases(
+    XrmDatabase		/* source_db */,
+    XrmDatabase*	/* target_db */
+);
+
+extern void XrmCombineDatabase(
+    XrmDatabase		/* source_db */,
+    XrmDatabase*	/* target_db */,
+    Bool		/* override */
+);
+
+#define XrmEnumAllLevels 0
+#define XrmEnumOneLevel  1
+
+extern Bool XrmEnumerateDatabase(
+    XrmDatabase		/* db */,
+    XrmNameList		/* name_prefix */,
+    XrmClassList	/* class_prefix */,
+    int			/* mode */,
+    Bool (*)(
+	     XrmDatabase*	/* db */,
+	     XrmBindingList	/* bindings */,
+	     XrmQuarkList	/* quarks */,
+	     XrmRepresentation*	/* type */,
+	     XrmValue*		/* value */,
+	     XPointer		/* closure */
+	     )		/* proc */,
+    XPointer		/* closure */
+);
+
+extern const char *XrmLocaleOfDatabase(
+    XrmDatabase 	/* database */
+);
+
+
+/****************************************************************
+ *
+ * Command line option mapping to resource entries
+ *
+ ****************************************************************/
+
+typedef enum {
+    XrmoptionNoArg,	/* Value is specified in OptionDescRec.value	    */
+    XrmoptionIsArg,     /* Value is the option string itself		    */
+    XrmoptionStickyArg, /* Value is characters immediately following option */
+    XrmoptionSepArg,    /* Value is next argument in argv		    */
+    XrmoptionResArg,	/* Resource and value in next argument in argv      */
+    XrmoptionSkipArg,   /* Ignore this option and the next argument in argv */
+    XrmoptionSkipLine,  /* Ignore this option and the rest of argv	    */
+    XrmoptionSkipNArgs	/* Ignore this option and the next
+			   OptionDescRes.value arguments in argv */
+} XrmOptionKind;
+
+typedef struct {
+    char	    *option;	    /* Option abbreviation in argv	    */
+    char	    *specifier;     /* Resource specifier		    */
+    XrmOptionKind   argKind;	    /* Which style of option it is	    */
+    XPointer	    value;	    /* Value to provide if XrmoptionNoArg   */
+} XrmOptionDescRec, *XrmOptionDescList;
+
+
+extern void XrmParseCommand(
+    XrmDatabase*	/* database */,
+    XrmOptionDescList	/* table */,
+    int			/* table_count */,
+    _Xconst char*	/* name */,
+    int*		/* argc_in_out */,
+    char**		/* argv_in_out */
+);
+
+_XFUNCPROTOEND
+
+#endif /* !defined(_X11_XRESOURCE_H_) && !defined(_XRESOURCE_H_) */
+/* DON'T ADD STUFF AFTER THIS #endif */
diff --git a/nx-X11/lib/include/X11/Xutil.h b/nx-X11/lib/include/X11/Xutil.h
new file mode 100644
index 000000000..48fa23cf5
--- /dev/null
+++ b/nx-X11/lib/include/X11/Xutil.h
@@ -0,0 +1,839 @@
+
+/***********************************************************
+
+Copyright 1987, 1998  The Open Group
+
+Permission to use, copy, modify, distribute, and sell this software and its
+documentation for any purpose is hereby granted without fee, provided that
+the above copyright notice appear in all copies and that both that
+copyright notice and this permission notice appear in supporting
+documentation.
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
+AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+Except as contained in this notice, the name of The Open Group shall not be
+used in advertising or otherwise to promote the sale, use or other dealings
+in this Software without prior written authorization from The Open Group.
+
+
+Copyright 1987 by Digital Equipment Corporation, Maynard, Massachusetts.
+
+                        All Rights Reserved
+
+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 Digital not be
+used in advertising or publicity pertaining to distribution of the
+software without specific, written prior permission.
+
+DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
+ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
+DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
+ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
+WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
+ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
+SOFTWARE.
+
+******************************************************************/
+
+#if !defined(_X11_XUTIL_H_) && !defined(_XUTIL_H_)
+#define _X11_XUTIL_H_
+#define _XUTIL_H_
+
+/* You must include <X11/Xlib.h> before including this file */
+#include <nx-X11/Xlib.h>
+#include <nx-X11/keysym.h>
+
+/* The Xlib structs are full of implicit padding to properly align members.
+   We can't clean that up without breaking ABI, so tell clang not to bother
+   complaining about it. */
+#ifdef __clang__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wpadded"
+#endif
+
+/*
+ * Bitmask returned by XParseGeometry().  Each bit tells if the corresponding
+ * value (x, y, width, height) was found in the parsed string.
+ */
+#define NoValue		0x0000
+#define XValue  	0x0001
+#define YValue		0x0002
+#define WidthValue  	0x0004
+#define HeightValue  	0x0008
+#define AllValues 	0x000F
+#define XNegative 	0x0010
+#define YNegative 	0x0020
+
+/*
+ * new version containing base_width, base_height, and win_gravity fields;
+ * used with WM_NORMAL_HINTS.
+ */
+typedef struct {
+    	long flags;	/* marks which fields in this structure are defined */
+	int x, y;		/* obsolete for new window mgrs, but clients */
+	int width, height;	/* should set so old wm's don't mess up */
+	int min_width, min_height;
+	int max_width, max_height;
+    	int width_inc, height_inc;
+	struct {
+		int x;	/* numerator */
+		int y;	/* denominator */
+	} min_aspect, max_aspect;
+	int base_width, base_height;		/* added by ICCCM version 1 */
+	int win_gravity;			/* added by ICCCM version 1 */
+} XSizeHints;
+
+/*
+ * The next block of definitions are for window manager properties that
+ * clients and applications use for communication.
+ */
+
+/* flags argument in size hints */
+#define USPosition	(1L << 0) /* user specified x, y */
+#define USSize		(1L << 1) /* user specified width, height */
+
+#define PPosition	(1L << 2) /* program specified position */
+#define PSize		(1L << 3) /* program specified size */
+#define PMinSize	(1L << 4) /* program specified minimum size */
+#define PMaxSize	(1L << 5) /* program specified maximum size */
+#define PResizeInc	(1L << 6) /* program specified resize increments */
+#define PAspect		(1L << 7) /* program specified min and max aspect ratios */
+#define PBaseSize	(1L << 8) /* program specified base for incrementing */
+#define PWinGravity	(1L << 9) /* program specified window gravity */
+
+/* obsolete */
+#define PAllHints (PPosition|PSize|PMinSize|PMaxSize|PResizeInc|PAspect)
+
+
+
+typedef struct {
+	long flags;	/* marks which fields in this structure are defined */
+	Bool input;	/* does this application rely on the window manager to
+			get keyboard input? */
+	int initial_state;	/* see below */
+	Pixmap icon_pixmap;	/* pixmap to be used as icon */
+	Window icon_window; 	/* window to be used as icon */
+	int icon_x, icon_y; 	/* initial position of icon */
+	Pixmap icon_mask;	/* icon mask bitmap */
+	XID window_group;	/* id of related window group */
+	/* this structure may be extended in the future */
+} XWMHints;
+
+/* definition for flags of XWMHints */
+
+#define InputHint 		(1L << 0)
+#define StateHint 		(1L << 1)
+#define IconPixmapHint		(1L << 2)
+#define IconWindowHint		(1L << 3)
+#define IconPositionHint 	(1L << 4)
+#define IconMaskHint		(1L << 5)
+#define WindowGroupHint		(1L << 6)
+#define AllHints (InputHint|StateHint|IconPixmapHint|IconWindowHint| \
+IconPositionHint|IconMaskHint|WindowGroupHint)
+#define XUrgencyHint		(1L << 8)
+
+/* definitions for initial window state */
+#define WithdrawnState 0	/* for windows that are not mapped */
+#define NormalState 1	/* most applications want to start this way */
+#define IconicState 3	/* application wants to start as an icon */
+
+/*
+ * Obsolete states no longer defined by ICCCM
+ */
+#define DontCareState 0	/* don't know or care */
+#define ZoomState 2	/* application wants to start zoomed */
+#define InactiveState 4	/* application believes it is seldom used; */
+			/* some wm's may put it on inactive menu */
+
+
+/*
+ * new structure for manipulating TEXT properties; used with WM_NAME,
+ * WM_ICON_NAME, WM_CLIENT_MACHINE, and WM_COMMAND.
+ */
+typedef struct {
+    unsigned char *value;		/* same as Property routines */
+    Atom encoding;			/* prop type */
+    int format;				/* prop data format: 8, 16, or 32 */
+    unsigned long nitems;		/* number of data items in value */
+} XTextProperty;
+
+#define XNoMemory -1
+#define XLocaleNotSupported -2
+#define XConverterNotFound -3
+
+typedef enum {
+    XStringStyle,		/* STRING */
+    XCompoundTextStyle,		/* COMPOUND_TEXT */
+    XTextStyle,			/* text in owner's encoding (current locale)*/
+    XStdICCTextStyle,		/* STRING, else COMPOUND_TEXT */
+    /* The following is an XFree86 extension, introduced in November 2000 */
+    XUTF8StringStyle		/* UTF8_STRING */
+} XICCEncodingStyle;
+
+typedef struct {
+	int min_width, min_height;
+	int max_width, max_height;
+	int width_inc, height_inc;
+} XIconSize;
+
+typedef struct {
+	char *res_name;
+	char *res_class;
+} XClassHint;
+
+#ifdef XUTIL_DEFINE_FUNCTIONS
+extern int XDestroyImage(
+        XImage *ximage);
+extern unsigned long XGetPixel(
+        XImage *ximage,
+        int x, int y);
+extern int XPutPixel(
+        XImage *ximage,
+        int x, int y,
+        unsigned long pixel);
+extern XImage *XSubImage(
+        XImage *ximage,
+        int x, int y,
+        unsigned int width, unsigned int height);
+extern int XAddPixel(
+        XImage *ximage,
+        long value);
+#else
+/*
+ * These macros are used to give some sugar to the image routines so that
+ * naive people are more comfortable with them.
+ */
+#define XDestroyImage(ximage) \
+	((*((ximage)->f.destroy_image))((ximage)))
+#define XGetPixel(ximage, x, y) \
+	((*((ximage)->f.get_pixel))((ximage), (x), (y)))
+#define XPutPixel(ximage, x, y, pixel) \
+	((*((ximage)->f.put_pixel))((ximage), (x), (y), (pixel)))
+#define XSubImage(ximage, x, y, width, height)  \
+	((*((ximage)->f.sub_image))((ximage), (x), (y), (width), (height)))
+#define XAddPixel(ximage, value) \
+	((*((ximage)->f.add_pixel))((ximage), (value)))
+#endif
+
+/*
+ * Compose sequence status structure, used in calling XLookupString.
+ */
+typedef struct _XComposeStatus {
+    XPointer compose_ptr;	/* state table pointer */
+    int chars_matched;		/* match state */
+} XComposeStatus;
+
+/*
+ * Keysym macros, used on Keysyms to test for classes of symbols
+ */
+#define IsKeypadKey(keysym) \
+  (((KeySym)(keysym) >= XK_KP_Space) && ((KeySym)(keysym) <= XK_KP_Equal))
+
+#define IsPrivateKeypadKey(keysym) \
+  (((KeySym)(keysym) >= 0x11000000) && ((KeySym)(keysym) <= 0x1100FFFF))
+
+#define IsCursorKey(keysym) \
+  (((KeySym)(keysym) >= XK_Home)     && ((KeySym)(keysym) <  XK_Select))
+
+#define IsPFKey(keysym) \
+  (((KeySym)(keysym) >= XK_KP_F1)     && ((KeySym)(keysym) <= XK_KP_F4))
+
+#define IsFunctionKey(keysym) \
+  (((KeySym)(keysym) >= XK_F1)       && ((KeySym)(keysym) <= XK_F35))
+
+#define IsMiscFunctionKey(keysym) \
+  (((KeySym)(keysym) >= XK_Select)   && ((KeySym)(keysym) <= XK_Break))
+
+#ifdef XK_XKB_KEYS
+#define IsModifierKey(keysym) \
+  ((((KeySym)(keysym) >= XK_Shift_L) && ((KeySym)(keysym) <= XK_Hyper_R)) \
+   || (((KeySym)(keysym) >= XK_ISO_Lock) && \
+       ((KeySym)(keysym) <= XK_ISO_Level5_Lock)) \
+   || ((KeySym)(keysym) == XK_Mode_switch) \
+   || ((KeySym)(keysym) == XK_Num_Lock))
+#else
+#define IsModifierKey(keysym) \
+  ((((KeySym)(keysym) >= XK_Shift_L) && ((KeySym)(keysym) <= XK_Hyper_R)) \
+   || ((KeySym)(keysym) == XK_Mode_switch) \
+   || ((KeySym)(keysym) == XK_Num_Lock))
+#endif
+/*
+ * opaque reference to Region data type
+ */
+typedef struct _XRegion *Region;
+
+/* Return values from XRectInRegion() */
+
+#define RectangleOut 0
+#define RectangleIn  1
+#define RectanglePart 2
+
+
+/*
+ * Information used by the visual utility routines to find desired visual
+ * type from the many visuals a display may support.
+ */
+
+typedef struct {
+  Visual *visual;
+  VisualID visualid;
+  int screen;
+  int depth;
+#if defined(__cplusplus) || defined(c_plusplus)
+  int c_class;					/* C++ */
+#else
+  int class;
+#endif
+  unsigned long red_mask;
+  unsigned long green_mask;
+  unsigned long blue_mask;
+  int colormap_size;
+  int bits_per_rgb;
+} XVisualInfo;
+
+#define VisualNoMask		0x0
+#define VisualIDMask 		0x1
+#define VisualScreenMask	0x2
+#define VisualDepthMask		0x4
+#define VisualClassMask		0x8
+#define VisualRedMaskMask	0x10
+#define VisualGreenMaskMask	0x20
+#define VisualBlueMaskMask	0x40
+#define VisualColormapSizeMask	0x80
+#define VisualBitsPerRGBMask	0x100
+#define VisualAllMask		0x1FF
+
+/*
+ * This defines a window manager property that clients may use to
+ * share standard color maps of type RGB_COLOR_MAP:
+ */
+typedef struct {
+	Colormap colormap;
+	unsigned long red_max;
+	unsigned long red_mult;
+	unsigned long green_max;
+	unsigned long green_mult;
+	unsigned long blue_max;
+	unsigned long blue_mult;
+	unsigned long base_pixel;
+	VisualID visualid;		/* added by ICCCM version 1 */
+	XID killid;			/* added by ICCCM version 1 */
+} XStandardColormap;
+
+#define ReleaseByFreeingColormap ((XID) 1L)  /* for killid field above */
+
+
+/*
+ * return codes for XReadBitmapFile and XWriteBitmapFile
+ */
+#define BitmapSuccess		0
+#define BitmapOpenFailed 	1
+#define BitmapFileInvalid 	2
+#define BitmapNoMemory		3
+
+/****************************************************************
+ *
+ * Context Management
+ *
+ ****************************************************************/
+
+
+/* Associative lookup table return codes */
+
+#define XCSUCCESS 0	/* No error. */
+#define XCNOMEM   1    /* Out of memory */
+#define XCNOENT   2    /* No entry in table */
+
+typedef int XContext;
+
+#define XUniqueContext()       ((XContext) XrmUniqueQuark())
+#define XStringToContext(string)   ((XContext) XrmStringToQuark(string))
+
+_XFUNCPROTOBEGIN
+
+/* The following declarations are alphabetized. */
+
+extern XClassHint *XAllocClassHint (
+    void
+);
+
+extern XIconSize *XAllocIconSize (
+    void
+);
+
+extern XSizeHints *XAllocSizeHints (
+    void
+);
+
+extern XStandardColormap *XAllocStandardColormap (
+    void
+);
+
+extern XWMHints *XAllocWMHints (
+    void
+);
+
+extern int XClipBox(
+    Region		/* r */,
+    XRectangle*		/* rect_return */
+);
+
+extern Region XCreateRegion(
+    void
+);
+
+extern const char *XDefaultString (void);
+
+extern int XDeleteContext(
+    Display*		/* display */,
+    XID			/* rid */,
+    XContext		/* context */
+);
+
+extern int XDestroyRegion(
+    Region		/* r */
+);
+
+extern int XEmptyRegion(
+    Region		/* r */
+);
+
+extern int XEqualRegion(
+    Region		/* r1 */,
+    Region		/* r2 */
+);
+
+extern int XFindContext(
+    Display*		/* display */,
+    XID			/* rid */,
+    XContext		/* context */,
+    XPointer*		/* data_return */
+);
+
+extern Status XGetClassHint(
+    Display*		/* display */,
+    Window		/* w */,
+    XClassHint*		/* class_hints_return */
+);
+
+extern Status XGetIconSizes(
+    Display*		/* display */,
+    Window		/* w */,
+    XIconSize**		/* size_list_return */,
+    int*		/* count_return */
+);
+
+extern Status XGetNormalHints(
+    Display*		/* display */,
+    Window		/* w */,
+    XSizeHints*		/* hints_return */
+);
+
+extern Status XGetRGBColormaps(
+    Display*		/* display */,
+    Window		/* w */,
+    XStandardColormap** /* stdcmap_return */,
+    int*		/* count_return */,
+    Atom		/* property */
+);
+
+extern Status XGetSizeHints(
+    Display*		/* display */,
+    Window		/* w */,
+    XSizeHints*		/* hints_return */,
+    Atom		/* property */
+);
+
+extern Status XGetStandardColormap(
+    Display*		/* display */,
+    Window		/* w */,
+    XStandardColormap*	/* colormap_return */,
+    Atom		/* property */
+);
+
+extern Status XGetTextProperty(
+    Display*		/* display */,
+    Window		/* window */,
+    XTextProperty*	/* text_prop_return */,
+    Atom		/* property */
+);
+
+extern XVisualInfo *XGetVisualInfo(
+    Display*		/* display */,
+    long		/* vinfo_mask */,
+    XVisualInfo*	/* vinfo_template */,
+    int*		/* nitems_return */
+);
+
+extern Status XGetWMClientMachine(
+    Display*		/* display */,
+    Window		/* w */,
+    XTextProperty*	/* text_prop_return */
+);
+
+extern XWMHints *XGetWMHints(
+    Display*		/* display */,
+    Window		/* w */
+);
+
+extern Status XGetWMIconName(
+    Display*		/* display */,
+    Window		/* w */,
+    XTextProperty*	/* text_prop_return */
+);
+
+extern Status XGetWMName(
+    Display*		/* display */,
+    Window		/* w */,
+    XTextProperty*	/* text_prop_return */
+);
+
+extern Status XGetWMNormalHints(
+    Display*		/* display */,
+    Window		/* w */,
+    XSizeHints*		/* hints_return */,
+    long*		/* supplied_return */
+);
+
+extern Status XGetWMSizeHints(
+    Display*		/* display */,
+    Window		/* w */,
+    XSizeHints*		/* hints_return */,
+    long*		/* supplied_return */,
+    Atom		/* property */
+);
+
+extern Status XGetZoomHints(
+    Display*		/* display */,
+    Window		/* w */,
+    XSizeHints*		/* zhints_return */
+);
+
+extern int XIntersectRegion(
+    Region		/* sra */,
+    Region		/* srb */,
+    Region		/* dr_return */
+);
+
+extern void XConvertCase(
+    KeySym		/* sym */,
+    KeySym*		/* lower */,
+    KeySym*		/* upper */
+);
+
+extern int XLookupString(
+    XKeyEvent*		/* event_struct */,
+    char*		/* buffer_return */,
+    int			/* bytes_buffer */,
+    KeySym*		/* keysym_return */,
+    XComposeStatus*	/* status_in_out */
+);
+
+extern Status XMatchVisualInfo(
+    Display*		/* display */,
+    int			/* screen */,
+    int			/* depth */,
+    int			/* class */,
+    XVisualInfo*	/* vinfo_return */
+);
+
+extern int XOffsetRegion(
+    Region		/* r */,
+    int			/* dx */,
+    int			/* dy */
+);
+
+extern Bool XPointInRegion(
+    Region		/* r */,
+    int			/* x */,
+    int			/* y */
+);
+
+extern Region XPolygonRegion(
+    XPoint*		/* points */,
+    int			/* n */,
+    int			/* fill_rule */
+);
+
+extern int XRectInRegion(
+    Region		/* r */,
+    int			/* x */,
+    int			/* y */,
+    unsigned int	/* width */,
+    unsigned int	/* height */
+);
+
+extern int XSaveContext(
+    Display*		/* display */,
+    XID			/* rid */,
+    XContext		/* context */,
+    _Xconst char*	/* data */
+);
+
+extern int XSetClassHint(
+    Display*		/* display */,
+    Window		/* w */,
+    XClassHint*		/* class_hints */
+);
+
+extern int XSetIconSizes(
+    Display*		/* display */,
+    Window		/* w */,
+    XIconSize*		/* size_list */,
+    int			/* count */
+);
+
+extern int XSetNormalHints(
+    Display*		/* display */,
+    Window		/* w */,
+    XSizeHints*		/* hints */
+);
+
+extern void XSetRGBColormaps(
+    Display*		/* display */,
+    Window		/* w */,
+    XStandardColormap*	/* stdcmaps */,
+    int			/* count */,
+    Atom		/* property */
+);
+
+extern int XSetSizeHints(
+    Display*		/* display */,
+    Window		/* w */,
+    XSizeHints*		/* hints */,
+    Atom		/* property */
+);
+
+extern int XSetStandardProperties(
+    Display*		/* display */,
+    Window		/* w */,
+    _Xconst char*	/* window_name */,
+    _Xconst char*	/* icon_name */,
+    Pixmap		/* icon_pixmap */,
+    char**		/* argv */,
+    int			/* argc */,
+    XSizeHints*		/* hints */
+);
+
+extern void XSetTextProperty(
+    Display*		/* display */,
+    Window		/* w */,
+    XTextProperty*	/* text_prop */,
+    Atom		/* property */
+);
+
+extern void XSetWMClientMachine(
+    Display*		/* display */,
+    Window		/* w */,
+    XTextProperty*	/* text_prop */
+);
+
+extern int XSetWMHints(
+    Display*		/* display */,
+    Window		/* w */,
+    XWMHints*		/* wm_hints */
+);
+
+extern void XSetWMIconName(
+    Display*		/* display */,
+    Window		/* w */,
+    XTextProperty*	/* text_prop */
+);
+
+extern void XSetWMName(
+    Display*		/* display */,
+    Window		/* w */,
+    XTextProperty*	/* text_prop */
+);
+
+extern void XSetWMNormalHints(
+    Display*		/* display */,
+    Window		/* w */,
+    XSizeHints*		/* hints */
+);
+
+extern void XSetWMProperties(
+    Display*		/* display */,
+    Window		/* w */,
+    XTextProperty*	/* window_name */,
+    XTextProperty*	/* icon_name */,
+    char**		/* argv */,
+    int			/* argc */,
+    XSizeHints*		/* normal_hints */,
+    XWMHints*		/* wm_hints */,
+    XClassHint*		/* class_hints */
+);
+
+extern void XmbSetWMProperties(
+    Display*		/* display */,
+    Window		/* w */,
+    _Xconst char*	/* window_name */,
+    _Xconst char*	/* icon_name */,
+    char**		/* argv */,
+    int			/* argc */,
+    XSizeHints*		/* normal_hints */,
+    XWMHints*		/* wm_hints */,
+    XClassHint*		/* class_hints */
+);
+
+extern void Xutf8SetWMProperties(
+    Display*		/* display */,
+    Window		/* w */,
+    _Xconst char*	/* window_name */,
+    _Xconst char*	/* icon_name */,
+    char**		/* argv */,
+    int			/* argc */,
+    XSizeHints*		/* normal_hints */,
+    XWMHints*		/* wm_hints */,
+    XClassHint*		/* class_hints */
+);
+
+extern void XSetWMSizeHints(
+    Display*		/* display */,
+    Window		/* w */,
+    XSizeHints*		/* hints */,
+    Atom		/* property */
+);
+
+extern int XSetRegion(
+    Display*		/* display */,
+    GC			/* gc */,
+    Region		/* r */
+);
+
+extern void XSetStandardColormap(
+    Display*		/* display */,
+    Window		/* w */,
+    XStandardColormap*	/* colormap */,
+    Atom		/* property */
+);
+
+extern int XSetZoomHints(
+    Display*		/* display */,
+    Window		/* w */,
+    XSizeHints*		/* zhints */
+);
+
+extern int XShrinkRegion(
+    Region		/* r */,
+    int			/* dx */,
+    int			/* dy */
+);
+
+extern Status XStringListToTextProperty(
+    char**		/* list */,
+    int			/* count */,
+    XTextProperty*	/* text_prop_return */
+);
+
+extern int XSubtractRegion(
+    Region		/* sra */,
+    Region		/* srb */,
+    Region		/* dr_return */
+);
+
+extern int XmbTextListToTextProperty(
+    Display*		display,
+    char**		list,
+    int			count,
+    XICCEncodingStyle	style,
+    XTextProperty*	text_prop_return
+);
+
+extern int XwcTextListToTextProperty(
+    Display*		display,
+    wchar_t**		list,
+    int			count,
+    XICCEncodingStyle	style,
+    XTextProperty*	text_prop_return
+);
+
+extern int Xutf8TextListToTextProperty(
+    Display*		display,
+    char**		list,
+    int			count,
+    XICCEncodingStyle	style,
+    XTextProperty*	text_prop_return
+);
+
+extern void XwcFreeStringList(
+    wchar_t**		list
+);
+
+extern Status XTextPropertyToStringList(
+    XTextProperty*	/* text_prop */,
+    char***		/* list_return */,
+    int*		/* count_return */
+);
+
+extern int XmbTextPropertyToTextList(
+    Display*		display,
+    const XTextProperty* text_prop,
+    char***		list_return,
+    int*		count_return
+);
+
+extern int XwcTextPropertyToTextList(
+    Display*		display,
+    const XTextProperty* text_prop,
+    wchar_t***		list_return,
+    int*		count_return
+);
+
+extern int Xutf8TextPropertyToTextList(
+    Display*		display,
+    const XTextProperty* text_prop,
+    char***		list_return,
+    int*		count_return
+);
+
+extern int XUnionRectWithRegion(
+    XRectangle*		/* rectangle */,
+    Region		/* src_region */,
+    Region		/* dest_region_return */
+);
+
+extern int XUnionRegion(
+    Region		/* sra */,
+    Region		/* srb */,
+    Region		/* dr_return */
+);
+
+extern int XWMGeometry(
+    Display*		/* display */,
+    int			/* screen_number */,
+    _Xconst char*	/* user_geometry */,
+    _Xconst char*	/* default_geometry */,
+    unsigned int	/* border_width */,
+    XSizeHints*		/* hints */,
+    int*		/* x_return */,
+    int*		/* y_return */,
+    int*		/* width_return */,
+    int*		/* height_return */,
+    int*		/* gravity_return */
+);
+
+extern int XXorRegion(
+    Region		/* sra */,
+    Region		/* srb */,
+    Region		/* dr_return */
+);
+
+#ifdef __clang__
+#pragma clang diagnostic pop
+#endif
+
+_XFUNCPROTOEND
+
+#endif /* !defined(_X11_XUTIL_H_) && !defined(_XUTIL_H_) */
diff --git a/nx-X11/lib/include/X11/cursorfont.h b/nx-X11/lib/include/X11/cursorfont.h
new file mode 100644
index 000000000..a0fbf3c6b
--- /dev/null
+++ b/nx-X11/lib/include/X11/cursorfont.h
@@ -0,0 +1,112 @@
+/*
+
+Copyright 1987, 1998  The Open Group
+
+Permission to use, copy, modify, distribute, and sell this software and its
+documentation for any purpose is hereby granted without fee, provided that
+the above copyright notice appear in all copies and that both that
+copyright notice and this permission notice appear in supporting
+documentation.
+
+The above copyright notice and this permission notice shall be included
+in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR
+OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.
+
+Except as contained in this notice, the name of The Open Group shall
+not be used in advertising or otherwise to promote the sale, use or
+other dealings in this Software without prior written authorization
+from The Open Group.
+
+*/
+
+#if !defined(_X11_CURSORFONT_H_) && !defined(_cursorfont_h_)
+#define _X11_CURSORFONT_H_
+#define _cursorfont_h_
+
+#define XC_num_glyphs 154
+#define XC_X_cursor 0
+#define XC_arrow 2
+#define XC_based_arrow_down 4
+#define XC_based_arrow_up 6
+#define XC_boat 8
+#define XC_bogosity 10
+#define XC_bottom_left_corner 12
+#define XC_bottom_right_corner 14
+#define XC_bottom_side 16
+#define XC_bottom_tee 18
+#define XC_box_spiral 20
+#define XC_center_ptr 22
+#define XC_circle 24
+#define XC_clock 26
+#define XC_coffee_mug 28
+#define XC_cross 30
+#define XC_cross_reverse 32
+#define XC_crosshair 34
+#define XC_diamond_cross 36
+#define XC_dot 38
+#define XC_dotbox 40
+#define XC_double_arrow 42
+#define XC_draft_large 44
+#define XC_draft_small 46
+#define XC_draped_box 48
+#define XC_exchange 50
+#define XC_fleur 52
+#define XC_gobbler 54
+#define XC_gumby 56
+#define XC_hand1 58
+#define XC_hand2 60
+#define XC_heart 62
+#define XC_icon 64
+#define XC_iron_cross 66
+#define XC_left_ptr 68
+#define XC_left_side 70
+#define XC_left_tee 72
+#define XC_leftbutton 74
+#define XC_ll_angle 76
+#define XC_lr_angle 78
+#define XC_man 80
+#define XC_middlebutton 82
+#define XC_mouse 84
+#define XC_pencil 86
+#define XC_pirate 88
+#define XC_plus 90
+#define XC_question_arrow 92
+#define XC_right_ptr 94
+#define XC_right_side 96
+#define XC_right_tee 98
+#define XC_rightbutton 100
+#define XC_rtl_logo 102
+#define XC_sailboat 104
+#define XC_sb_down_arrow 106
+#define XC_sb_h_double_arrow 108
+#define XC_sb_left_arrow 110
+#define XC_sb_right_arrow 112
+#define XC_sb_up_arrow 114
+#define XC_sb_v_double_arrow 116
+#define XC_shuttle 118
+#define XC_sizing 120
+#define XC_spider 122
+#define XC_spraycan 124
+#define XC_star 126
+#define XC_target 128
+#define XC_tcross 130
+#define XC_top_left_arrow 132
+#define XC_top_left_corner 134
+#define XC_top_right_corner 136
+#define XC_top_side 138
+#define XC_top_tee 140
+#define XC_trek 142
+#define XC_ul_angle 144
+#define XC_umbrella 146
+#define XC_ur_angle 148
+#define XC_watch 150
+#define XC_xterm 152
+
+#endif /* !defined(_X11_CURSORFONT_H_) && !defined(_cursorfont_h_) */
diff --git a/nx-X11/lib/include/xtrans/Xtrans.c b/nx-X11/lib/include/xtrans/Xtrans.c
new file mode 100644
index 000000000..328a970b1
--- /dev/null
+++ b/nx-X11/lib/include/xtrans/Xtrans.c
@@ -0,0 +1,1367 @@
+/*
+
+Copyright 1993, 1994, 1998  The Open Group
+
+Permission to use, copy, modify, distribute, and sell this software and its
+documentation for any purpose is hereby granted without fee, provided that
+the above copyright notice appear in all copies and that both that
+copyright notice and this permission notice appear in supporting
+documentation.
+
+The above copyright notice and this permission notice shall be included
+in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR
+OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.
+
+Except as contained in this notice, the name of The Open Group shall
+not be used in advertising or otherwise to promote the sale, use or
+other dealings in this Software without prior written authorization
+from The Open Group.
+
+ * Copyright 1993, 1994 NCR Corporation - Dayton, Ohio, USA
+ *
+ * All Rights Reserved
+ *
+ * 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 NCR not be used in advertising
+ * or publicity pertaining to distribution of the software without specific,
+ * written prior permission.  NCR makes no representations about the
+ * suitability of this software for any purpose.  It is provided "as is"
+ * without express or implied warranty.
+ *
+ * NCR DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
+ * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN
+ * NO EVENT SHALL NCR BE LIABLE FOR ANY SPECIAL, INDIRECT OR
+ * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS
+ * OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
+ * NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
+ * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+#include <ctype.h>
+#include <stdlib.h>
+#include <string.h>
+#ifdef HAVE_SYSTEMD_DAEMON
+#include <systemd/sd-daemon.h>
+#endif
+
+/*
+ * The transport table contains a definition for every transport (protocol)
+ * family. All operations that can be made on the transport go through this
+ * table.
+ *
+ * Each transport is assigned a unique transport id.
+ *
+ * New transports can be added by adding an entry in this table.
+ * For compatiblity, the transport ids should never be renumbered.
+ * Always add to the end of the list.
+ */
+
+#define TRANS_TLI_INET_INDEX		1
+#define TRANS_TLI_TCP_INDEX		2
+#define TRANS_TLI_TLI_INDEX		3
+#define TRANS_SOCKET_UNIX_INDEX		4
+#define TRANS_SOCKET_LOCAL_INDEX	5
+#define TRANS_SOCKET_INET_INDEX		6
+#define TRANS_SOCKET_TCP_INDEX		7
+#define TRANS_DNET_INDEX		8
+#define TRANS_LOCAL_LOCAL_INDEX		9
+#define TRANS_LOCAL_PTS_INDEX		10
+#define TRANS_LOCAL_NAMED_INDEX		11
+/* 12 used to be ISC, but that's gone. */
+#define TRANS_LOCAL_SCO_INDEX		13
+#define TRANS_SOCKET_INET6_INDEX	14
+#define TRANS_LOCAL_PIPE_INDEX		15
+
+
+static
+Xtransport_table Xtransports[] = {
+#if defined(TCPCONN)
+    { &TRANS(SocketTCPFuncs),	TRANS_SOCKET_TCP_INDEX },
+#if defined(IPv6) && defined(AF_INET6)
+    { &TRANS(SocketINET6Funcs),	TRANS_SOCKET_INET6_INDEX },
+#endif /* IPv6 */
+    { &TRANS(SocketINETFuncs),	TRANS_SOCKET_INET_INDEX },
+#endif /* TCPCONN */
+#if defined(UNIXCONN)
+#if !defined(LOCALCONN)
+    { &TRANS(SocketLocalFuncs),	TRANS_SOCKET_LOCAL_INDEX },
+#endif /* !LOCALCONN */
+    { &TRANS(SocketUNIXFuncs),	TRANS_SOCKET_UNIX_INDEX },
+#endif /* UNIXCONN */
+#if defined(LOCALCONN)
+    { &TRANS(LocalFuncs),	TRANS_LOCAL_LOCAL_INDEX },
+#ifndef __sun
+    { &TRANS(PTSFuncs),		TRANS_LOCAL_PTS_INDEX },
+#endif /* __sun */
+#if defined(SVR4) || defined(__SVR4)
+    { &TRANS(NAMEDFuncs),	TRANS_LOCAL_NAMED_INDEX },
+#endif
+#ifdef __sun
+    { &TRANS(PIPEFuncs),	TRANS_LOCAL_PIPE_INDEX },
+#endif /* __sun */
+#if defined(__SCO__) || defined(__UNIXWARE__)
+    { &TRANS(SCOFuncs),		TRANS_LOCAL_SCO_INDEX },
+#endif /* __SCO__ || __UNIXWARE__ */
+#endif /* LOCALCONN */
+};
+
+#define NUMTRANS	(sizeof(Xtransports)/sizeof(Xtransport_table))
+
+
+#ifdef WIN32
+#define ioctl ioctlsocket
+#endif
+
+
+
+/*
+ * These are a few utility function used by the public interface functions.
+ */
+
+void
+TRANS(FreeConnInfo) (XtransConnInfo ciptr)
+
+{
+    prmsg (3,"FreeConnInfo(%p)\n", (void *) ciptr);
+
+    if (ciptr->addr)
+	free (ciptr->addr);
+
+    if (ciptr->peeraddr)
+	free (ciptr->peeraddr);
+
+    if (ciptr->port)
+	free (ciptr->port);
+
+    free (ciptr);
+}
+
+
+#define PROTOBUFSIZE	20
+
+static Xtransport *
+TRANS(SelectTransport) (const char *protocol)
+
+{
+    char 	protobuf[PROTOBUFSIZE];
+    int		i;
+
+    prmsg (3,"SelectTransport(%s)\n", protocol);
+
+    /*
+     * Force Protocol to be lowercase as a way of doing
+     * a case insensitive match.
+     */
+
+    strncpy (protobuf, protocol, PROTOBUFSIZE - 1);
+    protobuf[PROTOBUFSIZE-1] = '\0';
+
+    for (i = 0; i < PROTOBUFSIZE && protobuf[i] != '\0'; i++)
+	if (isupper ((unsigned char)protobuf[i]))
+	    protobuf[i] = tolower ((unsigned char)protobuf[i]);
+
+    /* Look at all of the configured protocols */
+
+    for (i = 0; i < NUMTRANS; i++)
+    {
+	if (!strcmp (protobuf, Xtransports[i].transport->TransName))
+	    return Xtransports[i].transport;
+    }
+
+    return NULL;
+}
+
+#ifndef TEST_t
+static
+#endif /* TEST_t */
+int
+TRANS(ParseAddress) (const char *address,
+                     char **protocol, char **host, char **port)
+
+{
+    /*
+     * For the font library, the address is a string formatted
+     * as "protocol/host:port[/catalogue]".  Note that the catologue
+     * is optional.  At this time, the catologue info is ignored, but
+     * we have to parse it anyways.
+     *
+     * Other than fontlib, the address is a string formatted
+     * as "protocol/host:port".
+     *
+     * If the protocol part is missing, then assume TCP.
+     * If the protocol part and host part are missing, then assume local.
+     * If a "::" is found then assume DNET.
+     */
+
+    char	*mybuf, *tmpptr;
+    const char	*_protocol;
+    char	*_host, *_port;
+    char	hostnamebuf[256];
+    int		_host_len;
+
+    prmsg (3,"ParseAddress(%s)\n", address);
+
+    /* Copy the string so it can be changed */
+
+    tmpptr = mybuf = strdup (address);
+
+    /* Parse the string to get each component */
+
+    /* Get the protocol part */
+
+    _protocol = mybuf;
+
+
+   if ( ((mybuf = strchr (mybuf,'/')) == NULL) &&
+      ((mybuf = strrchr (tmpptr,':')) == NULL) )
+   {
+	/* address is in a bad format */
+	*protocol = NULL;
+	*host = NULL;
+	*port = NULL;
+	free (tmpptr);
+	return 0;
+    }
+
+    if (*mybuf == ':')
+    {
+	/*
+	 * If there is a hostname, then assume tcp, otherwise
+	 * it must be local.
+	 */
+	if (mybuf == tmpptr)
+	{
+	    /* There is neither a protocol or host specified */
+	    _protocol = "local";
+	}
+	else
+	{
+	    /* There is a hostname specified */
+	    _protocol = "tcp";
+	    mybuf = tmpptr;	/* reset to the begining of the host ptr */
+	}
+    }
+    else
+    {
+	/* *mybuf == '/' */
+
+	*mybuf ++= '\0'; /* put a null at the end of the protocol */
+
+	if (strlen(_protocol) == 0)
+	{
+	    /*
+	     * If there is a hostname, then assume tcp, otherwise
+	     * it must be local.
+	     */
+	    if (*mybuf != ':')
+		_protocol = "tcp";
+	    else
+		_protocol = "local";
+	}
+    }
+
+    /* Get the host part */
+
+    _host = mybuf;
+
+    if ((mybuf = strrchr (mybuf,':')) == NULL)
+    {
+	*protocol = NULL;
+	*host = NULL;
+	*port = NULL;
+	free (tmpptr);
+	return 0;
+    }
+
+    *mybuf ++= '\0';
+
+    _host_len = strlen(_host);
+    if (_host_len == 0)
+    {
+	TRANS(GetHostname) (hostnamebuf, sizeof (hostnamebuf));
+	_host = hostnamebuf;
+    }
+#if defined(IPv6) && defined(AF_INET6)
+    /* hostname in IPv6 [numeric_addr]:0 form? */
+    else if ( (_host_len > 3) &&
+      ((strcmp(_protocol, "tcp") == 0) || (strcmp(_protocol, "inet6") == 0))
+      && (*_host == '[') && (*(_host + _host_len - 1) == ']') ) {
+	struct sockaddr_in6 sin6;
+
+	*(_host + _host_len - 1) = '\0';
+
+	/* Verify address is valid IPv6 numeric form */
+	if (inet_pton(AF_INET6, _host + 1, &sin6) == 1) {
+	    /* It is. Use it as such. */
+	    _host++;
+	    _protocol = "inet6";
+	} else {
+	    /* It's not, restore it just in case some other code can use it. */
+	    *(_host + _host_len - 1) = ']';
+	}
+    }
+#endif
+
+
+    /* Get the port */
+
+    _port = mybuf;
+
+#if defined(FONT_t) || defined(FS_t)
+    /*
+     * Is there an optional catalogue list?
+     */
+
+    if ((mybuf = strchr (mybuf,'/')) != NULL)
+	*mybuf ++= '\0';
+
+    /*
+     * The rest, if any, is the (currently unused) catalogue list.
+     *
+     * _catalogue = mybuf;
+     */
+#endif
+
+#ifdef HAVE_LAUNCHD
+    /* launchd sockets will look like 'local//tmp/launch-XgkNns/:0' */
+    if(address != NULL && strlen(address)>8 && (!strncmp(address,"local//",7))) {
+      _protocol="local";
+      _host="";
+      _port=address+6;
+    }
+#endif
+
+    /*
+     * Now that we have all of the components, allocate new
+     * string space for them.
+     */
+
+    if ((*protocol = strdup (_protocol)) == NULL)
+    {
+	/* Malloc failed */
+	*port = NULL;
+	*host = NULL;
+	*protocol = NULL;
+	free (tmpptr);
+	return 0;
+    }
+
+    if ((*host = strdup (_host)) == NULL)
+    {
+	/* Malloc failed */
+	*port = NULL;
+	*host = NULL;
+	free (*protocol);
+	*protocol = NULL;
+	free (tmpptr);
+	return 0;
+	}
+
+    if ((*port = strdup (_port)) == NULL)
+    {
+	/* Malloc failed */
+	*port = NULL;
+	free (*host);
+	*host = NULL;
+	free (*protocol);
+	*protocol = NULL;
+	free (tmpptr);
+	return 0;
+    }
+
+    free (tmpptr);
+
+    return 1;
+}
+
+
+/*
+ * TRANS(Open) does all of the real work opening a connection. The only
+ * funny part about this is the type parameter which is used to decide which
+ * type of open to perform.
+ */
+
+static XtransConnInfo
+TRANS(Open) (int type, const char *address)
+
+{
+    char 		*protocol = NULL, *host = NULL, *port = NULL;
+    XtransConnInfo	ciptr = NULL;
+    Xtransport		*thistrans;
+
+    prmsg (2,"Open(%d,%s)\n", type, address);
+
+#if defined(WIN32) && defined(TCPCONN)
+    if (TRANS(WSAStartup)())
+    {
+	prmsg (1,"Open: WSAStartup failed\n");
+	return NULL;
+    }
+#endif
+
+    /* Parse the Address */
+
+    if (TRANS(ParseAddress) (address, &protocol, &host, &port) == 0)
+    {
+	prmsg (1,"Open: Unable to Parse address %s\n", address);
+	return NULL;
+    }
+
+    /* Determine the transport type */
+
+    if ((thistrans = TRANS(SelectTransport) (protocol)) == NULL)
+    {
+	prmsg (1,"Open: Unable to find transport for %s\n",
+	       protocol);
+
+	free (protocol);
+	free (host);
+	free (port);
+	return NULL;
+    }
+
+    /* Open the transport */
+
+    switch (type)
+    {
+    case XTRANS_OPEN_COTS_CLIENT:
+#ifdef TRANS_CLIENT
+	ciptr = thistrans->OpenCOTSClient(thistrans, protocol, host, port);
+#endif /* TRANS_CLIENT */
+	break;
+    case XTRANS_OPEN_COTS_SERVER:
+#ifdef TRANS_SERVER
+	ciptr = thistrans->OpenCOTSServer(thistrans, protocol, host, port);
+#endif /* TRANS_SERVER */
+	break;
+    default:
+	prmsg (1,"Open: Unknown Open type %d\n", type);
+    }
+
+    if (ciptr == NULL)
+    {
+	if (!(thistrans->flags & TRANS_DISABLED))
+	{
+	    prmsg (1,"Open: transport open failed for %s/%s:%s\n",
+	           protocol, host, port);
+	}
+	free (protocol);
+	free (host);
+	free (port);
+	return NULL;
+    }
+
+    ciptr->transptr = thistrans;
+    ciptr->port = port;			/* We need this for TRANS(Reopen) */
+
+    free (protocol);
+    free (host);
+
+    return ciptr;
+}
+
+
+#ifdef TRANS_REOPEN
+
+/*
+ * We might want to create an XtransConnInfo object based on a previously
+ * opened connection.  For example, the font server may clone itself and
+ * pass file descriptors to the parent.
+ */
+
+static XtransConnInfo
+TRANS(Reopen) (int type, int trans_id, int fd, const char *port)
+
+{
+    XtransConnInfo	ciptr = NULL;
+    Xtransport		*thistrans = NULL;
+    char		*save_port;
+    int			i;
+
+    prmsg (2,"Reopen(%d,%d,%s)\n", trans_id, fd, port);
+
+    /* Determine the transport type */
+
+    for (i = 0; i < NUMTRANS; i++)
+	if (Xtransports[i].transport_id == trans_id)
+	{
+	    thistrans = Xtransports[i].transport;
+	    break;
+	}
+
+    if (thistrans == NULL)
+    {
+	prmsg (1,"Reopen: Unable to find transport id %d\n",
+	       trans_id);
+
+	return NULL;
+    }
+
+    if ((save_port = strdup (port)) == NULL)
+    {
+	prmsg (1,"Reopen: Unable to malloc port string\n");
+
+	return NULL;
+    }
+
+    /* Get a new XtransConnInfo object */
+
+    switch (type)
+    {
+    case XTRANS_OPEN_COTS_SERVER:
+	ciptr = thistrans->ReopenCOTSServer(thistrans, fd, port);
+	break;
+    default:
+	prmsg (1,"Reopen: Bad Open type %d\n", type);
+    }
+
+    if (ciptr == NULL)
+    {
+	prmsg (1,"Reopen: transport open failed\n");
+	free (save_port);
+	return NULL;
+    }
+
+    ciptr->transptr = thistrans;
+    ciptr->port = save_port;
+
+    return ciptr;
+}
+
+#endif /* TRANS_REOPEN */
+
+
+
+/*
+ * These are the public interfaces to this Transport interface.
+ * These are the only functions that should have knowledge of the transport
+ * table.
+ */
+
+#ifdef TRANS_CLIENT
+
+XtransConnInfo
+TRANS(OpenCOTSClient) (const char *address)
+
+{
+    prmsg (2,"OpenCOTSClient(%s)\n", address);
+    return TRANS(Open) (XTRANS_OPEN_COTS_CLIENT, address);
+}
+
+#endif /* TRANS_CLIENT */
+
+
+#ifdef TRANS_SERVER
+
+XtransConnInfo
+TRANS(OpenCOTSServer) (const char *address)
+
+{
+    prmsg (2,"OpenCOTSServer(%s)\n", address);
+    return TRANS(Open) (XTRANS_OPEN_COTS_SERVER, address);
+}
+
+#endif /* TRANS_SERVER */
+
+
+#ifdef TRANS_REOPEN
+
+XtransConnInfo
+TRANS(ReopenCOTSServer) (int trans_id, int fd, const char *port)
+
+{
+    prmsg (2,"ReopenCOTSServer(%d, %d, %s)\n", trans_id, fd, port);
+    return TRANS(Reopen) (XTRANS_OPEN_COTS_SERVER, trans_id, fd, port);
+}
+
+int
+TRANS(GetReopenInfo) (XtransConnInfo ciptr,
+		      int *trans_id, int *fd, char **port)
+
+{
+    int i;
+
+    for (i = 0; i < NUMTRANS; i++)
+	if (Xtransports[i].transport == ciptr->transptr)
+	{
+	    *trans_id = Xtransports[i].transport_id;
+	    *fd = ciptr->fd;
+
+	    if ((*port = strdup (ciptr->port)) == NULL)
+		return 0;
+	    else
+		return 1;
+	}
+
+    return 0;
+}
+
+#endif /* TRANS_REOPEN */
+
+
+int
+TRANS(SetOption) (XtransConnInfo ciptr, int option, int arg)
+
+{
+    int	fd = ciptr->fd;
+    int	ret = 0;
+
+    prmsg (2,"SetOption(%d,%d,%d)\n", fd, option, arg);
+
+    /*
+     * For now, all transport type use the same stuff for setting options.
+     * As long as this is true, we can put the common code here. Once a more
+     * complicated transport such as shared memory or an OSI implementation
+     * that uses the session and application libraries is implemented, this
+     * code may have to move to a transport dependent function.
+     *
+     * ret = ciptr->transptr->SetOption (ciptr, option, arg);
+     */
+
+    switch (option)
+    {
+    case TRANS_NONBLOCKING:
+	switch (arg)
+	{
+	case 0:
+	    /* Set to blocking mode */
+	    break;
+	case 1: /* Set to non-blocking mode */
+
+#if defined(O_NONBLOCK) && !defined(SCO325)
+	    ret = fcntl (fd, F_GETFL, 0);
+	    if (ret != -1)
+		ret = fcntl (fd, F_SETFL, ret | O_NONBLOCK);
+#else
+#ifdef FIOSNBIO
+	{
+	    int arg;
+	    arg = 1;
+	    ret = ioctl (fd, FIOSNBIO, &arg);
+	}
+#else
+#if defined(WIN32)
+	{
+#ifdef WIN32
+	    u_long arg;
+#else
+	    int arg;
+#endif
+	    arg = 1;
+/* IBM TCP/IP understands this option too well: it causes TRANS(Read) to fail
+ * eventually with EWOULDBLOCK */
+	    ret = ioctl (fd, FIONBIO, &arg);
+	}
+#else
+	    ret = fcntl (fd, F_GETFL, 0);
+#ifdef FNDELAY
+	    ret = fcntl (fd, F_SETFL, ret | FNDELAY);
+#else
+	    ret = fcntl (fd, F_SETFL, ret | O_NDELAY);
+#endif
+#endif /* WIN32 */
+#endif /* FIOSNBIO */
+#endif /* O_NONBLOCK */
+	    break;
+	default:
+	    /* Unknown option */
+	    break;
+	}
+	break;
+    case TRANS_CLOSEONEXEC:
+#ifdef F_SETFD
+#ifdef FD_CLOEXEC
+	ret = fcntl (fd, F_SETFD, FD_CLOEXEC);
+#else
+	ret = fcntl (fd, F_SETFD, 1);
+#endif /* FD_CLOEXEC */
+#endif /* F_SETFD */
+	break;
+    }
+
+    return ret;
+}
+
+#ifdef TRANS_SERVER
+
+int
+TRANS(CreateListener) (XtransConnInfo ciptr, const char *port, unsigned int flags)
+
+{
+    return ciptr->transptr->CreateListener (ciptr, port, flags);
+}
+
+int
+TRANS(Received) (const char * protocol)
+
+{
+   Xtransport *trans;
+   int i = 0, ret = 0;
+
+   prmsg (5, "Received(%s)\n", protocol);
+
+   if ((trans = TRANS(SelectTransport)(protocol)) == NULL)
+   {
+	prmsg (1,"Received: unable to find transport: %s\n",
+	       protocol);
+
+	return -1;
+   }
+   if (trans->flags & TRANS_ALIAS) {
+       if (trans->nolisten)
+	   while (trans->nolisten[i]) {
+	       ret |= TRANS(Received)(trans->nolisten[i]);
+	       i++;
+       }
+   }
+
+   trans->flags |= TRANS_RECEIVED;
+   return ret;
+}
+
+int
+TRANS(NoListen) (const char * protocol)
+	
+{
+   Xtransport *trans;
+   int i = 0, ret = 0;
+
+   if ((trans = TRANS(SelectTransport)(protocol)) == NULL)
+   {
+	prmsg (1,"TransNoListen: unable to find transport: %s\n",
+	       protocol);
+
+	return -1;
+   }
+   if (trans->flags & TRANS_ALIAS) {
+       if (trans->nolisten)
+	   while (trans->nolisten[i]) {
+	       ret |= TRANS(NoListen)(trans->nolisten[i]);
+	       i++;
+       }
+   }
+
+   trans->flags |= TRANS_NOLISTEN;
+   return ret;
+}
+
+int
+TRANS(Listen) (const char * protocol)
+{
+   Xtransport *trans;
+   int i = 0, ret = 0;
+
+   if ((trans = TRANS(SelectTransport)(protocol)) == NULL)
+   {
+	prmsg (1,"TransListen: unable to find transport: %s\n",
+	       protocol);
+
+	return -1;
+   }
+   if (trans->flags & TRANS_ALIAS) {
+       if (trans->nolisten)
+	   while (trans->nolisten[i]) {
+	       ret |= TRANS(Listen)(trans->nolisten[i]);
+	       i++;
+       }
+   }
+
+   trans->flags &= ~TRANS_NOLISTEN;
+   return ret;
+}
+
+int
+TRANS(IsListening) (const char * protocol)
+{
+   Xtransport *trans;
+
+   if ((trans = TRANS(SelectTransport)(protocol)) == NULL)
+   {
+	prmsg (1,"TransIsListening: unable to find transport: %s\n",
+	       protocol);
+
+	return 0;
+   }
+
+   return !(trans->flags & TRANS_NOLISTEN);
+}
+
+int
+TRANS(ResetListener) (XtransConnInfo ciptr)
+
+{
+    if (ciptr->transptr->ResetListener)
+	return ciptr->transptr->ResetListener (ciptr);
+    else
+	return TRANS_RESET_NOOP;
+}
+
+
+XtransConnInfo
+TRANS(Accept) (XtransConnInfo ciptr, int *status)
+
+{
+    XtransConnInfo	newciptr;
+
+    prmsg (2,"Accept(%d)\n", ciptr->fd);
+
+    newciptr = ciptr->transptr->Accept (ciptr, status);
+
+    if (newciptr)
+	newciptr->transptr = ciptr->transptr;
+
+    return newciptr;
+}
+
+#endif /* TRANS_SERVER */
+
+
+#ifdef TRANS_CLIENT
+
+int
+TRANS(Connect) (XtransConnInfo ciptr, const char *address)
+
+{
+    char	*protocol;
+    char	*host;
+    char	*port;
+    int		ret;
+
+    prmsg (2,"Connect(%d,%s)\n", ciptr->fd, address);
+
+    if (TRANS(ParseAddress) (address, &protocol, &host, &port) == 0)
+    {
+	prmsg (1,"Connect: Unable to Parse address %s\n",
+	       address);
+	return -1;
+    }
+
+#ifdef HAVE_LAUNCHD
+    if (!host) host=strdup("");
+#endif
+
+    if (!port || !*port)
+    {
+	prmsg (1,"Connect: Missing port specification in %s\n",
+	      address);
+	if (protocol) free (protocol);
+	if (host) free (host);
+	return -1;
+    }
+
+    ret = ciptr->transptr->Connect (ciptr, host, port);
+
+    if (protocol) free (protocol);
+    if (host) free (host);
+    if (port) free (port);
+
+    return ret;
+}
+
+#endif /* TRANS_CLIENT */
+
+
+int
+TRANS(BytesReadable) (XtransConnInfo ciptr, BytesReadable_t *pend)
+
+{
+    return ciptr->transptr->BytesReadable (ciptr, pend);
+}
+
+int
+TRANS(Read) (XtransConnInfo ciptr, char *buf, int size)
+
+{
+    return ciptr->transptr->Read (ciptr, buf, size);
+}
+
+int
+TRANS(Write) (XtransConnInfo ciptr, char *buf, int size)
+
+{
+    return ciptr->transptr->Write (ciptr, buf, size);
+}
+
+int
+TRANS(Readv) (XtransConnInfo ciptr, struct iovec *buf, int size)
+
+{
+    return ciptr->transptr->Readv (ciptr, buf, size);
+}
+
+int
+TRANS(Writev) (XtransConnInfo ciptr, struct iovec *buf, int size)
+
+{
+    return ciptr->transptr->Writev (ciptr, buf, size);
+}
+
+#if XTRANS_SEND_FDS
+int
+TRANS(SendFd) (XtransConnInfo ciptr, int fd, int do_close)
+{
+    return ciptr->transptr->SendFd(ciptr, fd, do_close);
+}
+
+int
+TRANS(RecvFd) (XtransConnInfo ciptr)
+{
+    return ciptr->transptr->RecvFd(ciptr);
+}
+#endif
+
+int
+TRANS(Disconnect) (XtransConnInfo ciptr)
+
+{
+    return ciptr->transptr->Disconnect (ciptr);
+}
+
+int
+TRANS(Close) (XtransConnInfo ciptr)
+
+{
+    int ret;
+
+    prmsg (2,"Close(%d)\n", ciptr->fd);
+
+    ret = ciptr->transptr->Close (ciptr);
+
+    TRANS(FreeConnInfo) (ciptr);
+
+    return ret;
+}
+
+int
+TRANS(CloseForCloning) (XtransConnInfo ciptr)
+
+{
+    int ret;
+
+    prmsg (2,"CloseForCloning(%d)\n", ciptr->fd);
+
+    ret = ciptr->transptr->CloseForCloning (ciptr);
+
+    TRANS(FreeConnInfo) (ciptr);
+
+    return ret;
+}
+
+int
+TRANS(IsLocal) (XtransConnInfo ciptr)
+
+{
+    return (ciptr->family == AF_UNIX);
+}
+
+#ifdef NX_TRANS_SOCKET
+/* this is needed for pre-xcb X11 as we have in NX */
+int
+TRANS(GetMyAddr) (XtransConnInfo ciptr, int *familyp, int *addrlenp,
+                 Xtransaddr **addrp)
+
+{
+    prmsg (2,"GetMyAddr(%d)\n", ciptr->fd);
+
+    *familyp = ciptr->family;
+    *addrlenp = ciptr->addrlen;
+
+    if ((*addrp = (Xtransaddr *) malloc (ciptr->addrlen)) == NULL)
+    {
+       prmsg (1,"GetMyAddr: malloc failed\n");
+       return -1;
+    }
+    memcpy(*addrp, ciptr->addr, ciptr->addrlen);
+
+    return 0;
+}
+#endif
+
+int
+TRANS(GetPeerAddr) (XtransConnInfo ciptr, int *familyp, int *addrlenp,
+		    Xtransaddr **addrp)
+
+{
+    prmsg (2,"GetPeerAddr(%d)\n", ciptr->fd);
+
+    *familyp = ciptr->family;
+    *addrlenp = ciptr->peeraddrlen;
+
+    if ((*addrp = malloc (ciptr->peeraddrlen)) == NULL)
+    {
+	prmsg (1,"GetPeerAddr: malloc failed\n");
+	return -1;
+    }
+    memcpy(*addrp, ciptr->peeraddr, ciptr->peeraddrlen);
+
+    return 0;
+}
+
+
+int
+TRANS(GetConnectionNumber) (XtransConnInfo ciptr)
+
+{
+    return ciptr->fd;
+}
+
+
+/*
+ * These functions are really utility functions, but they require knowledge
+ * of the internal data structures, so they have to be part of the Transport
+ * Independant API.
+ */
+
+#ifdef TRANS_SERVER
+
+static int
+complete_network_count (void)
+
+{
+    int count = 0;
+    int found_local = 0;
+    int i;
+
+    /*
+     * For a complete network, we only need one LOCALCONN transport to work
+     */
+
+    for (i = 0; i < NUMTRANS; i++)
+    {
+	if (Xtransports[i].transport->flags & TRANS_ALIAS
+   	 || Xtransports[i].transport->flags & TRANS_NOLISTEN)
+	    continue;
+
+	if (Xtransports[i].transport->flags & TRANS_LOCAL)
+	    found_local = 1;
+	else
+	    count++;
+    }
+
+    return (count + found_local);
+}
+
+
+static int
+receive_listening_fds(const char* port, XtransConnInfo* temp_ciptrs,
+                      int* count_ret)
+
+{
+#ifdef HAVE_SYSTEMD_DAEMON
+    XtransConnInfo ciptr;
+    int i, systemd_listen_fds;
+
+    systemd_listen_fds = sd_listen_fds(1);
+    if (systemd_listen_fds < 0)
+    {
+        prmsg (1, "receive_listening_fds: sd_listen_fds error: %s\n",
+               strerror(-systemd_listen_fds));
+        return -1;
+    }
+
+    for (i = 0; i < systemd_listen_fds && *count_ret < NUMTRANS; i++)
+    {
+        struct sockaddr_storage a;
+        int ti;
+        const char* tn;
+        socklen_t al;
+
+        al = sizeof(a);
+        if (getsockname(i + SD_LISTEN_FDS_START, (struct sockaddr*)&a, &al) < 0) {
+            prmsg (1, "receive_listening_fds: getsockname error: %s\n",
+                   strerror(errno));
+            return -1;
+        }
+
+        switch (a.ss_family)
+        {
+        case AF_UNIX:
+            ti = TRANS_SOCKET_UNIX_INDEX;
+            if (*((struct sockaddr_un*)&a)->sun_path == '\0' &&
+                al > sizeof(sa_family_t))
+                tn = "local";
+            else
+                tn = "unix";
+            break;
+        case AF_INET:
+            ti = TRANS_SOCKET_INET_INDEX;
+            tn = "inet";
+            break;
+#if defined(IPv6) && defined(AF_INET6)
+        case AF_INET6:
+            ti = TRANS_SOCKET_INET6_INDEX;
+            tn = "inet6";
+            break;
+#endif /* IPv6 */
+        default:
+            prmsg (1, "receive_listening_fds:"
+                   "Got unknown socket address family\n");
+            return -1;
+        }
+
+        ciptr = TRANS(ReopenCOTSServer)(ti, i + SD_LISTEN_FDS_START, port);
+        if (!ciptr)
+        {
+            prmsg (1, "receive_listening_fds:"
+                   "Got NULL while trying to reopen socket received from systemd.\n");
+            return -1;
+        }
+
+        prmsg (5, "receive_listening_fds: received listener for %s, %d\n",
+               tn, ciptr->fd);
+        temp_ciptrs[(*count_ret)++] = ciptr;
+        TRANS(Received)(tn);
+    }
+#endif /* HAVE_SYSTEMD_DAEMON */
+    return 0;
+}
+
+#ifdef XQUARTZ_EXPORTS_LAUNCHD_FD
+extern int xquartz_launchd_fd;
+#endif
+
+int
+TRANS(MakeAllCOTSServerListeners) (const char *port, int *partial,
+                                   int *count_ret, XtransConnInfo **ciptrs_ret)
+
+{
+    char		buffer[256]; /* ??? What size ?? */
+    XtransConnInfo	ciptr, temp_ciptrs[NUMTRANS];
+    int			status, i, j;
+
+#if defined(IPv6) && defined(AF_INET6)
+    int		ipv6_succ = 0;
+#endif
+    prmsg (2,"MakeAllCOTSServerListeners(%s,%p)\n",
+	   port ? port : "NULL", (void *) ciptrs_ret);
+
+    *count_ret = 0;
+
+#ifdef XQUARTZ_EXPORTS_LAUNCHD_FD
+    fprintf(stderr, "Launchd socket fd: %d\n", xquartz_launchd_fd);
+    if(xquartz_launchd_fd != -1) {
+        if((ciptr = TRANS(ReopenCOTSServer(TRANS_SOCKET_LOCAL_INDEX,
+                                           xquartz_launchd_fd, getenv("DISPLAY"))))==NULL)
+            fprintf(stderr,"Got NULL while trying to Reopen launchd port\n");
+        else
+            temp_ciptrs[(*count_ret)++] = ciptr;
+    }
+#endif
+
+    if (receive_listening_fds(port, temp_ciptrs, count_ret) < 0)
+	return -1;
+
+    for (i = 0; i < NUMTRANS; i++)
+    {
+	Xtransport *trans = Xtransports[i].transport;
+	unsigned int flags = 0;
+
+	if (trans->flags&TRANS_ALIAS || trans->flags&TRANS_NOLISTEN ||
+	    trans->flags&TRANS_RECEIVED)
+	    continue;
+
+	snprintf(buffer, sizeof(buffer), "%s/:%s",
+		 trans->TransName, port ? port : "");
+
+	prmsg (5,"MakeAllCOTSServerListeners: opening %s\n",
+	       buffer);
+
+	if ((ciptr = TRANS(OpenCOTSServer(buffer))) == NULL)
+	{
+	    if (trans->flags & TRANS_DISABLED)
+		continue;
+
+	    prmsg (1,
+	  "MakeAllCOTSServerListeners: failed to open listener for %s\n",
+		  trans->TransName);
+	    continue;
+	}
+#if defined(IPv6) && defined(AF_INET6)
+		if ((Xtransports[i].transport_id == TRANS_SOCKET_INET_INDEX
+		     && ipv6_succ))
+		    flags |= ADDR_IN_USE_ALLOWED;
+#endif
+
+	if ((status = TRANS(CreateListener (ciptr, port, flags))) < 0)
+	{
+	    if (status == TRANS_ADDR_IN_USE)
+	    {
+		/*
+		 * We failed to bind to the specified address because the
+		 * address is in use.  It must be that a server is already
+		 * running at this address, and this function should fail.
+		 */
+
+		prmsg (1,
+		"MakeAllCOTSServerListeners: server already running\n");
+
+		for (j = 0; j < *count_ret; j++)
+		    TRANS(Close) (temp_ciptrs[j]);
+
+		*count_ret = 0;
+		*ciptrs_ret = NULL;
+		*partial = 0;
+		return -1;
+	    }
+	    else
+	    {
+		prmsg (1,
+	"MakeAllCOTSServerListeners: failed to create listener for %s\n",
+		  trans->TransName);
+
+		continue;
+	    }
+	}
+
+#if defined(IPv6) && defined(AF_INET6)
+	if (Xtransports[i].transport_id == TRANS_SOCKET_INET6_INDEX)
+	    ipv6_succ = 1;
+#endif
+
+	prmsg (5,
+	      "MakeAllCOTSServerListeners: opened listener for %s, %d\n",
+	      trans->TransName, ciptr->fd);
+
+	temp_ciptrs[*count_ret] = ciptr;
+	(*count_ret)++;
+    }
+
+    *partial = (*count_ret < complete_network_count());
+
+    prmsg (5,
+     "MakeAllCOTSServerListeners: partial=%d, actual=%d, complete=%d \n",
+	*partial, *count_ret, complete_network_count());
+
+    if (*count_ret > 0)
+    {
+	if ((*ciptrs_ret = malloc (
+	    *count_ret * sizeof (XtransConnInfo))) == NULL)
+	{
+	    return -1;
+	}
+
+	for (i = 0; i < *count_ret; i++)
+	{
+	    (*ciptrs_ret)[i] = temp_ciptrs[i];
+	}
+    }
+    else
+	*ciptrs_ret = NULL;
+
+    return 0;
+}
+
+#endif /* TRANS_SERVER */
+
+
+
+/*
+ * These routines are not part of the X Transport Interface, but they
+ * may be used by it.
+ */
+
+
+#ifdef WIN32
+
+/*
+ * emulate readv
+ */
+
+static int TRANS(ReadV) (XtransConnInfo ciptr, struct iovec *iov, int iovcnt)
+
+{
+    int i, len, total;
+    char *base;
+
+    ESET(0);
+    for (i = 0, total = 0;  i < iovcnt;  i++, iov++) {
+	len = iov->iov_len;
+	base = iov->iov_base;
+	while (len > 0) {
+	    register int nbytes;
+	    nbytes = TRANS(Read) (ciptr, base, len);
+	    if (nbytes < 0 && total == 0)  return -1;
+	    if (nbytes <= 0)  return total;
+	    ESET(0);
+	    len   -= nbytes;
+	    total += nbytes;
+	    base  += nbytes;
+	}
+    }
+    return total;
+}
+
+
+/*
+ * emulate writev
+ */
+
+static int TRANS(WriteV) (XtransConnInfo ciptr, struct iovec *iov, int iovcnt)
+
+{
+    int i, len, total;
+    char *base;
+
+    ESET(0);
+    for (i = 0, total = 0;  i < iovcnt;  i++, iov++) {
+	len = iov->iov_len;
+	base = iov->iov_base;
+	while (len > 0) {
+	    register int nbytes;
+	    nbytes = TRANS(Write) (ciptr, base, len);
+	    if (nbytes < 0 && total == 0)  return -1;
+	    if (nbytes <= 0)  return total;
+	    ESET(0);
+	    len   -= nbytes;
+	    total += nbytes;
+	    base  += nbytes;
+	}
+    }
+    return total;
+}
+
+#endif /* WIN32 */
+
+
+#if defined(_POSIX_SOURCE) || defined(USG) || defined(SVR4) || defined(__SVR4) || defined(__SCO__)
+#ifndef NEED_UTSNAME
+#define NEED_UTSNAME
+#endif
+#include <sys/utsname.h>
+#endif
+
+/*
+ * TRANS(GetHostname) - similar to gethostname but allows special processing.
+ */
+
+int TRANS(GetHostname) (char *buf, int maxlen)
+
+{
+    int len;
+
+#ifdef NEED_UTSNAME
+    struct utsname name;
+
+    uname (&name);
+    len = strlen (name.nodename);
+    if (len >= maxlen) len = maxlen - 1;
+    strncpy (buf, name.nodename, len);
+    buf[len] = '\0';
+#else
+    buf[0] = '\0';
+    (void) gethostname (buf, maxlen);
+    buf [maxlen - 1] = '\0';
+    len = strlen(buf);
+#endif /* NEED_UTSNAME */
+    return len;
+}
diff --git a/nx-X11/lib/include/xtrans/Xtrans.h b/nx-X11/lib/include/xtrans/Xtrans.h
new file mode 100644
index 000000000..54b2a1425
--- /dev/null
+++ b/nx-X11/lib/include/xtrans/Xtrans.h
@@ -0,0 +1,426 @@
+/*
+
+Copyright 1993, 1994, 1998  The Open Group
+
+Permission to use, copy, modify, distribute, and sell this software and its
+documentation for any purpose is hereby granted without fee, provided that
+the above copyright notice appear in all copies and that both that
+copyright notice and this permission notice appear in supporting
+documentation.
+
+The above copyright notice and this permission notice shall be included
+in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR
+OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.
+
+Except as contained in this notice, the name of The Open Group shall
+not be used in advertising or otherwise to promote the sale, use or
+other dealings in this Software without prior written authorization
+from The Open Group.
+
+ * Copyright 1993, 1994 NCR Corporation - Dayton, Ohio, USA
+ *
+ * All Rights Reserved
+ *
+ * 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 NCR not be used in advertising
+ * or publicity pertaining to distribution of the software without specific,
+ * written prior permission.  NCR makes no representations about the
+ * suitability of this software for any purpose.  It is provided "as is"
+ * without express or implied warranty.
+ *
+ * NCR DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
+ * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN
+ * NO EVENT SHALL NCR BE LIABLE FOR ANY SPECIAL, INDIRECT OR
+ * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS
+ * OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
+ * NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
+ * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+#ifndef _XTRANS_H_
+#define _XTRANS_H_
+
+#include <nx-X11/Xfuncproto.h>
+#include <nx-X11/Xos.h>
+#include <nx-X11/Xmd.h>
+
+#ifndef WIN32
+#include <sys/socket.h>
+#endif
+
+#ifdef __clang__
+/* Not all clients make use of all provided statics */
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wunused-function"
+#endif
+
+/*
+ * Set the functions names according to where this code is being compiled.
+ */
+
+#ifdef X11_t
+#define TRANS(func) _X11Trans##func
+#ifdef XTRANSDEBUG
+static const char *__xtransname = "_X11Trans";
+#endif
+#endif /* X11_t */
+
+#ifdef XSERV_t
+#define TRANS(func) _XSERVTrans##func
+#ifdef XTRANSDEBUG
+static const char *__xtransname = "_XSERVTrans";
+#endif
+#define X11_t
+#endif /* XSERV_t */
+
+#ifdef XIM_t
+#define TRANS(func) _XimXTrans##func
+#ifdef XTRANSDEBUG
+static const char *__xtransname = "_XimTrans";
+#endif
+#endif /* XIM_t */
+
+#ifdef FS_t
+#define TRANS(func) _FSTrans##func
+#ifdef XTRANSDEBUG
+static const char *__xtransname = "_FSTrans";
+#endif
+#endif /* FS_t */
+
+#ifdef FONT_t
+#define TRANS(func) _FontTrans##func
+#ifdef XTRANSDEBUG
+static const char *__xtransname = "_FontTrans";
+#endif
+#endif /* FONT_t */
+
+#ifdef ICE_t
+#define TRANS(func) _IceTrans##func
+#ifdef XTRANSDEBUG
+static const char *__xtransname = "_IceTrans";
+#endif
+#endif /* ICE_t */
+
+#if !defined(TRANS)
+#define TRANS(func) _XTrans##func
+#ifdef XTRANSDEBUG
+static const char *__xtransname = "_XTrans";
+#endif
+#endif /* !TRANS */
+
+#ifdef __clang__
+#pragma clang diagnostic pop
+#endif
+
+/*
+ * Create a single address structure that can be used wherever
+ * an address structure is needed. struct sockaddr is not big enough
+ * to hold a sockadd_un, so we create this definition to have a single
+ * structure that is big enough for all the structures we might need.
+ *
+ * This structure needs to be independent of the socket/TLI interface used.
+ */
+
+#if defined(IPv6) && defined(AF_INET6)
+typedef struct sockaddr_storage Xtransaddr;
+#else
+#define XTRANS_MAX_ADDR_LEN	128	/* large enough to hold sun_path */
+
+typedef	struct {
+    unsigned char	addr[XTRANS_MAX_ADDR_LEN];
+} Xtransaddr;
+#endif
+
+#ifdef LONG64
+typedef int BytesReadable_t;
+#else
+typedef long BytesReadable_t;
+#endif
+
+
+#if defined(WIN32) || defined(USG)
+
+/*
+ *      TRANS(Readv) and TRANS(Writev) use struct iovec, normally found
+ *      in Berkeley systems in <sys/uio.h>.  See the readv(2) and writev(2)
+ *      manual pages for details.
+ */
+
+struct iovec {
+    caddr_t iov_base;
+    int iov_len;
+};
+
+#else
+#include <sys/uio.h>
+#endif
+
+typedef struct _XtransConnInfo *XtransConnInfo;
+
+
+/*
+ * Transport Option definitions
+ */
+
+#define TRANS_NONBLOCKING	1
+#define	TRANS_CLOSEONEXEC	2
+
+
+/*
+ * Return values of Connect (0 is success)
+ */
+
+#define TRANS_CONNECT_FAILED 	-1
+#define TRANS_TRY_CONNECT_AGAIN -2
+#define TRANS_IN_PROGRESS	-3
+
+
+/*
+ * Return values of CreateListener (0 is success)
+ */
+
+#define TRANS_CREATE_LISTENER_FAILED 	-1
+#define TRANS_ADDR_IN_USE		-2
+
+
+/*
+ * Return values of Accept (0 is success)
+ */
+
+#define TRANS_ACCEPT_BAD_MALLOC			-1
+#define TRANS_ACCEPT_FAILED 			-2
+#define TRANS_ACCEPT_MISC_ERROR			-3
+
+
+/*
+ * ResetListener return values
+ */
+
+#define TRANS_RESET_NOOP	1
+#define TRANS_RESET_NEW_FD	2
+#define TRANS_RESET_FAILURE	3
+
+
+/*
+ * Function prototypes for the exposed interface
+ */
+
+void TRANS(FreeConnInfo) (
+    XtransConnInfo 	/* ciptr */
+);
+
+#ifdef TRANS_CLIENT
+
+XtransConnInfo TRANS(OpenCOTSClient)(
+    const char *	/* address */
+);
+
+#endif /* TRANS_CLIENT */
+
+#ifdef TRANS_SERVER
+
+XtransConnInfo TRANS(OpenCOTSServer)(
+    const char *	/* address */
+);
+
+#endif /* TRANS_SERVER */
+
+#ifdef TRANS_REOPEN
+
+XtransConnInfo TRANS(ReopenCOTSServer)(
+    int,		/* trans_id */
+    int,		/* fd */
+    const char *	/* port */
+);
+
+int TRANS(GetReopenInfo)(
+    XtransConnInfo,	/* ciptr */
+    int *,		/* trans_id */
+    int *,		/* fd */
+    char **		/* port */
+);
+
+#endif /* TRANS_REOPEN */
+
+
+int TRANS(SetOption)(
+    XtransConnInfo,	/* ciptr */
+    int,		/* option */
+    int			/* arg */
+);
+
+#ifdef TRANS_SERVER
+
+int TRANS(CreateListener)(
+    XtransConnInfo,	/* ciptr */
+    const char *,	/* port */
+    unsigned int	/* flags */
+);
+
+int TRANS(Received) (
+    const char*         /* protocol*/
+);
+
+int TRANS(NoListen) (
+    const char*         /* protocol*/
+);
+
+int TRANS(Listen) (
+    const char*         /* protocol*/
+);
+
+int TRANS(IsListening) (
+    const char*         /* protocol*/
+);
+
+int TRANS(ResetListener)(
+    XtransConnInfo	/* ciptr */
+);
+
+XtransConnInfo TRANS(Accept)(
+    XtransConnInfo,	/* ciptr */
+    int *		/* status */
+);
+
+#endif /* TRANS_SERVER */
+
+#ifdef TRANS_CLIENT
+
+int TRANS(Connect)(
+    XtransConnInfo,	/* ciptr */
+    const char *	/* address */
+);
+
+#endif /* TRANS_CLIENT */
+
+int TRANS(BytesReadable)(
+    XtransConnInfo,	/* ciptr */
+    BytesReadable_t *	/* pend */
+);
+
+int TRANS(Read)(
+    XtransConnInfo,	/* ciptr */
+    char *,		/* buf */
+    int			/* size */
+);
+
+int TRANS(Write)(
+    XtransConnInfo,	/* ciptr */
+    char *,		/* buf */
+    int			/* size */
+);
+
+int TRANS(Readv)(
+    XtransConnInfo,	/* ciptr */
+    struct iovec *,	/* buf */
+    int			/* size */
+);
+
+int TRANS(Writev)(
+    XtransConnInfo,	/* ciptr */
+    struct iovec *,	/* buf */
+    int			/* size */
+);
+
+int TRANS(SendFd) (XtransConnInfo ciptr, int fd, int do_close);
+
+int TRANS(RecvFd) (XtransConnInfo ciptr);
+
+int TRANS(Disconnect)(
+    XtransConnInfo	/* ciptr */
+);
+
+int TRANS(Close)(
+    XtransConnInfo	/* ciptr */
+);
+
+int TRANS(CloseForCloning)(
+    XtransConnInfo	/* ciptr */
+);
+
+int TRANS(IsLocal)(
+    XtransConnInfo	/* ciptr */
+);
+
+#ifdef NX_TRANS_SOCKET
+/* needed for pre-xcb libX11 as we have in NX */
+int TRANS(GetMyAddr)(
+    XtransConnInfo,    /* ciptr */
+    int *,             /* familyp */
+    int *,             /* addrlenp */
+    Xtransaddr **      /* addrp */
+);
+#endif
+
+int TRANS(GetPeerAddr)(
+    XtransConnInfo,	/* ciptr */
+    int *,		/* familyp */
+    int *,		/* addrlenp */
+    Xtransaddr **	/* addrp */
+);
+
+int TRANS(GetConnectionNumber)(
+    XtransConnInfo	/* ciptr */
+);
+
+#ifdef TRANS_SERVER
+
+int TRANS(MakeAllCOTSServerListeners)(
+    const char *,	/* port */
+    int *,		/* partial */
+    int *,		/* count_ret */
+    XtransConnInfo **	/* ciptrs_ret */
+);
+
+#endif /* TRANS_SERVER */
+
+
+/*
+ * Function Prototypes for Utility Functions.
+ */
+
+#ifdef X11_t
+
+int TRANS(ConvertAddress)(
+    int *,		/* familyp */
+    int *,		/* addrlenp */
+    Xtransaddr **	/* addrp */
+);
+
+#endif /* X11_t */
+
+#ifdef ICE_t
+
+char *
+TRANS(GetMyNetworkId)(
+    XtransConnInfo	/* ciptr */
+);
+
+char *
+TRANS(GetPeerNetworkId)(
+    XtransConnInfo	/* ciptr */
+);
+
+#endif /* ICE_t */
+
+int
+TRANS(GetHostname) (
+    char *	/* buf */,
+    int 	/* maxlen */
+);
+
+#if defined(WIN32) && defined(TCPCONN)
+int TRANS(WSAStartup)();
+#endif
+
+#endif /* _XTRANS_H_ */
diff --git a/nx-X11/lib/include/xtrans/Xtransint.h b/nx-X11/lib/include/xtrans/Xtransint.h
new file mode 100644
index 000000000..f7e07687b
--- /dev/null
+++ b/nx-X11/lib/include/xtrans/Xtransint.h
@@ -0,0 +1,433 @@
+/*
+
+Copyright 1993, 1994, 1998  The Open Group
+
+Permission to use, copy, modify, distribute, and sell this software and its
+documentation for any purpose is hereby granted without fee, provided that
+the above copyright notice appear in all copies and that both that
+copyright notice and this permission notice appear in supporting
+documentation.
+
+The above copyright notice and this permission notice shall be included
+in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR
+OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.
+
+Except as contained in this notice, the name of The Open Group shall
+not be used in advertising or otherwise to promote the sale, use or
+other dealings in this Software without prior written authorization
+from The Open Group.
+
+ * Copyright 1993, 1994 NCR Corporation - Dayton, Ohio, USA
+ *
+ * All Rights Reserved
+ *
+ * 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 NCR not be used in advertising
+ * or publicity pertaining to distribution of the software without specific,
+ * written prior permission.  NCR makes no representations about the
+ * suitability of this software for any purpose.  It is provided "as is"
+ * without express or implied warranty.
+ *
+ * NCR DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
+ * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN
+ * NO EVENT SHALL NCR BE LIABLE FOR ANY SPECIAL, INDIRECT OR
+ * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS
+ * OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
+ * NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
+ * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+#ifndef _XTRANSINT_H_
+#define _XTRANSINT_H_
+
+/*
+ * XTRANSDEBUG will enable the PRMSG() macros used in the X Transport
+ * Interface code. Each use of the PRMSG macro has a level associated with
+ * it. XTRANSDEBUG is defined to be a level. If the invocation level is =<
+ * the value of XTRANSDEBUG, then the message will be printed out to stderr.
+ * Recommended levels are:
+ *
+ *	XTRANSDEBUG=1	Error messages
+ *	XTRANSDEBUG=2 API Function Tracing
+ *	XTRANSDEBUG=3 All Function Tracing
+ *	XTRANSDEBUG=4 printing of intermediate values
+ *	XTRANSDEBUG=5 really detailed stuff
+#define XTRANSDEBUG 2
+ *
+ * Defining XTRANSDEBUGTIMESTAMP will cause printing timestamps with each
+ * message.
+ */
+
+#if !defined(XTRANSDEBUG) && defined(XTRANS_TRANSPORT_C)
+#  define XTRANSDEBUG 1
+#endif
+
+#ifdef WIN32
+# define _WILLWINSOCK_
+#endif
+
+#include "Xtrans.h"
+
+#ifndef _X_UNUSED  /* Defined in Xfuncproto.h in xproto >= 7.0.22 */
+# define _X_UNUSED  /* */
+#endif
+
+#ifdef XTRANSDEBUG
+# include <stdio.h>
+#endif /* XTRANSDEBUG */
+
+#include <errno.h>
+
+#ifndef WIN32
+#  include <sys/socket.h>
+# include <netinet/in.h>
+# include <arpa/inet.h>
+
+/*
+ * Moved the setting of NEED_UTSNAME to this header file from Xtrans.c,
+ * to avoid a race condition. JKJ (6/5/97)
+ */
+
+# if defined(_POSIX_SOURCE) || defined(USG) || defined(SVR4) || defined(__SVR4) || defined(__SCO__)
+#  ifndef NEED_UTSNAME
+#   define NEED_UTSNAME
+#  endif
+#  include <sys/utsname.h>
+# endif
+
+#  define ESET(val) errno = val
+# define EGET() errno
+
+#else /* WIN32 */
+
+# include <limits.h>	/* for USHRT_MAX */
+
+# define ESET(val) WSASetLastError(val)
+# define EGET() WSAGetLastError()
+
+#endif /* WIN32 */
+
+#include <stddef.h>
+
+#ifdef X11_t
+#define X_TCP_PORT	6000
+#endif
+
+#if XTRANS_SEND_FDS
+
+struct _XtransConnFd {
+    struct _XtransConnFd   *next;
+    int                    fd;
+    int                    do_close;
+};
+
+#endif
+
+struct _XtransConnInfo {
+    struct _Xtransport     *transptr;
+    int		index;
+    char	*priv;
+    int		flags;
+    int		fd;
+    char	*port;
+    int		family;
+    char	*addr;
+    int		addrlen;
+    char	*peeraddr;
+    int		peeraddrlen;
+    struct _XtransConnFd        *recv_fds;
+    struct _XtransConnFd        *send_fds;
+};
+
+#define XTRANS_OPEN_COTS_CLIENT       1
+#define XTRANS_OPEN_COTS_SERVER       2
+
+typedef struct _Xtransport {
+    const char	*TransName;
+    int		flags;
+
+#ifdef TRANS_CLIENT
+
+    XtransConnInfo (*OpenCOTSClient)(
+	struct _Xtransport *,	/* transport */
+	const char *,		/* protocol */
+	const char *,		/* host */
+	const char *		/* port */
+    );
+
+#endif /* TRANS_CLIENT */
+
+#ifdef TRANS_SERVER
+    const char **	nolisten;
+    XtransConnInfo (*OpenCOTSServer)(
+	struct _Xtransport *,	/* transport */
+	const char *,		/* protocol */
+	const char *,		/* host */
+	const char *		/* port */
+    );
+
+#endif /* TRANS_SERVER */
+
+#ifdef TRANS_REOPEN
+
+    XtransConnInfo (*ReopenCOTSServer)(
+	struct _Xtransport *,	/* transport */
+        int,			/* fd */
+        const char *		/* port */
+    );
+
+#endif /* TRANS_REOPEN */
+
+
+    int	(*SetOption)(
+	XtransConnInfo,		/* connection */
+	int,			/* option */
+	int			/* arg */
+    );
+
+#ifdef TRANS_SERVER
+/* Flags */
+# define ADDR_IN_USE_ALLOWED	1
+
+    int	(*CreateListener)(
+	XtransConnInfo,		/* connection */
+	const char *,		/* port */
+	unsigned int		/* flags */
+    );
+
+    int	(*ResetListener)(
+	XtransConnInfo		/* connection */
+    );
+
+    XtransConnInfo (*Accept)(
+	XtransConnInfo,		/* connection */
+        int *			/* status */
+    );
+
+#endif /* TRANS_SERVER */
+
+#ifdef TRANS_CLIENT
+
+    int	(*Connect)(
+	XtransConnInfo,		/* connection */
+	const char *,		/* host */
+	const char *		/* port */
+    );
+
+#endif /* TRANS_CLIENT */
+
+    int	(*BytesReadable)(
+	XtransConnInfo,		/* connection */
+	BytesReadable_t *	/* pend */
+    );
+
+    int	(*Read)(
+	XtransConnInfo,		/* connection */
+	char *,			/* buf */
+	int			/* size */
+    );
+
+    int	(*Write)(
+	XtransConnInfo,		/* connection */
+	char *,			/* buf */
+	int			/* size */
+    );
+
+    int	(*Readv)(
+	XtransConnInfo,		/* connection */
+	struct iovec *,		/* buf */
+	int			/* size */
+    );
+
+    int	(*Writev)(
+	XtransConnInfo,		/* connection */
+	struct iovec *,		/* buf */
+	int			/* size */
+    );
+
+#if XTRANS_SEND_FDS
+    int (*SendFd)(
+	XtransConnInfo,		/* connection */
+        int,                    /* fd */
+        int                     /* do_close */
+    );
+
+    int (*RecvFd)(
+	XtransConnInfo		/* connection */
+    );
+#endif
+
+    int	(*Disconnect)(
+	XtransConnInfo		/* connection */
+    );
+
+    int	(*Close)(
+	XtransConnInfo		/* connection */
+    );
+
+    int	(*CloseForCloning)(
+	XtransConnInfo		/* connection */
+    );
+
+} Xtransport;
+
+
+typedef struct _Xtransport_table {
+    Xtransport	*transport;
+    int		transport_id;
+} Xtransport_table;
+
+
+/*
+ * Flags for the flags member of Xtransport.
+ */
+
+#define TRANS_ALIAS	(1<<0)	/* record is an alias, don't create server */
+#define TRANS_LOCAL	(1<<1)	/* local transport */
+#define TRANS_DISABLED	(1<<2)	/* Don't open this one */
+#define TRANS_NOLISTEN  (1<<3)  /* Don't listen on this one */
+#define TRANS_NOUNLINK	(1<<4)	/* Don't unlink transport endpoints */
+#define TRANS_ABSTRACT	(1<<5)	/* Use abstract sockets if available */
+#define TRANS_NOXAUTH	(1<<6)	/* Don't verify authentication (because it's secure some other way at the OS layer) */
+#define TRANS_RECEIVED	(1<<7)  /* The fd for this has already been opened by someone else. */
+
+/* Flags to preserve when setting others */
+#define TRANS_KEEPFLAGS	(TRANS_NOUNLINK|TRANS_ABSTRACT)
+
+#ifdef XTRANS_TRANSPORT_C /* only provide static function prototypes when
+			     building the transport.c file that has them in */
+
+#ifdef __clang__
+/* Not all clients make use of all provided statics */
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wunused-function"
+#endif
+
+/*
+ * readv() and writev() don't exist or don't work correctly on some
+ * systems, so they may be emulated.
+ */
+
+#ifdef WIN32
+
+#define READV(ciptr, iov, iovcnt)	TRANS(ReadV)(ciptr, iov, iovcnt)
+
+static	int TRANS(ReadV)(
+    XtransConnInfo,	/* ciptr */
+    struct iovec *,	/* iov */
+    int			/* iovcnt */
+);
+
+#else
+
+#define READV(ciptr, iov, iovcnt)	readv(ciptr->fd, iov, iovcnt)
+
+#endif /* WIN32 */
+
+
+#ifdef WIN32
+
+#define WRITEV(ciptr, iov, iovcnt)	TRANS(WriteV)(ciptr, iov, iovcnt)
+
+static int TRANS(WriteV)(
+    XtransConnInfo,	/* ciptr */
+    struct iovec *,	/* iov */
+    int 		/* iovcnt */
+);
+
+#else
+
+#define WRITEV(ciptr, iov, iovcnt)	writev(ciptr->fd, iov, iovcnt)
+
+#endif /* WIN32 */
+
+#if defined(X11_t)
+static int is_numeric (
+    const char *	/* str */
+);
+#endif
+
+#ifdef TRANS_SERVER
+static int trans_mkdir (
+    const char *,	/* path */
+    int			/* mode */
+);
+#endif
+
+#ifdef __clang__
+#pragma clang diagnostic pop
+#endif
+
+/*
+ * Some XTRANSDEBUG stuff
+ */
+
+#ifdef XTRANSDEBUG
+#include <stdarg.h>
+
+/*
+ * The X server provides ErrorF() & VErrorF(), for other software that uses
+ * xtrans, we provide our own simple versions.
+ */
+# if defined(XSERV_t) && defined(TRANS_SERVER)
+#  include "os.h"
+# else
+static inline void _X_ATTRIBUTE_PRINTF(1, 0)
+VErrorF(const char *f, va_list args)
+{
+    vfprintf(stderr, f, args);
+    fflush(stderr);
+}
+
+static inline void  _X_ATTRIBUTE_PRINTF(1, 2)
+ErrorF(const char *f, ...)
+{
+    va_list args;
+
+    va_start(args, f);
+    VErrorF(f, args);
+    va_end(args);
+}
+# endif /* xserver */
+#endif /* XTRANSDEBUG */
+
+static inline void  _X_ATTRIBUTE_PRINTF(2, 3)
+prmsg(int lvl, const char *f, ...)
+{
+#ifdef XTRANSDEBUG
+    va_list args;
+
+    va_start(args, f);
+    if (lvl <= XTRANSDEBUG) {
+	int saveerrno = errno;
+
+	ErrorF("%s", __xtransname);
+	VErrorF(f, args);
+
+# ifdef XTRANSDEBUGTIMESTAMP
+	{
+	    struct timeval tp;
+	    gettimeofday(&tp, 0);
+	    ErrorF("timestamp (ms): %d\n",
+		   tp.tv_sec * 1000 + tp.tv_usec / 1000);
+	}
+# endif
+	errno = saveerrno;
+    }
+    va_end(args);
+#endif /* XTRANSDEBUG */
+}
+
+#endif /* XTRANS_TRANSPORT_C */
+
+#endif /* _XTRANSINT_H_ */
diff --git a/nx-X11/lib/include/xtrans/Xtranslcl.c b/nx-X11/lib/include/xtrans/Xtranslcl.c
new file mode 100644
index 000000000..7231d2a83
--- /dev/null
+++ b/nx-X11/lib/include/xtrans/Xtranslcl.c
@@ -0,0 +1,2486 @@
+/*
+
+Copyright 1993, 1994, 1998  The Open Group
+
+Permission to use, copy, modify, distribute, and sell this software and its
+documentation for any purpose is hereby granted without fee, provided that
+the above copyright notice appear in all copies and that both that
+copyright notice and this permission notice appear in supporting
+documentation.
+
+The above copyright notice and this permission notice shall be included
+in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR
+OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.
+
+Except as contained in this notice, the name of The Open Group shall
+not be used in advertising or otherwise to promote the sale, use or
+other dealings in this Software without prior written authorization
+from The Open Group.
+
+ * Copyright 1993, 1994 NCR Corporation - Dayton, Ohio, USA
+ *
+ * All Rights Reserved
+ *
+ * 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 NCR not be used in advertising
+ * or publicity pertaining to distribution of the software without specific,
+ * written prior permission.  NCR makes no representations about the
+ * suitability of this software for any purpose.  It is provided "as is"
+ * without express or implied warranty.
+ *
+ * NCR DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
+ * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN
+ * NO EVENT SHALL NCR BE LIABLE FOR ANY SPECIAL, INDIRECT OR
+ * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS
+ * OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
+ * NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
+ * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+/*
+ *
+ * The connection code/ideas in lib/X and server/os for SVR4/Intel
+ * environments was contributed by the following companies/groups:
+ *
+ *	MetroLink Inc
+ *	NCR
+ *	Pittsburgh Powercomputing Corporation (PPc)/Quarterdeck Office Systems
+ *	SGCS
+ *	Unix System Laboratories (USL) / Novell
+ *	XFree86
+ *
+ * The goal is to have common connection code among all SVR4/Intel vendors.
+ *
+ * ALL THE ABOVE COMPANIES DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS
+ * SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS,
+ * IN NO EVENT SHALL THESE COMPANIES * BE LIABLE FOR ANY SPECIAL, INDIRECT
+ * OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS
+ * OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
+ * OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE
+ * OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+#include <errno.h>
+#include <ctype.h>
+#include <sys/signal.h>
+#include <sys/ioctl.h>
+#include <sys/stat.h>
+#if defined(SVR4) || defined(__SVR4)
+#include <sys/filio.h>
+#endif
+#ifdef __sun
+# include <stropts.h>
+#else
+#include <sys/stropts.h>
+#endif
+#include <sys/wait.h>
+#include <sys/types.h>
+
+/*
+ * The local transports should be treated the same as a UNIX domain socket
+ * wrt authentication, etc. Because of this, we will use struct sockaddr_un
+ * for the address format. This will simplify the code in other places like
+ * The X Server.
+ */
+
+#include <sys/socket.h>
+#ifndef X_NO_SYS_UN
+#include <sys/un.h>
+#endif
+
+
+/* Types of local connections supported:
+ *  - PTS
+ *  - named pipes
+ *  - SCO
+ */
+#if !defined(__sun)
+# define LOCAL_TRANS_PTS
+#endif
+#if defined(SVR4) || defined(__SVR4)
+# define LOCAL_TRANS_NAMED
+#endif
+#if defined(__SCO__) || defined(__UNIXWARE__)
+# define LOCAL_TRANS_SCO
+#endif
+
+static int TRANS(LocalClose)(XtransConnInfo ciptr);
+
+/*
+ * These functions actually implement the local connection mechanisms.
+ */
+
+/* Type Not Supported */
+
+static int
+TRANS(OpenFail)(XtransConnInfo ciptr _X_UNUSED, const char *port _X_UNUSED)
+
+{
+    return -1;
+}
+
+#ifdef TRANS_REOPEN
+
+static int
+TRANS(ReopenFail)(XtransConnInfo ciptr _X_UNUSED, int fd _X_UNUSED,
+                  const char *port _X_UNUSED)
+
+{
+    return 0;
+}
+
+#endif /* TRANS_REOPEN */
+
+#if XTRANS_SEND_FDS
+static int
+TRANS(LocalRecvFdInvalid)(XtransConnInfo ciptr)
+{
+    errno = EINVAL;
+    return -1;
+}
+
+static int
+TRANS(LocalSendFdInvalid)(XtransConnInfo ciptr, int fd, int do_close)
+{
+    errno = EINVAL;
+    return -1;
+}
+#endif
+
+
+static int
+TRANS(FillAddrInfo)(XtransConnInfo ciptr,
+                    const char *sun_path, const char *peer_sun_path)
+
+{
+    struct sockaddr_un	*sunaddr;
+    struct sockaddr_un	*p_sunaddr;
+
+    ciptr->family = AF_UNIX;
+    ciptr->addrlen = sizeof (struct sockaddr_un);
+
+    if ((sunaddr = malloc (ciptr->addrlen)) == NULL)
+    {
+	prmsg(1,"FillAddrInfo: failed to allocate memory for addr\n");
+	return 0;
+    }
+
+    sunaddr->sun_family = AF_UNIX;
+
+    if (strlen(sun_path) > sizeof(sunaddr->sun_path) - 1) {
+	prmsg(1, "FillAddrInfo: path too long\n");
+	free((char *) sunaddr);
+	return 0;
+    }
+    strcpy (sunaddr->sun_path, sun_path);
+#if defined(BSD44SOCKETS)
+    sunaddr->sun_len = strlen (sunaddr->sun_path);
+#endif
+
+    ciptr->addr = (char *) sunaddr;
+
+    ciptr->peeraddrlen = sizeof (struct sockaddr_un);
+
+    if ((p_sunaddr = malloc (ciptr->peeraddrlen)) == NULL)
+    {
+	prmsg(1,
+	   "FillAddrInfo: failed to allocate memory for peer addr\n");
+	free (sunaddr);
+	ciptr->addr = NULL;
+
+	return 0;
+    }
+
+    p_sunaddr->sun_family = AF_UNIX;
+
+    if (strlen(peer_sun_path) > sizeof(p_sunaddr->sun_path) - 1) {
+	prmsg(1, "FillAddrInfo: peer path too long\n");
+	free((char *) p_sunaddr);
+	return 0;
+    }
+    strcpy (p_sunaddr->sun_path, peer_sun_path);
+#if defined(BSD44SOCKETS)
+    p_sunaddr->sun_len = strlen (p_sunaddr->sun_path);
+#endif
+
+    ciptr->peeraddr = (char *) p_sunaddr;
+
+    return 1;
+}
+
+
+
+#ifdef LOCAL_TRANS_PTS
+/* PTS */
+
+#if defined(SYSV) && !defined(__SCO__)
+#define SIGNAL_T int
+#else
+#define SIGNAL_T void
+#endif /* SYSV */
+
+typedef SIGNAL_T (*PFV)();
+
+extern PFV signal();
+
+extern char *ptsname(
+    int
+);
+
+static void _dummy(int sig _X_UNUSED)
+
+{
+}
+#endif /* LOCAL_TRANS_PTS */
+
+#ifndef __sun
+#define X_STREAMS_DIR	"/dev/X"
+#define DEV_SPX		"/dev/spx"
+#else
+#ifndef X11_t
+#define X_STREAMS_DIR	"/dev/X"
+#else
+#define X_STREAMS_DIR	"/tmp/.X11-pipe"
+#endif
+#endif
+
+#define DEV_PTMX	"/dev/ptmx"
+
+#if defined(X11_t)
+
+#define PTSNODENAME "/dev/X/server."
+#ifdef __sun
+#define NAMEDNODENAME "/tmp/.X11-pipe/X"
+#else
+#define NAMEDNODENAME "/dev/X/Nserver."
+
+#define SCORNODENAME	"/dev/X%1sR"
+#define SCOSNODENAME	"/dev/X%1sS"
+#endif /* !__sun */
+#endif
+#if defined(XIM_t)
+#ifdef __sun
+#define NAMEDNODENAME "/tmp/.XIM-pipe/XIM"
+#else
+#define PTSNODENAME	"/dev/X/XIM."
+#define NAMEDNODENAME	"/dev/X/NXIM."
+#define SCORNODENAME	"/dev/XIM.%sR"
+#define SCOSNODENAME	"/dev/XIM.%sS"
+#endif
+#endif
+#if defined(FS_t) || defined (FONT_t)
+#ifdef __sun
+#define NAMEDNODENAME	"/tmp/.font-pipe/fs"
+#else
+/*
+ * USL has already defined something here. We need to check with them
+ * and see if their choice is usable here.
+ */
+#define PTSNODENAME	"/dev/X/fontserver."
+#define NAMEDNODENAME	"/dev/X/Nfontserver."
+#define SCORNODENAME	"/dev/fontserver.%sR"
+#define SCOSNODENAME	"/dev/fontserver.%sS"
+#endif
+#endif
+#if defined(ICE_t)
+#ifdef __sun
+#define NAMEDNODENAME	"/tmp/.ICE-pipe/"
+#else
+#define PTSNODENAME	"/dev/X/ICE."
+#define NAMEDNODENAME	"/dev/X/NICE."
+#define SCORNODENAME	"/dev/ICE.%sR"
+#define SCOSNODENAME	"/dev/ICE.%sS"
+#endif
+#endif
+#if defined(TEST_t)
+#ifdef __sun
+#define NAMEDNODENAME	"/tmp/.Test-unix/test"
+#endif
+#define PTSNODENAME	"/dev/X/transtest."
+#define NAMEDNODENAME	"/dev/X/Ntranstest."
+#define SCORNODENAME	"/dev/transtest.%sR"
+#define SCOSNODENAME	"/dev/transtest.%sS"
+#endif
+
+
+
+#ifdef LOCAL_TRANS_PTS
+#ifdef TRANS_CLIENT
+
+static int
+TRANS(PTSOpenClient)(XtransConnInfo ciptr, const char *port)
+
+{
+#ifdef PTSNODENAME
+    int			fd,server,exitval,alarm_time,ret;
+    char		server_path[64];
+    char		*slave, namelen;
+    char		buf[20]; /* MAX_PATH_LEN?? */
+    PFV			savef;
+    pid_t		saved_pid;
+#endif
+
+    prmsg(2,"PTSOpenClient(%s)\n", port);
+
+#if !defined(PTSNODENAME)
+    prmsg(1,"PTSOpenClient: Protocol is not supported by a pts connection\n");
+    return -1;
+#else
+    if (port && *port ) {
+	if( *port == '/' ) { /* A full pathname */
+	    snprintf(server_path, sizeof(server_path), "%s", port);
+	    } else {
+	    snprintf(server_path, sizeof(server_path), "%s%s",
+		     PTSNODENAME, port);
+	    }
+    } else {
+	snprintf(server_path, sizeof(server_path), "%s%d",
+		 PTSNODENAME, getpid());
+    }
+
+
+    /*
+     * Open the node the on which the server is listening.
+     */
+
+    if ((server = open (server_path, O_RDWR)) < 0) {
+	prmsg(1,"PTSOpenClient: failed to open %s\n", server_path);
+	return -1;
+    }
+
+
+    /*
+     * Open the streams based pipe that will be this connection.
+     */
+
+    if ((fd = open(DEV_PTMX, O_RDWR)) < 0) {
+	prmsg(1,"PTSOpenClient: failed to open %s\n", DEV_PTMX);
+	close(server);
+	return(-1);
+    }
+
+    (void) grantpt(fd);
+    (void) unlockpt(fd);
+
+    slave = ptsname(fd); /* get name */
+
+    if( slave == NULL ) {
+	prmsg(1,"PTSOpenClient: failed to get ptsname()\n");
+	close(fd);
+	close(server);
+	return -1;
+    }
+
+    /*
+     * This is neccesary for the case where a program is setuid to non-root.
+     * grantpt() calls /usr/lib/pt_chmod which is set-uid root. This program will
+     * set the owner of the pt device incorrectly if the uid is not restored
+     * before it is called. The problem is that once it gets restored, it
+     * cannot be changed back to its original condition, hence the fork().
+     */
+
+    if(!(saved_pid=fork())) {
+	uid_t       saved_euid;
+
+	saved_euid = geteuid();
+	/** sets the euid to the actual/real uid **/
+	if (setuid( getuid() ) == -1) {
+		exit(1);
+	}
+	if( chown( slave, saved_euid, -1 ) < 0 ) {
+		exit( 1 );
+		}
+
+	exit( 0 );
+    }
+
+    waitpid(saved_pid, &exitval, 0);
+    if (WIFEXITED(exitval) && WEXITSTATUS(exitval) != 0) {
+	close(fd);
+	close(server);
+	prmsg(1, "PTSOpenClient: cannot set the owner of %s\n",
+	      slave);
+	return(-1);
+    }
+    if (chmod(slave, 0666) < 0) {
+	close(fd);
+	close(server);
+	prmsg(1,"PTSOpenClient: Cannot chmod %s\n", slave);
+	return(-1);
+    }
+
+    /*
+     * write slave name to server
+     */
+
+    namelen = strlen(slave);
+    buf[0] = namelen;
+    (void) sprintf(&buf[1], slave);
+    (void) write(server, buf, namelen+1);
+    (void) close(server);
+
+    /*
+     * wait for server to respond
+     */
+
+    savef = signal(SIGALRM, _dummy);
+    alarm_time = alarm (30); /* CONNECT_TIMEOUT */
+
+    ret = read(fd, buf, 1);
+
+    (void) alarm(alarm_time);
+    (void) signal(SIGALRM, savef);
+
+    if (ret != 1) {
+	prmsg(1,
+	"PTSOpenClient: failed to get acknoledgement from server\n");
+	(void) close(fd);
+	fd = -1;
+    }
+
+    /*
+     * Everything looks good: fill in the XtransConnInfo structure.
+     */
+
+    if (TRANS(FillAddrInfo) (ciptr, slave, server_path) == 0)
+    {
+	prmsg(1,"PTSOpenClient: failed to fill in addr info\n");
+	close(fd);
+	return -1;
+    }
+
+    return(fd);
+
+#endif /* !PTSNODENAME */
+}
+
+#endif /* TRANS_CLIENT */
+
+
+#ifdef TRANS_SERVER
+
+static int
+TRANS(PTSOpenServer)(XtransConnInfo ciptr, const char *port)
+
+{
+#ifdef PTSNODENAME
+    int fd, server;
+    char server_path[64], *slave;
+    int mode;
+#endif
+
+    prmsg(2,"PTSOpenServer(%s)\n", port);
+
+#if !defined(PTSNODENAME)
+    prmsg(1,"PTSOpenServer: Protocol is not supported by a pts connection\n");
+    return -1;
+#else
+    if (port && *port ) {
+	if( *port == '/' ) { /* A full pathname */
+		(void) sprintf(server_path, "%s", port);
+	    } else {
+		(void) sprintf(server_path, "%s%s", PTSNODENAME, port);
+	    }
+    } else {
+	(void) sprintf(server_path, "%s%d", PTSNODENAME, getpid());
+    }
+
+#ifdef HAS_STICKY_DIR_BIT
+    mode = 01777;
+#else
+    mode = 0777;
+#endif
+    if (trans_mkdir(X_STREAMS_DIR, mode) == -1) {
+	prmsg (1, "PTSOpenServer: mkdir(%s) failed, errno = %d\n",
+	       X_STREAMS_DIR, errno);
+	return(-1);
+    }
+
+#if 0
+    if( (fd=open(server_path, O_RDWR)) >= 0 ) {
+	/*
+	 * This doesn't prevent the server from starting up, and doesn't
+	 * prevent clients from trying to connect to the in-use PTS (which
+	 * is often in use by something other than another server).
+	 */
+	prmsg(1, "PTSOpenServer: A server is already running on port %s\n", port);
+	prmsg(1, "PTSOpenServer: Remove %s if this is incorrect.\n", server_path);
+	close(fd);
+	return(-1);
+    }
+#else
+    /* Just remove the old path (which is what happens with UNIXCONN) */
+#endif
+
+    unlink(server_path);
+
+    if( (fd=open(DEV_PTMX, O_RDWR)) < 0) {
+	prmsg(1, "PTSOpenServer: Unable to open %s\n", DEV_PTMX);
+	return(-1);
+    }
+
+    grantpt(fd);
+    unlockpt(fd);
+
+    if( (slave=ptsname(fd)) == NULL) {
+	prmsg(1, "PTSOpenServer: Unable to get slave device name\n");
+	close(fd);
+	return(-1);
+    }
+
+    if( link(slave,server_path) < 0 ) {
+	prmsg(1, "PTSOpenServer: Unable to link %s to %s\n", slave, server_path);
+	close(fd);
+	return(-1);
+    }
+
+    if( chmod(server_path, 0666) < 0 ) {
+	prmsg(1, "PTSOpenServer: Unable to chmod %s to 0666\n", server_path);
+	close(fd);
+	return(-1);
+    }
+
+    if( (server=open(server_path, O_RDWR)) < 0 ) {
+	prmsg(1, "PTSOpenServer: Unable to open server device %s\n", server_path);
+	close(fd);
+	return(-1);
+    }
+
+    close(server);
+
+    /*
+     * Everything looks good: fill in the XtransConnInfo structure.
+     */
+
+    if (TRANS(FillAddrInfo) (ciptr, server_path, server_path) == 0)
+    {
+	prmsg(1,"PTSOpenServer: failed to fill in addr info\n");
+	close(fd);
+	return -1;
+    }
+
+    return fd;
+
+#endif /* !PTSNODENAME */
+}
+
+static int
+TRANS(PTSAccept)(XtransConnInfo ciptr, XtransConnInfo newciptr, int *status)
+
+{
+    int			newfd;
+    int			in;
+    unsigned char	length;
+    char		buf[256];
+    struct sockaddr_un	*sunaddr;
+
+    prmsg(2,"PTSAccept(%x->%d)\n",ciptr,ciptr->fd);
+
+    if( (in=read(ciptr->fd,&length,1)) <= 0 ){
+	if( !in ) {
+		prmsg(2,
+		"PTSAccept: Incoming connection closed\n");
+		}
+	else {
+		prmsg(1,
+	"PTSAccept: Error reading incoming connection. errno=%d \n",
+								errno);
+		}
+	*status = TRANS_ACCEPT_MISC_ERROR;
+	return -1;
+    }
+
+    if( (in=read(ciptr->fd,buf,length)) <= 0 ){
+	if( !in ) {
+		prmsg(2,
+		"PTSAccept: Incoming connection closed\n");
+		}
+	else {
+		prmsg(1,
+"PTSAccept: Error reading device name for new connection. errno=%d \n",
+								errno);
+		}
+	*status = TRANS_ACCEPT_MISC_ERROR;
+	return -1;
+    }
+
+    buf[length] = '\0';
+
+    if( (newfd=open(buf,O_RDWR)) < 0 ) {
+	prmsg(1, "PTSAccept: Failed to open %s\n",buf);
+	*status = TRANS_ACCEPT_MISC_ERROR;
+	return -1;
+    }
+
+    write(newfd,"1",1);
+
+    /*
+     * Everything looks good: fill in the XtransConnInfo structure.
+     */
+
+    newciptr->addrlen=ciptr->addrlen;
+    if( (newciptr->addr = malloc(newciptr->addrlen)) == NULL ) {
+	prmsg(1,"PTSAccept: failed to allocate memory for peer addr\n");
+	close(newfd);
+	*status = TRANS_ACCEPT_BAD_MALLOC;
+	return -1;
+    }
+
+    memcpy(newciptr->addr,ciptr->addr,newciptr->addrlen);
+
+    newciptr->peeraddrlen=sizeof(struct sockaddr_un);
+    if( (sunaddr = malloc(newciptr->peeraddrlen)) == NULL ) {
+	prmsg(1,"PTSAccept: failed to allocate memory for peer addr\n");
+	free(newciptr->addr);
+	close(newfd);
+	*status = TRANS_ACCEPT_BAD_MALLOC;
+	return -1;
+    }
+
+    sunaddr->sun_family=AF_UNIX;
+    strcpy(sunaddr->sun_path,buf);
+#if defined(BSD44SOCKETS)
+    sunaddr->sun_len=strlen(sunaddr->sun_path);
+#endif
+
+    newciptr->peeraddr=(char *)sunaddr;
+
+    *status = 0;
+
+    return newfd;
+}
+
+#endif /* TRANS_SERVER */
+#endif /* LOCAL_TRANS_PTS */
+
+
+#ifdef LOCAL_TRANS_NAMED
+
+/* NAMED */
+
+#ifdef TRANS_CLIENT
+
+static int
+TRANS(NAMEDOpenClient)(XtransConnInfo ciptr, const char *port)
+
+{
+#ifdef NAMEDNODENAME
+    int			fd;
+    char		server_path[64];
+    struct stat		filestat;
+# ifndef __sun
+    extern int		isastream(int);
+# endif
+#endif
+
+    prmsg(2,"NAMEDOpenClient(%s)\n", port);
+
+#if !defined(NAMEDNODENAME)
+    prmsg(1,"NAMEDOpenClient: Protocol is not supported by a NAMED connection\n");
+    return -1;
+#else
+    if ( port && *port ) {
+	if( *port == '/' ) { /* A full pathname */
+		(void) snprintf(server_path, sizeof(server_path), "%s", port);
+	    } else {
+		(void) snprintf(server_path, sizeof(server_path), "%s%s", NAMEDNODENAME, port);
+	    }
+    } else {
+	(void) snprintf(server_path, sizeof(server_path), "%s%ld", NAMEDNODENAME, (long)getpid());
+    }
+
+    if ((fd = open(server_path, O_RDWR)) < 0) {
+	prmsg(1,"NAMEDOpenClient: Cannot open %s for NAMED connection\n", server_path);
+	return -1;
+    }
+
+    if (fstat(fd, &filestat) < 0 ) {
+	prmsg(1,"NAMEDOpenClient: Cannot stat %s for NAMED connection\n", server_path);
+	(void) close(fd);
+	return -1;
+    }
+
+    if ((filestat.st_mode & S_IFMT) != S_IFIFO) {
+	prmsg(1,"NAMEDOpenClient: Device %s is not a FIFO\n", server_path);
+	/* Is this really a failure? */
+	(void) close(fd);
+	return -1;
+    }
+
+
+    if (isastream(fd) <= 0) {
+	prmsg(1,"NAMEDOpenClient: %s is not a streams device\n", server_path);
+	(void) close(fd);
+	return -1;
+    }
+
+    /*
+     * Everything looks good: fill in the XtransConnInfo structure.
+     */
+
+    if (TRANS(FillAddrInfo) (ciptr, server_path, server_path) == 0)
+    {
+	prmsg(1,"NAMEDOpenClient: failed to fill in addr info\n");
+	close(fd);
+	return -1;
+    }
+
+    return(fd);
+
+#endif /* !NAMEDNODENAME */
+}
+
+#endif /* TRANS_CLIENT */
+
+
+#ifdef TRANS_SERVER
+
+
+#ifdef NAMEDNODENAME
+static int
+TRANS(NAMEDOpenPipe)(const char *server_path)
+{
+    int			fd, pipefd[2];
+    struct stat		sbuf;
+    int			mode;
+
+    prmsg(2,"NAMEDOpenPipe(%s)\n", server_path);
+
+#ifdef HAS_STICKY_DIR_BIT
+    mode = 01777;
+#else
+    mode = 0777;
+#endif
+    if (trans_mkdir(X_STREAMS_DIR, mode) == -1) {
+	prmsg (1, "NAMEDOpenPipe: mkdir(%s) failed, errno = %d\n",
+	       X_STREAMS_DIR, errno);
+	return(-1);
+    }
+
+    if(stat(server_path, &sbuf) != 0) {
+	if (errno == ENOENT) {
+	    if ((fd = creat(server_path, (mode_t)0666)) == -1) {
+		prmsg(1, "NAMEDOpenPipe: Can't open %s\n", server_path);
+		return(-1);
+	    }
+	    close(fd);
+	    if (chmod(server_path, (mode_t)0666) < 0) {
+		prmsg(1, "NAMEDOpenPipe: Can't open %s\n", server_path);
+		return(-1);
+	    }
+	} else {
+	    prmsg(1, "NAMEDOpenPipe: stat on %s failed\n", server_path);
+	    return(-1);
+	}
+    }
+
+    if( pipe(pipefd) != 0) {
+	prmsg(1, "NAMEDOpenPipe: pipe() failed, errno=%d\n",errno);
+	return(-1);
+    }
+
+    if( ioctl(pipefd[0], I_PUSH, "connld") != 0) {
+	prmsg(1, "NAMEDOpenPipe: ioctl(I_PUSH,\"connld\") failed, errno=%d\n",errno);
+	close(pipefd[0]);
+	close(pipefd[1]);
+	return(-1);
+    }
+
+    if( fattach(pipefd[0], server_path) != 0) {
+	prmsg(1, "NAMEDOpenPipe: fattach(%s) failed, errno=%d\n", server_path,errno);
+	close(pipefd[0]);
+	close(pipefd[1]);
+	return(-1);
+    }
+
+    return(pipefd[1]);
+}
+#endif
+
+static int
+TRANS(NAMEDOpenServer)(XtransConnInfo ciptr, const char *port)
+{
+#ifdef NAMEDNODENAME
+    int			fd;
+    char		server_path[64];
+#endif
+
+    prmsg(2,"NAMEDOpenServer(%s)\n", port);
+
+#if !defined(NAMEDNODENAME)
+    prmsg(1,"NAMEDOpenServer: Protocol is not supported by a NAMED connection\n");
+    return -1;
+#else
+    if ( port && *port ) {
+	if( *port == '/' ) { /* A full pathname */
+	    (void) snprintf(server_path, sizeof(server_path), "%s", port);
+	} else {
+	    (void) snprintf(server_path, sizeof(server_path), "%s%s",
+			    NAMEDNODENAME, port);
+	}
+    } else {
+	(void) snprintf(server_path, sizeof(server_path), "%s%ld",
+		       NAMEDNODENAME, (long)getpid());
+    }
+
+    fd = TRANS(NAMEDOpenPipe)(server_path);
+    if (fd < 0) {
+	return -1;
+    }
+
+    /*
+     * Everything looks good: fill in the XtransConnInfo structure.
+     */
+
+    if (TRANS(FillAddrInfo) (ciptr, server_path, server_path) == 0)
+    {
+	prmsg(1,"NAMEDOpenServer: failed to fill in addr info\n");
+	TRANS(LocalClose)(ciptr);
+	return -1;
+    }
+
+    return fd;
+
+#endif /* !NAMEDNODENAME */
+}
+
+static int
+TRANS(NAMEDResetListener) (XtransConnInfo ciptr)
+
+{
+  struct sockaddr_un      *sockname=(struct sockaddr_un *) ciptr->addr;
+  struct stat     statb;
+
+  prmsg(2,"NAMEDResetListener(%p, %d)\n", ciptr, ciptr->fd);
+
+  if (ciptr->fd != -1) {
+    /*
+     * see if the pipe has disappeared
+     */
+
+    if (stat (sockname->sun_path, &statb) == -1 ||
+	(statb.st_mode & S_IFMT) != S_IFIFO) {
+      prmsg(3, "Pipe %s trashed, recreating\n", sockname->sun_path);
+      TRANS(LocalClose)(ciptr);
+      ciptr->fd = TRANS(NAMEDOpenPipe)(sockname->sun_path);
+      if (ciptr->fd >= 0)
+	  return TRANS_RESET_NEW_FD;
+      else
+	  return TRANS_CREATE_LISTENER_FAILED;
+    }
+  }
+  return TRANS_RESET_NOOP;
+}
+
+static int
+TRANS(NAMEDAccept)(XtransConnInfo ciptr, XtransConnInfo newciptr, int *status)
+
+{
+    struct strrecvfd str;
+
+    prmsg(2,"NAMEDAccept(%p->%d)\n", ciptr, ciptr->fd);
+
+    if( ioctl(ciptr->fd, I_RECVFD, &str ) < 0 ) {
+	prmsg(1, "NAMEDAccept: ioctl(I_RECVFD) failed, errno=%d\n", errno);
+	*status = TRANS_ACCEPT_MISC_ERROR;
+	return(-1);
+    }
+
+    /*
+     * Everything looks good: fill in the XtransConnInfo structure.
+     */
+    newciptr->family=ciptr->family;
+    newciptr->addrlen=ciptr->addrlen;
+    if( (newciptr->addr = malloc(newciptr->addrlen)) == NULL ) {
+	prmsg(1,
+	      "NAMEDAccept: failed to allocate memory for pipe addr\n");
+	close(str.fd);
+	*status = TRANS_ACCEPT_BAD_MALLOC;
+	return -1;
+    }
+
+    memcpy(newciptr->addr,ciptr->addr,newciptr->addrlen);
+
+    newciptr->peeraddrlen=newciptr->addrlen;
+    if( (newciptr->peeraddr = malloc(newciptr->peeraddrlen)) == NULL ) {
+	prmsg(1,
+	"NAMEDAccept: failed to allocate memory for peer addr\n");
+	free(newciptr->addr);
+	close(str.fd);
+	*status = TRANS_ACCEPT_BAD_MALLOC;
+	return -1;
+    }
+
+    memcpy(newciptr->peeraddr,newciptr->addr,newciptr->peeraddrlen);
+
+    *status = 0;
+
+    return str.fd;
+}
+
+#endif /* TRANS_SERVER */
+
+#endif /* LOCAL_TRANS_NAMED */
+
+
+
+#if defined(LOCAL_TRANS_SCO)
+
+/*
+ * connect_spipe is used by the SCO connection type.
+ */
+static int
+connect_spipe(int fd1, int fd2)
+{
+    long temp;
+    struct strfdinsert sbuf;
+
+    sbuf.databuf.maxlen = -1;
+    sbuf.databuf.len = -1;
+    sbuf.databuf.buf = NULL;
+    sbuf.ctlbuf.maxlen = sizeof(long);
+    sbuf.ctlbuf.len = sizeof(long);
+    sbuf.ctlbuf.buf = (caddr_t)&temp;
+    sbuf.offset = 0;
+    sbuf.fildes = fd2;
+    sbuf.flags = 0;
+
+    if( ioctl(fd1, I_FDINSERT, &sbuf) < 0 )
+	return(-1);
+
+    return(0);
+}
+
+/*
+ * named_spipe is used by the SCO connection type.
+ */
+
+static int
+named_spipe(int fd, char *path)
+
+{
+    int oldUmask, ret;
+    struct stat sbuf;
+
+    oldUmask = umask(0);
+
+    (void) fstat(fd, &sbuf);
+    ret = mknod(path, 0020666, sbuf.st_rdev);
+
+    umask(oldUmask);
+
+    if (ret < 0) {
+	ret = -1;
+    } else {
+	ret = fd;
+    }
+
+    return(ret);
+}
+
+#endif /* defined(LOCAL_TRANS_SCO) */
+
+
+
+
+#ifdef LOCAL_TRANS_SCO
+/* SCO */
+
+/*
+ * 2002-11-09 (jkj@sco.com)
+ *
+ * This code has been modified to match what is in the actual SCO X server.
+ * This greatly helps inter-operability between X11R6 and X11R5 (the native
+ * SCO server). Mainly, it relies on streams nodes existing in /dev, not
+ * creating them or unlinking them, which breaks the native X server.
+ *
+ * However, this is only for the X protocol. For all other protocols, we
+ * do in fact create the nodes, as only X11R6 will use them, and this makes
+ * it possible to have both types of clients running, otherwise we get all
+ * kinds of nasty errors on startup for anything that doesnt use the X
+ * protocol (like SM, when KDE starts up).
+ */
+
+#ifdef TRANS_CLIENT
+
+static int
+TRANS(SCOOpenClient)(XtransConnInfo ciptr, const char *port)
+{
+#ifdef SCORNODENAME
+    int			fd, server, fl, ret;
+    char		server_path[64];
+    struct strbuf	ctlbuf;
+    unsigned long	alarm_time;
+    void		(*savef)();
+    long		temp;
+    extern int	getmsg(), putmsg();
+#endif
+
+    prmsg(2,"SCOOpenClient(%s)\n", port);
+    if (!port || !port[0])
+	port = "0";
+
+#if !defined(SCORNODENAME)
+    prmsg(2,"SCOOpenClient: Protocol is not supported by a SCO connection\n");
+    return -1;
+#else
+    (void) sprintf(server_path, SCORNODENAME, port);
+
+    if ((server = open(server_path, O_RDWR)) < 0) {
+	prmsg(1,"SCOOpenClient: failed to open %s\n", server_path);
+	return -1;
+    }
+
+    if ((fd = open(DEV_SPX, O_RDWR)) < 0) {
+	prmsg(1,"SCOOpenClient: failed to open %s\n", DEV_SPX);
+	close(server);
+	return -1;
+    }
+
+    (void) write(server, &server, 1);
+    ctlbuf.len = 0;
+    ctlbuf.maxlen = sizeof(long);
+    ctlbuf.buf = (caddr_t)&temp;
+    fl = 0;
+
+    savef = signal(SIGALRM, _dummy);
+    alarm_time = alarm(10);
+
+    ret = getmsg(server, &ctlbuf, 0, &fl);
+
+    (void) alarm(alarm_time);
+    (void) signal(SIGALRM, savef);
+
+    if (ret < 0) {
+	prmsg(1,"SCOOpenClient: error from getmsg\n");
+	close(fd);
+	close(server);
+	return -1;
+    }
+
+    /* The msg we got via getmsg is the result of an
+     * I_FDINSERT, so if we do a putmsg with whatever
+     * we recieved, we're doing another I_FDINSERT ...
+     */
+    (void) putmsg(fd, &ctlbuf, 0, 0);
+    (void) fcntl(fd,F_SETFL,fcntl(fd,F_GETFL,0)|O_NDELAY);
+
+    (void) close(server);
+
+    /*
+     * Everything looks good: fill in the XtransConnInfo structure.
+     */
+
+#if defined(X11_t) && defined(__SCO__)
+    ciptr->flags |= TRANS_NOUNLINK;
+#endif
+    if (TRANS(FillAddrInfo) (ciptr, server_path, server_path) == 0)
+    {
+	prmsg(1,"SCOOpenClient: failed to fill addr info\n");
+	close(fd);
+	return -1;
+    }
+
+    return(fd);
+
+#endif  /* !SCORNODENAME */
+}
+
+#endif /* TRANS_CLIENT */
+
+
+#ifdef TRANS_SERVER
+
+static int
+TRANS(SCOOpenServer)(XtransConnInfo ciptr, const char *port)
+{
+#ifdef SCORNODENAME
+    char		serverR_path[64];
+    char		serverS_path[64];
+    struct flock	mylock;
+    int			fdr = -1;
+    int			fds = -1;
+#endif
+
+    prmsg(2,"SCOOpenServer(%s)\n", port);
+    if (!port || !port[0])
+	port = "0";
+
+#if !defined(SCORNODENAME)
+    prmsg(1,"SCOOpenServer: Protocol is not supported by a SCO connection\n");
+    return -1;
+#else
+    (void) sprintf(serverR_path, SCORNODENAME, port);
+    (void) sprintf(serverS_path, SCOSNODENAME, port);
+
+#if !defined(X11_t) || !defined(__SCO__)
+    unlink(serverR_path);
+    unlink(serverS_path);
+
+    if ((fds = open(DEV_SPX, O_RDWR)) < 0 ||
+	(fdr = open(DEV_SPX, O_RDWR)) < 0 ) {
+	prmsg(1,"SCOOpenServer: failed to open %s\n", DEV_SPX);
+	if (fds >= 0)
+		close(fds);
+	if (fdr >= 0)
+		close(fdr);
+	return -1;
+    }
+
+    if (named_spipe (fds, serverS_path) == -1) {
+	prmsg(1,"SCOOpenServer: failed to create %s\n", serverS_path);
+	close (fdr);
+	close (fds);
+	return -1;
+    }
+
+    if (named_spipe (fdr, serverR_path) == -1) {
+	prmsg(1,"SCOOpenServer: failed to create %s\n", serverR_path);
+	close (fdr);
+	close (fds);
+	return -1;
+    }
+#else /* X11_t */
+
+    fds = open (serverS_path, O_RDWR | O_NDELAY);
+    if (fds < 0) {
+	prmsg(1,"SCOOpenServer: failed to open %s\n", serverS_path);
+	return -1;
+    }
+
+    /*
+     * Lock the connection device for the duration of the server.
+     * This resolves multiple server starts especially on SMP machines.
+     */
+    mylock.l_type	= F_WRLCK;
+    mylock.l_whence	= 0;
+    mylock.l_start	= 0;
+    mylock.l_len	= 0;
+    if (fcntl (fds, F_SETLK, &mylock) < 0) {
+	prmsg(1,"SCOOpenServer: failed to lock %s\n", serverS_path);
+	close (fds);
+	return -1;
+    }
+
+    fdr = open (serverR_path, O_RDWR | O_NDELAY);
+    if (fdr < 0) {
+	prmsg(1,"SCOOpenServer: failed to open %s\n", serverR_path);
+	close (fds);
+	return -1;
+    }
+#endif /* X11_t */
+
+    if (connect_spipe(fds, fdr)) {
+	prmsg(1,"SCOOpenServer: ioctl(I_FDINSERT) failed on %s\n",
+	      serverS_path);
+	close (fdr);
+	close (fds);
+	return -1;
+    }
+
+    /*
+     * Everything looks good: fill in the XtransConnInfo structure.
+     */
+
+#if defined(X11_t) && defined(__SCO__)
+    ciptr->flags |= TRANS_NOUNLINK;
+#endif
+    if (TRANS(FillAddrInfo) (ciptr, serverS_path, serverR_path) == 0) {
+	prmsg(1,"SCOOpenServer: failed to fill in addr info\n");
+	close(fds);
+	close(fdr);
+	return -1;
+    }
+
+    return(fds);
+
+#endif /* !SCORNODENAME */
+}
+
+static int
+TRANS(SCOAccept)(XtransConnInfo ciptr, XtransConnInfo newciptr, int *status)
+{
+    char		c;
+    int			fd;
+
+    prmsg(2,"SCOAccept(%d)\n", ciptr->fd);
+
+    if (read(ciptr->fd, &c, 1) < 0) {
+	prmsg(1,"SCOAccept: can't read from client\n");
+	*status = TRANS_ACCEPT_MISC_ERROR;
+	return(-1);
+    }
+
+    if( (fd = open(DEV_SPX, O_RDWR)) < 0 ) {
+	prmsg(1,"SCOAccept: can't open \"%s\"\n",DEV_SPX);
+	*status = TRANS_ACCEPT_MISC_ERROR;
+	return(-1);
+    }
+
+    if (connect_spipe (ciptr->fd, fd) < 0) {
+	prmsg(1,"SCOAccept: ioctl(I_FDINSERT) failed\n");
+	close (fd);
+	*status = TRANS_ACCEPT_MISC_ERROR;
+	return -1;
+    }
+
+    /*
+     * Everything looks good: fill in the XtransConnInfo structure.
+     */
+
+    newciptr->addrlen=ciptr->addrlen;
+    if( (newciptr->addr = malloc(newciptr->addrlen)) == NULL ) {
+	prmsg(1,
+	      "SCOAccept: failed to allocate memory for peer addr\n");
+	close(fd);
+	*status = TRANS_ACCEPT_BAD_MALLOC;
+	return -1;
+    }
+
+    memcpy(newciptr->addr,ciptr->addr,newciptr->addrlen);
+#if defined(__SCO__)
+    newciptr->flags |= TRANS_NOUNLINK;
+#endif
+
+    newciptr->peeraddrlen=newciptr->addrlen;
+    if( (newciptr->peeraddr = malloc(newciptr->peeraddrlen)) == NULL ) {
+	prmsg(1,
+	      "SCOAccept: failed to allocate memory for peer addr\n");
+	free(newciptr->addr);
+	close(fd);
+	*status = TRANS_ACCEPT_BAD_MALLOC;
+	return -1;
+    }
+
+    memcpy(newciptr->peeraddr,newciptr->addr,newciptr->peeraddrlen);
+
+    *status = 0;
+
+    return(fd);
+}
+
+#endif /* TRANS_SERVER */
+#endif /* LOCAL_TRANS_SCO */
+
+
+
+#ifdef TRANS_REOPEN
+#ifdef LOCAL_TRANS_PTS
+
+static int
+TRANS(PTSReopenServer)(XtransConnInfo ciptr, int fd, const char *port)
+
+{
+#ifdef PTSNODENAME
+    char server_path[64];
+#endif
+
+    prmsg(2,"PTSReopenServer(%d,%s)\n", fd, port);
+
+#if !defined(PTSNODENAME)
+    prmsg(1,"PTSReopenServer: Protocol is not supported by a pts connection\n");
+    return 0;
+#else
+    if (port && *port ) {
+	if( *port == '/' ) { /* A full pathname */
+	    snprintf(server_path, sizeof(server_path), "%s", port);
+	    } else {
+	    snprintf(server_path, sizeof(server_path), "%s%s",
+		     PTSNODENAME, port);
+	    }
+    } else {
+	snprintf(server_path, sizeof(server_path), "%s%ld",
+		PTSNODENAME, (long)getpid());
+    }
+
+    if (TRANS(FillAddrInfo) (ciptr, server_path, server_path) == 0)
+    {
+	prmsg(1,"PTSReopenServer: failed to fill in addr info\n");
+	return 0;
+    }
+
+    return 1;
+
+#endif /* !PTSNODENAME */
+}
+
+#endif /* LOCAL_TRANS_PTS */
+
+#ifdef LOCAL_TRANS_NAMED
+
+static int
+TRANS(NAMEDReopenServer)(XtransConnInfo ciptr, int fd _X_UNUSED, const char *port)
+
+{
+#ifdef NAMEDNODENAME
+    char server_path[64];
+#endif
+
+    prmsg(2,"NAMEDReopenServer(%s)\n", port);
+
+#if !defined(NAMEDNODENAME)
+    prmsg(1,"NAMEDReopenServer: Protocol is not supported by a NAMED connection\n");
+    return 0;
+#else
+    if ( port && *port ) {
+	if( *port == '/' ) { /* A full pathname */
+	    snprintf(server_path, sizeof(server_path),"%s", port);
+	} else {
+	    snprintf(server_path, sizeof(server_path), "%s%s",
+		     NAMEDNODENAME, port);
+	}
+    } else {
+	snprintf(server_path, sizeof(server_path), "%s%ld",
+		NAMEDNODENAME, (long)getpid());
+    }
+
+    if (TRANS(FillAddrInfo) (ciptr, server_path, server_path) == 0)
+    {
+	prmsg(1,"NAMEDReopenServer: failed to fill in addr info\n");
+	return 0;
+    }
+
+    return 1;
+
+#endif /* !NAMEDNODENAME */
+}
+
+#endif /* LOCAL_TRANS_NAMED */
+
+
+#ifdef LOCAL_TRANS_SCO
+static int
+TRANS(SCOReopenServer)(XtransConnInfo ciptr, int fd, const char *port)
+
+{
+#ifdef SCORNODENAME
+    char serverR_path[64], serverS_path[64];
+#endif
+
+    prmsg(2,"SCOReopenServer(%s)\n", port);
+    if (!port || !port[0])
+      port = "0";
+
+#if !defined(SCORNODENAME)
+    prmsg(2,"SCOReopenServer: Protocol is not supported by a SCO connection\n");
+    return 0;
+#else
+    (void) sprintf(serverR_path, SCORNODENAME, port);
+    (void) sprintf(serverS_path, SCOSNODENAME, port);
+
+#if defined(X11_t) && defined(__SCO__)
+    ciptr->flags |= TRANS_NOUNLINK;
+#endif
+    if (TRANS(FillAddrInfo) (ciptr, serverS_path, serverR_path) == 0)
+    {
+	prmsg(1, "SCOReopenServer: failed to fill in addr info\n");
+	return 0;
+    }
+
+    return 1;
+
+#endif /* SCORNODENAME */
+}
+
+#endif /* LOCAL_TRANS_SCO */
+
+#endif /* TRANS_REOPEN */
+
+
+
+/*
+ * This table contains all of the entry points for the different local
+ * connection mechanisms.
+ */
+
+typedef struct _LOCALtrans2dev {
+    const char	*transname;
+
+#ifdef TRANS_CLIENT
+
+    int	(*devcotsopenclient)(
+	XtransConnInfo, const char * /*port*/
+);
+
+#endif /* TRANS_CLIENT */
+
+#ifdef TRANS_SERVER
+
+    int	(*devcotsopenserver)(
+	XtransConnInfo, const char * /*port*/
+);
+
+#endif /* TRANS_SERVER */
+
+#ifdef TRANS_CLIENT
+
+    int	(*devcltsopenclient)(
+	XtransConnInfo, const char * /*port*/
+);
+
+#endif /* TRANS_CLIENT */
+
+#ifdef TRANS_SERVER
+
+    int	(*devcltsopenserver)(
+	XtransConnInfo, const char * /*port*/
+);
+
+#endif /* TRANS_SERVER */
+
+#ifdef TRANS_REOPEN
+
+    int	(*devcotsreopenserver)(
+	XtransConnInfo,
+	int, 	/* fd */
+	const char * 	/* port */
+);
+
+    int	(*devcltsreopenserver)(
+	XtransConnInfo,
+	int, 	/* fd */
+	const char *	/* port */
+);
+
+#endif /* TRANS_REOPEN */
+
+#ifdef TRANS_SERVER
+
+    int (*devreset)(
+	XtransConnInfo /* ciptr */
+);
+
+    int	(*devaccept)(
+	XtransConnInfo, XtransConnInfo, int *
+);
+
+#endif /* TRANS_SERVER */
+
+} LOCALtrans2dev;
+
+static LOCALtrans2dev LOCALtrans2devtab[] = {
+#ifdef LOCAL_TRANS_PTS
+{"",
+#ifdef TRANS_CLIENT
+     TRANS(PTSOpenClient),
+#endif /* TRANS_CLIENT */
+#ifdef TRANS_SERVER
+     TRANS(PTSOpenServer),
+#endif /* TRANS_SERVER */
+#ifdef TRANS_CLIENT
+     TRANS(OpenFail),
+#endif /* TRANS_CLIENT */
+#ifdef TRANS_SERVER
+     TRANS(OpenFail),
+#endif /* TRANS_SERVER */
+#ifdef TRANS_REOPEN
+     TRANS(PTSReopenServer),
+     TRANS(ReopenFail),
+#endif
+#ifdef TRANS_SERVER
+     NULL,		/* ResetListener */
+     TRANS(PTSAccept)
+#endif /* TRANS_SERVER */
+},
+
+{"local",
+#ifdef TRANS_CLIENT
+     TRANS(PTSOpenClient),
+#endif /* TRANS_CLIENT */
+#ifdef TRANS_SERVER
+     TRANS(PTSOpenServer),
+#endif /* TRANS_SERVER */
+#ifdef TRANS_CLIENT
+     TRANS(OpenFail),
+#endif /* TRANS_CLIENT */
+#ifdef TRANS_SERVER
+     TRANS(OpenFail),
+#endif /* TRANS_SERVER */
+#ifdef TRANS_REOPEN
+     TRANS(PTSReopenServer),
+     TRANS(ReopenFail),
+#endif
+#ifdef TRANS_SERVER
+     NULL,		/* ResetListener */
+     TRANS(PTSAccept)
+#endif /* TRANS_SERVER */
+},
+
+{"pts",
+#ifdef TRANS_CLIENT
+     TRANS(PTSOpenClient),
+#endif /* TRANS_CLIENT */
+#ifdef TRANS_SERVER
+     TRANS(PTSOpenServer),
+#endif /* TRANS_SERVER */
+#ifdef TRANS_CLIENT
+     TRANS(OpenFail),
+#endif /* TRANS_CLIENT */
+#ifdef TRANS_SERVER
+     TRANS(OpenFail),
+#endif /* TRANS_SERVER */
+#ifdef TRANS_REOPEN
+     TRANS(PTSReopenServer),
+     TRANS(ReopenFail),
+#endif
+#ifdef TRANS_SERVER
+     NULL,		/* ResetListener */
+     TRANS(PTSAccept)
+#endif /* TRANS_SERVER */
+},
+#else /* !LOCAL_TRANS_PTS */
+{"",
+#ifdef TRANS_CLIENT
+     TRANS(NAMEDOpenClient),
+#endif /* TRANS_CLIENT */
+#ifdef TRANS_SERVER
+     TRANS(NAMEDOpenServer),
+#endif /* TRANS_SERVER */
+#ifdef TRANS_CLIENT
+     TRANS(OpenFail),
+#endif /* TRANS_CLIENT */
+#ifdef TRANS_SERVER
+     TRANS(OpenFail),
+#endif /* TRANS_SERVER */
+#ifdef TRANS_REOPEN
+     TRANS(NAMEDReopenServer),
+     TRANS(ReopenFail),
+#endif
+#ifdef TRANS_SERVER
+     TRANS(NAMEDResetListener),
+     TRANS(NAMEDAccept)
+#endif /* TRANS_SERVER */
+},
+
+{"local",
+#ifdef TRANS_CLIENT
+     TRANS(NAMEDOpenClient),
+#endif /* TRANS_CLIENT */
+#ifdef TRANS_SERVER
+     TRANS(NAMEDOpenServer),
+#endif /* TRANS_SERVER */
+#ifdef TRANS_CLIENT
+     TRANS(OpenFail),
+#endif /* TRANS_CLIENT */
+#ifdef TRANS_SERVER
+     TRANS(OpenFail),
+#endif /* TRANS_SERVER */
+#ifdef TRANS_REOPEN
+     TRANS(NAMEDReopenServer),
+     TRANS(ReopenFail),
+#endif
+#ifdef TRANS_SERVER
+     TRANS(NAMEDResetListener),
+     TRANS(NAMEDAccept)
+#endif /* TRANS_SERVER */
+},
+#endif /* !LOCAL_TRANS_PTS */
+
+#ifdef LOCAL_TRANS_NAMED
+{"named",
+#ifdef TRANS_CLIENT
+     TRANS(NAMEDOpenClient),
+#endif /* TRANS_CLIENT */
+#ifdef TRANS_SERVER
+     TRANS(NAMEDOpenServer),
+#endif /* TRANS_SERVER */
+#ifdef TRANS_CLIENT
+     TRANS(OpenFail),
+#endif /* TRANS_CLIENT */
+#ifdef TRANS_SERVER
+     TRANS(OpenFail),
+#endif /* TRANS_SERVER */
+#ifdef TRANS_REOPEN
+     TRANS(NAMEDReopenServer),
+     TRANS(ReopenFail),
+#endif
+#ifdef TRANS_SERVER
+     TRANS(NAMEDResetListener),
+     TRANS(NAMEDAccept)
+#endif /* TRANS_SERVER */
+},
+
+#ifdef __sun /* Alias "pipe" to named, since that's what Solaris called it */
+{"pipe",
+#ifdef TRANS_CLIENT
+     TRANS(NAMEDOpenClient),
+#endif /* TRANS_CLIENT */
+#ifdef TRANS_SERVER
+     TRANS(NAMEDOpenServer),
+#endif /* TRANS_SERVER */
+#ifdef TRANS_CLIENT
+     TRANS(OpenFail),
+#endif /* TRANS_CLIENT */
+#ifdef TRANS_SERVER
+     TRANS(OpenFail),
+#endif /* TRANS_SERVER */
+#ifdef TRANS_REOPEN
+     TRANS(NAMEDReopenServer),
+     TRANS(ReopenFail),
+#endif
+#ifdef TRANS_SERVER
+     TRANS(NAMEDResetListener),
+     TRANS(NAMEDAccept)
+#endif /* TRANS_SERVER */
+},
+#endif /* __sun */
+#endif /* LOCAL_TRANS_NAMED */
+
+
+#ifdef LOCAL_TRANS_SCO
+{"sco",
+#ifdef TRANS_CLIENT
+     TRANS(SCOOpenClient),
+#endif /* TRANS_CLIENT */
+#ifdef TRANS_SERVER
+     TRANS(SCOOpenServer),
+#endif /* TRANS_SERVER */
+#ifdef TRANS_CLIENT
+     TRANS(OpenFail),
+#endif /* TRANS_CLIENT */
+#ifdef TRANS_SERVER
+     TRANS(OpenFail),
+#endif /* TRANS_SERVER */
+#ifdef TRANS_REOPEN
+     TRANS(SCOReopenServer),
+     TRANS(ReopenFail),
+#endif
+#ifdef TRANS_SERVER
+     NULL,		/* ResetListener */
+     TRANS(SCOAccept)
+#endif /* TRANS_SERVER */
+},
+#endif /* LOCAL_TRANS_SCO */
+};
+
+#define NUMTRANSPORTS	(sizeof(LOCALtrans2devtab)/sizeof(LOCALtrans2dev))
+
+static const char	*XLOCAL=NULL;
+static	char	*workingXLOCAL=NULL;
+static	char	*freeXLOCAL=NULL;
+
+#if defined(__SCO__)
+#define DEF_XLOCAL "SCO:UNIX:PTS"
+#elif defined(__UNIXWARE__)
+#define DEF_XLOCAL "UNIX:PTS:NAMED:SCO"
+#elif defined(__sun)
+#define DEF_XLOCAL "UNIX:NAMED"
+#else
+#define DEF_XLOCAL "UNIX:PTS:NAMED:SCO"
+#endif
+
+static void
+TRANS(LocalInitTransports)(const char *protocol)
+
+{
+    prmsg(3,"LocalInitTransports(%s)\n", protocol);
+
+    if( strcmp(protocol,"local") && strcmp(protocol,"LOCAL") )
+    {
+	workingXLOCAL = freeXLOCAL = strdup (protocol);
+    }
+    else {
+	XLOCAL=(char *)getenv("XLOCAL");
+	if(XLOCAL==NULL)
+	    XLOCAL=DEF_XLOCAL;
+	workingXLOCAL = freeXLOCAL = strdup (XLOCAL);
+    }
+}
+
+static void
+TRANS(LocalEndTransports)(void)
+
+{
+    prmsg(3,"LocalEndTransports()\n");
+    free(freeXLOCAL);
+}
+
+#define TYPEBUFSIZE	32
+
+#ifdef TRANS_CLIENT
+
+static LOCALtrans2dev *
+TRANS(LocalGetNextTransport)(void)
+
+{
+    int	i,j;
+    char	*typetocheck;
+    char	typebuf[TYPEBUFSIZE];
+    prmsg(3,"LocalGetNextTransport()\n");
+
+    while(1)
+    {
+	if( workingXLOCAL == NULL || *workingXLOCAL == '\0' )
+	    return NULL;
+
+	typetocheck=workingXLOCAL;
+	workingXLOCAL=strchr(workingXLOCAL,':');
+	if(workingXLOCAL && *workingXLOCAL)
+	    *workingXLOCAL++='\0';
+
+	for(i=0;i<NUMTRANSPORTS;i++)
+	{
+	    /*
+	     * This is equivalent to a case insensitive strcmp(),
+	     * but should be more portable.
+	     */
+	    strncpy(typebuf,typetocheck,TYPEBUFSIZE);
+	    for(j=0;j<TYPEBUFSIZE;j++)
+		if (isupper(typebuf[j]))
+		    typebuf[j]=tolower(typebuf[j]);
+
+	    /* Now, see if they match */
+	    if(!strcmp(LOCALtrans2devtab[i].transname,typebuf))
+		return &LOCALtrans2devtab[i];
+	}
+    }
+#if 0
+    /*NOTREACHED*/
+    return NULL;
+#endif
+}
+
+#ifdef NEED_UTSNAME
+#include <sys/utsname.h>
+#endif
+
+/*
+ * Make sure 'host' is really local.
+ */
+
+static int
+HostReallyLocal (const char *host)
+
+{
+    /*
+     * The 'host' passed to this function may have been generated
+     * by either uname() or gethostname().  We try both if possible.
+     */
+
+#ifdef NEED_UTSNAME
+    struct utsname name;
+#endif
+    char buf[256];
+
+#ifdef NEED_UTSNAME
+    if (uname (&name) >= 0 && strcmp (host, name.nodename) == 0)
+	return (1);
+#endif
+
+    buf[0] = '\0';
+    (void) gethostname (buf, 256);
+    buf[255] = '\0';
+
+    if (strcmp (host, buf) == 0)
+	return (1);
+
+    return (0);
+}
+
+
+static XtransConnInfo
+TRANS(LocalOpenClient)(int type, const char *protocol,
+                       const char *host, const char *port)
+
+{
+    LOCALtrans2dev *transptr;
+    XtransConnInfo ciptr;
+    int index;
+
+    prmsg(3,"LocalOpenClient()\n");
+
+    /*
+     * Make sure 'host' is really local.  If not, we return failure.
+     * The reason we make this check is because a process may advertise
+     * a "local" address for which it can accept connections, but if a
+     * process on a remote machine tries to connect to this address,
+     * we know for sure it will fail.
+     */
+
+    if (strcmp (host, "unix") != 0 && !HostReallyLocal (host))
+    {
+	prmsg (1,
+	   "LocalOpenClient: Cannot connect to non-local host %s\n",
+	       host);
+	return NULL;
+    }
+
+
+#if defined(X11_t)
+    /*
+     * X has a well known port, that is transport dependant. It is easier
+     * to handle it here, than try and come up with a transport independent
+     * representation that can be passed in and resolved the usual way.
+     *
+     * The port that is passed here is really a string containing the idisplay
+     * from ConnectDisplay(). Since that is what we want for the local transports,
+     * we don't have to do anything special.
+     */
+#endif /* X11_t */
+
+    if( (ciptr = calloc(1,sizeof(struct _XtransConnInfo))) == NULL )
+    {
+	prmsg(1,"LocalOpenClient: calloc(1,%lu) failed\n",
+	      sizeof(struct _XtransConnInfo));
+	return NULL;
+    }
+
+    ciptr->fd = -1;
+
+    TRANS(LocalInitTransports)(protocol);
+
+    index = 0;
+    for(transptr=TRANS(LocalGetNextTransport)();
+	transptr!=NULL;transptr=TRANS(LocalGetNextTransport)(), index++)
+    {
+	switch( type )
+	{
+	case XTRANS_OPEN_COTS_CLIENT:
+	    ciptr->fd=transptr->devcotsopenclient(ciptr,port);
+	    break;
+	case XTRANS_OPEN_COTS_SERVER:
+	    prmsg(1,
+		  "LocalOpenClient: Should not be opening a server with this function\n");
+	    break;
+	default:
+	    prmsg(1,
+		  "LocalOpenClient: Unknown Open type %d\n",
+		  type);
+	}
+	if( ciptr->fd >= 0 )
+	    break;
+    }
+
+    TRANS(LocalEndTransports)();
+
+    if( ciptr->fd < 0 )
+    {
+	free(ciptr);
+	return NULL;
+    }
+
+    ciptr->priv=(char *)transptr;
+    ciptr->index = index;
+
+    return ciptr;
+}
+
+#endif /* TRANS_CLIENT */
+
+
+#ifdef TRANS_SERVER
+
+static XtransConnInfo
+TRANS(LocalOpenServer)(int type, const char *protocol,
+                       const char *host _X_UNUSED, const char *port)
+
+{
+    int	i;
+    XtransConnInfo ciptr;
+
+    prmsg(2,"LocalOpenServer(%d,%s,%s)\n", type, protocol, port);
+
+#if defined(X11_t)
+    /*
+     * For X11, the port will be in the format xserverN where N is the
+     * display number. All of the local connections just need to know
+     * the display number because they don't do any name resolution on
+     * the port. This just truncates port to the display portion.
+     */
+#endif /* X11_t */
+
+    if( (ciptr = calloc(1,sizeof(struct _XtransConnInfo))) == NULL )
+    {
+	prmsg(1,"LocalOpenServer: calloc(1,%lu) failed\n",
+	      sizeof(struct _XtransConnInfo));
+	return NULL;
+    }
+
+    for(i=1;i<NUMTRANSPORTS;i++)
+    {
+	if( strcmp(protocol,LOCALtrans2devtab[i].transname) != 0 )
+	    continue;
+	switch( type )
+	{
+	case XTRANS_OPEN_COTS_CLIENT:
+	    prmsg(1,
+		  "LocalOpenServer: Should not be opening a client with this function\n");
+	    break;
+	case XTRANS_OPEN_COTS_SERVER:
+	    ciptr->fd=LOCALtrans2devtab[i].devcotsopenserver(ciptr,port);
+	    break;
+	default:
+	    prmsg(1,"LocalOpenServer: Unknown Open type %d\n",
+		  type );
+	}
+	if( ciptr->fd >= 0 ) {
+	    ciptr->priv=(char *)&LOCALtrans2devtab[i];
+	    ciptr->index=i;
+	    ciptr->flags = 1 | (ciptr->flags & TRANS_KEEPFLAGS);
+	    return ciptr;
+	}
+    }
+
+    free(ciptr);
+    return NULL;
+}
+
+#endif /* TRANS_SERVER */
+
+
+#ifdef TRANS_REOPEN
+
+static XtransConnInfo
+TRANS(LocalReopenServer)(int type, int index, int fd, const char *port)
+
+{
+    XtransConnInfo ciptr;
+    int stat = 0;
+
+    prmsg(2,"LocalReopenServer(%d,%d,%d)\n", type, index, fd);
+
+    if( (ciptr = calloc(1,sizeof(struct _XtransConnInfo))) == NULL )
+    {
+	prmsg(1,"LocalReopenServer: calloc(1,%lu) failed\n",
+	      sizeof(struct _XtransConnInfo));
+	return NULL;
+    }
+
+    ciptr->fd = fd;
+
+    switch( type )
+    {
+    case XTRANS_OPEN_COTS_SERVER:
+	stat = LOCALtrans2devtab[index].devcotsreopenserver(ciptr,fd,port);
+	break;
+   default:
+	prmsg(1,"LocalReopenServer: Unknown Open type %d\n",
+	  type );
+    }
+
+    if( stat > 0 ) {
+	ciptr->priv=(char *)&LOCALtrans2devtab[index];
+	ciptr->index=index;
+	ciptr->flags = 1 | (ciptr->flags & TRANS_KEEPFLAGS);
+	return ciptr;
+    }
+
+    free(ciptr);
+    return NULL;
+}
+
+#endif /* TRANS_REOPEN */
+
+
+
+/*
+ * This is the Local implementation of the X Transport service layer
+ */
+
+#ifdef TRANS_CLIENT
+
+static XtransConnInfo
+TRANS(LocalOpenCOTSClient)(Xtransport *thistrans _X_UNUSED, const char *protocol,
+			   const char *host, const char *port)
+
+{
+    prmsg(2,"LocalOpenCOTSClient(%s,%s,%s)\n",protocol,host,port);
+
+    return TRANS(LocalOpenClient)(XTRANS_OPEN_COTS_CLIENT, protocol, host, port);
+}
+
+#endif /* TRANS_CLIENT */
+
+
+#ifdef TRANS_SERVER
+
+static XtransConnInfo
+TRANS(LocalOpenCOTSServer)(Xtransport *thistrans, const char *protocol,
+			   const char *host, const char *port)
+
+{
+    char *typetocheck = NULL;
+    int found = 0;
+    char typebuf[TYPEBUFSIZE];
+
+    prmsg(2,"LocalOpenCOTSServer(%s,%s,%s)\n",protocol,host,port);
+
+    /* Check if this local type is in the XLOCAL list */
+    TRANS(LocalInitTransports)("local");
+    typetocheck = workingXLOCAL;
+    while (typetocheck && !found) {
+	int j;
+
+	workingXLOCAL = strchr(workingXLOCAL, ':');
+	if (workingXLOCAL && *workingXLOCAL)
+	    *workingXLOCAL++ = '\0';
+	strncpy(typebuf, typetocheck, TYPEBUFSIZE);
+	for (j = 0; j < TYPEBUFSIZE; j++)
+	    if (isupper(typebuf[j]))
+		typebuf[j] = tolower(typebuf[j]);
+	if (!strcmp(thistrans->TransName, typebuf))
+	    found = 1;
+	typetocheck = workingXLOCAL;
+    }
+    TRANS(LocalEndTransports)();
+
+    if (!found) {
+	prmsg(3,"LocalOpenCOTSServer: disabling %s\n",thistrans->TransName);
+	thistrans->flags |= TRANS_DISABLED;
+	return NULL;
+    }
+
+    return TRANS(LocalOpenServer)(XTRANS_OPEN_COTS_SERVER, protocol, host, port);
+}
+
+#endif /* TRANS_SERVER */
+
+#ifdef TRANS_REOPEN
+
+static XtransConnInfo
+TRANS(LocalReopenCOTSServer)(Xtransport *thistrans, int fd, const char *port)
+
+{
+    int index;
+
+    prmsg(2,"LocalReopenCOTSServer(%d,%s)\n", fd, port);
+
+    for(index=1;index<NUMTRANSPORTS;index++)
+    {
+	if( strcmp(thistrans->TransName,
+	    LOCALtrans2devtab[index].transname) == 0 )
+	    break;
+    }
+
+    if (index >= NUMTRANSPORTS)
+    {
+	return (NULL);
+    }
+
+    return TRANS(LocalReopenServer)(XTRANS_OPEN_COTS_SERVER,
+	index, fd, port);
+}
+
+#endif /* TRANS_REOPEN */
+
+
+
+static int
+TRANS(LocalSetOption)(XtransConnInfo ciptr, int option, int arg)
+
+{
+    prmsg(2,"LocalSetOption(%d,%d,%d)\n",ciptr->fd,option,arg);
+
+    return -1;
+}
+
+
+#ifdef TRANS_SERVER
+
+static int
+TRANS(LocalCreateListener)(XtransConnInfo ciptr, const char *port,
+                           unsigned int flags _X_UNUSED)
+
+{
+    prmsg(2,"LocalCreateListener(%p->%d,%s)\n",ciptr,ciptr->fd,port);
+
+    return 0;
+}
+
+static int
+TRANS(LocalResetListener)(XtransConnInfo ciptr)
+
+{
+    LOCALtrans2dev	*transptr;
+
+    prmsg(2,"LocalResetListener(%p)\n",ciptr);
+
+    transptr=(LOCALtrans2dev *)ciptr->priv;
+    if (transptr->devreset != NULL) {
+	return transptr->devreset(ciptr);
+    }
+    return TRANS_RESET_NOOP;
+}
+
+
+static XtransConnInfo
+TRANS(LocalAccept)(XtransConnInfo ciptr, int *status)
+
+{
+    XtransConnInfo	newciptr;
+    LOCALtrans2dev	*transptr;
+
+    prmsg(2,"LocalAccept(%p->%d)\n", ciptr, ciptr->fd);
+
+    transptr=(LOCALtrans2dev *)ciptr->priv;
+
+    if( (newciptr = calloc(1,sizeof(struct _XtransConnInfo)))==NULL )
+    {
+	prmsg(1,"LocalAccept: calloc(1,%lu) failed\n",
+	      sizeof(struct _XtransConnInfo));
+	*status = TRANS_ACCEPT_BAD_MALLOC;
+	return NULL;
+    }
+
+    newciptr->fd=transptr->devaccept(ciptr,newciptr,status);
+
+    if( newciptr->fd < 0 )
+    {
+	free(newciptr);
+	return NULL;
+    }
+
+    newciptr->priv=(char *)transptr;
+    newciptr->index = ciptr->index;
+
+    *status = 0;
+
+    return newciptr;
+}
+
+#endif /* TRANS_SERVER */
+
+
+#ifdef TRANS_CLIENT
+
+static int
+TRANS(LocalConnect)(XtransConnInfo ciptr,
+                    const char *host _X_UNUSED, const char *port)
+
+{
+    prmsg(2,"LocalConnect(%p->%d,%s)\n", ciptr, ciptr->fd, port);
+
+    return 0;
+}
+
+#endif /* TRANS_CLIENT */
+
+
+static int
+TRANS(LocalBytesReadable)(XtransConnInfo ciptr, BytesReadable_t *pend )
+
+{
+    prmsg(2,"LocalBytesReadable(%p->%d,%p)\n", ciptr, ciptr->fd, pend);
+
+#if defined(SCO325)
+    return ioctl(ciptr->fd, I_NREAD, (char *)pend);
+#else
+    return ioctl(ciptr->fd, FIONREAD, (char *)pend);
+#endif
+}
+
+static int
+TRANS(LocalRead)(XtransConnInfo ciptr, char *buf, int size)
+
+{
+    prmsg(2,"LocalRead(%d,%p,%d)\n", ciptr->fd, buf, size );
+
+    return read(ciptr->fd,buf,size);
+}
+
+static int
+TRANS(LocalWrite)(XtransConnInfo ciptr, char *buf, int size)
+
+{
+    prmsg(2,"LocalWrite(%d,%p,%d)\n", ciptr->fd, buf, size );
+
+    return write(ciptr->fd,buf,size);
+}
+
+static int
+TRANS(LocalReadv)(XtransConnInfo ciptr, struct iovec *buf, int size)
+
+{
+    prmsg(2,"LocalReadv(%d,%p,%d)\n", ciptr->fd, buf, size );
+
+    return READV(ciptr,buf,size);
+}
+
+static int
+TRANS(LocalWritev)(XtransConnInfo ciptr, struct iovec *buf, int size)
+
+{
+    prmsg(2,"LocalWritev(%d,%p,%d)\n", ciptr->fd, buf, size );
+
+    return WRITEV(ciptr,buf,size);
+}
+
+static int
+TRANS(LocalDisconnect)(XtransConnInfo ciptr)
+
+{
+    prmsg(2,"LocalDisconnect(%p->%d)\n", ciptr, ciptr->fd);
+
+    return 0;
+}
+
+static int
+TRANS(LocalClose)(XtransConnInfo ciptr)
+
+{
+    struct sockaddr_un      *sockname=(struct sockaddr_un *) ciptr->addr;
+    int	ret;
+
+    prmsg(2,"LocalClose(%p->%d)\n", ciptr, ciptr->fd );
+
+    ret=close(ciptr->fd);
+
+    if(ciptr->flags
+       && sockname
+       && sockname->sun_family == AF_UNIX
+       && sockname->sun_path[0] )
+    {
+	if (!(ciptr->flags & TRANS_NOUNLINK))
+	    unlink(sockname->sun_path);
+    }
+
+    return ret;
+}
+
+static int
+TRANS(LocalCloseForCloning)(XtransConnInfo ciptr)
+
+{
+    int ret;
+
+    prmsg(2,"LocalCloseForCloning(%p->%d)\n", ciptr, ciptr->fd );
+
+    /* Don't unlink path */
+
+    ret=close(ciptr->fd);
+
+    return ret;
+}
+
+
+/*
+ * MakeAllCOTSServerListeners() will go through the entire Xtransports[]
+ * array defined in Xtrans.c and try to OpenCOTSServer() for each entry.
+ * We will add duplicate entries to that table so that the OpenCOTSServer()
+ * function will get called once for each type of local transport.
+ *
+ * The TransName is in lowercase, so it will never match during a normal
+ * call to SelectTransport() in Xtrans.c.
+ */
+
+#ifdef TRANS_SERVER
+static const char * local_aliases[] = {
+# ifdef LOCAL_TRANS_PTS
+                                  "pts",
+# endif
+				  "named",
+# ifdef __sun
+				  "pipe", /* compatibility with Solaris Xlib */
+#  endif
+# ifdef LOCAL_TRANS_SCO
+				  "sco",
+# endif
+				  NULL };
+#endif
+
+Xtransport	TRANS(LocalFuncs) = {
+	/* Local Interface */
+	"local",
+	TRANS_ALIAS | TRANS_LOCAL,
+#ifdef TRANS_CLIENT
+	TRANS(LocalOpenCOTSClient),
+#endif /* TRANS_CLIENT */
+#ifdef TRANS_SERVER
+	local_aliases,
+	TRANS(LocalOpenCOTSServer),
+#endif /* TRANS_SERVER */
+#ifdef TRANS_REOPEN
+	TRANS(LocalReopenCOTSServer),
+#endif
+	TRANS(LocalSetOption),
+#ifdef TRANS_SERVER
+	TRANS(LocalCreateListener),
+	TRANS(LocalResetListener),
+	TRANS(LocalAccept),
+#endif /* TRANS_SERVER */
+#ifdef TRANS_CLIENT
+	TRANS(LocalConnect),
+#endif /* TRANS_CLIENT */
+	TRANS(LocalBytesReadable),
+	TRANS(LocalRead),
+	TRANS(LocalWrite),
+	TRANS(LocalReadv),
+	TRANS(LocalWritev),
+#if XTRANS_SEND_FDS
+	TRANS(LocalSendFdInvalid),
+	TRANS(LocalRecvFdInvalid),
+#endif
+	TRANS(LocalDisconnect),
+	TRANS(LocalClose),
+	TRANS(LocalCloseForCloning),
+};
+
+#ifdef LOCAL_TRANS_PTS
+
+Xtransport	TRANS(PTSFuncs) = {
+	/* Local Interface */
+	"pts",
+	TRANS_LOCAL,
+#ifdef TRANS_CLIENT
+	TRANS(LocalOpenCOTSClient),
+#endif /* TRANS_CLIENT */
+#ifdef TRANS_SERVER
+	NULL,
+	TRANS(LocalOpenCOTSServer),
+#endif /* TRANS_SERVER */
+#ifdef TRANS_REOPEN
+	TRANS(LocalReopenCOTSServer),
+#endif
+	TRANS(LocalSetOption),
+#ifdef TRANS_SERVER
+	TRANS(LocalCreateListener),
+	TRANS(LocalResetListener),
+	TRANS(LocalAccept),
+#endif /* TRANS_SERVER */
+#ifdef TRANS_CLIENT
+	TRANS(LocalConnect),
+#endif /* TRANS_CLIENT */
+	TRANS(LocalBytesReadable),
+	TRANS(LocalRead),
+	TRANS(LocalWrite),
+	TRANS(LocalReadv),
+	TRANS(LocalWritev),
+#if XTRANS_SEND_FDS
+	TRANS(LocalSendFdInvalid),
+	TRANS(LocalRecvFdInvalid),
+#endif
+	TRANS(LocalDisconnect),
+	TRANS(LocalClose),
+	TRANS(LocalCloseForCloning),
+};
+
+#endif /* LOCAL_TRANS_PTS */
+
+#ifdef LOCAL_TRANS_NAMED
+
+Xtransport	TRANS(NAMEDFuncs) = {
+	/* Local Interface */
+	"named",
+	TRANS_LOCAL,
+#ifdef TRANS_CLIENT
+	TRANS(LocalOpenCOTSClient),
+#endif /* TRANS_CLIENT */
+#ifdef TRANS_SERVER
+	NULL,
+	TRANS(LocalOpenCOTSServer),
+#endif /* TRANS_SERVER */
+#ifdef TRANS_REOPEN
+	TRANS(LocalReopenCOTSServer),
+#endif
+	TRANS(LocalSetOption),
+#ifdef TRANS_SERVER
+	TRANS(LocalCreateListener),
+	TRANS(LocalResetListener),
+	TRANS(LocalAccept),
+#endif /* TRANS_SERVER */
+#ifdef TRANS_CLIENT
+	TRANS(LocalConnect),
+#endif /* TRANS_CLIENT */
+	TRANS(LocalBytesReadable),
+	TRANS(LocalRead),
+	TRANS(LocalWrite),
+	TRANS(LocalReadv),
+	TRANS(LocalWritev),
+#if XTRANS_SEND_FDS
+	TRANS(LocalSendFdInvalid),
+	TRANS(LocalRecvFdInvalid),
+#endif
+	TRANS(LocalDisconnect),
+	TRANS(LocalClose),
+	TRANS(LocalCloseForCloning),
+};
+
+#ifdef __sun
+Xtransport	TRANS(PIPEFuncs) = {
+	/* Local Interface */
+	"pipe",
+	TRANS_ALIAS | TRANS_LOCAL,
+#ifdef TRANS_CLIENT
+	TRANS(LocalOpenCOTSClient),
+#endif /* TRANS_CLIENT */
+#ifdef TRANS_SERVER
+	NULL,
+	TRANS(LocalOpenCOTSServer),
+#endif /* TRANS_SERVER */
+#ifdef TRANS_REOPEN
+	TRANS(LocalReopenCOTSServer),
+#endif
+	TRANS(LocalSetOption),
+#ifdef TRANS_SERVER
+	TRANS(LocalCreateListener),
+	TRANS(LocalResetListener),
+	TRANS(LocalAccept),
+#endif /* TRANS_SERVER */
+#ifdef TRANS_CLIENT
+	TRANS(LocalConnect),
+#endif /* TRANS_CLIENT */
+	TRANS(LocalBytesReadable),
+	TRANS(LocalRead),
+	TRANS(LocalWrite),
+	TRANS(LocalReadv),
+	TRANS(LocalWritev),
+#if XTRANS_SEND_FDS
+	TRANS(LocalSendFdInvalid),
+	TRANS(LocalRecvFdInvalid),
+#endif
+	TRANS(LocalDisconnect),
+	TRANS(LocalClose),
+	TRANS(LocalCloseForCloning),
+};
+#endif /* __sun */
+#endif /* LOCAL_TRANS_NAMED */
+
+
+#ifdef LOCAL_TRANS_SCO
+Xtransport	TRANS(SCOFuncs) = {
+	/* Local Interface */
+	"sco",
+	TRANS_LOCAL,
+#ifdef TRANS_CLIENT
+	TRANS(LocalOpenCOTSClient),
+#endif /* TRANS_CLIENT */
+#ifdef TRANS_SERVER
+	NULL,
+	TRANS(LocalOpenCOTSServer),
+#endif /* TRANS_SERVER */
+#ifdef TRANS_REOPEN
+	TRANS(LocalReopenCOTSServer),
+#endif
+	TRANS(LocalSetOption),
+#ifdef TRANS_SERVER
+	TRANS(LocalCreateListener),
+	TRANS(LocalResetListener),
+	TRANS(LocalAccept),
+#endif /* TRANS_SERVER */
+#ifdef TRANS_CLIENT
+	TRANS(LocalConnect),
+#endif /* TRANS_CLIENT */
+	TRANS(LocalBytesReadable),
+	TRANS(LocalRead),
+	TRANS(LocalWrite),
+	TRANS(LocalReadv),
+	TRANS(LocalWritev),
+#if XTRANS_SEND_FDS
+	TRANS(LocalSendFdInvalid),
+	TRANS(LocalRecvFdInvalid),
+#endif
+	TRANS(LocalDisconnect),
+	TRANS(LocalClose),
+	TRANS(LocalCloseForCloning),
+};
+#endif /* LOCAL_TRANS_SCO */
diff --git a/nx-X11/lib/include/xtrans/Xtranssock.c b/nx-X11/lib/include/xtrans/Xtranssock.c
new file mode 100644
index 000000000..dff217e9d
--- /dev/null
+++ b/nx-X11/lib/include/xtrans/Xtranssock.c
@@ -0,0 +1,3554 @@
+/**************************************************************************/
+/*                                                                        */
+/* Copyright (c) 2001, 2011 NoMachine (http://www.nomachine.com)          */
+/* Copyright (c) 2008-2014 Oleksandr Shneyder <o.shneyder@phoca-gmbh.de>  */
+/* Copyright (c) 2011-2016 Mike Gabriel <mike.gabriel@das-netzwerkteam.de>*/
+/* Copyright (c) 2014-2016 Mihai Moldovan <ionic@ionic.de>                */
+/* Copyright (c) 2014-2016 Ulrich Sibiller <uli42@gmx.de>                 */
+/* Copyright (c) 2015-2016 Qindel Group (http://www.qindel.com)           */
+/*                                                                        */
+/* nx-X11, NX protocol compression and NX extensions to this software     */
+/* are copyright of the aforementioned persons and companies.             */
+/*                                                                        */
+/* Redistribution and use of the present software is allowed according    */
+/* to terms specified in the file LICENSE which comes in the source       */
+/* distribution.                                                          */
+/*                                                                        */
+/* All rights reserved.                                                   */
+/*                                                                        */
+/* NOTE: This software has received contributions from various other      */
+/* contributors, only the core maintainers and supporters are listed as   */
+/* copyright holders. Please contact us, if you feel you should be listed */
+/* as copyright holder, as well.                                          */
+/*                                                                        */
+/**************************************************************************/
+
+/*
+ * Copyright (c) 2002, Oracle and/or its affiliates. All rights reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the next
+ * paragraph) shall be included in all copies or substantial portions of the
+ * Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ */
+/*
+
+Copyright 1993, 1994, 1998  The Open Group
+
+Permission to use, copy, modify, distribute, and sell this software and its
+documentation for any purpose is hereby granted without fee, provided that
+the above copyright notice appear in all copies and that both that
+copyright notice and this permission notice appear in supporting
+documentation.
+
+The above copyright notice and this permission notice shall be included
+in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR
+OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.
+
+Except as contained in this notice, the name of the copyright holders shall
+not be used in advertising or otherwise to promote the sale, use or
+other dealings in this Software without prior written authorization
+from the copyright holders.
+
+ * Copyright 1993, 1994 NCR Corporation - Dayton, Ohio, USA
+ *
+ * All Rights Reserved
+ *
+ * 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 NCR not be used in advertising
+ * or publicity pertaining to distribution of the software without specific,
+ * written prior permission.  NCR makes no representations about the
+ * suitability of this software for any purpose.  It is provided "as is"
+ * without express or implied warranty.
+ *
+ * NCR DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
+ * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN
+ * NO EVENT SHALL NCR BE LIABLE FOR ANY SPECIAL, INDIRECT OR
+ * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS
+ * OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
+ * NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
+ * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+#ifdef NX_TRANS_SOCKET
+
+#ifdef NX_TRANS_DEBUG
+#define XTRANSDEBUG 5
+#endif
+
+#ifndef PF_LOCAL
+#define PF_LOCAL PF_UNIX
+#endif
+
+#endif
+
+#include <ctype.h>
+#ifdef XTHREADS
+#include <nx-X11/Xthreads.h>
+#endif
+
+#ifndef WIN32
+
+#if defined(TCPCONN) || defined(UNIXCONN)
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
+#endif
+
+#if defined(TCPCONN) || defined(UNIXCONN)
+#define X_INCLUDE_NETDB_H
+#define XOS_USE_NO_LOCKING
+#include <nx-X11/Xos_r.h>
+#endif
+
+#ifdef UNIXCONN
+#ifndef X_NO_SYS_UN
+#include <sys/un.h>
+#endif
+#include <sys/stat.h>
+#endif
+
+
+#ifndef NO_TCP_H
+#if defined(linux) || defined(__GLIBC__)
+#include <sys/param.h>
+#endif /* linux || __GLIBC__ */
+#if defined(__NetBSD__) || defined(__OpenBSD__) || defined(__FreeBSD__) || defined(__DragonFly__)
+#include <sys/param.h>
+#include <machine/endian.h>
+#endif /* __NetBSD__ || __OpenBSD__ || __FreeBSD__ || __DragonFly__ */
+#include <netinet/tcp.h>
+#endif /* !NO_TCP_H */
+
+#include <sys/ioctl.h>
+#if defined(SVR4) || defined(__SVR4)
+#include <sys/filio.h>
+#endif
+
+#include <unistd.h>
+
+#else /* !WIN32 */
+
+#include <nx-X11/Xwinsock.h>
+#include <nx-X11/Xwindows.h>
+#include <nx-X11/Xw32defs.h>
+#undef close
+#define close closesocket
+#define ECONNREFUSED WSAECONNREFUSED
+#define EADDRINUSE WSAEADDRINUSE
+#define EPROTOTYPE WSAEPROTOTYPE
+#undef EWOULDBLOCK
+#define EWOULDBLOCK WSAEWOULDBLOCK
+#define EINPROGRESS WSAEINPROGRESS
+#undef EINTR
+#define EINTR WSAEINTR
+#define X_INCLUDE_NETDB_H
+#define XOS_USE_MTSAFE_NETDBAPI
+#include <nx-X11/Xos_r.h>
+#endif /* WIN32 */
+
+#if defined(SO_DONTLINGER) && defined(SO_LINGER)
+#undef SO_DONTLINGER
+#endif
+
+/* others don't need this */
+#define SocketInitOnce() /**/
+
+#ifdef linux
+#define HAVE_ABSTRACT_SOCKETS
+#endif
+
+#define MIN_BACKLOG 128
+#ifdef SOMAXCONN
+#if SOMAXCONN > MIN_BACKLOG
+#define BACKLOG SOMAXCONN
+#endif
+#endif
+#ifndef BACKLOG
+#define BACKLOG MIN_BACKLOG
+#endif
+
+/*
+ * This is the Socket implementation of the X Transport service layer
+ *
+ * This file contains the implementation for both the UNIX and INET domains,
+ * and can be built for either one, or both.
+ *
+ */
+
+typedef struct _Sockettrans2dev {
+    const char	*transname;
+    int		family;
+    int		devcotsname;
+    int		devcltsname;
+    int		protocol;
+} Sockettrans2dev;
+
+static Sockettrans2dev Sockettrans2devtab[] = {
+#ifdef TCPCONN
+    {"inet",AF_INET,SOCK_STREAM,SOCK_DGRAM,0},
+#if !defined(IPv6) || !defined(AF_INET6)
+    {"tcp",AF_INET,SOCK_STREAM,SOCK_DGRAM,0},
+#else /* IPv6 */
+    {"tcp",AF_INET6,SOCK_STREAM,SOCK_DGRAM,0},
+    {"tcp",AF_INET,SOCK_STREAM,SOCK_DGRAM,0}, /* fallback */
+    {"inet6",AF_INET6,SOCK_STREAM,SOCK_DGRAM,0},
+#endif
+#endif /* TCPCONN */
+#ifdef UNIXCONN
+    {"unix",AF_UNIX,SOCK_STREAM,SOCK_DGRAM,0},
+#if !defined(LOCALCONN)
+    {"local",AF_UNIX,SOCK_STREAM,SOCK_DGRAM,0},
+#endif /* !LOCALCONN */
+#endif /* UNIXCONN */
+};
+
+#define NUMSOCKETFAMILIES (sizeof(Sockettrans2devtab)/sizeof(Sockettrans2dev))
+
+#ifdef TCPCONN
+static int TRANS(SocketINETClose) (XtransConnInfo ciptr);
+#endif
+
+#ifdef UNIXCONN
+
+
+#if defined(X11_t)
+#define UNIX_PATH "/tmp/.X11-unix/X"
+#define UNIX_DIR "/tmp/.X11-unix"
+#endif /* X11_t */
+#if defined(XIM_t)
+#define UNIX_PATH "/tmp/.XIM-unix/XIM"
+#define UNIX_DIR "/tmp/.XIM-unix"
+#endif /* XIM_t */
+#if defined(FS_t) || defined(FONT_t)
+#define UNIX_PATH "/tmp/.font-unix/fs"
+#define UNIX_DIR "/tmp/.font-unix"
+#endif /* FS_t || FONT_t */
+#if defined(ICE_t)
+#define UNIX_PATH "/tmp/.ICE-unix/"
+#define UNIX_DIR "/tmp/.ICE-unix"
+#endif /* ICE_t */
+
+
+#endif /* UNIXCONN */
+
+#define PORTBUFSIZE	32
+
+#ifndef MAXHOSTNAMELEN
+#define MAXHOSTNAMELEN 255
+#endif
+
+#if defined HAVE_SOCKLEN_T || (defined(IPv6) && defined(AF_INET6))
+# define SOCKLEN_T socklen_t
+#elif defined(SVR4) || defined(__SVR4) || defined(__SCO__)
+# define SOCKLEN_T size_t 
+#else
+# define SOCKLEN_T int
+#endif
+
+#ifndef X11_t
+
+/*
+ * No NX changes if this is not
+ * compiled as a X11 transport.
+ */
+
+#undef NX_TRANS_SOCKET
+
+#endif
+
+#ifdef NX_TRANS_SOCKET
+
+#if XTRANS_SEND_FDS
+   #error XTRANS_SEND_FDS is unsupported for NX!
+#endif
+
+#ifdef TRANS_CLIENT
+
+#include <nx/NX.h>
+
+typedef struct
+{
+    XtransConnInfo info;
+    int            local;
+    int            remote;
+    int            congestion;
+
+} _NXProxyConnInfo;
+
+#define NX_PROXY_CONN_LIMIT     256
+
+static _NXProxyConnInfo *_NXProxyConnInfoTab[NX_PROXY_CONN_LIMIT];
+
+#endif /* #ifdef TRANS_CLIENT */
+
+static char *_NXGetUnixDir(char *dir);
+static char *_NXGetUnixPath(char *path);
+
+/*
+ * Forcibly close any connection attempt on the
+ * listening socket. Need this to avoid loopback
+ * connections to the agent server.
+ */
+
+#ifdef TRANS_SERVER
+
+void TRANS(SocketRejectConnection) (XtransConnInfo ciptr)
+{
+    socklen_t sa_l = sizeof(struct sockaddr);
+    struct sockaddr sa;
+    fd_set fs;
+    struct timeval t;
+    int f;
+
+    prmsg (3, "SocketRejectConnection(%p)\n", (void *) ciptr);
+
+    FD_ZERO(&fs);
+    FD_SET(ciptr -> fd, &fs);
+
+    t.tv_sec  = 0;
+    t.tv_usec = 0;
+
+    /*
+     * Check if there is an awaiting connection.
+     */
+
+    if (select(ciptr -> fd + 1, &fs, NULL, NULL, &t) == 1)
+    {
+#ifdef NX_TRANS_TEST
+        fprintf(stderr, "SocketRejectConnection: Accepting connection attempt on fd [%d].\n",
+                    ciptr -> fd);
+#endif
+        /*
+         * If there is one, close it.
+         */
+
+        if ((f = accept(ciptr -> fd, &sa, &sa_l)) >= 0)
+        {
+#ifdef NX_TRANS_TEST
+            fprintf(stderr, "SocketRejectConnection: Closing connection attempt on fd [%d].\n",
+                        ciptr -> fd);
+#endif
+            close(f);
+        }
+    }
+}
+
+#endif /* #ifdef TRANS_SERVER */
+
+#ifdef TRANS_CLIENT
+
+void *TRANS(SocketProxyConnInfo) (XtransConnInfo ciptr)
+{
+    if (_NXProxyConnInfoTab[ciptr->fd] != NULL)
+    {
+      return ciptr->priv;
+    }
+
+    return NULL;
+}
+
+static XtransConnInfo TRANS(SocketCreateConnInfo) ()
+{
+    XtransConnInfo ciptr;
+
+    int fds[2];
+
+#ifdef NX_TRANS_TEST
+    fprintf(stderr, "SocketCreateConnInfo: Going to create the NX connection info.\n");
+#endif
+
+    if ((ciptr = (XtransConnInfo) calloc (1, sizeof(struct _XtransConnInfo))) == NULL)
+    {
+        prmsg (1, "SocketCreateConnInfo: malloc failed\n");
+        return NULL;
+    }
+
+    /*
+     * Create a pair of sockets. We'll communicate with
+     * the NX proxy by reading and writing to our end.
+     */
+
+#ifdef NX_TRANS_TEST
+    fprintf(stderr, "SocketCreateConnInfo: Going to create the NX socketpair.\n");
+#endif
+
+    if (socketpair(PF_LOCAL, SOCK_STREAM, 0, fds) < 0)
+    {
+        prmsg (1, "SocketCreateConnInfo: socketpair() failed.\n");
+        free ((char *) ciptr);
+        return NULL;
+    }
+
+#ifdef NX_TRANS_TEST
+    fprintf(stderr, "SocketCreateConnInfo: X socket end is [%d] NX proxy end is [%d].\n",
+                fds[0], fds[1]);
+#endif
+
+    /*
+     * Save in _NXProxyConnInfoTab the local and remote end of
+     * the socketpair. The remote end will be used by the proxy.
+     * When the memory-to-memory transport is activated, the
+     * agent and the proxy don't read or write to the real des-
+     * criptors but the communication takes place by reading
+     * and writing to the proxy's buffers.
+     */
+
+    ciptr->fd = fds[0];
+
+    if (ciptr->fd >= NX_PROXY_CONN_LIMIT)
+    {
+        prmsg (1, "SocketCreateConnInfo: No space for a new _NXProxyConnInfo for [%d].\n",
+                  ciptr->fd);
+        free ((char *) ciptr);
+        return NULL;
+    }
+    else if (_NXProxyConnInfoTab[ciptr->fd] != NULL)
+    {
+        prmsg (1, "SocketCreateConnInfo: _NXProxyConnInfo for [%d] is not NULL. Exiting.\n",
+                   ciptr->fd);
+        exit(1);
+    }
+
+    _NXProxyConnInfoTab[ciptr->fd] = (_NXProxyConnInfo *) calloc(1, sizeof(_NXProxyConnInfo));
+
+    if (_NXProxyConnInfoTab[ciptr->fd] == NULL)
+    {
+        prmsg (1, "SocketCreateConnInfo: Alloc of _NXProxyConnInfo failed.\n");
+        free ((char *) ciptr);
+        return NULL;
+    }
+
+#ifdef NX_TRANS_TEST
+    fprintf(stderr, "SocketCreateConnInfo: Allocated new _NXProxyConnInfo for [%d].\n",
+                ciptr->fd);
+#endif
+
+    _NXProxyConnInfoTab[ciptr->fd]->info       = ciptr;
+    _NXProxyConnInfoTab[ciptr->fd]->local      = fds[0];
+    _NXProxyConnInfoTab[ciptr->fd]->remote     = fds[1];
+    _NXProxyConnInfoTab[ciptr->fd]->congestion = 0;
+
+    ciptr->priv = (char *) _NXProxyConnInfoTab[ciptr->fd];
+
+    return ciptr;
+}
+
+static int TRANS(SocketConnectConnInfo) (XtransConnInfo ciptr, const char *host, const char *port)
+{
+    int fds[2];
+    char display[1024];
+
+    _NXProxyConnInfo *proxy_conn;
+
+#ifdef NX_TRANS_TEST
+    fprintf(stderr, "SocketConnectConnInfo: Going to connect NX fd [%d] to host [%s] port [%s].\n",
+                ciptr->fd, host, port);
+#endif
+
+    /*
+     * We should have already created the socket pair.
+     */
+
+    proxy_conn = (_NXProxyConnInfo *) ciptr->priv;
+
+    if (proxy_conn == NULL)
+    {
+        prmsg (1, "SocketConnectConnInfo: Pointer to _NXProxyConnInfo is NULL. Exiting.\n");
+
+        exit(1);
+    }
+    else if (_NXProxyConnInfoTab[ciptr->fd] != (_NXProxyConnInfo *) ciptr->priv)
+    {
+        prmsg (1, "SocketConnectConnInfo: Can't find _NXProxyConnInfo in table. Exiting.\n");
+
+        exit(1);
+    }
+
+    if (strlen(host) + strlen(port) + 1 >= 1023)
+    {
+        prmsg (1, "SocketConnectConnInfo: Length of NX display string '%s:%s' would exceed %d characters.\n",
+                   host, port, 1023);
+
+        return TRANS_CONNECT_FAILED;
+    }
+
+    sprintf(display, "%s:%s", host, port);
+
+#ifdef NX_TRANS_TEST
+    fprintf(stderr, "SocketConnectConnInfo: Setting close-on-exec flag on local NX descriptor [%d].\n",
+                proxy_conn -> local);
+#endif
+
+#ifdef F_SETFD
+#ifdef FD_CLOEXEC
+    if (fcntl(proxy_conn -> local, F_SETFD, FD_CLOEXEC) != 0)
+#else
+    if (fcntl(proxy_conn -> local, F_SETFD, 1) != 0)
+#endif
+#endif
+    {
+        prmsg (1, "SocketConnectConnInfo: Cannot set close-on-exec on local NX descriptor [%d].\n",
+                   proxy_conn -> local);
+
+        return TRANS_CONNECT_FAILED;
+    }
+
+#ifdef NX_TRANS_TEST
+    fprintf(stderr, "SocketConnectConnInfo: Creating the NX transport with display [%s].\n",
+                display);
+#endif
+
+    if (NXTransCreate(NX_FD_ANY, NX_MODE_CLIENT, display) < 0)
+    {
+        prmsg (1, "SocketConnectConnInfo: Cannot create the NX transport.\n");
+
+        return TRANS_CONNECT_FAILED;
+    }
+
+#ifdef NX_TRANS_TEST
+    fprintf(stderr, "SocketConnectConnInfo: Starting the NX agent with descriptor [%d].\n",
+                proxy_conn -> remote);
+#endif
+
+    fds[0] = proxy_conn -> local;
+    fds[1] = proxy_conn -> remote;
+
+    NXTransAgent(fds);
+
+    return 0;
+}
+
+static void TRANS(SocketCloseConnInfo) (XtransConnInfo ciptr)
+{
+    _NXProxyConnInfo *proxy_conn;
+
+#ifdef NX_TRANS_TEST
+    fprintf(stderr, "SocketCloseConnInfo: Going to close the NX fd [%d].\n", ciptr->fd);
+#endif
+
+    proxy_conn = (_NXProxyConnInfo *) ciptr->priv;
+
+    if (proxy_conn == NULL)
+    {
+        prmsg (1, "SocketCloseConnInfo: Pointer to _NXProxyConnInfo is NULL. Exiting.\n");
+
+        exit(1);
+    }
+    else if (ciptr->fd >= NX_PROXY_CONN_LIMIT ||
+                 _NXProxyConnInfoTab[ciptr->fd] != (_NXProxyConnInfo *) ciptr->priv)
+    {
+        prmsg (1, "SocketCloseConnInfo: Can't find _NXProxyConnInfo in table. Exiting.\n");
+        exit(1);
+    }
+    else if (_NXProxyConnInfoTab[ciptr->fd] -> info != ciptr ||
+                 _NXProxyConnInfoTab[ciptr->fd] -> local != ciptr->fd)
+    {
+        prmsg (1, "SocketCloseConnInfo: Invalid _NXProxyConnInfo structure for [%d]. Exiting.\n",
+                   ciptr->fd);
+        exit(1);
+    }
+    else if (proxy_conn->local < 0 || proxy_conn->remote < 0)
+    {
+        prmsg (1, "SocketCloseConnInfo: Invalid socket pair in NX connection for [%d]. Exiting.\n",
+                   ciptr->fd);
+        exit(1);
+    }
+
+    NXTransClose(ciptr->fd);
+
+    /*
+     *  Get rid of the _NXProxyConnInfo structure.
+     */
+
+#ifdef NX_TRANS_TEST
+    fprintf(stderr, "SocketCloseConnInfo: Freeing _NXProxyConnInfo structure for [%d].\n",
+                ciptr->fd);
+#endif
+
+    free((char *) _NXProxyConnInfoTab[ciptr->fd]);
+
+    _NXProxyConnInfoTab[ciptr->fd] = NULL;
+
+    ciptr->priv = NULL;
+
+#ifdef NX_TRANS_TEST
+    fprintf(stderr, "SocketCloseConnInfo: Should now close the local descriptor [%d].\n",
+                ciptr->fd);
+#endif
+}
+
+#endif /* #ifdef TRANS_CLIENT */
+
+#if defined(TRANS_CLIENT) && defined(NX_TRANS_CHANGE)
+
+/*
+ * Check the congestion state of the NX transport
+ * and return 1 if there has been a change. This
+ * can be extended by adding a few counters track-
+ * ing the bandwidth usage of the X11 connection.
+ */
+
+int TRANS(SocketCongestionChange) (XtransConnInfo ciptr, int *state)
+{
+    int congestion;
+
+    _NXProxyConnInfo *proxy_conn;
+
+    prmsg (3, "SocketCongestionChange(%p)\n", (void *) ciptr);
+
+    proxy_conn = (_NXProxyConnInfo *) ciptr->priv;
+
+    if (proxy_conn == NULL)
+    {
+#ifdef NX_TRANS_DEBUG
+        fprintf(stderr, "SocketCongestionChange: Descriptor [%d] doesn't appear to be a NX connection.\n",
+                    ciptr->fd);
+#endif
+        return 0;
+    }
+
+#ifdef NX_TRANS_DEBUG
+    fprintf(stderr, "SocketCongestionChange: Checking congestion on fd [%d] with old state [%d].\n",
+                ciptr->fd, proxy_conn->congestion);
+#endif
+
+    congestion = NXTransCongestion(ciptr->fd);
+
+    if (congestion != proxy_conn->congestion)
+    {
+        proxy_conn->congestion = congestion;
+
+#ifdef NX_TRANS_TEST
+        fprintf(stderr, "SocketCongestionChange: Change detected on fd [%d] with new state [%d].\n",
+                    ciptr->fd, proxy_conn->congestion);
+#endif
+        return 1;
+    }
+
+#ifdef NX_TRANS_TEST
+    fprintf(stderr, "SocketCongestionChange: No change on fd [%d] with current state [%d].\n",
+                ciptr->fd, congestion);
+#endif
+    return 0;
+}
+
+#endif /* #if defined(TRANS_CLIENT) && defined(NX_TRANS_CHANGE) */
+
+#endif /* #ifdef NX_TRANS_SOCKET */
+
+/*
+ * These are some utility function used by the real interface function below.
+ */
+
+static int
+TRANS(SocketSelectFamily) (int first, const char *family)
+
+{
+    int     i;
+
+    prmsg (3,"SocketSelectFamily(%s)\n", family);
+
+    for (i = first + 1; i < NUMSOCKETFAMILIES;i++)
+    {
+        if (!strcmp (family, Sockettrans2devtab[i].transname))
+	    return i;
+    }
+
+    return (first == -1 ? -2 : -1);
+}
+
+
+/*
+ * This function gets the local address of the socket and stores it in the
+ * XtransConnInfo structure for the connection.
+ */
+
+static int
+TRANS(SocketINETGetAddr) (XtransConnInfo ciptr)
+
+{
+#if defined(IPv6) && defined(AF_INET6)
+    struct sockaddr_storage socknamev6;
+#else
+    struct sockaddr_in socknamev4;
+#endif
+    void *socknamePtr;
+    SOCKLEN_T namelen;
+
+    prmsg (3,"SocketINETGetAddr(%p)\n", (void *) ciptr);
+
+#if defined(IPv6) && defined(AF_INET6)
+	namelen = sizeof(socknamev6);
+	socknamePtr = &socknamev6;
+#else
+	namelen = sizeof(socknamev4);
+	socknamePtr = &socknamev4;
+#endif
+
+    bzero(socknamePtr, namelen);
+
+    if (getsockname (ciptr->fd,(struct sockaddr *) socknamePtr,
+		     (void *)&namelen) < 0)
+    {
+#ifdef WIN32
+	errno = WSAGetLastError();
+#endif
+	prmsg (1,"SocketINETGetAddr: getsockname() failed: %d\n",
+	    EGET());
+	return -1;
+    }
+
+    /*
+     * Everything looks good: fill in the XtransConnInfo structure.
+     */
+
+    if ((ciptr->addr = malloc (namelen)) == NULL)
+    {
+        prmsg (1,
+	    "SocketINETGetAddr: Can't allocate space for the addr\n");
+        return -1;
+    }
+
+#if defined(IPv6) && defined(AF_INET6)
+	ciptr->family = ((struct sockaddr *)socknamePtr)->sa_family;
+#else
+	ciptr->family = socknamev4.sin_family;
+#endif
+    ciptr->addrlen = namelen;
+    memcpy (ciptr->addr, socknamePtr, ciptr->addrlen);
+
+    return 0;
+}
+
+
+/*
+ * This function gets the remote address of the socket and stores it in the
+ * XtransConnInfo structure for the connection.
+ */
+
+static int
+TRANS(SocketINETGetPeerAddr) (XtransConnInfo ciptr)
+
+{
+#if defined(IPv6) && defined(AF_INET6)
+    struct sockaddr_storage socknamev6;
+#endif
+    struct sockaddr_in 	socknamev4;
+    void *socknamePtr;
+    SOCKLEN_T namelen;
+
+#if defined(IPv6) && defined(AF_INET6)
+    if (ciptr->family == AF_INET6)
+    {
+	namelen = sizeof(socknamev6);
+	socknamePtr = &socknamev6;
+    }
+    else
+#endif
+    {
+	namelen = sizeof(socknamev4);
+	socknamePtr = &socknamev4;
+    }
+
+    bzero(socknamePtr, namelen);
+
+    prmsg (3,"SocketINETGetPeerAddr(%p)\n", (void *) ciptr);
+
+    if (getpeername (ciptr->fd, (struct sockaddr *) socknamePtr,
+		     (void *)&namelen) < 0)
+    {
+#ifdef WIN32
+	errno = WSAGetLastError();
+#endif
+	prmsg (1,"SocketINETGetPeerAddr: getpeername() failed: %d\n",
+	    EGET());
+	return -1;
+    }
+
+    /*
+     * Everything looks good: fill in the XtransConnInfo structure.
+     */
+
+    if ((ciptr->peeraddr = malloc (namelen)) == NULL)
+    {
+        prmsg (1,
+	   "SocketINETGetPeerAddr: Can't allocate space for the addr\n");
+        return -1;
+    }
+
+    ciptr->peeraddrlen = namelen;
+    memcpy (ciptr->peeraddr, socknamePtr, ciptr->peeraddrlen);
+
+    return 0;
+}
+
+
+static XtransConnInfo
+TRANS(SocketOpen) (int i, int type)
+
+{
+    XtransConnInfo	ciptr;
+
+    prmsg (3,"SocketOpen(%d,%d)\n", i, type);
+
+    if ((ciptr = calloc (1, sizeof(struct _XtransConnInfo))) == NULL)
+    {
+	prmsg (1, "SocketOpen: malloc failed\n");
+	return NULL;
+    }
+
+    if ((ciptr->fd = socket(Sockettrans2devtab[i].family, type,
+	Sockettrans2devtab[i].protocol)) < 0
+#ifndef WIN32
+#if (defined(X11_t) && !defined(USE_POLL)) || defined(FS_t) || defined(FONT_t)
+       || ciptr->fd >= sysconf(_SC_OPEN_MAX)
+#endif
+#endif
+      ) {
+#ifdef WIN32
+	errno = WSAGetLastError();
+#endif
+	prmsg (2, "SocketOpen: socket() failed for %s\n",
+	    Sockettrans2devtab[i].transname);
+
+	free (ciptr);
+	return NULL;
+    }
+
+#ifdef TCP_NODELAY
+    if (Sockettrans2devtab[i].family == AF_INET
+#if defined(IPv6) && defined(AF_INET6)
+      || Sockettrans2devtab[i].family == AF_INET6
+#endif
+    )
+    {
+	/*
+	 * turn off TCP coalescence for INET sockets
+	 */
+
+	int tmp = 1;
+	setsockopt (ciptr->fd, IPPROTO_TCP, TCP_NODELAY,
+	    (char *) &tmp, sizeof (int));
+    }
+#endif
+
+    /*
+     * Some systems provide a really small default buffer size for
+     * UNIX sockets.  Bump it up a bit such that large transfers don't
+     * proceed at glacial speed.
+     */
+#ifdef SO_SNDBUF
+    if (Sockettrans2devtab[i].family == AF_UNIX)
+    {
+	SOCKLEN_T len = sizeof (int);
+	int val;
+
+	if (getsockopt (ciptr->fd, SOL_SOCKET, SO_SNDBUF,
+	    (char *) &val, &len) == 0 && val < 64 * 1024)
+	{
+	    val = 64 * 1024;
+	    setsockopt (ciptr->fd, SOL_SOCKET, SO_SNDBUF,
+	        (char *) &val, sizeof (int));
+	}
+    }
+#endif
+
+    return ciptr;
+}
+
+
+#ifdef TRANS_REOPEN
+
+static XtransConnInfo
+TRANS(SocketReopen) (int i _X_UNUSED, int type, int fd, const char *port)
+
+{
+    XtransConnInfo	ciptr;
+    int portlen;
+    struct sockaddr *addr;
+    size_t addrlen;
+
+    prmsg (3,"SocketReopen(%d,%d,%s)\n", type, fd, port);
+
+    if (port == NULL) {
+      prmsg (1, "SocketReopen: port was null!\n");
+      return NULL;
+    }
+
+    portlen = strlen(port) + 1; // include space for trailing null
+#ifdef SOCK_MAXADDRLEN
+    if (portlen < 0 || portlen > (SOCK_MAXADDRLEN + 2)) {
+      prmsg (1, "SocketReopen: invalid portlen %d\n", portlen);
+      return NULL;
+    }
+    if (portlen < 14) portlen = 14;
+#else
+    if (portlen < 0 || portlen > 14) {
+      prmsg (1, "SocketReopen: invalid portlen %d\n", portlen);
+      return NULL;
+    }
+#endif /*SOCK_MAXADDRLEN*/
+
+    if ((ciptr = calloc (1, sizeof(struct _XtransConnInfo))) == NULL)
+    {
+	prmsg (1, "SocketReopen: malloc(ciptr) failed\n");
+	return NULL;
+    }
+
+    ciptr->fd = fd;
+
+    addrlen = portlen + offsetof(struct sockaddr, sa_data);
+    if ((addr = calloc (1, addrlen)) == NULL) {
+	prmsg (1, "SocketReopen: malloc(addr) failed\n");
+	free (ciptr);
+	return NULL;
+    }
+    ciptr->addr = (char *) addr;
+    ciptr->addrlen = addrlen;
+
+    if ((ciptr->peeraddr = calloc (1, addrlen)) == NULL) {
+	prmsg (1, "SocketReopen: malloc(portaddr) failed\n");
+	free (addr);
+	free (ciptr);
+	return NULL;
+    }
+    ciptr->peeraddrlen = addrlen;
+
+    /* Initialize ciptr structure as if it were a normally-opened unix socket */
+    ciptr->flags = TRANS_LOCAL | TRANS_NOUNLINK;
+#ifdef BSD44SOCKETS
+    addr->sa_len = addrlen;
+#endif
+    addr->sa_family = AF_UNIX;
+#if defined(HAVE_STRLCPY) || defined(HAS_STRLCPY)
+    strlcpy(addr->sa_data, port, portlen);
+#else
+    strncpy(addr->sa_data, port, portlen);
+#endif
+    ciptr->family = AF_UNIX;
+    memcpy(ciptr->peeraddr, ciptr->addr, addrlen);
+    ciptr->port = rindex(addr->sa_data, ':');
+    if (ciptr->port == NULL) {
+	if (is_numeric(addr->sa_data)) {
+	    ciptr->port = addr->sa_data;
+	}
+    } else if (ciptr->port[0] == ':') {
+	ciptr->port++;
+    }
+    /* port should now point to portnum or NULL */
+    return ciptr;
+}
+
+#endif /* TRANS_REOPEN */
+
+
+/*
+ * These functions are the interface supplied in the Xtransport structure
+ */
+
+#ifdef TRANS_CLIENT
+
+static XtransConnInfo
+TRANS(SocketOpenCOTSClientBase) (const char *transname, const char *protocol,
+			   const char *host, const char *port, int previndex)
+{
+    XtransConnInfo	ciptr;
+    int			i = previndex;
+
+    prmsg (2, "SocketOpenCOTSClient(%s,%s,%s)\n",
+	protocol, host, port);
+
+    SocketInitOnce();
+
+    while ((i = TRANS(SocketSelectFamily) (i, transname)) >= 0) {
+
+#if defined(NX_TRANS_SOCKET) && defined(TRANS_CLIENT)
+
+        if ((!strcmp(protocol, "local") || !strcmp(protocol, "nx")) &&
+                (!strcasecmp(host, "nx") || !strncasecmp(host, "nx,", 3)))
+        {
+            ciptr = TRANS(SocketCreateConnInfo) ();
+
+            if (ciptr == NULL)
+            {
+                prmsg (1, "SocketOpenCOTSClient: Unable to create the NX connection info for %s.\n",
+                           transname);
+
+                return NULL;
+            }
+
+            ciptr->index = i;
+
+            return ciptr;
+        }
+
+#endif /* #if defined(NX_TRANS_SOCKET) && defined(TRANS_CLIENT) */
+
+	if ((ciptr = TRANS(SocketOpen) (
+		i, Sockettrans2devtab[i].devcotsname)) != NULL) {
+	    /* Save the index for later use */
+
+	    ciptr->index = i;
+	    break;
+	}
+    }
+    if (i < 0) {
+	if (i == -1)
+	    prmsg (1,"SocketOpenCOTSClient: Unable to open socket for %s\n",
+		   transname);
+	else
+	    prmsg (1,"SocketOpenCOTSClient: Unable to determine socket type for %s\n",
+		   transname);
+	return NULL;
+    }
+
+#if defined(NX_TRANS_SOCKET) && defined(TRANS_CLIENT)
+
+    ciptr->priv = NULL;
+
+#endif
+
+    return ciptr;
+}
+
+static XtransConnInfo
+TRANS(SocketOpenCOTSClient) (Xtransport *thistrans, const char *protocol,
+			     const char *host, const char *port)
+{
+    return TRANS(SocketOpenCOTSClientBase)(
+			thistrans->TransName, protocol, host, port, -1);
+}
+
+
+#endif /* TRANS_CLIENT */
+
+
+#ifdef TRANS_SERVER
+
+static XtransConnInfo
+TRANS(SocketOpenCOTSServer) (Xtransport *thistrans, const char *protocol,
+			     const char *host, const char *port)
+
+{
+    XtransConnInfo	ciptr;
+    int	i = -1;
+
+    prmsg (2,"SocketOpenCOTSServer(%s,%s,%s)\n", protocol, host, port);
+
+    SocketInitOnce();
+
+    while ((i = TRANS(SocketSelectFamily) (i, thistrans->TransName)) >= 0) {
+	if ((ciptr = TRANS(SocketOpen) (
+		 i, Sockettrans2devtab[i].devcotsname)) != NULL)
+	    break;
+    }
+    if (i < 0) {
+	if (i == -1)
+	    prmsg (1,"SocketOpenCOTSServer: Unable to open socket for %s\n",
+		   thistrans->TransName);
+	else
+	    prmsg (1,"SocketOpenCOTSServer: Unable to determine socket type for %s\n",
+		   thistrans->TransName);
+	return NULL;
+    }
+
+    /*
+     * Using this prevents the bind() check for an existing server listening
+     * on the same port, but it is required for other reasons.
+     */
+#ifdef SO_REUSEADDR
+
+    /*
+     * SO_REUSEADDR only applied to AF_INET && AF_INET6
+     */
+
+    if (Sockettrans2devtab[i].family == AF_INET
+#if defined(IPv6) && defined(AF_INET6)
+      || Sockettrans2devtab[i].family == AF_INET6
+#endif
+    )
+    {
+	int one = 1;
+	setsockopt (ciptr->fd, SOL_SOCKET, SO_REUSEADDR,
+		    (char *) &one, sizeof (int));
+    }
+#endif
+#ifdef IPV6_V6ONLY
+    if (Sockettrans2devtab[i].family == AF_INET6)
+    {
+	int one = 1;
+	setsockopt(ciptr->fd, IPPROTO_IPV6, IPV6_V6ONLY, &one, sizeof(int));
+    }
+#endif
+    /* Save the index for later use */
+
+    ciptr->index = i;
+
+    return ciptr;
+}
+
+#endif /* TRANS_SERVER */
+
+
+#ifdef TRANS_REOPEN
+
+static XtransConnInfo
+TRANS(SocketReopenCOTSServer) (Xtransport *thistrans, int fd, const char *port)
+
+{
+    XtransConnInfo	ciptr;
+    int			i = -1;
+
+    prmsg (2,
+	"SocketReopenCOTSServer(%d, %s)\n", fd, port);
+
+    SocketInitOnce();
+
+    while ((i = TRANS(SocketSelectFamily) (i, thistrans->TransName)) >= 0) {
+	if ((ciptr = TRANS(SocketReopen) (
+		 i, Sockettrans2devtab[i].devcotsname, fd, port)) != NULL)
+	    break;
+    }
+    if (i < 0) {
+	if (i == -1)
+	    prmsg (1,"SocketReopenCOTSServer: Unable to open socket for %s\n",
+		   thistrans->TransName);
+	else
+	    prmsg (1,"SocketReopenCOTSServer: Unable to determine socket type for %s\n",
+		   thistrans->TransName);
+	return NULL;
+    }
+
+    /* Save the index for later use */
+
+    ciptr->index = i;
+
+    return ciptr;
+}
+
+#endif /* TRANS_REOPEN */
+
+
+static int
+TRANS(SocketSetOption) (XtransConnInfo ciptr, int option, int arg)
+
+{
+    prmsg (2,"SocketSetOption(%d,%d,%d)\n", ciptr->fd, option, arg);
+
+#ifdef NX_TRANS_TEST
+    fprintf(stderr, "SocketSetOption: WARNING! Not setting option [%d] with value [%d] on descriptor [%d].\n",
+                option, arg, ciptr -> fd);
+#endif
+
+    return -1;
+}
+
+#ifdef UNIXCONN
+static int
+set_sun_path(const char *port, const char *upath, char *path, int abstract)
+{
+    struct sockaddr_un s;
+    int maxlen = sizeof(s.sun_path) - 1;
+    const char *at = "";
+
+    if (!port || !*port || !path)
+	return -1;
+
+#ifdef HAVE_ABSTRACT_SOCKETS
+    if (port[0] == '@')
+	upath = "";
+    else if (abstract)
+	at = "@";
+#endif
+
+    if (*port == '/') /* a full pathname */
+	upath = "";
+
+    if (strlen(port) + strlen(upath) > maxlen)
+	return -1;
+    snprintf(path, sizeof(s.sun_path), "%s%s%s", at, upath, port);
+    return 0;
+}
+#endif
+
+#ifdef TRANS_SERVER
+
+static int
+TRANS(SocketCreateListener) (XtransConnInfo ciptr,
+			     struct sockaddr *sockname,
+			     int socknamelen, unsigned int flags)
+
+{
+    SOCKLEN_T namelen = socknamelen;
+    int	fd = ciptr->fd;
+    int	retry;
+
+    prmsg (3, "SocketCreateListener(%p,%d)\n", (void *) ciptr, fd);
+
+    if (Sockettrans2devtab[ciptr->index].family == AF_INET
+#if defined(IPv6) && defined(AF_INET6)
+      || Sockettrans2devtab[ciptr->index].family == AF_INET6
+#endif
+	)
+	retry = 20;
+    else
+	retry = 0;
+
+#if defined(NX_TRANS_SOCKET) && defined(NX_TRANS_TEST)
+    fprintf(stderr, "SocketCreateListener: Creating listener for ciptr at [%p] on path [%s].\n",
+                (void *) ciptr, ((struct sockaddr_un *) sockname)->sun_family == AF_UNIX ?
+                    ((struct sockaddr_un *) sockname)->sun_path : "TCP");
+#endif
+    while (bind (fd, (struct sockaddr *) sockname, namelen) < 0)
+    {
+	if (errno == EADDRINUSE) {
+	    if (flags & ADDR_IN_USE_ALLOWED)
+		break;
+	    else
+		return TRANS_ADDR_IN_USE;
+	}
+
+	if (retry-- == 0) {
+	    prmsg (1, "SocketCreateListener: failed to bind listener\n");
+	    close (fd);
+	    return TRANS_CREATE_LISTENER_FAILED;
+	}
+#ifdef SO_REUSEADDR
+	sleep (1);
+#else
+	sleep (10);
+#endif /* SO_REUSEDADDR */
+    }
+
+    if (Sockettrans2devtab[ciptr->index].family == AF_INET
+#if defined(IPv6) && defined(AF_INET6)
+      || Sockettrans2devtab[ciptr->index].family == AF_INET6
+#endif
+	) {
+#ifdef SO_DONTLINGER
+	setsockopt (fd, SOL_SOCKET, SO_DONTLINGER, (char *) NULL, 0);
+#else
+#ifdef SO_LINGER
+    {
+	static int linger[2] = { 0, 0 };
+	setsockopt (fd, SOL_SOCKET, SO_LINGER,
+		(char *) linger, sizeof (linger));
+    }
+#endif
+#endif
+}
+
+    if (listen (fd, BACKLOG) < 0)
+    {
+	prmsg (1, "SocketCreateListener: listen() failed\n");
+	close (fd);
+	return TRANS_CREATE_LISTENER_FAILED;
+    }
+
+    /* Set a flag to indicate that this connection is a listener */
+
+    ciptr->flags = 1 | (ciptr->flags & TRANS_KEEPFLAGS);
+
+#if defined(NX_TRANS_SOCKET) && defined(NX_TRANS_TEST)
+    fprintf(stderr, "SocketCreateListener: Set flags to [%d] for ciptr [%p].\n",
+                ciptr->flags, (void *) ciptr);
+#endif
+
+    return 0;
+}
+
+#ifdef TCPCONN
+static int
+TRANS(SocketINETCreateListener) (XtransConnInfo ciptr, const char *port,
+                                 unsigned int flags)
+
+{
+#if defined(IPv6) && defined(AF_INET6)
+    struct sockaddr_storage sockname;
+#else
+    struct sockaddr_in	    sockname;
+#endif
+    unsigned short	    sport;
+    SOCKLEN_T	namelen = sizeof(sockname);
+    int		status;
+    long	tmpport;
+#ifdef XTHREADS_NEEDS_BYNAMEPARAMS
+    _Xgetservbynameparams sparams;
+#endif
+    struct servent *servp;
+
+#ifdef X11_t
+    char	portbuf[PORTBUFSIZE];
+#endif
+
+    prmsg (2, "SocketINETCreateListener(%s)\n", port);
+
+#ifdef X11_t
+    /*
+     * X has a well known port, that is transport dependent. It is easier
+     * to handle it here, than try and come up with a transport independent
+     * representation that can be passed in and resolved the usual way.
+     *
+     * The port that is passed here is really a string containing the idisplay
+     * from ConnectDisplay().
+     */
+
+    if (is_numeric (port))
+    {
+	/* fixup the server port address */
+	tmpport = X_TCP_PORT + strtol (port, (char**)NULL, 10);
+	snprintf (portbuf, sizeof(portbuf), "%lu", tmpport);
+	port = portbuf;
+    }
+#endif
+
+    if (port && *port)
+    {
+	/* Check to see if the port string is just a number (handles X11) */
+
+	if (!is_numeric (port))
+	{
+	    if ((servp = _XGetservbyname (port,"tcp",sparams)) == NULL)
+	    {
+		prmsg (1,
+	     "SocketINETCreateListener: Unable to get service for %s\n",
+		      port);
+		return TRANS_CREATE_LISTENER_FAILED;
+	    }
+	    /* we trust getservbyname to return a valid number */
+	    sport = servp->s_port;
+	}
+	else
+	{
+	    tmpport = strtol (port, (char**)NULL, 10);
+	    /*
+	     * check that somehow the port address isn't negative or in
+	     * the range of reserved port addresses. This can happen and
+	     * be very bad if the server is suid-root and the user does
+	     * something (dumb) like `X :60049`.
+	     */
+	    if (tmpport < 1024 || tmpport > USHRT_MAX)
+		return TRANS_CREATE_LISTENER_FAILED;
+
+	    sport = (unsigned short) tmpport;
+	}
+    }
+    else
+	sport = 0;
+
+    bzero(&sockname, sizeof(sockname));
+#if defined(IPv6) && defined(AF_INET6)
+    if (Sockettrans2devtab[ciptr->index].family == AF_INET) {
+	namelen = sizeof (struct sockaddr_in);
+#ifdef BSD44SOCKETS
+	((struct sockaddr_in *)&sockname)->sin_len = namelen;
+#endif
+	((struct sockaddr_in *)&sockname)->sin_family = AF_INET;
+	((struct sockaddr_in *)&sockname)->sin_port = htons(sport);
+	((struct sockaddr_in *)&sockname)->sin_addr.s_addr = htonl(INADDR_ANY);
+    } else {
+	namelen = sizeof (struct sockaddr_in6);
+#ifdef SIN6_LEN
+	((struct sockaddr_in6 *)&sockname)->sin6_len = sizeof(sockname);
+#endif
+	((struct sockaddr_in6 *)&sockname)->sin6_family = AF_INET6;
+	((struct sockaddr_in6 *)&sockname)->sin6_port = htons(sport);
+	((struct sockaddr_in6 *)&sockname)->sin6_addr = in6addr_any;
+    }
+#else
+#ifdef BSD44SOCKETS
+    sockname.sin_len = sizeof (sockname);
+#endif
+    sockname.sin_family = AF_INET;
+    sockname.sin_port = htons (sport);
+    sockname.sin_addr.s_addr = htonl (INADDR_ANY);
+#endif
+
+    if ((status = TRANS(SocketCreateListener) (ciptr,
+	(struct sockaddr *) &sockname, namelen, flags)) < 0)
+    {
+	prmsg (1,
+    "SocketINETCreateListener: ...SocketCreateListener() failed\n");
+	return status;
+    }
+
+    if (TRANS(SocketINETGetAddr) (ciptr) < 0)
+    {
+	prmsg (1,
+       "SocketINETCreateListener: ...SocketINETGetAddr() failed\n");
+	return TRANS_CREATE_LISTENER_FAILED;
+    }
+
+    return 0;
+}
+
+#endif /* TCPCONN */
+
+
+#ifdef UNIXCONN
+
+static int
+TRANS(SocketUNIXCreateListener) (XtransConnInfo ciptr, const char *port,
+				 unsigned int flags)
+
+{
+    struct sockaddr_un	sockname;
+    int			namelen;
+    int			oldUmask;
+    int			status;
+    unsigned int	mode;
+    char		tmpport[108];
+
+    int			abstract = 0;
+#ifdef HAVE_ABSTRACT_SOCKETS
+    abstract = ciptr->transptr->flags & TRANS_ABSTRACT;
+#endif
+
+    prmsg (2, "SocketUNIXCreateListener(%s)\n",
+	port ? port : "NULL");
+
+    /* Make sure the directory is created */
+
+    oldUmask = umask (0);
+
+#ifdef UNIX_DIR
+#ifdef HAS_STICKY_DIR_BIT
+    mode = 01777;
+#else
+    mode = 0777;
+#endif
+#ifdef NX_TRANS_SOCKET
+    if (!abstract && trans_mkdir(_NXGetUnixDir(UNIX_DIR), mode) == -1) {
+        prmsg (1, "SocketUNIXCreateListener: mkdir(%s) failed, errno = %d\n",
+               _NXGetUnixDir(UNIX_DIR), errno);
+#else
+    if (!abstract && trans_mkdir(UNIX_DIR, mode) == -1) {
+	prmsg (1, "SocketUNIXCreateListener: mkdir(%s) failed, errno = %d\n",
+	       UNIX_DIR, errno);
+#endif
+	(void) umask (oldUmask);
+	return TRANS_CREATE_LISTENER_FAILED;
+    }
+#endif
+
+    memset(&sockname, 0, sizeof(sockname));
+    sockname.sun_family = AF_UNIX;
+
+    if (!(port && *port)) {
+	snprintf (tmpport, sizeof(tmpport), "%s%ld", UNIX_PATH, (long)getpid());
+	port = tmpport;
+    }
+#ifdef NX_TRANS_SOCKET
+    if (set_sun_path(port, _NXGetUnixPath(UNIX_PATH), sockname.sun_path, abstract) != 0) {
+#else
+	if (set_sun_path(port, UNIX_PATH, sockname.sun_path, abstract) != 0) {
+#endif
+	    prmsg (1, "SocketUNIXCreateListener: path too long\n");
+	    return TRANS_CREATE_LISTENER_FAILED;
+	}
+
+#if (defined(BSD44SOCKETS) || defined(__UNIXWARE__))
+    sockname.sun_len = strlen(sockname.sun_path);
+#endif
+
+#if defined(BSD44SOCKETS) || defined(SUN_LEN)
+    namelen = SUN_LEN(&sockname);
+#else
+    namelen = strlen(sockname.sun_path) + offsetof(struct sockaddr_un, sun_path);
+#endif
+
+#if defined(NX_TRANS_SOCKET) && defined(NX_TRANS_TEST)
+    fprintf(stderr, "SocketUNIXCreateListener: Unlinking path [%s] for ciptr at [%p].\n",
+                sockname.sun_path, (void *) ciptr);
+#endif
+    if (abstract) {
+	sockname.sun_path[0] = '\0';
+	namelen = offsetof(struct sockaddr_un, sun_path) + 1 + strlen(&sockname.sun_path[1]);
+    }
+    else
+	unlink (sockname.sun_path);
+
+    if ((status = TRANS(SocketCreateListener) (ciptr,
+	(struct sockaddr *) &sockname, namelen, flags)) < 0)
+    {
+	prmsg (1,
+    "SocketUNIXCreateListener: ...SocketCreateListener() failed\n");
+	(void) umask (oldUmask);
+	return status;
+    }
+
+    /*
+     * Now that the listener is esablished, create the addr info for
+     * this connection. getpeername() doesn't work for UNIX Domain Sockets
+     * on some systems (hpux at least), so we will just do it manually, instead
+     * of calling something like TRANS(SocketUNIXGetAddr).
+     */
+
+    namelen = sizeof (sockname); /* this will always make it the same size */
+
+    if ((ciptr->addr = malloc (namelen)) == NULL)
+    {
+        prmsg (1,
+        "SocketUNIXCreateListener: Can't allocate space for the addr\n");
+	(void) umask (oldUmask);
+        return TRANS_CREATE_LISTENER_FAILED;
+    }
+
+    if (abstract)
+	sockname.sun_path[0] = '@';
+
+    ciptr->family = sockname.sun_family;
+    ciptr->addrlen = namelen;
+    memcpy (ciptr->addr, &sockname, ciptr->addrlen);
+
+    (void) umask (oldUmask);
+
+    return 0;
+}
+
+
+static int
+TRANS(SocketUNIXResetListener) (XtransConnInfo ciptr)
+
+{
+    /*
+     * See if the unix domain socket has disappeared.  If it has, recreate it.
+     */
+
+    struct sockaddr_un 	*unsock = (struct sockaddr_un *) ciptr->addr;
+    struct stat		statb;
+    int 		status = TRANS_RESET_NOOP;
+    unsigned int	mode;
+    int abstract = 0;
+#ifdef HAVE_ABSTRACT_SOCKETS
+    abstract = ciptr->transptr->flags & TRANS_ABSTRACT;
+#endif
+
+    prmsg (3, "SocketUNIXResetListener(%p,%d)\n", (void *) ciptr, ciptr->fd);
+
+    if (!abstract && (
+	stat (unsock->sun_path, &statb) == -1 ||
+        ((statb.st_mode & S_IFMT) !=
+#if defined(NCR) || defined(SCO325) || !defined(S_IFSOCK)
+			S_IFIFO
+#else
+			S_IFSOCK
+#endif
+				)))
+    {
+	int oldUmask = umask (0);
+
+#ifdef UNIX_DIR
+#ifdef HAS_STICKY_DIR_BIT
+	mode = 01777;
+#else
+	mode = 0777;
+#endif
+#ifdef NX_TRANS_SOCKET
+        if (trans_mkdir(_NXGetUnixDir(UNIX_DIR), mode) == -1) {
+            prmsg (1, "SocketUNIXResetListener: mkdir(%s) failed, errno = %d\n",
+            _NXGetUnixDir(UNIX_DIR), errno);
+#else
+        if (trans_mkdir(UNIX_DIR, mode) == -1) {
+            prmsg (1, "SocketUNIXResetListener: mkdir(%s) failed, errno = %d\n",
+	    UNIX_DIR, errno);
+#endif
+	    (void) umask (oldUmask);
+	    return TRANS_RESET_FAILURE;
+        }
+#endif
+
+	close (ciptr->fd);
+	unlink (unsock->sun_path);
+
+	if ((ciptr->fd = socket (AF_UNIX, SOCK_STREAM, 0)) < 0)
+	{
+	    TRANS(FreeConnInfo) (ciptr);
+	    (void) umask (oldUmask);
+	    return TRANS_RESET_FAILURE;
+	}
+
+	if (bind (ciptr->fd, (struct sockaddr *) unsock, ciptr->addrlen) < 0)
+	{
+	    close (ciptr->fd);
+	    TRANS(FreeConnInfo) (ciptr);
+	    return TRANS_RESET_FAILURE;
+	}
+
+	if (listen (ciptr->fd, BACKLOG) < 0)
+	{
+	    close (ciptr->fd);
+	    TRANS(FreeConnInfo) (ciptr);
+	    (void) umask (oldUmask);
+	    return TRANS_RESET_FAILURE;
+	}
+
+	umask (oldUmask);
+
+	status = TRANS_RESET_NEW_FD;
+    }
+
+    return status;
+}
+
+#endif /* UNIXCONN */
+
+
+#ifdef TCPCONN
+
+static XtransConnInfo
+TRANS(SocketINETAccept) (XtransConnInfo ciptr, int *status)
+
+{
+    XtransConnInfo	newciptr;
+    struct sockaddr_in	sockname;
+    SOCKLEN_T		namelen = sizeof(sockname);
+
+    prmsg (2, "SocketINETAccept(%p,%d)\n", (void *) ciptr, ciptr->fd);
+
+    if ((newciptr = calloc (1, sizeof(struct _XtransConnInfo))) == NULL)
+    {
+	prmsg (1, "SocketINETAccept: malloc failed\n");
+	*status = TRANS_ACCEPT_BAD_MALLOC;
+	return NULL;
+    }
+
+    if ((newciptr->fd = accept (ciptr->fd,
+	(struct sockaddr *) &sockname, (void *)&namelen)) < 0)
+    {
+#ifdef WIN32
+	errno = WSAGetLastError();
+#endif
+	prmsg (1, "SocketINETAccept: accept() failed\n");
+	free (newciptr);
+	*status = TRANS_ACCEPT_FAILED;
+	return NULL;
+    }
+
+#ifdef TCP_NODELAY
+    {
+	/*
+	 * turn off TCP coalescence for INET sockets
+	 */
+
+	int tmp = 1;
+	setsockopt (newciptr->fd, IPPROTO_TCP, TCP_NODELAY,
+	    (char *) &tmp, sizeof (int));
+    }
+#endif
+
+    /*
+     * Get this address again because the transport may give a more
+     * specific address now that a connection is established.
+     */
+
+    if (TRANS(SocketINETGetAddr) (newciptr) < 0)
+    {
+	prmsg (1,
+	    "SocketINETAccept: ...SocketINETGetAddr() failed:\n");
+	close (newciptr->fd);
+	free (newciptr);
+	*status = TRANS_ACCEPT_MISC_ERROR;
+        return NULL;
+    }
+
+    if (TRANS(SocketINETGetPeerAddr) (newciptr) < 0)
+    {
+	prmsg (1,
+	  "SocketINETAccept: ...SocketINETGetPeerAddr() failed:\n");
+	close (newciptr->fd);
+	if (newciptr->addr) free (newciptr->addr);
+	free (newciptr);
+	*status = TRANS_ACCEPT_MISC_ERROR;
+        return NULL;
+    }
+
+    *status = 0;
+
+    return newciptr;
+}
+
+#endif /* TCPCONN */
+
+
+#ifdef UNIXCONN
+static XtransConnInfo
+TRANS(SocketUNIXAccept) (XtransConnInfo ciptr, int *status)
+
+{
+    XtransConnInfo	newciptr;
+    struct sockaddr_un	sockname;
+    SOCKLEN_T 		namelen = sizeof sockname;
+
+    prmsg (2, "SocketUNIXAccept(%p,%d)\n", (void *) ciptr, ciptr->fd);
+
+    if ((newciptr = calloc (1, sizeof(struct _XtransConnInfo))) == NULL)
+    {
+	prmsg (1, "SocketUNIXAccept: malloc() failed\n");
+	*status = TRANS_ACCEPT_BAD_MALLOC;
+	return NULL;
+    }
+
+    if ((newciptr->fd = accept (ciptr->fd,
+	(struct sockaddr *) &sockname, (void *)&namelen)) < 0)
+    {
+	prmsg (1, "SocketUNIXAccept: accept() failed\n");
+	free (newciptr);
+	*status = TRANS_ACCEPT_FAILED;
+	return NULL;
+    }
+
+	ciptr->addrlen = namelen;
+    /*
+     * Get the socket name and the peer name from the listener socket,
+     * since this is unix domain.
+     */
+
+    if ((newciptr->addr = malloc (ciptr->addrlen)) == NULL)
+    {
+        prmsg (1,
+        "SocketUNIXAccept: Can't allocate space for the addr\n");
+	close (newciptr->fd);
+	free (newciptr);
+	*status = TRANS_ACCEPT_BAD_MALLOC;
+        return NULL;
+    }
+
+    /*
+     * if the socket is abstract, we already modified the address to have a
+     * @ instead of the initial NUL, so no need to do that again here.
+     */
+
+    newciptr->addrlen = ciptr->addrlen;
+    memcpy (newciptr->addr, ciptr->addr, newciptr->addrlen);
+
+    if ((newciptr->peeraddr = malloc (ciptr->addrlen)) == NULL)
+    {
+        prmsg (1,
+	      "SocketUNIXAccept: Can't allocate space for the addr\n");
+	close (newciptr->fd);
+	if (newciptr->addr) free (newciptr->addr);
+	free (newciptr);
+	*status = TRANS_ACCEPT_BAD_MALLOC;
+        return NULL;
+    }
+
+    newciptr->peeraddrlen = ciptr->addrlen;
+    memcpy (newciptr->peeraddr, ciptr->addr, newciptr->addrlen);
+
+    newciptr->family = AF_UNIX;
+
+    *status = 0;
+
+    return newciptr;
+}
+
+#endif /* UNIXCONN */
+
+#endif /* TRANS_SERVER */
+
+
+#ifdef TRANS_CLIENT
+
+#ifdef TCPCONN
+
+#if defined(IPv6) && defined(AF_INET6)
+struct addrlist {
+    struct addrinfo *	addr;
+    struct addrinfo *	firstaddr;
+    char 		port[PORTBUFSIZE];
+    char 		host[MAXHOSTNAMELEN];
+};
+static struct addrlist  *addrlist = NULL;
+#endif
+
+
+static int
+TRANS(SocketINETConnect) (XtransConnInfo ciptr,
+                          const char *host, const char *port)
+
+{
+    struct sockaddr *	socketaddr = NULL;
+    int			socketaddrlen = 0;
+    int			res;
+#if defined(IPv6) && defined(AF_INET6)
+    struct addrinfo 	hints;
+    char		ntopbuf[INET6_ADDRSTRLEN];
+    int			resetonce = 0;
+#else
+    struct sockaddr_in	sockname;
+    struct hostent	*hostp;
+    struct servent	*servp;
+    unsigned long 	tmpaddr;
+#endif
+#ifdef XTHREADS_NEEDS_BYNAMEPARAMS
+    _Xgethostbynameparams hparams;
+    _Xgetservbynameparams sparams;
+#endif
+#ifdef X11_t
+    char	portbuf[PORTBUFSIZE];
+#endif
+
+    char 		hostnamebuf[256];		/* tmp space */
+
+    prmsg (2,"SocketINETConnect(%d,%s,%s)\n", ciptr->fd, host, port);
+
+    if (!host)
+    {
+	hostnamebuf[0] = '\0';
+	(void) TRANS(GetHostname) (hostnamebuf, sizeof hostnamebuf);
+	host = hostnamebuf;
+    }
+
+#ifdef X11_t
+    /*
+     * X has a well known port, that is transport dependent. It is easier
+     * to handle it here, than try and come up with a transport independent
+     * representation that can be passed in and resolved the usual way.
+     *
+     * The port that is passed here is really a string containing the idisplay
+     * from ConnectDisplay().
+     */
+
+    if (is_numeric (port))
+    {
+	long tmpport = X_TCP_PORT + strtol (port, (char**)NULL, 10);
+	snprintf (portbuf, sizeof(portbuf), "%lu", tmpport);
+	port = portbuf;
+    }
+#endif
+
+#if defined(IPv6) && defined(AF_INET6)
+    {
+	if (addrlist != NULL) {
+	    if (strcmp(host,addrlist->host) || strcmp(port,addrlist->port)) {
+		if (addrlist->firstaddr)
+		    freeaddrinfo(addrlist->firstaddr);
+		addrlist->firstaddr = NULL;
+	    }
+	} else {
+	    addrlist = malloc(sizeof(struct addrlist));
+	    addrlist->firstaddr = NULL;
+	}
+
+	if (addrlist->firstaddr == NULL) {
+	    strncpy(addrlist->port, port, sizeof(addrlist->port));
+	    addrlist->port[sizeof(addrlist->port) - 1] = '\0';
+	    strncpy(addrlist->host, host, sizeof(addrlist->host));
+	    addrlist->host[sizeof(addrlist->host) - 1] = '\0';
+
+	    bzero(&hints,sizeof(hints));
+	    hints.ai_socktype = Sockettrans2devtab[ciptr->index].devcotsname;
+
+	    res = getaddrinfo(host,port,&hints,&addrlist->firstaddr);
+	    if (res != 0) {
+		prmsg (1, "SocketINETConnect() can't get address "
+			"for %s:%s: %s\n", host, port, gai_strerror(res));
+		ESET(EINVAL);
+		return TRANS_CONNECT_FAILED;
+	    }
+	    for (res = 0, addrlist->addr = addrlist->firstaddr;
+		 addrlist->addr ; res++) {
+		addrlist->addr = addrlist->addr->ai_next;
+	    }
+	    prmsg(4,"Got New Address list with %d addresses\n", res);
+	    res = 0;
+	    addrlist->addr = NULL;
+	}
+
+	while (socketaddr == NULL) {
+	    if (addrlist->addr == NULL) {
+		if (resetonce) {
+		    /* Already checked entire list - no usable addresses */
+		    prmsg (1, "SocketINETConnect() no usable address "
+			   "for %s:%s\n", host, port);
+		    return TRANS_CONNECT_FAILED;
+		} else {
+		    /* Go back to beginning of list */
+		    resetonce = 1;
+		    addrlist->addr = addrlist->firstaddr;
+		}
+	    }
+
+	    socketaddr = addrlist->addr->ai_addr;
+	    socketaddrlen = addrlist->addr->ai_addrlen;
+
+	    if (addrlist->addr->ai_family == AF_INET) {
+		struct sockaddr_in *sin = (struct sockaddr_in *) socketaddr;
+
+		prmsg (4,"SocketINETConnect() sockname.sin_addr = %s\n",
+			inet_ntop(addrlist->addr->ai_family,&sin->sin_addr,
+			ntopbuf,sizeof(ntopbuf)));
+
+		prmsg (4,"SocketINETConnect() sockname.sin_port = %d\n",
+			ntohs(sin->sin_port));
+
+		if (Sockettrans2devtab[ciptr->index].family == AF_INET6) {
+		    if (strcmp(Sockettrans2devtab[ciptr->index].transname,
+				"tcp") == 0) {
+			XtransConnInfo newciptr;
+
+			/*
+			 * Our socket is an IPv6 socket, but the address is
+			 * IPv4.  Close it and get an IPv4 socket.  This is
+			 * needed for IPv4 connections to work on platforms
+			 * that don't allow IPv4 over IPv6 sockets.
+			 */
+			TRANS(SocketINETClose)(ciptr);
+			newciptr = TRANS(SocketOpenCOTSClientBase)(
+					"tcp", "tcp", host, port, ciptr->index);
+			if (newciptr)
+			    ciptr->fd = newciptr->fd;
+			if (!newciptr ||
+			    Sockettrans2devtab[newciptr->index].family !=
+				AF_INET) {
+			    socketaddr = NULL;
+			    prmsg (4,"SocketINETConnect() Cannot get IPv4 "
+					" socketfor IPv4 address\n");
+			}
+			if (newciptr)
+			    free(newciptr);
+		    } else {
+			socketaddr = NULL;
+			prmsg (4,"SocketINETConnect Skipping IPv4 address\n");
+		    }
+		}
+	    } else if (addrlist->addr->ai_family == AF_INET6) {
+		struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *) socketaddr;
+
+		prmsg (4,"SocketINETConnect() sockname.sin6_addr = %s\n",
+			inet_ntop(addrlist->addr->ai_family,
+				  &sin6->sin6_addr,ntopbuf,sizeof(ntopbuf)));
+		prmsg (4,"SocketINETConnect() sockname.sin6_port = %d\n",
+			ntohs(sin6->sin6_port));
+
+		if (Sockettrans2devtab[ciptr->index].family == AF_INET) {
+		    if (strcmp(Sockettrans2devtab[ciptr->index].transname,
+				"tcp") == 0) {
+			XtransConnInfo newciptr;
+
+			/*
+			 * Close the IPv4 socket and try to open an IPv6 socket.
+			 */
+			TRANS(SocketINETClose)(ciptr);
+			newciptr = TRANS(SocketOpenCOTSClientBase)(
+					"tcp", "tcp", host, port, -1);
+			if (newciptr)
+			    ciptr->fd = newciptr->fd;
+			if (!newciptr ||
+			    Sockettrans2devtab[newciptr->index].family !=
+					AF_INET6) {
+			    socketaddr = NULL;
+			    prmsg (4,"SocketINETConnect() Cannot get IPv6 "
+				   "socket for IPv6 address\n");
+			}
+			if (newciptr)
+			    free(newciptr);
+		    }
+		    else
+		    {
+			socketaddr = NULL;
+			prmsg (4,"SocketINETConnect() Skipping IPv6 address\n");
+		    }
+		}
+	    } else {
+		socketaddr = NULL; /* Unsupported address type */
+	    }
+	    if (socketaddr == NULL) {
+		addrlist->addr = addrlist->addr->ai_next;
+	    }
+	}
+    }
+#else
+    {
+	/*
+	 * Build the socket name.
+	 */
+
+#ifdef BSD44SOCKETS
+	sockname.sin_len = sizeof (struct sockaddr_in);
+#endif
+	sockname.sin_family = AF_INET;
+
+	/*
+	 * fill in sin_addr
+	 */
+
+#ifndef INADDR_NONE
+#define INADDR_NONE ((in_addr_t) 0xffffffff)
+#endif
+
+	/* check for ww.xx.yy.zz host string */
+
+	if (isascii (host[0]) && isdigit (host[0])) {
+	    tmpaddr = inet_addr (host); /* returns network byte order */
+	} else {
+	    tmpaddr = INADDR_NONE;
+	}
+
+	prmsg (4,"SocketINETConnect() inet_addr(%s) = %x\n", host, tmpaddr);
+
+	if (tmpaddr == INADDR_NONE) {
+	    if ((hostp = _XGethostbyname(host,hparams)) == NULL) {
+		prmsg (1,"SocketINETConnect: Can't get address for %s\n",
+			host);
+		ESET(EINVAL);
+		return TRANS_CONNECT_FAILED;
+	    }
+	    if (hostp->h_addrtype != AF_INET) {  /* is IP host? */
+		prmsg (1,"SocketINETConnect: not INET host%s\n", host);
+		ESET(EPROTOTYPE);
+		return TRANS_CONNECT_FAILED;
+	    }
+
+	    memcpy ((char *) &sockname.sin_addr, (char *) hostp->h_addr,
+		    sizeof (sockname.sin_addr));
+
+	} else {
+	    sockname.sin_addr.s_addr = tmpaddr;
+        }
+
+	/*
+	 * fill in sin_port
+	 */
+
+	/* Check for number in the port string */
+
+	if (!is_numeric (port)) {
+	    if ((servp = _XGetservbyname (port,"tcp",sparams)) == NULL) {
+		prmsg (1,"SocketINETConnect: can't get service for %s\n",
+			port);
+		return TRANS_CONNECT_FAILED;
+	    }
+	    sockname.sin_port = htons (servp->s_port);
+	} else {
+	    long tmpport = strtol (port, (char**)NULL, 10);
+	    if (tmpport < 1024 || tmpport > USHRT_MAX)
+		return TRANS_CONNECT_FAILED;
+	    sockname.sin_port = htons (((unsigned short) tmpport));
+	}
+
+	prmsg (4,"SocketINETConnect: sockname.sin_port = %d\n",
+		ntohs(sockname.sin_port));
+	socketaddr = (struct sockaddr *) &sockname;
+	socketaddrlen = sizeof(sockname);
+    }
+#endif
+
+    /*
+     * Turn on socket keepalive so the client process will eventually
+     * be notified with a SIGPIPE signal if the display server fails
+     * to respond to a periodic transmission of messages
+     * on the connected socket.
+     * This is useful to avoid hung application processes when the
+     * processes are not spawned from the xdm session and
+     * the display server terminates abnormally.
+     * (Someone turned off the power switch.)
+     */
+
+    {
+	int tmp = 1;
+	setsockopt (ciptr->fd, SOL_SOCKET, SO_KEEPALIVE,
+		(char *) &tmp, sizeof (int));
+    }
+
+    /*
+     * Do the connect()
+     */
+
+    if (connect (ciptr->fd, socketaddr, socketaddrlen ) < 0)
+    {
+#ifdef WIN32
+	int olderrno = WSAGetLastError();
+#else
+	int olderrno = errno;
+#endif
+
+	/*
+	 * If the error was ECONNREFUSED, the server may be overloaded
+	 * and we should try again.
+	 *
+	 * If the error was EWOULDBLOCK or EINPROGRESS then the socket
+	 * was non-blocking and we should poll using select
+	 *
+	 * If the error was EINTR, the connect was interrupted and we
+	 * should try again.
+	 *
+	 * If multiple addresses are found for a host then we should
+	 * try to connect again with a different address for a larger
+	 * number of errors that made us quit before, since those
+	 * could be caused by trying to use an IPv6 address to contact
+	 * a machine with an IPv4-only server or other reasons that
+	 * only affect one of a set of addresses.
+	 */
+
+	if (olderrno == ECONNREFUSED || olderrno == EINTR
+#if defined(IPv6) && defined(AF_INET6)
+	  || (((addrlist->addr->ai_next != NULL) ||
+	        (addrlist->addr != addrlist->firstaddr)) &&
+               (olderrno == ENETUNREACH || olderrno == EAFNOSUPPORT ||
+		 olderrno == EADDRNOTAVAIL || olderrno == ETIMEDOUT
+#if defined(EHOSTDOWN)
+		   || olderrno == EHOSTDOWN
+#endif
+	       ))
+#endif
+	    )
+	    res = TRANS_TRY_CONNECT_AGAIN;
+	else if (olderrno == EWOULDBLOCK || olderrno == EINPROGRESS)
+	    res = TRANS_IN_PROGRESS;
+	else
+	{
+	    prmsg (2,"SocketINETConnect: Can't connect: errno = %d\n",
+		   olderrno);
+
+	    res = TRANS_CONNECT_FAILED;
+	}
+    } else {
+	res = 0;
+
+
+	/*
+	 * Sync up the address fields of ciptr.
+	 */
+
+	if (TRANS(SocketINETGetAddr) (ciptr) < 0)
+	{
+	    prmsg (1,
+	     "SocketINETConnect: ...SocketINETGetAddr() failed:\n");
+	    res = TRANS_CONNECT_FAILED;
+	}
+
+	else if (TRANS(SocketINETGetPeerAddr) (ciptr) < 0)
+	{
+	    prmsg (1,
+	      "SocketINETConnect: ...SocketINETGetPeerAddr() failed:\n");
+	    res = TRANS_CONNECT_FAILED;
+	}
+    }
+
+#if defined(IPv6) && defined(AF_INET6)
+   if (res != 0) {
+	addrlist->addr = addrlist->addr->ai_next;
+   }
+#endif
+
+    return res;
+}
+
+#endif /* TCPCONN */
+
+
+
+#ifdef UNIXCONN
+
+/*
+ * Make sure 'host' is really local.
+ */
+
+static int
+UnixHostReallyLocal (const char *host)
+
+{
+    char hostnamebuf[256];
+
+    TRANS(GetHostname) (hostnamebuf, sizeof (hostnamebuf));
+
+    if (strcmp (hostnamebuf, host) == 0)
+    {
+	return (1);
+    } else {
+#if defined(IPv6) && defined(AF_INET6)
+	struct addrinfo *localhostaddr;
+	struct addrinfo *otherhostaddr;
+	struct addrinfo *i, *j;
+	int equiv = 0;
+
+	if (getaddrinfo(hostnamebuf, NULL, NULL, &localhostaddr) != 0)
+	    return 0;
+	if (getaddrinfo(host, NULL, NULL, &otherhostaddr) != 0) {
+	    freeaddrinfo(localhostaddr);
+	    return 0;
+	}
+
+	for (i = localhostaddr; i != NULL && equiv == 0; i = i->ai_next) {
+	    for (j = otherhostaddr; j != NULL && equiv == 0; j = j->ai_next) {
+		if (i->ai_family == j->ai_family) {
+		    if (i->ai_family == AF_INET) {
+			struct sockaddr_in *sinA
+			  = (struct sockaddr_in *) i->ai_addr;
+			struct sockaddr_in *sinB
+			  = (struct sockaddr_in *) j->ai_addr;
+			struct in_addr *A = &sinA->sin_addr;
+			struct in_addr *B = &sinB->sin_addr;
+
+			if (memcmp(A,B,sizeof(struct in_addr)) == 0) {
+			    equiv = 1;
+			}
+		    } else if (i->ai_family == AF_INET6) {
+			struct sockaddr_in6 *sinA
+			  = (struct sockaddr_in6 *) i->ai_addr;
+			struct sockaddr_in6 *sinB
+			  = (struct sockaddr_in6 *) j->ai_addr;
+			struct in6_addr *A = &sinA->sin6_addr;
+			struct in6_addr *B = &sinB->sin6_addr;
+
+			if (memcmp(A,B,sizeof(struct in6_addr)) == 0) {
+			    equiv = 1;
+			}
+		    }
+		}
+	    }
+	}
+
+	freeaddrinfo(localhostaddr);
+	freeaddrinfo(otherhostaddr);
+	return equiv;
+#else
+	/*
+	 * A host may have more than one network address.  If any of the
+	 * network addresses of 'host' (specified to the connect call)
+	 * match any of the network addresses of 'hostname' (determined
+	 * by TRANS(GetHostname)), then the two hostnames are equivalent,
+	 * and we know that 'host' is really a local host.
+	 */
+	char specified_local_addr_list[10][4];
+	int scount, equiv, i, j;
+#ifdef XTHREADS_NEEDS_BYNAMEPARAMS
+	_Xgethostbynameparams hparams;
+#endif
+	struct hostent *hostp;
+
+	if ((hostp = _XGethostbyname (host,hparams)) == NULL)
+	    return (0);
+
+	scount = 0;
+	while (hostp->h_addr_list[scount] && scount <= 8)
+	{
+	    /*
+	     * The 2nd call to gethostname() overrides the data
+	     * from the 1st call, so we must save the address list.
+	     */
+
+	    specified_local_addr_list[scount][0] =
+				hostp->h_addr_list[scount][0];
+	    specified_local_addr_list[scount][1] =
+				hostp->h_addr_list[scount][1];
+	    specified_local_addr_list[scount][2] =
+				hostp->h_addr_list[scount][2];
+	    specified_local_addr_list[scount][3] =
+				hostp->h_addr_list[scount][3];
+	    scount++;
+	}
+	if ((hostp = _XGethostbyname (hostnamebuf,hparams)) == NULL)
+	    return (0);
+
+	equiv = 0;
+	i = 0;
+
+	while (i < scount && !equiv)
+	{
+	    j = 0;
+
+	    while (hostp->h_addr_list[j])
+	    {
+		if ((specified_local_addr_list[i][0] ==
+					hostp->h_addr_list[j][0]) &&
+		    (specified_local_addr_list[i][1] ==
+					hostp->h_addr_list[j][1]) &&
+		    (specified_local_addr_list[i][2] ==
+					hostp->h_addr_list[j][2]) &&
+		    (specified_local_addr_list[i][3] ==
+					hostp->h_addr_list[j][3]))
+		{
+		    /* They're equal, so we're done */
+
+		    equiv = 1;
+		    break;
+		}
+
+		j++;
+	    }
+
+	    i++;
+	}
+	return (equiv);
+#endif
+    }
+}
+
+static int
+TRANS(SocketUNIXConnect) (XtransConnInfo ciptr,
+                          const char *host, const char *port)
+
+{
+    struct sockaddr_un	sockname;
+    SOCKLEN_T		namelen;
+
+
+    int abstract = 0;
+#ifdef HAVE_ABSTRACT_SOCKETS
+    abstract = ciptr->transptr->flags & TRANS_ABSTRACT;
+#endif
+
+    prmsg (2,"SocketUNIXConnect(%d,%s,%s)\n", ciptr->fd, host, port);
+
+    /*
+     * Make sure 'host' is really local.  If not, we return failure.
+     * The reason we make this check is because a process may advertise
+     * a "local" network ID for which it can accept connections, but if
+     * a process on a remote machine tries to connect to this network ID,
+     * we know for sure it will fail.
+     */
+
+#if defined(NX_TRANS_SOCKET) && defined(TRANS_CLIENT)
+    if (host && *host && host[0]!='/' && strcmp(host, "unix") != 0 && strcasecmp(host, "nx") != 0 &&
+            strncasecmp(host, "nx,", 3) != 0 && !UnixHostReallyLocal (host))
+#else
+    if (host && *host && host[0]!='/' && strcmp (host, "unix") != 0 && !UnixHostReallyLocal (host))
+#endif
+    {
+	prmsg (1,
+	   "SocketUNIXConnect: Cannot connect to non-local host %s\n",
+	       host);
+	return TRANS_CONNECT_FAILED;
+    }
+
+
+    /*
+     * Check the port.
+     */
+
+    if (!port || !*port)
+    {
+	prmsg (1,"SocketUNIXConnect: Missing port specification\n");
+	return TRANS_CONNECT_FAILED;
+    }
+
+    /*
+     * Build the socket name.
+     */
+
+    sockname.sun_family = AF_UNIX;
+
+#ifdef NX_TRANS_SOCKET
+    if (set_sun_path(port, _NXGetUnixPath(UNIX_PATH), sockname.sun_path, abstract) != 0) {
+#else
+    if (set_sun_path(port, UNIX_PATH, sockname.sun_path, abstract) != 0) {
+#endif
+	prmsg (1, "SocketUNIXConnect: path too long\n");
+	return TRANS_CONNECT_FAILED;
+    }
+
+#if (defined(BSD44SOCKETS) || defined(__UNIXWARE__))
+    sockname.sun_len = strlen (sockname.sun_path);
+#endif
+
+#if defined(BSD44SOCKETS) || defined(SUN_LEN)
+    namelen = SUN_LEN (&sockname);
+#else
+    namelen = strlen (sockname.sun_path) + offsetof(struct sockaddr_un, sun_path);
+#endif
+
+
+
+#if defined(NX_TRANS_SOCKET) && defined(TRANS_CLIENT)
+
+    if (ciptr->priv != NULL)
+    {
+        if (TRANS(SocketConnectConnInfo) (ciptr, host, port) != 0)
+        {
+            return TRANS_CONNECT_FAILED;
+        }
+
+        goto SocketUNIXConnectPost;
+    }
+
+#endif
+
+    /*
+     * Adjust the socket path if using abstract sockets.
+     * Done here because otherwise all the strlen() calls above would fail.
+     */
+
+    if (abstract) {
+	sockname.sun_path[0] = '\0';
+    }
+
+    /*
+     * Do the connect()
+     */
+
+    if (connect (ciptr->fd, (struct sockaddr *) &sockname, namelen) < 0)
+    {
+	int olderrno = errno;
+	int connected = 0;
+
+	if (!connected)
+	{
+	    errno = olderrno;
+
+	    /*
+	     * If the error was ENOENT, the server may be starting up; we used
+	     * to suggest to try again in this case with
+	     * TRANS_TRY_CONNECT_AGAIN, but this introduced problems for
+	     * processes still referencing stale sockets in their environment.
+	     * Hence, we now return a hard error, TRANS_CONNECT_FAILED, and it
+	     * is suggested that higher level stacks handle retries on their
+	     * level when they face a slow starting server.
+	     *
+	     * If the error was EWOULDBLOCK or EINPROGRESS then the socket
+	     * was non-blocking and we should poll using select
+	     *
+	     * If the error was EINTR, the connect was interrupted and we
+	     * should try again.
+	     */
+
+	    if (olderrno == EWOULDBLOCK || olderrno == EINPROGRESS)
+		return TRANS_IN_PROGRESS;
+	    else if (olderrno == EINTR)
+		return TRANS_TRY_CONNECT_AGAIN;
+	    else if (olderrno == ENOENT || olderrno == ECONNREFUSED) {
+		/* If opening as abstract socket failed, try again normally */
+		if (abstract) {
+		    ciptr->transptr->flags &= ~(TRANS_ABSTRACT);
+		    return TRANS_TRY_CONNECT_AGAIN;
+		} else {
+		    return TRANS_CONNECT_FAILED;
+		}
+	    } else {
+		prmsg (2,"SocketUNIXConnect: Can't connect: errno = %d\n",
+		       EGET());
+
+		return TRANS_CONNECT_FAILED;
+	    }
+	}
+    }
+
+#if defined(NX_TRANS_SOCKET) && defined(TRANS_CLIENT)
+
+SocketUNIXConnectPost:
+
+#endif
+
+    /*
+     * Get the socket name and the peer name from the connect socket,
+     * since this is unix domain.
+     */
+
+    if ((ciptr->addr = malloc(namelen)) == NULL ||
+       (ciptr->peeraddr = malloc(namelen)) == NULL)
+    {
+        prmsg (1,
+	"SocketUNIXCreateListener: Can't allocate space for the addr\n");
+        return TRANS_CONNECT_FAILED;
+    }
+
+    if (abstract)
+	sockname.sun_path[0] = '@';
+
+    ciptr->family = AF_UNIX;
+    ciptr->addrlen = namelen;
+    ciptr->peeraddrlen = namelen;
+    memcpy (ciptr->addr, &sockname, ciptr->addrlen);
+    memcpy (ciptr->peeraddr, &sockname, ciptr->peeraddrlen);
+
+    return 0;
+}
+
+#endif /* UNIXCONN */
+
+#endif /* TRANS_CLIENT */
+
+
+static int
+TRANS(SocketBytesReadable) (XtransConnInfo ciptr, BytesReadable_t *pend)
+
+{
+    prmsg (2,"SocketBytesReadable(%p,%d,%p)\n",
+	(void *) ciptr, ciptr->fd, (void *) pend);
+
+#if defined(NX_TRANS_SOCKET) && defined(TRANS_CLIENT)
+
+    if (ciptr->priv)
+    {
+        if (NXTransRunning(ciptr->fd) == 0)
+        {
+            /*
+             * Force the application to shut down the
+             * socket if the NX transport is gone. We
+             * may probably save this additional call.
+             */
+
+#ifdef NX_TRANS_DEBUG
+            fprintf(stderr, "SocketBytesReadable: NX transport not running for descriptor [%d].\n",
+                        ciptr->fd);
+#endif
+            ESET(EPIPE);
+
+            return -1;
+        }
+        else
+        {
+            /*
+             * Emulate BytesReadable. Some X applications may use the system
+             * select() in their main loop, instead of the _XSelect() that is
+             * replaced by NX. Still these applications use _XEventsQueued to
+             * poll events from the X connection, and _XEventsQueued uses the
+             * NX _XSelect(), so it is generally possible to let the client
+             * yield the control to NX and let it handle the I/O on the proxy
+             * descriptors even if the application is not explicitly designed
+             * to work as a NX agent.
+             */
+
+#ifdef NX_TRANS_DEBUG
+
+            int result;
+
+            result = NXTransReadable(ciptr->fd, (int *) pend);
+
+            fprintf(stderr, "SocketBytesReadable: Descriptor [%d] result [%d] readable [%ld].\n",
+                        ciptr->fd, result, *pend);
+
+            return result;
+#else
+            return NXTransReadable(ciptr->fd, (int *) pend);
+#endif
+        }
+    }
+
+#endif /* #if defined(NX_TRANS_SOCKET) && defined(TRANS_CLIENT) */
+
+#ifdef WIN32
+    {
+	int ret = ioctlsocket ((SOCKET) ciptr->fd, FIONREAD, (u_long *) pend);
+	if (ret == SOCKET_ERROR) errno = WSAGetLastError();
+	return ret;
+    }
+#else
+    return ioctl (ciptr->fd, FIONREAD, (char *) pend);
+#endif /* WIN32 */
+}
+
+#if XTRANS_SEND_FDS
+
+static void
+appendFd(struct _XtransConnFd **prev, int fd, int do_close)
+{
+    struct _XtransConnFd *cf, *new;
+
+    new = malloc (sizeof (struct _XtransConnFd));
+    if (!new) {
+        /* XXX mark connection as broken */
+        close(fd);
+        return;
+    }
+    new->next = 0;
+    new->fd = fd;
+    new->do_close = do_close;
+    /* search to end of list */
+    for (; (cf = *prev); prev = &(cf->next));
+    *prev = new;
+}
+
+static int
+removeFd(struct _XtransConnFd **prev)
+{
+    struct _XtransConnFd *cf;
+    int fd;
+
+    if ((cf = *prev)) {
+        *prev = cf->next;
+        fd = cf->fd;
+        free(cf);
+    } else
+        fd = -1;
+    return fd;
+}
+
+static void
+discardFd(struct _XtransConnFd **prev, struct _XtransConnFd *upto, int do_close)
+{
+    struct _XtransConnFd *cf, *next;
+
+    for (cf = *prev; cf != upto; cf = next) {
+        next = cf->next;
+        if (do_close || cf->do_close)
+            close(cf->fd);
+        free(cf);
+    }
+    *prev = upto;
+}
+
+static void
+cleanupFds(XtransConnInfo ciptr)
+{
+    /* Clean up the send list but don't close the fds */
+    discardFd(&ciptr->send_fds, NULL, 0);
+    /* Clean up the recv list and *do* close the fds */
+    discardFd(&ciptr->recv_fds, NULL, 1);
+}
+
+static int
+nFd(struct _XtransConnFd **prev)
+{
+    struct _XtransConnFd *cf;
+    int n = 0;
+
+    for (cf = *prev; cf; cf = cf->next)
+        n++;
+    return n;
+}
+
+static int
+TRANS(SocketRecvFd) (XtransConnInfo ciptr)
+{
+    prmsg (2, "SocketRecvFd(%d)\n", ciptr->fd);
+    return removeFd(&ciptr->recv_fds);
+}
+
+static int
+TRANS(SocketSendFd) (XtransConnInfo ciptr, int fd, int do_close)
+{
+    appendFd(&ciptr->send_fds, fd, do_close);
+    return 0;
+}
+
+static int
+TRANS(SocketRecvFdInvalid)(XtransConnInfo ciptr)
+{
+    errno = EINVAL;
+    return -1;
+}
+
+static int
+TRANS(SocketSendFdInvalid)(XtransConnInfo ciptr, int fd, int do_close)
+{
+    errno = EINVAL;
+    return -1;
+}
+
+#define MAX_FDS		128
+
+union fd_pass {
+	struct cmsghdr	cmsghdr;
+	char		buf[CMSG_SPACE(MAX_FDS * sizeof(int))];
+};
+
+#endif /* XTRANS_SEND_FDS */
+
+static int
+TRANS(SocketRead) (XtransConnInfo ciptr, char *buf, int size)
+
+{
+    prmsg (2,"SocketRead(%d,%p,%d)\n", ciptr->fd, (void *) buf, size);
+
+#if defined(NX_TRANS_SOCKET) && defined(TRANS_CLIENT)
+
+    /*
+     * If we have a valid priv pointer then this
+     * is an internal connection to the proxy.
+     * In this case we should emulate the read.
+     */
+
+    if (ciptr->priv)
+    {
+        int result;
+
+        result = NXTransRead(ciptr->fd, buf, size);
+
+#ifdef NX_TRANS_DEBUG
+        if (result < 0 && EGET() == EAGAIN)
+        {
+            fprintf(stderr, "SocketRead: Read from descriptor [%d] would block.\n",
+                     ciptr->fd);
+        }
+        else
+        {
+            fprintf(stderr, "SocketRead: Read [%d] bytes from descriptor [%d].\n",
+                     result, ciptr->fd);
+        }
+#endif
+        return result;
+    }
+    else
+    {
+    /* FIXME: same code as below, should be possible without duplication */
+#if XTRANS_SEND_FDS
+        struct iovec    iov = {
+            .iov_base = buf,
+            .iov_len = size
+        };
+        union fd_pass   cmsgbuf;
+        struct msghdr   msg = {
+            .msg_name = NULL,
+            .msg_namelen = 0,
+            .msg_iov = &iov,
+            .msg_iovlen = 1,
+            .msg_control = cmsgbuf.buf,
+            .msg_controllen = CMSG_LEN(MAX_FDS * sizeof(int))
+        };
+
+        size = recvmsg(ciptr->fd, &msg, 0);
+        if (size >= 0) {
+            struct cmsghdr *hdr;
+
+            for (hdr = CMSG_FIRSTHDR(&msg); hdr; hdr = CMSG_NXTHDR(&msg, hdr)) {
+                if (hdr->cmsg_level == SOL_SOCKET && hdr->cmsg_type == SCM_RIGHTS) {
+                    int nfd = (hdr->cmsg_len - CMSG_LEN(0)) / sizeof (int);
+                    int i;
+                    int *fd = (int *) CMSG_DATA(hdr);
+
+                    for (i = 0; i < nfd; i++)
+                        appendFd(&ciptr->recv_fds, fd[i], 0);
+                }
+            }
+        }
+        return size;
+#else
+        return read (ciptr->fd, buf, size);
+#endif /* XTRANS_SEND_FDS */
+    }
+
+#else /* #if defined(NX_TRANS_SOCKET) && defined(TRANS_CLIENT) */
+
+#if defined(WIN32)
+    {
+	int ret = recv ((SOCKET)ciptr->fd, buf, size, 0);
+#ifdef WIN32
+	if (ret == SOCKET_ERROR) errno = WSAGetLastError();
+#endif
+	return ret;
+    }
+#else
+#if XTRANS_SEND_FDS
+    {
+        struct iovec    iov = {
+            .iov_base = buf,
+            .iov_len = size
+        };
+        union fd_pass   cmsgbuf;
+        struct msghdr   msg = {
+            .msg_name = NULL,
+            .msg_namelen = 0,
+            .msg_iov = &iov,
+            .msg_iovlen = 1,
+            .msg_control = cmsgbuf.buf,
+            .msg_controllen = CMSG_LEN(MAX_FDS * sizeof(int))
+        };
+
+        size = recvmsg(ciptr->fd, &msg, 0);
+        if (size >= 0) {
+            struct cmsghdr *hdr;
+
+            for (hdr = CMSG_FIRSTHDR(&msg); hdr; hdr = CMSG_NXTHDR(&msg, hdr)) {
+                if (hdr->cmsg_level == SOL_SOCKET && hdr->cmsg_type == SCM_RIGHTS) {
+                    int nfd = (hdr->cmsg_len - CMSG_LEN(0)) / sizeof (int);
+                    int i;
+                    int *fd = (int *) CMSG_DATA(hdr);
+
+                    for (i = 0; i < nfd; i++)
+                        appendFd(&ciptr->recv_fds, fd[i], 0);
+                }
+            }
+        }
+        return size;
+    }
+#else
+    return read (ciptr->fd, buf, size);
+#endif /* XTRANS_SEND_FDS */
+#endif /* WIN32 */
+
+#endif /* #if defined(NX_TRANS_SOCKET) && defined(TRANS_CLIENT) */
+}
+
+static int
+TRANS(SocketReadv) (XtransConnInfo ciptr, struct iovec *buf, int size)
+
+{
+    prmsg (2,"SocketReadv(%d,%p,%d)\n", ciptr->fd, (void *) buf, size);
+
+#if defined(NX_TRANS_SOCKET) && defined(TRANS_CLIENT)
+
+    /*
+     * If we have a valid priv pointer then this
+     * is an internal connection to the proxy.
+     * In this case we should emulate the readv.
+     */
+
+    if (ciptr->priv)
+    {
+        return NXTransReadVector(ciptr->fd, buf, size);
+    }
+    else
+    {
+    /* FIXME: same code as below, should be possible without duplication */
+#if XTRANS_SEND_FDS
+        union fd_pass   cmsgbuf;
+        struct msghdr   msg = {
+            .msg_name = NULL,
+            .msg_namelen = 0,
+            .msg_iov = buf,
+            .msg_iovlen = size,
+            .msg_control = cmsgbuf.buf,
+            .msg_controllen = CMSG_LEN(MAX_FDS * sizeof(int))
+        };
+
+        size = recvmsg(ciptr->fd, &msg, 0);
+        if (size >= 0) {
+            struct cmsghdr *hdr;
+
+            for (hdr = CMSG_FIRSTHDR(&msg); hdr; hdr = CMSG_NXTHDR(&msg, hdr)) {
+                if (hdr->cmsg_level == SOL_SOCKET && hdr->cmsg_type == SCM_RIGHTS) {
+                    int nfd = (hdr->cmsg_len - CMSG_LEN(0)) / sizeof (int);
+                    int i;
+                    int *fd = (int *) CMSG_DATA(hdr);
+
+                    for (i = 0; i < nfd; i++)
+                        appendFd(&ciptr->recv_fds, fd[i], 0);
+                }
+            }
+        }
+        return size;
+#else
+        return READV (ciptr, buf, size);
+#endif
+    }
+
+#else /* #if defined(NX_TRANS_SOCKET) && defined(TRANS_CLIENT) */
+
+#if XTRANS_SEND_FDS
+    {
+        union fd_pass   cmsgbuf;
+        struct msghdr   msg = {
+            .msg_name = NULL,
+            .msg_namelen = 0,
+            .msg_iov = buf,
+            .msg_iovlen = size,
+            .msg_control = cmsgbuf.buf,
+            .msg_controllen = CMSG_LEN(MAX_FDS * sizeof(int))
+        };
+
+        size = recvmsg(ciptr->fd, &msg, 0);
+        if (size >= 0) {
+            struct cmsghdr *hdr;
+
+            for (hdr = CMSG_FIRSTHDR(&msg); hdr; hdr = CMSG_NXTHDR(&msg, hdr)) {
+                if (hdr->cmsg_level == SOL_SOCKET && hdr->cmsg_type == SCM_RIGHTS) {
+                    int nfd = (hdr->cmsg_len - CMSG_LEN(0)) / sizeof (int);
+                    int i;
+                    int *fd = (int *) CMSG_DATA(hdr);
+
+                    for (i = 0; i < nfd; i++)
+                        appendFd(&ciptr->recv_fds, fd[i], 0);
+                }
+            }
+        }
+        return size;
+    }
+#else
+    return READV (ciptr, buf, size);
+#endif
+
+#endif /* #if defined(NX_TRANS_SOCKET) && defined(TRANS_CLIENT) */
+}
+
+
+static int
+TRANS(SocketWritev) (XtransConnInfo ciptr, struct iovec *buf, int size)
+
+{
+    prmsg (2,"SocketWritev(%d,%p,%d)\n", ciptr->fd, (void *) buf, size);
+
+#if defined(NX_TRANS_SOCKET) && defined(TRANS_CLIENT)
+
+    /*
+     * If we have a valid priv pointer then this
+     * is an internal connection to the proxy.
+     * In this case we should emulate the writev.
+     */
+
+    if (ciptr->priv)
+    {
+        return NXTransWriteVector(ciptr->fd, buf, size);
+    }
+    else
+    {
+    /* FIXME: same code as below, should be possible without duplication */
+#if XTRANS_SEND_FDS
+    if (ciptr->send_fds)
+    {
+        union fd_pass           cmsgbuf;
+        int                     nfd = nFd(&ciptr->send_fds);
+        struct _XtransConnFd    *cf = ciptr->send_fds;
+        struct msghdr           msg = {
+            .msg_name = NULL,
+            .msg_namelen = 0,
+            .msg_iov = buf,
+            .msg_iovlen = size,
+            .msg_control = cmsgbuf.buf,
+            .msg_controllen = CMSG_LEN(nfd * sizeof(int))
+        };
+        struct cmsghdr          *hdr = CMSG_FIRSTHDR(&msg);
+        int                     i;
+        int                     *fds;
+
+        hdr->cmsg_len = msg.msg_controllen;
+        hdr->cmsg_level = SOL_SOCKET;
+        hdr->cmsg_type = SCM_RIGHTS;
+
+        fds = (int *) CMSG_DATA(hdr);
+        /* Set up fds */
+        for (i = 0; i < nfd; i++) {
+            fds[i] = cf->fd;
+            cf = cf->next;
+        }
+
+        i = sendmsg(ciptr->fd, &msg, 0);
+        if (i > 0)
+            discardFd(&ciptr->send_fds, cf, 0);
+        return i;
+    }
+#endif
+        return WRITEV (ciptr, buf, size);
+    }
+
+#else /* #if defined(NX_TRANS_SOCKET) && defined(TRANS_CLIENT) */
+
+#if XTRANS_SEND_FDS
+    if (ciptr->send_fds)
+    {
+        union fd_pass           cmsgbuf;
+        int                     nfd = nFd(&ciptr->send_fds);
+        struct _XtransConnFd    *cf = ciptr->send_fds;
+        struct msghdr           msg = {
+            .msg_name = NULL,
+            .msg_namelen = 0,
+            .msg_iov = buf,
+            .msg_iovlen = size,
+            .msg_control = cmsgbuf.buf,
+            .msg_controllen = CMSG_LEN(nfd * sizeof(int))
+        };
+        struct cmsghdr          *hdr = CMSG_FIRSTHDR(&msg);
+        int                     i;
+        int                     *fds;
+
+        hdr->cmsg_len = msg.msg_controllen;
+        hdr->cmsg_level = SOL_SOCKET;
+        hdr->cmsg_type = SCM_RIGHTS;
+
+        fds = (int *) CMSG_DATA(hdr);
+        /* Set up fds */
+        for (i = 0; i < nfd; i++) {
+            fds[i] = cf->fd;
+            cf = cf->next;
+        }
+
+        i = sendmsg(ciptr->fd, &msg, 0);
+        if (i > 0)
+            discardFd(&ciptr->send_fds, cf, 0);
+        return i;
+    }
+#endif
+    return WRITEV (ciptr, buf, size);
+
+#endif /* #if defined(NX_TRANS_SOCKET) && defined(TRANS_CLIENT) */
+}
+
+
+static int
+TRANS(SocketWrite) (XtransConnInfo ciptr, char *buf, int size)
+
+{
+    prmsg (2,"SocketWrite(%d,%p,%d)\n", ciptr->fd, (void *) buf, size);
+
+#if defined(NX_TRANS_SOCKET) && defined(TRANS_CLIENT)
+
+    /*
+     * If we have a valid priv pointer then this
+     * is an internal connection to the proxy.
+     * In this case we should emulate the write.
+     */
+
+    if (ciptr->priv)
+    {
+        int result;
+
+        result = NXTransWrite(ciptr->fd, buf, size);
+
+#ifdef NX_TRANS_DEBUG
+        if (result < 0 && EGET() == EAGAIN)
+        {
+            fprintf(stderr, "SocketWrite: Write on descriptor [%d] would block.\n",
+                     ciptr->fd);
+        }
+        else
+        {
+            fprintf(stderr, "SocketWrite: Written [%d] bytes on descriptor [%d].\n",
+                     result, ciptr->fd);
+        }
+#endif
+        return result;
+    }
+    else
+    {
+    /* FIXME: same code as below, should be possible without duplication */
+#if XTRANS_SEND_FDS
+        if (ciptr->send_fds)
+        {
+            struct iovec            iov;
+
+            iov.iov_base = buf;
+            iov.iov_len = size;
+            return TRANS(SocketWritev)(ciptr, &iov, 1);
+        }
+#endif /* XTRANS_SEND_FDS */
+        return write (ciptr->fd, buf, size);
+    }
+
+#else /* #if defined(NX_TRANS_SOCKET) && defined(TRANS_CLIENT) */
+
+#if defined(WIN32)
+    {
+	int ret = send ((SOCKET)ciptr->fd, buf, size, 0);
+#ifdef WIN32
+	if (ret == SOCKET_ERROR) errno = WSAGetLastError();
+#endif
+	return ret;
+    }
+#else
+#if XTRANS_SEND_FDS
+    if (ciptr->send_fds)
+    {
+        struct iovec            iov;
+
+        iov.iov_base = buf;
+        iov.iov_len = size;
+        return TRANS(SocketWritev)(ciptr, &iov, 1);
+    }
+#endif /* XTRANS_SEND_FDS */
+    return write (ciptr->fd, buf, size);
+#endif /* WIN32 */
+
+#endif /* #if defined(NX_TRANS_SOCKET) && defined(TRANS_CLIENT) */
+}
+
+static int
+TRANS(SocketDisconnect) (XtransConnInfo ciptr)
+
+{
+    prmsg (2,"SocketDisconnect(%p,%d)\n", (void *) ciptr, ciptr->fd);
+
+#ifdef WIN32
+    {
+	int ret = shutdown (ciptr->fd, 2);
+	if (ret == SOCKET_ERROR) errno = WSAGetLastError();
+	return ret;
+    }
+#else
+    return shutdown (ciptr->fd, 2); /* disallow further sends and receives */
+#endif
+}
+
+
+#ifdef TCPCONN
+static int
+TRANS(SocketINETClose) (XtransConnInfo ciptr)
+
+{
+    prmsg (2,"SocketINETClose(%p,%d)\n", (void *) ciptr, ciptr->fd);
+
+#ifdef WIN32
+    {
+	int ret = close (ciptr->fd);
+	if (ret == SOCKET_ERROR) errno = WSAGetLastError();
+	return ret;
+    }
+#else
+    return close (ciptr->fd);
+#endif
+}
+
+#endif /* TCPCONN */
+
+
+#ifdef UNIXCONN
+static int
+TRANS(SocketUNIXClose) (XtransConnInfo ciptr)
+{
+    /*
+     * If this is the server side, then once the socket is closed,
+     * it must be unlinked to completely close it
+     */
+
+    struct sockaddr_un	*sockname = (struct sockaddr_un *) ciptr->addr;
+    int ret;
+
+    prmsg (2,"SocketUNIXClose(%p,%d)\n", (void *) ciptr, ciptr->fd);
+
+#if defined(NX_TRANS_SOCKET) && defined(TRANS_CLIENT)
+
+    if (ciptr->priv)
+    {
+        TRANS(SocketCloseConnInfo) (ciptr);
+    }
+
+#endif
+
+#if XTRANS_SEND_FDS
+    cleanupFds(ciptr);
+#endif
+    ret = close(ciptr->fd);
+
+#if defined(NX_TRANS_SOCKET) && defined(NX_TRANS_TEST)
+    fprintf(stderr, "SocketUNIXClose: Flags are [%d] for ciptr at [%p] check is [%d].\n",
+                ciptr->flags, (void *) ciptr, (ciptr->flags && sockname
+                    && sockname->sun_family == AF_UNIX && sockname->sun_path[0]));
+#endif
+
+    if (ciptr->flags
+       && sockname
+       && sockname->sun_family == AF_UNIX
+       && sockname->sun_path[0])
+    {
+#if defined(NX_TRANS_SOCKET) && defined(NX_TRANS_TEST)
+        if (!(ciptr->flags & TRANS_NOUNLINK
+	    || ciptr->transptr->flags & TRANS_ABSTRACT))
+        {
+                fprintf(stderr, "SocketUNIXClose: Unlinking path [%s] for ciptr at [%p].\n",
+                            sockname->sun_path, (void *) ciptr);
+                unlink (sockname->sun_path);
+        }
+#else
+	if (!(ciptr->flags & TRANS_NOUNLINK
+	    || ciptr->transptr->flags & TRANS_ABSTRACT))
+		unlink (sockname->sun_path);
+#endif
+    }
+
+    return ret;
+}
+
+static int
+TRANS(SocketUNIXCloseForCloning) (XtransConnInfo ciptr)
+
+{
+    /*
+     * Don't unlink path.
+     */
+
+    int ret;
+
+    prmsg (2,"SocketUNIXCloseForCloning(%p,%d)\n",
+	(void *) ciptr, ciptr->fd);
+
+#if defined(NX_TRANS_SOCKET) && defined(TRANS_CLIENT)
+
+    if (ciptr->priv)
+    {
+        TRANS(SocketCloseConnInfo) (ciptr);
+    }
+
+#endif
+
+#if XTRANS_SEND_FDS
+    cleanupFds(ciptr);
+#endif
+    ret = close(ciptr->fd);
+
+    return ret;
+}
+
+#endif /* UNIXCONN */
+
+
+#ifdef TCPCONN
+# ifdef TRANS_SERVER
+static const char* tcp_nolisten[] = {
+	"inet",
+#if defined(IPv6) && defined(AF_INET6)
+	"inet6",
+#endif
+	NULL
+};
+# endif
+
+Xtransport	TRANS(SocketTCPFuncs) = {
+	/* Socket Interface */
+	"tcp",
+        TRANS_ALIAS,
+#ifdef TRANS_CLIENT
+	TRANS(SocketOpenCOTSClient),
+#endif /* TRANS_CLIENT */
+#ifdef TRANS_SERVER
+	tcp_nolisten,
+	TRANS(SocketOpenCOTSServer),
+#endif /* TRANS_SERVER */
+#ifdef TRANS_REOPEN
+	TRANS(SocketReopenCOTSServer),
+#endif
+	TRANS(SocketSetOption),
+#ifdef TRANS_SERVER
+	TRANS(SocketINETCreateListener),
+	NULL,		       			/* ResetListener */
+	TRANS(SocketINETAccept),
+#endif /* TRANS_SERVER */
+#ifdef TRANS_CLIENT
+	TRANS(SocketINETConnect),
+#endif /* TRANS_CLIENT */
+	TRANS(SocketBytesReadable),
+	TRANS(SocketRead),
+	TRANS(SocketWrite),
+	TRANS(SocketReadv),
+	TRANS(SocketWritev),
+#if XTRANS_SEND_FDS
+        TRANS(SocketSendFdInvalid),
+        TRANS(SocketRecvFdInvalid),
+#endif
+	TRANS(SocketDisconnect),
+	TRANS(SocketINETClose),
+	TRANS(SocketINETClose),
+	};
+
+Xtransport	TRANS(SocketINETFuncs) = {
+	/* Socket Interface */
+	"inet",
+	0,
+#ifdef TRANS_CLIENT
+	TRANS(SocketOpenCOTSClient),
+#endif /* TRANS_CLIENT */
+#ifdef TRANS_SERVER
+	NULL,
+	TRANS(SocketOpenCOTSServer),
+#endif /* TRANS_SERVER */
+#ifdef TRANS_REOPEN
+	TRANS(SocketReopenCOTSServer),
+#endif
+	TRANS(SocketSetOption),
+#ifdef TRANS_SERVER
+	TRANS(SocketINETCreateListener),
+	NULL,		       			/* ResetListener */
+	TRANS(SocketINETAccept),
+#endif /* TRANS_SERVER */
+#ifdef TRANS_CLIENT
+	TRANS(SocketINETConnect),
+#endif /* TRANS_CLIENT */
+	TRANS(SocketBytesReadable),
+	TRANS(SocketRead),
+	TRANS(SocketWrite),
+	TRANS(SocketReadv),
+	TRANS(SocketWritev),
+#if XTRANS_SEND_FDS
+        TRANS(SocketSendFdInvalid),
+        TRANS(SocketRecvFdInvalid),
+#endif
+	TRANS(SocketDisconnect),
+	TRANS(SocketINETClose),
+	TRANS(SocketINETClose),
+	};
+
+#if defined(IPv6) && defined(AF_INET6)
+Xtransport     TRANS(SocketINET6Funcs) = {
+	/* Socket Interface */
+	"inet6",
+	0,
+#ifdef TRANS_CLIENT
+	TRANS(SocketOpenCOTSClient),
+#endif /* TRANS_CLIENT */
+#ifdef TRANS_SERVER
+	NULL,
+	TRANS(SocketOpenCOTSServer),
+#endif /* TRANS_SERVER */
+#ifdef TRANS_REOPEN
+	TRANS(SocketReopenCOTSServer),
+#endif
+	TRANS(SocketSetOption),
+#ifdef TRANS_SERVER
+	TRANS(SocketINETCreateListener),
+	NULL,					/* ResetListener */
+	TRANS(SocketINETAccept),
+#endif /* TRANS_SERVER */
+#ifdef TRANS_CLIENT
+	TRANS(SocketINETConnect),
+#endif /* TRANS_CLIENT */
+	TRANS(SocketBytesReadable),
+	TRANS(SocketRead),
+	TRANS(SocketWrite),
+	TRANS(SocketReadv),
+	TRANS(SocketWritev),
+#if XTRANS_SEND_FDS
+        TRANS(SocketSendFdInvalid),
+        TRANS(SocketRecvFdInvalid),
+#endif
+	TRANS(SocketDisconnect),
+	TRANS(SocketINETClose),
+	TRANS(SocketINETClose),
+	};
+#endif /* IPv6 */
+#endif /* TCPCONN */
+
+#ifdef UNIXCONN
+#if !defined(LOCALCONN)
+Xtransport	TRANS(SocketLocalFuncs) = {
+	/* Socket Interface */
+	"local",
+#ifdef HAVE_ABSTRACT_SOCKETS
+	TRANS_ABSTRACT,
+#else
+	0,
+#endif
+#ifdef TRANS_CLIENT
+	TRANS(SocketOpenCOTSClient),
+#endif /* TRANS_CLIENT */
+#ifdef TRANS_SERVER
+	NULL,
+	TRANS(SocketOpenCOTSServer),
+#endif /* TRANS_SERVER */
+#ifdef TRANS_REOPEN
+	TRANS(SocketReopenCOTSServer),
+#endif
+	TRANS(SocketSetOption),
+#ifdef TRANS_SERVER
+	TRANS(SocketUNIXCreateListener),
+	TRANS(SocketUNIXResetListener),
+	TRANS(SocketUNIXAccept),
+#endif /* TRANS_SERVER */
+#ifdef TRANS_CLIENT
+	TRANS(SocketUNIXConnect),
+#endif /* TRANS_CLIENT */
+	TRANS(SocketBytesReadable),
+	TRANS(SocketRead),
+	TRANS(SocketWrite),
+	TRANS(SocketReadv),
+	TRANS(SocketWritev),
+#if XTRANS_SEND_FDS
+        TRANS(SocketSendFd),
+        TRANS(SocketRecvFd),
+#endif
+	TRANS(SocketDisconnect),
+	TRANS(SocketUNIXClose),
+	TRANS(SocketUNIXCloseForCloning),
+	};
+#endif /* !LOCALCONN */
+# ifdef TRANS_SERVER
+#  if !defined(LOCALCONN)
+static const char* unix_nolisten[] = { "local" , NULL };
+#  endif
+# endif
+
+Xtransport	TRANS(SocketUNIXFuncs) = {
+	/* Socket Interface */
+	"unix",
+#if !defined(LOCALCONN) && !defined(HAVE_ABSTRACT_SOCKETS)
+        TRANS_ALIAS,
+#else
+	0,
+#endif
+#ifdef TRANS_CLIENT
+	TRANS(SocketOpenCOTSClient),
+#endif /* TRANS_CLIENT */
+#ifdef TRANS_SERVER
+#if !defined(LOCALCONN)
+	unix_nolisten,
+#else
+	NULL,
+#endif
+	TRANS(SocketOpenCOTSServer),
+#endif /* TRANS_SERVER */
+#ifdef TRANS_REOPEN
+	TRANS(SocketReopenCOTSServer),
+#endif
+	TRANS(SocketSetOption),
+#ifdef TRANS_SERVER
+	TRANS(SocketUNIXCreateListener),
+	TRANS(SocketUNIXResetListener),
+	TRANS(SocketUNIXAccept),
+#endif /* TRANS_SERVER */
+#ifdef TRANS_CLIENT
+	TRANS(SocketUNIXConnect),
+#endif /* TRANS_CLIENT */
+	TRANS(SocketBytesReadable),
+	TRANS(SocketRead),
+	TRANS(SocketWrite),
+	TRANS(SocketReadv),
+	TRANS(SocketWritev),
+#if XTRANS_SEND_FDS
+        TRANS(SocketSendFd),
+        TRANS(SocketRecvFd),
+#endif
+	TRANS(SocketDisconnect),
+	TRANS(SocketUNIXClose),
+	TRANS(SocketUNIXCloseForCloning),
+	};
+
+#endif /* UNIXCONN */
+
+#ifdef NX_TRANS_SOCKET
+/*
+ * Override the UNIX_DIR and UNIX_PATH settings and
+ * make them configurable, based on the NX_TEMP or
+ * the TEMP environment.
+ *
+ * We must be careful as the same defines are used
+ * for different directories, based on the subsystem
+ * that is compiling this, while we want to override
+ * only the '/tmp/.X11-unix' and '/tmp/.X11-unix/X'
+ * settings.
+ */
+
+static char _NXUnixDir[1024];
+static char _NXUnixPath[1024];
+
+static char *_NXGetUnixDir(char *dir)
+{
+    const char *tempDir;
+
+    prmsg (3, "_NXGetUnixDir(%s)\n", dir);
+
+    if (strcmp(dir, UNIX_DIR) != 0)
+    {
+#ifdef NX_TRANS_TEST
+        fprintf(stderr, "_NXGetUnixDir: Returning other Unix directory [%s].\n", dir);
+#endif
+        return dir;
+    }
+
+    /*
+     * Check the environment only once.
+     */
+
+    if (*_NXUnixDir != '\0')
+    {
+        return _NXUnixDir;
+    }
+
+#ifdef NX_TRANS_TEST
+    fprintf(stderr, "_NXGetUnixDir: Trying with the NX_TEMP environment.\n");
+#endif
+
+    tempDir = getenv("NX_TEMP");
+
+    if (tempDir == NULL || *tempDir == '\0')
+    {
+#ifdef NX_TRANS_TEST
+        fprintf(stderr, "_NXGetUnixDir: Trying with the TEMP environment.\n");
+#endif
+
+        tempDir = getenv("TEMP");
+    }
+
+    if (tempDir != NULL && *tempDir != '\0')
+    {
+        if (strlen(tempDir) + strlen("/.X11-unix") + 1 > 1024)
+        {
+#ifdef NX_TRANS_TEST
+            fprintf(stderr, "_NXGetUnixDir: WARNING! Maximum length of X11 Unix directory exceeded.\n");
+#endif
+            goto _NXGetUnixDirError;
+        }
+
+        strcpy(_NXUnixDir, tempDir);
+        strcat(_NXUnixDir, "/.X11-unix");
+
+#ifdef NX_TRANS_TEST
+        fprintf(stderr, "_NXGetUnixDir: Using X11 Unix directory [%s].\n", _NXUnixDir);
+#endif
+
+        return _NXUnixDir;
+    }
+
+_NXGetUnixDirError:
+
+    strcpy(_NXUnixDir, dir);
+
+#ifdef NX_TRANS_TEST
+    fprintf(stderr, "_NXGetUnixDir: Returning default X11 Unix directory [%s].\n", _NXUnixDir);
+#endif
+
+    return _NXUnixDir;
+}
+
+static char *_NXGetUnixPath(char *path)
+{
+    const char *unixDir;
+
+    prmsg (3, "_NXGetUnixPath(%s)\n", path);
+
+    if (strcmp(path, UNIX_PATH) != 0)
+    {
+#ifdef NX_TRANS_TEST
+        fprintf(stderr, "_NXGetUnixPath: Returning other X11 Unix path [%s].\n", path);
+#endif
+        return path;
+    }
+
+    /*
+     * Check the environment only once.
+     */
+
+    if (*_NXUnixPath != '\0')
+    {
+        return _NXUnixPath;
+    }
+
+    unixDir = _NXGetUnixDir(UNIX_DIR);
+
+#ifdef NX_TRANS_TEST
+    fprintf(stderr, "_NXGetUnixPath: Got X11 Unix directory [%s].\n", unixDir);
+#endif
+
+    if (strlen(unixDir) + strlen("/X") + 1 > 1024)
+    {
+#ifdef NX_TRANS_TEST
+        fprintf(stderr, "_NXGetUnixPath: WARNING! Maximum length of X11 Unix path exceeded.\n");
+#endif
+
+        goto _NXGetUnixPathError;
+    }
+
+    strcpy(_NXUnixPath, unixDir);
+    strcat(_NXUnixPath, "/X");
+
+#ifdef NX_TRANS_TEST
+    fprintf(stderr, "_NXGetUnixPath: Returning X11 Unix path [%s].\n", _NXUnixPath);
+#endif
+
+    return _NXUnixPath;
+
+_NXGetUnixPathError:
+
+    strcpy(_NXUnixPath, path);
+
+#ifdef NX_TRANS_TEST
+    fprintf(stderr, "_NXGetUnixPath: Returning default X11 Unix path [%s].\n", _NXUnixPath);
+#endif
+
+    return _NXUnixPath;
+}
+
+#endif /* NX_TRANS_SOCKET */
diff --git a/nx-X11/lib/include/xtrans/Xtransutil.c b/nx-X11/lib/include/xtrans/Xtransutil.c
new file mode 100644
index 000000000..0063e83d8
--- /dev/null
+++ b/nx-X11/lib/include/xtrans/Xtransutil.c
@@ -0,0 +1,639 @@
+/*
+
+Copyright 1993, 1994, 1998  The Open Group
+
+Permission to use, copy, modify, distribute, and sell this software and its
+documentation for any purpose is hereby granted without fee, provided that
+the above copyright notice appear in all copies and that both that
+copyright notice and this permission notice appear in supporting
+documentation.
+
+The above copyright notice and this permission notice shall be included
+in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR
+OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.
+
+Except as contained in this notice, the name of The Open Group shall
+not be used in advertising or otherwise to promote the sale, use or
+other dealings in this Software without prior written authorization
+from The Open Group.
+
+ * Copyright 1993, 1994 NCR Corporation - Dayton, Ohio, USA
+ *
+ * All Rights Reserved
+ *
+ * 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 NCR not be used in advertising
+ * or publicity pertaining to distribution of the software without specific,
+ * written prior permission.  NCR makes no representations about the
+ * suitability of this software for any purpose.  It is provided "as is"
+ * without express or implied warranty.
+ *
+ * NCRS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
+ * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN
+ * NO EVENT SHALL NCR BE LIABLE FOR ANY SPECIAL, INDIRECT OR
+ * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS
+ * OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
+ * NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
+ * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+/*
+ * These are some utility functions created for convenience or to provide
+ * an interface that is similar to an existing interface. These are built
+ * only using the Transport Independant API, and have no knowledge of
+ * the internal implementation.
+ */
+
+#ifdef XTHREADS
+#include <X11/Xthreads.h>
+#endif
+#ifdef WIN32
+#include <X11/Xlibint.h>
+#include <X11/Xwinsock.h>
+#endif
+
+#ifdef X11_t
+
+/*
+ * These values come from X.h and Xauth.h, and MUST match them. Some
+ * of these values are also defined by the ChangeHost protocol message.
+ */
+
+#define FamilyInternet		0	/* IPv4 */
+#define FamilyDECnet		1
+#define FamilyChaos		2
+#define FamilyInternet6		6
+#define FamilyAmoeba		33
+#define FamilyLocalHost		252
+#define FamilyKrb5Principal	253
+#define FamilyNetname		254
+#define FamilyLocal		256
+#define FamilyWild		65535
+
+/*
+ * TRANS(ConvertAddress) converts a sockaddr based address to an
+ * X authorization based address. Some of this is defined as part of
+ * the ChangeHost protocol. The rest is just done in a consistent manner.
+ */
+
+int
+TRANS(ConvertAddress)(int *familyp, int *addrlenp, Xtransaddr **addrp)
+
+{
+
+    prmsg(2,"ConvertAddress(%d,%d,%p)\n",*familyp,*addrlenp,(void *) *addrp);
+
+    switch( *familyp )
+    {
+#if defined(TCPCONN)
+    case AF_INET:
+    {
+	/*
+	 * Check for the BSD hack localhost address 127.0.0.1.
+	 * In this case, we are really FamilyLocal.
+	 */
+
+	struct sockaddr_in saddr;
+	int len = sizeof(saddr.sin_addr.s_addr);
+	char *cp = (char *) &saddr.sin_addr.s_addr;
+
+	memcpy (&saddr, *addrp, sizeof (struct sockaddr_in));
+
+	if ((len == 4) && (cp[0] == 127) && (cp[1] == 0) &&
+	    (cp[2] == 0) && (cp[3] == 1))
+	{
+	    *familyp=FamilyLocal;
+	}
+	else
+	{
+	    *familyp=FamilyInternet;
+	    *addrlenp=len;
+	    memcpy(*addrp,&saddr.sin_addr,len);
+	}
+	break;
+    }
+
+#if defined(IPv6) && defined(AF_INET6)
+    case AF_INET6:
+    {
+	struct sockaddr_in6 saddr6;
+
+	memcpy (&saddr6, *addrp, sizeof (struct sockaddr_in6));
+
+	if (IN6_IS_ADDR_LOOPBACK(&saddr6.sin6_addr))
+	{
+	    *familyp=FamilyLocal;
+	}
+	else if (IN6_IS_ADDR_V4MAPPED(&(saddr6.sin6_addr))) {
+	    char *cp = (char *) &saddr6.sin6_addr.s6_addr[12];
+
+	    if ((cp[0] == 127) && (cp[1] == 0) &&
+	      (cp[2] == 0) && (cp[3] == 1))
+	    {
+		*familyp=FamilyLocal;
+	    }
+	    else
+	    {
+		*familyp=FamilyInternet;
+		*addrlenp = sizeof (struct in_addr);
+		memcpy(*addrp,cp,*addrlenp);
+	    }
+	}
+	else
+	{
+	    *familyp=FamilyInternet6;
+	    *addrlenp=sizeof(saddr6.sin6_addr);
+	    memcpy(*addrp,&saddr6.sin6_addr,sizeof(saddr6.sin6_addr));
+	}
+	break;
+    }
+#endif /* IPv6 */
+#endif /* defined(TCPCONN) */
+
+
+#if defined(UNIXCONN) || defined(LOCALCONN)
+    case AF_UNIX:
+    {
+	*familyp=FamilyLocal;
+	break;
+    }
+#endif /* defined(UNIXCONN) || defined(LOCALCONN) */
+
+#if (defined(__SCO__) || defined(__UNIXWARE__)) && defined(LOCALCONN)
+    case 0:
+    {
+	*familyp=FamilyLocal;
+	break;
+    }
+#endif
+
+    default:
+	prmsg(1,"ConvertAddress: Unknown family type %d\n",
+	      *familyp);
+	return -1;
+    }
+
+
+    if (*familyp == FamilyLocal)
+    {
+	/*
+	 * In the case of a local connection, we need to get the
+	 * host name for authentication.
+	 */
+
+	char hostnamebuf[256];
+	int len = TRANS(GetHostname) (hostnamebuf, sizeof hostnamebuf);
+
+	if (len > 0) {
+	    if (*addrp && *addrlenp < (len + 1))
+	    {
+		free (*addrp);
+		*addrp = NULL;
+	    }
+	    if (!*addrp)
+		*addrp = malloc (len + 1);
+	    if (*addrp) {
+		strcpy ((char *) *addrp, hostnamebuf);
+		*addrlenp = len;
+	    } else {
+		*addrlenp = 0;
+	    }
+	}
+	else
+	{
+	    if (*addrp)
+		free (*addrp);
+	    *addrp = NULL;
+	    *addrlenp = 0;
+	}
+    }
+
+    return 0;
+}
+
+#endif /* X11_t */
+
+#ifdef ICE_t
+
+/* Needed for _XGethostbyaddr usage in TRANS(GetPeerNetworkId) */
+# if defined(TCPCONN) || defined(UNIXCONN)
+#  define X_INCLUDE_NETDB_H
+#  define XOS_USE_NO_LOCKING
+#  include <X11/Xos_r.h>
+# endif
+
+#include <signal.h>
+
+char *
+TRANS(GetMyNetworkId) (XtransConnInfo ciptr)
+
+{
+    int		family = ciptr->family;
+    char 	*addr = ciptr->addr;
+    char	hostnamebuf[256];
+    char 	*networkId = NULL;
+    const char	*transName = ciptr->transptr->TransName;
+
+    if (gethostname (hostnamebuf, sizeof (hostnamebuf)) < 0)
+    {
+	return (NULL);
+    }
+
+    switch (family)
+    {
+#if defined(UNIXCONN) || defined(LOCALCONN)
+    case AF_UNIX:
+    {
+	struct sockaddr_un *saddr = (struct sockaddr_un *) addr;
+	networkId = malloc (3 + strlen (transName) +
+	    strlen (hostnamebuf) + strlen (saddr->sun_path));
+	sprintf (networkId, "%s/%s:%s", transName,
+	    hostnamebuf, saddr->sun_path);
+	break;
+    }
+#endif /* defined(UNIXCONN) || defined(LOCALCONN) */
+
+#if defined(TCPCONN)
+    case AF_INET:
+#if defined(IPv6) && defined(AF_INET6)
+    case AF_INET6:
+#endif
+    {
+	struct sockaddr_in *saddr = (struct sockaddr_in *) addr;
+#if defined(IPv6) && defined(AF_INET6)
+	struct sockaddr_in6 *saddr6 = (struct sockaddr_in6 *) addr;
+#endif
+	int portnum;
+	char portnumbuf[10];
+
+
+#if defined(IPv6) && defined(AF_INET6)
+	if (family == AF_INET6)
+	    portnum = ntohs (saddr6->sin6_port);
+	else
+#endif
+	    portnum = ntohs (saddr->sin_port);
+
+	snprintf (portnumbuf, sizeof(portnumbuf), "%d", portnum);
+	networkId = malloc (3 + strlen (transName) +
+	    strlen (hostnamebuf) + strlen (portnumbuf));
+	sprintf (networkId, "%s/%s:%s", transName, hostnamebuf, portnumbuf);
+	break;
+    }
+#endif /* defined(TCPCONN) */
+
+
+    default:
+	break;
+    }
+
+    return (networkId);
+}
+
+#include <setjmp.h>
+static jmp_buf env;
+
+#ifdef SIGALRM
+static volatile int nameserver_timedout = 0;
+
+static void
+nameserver_lost(int sig _X_UNUSED)
+{
+  nameserver_timedout = 1;
+  longjmp (env, -1);
+  /* NOTREACHED */
+}
+#endif /* SIGALARM */
+
+
+char *
+TRANS(GetPeerNetworkId) (XtransConnInfo ciptr)
+
+{
+    int		family = ciptr->family;
+    char	*peer_addr = ciptr->peeraddr;
+    char	*hostname;
+    char	addrbuf[256];
+    const char	*addr = NULL;
+
+    switch (family)
+    {
+    case AF_UNSPEC:
+#if defined(UNIXCONN) || defined(LOCALCONN)
+    case AF_UNIX:
+    {
+	if (gethostname (addrbuf, sizeof (addrbuf)) == 0)
+	    addr = addrbuf;
+	break;
+    }
+#endif /* defined(UNIXCONN) || defined(LOCALCONN) */
+
+#if defined(TCPCONN)
+    case AF_INET:
+#if defined(IPv6) && defined(AF_INET6)
+    case AF_INET6:
+#endif
+    {
+	struct sockaddr_in *saddr = (struct sockaddr_in *) peer_addr;
+#if defined(IPv6) && defined(AF_INET6)
+	struct sockaddr_in6 *saddr6 = (struct sockaddr_in6 *) peer_addr;
+#endif
+	char *address;
+	int addresslen;
+#ifdef XTHREADS_NEEDS_BYNAMEPARAMS
+	_Xgethostbynameparams hparams;
+#endif
+	struct hostent * volatile hostp = NULL;
+
+#if defined(IPv6) && defined(AF_INET6)
+	if (family == AF_INET6)
+	{
+	    address = (char *) &saddr6->sin6_addr;
+	    addresslen = sizeof (saddr6->sin6_addr);
+	}
+	else
+#endif
+	{
+	    address = (char *) &saddr->sin_addr;
+	    addresslen = sizeof (saddr->sin_addr);
+	}
+
+#ifdef SIGALRM
+	/*
+	 * gethostbyaddr can take a LONG time if the host does not exist.
+	 * Assume that if it does not respond in NAMESERVER_TIMEOUT seconds
+	 * that something is wrong and do not make the user wait.
+	 * gethostbyaddr will continue after a signal, so we have to
+	 * jump out of it.
+	 */
+
+	nameserver_timedout = 0;
+	signal (SIGALRM, nameserver_lost);
+	alarm (4);
+	if (setjmp(env) == 0) {
+#endif
+	    hostp = _XGethostbyaddr (address, addresslen, family, hparams);
+#ifdef SIGALRM
+	}
+	alarm (0);
+#endif
+	if (hostp != NULL)
+	  addr = hostp->h_name;
+	else
+#if defined(IPv6) && defined(AF_INET6)
+	  addr = inet_ntop (family, address, addrbuf, sizeof (addrbuf));
+#else
+	  addr = inet_ntoa (saddr->sin_addr);
+#endif
+	break;
+    }
+
+#endif /* defined(TCPCONN) */
+
+
+    default:
+	return (NULL);
+    }
+
+
+    hostname = malloc (strlen (ciptr->transptr->TransName) + strlen (addr) + 2);
+    strcpy (hostname, ciptr->transptr->TransName);
+    strcat (hostname, "/");
+    if (addr)
+	strcat (hostname, addr);
+
+    return (hostname);
+}
+
+#endif /* ICE_t */
+
+
+#if defined(WIN32) && defined(TCPCONN)
+int
+TRANS(WSAStartup) (void)
+{
+    static WSADATA wsadata;
+
+    prmsg (2,"WSAStartup()\n");
+
+    if (!wsadata.wVersion && WSAStartup(MAKEWORD(2,2), &wsadata))
+        return 1;
+    return 0;
+}
+#endif
+
+#include <ctype.h>
+
+#if defined(X11_t)
+static int
+is_numeric (const char *str)
+{
+    int i;
+
+    for (i = 0; i < (int) strlen (str); i++)
+	if (!isdigit (str[i]))
+	    return (0);
+
+    return (1);
+}
+#endif
+
+#ifdef TRANS_SERVER
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <errno.h>
+
+#if !defined(S_IFLNK) && !defined(S_ISLNK)
+#undef lstat
+#define lstat(a,b) stat(a,b)
+#endif
+
+#define FAIL_IF_NOMODE  1
+#define FAIL_IF_NOT_ROOT 2
+#define WARN_NO_ACCESS 4
+
+/*
+ * We make the assumption that when the 'sticky' (t) bit is requested
+ * it's not save if the directory has non-root ownership or the sticky
+ * bit cannot be set and fail.
+ */
+static int
+trans_mkdir(const char *path, int mode)
+{
+    struct stat buf;
+
+    if (lstat(path, &buf) != 0) {
+	if (errno != ENOENT) {
+	    prmsg(1, "mkdir: ERROR: (l)stat failed for %s (%d)\n",
+		  path, errno);
+	    return -1;
+	}
+	/* Dir doesn't exist. Try to create it */
+
+#if !defined(WIN32) && !defined(__CYGWIN__)
+	/*
+	 * 'sticky' bit requested: assume application makes
+	 * certain security implications. If effective user ID
+	 * is != 0: fail as we may not be able to meet them.
+	 */
+	if (geteuid() != 0) {
+	    if (mode & 01000) {
+		prmsg(1, "mkdir: ERROR: euid != 0,"
+		      "directory %s will not be created.\n",
+		      path);
+#ifdef FAIL_HARD
+		return -1;
+#endif
+	    } else {
+		prmsg(1, "mkdir: Cannot create %s with root ownership\n",
+		      path);
+	    }
+	}
+#endif
+
+#ifndef WIN32
+	if (mkdir(path, mode) == 0) {
+	    if (chmod(path, mode)) {
+		prmsg(1, "mkdir: ERROR: Mode of %s should be set to %04o\n",
+		      path, mode);
+#ifdef FAIL_HARD
+		return -1;
+#endif
+	    }
+#else
+	if (mkdir(path) == 0) {
+#endif
+	} else {
+	    prmsg(1, "mkdir: ERROR: Cannot create %s\n",
+		  path);
+	    return -1;
+	}
+
+	return 0;
+
+    } else {
+	if (S_ISDIR(buf.st_mode)) {
+	    int updateOwner = 0;
+	    int updateMode = 0;
+	    int updatedOwner = 0;
+	    int updatedMode = 0;
+	    int status = 0;
+	    /* Check if the directory's ownership is OK. */
+	    if (buf.st_uid != 0)
+		updateOwner = 1;
+
+	    /*
+	     * Check if the directory's mode is OK.  An exact match isn't
+	     * required, just a mode that isn't more permissive than the
+	     * one requested.
+	     */
+	    if ((~mode) & 0077 & buf.st_mode)
+		updateMode = 1;
+
+	    /*
+	     * If the directory is not writeable not everybody may
+	     * be able to create sockets. Therefore warn if mode
+	     * cannot be fixed.
+	     */
+	    if ((~buf.st_mode) & 0022 & mode) {
+		updateMode = 1;
+		status |= WARN_NO_ACCESS;
+	    }
+
+	    /*
+	     * If 'sticky' bit is requested fail if owner isn't root
+	     * as we assume the caller makes certain security implications
+	     */
+	    if (mode & 01000) {
+		status |= FAIL_IF_NOT_ROOT;
+		if (!(buf.st_mode & 01000)) {
+		    status |= FAIL_IF_NOMODE;
+		    updateMode = 1;
+		}
+	    }
+
+#ifdef HAS_FCHOWN
+	    /*
+	     * If fchown(2) and fchmod(2) are available, try to correct the
+	     * directory's owner and mode.  Otherwise it isn't safe to attempt
+	     * to do this.
+	     */
+	    if (updateMode || updateOwner) {
+		int fd = -1;
+		struct stat fbuf;
+		if ((fd = open(path, O_RDONLY)) != -1) {
+		    if (fstat(fd, &fbuf) == -1) {
+			prmsg(1, "mkdir: ERROR: fstat failed for %s (%d)\n",
+			      path, errno);
+			close(fd);
+			return -1;
+		    }
+		    /*
+		     * Verify that we've opened the same directory as was
+		     * checked above.
+		     */
+		    if (!S_ISDIR(fbuf.st_mode) ||
+			buf.st_dev != fbuf.st_dev ||
+			buf.st_ino != fbuf.st_ino) {
+			prmsg(1, "mkdir: ERROR: inode for %s changed\n",
+			      path);
+			close(fd);
+			return -1;
+		    }
+		    if (updateOwner && fchown(fd, 0, 0) == 0)
+			updatedOwner = 1;
+		    if (updateMode && fchmod(fd, mode) == 0)
+			updatedMode = 1;
+		    close(fd);
+		}
+	    }
+#endif
+
+	    if (updateOwner && !updatedOwner) {
+#ifdef FAIL_HARD
+		if (status & FAIL_IF_NOT_ROOT) {
+		    prmsg(1, "mkdir: ERROR: Owner of %s must be set to root\n",
+			  path);
+		    return -1;
+		}
+#endif
+#if !defined(__APPLE_CC__) && !defined(__CYGWIN__)
+		prmsg(1, "mkdir: Owner of %s should be set to root\n",
+		      path);
+#endif
+	    }
+
+	    if (updateMode && !updatedMode) {
+#ifdef FAIL_HARD
+		if (status & FAIL_IF_NOMODE) {
+		    prmsg(1, "mkdir: ERROR: Mode of %s must be set to %04o\n",
+			  path, mode);
+		    return -1;
+		}
+#endif
+		prmsg(1, "mkdir: Mode of %s should be set to %04o\n",
+		      path, mode);
+		if (status & WARN_NO_ACCESS) {
+		    prmsg(1, "mkdir: this may cause subsequent errors\n");
+		}
+	    }
+	    return 0;
+	}
+	return -1;
+    }
+
+    /* In all other cases, fail */
+    return -1;
+}
+
+#endif /* TRANS_SERVER */
diff --git a/nx-X11/lib/include/xtrans/transport.c b/nx-X11/lib/include/xtrans/transport.c
new file mode 100644
index 000000000..b62fc7b64
--- /dev/null
+++ b/nx-X11/lib/include/xtrans/transport.c
@@ -0,0 +1,74 @@
+/*
+
+Copyright 1993, 1994, 1998  The Open Group
+
+Permission to use, copy, modify, distribute, and sell this software and its
+documentation for any purpose is hereby granted without fee, provided that
+the above copyright notice appear in all copies and that both that
+copyright notice and this permission notice appear in supporting
+documentation.
+
+The above copyright notice and this permission notice shall be included
+in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR
+OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.
+
+Except as contained in this notice, the name of The Open Group shall
+not be used in advertising or otherwise to promote the sale, use or
+other dealings in this Software without prior written authorization
+from The Open Group.
+
+ * Copyright 1993, 1994 NCR Corporation - Dayton, Ohio, USA
+ *
+ * All Rights Reserved
+ *
+ * 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 NCR not be used in advertising
+ * or publicity pertaining to distribution of the software without specific,
+ * written prior permission.  NCR makes no representations about the
+ * suitability of this software for any purpose.  It is provided "as is"
+ * without express or implied warranty.
+ *
+ * NCR DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
+ * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN
+ * NO EVENT SHALL NCR BE LIABLE FOR ANY SPECIAL, INDIRECT OR
+ * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS
+ * OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
+ * NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
+ * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+#include <stdlib.h>
+
+#define XTRANS_TRANSPORT_C  /* used to flag Xtransint.h that it's being used
+			       here, not just #included in another file */
+
+#include "Xtransint.h"
+
+#ifdef __clang__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wformat-nonliteral"
+#pragma clang diagnostic ignored "-Wdeprecated-declarations"
+#endif
+
+#ifdef LOCALCONN
+#include "Xtranslcl.c"
+#endif
+#if defined(TCPCONN) || defined(UNIXCONN)
+#include "Xtranssock.c"
+#endif
+#include "Xtrans.c"
+#include "Xtransutil.c"
+
+#ifdef __clang__
+#pragma clang diagnostic pop
+#endif