aboutsummaryrefslogtreecommitdiff
path: root/nx-X11/lib/ICE/error.c
diff options
context:
space:
mode:
Diffstat (limited to 'nx-X11/lib/ICE/error.c')
-rw-r--r--nx-X11/lib/ICE/error.c641
1 files changed, 641 insertions, 0 deletions
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);
+}