diff options
Diffstat (limited to 'nx-X11/lib/ICE')
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; + } +} |