aboutsummaryrefslogtreecommitdiff
path: root/nx-X11/lib/ICE
diff options
context:
space:
mode:
authorReinhard Tartler <siretart@tauware.de>2011-10-10 17:43:39 +0200
committerReinhard Tartler <siretart@tauware.de>2011-10-10 17:43:39 +0200
commitf4092abdf94af6a99aff944d6264bc1284e8bdd4 (patch)
tree2ac1c9cc16ceb93edb2c4382c088dac5aeafdf0f /nx-X11/lib/ICE
parenta840692edc9c6d19cd7c057f68e39c7d95eb767d (diff)
downloadnx-libs-f4092abdf94af6a99aff944d6264bc1284e8bdd4.tar.gz
nx-libs-f4092abdf94af6a99aff944d6264bc1284e8bdd4.tar.bz2
nx-libs-f4092abdf94af6a99aff944d6264bc1284e8bdd4.zip
Imported nx-X11-3.1.0-1.tar.gznx-X11/3.1.0-1
Summary: Imported nx-X11-3.1.0-1.tar.gz Keywords: Imported nx-X11-3.1.0-1.tar.gz into Git repository
Diffstat (limited to 'nx-X11/lib/ICE')
-rw-r--r--nx-X11/lib/ICE/ICE-def.cpp74
-rw-r--r--nx-X11/lib/ICE/ICE.h102
-rw-r--r--nx-X11/lib/ICE/ICEconn.h251
-rw-r--r--nx-X11/lib/ICE/ICElib.h433
-rw-r--r--nx-X11/lib/ICE/ICElibint.h537
-rw-r--r--nx-X11/lib/ICE/ICEmsg.h295
-rw-r--r--nx-X11/lib/ICE/ICEproto.h176
-rw-r--r--nx-X11/lib/ICE/ICEutil.h126
-rw-r--r--nx-X11/lib/ICE/Imakefile92
-rw-r--r--nx-X11/lib/ICE/accept.c188
-rw-r--r--nx-X11/lib/ICE/authutil.c539
-rw-r--r--nx-X11/lib/ICE/connect.c543
-rw-r--r--nx-X11/lib/ICE/error.c641
-rw-r--r--nx-X11/lib/ICE/getauth.c274
-rw-r--r--nx-X11/lib/ICE/globals.h64
-rw-r--r--nx-X11/lib/ICE/iceauth.c278
-rw-r--r--nx-X11/lib/ICE/listen.c283
-rw-r--r--nx-X11/lib/ICE/listenwk.c161
-rw-r--r--nx-X11/lib/ICE/locking.c67
-rw-r--r--nx-X11/lib/ICE/misc.c630
-rw-r--r--nx-X11/lib/ICE/ping.c66
-rw-r--r--nx-X11/lib/ICE/process.c2548
-rw-r--r--nx-X11/lib/ICE/protosetup.c293
-rw-r--r--nx-X11/lib/ICE/register.c256
-rw-r--r--nx-X11/lib/ICE/replywait.c161
-rw-r--r--nx-X11/lib/ICE/setauth.c121
-rw-r--r--nx-X11/lib/ICE/shutdown.c330
-rw-r--r--nx-X11/lib/ICE/watch.c206
28 files changed, 9735 insertions, 0 deletions
diff --git a/nx-X11/lib/ICE/ICE-def.cpp b/nx-X11/lib/ICE/ICE-def.cpp
new file mode 100644
index 000000000..cb9a27d7b
--- /dev/null
+++ b/nx-X11/lib/ICE/ICE-def.cpp
@@ -0,0 +1,74 @@
+LIBRARY ICE
+VERSION LIBRARY_VERSION
+EXPORTS
+ IceAcceptConnection
+ IceAddConnectionWatch
+ IceAllocScratch
+ IceAppLockConn
+ IceAppUnlockConn
+ IceAuthFileName
+ IceCheckShutdownNegotiation
+ IceCloseConnection
+ IceComposeNetworkIdList
+ IceConnectionNumber
+ IceConnectionStatus
+ IceConnectionString
+ IceFlush
+ IceFreeAuthFileEntry
+ IceFreeListenObjs
+ IceGenerateMagicCookie
+ IceGetAuthFileEntry
+ IceGetConnectionContext
+ IceGetInBufSize
+ IceGetListenConnectionNumber
+ IceGetListenConnectionString
+ IceGetOutBufSize
+ IceInitThreads
+ IceLastReceivedSequenceNumber
+ IceLastSentSequenceNumber
+ IceListenForConnections
+ IceLockAuthFile
+ IceOpenConnection
+ IcePing
+ IceProcessMessages
+ IceProtocolRevision
+ IceProtocolSetup
+ IceProtocolShutdown
+ IceProtocolVersion
+ IceReadAuthFileEntry
+ IceRegisterForProtocolReply
+ IceRegisterForProtocolSetup
+ IceRelease
+ IceRemoveConnectionWatch
+ IceSetErrorHandler
+ IceSetHostBasedAuthProc
+ IceSetIOErrorHandler
+ IceSetPaAuthData
+ IceSetShutdownNegotiation
+ IceSwapping
+ IceUnlockAuthFile
+ IceVendor
+ IceWriteAuthFileEntry
+ _IceTransGetPeerAddr
+ _IceTransGetPeerNetworkId
+ _IceErrorBadMinor
+ _IceErrorBadLength
+ _IceErrorBadState
+ _IceErrorBadValue
+ _IcePaMagicCookie1Proc
+ _IcePoMagicCookie1Proc
+ _IceRead
+ _IceReadSkip
+ _IceWrite
+ IceListenForWellKnownConnections
+ _IceTransGetHostname
+ _IceTransSetOption
+ _IceTransConnect
+ _IceTransClose
+ _IceTransOpenCOTSClient
+ _IceTransGetConnectionNumber
+ _IceTransRead
+ _IceTransWrite
+
+/* $Xorg: ICE-def.cpp,v 1.3 2000/08/21 16:42:31 coskrey Exp $ */
+/* $XFree86: xc/lib/ICE/ICE-def.cpp,v 1.4 2001/01/17 19:41:29 dawes Exp $ */
diff --git a/nx-X11/lib/ICE/ICE.h b/nx-X11/lib/ICE/ICE.h
new file mode 100644
index 000000000..e2924f1ab
--- /dev/null
+++ b/nx-X11/lib/ICE/ICE.h
@@ -0,0 +1,102 @@
+/* $Xorg: ICE.h,v 1.4 2001/02/09 02:03:26 xorgcvs Exp $ */
+/******************************************************************************
+
+
+Copyright 1993, 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.
+
+Author: Ralph Mor, X Consortium
+
+******************************************************************************/
+
+#ifndef _ICE_H_
+#define _ICE_H_
+
+/*
+ * Protocol Version
+ */
+
+#define IceProtoMajor 1
+#define IceProtoMinor 0
+
+
+/*
+ * Byte Order
+ */
+
+#define IceLSBfirst 0
+#define IceMSBfirst 1
+
+
+/*
+ * ICE minor opcodes
+ */
+
+#define ICE_Error 0
+#define ICE_ByteOrder 1
+#define ICE_ConnectionSetup 2
+#define ICE_AuthRequired 3
+#define ICE_AuthReply 4
+#define ICE_AuthNextPhase 5
+#define ICE_ConnectionReply 6
+#define ICE_ProtocolSetup 7
+#define ICE_ProtocolReply 8
+#define ICE_Ping 9
+#define ICE_PingReply 10
+#define ICE_WantToClose 11
+#define ICE_NoClose 12
+
+
+/*
+ * Error severity
+ */
+
+#define IceCanContinue 0
+#define IceFatalToProtocol 1
+#define IceFatalToConnection 2
+
+
+/*
+ * ICE error classes that are common to all protocols
+ */
+
+#define IceBadMinor 0x8000
+#define IceBadState 0x8001
+#define IceBadLength 0x8002
+#define IceBadValue 0x8003
+
+
+/*
+ * ICE error classes that are specific to the ICE protocol
+ */
+
+#define IceBadMajor 0
+#define IceNoAuth 1
+#define IceNoVersion 2
+#define IceSetupFailed 3
+#define IceAuthRejected 4
+#define IceAuthFailed 5
+#define IceProtocolDuplicate 6
+#define IceMajorOpcodeDuplicate 7
+#define IceUnknownProtocol 8
+
+#endif /* _ICE_H_ */
diff --git a/nx-X11/lib/ICE/ICEconn.h b/nx-X11/lib/ICE/ICEconn.h
new file mode 100644
index 000000000..cdfaccaea
--- /dev/null
+++ b/nx-X11/lib/ICE/ICEconn.h
@@ -0,0 +1,251 @@
+/* $Xorg: ICEconn.h,v 1.5 2001/02/09 02:03:26 xorgcvs Exp $ */
+/******************************************************************************
+
+
+Copyright 1993, 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.
+
+Author: Ralph Mor, X Consortium
+******************************************************************************/
+
+#ifndef _ICECONN_H_
+#define _ICECONN_H_
+
+#include <X11/ICE/ICElib.h>
+
+/*
+ * Data structures for ICE connection object
+ */
+
+typedef struct _IceSavedReplyWait {
+ IceReplyWaitInfo *reply_wait;
+ Bool reply_ready;
+ struct _IceSavedReplyWait *next;
+} _IceSavedReplyWait;
+
+typedef struct _IcePingWait {
+ IcePingReplyProc ping_reply_proc;
+ IcePointer client_data;
+ struct _IcePingWait *next;
+} _IcePingWait;
+
+typedef struct {
+ char *vendor;
+ char *release;
+ int version_count;
+ IcePoVersionRec *version_recs;
+ int auth_count;
+ char **auth_names;
+ IcePoAuthProc *auth_procs;
+ IceIOErrorProc io_error_proc;
+} _IcePoProtocol;
+
+typedef struct {
+ char *vendor;
+ char *release;
+ int version_count;
+ IcePaVersionRec *version_recs;
+ IceProtocolSetupProc protocol_setup_proc;
+ IceProtocolActivateProc protocol_activate_proc;
+ int auth_count;
+ char **auth_names;
+ IcePaAuthProc *auth_procs;
+ IceHostBasedAuthProc host_based_auth_proc;
+ IceIOErrorProc io_error_proc;
+} _IcePaProtocol;
+
+typedef struct {
+ char *protocol_name;
+ _IcePoProtocol *orig_client;
+ _IcePaProtocol *accept_client;
+} _IceProtocol;
+
+typedef struct {
+ Bool in_use;
+ int my_opcode;
+ _IceProtocol *protocol;
+ IcePointer client_data;
+ Bool accept_flag;
+ union {
+ IcePaProcessMsgProc accept_client;
+ IcePoProcessMsgProc orig_client;
+ } process_msg_proc;
+} _IceProcessMsgInfo;
+
+typedef struct {
+ int his_version_index;
+ int my_version_index;
+ char *his_vendor;
+ char *his_release;
+ char my_auth_index;
+ IcePointer my_auth_state;
+ Bool must_authenticate;
+} _IceConnectToMeInfo;
+
+typedef struct {
+ int his_opcode;
+ int my_opcode;
+ int his_version_index;
+ int my_version_index;
+ char *his_vendor;
+ char *his_release;
+ char my_auth_index;
+ IcePointer my_auth_state;
+ Bool must_authenticate;
+} _IceProtoSetupToMeInfo;
+
+typedef struct {
+ Bool auth_active;
+ char my_auth_index;
+ IcePointer my_auth_state;
+} _IceConnectToYouInfo;
+
+typedef struct {
+ int my_opcode;
+ int my_auth_count;
+ int *my_auth_indices;
+ Bool auth_active;
+ char my_auth_index;
+ IcePointer my_auth_state;
+} _IceProtoSetupToYouInfo;
+
+
+struct _IceConn {
+
+ unsigned int io_ok : 1; /* did an IO error occur? */
+ unsigned int swap : 1; /* do we need to swap on reads? */
+ unsigned int waiting_for_byteorder : 1; /* waiting for a ByteOrder msg? */
+ unsigned int skip_want_to_close : 1; /* avoid shutdown negotiation? */
+ unsigned int want_to_close : 1; /* did we send a WantToClose? */
+ unsigned int free_asap : 1; /* free as soon as possible */
+ unsigned int unused1 : 2; /* future use */
+ unsigned int unused2 : 8; /* future use */
+
+ IceConnectStatus connection_status; /* pending, accepted, rejected */
+
+ unsigned char my_ice_version_index; /* which version are we using? */
+
+ struct _XtransConnInfo *trans_conn; /* transport connection object */
+ unsigned long send_sequence; /* Sequence # of last msg sent */
+ unsigned long receive_sequence; /* Sequence # of last msg received */
+
+ char *connection_string; /* network connection string */
+ char *vendor; /* other client's vendor */
+ char *release; /* other client's release */
+
+ char *inbuf; /* Input buffer starting address */
+ char *inbufptr; /* Input buffer index pointer */
+ char *inbufmax; /* Input buffer maximum+1 address */
+
+ char *outbuf; /* Output buffer starting address */
+ char *outbufptr; /* Output buffer index pointer */
+ char *outbufmax; /* Output buffer maximum+1 address */
+
+ char *scratch; /* scratch buffer */
+ unsigned long scratch_size; /* scratch size */
+
+ int dispatch_level; /* IceProcessMessages dispatch level */
+
+ IcePointer context; /* context associated with caller
+ of IceOpenConnection */
+
+ /*
+ * Before we read a message, the major opcode of the message must be
+ * mapped to our corresponding major opcode (the two clients can use
+ * different opcodes for the same protocol). In order to save space,
+ * we keep track of the mininum and maximum major opcodes used by the
+ * other client. To get the information on how to process this message,
+ * we do the following...
+ *
+ * processMsgInfo = iceConn->process_msg_info[
+ * message->majorOpcode - iceConn->his_min_opcode]
+ *
+ * Note that the number of elements in the iceConn->process_msg_info
+ * array is always (iceConn->his_max_opcode - iceConn->his_min_opcode + 1).
+ * We check process_msg_info->in_use to see if the opcode is being used.
+ */
+
+ _IceProcessMsgInfo *process_msg_info;
+ char his_min_opcode; /* [1..255] */
+ char his_max_opcode; /* [1..255] */
+
+
+ /*
+ * Number of times this iceConn was returned in IceOpenConnection
+ * or IceAcceptConnection.
+ */
+
+ unsigned char open_ref_count;
+
+
+ /*
+ * Number of active protocols.
+ */
+
+ unsigned char proto_ref_count;
+
+
+ /*
+ * If this ICE connection was created with IceAcceptConnection,
+ * the listen_obj field is set to the listen object. Otherwise,
+ * the listen_obj field is NULL.
+ */
+
+ IceListenObj listen_obj;
+
+
+
+
+ /*
+ * We need to keep track of all the replies we're waiting for.
+ * Check the comments in process.c for how this works.
+ */
+
+ _IceSavedReplyWait *saved_reply_waits;
+
+
+ /*
+ * We keep track of all Pings sent from the client. When the Ping reply
+ * arrives, we remove it from the list.
+ */
+
+ _IcePingWait *ping_waits;
+
+
+ /*
+ * Some state for a client doing a Connection/Protocol Setup
+ */
+
+ _IceConnectToYouInfo *connect_to_you;
+ _IceProtoSetupToYouInfo *protosetup_to_you;
+
+
+ /*
+ * Some state for a client receiving a Connection/Protocol Setup
+ */
+
+ _IceConnectToMeInfo *connect_to_me;
+ _IceProtoSetupToMeInfo *protosetup_to_me;
+
+};
+
+#endif /* _ICECONN_H_ */
diff --git a/nx-X11/lib/ICE/ICElib.h b/nx-X11/lib/ICE/ICElib.h
new file mode 100644
index 000000000..eb7a3aa32
--- /dev/null
+++ b/nx-X11/lib/ICE/ICElib.h
@@ -0,0 +1,433 @@
+/* $Xorg: ICElib.h,v 1.5 2001/02/09 02:03:26 xorgcvs Exp $ */
+/******************************************************************************
+
+
+Copyright 1993, 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.
+
+Author: Ralph Mor, X Consortium
+******************************************************************************/
+/* $XFree86: xc/lib/ICE/ICElib.h,v 3.4 2001/12/14 19:53:35 dawes Exp $ */
+
+#ifndef _ICELIB_H_
+#define _ICELIB_H_
+
+#include <X11/ICE/ICE.h>
+#include <X11/Xfuncproto.h>
+
+#define Bool int
+#define Status int
+#define True 1
+#define False 0
+
+typedef void *IcePointer;
+
+typedef enum {
+ IcePoAuthHaveReply,
+ IcePoAuthRejected,
+ IcePoAuthFailed,
+ IcePoAuthDoneCleanup
+} IcePoAuthStatus;
+
+typedef enum {
+ IcePaAuthContinue,
+ IcePaAuthAccepted,
+ IcePaAuthRejected,
+ IcePaAuthFailed
+} IcePaAuthStatus;
+
+typedef enum {
+ IceConnectPending,
+ IceConnectAccepted,
+ IceConnectRejected,
+ IceConnectIOError
+} IceConnectStatus;
+
+typedef enum {
+ IceProtocolSetupSuccess,
+ IceProtocolSetupFailure,
+ IceProtocolSetupIOError,
+ IceProtocolAlreadyActive
+} IceProtocolSetupStatus;
+
+typedef enum {
+ IceAcceptSuccess,
+ IceAcceptFailure,
+ IceAcceptBadMalloc
+} IceAcceptStatus;
+
+typedef enum {
+ IceClosedNow,
+ IceClosedASAP,
+ IceConnectionInUse,
+ IceStartedShutdownNegotiation
+} IceCloseStatus;
+
+typedef enum {
+ IceProcessMessagesSuccess,
+ IceProcessMessagesIOError,
+ IceProcessMessagesConnectionClosed
+} IceProcessMessagesStatus;
+
+typedef struct {
+ unsigned long sequence_of_request;
+ int major_opcode_of_request;
+ int minor_opcode_of_request;
+ IcePointer reply;
+} IceReplyWaitInfo;
+
+typedef struct _IceConn *IceConn;
+typedef struct _IceListenObj *IceListenObj;
+
+typedef void (*IceWatchProc) (
+ IceConn /* iceConn */,
+ IcePointer /* clientData */,
+ Bool /* opening */,
+ IcePointer * /* watchData */
+);
+
+typedef void (*IcePoProcessMsgProc) (
+ IceConn /* iceConn */,
+ IcePointer /* clientData */,
+ int /* opcode */,
+ unsigned long /* length */,
+ Bool /* swap */,
+ IceReplyWaitInfo * /* replyWait */,
+ Bool * /* replyReadyRet */
+);
+
+typedef void (*IcePaProcessMsgProc) (
+ IceConn /* iceConn */,
+ IcePointer /* clientData */,
+ int /* opcode */,
+ unsigned long /* length */,
+ Bool /* swap */
+);
+
+typedef struct {
+ int major_version;
+ int minor_version;
+ IcePoProcessMsgProc process_msg_proc;
+} IcePoVersionRec;
+
+typedef struct {
+ int major_version;
+ int minor_version;
+ IcePaProcessMsgProc process_msg_proc;
+} IcePaVersionRec;
+
+typedef IcePoAuthStatus (*IcePoAuthProc) (
+ IceConn /* iceConn */,
+ IcePointer * /* authStatePtr */,
+ Bool /* cleanUp */,
+ Bool /* swap */,
+ int /* authDataLen */,
+ IcePointer /* authData */,
+ int * /* replyDataLenRet */,
+ IcePointer * /* replyDataRet */,
+ char ** /* errorStringRet */
+);
+
+typedef IcePaAuthStatus (*IcePaAuthProc) (
+ IceConn /* iceConn */,
+ IcePointer * /* authStatePtr */,
+ Bool /* swap */,
+ int /* authDataLen */,
+ IcePointer /* authData */,
+ int * /* replyDataLenRet */,
+ IcePointer * /* replyDataRet */,
+ char ** /* errorStringRet */
+);
+
+typedef Bool (*IceHostBasedAuthProc) (
+ char * /* hostName */
+);
+
+typedef Status (*IceProtocolSetupProc) (
+ IceConn /* iceConn */,
+ int /* majorVersion */,
+ int /* minorVersion */,
+ char * /* vendor */,
+ char * /* release */,
+ IcePointer * /* clientDataRet */,
+ char ** /* failureReasonRet */
+);
+
+typedef void (*IceProtocolActivateProc) (
+ IceConn /* iceConn */,
+ IcePointer /* clientData */
+);
+
+typedef void (*IceIOErrorProc) (
+ IceConn /* iceConn */
+);
+
+typedef void (*IcePingReplyProc) (
+ IceConn /* iceConn */,
+ IcePointer /* clientData */
+);
+
+typedef void (*IceErrorHandler) (
+ IceConn /* iceConn */,
+ Bool /* swap */,
+ int /* offendingMinorOpcode */,
+ unsigned long /* offendingSequence */,
+ int /* errorClass */,
+ int /* severity */,
+ IcePointer /* values */
+);
+
+typedef void (*IceIOErrorHandler) (
+ IceConn /* iceConn */
+);
+
+
+/*
+ * Function prototypes
+ */
+
+_XFUNCPROTOBEGIN
+
+extern int IceRegisterForProtocolSetup (
+ char * /* protocolName */,
+ char * /* vendor */,
+ char * /* release */,
+ int /* versionCount */,
+ IcePoVersionRec * /* versionRecs */,
+ int /* authCount */,
+ char ** /* authNames */,
+ IcePoAuthProc * /* authProcs */,
+ IceIOErrorProc /* IOErrorProc */
+);
+
+extern int IceRegisterForProtocolReply (
+ char * /* protocolName */,
+ char * /* vendor */,
+ char * /* release */,
+ int /* versionCount */,
+ IcePaVersionRec * /* versionRecs */,
+ int /* authCount */,
+ char ** /* authNames */,
+ IcePaAuthProc * /* authProcs */,
+ IceHostBasedAuthProc /* hostBasedAuthProc */,
+ IceProtocolSetupProc /* protocolSetupProc */,
+ IceProtocolActivateProc /* protocolActivateProc */,
+ IceIOErrorProc /* IOErrorProc */
+);
+
+extern IceConn IceOpenConnection (
+ char * /* networkIdsList */,
+ IcePointer /* context */,
+ Bool /* mustAuthenticate */,
+ int /* majorOpcodeCheck */,
+ int /* errorLength */,
+ char * /* errorStringRet */
+);
+
+extern IcePointer IceGetConnectionContext (
+ IceConn /* iceConn */
+);
+
+extern Status IceListenForConnections (
+ int * /* countRet */,
+ IceListenObj ** /* listenObjsRet */,
+ int /* errorLength */,
+ char * /* errorStringRet */
+);
+
+extern Status IceListenForWellKnownConnections (
+ char * /* port */,
+ int * /* countRet */,
+ IceListenObj ** /* listenObjsRet */,
+ int /* errorLength */,
+ char * /* errorStringRet */
+);
+
+extern int IceGetListenConnectionNumber (
+ IceListenObj /* listenObj */
+);
+
+extern char *IceGetListenConnectionString (
+ IceListenObj /* listenObj */
+);
+
+extern char *IceComposeNetworkIdList (
+ int /* count */,
+ IceListenObj * /* listenObjs */
+);
+
+extern void IceFreeListenObjs (
+ int /* count */,
+ IceListenObj * /* listenObjs */
+);
+
+extern void IceSetHostBasedAuthProc (
+ IceListenObj /* listenObj */,
+ IceHostBasedAuthProc /* hostBasedAuthProc */
+);
+
+extern IceConn IceAcceptConnection (
+ IceListenObj /* listenObj */,
+ IceAcceptStatus * /* statusRet */
+);
+
+extern void IceSetShutdownNegotiation (
+ IceConn /* iceConn */,
+ Bool /* negotiate */
+);
+
+extern Bool IceCheckShutdownNegotiation (
+ IceConn /* iceConn */
+);
+
+extern IceCloseStatus IceCloseConnection (
+ IceConn /* iceConn */
+);
+
+extern Status IceAddConnectionWatch (
+ IceWatchProc /* watchProc */,
+ IcePointer /* clientData */
+);
+
+extern void IceRemoveConnectionWatch (
+ IceWatchProc /* watchProc */,
+ IcePointer /* clientData */
+);
+
+extern IceProtocolSetupStatus IceProtocolSetup (
+ IceConn /* iceConn */,
+ int /* myOpcode */,
+ IcePointer /* clientData */,
+ Bool /* mustAuthenticate */,
+ int * /* majorVersionRet */,
+ int * /* minorVersionRet */,
+ char ** /* vendorRet */,
+ char ** /* releaseRet */,
+ int /* errorLength */,
+ char * /* errorStringRet */
+);
+
+extern Status IceProtocolShutdown (
+ IceConn /* iceConn */,
+ int /* majorOpcode */
+);
+
+extern IceProcessMessagesStatus IceProcessMessages (
+ IceConn /* iceConn */,
+ IceReplyWaitInfo * /* replyWait */,
+ Bool * /* replyReadyRet */
+);
+
+extern Status IcePing (
+ IceConn /* iceConn */,
+ IcePingReplyProc /* pingReplyProc */,
+ IcePointer /* clientData */
+);
+
+extern char *IceAllocScratch (
+ IceConn /* iceConn */,
+ unsigned long /* size */
+);
+
+extern int IceFlush (
+ IceConn /* iceConn */
+);
+
+extern int IceGetOutBufSize (
+ IceConn /* iceConn */
+);
+
+extern int IceGetInBufSize (
+ IceConn /* iceConn */
+);
+
+extern IceConnectStatus IceConnectionStatus (
+ IceConn /* iceConn */
+);
+
+extern char *IceVendor (
+ IceConn /* iceConn */
+);
+
+extern char *IceRelease (
+ IceConn /* iceConn */
+);
+
+extern int IceProtocolVersion (
+ IceConn /* iceConn */
+);
+
+extern int IceProtocolRevision (
+ IceConn /* iceConn */
+);
+
+extern int IceConnectionNumber (
+ IceConn /* iceConn */
+);
+
+extern char *IceConnectionString (
+ IceConn /* iceConn */
+);
+
+extern unsigned long IceLastSentSequenceNumber (
+ IceConn /* iceConn */
+);
+
+extern unsigned long IceLastReceivedSequenceNumber (
+ IceConn /* iceConn */
+);
+
+extern Bool IceSwapping (
+ IceConn /* iceConn */
+);
+
+extern IceErrorHandler IceSetErrorHandler (
+ IceErrorHandler /* handler */
+);
+
+extern IceIOErrorHandler IceSetIOErrorHandler (
+ IceIOErrorHandler /* handler */
+);
+
+extern char *IceGetPeerName (
+ IceConn /* iceConn */
+);
+
+/*
+ * Multithread Routines
+ */
+
+extern Status IceInitThreads (
+ void
+);
+
+extern void IceAppLockConn (
+ IceConn /* iceConn */
+);
+
+extern void IceAppUnlockConn (
+ IceConn /* iceConn */
+);
+
+_XFUNCPROTOEND
+
+#endif /* _ICELIB_H_ */
diff --git a/nx-X11/lib/ICE/ICElibint.h b/nx-X11/lib/ICE/ICElibint.h
new file mode 100644
index 000000000..fd84fdebf
--- /dev/null
+++ b/nx-X11/lib/ICE/ICElibint.h
@@ -0,0 +1,537 @@
+/* $Xorg: ICElibint.h,v 1.4 2001/02/09 02:03:26 xorgcvs Exp $ */
+/******************************************************************************
+
+
+Copyright 1993, 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.
+
+Author: Ralph Mor, X Consortium
+******************************************************************************/
+/* $XFree86: xc/lib/ICE/ICElibint.h,v 1.6 2001/12/14 19:53:35 dawes Exp $ */
+
+#ifndef _ICELIBINT_H_
+#define _ICELIBINT_H_
+
+#include <X11/Xos.h>
+#include <X11/Xfuncs.h>
+#include <X11/Xmd.h>
+#include <X11/ICE/ICEproto.h>
+#include <X11/ICE/ICEconn.h>
+#include <X11/ICE/ICEmsg.h>
+
+#include <stdlib.h>
+#include <stddef.h>
+
+
+/*
+ * Vendor & Release
+ */
+
+#define IceVendorString "MIT"
+#define IceReleaseString "1.0"
+
+
+/*
+ * Pad to a 64 bit boundary
+ */
+
+#define PAD64(_bytes) ((8 - ((unsigned int) (_bytes) % 8)) % 8)
+
+#define PADDED_BYTES64(_bytes) (_bytes + PAD64 (_bytes))
+
+
+/*
+ * Pad to 32 bit boundary
+ */
+
+#define PAD32(_bytes) ((4 - ((unsigned int) (_bytes) % 4)) % 4)
+
+#define PADDED_BYTES32(_bytes) (_bytes + PAD32 (_bytes))
+
+
+/*
+ * Number of 8 byte units in _bytes.
+ */
+
+#define WORD64COUNT(_bytes) (((unsigned int) ((_bytes) + 7)) >> 3)
+
+
+/*
+ * Number of 4 byte units in _bytes.
+ */
+
+#define WORD32COUNT(_bytes) (((unsigned int) ((_bytes) + 3)) >> 2)
+
+
+/*
+ * Given a string, compute the number of bytes for the STRING representation
+ */
+
+#define STRING_BYTES(_string) \
+ (2 + strlen (_string) + PAD32 (2 + strlen (_string)))
+
+
+/*
+ * Size of ICE input/output buffers
+ */
+
+#define ICE_INBUFSIZE 1024
+
+#define ICE_OUTBUFSIZE 1024
+
+
+/*
+ * Maxium number of ICE authentication methods allowed, and maxiumum
+ * number of authentication data entries allowed to be set in the
+ * IceSetPaAuthData function.
+ *
+ * We should use linked lists, but this is easier and should suffice.
+ */
+
+#define MAX_ICE_AUTH_NAMES 32
+#define ICE_MAX_AUTH_DATA_ENTRIES 100
+
+
+/*
+ * ICE listen object
+ */
+
+struct _IceListenObj {
+ struct _XtransConnInfo *trans_conn; /* transport connection object */
+ char *network_id;
+ IceHostBasedAuthProc host_based_auth_proc;
+};
+
+
+/*
+ * Some internal data structures for processing ICE messages.
+ */
+
+typedef void (*_IceProcessCoreMsgProc) (
+ IceConn /* iceConn */,
+ int /* opcode */,
+ unsigned long /* length */,
+ Bool /* swap */,
+ IceReplyWaitInfo * /* replyWait */,
+ Bool * /* replyReadyRet */,
+ Bool * /* connectionClosedRet */
+);
+
+typedef struct {
+ int major_version;
+ int minor_version;
+ _IceProcessCoreMsgProc process_core_msg_proc;
+} _IceVersion;
+
+
+/*
+ * STORE FOO
+ */
+
+#define STORE_CARD8(_pBuf, _val) \
+{ \
+ *((CARD8 *) _pBuf) = _val; \
+ _pBuf += 1; \
+}
+
+#ifndef WORD64
+
+#define STORE_CARD16(_pBuf, _val) \
+{ \
+ *((CARD16 *) _pBuf) = _val; \
+ _pBuf += 2; \
+}
+
+#define STORE_CARD32(_pBuf, _val) \
+{ \
+ *((CARD32 *) _pBuf) = _val; \
+ _pBuf += 4; \
+}
+
+#else /* WORD64 */
+
+#define STORE_CARD16(_pBuf, _val) \
+{ \
+ struct { \
+ int value :16; \
+ int pad :16; \
+ } _d; \
+ _d.value = _val; \
+ memcpy (_pBuf, &_d, 2); \
+ _pBuf += 2; \
+}
+
+#define STORE_CARD32(_pBuf, _val) \
+{ \
+ struct { \
+ int value :32; \
+ } _d; \
+ _d.value = _val; \
+ memcpy (_pBuf, &_d, 4); \
+ _pBuf += 4; \
+}
+
+#endif /* WORD64 */
+
+#define STORE_STRING(_pBuf, _string) \
+{ \
+ CARD16 _len = strlen (_string); \
+ STORE_CARD16 (_pBuf, _len); \
+ memcpy (_pBuf, _string, _len); \
+ _pBuf += _len; \
+ if (PAD32 (2 + _len)) \
+ _pBuf += PAD32 (2 + _len); \
+}
+
+
+/*
+ * EXTRACT FOO
+ */
+
+#define EXTRACT_CARD8(_pBuf, _val) \
+{ \
+ _val = *((CARD8 *) _pBuf); \
+ _pBuf += 1; \
+}
+
+#ifndef WORD64
+
+#define EXTRACT_CARD16(_pBuf, _swap, _val) \
+{ \
+ _val = *((CARD16 *) _pBuf); \
+ _pBuf += 2; \
+ if (_swap) \
+ _val = lswaps (_val); \
+}
+
+#define EXTRACT_CARD32(_pBuf, _swap, _val) \
+{ \
+ _val = *((CARD32 *) _pBuf); \
+ _pBuf += 4; \
+ if (_swap) \
+ _val = lswapl (_val); \
+}
+
+#else /* WORD64 */
+
+#define EXTRACT_CARD16(_pBuf, _swap, _val) \
+{ \
+ _val = *(_pBuf + 0) & 0xff; /* 0xff incase _pBuf is signed */ \
+ _val <<= 8; \
+ _val |= *(_pBuf + 1) & 0xff;\
+ _pBuf += 2; \
+ if (_swap) \
+ _val = lswaps (_val); \
+}
+
+#define EXTRACT_CARD32(_pBuf, _swap, _val) \
+{ \
+ _val = *(_pBuf + 0) & 0xff; /* 0xff incase _pBuf is signed */ \
+ _val <<= 8; \
+ _val |= *(_pBuf + 1) & 0xff;\
+ _val <<= 8; \
+ _val |= *(_pBuf + 2) & 0xff;\
+ _val <<= 8; \
+ _val |= *(_pBuf + 3) & 0xff;\
+ _pBuf += 4; \
+ if (_swap) \
+ _val = lswapl (_val); \
+}
+
+#endif /* WORD64 */
+
+#define EXTRACT_STRING(_pBuf, _swap, _string) \
+{ \
+ CARD16 _len; \
+ EXTRACT_CARD16 (_pBuf, _swap, _len); \
+ _string = (char *) malloc (_len + 1); \
+ memcpy (_string, _pBuf, _len); \
+ _pBuf += _len; \
+ _string[_len] = '\0'; \
+ if (PAD32 (2 + _len)) \
+ _pBuf += PAD32 (2 + _len); \
+}
+
+#define EXTRACT_LISTOF_STRING(_pBuf, _swap, _count, _strings) \
+{ \
+ int _i; \
+ for (_i = 0; _i < _count; _i++) \
+ EXTRACT_STRING (_pBuf, _swap, _strings[_i]); \
+}
+
+
+#define SKIP_STRING(_pBuf, _swap, _end, _bail) \
+{ \
+ CARD16 _len; \
+ EXTRACT_CARD16 (_pBuf, _swap, _len); \
+ _pBuf += _len + PAD32(2+_len); \
+ if (_pBuf > _end) { \
+ _bail; \
+ } \
+}
+
+#define SKIP_LISTOF_STRING(_pBuf, _swap, _count, _end, _bail) \
+{ \
+ int _i; \
+ for (_i = 0; _i < _count; _i++) \
+ SKIP_STRING (_pBuf, _swap, _end, _bail); \
+}
+
+
+
+/*
+ * Byte swapping
+ */
+
+/* byte swap a long literal */
+#define lswapl(_val) ((((_val) & 0xff) << 24) |\
+ (((_val) & 0xff00) << 8) |\
+ (((_val) & 0xff0000) >> 8) |\
+ (((_val) >> 24) & 0xff))
+
+/* byte swap a short literal */
+#define lswaps(_val) ((((_val) & 0xff) << 8) | (((_val) >> 8) & 0xff))
+
+
+
+/*
+ * ICE replies (not processed via callbacks because we block)
+ */
+
+#define ICE_CONNECTION_REPLY 1
+#define ICE_CONNECTION_ERROR 2
+#define ICE_PROTOCOL_REPLY 3
+#define ICE_PROTOCOL_ERROR 4
+
+typedef struct {
+ int type;
+ int version_index;
+ char *vendor;
+ char *release;
+} _IceConnectionReply;
+
+typedef struct {
+ int type;
+ char *error_message;
+} _IceConnectionError;
+
+typedef struct {
+ int type;
+ int major_opcode;
+ int version_index;
+ char *vendor;
+ char *release;
+} _IceProtocolReply;
+
+typedef struct {
+ int type;
+ char *error_message;
+} _IceProtocolError;
+
+
+typedef union {
+ int type;
+ _IceConnectionReply connection_reply;
+ _IceConnectionError connection_error;
+ _IceProtocolReply protocol_reply;
+ _IceProtocolError protocol_error;
+} _IceReply;
+
+
+/*
+ * Watch for ICE connection create/destroy.
+ */
+
+typedef struct _IceWatchedConnection {
+ IceConn iceConn;
+ IcePointer watch_data;
+ struct _IceWatchedConnection *next;
+} _IceWatchedConnection;
+
+typedef struct _IceWatchProc {
+ IceWatchProc watch_proc;
+ IcePointer client_data;
+ _IceWatchedConnection *watched_connections;
+ struct _IceWatchProc *next;
+} _IceWatchProc;
+
+
+/*
+ * Locking
+ */
+
+#define IceLockConn(_iceConn)
+#define IceUnlockConn(_iceConn)
+
+
+/*
+ * Extern declarations
+ */
+
+extern IceConn _IceConnectionObjs[];
+extern char *_IceConnectionStrings[];
+extern int _IceConnectionCount;
+
+extern _IceProtocol _IceProtocols[];
+extern int _IceLastMajorOpcode;
+
+extern int _IceAuthCount;
+extern char *_IceAuthNames[];
+extern IcePoAuthProc _IcePoAuthProcs[];
+extern IcePaAuthProc _IcePaAuthProcs[];
+
+extern int _IceVersionCount;
+extern _IceVersion _IceVersions[];
+
+extern _IceWatchProc *_IceWatchProcs;
+
+extern IceErrorHandler _IceErrorHandler;
+extern IceIOErrorHandler _IceIOErrorHandler;
+
+
+extern void _IceErrorBadMajor (
+ IceConn /* iceConn */,
+ int /* offendingMajor */,
+ int /* offendingMinor */,
+ int /* severity */
+);
+
+extern void _IceErrorNoAuthentication (
+ IceConn /* iceConn */,
+ int /* offendingMinor */
+);
+
+extern void _IceErrorNoVersion (
+ IceConn /* iceConn */,
+ int /* offendingMinor */
+);
+
+extern void _IceErrorSetupFailed (
+ IceConn /* iceConn */,
+ int /* offendingMinor */,
+ char * /* reason */
+);
+
+extern void _IceErrorAuthenticationRejected (
+ IceConn /* iceConn */,
+ int /* offendingMinor */,
+ char * /* reason */
+);
+
+extern void _IceErrorAuthenticationFailed (
+ IceConn /* iceConn */,
+ int /* offendingMinor */,
+ char * /* reason */
+);
+
+extern void _IceErrorProtocolDuplicate (
+ IceConn /* iceConn */,
+ char * /* protocolName */
+);
+
+extern void _IceErrorMajorOpcodeDuplicate (
+ IceConn /* iceConn */,
+ int /* majorOpcode */
+);
+
+extern void _IceErrorUnknownProtocol (
+ IceConn /* iceConn */,
+ char * /* protocolName */
+);
+
+extern void _IceAddOpcodeMapping (
+ IceConn /* iceConn */,
+ int /* hisOpcode */,
+ int /* myOpcode */
+);
+
+extern char *_IceGetPeerName (
+ IceConn /* iceConn */
+);
+
+extern void _IceFreeConnection (
+ IceConn /* iceConn */
+);
+
+extern void _IceAddReplyWait (
+ IceConn /* iceConn */,
+ IceReplyWaitInfo * /* replyWait */
+);
+
+extern IceReplyWaitInfo *_IceSearchReplyWaits (
+ IceConn /* iceConn */,
+ int /* majorOpcode */
+);
+
+extern void _IceSetReplyReady (
+ IceConn /* iceConn */,
+ IceReplyWaitInfo * /* replyWait */
+);
+
+extern Bool _IceCheckReplyReady (
+ IceConn /* iceConn */,
+ IceReplyWaitInfo * /* replyWait */
+);
+
+extern void _IceConnectionOpened (
+ IceConn /* iceConn */
+);
+
+extern void _IceConnectionClosed (
+ IceConn /* iceConn */
+);
+
+extern void _IceGetPoAuthData (
+ char * /* protocol_name */,
+ char * /* address */,
+ char * /* auth_name */,
+ unsigned short * /* auth_data_length_ret */,
+ char ** /* auth_data_ret */
+);
+
+extern void _IceGetPaAuthData (
+ char * /* protocol_name */,
+ char * /* address */,
+ char * /* auth_name */,
+ unsigned short * /* auth_data_length_ret */,
+ char ** /* auth_data_ret */
+);
+
+extern void _IceGetPoValidAuthIndices (
+ char * /* protocol_name */,
+ char * /* address */,
+ int /* num_auth_names */,
+ char ** /* auth_names */,
+ int * /* num_indices_ret */,
+ int * /* indices_ret */
+);
+
+extern void _IceGetPaValidAuthIndices (
+ char * /* protocol_name */,
+ char * /* address */,
+ int /* num_auth_names */,
+ char ** /* auth_names */,
+ int * /* num_indices_ret */,
+ int * /* indices_ret */
+);
+
+#endif /* _ICELIBINT_H_ */
diff --git a/nx-X11/lib/ICE/ICEmsg.h b/nx-X11/lib/ICE/ICEmsg.h
new file mode 100644
index 000000000..ddae02784
--- /dev/null
+++ b/nx-X11/lib/ICE/ICEmsg.h
@@ -0,0 +1,295 @@
+/* $Xorg: ICEmsg.h,v 1.4 2001/02/09 02:03:26 xorgcvs Exp $ */
+/******************************************************************************
+
+
+Copyright 1993, 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.
+
+Author: Ralph Mor, X Consortium
+******************************************************************************/
+/* $XFree86: xc/lib/ICE/ICEmsg.h,v 1.4 2001/12/20 19:40:59 tsi Exp $ */
+
+#ifndef _ICEMSG_H_
+#define _ICEMSG_H_
+
+#include <X11/Xfuncproto.h>
+
+#include <X11/ICE/ICEconn.h>
+
+_XFUNCPROTOBEGIN
+
+/*
+ * Function prototypes for internal ICElib functions
+ */
+
+extern Status _IceRead (
+ IceConn /* iceConn */,
+ unsigned long /* nbytes */,
+ char * /* ptr */
+);
+
+extern void _IceReadSkip (
+ IceConn /* iceConn */,
+ unsigned long /* nbytes */
+);
+
+extern void _IceWrite (
+ IceConn /* iceConn */,
+ unsigned long /* nbytes */,
+ char * /* ptr */
+);
+
+
+extern void _IceErrorBadMinor (
+ IceConn /* iceConn */,
+ int /* majorOpcode */,
+ int /* offendingMinor */,
+ int /* severity */
+);
+
+extern void _IceErrorBadState (
+ IceConn /* iceConn */,
+ int /* majorOpcode */,
+ int /* offendingMinor */,
+ int /* severity */
+);
+
+extern void _IceErrorBadLength (
+ IceConn /* iceConn */,
+ int /* majorOpcode */,
+ int /* offendingMinor */,
+ int /* severity */
+);
+
+extern void _IceErrorBadValue (
+ IceConn /* iceConn */,
+ int /* majorOpcode */,
+ int /* offendingMinor */,
+ int /* offset */,
+ int /* length */,
+ IcePointer /* value */
+);
+
+
+/*
+ * Macro to check if IO operations are valid on an ICE connection.
+ */
+
+#define IceValidIO(_iceConn) _iceConn->io_ok
+
+
+/*
+ * Macros for writing messages.
+ */
+
+#define IceGetHeader(_iceConn, _major, _minor, _headerSize, _msgType, _pMsg) \
+ if ((_iceConn->outbufptr + _headerSize) > _iceConn->outbufmax) \
+ IceFlush (_iceConn); \
+ _pMsg = (_msgType *) _iceConn->outbufptr; \
+ _pMsg->majorOpcode = _major; \
+ _pMsg->minorOpcode = _minor; \
+ _pMsg->length = (_headerSize - SIZEOF (iceMsg)) >> 3; \
+ _iceConn->outbufptr += _headerSize; \
+ _iceConn->send_sequence++
+
+#define IceGetHeaderExtra(_iceConn, _major, _minor, _headerSize, _extra, _msgType, _pMsg, _pData) \
+ if ((_iceConn->outbufptr + \
+ _headerSize + ((_extra) << 3)) > _iceConn->outbufmax) \
+ IceFlush (_iceConn); \
+ _pMsg = (_msgType *) _iceConn->outbufptr; \
+ if ((_iceConn->outbufptr + \
+ _headerSize + ((_extra) << 3)) <= _iceConn->outbufmax) \
+ _pData = (char *) _pMsg + _headerSize; \
+ else \
+ _pData = NULL; \
+ _pMsg->majorOpcode = _major; \
+ _pMsg->minorOpcode = _minor; \
+ _pMsg->length = ((_headerSize - SIZEOF (iceMsg)) >> 3) + (_extra); \
+ _iceConn->outbufptr += (_headerSize + ((_extra) << 3)); \
+ _iceConn->send_sequence++
+
+#define IceSimpleMessage(_iceConn, _major, _minor) \
+{ \
+ iceMsg *_pMsg; \
+ IceGetHeader (_iceConn, _major, _minor, SIZEOF (iceMsg), iceMsg, _pMsg); \
+}
+
+#define IceErrorHeader(_iceConn, _offendingMajorOpcode, _offendingMinorOpcode, _offendingSequenceNum, _severity, _errorClass, _dataLength) \
+{ \
+ iceErrorMsg *_pMsg; \
+\
+ IceGetHeader (_iceConn, _offendingMajorOpcode, ICE_Error, \
+ SIZEOF (iceErrorMsg), iceErrorMsg, _pMsg); \
+ _pMsg->length += (_dataLength); \
+ _pMsg->offendingMinorOpcode = _offendingMinorOpcode; \
+ _pMsg->severity = _severity; \
+ _pMsg->offendingSequenceNum = _offendingSequenceNum; \
+ _pMsg->errorClass = _errorClass; \
+}
+
+
+/*
+ * Write data into the ICE output buffer.
+ */
+
+#define IceWriteData(_iceConn, _bytes, _data) \
+{ \
+ if ((_iceConn->outbufptr + (_bytes)) > _iceConn->outbufmax) \
+ { \
+ IceFlush (_iceConn); \
+ _IceWrite (_iceConn, (unsigned long) (_bytes), _data); \
+ } \
+ else \
+ { \
+ memcpy (_iceConn->outbufptr, _data, _bytes); \
+ _iceConn->outbufptr += (_bytes); \
+ } \
+}
+
+#ifndef WORD64
+
+#define IceWriteData16(_iceConn, _bytes, _data) \
+ IceWriteData (_iceConn, _bytes, (char *) _data)
+
+#define IceWriteData32(_iceConn, _bytes, _data) \
+ IceWriteData (_iceConn, _bytes, (char *) _data)
+
+#else /* WORD64 */
+
+/* IceWriteData16 and IceWriteData32 defined in misc.c for WORD64 */
+
+#endif /* WORD64 */
+
+
+/*
+ * The IceSendData macro bypasses copying the data to the
+ * ICE connection buffer and sends the data directly. If necessary,
+ * the ICE connection buffer is first flushed.
+ */
+
+#define IceSendData(_iceConn, _bytes, _data) \
+{ \
+ if (_iceConn->outbufptr > _iceConn->outbuf) \
+ IceFlush (_iceConn); \
+ _IceWrite (_iceConn, (unsigned long) (_bytes), _data); \
+}
+
+
+/*
+ * Write pad bytes. Used to force 32 or 64 bit alignment.
+ * A maxium of 7 pad bytes can be specified.
+ */
+
+#define IceWritePad(_iceConn, _bytes) \
+{ \
+ if ((_iceConn->outbufptr + (_bytes)) > _iceConn->outbufmax) \
+ { \
+ char _dummy[7]; \
+ IceFlush (_iceConn); \
+ _IceWrite (_iceConn, (unsigned long) (_bytes), _dummy); \
+ } \
+ else \
+ { \
+ _iceConn->outbufptr += (_bytes); \
+ } \
+}
+
+
+/*
+ * Macros for reading messages.
+ */
+
+#define IceReadCompleteMessage(_iceConn, _headerSize, _msgType, _pMsg, _pData)\
+{ \
+ unsigned long _bytes; \
+ IceReadMessageHeader (_iceConn, _headerSize, _msgType, _pMsg); \
+ _bytes = (_pMsg->length << 3) - (_headerSize - SIZEOF (iceMsg)); \
+ if ((_iceConn->inbufmax - _iceConn->inbufptr) >= _bytes) \
+ { \
+ _IceRead (_iceConn, _bytes, _iceConn->inbufptr); \
+ _pData = _iceConn->inbufptr; \
+ _iceConn->inbufptr += _bytes; \
+ } \
+ else \
+ { \
+ _pData = (char *) malloc ((unsigned) _bytes); \
+ if (_pData) \
+ _IceRead (_iceConn, _bytes, _pData); \
+ else \
+ _IceReadSkip (_iceConn, _bytes); \
+ } \
+}
+
+#define IceDisposeCompleteMessage(_iceConn, _pData) \
+ if ((char *) _pData < _iceConn->inbuf || \
+ (char *) _pData >= _iceConn->inbufmax) \
+ free ((char *) _pData);
+
+
+#define IceReadSimpleMessage(_iceConn, _msgType, _pMsg) \
+ _pMsg = (_msgType *) (_iceConn->inbuf);
+
+#define IceReadMessageHeader(_iceConn, _headerSize, _msgType, _pMsg) \
+{ \
+ _IceRead (_iceConn, \
+ (unsigned long) (_headerSize - SIZEOF (iceMsg)), \
+ _iceConn->inbufptr); \
+ _pMsg = (_msgType *) (_iceConn->inbuf); \
+ _iceConn->inbufptr += (_headerSize - SIZEOF (iceMsg)); \
+}
+
+#define IceReadData(_iceConn, _bytes, _pData) \
+ _IceRead (_iceConn, (unsigned long) (_bytes), (char *) _pData); \
+
+#ifndef WORD64
+
+#define IceReadData16(_iceConn, _swap, _bytes, _pData) \
+{ \
+ _IceRead (_iceConn, (unsigned long) (_bytes), (char *) _pData); \
+}
+
+#define IceReadData32(_iceConn, _swap, _bytes, _pData) \
+{ \
+ _IceRead (_iceConn, (unsigned long) (_bytes), (char *) _pData); \
+}
+
+#else /* WORD64 */
+
+/* IceReadData16 and IceReadData32 defined in misc.c for WORD64 */
+
+#endif /* WORD64 */
+
+
+/*
+ * Read pad bytes (for 32 or 64 bit alignment).
+ * A maxium of 7 pad bytes can be specified.
+ */
+
+#define IceReadPad(_iceConn, _bytes) \
+{ \
+ char _dummy[7]; \
+ _IceRead (_iceConn, (unsigned long) (_bytes), _dummy); \
+}
+
+_XFUNCPROTOEND
+
+#endif /* _ICEMSG_H_ */
diff --git a/nx-X11/lib/ICE/ICEproto.h b/nx-X11/lib/ICE/ICEproto.h
new file mode 100644
index 000000000..9ca7c44ce
--- /dev/null
+++ b/nx-X11/lib/ICE/ICEproto.h
@@ -0,0 +1,176 @@
+/* $Xorg: ICEproto.h,v 1.5 2001/02/09 02:03:26 xorgcvs Exp $ */
+/******************************************************************************
+
+
+Copyright 1993, 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.
+
+Author: Ralph Mor, X Consortium
+******************************************************************************/
+
+#ifndef _ICEPROTO_H_
+#define _ICEPROTO_H_
+
+#include <X11/Xmd.h>
+
+typedef struct {
+ CARD8 majorOpcode;
+ CARD8 minorOpcode;
+ CARD8 data[2];
+ CARD32 length B32;
+} iceMsg;
+
+typedef struct {
+ CARD8 majorOpcode;
+ CARD8 minorOpcode;
+ CARD16 errorClass B16;
+ CARD32 length B32;
+ CARD8 offendingMinorOpcode;
+ CARD8 severity;
+ CARD16 unused B16;
+ CARD32 offendingSequenceNum B32;
+ /* n varying values */
+ /* p p = pad (n, 8) */
+} iceErrorMsg;
+
+typedef struct {
+ CARD8 majorOpcode;
+ CARD8 minorOpcode;
+ CARD8 byteOrder;
+ CARD8 unused;
+ CARD32 length B32;
+} iceByteOrderMsg;
+
+typedef struct {
+ CARD8 majorOpcode;
+ CARD8 minorOpcode;
+ CARD8 versionCount;
+ CARD8 authCount;
+ CARD32 length B32;
+ CARD8 mustAuthenticate;
+ CARD8 unused[7];
+ /* i STRING vendor */
+ /* j STRING release */
+ /* k LIST of STRING authentication-protocol-names */
+ /* m LIST of VERSION version-list */
+ /* p p = pad (i+j+k+m, 8) */
+} iceConnectionSetupMsg;
+
+typedef struct {
+ CARD8 majorOpcode;
+ CARD8 minorOpcode;
+ CARD8 authIndex;
+ CARD8 unused1;
+ CARD32 length B32;
+ CARD16 authDataLength B16;
+ CARD8 unused2[6];
+ /* n varying data */
+ /* p p = pad (n, 8) */
+} iceAuthRequiredMsg;
+
+typedef struct {
+ CARD8 majorOpcode;
+ CARD8 minorOpcode;
+ CARD8 unused1[2];
+ CARD32 length B32;
+ CARD16 authDataLength B16;
+ CARD8 unused2[6];
+ /* n varying data */
+ /* p p = pad (n, 8) */
+} iceAuthReplyMsg;
+
+typedef struct {
+ CARD8 majorOpcode;
+ CARD8 minorOpcode;
+ CARD8 unused1[2];
+ CARD32 length B32;
+ CARD16 authDataLength B16;
+ CARD8 unused2[6];
+ /* n varying data */
+ /* p p = pad (n, 8) */
+} iceAuthNextPhaseMsg;
+
+typedef struct {
+ CARD8 majorOpcode;
+ CARD8 minorOpcode;
+ CARD8 versionIndex;
+ CARD8 unused;
+ CARD32 length B32;
+ /* i STRING vendor */
+ /* j STRING release */
+ /* p p = pad (i+j, 8) */
+} iceConnectionReplyMsg;
+
+typedef struct {
+ CARD8 majorOpcode;
+ CARD8 minorOpcode;
+ CARD8 protocolOpcode;
+ CARD8 mustAuthenticate;
+ CARD32 length B32;
+ CARD8 versionCount;
+ CARD8 authCount;
+ CARD8 unused[6];
+ /* i STRING protocol-name */
+ /* j STRING vendor */
+ /* k STRING release */
+ /* m LIST of STRING authentication-protocol-names */
+ /* n LIST of VERSION version-list */
+ /* p p = pad (i+j+k+m+n, 8) */
+} iceProtocolSetupMsg;
+
+typedef struct {
+ CARD8 majorOpcode;
+ CARD8 minorOpcode;
+ CARD8 versionIndex;
+ CARD8 protocolOpcode;
+ CARD32 length B32;
+ /* i STRING vendor */
+ /* j STRING release */
+ /* p p = pad (i+j, 8) */
+} iceProtocolReplyMsg;
+
+typedef iceMsg icePingMsg;
+typedef iceMsg icePingReplyMsg;
+typedef iceMsg iceWantToCloseMsg;
+typedef iceMsg iceNoCloseMsg;
+
+
+/*
+ * SIZEOF values. These better be multiples of 8.
+ */
+
+#define sz_iceMsg 8
+#define sz_iceErrorMsg 16
+#define sz_iceByteOrderMsg 8
+#define sz_iceConnectionSetupMsg 16
+#define sz_iceAuthRequiredMsg 16
+#define sz_iceAuthReplyMsg 16
+#define sz_iceAuthNextPhaseMsg 16
+#define sz_iceConnectionReplyMsg 8
+#define sz_iceProtocolSetupMsg 16
+#define sz_iceProtocolReplyMsg 8
+#define sz_icePingMsg 8
+#define sz_icePingReplyMsg 8
+#define sz_iceWantToCloseMsg 8
+#define sz_iceNoCloseMsg 8
+
+#endif /* _ICEPROTO_H_ */
diff --git a/nx-X11/lib/ICE/ICEutil.h b/nx-X11/lib/ICE/ICEutil.h
new file mode 100644
index 000000000..8651d94eb
--- /dev/null
+++ b/nx-X11/lib/ICE/ICEutil.h
@@ -0,0 +1,126 @@
+/* $Xorg: ICEutil.h,v 1.5 2001/02/09 02:03:26 xorgcvs Exp $ */
+/******************************************************************************
+
+
+Copyright 1993, 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.
+
+Author: Ralph Mor, X Consortium
+******************************************************************************/
+/* $XFree86: xc/lib/ICE/ICEutil.h,v 1.4 2001/12/20 19:40:59 tsi Exp $ */
+
+#ifndef _ICEUTIL_H_
+#define _ICEUTIL_H_
+
+#include <X11/Xfuncproto.h>
+
+#include <stdio.h>
+
+_XFUNCPROTOBEGIN
+
+/*
+ * Data structure for entry in ICE authority file
+ */
+
+typedef struct {
+ char *protocol_name;
+ unsigned short protocol_data_length;
+ char *protocol_data;
+ char *network_id;
+ char *auth_name;
+ unsigned short auth_data_length;
+ char *auth_data;
+} IceAuthFileEntry;
+
+
+/*
+ * Authentication data maintained in memory.
+ */
+
+typedef struct {
+ char *protocol_name;
+ char *network_id;
+ char *auth_name;
+ unsigned short auth_data_length;
+ char *auth_data;
+} IceAuthDataEntry;
+
+
+/*
+ * Return values from IceLockAuthFile
+ */
+
+#define IceAuthLockSuccess 0 /* lock succeeded */
+#define IceAuthLockError 1 /* lock unexpectely failed, check errno */
+#define IceAuthLockTimeout 2 /* lock failed, timeouts expired */
+
+
+/*
+ * Function Prototypes
+ */
+
+extern char *IceAuthFileName (
+ void
+);
+
+extern int IceLockAuthFile (
+ char * /* file_name */,
+ int /* retries */,
+ int /* timeout */,
+ long /* dead */
+);
+
+extern void IceUnlockAuthFile (
+ char * /* file_name */
+);
+
+extern IceAuthFileEntry *IceReadAuthFileEntry (
+ FILE * /* auth_file */
+);
+
+extern void IceFreeAuthFileEntry (
+ IceAuthFileEntry * /* auth */
+);
+
+extern Status IceWriteAuthFileEntry (
+ FILE * /* auth_file */,
+ IceAuthFileEntry * /* auth */
+);
+
+extern IceAuthFileEntry *IceGetAuthFileEntry (
+ char * /* protocol_name */,
+ char * /* network_id */,
+ char * /* auth_name */
+);
+
+extern char *IceGenerateMagicCookie (
+ int /* len */
+);
+
+extern void IceSetPaAuthData (
+ int /* numEntries */,
+ IceAuthDataEntry * /* entries */
+);
+
+_XFUNCPROTOEND
+
+#endif /* _ICEUTIL_H_ */
diff --git a/nx-X11/lib/ICE/Imakefile b/nx-X11/lib/ICE/Imakefile
new file mode 100644
index 000000000..0dce0c7b4
--- /dev/null
+++ b/nx-X11/lib/ICE/Imakefile
@@ -0,0 +1,92 @@
+XCOMM $Xorg: Imakefile,v 1.3 2000/08/17 19:44:11 cpqbld Exp $
+
+
+
+
+XCOMM $XFree86: xc/lib/ICE/Imakefile,v 3.5 2001/04/23 16:17:06 tsi Exp $
+
+#define DoNormalLib NormalLibICE
+#define DoSharedLib SharedLibICE
+#define DoExtraLib SharedLibICE
+#define DoDebugLib DebugLibICE
+#define DoProfileLib ProfileLibICE
+#define LibName ICE
+#define SoRev SOICEREV
+#define IncSubdir X11
+#define IncSubSubdir ICE
+
+#ifdef SharedICEReqs
+REQUIREDLIBS = SharedICEReqs
+#endif
+
+#if (SystemV || SystemV4) && !HasSockets
+CONN_DEFINES = -DTCPCONN -DICE_t -DTRANS_CLIENT -DTRANS_SERVER $(XTRANS_FAILDEFINES)
+#else
+CONN_DEFINES = $(CONNECTION_FLAGS) -DICE_t -DTRANS_CLIENT -DTRANS_SERVER $(XTRANS_FAILDEFINES)
+#endif
+
+#if HasBSD44Sockets
+SOCK_DEFINES = -DBSD44SOCKETS
+#endif
+
+DEPEND_DEFINES = $(TRANS_INCLUDES) $(CONN_DEFINES) DependDefines
+
+HEADERS = ICE.h \
+ ICEconn.h \
+ ICEproto.h \
+ ICElib.h \
+ ICEmsg.h \
+ ICEutil.h
+
+SRCS = accept.c \
+ authutil.c \
+ connect.c \
+ error.c \
+ getauth.c \
+ iceauth.c \
+ listen.c \
+ listenwk.c \
+ locking.c \
+ misc.c \
+ ping.c \
+ process.c \
+ protosetup.c \
+ register.c \
+ replywait.c \
+ setauth.c \
+ shutdown.c \
+ transport.c \
+ watch.c
+
+OBJS = accept.o \
+ authutil.o \
+ connect.o \
+ error.o \
+ getauth.o \
+ iceauth.o \
+ listen.o \
+ listenwk.o \
+ locking.o \
+ misc.o \
+ ping.o \
+ process.o \
+ protosetup.o \
+ register.o \
+ replywait.o \
+ setauth.o \
+ shutdown.o \
+ transport.o \
+ watch.o
+
+#include <Library.tmpl>
+
+SpecialCLibObjectRule(accept,$(ICONFIGFILES),$(TRANS_INCLUDES) $(CONN_DEFINES))
+SpecialCLibObjectRule(connect,$(ICONFIGFILES),$(TRANS_INCLUDES) $(CONN_DEFINES))
+SpecialCLibObjectRule(listen,$(ICONFIGFILES),$(TRANS_INCLUDES) $(CONN_DEFINES))
+SpecialCLibObjectRule(listenwk,$(ICONFIGFILES),$(TRANS_INCLUDES) $(CONN_DEFINES))
+SpecialCLibObjectRule(misc,$(ICONFIGFILES),$(TRANS_INCLUDES) $(CONN_DEFINES))
+SpecialCLibObjectRule(shutdown,$(ICONFIGFILES),$(TRANS_INCLUDES) $(CONN_DEFINES))
+SpecialCLibObjectRule(transport,$(ICONFIGFILES),$(TRANS_INCLUDES) $(CONN_DEFINES) $(SOCK_DEFINES))
+LinkSourceFile(transport.c,$(TRANSCOMMSRC))
+
+DependTarget()
diff --git a/nx-X11/lib/ICE/accept.c b/nx-X11/lib/ICE/accept.c
new file mode 100644
index 000000000..df2b258c5
--- /dev/null
+++ b/nx-X11/lib/ICE/accept.c
@@ -0,0 +1,188 @@
+/* $Xorg: accept.c,v 1.4 2001/02/09 02:03:26 xorgcvs Exp $ */
+/******************************************************************************
+
+
+Copyright 1993, 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.
+
+Author: Ralph Mor, X Consortium
+******************************************************************************/
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+#include <X11/ICE/ICElib.h>
+#include "ICElibint.h"
+#include <X11/Xtrans/Xtrans.h>
+
+
+IceConn
+IceAcceptConnection (listenObj, statusRet)
+
+IceListenObj listenObj;
+IceAcceptStatus *statusRet;
+
+{
+ IceConn iceConn;
+ XtransConnInfo newconn;
+ iceByteOrderMsg *pMsg;
+ int endian, status;
+
+ /*
+ * Accept the connection.
+ */
+
+ if ((newconn = _IceTransAccept (listenObj->trans_conn, &status)) == 0)
+ {
+ if (status == TRANS_ACCEPT_BAD_MALLOC)
+ *statusRet = IceAcceptBadMalloc;
+ else
+ *statusRet = IceAcceptFailure;
+ return (NULL);
+ }
+
+
+ /*
+ * Set close-on-exec so that programs that fork() don't get confused.
+ */
+
+ _IceTransSetOption (newconn, TRANS_CLOSEONEXEC, 1);
+
+
+ /*
+ * Create an ICE object for this connection.
+ */
+
+ if ((iceConn = (IceConn) malloc (sizeof (struct _IceConn))) == NULL)
+ {
+ _IceTransClose (newconn);
+ *statusRet = IceAcceptBadMalloc;
+ return (NULL);
+ }
+
+ iceConn->listen_obj = listenObj;
+
+ iceConn->waiting_for_byteorder = True;
+ iceConn->connection_status = IceConnectPending;
+ iceConn->io_ok = True;
+ iceConn->dispatch_level = 0;
+ iceConn->context = NULL;
+ iceConn->my_ice_version_index = 0;
+
+ iceConn->trans_conn = newconn;
+ iceConn->send_sequence = 0;
+ iceConn->receive_sequence = 0;
+
+ iceConn->connection_string = (char *) malloc (
+ strlen (listenObj->network_id) + 1);
+
+ if (iceConn->connection_string == NULL)
+ {
+ _IceTransClose (newconn);
+ free ((char *) iceConn);
+ *statusRet = IceAcceptBadMalloc;
+ return (NULL);
+ }
+ else
+ strcpy (iceConn->connection_string, listenObj->network_id);
+
+ iceConn->vendor = NULL;
+ iceConn->release = NULL;
+
+ if ((iceConn->inbuf = iceConn->inbufptr =
+ (char *) malloc (ICE_INBUFSIZE)) != NULL)
+ {
+ iceConn->inbufmax = iceConn->inbuf + ICE_INBUFSIZE;
+ }
+ else
+ {
+ _IceTransClose (newconn);
+ free ((char *) iceConn);
+ *statusRet = IceAcceptBadMalloc;
+ return (NULL);
+ }
+
+ if ((iceConn->outbuf = iceConn->outbufptr =
+ (char *) malloc (ICE_OUTBUFSIZE)) != NULL)
+ {
+ iceConn->outbufmax = iceConn->outbuf + ICE_OUTBUFSIZE;
+ }
+ else
+ {
+ _IceTransClose (newconn);
+ free (iceConn->inbuf);
+ free ((char *) iceConn);
+ *statusRet = IceAcceptBadMalloc;
+ return (NULL);
+ }
+
+ iceConn->scratch = NULL;
+ iceConn->scratch_size = 0;
+
+ iceConn->open_ref_count = 1;
+ iceConn->proto_ref_count = 0;
+
+ iceConn->skip_want_to_close = False;
+ iceConn->want_to_close = False;
+ iceConn->free_asap = False;
+
+ iceConn->saved_reply_waits = NULL;
+ iceConn->ping_waits = NULL;
+
+ iceConn->process_msg_info = NULL;
+
+ iceConn->connect_to_you = NULL;
+ iceConn->protosetup_to_you = NULL;
+
+ iceConn->connect_to_me = NULL;
+ iceConn->protosetup_to_me = NULL;
+
+
+ /*
+ * Send our byte order.
+ */
+
+ IceGetHeader (iceConn, 0, ICE_ByteOrder,
+ SIZEOF (iceByteOrderMsg), iceByteOrderMsg, pMsg);
+
+ endian = 1;
+ if (*(char *) &endian)
+ pMsg->byteOrder = IceLSBfirst;
+ else
+ pMsg->byteOrder = IceMSBfirst;
+
+ IceFlush (iceConn);
+
+
+ if (_IceWatchProcs)
+ {
+ /*
+ * Notify the watch procedures that an iceConn was opened.
+ */
+
+ _IceConnectionOpened (iceConn);
+ }
+
+ *statusRet = IceAcceptSuccess;
+
+ return (iceConn);
+}
diff --git a/nx-X11/lib/ICE/authutil.c b/nx-X11/lib/ICE/authutil.c
new file mode 100644
index 000000000..7b620732e
--- /dev/null
+++ b/nx-X11/lib/ICE/authutil.c
@@ -0,0 +1,539 @@
+/* $Xorg: authutil.c,v 1.5 2001/02/09 02:03:26 xorgcvs Exp $ */
+/* $XdotOrg: xc/lib/ICE/authutil.c,v 1.4 2005/07/03 07:00:55 daniels Exp $ */
+/******************************************************************************
+
+
+Copyright 1993, 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.
+
+Author: Ralph Mor, X Consortium
+******************************************************************************/
+/* $XFree86: authutil.c,v 3.9 2002/05/31 18:45:41 dawes Exp $ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+#include <X11/ICE/ICElib.h>
+#include "ICElibint.h"
+#include <X11/ICE/ICEutil.h>
+#include <X11/Xos.h>
+#include <sys/stat.h>
+#include <errno.h>
+
+#include <time.h>
+#define Time_t time_t
+#ifdef __UNIXOS2__
+extern char* getenv(const char*);
+#define link rename
+#endif
+#ifndef X_NOT_POSIX
+#include <unistd.h>
+#else
+#ifndef WIN32
+extern unsigned sleep ();
+#else
+#define link rename
+#endif
+#endif
+
+static Status read_short ();
+static Status read_string ();
+static Status read_counted_string ();
+static Status write_short ();
+static Status write_string ();
+static Status write_counted_string ();
+
+
+
+/*
+ * The following routines are for manipulating the .ICEauthority file
+ * These are utility functions - they are not part of the standard
+ * ICE library specification.
+ */
+
+char *
+IceAuthFileName ()
+
+{
+ static char slashDotICEauthority[] = "/.ICEauthority";
+ char *name;
+ static char *buf;
+ static int bsize;
+ int size;
+#if defined(WIN32) || defined(__UNIXOS2__)
+#ifndef PATH_MAX
+#define PATH_MAX 512
+#endif
+ char dir[PATH_MAX];
+#endif
+
+ if ((name = getenv ("ICEAUTHORITY")))
+ return (name);
+
+ name = getenv ("HOME");
+
+ if (!name)
+ {
+#ifdef WIN32
+ register char *ptr1;
+ register char *ptr2;
+ int len1 = 0, len2 = 0;
+
+ if ((ptr1 = getenv("HOMEDRIVE")) && (ptr2 = getenv("HOMEDIR"))) {
+ len1 = strlen (ptr1);
+ len2 = strlen (ptr2);
+ } else if (ptr2 = getenv("USERNAME")) {
+ len1 = strlen (ptr1 = "/users/");
+ len2 = strlen (ptr2);
+ }
+ if ((len1 + len2 + 1) < PATH_MAX) {
+ sprintf (dir, "%s%s", ptr1, (ptr2) ? ptr2 : "");
+ name = dir;
+ }
+ if (!name)
+#endif
+#ifdef __UNIXOS2__
+ strcpy (dir,"c:");
+ name = dir;
+ if (!name)
+#endif
+ return (NULL);
+ }
+
+ size = strlen (name) + strlen (&slashDotICEauthority[1]) + 2;
+
+ if (size > bsize)
+ {
+ if (buf)
+ free (buf);
+ buf = malloc ((unsigned) size);
+ if (!buf)
+ return (NULL);
+ bsize = size;
+ }
+
+ strcpy (buf, name);
+ strcat (buf, slashDotICEauthority + (name[1] == '\0' ? 1 : 0));
+
+ return (buf);
+}
+
+
+
+int
+IceLockAuthFile (file_name, retries, timeout, dead)
+
+char *file_name;
+int retries;
+int timeout;
+long dead;
+
+{
+ char creat_name[1025], link_name[1025];
+ struct stat statb;
+ Time_t now;
+ int creat_fd = -1;
+
+ if ((int) strlen (file_name) > 1022)
+ return (IceAuthLockError);
+
+ strcpy (creat_name, file_name);
+ strcat (creat_name, "-c");
+ strcpy (link_name, file_name);
+ strcat (link_name, "-l");
+
+ if (stat (creat_name, &statb) != -1)
+ {
+ now = time ((Time_t *) 0);
+
+ /*
+ * NFS may cause ctime to be before now, special
+ * case a 0 deadtime to force lock removal
+ */
+
+ if (dead == 0 || now - statb.st_ctime > dead)
+ {
+ unlink (creat_name);
+ unlink (link_name);
+ }
+ }
+
+ while (retries > 0)
+ {
+ if (creat_fd == -1)
+ {
+ creat_fd = creat (creat_name, 0666);
+
+ if (creat_fd == -1)
+ {
+ if (errno != EACCES)
+ return (IceAuthLockError);
+ }
+ else
+ close (creat_fd);
+ }
+
+ if (creat_fd != -1)
+ {
+ if (link (creat_name, link_name) != -1)
+ return (IceAuthLockSuccess);
+
+ if (errno == ENOENT)
+ {
+ creat_fd = -1; /* force re-creat next time around */
+ continue;
+ }
+
+ if (errno != EEXIST)
+ return (IceAuthLockError);
+ }
+
+ sleep ((unsigned) timeout);
+ --retries;
+ }
+
+ return (IceAuthLockTimeout);
+}
+
+
+
+void
+IceUnlockAuthFile (file_name)
+
+char *file_name;
+
+{
+#ifndef WIN32
+ char creat_name[1025];
+#endif
+ char link_name[1025];
+
+ if ((int) strlen (file_name) > 1022)
+ return;
+
+#ifndef WIN32
+ strcpy (creat_name, file_name);
+ strcat (creat_name, "-c");
+#endif
+ strcpy (link_name, file_name);
+ strcat (link_name, "-l");
+
+#ifndef WIN32
+ unlink (creat_name);
+#endif
+ unlink (link_name);
+}
+
+
+
+IceAuthFileEntry *
+IceReadAuthFileEntry (auth_file)
+
+FILE *auth_file;
+
+{
+ IceAuthFileEntry local;
+ IceAuthFileEntry *ret;
+
+ local.protocol_name = NULL;
+ local.protocol_data = NULL;
+ local.network_id = NULL;
+ local.auth_name = NULL;
+ local.auth_data = NULL;
+
+ if (!read_string (auth_file, &local.protocol_name))
+ return (NULL);
+
+ if (!read_counted_string (auth_file,
+ &local.protocol_data_length, &local.protocol_data))
+ goto bad;
+
+ if (!read_string (auth_file, &local.network_id))
+ goto bad;
+
+ if (!read_string (auth_file, &local.auth_name))
+ goto bad;
+
+ if (!read_counted_string (auth_file,
+ &local.auth_data_length, &local.auth_data))
+ goto bad;
+
+ if (!(ret = (IceAuthFileEntry *) malloc (sizeof (IceAuthFileEntry))))
+ goto bad;
+
+ *ret = local;
+
+ return (ret);
+
+ bad:
+
+ if (local.protocol_name) free (local.protocol_name);
+ if (local.protocol_data) free (local.protocol_data);
+ if (local.network_id) free (local.network_id);
+ if (local.auth_name) free (local.auth_name);
+ if (local.auth_data) free (local.auth_data);
+
+ return (NULL);
+}
+
+
+
+void
+IceFreeAuthFileEntry (auth)
+
+IceAuthFileEntry *auth;
+
+{
+ if (auth)
+ {
+ if (auth->protocol_name) free (auth->protocol_name);
+ if (auth->protocol_data) free (auth->protocol_data);
+ if (auth->network_id) free (auth->network_id);
+ if (auth->auth_name) free (auth->auth_name);
+ if (auth->auth_data) free (auth->auth_data);
+ free ((char *) auth);
+ }
+}
+
+
+
+Status
+IceWriteAuthFileEntry (auth_file, auth)
+
+FILE *auth_file;
+IceAuthFileEntry *auth;
+
+{
+ if (!write_string (auth_file, auth->protocol_name))
+ return (0);
+
+ if (!write_counted_string (auth_file,
+ auth->protocol_data_length, auth->protocol_data))
+ return (0);
+
+ if (!write_string (auth_file, auth->network_id))
+ return (0);
+
+ if (!write_string (auth_file, auth->auth_name))
+ return (0);
+
+ if (!write_counted_string (auth_file,
+ auth->auth_data_length, auth->auth_data))
+ return (0);
+
+ return (1);
+}
+
+
+
+IceAuthFileEntry *
+IceGetAuthFileEntry (protocol_name, network_id, auth_name)
+
+char *protocol_name;
+char *network_id;
+char *auth_name;
+
+{
+ FILE *auth_file;
+ char *filename;
+ IceAuthFileEntry *entry;
+
+ if (!(filename = IceAuthFileName ()))
+ return (NULL);
+
+ if (access (filename, R_OK) != 0) /* checks REAL id */
+ return (NULL);
+
+ if (!(auth_file = fopen (filename, "rb")))
+ return (NULL);
+
+ for (;;)
+ {
+ if (!(entry = IceReadAuthFileEntry (auth_file)))
+ break;
+
+ if (strcmp (protocol_name, entry->protocol_name) == 0 &&
+ strcmp (network_id, entry->network_id) == 0 &&
+ strcmp (auth_name, entry->auth_name) == 0)
+ {
+ break;
+ }
+
+ IceFreeAuthFileEntry (entry);
+ }
+
+ fclose (auth_file);
+
+ return (entry);
+}
+
+
+
+/*
+ * local routines
+ */
+
+static Status
+read_short (file, shortp)
+
+FILE *file;
+unsigned short *shortp;
+
+{
+ unsigned char file_short[2];
+
+ if (fread ((char *) file_short, (int) sizeof (file_short), 1, file) != 1)
+ return (0);
+
+ *shortp = file_short[0] * 256 + file_short[1];
+ return (1);
+}
+
+
+static Status
+read_string (file, stringp)
+
+FILE *file;
+char **stringp;
+
+{
+ unsigned short len;
+ char *data;
+
+ if (!read_short (file, &len))
+ return (0);
+
+ data = malloc ((unsigned) len + 1);
+
+ if (!data)
+ return (0);
+
+ if (len != 0)
+ {
+ if (fread (data, (int) sizeof (char), (int) len, file) != len)
+ {
+ free (data);
+ return (0);
+ }
+
+ }
+ data[len] = '\0';
+
+ *stringp = data;
+
+ return (1);
+}
+
+
+static Status
+read_counted_string (file, countp, stringp)
+
+FILE *file;
+unsigned short *countp;
+char **stringp;
+
+{
+ unsigned short len;
+ char *data;
+
+ if (!read_short (file, &len))
+ return (0);
+
+ if (len == 0)
+ {
+ data = 0;
+ }
+ else
+ {
+ data = malloc ((unsigned) len);
+
+ if (!data)
+ return (0);
+
+ if (fread (data, (int) sizeof (char), (int) len, file) != len)
+ {
+ free (data);
+ return (0);
+ }
+ }
+
+ *stringp = data;
+ *countp = len;
+
+ return (1);
+}
+
+
+static Status
+write_short (file, s)
+
+FILE *file;
+unsigned short s;
+
+{
+ unsigned char file_short[2];
+
+ file_short[0] = (s & (unsigned) 0xff00) >> 8;
+ file_short[1] = s & 0xff;
+
+ if (fwrite ((char *) file_short, (int) sizeof (file_short), 1, file) != 1)
+ return (0);
+
+ return (1);
+}
+
+
+static Status
+write_string (file, string)
+
+FILE *file;
+char *string;
+
+{
+ unsigned short count = strlen (string);
+
+ if (!write_short (file, count))
+ return (0);
+
+ if (fwrite (string, (int) sizeof (char), (int) count, file) != count)
+ return (0);
+
+ return (1);
+}
+
+
+static Status
+write_counted_string (file, count, string)
+
+FILE *file;
+unsigned short count;
+char *string;
+
+{
+ if (!write_short (file, count))
+ return (0);
+
+ if (fwrite (string, (int) sizeof (char), (int) count, file) != count)
+ return (0);
+
+ return (1);
+}
diff --git a/nx-X11/lib/ICE/connect.c b/nx-X11/lib/ICE/connect.c
new file mode 100644
index 000000000..e06aa04bc
--- /dev/null
+++ b/nx-X11/lib/ICE/connect.c
@@ -0,0 +1,543 @@
+/* $Xorg: connect.c,v 1.4 2001/02/09 02:03:26 xorgcvs Exp $ */
+/******************************************************************************
+
+
+Copyright 1993, 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.
+
+Author: Ralph Mor, X Consortium
+******************************************************************************/
+/* $XFree86: xc/lib/ICE/connect.c,v 3.9 2001/12/14 19:53:35 dawes Exp $ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+#include <X11/ICE/ICElib.h>
+#include "ICElibint.h"
+#include <X11/Xtrans/Xtrans.h>
+#include "globals.h"
+
+static XtransConnInfo ConnectToPeer();
+
+#define Strstr strstr
+
+IceConn
+IceOpenConnection (networkIdsList, context, mustAuthenticate, majorOpcodeCheck,
+ errorLength, errorStringRet)
+
+char *networkIdsList;
+IcePointer context;
+Bool mustAuthenticate;
+int majorOpcodeCheck;
+int errorLength;
+char *errorStringRet;
+
+{
+ IceConn iceConn;
+ int extra, i, j;
+ int endian;
+ Bool gotReply, ioErrorOccured;
+ unsigned long setup_sequence;
+ iceByteOrderMsg *pByteOrderMsg;
+ iceConnectionSetupMsg *pSetupMsg;
+ char *pData;
+ IceReplyWaitInfo replyWait;
+ _IceReply reply;
+ int authUsableCount;
+ int authUsableFlags[MAX_ICE_AUTH_NAMES];
+ int authIndices[MAX_ICE_AUTH_NAMES];
+
+ if (errorStringRet && errorLength > 0)
+ *errorStringRet = '\0';
+
+ if (networkIdsList == NULL || *networkIdsList == '\0')
+ {
+ strncpy (errorStringRet,
+ "networkIdsList argument is NULL", errorLength);
+ return (NULL);
+ }
+
+ /*
+ * Check to see if we can use a previously created ICE connection.
+ *
+ * If iceConn->want_to_close is True, or iceConn->free_asap is True,
+ * we can not use the iceConn.
+ *
+ * If 'context' is non-NULL, we will only use a previously opened ICE
+ * connection if the specified 'context' is equal to the context
+ * associated with the ICE connection, or if the context associated
+ * with the ICE connection is NULL.
+ *
+ * If 'majorOpcodeCheck' is non-zero, it will contain a protocol major
+ * opcode that we should make sure is not already active on the ICE
+ * connection. Some clients will want two seperate connections for the
+ * same protocol to the same destination client.
+ */
+
+ for (i = 0; i < _IceConnectionCount; i++)
+ {
+ char *strptr;
+ if ((strptr = (char *) Strstr (
+ networkIdsList, _IceConnectionStrings[i])) != NULL)
+ {
+ char ch = *(strptr + strlen (_IceConnectionStrings[i]));
+ if (ch == ',' || ch == '\0')
+ {
+ /*
+ * OK, we found a connection. Make sure we can reuse it.
+ */
+
+ IceConn iceConn = _IceConnectionObjs[i];
+
+ if (iceConn->want_to_close || iceConn->free_asap ||
+ (context && iceConn->context &&
+ iceConn->context != context))
+ {
+ /* force a new connection to be created */
+ break;
+ }
+
+ if (majorOpcodeCheck)
+ {
+ for (j = iceConn->his_min_opcode;
+ j <= iceConn->his_max_opcode; j++)
+ {
+ if (iceConn->process_msg_info[
+ j - iceConn->his_min_opcode].in_use &&
+ iceConn->process_msg_info[
+ j - iceConn->his_min_opcode].my_opcode ==
+ majorOpcodeCheck)
+ break;
+ }
+
+ if (j <= iceConn->his_max_opcode ||
+ (iceConn->protosetup_to_you &&
+ iceConn->protosetup_to_you->my_opcode ==
+ majorOpcodeCheck))
+ {
+ /* force a new connection to be created */
+ break;
+ }
+ }
+
+ iceConn->open_ref_count++;
+ if (context && !iceConn->context)
+ iceConn->context = context;
+ return (iceConn);
+ }
+ }
+ }
+
+ if ((iceConn = (IceConn) malloc (sizeof (struct _IceConn))) == NULL)
+ {
+ strncpy (errorStringRet, "Can't malloc", errorLength);
+ return (NULL);
+ }
+
+
+ /*
+ * Open a network connection with the peer client.
+ */
+
+ if ((iceConn->trans_conn = ConnectToPeer (networkIdsList,
+ &iceConn->connection_string)) == NULL)
+ {
+ free ((char *) iceConn);
+ strncpy (errorStringRet, "Could not open network socket", errorLength);
+ return (NULL);
+ }
+
+ /*
+ * Set close-on-exec so that programs that fork() don't get confused.
+ */
+
+ _IceTransSetOption (iceConn->trans_conn, TRANS_CLOSEONEXEC, 1);
+
+ iceConn->listen_obj = NULL;
+
+ iceConn->connection_status = IceConnectPending;
+ iceConn->io_ok = True;
+ iceConn->dispatch_level = 0;
+ iceConn->context = context;
+ iceConn->my_ice_version_index = 0;
+ iceConn->send_sequence = 0;
+ iceConn->receive_sequence = 0;
+
+ iceConn->vendor = NULL;
+ iceConn->release = NULL;
+ iceConn->outbuf = NULL;
+
+ iceConn->scratch = NULL;
+ iceConn->scratch_size = 0;
+
+ iceConn->process_msg_info = NULL;
+
+ iceConn->connect_to_you = NULL;
+ iceConn->protosetup_to_you = NULL;
+
+ iceConn->connect_to_me = NULL;
+ iceConn->protosetup_to_me = NULL;
+
+ if ((iceConn->inbuf = iceConn->inbufptr =
+ (char *) malloc (ICE_INBUFSIZE)) == NULL)
+ {
+ _IceFreeConnection (iceConn);
+ strncpy (errorStringRet, "Can't malloc", errorLength);
+ return (NULL);
+ }
+
+ iceConn->inbufmax = iceConn->inbuf + ICE_INBUFSIZE;
+
+ if ((iceConn->outbuf = iceConn->outbufptr =
+ (char *) calloc (1, ICE_OUTBUFSIZE)) == NULL)
+ {
+ _IceFreeConnection (iceConn);
+ strncpy (errorStringRet, "Can't malloc", errorLength);
+ return (NULL);
+ }
+
+ iceConn->outbufmax = iceConn->outbuf + ICE_OUTBUFSIZE;
+
+ iceConn->open_ref_count = 1;
+ iceConn->proto_ref_count = 0;
+
+ iceConn->skip_want_to_close = False;
+ iceConn->want_to_close = False;
+ iceConn->free_asap = False;
+
+ iceConn->saved_reply_waits = NULL;
+ iceConn->ping_waits = NULL;
+
+ iceConn->connect_to_you = (_IceConnectToYouInfo *) malloc (
+ sizeof (_IceConnectToYouInfo));
+ iceConn->connect_to_you->auth_active = 0;
+
+ /*
+ * Send our byte order.
+ */
+
+ IceGetHeader (iceConn, 0, ICE_ByteOrder,
+ SIZEOF (iceByteOrderMsg), iceByteOrderMsg, pByteOrderMsg);
+
+ endian = 1;
+ if (*(char *) &endian)
+ pByteOrderMsg->byteOrder = IceLSBfirst;
+ else
+ pByteOrderMsg->byteOrder = IceMSBfirst;
+
+ IceFlush (iceConn);
+
+
+ /*
+ * Now read the ByteOrder message from the other client.
+ * iceConn->swap should be set to the appropriate boolean
+ * value after the call to IceProcessMessages.
+ */
+
+ iceConn->waiting_for_byteorder = True;
+
+ ioErrorOccured = False;
+ while (iceConn->waiting_for_byteorder == True && !ioErrorOccured)
+ {
+ ioErrorOccured = (IceProcessMessages (
+ iceConn, NULL, NULL) == IceProcessMessagesIOError);
+ }
+
+ if (ioErrorOccured)
+ {
+ _IceFreeConnection (iceConn);
+ strncpy (errorStringRet, "IO error occured opening connection",
+ errorLength);
+ return (NULL);
+ }
+
+ if (iceConn->connection_status == IceConnectRejected)
+ {
+ /*
+ * We failed to get the required ByteOrder message.
+ */
+
+ _IceFreeConnection (iceConn);
+ strncpy (errorStringRet,
+ "Internal error - did not receive the expected ByteOrder message",
+ errorLength);
+ return (NULL);
+ }
+
+
+ /*
+ * Determine which authentication methods are available for
+ * the Connection Setup authentication.
+ */
+
+ _IceGetPoValidAuthIndices (
+ "ICE", iceConn->connection_string,
+ _IceAuthCount, _IceAuthNames, &authUsableCount, authIndices);
+
+ for (i = 0; i < _IceAuthCount; i++)
+ {
+ authUsableFlags[i] = 0;
+ for (j = 0; j < authUsableCount && !authUsableFlags[i]; j++)
+ authUsableFlags[i] = (authIndices[j] == i);
+ }
+
+
+ /*
+ * Now send a Connection Setup message.
+ */
+
+ extra = STRING_BYTES (IceVendorString) + STRING_BYTES (IceReleaseString);
+
+ for (i = 0; i < _IceAuthCount; i++)
+ if (authUsableFlags[i])
+ {
+ extra += STRING_BYTES (_IceAuthNames[i]);
+ }
+
+ extra += (_IceVersionCount * 4);
+
+ IceGetHeaderExtra (iceConn, 0, ICE_ConnectionSetup,
+ SIZEOF (iceConnectionSetupMsg), WORD64COUNT (extra),
+ iceConnectionSetupMsg, pSetupMsg, pData);
+
+ setup_sequence = iceConn->send_sequence;
+
+ pSetupMsg->versionCount = _IceVersionCount;
+ pSetupMsg->authCount = authUsableCount;
+ pSetupMsg->mustAuthenticate = mustAuthenticate;
+
+ STORE_STRING (pData, IceVendorString);
+ STORE_STRING (pData, IceReleaseString);
+
+ for (i = 0; i < _IceAuthCount; i++)
+ if (authUsableFlags[i])
+ {
+ STORE_STRING (pData, _IceAuthNames[i]);
+ }
+
+ for (i = 0; i < _IceVersionCount; i++)
+ {
+ STORE_CARD16 (pData, _IceVersions[i].major_version);
+ STORE_CARD16 (pData, _IceVersions[i].minor_version);
+ }
+
+ IceFlush (iceConn);
+
+
+ /*
+ * Process messages until we get a Connection Reply or an Error Message.
+ * Authentication will take place behind the scenes.
+ */
+
+ replyWait.sequence_of_request = setup_sequence;
+ replyWait.major_opcode_of_request = 0;
+ replyWait.minor_opcode_of_request = ICE_ConnectionSetup;
+ replyWait.reply = (IcePointer) &reply;
+
+ gotReply = False;
+ ioErrorOccured = False;
+
+ while (!gotReply && !ioErrorOccured)
+ {
+ ioErrorOccured = (IceProcessMessages (
+ iceConn, &replyWait, &gotReply) == IceProcessMessagesIOError);
+
+ if (ioErrorOccured)
+ {
+ strncpy (errorStringRet, "IO error occured opening connection",
+ errorLength);
+ _IceFreeConnection (iceConn);
+ iceConn = NULL;
+ }
+ else if (gotReply)
+ {
+ if (reply.type == ICE_CONNECTION_REPLY)
+ {
+ if (reply.connection_reply.version_index >= _IceVersionCount)
+ {
+ strncpy (errorStringRet,
+ "Got a bad version index in the Connection Reply",
+ errorLength);
+
+ free (reply.connection_reply.vendor);
+ free (reply.connection_reply.release);
+ _IceFreeConnection (iceConn);
+ iceConn = NULL;
+ }
+ else
+ {
+ iceConn->my_ice_version_index =
+ reply.connection_reply.version_index;
+ iceConn->vendor = reply.connection_reply.vendor;
+ iceConn->release = reply.connection_reply.release;
+
+ _IceConnectionObjs[_IceConnectionCount] = iceConn;
+ _IceConnectionStrings[_IceConnectionCount] =
+ iceConn->connection_string;
+ _IceConnectionCount++;
+
+ free ((char *) iceConn->connect_to_you);
+ iceConn->connect_to_you = NULL;
+
+ iceConn->connection_status = IceConnectAccepted;
+ }
+ }
+ else /* reply.type == ICE_CONNECTION_ERROR */
+ {
+ /* Connection failed */
+
+ strncpy (errorStringRet, reply.connection_error.error_message,
+ errorLength);
+
+ free (reply.connection_error.error_message);
+
+ _IceFreeConnection (iceConn);
+ iceConn = NULL;
+ }
+ }
+ }
+
+ if (iceConn && _IceWatchProcs)
+ {
+ /*
+ * Notify the watch procedures that an iceConn was opened.
+ */
+
+ _IceConnectionOpened (iceConn);
+ }
+
+ return (iceConn);
+}
+
+
+
+IcePointer
+IceGetConnectionContext (iceConn)
+
+IceConn iceConn;
+
+{
+ return (iceConn->context);
+}
+
+
+
+/* ------------------------------------------------------------------------- *
+ * local routines *
+ * ------------------------------------------------------------------------- */
+
+#define ICE_CONNECTION_RETRIES 5
+
+
+static XtransConnInfo
+ConnectToPeer (networkIdsList, actualConnectionRet)
+
+char *networkIdsList;
+char **actualConnectionRet;
+
+{
+ char addrbuf[256];
+ char* address;
+ char *ptr, *endptr, *delim;
+ int madeConnection = 0;
+ int len, retry;
+ int connect_stat;
+ int address_size;
+ XtransConnInfo trans_conn = NULL;
+
+ *actualConnectionRet = NULL;
+
+ ptr = networkIdsList;
+ len = strlen (networkIdsList);
+ endptr = networkIdsList + len;
+
+ if (len < sizeof addrbuf)
+ {
+ address = addrbuf;
+ address_size = 256;
+ }
+ else
+ {
+ address = malloc (len + 1);
+ address_size = len;
+ }
+
+ while (ptr < endptr && !madeConnection)
+ {
+ if ((delim = (char *) strchr (ptr, ',')) == NULL)
+ delim = endptr;
+
+ len = delim - ptr;
+ if (len > address_size - 1)
+ len = address_size - 1;
+ strncpy (address, ptr, len);
+ address[len] = '\0';
+
+ ptr = delim + 1;
+
+ for (retry = ICE_CONNECTION_RETRIES; retry >= 0; retry--)
+ {
+ if ((trans_conn = _IceTransOpenCOTSClient (address)) == NULL)
+ {
+ break;
+ }
+
+ if ((connect_stat = _IceTransConnect (trans_conn, address)) < 0)
+ {
+ _IceTransClose (trans_conn);
+
+ if (connect_stat == TRANS_TRY_CONNECT_AGAIN)
+ {
+ sleep(1);
+ continue;
+ }
+ else
+ break;
+ }
+ else
+ {
+ madeConnection = 1;
+ break;
+ }
+ }
+ }
+
+ if (madeConnection)
+ {
+ /*
+ * We need to return the actual network connection string
+ */
+
+ *actualConnectionRet = (char *) malloc (strlen (address) + 1);
+ strcpy (*actualConnectionRet, address);
+
+
+ /*
+ * Return the file descriptor
+ */
+ }
+ else trans_conn = NULL;
+
+ if (address != addrbuf) free (address);
+
+ return trans_conn;
+}
diff --git a/nx-X11/lib/ICE/error.c b/nx-X11/lib/ICE/error.c
new file mode 100644
index 000000000..49b164bcc
--- /dev/null
+++ b/nx-X11/lib/ICE/error.c
@@ -0,0 +1,641 @@
+/* $Xorg: error.c,v 1.4 2001/02/09 02:03:26 xorgcvs Exp $ */
+/******************************************************************************
+
+
+Copyright 1993, 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.
+
+Author: Ralph Mor, X Consortium
+******************************************************************************/
+/* $XFree86: xc/lib/ICE/error.c,v 1.5 2001/10/28 03:32:28 tsi Exp $ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+#include <X11/ICE/ICElib.h>
+#include "ICElibint.h"
+#include <stdio.h>
+
+#include <errno.h>
+
+
+void
+_IceErrorBadMinor (iceConn, majorOpcode, offendingMinor, severity)
+
+IceConn iceConn;
+int majorOpcode;
+int offendingMinor;
+int severity;
+
+{
+ IceErrorHeader (iceConn,
+ majorOpcode, offendingMinor,
+ iceConn->receive_sequence,
+ severity,
+ IceBadMinor,
+ 0);
+
+ IceFlush (iceConn);
+}
+
+
+void
+_IceErrorBadState (iceConn, majorOpcode, offendingMinor, severity)
+
+IceConn iceConn;
+int majorOpcode;
+int offendingMinor;
+int severity;
+
+{
+ IceErrorHeader (iceConn,
+ majorOpcode, offendingMinor,
+ iceConn->receive_sequence,
+ severity,
+ IceBadState,
+ 0);
+
+ IceFlush (iceConn);
+}
+
+
+void
+_IceErrorBadLength (iceConn, majorOpcode, offendingMinor, severity)
+
+IceConn iceConn;
+int majorOpcode;
+int offendingMinor;
+int severity;
+
+{
+ IceErrorHeader (iceConn,
+ majorOpcode, offendingMinor,
+ iceConn->receive_sequence,
+ severity,
+ IceBadLength,
+ 0);
+
+ IceFlush (iceConn);
+}
+
+
+void
+_IceErrorBadValue (iceConn, majorOpcode, offendingMinor, offset, length, value)
+
+IceConn iceConn;
+int majorOpcode;
+int offendingMinor;
+int offset;
+int length; /* in bytes */
+IcePointer value;
+
+{
+ IceErrorHeader (iceConn,
+ majorOpcode, offendingMinor,
+ iceConn->receive_sequence,
+ IceCanContinue,
+ IceBadValue,
+ WORD64COUNT (8 + length));
+
+ IceWriteData32 (iceConn, 4, &offset);
+ IceWriteData32 (iceConn, 4, &length);
+ IceWriteData (iceConn, length, (char *) value);
+
+ if (PAD64 (length))
+ IceWritePad (iceConn, PAD64 (length));
+
+ IceFlush (iceConn);
+}
+
+
+void
+_IceErrorNoAuthentication (iceConn, offendingMinor)
+
+IceConn iceConn;
+int offendingMinor;
+
+{
+ int severity = (offendingMinor == ICE_ConnectionSetup) ?
+ IceFatalToConnection : IceFatalToProtocol;
+
+ IceErrorHeader (iceConn,
+ 0, offendingMinor,
+ iceConn->receive_sequence,
+ severity,
+ IceNoAuth,
+ 0);
+
+ IceFlush (iceConn);
+}
+
+
+void
+_IceErrorNoVersion (iceConn, offendingMinor)
+
+IceConn iceConn;
+int offendingMinor;
+
+{
+ int severity = (offendingMinor == ICE_ConnectionSetup) ?
+ IceFatalToConnection : IceFatalToProtocol;
+
+ IceErrorHeader (iceConn,
+ 0, offendingMinor,
+ iceConn->receive_sequence,
+ severity,
+ IceNoVersion,
+ 0);
+
+ IceFlush (iceConn);
+}
+
+
+void
+_IceErrorSetupFailed (iceConn, offendingMinor, reason)
+
+IceConn iceConn;
+int offendingMinor;
+char *reason;
+
+{
+ char *pBuf, *pStart;
+ int bytes;
+ int severity = (offendingMinor == ICE_ConnectionSetup) ?
+ IceFatalToConnection : IceFatalToProtocol;
+
+ if (!reason)
+ reason = "";
+ bytes = STRING_BYTES (reason);
+
+ IceErrorHeader (iceConn,
+ 0, offendingMinor,
+ iceConn->receive_sequence,
+ severity,
+ IceSetupFailed,
+ WORD64COUNT (bytes));
+
+ pBuf = pStart = IceAllocScratch (iceConn, PADDED_BYTES64 (bytes));
+ STORE_STRING (pBuf, reason);
+
+ IceWriteData (iceConn, PADDED_BYTES64 (bytes), pStart);
+ IceFlush (iceConn);
+}
+
+
+void
+_IceErrorAuthenticationRejected (iceConn, offendingMinor, reason)
+
+IceConn iceConn;
+int offendingMinor;
+char *reason;
+
+{
+ char *pBuf, *pStart;
+ int bytes;
+
+ if (!reason)
+ reason = "";
+ bytes = STRING_BYTES (reason);
+
+ IceErrorHeader (iceConn,
+ 0, offendingMinor,
+ iceConn->receive_sequence,
+ IceFatalToProtocol,
+ IceAuthRejected,
+ WORD64COUNT (bytes));
+
+ pBuf = pStart = IceAllocScratch (iceConn, PADDED_BYTES64 (bytes));
+ STORE_STRING (pBuf, reason);
+
+ IceWriteData (iceConn, PADDED_BYTES64 (bytes), pStart);
+ IceFlush (iceConn);
+}
+
+
+void
+_IceErrorAuthenticationFailed (iceConn, offendingMinor, reason)
+
+IceConn iceConn;
+int offendingMinor;
+char *reason;
+
+{
+ char *pBuf, *pStart;
+ int bytes;
+
+ if (!reason)
+ reason = "";
+ bytes = STRING_BYTES (reason);
+
+ IceErrorHeader (iceConn,
+ 0, offendingMinor,
+ iceConn->receive_sequence,
+ IceFatalToProtocol,
+ IceAuthFailed,
+ WORD64COUNT (bytes));
+
+ pBuf = pStart = IceAllocScratch (iceConn, PADDED_BYTES64 (bytes));
+ STORE_STRING (pBuf, reason);
+
+ IceWriteData (iceConn, PADDED_BYTES64 (bytes), pStart);
+ IceFlush (iceConn);
+}
+
+
+void
+_IceErrorProtocolDuplicate (iceConn, protocolName)
+
+IceConn iceConn;
+char *protocolName;
+
+{
+ char *pBuf, *pStart;
+ int bytes;
+
+ if (!protocolName)
+ protocolName = "";
+ bytes = STRING_BYTES (protocolName);
+
+ IceErrorHeader (iceConn,
+ 0, ICE_ProtocolSetup,
+ iceConn->receive_sequence,
+ IceFatalToProtocol,
+ IceProtocolDuplicate,
+ WORD64COUNT (bytes));
+
+ pBuf = pStart = IceAllocScratch (iceConn, PADDED_BYTES64 (bytes));
+ STORE_STRING (pBuf, protocolName);
+
+ IceWriteData (iceConn, PADDED_BYTES64 (bytes), pStart);
+ IceFlush (iceConn);
+}
+
+
+void
+_IceErrorMajorOpcodeDuplicate (iceConn, majorOpcode)
+
+IceConn iceConn;
+int majorOpcode;
+
+{
+ char mOp = (char) majorOpcode;
+
+ IceErrorHeader (iceConn,
+ 0, ICE_ProtocolSetup,
+ iceConn->receive_sequence,
+ IceFatalToProtocol,
+ IceMajorOpcodeDuplicate,
+ 1 /* length */);
+
+ IceWriteData (iceConn, 8, &mOp);
+ IceFlush (iceConn);
+}
+
+
+void
+_IceErrorUnknownProtocol (iceConn, protocolName)
+
+IceConn iceConn;
+char *protocolName;
+
+{
+ char *pBuf, *pStart;
+ int bytes;
+
+ if (!protocolName)
+ protocolName = "";
+ bytes = STRING_BYTES (protocolName);
+
+ IceErrorHeader (iceConn,
+ 0, ICE_ProtocolSetup,
+ iceConn->receive_sequence,
+ IceFatalToProtocol,
+ IceUnknownProtocol,
+ WORD64COUNT (bytes));
+
+ pBuf = pStart = IceAllocScratch (iceConn, PADDED_BYTES64 (bytes));
+ STORE_STRING (pBuf, protocolName);
+
+ IceWriteData (iceConn, PADDED_BYTES64 (bytes), pStart);
+ IceFlush (iceConn);
+}
+
+
+void
+_IceErrorBadMajor (iceConn, offendingMajor, offendingMinor, severity)
+
+IceConn iceConn;
+int offendingMajor;
+int offendingMinor;
+int severity;
+
+{
+ char maj = (char) offendingMajor;
+
+ IceErrorHeader (iceConn,
+ 0, offendingMinor,
+ iceConn->receive_sequence,
+ severity,
+ IceBadMajor,
+ 1 /* length */);
+
+ IceWriteData (iceConn, 8, &maj);
+ IceFlush (iceConn);
+}
+
+
+
+/*
+ * Default error handler.
+ */
+
+void
+_IceDefaultErrorHandler (iceConn, swap,
+ offendingMinorOpcode, offendingSequence, errorClass, severity, values)
+
+IceConn iceConn;
+Bool swap;
+int offendingMinorOpcode;
+unsigned long offendingSequence;
+int errorClass;
+int severity;
+IcePointer values;
+
+{
+ char *str;
+ char *pData = (char *) values;
+
+ switch (offendingMinorOpcode)
+ {
+ case ICE_ConnectionSetup:
+ str = "ConnectionSetup";
+ break;
+ case ICE_AuthRequired:
+ str = "AuthRequired";
+ break;
+ case ICE_AuthReply:
+ str = "AuthReply";
+ break;
+ case ICE_AuthNextPhase:
+ str = "AuthNextPhase";
+ break;
+ case ICE_ConnectionReply:
+ str = "ConnectionReply";
+ break;
+ case ICE_ProtocolSetup:
+ str = "ProtocolSetup";
+ break;
+ case ICE_ProtocolReply:
+ str = "ProtocolReply";
+ break;
+ case ICE_Ping:
+ str = "Ping";
+ break;
+ case ICE_PingReply:
+ str = "PingReply";
+ break;
+ case ICE_WantToClose:
+ str = "WantToClose";
+ break;
+ case ICE_NoClose:
+ str = "NoClose";
+ break;
+ default:
+ str = "";
+ }
+
+ fprintf (stderr, "\n");
+
+ fprintf (stderr, "ICE error: Offending minor opcode = %d (%s)\n",
+ offendingMinorOpcode, str);
+
+ fprintf (stderr, " Offending sequence number = %lu\n",
+ offendingSequence);
+
+ switch (errorClass)
+ {
+ case IceBadMinor:
+ str = "BadMinor";
+ break;
+ case IceBadState:
+ str = "BadState";
+ break;
+ case IceBadLength:
+ str = "BadLength";
+ break;
+ case IceBadValue:
+ str = "BadValue";
+ break;
+ case IceBadMajor:
+ str = "BadMajor";
+ break;
+ case IceNoAuth:
+ str = "NoAuthentication";
+ break;
+ case IceNoVersion:
+ str = "NoVersion";
+ break;
+ case IceSetupFailed:
+ str = "SetupFailed";
+ break;
+ case IceAuthRejected:
+ str = "AuthenticationRejected";
+ break;
+ case IceAuthFailed:
+ str = "AuthenticationFailed";
+ break;
+ case IceProtocolDuplicate:
+ str = "ProtocolDuplicate";
+ break;
+ case IceMajorOpcodeDuplicate:
+ str = "MajorOpcodeDuplicate";
+ break;
+ case IceUnknownProtocol:
+ str = "UnknownProtocol";
+ break;
+ default:
+ str = "???";
+ }
+
+ fprintf (stderr, " Error class = %s\n", str);
+
+ if (severity == IceCanContinue)
+ str = "CanContinue";
+ else if (severity == IceFatalToProtocol)
+ str = "FatalToProtocol";
+ else if (severity == IceFatalToConnection)
+ str = "FatalToConnection";
+ else
+ str = "???";
+
+ fprintf (stderr, " Severity = %s\n", str);
+
+ switch (errorClass)
+ {
+ case IceBadValue:
+ {
+ int offset, length, val;
+
+ EXTRACT_CARD32 (pData, swap, offset);
+ EXTRACT_CARD32 (pData, swap, length);
+
+ fprintf (stderr,
+ " BadValue Offset = %d\n", offset);
+ fprintf (stderr,
+ " BadValue Length = %d\n", length);
+
+ if (length <= 4)
+ {
+ if (length == 1)
+ val = (int) *pData;
+ else if (length == 2)
+ {
+ EXTRACT_CARD16 (pData, swap, val);
+ }
+ else
+ {
+ EXTRACT_CARD32 (pData, swap, val);
+ }
+
+ fprintf (stderr,
+ " BadValue = %d\n", val);
+ }
+ break;
+ }
+
+ case IceBadMajor:
+
+ fprintf (stderr, "Major opcode : %d\n", (int) *pData);
+ break;
+
+ case IceSetupFailed:
+
+ EXTRACT_STRING (pData, swap, str);
+ fprintf (stderr, "Reason : %s\n", str);
+ break;
+
+ case IceAuthRejected:
+
+ EXTRACT_STRING (pData, swap, str);
+ fprintf (stderr, "Reason : %s\n", str);
+ break;
+
+ case IceAuthFailed:
+
+ EXTRACT_STRING (pData, swap, str);
+ fprintf (stderr, "Reason : %s\n", str);
+ break;
+
+ case IceProtocolDuplicate:
+
+ EXTRACT_STRING (pData, swap, str);
+ fprintf (stderr, "Protocol name : %s\n", str);
+ break;
+
+ case IceMajorOpcodeDuplicate:
+
+ fprintf (stderr, "Major opcode : %d\n", (int) *pData);
+ break;
+
+ case IceUnknownProtocol:
+
+ EXTRACT_STRING (pData, swap, str);
+ fprintf (stderr, "Protocol name : %s\n", str);
+ break;
+
+ default:
+ break;
+ }
+
+ fprintf (stderr, "\n");
+
+ if (severity != IceCanContinue)
+ exit (1);
+}
+
+
+
+/*
+ * This procedure sets the ICE error handler to be the specified
+ * routine. If NULL is passed in the default error handler is restored.
+ * The function's return value is the previous error handler.
+ */
+
+IceErrorHandler
+IceSetErrorHandler (handler)
+
+IceErrorHandler handler;
+
+{
+ IceErrorHandler oldHandler = _IceErrorHandler;
+
+ if (handler != NULL)
+ _IceErrorHandler = handler;
+ else
+ _IceErrorHandler = _IceDefaultErrorHandler;
+
+ return (oldHandler);
+}
+
+
+
+/*
+ * Default IO error handler.
+ */
+
+void
+_IceDefaultIOErrorHandler (iceConn)
+
+IceConn iceConn;
+
+{
+ fprintf (stderr,
+ "ICE default IO error handler doing an exit(), pid = %ld, errno = %d\n",
+ (long)getpid(), errno);
+
+ exit (1);
+}
+
+
+
+/*
+ * This procedure sets the ICE fatal I/O error handler to be the
+ * specified routine. If NULL is passed in the default error
+ * handler is restored. The function's return value is the
+ * previous error handler.
+ */
+
+IceIOErrorHandler
+IceSetIOErrorHandler (handler)
+
+IceIOErrorHandler handler;
+
+{
+ IceIOErrorHandler oldHandler = _IceIOErrorHandler;
+
+ if (handler != NULL)
+ _IceIOErrorHandler = handler;
+ else
+ _IceIOErrorHandler = _IceDefaultIOErrorHandler;
+
+ return (oldHandler);
+}
diff --git a/nx-X11/lib/ICE/getauth.c b/nx-X11/lib/ICE/getauth.c
new file mode 100644
index 000000000..73fcd8aec
--- /dev/null
+++ b/nx-X11/lib/ICE/getauth.c
@@ -0,0 +1,274 @@
+/* $Xorg: getauth.c,v 1.4 2001/02/09 02:03:26 xorgcvs Exp $ */
+/******************************************************************************
+
+
+Copyright 1993, 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.
+
+Author: Ralph Mor, X Consortium
+******************************************************************************/
+/* $XFree86: xc/lib/ICE/getauth.c,v 1.2 2001/10/28 03:32:28 tsi Exp $ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+#include <X11/ICE/ICElib.h>
+#include "ICElibint.h"
+#include <X11/ICE/ICEutil.h>
+
+static Bool auth_valid ();
+
+extern int _IcePaAuthDataEntryCount;
+extern IceAuthDataEntry _IcePaAuthDataEntries[];
+
+
+/*
+ * The functions in this file are not a standard part of ICElib.
+ *
+ * The sample implementation uses an .ICEauthority to manipulate
+ * authentication data.
+ *
+ * For the client that initiates a Protocol Setup, we look in the
+ * .ICEauthority file to get the data.
+ *
+ * For the client accepting the Protocol Setup, we get the data
+ * from an in-memory database of authentication data (set by the
+ * application calling IceSetPaAuthData). We have to get the data
+ * from memory because getting it directly from the .ICEauthority
+ * file is not secure - someone can just modify the contents of the
+ * .ICEauthority file behind our back.
+ */
+
+void
+_IceGetPoAuthData (protocolName, networkId, authName,
+ authDataLenRet, authDataRet)
+
+char *protocolName;
+char *networkId;
+char *authName;
+unsigned short *authDataLenRet;
+char **authDataRet;
+
+{
+ IceAuthFileEntry *entry;
+
+ entry = IceGetAuthFileEntry (protocolName, networkId, authName);
+
+ if (entry)
+ {
+ *authDataLenRet = entry->auth_data_length;
+
+ if ((*authDataRet = (char *) malloc (entry->auth_data_length)) != NULL)
+ memcpy (*authDataRet, entry->auth_data, entry->auth_data_length);
+ }
+ else
+ {
+ *authDataLenRet = 0;
+ *authDataRet = NULL;
+ }
+
+ IceFreeAuthFileEntry (entry);
+}
+
+
+
+void
+_IceGetPaAuthData (protocolName, networkId, authName,
+ authDataLenRet, authDataRet)
+
+char *protocolName;
+char *networkId;
+char *authName;
+unsigned short *authDataLenRet;
+char **authDataRet;
+
+{
+ IceAuthDataEntry *entry = NULL;
+ int found = 0;
+ int i;
+
+ for (i = 0; i < _IcePaAuthDataEntryCount && !found; i++)
+ {
+ entry = &_IcePaAuthDataEntries[i];
+
+ found =
+ strcmp (protocolName, entry->protocol_name) == 0 &&
+ strcmp (networkId, entry->network_id) == 0 &&
+ strcmp (authName, entry->auth_name) == 0;
+ }
+
+ if (found)
+ {
+ *authDataLenRet = entry->auth_data_length;
+
+ if ((*authDataRet = (char *) malloc (entry->auth_data_length)) != NULL)
+ memcpy (*authDataRet, entry->auth_data, entry->auth_data_length);
+ }
+ else
+ {
+ *authDataLenRet = 0;
+ *authDataRet = NULL;
+ }
+}
+
+
+
+void
+_IceGetPoValidAuthIndices (protocol_name, network_id,
+ num_auth_names, auth_names, num_indices_ret, indices_ret)
+
+char *protocol_name;
+char *network_id;
+int num_auth_names;
+char **auth_names;
+int *num_indices_ret;
+int *indices_ret; /* in/out arg */
+
+{
+ FILE *auth_file;
+ char *filename;
+ IceAuthFileEntry *entry;
+ int index_ret, i;
+
+ *num_indices_ret = 0;
+
+ if (!(filename = IceAuthFileName ()))
+ return;
+
+ if (access (filename, R_OK) != 0) /* checks REAL id */
+ return;
+
+ if (!(auth_file = fopen (filename, "rb")))
+ return;
+
+ for (;;)
+ {
+ if (!(entry = IceReadAuthFileEntry (auth_file)))
+ break;
+
+ if (strcmp (protocol_name, entry->protocol_name) == 0 &&
+ strcmp (network_id, entry->network_id) == 0 &&
+ auth_valid (entry->auth_name, num_auth_names,
+ auth_names, &index_ret))
+ {
+ /*
+ * Make sure we didn't store this index already.
+ */
+
+ for (i = 0; i < *num_indices_ret; i++)
+ if (index_ret == indices_ret[i])
+ break;
+
+ if (i >= *num_indices_ret)
+ {
+ indices_ret[*num_indices_ret] = index_ret;
+ *num_indices_ret += 1;
+ }
+ }
+
+ IceFreeAuthFileEntry (entry);
+ }
+
+ fclose (auth_file);
+}
+
+
+
+void
+_IceGetPaValidAuthIndices (protocol_name, network_id,
+ num_auth_names, auth_names, num_indices_ret, indices_ret)
+
+char *protocol_name;
+char *network_id;
+int num_auth_names;
+char **auth_names;
+int *num_indices_ret;
+int *indices_ret; /* in/out arg */
+
+{
+ int index_ret;
+ int i, j;
+ IceAuthDataEntry *entry;
+
+ *num_indices_ret = 0;
+
+ for (i = 0; i < _IcePaAuthDataEntryCount; i++)
+ {
+ entry = &_IcePaAuthDataEntries[i];
+
+ if (strcmp (protocol_name, entry->protocol_name) == 0 &&
+ strcmp (network_id, entry->network_id) == 0 &&
+ auth_valid (entry->auth_name, num_auth_names,
+ auth_names, &index_ret))
+ {
+ /*
+ * Make sure we didn't store this index already.
+ */
+
+ for (j = 0; j < *num_indices_ret; j++)
+ if (index_ret == indices_ret[j])
+ break;
+
+ if (j >= *num_indices_ret)
+ {
+ indices_ret[*num_indices_ret] = index_ret;
+ *num_indices_ret += 1;
+ }
+ }
+ }
+}
+
+
+
+/*
+ * local routines
+ */
+
+static Bool
+auth_valid (auth_name, num_auth_names, auth_names, index_ret)
+
+char *auth_name;
+int num_auth_names;
+char **auth_names;
+int *index_ret;
+
+{
+ /*
+ * Check if auth_name is in auth_names. Return index.
+ */
+
+ int i;
+
+ for (i = 0; i < num_auth_names; i++)
+ if (strcmp (auth_name, auth_names[i]) == 0)
+ {
+ break;
+ }
+
+ if (i < num_auth_names)
+ {
+ *index_ret = i;
+ return (1);
+ }
+ else
+ return (0);
+}
diff --git a/nx-X11/lib/ICE/globals.h b/nx-X11/lib/ICE/globals.h
new file mode 100644
index 000000000..0532f5565
--- /dev/null
+++ b/nx-X11/lib/ICE/globals.h
@@ -0,0 +1,64 @@
+/* $Xorg: globals.h,v 1.4 2001/02/09 02:03:26 xorgcvs Exp $ */
+/******************************************************************************
+
+
+Copyright 1993, 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.
+
+Author: Ralph Mor, X Consortium
+******************************************************************************/
+/* $XFree86: xc/lib/ICE/globals.h,v 1.4 2001/12/14 19:53:35 dawes Exp $ */
+
+extern void _IceDefaultErrorHandler ();
+extern void _IceDefaultIOErrorHandler ();
+
+extern IcePoAuthStatus _IcePoMagicCookie1Proc ();
+extern IcePaAuthStatus _IcePaMagicCookie1Proc ();
+
+extern void _IceProcessCoreMessage ();
+
+#ifndef __UNIXOS2__
+IceConn _IceConnectionObjs[256];
+char *_IceConnectionStrings[256];
+_IceProtocol _IceProtocols[255];
+#else
+IceConn _IceConnectionObjs[256] = {0};
+char *_IceConnectionStrings[256] = {0};
+_IceProtocol _IceProtocols[255] = {0};
+#endif
+int _IceConnectionCount = 0;
+
+int _IceLastMajorOpcode = 0;
+
+int _IceAuthCount = 1;
+char *_IceAuthNames[] = {"MIT-MAGIC-COOKIE-1"};
+IcePoAuthProc _IcePoAuthProcs[] = {_IcePoMagicCookie1Proc};
+IcePaAuthProc _IcePaAuthProcs[] = {_IcePaMagicCookie1Proc};
+
+int _IceVersionCount = 1;
+_IceVersion _IceVersions[] = {
+ {IceProtoMajor, IceProtoMinor, _IceProcessCoreMessage}};
+
+_IceWatchProc *_IceWatchProcs = NULL;
+
+IceErrorHandler _IceErrorHandler = _IceDefaultErrorHandler;
+IceIOErrorHandler _IceIOErrorHandler = _IceDefaultIOErrorHandler;
diff --git a/nx-X11/lib/ICE/iceauth.c b/nx-X11/lib/ICE/iceauth.c
new file mode 100644
index 000000000..01c73ced3
--- /dev/null
+++ b/nx-X11/lib/ICE/iceauth.c
@@ -0,0 +1,278 @@
+/* $Xorg: iceauth.c,v 1.4 2001/02/09 02:03:26 xorgcvs Exp $ */
+/******************************************************************************
+
+
+Copyright 1993, 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.
+
+Author: Ralph Mor, X Consortium
+******************************************************************************/
+/* $XFree86: xc/lib/ICE/iceauth.c,v 3.5 2001/12/14 19:53:36 dawes Exp $ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+#include <X11/ICE/ICElib.h>
+#include "ICElibint.h"
+#include <X11/ICE/ICEutil.h>
+
+#include <time.h>
+#define Time_t time_t
+
+static int binaryEqual ();
+
+static int was_called_state;
+
+/*
+ * MIT-MAGIC-COOKIE-1 is a sample authentication method implemented by
+ * the SI. It is not part of standard ICElib.
+ */
+
+
+char *
+IceGenerateMagicCookie (len)
+
+int len;
+
+{
+ char *auth;
+ long ldata[2];
+ int seed;
+ int value;
+ int i;
+
+ if ((auth = (char *) malloc (len + 1)) == NULL)
+ return (NULL);
+
+#ifdef ITIMER_REAL
+ {
+ struct timeval now;
+ X_GETTIMEOFDAY (&now);
+ ldata[0] = now.tv_sec;
+ ldata[1] = now.tv_usec;
+ }
+#else
+ {
+#ifndef __UNIXOS2__
+ long time ();
+#endif
+ ldata[0] = time ((long *) 0);
+ ldata[1] = getpid ();
+ }
+#endif
+ seed = (ldata[0]) + (ldata[1] << 16);
+ srand (seed);
+ for (i = 0; i < len; i++)
+ {
+ value = rand ();
+ auth[i] = value & 0xff;
+ }
+ auth[len] = '\0';
+
+ return (auth);
+}
+
+
+
+IcePoAuthStatus
+_IcePoMagicCookie1Proc (iceConn, authStatePtr, cleanUp, swap,
+ authDataLen, authData, replyDataLenRet, replyDataRet, errorStringRet)
+
+IceConn iceConn;
+IcePointer *authStatePtr;
+Bool cleanUp;
+Bool swap;
+int authDataLen;
+IcePointer authData;
+int *replyDataLenRet;
+IcePointer *replyDataRet;
+char **errorStringRet;
+
+{
+ if (cleanUp)
+ {
+ /*
+ * We didn't allocate any state. We're done.
+ */
+
+ return (IcePoAuthDoneCleanup);
+ }
+
+ *errorStringRet = NULL;
+
+ if (*authStatePtr == NULL)
+ {
+ /*
+ * This is the first time we're being called. Search the
+ * authentication data for the first occurence of
+ * MIT-MAGIC-COOKIE-1 that matches iceConn->connection_string.
+ */
+
+ unsigned short length;
+ char *data;
+
+ _IceGetPoAuthData ("ICE", iceConn->connection_string,
+ "MIT-MAGIC-COOKIE-1", &length, &data);
+
+ if (!data)
+ {
+ char *tempstr =
+ "Could not find correct MIT-MAGIC-COOKIE-1 authentication";
+
+ *errorStringRet = (char *) malloc (strlen (tempstr) + 1);
+ if (*errorStringRet)
+ strcpy (*errorStringRet, tempstr);
+
+ return (IcePoAuthFailed);
+ }
+ else
+ {
+ *authStatePtr = (IcePointer) &was_called_state;
+
+ *replyDataLenRet = length;
+ *replyDataRet = data;
+
+ return (IcePoAuthHaveReply);
+ }
+ }
+ else
+ {
+ /*
+ * We should never get here for MIT-MAGIC-COOKIE-1 since it is
+ * a single pass authentication method.
+ */
+
+ char *tempstr = "MIT-MAGIC-COOKIE-1 authentication internal error";
+
+ *errorStringRet = (char *) malloc (strlen (tempstr) + 1);
+ if (*errorStringRet)
+ strcpy (*errorStringRet, tempstr);
+
+ return (IcePoAuthFailed);
+ }
+}
+
+
+
+IcePaAuthStatus
+_IcePaMagicCookie1Proc (iceConn, authStatePtr, swap,
+ authDataLen, authData, replyDataLenRet, replyDataRet, errorStringRet)
+
+IceConn iceConn;
+IcePointer *authStatePtr;
+Bool swap;
+int authDataLen;
+IcePointer authData;
+int *replyDataLenRet;
+IcePointer *replyDataRet;
+char **errorStringRet;
+
+{
+ *errorStringRet = NULL;
+ *replyDataLenRet = 0;
+ *replyDataRet = NULL;
+
+ if (*authStatePtr == NULL)
+ {
+ /*
+ * This is the first time we're being called. We don't have
+ * any data to pass to the other client.
+ */
+
+ *authStatePtr = (IcePointer) &was_called_state;
+
+ return (IcePaAuthContinue);
+ }
+ else
+ {
+ /*
+ * Search the authentication data for the first occurence of
+ * MIT-MAGIC-COOKIE-1 that matches iceConn->connection_string.
+ */
+
+ unsigned short length;
+ char *data;
+
+ _IceGetPaAuthData ("ICE", iceConn->connection_string,
+ "MIT-MAGIC-COOKIE-1", &length, &data);
+
+ if (data)
+ {
+ IcePaAuthStatus stat;
+
+ if (authDataLen == length &&
+ binaryEqual ((char *) authData, data, authDataLen))
+ {
+ stat = IcePaAuthAccepted;
+ }
+ else
+ {
+ char *tempstr = "MIT-MAGIC-COOKIE-1 authentication rejected";
+
+ *errorStringRet = (char *) malloc (strlen (tempstr) + 1);
+ if (*errorStringRet)
+ strcpy (*errorStringRet, tempstr);
+
+ stat = IcePaAuthRejected;
+ }
+
+ free (data);
+ return (stat);
+ }
+ else
+ {
+ /*
+ * We should never get here because in the ConnectionReply
+ * we should have passed all the valid methods. So we should
+ * always find a valid entry.
+ */
+
+ char *tempstr =
+ "MIT-MAGIC-COOKIE-1 authentication internal error";
+
+ *errorStringRet = (char *) malloc (strlen (tempstr) + 1);
+ if (*errorStringRet)
+ strcpy (*errorStringRet, tempstr);
+
+ return (IcePaAuthFailed);
+ }
+ }
+}
+
+
+
+/*
+ * local routines
+ */
+
+static int
+binaryEqual (a, b, len)
+
+register char *a, *b;
+register unsigned len;
+
+{
+ while (len--)
+ if (*a++ != *b++)
+ return 0;
+ return 1;
+}
diff --git a/nx-X11/lib/ICE/listen.c b/nx-X11/lib/ICE/listen.c
new file mode 100644
index 000000000..7708cfe02
--- /dev/null
+++ b/nx-X11/lib/ICE/listen.c
@@ -0,0 +1,283 @@
+/* $Xorg: listen.c,v 1.5 2001/02/09 02:03:26 xorgcvs Exp $ */
+/******************************************************************************
+
+
+Copyright 1993, 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.
+
+Author: Ralph Mor, X Consortium
+******************************************************************************/
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+#include <X11/ICE/ICElib.h>
+#include "ICElibint.h"
+#include <X11/Xtrans/Xtrans.h>
+#include <stdio.h>
+
+
+Status
+IceListenForConnections (countRet, listenObjsRet, errorLength, errorStringRet)
+
+int *countRet;
+IceListenObj **listenObjsRet;
+int errorLength;
+char *errorStringRet;
+
+{
+ struct _IceListenObj *listenObjs;
+ char *networkId;
+ int transCount, partial, i, j;
+ Status status = 1;
+ XtransConnInfo *transConns = NULL;
+
+
+ if ((_IceTransMakeAllCOTSServerListeners (NULL, &partial,
+ &transCount, &transConns) < 0) || (transCount < 1))
+ {
+ *listenObjsRet = NULL;
+ *countRet = 0;
+
+ strncpy (errorStringRet,
+ "Cannot establish any listening sockets", errorLength);
+
+ return (0);
+ }
+
+ if ((listenObjs = (struct _IceListenObj *) malloc (
+ transCount * sizeof (struct _IceListenObj))) == NULL)
+ {
+ for (i = 0; i < transCount; i++)
+ _IceTransClose (transConns[i]);
+ free ((char *) transConns);
+ return (0);
+ }
+
+ *countRet = 0;
+
+ for (i = 0; i < transCount; i++)
+ {
+ networkId = _IceTransGetMyNetworkId (transConns[i]);
+
+ if (networkId)
+ {
+ listenObjs[*countRet].trans_conn = transConns[i];
+ listenObjs[*countRet].network_id = networkId;
+
+ (*countRet)++;
+ }
+ }
+
+ if (*countRet == 0)
+ {
+ *listenObjsRet = NULL;
+
+ strncpy (errorStringRet,
+ "Cannot establish any listening sockets", errorLength);
+
+ status = 0;
+ }
+ else
+ {
+ *listenObjsRet = (IceListenObj *) malloc (
+ *countRet * sizeof (IceListenObj));
+
+ if (*listenObjsRet == NULL)
+ {
+ strncpy (errorStringRet, "Malloc failed", errorLength);
+
+ status = 0;
+ }
+ else
+ {
+ for (i = 0; i < *countRet; i++)
+ {
+ (*listenObjsRet)[i] = (IceListenObj) malloc (
+ sizeof (struct _IceListenObj));
+
+ if ((*listenObjsRet)[i] == NULL)
+ {
+ strncpy (errorStringRet, "Malloc failed", errorLength);
+
+ for (j = 0; j < i; j++)
+ free ((char *) (*listenObjsRet)[j]);
+
+ free ((char *) *listenObjsRet);
+
+ status = 0;
+ }
+ else
+ {
+ *((*listenObjsRet)[i]) = listenObjs[i];
+ }
+ }
+ }
+ }
+
+ if (status == 1)
+ {
+ if (errorStringRet && errorLength > 0)
+ *errorStringRet = '\0';
+
+ for (i = 0; i < *countRet; i++)
+ {
+ (*listenObjsRet)[i]->host_based_auth_proc = NULL;
+ }
+ }
+ else
+ {
+ for (i = 0; i < transCount; i++)
+ _IceTransClose (transConns[i]);
+ }
+
+ free ((char *) listenObjs);
+ free ((char *) transConns);
+
+ return (status);
+}
+
+
+
+int
+IceGetListenConnectionNumber (listenObj)
+
+IceListenObj listenObj;
+
+{
+ return (_IceTransGetConnectionNumber (listenObj->trans_conn));
+}
+
+
+
+char *
+IceGetListenConnectionString (listenObj)
+
+IceListenObj listenObj;
+
+{
+ char *networkId;
+
+ networkId = (char *) malloc (strlen (listenObj->network_id) + 1);
+
+ if (networkId)
+ strcpy (networkId, listenObj->network_id);
+
+ return (networkId);
+}
+
+
+
+char *
+IceComposeNetworkIdList (count, listenObjs)
+
+int count;
+IceListenObj *listenObjs;
+
+{
+ char *list;
+ int len = 0;
+ int i;
+
+ if (count < 1 || listenObjs == NULL)
+ return (NULL);
+
+ for (i = 0; i < count; i++)
+ len += (strlen (listenObjs[i]->network_id) + 1);
+
+ list = (char *) malloc (len);
+
+ if (list == NULL)
+ return (NULL);
+ else
+ {
+ int doneCount = 0;
+
+ list[0] = '\0';
+
+ for (i = 0; i < count; i++)
+ {
+ if (_IceTransIsLocal (listenObjs[i]->trans_conn))
+ {
+ strcat (list, listenObjs[i]->network_id);
+ doneCount++;
+ if (doneCount < count)
+ strcat (list, ",");
+ }
+ }
+
+ if (doneCount < count)
+ {
+ for (i = 0; i < count; i++)
+ {
+ if (!_IceTransIsLocal (listenObjs[i]->trans_conn))
+ {
+ strcat (list, listenObjs[i]->network_id);
+ doneCount++;
+ if (doneCount < count)
+ strcat (list, ",");
+ }
+ }
+ }
+
+ return (list);
+ }
+}
+
+
+
+void
+IceFreeListenObjs (count, listenObjs)
+
+int count;
+IceListenObj *listenObjs;
+
+{
+ int i;
+
+ for (i = 0; i < count; i++)
+ {
+ free (listenObjs[i]->network_id);
+ _IceTransClose (listenObjs[i]->trans_conn);
+ free ((char *) listenObjs[i]);
+ }
+
+ free ((char *) listenObjs);
+}
+
+
+
+/*
+ * Allow host based authentication for the ICE Connection Setup.
+ * Do not confuse with the host based authentication callbacks that
+ * can be set up in IceRegisterForProtocolReply.
+ */
+
+void
+IceSetHostBasedAuthProc (listenObj, hostBasedAuthProc)
+
+IceListenObj listenObj;
+IceHostBasedAuthProc hostBasedAuthProc;
+
+{
+ listenObj->host_based_auth_proc = hostBasedAuthProc;
+}
diff --git a/nx-X11/lib/ICE/listenwk.c b/nx-X11/lib/ICE/listenwk.c
new file mode 100644
index 000000000..f97aa44af
--- /dev/null
+++ b/nx-X11/lib/ICE/listenwk.c
@@ -0,0 +1,161 @@
+/* $Xorg: listenwk.c,v 1.5 2001/02/09 02:03:26 xorgcvs Exp $ */
+
+/*
+
+Copyright 1996, 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.
+
+*/
+/* $XFree86: xc/lib/ICE/listenwk.c,v 1.3 2001/01/17 19:41:29 dawes Exp $ */
+
+
+/* Author: Ralph Mor, X Consortium */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+#include <X11/ICE/ICElib.h>
+#include "ICElibint.h"
+#include <X11/Xtrans/Xtrans.h>
+#include <stdio.h>
+
+
+Status
+IceListenForWellKnownConnections (port, countRet, listenObjsRet, errorLength, errorStringRet)
+
+char *port;
+int *countRet;
+IceListenObj **listenObjsRet;
+int errorLength;
+char *errorStringRet;
+
+{
+ struct _IceListenObj *listenObjs;
+ char *networkId;
+ int transCount, partial, i, j;
+ Status status = 1;
+ XtransConnInfo *transConns = NULL;
+
+
+ if ((_IceTransMakeAllCOTSServerListeners (port, &partial,
+ &transCount, &transConns) < 0) || (transCount < 1))
+ {
+ *listenObjsRet = NULL;
+ *countRet = 0;
+
+ strncpy (errorStringRet,
+ "Cannot establish any listening sockets", errorLength);
+
+ return (0);
+ }
+
+ if ((listenObjs = (struct _IceListenObj *) malloc (
+ transCount * sizeof (struct _IceListenObj))) == NULL)
+ {
+ for (i = 0; i < transCount; i++)
+ _IceTransClose (transConns[i]);
+ free ((char *) transConns);
+ return (0);
+ }
+
+ *countRet = 0;
+
+ for (i = 0; i < transCount; i++)
+ {
+ networkId = (char *)_IceTransGetMyNetworkId (transConns[i]);
+
+ if (networkId)
+ {
+ listenObjs[*countRet].trans_conn = transConns[i];
+ listenObjs[*countRet].network_id = networkId;
+
+ (*countRet)++;
+ }
+ }
+
+ if (*countRet == 0)
+ {
+ *listenObjsRet = NULL;
+
+ strncpy (errorStringRet,
+ "Cannot establish any listening sockets", errorLength);
+
+ status = 0;
+ }
+ else
+ {
+ *listenObjsRet = (IceListenObj *) malloc (
+ *countRet * sizeof (IceListenObj));
+
+ if (*listenObjsRet == NULL)
+ {
+ strncpy (errorStringRet, "Malloc failed", errorLength);
+
+ status = 0;
+ }
+ else
+ {
+ for (i = 0; i < *countRet; i++)
+ {
+ (*listenObjsRet)[i] = (IceListenObj) malloc (
+ sizeof (struct _IceListenObj));
+
+ if ((*listenObjsRet)[i] == NULL)
+ {
+ strncpy (errorStringRet, "Malloc failed", errorLength);
+
+ for (j = 0; j < i; j++)
+ free ((char *) (*listenObjsRet)[j]);
+
+ free ((char *) *listenObjsRet);
+
+ status = 0;
+ }
+ else
+ {
+ *((*listenObjsRet)[i]) = listenObjs[i];
+ }
+ }
+ }
+ }
+
+ if (status == 1)
+ {
+ if (errorStringRet && errorLength > 0)
+ *errorStringRet = '\0';
+
+ for (i = 0; i < *countRet; i++)
+ {
+ (*listenObjsRet)[i]->host_based_auth_proc = NULL;
+ }
+ }
+ else
+ {
+ for (i = 0; i < transCount; i++)
+ _IceTransClose (transConns[i]);
+ }
+
+ free ((char *) listenObjs);
+ free ((char *) transConns);
+
+ return (status);
+}
diff --git a/nx-X11/lib/ICE/locking.c b/nx-X11/lib/ICE/locking.c
new file mode 100644
index 000000000..510803030
--- /dev/null
+++ b/nx-X11/lib/ICE/locking.c
@@ -0,0 +1,67 @@
+/* $Xorg: locking.c,v 1.4 2001/02/09 02:03:26 xorgcvs Exp $ */
+/******************************************************************************
+
+
+Copyright 1993, 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.
+
+Author: Ralph Mor, X Consortium
+******************************************************************************/
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+#include <X11/ICE/ICElib.h>
+#include "ICElibint.h"
+
+
+/*
+ * NOT IMPLEMENTED YET
+ */
+
+
+Status
+IceInitThreads ()
+
+{
+ return (0);
+}
+
+
+void
+IceAppLockConn (iceConn)
+
+IceConn iceConn;
+
+{
+ IceLockConn (iceConn);
+}
+
+
+void
+IceAppUnlockConn (iceConn)
+
+IceConn iceConn;
+
+{
+ IceUnlockConn (iceConn);
+}
diff --git a/nx-X11/lib/ICE/misc.c b/nx-X11/lib/ICE/misc.c
new file mode 100644
index 000000000..a6e91c65a
--- /dev/null
+++ b/nx-X11/lib/ICE/misc.c
@@ -0,0 +1,630 @@
+/* $Xorg: misc.c,v 1.4 2001/02/09 02:03:26 xorgcvs Exp $ */
+/******************************************************************************
+
+
+Copyright 1993, 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.
+
+Author: Ralph Mor, X Consortium
+******************************************************************************/
+/* $XFree86: xc/lib/ICE/misc.c,v 1.3 2001/01/17 19:41:29 dawes Exp $ */
+
+#ifdef WIN32
+#define _WILLWINSOCK_
+#endif
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+#include <X11/ICE/ICElib.h>
+#include "ICElibint.h"
+#include <X11/Xtrans/Xtrans.h>
+#include <stdio.h>
+#ifdef WIN32
+#include <X11/Xwinsock.h>
+#include <X11/Xw32defs.h>
+#endif
+
+
+/*
+ * scratch buffer
+ */
+
+char *
+IceAllocScratch (iceConn, size)
+
+IceConn iceConn;
+unsigned long size;
+
+{
+ if (!iceConn->scratch || size > iceConn->scratch_size)
+ {
+ if (iceConn->scratch)
+ free (iceConn->scratch);
+
+ iceConn->scratch = (char *) malloc ((unsigned) size);
+ iceConn->scratch_size = size;
+ }
+
+ return (iceConn->scratch);
+}
+
+
+
+/*
+ * Output/Input buffer functions
+ */
+
+int
+IceFlush (iceConn)
+
+IceConn iceConn;
+
+{
+ _IceWrite (iceConn,
+ (unsigned long) (iceConn->outbufptr - iceConn->outbuf),
+ iceConn->outbuf);
+
+ iceConn->outbufptr = iceConn->outbuf;
+ return 1;
+}
+
+
+int
+IceGetOutBufSize (iceConn)
+
+IceConn iceConn;
+
+{
+ return (iceConn->outbufmax - iceConn->outbuf);
+}
+
+
+int
+IceGetInBufSize (iceConn)
+
+IceConn iceConn;
+
+{
+ return (iceConn->inbufmax - iceConn->inbuf);
+}
+
+
+
+/*
+ * informational functions
+ */
+
+IceConnectStatus
+IceConnectionStatus (iceConn)
+
+IceConn iceConn;
+
+{
+ return (iceConn->connection_status);
+}
+
+
+char *
+IceVendor (iceConn)
+
+IceConn iceConn;
+
+{
+ char *string = (char *) malloc (strlen (iceConn->vendor) + 1);
+
+ if (string)
+ strcpy (string, iceConn->vendor);
+
+ return (string);
+}
+
+
+char *
+IceRelease (iceConn)
+
+IceConn iceConn;
+
+{
+ char *string = (char *) malloc (strlen (iceConn->release) + 1);
+
+ if (string)
+ strcpy (string, iceConn->release);
+
+ return (string);
+}
+
+
+int
+IceProtocolVersion (iceConn)
+
+IceConn iceConn;
+
+{
+ return (_IceVersions[iceConn->my_ice_version_index].major_version);
+}
+
+
+int
+IceProtocolRevision (iceConn)
+
+IceConn iceConn;
+
+{
+ return (_IceVersions[iceConn->my_ice_version_index].minor_version);
+}
+
+
+int
+IceConnectionNumber (iceConn)
+
+IceConn iceConn;
+
+{
+ return (_IceTransGetConnectionNumber (iceConn->trans_conn));
+}
+
+
+char *
+IceConnectionString (iceConn)
+
+IceConn iceConn;
+
+{
+ if (iceConn->connection_string)
+ {
+ char *string = (char *) malloc (
+ strlen (iceConn->connection_string) + 1);
+
+ if (string)
+ strcpy (string, iceConn->connection_string);
+
+ return (string);
+ }
+ else
+ return (NULL);
+}
+
+
+unsigned long
+IceLastSentSequenceNumber (iceConn)
+
+IceConn iceConn;
+
+{
+ return (iceConn->send_sequence);
+}
+
+
+unsigned long
+IceLastReceivedSequenceNumber (iceConn)
+
+IceConn iceConn;
+
+{
+ return (iceConn->receive_sequence);
+}
+
+
+Bool
+IceSwapping (iceConn)
+
+IceConn iceConn;
+
+{
+ return (iceConn->swap);
+}
+
+
+
+/*
+ * Read "n" bytes from a connection.
+ *
+ * Return Status 0 if we detected an EXPECTED closed connection.
+ *
+ */
+
+Status
+_IceRead (iceConn, nbytes, ptr)
+
+register IceConn iceConn;
+unsigned long nbytes;
+register char *ptr;
+
+{
+ register unsigned long nleft;
+
+ nleft = nbytes;
+ while (nleft > 0)
+ {
+ int nread;
+
+ if (iceConn->io_ok)
+ nread = _IceTransRead (iceConn->trans_conn, ptr, (int) nleft);
+ else
+ return (1);
+
+ if (nread <= 0)
+ {
+#ifdef WIN32
+ errno = WSAGetLastError();
+#endif
+ if (iceConn->want_to_close)
+ {
+ /*
+ * We sent a WantToClose message and now we detected that
+ * the other side closed the connection.
+ */
+
+ _IceConnectionClosed (iceConn); /* invoke watch procs */
+ _IceFreeConnection (iceConn);
+
+ return (0);
+ }
+ else
+ {
+ /*
+ * Fatal IO error. First notify each protocol's IceIOErrorProc
+ * callback, then invoke the application IO error handler.
+ */
+
+ iceConn->io_ok = False;
+
+ if (iceConn->connection_status == IceConnectPending)
+ {
+ /*
+ * Don't invoke IO error handler if we are in the
+ * middle of a connection setup.
+ */
+
+ return (1);
+ }
+
+ if (iceConn->process_msg_info)
+ {
+ int i;
+
+ for (i = iceConn->his_min_opcode;
+ i <= iceConn->his_max_opcode; i++)
+ {
+ _IceProcessMsgInfo *process;
+
+ process = &iceConn->process_msg_info[
+ i - iceConn->his_min_opcode];
+
+ if (process->in_use)
+ {
+ IceIOErrorProc IOErrProc = process->accept_flag ?
+ process->protocol->accept_client->io_error_proc :
+ process->protocol->orig_client->io_error_proc;
+
+ if (IOErrProc)
+ (*IOErrProc) (iceConn);
+ }
+ }
+ }
+
+ (*_IceIOErrorHandler) (iceConn);
+ return (1);
+ }
+ }
+
+ nleft -= nread;
+ ptr += nread;
+ }
+
+ return (1);
+}
+
+
+
+/*
+ * If we read a message header with a bad major or minor opcode,
+ * we need to advance to the end of the message. This way, the next
+ * message can be processed correctly.
+ */
+
+void
+_IceReadSkip (iceConn, nbytes)
+
+register IceConn iceConn;
+register unsigned long nbytes;
+
+{
+ char temp[512];
+
+ while (nbytes > 0)
+ {
+ unsigned long rbytes = nbytes > 512 ? 512 : nbytes;
+
+ _IceRead (iceConn, rbytes, temp);
+ nbytes -= rbytes;
+ }
+}
+
+
+
+/*
+ * Write "n" bytes to a connection.
+ */
+
+void
+_IceWrite (iceConn, nbytes, ptr)
+
+register IceConn iceConn;
+unsigned long nbytes;
+register char *ptr;
+
+{
+ register unsigned long nleft;
+
+ nleft = nbytes;
+ while (nleft > 0)
+ {
+ int nwritten;
+
+ if (iceConn->io_ok)
+ nwritten = _IceTransWrite (iceConn->trans_conn, ptr, (int) nleft);
+ else
+ return;
+
+ if (nwritten <= 0)
+ {
+#ifdef WIN32
+ errno = WSAGetLastError();
+#endif
+ /*
+ * Fatal IO error. First notify each protocol's IceIOErrorProc
+ * callback, then invoke the application IO error handler.
+ */
+
+ iceConn->io_ok = False;
+
+ if (iceConn->connection_status == IceConnectPending)
+ {
+ /*
+ * Don't invoke IO error handler if we are in the
+ * middle of a connection setup.
+ */
+
+ return;
+ }
+
+ if (iceConn->process_msg_info)
+ {
+ int i;
+
+ for (i = iceConn->his_min_opcode;
+ i <= iceConn->his_max_opcode; i++)
+ {
+ _IceProcessMsgInfo *process;
+
+ process = &iceConn->process_msg_info[
+ i - iceConn->his_min_opcode];
+
+ if (process->in_use)
+ {
+ IceIOErrorProc IOErrProc = process->accept_flag ?
+ process->protocol->accept_client->io_error_proc :
+ process->protocol->orig_client->io_error_proc;
+
+ if (IOErrProc)
+ (*IOErrProc) (iceConn);
+ }
+ }
+ }
+
+ (*_IceIOErrorHandler) (iceConn);
+ return;
+ }
+
+ nleft -= nwritten;
+ ptr += nwritten;
+ }
+}
+
+#ifdef WORD64
+
+IceWriteData16 (iceConn, nbytes, data)
+
+IceConn iceConn;
+unsigned long nbytes;
+short *data;
+
+{
+ int numShorts = nbytes / 2;
+ int index = 0;
+
+ while (index < numShorts)
+ {
+ int spaceLeft, count, i;
+ int shortsLeft = numShorts - index;
+
+ spaceLeft = iceConn->outbufmax - iceConn->outbufptr - 1;
+
+ if (spaceLeft < 2)
+ {
+ IceFlush (iceConn);
+ spaceLeft = iceConn->outbufmax - iceConn->outbufptr - 1;
+ }
+
+ count = (shortsLeft < spaceLeft / 2) ? shortsLeft : spaceLeft / 2;
+
+ for (i = 0; i < count; i++)
+ STORE_CARD16 (iceConn->outbufptr, data[index++]);
+ }
+}
+
+
+IceWriteData32 (iceConn, nbytes, data)
+
+IceConn iceConn;
+unsigned long nbytes;
+int *data;
+
+{
+ int numLongs = nbytes / 4;
+ int index = 0;
+
+ while (index < numLongs)
+ {
+ int spaceLeft, count, i;
+ int longsLeft = numLongs - index;
+
+ spaceLeft = iceConn->outbufmax - iceConn->outbufptr - 1;
+
+ if (spaceLeft < 4)
+ {
+ IceFlush (iceConn);
+ spaceLeft = iceConn->outbufmax - iceConn->outbufptr - 1;
+ }
+
+ count = (longsLeft < spaceLeft / 4) ? longsLeft : spaceLeft / 4;
+
+ for (i = 0; i < count; i++)
+ STORE_CARD32 (iceConn->outbufptr, data[index++]);
+ }
+}
+
+
+IceReadData16 (iceConn, swap, nbytes, data)
+
+IceConn iceConn;
+Bool swap;
+unsigned long nbytes;
+short *data;
+
+{
+ /* NOT IMPLEMENTED YET */
+}
+
+
+IceReadData32 (iceConn, swap, nbytes, data)
+
+IceConn iceConn;
+Bool swap;
+unsigned long nbytes;
+int *data;
+
+{
+ /* NOT IMPLEMENTED YET */
+}
+
+#endif /* WORD64 */
+
+
+
+void
+_IceAddOpcodeMapping (iceConn, hisOpcode, myOpcode)
+
+IceConn iceConn;
+int hisOpcode;
+int myOpcode;
+
+{
+ if (hisOpcode <= 0 || hisOpcode > 255)
+ {
+ return;
+ }
+ else if (iceConn->process_msg_info == NULL)
+ {
+ iceConn->process_msg_info = (_IceProcessMsgInfo *) malloc (
+ sizeof (_IceProcessMsgInfo));
+ iceConn->his_min_opcode = iceConn->his_max_opcode = hisOpcode;
+ }
+ else if (hisOpcode < iceConn->his_min_opcode)
+ {
+ _IceProcessMsgInfo *oldVec = iceConn->process_msg_info;
+ int oldsize = iceConn->his_max_opcode - iceConn->his_min_opcode + 1;
+ int newsize = iceConn->his_max_opcode - hisOpcode + 1;
+ int i;
+
+ iceConn->process_msg_info = (_IceProcessMsgInfo *) malloc (
+ newsize * sizeof (_IceProcessMsgInfo));
+
+ memcpy (&iceConn->process_msg_info[
+ iceConn->his_min_opcode - hisOpcode], oldVec,
+ oldsize * sizeof (_IceProcessMsgInfo));
+
+ free ((char *) oldVec);
+
+ for (i = hisOpcode + 1; i < iceConn->his_min_opcode; i++)
+ {
+ iceConn->process_msg_info[i -
+ iceConn->his_min_opcode].in_use = False;
+
+ iceConn->process_msg_info[i -
+ iceConn->his_min_opcode].protocol = NULL;
+ }
+
+ iceConn->his_min_opcode = hisOpcode;
+ }
+ else if (hisOpcode > iceConn->his_max_opcode)
+ {
+ _IceProcessMsgInfo *oldVec = iceConn->process_msg_info;
+ int oldsize = iceConn->his_max_opcode - iceConn->his_min_opcode + 1;
+ int newsize = hisOpcode - iceConn->his_min_opcode + 1;
+ int i;
+
+ iceConn->process_msg_info = (_IceProcessMsgInfo *) malloc (
+ newsize * sizeof (_IceProcessMsgInfo));
+
+ memcpy (iceConn->process_msg_info, oldVec,
+ oldsize * sizeof (_IceProcessMsgInfo));
+
+ free ((char *) oldVec);
+
+ for (i = iceConn->his_max_opcode + 1; i < hisOpcode; i++)
+ {
+ iceConn->process_msg_info[i -
+ iceConn->his_min_opcode].in_use = False;
+
+ iceConn->process_msg_info[i -
+ iceConn->his_min_opcode].protocol = NULL;
+ }
+
+ iceConn->his_max_opcode = hisOpcode;
+ }
+
+ iceConn->process_msg_info[hisOpcode -
+ iceConn->his_min_opcode].in_use = True;
+
+ iceConn->process_msg_info[hisOpcode -
+ iceConn->his_min_opcode].my_opcode = myOpcode;
+
+ iceConn->process_msg_info[hisOpcode -
+ iceConn->his_min_opcode].protocol = &_IceProtocols[myOpcode - 1];
+}
+
+
+
+char *
+IceGetPeerName (IceConn iceConn)
+{
+ return (_IceTransGetPeerNetworkId (iceConn->trans_conn));
+}
+
+
+char *
+_IceGetPeerName (IceConn iceConn)
+{
+ return (IceGetPeerName(iceConn));
+}
diff --git a/nx-X11/lib/ICE/ping.c b/nx-X11/lib/ICE/ping.c
new file mode 100644
index 000000000..45329b6f5
--- /dev/null
+++ b/nx-X11/lib/ICE/ping.c
@@ -0,0 +1,66 @@
+/* $Xorg: ping.c,v 1.4 2001/02/09 02:03:26 xorgcvs Exp $ */
+/******************************************************************************
+
+
+Copyright 1993, 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.
+
+Author: Ralph Mor, X Consortium
+******************************************************************************/
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+#include <X11/ICE/ICElib.h>
+#include "ICElibint.h"
+
+Status
+IcePing (iceConn, pingReplyProc, clientData)
+
+IceConn iceConn;
+IcePingReplyProc pingReplyProc;
+IcePointer clientData;
+
+{
+ _IcePingWait *newping = (_IcePingWait *) malloc (sizeof (_IcePingWait));
+ _IcePingWait *ptr = iceConn->ping_waits;
+
+ if (newping == NULL)
+ return (0);
+
+ newping->ping_reply_proc = pingReplyProc;
+ newping->client_data = clientData;
+ newping->next = NULL;
+
+ while (ptr && ptr->next)
+ ptr = ptr->next;
+
+ if (ptr == NULL)
+ iceConn->ping_waits = newping;
+ else
+ ptr->next = newping;
+
+ IceSimpleMessage (iceConn, 0, ICE_Ping);
+ IceFlush (iceConn);
+
+ return (1);
+}
diff --git a/nx-X11/lib/ICE/process.c b/nx-X11/lib/ICE/process.c
new file mode 100644
index 000000000..2a97dcbe8
--- /dev/null
+++ b/nx-X11/lib/ICE/process.c
@@ -0,0 +1,2548 @@
+/* $Xorg: process.c,v 1.4 2001/02/09 02:03:26 xorgcvs Exp $ */
+/******************************************************************************
+
+
+Copyright 1993, 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.
+
+Author: Ralph Mor, X Consortium
+******************************************************************************/
+/* $XFree86: xc/lib/ICE/process.c,v 3.9tsi Exp $ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+#include <X11/ICE/ICElib.h>
+#include "ICElibint.h"
+
+#include <stdio.h> /* sprintf */
+
+/*
+ * Check for bad length
+ */
+
+#define CHECK_SIZE_MATCH(_iceConn, _opcode, _expected_len, _actual_len, _severity, _return) \
+ if ((((_actual_len) - SIZEOF (iceMsg)) >> 3) != _expected_len) \
+ { \
+ _IceErrorBadLength (_iceConn, 0, _opcode, _severity); \
+ return (_return); \
+ }
+
+#define CHECK_AT_LEAST_SIZE(_iceConn, _opcode, _expected_len, _actual_len, _severity) \
+ if ((((_actual_len) - SIZEOF (iceMsg)) >> 3) > _expected_len) \
+ { \
+ _IceErrorBadLength (_iceConn, 0, _opcode, _severity); \
+ return (0); \
+ }
+
+#define CHECK_COMPLETE_SIZE(_iceConn, _opcode, _expected_len, _actual_len, _pStart, _severity) \
+ if (((PADDED_BYTES64((_actual_len)) - SIZEOF (iceMsg)) >> 3) \
+ != _expected_len) \
+ { \
+ _IceErrorBadLength (_iceConn, 0, _opcode, _severity); \
+ IceDisposeCompleteMessage (iceConn, _pStart); \
+ return (0); \
+ }
+
+#define BAIL_STRING(_iceConn, _opcode, _pStart) {\
+ _IceErrorBadLength (_iceConn, 0, _opcode, IceFatalToConnection);\
+ IceDisposeCompleteMessage (_iceConn, _pStart);\
+ return (0);\
+}
+
+/*
+ * IceProcessMessages:
+ *
+ * If replyWait == NULL, the client is not waiting for a reply.
+ *
+ * If replyWait != NULL, the client is waiting for a reply...
+ *
+ * - replyWait->sequence_of_request is the sequence number of the
+ * message for which the client is waiting a reply. This is needed
+ * to determine if an error matches a replyWait.
+ *
+ * - replyWait->major_opcode_of_request is the major opcode of the
+ * message for which we are waiting a reply.
+ *
+ * - replyWait->minor_opcode_of_request is the minor opcode of the
+ * message for which we are waiting a reply.
+ *
+ * - replyWait->reply is a pointer to the reply message which will be
+ * filled in when the reply is ready (the protocol library should
+ * cast this IcePointer to the appropriate reply type). In most cases,
+ * the reply will have some fixed-size part, and the sender function
+ * will have provided a pointer to a structure (e.g.) to hold this
+ * fixed-size data. If there is variable-length data, it would be
+ * expected that the reply function will have to allocate additional
+ * memory and store pointer(s) to that memory in the fixed-size
+ * structure. If the entire data is variable length (e.g., a single
+ * variable-length string), then the sender function would probably
+ * just pass a pointer to fixed-size space to hold a pointer, and the
+ * reply function would allocate the storage and store the pointer.
+ * It is the responsibility of the client receiving the reply to
+ * free up any memory allocated on it's behalf.
+ *
+ * We might be waiting for several different replies (a function can wait
+ * for a reply, and while calling IceProcessMessages, a callback can be
+ * invoked which will wait for another reply). We take advantage of the
+ * fact that for a given protocol, we are guaranteed that messages are
+ * processed in the order we sent them. So, everytime we have a new
+ * replyWait, we add it to the END of the 'saved_reply_waits' list. When
+ * we read a message and want to see if it matches a replyWait, we use the
+ * FIRST replyWait in the list with the major opcode of the message. If the
+ * reply is ready, we remove that replyWait from the list.
+ *
+ * If the reply/error is ready for the replyWait passed in to
+ * IceProcessMessages, *replyReadyRet is set to True.
+ *
+ * The return value of IceProcessMessages is one of the following:
+ *
+ * IceProcessMessagesSuccess - the message was processed successfully.
+ * IceProcessMessagesIOError - an IO error occured. The caller should
+ * invoked IceCloseConnection.
+ * IceProcessMessagesConnectionClosed - the connection was closed as a
+ * result of shutdown negotiation.
+ */
+
+IceProcessMessagesStatus
+IceProcessMessages (iceConn, replyWait, replyReadyRet)
+
+IceConn iceConn;
+IceReplyWaitInfo *replyWait;
+Bool *replyReadyRet;
+
+{
+ iceMsg *header;
+ Bool replyReady = False;
+ IceReplyWaitInfo *useThisReplyWait = NULL;
+ IceProcessMessagesStatus retStatus = IceProcessMessagesSuccess;
+
+ if (replyWait)
+ *replyReadyRet = False;
+
+ /*
+ * Each time IceProcessMessages is entered, we increment the dispatch
+ * level. Each time we leave it, we decrement the dispatch level.
+ */
+
+ iceConn->dispatch_level++;
+
+
+ /*
+ * Read the ICE message header.
+ */
+
+ if (!_IceRead (iceConn, (unsigned long) SIZEOF (iceMsg), iceConn->inbuf))
+ {
+ /*
+ * If we previously sent a WantToClose and now we detected
+ * that the connection was closed, _IceRead returns status 0.
+ * Since the connection was closed, we just want to return here.
+ */
+
+ return (IceProcessMessagesConnectionClosed);
+ }
+
+ if (!iceConn->io_ok)
+ {
+ /*
+ * An unexpected IO error occured. The caller of IceProcessMessages
+ * should call IceCloseConnection which will cause the watch procedures
+ * to be invoked and the ICE connection to be freed.
+ */
+
+ iceConn->dispatch_level--;
+ iceConn->connection_status = IceConnectIOError;
+ return (IceProcessMessagesIOError);
+ }
+
+ header = (iceMsg *) iceConn->inbuf;
+ iceConn->inbufptr = iceConn->inbuf + SIZEOF (iceMsg);
+
+ iceConn->receive_sequence++;
+
+ if (iceConn->waiting_for_byteorder)
+ {
+ if (header->majorOpcode == 0 &&
+ header->minorOpcode == ICE_ByteOrder)
+ {
+ char byteOrder = ((iceByteOrderMsg *) header)->byteOrder;
+ int endian = 1;
+
+ CHECK_SIZE_MATCH (iceConn, ICE_ByteOrder,
+ header->length, SIZEOF (iceByteOrderMsg),
+ IceFatalToConnection, IceProcessMessagesIOError);
+
+ if (byteOrder != IceMSBfirst && byteOrder != IceLSBfirst)
+ {
+ _IceErrorBadValue (iceConn, 0,
+ ICE_ByteOrder, 2, 1, &byteOrder);
+
+ iceConn->connection_status = IceConnectRejected;
+ }
+ else
+ {
+ iceConn->swap =
+ (((*(char *) &endian) && byteOrder == IceMSBfirst) ||
+ (!(*(char *) &endian) && byteOrder == IceLSBfirst));
+
+ iceConn->waiting_for_byteorder = 0;
+ }
+ }
+ else
+ {
+ if (header->majorOpcode != 0)
+ {
+ _IceErrorBadMajor (iceConn, header->majorOpcode,
+ header->minorOpcode, IceFatalToConnection);
+ }
+ else
+ {
+ _IceErrorBadState (iceConn, 0,
+ header->minorOpcode, IceFatalToConnection);
+ }
+
+ iceConn->connection_status = IceConnectRejected;
+ }
+
+ iceConn->dispatch_level--;
+ if (!iceConn->io_ok)
+ {
+ iceConn->connection_status = IceConnectIOError;
+ retStatus = IceProcessMessagesIOError;
+ }
+
+ return (retStatus);
+ }
+
+ if (iceConn->swap)
+ {
+ /* swap the length field */
+
+ header->length = lswapl (header->length);
+ }
+
+ if (replyWait)
+ {
+ /*
+ * Add to the list of replyWaits (only if it doesn't exist
+ * in the list already.
+ */
+
+ _IceAddReplyWait (iceConn, replyWait);
+
+ /*
+ * Note that there are two different replyWaits. The first is
+ * the one passed into IceProcessMessages, and is the replyWait
+ * for the message the client is blocking on. The second is
+ * the replyWait for the message currently being processed
+ * by IceProcessMessages. We call it "useThisReplyWait".
+ *
+ * Also, when two hosts communicate over an ICE connection and use
+ * different major opcodes for a subprotocol, it is impossible
+ * to use message replies unless we translate opcodes before
+ * comparing them.
+ */
+
+ {
+ int op;
+
+ if (header->majorOpcode == 0)
+ {
+ op = 0;
+ }
+ else
+ {
+ int idx = header->majorOpcode - iceConn->his_min_opcode;
+ op = iceConn->process_msg_info[idx].my_opcode;
+ }
+ useThisReplyWait = _IceSearchReplyWaits (iceConn, op);
+ }
+ }
+
+ if (header->majorOpcode == 0)
+ {
+ /*
+ * ICE protocol
+ */
+
+ Bool connectionClosed;
+
+ _IceProcessCoreMsgProc processIce =
+ _IceVersions[iceConn->my_ice_version_index].process_core_msg_proc;
+
+ (*processIce) (iceConn, header->minorOpcode,
+ header->length, iceConn->swap,
+ useThisReplyWait, &replyReady, &connectionClosed);
+
+ if (connectionClosed)
+ {
+ /*
+ * As a result of shutdown negotiation, the connection was closed.
+ */
+
+ return (IceProcessMessagesConnectionClosed);
+ }
+ }
+ else
+ {
+ /*
+ * Sub protocol
+ */
+
+ if ((int) header->majorOpcode < iceConn->his_min_opcode ||
+ (int) header->majorOpcode > iceConn->his_max_opcode ||
+ !(iceConn->process_msg_info[header->majorOpcode -
+ iceConn->his_min_opcode].in_use))
+ {
+ /*
+ * The protocol of the message we just read is not supported.
+ */
+
+ _IceErrorBadMajor (iceConn, header->majorOpcode,
+ header->minorOpcode, IceCanContinue);
+
+ _IceReadSkip (iceConn, header->length << 3);
+ }
+ else
+ {
+ _IceProcessMsgInfo *processMsgInfo = &iceConn->process_msg_info[
+ header->majorOpcode - iceConn->his_min_opcode];
+
+ if (processMsgInfo->accept_flag)
+ {
+ IcePaProcessMsgProc processProc =
+ processMsgInfo->process_msg_proc.accept_client;
+
+ (*processProc) (iceConn, processMsgInfo->client_data,
+ header->minorOpcode, header->length, iceConn->swap);
+ }
+ else
+ {
+ IcePoProcessMsgProc processProc =
+ processMsgInfo->process_msg_proc.orig_client;
+
+ (*processProc) (iceConn,
+ processMsgInfo->client_data, header->minorOpcode,
+ header->length, iceConn->swap,
+ useThisReplyWait, &replyReady);
+ }
+ }
+ }
+
+ if (replyReady)
+ {
+ _IceSetReplyReady (iceConn, useThisReplyWait);
+ }
+
+
+ /*
+ * Now we check if the reply is ready for the replyWait passed
+ * into IceProcessMessages. The replyWait is removed from the
+ * replyWait list if it is ready.
+ */
+
+ if (replyWait)
+ *replyReadyRet = _IceCheckReplyReady (iceConn, replyWait);
+
+
+ /*
+ * Decrement the dispatch level. If we reach level 0, and the
+ * free_asap bit is set, free the connection now. Also check for
+ * possible bad IO status.
+ */
+
+ iceConn->dispatch_level--;
+
+ if (iceConn->dispatch_level == 0 && iceConn->free_asap)
+ {
+ _IceFreeConnection (iceConn);
+ retStatus = IceProcessMessagesConnectionClosed;
+ }
+ else if (!iceConn->io_ok)
+ {
+ iceConn->connection_status = IceConnectIOError;
+ retStatus = IceProcessMessagesIOError;
+ }
+
+ return (retStatus);
+}
+
+
+
+static void
+AuthRequired (iceConn, authIndex, authDataLen, authData)
+
+IceConn iceConn;
+int authIndex;
+int authDataLen;
+IcePointer authData;
+
+{
+ iceAuthRequiredMsg *pMsg;
+
+ IceGetHeader (iceConn, 0, ICE_AuthRequired,
+ SIZEOF (iceAuthRequiredMsg), iceAuthRequiredMsg, pMsg);
+
+ pMsg->authIndex = authIndex;
+ pMsg->authDataLength = authDataLen;
+ pMsg->length += WORD64COUNT (authDataLen);
+
+ IceWriteData (iceConn, authDataLen, (char *) authData);
+
+ if (PAD64 (authDataLen))
+ IceWritePad (iceConn, PAD64 (authDataLen));
+
+ IceFlush (iceConn);
+}
+
+
+
+static void
+AuthReply (iceConn, authDataLen, authData)
+
+IceConn iceConn;
+int authDataLen;
+IcePointer authData;
+
+{
+ iceAuthReplyMsg *pMsg;
+
+ IceGetHeader (iceConn, 0, ICE_AuthReply,
+ SIZEOF (iceAuthReplyMsg), iceAuthReplyMsg, pMsg);
+
+ pMsg->authDataLength = authDataLen;
+ pMsg->length += WORD64COUNT (authDataLen);
+
+ IceWriteData (iceConn, authDataLen, (char *) authData);
+
+ if (PAD64 (authDataLen))
+ IceWritePad (iceConn, PAD64 (authDataLen));
+
+ IceFlush (iceConn);
+}
+
+
+
+static void
+AuthNextPhase (iceConn, authDataLen, authData)
+
+IceConn iceConn;
+int authDataLen;
+IcePointer authData;
+
+{
+ iceAuthNextPhaseMsg *pMsg;
+
+ IceGetHeader (iceConn, 0, ICE_AuthNextPhase,
+ SIZEOF (iceAuthNextPhaseMsg), iceAuthNextPhaseMsg, pMsg);
+
+ pMsg->authDataLength = authDataLen;
+ pMsg->length += WORD64COUNT (authDataLen);
+
+ IceWriteData (iceConn, authDataLen, (char *) authData);
+
+ if (PAD64 (authDataLen))
+ IceWritePad (iceConn, PAD64 (authDataLen));
+
+ IceFlush (iceConn);
+}
+
+
+
+static void
+AcceptConnection (iceConn, versionIndex)
+
+IceConn iceConn;
+int versionIndex;
+
+{
+ iceConnectionReplyMsg *pMsg;
+ char *pData;
+ int extra;
+
+ extra = STRING_BYTES (IceVendorString) + STRING_BYTES (IceReleaseString);
+
+ IceGetHeaderExtra (iceConn, 0, ICE_ConnectionReply,
+ SIZEOF (iceConnectionReplyMsg), WORD64COUNT (extra),
+ iceConnectionReplyMsg, pMsg, pData);
+
+ pMsg->versionIndex = versionIndex;
+
+ STORE_STRING (pData, IceVendorString);
+ STORE_STRING (pData, IceReleaseString);
+
+ IceFlush (iceConn);
+
+ iceConn->connection_status = IceConnectAccepted;
+}
+
+
+
+static void
+AcceptProtocol (iceConn, hisOpcode, myOpcode, versionIndex, vendor, release)
+
+IceConn iceConn;
+int hisOpcode;
+int myOpcode;
+int versionIndex;
+char *vendor;
+char *release;
+
+{
+ iceProtocolReplyMsg *pMsg;
+ char *pData;
+ int extra;
+
+ extra = STRING_BYTES (vendor) + STRING_BYTES (release);
+
+ IceGetHeaderExtra (iceConn, 0, ICE_ProtocolReply,
+ SIZEOF (iceProtocolReplyMsg), WORD64COUNT (extra),
+ iceProtocolReplyMsg, pMsg, pData);
+
+ pMsg->protocolOpcode = myOpcode;
+ pMsg->versionIndex = versionIndex;
+
+ STORE_STRING (pData, vendor);
+ STORE_STRING (pData, release);
+
+ IceFlush (iceConn);
+
+
+ /*
+ * We may be using a different major opcode for this protocol
+ * than the other client. Whenever we get a message, we must
+ * map to our own major opcode.
+ */
+
+ _IceAddOpcodeMapping (iceConn, hisOpcode, myOpcode);
+}
+
+
+
+static void
+PingReply (iceConn)
+
+IceConn iceConn;
+
+{
+ IceSimpleMessage (iceConn, 0, ICE_PingReply);
+ IceFlush (iceConn);
+}
+
+
+
+static Bool
+ProcessError (iceConn, length, swap, replyWait)
+
+IceConn iceConn;
+unsigned long length;
+Bool swap;
+IceReplyWaitInfo *replyWait;
+
+{
+ int invokeHandler = 0;
+ Bool errorReturned = False;
+ iceErrorMsg *message;
+ char *pData, *pStart;
+ char severity;
+
+ CHECK_AT_LEAST_SIZE (iceConn, ICE_Error,
+ length, SIZEOF (iceErrorMsg),
+ (iceConn->connect_to_you || iceConn->connect_to_me) ?
+ IceFatalToConnection : IceFatalToProtocol);
+
+ IceReadCompleteMessage (iceConn, SIZEOF (iceErrorMsg),
+ iceErrorMsg, message, pStart);
+
+ if (!IceValidIO (iceConn))
+ {
+ IceDisposeCompleteMessage (iceConn, pStart);
+ return (0);
+ }
+
+ severity = message->severity;
+
+ if (severity != IceCanContinue && severity != IceFatalToProtocol &&
+ severity != IceFatalToConnection)
+ {
+ _IceErrorBadValue (iceConn, 0,
+ ICE_Error, 9, 1, &severity);
+ IceDisposeCompleteMessage (iceConn, pStart);
+ return (0);
+ }
+
+ pData = pStart;
+
+ if (swap)
+ {
+ message->errorClass = lswaps (message->errorClass);
+ message->offendingSequenceNum = lswapl (message->offendingSequenceNum);
+ }
+
+ if (!replyWait ||
+ message->offendingSequenceNum != replyWait->sequence_of_request)
+ {
+ invokeHandler = 1;
+ }
+ else
+ {
+ if (iceConn->connect_to_you &&
+ ((!iceConn->connect_to_you->auth_active &&
+ message->offendingMinorOpcode == ICE_ConnectionSetup) ||
+ (iceConn->connect_to_you->auth_active &&
+ message->offendingMinorOpcode == ICE_AuthReply)))
+ {
+ _IceConnectionError *errorReply =
+ &(((_IceReply *) (replyWait->reply))->connection_error);
+ char *errorStr = NULL;
+ char *tempstr;
+ char *prefix, *temp;
+
+ invokeHandler = 0;
+ errorReturned = True;
+
+ switch (message->errorClass)
+ {
+ case IceNoVersion:
+
+ tempstr =
+ "None of the ICE versions specified are supported";
+ errorStr = (char *) malloc (strlen (tempstr) + 1);
+ strcpy (errorStr, tempstr);
+ break;
+
+ case IceNoAuth:
+
+ tempstr =
+ "None of the authentication protocols specified are supported";
+ errorStr = (char *) malloc (strlen (tempstr) + 1);
+ strcpy (errorStr, tempstr);
+ break;
+
+ case IceSetupFailed:
+
+ prefix = "Connection Setup Failed, reason : ";
+
+ EXTRACT_STRING (pData, swap, temp);
+ errorStr = (char *) malloc (
+ strlen (prefix) + strlen (temp) + 1);
+ sprintf (errorStr, "%s%s", prefix, temp);
+ free (temp);
+ break;
+
+ case IceAuthRejected:
+
+ prefix = "Authentication Rejected, reason : ";
+ EXTRACT_STRING (pData, swap, temp);
+ errorStr = (char *) malloc (
+ strlen (prefix) + strlen (temp) + 1);
+ sprintf (errorStr, "%s%s", prefix, temp);
+ free (temp);
+ break;
+
+ case IceAuthFailed:
+
+ prefix = "Authentication Failed, reason : ";
+ EXTRACT_STRING (pData, swap, temp);
+ errorStr = (char *) malloc (
+ strlen (prefix) + strlen (temp) + 1);
+ sprintf (errorStr, "%s%s", prefix, temp);
+ free (temp);
+ break;
+
+ default:
+ invokeHandler = 1;
+ }
+
+ errorReply->type = ICE_CONNECTION_ERROR;
+ errorReply->error_message = errorStr;
+ }
+ else if (iceConn->protosetup_to_you &&
+ ((!iceConn->protosetup_to_you->auth_active &&
+ message->offendingMinorOpcode == ICE_ProtocolSetup) ||
+ (iceConn->protosetup_to_you->auth_active &&
+ message->offendingMinorOpcode == ICE_AuthReply)))
+ {
+ _IceProtocolError *errorReply =
+ &(((_IceReply *) (replyWait->reply))->protocol_error);
+ char *errorStr = "";
+ char *prefix, *temp;
+
+ invokeHandler = 0;
+ errorReturned = True;
+
+ switch (message->errorClass)
+ {
+ case IceNoVersion:
+
+ temp =
+ "None of the protocol versions specified are supported";
+ errorStr = (char *) malloc (strlen (temp) + 1);
+ strcpy (errorStr, temp);
+ break;
+
+ case IceNoAuth:
+
+ temp =
+ "None of the authentication protocols specified are supported";
+ errorStr = (char *) malloc (strlen (temp) + 1);
+ strcpy (errorStr, temp);
+ break;
+
+ case IceSetupFailed:
+
+ prefix = "Protocol Setup Failed, reason : ";
+
+ EXTRACT_STRING (pData, swap, temp);
+ errorStr = (char *) malloc (
+ strlen (prefix) + strlen (temp) + 1);
+ sprintf (errorStr, "%s%s", prefix, temp);
+ free (temp);
+ break;
+
+ case IceAuthRejected:
+
+ prefix = "Authentication Rejected, reason : ";
+ EXTRACT_STRING (pData, swap, temp);
+ errorStr = (char *) malloc (
+ strlen (prefix) + strlen (temp) + 1);
+ sprintf (errorStr, "%s%s", prefix, temp);
+ free (temp);
+ break;
+
+ case IceAuthFailed:
+
+ prefix = "Authentication Failed, reason : ";
+ EXTRACT_STRING (pData, swap, temp);
+ errorStr = (char *) malloc (
+ strlen (prefix) + strlen (temp) + 1);
+ sprintf (errorStr, "%s%s", prefix, temp);
+ free (temp);
+ break;
+
+ case IceProtocolDuplicate:
+
+ prefix = "Protocol was already registered : ";
+ EXTRACT_STRING (pData, swap, temp);
+ errorStr = (char *) malloc (
+ strlen (prefix) + strlen (temp) + 1);
+ sprintf (errorStr, "%s%s", prefix, temp);
+ free (temp);
+ break;
+
+ case IceMajorOpcodeDuplicate:
+
+ prefix = "The major opcode was already used : ";
+ errorStr = (char *) malloc (strlen (prefix) + 2);
+ sprintf (errorStr, "%s%d", prefix, (int) *pData);
+ break;
+
+ case IceUnknownProtocol:
+
+ prefix = "Unknown Protocol : ";
+ EXTRACT_STRING (pData, swap, temp);
+ errorStr = (char *) malloc (
+ strlen (prefix) + strlen (temp) + 1);
+ sprintf (errorStr, "%s%s", prefix, temp);
+ free (temp);
+ break;
+
+ default:
+ invokeHandler = 1;
+ }
+
+ errorReply->type = ICE_PROTOCOL_ERROR;
+ errorReply->error_message = errorStr;
+ }
+
+ if (errorReturned == True)
+ {
+ /*
+ * If we tried to authenticate, tell the authentication
+ * procedure to clean up.
+ */
+
+ IcePoAuthProc authProc;
+
+ if (iceConn->connect_to_you &&
+ iceConn->connect_to_you->auth_active)
+ {
+ authProc = _IcePoAuthProcs[(int)
+ (iceConn->connect_to_you->my_auth_index)];
+
+ (*authProc) (iceConn, &iceConn->connect_to_you->my_auth_state,
+ True /* clean up */, False /* swap */,
+ 0, NULL, NULL, NULL, NULL);
+ }
+ else if (iceConn->protosetup_to_you &&
+ iceConn->protosetup_to_you->auth_active)
+ {
+ _IcePoProtocol *protocol = _IceProtocols[
+ iceConn->protosetup_to_you->my_opcode - 1].orig_client;
+
+ authProc = protocol->auth_procs[(int)(iceConn->
+ protosetup_to_you->my_auth_index)];
+
+ (*authProc) (iceConn,
+ &iceConn->protosetup_to_you->my_auth_state,
+ True /* clean up */, False /* swap */,
+ 0, NULL, NULL, NULL, NULL);
+ }
+ }
+ }
+
+ if (invokeHandler)
+ {
+ (*_IceErrorHandler) (iceConn, swap, message->offendingMinorOpcode,
+ message->offendingSequenceNum, message->errorClass,
+ message->severity, (IcePointer) pData);
+ }
+
+ IceDisposeCompleteMessage (iceConn, pStart);
+
+ return (errorReturned);
+}
+
+
+
+static int
+ProcessConnectionSetup (iceConn, length, swap)
+
+IceConn iceConn;
+unsigned long length;
+Bool swap;
+
+{
+ iceConnectionSetupMsg *message;
+ int myVersionCount, hisVersionCount;
+ int myVersionIndex, hisVersionIndex;
+ int hisMajorVersion, hisMinorVersion;
+ int myAuthCount, hisAuthCount;
+ int found, i, j;
+ char *myAuthName, **hisAuthNames = NULL;
+ char *pData, *pStart, *pEnd;
+ char *vendor = NULL;
+ char *release = NULL;
+ int myAuthIndex = 0;
+ int hisAuthIndex = 0;
+ int accept_setup_now = 0;
+ char mustAuthenticate;
+ int authUsableCount;
+ int authUsableFlags[MAX_ICE_AUTH_NAMES];
+ int authIndices[MAX_ICE_AUTH_NAMES];
+
+ CHECK_AT_LEAST_SIZE (iceConn, ICE_ConnectionSetup,
+ length, SIZEOF (iceConnectionSetupMsg), IceFatalToConnection);
+
+ IceReadCompleteMessage (iceConn, SIZEOF (iceConnectionSetupMsg),
+ iceConnectionSetupMsg, message, pStart);
+
+ if (!IceValidIO (iceConn))
+ {
+ IceDisposeCompleteMessage (iceConn, pStart);
+ return (0);
+ }
+
+ pData = pStart;
+ pEnd = pStart + (length << 3);
+
+ SKIP_STRING (pData, swap, pEnd,
+ BAIL_STRING(iceConn, ICE_ConnectionSetup,
+ pStart)); /* vendor */
+ SKIP_STRING (pData, swap, pEnd,
+ BAIL_STRING(iceConn, ICE_ConnectionSetup,
+ pStart)); /* release */
+ SKIP_LISTOF_STRING (pData, swap, (int) message->authCount, pEnd,
+ BAIL_STRING(iceConn, ICE_ConnectionSetup,
+ pStart)); /* auth names */
+
+ pData += (message->versionCount * 4); /* versions */
+
+ CHECK_COMPLETE_SIZE (iceConn, ICE_ConnectionSetup,
+ length, pData - pStart + SIZEOF (iceConnectionSetupMsg),
+ pStart, IceFatalToConnection);
+
+ mustAuthenticate = message->mustAuthenticate;
+ if (mustAuthenticate != 0 && mustAuthenticate != 1)
+ {
+ _IceErrorBadValue (iceConn, 0,
+ ICE_ConnectionSetup, 8, 1, &mustAuthenticate);
+ iceConn->connection_status = IceConnectRejected;
+ IceDisposeCompleteMessage (iceConn, pStart);
+ return (0);
+ }
+
+ pData = pStart;
+
+ EXTRACT_STRING (pData, swap, vendor);
+ EXTRACT_STRING (pData, swap, release);
+
+ if ((hisAuthCount = message->authCount) > 0)
+ {
+ hisAuthNames = (char **) malloc (hisAuthCount * sizeof (char *));
+ EXTRACT_LISTOF_STRING (pData, swap, hisAuthCount, hisAuthNames);
+ }
+
+ hisVersionCount = message->versionCount;
+ myVersionCount = _IceVersionCount;
+
+ hisVersionIndex = myVersionIndex = found = 0;
+
+ for (i = 0; i < hisVersionCount && !found; i++)
+ {
+ EXTRACT_CARD16 (pData, swap, hisMajorVersion);
+ EXTRACT_CARD16 (pData, swap, hisMinorVersion);
+
+ for (j = 0; j < myVersionCount && !found; j++)
+ {
+ if (_IceVersions[j].major_version == hisMajorVersion &&
+ _IceVersions[j].minor_version == hisMinorVersion)
+ {
+ hisVersionIndex = i;
+ myVersionIndex = j;
+ found = 1;
+ }
+ }
+ }
+
+ if (!found)
+ {
+ _IceErrorNoVersion (iceConn, ICE_ConnectionSetup);
+ iceConn->connection_status = IceConnectRejected;
+
+ free (vendor);
+ free (release);
+
+ if (hisAuthCount > 0)
+ {
+ for (i = 0; i < hisAuthCount; i++)
+ free (hisAuthNames[i]);
+
+ free ((char *) hisAuthNames);
+ }
+
+ IceDisposeCompleteMessage (iceConn, pStart);
+ return (0);
+ }
+
+ _IceGetPaValidAuthIndices ("ICE", iceConn->connection_string,
+ _IceAuthCount, _IceAuthNames, &authUsableCount, authIndices);
+
+ for (i = 0; i < _IceAuthCount; i++)
+ {
+ authUsableFlags[i] = 0;
+ for (j = 0; j < authUsableCount && !authUsableFlags[i]; j++)
+ authUsableFlags[i] = (authIndices[j] == i);
+ }
+
+ myAuthCount = _IceAuthCount;
+
+ for (i = found = 0; i < myAuthCount && !found; i++)
+ {
+ if (authUsableFlags[i])
+ {
+ myAuthName = _IceAuthNames[i];
+
+ for (j = 0; j < hisAuthCount && !found; j++)
+ if (strcmp (myAuthName, hisAuthNames[j]) == 0)
+ {
+ myAuthIndex = i;
+ hisAuthIndex = j;
+ found = 1;
+ }
+ }
+ }
+
+ if (!found)
+ {
+ /*
+ * None of the authentication methods specified by the
+ * other client is supported. If the other client requires
+ * authentication, we must reject the connection now.
+ * Otherwise, we can invoke the host-based authentication callback
+ * to see if we can accept this connection.
+ */
+
+ if (mustAuthenticate || !iceConn->listen_obj->host_based_auth_proc)
+ {
+ _IceErrorNoAuthentication (iceConn, ICE_ConnectionSetup);
+ iceConn->connection_status = IceConnectRejected;
+ }
+ else
+ {
+ char *hostname = _IceGetPeerName (iceConn);
+
+ if ((*iceConn->listen_obj->host_based_auth_proc) (hostname))
+ {
+ accept_setup_now = 1;
+ }
+ else
+ {
+ _IceErrorAuthenticationRejected (iceConn,
+ ICE_ConnectionSetup, "None of the authentication protocols specified are supported and host-based authentication failed");
+
+ iceConn->connection_status = IceConnectRejected;
+ }
+
+ if (hostname)
+ free (hostname);
+ }
+
+ if (iceConn->connection_status == IceConnectRejected)
+ {
+ free (vendor);
+ free (release);
+ }
+ }
+ else
+ {
+ IcePaAuthStatus status;
+ int authDataLen;
+ IcePointer authData = NULL;
+ IcePointer authState;
+ char *errorString = NULL;
+ IcePaAuthProc authProc = _IcePaAuthProcs[myAuthIndex];
+
+ authState = NULL;
+
+ status = (*authProc) (iceConn, &authState,
+ swap, 0, NULL, &authDataLen, &authData, &errorString);
+
+ if (status == IcePaAuthContinue)
+ {
+ _IceConnectToMeInfo *setupInfo;
+
+ AuthRequired (iceConn, hisAuthIndex, authDataLen, authData);
+
+ iceConn->connect_to_me = setupInfo = (_IceConnectToMeInfo *)
+ malloc (sizeof (_IceConnectToMeInfo));
+
+ setupInfo->my_version_index = myVersionIndex;
+ setupInfo->his_version_index = hisVersionIndex;
+ setupInfo->his_vendor = vendor;
+ setupInfo->his_release = release;
+ setupInfo->my_auth_index = myAuthIndex;
+ setupInfo->my_auth_state = authState;
+ setupInfo->must_authenticate = mustAuthenticate;
+ }
+ else if (status == IcePaAuthAccepted)
+ {
+ accept_setup_now = 1;
+ }
+
+ if (authData && authDataLen > 0)
+ free ((char *) authData);
+
+ if (errorString)
+ free (errorString);
+ }
+
+ if (accept_setup_now)
+ {
+ AcceptConnection (iceConn, hisVersionIndex);
+
+ iceConn->vendor = vendor;
+ iceConn->release = release;
+ iceConn->my_ice_version_index = myVersionIndex;
+ }
+
+ if (hisAuthCount > 0)
+ {
+ for (i = 0; i < hisAuthCount; i++)
+ free (hisAuthNames[i]);
+
+ free ((char *) hisAuthNames);
+ }
+
+ IceDisposeCompleteMessage (iceConn, pStart);
+ return (0);
+}
+
+
+
+static Bool
+ProcessAuthRequired (iceConn, length, swap, replyWait)
+
+IceConn iceConn;
+unsigned long length;
+Bool swap;
+IceReplyWaitInfo *replyWait;
+
+{
+ iceAuthRequiredMsg *message;
+ int authDataLen;
+ IcePointer authData;
+ int replyDataLen;
+ IcePointer replyData = NULL;
+ char *errorString = NULL;
+ IcePoAuthProc authProc;
+ IcePoAuthStatus status;
+ IcePointer authState;
+ int realAuthIndex = 0;
+
+ CHECK_AT_LEAST_SIZE (iceConn, ICE_AuthRequired,
+ length, SIZEOF (iceAuthRequiredMsg),
+ iceConn->connect_to_you ? IceFatalToConnection : IceFatalToProtocol);
+
+ IceReadCompleteMessage (iceConn, SIZEOF (iceAuthRequiredMsg),
+ iceAuthRequiredMsg, message, authData);
+
+ if (!IceValidIO (iceConn))
+ {
+ IceDisposeCompleteMessage (iceConn, authData);
+ return (0);
+ }
+
+ if (swap)
+ {
+ message->authDataLength = lswaps (message->authDataLength);
+ }
+
+ CHECK_COMPLETE_SIZE (iceConn, ICE_AuthRequired, length,
+ message->authDataLength + SIZEOF (iceAuthRequiredMsg), authData,
+ iceConn->connect_to_you ? IceFatalToConnection : IceFatalToProtocol);
+
+ if (iceConn->connect_to_you)
+ {
+ if ((int) message->authIndex >= _IceAuthCount)
+ {
+ _IceConnectionError *errorReply =
+ &(((_IceReply *) (replyWait->reply))->connection_error);
+
+ char *tempstr = "Received bad authIndex in the AuthRequired message";
+ char errIndex = (int) message->authIndex;
+
+ errorString = (char *) malloc (strlen (tempstr) + 1);
+ strcpy (errorString, tempstr);
+
+ errorReply->type = ICE_CONNECTION_ERROR;
+ errorReply->error_message = errorString;
+
+ _IceErrorBadValue (iceConn, 0,
+ ICE_AuthRequired, 2, 1, &errIndex);
+
+ IceDisposeCompleteMessage (iceConn, authData);
+ return (1);
+ }
+ else
+ {
+ authProc = _IcePoAuthProcs[message->authIndex];
+
+ iceConn->connect_to_you->auth_active = 1;
+ }
+ }
+ else if (iceConn->protosetup_to_you)
+ {
+ if ((int) message->authIndex >=
+ iceConn->protosetup_to_you->my_auth_count)
+ {
+ _IceProtocolError *errorReply =
+ &(((_IceReply *) (replyWait->reply))->protocol_error);
+
+ char *tempstr = "Received bad authIndex in the AuthRequired message";
+ char errIndex = (int) message->authIndex;
+
+ errorString = (char *) malloc (strlen (tempstr) + 1);
+ strcpy (errorString, tempstr);
+
+ errorReply->type = ICE_PROTOCOL_ERROR;
+ errorReply->error_message = errorString;
+
+ _IceErrorBadValue (iceConn, 0,
+ ICE_AuthRequired, 2, 1, &errIndex);
+
+ IceDisposeCompleteMessage (iceConn, authData);
+ return (1);
+ }
+ else
+ {
+ _IcePoProtocol *myProtocol = _IceProtocols[
+ iceConn->protosetup_to_you->my_opcode - 1].orig_client;
+
+ realAuthIndex = iceConn->protosetup_to_you->
+ my_auth_indices[message->authIndex];
+
+ authProc = myProtocol->auth_procs[realAuthIndex];
+
+ iceConn->protosetup_to_you->auth_active = 1;
+ }
+ }
+ else
+ {
+ /*
+ * Unexpected message
+ */
+
+ _IceErrorBadState (iceConn, 0, ICE_AuthRequired, IceCanContinue);
+
+ IceDisposeCompleteMessage (iceConn, authData);
+ return (0);
+ }
+
+ authState = NULL;
+ authDataLen = message->authDataLength;
+
+ status = (*authProc) (iceConn, &authState, False /* don't clean up */,
+ swap, authDataLen, authData, &replyDataLen, &replyData, &errorString);
+
+ if (status == IcePoAuthHaveReply)
+ {
+ AuthReply (iceConn, replyDataLen, replyData);
+
+ replyWait->sequence_of_request = iceConn->send_sequence;
+ replyWait->minor_opcode_of_request = ICE_AuthReply;
+
+ if (iceConn->connect_to_you)
+ {
+ iceConn->connect_to_you->my_auth_state = authState;
+ iceConn->connect_to_you->my_auth_index = message->authIndex;
+ }
+ else if (iceConn->protosetup_to_you)
+ {
+ iceConn->protosetup_to_you->my_auth_state = authState;
+ iceConn->protosetup_to_you->my_auth_index = realAuthIndex;
+ }
+ }
+ else if (status == IcePoAuthRejected || status == IcePoAuthFailed)
+ {
+ char *prefix, *returnErrorString;
+
+ if (status == IcePoAuthRejected)
+ {
+ _IceErrorAuthenticationRejected (iceConn,
+ ICE_AuthRequired, errorString);
+
+ prefix = "Authentication Rejected, reason : ";
+ }
+ else
+ {
+ _IceErrorAuthenticationFailed (iceConn,
+ ICE_AuthRequired, errorString);
+
+ prefix = "Authentication Failed, reason : ";
+ }
+
+ returnErrorString = (char *) malloc (strlen (prefix) +
+ strlen (errorString) + 1);
+ sprintf (returnErrorString, "%s%s", prefix, errorString);
+ free (errorString);
+
+ if (iceConn->connect_to_you)
+ {
+ _IceConnectionError *errorReply =
+ &(((_IceReply *) (replyWait->reply))->connection_error);
+
+ errorReply->type = ICE_CONNECTION_ERROR;
+ errorReply->error_message = returnErrorString;
+ }
+ else
+ {
+ _IceProtocolError *errorReply =
+ &(((_IceReply *) (replyWait->reply))->protocol_error);
+
+ errorReply->type = ICE_PROTOCOL_ERROR;
+ errorReply->error_message = returnErrorString;
+ }
+ }
+
+ if (replyData && replyDataLen > 0)
+ free ((char *) replyData);
+
+ IceDisposeCompleteMessage (iceConn, authData);
+
+ return (status != IcePoAuthHaveReply);
+}
+
+
+
+static int
+ProcessAuthReply (iceConn, length, swap)
+
+IceConn iceConn;
+unsigned long length;
+Bool swap;
+
+{
+ iceAuthReplyMsg *message;
+ int replyDataLen;
+ IcePointer replyData;
+ int authDataLen;
+ IcePointer authData = NULL;
+ char *errorString = NULL;
+
+ CHECK_AT_LEAST_SIZE (iceConn, ICE_AuthReply,
+ length, SIZEOF (iceAuthReplyMsg),
+ iceConn->connect_to_me ? IceFatalToConnection : IceFatalToProtocol);
+
+ IceReadCompleteMessage (iceConn, SIZEOF (iceAuthReplyMsg),
+ iceAuthReplyMsg, message, replyData);
+
+ if (!IceValidIO (iceConn))
+ {
+ IceDisposeCompleteMessage (iceConn, replyData);
+ return (0);
+ }
+
+ if (swap)
+ {
+ message->authDataLength = lswaps (message->authDataLength);
+ }
+
+ CHECK_COMPLETE_SIZE (iceConn, ICE_AuthReply, length,
+ message->authDataLength + SIZEOF (iceAuthReplyMsg), replyData,
+ iceConn->connect_to_me ? IceFatalToConnection : IceFatalToProtocol);
+
+ replyDataLen = message->authDataLength;
+
+ if (iceConn->connect_to_me)
+ {
+ IcePaAuthProc authProc = _IcePaAuthProcs[(int)
+ (iceConn->connect_to_me->my_auth_index)];
+ IcePaAuthStatus status =
+ (*authProc) (iceConn, &iceConn->connect_to_me->my_auth_state, swap,
+ replyDataLen, replyData, &authDataLen, &authData, &errorString);
+
+ if (status == IcePaAuthContinue)
+ {
+ AuthNextPhase (iceConn, authDataLen, authData);
+ }
+ else if (status == IcePaAuthRejected || status == IcePaAuthFailed)
+ {
+ /*
+ * Before we reject, invoke host-based authentication callback
+ * and give it a chance to accept the connection (only if the
+ * other client doesn't require authentication).
+ */
+
+ if (!iceConn->connect_to_me->must_authenticate &&
+ iceConn->listen_obj->host_based_auth_proc)
+ {
+ char *hostname = _IceGetPeerName (iceConn);
+
+ if ((*iceConn->listen_obj->host_based_auth_proc) (hostname))
+ {
+ status = IcePaAuthAccepted;
+ }
+
+ if (hostname)
+ free (hostname);
+ }
+
+ if (status != IcePaAuthAccepted)
+ {
+ free (iceConn->connect_to_me->his_vendor);
+ free (iceConn->connect_to_me->his_release);
+ free ((char *) iceConn->connect_to_me);
+ iceConn->connect_to_me = NULL;
+
+ iceConn->connection_status = IceConnectRejected;
+
+ if (status == IcePaAuthRejected)
+ {
+ _IceErrorAuthenticationRejected (iceConn,
+ ICE_AuthReply, errorString);
+ }
+ else
+ {
+ _IceErrorAuthenticationFailed (iceConn,
+ ICE_AuthReply, errorString);
+ }
+ }
+ }
+
+ if (status == IcePaAuthAccepted)
+ {
+ AcceptConnection (iceConn,
+ iceConn->connect_to_me->his_version_index);
+
+ iceConn->vendor = iceConn->connect_to_me->his_vendor;
+ iceConn->release = iceConn->connect_to_me->his_release;
+ iceConn->my_ice_version_index =
+ iceConn->connect_to_me->my_version_index;
+
+ free ((char *) iceConn->connect_to_me);
+ iceConn->connect_to_me = NULL;
+ }
+ }
+ else if (iceConn->protosetup_to_me)
+ {
+ _IcePaProtocol *myProtocol = _IceProtocols[iceConn->protosetup_to_me->
+ my_opcode - 1].accept_client;
+ IcePaAuthProc authProc = myProtocol->auth_procs[(int)
+ (iceConn->protosetup_to_me->my_auth_index)];
+ IcePaAuthStatus status =
+ (*authProc) (iceConn, &iceConn->protosetup_to_me->my_auth_state,
+ swap, replyDataLen, replyData,
+ &authDataLen, &authData, &errorString);
+ int free_setup_info = 1;
+
+ if (status == IcePaAuthContinue)
+ {
+ AuthNextPhase (iceConn, authDataLen, authData);
+ free_setup_info = 0;
+ }
+ else if (status == IcePaAuthRejected || status == IcePaAuthFailed)
+ {
+ /*
+ * Before we reject, invoke host-based authentication callback
+ * and give it a chance to accept the Protocol Setup (only if the
+ * other client doesn't require authentication).
+ */
+
+ if (!iceConn->protosetup_to_me->must_authenticate &&
+ myProtocol->host_based_auth_proc)
+ {
+ char *hostname = _IceGetPeerName (iceConn);
+
+ if ((*myProtocol->host_based_auth_proc) (hostname))
+ {
+ status = IcePaAuthAccepted;
+ }
+
+ if (hostname)
+ free (hostname);
+ }
+
+ if (status == IcePaAuthRejected)
+ {
+ _IceErrorAuthenticationRejected (iceConn,
+ ICE_AuthReply, errorString);
+ }
+ else
+ {
+ _IceErrorAuthenticationFailed (iceConn,
+ ICE_AuthReply, errorString);
+ }
+ }
+
+ if (status == IcePaAuthAccepted)
+ {
+ IcePaProcessMsgProc processMsgProc;
+ IceProtocolSetupProc protocolSetupProc;
+ IceProtocolActivateProc protocolActivateProc;
+ _IceProcessMsgInfo *process_msg_info;
+ IcePointer clientData = NULL;
+ char *failureReason = NULL;
+ Status status = 1;
+
+ protocolSetupProc = myProtocol->protocol_setup_proc;
+ protocolActivateProc = myProtocol->protocol_activate_proc;
+
+ if (protocolSetupProc)
+ {
+ /*
+ * Notify the client of the Protocol Setup.
+ */
+
+ status = (*protocolSetupProc) (iceConn,
+ myProtocol->version_recs[iceConn->protosetup_to_me->
+ my_version_index].major_version,
+ myProtocol->version_recs[iceConn->protosetup_to_me->
+ my_version_index].minor_version,
+ iceConn->protosetup_to_me->his_vendor,
+ iceConn->protosetup_to_me->his_release,
+ &clientData, &failureReason);
+
+ /*
+ * Set vendor and release pointers to NULL, so it won't
+ * get freed below. The ProtocolSetupProc should
+ * free it.
+ */
+
+ iceConn->protosetup_to_me->his_vendor = NULL;
+ iceConn->protosetup_to_me->his_release = NULL;
+ }
+
+ if (status != 0)
+ {
+ /*
+ * Send the Protocol Reply
+ */
+
+ AcceptProtocol (iceConn,
+ iceConn->protosetup_to_me->his_opcode,
+ iceConn->protosetup_to_me->my_opcode,
+ iceConn->protosetup_to_me->his_version_index,
+ myProtocol->vendor, myProtocol->release);
+
+
+ /*
+ * Set info for this protocol.
+ */
+
+ processMsgProc = myProtocol->version_recs[
+ iceConn->protosetup_to_me->
+ my_version_index].process_msg_proc;
+
+ process_msg_info = &iceConn->process_msg_info[
+ iceConn->protosetup_to_me->
+ his_opcode -iceConn->his_min_opcode];
+
+ process_msg_info->client_data = clientData;
+ process_msg_info->accept_flag = 1;
+ process_msg_info->process_msg_proc.
+ accept_client = processMsgProc;
+
+
+ /*
+ * Increase the reference count for the number
+ * of active protocols.
+ */
+
+ iceConn->proto_ref_count++;
+
+
+ /*
+ * Notify the client that the protocol is active. The reason
+ * we have this 2nd callback invoked is because the client
+ * may wish to immediately generate a message for this
+ * protocol, but it must wait until we send the Protocol Reply.
+ */
+
+ if (protocolActivateProc)
+ {
+ (*protocolActivateProc) (iceConn,
+ process_msg_info->client_data);
+ }
+ }
+ else
+ {
+ /*
+ * An error was encountered.
+ */
+
+ _IceErrorSetupFailed (iceConn, ICE_ProtocolSetup,
+ failureReason);
+
+ if (failureReason)
+ free (failureReason);
+ }
+ }
+
+
+ if (free_setup_info)
+ {
+ if (iceConn->protosetup_to_me->his_vendor)
+ free (iceConn->protosetup_to_me->his_vendor);
+ if (iceConn->protosetup_to_me->his_release)
+ free (iceConn->protosetup_to_me->his_release);
+ free ((char *) iceConn->protosetup_to_me);
+ iceConn->protosetup_to_me = NULL;
+ }
+ }
+ else
+ {
+ /*
+ * Unexpected message
+ */
+
+ _IceErrorBadState (iceConn, 0, ICE_AuthReply, IceCanContinue);
+ }
+
+ if (authData && authDataLen > 0)
+ free ((char *) authData);
+
+ if (errorString)
+ free (errorString);
+
+ IceDisposeCompleteMessage (iceConn, replyData);
+ return (0);
+}
+
+
+
+static Bool
+ProcessAuthNextPhase (iceConn, length, swap, replyWait)
+
+IceConn iceConn;
+unsigned long length;
+Bool swap;
+IceReplyWaitInfo *replyWait;
+
+{
+ iceAuthNextPhaseMsg *message;
+ int authDataLen;
+ IcePointer authData;
+ int replyDataLen;
+ IcePointer replyData = NULL;
+ char *errorString = NULL;
+ IcePoAuthProc authProc;
+ IcePoAuthStatus status;
+ IcePointer *authState;
+
+ CHECK_AT_LEAST_SIZE (iceConn, ICE_AuthNextPhase,
+ length, SIZEOF (iceAuthNextPhaseMsg),
+ iceConn->connect_to_you ? IceFatalToConnection : IceFatalToProtocol);
+
+ IceReadCompleteMessage (iceConn, SIZEOF (iceAuthNextPhaseMsg),
+ iceAuthNextPhaseMsg, message, authData);
+
+ if (!IceValidIO (iceConn))
+ {
+ IceDisposeCompleteMessage (iceConn, authData);
+ return (0);
+ }
+
+ if (swap)
+ {
+ message->authDataLength = lswaps (message->authDataLength);
+ }
+
+ CHECK_COMPLETE_SIZE (iceConn, ICE_AuthNextPhase, length,
+ message->authDataLength + SIZEOF (iceAuthNextPhaseMsg), authData,
+ iceConn->connect_to_you ? IceFatalToConnection : IceFatalToProtocol);
+
+ if (iceConn->connect_to_you)
+ {
+ authProc = _IcePoAuthProcs[(int)
+ (iceConn->connect_to_you->my_auth_index)];
+
+ authState = &iceConn->connect_to_you->my_auth_state;
+ }
+ else if (iceConn->protosetup_to_you)
+ {
+ _IcePoProtocol *myProtocol =
+ _IceProtocols[iceConn->protosetup_to_you->my_opcode - 1].orig_client;
+
+ authProc = myProtocol->auth_procs[(int)
+ (iceConn->protosetup_to_you->my_auth_index)];
+
+ authState = &iceConn->protosetup_to_you->my_auth_state;
+ }
+ else
+ {
+ /*
+ * Unexpected message
+ */
+
+ _IceErrorBadState (iceConn, 0, ICE_AuthNextPhase, IceCanContinue);
+
+ IceDisposeCompleteMessage (iceConn, authData);
+ return (0);
+ }
+
+ authDataLen = message->authDataLength;
+
+ status = (*authProc) (iceConn, authState, False /* don't clean up */,
+ swap, authDataLen, authData, &replyDataLen, &replyData, &errorString);
+
+ if (status == IcePoAuthHaveReply)
+ {
+ AuthReply (iceConn, replyDataLen, replyData);
+
+ replyWait->sequence_of_request = iceConn->send_sequence;
+ }
+ else if (status == IcePoAuthRejected || status == IcePoAuthFailed)
+ {
+ char *prefix = NULL, *returnErrorString;
+
+ if (status == IcePoAuthRejected)
+ {
+ _IceErrorAuthenticationRejected (iceConn,
+ ICE_AuthNextPhase, errorString);
+
+ prefix = "Authentication Rejected, reason : ";
+ }
+ else if (status == IcePoAuthFailed)
+ {
+ _IceErrorAuthenticationFailed (iceConn,
+ ICE_AuthNextPhase, errorString);
+
+ prefix = "Authentication Failed, reason : ";
+ }
+
+ returnErrorString = (char *) malloc (strlen (prefix) +
+ strlen (errorString) + 1);
+ sprintf (returnErrorString, "%s%s", prefix, errorString);
+ free (errorString);
+
+ if (iceConn->connect_to_you)
+ {
+ _IceConnectionError *errorReply =
+ &(((_IceReply *) (replyWait->reply))->connection_error);
+
+ errorReply->type = ICE_CONNECTION_ERROR;
+ errorReply->error_message = returnErrorString;
+ }
+ else
+ {
+ _IceProtocolError *errorReply =
+ &(((_IceReply *) (replyWait->reply))->protocol_error);
+
+ errorReply->type = ICE_PROTOCOL_ERROR;
+ errorReply->error_message = returnErrorString;
+ }
+ }
+
+ if (replyData && replyDataLen > 0)
+ free ((char *) replyData);
+
+ IceDisposeCompleteMessage (iceConn, authData);
+
+ return (status != IcePoAuthHaveReply);
+}
+
+
+
+static Bool
+ProcessConnectionReply (iceConn, length, swap, replyWait)
+
+IceConn iceConn;
+unsigned long length;
+Bool swap;
+IceReplyWaitInfo *replyWait;
+
+{
+ iceConnectionReplyMsg *message;
+ char *pData, *pStart, *pEnd;
+ Bool replyReady;
+
+#if 0 /* No-op */
+ CHECK_AT_LEAST_SIZE (iceConn, ICE_ConnectionReply,
+ length, SIZEOF (iceConnectionReplyMsg), IceFatalToConnection);
+#endif
+
+ IceReadCompleteMessage (iceConn, SIZEOF (iceConnectionReplyMsg),
+ iceConnectionReplyMsg, message, pStart);
+
+ if (!IceValidIO (iceConn))
+ {
+ IceDisposeCompleteMessage (iceConn, pStart);
+ return (0);
+ }
+
+ pData = pStart;
+ pEnd = pStart + (length << 3);
+
+ SKIP_STRING (pData, swap, pEnd,
+ BAIL_STRING (iceConn, ICE_ConnectionReply,
+ pStart)); /* vendor */
+ SKIP_STRING (pData, swap, pEnd,
+ BAIL_STRING (iceConn, ICE_ConnectionReply,
+ pStart)); /* release */
+
+ CHECK_COMPLETE_SIZE (iceConn, ICE_ConnectionReply,
+ length, pData - pStart + SIZEOF (iceConnectionReplyMsg),
+ pStart, IceFatalToConnection);
+
+ pData = pStart;
+
+ if (iceConn->connect_to_you)
+ {
+ if (iceConn->connect_to_you->auth_active)
+ {
+ /*
+ * Tell the authentication procedure to clean up.
+ */
+
+ IcePoAuthProc authProc = _IcePoAuthProcs[(int)
+ (iceConn->connect_to_you->my_auth_index)];
+
+ (*authProc) (iceConn, &iceConn->connect_to_you->my_auth_state,
+ True /* clean up */, False /* swap */,
+ 0, NULL, NULL, NULL, NULL);
+ }
+
+ if ((int) message->versionIndex >= _IceVersionCount)
+ {
+ _IceConnectionError *errorReply =
+ &(((_IceReply *) (replyWait->reply))->connection_error);
+ char errIndex = message->versionIndex;
+
+ _IceErrorBadValue (iceConn, 0,
+ ICE_ConnectionReply, 2, 1, &errIndex);
+
+ errorReply->type = ICE_CONNECTION_ERROR;
+ errorReply->error_message =
+ "Received bad version index in Connection Reply";
+ }
+ else
+ {
+ _IceReply *reply = (_IceReply *) (replyWait->reply);
+
+ reply->type = ICE_CONNECTION_REPLY;
+ reply->connection_reply.version_index = message->versionIndex;
+
+ EXTRACT_STRING (pData, swap, reply->connection_reply.vendor);
+ EXTRACT_STRING (pData, swap, reply->connection_reply.release);
+ }
+
+ replyReady = True;
+ }
+ else
+ {
+ /*
+ * Unexpected message
+ */
+
+ _IceErrorBadState (iceConn, 0, ICE_ConnectionReply, IceCanContinue);
+
+ replyReady = False;
+ }
+
+ IceDisposeCompleteMessage (iceConn, pStart);
+
+ return (replyReady);
+}
+
+
+
+static int
+ProcessProtocolSetup (iceConn, length, swap)
+
+IceConn iceConn;
+unsigned long length;
+Bool swap;
+
+{
+ iceProtocolSetupMsg *message;
+ _IcePaProtocol *myProtocol;
+ int myVersionCount, hisVersionCount;
+ int myVersionIndex, hisVersionIndex;
+ int hisMajorVersion, hisMinorVersion;
+ int myAuthCount, hisAuthCount;
+ int myOpcode, hisOpcode;
+ int found, i, j;
+ char *myAuthName, **hisAuthNames = NULL;
+ char *protocolName;
+ char *pData, *pStart, *pEnd;
+ char *vendor = NULL;
+ char *release = NULL;
+ int accept_setup_now = 0;
+ int myAuthIndex = 0;
+ int hisAuthIndex = 0;
+ char mustAuthenticate;
+ int authUsableCount;
+ int authUsableFlags[MAX_ICE_AUTH_NAMES];
+ int authIndices[MAX_ICE_AUTH_NAMES];
+
+ CHECK_AT_LEAST_SIZE (iceConn, ICE_ProtocolSetup,
+ length, SIZEOF (iceProtocolSetupMsg), IceFatalToProtocol);
+
+ if (iceConn->want_to_close)
+ {
+ /*
+ * If we sent a WantToClose message, but just got a ProtocolSetup,
+ * we must cancel our WantToClose. It is the responsiblity of the
+ * other client to send a WantToClose later on.
+ */
+
+ iceConn->want_to_close = 0;
+ }
+
+ IceReadCompleteMessage (iceConn, SIZEOF (iceProtocolSetupMsg),
+ iceProtocolSetupMsg, message, pStart);
+
+ if (!IceValidIO (iceConn))
+ {
+ IceDisposeCompleteMessage (iceConn, pStart);
+ return (0);
+ }
+
+ pData = pStart;
+ pEnd = pStart + (length << 3);
+
+ SKIP_STRING (pData, swap, pEnd,
+ BAIL_STRING(iceConn, ICE_ProtocolSetup,
+ pStart)); /* proto name */
+ SKIP_STRING (pData, swap, pEnd,
+ BAIL_STRING(iceConn, ICE_ProtocolSetup,
+ pStart)); /* vendor */
+ SKIP_STRING (pData, swap, pEnd,
+ BAIL_STRING(iceConn, ICE_ProtocolSetup,
+ pStart)); /* release */
+ SKIP_LISTOF_STRING (pData, swap, (int) message->authCount, pEnd,
+ BAIL_STRING(iceConn, ICE_ProtocolSetup,
+ pStart)); /* auth names */
+ pData += (message->versionCount * 4); /* versions */
+
+ CHECK_COMPLETE_SIZE (iceConn, ICE_ProtocolSetup,
+ length, pData - pStart + SIZEOF (iceProtocolSetupMsg),
+ pStart, IceFatalToProtocol);
+
+ mustAuthenticate = message->mustAuthenticate;
+
+ if (mustAuthenticate != 0 && mustAuthenticate != 1)
+ {
+ _IceErrorBadValue (iceConn, 0,
+ ICE_ProtocolSetup, 4, 1, &mustAuthenticate);
+ IceDisposeCompleteMessage (iceConn, pStart);
+ return (0);
+ }
+
+ pData = pStart;
+
+ if (iceConn->process_msg_info &&
+ (int) message->protocolOpcode >= iceConn->his_min_opcode &&
+ (int) message->protocolOpcode <= iceConn->his_max_opcode &&
+ iceConn->process_msg_info[
+ message->protocolOpcode - iceConn->his_min_opcode].in_use)
+ {
+ _IceErrorMajorOpcodeDuplicate (iceConn, message->protocolOpcode);
+ IceDisposeCompleteMessage (iceConn, pStart);
+ return (0);
+ }
+
+ EXTRACT_STRING (pData, swap, protocolName);
+
+ if (iceConn->process_msg_info)
+ {
+ for (i = 0;
+ i <= (iceConn->his_max_opcode - iceConn->his_min_opcode); i++)
+ {
+ if (iceConn->process_msg_info[i].in_use && strcmp (protocolName,
+ iceConn->process_msg_info[i].protocol->protocol_name) == 0)
+ {
+ _IceErrorProtocolDuplicate (iceConn, protocolName);
+ free (protocolName);
+ IceDisposeCompleteMessage (iceConn, pStart);
+ return (0);
+ }
+ }
+ }
+
+ for (i = 0; i < _IceLastMajorOpcode; i++)
+ if (strcmp (protocolName, _IceProtocols[i].protocol_name) == 0)
+ break;
+
+ if (i < _IceLastMajorOpcode &&
+ (myProtocol = _IceProtocols[i].accept_client) != NULL)
+ {
+ hisOpcode = message->protocolOpcode;
+ myOpcode = i + 1;
+ free (protocolName);
+ }
+ else
+ {
+ _IceErrorUnknownProtocol (iceConn, protocolName);
+ free (protocolName);
+ IceDisposeCompleteMessage (iceConn, pStart);
+ return (0);
+ }
+
+ EXTRACT_STRING (pData, swap, vendor);
+ EXTRACT_STRING (pData, swap, release);
+
+ if ((hisAuthCount = message->authCount) > 0)
+ {
+ hisAuthNames = (char **) malloc (hisAuthCount * sizeof (char *));
+ EXTRACT_LISTOF_STRING (pData, swap, hisAuthCount, hisAuthNames);
+ }
+
+ hisVersionCount = message->versionCount;
+ myVersionCount = myProtocol->version_count;
+
+ hisVersionIndex = myVersionIndex = found = 0;
+
+ for (i = 0; i < hisVersionCount && !found; i++)
+ {
+ EXTRACT_CARD16 (pData, swap, hisMajorVersion);
+ EXTRACT_CARD16 (pData, swap, hisMinorVersion);
+
+ for (j = 0; j < myVersionCount && !found; j++)
+ {
+ if (myProtocol->version_recs[j].major_version == hisMajorVersion &&
+ myProtocol->version_recs[j].minor_version == hisMinorVersion)
+ {
+ hisVersionIndex = i;
+ myVersionIndex = j;
+ found = 1;
+ }
+ }
+ }
+
+ if (!found)
+ {
+ _IceErrorNoVersion (iceConn, ICE_ProtocolSetup);
+
+ free (vendor);
+ free (release);
+
+ if (hisAuthCount > 0)
+ {
+ for (i = 0; i < hisAuthCount; i++)
+ free (hisAuthNames[i]);
+
+ free ((char *) hisAuthNames);
+ }
+
+ IceDisposeCompleteMessage (iceConn, pStart);
+ return (0);
+ }
+
+ myAuthCount = myProtocol->auth_count;
+
+ _IceGetPaValidAuthIndices (
+ _IceProtocols[myOpcode - 1].protocol_name,
+ iceConn->connection_string, myAuthCount, myProtocol->auth_names,
+ &authUsableCount, authIndices);
+
+ for (i = 0; i < myAuthCount; i++)
+ {
+ authUsableFlags[i] = 0;
+ for (j = 0; j < authUsableCount && !authUsableFlags[i]; j++)
+ authUsableFlags[i] = (authIndices[j] == i);
+ }
+
+ for (i = found = 0; i < myAuthCount && !found; i++)
+ {
+ if (authUsableFlags[i])
+ {
+ myAuthName = myProtocol->auth_names[i];
+
+ for (j = 0; j < hisAuthCount && !found; j++)
+ if (strcmp (myAuthName, hisAuthNames[j]) == 0)
+ {
+ myAuthIndex = i;
+ hisAuthIndex = j;
+ found = 1;
+ }
+ }
+ }
+
+ if (!found)
+ {
+ /*
+ * None of the authentication methods specified by the
+ * other client is supported. If the other client requires
+ * authentication, we must reject the Protocol Setup now.
+ * Otherwise, we can invoke the host-based authentication callback
+ * to see if we can accept this Protocol Setup.
+ */
+
+ if (mustAuthenticate || !myProtocol->host_based_auth_proc)
+ {
+ _IceErrorNoAuthentication (iceConn, ICE_ProtocolSetup);
+ }
+ else
+ {
+ char *hostname = _IceGetPeerName (iceConn);
+
+ if ((*myProtocol->host_based_auth_proc) (hostname))
+ {
+ accept_setup_now = 1;
+ }
+ else
+ {
+ _IceErrorAuthenticationRejected (iceConn,
+ ICE_ProtocolSetup, "None of the authentication protocols specified are supported and host-based authentication failed");
+ }
+
+ if (hostname)
+ free (hostname);
+ }
+ }
+ else
+ {
+ IcePaAuthStatus status;
+ int authDataLen;
+ IcePointer authData = NULL;
+ IcePointer authState;
+ char *errorString = NULL;
+ IcePaAuthProc authProc =
+ myProtocol->auth_procs[myAuthIndex];
+
+ authState = NULL;
+
+ status = (*authProc) (iceConn, &authState, swap, 0, NULL,
+ &authDataLen, &authData, &errorString);
+
+ if (status == IcePaAuthContinue)
+ {
+ _IceProtoSetupToMeInfo *setupInfo;
+
+ AuthRequired (iceConn, hisAuthIndex, authDataLen, authData);
+
+ iceConn->protosetup_to_me = setupInfo =
+ (_IceProtoSetupToMeInfo *) malloc (
+ sizeof (_IceProtoSetupToMeInfo));
+
+ setupInfo->his_opcode = hisOpcode;
+ setupInfo->my_opcode = myOpcode;
+ setupInfo->my_version_index = myVersionIndex;
+ setupInfo->his_version_index = hisVersionIndex;
+ setupInfo->his_vendor = vendor;
+ setupInfo->his_release = release;
+ vendor = release = NULL; /* so we don't free it */
+ setupInfo->my_auth_index = myAuthIndex;
+ setupInfo->my_auth_state = authState;
+ setupInfo->must_authenticate = mustAuthenticate;
+ }
+ else if (status == IcePaAuthAccepted)
+ {
+ accept_setup_now = 1;
+ }
+
+ if (authData && authDataLen > 0)
+ free ((char *) authData);
+
+ if (errorString)
+ free (errorString);
+ }
+
+ if (accept_setup_now)
+ {
+ IcePaProcessMsgProc processMsgProc;
+ IceProtocolSetupProc protocolSetupProc;
+ IceProtocolActivateProc protocolActivateProc;
+ _IceProcessMsgInfo *process_msg_info;
+ IcePointer clientData = NULL;
+ char *failureReason = NULL;
+ Status status = 1;
+
+ protocolSetupProc = myProtocol->protocol_setup_proc;
+ protocolActivateProc = myProtocol->protocol_activate_proc;
+
+ if (protocolSetupProc)
+ {
+ /*
+ * Notify the client of the Protocol Setup.
+ */
+
+ status = (*protocolSetupProc) (iceConn,
+ myProtocol->version_recs[myVersionIndex].major_version,
+ myProtocol->version_recs[myVersionIndex].minor_version,
+ vendor, release, &clientData, &failureReason);
+
+ vendor = release = NULL; /* so we don't free it */
+ }
+
+ if (status != 0)
+ {
+ /*
+ * Send the Protocol Reply
+ */
+
+ AcceptProtocol (iceConn, hisOpcode, myOpcode, hisVersionIndex,
+ myProtocol->vendor, myProtocol->release);
+
+
+ /*
+ * Set info for this protocol.
+ */
+
+ processMsgProc = myProtocol->version_recs[
+ myVersionIndex].process_msg_proc;
+
+ process_msg_info = &iceConn->process_msg_info[hisOpcode -
+ iceConn->his_min_opcode];
+
+ process_msg_info->client_data = clientData;
+ process_msg_info->accept_flag = 1;
+ process_msg_info->process_msg_proc.accept_client = processMsgProc;
+
+
+ /*
+ * Increase the reference count for the number of active protocols.
+ */
+
+ iceConn->proto_ref_count++;
+
+
+ /*
+ * Notify the client that the protocol is active. The reason
+ * we have this 2nd callback invoked is because the client
+ * may wish to immediately generate a message for this
+ * protocol, but it must wait until we send the Protocol Reply.
+ */
+
+ if (protocolActivateProc)
+ {
+ (*protocolActivateProc) (iceConn,
+ process_msg_info->client_data);
+ }
+ }
+ else
+ {
+ /*
+ * An error was encountered.
+ */
+
+ _IceErrorSetupFailed (iceConn, ICE_ProtocolSetup, failureReason);
+
+ if (failureReason)
+ free (failureReason);
+ }
+ }
+
+ if (vendor)
+ free (vendor);
+
+ if (release)
+ free (release);
+
+ if (hisAuthCount > 0)
+ {
+ for (i = 0; i < hisAuthCount; i++)
+ free (hisAuthNames[i]);
+
+ free ((char *) hisAuthNames);
+ }
+
+ IceDisposeCompleteMessage (iceConn, pStart);
+ return (0);
+}
+
+
+
+static Bool
+ProcessProtocolReply (iceConn, length, swap, replyWait)
+
+IceConn iceConn;
+unsigned long length;
+Bool swap;
+IceReplyWaitInfo *replyWait;
+
+{
+ iceProtocolReplyMsg *message;
+ char *pData, *pStart, *pEnd;
+ Bool replyReady;
+
+#if 0 /* No-op */
+ CHECK_AT_LEAST_SIZE (iceConn, ICE_ProtocolReply,
+ length, SIZEOF (iceProtocolReplyMsg), IceFatalToProtocol);
+#endif
+
+ IceReadCompleteMessage (iceConn, SIZEOF (iceProtocolReplyMsg),
+ iceProtocolReplyMsg, message, pStart);
+
+ if (!IceValidIO (iceConn))
+ {
+ IceDisposeCompleteMessage (iceConn, pStart);
+ return (0);
+ }
+
+ pData = pStart;
+ pEnd = pStart + (length << 3);
+
+ SKIP_STRING (pData, swap, pEnd,
+ BAIL_STRING(iceConn, ICE_ProtocolReply,
+ pStart)); /* vendor */
+ SKIP_STRING (pData, swap, pEnd,
+ BAIL_STRING(iceConn, ICE_ProtocolReply,
+ pStart)); /* release */
+
+ CHECK_COMPLETE_SIZE (iceConn, ICE_ProtocolReply,
+ length, pData - pStart + SIZEOF (iceProtocolReplyMsg),
+ pStart, IceFatalToProtocol);
+
+ pData = pStart;
+
+ if (iceConn->protosetup_to_you)
+ {
+ if (iceConn->protosetup_to_you->auth_active)
+ {
+ /*
+ * Tell the authentication procedure to clean up.
+ */
+
+ _IcePoProtocol *myProtocol = _IceProtocols[
+ iceConn->protosetup_to_you->my_opcode - 1].orig_client;
+
+ IcePoAuthProc authProc = myProtocol->auth_procs[(int)
+ (iceConn->protosetup_to_you->my_auth_index)];
+
+#ifdef SVR4
+
+/*
+ * authProc is never NULL, but the cc compiler on UNIX System V/386
+ * Release 4.2 Version 1 screws up an optimization. Unless there is
+ * some sort of reference to authProc before the function call, the
+ * function call will seg fault.
+ */
+ if (authProc)
+#endif
+ (*authProc) (iceConn,
+ &iceConn->protosetup_to_you->my_auth_state,
+ True /* clean up */, False /* swap */,
+ 0, NULL, NULL, NULL, NULL);
+ }
+
+ if ((int) message->versionIndex >= _IceVersionCount)
+ {
+ _IceProtocolError *errorReply =
+ &(((_IceReply *) (replyWait->reply))->protocol_error);
+ char errIndex = message->versionIndex;
+
+ _IceErrorBadValue (iceConn, 0,
+ ICE_ProtocolReply, 2, 1, &errIndex);
+
+ errorReply->type = ICE_PROTOCOL_ERROR;
+ errorReply->error_message =
+ "Received bad version index in Protocol Reply";
+ }
+ else
+ {
+ _IceProtocolReply *reply =
+ &(((_IceReply *) (replyWait->reply))->protocol_reply);
+
+ reply->type = ICE_PROTOCOL_REPLY;
+ reply->major_opcode = message->protocolOpcode;
+ reply->version_index = message->versionIndex;
+
+ EXTRACT_STRING (pData, swap, reply->vendor);
+ EXTRACT_STRING (pData, swap, reply->release);
+ }
+
+ replyReady = True;
+ }
+ else
+ {
+ _IceErrorBadState (iceConn, 0, ICE_ProtocolReply, IceCanContinue);
+
+ replyReady = False;
+ }
+
+ IceDisposeCompleteMessage (iceConn, pStart);
+
+ return (replyReady);
+}
+
+
+
+static int
+ProcessPing (iceConn, length)
+
+IceConn iceConn;
+unsigned long length;
+
+{
+ CHECK_SIZE_MATCH (iceConn, ICE_Ping,
+ length, SIZEOF (icePingMsg), IceFatalToConnection, 0);
+
+ PingReply (iceConn);
+
+ return (0);
+}
+
+
+
+static int
+ProcessPingReply (iceConn, length)
+
+IceConn iceConn;
+unsigned long length;
+
+{
+ CHECK_SIZE_MATCH (iceConn, ICE_PingReply,
+ length, SIZEOF (icePingReplyMsg), IceFatalToConnection, 0);
+
+ if (iceConn->ping_waits)
+ {
+ _IcePingWait *next = iceConn->ping_waits->next;
+
+ (*iceConn->ping_waits->ping_reply_proc) (iceConn,
+ iceConn->ping_waits->client_data);
+
+ free ((char *) iceConn->ping_waits);
+ iceConn->ping_waits = next;
+ }
+ else
+ {
+ _IceErrorBadState (iceConn, 0, ICE_PingReply, IceCanContinue);
+ }
+
+ return (0);
+}
+
+
+
+static int
+ProcessWantToClose (iceConn, length, connectionClosedRet)
+
+IceConn iceConn;
+unsigned long length;
+Bool *connectionClosedRet;
+
+{
+ *connectionClosedRet = False;
+
+ CHECK_SIZE_MATCH (iceConn, ICE_WantToClose,
+ length, SIZEOF (iceWantToCloseMsg), IceFatalToConnection, 0);
+
+ if (iceConn->want_to_close || iceConn->open_ref_count == 0)
+ {
+ /*
+ * We just received a WantToClose. Either we also sent a
+ * WantToClose, so we close the connection, or the iceConn
+ * is not being used, so we close the connection. This
+ * second case is possible if we sent a WantToClose because
+ * the iceConn->open_ref_count reached zero, but then we
+ * received a NoClose.
+ */
+
+ _IceConnectionClosed (iceConn); /* invoke watch procs */
+ _IceFreeConnection (iceConn);
+ *connectionClosedRet = True;
+ }
+ else if (iceConn->proto_ref_count > 0)
+ {
+ /*
+ * We haven't shut down all of our protocols yet. We send a NoClose,
+ * and it's up to us to generate a WantToClose later on.
+ */
+
+ IceSimpleMessage (iceConn, 0, ICE_NoClose);
+ IceFlush (iceConn);
+ }
+ else
+ {
+ /*
+ * The reference count on this iceConn is zero. This means that
+ * there are no active protocols, but the client didn't explicitly
+ * close the connection yet. If we didn't just send a Protocol Setup,
+ * we send a NoClose, and it's up to us to generate a WantToClose
+ * later on.
+ */
+
+ if (!iceConn->protosetup_to_you)
+ {
+ IceSimpleMessage (iceConn, 0, ICE_NoClose);
+ IceFlush (iceConn);
+ }
+ }
+
+ return (0);
+}
+
+
+
+static int
+ProcessNoClose (iceConn, length)
+
+IceConn iceConn;
+unsigned long length;
+
+{
+ CHECK_SIZE_MATCH (iceConn, ICE_NoClose,
+ length, SIZEOF (iceNoCloseMsg), IceFatalToConnection, 0);
+
+ if (iceConn->want_to_close)
+ {
+ /*
+ * The other side can't close now. We cancel our WantToClose,
+ * and we can expect a WantToClose from the other side.
+ */
+
+ iceConn->want_to_close = 0;
+ }
+ else
+ {
+ _IceErrorBadState (iceConn, 0, ICE_NoClose, IceCanContinue);
+ }
+
+ return (0);
+}
+
+
+
+void
+_IceProcessCoreMessage (iceConn, opcode, length, swap,
+ replyWait, replyReadyRet, connectionClosedRet)
+
+IceConn iceConn;
+int opcode;
+unsigned long length;
+Bool swap;
+IceReplyWaitInfo *replyWait;
+Bool *replyReadyRet;
+Bool *connectionClosedRet;
+
+{
+ Bool replyReady = False;
+
+ *connectionClosedRet = False;
+
+ switch (opcode)
+ {
+ case ICE_Error:
+
+ replyReady = ProcessError (iceConn, length, swap, replyWait);
+ break;
+
+ case ICE_ConnectionSetup:
+
+ ProcessConnectionSetup (iceConn, length, swap);
+ break;
+
+ case ICE_AuthRequired:
+
+ replyReady = ProcessAuthRequired (iceConn, length, swap, replyWait);
+ break;
+
+ case ICE_AuthReply:
+
+ ProcessAuthReply (iceConn, length, swap);
+ break;
+
+ case ICE_AuthNextPhase:
+
+ replyReady = ProcessAuthNextPhase (iceConn, length, swap, replyWait);
+ break;
+
+ case ICE_ConnectionReply:
+
+ replyReady = ProcessConnectionReply (iceConn, length, swap, replyWait);
+ break;
+
+ case ICE_ProtocolSetup:
+
+ ProcessProtocolSetup (iceConn, length, swap);
+ break;
+
+ case ICE_ProtocolReply:
+
+ replyReady = ProcessProtocolReply (iceConn, length, swap, replyWait);
+ break;
+
+ case ICE_Ping:
+
+ ProcessPing (iceConn, length);
+ break;
+
+ case ICE_PingReply:
+
+ ProcessPingReply (iceConn, length);
+ break;
+
+ case ICE_WantToClose:
+
+ ProcessWantToClose (iceConn, length, connectionClosedRet);
+ break;
+
+ case ICE_NoClose:
+
+ ProcessNoClose (iceConn, length);
+ break;
+
+ default:
+
+ _IceErrorBadMinor (iceConn, 0, opcode, IceCanContinue);
+ _IceReadSkip (iceConn, length << 3);
+ break;
+ }
+
+ if (replyWait)
+ *replyReadyRet = replyReady;
+}
+
diff --git a/nx-X11/lib/ICE/protosetup.c b/nx-X11/lib/ICE/protosetup.c
new file mode 100644
index 000000000..7a21e2e1d
--- /dev/null
+++ b/nx-X11/lib/ICE/protosetup.c
@@ -0,0 +1,293 @@
+/* $Xorg: protosetup.c,v 1.4 2001/02/09 02:03:26 xorgcvs Exp $ */
+/******************************************************************************
+
+
+Copyright 1993, 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.
+
+Author: Ralph Mor, X Consortium
+******************************************************************************/
+/* $XFree86: xc/lib/ICE/protosetup.c,v 1.2 2001/10/28 03:32:28 tsi Exp $ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+#include <X11/ICE/ICElib.h>
+#include "ICElibint.h"
+
+
+IceProtocolSetupStatus
+IceProtocolSetup (iceConn, myOpcode, clientData, mustAuthenticate,
+ majorVersionRet, minorVersionRet, vendorRet, releaseRet,
+ errorLength, errorStringRet)
+
+IceConn iceConn;
+int myOpcode;
+IcePointer clientData;
+Bool mustAuthenticate;
+int *majorVersionRet;
+int *minorVersionRet;
+char **vendorRet;
+char **releaseRet;
+int errorLength;
+char *errorStringRet;
+
+{
+ iceProtocolSetupMsg *pMsg;
+ char *pData;
+ _IceProtocol *myProtocol;
+ int extra;
+ Bool gotReply, ioErrorOccured;
+ int accepted, i;
+ int hisOpcode;
+ unsigned long setup_sequence;
+ IceReplyWaitInfo replyWait;
+ _IceReply reply;
+ IcePoVersionRec *versionRec = NULL;
+ int authCount;
+ int *authIndices;
+
+ if (errorStringRet && errorLength > 0)
+ *errorStringRet = '\0';
+
+ *majorVersionRet = 0;
+ *minorVersionRet = 0;
+ *vendorRet = NULL;
+ *releaseRet = NULL;
+
+ if (myOpcode < 1 || myOpcode > _IceLastMajorOpcode)
+ {
+ strncpy (errorStringRet, "myOpcode out of range", errorLength);
+ return (IceProtocolSetupFailure);
+ }
+
+ myProtocol = &_IceProtocols[myOpcode - 1];
+
+ if (myProtocol->orig_client == NULL)
+ {
+ strncpy (errorStringRet,
+ "IceRegisterForProtocolSetup was not called", errorLength);
+ return (IceProtocolSetupFailure);
+ }
+
+
+ /*
+ * Make sure this protocol hasn't been activated already.
+ */
+
+ if (iceConn->process_msg_info)
+ {
+ for (i = iceConn->his_min_opcode; i <= iceConn->his_max_opcode; i++)
+ {
+ if (iceConn->process_msg_info[
+ i - iceConn->his_min_opcode].in_use &&
+ iceConn->process_msg_info[
+ i - iceConn->his_min_opcode ].my_opcode == myOpcode)
+ break;
+ }
+
+ if (i <= iceConn->his_max_opcode)
+ {
+ return (IceProtocolAlreadyActive);
+ }
+ }
+
+ /*
+ * Generate the message.
+ */
+
+ if (myProtocol->orig_client->auth_count > 0)
+ {
+ authIndices = (int *) malloc (
+ myProtocol->orig_client->auth_count * sizeof (int));
+
+ _IceGetPoValidAuthIndices (myProtocol->protocol_name,
+ iceConn->connection_string,
+ myProtocol->orig_client->auth_count,
+ myProtocol->orig_client->auth_names,
+ &authCount, authIndices);
+
+ }
+ else
+ {
+ authCount = 0;
+ authIndices = NULL;
+ }
+
+ extra = STRING_BYTES (myProtocol->protocol_name) +
+ STRING_BYTES (myProtocol->orig_client->vendor) +
+ STRING_BYTES (myProtocol->orig_client->release);
+
+ for (i = 0; i < authCount; i++)
+ {
+ extra += STRING_BYTES (myProtocol->orig_client->auth_names[
+ authIndices[i]]);
+ }
+
+ extra += (myProtocol->orig_client->version_count * 4);
+
+ IceGetHeaderExtra (iceConn, 0, ICE_ProtocolSetup,
+ SIZEOF (iceProtocolSetupMsg), WORD64COUNT (extra),
+ iceProtocolSetupMsg, pMsg, pData);
+
+ setup_sequence = iceConn->send_sequence;
+
+ pMsg->protocolOpcode = myOpcode;
+ pMsg->versionCount = myProtocol->orig_client->version_count;
+ pMsg->authCount = authCount;
+ pMsg->mustAuthenticate = mustAuthenticate;
+
+ STORE_STRING (pData, myProtocol->protocol_name);
+ STORE_STRING (pData, myProtocol->orig_client->vendor);
+ STORE_STRING (pData, myProtocol->orig_client->release);
+
+ for (i = 0; i < authCount; i++)
+ {
+ STORE_STRING (pData, myProtocol->orig_client->auth_names[
+ authIndices[i]]);
+ }
+
+ for (i = 0; i < myProtocol->orig_client->version_count; i++)
+ {
+ STORE_CARD16 (pData,
+ myProtocol->orig_client->version_recs[i].major_version);
+ STORE_CARD16 (pData,
+ myProtocol->orig_client->version_recs[i].minor_version);
+ }
+
+ IceFlush (iceConn);
+
+
+ /*
+ * Process messages until we get a Protocol Reply.
+ */
+
+ replyWait.sequence_of_request = setup_sequence;
+ replyWait.major_opcode_of_request = 0;
+ replyWait.minor_opcode_of_request = ICE_ProtocolSetup;
+ replyWait.reply = (IcePointer) &reply;
+
+ iceConn->protosetup_to_you = (_IceProtoSetupToYouInfo *) malloc (
+ sizeof (_IceProtoSetupToYouInfo));
+ iceConn->protosetup_to_you->my_opcode = myOpcode;
+ iceConn->protosetup_to_you->my_auth_count = authCount;
+ iceConn->protosetup_to_you->auth_active = 0;
+ iceConn->protosetup_to_you->my_auth_indices = authIndices;
+
+ gotReply = False;
+ ioErrorOccured = False;
+ accepted = 0;
+
+ while (!gotReply && !ioErrorOccured)
+ {
+ ioErrorOccured = (IceProcessMessages (
+ iceConn, &replyWait, &gotReply) == IceProcessMessagesIOError);
+
+ if (ioErrorOccured)
+ {
+ strncpy (errorStringRet,
+ "IO error occured doing Protocol Setup on connection",
+ errorLength);
+ return (IceProtocolSetupIOError);
+ }
+ else if (gotReply)
+ {
+ if (reply.type == ICE_PROTOCOL_REPLY)
+ {
+ if (reply.protocol_reply.version_index >=
+ myProtocol->orig_client->version_count)
+ {
+ strncpy (errorStringRet,
+ "Got a bad version index in the Protocol Reply",
+ errorLength);
+
+ free (reply.protocol_reply.vendor);
+ free (reply.protocol_reply.release);
+ }
+ else
+ {
+ versionRec = &(myProtocol->orig_client->version_recs[
+ reply.protocol_reply.version_index]);
+
+ accepted = 1;
+ }
+ }
+ else /* reply.type == ICE_PROTOCOL_ERROR */
+ {
+ /* Protocol Setup failed */
+
+ strncpy (errorStringRet, reply.protocol_error.error_message,
+ errorLength);
+
+ free (reply.protocol_error.error_message);
+ }
+
+ if (iceConn->protosetup_to_you->my_auth_indices)
+ free ((char *) iceConn->protosetup_to_you->my_auth_indices);
+ free ((char *) iceConn->protosetup_to_you);
+ iceConn->protosetup_to_you = NULL;
+ }
+ }
+
+ if (accepted)
+ {
+ _IceProcessMsgInfo *process_msg_info;
+
+ *majorVersionRet = versionRec->major_version;
+ *minorVersionRet = versionRec->minor_version;
+ *vendorRet = reply.protocol_reply.vendor;
+ *releaseRet = reply.protocol_reply.release;
+
+
+ /*
+ * Increase the reference count for the number of active protocols.
+ */
+
+ iceConn->proto_ref_count++;
+
+
+ /*
+ * We may be using a different major opcode for this protocol
+ * than the other client. Whenever we get a message, we must
+ * map to our own major opcode.
+ */
+
+ hisOpcode = reply.protocol_reply.major_opcode;
+
+ _IceAddOpcodeMapping (iceConn, hisOpcode, myOpcode);
+
+ process_msg_info = &iceConn->process_msg_info[hisOpcode -
+ iceConn->his_min_opcode];
+
+ process_msg_info->client_data = clientData;
+ process_msg_info->accept_flag = 0;
+
+ process_msg_info->process_msg_proc.orig_client =
+ versionRec->process_msg_proc;
+
+ return (IceProtocolSetupSuccess);
+ }
+ else
+ {
+ return (IceProtocolSetupFailure);
+ }
+}
diff --git a/nx-X11/lib/ICE/register.c b/nx-X11/lib/ICE/register.c
new file mode 100644
index 000000000..20e60dfdf
--- /dev/null
+++ b/nx-X11/lib/ICE/register.c
@@ -0,0 +1,256 @@
+/* $Xorg: register.c,v 1.4 2001/02/09 02:03:26 xorgcvs Exp $ */
+/******************************************************************************
+
+
+Copyright 1993, 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.
+
+Author: Ralph Mor, X Consortium
+******************************************************************************/
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+#include <X11/ICE/ICElib.h>
+#include "ICElibint.h"
+
+int
+IceRegisterForProtocolSetup (protocolName, vendor, release,
+ versionCount, versionRecs, authCount, authNames, authProcs, IOErrorProc)
+
+char *protocolName;
+char *vendor;
+char *release;
+int versionCount;
+IcePoVersionRec *versionRecs;
+int authCount;
+char **authNames;
+IcePoAuthProc *authProcs;
+IceIOErrorProc IOErrorProc;
+
+{
+ _IcePoProtocol *p;
+ int opcodeRet, i;
+
+ for (i = 1; i <= _IceLastMajorOpcode; i++)
+ if (strcmp (protocolName, _IceProtocols[i - 1].protocol_name) == 0)
+ {
+ if (_IceProtocols[i - 1].orig_client != NULL)
+ {
+ /*
+ * We've already registered this protocol.
+ */
+
+ return (i);
+ }
+ else
+ {
+ break;
+ }
+ }
+
+ if (i <= _IceLastMajorOpcode)
+ {
+ p = _IceProtocols[i - 1].orig_client =
+ (_IcePoProtocol *) malloc (sizeof (_IcePoProtocol));
+ opcodeRet = i;
+ }
+ else if (_IceLastMajorOpcode == 255 ||
+ versionCount < 1 ||
+ strlen (protocolName) == 0)
+ {
+ return (-1);
+ }
+ else
+ {
+ char *name;
+
+ _IceProtocols[_IceLastMajorOpcode].protocol_name = name =
+ (char *) malloc (strlen (protocolName) + 1);
+ strcpy (name, protocolName);
+
+ p = _IceProtocols[_IceLastMajorOpcode].orig_client =
+ (_IcePoProtocol *) malloc (sizeof (_IcePoProtocol));
+
+ _IceProtocols[_IceLastMajorOpcode].accept_client = NULL;
+
+ opcodeRet = ++_IceLastMajorOpcode;
+ }
+
+ p->vendor = (char *) malloc (strlen (vendor) + 1);
+ strcpy (p->vendor, vendor);
+
+ p->release = (char *) malloc (strlen (release) + 1);
+ strcpy (p->release, release);
+
+ p->version_count = versionCount;
+
+ p->version_recs = (IcePoVersionRec *) malloc (
+ versionCount * sizeof (IcePoVersionRec));
+ memcpy (p->version_recs, versionRecs,
+ versionCount * sizeof (IcePoVersionRec));
+
+ if ((p->auth_count = authCount) > 0)
+ {
+ p->auth_names = (char **) malloc (
+ authCount * sizeof (char *));
+
+ p->auth_procs = (IcePoAuthProc *) malloc (
+ authCount * sizeof (IcePoAuthProc));
+
+ for (i = 0; i < authCount; i++)
+ {
+ p->auth_names[i] =
+ (char *) malloc (strlen (authNames[i]) + 1);
+ strcpy (p->auth_names[i], authNames[i]);
+
+ p->auth_procs[i] = authProcs[i];
+ }
+ }
+ else
+ {
+ p->auth_names = NULL;
+ p->auth_procs = NULL;
+ }
+
+ p->io_error_proc = IOErrorProc;
+
+ return (opcodeRet);
+}
+
+
+
+int
+IceRegisterForProtocolReply (protocolName, vendor, release,
+ versionCount, versionRecs, authCount, authNames, authProcs,
+ hostBasedAuthProc, protocolSetupProc, protocolActivateProc,
+ IOErrorProc)
+
+char *protocolName;
+char *vendor;
+char *release;
+int versionCount;
+IcePaVersionRec *versionRecs;
+int authCount;
+char **authNames;
+IcePaAuthProc *authProcs;
+IceHostBasedAuthProc hostBasedAuthProc;
+IceProtocolSetupProc protocolSetupProc;
+IceProtocolActivateProc protocolActivateProc;
+IceIOErrorProc IOErrorProc;
+
+{
+ _IcePaProtocol *p;
+ int opcodeRet, i;
+
+ for (i = 1; i <= _IceLastMajorOpcode; i++)
+ if (strcmp (protocolName, _IceProtocols[i - 1].protocol_name) == 0)
+ {
+ if (_IceProtocols[i - 1].accept_client != NULL)
+ {
+ /*
+ * We've already registered this protocol.
+ */
+
+ return (i);
+ }
+ else
+ {
+ break;
+ }
+ }
+
+
+ if (i <= _IceLastMajorOpcode)
+ {
+ p = _IceProtocols[i - 1].accept_client =
+ (_IcePaProtocol *) malloc (sizeof (_IcePaProtocol));
+ opcodeRet = i;
+ }
+ else if (_IceLastMajorOpcode == 255 ||
+ versionCount < 1 ||
+ strlen (protocolName) == 0)
+ {
+ return (-1);
+ }
+ else
+ {
+ char *name;
+
+ _IceProtocols[_IceLastMajorOpcode].protocol_name = name =
+ (char *) malloc (strlen (protocolName) + 1);
+ strcpy (name, protocolName);
+
+ _IceProtocols[_IceLastMajorOpcode].orig_client = NULL;
+
+ p = _IceProtocols[_IceLastMajorOpcode].accept_client =
+ (_IcePaProtocol *) malloc (sizeof (_IcePaProtocol));
+
+ opcodeRet = ++_IceLastMajorOpcode;
+ }
+
+ p->vendor = (char *) malloc (strlen (vendor) + 1);
+ strcpy (p->vendor, vendor);
+
+ p->release = (char *) malloc (strlen (release) + 1);
+ strcpy (p->release, release);
+
+ p->version_count = versionCount;
+
+ p->version_recs = (IcePaVersionRec *) malloc (
+ versionCount * sizeof (IcePaVersionRec));
+ memcpy (p->version_recs, versionRecs,
+ versionCount * sizeof (IcePaVersionRec));
+
+ p->protocol_setup_proc = protocolSetupProc;
+ p->protocol_activate_proc = protocolActivateProc;
+
+ if ((p->auth_count = authCount) > 0)
+ {
+ p->auth_names = (char **) malloc (
+ authCount * sizeof (char *));
+
+ p->auth_procs = (IcePaAuthProc *) malloc (
+ authCount * sizeof (IcePaAuthProc));
+
+ for (i = 0; i < authCount; i++)
+ {
+ p->auth_names[i] =
+ (char *) malloc (strlen (authNames[i]) + 1);
+ strcpy (p->auth_names[i], authNames[i]);
+
+ p->auth_procs[i] = authProcs[i];
+ }
+ }
+ else
+ {
+ p->auth_names = NULL;
+ p->auth_procs = NULL;
+ }
+
+ p->host_based_auth_proc = hostBasedAuthProc;
+
+ p->io_error_proc = IOErrorProc;
+
+ return (opcodeRet);
+}
+
diff --git a/nx-X11/lib/ICE/replywait.c b/nx-X11/lib/ICE/replywait.c
new file mode 100644
index 000000000..e00eb9285
--- /dev/null
+++ b/nx-X11/lib/ICE/replywait.c
@@ -0,0 +1,161 @@
+/* $Xorg: replywait.c,v 1.4 2001/02/09 02:03:26 xorgcvs Exp $ */
+/******************************************************************************
+
+
+Copyright 1993, 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.
+
+Author: Ralph Mor, X Consortium
+******************************************************************************/
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+#include <X11/ICE/ICElib.h>
+#include "ICElibint.h"
+
+
+void
+_IceAddReplyWait (iceConn, replyWait)
+
+IceConn iceConn;
+IceReplyWaitInfo *replyWait;
+
+{
+ /*
+ * Add this replyWait to the end of the list (only if the
+ * replyWait is not already in the list).
+ */
+
+ _IceSavedReplyWait *savedReplyWait;
+ _IceSavedReplyWait *prev, *last;
+
+ prev = NULL;
+ last = iceConn->saved_reply_waits;
+
+ while (last)
+ {
+ if (last->reply_wait == replyWait)
+ return;
+
+ prev = last;
+ last = last->next;
+ }
+
+ savedReplyWait = (_IceSavedReplyWait *) malloc (
+ sizeof (_IceSavedReplyWait));
+
+ savedReplyWait->reply_wait = replyWait;
+ savedReplyWait->reply_ready = False;
+ savedReplyWait->next = NULL;
+
+ if (prev == NULL)
+ iceConn->saved_reply_waits = savedReplyWait;
+ else
+ prev->next = savedReplyWait;
+}
+
+
+
+IceReplyWaitInfo *
+_IceSearchReplyWaits (iceConn, majorOpcode)
+
+IceConn iceConn;
+int majorOpcode;
+
+{
+ /*
+ * Return the first replyWait in the list with the given majorOpcode
+ */
+
+ _IceSavedReplyWait *savedReplyWait = iceConn->saved_reply_waits;
+
+ while (savedReplyWait && !savedReplyWait->reply_ready &&
+ savedReplyWait->reply_wait->major_opcode_of_request != majorOpcode)
+ {
+ savedReplyWait = savedReplyWait->next;
+ }
+
+ return (savedReplyWait ? savedReplyWait->reply_wait : NULL);
+}
+
+
+
+void
+_IceSetReplyReady (iceConn, replyWait)
+
+IceConn iceConn;
+IceReplyWaitInfo *replyWait;
+
+{
+ /*
+ * The replyWait specified has a reply ready.
+ */
+
+ _IceSavedReplyWait *savedReplyWait = iceConn->saved_reply_waits;
+
+ while (savedReplyWait && savedReplyWait->reply_wait != replyWait)
+ savedReplyWait = savedReplyWait->next;
+
+ if (savedReplyWait)
+ savedReplyWait->reply_ready = True;
+}
+
+
+
+Bool
+_IceCheckReplyReady (iceConn, replyWait)
+
+IceConn iceConn;
+IceReplyWaitInfo *replyWait;
+
+{
+ _IceSavedReplyWait *savedReplyWait = iceConn->saved_reply_waits;
+ _IceSavedReplyWait *prev = NULL;
+ Bool found = False;
+ Bool ready;
+
+ while (savedReplyWait && !found)
+ {
+ if (savedReplyWait->reply_wait == replyWait)
+ found = True;
+ else
+ {
+ prev = savedReplyWait;
+ savedReplyWait = savedReplyWait->next;
+ }
+ }
+
+ ready = found && savedReplyWait->reply_ready;
+
+ if (ready)
+ {
+ if (prev == NULL)
+ iceConn->saved_reply_waits = savedReplyWait->next;
+ else
+ prev->next = savedReplyWait->next;
+
+ free ((char *) savedReplyWait);
+ }
+
+ return (ready);
+}
diff --git a/nx-X11/lib/ICE/setauth.c b/nx-X11/lib/ICE/setauth.c
new file mode 100644
index 000000000..4fd77182a
--- /dev/null
+++ b/nx-X11/lib/ICE/setauth.c
@@ -0,0 +1,121 @@
+/* $Xorg: setauth.c,v 1.4 2001/02/09 02:03:26 xorgcvs Exp $ */
+/******************************************************************************
+
+
+Copyright 1993, 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.
+
+Author: Ralph Mor, X Consortium
+******************************************************************************/
+/* $XFree86: xc/lib/ICE/setauth.c,v 1.4 2001/12/14 19:53:36 dawes Exp $ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+#include <X11/ICE/ICElib.h>
+#include "ICElibint.h"
+#include <X11/ICE/ICEutil.h>
+
+
+/*
+ * IceSetPaAuthData is not a standard part of ICElib, it is specific
+ * to the sample implementation.
+ *
+ * For the client that initiates a Protocol Setup, we look in the
+ * .ICEauthority file to get authentication data.
+ *
+ * For the client accepting the Protocol Setup, we get the data
+ * from an in-memory database of authentication data (set by the
+ * application calling IceSetPaAuthData). We have to get the data
+ * from memory because getting it directly from the .ICEauthority
+ * file is not secure - someone can just modify the contents of the
+ * .ICEauthority file behind our back.
+ */
+
+int _IcePaAuthDataEntryCount = 0;
+#ifndef __UNIXOS2__
+IceAuthDataEntry _IcePaAuthDataEntries[ICE_MAX_AUTH_DATA_ENTRIES];
+#else
+IceAuthDataEntry _IcePaAuthDataEntries[ICE_MAX_AUTH_DATA_ENTRIES] = {0};
+#endif
+
+
+void
+IceSetPaAuthData (numEntries, entries)
+
+int numEntries;
+IceAuthDataEntry *entries;
+
+{
+ /*
+ * _IcePaAuthDataEntries should really be a linked list.
+ * On my list of TO DO stuff.
+ */
+
+ int i, j;
+
+ for (i = 0; i < numEntries; i++)
+ {
+ for (j = 0; j < _IcePaAuthDataEntryCount; j++)
+ if (strcmp (entries[i].protocol_name,
+ _IcePaAuthDataEntries[j].protocol_name) == 0 &&
+ strcmp (entries[i].network_id,
+ _IcePaAuthDataEntries[j].network_id) == 0 &&
+ strcmp (entries[i].auth_name,
+ _IcePaAuthDataEntries[j].auth_name) == 0)
+ break;
+
+ if (j < _IcePaAuthDataEntryCount)
+ {
+ free (_IcePaAuthDataEntries[j].protocol_name);
+ free (_IcePaAuthDataEntries[j].network_id);
+ free (_IcePaAuthDataEntries[j].auth_name);
+ free (_IcePaAuthDataEntries[j].auth_data);
+ }
+ else
+ {
+ _IcePaAuthDataEntryCount++;
+ }
+
+ _IcePaAuthDataEntries[j].protocol_name = (char *) malloc (
+ strlen (entries[i].protocol_name) + 1);
+ strcpy (_IcePaAuthDataEntries[j].protocol_name,
+ entries[i].protocol_name);
+
+ _IcePaAuthDataEntries[j].network_id = (char *) malloc (
+ strlen (entries[i].network_id) + 1);
+ strcpy (_IcePaAuthDataEntries[j].network_id,
+ entries[i].network_id);
+
+ _IcePaAuthDataEntries[j].auth_name = (char *) malloc (
+ strlen (entries[i].auth_name) + 1);
+ strcpy (_IcePaAuthDataEntries[j].auth_name,
+ entries[i].auth_name);
+
+ _IcePaAuthDataEntries[j].auth_data_length =
+ entries[i].auth_data_length;
+ _IcePaAuthDataEntries[j].auth_data = (char *) malloc (
+ entries[i].auth_data_length);
+ memcpy (_IcePaAuthDataEntries[j].auth_data,
+ entries[i].auth_data, entries[i].auth_data_length);
+ }
+}
diff --git a/nx-X11/lib/ICE/shutdown.c b/nx-X11/lib/ICE/shutdown.c
new file mode 100644
index 000000000..5c957c7bb
--- /dev/null
+++ b/nx-X11/lib/ICE/shutdown.c
@@ -0,0 +1,330 @@
+/* $Xorg: shutdown.c,v 1.4 2001/02/09 02:03:26 xorgcvs Exp $ */
+/******************************************************************************
+
+
+Copyright 1993, 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.
+
+Author: Ralph Mor, X Consortium
+******************************************************************************/
+/* $XFree86: xc/lib/ICE/shutdown.c,v 3.3 2001/08/01 00:44:37 tsi Exp $ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+#include <X11/ICE/ICElib.h>
+#include "ICElibint.h"
+#include <X11/Xtrans/Xtrans.h>
+
+
+Status
+IceProtocolShutdown (iceConn, majorOpcode)
+
+IceConn iceConn;
+int majorOpcode;
+
+{
+ if (iceConn->proto_ref_count == 0 || iceConn->process_msg_info == NULL ||
+ majorOpcode < 1 || majorOpcode > _IceLastMajorOpcode)
+ {
+ return (0);
+ }
+ else
+ {
+ /*
+ * Make sure this majorOpcode is really being used.
+ */
+
+ int i;
+
+ for (i = iceConn->his_min_opcode; i <= iceConn->his_max_opcode; i++)
+ {
+ if (iceConn->process_msg_info[
+ i - iceConn->his_min_opcode].in_use &&
+ iceConn->process_msg_info[
+ i - iceConn->his_min_opcode].my_opcode == majorOpcode)
+ break;
+ }
+
+ if (i > iceConn->his_max_opcode)
+ {
+ return (0);
+ }
+ else
+ {
+ /*
+ * OK, we can shut down the protocol.
+ */
+
+ iceConn->process_msg_info[
+ i - iceConn->his_min_opcode].in_use = False;
+ iceConn->proto_ref_count--;
+
+ return (1);
+ }
+ }
+}
+
+
+
+void
+IceSetShutdownNegotiation (iceConn, negotiate)
+
+IceConn iceConn;
+Bool negotiate;
+
+{
+ iceConn->skip_want_to_close = negotiate ? False : True;
+}
+
+
+
+Bool
+IceCheckShutdownNegotiation (iceConn)
+
+IceConn iceConn;
+
+{
+ return (iceConn->skip_want_to_close ? False : True);
+}
+
+
+
+IceCloseStatus
+IceCloseConnection (iceConn)
+
+IceConn iceConn;
+
+{
+ int refCountReachedZero;
+ IceCloseStatus status;
+
+ /*
+ * If this connection object was never valid, we can close
+ * it right now. This happens if IceAcceptConnection was
+ * called, but after calling IceProcessMessages several times
+ * the connection was rejected (because of authentication or
+ * some other reason).
+ */
+
+ if (iceConn->listen_obj &&
+ iceConn->connection_status != IceConnectAccepted)
+ {
+ _IceConnectionClosed (iceConn); /* invoke watch procs */
+ _IceFreeConnection (iceConn);
+ return (IceClosedNow);
+ }
+
+
+ /*---------------------------------------------------------------
+
+ ACTIONS:
+
+ A = Invoke Watch Procedures
+ B = Set free-asap bit
+ C = Free connection
+ D = Initialize shutdown negotiation
+ N = do nothing
+
+
+ ACTION TABLE:
+
+ IO free- dispatch protocol shutdown
+ error asap bit level refcount negotiation ACTION
+ occured set reached 0 reached 0
+
+ 0 0 0 0 0 N
+ 0 0 0 0 1 N
+ 0 0 0 1 0 AB
+ 0 0 0 1 1 N
+ 0 0 1 0 0 N
+ 0 0 1 0 1 N
+ 0 0 1 1 0 AC
+ 0 0 1 1 1 D
+ 0 1 0 0 0 N
+ 0 1 0 0 1 N
+ 0 1 0 1 0 N
+ 0 1 0 1 1 N
+ 0 1 1 0 0 C
+ 0 1 1 0 1 D
+ 0 1 1 1 0 C
+ 0 1 1 1 1 D
+ 1 0 0 0 0 AB
+ 1 0 0 0 1 AB
+ 1 0 0 1 0 AB
+ 1 0 0 1 1 AB
+ 1 0 1 0 0 AC
+ 1 0 1 0 1 AC
+ 1 0 1 1 0 AC
+ 1 0 1 1 1 AC
+ 1 1 0 0 0 N
+ 1 1 0 0 1 N
+ 1 1 0 1 0 N
+ 1 1 0 1 1 N
+ 1 1 1 0 0 C
+ 1 1 1 0 1 C
+ 1 1 1 1 0 C
+ 1 1 1 1 1 C
+
+ ---------------------------------------------------------------*/
+
+ if (iceConn->open_ref_count > 0)
+ iceConn->open_ref_count--;
+
+ refCountReachedZero = iceConn->open_ref_count == 0 &&
+ iceConn->proto_ref_count == 0;
+
+ status = IceConnectionInUse;
+
+ if (!iceConn->free_asap && (!iceConn->io_ok ||
+ (iceConn->io_ok && refCountReachedZero &&
+ iceConn->skip_want_to_close)))
+ {
+ /*
+ * Invoke the watch procedures now.
+ */
+
+ _IceConnectionClosed (iceConn);
+ status = IceClosedNow; /* may be overwritten by IceClosedASAP */
+ }
+
+ if (!iceConn->free_asap && iceConn->dispatch_level != 0 &&
+ (!iceConn->io_ok ||
+ (iceConn->io_ok && refCountReachedZero &&
+ iceConn->skip_want_to_close)))
+ {
+ /*
+ * Set flag so we free the connection as soon as possible.
+ */
+
+ iceConn->free_asap = True;
+ status = IceClosedASAP;
+ }
+
+ if (iceConn->io_ok && iceConn->dispatch_level == 0 &&
+ !iceConn->skip_want_to_close && refCountReachedZero)
+ {
+ /*
+ * Initiate shutdown negotiation.
+ */
+
+ IceSimpleMessage (iceConn, 0, ICE_WantToClose);
+ IceFlush (iceConn);
+
+ iceConn->want_to_close = 1;
+
+ status = IceStartedShutdownNegotiation;
+ }
+ else if (iceConn->dispatch_level == 0 &&
+ (!iceConn->io_ok || (iceConn->io_ok && iceConn->skip_want_to_close &&
+ (iceConn->free_asap || (!iceConn->free_asap && refCountReachedZero)))))
+ {
+ /*
+ * Free the connection.
+ */
+
+ _IceFreeConnection (iceConn);
+
+ status = IceClosedNow;
+ }
+
+ return (status);
+}
+
+
+
+void
+_IceFreeConnection (iceConn)
+
+IceConn iceConn;
+
+{
+ if (iceConn->listen_obj == NULL)
+ {
+ /*
+ * This iceConn was created with IceOpenConnection.
+ * We keep track of all open IceConn's, so we need
+ * to remove it from the list.
+ */
+
+ int i;
+
+ for (i = 0; i < _IceConnectionCount; i++)
+ if (_IceConnectionObjs[i] == iceConn)
+ break;
+
+ if (i < _IceConnectionCount)
+ {
+ if (i < _IceConnectionCount - 1)
+ {
+ _IceConnectionObjs[i] =
+ _IceConnectionObjs[_IceConnectionCount - 1];
+ _IceConnectionStrings[i] =
+ _IceConnectionStrings[_IceConnectionCount - 1];
+ }
+
+ _IceConnectionCount--;
+ }
+ }
+
+ if (iceConn->trans_conn)
+ _IceTransClose (iceConn->trans_conn);
+
+ if (iceConn->connection_string)
+ free (iceConn->connection_string);
+
+ if (iceConn->vendor)
+ free (iceConn->vendor);
+
+ if (iceConn->release)
+ free (iceConn->release);
+
+ if (iceConn->inbuf)
+ free (iceConn->inbuf);
+
+ if (iceConn->outbuf)
+ free (iceConn->outbuf);
+
+ if (iceConn->scratch)
+ free (iceConn->scratch);
+
+ if (iceConn->process_msg_info)
+ free ((char *) iceConn->process_msg_info);
+
+ if (iceConn->connect_to_you)
+ free ((char *) iceConn->connect_to_you);
+
+ if (iceConn->protosetup_to_you)
+ free ((char *) iceConn->protosetup_to_you);
+
+ if (iceConn->connect_to_me)
+ free ((char *) iceConn->connect_to_me);
+
+ if (iceConn->protosetup_to_me)
+ free ((char *) iceConn->protosetup_to_me);
+
+ free ((char *) iceConn);
+}
+
+
+
+
diff --git a/nx-X11/lib/ICE/watch.c b/nx-X11/lib/ICE/watch.c
new file mode 100644
index 000000000..ec90d78e4
--- /dev/null
+++ b/nx-X11/lib/ICE/watch.c
@@ -0,0 +1,206 @@
+/* $Xorg: watch.c,v 1.4 2001/02/09 02:03:26 xorgcvs Exp $ */
+/******************************************************************************
+
+
+Copyright 1993, 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.
+
+Author: Ralph Mor, X Consortium
+******************************************************************************/
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+#include <X11/ICE/ICElib.h>
+#include "ICElibint.h"
+
+
+Status
+IceAddConnectionWatch (watchProc, clientData)
+
+IceWatchProc watchProc;
+IcePointer clientData;
+
+{
+ /*
+ * watchProc will be called each time an ICE connection is
+ * created/destroyed by ICElib.
+ */
+
+ _IceWatchProc *ptr = _IceWatchProcs;
+ _IceWatchProc *newWatchProc;
+ int i;
+
+ if ((newWatchProc = (_IceWatchProc *) malloc (
+ sizeof (_IceWatchProc))) == NULL)
+ {
+ return (0);
+ }
+
+ newWatchProc->watch_proc = watchProc;
+ newWatchProc->client_data = clientData;
+ newWatchProc->watched_connections = NULL;
+ newWatchProc->next = NULL;
+
+ while (ptr && ptr->next)
+ ptr = ptr->next;
+
+ if (ptr == NULL)
+ _IceWatchProcs = newWatchProc;
+ else
+ ptr->next = newWatchProc;
+
+
+ /*
+ * Invoke the watch proc with any previously opened ICE connections.
+ */
+
+ for (i = 0; i < _IceConnectionCount; i++)
+ {
+ _IceWatchedConnection *newWatchedConn = (_IceWatchedConnection *)
+ malloc (sizeof (_IceWatchedConnection));
+
+ newWatchedConn->iceConn = _IceConnectionObjs[i];
+ newWatchedConn->next = NULL;
+
+ newWatchProc->watched_connections = newWatchedConn;
+
+ (*newWatchProc->watch_proc) (_IceConnectionObjs[i],
+ newWatchProc->client_data, True, &newWatchedConn->watch_data);
+ }
+
+ return (1);
+}
+
+
+
+void
+IceRemoveConnectionWatch (watchProc, clientData)
+
+IceWatchProc watchProc;
+IcePointer clientData;
+
+{
+ _IceWatchProc *currWatchProc = _IceWatchProcs;
+ _IceWatchProc *prevWatchProc = NULL;
+
+ while (currWatchProc && (currWatchProc->watch_proc != watchProc ||
+ currWatchProc->client_data != clientData))
+ {
+ prevWatchProc = currWatchProc;
+ currWatchProc = currWatchProc->next;
+ }
+
+ if (currWatchProc)
+ {
+ _IceWatchProc *nextWatchProc = currWatchProc->next;
+ _IceWatchedConnection *watchedConn;
+
+ watchedConn = currWatchProc->watched_connections;
+ while (watchedConn)
+ {
+ _IceWatchedConnection *nextWatchedConn = watchedConn->next;
+ free ((char *) watchedConn);
+ watchedConn = nextWatchedConn;
+ }
+
+ if (prevWatchProc == NULL)
+ _IceWatchProcs = nextWatchProc;
+ else
+ prevWatchProc->next = nextWatchProc;
+
+ free ((char *) currWatchProc);
+ }
+}
+
+
+
+void
+_IceConnectionOpened (iceConn)
+
+IceConn iceConn;
+
+{
+ _IceWatchProc *watchProc = _IceWatchProcs;
+
+ while (watchProc)
+ {
+ _IceWatchedConnection *newWatchedConn = (_IceWatchedConnection *)
+ malloc (sizeof (_IceWatchedConnection));
+ _IceWatchedConnection *watchedConn;
+
+ watchedConn = watchProc->watched_connections;
+ while (watchedConn && watchedConn->next)
+ watchedConn = watchedConn->next;
+
+ newWatchedConn->iceConn = iceConn;
+ newWatchedConn->next = NULL;
+
+ if (watchedConn == NULL)
+ watchProc->watched_connections = newWatchedConn;
+ else
+ watchedConn->next = newWatchedConn;
+
+ (*watchProc->watch_proc) (iceConn,
+ watchProc->client_data, True, &newWatchedConn->watch_data);
+
+ watchProc = watchProc->next;
+ }
+}
+
+
+
+void
+_IceConnectionClosed (iceConn)
+
+IceConn iceConn;
+
+{
+ _IceWatchProc *watchProc = _IceWatchProcs;
+
+ while (watchProc)
+ {
+ _IceWatchedConnection *watchedConn = watchProc->watched_connections;
+ _IceWatchedConnection *prev = NULL;
+
+ while (watchedConn && watchedConn->iceConn != iceConn)
+ {
+ prev = watchedConn;
+ watchedConn = watchedConn->next;
+ }
+
+ if (watchedConn)
+ {
+ (*watchProc->watch_proc) (iceConn,
+ watchProc->client_data, False, &watchedConn->watch_data);
+
+ if (prev == NULL)
+ watchProc->watched_connections = watchedConn->next;
+ else
+ prev->next = watchedConn->next;
+
+ free ((char *) watchedConn);
+ }
+
+ watchProc = watchProc->next;
+ }
+}