Copy the KDE 3.5 branch to branches/trinity for new KDE 3.5 features.

BUG:215923


git-svn-id: svn://anonsvn.kde.org/home/kde/branches/trinity/kdelibs@1054174 283d02a7-25f6-0310-bc7c-ecb5cbfe19da

1 files changed, 650 insertions, 0 deletions

diff --git a/dcop/KDE-ICE/error.c b/dcop/KDE-ICE/error.c
new file mode 100644
index 000000000..c187d7cd7
--- /dev/null
+++ b/dcop/KDE-ICE/error.c
@@ -0,0 +1,650 @@
+/* $XConsortium: error.c /main/16 1995/09/15 13:54:01 mor $ */
+/******************************************************************************
+
+
+Copyright (c) 1993  X Consortium
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice 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
+X CONSORTIUM 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 X Consortium 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 X Consortium.
+
+Author: Ralph Mor, X Consortium
+******************************************************************************/
+
+#include "KDE-ICE/ICElib.h"
+#include "KDE-ICE/ICElibint.h"
+#include "KDE-ICE/globals.h"
+
+#include <stdio.h>
+#include <string.h>
+#include <errno.h>
+
+#ifdef X_NOT_STDC_ENV
+extern int errno;
+#endif
+
+
+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;
+const 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;
+const 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;
+const 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;
+const 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[8];
+    mOp[0] = (char) majorOpcode;
+    mOp[1] = mOp[2] = mOp[3] = mOp[4] = mOp[5] = mOp[6] = mOp[7] = 0;
+
+    IceErrorHeader (iceConn,
+	0, ICE_ProtocolSetup,
+	iceConn->receive_sequence,
+	IceFatalToProtocol,
+	IceMajorOpcodeDuplicate,
+	1 /* length */);
+
+    IceWriteData (iceConn, 8, mOp);
+    IceFlush (iceConn);
+}
+
+
+void
+_IceErrorUnknownProtocol (iceConn, protocolName)
+
+IceConn		iceConn;
+const 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[8];
+    maj[0] = (char) offendingMajor;
+    maj[1] = maj[2] = maj[3] = maj[4] = maj[5] = maj[6] = maj[7] = 0;
+
+    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;
+    (void)iceConn;/*unused*/
+
+    switch (offendingMinorOpcode)
+    {
+        case ICE_ConnectionSetup:
+            str = (char *)"ConnectionSetup";
+	    break;
+        case ICE_AuthRequired:
+            str = (char *)"AuthRequired";
+	    break;
+        case ICE_AuthReply:
+            str = (char *)"AuthReply";
+	    break;
+        case ICE_AuthNextPhase:
+            str = (char *)"AuthNextPhase";
+	    break;
+        case ICE_ConnectionReply:
+            str = (char *)"ConnectionReply";
+	    break;
+        case ICE_ProtocolSetup:
+            str = (char *)"ProtocolSetup";
+	    break;
+        case ICE_ProtocolReply:
+            str = (char *)"ProtocolReply";
+	    break;
+        case ICE_Ping:
+            str = (char *)"Ping";
+	    break;
+        case ICE_PingReply:
+            str = (char *)"PingReply";
+	    break;
+        case ICE_WantToClose:
+            str = (char *)"WantToClose";
+	    break;
+        case ICE_NoClose:
+            str = (char *)"NoClose";
+	    break;
+	default:
+	    str = (char *)"";
+	}
+
+    fprintf (stderr, "\n");
+
+    fprintf (stderr, "ICE error:  Offending minor opcode    = %d (%s)\n",
+	offendingMinorOpcode, str);
+
+    fprintf (stderr, "            Offending sequence number = %ld\n",
+	offendingSequence);
+
+    switch (errorClass)
+    {
+        case IceBadMinor:
+            str = (char *)"BadMinor";
+            break;
+        case IceBadState:
+            str = (char *)"BadState";
+            break;
+        case IceBadLength:
+            str = (char *)"BadLength";
+            break;
+        case IceBadValue:
+            str = (char *)"BadValue";
+            break;
+        case IceBadMajor:
+            str = (char *)"BadMajor";
+            break;
+        case IceNoAuth:
+            str = (char *)"NoAuthentication";
+            break;
+        case IceNoVersion:
+            str = (char *)"NoVersion";
+            break;
+        case IceSetupFailed:
+            str = (char *)"SetupFailed";
+            break;
+        case IceAuthRejected:
+            str = (char *)"AuthenticationRejected";
+            break;
+        case IceAuthFailed:
+            str = (char *)"AuthenticationFailed";
+            break;
+        case IceProtocolDuplicate:
+            str = (char *)"ProtocolDuplicate";
+            break;
+        case IceMajorOpcodeDuplicate:
+            str = (char *)"MajorOpcodeDuplicate";
+            break;
+        case IceUnknownProtocol:
+            str = (char *)"UnknownProtocol";
+            break;
+	default:
+	    str = (char *)"???";
+    }
+
+    fprintf (stderr, "            Error class               = %s\n", str);
+
+    if (severity == IceCanContinue)
+	str = (char *)"CanContinue";
+    else if (severity == IceFatalToProtocol)
+	str = (char *)"FatalToProtocol";
+    else if (severity == IceFatalToConnection)
+	str = (char *)"FatalToConnection";
+    else
+	str = (char *)"???";
+
+    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;
+
+{
+    (void)iceConn;/*unused*/
+    fprintf (stderr,
+	"ICE default IO error handler doing an exit(), pid = %d, errno = %d\n",
+	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);
+}