Merge remote-tracking branch 'origin/released'

Conflicts:
	xorg-server/Xext/dpms.c
	xorg-server/Xext/saver.c
	xorg-server/Xext/security.c
	xorg-server/Xext/shape.c
	xorg-server/Xext/sync.c
	xorg-server/Xi/opendev.c
	xorg-server/fb/wfbrename.h
	xorg-server/glx/glxserver.h
	xorg-server/hw/xwin/winwindowswm.c
	xorg-server/mi/miarc.c
	xorg-server/mi/miwideline.c
	xorg-server/os/io.c
	xorg-server/render/mipict.c

17 files changed, 8135 insertions, 8346 deletions

diff --git a/xorg-server/Xext/bigreq.c b/xorg-server/Xext/bigreq.c
index 3dcb69579..a939e1699 100644
--- a/xorg-server/Xext/bigreq.c
+++ b/xorg-server/Xext/bigreq.c
@@ -1,78 +1,77 @@
-/*

-

-Copyright 1992, 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.

-

-*/

-

-#ifdef HAVE_DIX_CONFIG_H

-#include <dix-config.h>

-#endif

-

-#include <X11/X.h>

-#include <X11/Xproto.h>

-#include "misc.h"

-#include "os.h"

-#include "dixstruct.h"

-#include "extnsionst.h"

-#include <X11/extensions/bigreqsproto.h>

-#include "opaque.h"

-#include "modinit.h"

-

-void BigReqExtensionInit(INITARGS);

-

-static int

-ProcBigReqDispatch (ClientPtr client)

-{

-    REQUEST(xBigReqEnableReq);

-    xBigReqEnableReply rep;

-     int n;

-

-    if (client->swapped) {

-	swaps(&stuff->length, n);

-    }

-    if (stuff->brReqType != X_BigReqEnable)

-	return BadRequest;

-    REQUEST_SIZE_MATCH(xBigReqEnableReq);

-    client->big_requests = TRUE;

-    memset(&rep, 0, sizeof(xBigReqEnableReply));

-    rep.type = X_Reply;

-    rep.length = 0;

-    rep.sequenceNumber = client->sequence;

-    rep.max_request_size = maxBigRequestSize;

-    if (client->swapped) {

-    	swaps(&rep.sequenceNumber, n);

-	swapl(&rep.max_request_size, n);

-    }

-    WriteToClient(client, sizeof(xBigReqEnableReply), (char *)&rep);

-    return Success;

-}

-

-void

-BigReqExtensionInit(INITARGS)

-{

-    AddExtension(XBigReqExtensionName, 0, 0,

-		 ProcBigReqDispatch, ProcBigReqDispatch,

-		 NULL, StandardMinorOpcode);

-}

+/*
+
+Copyright 1992, 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.
+
+*/
+
+#ifdef HAVE_DIX_CONFIG_H
+#include <dix-config.h>
+#endif
+
+#include <X11/X.h>
+#include <X11/Xproto.h>
+#include "misc.h"
+#include "os.h"
+#include "dixstruct.h"
+#include "extnsionst.h"
+#include <X11/extensions/bigreqsproto.h>
+#include "opaque.h"
+#include "modinit.h"
+
+void BigReqExtensionInit(INITARGS);
+
+static int
+ProcBigReqDispatch (ClientPtr client)
+{
+    REQUEST(xBigReqEnableReq);
+    xBigReqEnableReply rep;
+
+    if (client->swapped) {
+	swaps(&stuff->length);
+    }
+    if (stuff->brReqType != X_BigReqEnable)
+	return BadRequest;
+    REQUEST_SIZE_MATCH(xBigReqEnableReq);
+    client->big_requests = TRUE;
+    memset(&rep, 0, sizeof(xBigReqEnableReply));
+    rep.type = X_Reply;
+    rep.length = 0;
+    rep.sequenceNumber = client->sequence;
+    rep.max_request_size = maxBigRequestSize;
+    if (client->swapped) {
+	swaps(&rep.sequenceNumber);
+	swapl(&rep.max_request_size);
+    }
+    WriteToClient(client, sizeof(xBigReqEnableReply), (char *)&rep);
+    return Success;
+}
+
+void
+BigReqExtensionInit(INITARGS)
+{
+    AddExtension(XBigReqExtensionName, 0, 0,
+		 ProcBigReqDispatch, ProcBigReqDispatch,
+		 NULL, StandardMinorOpcode);
+}
diff --git a/xorg-server/Xext/dpms.c b/xorg-server/Xext/dpms.c
index 79b2e2944..e82f495aa 100644
--- a/xorg-server/Xext/dpms.c
+++ b/xorg-server/Xext/dpms.c
@@ -1,381 +1,369 @@
-/*****************************************************************

-

-Copyright (c) 1996 Digital Equipment Corporation, Maynard, Massachusetts.

-

-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.

-

-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

-DIGITAL EQUIPMENT CORPORATION BE LIABLE FOR ANY CLAIM, DAMAGES, INCLUDING, 

-BUT NOT LIMITED TO CONSEQUENTIAL OR INCIDENTAL 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 Digital Equipment Corporation 

-shall not be used in advertising or otherwise to promote the sale, use or other

-dealings in this Software without prior written authorization from Digital 

-Equipment Corporation.

-

-******************************************************************/

-

-#ifdef HAVE_DIX_CONFIG_H

-#include <dix-config.h>

-#else

-#define DPMSExtension

-#endif

-

-#include <X11/X.h>

-#include <X11/Xproto.h>

-#include "misc.h"

-#include "os.h"

-#include "dixstruct.h"

-#include "extnsionst.h"

-#include "opaque.h"

-#include <X11/extensions/dpmsproto.h>

-#include "dpmsproc.h"

-#include "modinit.h"

-

-static int

-ProcDPMSGetVersion(ClientPtr client)

-{

-    /* REQUEST(xDPMSGetVersionReq); */

-    xDPMSGetVersionReply rep;

-    int n;

-

-    REQUEST_SIZE_MATCH(xDPMSGetVersionReq);

-

-    rep.type = X_Reply;

-    rep.length = 0;

-    rep.sequenceNumber = client->sequence;

-    rep.majorVersion = DPMSMajorVersion;

-    rep.minorVersion = DPMSMinorVersion;

-    if (client->swapped) {

-    	swaps(&rep.sequenceNumber, n);

-	swaps(&rep.majorVersion, n);

-	swaps(&rep.minorVersion, n);

-    }

-    WriteToClient(client, sizeof(xDPMSGetVersionReply), (char *)&rep);

-    return Success;

-}

-

-static int

-ProcDPMSCapable(ClientPtr client)

-{

-    /* REQUEST(xDPMSCapableReq); */

-    xDPMSCapableReply rep;

-    int n;

-

-    REQUEST_SIZE_MATCH(xDPMSCapableReq);

-

-    rep.type = X_Reply;

-    rep.length = 0;

-    rep.sequenceNumber = client->sequence;

-    rep.capable = DPMSCapableFlag;

-

-    if (client->swapped) {

-	swaps(&rep.sequenceNumber, n);

-    }

-    WriteToClient(client, sizeof(xDPMSCapableReply), (char *)&rep);

-    return Success;

-}

-

-static int

-ProcDPMSGetTimeouts(ClientPtr client)

-{

-    /* REQUEST(xDPMSGetTimeoutsReq); */

-    xDPMSGetTimeoutsReply rep;

-    int n;

-

-    REQUEST_SIZE_MATCH(xDPMSGetTimeoutsReq);

-

-    rep.type = X_Reply;

-    rep.length = 0;

-    rep.sequenceNumber = client->sequence;

-    rep.standby = DPMSStandbyTime / MILLI_PER_SECOND;

-    rep.suspend = DPMSSuspendTime / MILLI_PER_SECOND;

-    rep.off = DPMSOffTime / MILLI_PER_SECOND;

-

-    if (client->swapped) {

-    	swaps(&rep.sequenceNumber, n);

-	swaps(&rep.standby, n);

-	swaps(&rep.suspend, n);

-	swaps(&rep.off, n);

-    }

-    WriteToClient(client, sizeof(xDPMSGetTimeoutsReply), (char *)&rep);

-    return Success;

-}

-

-static int

-ProcDPMSSetTimeouts(ClientPtr client)

-{

-    REQUEST(xDPMSSetTimeoutsReq);

-

-    REQUEST_SIZE_MATCH(xDPMSSetTimeoutsReq);

-

-    if ((stuff->off != 0)&&(stuff->off < stuff->suspend)) 

-    {

-	client->errorValue = stuff->off;

-	return BadValue;

-    }

-    if ((stuff->suspend != 0)&&(stuff->suspend < stuff->standby))

-    {

-	client->errorValue = stuff->suspend;

-	return BadValue;

-    }  

-

-    DPMSStandbyTime = stuff->standby * MILLI_PER_SECOND;

-    DPMSSuspendTime = stuff->suspend * MILLI_PER_SECOND;

-    DPMSOffTime = stuff->off * MILLI_PER_SECOND;

-    SetScreenSaverTimer();

-

-    return Success;

-}

-

-static int

-ProcDPMSEnable(ClientPtr client)

-{

-    Bool was_enabled = DPMSEnabled;

-

-    REQUEST_SIZE_MATCH(xDPMSEnableReq);

-

-    if (DPMSCapableFlag) {

-	DPMSEnabled = TRUE;

-	if (!was_enabled)

-	    SetScreenSaverTimer();

-    }

-

-    return Success;

-}

-

-static int

-ProcDPMSDisable(ClientPtr client)

-{

-    /* REQUEST(xDPMSDisableReq); */

-

-    REQUEST_SIZE_MATCH(xDPMSDisableReq);

-

-    DPMSSet(client, DPMSModeOn);

-

-    DPMSEnabled = FALSE;

-

-    return Success;

-}

-

-static int

-ProcDPMSForceLevel(ClientPtr client)

-{

-    REQUEST(xDPMSForceLevelReq);

-

-    REQUEST_SIZE_MATCH(xDPMSForceLevelReq);

-

-    if (!DPMSEnabled)

-	return BadMatch;

-

-    if (stuff->level != DPMSModeOn &&

-        stuff->level != DPMSModeStandby &&

-        stuff->level != DPMSModeSuspend &&

-        stuff->level != DPMSModeOff) {

-	client->errorValue = stuff->level;

-	return BadValue;

-    }

-

-    DPMSSet(client, stuff->level);

-

-    return Success;

-}

-

-static int

-ProcDPMSInfo(ClientPtr client)

-{

-    /* REQUEST(xDPMSInfoReq); */

-    xDPMSInfoReply rep;

-    int n;

-

-    REQUEST_SIZE_MATCH(xDPMSInfoReq);

-

-    rep.type = X_Reply;

-    rep.length = 0;

-    rep.sequenceNumber = client->sequence;

-    rep.power_level = DPMSPowerLevel;

-    rep.state = DPMSEnabled;

-

-    if (client->swapped) {

-    	swaps(&rep.sequenceNumber, n);

-	swaps(&rep.power_level, n);

-    }

-    WriteToClient(client, sizeof(xDPMSInfoReply), (char *)&rep);

-    return Success;

-}

-

-static int

-ProcDPMSDispatch (ClientPtr client)

-{

-    REQUEST(xReq);

-

-    switch (stuff->data)

-    {

-    case X_DPMSGetVersion:

-	return ProcDPMSGetVersion(client);

-    case X_DPMSCapable:

-	return ProcDPMSCapable(client);

-    case X_DPMSGetTimeouts:

-	return ProcDPMSGetTimeouts(client);

-    case X_DPMSSetTimeouts:

-	return ProcDPMSSetTimeouts(client);

-    case X_DPMSEnable:

-	return ProcDPMSEnable(client);

-    case X_DPMSDisable:

-	return ProcDPMSDisable(client);

-    case X_DPMSForceLevel:

-	return ProcDPMSForceLevel(client);

-    case X_DPMSInfo:

-	return ProcDPMSInfo(client);

-    default:

-	return BadRequest;

-    }

-}

-

-static int

-SProcDPMSGetVersion(ClientPtr client)

-{

-    int n;

-    REQUEST(xDPMSGetVersionReq);

-

-    swaps(&stuff->length, n);

-    REQUEST_SIZE_MATCH(xDPMSGetVersionReq);

-    swaps(&stuff->majorVersion, n);

-    swaps(&stuff->minorVersion, n);

-    return ProcDPMSGetVersion(client);

-}

-

-static int

-SProcDPMSCapable(ClientPtr client)

-{

-    REQUEST(xDPMSCapableReq);

-    int n;

-

-    swaps(&stuff->length, n);

-    REQUEST_SIZE_MATCH(xDPMSCapableReq);

-

-    return ProcDPMSCapable(client);

-}

-

-static int

-SProcDPMSGetTimeouts(ClientPtr client)

-{

-    REQUEST(xDPMSGetTimeoutsReq);

-    int n;

-

-    swaps(&stuff->length, n);

-    REQUEST_SIZE_MATCH(xDPMSGetTimeoutsReq);

-

-    return ProcDPMSGetTimeouts(client);

-}

-

-static int

-SProcDPMSSetTimeouts(ClientPtr client)

-{

-    REQUEST(xDPMSSetTimeoutsReq);

-    int n;

-

-    swaps(&stuff->length, n);

-    REQUEST_SIZE_MATCH(xDPMSSetTimeoutsReq);

-

-    swaps(&stuff->standby, n);

-    swaps(&stuff->suspend, n);

-    swaps(&stuff->off, n);

-    return ProcDPMSSetTimeouts(client);

-}

-

-static int

-SProcDPMSEnable(ClientPtr client)

-{

-    REQUEST(xDPMSEnableReq);

-    int n;

-

-    swaps(&stuff->length, n);

-    REQUEST_SIZE_MATCH(xDPMSEnableReq);

-

-    return ProcDPMSEnable(client);

-}

-

-static int

-SProcDPMSDisable(ClientPtr client)

-{

-    REQUEST(xDPMSDisableReq);

-    int n;

-

-    swaps(&stuff->length, n);

-    REQUEST_SIZE_MATCH(xDPMSDisableReq);

-

-    return ProcDPMSDisable(client);

-}

-

-static int

-SProcDPMSForceLevel(ClientPtr client)

-{

-    REQUEST(xDPMSForceLevelReq);

-    int n;

-

-    swaps(&stuff->length, n);

-    REQUEST_SIZE_MATCH(xDPMSForceLevelReq);

-

-    swaps(&stuff->level, n);

-

-    return ProcDPMSForceLevel(client);

-}

-

-static int

-SProcDPMSInfo(ClientPtr client)

-{

-    REQUEST(xDPMSInfoReq);

-    int n;

-

-    swaps(&stuff->length, n);

-    REQUEST_SIZE_MATCH(xDPMSInfoReq);

-

-    return ProcDPMSInfo(client);

-}

-

-static int

-SProcDPMSDispatch (ClientPtr client)

-{

-    REQUEST(xReq);

-    switch (stuff->data)

-    {

-    case X_DPMSGetVersion:

-	return SProcDPMSGetVersion(client);

-    case X_DPMSCapable:

-	return SProcDPMSCapable(client);

-    case X_DPMSGetTimeouts:

-	return SProcDPMSGetTimeouts(client);

-    case X_DPMSSetTimeouts:

-	return SProcDPMSSetTimeouts(client);

-    case X_DPMSEnable:

-	return SProcDPMSEnable(client);

-    case X_DPMSDisable:

-	return SProcDPMSDisable(client);

-    case X_DPMSForceLevel:

-	return SProcDPMSForceLevel(client);

-    case X_DPMSInfo:

-	return SProcDPMSInfo(client);

-    default:

-	return BadRequest;

-    }

-}

-

-void

-DPMSExtensionInit(INITARGS)

-{

-    AddExtension(DPMSExtensionName, 0, 0,

-		 ProcDPMSDispatch, SProcDPMSDispatch,

-		 NULL, StandardMinorOpcode);

-}

+/*****************************************************************
+
+Copyright (c) 1996 Digital Equipment Corporation, Maynard, Massachusetts.
+
+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.
+
+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
+DIGITAL EQUIPMENT CORPORATION BE LIABLE FOR ANY CLAIM, DAMAGES, INCLUDING, 
+BUT NOT LIMITED TO CONSEQUENTIAL OR INCIDENTAL 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 Digital Equipment Corporation 
+shall not be used in advertising or otherwise to promote the sale, use or other
+dealings in this Software without prior written authorization from Digital 
+Equipment Corporation.
+
+******************************************************************/
+
+#ifdef HAVE_DIX_CONFIG_H
+#include <dix-config.h>
+#else
+#define DPMSExtension
+#endif
+
+#include <X11/X.h>
+#include <X11/Xproto.h>
+#include "misc.h"
+#include "os.h"
+#include "dixstruct.h"
+#include "extnsionst.h"
+#include "opaque.h"
+#include <X11/extensions/dpmsproto.h>
+#include "dpmsproc.h"
+#include "modinit.h"
+
+static int
+ProcDPMSGetVersion(ClientPtr client)
+{
+    /* REQUEST(xDPMSGetVersionReq); */
+    xDPMSGetVersionReply rep;
+
+    REQUEST_SIZE_MATCH(xDPMSGetVersionReq);
+
+    rep.type = X_Reply;
+    rep.length = 0;
+    rep.sequenceNumber = client->sequence;
+    rep.majorVersion = DPMSMajorVersion;
+    rep.minorVersion = DPMSMinorVersion;
+    if (client->swapped) {
+	swaps(&rep.sequenceNumber);
+	swaps(&rep.majorVersion);
+	swaps(&rep.minorVersion);
+    }
+    WriteToClient(client, sizeof(xDPMSGetVersionReply), (char *)&rep);
+    return Success;
+}
+
+static int
+ProcDPMSCapable(ClientPtr client)
+{
+    /* REQUEST(xDPMSCapableReq); */
+    xDPMSCapableReply rep;
+
+    REQUEST_SIZE_MATCH(xDPMSCapableReq);
+
+    rep.type = X_Reply;
+    rep.length = 0;
+    rep.sequenceNumber = client->sequence;
+    rep.capable = DPMSCapableFlag;
+
+    if (client->swapped) {
+	swaps(&rep.sequenceNumber);
+    }
+    WriteToClient(client, sizeof(xDPMSCapableReply), (char *)&rep);
+    return Success;
+}
+
+static int
+ProcDPMSGetTimeouts(ClientPtr client)
+{
+    /* REQUEST(xDPMSGetTimeoutsReq); */
+    xDPMSGetTimeoutsReply rep;
+
+    REQUEST_SIZE_MATCH(xDPMSGetTimeoutsReq);
+
+    rep.type = X_Reply;
+    rep.length = 0;
+    rep.sequenceNumber = client->sequence;
+    rep.standby = DPMSStandbyTime / MILLI_PER_SECOND;
+    rep.suspend = DPMSSuspendTime / MILLI_PER_SECOND;
+    rep.off = DPMSOffTime / MILLI_PER_SECOND;
+
+    if (client->swapped) {
+	swaps(&rep.sequenceNumber);
+	swaps(&rep.standby);
+	swaps(&rep.suspend);
+	swaps(&rep.off);
+    }
+    WriteToClient(client, sizeof(xDPMSGetTimeoutsReply), (char *)&rep);
+    return Success;
+}
+
+static int
+ProcDPMSSetTimeouts(ClientPtr client)
+{
+    REQUEST(xDPMSSetTimeoutsReq);
+
+    REQUEST_SIZE_MATCH(xDPMSSetTimeoutsReq);
+
+    if ((stuff->off != 0)&&(stuff->off < stuff->suspend)) 
+    {
+	client->errorValue = stuff->off;
+	return BadValue;
+    }
+    if ((stuff->suspend != 0)&&(stuff->suspend < stuff->standby))
+    {
+	client->errorValue = stuff->suspend;
+	return BadValue;
+    }  
+
+    DPMSStandbyTime = stuff->standby * MILLI_PER_SECOND;
+    DPMSSuspendTime = stuff->suspend * MILLI_PER_SECOND;
+    DPMSOffTime = stuff->off * MILLI_PER_SECOND;
+    SetScreenSaverTimer();
+
+    return Success;
+}
+
+static int
+ProcDPMSEnable(ClientPtr client)
+{
+    Bool was_enabled = DPMSEnabled;
+
+    REQUEST_SIZE_MATCH(xDPMSEnableReq);
+
+    if (DPMSCapableFlag) {
+	DPMSEnabled = TRUE;
+	if (!was_enabled)
+	    SetScreenSaverTimer();
+    }
+
+    return Success;
+}
+
+static int
+ProcDPMSDisable(ClientPtr client)
+{
+    /* REQUEST(xDPMSDisableReq); */
+
+    REQUEST_SIZE_MATCH(xDPMSDisableReq);
+
+    DPMSSet(client, DPMSModeOn);
+
+    DPMSEnabled = FALSE;
+
+    return Success;
+}
+
+static int
+ProcDPMSForceLevel(ClientPtr client)
+{
+    REQUEST(xDPMSForceLevelReq);
+
+    REQUEST_SIZE_MATCH(xDPMSForceLevelReq);
+
+    if (!DPMSEnabled)
+	return BadMatch;
+
+    if (stuff->level != DPMSModeOn &&
+        stuff->level != DPMSModeStandby &&
+        stuff->level != DPMSModeSuspend &&
+        stuff->level != DPMSModeOff) {
+	client->errorValue = stuff->level;
+	return BadValue;
+    }
+
+    DPMSSet(client, stuff->level);
+
+    return Success;
+}
+
+static int
+ProcDPMSInfo(ClientPtr client)
+{
+    /* REQUEST(xDPMSInfoReq); */
+    xDPMSInfoReply rep;
+
+    REQUEST_SIZE_MATCH(xDPMSInfoReq);
+
+    rep.type = X_Reply;
+    rep.length = 0;
+    rep.sequenceNumber = client->sequence;
+    rep.power_level = DPMSPowerLevel;
+    rep.state = DPMSEnabled;
+
+    if (client->swapped) {
+	swaps(&rep.sequenceNumber);
+	swaps(&rep.power_level);
+    }
+    WriteToClient(client, sizeof(xDPMSInfoReply), (char *)&rep);
+    return Success;
+}
+
+static int
+ProcDPMSDispatch (ClientPtr client)
+{
+    REQUEST(xReq);
+
+    switch (stuff->data)
+    {
+    case X_DPMSGetVersion:
+	return ProcDPMSGetVersion(client);
+    case X_DPMSCapable:
+	return ProcDPMSCapable(client);
+    case X_DPMSGetTimeouts:
+	return ProcDPMSGetTimeouts(client);
+    case X_DPMSSetTimeouts:
+	return ProcDPMSSetTimeouts(client);
+    case X_DPMSEnable:
+	return ProcDPMSEnable(client);
+    case X_DPMSDisable:
+	return ProcDPMSDisable(client);
+    case X_DPMSForceLevel:
+	return ProcDPMSForceLevel(client);
+    case X_DPMSInfo:
+	return ProcDPMSInfo(client);
+    default:
+	return BadRequest;
+    }
+}
+
+static int
+SProcDPMSGetVersion(ClientPtr client)
+{
+    REQUEST(xDPMSGetVersionReq);
+
+    swaps(&stuff->length);
+    REQUEST_SIZE_MATCH(xDPMSGetVersionReq);
+    swaps(&stuff->majorVersion);
+    swaps(&stuff->minorVersion);
+    return ProcDPMSGetVersion(client);
+}
+
+static int
+SProcDPMSCapable(ClientPtr client)
+{
+    REQUEST(xDPMSCapableReq);
+
+    swaps(&stuff->length);
+    REQUEST_SIZE_MATCH(xDPMSCapableReq);
+
+    return ProcDPMSCapable(client);
+}
+
+static int
+SProcDPMSGetTimeouts(ClientPtr client)
+{
+    REQUEST(xDPMSGetTimeoutsReq);
+
+    swaps(&stuff->length);
+    REQUEST_SIZE_MATCH(xDPMSGetTimeoutsReq);
+
+    return ProcDPMSGetTimeouts(client);
+}
+
+static int
+SProcDPMSSetTimeouts(ClientPtr client)
+{
+    REQUEST(xDPMSSetTimeoutsReq);
+
+    swaps(&stuff->length);
+    REQUEST_SIZE_MATCH(xDPMSSetTimeoutsReq);
+
+    swaps(&stuff->standby);
+    swaps(&stuff->suspend);
+    swaps(&stuff->off);
+    return ProcDPMSSetTimeouts(client);
+}
+
+static int
+SProcDPMSEnable(ClientPtr client)
+{
+    REQUEST(xDPMSEnableReq);
+
+    swaps(&stuff->length);
+    REQUEST_SIZE_MATCH(xDPMSEnableReq);
+
+    return ProcDPMSEnable(client);
+}
+
+static int
+SProcDPMSDisable(ClientPtr client)
+{
+    REQUEST(xDPMSDisableReq);
+
+    swaps(&stuff->length);
+    REQUEST_SIZE_MATCH(xDPMSDisableReq);
+
+    return ProcDPMSDisable(client);
+}
+
+static int
+SProcDPMSForceLevel(ClientPtr client)
+{
+    REQUEST(xDPMSForceLevelReq);
+
+    swaps(&stuff->length);
+    REQUEST_SIZE_MATCH(xDPMSForceLevelReq);
+
+    swaps(&stuff->level);
+
+    return ProcDPMSForceLevel(client);
+}
+
+static int
+SProcDPMSInfo(ClientPtr client)
+{
+    REQUEST(xDPMSInfoReq);
+
+    swaps(&stuff->length);
+    REQUEST_SIZE_MATCH(xDPMSInfoReq);
+
+    return ProcDPMSInfo(client);
+}
+
+static int
+SProcDPMSDispatch (ClientPtr client)
+{
+    REQUEST(xReq);
+    switch (stuff->data)
+    {
+    case X_DPMSGetVersion:
+	return SProcDPMSGetVersion(client);
+    case X_DPMSCapable:
+	return SProcDPMSCapable(client);
+    case X_DPMSGetTimeouts:
+	return SProcDPMSGetTimeouts(client);
+    case X_DPMSSetTimeouts:
+	return SProcDPMSSetTimeouts(client);
+    case X_DPMSEnable:
+	return SProcDPMSEnable(client);
+    case X_DPMSDisable:
+	return SProcDPMSDisable(client);
+    case X_DPMSForceLevel:
+	return SProcDPMSForceLevel(client);
+    case X_DPMSInfo:
+	return SProcDPMSInfo(client);
+    default:
+	return BadRequest;
+    }
+}
+
+void
+DPMSExtensionInit(INITARGS)
+{
+    AddExtension(DPMSExtensionName, 0, 0,
+		 ProcDPMSDispatch, SProcDPMSDispatch,
+		 NULL, StandardMinorOpcode);
+}
diff --git a/xorg-server/Xext/geext.c b/xorg-server/Xext/geext.c
index 18f8ffeac..a8718ccbd 100644
--- a/xorg-server/Xext/geext.c
+++ b/xorg-server/Xext/geext.c
@@ -58,7 +58,6 @@ static void SGEGenericEvent(xEvent* from, xEvent* to);
 static int
 ProcGEQueryVersion(ClientPtr client)
 {
-    int n;
     GEClientInfoPtr pGEClient = GEGetClient(client);
     xGEQueryVersionReply rep;
     REQUEST(xGEQueryVersionReq);
@@ -80,10 +79,10 @@ ProcGEQueryVersion(ClientPtr client)
 
     if (client->swapped)
     {
-	swaps(&rep.sequenceNumber, n);
-        swapl(&rep.length, n);
-        swaps(&rep.majorVersion, n);
-        swaps(&rep.minorVersion, n);
+	swaps(&rep.sequenceNumber);
+	swapl(&rep.length);
+	swaps(&rep.majorVersion);
+	swaps(&rep.minorVersion);
     }
 
     WriteToClient(client, sizeof(xGEQueryVersionReply), (char*)&rep);
@@ -101,13 +100,12 @@ int (*ProcGEVector[GENumberRequests])(ClientPtr) = {
 static int
 SProcGEQueryVersion(ClientPtr client)
 {
-    int n;
     REQUEST(xGEQueryVersionReq);
 
-    swaps(&stuff->length, n);
+    swaps(&stuff->length);
     REQUEST_SIZE_MATCH(xGEQueryVersionReq);
-    swaps(&stuff->majorVersion, n);
-    swaps(&stuff->minorVersion, n);
+    swaps(&stuff->majorVersion);
+    swaps(&stuff->minorVersion);
     return(*ProcGEVector[stuff->ReqType])(client);
 }
 
diff --git a/xorg-server/Xext/panoramiX.c b/xorg-server/Xext/panoramiX.c
index 00afe94f1..fae7c81c9 100644
--- a/xorg-server/Xext/panoramiX.c
+++ b/xorg-server/Xext/panoramiX.c
@@ -388,7 +388,7 @@ XineramaRegisterConnectionBlockCallback(void (*func)(void))
     return TRUE;
 }
 
-static void XineramaInitData(ScreenPtr pScreen)
+static void XineramaInitData(void)
 {
     int i, w, h;
 
@@ -397,7 +397,7 @@ static void XineramaInitData(ScreenPtr pScreen)
 	BoxRec TheBox;
 	RegionRec ScreenRegion;
 
-        pScreen = screenInfo.screens[i];
+	ScreenPtr pScreen = screenInfo.screens[i];
 
 	TheBox.x1 = pScreen->x;
 	TheBox.x2 = TheBox.x1 + pScreen->width;
@@ -414,7 +414,7 @@ static void XineramaInitData(ScreenPtr pScreen)
     PanoramiXPixHeight = screenInfo.screens[0]->y + screenInfo.screens[0]->height;
 
     FOR_NSCREENS_FORWARD_SKIP(i) {
-	pScreen = screenInfo.screens[i];
+	ScreenPtr pScreen = screenInfo.screens[i];
 	w = pScreen->x + pScreen->width;
 	h = pScreen->y + pScreen->height;
 
@@ -425,10 +425,10 @@ static void XineramaInitData(ScreenPtr pScreen)
     }
 }
 
-void XineramaReinitData(ScreenPtr pScreen)
+void XineramaReinitData(void)
 {
     RegionUninit(&PanoramiXScreenRegion);
-    XineramaInitData(pScreen);
+    XineramaInitData();
 }
 
 /*
@@ -525,7 +525,7 @@ void PanoramiXExtensionInit(int argc, char *argv[])
 	return;
     }
   
-    XineramaInitData(pScreen);
+    XineramaInitData();
 
     /*
      *	Put our processes into the ProcVector
@@ -909,7 +909,6 @@ ProcPanoramiXQueryVersion (ClientPtr client)
 {
     /* REQUEST(xPanoramiXQueryVersionReq); */
     xPanoramiXQueryVersionReply		rep;
-    register 	int			n;
 
     REQUEST_SIZE_MATCH (xPanoramiXQueryVersionReq);
     rep.type = X_Reply;
@@ -918,10 +917,10 @@ ProcPanoramiXQueryVersion (ClientPtr client)
     rep.majorVersion = SERVER_PANORAMIX_MAJOR_VERSION;
     rep.minorVersion = SERVER_PANORAMIX_MINOR_VERSION;
     if (client->swapped) { 
-        swaps(&rep.sequenceNumber, n);
-        swapl(&rep.length, n);     
-        swaps(&rep.majorVersion, n);
-        swaps(&rep.minorVersion, n);
+        swaps(&rep.sequenceNumber);
+        swapl(&rep.length);
+        swaps(&rep.majorVersion);
+        swaps(&rep.minorVersion);
     }
     WriteToClient(client, sizeof (xPanoramiXQueryVersionReply), (char *)&rep);
     return Success;
@@ -933,7 +932,7 @@ ProcPanoramiXGetState(ClientPtr client)
 	REQUEST(xPanoramiXGetStateReq);
     	WindowPtr			pWin;
 	xPanoramiXGetStateReply		rep;
-	int			n, rc;
+	int			rc;
 	
 	REQUEST_SIZE_MATCH(xPanoramiXGetStateReq);
 	rc = dixLookupWindow(&pWin, stuff->window, client, DixGetAttrAccess);
@@ -946,9 +945,9 @@ ProcPanoramiXGetState(ClientPtr client)
 	rep.state = !noPanoramiXExtension;
 	rep.window = stuff->window;
     	if (client->swapped) {
-	    swaps (&rep.sequenceNumber, n);
-	    swapl (&rep.length, n);
-	    swapl (&rep.window, n);
+	    swaps(&rep.sequenceNumber);
+	    swapl(&rep.length);
+	    swapl(&rep.window);
 	}	
 	WriteToClient (client, sizeof (xPanoramiXGetStateReply), (char *) &rep);
 	return Success;
@@ -961,7 +960,7 @@ ProcPanoramiXGetScreenCount(ClientPtr client)
 	REQUEST(xPanoramiXGetScreenCountReq);
     	WindowPtr			pWin;
 	xPanoramiXGetScreenCountReply	rep;
-	int			n, rc;
+	int			rc;
 
 	REQUEST_SIZE_MATCH(xPanoramiXGetScreenCountReq);
 	rc = dixLookupWindow(&pWin, stuff->window, client, DixGetAttrAccess);
@@ -974,9 +973,9 @@ ProcPanoramiXGetScreenCount(ClientPtr client)
 	rep.ScreenCount = PanoramiXNumScreens;
 	rep.window = stuff->window;
     	if (client->swapped) {
-	    swaps (&rep.sequenceNumber, n);
-	    swapl (&rep.length, n);
-	    swapl (&rep.window, n);
+	    swaps(&rep.sequenceNumber);
+	    swapl(&rep.length);
+	    swapl(&rep.window);
 	}	
 	WriteToClient (client, sizeof (xPanoramiXGetScreenCountReply), (char *) &rep);
 	return Success;
@@ -988,7 +987,7 @@ ProcPanoramiXGetScreenSize(ClientPtr client)
 	REQUEST(xPanoramiXGetScreenSizeReq);
     	WindowPtr			pWin;
 	xPanoramiXGetScreenSizeReply	rep;
-	int			n, rc;
+	int			rc;
 	
 	if (stuff->screen >= PanoramiXNumScreens)
 	    return BadMatch;
@@ -1007,12 +1006,12 @@ ProcPanoramiXGetScreenSize(ClientPtr client)
 	rep.window = stuff->window;
 	rep.screen = stuff->screen;
     	if (client->swapped) {
-	    swaps (&rep.sequenceNumber, n);
-	    swapl (&rep.length, n);
-	    swapl (&rep.width, n);
-	    swapl (&rep.height, n);
-	    swapl (&rep.window, n);
-	    swapl (&rep.screen, n);
+	    swaps(&rep.sequenceNumber);
+	    swapl(&rep.length);
+	    swapl(&rep.width);
+	    swapl(&rep.height);
+	    swapl(&rep.window);
+	    swapl(&rep.screen);
 	}	
 	WriteToClient (client, sizeof (xPanoramiXGetScreenSizeReply), (char *) &rep);
 	return Success;
@@ -1040,10 +1039,9 @@ ProcXineramaIsActive(ClientPtr client)
     rep.state = !noPanoramiXExtension;
 #endif
     if (client->swapped) {
-	int n;
-	swaps (&rep.sequenceNumber, n);
-	swapl (&rep.length, n);
-	swapl (&rep.state, n);
+	swaps(&rep.sequenceNumber);
+	swapl(&rep.length);
+	swapl(&rep.state);
     }	
     WriteToClient (client, sizeof (xXineramaIsActiveReply), (char *) &rep);
     return Success;
@@ -1063,10 +1061,9 @@ ProcXineramaQueryScreens(ClientPtr client)
     rep.number = (noPanoramiXExtension) ? 0 : PanoramiXNumScreens;
     rep.length = bytes_to_int32(rep.number * sz_XineramaScreenInfo);
     if (client->swapped) {
-	int n;
-	swaps (&rep.sequenceNumber, n);
-	swapl (&rep.length, n);
-	swapl (&rep.number, n);
+	swaps(&rep.sequenceNumber);
+	swapl(&rep.length);
+	swapl(&rep.number);
     }	
     WriteToClient (client, sizeof (xXineramaQueryScreensReply), (char *) &rep);
 
@@ -1081,11 +1078,10 @@ ProcXineramaQueryScreens(ClientPtr client)
 	    scratch.height = screenInfo.screens[i]->height;
 	
 	    if(client->swapped) {
-		int n;
-		swaps (&scratch.x_org, n);
-		swaps (&scratch.y_org, n);
-		swaps (&scratch.width, n);
-		swaps (&scratch.height, n);
+		swaps(&scratch.x_org);
+		swaps(&scratch.y_org);
+		swaps(&scratch.width);
+		swaps(&scratch.height);
 	    }
 	    WriteToClient (client, sz_XineramaScreenInfo, (char *) &scratch);
 	}
diff --git a/xorg-server/Xext/panoramiXSwap.c b/xorg-server/Xext/panoramiXSwap.c
index e1720c9ab..79277021a 100644
--- a/xorg-server/Xext/panoramiXSwap.c
+++ b/xorg-server/Xext/panoramiXSwap.c
@@ -51,9 +51,8 @@ static int
 SProcPanoramiXQueryVersion (ClientPtr client)
 {
 	REQUEST(xPanoramiXQueryVersionReq);
-	int n;
 
-	swaps(&stuff->length,n);
+	swaps(&stuff->length);
 	REQUEST_SIZE_MATCH (xPanoramiXQueryVersionReq);
 	return ProcPanoramiXQueryVersion(client);
 }
@@ -62,11 +61,10 @@ static int
 SProcPanoramiXGetState(ClientPtr client)
 {
 	REQUEST(xPanoramiXGetStateReq);
-	int n;
 
- 	swaps (&stuff->length, n);	
+	swaps(&stuff->length);
 	REQUEST_SIZE_MATCH(xPanoramiXGetStateReq);
-	swapl (&stuff->window, n);
+	swapl(&stuff->window);
 	return ProcPanoramiXGetState(client);
 }
 
@@ -74,11 +72,10 @@ static int
 SProcPanoramiXGetScreenCount(ClientPtr client)
 {
 	REQUEST(xPanoramiXGetScreenCountReq);
-	int n;
 
-	swaps (&stuff->length, n);
+	swaps(&stuff->length);
 	REQUEST_SIZE_MATCH(xPanoramiXGetScreenCountReq);
-	swapl (&stuff->window, n);
+	swapl(&stuff->window);
 	return ProcPanoramiXGetScreenCount(client);
 }
 
@@ -86,12 +83,11 @@ static int
 SProcPanoramiXGetScreenSize(ClientPtr client)
 {
 	REQUEST(xPanoramiXGetScreenSizeReq);
-	int n;
 
-	swaps (&stuff->length, n);
+	swaps(&stuff->length);
 	REQUEST_SIZE_MATCH(xPanoramiXGetScreenSizeReq);
-	swapl (&stuff->window, n);
-	swapl (&stuff->screen, n);
+	swapl(&stuff->window);
+	swapl(&stuff->screen);
 	return ProcPanoramiXGetScreenSize(client);
 }
 
@@ -100,9 +96,8 @@ static int
 SProcXineramaIsActive(ClientPtr client)
 {
 	REQUEST(xXineramaIsActiveReq);
-	int n;
 
-	swaps (&stuff->length, n);
+	swaps(&stuff->length);
 	REQUEST_SIZE_MATCH(xXineramaIsActiveReq);
 	return ProcXineramaIsActive(client);
 }
@@ -112,9 +107,8 @@ static int
 SProcXineramaQueryScreens(ClientPtr client)
 {
 	REQUEST(xXineramaQueryScreensReq);
-	int n;
 
-	swaps (&stuff->length, n);
+	swaps(&stuff->length);
 	REQUEST_SIZE_MATCH(xXineramaQueryScreensReq);
 	return ProcXineramaQueryScreens(client);
 }
diff --git a/xorg-server/Xext/panoramiXsrv.h b/xorg-server/Xext/panoramiXsrv.h
index 6fc903b88..39d495203 100644
--- a/xorg-server/Xext/panoramiXsrv.h
+++ b/xorg-server/Xext/panoramiXsrv.h
@@ -19,7 +19,7 @@ extern _X_EXPORT PanoramiXRes * PanoramiXFindIDByScrnum(RESTYPE, XID, int);
 extern _X_EXPORT Bool XineramaRegisterConnectionBlockCallback(void (*func)(void));
 extern _X_EXPORT int XineramaDeleteResource(pointer, XID);
 
-extern _X_EXPORT void XineramaReinitData(ScreenPtr);
+extern _X_EXPORT void XineramaReinitData(void);
 
 extern _X_EXPORT RESTYPE XRC_DRAWABLE;
 extern _X_EXPORT RESTYPE XRT_WINDOW;
diff --git a/xorg-server/Xext/saver.c b/xorg-server/Xext/saver.c
index 5fd6c895d..a3ad3398a 100644
--- a/xorg-server/Xext/saver.c
+++ b/xorg-server/Xext/saver.c
@@ -1,1517 +1,1503 @@
-/*

- *

-Copyright (c) 1992  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:  Keith Packard, MIT X Consortium

- */

-

-

-#ifdef HAVE_DIX_CONFIG_H

-#include <dix-config.h>

-#else

-#define SCREENSAVER

-#endif

-

-#ifdef CreateWindow

-#undef CreateWindow

-#endif

-

-#include <X11/X.h>

-#include <X11/Xproto.h>

-#include "misc.h"

-#include "os.h"

-#include "windowstr.h"

-#include "scrnintstr.h"

-#include "pixmapstr.h"

-#include "extnsionst.h"

-#include "dixstruct.h"

-#include "resource.h"

-#include "opaque.h"

-#include <X11/extensions/saverproto.h>

-#include "gcstruct.h"

-#include "cursorstr.h"

-#include "colormapst.h"

-#include "xace.h"

-#ifdef PANORAMIX

-#include "panoramiX.h"

-#include "panoramiXsrv.h"

-#endif

-#ifdef DPMSExtension

-#include <X11/extensions/dpmsconst.h>

-#endif

-#include "protocol-versions.h"

-

-#include <stdio.h>

-

-#include "modinit.h"

-

-static int ScreenSaverEventBase = 0;

-

-

-static Bool ScreenSaverHandle (

-	ScreenPtr /* pScreen */,

-	int /* xstate */,

-	Bool /* force */

-	);

-

-static Bool

-CreateSaverWindow (

-	ScreenPtr /* pScreen */

-	);

-

-static Bool

-DestroySaverWindow (

-	ScreenPtr /* pScreen */

-	);

-

-static void

-UninstallSaverColormap (

-	ScreenPtr /* pScreen */

-	);

-

-static void

-CheckScreenPrivate (

-	ScreenPtr /* pScreen */

-	);

-

-static void SScreenSaverNotifyEvent (

-	xScreenSaverNotifyEvent * /* from */,

-	xScreenSaverNotifyEvent * /* to */

-	);

-

-static RESTYPE SuspendType;  /* resource type for suspension records */

-

-typedef struct _ScreenSaverSuspension *ScreenSaverSuspensionPtr;

-

-/* List of clients that are suspending the screensaver. */

-static ScreenSaverSuspensionPtr suspendingClients = NULL;

-

-/*

- * clientResource is a resource ID that's added when the record is

- * allocated, so the record is freed and the screensaver resumed when

- * the client disconnects. count is the number of times the client has

- * requested the screensaver be suspended.

- */

-typedef struct _ScreenSaverSuspension

-{

-    ScreenSaverSuspensionPtr  next;

-    ClientPtr                 pClient;

-    XID                       clientResource;

-    int                       count;

-} ScreenSaverSuspensionRec;

-

-static int ScreenSaverFreeSuspend(

-    pointer /*value */,

-    XID /* id */

-);

-

-/*

- * each screen has a list of clients requesting

- * ScreenSaverNotify events.  Each client has a resource

- * for each screen it selects ScreenSaverNotify input for,

- * this resource is used to delete the ScreenSaverNotifyRec

- * entry from the per-screen queue.

- */

-

-static RESTYPE SaverEventType;   /* resource type for event masks */

-

-typedef struct _ScreenSaverEvent *ScreenSaverEventPtr;

-

-typedef struct _ScreenSaverEvent {

-    ScreenSaverEventPtr	next;

-    ClientPtr		client;

-    ScreenPtr		screen;

-    XID			resource;

-    CARD32		mask;

-} ScreenSaverEventRec;

-

-static int ScreenSaverFreeEvents(

-    pointer /* value */,

-    XID /* id */

-);

-

-static Bool setEventMask (

-    ScreenPtr /* pScreen */,

-    ClientPtr /* client */,

-    unsigned long /* mask */

-);

-

-static unsigned long getEventMask (

-    ScreenPtr /* pScreen */,

-    ClientPtr /* client */

-);

-

-/*

- * when a client sets the screen saver attributes, a resource is

- * kept to be freed when the client exits

- */

-

-static RESTYPE AttrType;    /* resource type for attributes */

-

-typedef struct _ScreenSaverAttr {

-    ScreenPtr	    screen;

-    ClientPtr	    client;

-    XID		    resource;

-    short	    x, y;

-    unsigned short  width, height, borderWidth;

-    unsigned char   class;

-    unsigned char   depth;

-    VisualID	    visual;

-    CursorPtr	    pCursor;

-    PixmapPtr	    pBackgroundPixmap;

-    PixmapPtr	    pBorderPixmap;

-    Colormap	    colormap;

-    unsigned long   mask;		/* no pixmaps or cursors */

-    unsigned long   *values;

-} ScreenSaverAttrRec, *ScreenSaverAttrPtr;

-

-static int ScreenSaverFreeAttr (

-    pointer /* value */,

-    XID /* id */

-);

-

-static void FreeAttrs (

-    ScreenSaverAttrPtr	/* pAttr */

-);

-

-static void FreeScreenAttr (

-    ScreenSaverAttrPtr	/* pAttr */

-);

-

-static void

-SendScreenSaverNotify (

-    ScreenPtr /* pScreen */,

-    int /* state */,

-    Bool /* forced */

-);

-

-typedef struct _ScreenSaverScreenPrivate {

-    ScreenSaverEventPtr	    events;

-    ScreenSaverAttrPtr	    attr;

-    Bool		    hasWindow;

-    Colormap		    installedMap;

-} ScreenSaverScreenPrivateRec, *ScreenSaverScreenPrivatePtr;

-

-static ScreenSaverScreenPrivatePtr

-MakeScreenPrivate (

-	ScreenPtr /* pScreen */

-	);

-

-static DevPrivateKeyRec ScreenPrivateKeyRec;

-#define ScreenPrivateKey (&ScreenPrivateKeyRec)

-

-#define GetScreenPrivate(s) ((ScreenSaverScreenPrivatePtr) \

-    dixLookupPrivate(&(s)->devPrivates, ScreenPrivateKey))

-#define SetScreenPrivate(s,v) \

-    dixSetPrivate(&(s)->devPrivates, ScreenPrivateKey, v);

-#define SetupScreen(s)	ScreenSaverScreenPrivatePtr pPriv = (s ? GetScreenPrivate(s) : NULL)

-

-#define New(t)	(malloc(sizeof (t)))

-

-static void

-CheckScreenPrivate (ScreenPtr pScreen)

-{

-    SetupScreen (pScreen);

-

-    if (!pPriv)

-	return;

-    if (!pPriv->attr && !pPriv->events &&

-	!pPriv->hasWindow && pPriv->installedMap == None)

-    {

-	free(pPriv);

-	SetScreenPrivate (pScreen, NULL);

-	pScreen->screensaver.ExternalScreenSaver = NULL;

-    }

-}

-

-static ScreenSaverScreenPrivatePtr

-MakeScreenPrivate (ScreenPtr pScreen)

-{

-    SetupScreen (pScreen);

-

-    if (pPriv)

-	return pPriv;

-    pPriv = New (ScreenSaverScreenPrivateRec);

-    if (!pPriv)

-	return 0;

-    pPriv->events = 0;

-    pPriv->attr = 0;

-    pPriv->hasWindow = FALSE;

-    pPriv->installedMap = None;

-    SetScreenPrivate (pScreen, pPriv);

-    pScreen->screensaver.ExternalScreenSaver = ScreenSaverHandle;

-    return pPriv;

-}

-

-static unsigned long

-getEventMask (ScreenPtr pScreen, ClientPtr client)

-{

-    SetupScreen(pScreen);

-    ScreenSaverEventPtr	pEv;

-

-    if (!pPriv)

-	return 0;

-    for (pEv = pPriv->events; pEv; pEv = pEv->next)

-	if (pEv->client == client)

-	    return pEv->mask;

-    return 0;

-}

-

-static Bool

-setEventMask (ScreenPtr pScreen, ClientPtr client, unsigned long mask)

-{

-    SetupScreen(pScreen);

-    ScreenSaverEventPtr	pEv, *pPrev;

-

-    if (getEventMask (pScreen, client) == mask)

-	return TRUE;

-    if (!pPriv)

-    {

-	pPriv = MakeScreenPrivate (pScreen);

-	if (!pPriv)

-	    return FALSE;

-    }

-    for (pPrev = &pPriv->events; (pEv = *pPrev) != 0; pPrev = &pEv->next)

-	if (pEv->client == client)

-	    break;

-    if (mask == 0)

-    {

-	FreeResource (pEv->resource, SaverEventType);

-	*pPrev = pEv->next;

-	free(pEv);

-	CheckScreenPrivate (pScreen);

-    }

-    else

-    {

-    	if (!pEv) 

-    	{

-	    pEv = New (ScreenSaverEventRec);

-	    if (!pEv) 

-	    {

-		CheckScreenPrivate (pScreen);

-	    	return FALSE;

-	    }

-    	    *pPrev = pEv;

-    	    pEv->next = NULL;

-    	    pEv->client = client;

-    	    pEv->screen = pScreen;

-    	    pEv->resource = FakeClientID (client->index);

-	    if (!AddResource (pEv->resource, SaverEventType, (pointer) pEv))

-		return FALSE;

-    	}

-	pEv->mask = mask;

-    }

-    return TRUE;

-}

-

-static void

-FreeAttrs (ScreenSaverAttrPtr pAttr)

-{

-    PixmapPtr	    pPixmap;

-    CursorPtr	    pCursor;

-

-    if ((pPixmap = pAttr->pBackgroundPixmap) != 0)

-	(*pPixmap->drawable.pScreen->DestroyPixmap)(pPixmap);

-    if ((pPixmap = pAttr->pBorderPixmap) != 0)

-	(*pPixmap->drawable.pScreen->DestroyPixmap)(pPixmap);

-    if ((pCursor = pAttr->pCursor) != 0)

-	FreeCursor (pCursor, (Cursor) 0);

-}

-

-static void

-FreeScreenAttr (ScreenSaverAttrPtr pAttr)

-{

-    FreeAttrs (pAttr);

-    free(pAttr->values);

-    free(pAttr);

-}

-

-static int

-ScreenSaverFreeEvents (pointer value, XID id)

-{

-    ScreenSaverEventPtr	pOld = (ScreenSaverEventPtr)value;

-    ScreenPtr pScreen = pOld->screen;

-    SetupScreen (pScreen);

-    ScreenSaverEventPtr	pEv, *pPrev;

-

-    if (!pPriv)

-	return TRUE;

-    for (pPrev = &pPriv->events; (pEv = *pPrev) != 0; pPrev = &pEv->next)

-	if (pEv == pOld)

-	    break;

-    if (!pEv)

-	return TRUE;

-    *pPrev = pEv->next;

-    free(pEv);

-    CheckScreenPrivate (pScreen);

-    return TRUE;

-}

-

-static int

-ScreenSaverFreeAttr (pointer value, XID id)

-{

-    ScreenSaverAttrPtr	pOldAttr = (ScreenSaverAttrPtr)value;

-    ScreenPtr	pScreen = pOldAttr->screen;

-    SetupScreen (pScreen);

-

-    if (!pPriv)

-	return TRUE;

-    if (pPriv->attr != pOldAttr)

-	return TRUE;

-    FreeScreenAttr (pOldAttr);

-    pPriv->attr = NULL;

-    if (pPriv->hasWindow)

-    {

-	dixSaveScreens (serverClient, SCREEN_SAVER_FORCER, ScreenSaverReset);

-	dixSaveScreens (serverClient, SCREEN_SAVER_FORCER, ScreenSaverActive);

-    }

-    CheckScreenPrivate (pScreen);

-    return TRUE;

-}

-

-static int

-ScreenSaverFreeSuspend (pointer value, XID id)

-{

-    ScreenSaverSuspensionPtr data = (ScreenSaverSuspensionPtr) value;

-    ScreenSaverSuspensionPtr *prev, this;

-

-    /* Unlink and free the suspension record for the client */

-    for (prev = &suspendingClients; (this = *prev); prev = &this->next)

-    {

-	if (this == data)

-	{

-	    *prev = this->next;

-	    free(this);

-	    break;

-	}

-    }

-

-    /* Reenable the screensaver if this was the last client suspending it. */

-    if (screenSaverSuspended && suspendingClients == NULL)

-    {

-	screenSaverSuspended = FALSE;

-

-	/* The screensaver could be active, since suspending it (by design)

-	   doesn't prevent it from being forceably activated */

-#ifdef DPMSExtension

-	if (screenIsSaved != SCREEN_SAVER_ON && DPMSPowerLevel == DPMSModeOn)

-#else

-	if (screenIsSaved != SCREEN_SAVER_ON)

-#endif

-	{

-	    UpdateCurrentTimeIf();

-	    lastDeviceEventTime = currentTime;

-	    SetScreenSaverTimer();

-	}

-    }

-

-    return Success;

-}

-

-static void

-SendScreenSaverNotify (ScreenPtr pScreen, int state, Bool forced)

-{

-    ScreenSaverScreenPrivatePtr	pPriv;

-    ScreenSaverEventPtr		pEv;

-    unsigned long		mask;

-    xScreenSaverNotifyEvent	ev;

-    int				kind;

-

-    UpdateCurrentTimeIf ();

-    mask = ScreenSaverNotifyMask;

-    if (state == ScreenSaverCycle)

-	mask = ScreenSaverCycleMask;

-    pScreen = screenInfo.screens[pScreen->myNum];

-    pPriv = GetScreenPrivate(pScreen);

-    if (!pPriv)

-	return;

-    if (pPriv->attr)

-	kind = ScreenSaverExternal;

-    else if (ScreenSaverBlanking != DontPreferBlanking)

-	kind = ScreenSaverBlanked;

-    else

-	kind = ScreenSaverInternal;

-    for (pEv = pPriv->events; pEv; pEv = pEv->next)

-    {

-	if (!(pEv->mask & mask))

-	    continue;

-	ev.type = ScreenSaverNotify + ScreenSaverEventBase;

-	ev.state = state;

-	ev.timestamp = currentTime.milliseconds;

-	ev.root = pScreen->root->drawable.id;

-	ev.window = pScreen->screensaver.wid;

-	ev.kind = kind;

-	ev.forced = forced;

-	WriteEventsToClient (pEv->client, 1, (xEvent *) &ev);

-    }

-}

-

-static void

-SScreenSaverNotifyEvent (xScreenSaverNotifyEvent *from,

-                         xScreenSaverNotifyEvent *to)

-{

-    to->type = from->type;

-    to->state = from->state;

-    cpswaps (from->sequenceNumber, to->sequenceNumber);

-    cpswapl (from->timestamp, to->timestamp);    

-    cpswapl (from->root, to->root);    

-    cpswapl (from->window, to->window);    

-    to->kind = from->kind;

-    to->forced = from->forced;

-}

-

-static void

-UninstallSaverColormap (ScreenPtr pScreen)

-{

-    SetupScreen(pScreen);

-    ColormapPtr			pCmap;

-    int rc;

-

-    if (pPriv && pPriv->installedMap != None)

-    {

-	rc = dixLookupResourceByType((pointer *)&pCmap, pPriv->installedMap,

-				     RT_COLORMAP, serverClient,

-				     DixUninstallAccess);

-	if (rc == Success)

-	    (*pCmap->pScreen->UninstallColormap) (pCmap);

-	pPriv->installedMap = None;

-	CheckScreenPrivate (pScreen);

-    }

-}

-

-static Bool

-CreateSaverWindow (ScreenPtr pScreen)

-{

-    SetupScreen (pScreen);

-    ScreenSaverStuffPtr		pSaver;

-    ScreenSaverAttrPtr		pAttr;

-    WindowPtr			pWin;

-    int				result;

-    unsigned long		mask;

-    Colormap			*installedMaps;

-    int				numInstalled;

-    int				i;

-    Colormap			wantMap;

-    ColormapPtr			pCmap;

-

-    pSaver = &pScreen->screensaver;

-    if (pSaver->pWindow)

-    {

-	pSaver->pWindow = NullWindow;

-	FreeResource (pSaver->wid, RT_NONE);

-	if (pPriv)

-	{

-	    UninstallSaverColormap (pScreen);

-	    pPriv->hasWindow = FALSE;

-	    CheckScreenPrivate (pScreen);

-	}

-    }

-

-    if (!pPriv || !(pAttr = pPriv->attr))

-	return FALSE;

-

-    pPriv->installedMap = None;

-

-    if (GrabInProgress && GrabInProgress != pAttr->client->index)

-	return FALSE;

-

-    pWin = CreateWindow (pSaver->wid, pScreen->root,

-			 pAttr->x, pAttr->y, pAttr->width, pAttr->height,

-			 pAttr->borderWidth, pAttr->class, 

-			 pAttr->mask, (XID *)pAttr->values, 

-			 pAttr->depth, serverClient, pAttr->visual, 

-			 &result);

-    if (!pWin)

-	return FALSE;

-

-    if (!AddResource(pWin->drawable.id, RT_WINDOW, pWin))

-	return FALSE;

-

-    mask = 0;

-    if (pAttr->pBackgroundPixmap)

-    {

-	pWin->backgroundState = BackgroundPixmap;

-	pWin->background.pixmap = pAttr->pBackgroundPixmap;

-	pAttr->pBackgroundPixmap->refcnt++;

-	mask |= CWBackPixmap;

-    }

-    if (pAttr->pBorderPixmap)

-    {

-	pWin->borderIsPixel = FALSE;

-	pWin->border.pixmap = pAttr->pBorderPixmap;

-	pAttr->pBorderPixmap->refcnt++;

-	mask |= CWBorderPixmap;

-    }

-    if (pAttr->pCursor)

-    {

-	if (!pWin->optional)

-	    if (!MakeWindowOptional (pWin))

-	    {

-    	    	FreeResource (pWin->drawable.id, RT_NONE);

-    	    	return FALSE;

-	    }

-	pAttr->pCursor->refcnt++;

-	if (pWin->optional->cursor)

-	    FreeCursor (pWin->optional->cursor, (Cursor)0);

-	pWin->optional->cursor = pAttr->pCursor;

-	pWin->cursorIsNone = FALSE;

-	CheckWindowOptionalNeed (pWin);

-	mask |= CWCursor;

-    }

-    if (mask)

-	(*pScreen->ChangeWindowAttributes) (pWin, mask);

-

-    if (pAttr->colormap != None)

-	(void) ChangeWindowAttributes (pWin, CWColormap, &pAttr->colormap,

-				       serverClient);

-

-    MapWindow (pWin, serverClient);

-

-    pPriv->hasWindow = TRUE;

-    pSaver->pWindow = pWin;

-

-    /* check and install our own colormap if it isn't installed now */

-    wantMap = wColormap (pWin);

-    if (wantMap == None)

-	return TRUE;

-    installedMaps = malloc(pScreen->maxInstalledCmaps * sizeof (Colormap));

-    numInstalled = (*pWin->drawable.pScreen->ListInstalledColormaps)

-						    (pScreen, installedMaps);

-    for (i = 0; i < numInstalled; i++) 

-	if (installedMaps[i] == wantMap)

-	    break;

-

-    free((char *) installedMaps);

-

-    if (i < numInstalled)

-	return TRUE;

-

-    result = dixLookupResourceByType((pointer *)&pCmap, wantMap, RT_COLORMAP,

-				     serverClient, DixInstallAccess);

-    if (result != Success)

-	return TRUE;

-

-    pPriv->installedMap = wantMap;

-

-    (*pCmap->pScreen->InstallColormap) (pCmap);

-

-    return TRUE;

-}

-

-static Bool

-DestroySaverWindow (ScreenPtr pScreen)

-{

-    SetupScreen(pScreen);

-    ScreenSaverStuffPtr		pSaver;

-

-    if (!pPriv || !pPriv->hasWindow)

-	return FALSE;

-

-    pSaver = &pScreen->screensaver;

-    if (pSaver->pWindow)

-    {

-	pSaver->pWindow = NullWindow;

-	FreeResource (pSaver->wid, RT_NONE);

-    }

-    pPriv->hasWindow = FALSE;

-    CheckScreenPrivate (pScreen);

-    UninstallSaverColormap (pScreen);

-    return TRUE;

-}

-

-static Bool

-ScreenSaverHandle (ScreenPtr pScreen, int xstate, Bool force)

-{

-    int				state = 0;

-    Bool			ret = FALSE;

-    ScreenSaverScreenPrivatePtr	pPriv;

-

-    switch (xstate)

-    {

-    case SCREEN_SAVER_ON:	

-	state = ScreenSaverOn;

-	ret = CreateSaverWindow (pScreen);

-	break;

-    case SCREEN_SAVER_OFF:	

-	state = ScreenSaverOff;

-	ret = DestroySaverWindow (pScreen);

-	break;

-    case SCREEN_SAVER_CYCLE:	

-	state = ScreenSaverCycle;

-	pPriv = GetScreenPrivate (pScreen);

-	if (pPriv && pPriv->hasWindow)

-	    ret = TRUE;

-	

-    }

-#ifdef PANORAMIX

-    if(noPanoramiXExtension || !pScreen->myNum)

-#endif

-       SendScreenSaverNotify (pScreen, state, force);

-    return ret;

-}

-

-static int

-ProcScreenSaverQueryVersion (ClientPtr client)

-{

-    xScreenSaverQueryVersionReply	rep;

-    int		n;

-

-    REQUEST_SIZE_MATCH (xScreenSaverQueryVersionReq);

-    rep.type = X_Reply;

-    rep.length = 0;

-    rep.sequenceNumber = client->sequence;

-    rep.majorVersion = SERVER_SAVER_MAJOR_VERSION;

-    rep.minorVersion = SERVER_SAVER_MINOR_VERSION;

-    if (client->swapped) {

-    	swaps(&rep.sequenceNumber, n);

-    	swapl(&rep.length, n);

-    }

-    WriteToClient(client, sizeof (xScreenSaverQueryVersionReply), (char *)&rep);

-    return Success;

-}

-

-static int

-ProcScreenSaverQueryInfo (ClientPtr client)

-{

-    REQUEST(xScreenSaverQueryInfoReq);

-    xScreenSaverQueryInfoReply	rep;

-    int		n, rc;

-    ScreenSaverStuffPtr		pSaver;

-    DrawablePtr			pDraw;

-    CARD32			lastInput;

-    ScreenSaverScreenPrivatePtr	pPriv;

-

-    REQUEST_SIZE_MATCH (xScreenSaverQueryInfoReq);

-    rc = dixLookupDrawable(&pDraw, stuff->drawable, client, 0,

-			   DixGetAttrAccess);

-    if (rc != Success)

-	return rc;

-    rc = XaceHook(XACE_SCREENSAVER_ACCESS, client, pDraw->pScreen,

-		  DixGetAttrAccess);

-    if (rc != Success)

-	return rc;

-

-    pSaver = &pDraw->pScreen->screensaver;

-    pPriv = GetScreenPrivate (pDraw->pScreen);

-

-    UpdateCurrentTime ();

-    lastInput = GetTimeInMillis() - lastDeviceEventTime.milliseconds;

-

-    rep.type = X_Reply;

-    rep.length = 0;

-    rep.sequenceNumber = client->sequence;

-    rep.window = pSaver->wid;

-    if (screenIsSaved != SCREEN_SAVER_OFF)

-    {

-	rep.state = ScreenSaverOn;

-	if (ScreenSaverTime)

-	    rep.tilOrSince = lastInput - ScreenSaverTime;

-	else

-	    rep.tilOrSince = 0;

-    }

-    else

-    {

-	if (ScreenSaverTime)

-	{

-	    rep.state = ScreenSaverOff;

-	    if (ScreenSaverTime < lastInput)

-		rep.tilOrSince = 0;

-	    else

-		rep.tilOrSince = ScreenSaverTime - lastInput;

-	}

-	else

-	{

-	    rep.state = ScreenSaverDisabled;

-	    rep.tilOrSince = 0;

-	}

-    }

-    rep.idle = lastInput;

-    rep.eventMask = getEventMask (pDraw->pScreen, client);

-    if (pPriv && pPriv->attr)

-	rep.kind = ScreenSaverExternal;

-    else if (ScreenSaverBlanking != DontPreferBlanking)

-	rep.kind = ScreenSaverBlanked;

-    else

-	rep.kind = ScreenSaverInternal;

-    if (client->swapped)

-    {

-	swaps (&rep.sequenceNumber, n);

-	swapl (&rep.length, n);

-	swapl (&rep.window, n);

-	swapl (&rep.tilOrSince, n);

-	swapl (&rep.idle, n);

-	swapl (&rep.eventMask, n);

-    }

-    WriteToClient(client, sizeof (xScreenSaverQueryInfoReply), (char *)&rep);

-    return Success;

-}

-

-static int

-ProcScreenSaverSelectInput (ClientPtr client)

-{

-    REQUEST(xScreenSaverSelectInputReq);

-    DrawablePtr			pDraw;

-    int				rc;

-

-    REQUEST_SIZE_MATCH (xScreenSaverSelectInputReq);

-    rc = dixLookupDrawable (&pDraw, stuff->drawable, client, 0,

-			    DixGetAttrAccess);

-    if (rc != Success)

-	return rc;

-

-    rc = XaceHook(XACE_SCREENSAVER_ACCESS, client, pDraw->pScreen,

-		  DixSetAttrAccess);

-    if (rc != Success)

-	return rc;

-

-    if (!setEventMask (pDraw->pScreen, client, stuff->eventMask))

-	return BadAlloc;

-    return Success;

-}

-

-static int

-ScreenSaverSetAttributes (ClientPtr client)

-{

-    REQUEST(xScreenSaverSetAttributesReq);

-    DrawablePtr			pDraw;

-    WindowPtr			pParent;

-    ScreenPtr			pScreen;

-    ScreenSaverScreenPrivatePtr pPriv = 0;

-    ScreenSaverAttrPtr		pAttr = 0;

-    int				ret, len, class, bw, depth;

-    unsigned long		visual;

-    int				idepth, ivisual;

-    Bool			fOK;

-    DepthPtr			pDepth;

-    WindowOptPtr		ancwopt;

-    unsigned int		*pVlist;

-    unsigned long		*values = 0;

-    unsigned long		tmask, imask;

-    unsigned long		val;

-    Pixmap			pixID;

-    PixmapPtr			pPixmap;

-    Cursor			cursorID;

-    CursorPtr			pCursor;

-    Colormap			cmap;

-    ColormapPtr			pCmap;

-

-    REQUEST_AT_LEAST_SIZE (xScreenSaverSetAttributesReq);

-    ret = dixLookupDrawable(&pDraw, stuff->drawable, client, 0,

-			    DixGetAttrAccess);

-    if (ret != Success)

-	return ret;

-    pScreen = pDraw->pScreen;

-    pParent = pScreen->root;

-

-    ret = XaceHook(XACE_SCREENSAVER_ACCESS, client, pScreen, DixSetAttrAccess);

-    if (ret != Success)

-	return ret;

-

-    len = stuff->length -  bytes_to_int32(sizeof(xScreenSaverSetAttributesReq));

-    if (Ones(stuff->mask) != len)

-        return BadLength;

-    if (!stuff->width || !stuff->height)

-    {

-	client->errorValue = 0;

-        return BadValue;

-    }

-    switch (class = stuff->c_class) 

-    {

-    case CopyFromParent:

-    case InputOnly:

-    case InputOutput:

-	break;

-    default:

-	client->errorValue = class;

-	return BadValue;

-    }

-    bw = stuff->borderWidth;

-    depth = stuff->depth;

-    visual = stuff->visualID;

-

-    /* copied directly from CreateWindow */

-

-    if (class == CopyFromParent)

-	class = pParent->drawable.class;

-

-    if ((class != InputOutput) && (class != InputOnly))

-    {

-	client->errorValue = class;

-	return BadValue;

-    }

-

-    if ((class != InputOnly) && (pParent->drawable.class == InputOnly))

-        return BadMatch;

-

-    if ((class == InputOnly) && ((bw != 0) || (depth != 0)))

-        return BadMatch;

-

-    if ((class == InputOutput) && (depth == 0))

-        depth = pParent->drawable.depth;

-    ancwopt = pParent->optional;

-    if (!ancwopt)

-	ancwopt = FindWindowWithOptional(pParent)->optional;

-    if (visual == CopyFromParent)

-	visual = ancwopt->visual;

-

-    /* Find out if the depth and visual are acceptable for this Screen */

-    if ((visual != ancwopt->visual) || (depth != pParent->drawable.depth))

-    {

-	fOK = FALSE;

-	for(idepth = 0; idepth < pScreen->numDepths; idepth++)

-	{

-	    pDepth = (DepthPtr) &pScreen->allowedDepths[idepth];

-	    if ((depth == pDepth->depth) || (depth == 0))

-	    {

-		for (ivisual = 0; ivisual < pDepth->numVids; ivisual++)

-		{

-		    if (visual == pDepth->vids[ivisual])

-		    {

-			fOK = TRUE;

-			break;

-		    }

-		}

-	    }

-	}

-	if (fOK == FALSE)

-	    return BadMatch;

-    }

-

-    if (((stuff->mask & (CWBorderPixmap | CWBorderPixel)) == 0) &&

-	(class != InputOnly) &&

-	(depth != pParent->drawable.depth))

-    {

-        return BadMatch;

-    }

-

-    if (((stuff->mask & CWColormap) == 0) &&

-	(class != InputOnly) &&

-	((visual != ancwopt->visual) || (ancwopt->colormap == None)))

-    {

-	return BadMatch;

-    }

-

-    /* end of errors from CreateWindow */

-

-    pPriv = GetScreenPrivate (pScreen);

-    if (pPriv && pPriv->attr)

-    {

-	if (pPriv->attr->client != client)

-	    return BadAccess;

-    }

-    if (!pPriv)

-    {

-	pPriv = MakeScreenPrivate (pScreen);

-	if (!pPriv)

-	    return FALSE;

-    }

-    pAttr = New (ScreenSaverAttrRec);

-    if (!pAttr)

-    {

-	ret = BadAlloc;

-	goto bail;

-    }

-    /* over allocate for override redirect */

-    values = malloc((len + 1) * sizeof (unsigned long));

-    if (!values)

-    {

-	ret = BadAlloc;

-	goto bail;

-    }

-    pAttr->screen = pScreen;

-    pAttr->client = client;

-    pAttr->x = stuff->x;

-    pAttr->y = stuff->y;

-    pAttr->width = stuff->width;

-    pAttr->height = stuff->height;

-    pAttr->borderWidth = stuff->borderWidth;

-    pAttr->class = stuff->c_class;

-    pAttr->depth = depth;

-    pAttr->visual = visual;

-    pAttr->colormap = None;

-    pAttr->pCursor = NullCursor;

-    pAttr->pBackgroundPixmap = NullPixmap;

-    pAttr->pBorderPixmap = NullPixmap;

-    pAttr->values = values;

-    /*

-     * go through the mask, checking the values,

-     * looking up pixmaps and cursors and hold a reference

-     * to them.

-     */

-    pAttr->mask = tmask = stuff->mask | CWOverrideRedirect;

-    pVlist = (unsigned int *) (stuff + 1);

-    while (tmask) {

-	imask = lowbit (tmask);

-	tmask &= ~imask;

-	switch (imask)

-        {

-	case CWBackPixmap:

-	    pixID = (Pixmap )*pVlist;

-	    if (pixID == None)

-	    {

-		*values++ = None;

-	    }

-	    else if (pixID == ParentRelative)

-	    {

-		if (depth != pParent->drawable.depth)

-		{

-		    ret = BadMatch;

-		    goto PatchUp;

-		}

-		*values++ = ParentRelative;

-	    }

-            else

-	    {	

-		ret = dixLookupResourceByType((pointer *)&pPixmap, pixID, RT_PIXMAP,

-					client, DixReadAccess);

-		if (ret == Success)

-		{

-                    if  ((pPixmap->drawable.depth != depth) ||

-			 (pPixmap->drawable.pScreen != pScreen))

-		    {

-                        ret = BadMatch;

-			goto PatchUp;

-		    }

-		    pAttr->pBackgroundPixmap = pPixmap;

-		    pPixmap->refcnt++;

-		    pAttr->mask &= ~CWBackPixmap;

-		}

-	        else

-		{

-		    client->errorValue = pixID;

-		    goto PatchUp;

-		}

-	    }

-	    break;

-	case CWBackPixel:

-	    *values++ = (CARD32) *pVlist;

-	    break;

-	case CWBorderPixmap:

-	    pixID = (Pixmap ) *pVlist;

-	    if (pixID == CopyFromParent)

-	    {

-		if (depth != pParent->drawable.depth)

-		{

-		    ret = BadMatch;

-		    goto PatchUp;

-		}

-		*values++ = CopyFromParent;

-	    }

-	    else

-	    {	

-		ret = dixLookupResourceByType((pointer *)&pPixmap, pixID, RT_PIXMAP,

-					client, DixReadAccess);

-		if (ret == Success)

-		{

-                    if  ((pPixmap->drawable.depth != depth) ||

-			 (pPixmap->drawable.pScreen != pScreen))

-		    {

-			ret = BadMatch;

-			goto PatchUp;

-		    }

-		    pAttr->pBorderPixmap = pPixmap;

-		    pPixmap->refcnt++;

-		    pAttr->mask &= ~CWBorderPixmap;

-		}

-    	        else

-		{

-		    client->errorValue = pixID;

-		    goto PatchUp;

-		}

-	    }

-	    break;

-	case CWBorderPixel:

-            *values++ = (CARD32) *pVlist;

-            break;

-	case CWBitGravity:

-	    val = (CARD8 )*pVlist;

-	    if (val > StaticGravity)

-	    {

-		ret = BadValue;

-		client->errorValue = val;

-		goto PatchUp;

-	    }

-	    *values++ = val;

-	    break;

-	case CWWinGravity:

-	    val = (CARD8 )*pVlist;

-	    if (val > StaticGravity)

-	    {

-		ret = BadValue;

-		client->errorValue = val;

-		goto PatchUp;

-	    }

-	    *values++ = val;

-	    break;

-	case CWBackingStore:

-	    val = (CARD8 )*pVlist;

-	    if ((val != NotUseful) && (val != WhenMapped) && (val != Always))

-	    {

-		ret = BadValue;

-		client->errorValue = val;

-		goto PatchUp;

-	    }

-	    *values++ = val;

-	    break;

-	case CWBackingPlanes:

-	    *values++ = (CARD32) *pVlist;

-	    break;

-	case CWBackingPixel:

-	    *values++ = (CARD32) *pVlist;

-	    break;

-	case CWSaveUnder:

-	    val = (BOOL) *pVlist;

-	    if ((val != xTrue) && (val != xFalse))

-	    {

-		ret = BadValue;

-		client->errorValue = val;

-		goto PatchUp;

-	    }

-	    *values++ = val;

-	    break;

-	case CWEventMask:

-	    *values++ = (CARD32) *pVlist;

-	    break;

-	case CWDontPropagate:

-	    *values++ = (CARD32) *pVlist;

-	    break;

-	case CWOverrideRedirect:

-	    if (!(stuff->mask & CWOverrideRedirect))

-		pVlist--;

-	    else

-	    {

-	    	val = (BOOL ) *pVlist;

-	    	if ((val != xTrue) && (val != xFalse))

-	    	{

-		    ret = BadValue;

-		    client->errorValue = val;

-		    goto PatchUp;

-	    	}

-	    }

-	    *values++ = xTrue;

-	    break;

-	case CWColormap:

-	    cmap = (Colormap) *pVlist;

-	    ret = dixLookupResourceByType((pointer *)&pCmap, cmap, RT_COLORMAP,

-				    client, DixUseAccess);

-	    if (ret != Success)

-	    {

-		client->errorValue = cmap;

-		goto PatchUp;

-	    }

-	    if (pCmap->pVisual->vid != visual || pCmap->pScreen != pScreen)

-	    {

-		ret = BadMatch;

-		goto PatchUp;

-	    }

-	    pAttr->colormap = cmap;

-	    pAttr->mask &= ~CWColormap;

-	    break;

-	case CWCursor:

-	    cursorID = (Cursor ) *pVlist;

-	    if ( cursorID == None)

-	    {

-		*values++ = None;

-	    }

-	    else

-	    {

-		ret = dixLookupResourceByType((pointer *)&pCursor, cursorID,

-					RT_CURSOR, client, DixUseAccess);

-	    	if (ret != Success)

-	    	{

-		    client->errorValue = cursorID;

-		    goto PatchUp;

-	    	}

-		pCursor->refcnt++;

-		pAttr->pCursor = pCursor;

-		pAttr->mask &= ~CWCursor;

-	    }

-	    break;

-     	 default:

-	    ret = BadValue;

-	    client->errorValue = stuff->mask;

-	    goto PatchUp;

-	}

-	pVlist++;

-    }

-    if (pPriv->attr)

-	FreeScreenAttr (pPriv->attr);

-    pPriv->attr = pAttr;

-    pAttr->resource = FakeClientID (client->index);

-    if (!AddResource (pAttr->resource, AttrType, (pointer) pAttr))

-	return BadAlloc;

-    return Success;

-PatchUp:

-    FreeAttrs (pAttr);

-bail:

-    CheckScreenPrivate (pScreen);

-    if (pAttr) free(pAttr->values);

-    free(pAttr);

-    return ret;

-}

-

-static int

-ScreenSaverUnsetAttributes (ClientPtr client)

-{

-    REQUEST(xScreenSaverSetAttributesReq);

-    DrawablePtr			pDraw;

-    ScreenSaverScreenPrivatePtr	pPriv;

-    int				rc;

-

-    REQUEST_SIZE_MATCH (xScreenSaverUnsetAttributesReq);

-    rc = dixLookupDrawable(&pDraw, stuff->drawable, client, 0,

-			   DixGetAttrAccess);

-    if (rc != Success)

-	return rc;

-    pPriv = GetScreenPrivate (pDraw->pScreen);

-    if (pPriv && pPriv->attr && pPriv->attr->client == client)

-    {

-	FreeResource (pPriv->attr->resource, AttrType);

-    	FreeScreenAttr (pPriv->attr);

-	pPriv->attr = NULL;

-	CheckScreenPrivate (pDraw->pScreen);

-    }

-    return Success;

-}

-

-static int

-ProcScreenSaverSetAttributes (ClientPtr client)

-{

-#ifdef PANORAMIX

-    if(!noPanoramiXExtension) {

-       REQUEST(xScreenSaverSetAttributesReq);

-       PanoramiXRes *draw;

-       PanoramiXRes *backPix = NULL;

-       PanoramiXRes *bordPix = NULL;

-       PanoramiXRes *cmap    = NULL;

-       int i, status, len;

-       int  pback_offset = 0, pbord_offset = 0, cmap_offset = 0;

-       XID orig_visual, tmp;

-

-       REQUEST_AT_LEAST_SIZE (xScreenSaverSetAttributesReq);

-

-       status = dixLookupResourceByClass((pointer *)&draw, stuff->drawable,

-					 XRC_DRAWABLE, client, DixWriteAccess);

-       if (status != Success)

-           return (status == BadValue) ? BadDrawable : status;

-

-       len = stuff->length -  bytes_to_int32(sizeof(xScreenSaverSetAttributesReq));

-       if (Ones(stuff->mask) != len)

-           return BadLength;

-

-       if((Mask)stuff->mask & CWBackPixmap) {

-          pback_offset = Ones((Mask)stuff->mask & (CWBackPixmap - 1));

-          tmp = *((CARD32 *) &stuff[1] + pback_offset);

-          if ((tmp != None) && (tmp != ParentRelative)) {

-	      status = dixLookupResourceByType((pointer *)&backPix, tmp,

-					       XRT_PIXMAP, client,

-					       DixReadAccess);

-	      if (status != Success)

-		  return status;

-          }

-       }

-

-       if ((Mask)stuff->mask & CWBorderPixmap) {

-          pbord_offset = Ones((Mask)stuff->mask & (CWBorderPixmap - 1));

-          tmp = *((CARD32 *) &stuff[1] + pbord_offset);

-          if (tmp != CopyFromParent) {

-	      status = dixLookupResourceByType((pointer *)&bordPix, tmp,

-					       XRT_PIXMAP, client,

-					       DixReadAccess);

-	      if (status != Success)

-		  return status;

-          }

-       }

-

-       if ((Mask)stuff->mask & CWColormap) {

-           cmap_offset = Ones((Mask)stuff->mask & (CWColormap - 1));

-           tmp = *((CARD32 *) &stuff[1] + cmap_offset);

-           if ((tmp != CopyFromParent) && (tmp != None)) {

-	       status = dixLookupResourceByType((pointer *)&cmap, tmp,

-						XRT_COLORMAP, client,

-						DixReadAccess);

-	       if (status != Success)

-		   return status;

-           }

-       }

-

-       orig_visual = stuff->visualID;

-

-       FOR_NSCREENS_BACKWARD(i) {

-          stuff->drawable = draw->info[i].id;  

-          if (backPix)

-             *((CARD32 *) &stuff[1] + pback_offset) = backPix->info[i].id;

-          if (bordPix)

-             *((CARD32 *) &stuff[1] + pbord_offset) = bordPix->info[i].id;

-          if (cmap)

-             *((CARD32 *) &stuff[1] + cmap_offset) = cmap->info[i].id;

-

-          if (orig_visual != CopyFromParent) 

-            stuff->visualID = PanoramiXTranslateVisualID(i, orig_visual);

-

-          status = ScreenSaverSetAttributes(client);

-       }

-

-       return status;

-    }

-#endif

-

-    return ScreenSaverSetAttributes(client);

-}

-

-static int

-ProcScreenSaverUnsetAttributes (ClientPtr client)

-{

-#ifdef PANORAMIX

-    if(!noPanoramiXExtension) {

-       REQUEST(xScreenSaverUnsetAttributesReq);

-       PanoramiXRes *draw;

-       int rc, i;

-

-       rc = dixLookupResourceByClass((pointer *)&draw, stuff->drawable,

-				     XRC_DRAWABLE, client, DixWriteAccess);

-       if (rc != Success)

-           return (rc == BadValue) ? BadDrawable : rc;

-

-       for(i = PanoramiXNumScreens - 1; i > 0; i--) {

-            stuff->drawable = draw->info[i].id;

-            ScreenSaverUnsetAttributes(client);

-       }

-

-       stuff->drawable = draw->info[0].id;

-    }

-#endif

-

-    return ScreenSaverUnsetAttributes(client);

-}

-

-static int

-ProcScreenSaverSuspend (ClientPtr client)

-{

-    ScreenSaverSuspensionPtr *prev, this;

-

-    REQUEST(xScreenSaverSuspendReq);

-    REQUEST_SIZE_MATCH(xScreenSaverSuspendReq);

-

-    /* Check if this client is suspending the screensaver */

-    for (prev = &suspendingClients; (this = *prev); prev = &this->next)

-	if (this->pClient == client)

-	    break;

-

-    if (this)

-    {

-	if (stuff->suspend == TRUE)

-	   this->count++;

-	else if (--this->count == 0)

-	   FreeResource (this->clientResource, RT_NONE);

-

-	return Success;

-    }

-

-    /* If we get to this point, this client isn't suspending the screensaver */

-    if (stuff->suspend == FALSE)

-	return Success;

-

-    /*

-     * Allocate a suspension record for the client, and stop the screensaver

-     * if it isn't already suspended by another client. We attach a resource ID

-     * to the record, so the screensaver will be reenabled and the record freed

-     * if the client disconnects without reenabling it first.

-     */

-    this = malloc(sizeof (ScreenSaverSuspensionRec));

-

-    if (!this)

-	return BadAlloc;

-

-    this->next           = NULL;

-    this->pClient        = client;

-    this->count          = 1;

-    this->clientResource = FakeClientID (client->index);

-

-    if (!AddResource (this->clientResource, SuspendType, (pointer) this))

-    {

-	free(this);

-	return BadAlloc;

-    }

-

-    *prev = this;

-    if (!screenSaverSuspended)

-    {

-	screenSaverSuspended = TRUE;

-	FreeScreenSaverTimer();

-    }

-

-    return Success;

-}

-

-static int (*NormalVector[]) (ClientPtr /* client */) = {

-    ProcScreenSaverQueryVersion,

-    ProcScreenSaverQueryInfo,

-    ProcScreenSaverSelectInput,

-    ProcScreenSaverSetAttributes,

-    ProcScreenSaverUnsetAttributes,

-    ProcScreenSaverSuspend,

-};

-

-#define NUM_REQUESTS	((sizeof NormalVector) / (sizeof NormalVector[0]))

-

-static int

-ProcScreenSaverDispatch (ClientPtr client)

-{

-    REQUEST(xReq);

-

-    if (stuff->data < NUM_REQUESTS)

-	return (*NormalVector[stuff->data])(client);

-    return BadRequest;

-}

-

-static int

-SProcScreenSaverQueryVersion (ClientPtr client)

-{

-    REQUEST(xScreenSaverQueryVersionReq);

-    int	    n;

-

-    swaps (&stuff->length, n);

-    REQUEST_SIZE_MATCH(xScreenSaverQueryVersionReq);

-    return ProcScreenSaverQueryVersion (client);

-}

-

-static int

-SProcScreenSaverQueryInfo (ClientPtr client)

-{

-    REQUEST(xScreenSaverQueryInfoReq);

-    int	    n;

-

-    swaps (&stuff->length, n);

-    REQUEST_SIZE_MATCH(xScreenSaverQueryInfoReq);

-    swapl (&stuff->drawable, n);

-    return ProcScreenSaverQueryInfo (client);

-}

-

-static int

-SProcScreenSaverSelectInput (ClientPtr client)

-{

-    REQUEST(xScreenSaverSelectInputReq);

-    int	    n;

-

-    swaps (&stuff->length, n);

-    REQUEST_SIZE_MATCH(xScreenSaverSelectInputReq);

-    swapl (&stuff->drawable, n);

-    swapl (&stuff->eventMask, n);

-    return ProcScreenSaverSelectInput (client);

-}

-

-static int

-SProcScreenSaverSetAttributes (ClientPtr client)

-{

-    REQUEST(xScreenSaverSetAttributesReq);

-    int	    n;

-

-    swaps (&stuff->length, n);

-    REQUEST_AT_LEAST_SIZE(xScreenSaverSetAttributesReq);

-    swapl (&stuff->drawable, n);

-    swaps (&stuff->x, n);

-    swaps (&stuff->y, n);

-    swaps (&stuff->width, n);

-    swaps (&stuff->height, n);

-    swaps (&stuff->borderWidth, n);

-    swapl (&stuff->visualID, n);

-    swapl (&stuff->mask, n);

-    SwapRestL(stuff);

-    return ProcScreenSaverSetAttributes (client);

-}

-

-static int

-SProcScreenSaverUnsetAttributes (ClientPtr client)

-{

-    REQUEST(xScreenSaverUnsetAttributesReq);

-    int	    n;

-

-    swaps (&stuff->length, n);

-    REQUEST_SIZE_MATCH(xScreenSaverUnsetAttributesReq);

-    swapl (&stuff->drawable, n);

-    return ProcScreenSaverUnsetAttributes (client);

-}

-

-static int

-SProcScreenSaverSuspend (ClientPtr client)

-{

-    int n;

-    REQUEST(xScreenSaverSuspendReq);

-

-    swaps(&stuff->length, n);

-    REQUEST_SIZE_MATCH(xScreenSaverSuspendReq);

-    swapl(&stuff->suspend, n);

-    return ProcScreenSaverSuspend (client);

-}

-

-static int (*SwappedVector[]) (ClientPtr /* client */) = {

-    SProcScreenSaverQueryVersion,

-    SProcScreenSaverQueryInfo,

-    SProcScreenSaverSelectInput,

-    SProcScreenSaverSetAttributes,

-    SProcScreenSaverUnsetAttributes,

-    SProcScreenSaverSuspend,

-};

-

-static int

-SProcScreenSaverDispatch (ClientPtr client)

-{

-    REQUEST(xReq);

-

-    if (stuff->data < NUM_REQUESTS)

-	return (*SwappedVector[stuff->data])(client);

-    return BadRequest;

-}

-

-void

-ScreenSaverExtensionInit(INITARGS)

-{

-    ExtensionEntry *extEntry;

-    int		    i;

-    ScreenPtr	    pScreen;

-

-    if (!dixRegisterPrivateKey(&ScreenPrivateKeyRec, PRIVATE_SCREEN, 0))

-	return;

-

-    AttrType = CreateNewResourceType(ScreenSaverFreeAttr, "SaverAttr");

-    SaverEventType = CreateNewResourceType(ScreenSaverFreeEvents,

-					   "SaverEvent");

-    SuspendType = CreateNewResourceType(ScreenSaverFreeSuspend,

-					"SaverSuspend");

-

-    for (i = 0; i < screenInfo.numScreens; i++)

-    {

-	pScreen = screenInfo.screens[i];

-	SetScreenPrivate (pScreen, NULL);

-    }

-    if (AttrType && SaverEventType && SuspendType &&

-	(extEntry = AddExtension(ScreenSaverName, ScreenSaverNumberEvents, 0,

-				 ProcScreenSaverDispatch, SProcScreenSaverDispatch,

-				 NULL, StandardMinorOpcode)))

-    {

-	ScreenSaverEventBase = extEntry->eventBase;

-	EventSwapVector[ScreenSaverEventBase] = (EventSwapPtr) SScreenSaverNotifyEvent;

-    }

-}

+/*
+ *
+Copyright (c) 1992  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:  Keith Packard, MIT X Consortium
+ */
+
+
+#ifdef HAVE_DIX_CONFIG_H
+#include <dix-config.h>
+#else
+#define SCREENSAVER
+#endif
+
+#ifdef CreateWindow
+#undef CreateWindow
+#endif
+
+#include <X11/X.h>
+#include <X11/Xproto.h>
+#include "misc.h"
+#include "os.h"
+#include "windowstr.h"
+#include "scrnintstr.h"
+#include "pixmapstr.h"
+#include "extnsionst.h"
+#include "dixstruct.h"
+#include "resource.h"
+#include "opaque.h"
+#include <X11/extensions/saverproto.h>
+#include "gcstruct.h"
+#include "cursorstr.h"
+#include "colormapst.h"
+#include "xace.h"
+#ifdef PANORAMIX
+#include "panoramiX.h"
+#include "panoramiXsrv.h"
+#endif
+#ifdef DPMSExtension
+#include <X11/extensions/dpmsconst.h>
+#endif
+#include "protocol-versions.h"
+
+#include <stdio.h>
+
+#include "modinit.h"
+
+static int ScreenSaverEventBase = 0;
+
+
+static Bool ScreenSaverHandle (
+	ScreenPtr /* pScreen */,
+	int /* xstate */,
+	Bool /* force */
+	);
+
+static Bool
+CreateSaverWindow (
+	ScreenPtr /* pScreen */
+	);
+
+static Bool
+DestroySaverWindow (
+	ScreenPtr /* pScreen */
+	);
+
+static void
+UninstallSaverColormap (
+	ScreenPtr /* pScreen */
+	);
+
+static void
+CheckScreenPrivate (
+	ScreenPtr /* pScreen */
+	);
+
+static void SScreenSaverNotifyEvent (
+	xScreenSaverNotifyEvent * /* from */,
+	xScreenSaverNotifyEvent * /* to */
+	);
+
+static RESTYPE SuspendType;  /* resource type for suspension records */
+
+typedef struct _ScreenSaverSuspension *ScreenSaverSuspensionPtr;
+
+/* List of clients that are suspending the screensaver. */
+static ScreenSaverSuspensionPtr suspendingClients = NULL;
+
+/*
+ * clientResource is a resource ID that's added when the record is
+ * allocated, so the record is freed and the screensaver resumed when
+ * the client disconnects. count is the number of times the client has
+ * requested the screensaver be suspended.
+ */
+typedef struct _ScreenSaverSuspension
+{
+    ScreenSaverSuspensionPtr  next;
+    ClientPtr                 pClient;
+    XID                       clientResource;
+    int                       count;
+} ScreenSaverSuspensionRec;
+
+static int ScreenSaverFreeSuspend(
+    pointer /*value */,
+    XID /* id */
+);
+
+/*
+ * each screen has a list of clients requesting
+ * ScreenSaverNotify events.  Each client has a resource
+ * for each screen it selects ScreenSaverNotify input for,
+ * this resource is used to delete the ScreenSaverNotifyRec
+ * entry from the per-screen queue.
+ */
+
+static RESTYPE SaverEventType;   /* resource type for event masks */
+
+typedef struct _ScreenSaverEvent *ScreenSaverEventPtr;
+
+typedef struct _ScreenSaverEvent {
+    ScreenSaverEventPtr	next;
+    ClientPtr		client;
+    ScreenPtr		screen;
+    XID			resource;
+    CARD32		mask;
+} ScreenSaverEventRec;
+
+static int ScreenSaverFreeEvents(
+    pointer /* value */,
+    XID /* id */
+);
+
+static Bool setEventMask (
+    ScreenPtr /* pScreen */,
+    ClientPtr /* client */,
+    unsigned long /* mask */
+);
+
+static unsigned long getEventMask (
+    ScreenPtr /* pScreen */,
+    ClientPtr /* client */
+);
+
+/*
+ * when a client sets the screen saver attributes, a resource is
+ * kept to be freed when the client exits
+ */
+
+static RESTYPE AttrType;    /* resource type for attributes */
+
+typedef struct _ScreenSaverAttr {
+    ScreenPtr	    screen;
+    ClientPtr	    client;
+    XID		    resource;
+    short	    x, y;
+    unsigned short  width, height, borderWidth;
+    unsigned char   class;
+    unsigned char   depth;
+    VisualID	    visual;
+    CursorPtr	    pCursor;
+    PixmapPtr	    pBackgroundPixmap;
+    PixmapPtr	    pBorderPixmap;
+    Colormap	    colormap;
+    unsigned long   mask;		/* no pixmaps or cursors */
+    unsigned long   *values;
+} ScreenSaverAttrRec, *ScreenSaverAttrPtr;
+
+static int ScreenSaverFreeAttr (
+    pointer /* value */,
+    XID /* id */
+);
+
+static void FreeAttrs (
+    ScreenSaverAttrPtr	/* pAttr */
+);
+
+static void FreeScreenAttr (
+    ScreenSaverAttrPtr	/* pAttr */
+);
+
+static void
+SendScreenSaverNotify (
+    ScreenPtr /* pScreen */,
+    int /* state */,
+    Bool /* forced */
+);
+
+typedef struct _ScreenSaverScreenPrivate {
+    ScreenSaverEventPtr	    events;
+    ScreenSaverAttrPtr	    attr;
+    Bool		    hasWindow;
+    Colormap		    installedMap;
+} ScreenSaverScreenPrivateRec, *ScreenSaverScreenPrivatePtr;
+
+static ScreenSaverScreenPrivatePtr
+MakeScreenPrivate (
+	ScreenPtr /* pScreen */
+	);
+
+static DevPrivateKeyRec ScreenPrivateKeyRec;
+#define ScreenPrivateKey (&ScreenPrivateKeyRec)
+
+#define GetScreenPrivate(s) ((ScreenSaverScreenPrivatePtr) \
+    dixLookupPrivate(&(s)->devPrivates, ScreenPrivateKey))
+#define SetScreenPrivate(s,v) \
+    dixSetPrivate(&(s)->devPrivates, ScreenPrivateKey, v);
+#define SetupScreen(s)	ScreenSaverScreenPrivatePtr pPriv = (s ? GetScreenPrivate(s) : NULL)
+
+#define New(t)	(malloc(sizeof (t)))
+
+static void
+CheckScreenPrivate (ScreenPtr pScreen)
+{
+    SetupScreen (pScreen);
+
+    if (!pPriv)
+	return;
+    if (!pPriv->attr && !pPriv->events &&
+	!pPriv->hasWindow && pPriv->installedMap == None)
+    {
+	free(pPriv);
+	SetScreenPrivate (pScreen, NULL);
+	pScreen->screensaver.ExternalScreenSaver = NULL;
+    }
+}
+
+static ScreenSaverScreenPrivatePtr
+MakeScreenPrivate (ScreenPtr pScreen)
+{
+    SetupScreen (pScreen);
+
+    if (pPriv)
+	return pPriv;
+    pPriv = New (ScreenSaverScreenPrivateRec);
+    if (!pPriv)
+	return 0;
+    pPriv->events = 0;
+    pPriv->attr = 0;
+    pPriv->hasWindow = FALSE;
+    pPriv->installedMap = None;
+    SetScreenPrivate (pScreen, pPriv);
+    pScreen->screensaver.ExternalScreenSaver = ScreenSaverHandle;
+    return pPriv;
+}
+
+static unsigned long
+getEventMask (ScreenPtr pScreen, ClientPtr client)
+{
+    SetupScreen(pScreen);
+    ScreenSaverEventPtr	pEv;
+
+    if (!pPriv)
+	return 0;
+    for (pEv = pPriv->events; pEv; pEv = pEv->next)
+	if (pEv->client == client)
+	    return pEv->mask;
+    return 0;
+}
+
+static Bool
+setEventMask (ScreenPtr pScreen, ClientPtr client, unsigned long mask)
+{
+    SetupScreen(pScreen);
+    ScreenSaverEventPtr	pEv, *pPrev;
+
+    if (getEventMask (pScreen, client) == mask)
+	return TRUE;
+    if (!pPriv)
+    {
+	pPriv = MakeScreenPrivate (pScreen);
+	if (!pPriv)
+	    return FALSE;
+    }
+    for (pPrev = &pPriv->events; (pEv = *pPrev) != 0; pPrev = &pEv->next)
+	if (pEv->client == client)
+	    break;
+    if (mask == 0)
+    {
+	FreeResource (pEv->resource, SaverEventType);
+	*pPrev = pEv->next;
+	free(pEv);
+	CheckScreenPrivate (pScreen);
+    }
+    else
+    {
+    	if (!pEv) 
+    	{
+	    pEv = New (ScreenSaverEventRec);
+	    if (!pEv) 
+	    {
+		CheckScreenPrivate (pScreen);
+	    	return FALSE;
+	    }
+    	    *pPrev = pEv;
+    	    pEv->next = NULL;
+    	    pEv->client = client;
+    	    pEv->screen = pScreen;
+    	    pEv->resource = FakeClientID (client->index);
+	    if (!AddResource (pEv->resource, SaverEventType, (pointer) pEv))
+		return FALSE;
+    	}
+	pEv->mask = mask;
+    }
+    return TRUE;
+}
+
+static void
+FreeAttrs (ScreenSaverAttrPtr pAttr)
+{
+    PixmapPtr	    pPixmap;
+    CursorPtr	    pCursor;
+
+    if ((pPixmap = pAttr->pBackgroundPixmap) != 0)
+	(*pPixmap->drawable.pScreen->DestroyPixmap)(pPixmap);
+    if ((pPixmap = pAttr->pBorderPixmap) != 0)
+	(*pPixmap->drawable.pScreen->DestroyPixmap)(pPixmap);
+    if ((pCursor = pAttr->pCursor) != 0)
+	FreeCursor (pCursor, (Cursor) 0);
+}
+
+static void
+FreeScreenAttr (ScreenSaverAttrPtr pAttr)
+{
+    FreeAttrs (pAttr);
+    free(pAttr->values);
+    free(pAttr);
+}
+
+static int
+ScreenSaverFreeEvents (pointer value, XID id)
+{
+    ScreenSaverEventPtr	pOld = (ScreenSaverEventPtr)value;
+    ScreenPtr pScreen = pOld->screen;
+    SetupScreen (pScreen);
+    ScreenSaverEventPtr	pEv, *pPrev;
+
+    if (!pPriv)
+	return TRUE;
+    for (pPrev = &pPriv->events; (pEv = *pPrev) != 0; pPrev = &pEv->next)
+	if (pEv == pOld)
+	    break;
+    if (!pEv)
+	return TRUE;
+    *pPrev = pEv->next;
+    free(pEv);
+    CheckScreenPrivate (pScreen);
+    return TRUE;
+}
+
+static int
+ScreenSaverFreeAttr (pointer value, XID id)
+{
+    ScreenSaverAttrPtr	pOldAttr = (ScreenSaverAttrPtr)value;
+    ScreenPtr	pScreen = pOldAttr->screen;
+    SetupScreen (pScreen);
+
+    if (!pPriv)
+	return TRUE;
+    if (pPriv->attr != pOldAttr)
+	return TRUE;
+    FreeScreenAttr (pOldAttr);
+    pPriv->attr = NULL;
+    if (pPriv->hasWindow)
+    {
+	dixSaveScreens (serverClient, SCREEN_SAVER_FORCER, ScreenSaverReset);
+	dixSaveScreens (serverClient, SCREEN_SAVER_FORCER, ScreenSaverActive);
+    }
+    CheckScreenPrivate (pScreen);
+    return TRUE;
+}
+
+static int
+ScreenSaverFreeSuspend (pointer value, XID id)
+{
+    ScreenSaverSuspensionPtr data = (ScreenSaverSuspensionPtr) value;
+    ScreenSaverSuspensionPtr *prev, this;
+
+    /* Unlink and free the suspension record for the client */
+    for (prev = &suspendingClients; (this = *prev); prev = &this->next)
+    {
+	if (this == data)
+	{
+	    *prev = this->next;
+	    free(this);
+	    break;
+	}
+    }
+
+    /* Reenable the screensaver if this was the last client suspending it. */
+    if (screenSaverSuspended && suspendingClients == NULL)
+    {
+	screenSaverSuspended = FALSE;
+
+	/* The screensaver could be active, since suspending it (by design)
+	   doesn't prevent it from being forceably activated */
+#ifdef DPMSExtension
+	if (screenIsSaved != SCREEN_SAVER_ON && DPMSPowerLevel == DPMSModeOn)
+#else
+	if (screenIsSaved != SCREEN_SAVER_ON)
+#endif
+	{
+	    UpdateCurrentTimeIf();
+	    lastDeviceEventTime = currentTime;
+	    SetScreenSaverTimer();
+	}
+    }
+
+    return Success;
+}
+
+static void
+SendScreenSaverNotify (ScreenPtr pScreen, int state, Bool forced)
+{
+    ScreenSaverScreenPrivatePtr	pPriv;
+    ScreenSaverEventPtr		pEv;
+    unsigned long		mask;
+    xScreenSaverNotifyEvent	ev;
+    int				kind;
+
+    UpdateCurrentTimeIf ();
+    mask = ScreenSaverNotifyMask;
+    if (state == ScreenSaverCycle)
+	mask = ScreenSaverCycleMask;
+    pScreen = screenInfo.screens[pScreen->myNum];
+    pPriv = GetScreenPrivate(pScreen);
+    if (!pPriv)
+	return;
+    if (pPriv->attr)
+	kind = ScreenSaverExternal;
+    else if (ScreenSaverBlanking != DontPreferBlanking)
+	kind = ScreenSaverBlanked;
+    else
+	kind = ScreenSaverInternal;
+    for (pEv = pPriv->events; pEv; pEv = pEv->next)
+    {
+	if (!(pEv->mask & mask))
+	    continue;
+	ev.type = ScreenSaverNotify + ScreenSaverEventBase;
+	ev.state = state;
+	ev.timestamp = currentTime.milliseconds;
+	ev.root = pScreen->root->drawable.id;
+	ev.window = pScreen->screensaver.wid;
+	ev.kind = kind;
+	ev.forced = forced;
+	WriteEventsToClient (pEv->client, 1, (xEvent *) &ev);
+    }
+}
+
+static void
+SScreenSaverNotifyEvent (xScreenSaverNotifyEvent *from,
+                         xScreenSaverNotifyEvent *to)
+{
+    to->type = from->type;
+    to->state = from->state;
+    cpswaps (from->sequenceNumber, to->sequenceNumber);
+    cpswapl (from->timestamp, to->timestamp);    
+    cpswapl (from->root, to->root);    
+    cpswapl (from->window, to->window);    
+    to->kind = from->kind;
+    to->forced = from->forced;
+}
+
+static void
+UninstallSaverColormap (ScreenPtr pScreen)
+{
+    SetupScreen(pScreen);
+    ColormapPtr			pCmap;
+    int rc;
+
+    if (pPriv && pPriv->installedMap != None)
+    {
+	rc = dixLookupResourceByType((pointer *)&pCmap, pPriv->installedMap,
+				     RT_COLORMAP, serverClient,
+				     DixUninstallAccess);
+	if (rc == Success)
+	    (*pCmap->pScreen->UninstallColormap) (pCmap);
+	pPriv->installedMap = None;
+	CheckScreenPrivate (pScreen);
+    }
+}
+
+static Bool
+CreateSaverWindow (ScreenPtr pScreen)
+{
+    SetupScreen (pScreen);
+    ScreenSaverStuffPtr		pSaver;
+    ScreenSaverAttrPtr		pAttr;
+    WindowPtr			pWin;
+    int				result;
+    unsigned long		mask;
+    Colormap			*installedMaps;
+    int				numInstalled;
+    int				i;
+    Colormap			wantMap;
+    ColormapPtr			pCmap;
+
+    pSaver = &pScreen->screensaver;
+    if (pSaver->pWindow)
+    {
+	pSaver->pWindow = NullWindow;
+	FreeResource (pSaver->wid, RT_NONE);
+	if (pPriv)
+	{
+	    UninstallSaverColormap (pScreen);
+	    pPriv->hasWindow = FALSE;
+	    CheckScreenPrivate (pScreen);
+	}
+    }
+
+    if (!pPriv || !(pAttr = pPriv->attr))
+	return FALSE;
+
+    pPriv->installedMap = None;
+
+    if (GrabInProgress && GrabInProgress != pAttr->client->index)
+	return FALSE;
+
+    pWin = CreateWindow (pSaver->wid, pScreen->root,
+			 pAttr->x, pAttr->y, pAttr->width, pAttr->height,
+			 pAttr->borderWidth, pAttr->class, 
+			 pAttr->mask, (XID *)pAttr->values, 
+			 pAttr->depth, serverClient, pAttr->visual, 
+			 &result);
+    if (!pWin)
+	return FALSE;
+
+    if (!AddResource(pWin->drawable.id, RT_WINDOW, pWin))
+	return FALSE;
+
+    mask = 0;
+    if (pAttr->pBackgroundPixmap)
+    {
+	pWin->backgroundState = BackgroundPixmap;
+	pWin->background.pixmap = pAttr->pBackgroundPixmap;
+	pAttr->pBackgroundPixmap->refcnt++;
+	mask |= CWBackPixmap;
+    }
+    if (pAttr->pBorderPixmap)
+    {
+	pWin->borderIsPixel = FALSE;
+	pWin->border.pixmap = pAttr->pBorderPixmap;
+	pAttr->pBorderPixmap->refcnt++;
+	mask |= CWBorderPixmap;
+    }
+    if (pAttr->pCursor)
+    {
+	if (!pWin->optional)
+	    if (!MakeWindowOptional (pWin))
+	    {
+    	    	FreeResource (pWin->drawable.id, RT_NONE);
+    	    	return FALSE;
+	    }
+	pAttr->pCursor->refcnt++;
+	if (pWin->optional->cursor)
+	    FreeCursor (pWin->optional->cursor, (Cursor)0);
+	pWin->optional->cursor = pAttr->pCursor;
+	pWin->cursorIsNone = FALSE;
+	CheckWindowOptionalNeed (pWin);
+	mask |= CWCursor;
+    }
+    if (mask)
+	(*pScreen->ChangeWindowAttributes) (pWin, mask);
+
+    if (pAttr->colormap != None)
+	(void) ChangeWindowAttributes (pWin, CWColormap, &pAttr->colormap,
+				       serverClient);
+
+    MapWindow (pWin, serverClient);
+
+    pPriv->hasWindow = TRUE;
+    pSaver->pWindow = pWin;
+
+    /* check and install our own colormap if it isn't installed now */
+    wantMap = wColormap (pWin);
+    if (wantMap == None)
+	return TRUE;
+    installedMaps = malloc(pScreen->maxInstalledCmaps * sizeof (Colormap));
+    numInstalled = (*pWin->drawable.pScreen->ListInstalledColormaps)
+						    (pScreen, installedMaps);
+    for (i = 0; i < numInstalled; i++) 
+	if (installedMaps[i] == wantMap)
+	    break;
+
+    free((char *) installedMaps);
+
+    if (i < numInstalled)
+	return TRUE;
+
+    result = dixLookupResourceByType((pointer *)&pCmap, wantMap, RT_COLORMAP,
+				     serverClient, DixInstallAccess);
+    if (result != Success)
+	return TRUE;
+
+    pPriv->installedMap = wantMap;
+
+    (*pCmap->pScreen->InstallColormap) (pCmap);
+
+    return TRUE;
+}
+
+static Bool
+DestroySaverWindow (ScreenPtr pScreen)
+{
+    SetupScreen(pScreen);
+    ScreenSaverStuffPtr		pSaver;
+
+    if (!pPriv || !pPriv->hasWindow)
+	return FALSE;
+
+    pSaver = &pScreen->screensaver;
+    if (pSaver->pWindow)
+    {
+	pSaver->pWindow = NullWindow;
+	FreeResource (pSaver->wid, RT_NONE);
+    }
+    pPriv->hasWindow = FALSE;
+    CheckScreenPrivate (pScreen);
+    UninstallSaverColormap (pScreen);
+    return TRUE;
+}
+
+static Bool
+ScreenSaverHandle (ScreenPtr pScreen, int xstate, Bool force)
+{
+    int				state = 0;
+    Bool			ret = FALSE;
+    ScreenSaverScreenPrivatePtr	pPriv;
+
+    switch (xstate)
+    {
+    case SCREEN_SAVER_ON:	
+	state = ScreenSaverOn;
+	ret = CreateSaverWindow (pScreen);
+	break;
+    case SCREEN_SAVER_OFF:	
+	state = ScreenSaverOff;
+	ret = DestroySaverWindow (pScreen);
+	break;
+    case SCREEN_SAVER_CYCLE:	
+	state = ScreenSaverCycle;
+	pPriv = GetScreenPrivate (pScreen);
+	if (pPriv && pPriv->hasWindow)
+	    ret = TRUE;
+	
+    }
+#ifdef PANORAMIX
+    if(noPanoramiXExtension || !pScreen->myNum)
+#endif
+       SendScreenSaverNotify (pScreen, state, force);
+    return ret;
+}
+
+static int
+ProcScreenSaverQueryVersion (ClientPtr client)
+{
+    xScreenSaverQueryVersionReply	rep;
+    REQUEST_SIZE_MATCH (xScreenSaverQueryVersionReq);
+    rep.type = X_Reply;
+    rep.length = 0;
+    rep.sequenceNumber = client->sequence;
+    rep.majorVersion = SERVER_SAVER_MAJOR_VERSION;
+    rep.minorVersion = SERVER_SAVER_MINOR_VERSION;
+    if (client->swapped) {
+	swaps(&rep.sequenceNumber);
+	swapl(&rep.length);
+    }
+    WriteToClient(client, sizeof (xScreenSaverQueryVersionReply), (char *)&rep);
+    return Success;
+}
+
+static int
+ProcScreenSaverQueryInfo (ClientPtr client)
+{
+    REQUEST(xScreenSaverQueryInfoReq);
+    xScreenSaverQueryInfoReply	rep;
+    int		rc;
+    ScreenSaverStuffPtr		pSaver;
+    DrawablePtr			pDraw;
+    CARD32			lastInput;
+    ScreenSaverScreenPrivatePtr	pPriv;
+
+    REQUEST_SIZE_MATCH (xScreenSaverQueryInfoReq);
+    rc = dixLookupDrawable(&pDraw, stuff->drawable, client, 0,
+			   DixGetAttrAccess);
+    if (rc != Success)
+	return rc;
+    rc = XaceHook(XACE_SCREENSAVER_ACCESS, client, pDraw->pScreen,
+		  DixGetAttrAccess);
+    if (rc != Success)
+	return rc;
+
+    pSaver = &pDraw->pScreen->screensaver;
+    pPriv = GetScreenPrivate (pDraw->pScreen);
+
+    UpdateCurrentTime ();
+    lastInput = GetTimeInMillis() - lastDeviceEventTime.milliseconds;
+
+    rep.type = X_Reply;
+    rep.length = 0;
+    rep.sequenceNumber = client->sequence;
+    rep.window = pSaver->wid;
+    if (screenIsSaved != SCREEN_SAVER_OFF)
+    {
+	rep.state = ScreenSaverOn;
+	if (ScreenSaverTime)
+	    rep.tilOrSince = lastInput - ScreenSaverTime;
+	else
+	    rep.tilOrSince = 0;
+    }
+    else
+    {
+	if (ScreenSaverTime)
+	{
+	    rep.state = ScreenSaverOff;
+	    if (ScreenSaverTime < lastInput)
+		rep.tilOrSince = 0;
+	    else
+		rep.tilOrSince = ScreenSaverTime - lastInput;
+	}
+	else
+	{
+	    rep.state = ScreenSaverDisabled;
+	    rep.tilOrSince = 0;
+	}
+    }
+    rep.idle = lastInput;
+    rep.eventMask = getEventMask (pDraw->pScreen, client);
+    if (pPriv && pPriv->attr)
+	rep.kind = ScreenSaverExternal;
+    else if (ScreenSaverBlanking != DontPreferBlanking)
+	rep.kind = ScreenSaverBlanked;
+    else
+	rep.kind = ScreenSaverInternal;
+    if (client->swapped)
+    {
+	swaps(&rep.sequenceNumber);
+	swapl(&rep.length);
+	swapl(&rep.window);
+	swapl(&rep.tilOrSince);
+	swapl(&rep.idle);
+	swapl(&rep.eventMask);
+    }
+    WriteToClient(client, sizeof (xScreenSaverQueryInfoReply), (char *)&rep);
+    return Success;
+}
+
+static int
+ProcScreenSaverSelectInput (ClientPtr client)
+{
+    REQUEST(xScreenSaverSelectInputReq);
+    DrawablePtr			pDraw;
+    int				rc;
+
+    REQUEST_SIZE_MATCH (xScreenSaverSelectInputReq);
+    rc = dixLookupDrawable (&pDraw, stuff->drawable, client, 0,
+			    DixGetAttrAccess);
+    if (rc != Success)
+	return rc;
+
+    rc = XaceHook(XACE_SCREENSAVER_ACCESS, client, pDraw->pScreen,
+		  DixSetAttrAccess);
+    if (rc != Success)
+	return rc;
+
+    if (!setEventMask (pDraw->pScreen, client, stuff->eventMask))
+	return BadAlloc;
+    return Success;
+}
+
+static int
+ScreenSaverSetAttributes (ClientPtr client)
+{
+    REQUEST(xScreenSaverSetAttributesReq);
+    DrawablePtr			pDraw;
+    WindowPtr			pParent;
+    ScreenPtr			pScreen;
+    ScreenSaverScreenPrivatePtr pPriv = 0;
+    ScreenSaverAttrPtr		pAttr = 0;
+    int				ret, len, class, bw, depth;
+    unsigned long		visual;
+    int				idepth, ivisual;
+    Bool			fOK;
+    DepthPtr			pDepth;
+    WindowOptPtr		ancwopt;
+    unsigned int		*pVlist;
+    unsigned long		*values = 0;
+    unsigned long		tmask, imask;
+    unsigned long		val;
+    Pixmap			pixID;
+    PixmapPtr			pPixmap;
+    Cursor			cursorID;
+    CursorPtr			pCursor;
+    Colormap			cmap;
+    ColormapPtr			pCmap;
+
+    REQUEST_AT_LEAST_SIZE (xScreenSaverSetAttributesReq);
+    ret = dixLookupDrawable(&pDraw, stuff->drawable, client, 0,
+			    DixGetAttrAccess);
+    if (ret != Success)
+	return ret;
+    pScreen = pDraw->pScreen;
+    pParent = pScreen->root;
+
+    ret = XaceHook(XACE_SCREENSAVER_ACCESS, client, pScreen, DixSetAttrAccess);
+    if (ret != Success)
+	return ret;
+
+    len = stuff->length -  bytes_to_int32(sizeof(xScreenSaverSetAttributesReq));
+    if (Ones(stuff->mask) != len)
+        return BadLength;
+    if (!stuff->width || !stuff->height)
+    {
+	client->errorValue = 0;
+        return BadValue;
+    }
+    switch (class = stuff->c_class) 
+    {
+    case CopyFromParent:
+    case InputOnly:
+    case InputOutput:
+	break;
+    default:
+	client->errorValue = class;
+	return BadValue;
+    }
+    bw = stuff->borderWidth;
+    depth = stuff->depth;
+    visual = stuff->visualID;
+
+    /* copied directly from CreateWindow */
+
+    if (class == CopyFromParent)
+	class = pParent->drawable.class;
+
+    if ((class != InputOutput) && (class != InputOnly))
+    {
+	client->errorValue = class;
+	return BadValue;
+    }
+
+    if ((class != InputOnly) && (pParent->drawable.class == InputOnly))
+        return BadMatch;
+
+    if ((class == InputOnly) && ((bw != 0) || (depth != 0)))
+        return BadMatch;
+
+    if ((class == InputOutput) && (depth == 0))
+        depth = pParent->drawable.depth;
+    ancwopt = pParent->optional;
+    if (!ancwopt)
+	ancwopt = FindWindowWithOptional(pParent)->optional;
+    if (visual == CopyFromParent)
+	visual = ancwopt->visual;
+
+    /* Find out if the depth and visual are acceptable for this Screen */
+    if ((visual != ancwopt->visual) || (depth != pParent->drawable.depth))
+    {
+	fOK = FALSE;
+	for(idepth = 0; idepth < pScreen->numDepths; idepth++)
+	{
+	    pDepth = (DepthPtr) &pScreen->allowedDepths[idepth];
+	    if ((depth == pDepth->depth) || (depth == 0))
+	    {
+		for (ivisual = 0; ivisual < pDepth->numVids; ivisual++)
+		{
+		    if (visual == pDepth->vids[ivisual])
+		    {
+			fOK = TRUE;
+			break;
+		    }
+		}
+	    }
+	}
+	if (fOK == FALSE)
+	    return BadMatch;
+    }
+
+    if (((stuff->mask & (CWBorderPixmap | CWBorderPixel)) == 0) &&
+	(class != InputOnly) &&
+	(depth != pParent->drawable.depth))
+    {
+        return BadMatch;
+    }
+
+    if (((stuff->mask & CWColormap) == 0) &&
+	(class != InputOnly) &&
+	((visual != ancwopt->visual) || (ancwopt->colormap == None)))
+    {
+	return BadMatch;
+    }
+
+    /* end of errors from CreateWindow */
+
+    pPriv = GetScreenPrivate (pScreen);
+    if (pPriv && pPriv->attr)
+    {
+	if (pPriv->attr->client != client)
+	    return BadAccess;
+    }
+    if (!pPriv)
+    {
+	pPriv = MakeScreenPrivate (pScreen);
+	if (!pPriv)
+	    return FALSE;
+    }
+    pAttr = New (ScreenSaverAttrRec);
+    if (!pAttr)
+    {
+	ret = BadAlloc;
+	goto bail;
+    }
+    /* over allocate for override redirect */
+    values = malloc((len + 1) * sizeof (unsigned long));
+    if (!values)
+    {
+	ret = BadAlloc;
+	goto bail;
+    }
+    pAttr->screen = pScreen;
+    pAttr->client = client;
+    pAttr->x = stuff->x;
+    pAttr->y = stuff->y;
+    pAttr->width = stuff->width;
+    pAttr->height = stuff->height;
+    pAttr->borderWidth = stuff->borderWidth;
+    pAttr->class = stuff->c_class;
+    pAttr->depth = depth;
+    pAttr->visual = visual;
+    pAttr->colormap = None;
+    pAttr->pCursor = NullCursor;
+    pAttr->pBackgroundPixmap = NullPixmap;
+    pAttr->pBorderPixmap = NullPixmap;
+    pAttr->values = values;
+    /*
+     * go through the mask, checking the values,
+     * looking up pixmaps and cursors and hold a reference
+     * to them.
+     */
+    pAttr->mask = tmask = stuff->mask | CWOverrideRedirect;
+    pVlist = (unsigned int *) (stuff + 1);
+    while (tmask) {
+	imask = lowbit (tmask);
+	tmask &= ~imask;
+	switch (imask)
+        {
+	case CWBackPixmap:
+	    pixID = (Pixmap )*pVlist;
+	    if (pixID == None)
+	    {
+		*values++ = None;
+	    }
+	    else if (pixID == ParentRelative)
+	    {
+		if (depth != pParent->drawable.depth)
+		{
+		    ret = BadMatch;
+		    goto PatchUp;
+		}
+		*values++ = ParentRelative;
+	    }
+            else
+	    {	
+		ret = dixLookupResourceByType((pointer *)&pPixmap, pixID, RT_PIXMAP,
+					client, DixReadAccess);
+		if (ret == Success)
+		{
+                    if  ((pPixmap->drawable.depth != depth) ||
+			 (pPixmap->drawable.pScreen != pScreen))
+		    {
+                        ret = BadMatch;
+			goto PatchUp;
+		    }
+		    pAttr->pBackgroundPixmap = pPixmap;
+		    pPixmap->refcnt++;
+		    pAttr->mask &= ~CWBackPixmap;
+		}
+	        else
+		{
+		    client->errorValue = pixID;
+		    goto PatchUp;
+		}
+	    }
+	    break;
+	case CWBackPixel:
+	    *values++ = (CARD32) *pVlist;
+	    break;
+	case CWBorderPixmap:
+	    pixID = (Pixmap ) *pVlist;
+	    if (pixID == CopyFromParent)
+	    {
+		if (depth != pParent->drawable.depth)
+		{
+		    ret = BadMatch;
+		    goto PatchUp;
+		}
+		*values++ = CopyFromParent;
+	    }
+	    else
+	    {	
+		ret = dixLookupResourceByType((pointer *)&pPixmap, pixID, RT_PIXMAP,
+					client, DixReadAccess);
+		if (ret == Success)
+		{
+                    if  ((pPixmap->drawable.depth != depth) ||
+			 (pPixmap->drawable.pScreen != pScreen))
+		    {
+			ret = BadMatch;
+			goto PatchUp;
+		    }
+		    pAttr->pBorderPixmap = pPixmap;
+		    pPixmap->refcnt++;
+		    pAttr->mask &= ~CWBorderPixmap;
+		}
+    	        else
+		{
+		    client->errorValue = pixID;
+		    goto PatchUp;
+		}
+	    }
+	    break;
+	case CWBorderPixel:
+            *values++ = (CARD32) *pVlist;
+            break;
+	case CWBitGravity:
+	    val = (CARD8 )*pVlist;
+	    if (val > StaticGravity)
+	    {
+		ret = BadValue;
+		client->errorValue = val;
+		goto PatchUp;
+	    }
+	    *values++ = val;
+	    break;
+	case CWWinGravity:
+	    val = (CARD8 )*pVlist;
+	    if (val > StaticGravity)
+	    {
+		ret = BadValue;
+		client->errorValue = val;
+		goto PatchUp;
+	    }
+	    *values++ = val;
+	    break;
+	case CWBackingStore:
+	    val = (CARD8 )*pVlist;
+	    if ((val != NotUseful) && (val != WhenMapped) && (val != Always))
+	    {
+		ret = BadValue;
+		client->errorValue = val;
+		goto PatchUp;
+	    }
+	    *values++ = val;
+	    break;
+	case CWBackingPlanes:
+	    *values++ = (CARD32) *pVlist;
+	    break;
+	case CWBackingPixel:
+	    *values++ = (CARD32) *pVlist;
+	    break;
+	case CWSaveUnder:
+	    val = (BOOL) *pVlist;
+	    if ((val != xTrue) && (val != xFalse))
+	    {
+		ret = BadValue;
+		client->errorValue = val;
+		goto PatchUp;
+	    }
+	    *values++ = val;
+	    break;
+	case CWEventMask:
+	    *values++ = (CARD32) *pVlist;
+	    break;
+	case CWDontPropagate:
+	    *values++ = (CARD32) *pVlist;
+	    break;
+	case CWOverrideRedirect:
+	    if (!(stuff->mask & CWOverrideRedirect))
+		pVlist--;
+	    else
+	    {
+	    	val = (BOOL ) *pVlist;
+	    	if ((val != xTrue) && (val != xFalse))
+	    	{
+		    ret = BadValue;
+		    client->errorValue = val;
+		    goto PatchUp;
+	    	}
+	    }
+	    *values++ = xTrue;
+	    break;
+	case CWColormap:
+	    cmap = (Colormap) *pVlist;
+	    ret = dixLookupResourceByType((pointer *)&pCmap, cmap, RT_COLORMAP,
+				    client, DixUseAccess);
+	    if (ret != Success)
+	    {
+		client->errorValue = cmap;
+		goto PatchUp;
+	    }
+	    if (pCmap->pVisual->vid != visual || pCmap->pScreen != pScreen)
+	    {
+		ret = BadMatch;
+		goto PatchUp;
+	    }
+	    pAttr->colormap = cmap;
+	    pAttr->mask &= ~CWColormap;
+	    break;
+	case CWCursor:
+	    cursorID = (Cursor ) *pVlist;
+	    if ( cursorID == None)
+	    {
+		*values++ = None;
+	    }
+	    else
+	    {
+		ret = dixLookupResourceByType((pointer *)&pCursor, cursorID,
+					RT_CURSOR, client, DixUseAccess);
+	    	if (ret != Success)
+	    	{
+		    client->errorValue = cursorID;
+		    goto PatchUp;
+	    	}
+		pCursor->refcnt++;
+		pAttr->pCursor = pCursor;
+		pAttr->mask &= ~CWCursor;
+	    }
+	    break;
+     	 default:
+	    ret = BadValue;
+	    client->errorValue = stuff->mask;
+	    goto PatchUp;
+	}
+	pVlist++;
+    }
+    if (pPriv->attr)
+	FreeScreenAttr (pPriv->attr);
+    pPriv->attr = pAttr;
+    pAttr->resource = FakeClientID (client->index);
+    if (!AddResource (pAttr->resource, AttrType, (pointer) pAttr))
+	return BadAlloc;
+    return Success;
+PatchUp:
+    FreeAttrs (pAttr);
+bail:
+    CheckScreenPrivate (pScreen);
+    if (pAttr) free(pAttr->values);
+    free(pAttr);
+    return ret;
+}
+
+static int
+ScreenSaverUnsetAttributes (ClientPtr client)
+{
+    REQUEST(xScreenSaverSetAttributesReq);
+    DrawablePtr			pDraw;
+    ScreenSaverScreenPrivatePtr	pPriv;
+    int				rc;
+
+    REQUEST_SIZE_MATCH (xScreenSaverUnsetAttributesReq);
+    rc = dixLookupDrawable(&pDraw, stuff->drawable, client, 0,
+			   DixGetAttrAccess);
+    if (rc != Success)
+	return rc;
+    pPriv = GetScreenPrivate (pDraw->pScreen);
+    if (pPriv && pPriv->attr && pPriv->attr->client == client)
+    {
+	FreeResource (pPriv->attr->resource, AttrType);
+    	FreeScreenAttr (pPriv->attr);
+	pPriv->attr = NULL;
+	CheckScreenPrivate (pDraw->pScreen);
+    }
+    return Success;
+}
+
+static int
+ProcScreenSaverSetAttributes (ClientPtr client)
+{
+#ifdef PANORAMIX
+    if(!noPanoramiXExtension) {
+       REQUEST(xScreenSaverSetAttributesReq);
+       PanoramiXRes *draw;
+       PanoramiXRes *backPix = NULL;
+       PanoramiXRes *bordPix = NULL;
+       PanoramiXRes *cmap    = NULL;
+       int i, status, len;
+       int  pback_offset = 0, pbord_offset = 0, cmap_offset = 0;
+       XID orig_visual, tmp;
+
+       REQUEST_AT_LEAST_SIZE (xScreenSaverSetAttributesReq);
+
+       status = dixLookupResourceByClass((pointer *)&draw, stuff->drawable,
+					 XRC_DRAWABLE, client, DixWriteAccess);
+       if (status != Success)
+           return (status == BadValue) ? BadDrawable : status;
+
+       len = stuff->length -  bytes_to_int32(sizeof(xScreenSaverSetAttributesReq));
+       if (Ones(stuff->mask) != len)
+           return BadLength;
+
+       if((Mask)stuff->mask & CWBackPixmap) {
+          pback_offset = Ones((Mask)stuff->mask & (CWBackPixmap - 1));
+          tmp = *((CARD32 *) &stuff[1] + pback_offset);
+          if ((tmp != None) && (tmp != ParentRelative)) {
+	      status = dixLookupResourceByType((pointer *)&backPix, tmp,
+					       XRT_PIXMAP, client,
+					       DixReadAccess);
+	      if (status != Success)
+		  return status;
+          }
+       }
+
+       if ((Mask)stuff->mask & CWBorderPixmap) {
+          pbord_offset = Ones((Mask)stuff->mask & (CWBorderPixmap - 1));
+          tmp = *((CARD32 *) &stuff[1] + pbord_offset);
+          if (tmp != CopyFromParent) {
+	      status = dixLookupResourceByType((pointer *)&bordPix, tmp,
+					       XRT_PIXMAP, client,
+					       DixReadAccess);
+	      if (status != Success)
+		  return status;
+          }
+       }
+
+       if ((Mask)stuff->mask & CWColormap) {
+           cmap_offset = Ones((Mask)stuff->mask & (CWColormap - 1));
+           tmp = *((CARD32 *) &stuff[1] + cmap_offset);
+           if ((tmp != CopyFromParent) && (tmp != None)) {
+	       status = dixLookupResourceByType((pointer *)&cmap, tmp,
+						XRT_COLORMAP, client,
+						DixReadAccess);
+	       if (status != Success)
+		   return status;
+           }
+       }
+
+       orig_visual = stuff->visualID;
+
+       FOR_NSCREENS_BACKWARD(i) {
+          stuff->drawable = draw->info[i].id;  
+          if (backPix)
+             *((CARD32 *) &stuff[1] + pback_offset) = backPix->info[i].id;
+          if (bordPix)
+             *((CARD32 *) &stuff[1] + pbord_offset) = bordPix->info[i].id;
+          if (cmap)
+             *((CARD32 *) &stuff[1] + cmap_offset) = cmap->info[i].id;
+
+          if (orig_visual != CopyFromParent) 
+            stuff->visualID = PanoramiXTranslateVisualID(i, orig_visual);
+
+          status = ScreenSaverSetAttributes(client);
+       }
+
+       return status;
+    }
+#endif
+
+    return ScreenSaverSetAttributes(client);
+}
+
+static int
+ProcScreenSaverUnsetAttributes (ClientPtr client)
+{
+#ifdef PANORAMIX
+    if(!noPanoramiXExtension) {
+       REQUEST(xScreenSaverUnsetAttributesReq);
+       PanoramiXRes *draw;
+       int rc, i;
+
+       rc = dixLookupResourceByClass((pointer *)&draw, stuff->drawable,
+				     XRC_DRAWABLE, client, DixWriteAccess);
+       if (rc != Success)
+           return (rc == BadValue) ? BadDrawable : rc;
+
+       for(i = PanoramiXNumScreens - 1; i > 0; i--) {
+            stuff->drawable = draw->info[i].id;
+            ScreenSaverUnsetAttributes(client);
+       }
+
+       stuff->drawable = draw->info[0].id;
+    }
+#endif
+
+    return ScreenSaverUnsetAttributes(client);
+}
+
+static int
+ProcScreenSaverSuspend (ClientPtr client)
+{
+    ScreenSaverSuspensionPtr *prev, this;
+
+    REQUEST(xScreenSaverSuspendReq);
+    REQUEST_SIZE_MATCH(xScreenSaverSuspendReq);
+
+    /* Check if this client is suspending the screensaver */
+    for (prev = &suspendingClients; (this = *prev); prev = &this->next)
+	if (this->pClient == client)
+	    break;
+
+    if (this)
+    {
+	if (stuff->suspend == TRUE)
+	   this->count++;
+	else if (--this->count == 0)
+	   FreeResource (this->clientResource, RT_NONE);
+
+	return Success;
+    }
+
+    /* If we get to this point, this client isn't suspending the screensaver */
+    if (stuff->suspend == FALSE)
+	return Success;
+
+    /*
+     * Allocate a suspension record for the client, and stop the screensaver
+     * if it isn't already suspended by another client. We attach a resource ID
+     * to the record, so the screensaver will be reenabled and the record freed
+     * if the client disconnects without reenabling it first.
+     */
+    this = malloc(sizeof (ScreenSaverSuspensionRec));
+
+    if (!this)
+	return BadAlloc;
+
+    this->next           = NULL;
+    this->pClient        = client;
+    this->count          = 1;
+    this->clientResource = FakeClientID (client->index);
+
+    if (!AddResource (this->clientResource, SuspendType, (pointer) this))
+    {
+	free(this);
+	return BadAlloc;
+    }
+
+    *prev = this;
+    if (!screenSaverSuspended)
+    {
+	screenSaverSuspended = TRUE;
+	FreeScreenSaverTimer();
+    }
+
+    return Success;
+}
+
+static int (*NormalVector[]) (ClientPtr /* client */) = {
+    ProcScreenSaverQueryVersion,
+    ProcScreenSaverQueryInfo,
+    ProcScreenSaverSelectInput,
+    ProcScreenSaverSetAttributes,
+    ProcScreenSaverUnsetAttributes,
+    ProcScreenSaverSuspend,
+};
+
+#define NUM_REQUESTS	((sizeof NormalVector) / (sizeof NormalVector[0]))
+
+static int
+ProcScreenSaverDispatch (ClientPtr client)
+{
+    REQUEST(xReq);
+
+    if (stuff->data < NUM_REQUESTS)
+	return (*NormalVector[stuff->data])(client);
+    return BadRequest;
+}
+
+static int
+SProcScreenSaverQueryVersion (ClientPtr client)
+{
+    REQUEST(xScreenSaverQueryVersionReq);
+    swaps(&stuff->length);
+    REQUEST_SIZE_MATCH(xScreenSaverQueryVersionReq);
+    return ProcScreenSaverQueryVersion (client);
+}
+
+static int
+SProcScreenSaverQueryInfo (ClientPtr client)
+{
+    REQUEST(xScreenSaverQueryInfoReq);
+    swaps(&stuff->length);
+    REQUEST_SIZE_MATCH(xScreenSaverQueryInfoReq);
+    swapl(&stuff->drawable);
+    return ProcScreenSaverQueryInfo (client);
+}
+
+static int
+SProcScreenSaverSelectInput (ClientPtr client)
+{
+    REQUEST(xScreenSaverSelectInputReq);
+    swaps(&stuff->length);
+    REQUEST_SIZE_MATCH(xScreenSaverSelectInputReq);
+    swapl(&stuff->drawable);
+    swapl(&stuff->eventMask);
+    return ProcScreenSaverSelectInput (client);
+}
+
+static int
+SProcScreenSaverSetAttributes (ClientPtr client)
+{
+    REQUEST(xScreenSaverSetAttributesReq);
+    swaps(&stuff->length);
+    REQUEST_AT_LEAST_SIZE(xScreenSaverSetAttributesReq);
+    swapl(&stuff->drawable);
+    swaps(&stuff->x);
+    swaps(&stuff->y);
+    swaps(&stuff->width);
+    swaps(&stuff->height);
+    swaps(&stuff->borderWidth);
+    swapl(&stuff->visualID);
+    swapl(&stuff->mask);
+    SwapRestL(stuff);
+    return ProcScreenSaverSetAttributes (client);
+}
+
+static int
+SProcScreenSaverUnsetAttributes (ClientPtr client)
+{
+    REQUEST(xScreenSaverUnsetAttributesReq);
+    swaps(&stuff->length);
+    REQUEST_SIZE_MATCH(xScreenSaverUnsetAttributesReq);
+    swapl(&stuff->drawable);
+    return ProcScreenSaverUnsetAttributes (client);
+}
+
+static int
+SProcScreenSaverSuspend (ClientPtr client)
+{
+    REQUEST(xScreenSaverSuspendReq);
+
+    swaps(&stuff->length);
+    REQUEST_SIZE_MATCH(xScreenSaverSuspendReq);
+    return ProcScreenSaverSuspend (client);
+}
+
+static int (*SwappedVector[]) (ClientPtr /* client */) = {
+    SProcScreenSaverQueryVersion,
+    SProcScreenSaverQueryInfo,
+    SProcScreenSaverSelectInput,
+    SProcScreenSaverSetAttributes,
+    SProcScreenSaverUnsetAttributes,
+    SProcScreenSaverSuspend,
+};
+
+static int
+SProcScreenSaverDispatch (ClientPtr client)
+{
+    REQUEST(xReq);
+
+    if (stuff->data < NUM_REQUESTS)
+	return (*SwappedVector[stuff->data])(client);
+    return BadRequest;
+}
+
+void
+ScreenSaverExtensionInit(INITARGS)
+{
+    ExtensionEntry *extEntry;
+    int		    i;
+    ScreenPtr	    pScreen;
+
+    if (!dixRegisterPrivateKey(&ScreenPrivateKeyRec, PRIVATE_SCREEN, 0))
+	return;
+
+    AttrType = CreateNewResourceType(ScreenSaverFreeAttr, "SaverAttr");
+    SaverEventType = CreateNewResourceType(ScreenSaverFreeEvents,
+					   "SaverEvent");
+    SuspendType = CreateNewResourceType(ScreenSaverFreeSuspend,
+					"SaverSuspend");
+
+    for (i = 0; i < screenInfo.numScreens; i++)
+    {
+	pScreen = screenInfo.screens[i];
+	SetScreenPrivate (pScreen, NULL);
+    }
+    if (AttrType && SaverEventType && SuspendType &&
+	(extEntry = AddExtension(ScreenSaverName, ScreenSaverNumberEvents, 0,
+				 ProcScreenSaverDispatch, SProcScreenSaverDispatch,
+				 NULL, StandardMinorOpcode)))
+    {
+	ScreenSaverEventBase = extEntry->eventBase;
+	EventSwapVector[ScreenSaverEventBase] = (EventSwapPtr) SScreenSaverNotifyEvent;
+    }
+}
diff --git a/xorg-server/Xext/security.c b/xorg-server/Xext/security.c
index ad6f9a3ef..5d2d0522f 100644
--- a/xorg-server/Xext/security.c
+++ b/xorg-server/Xext/security.c
@@ -1,1148 +1,1143 @@
-/*

-

-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.

-

-*/

-

-#ifdef HAVE_DIX_CONFIG_H

-#include <dix-config.h>

-#else

-#define XACE

-#endif

-

-#include "scrnintstr.h"

-#include "inputstr.h"

-#include "windowstr.h"

-#include "propertyst.h"

-#include "colormapst.h"

-#include "privates.h"

-#include "registry.h"

-#include "xacestr.h"

-#include "securitysrv.h"

-#include <X11/extensions/securproto.h>

-#include "modinit.h"

-#include "protocol-versions.h"

-

-/* Extension stuff */

-static int SecurityErrorBase;  /* first Security error number */

-static int SecurityEventBase;  /* first Security event number */

-

-RESTYPE SecurityAuthorizationResType; /* resource type for authorizations */

-static RESTYPE RTEventClient;

-

-static CallbackListPtr SecurityValidateGroupCallback = NULL;

-

-/* Private state record */

-static DevPrivateKeyRec stateKeyRec;

-#define stateKey (&stateKeyRec)

-

-/* This is what we store as client security state */

-typedef struct {

-    int haveState;

-    unsigned int trustLevel;

-    XID authId;

-} SecurityStateRec;

-

-/* Extensions that untrusted clients shouldn't have access to */

-static char *SecurityTrustedExtensions[] = {

-    "XC-MISC",

-    "BIG-REQUESTS",

-    "XpExtension",

-    NULL

-};

-

-/*

- * Access modes that untrusted clients are allowed on trusted objects.

- */

-static const Mask SecurityResourceMask =

-    DixGetAttrAccess | DixReceiveAccess | DixListPropAccess |

-    DixGetPropAccess | DixListAccess;

-static const Mask SecurityWindowExtraMask = DixRemoveAccess;

-static const Mask SecurityRootWindowExtraMask =

-    DixReceiveAccess | DixSendAccess | DixAddAccess | DixRemoveAccess;

-static const Mask SecurityDeviceMask =

-    DixGetAttrAccess | DixReceiveAccess | DixGetFocusAccess |

-    DixGrabAccess | DixSetAttrAccess | DixUseAccess;

-static const Mask SecurityServerMask = DixGetAttrAccess | DixGrabAccess;

-static const Mask SecurityClientMask = DixGetAttrAccess;

-

-

-/* SecurityAudit

- *

- * Arguments:

- *	format is the formatting string to be used to interpret the

- *	  remaining arguments.

- *

- * Returns: nothing.

- *

- * Side Effects:

- *	Writes the message to the log file if security logging is on.

- */

-

-static void

-SecurityAudit(char *format, ...)

-{

-    va_list args;

-

-    if (auditTrailLevel < SECURITY_AUDIT_LEVEL)

-	return;

-    va_start(args, format);

-    VAuditF(format, args);

-    va_end(args);

-} /* SecurityAudit */

-

-/*

- * Performs a Security permission check.

- */

-static int

-SecurityDoCheck(SecurityStateRec *subj, SecurityStateRec *obj,

-		Mask requested, Mask allowed)

-{

-    if (!subj->haveState || !obj->haveState)

-	return Success;

-    if (subj->trustLevel == XSecurityClientTrusted)

-	return Success;

-    if (obj->trustLevel != XSecurityClientTrusted)

-	return Success;

-    if ((requested | allowed) == allowed)

-	return Success;

-

-    return BadAccess;

-}

-

-/*

- * Labels initial server objects.

- */

-static void

-SecurityLabelInitial(void)

-{

-    SecurityStateRec *state;

-

-    /* Do the serverClient */

-    state = dixLookupPrivate(&serverClient->devPrivates, stateKey);

-    state->trustLevel = XSecurityClientTrusted;

-    state->haveState = TRUE;

-}

-

-/*

- * Looks up a request name

- */

-static _X_INLINE const char *

-SecurityLookupRequestName(ClientPtr client)

-{

-    int major = ((xReq *)client->requestBuffer)->reqType;

-    int minor = MinorOpcodeOfRequest(client);

-    return LookupRequestName(major, minor);

-}

-

-

-/* SecurityDeleteAuthorization

- *

- * Arguments:

- *	value is the authorization to delete.

- *	id is its resource ID.

- *

- * Returns: Success.

- *

- * Side Effects:

- *	Frees everything associated with the authorization.

- */

-

-static int

-SecurityDeleteAuthorization(

-    pointer value,

-    XID id)

-{

-    SecurityAuthorizationPtr pAuth = (SecurityAuthorizationPtr)value;

-    unsigned short name_len, data_len;

-    char *name, *data;

-    int status;

-    int i;

-    OtherClientsPtr pEventClient;

-

-    /* Remove the auth using the os layer auth manager */

-

-    status = AuthorizationFromID(pAuth->id, &name_len, &name,

-				 &data_len, &data);

-    assert(status);

-    status = RemoveAuthorization(name_len, name, data_len, data);

-    assert(status);

-    (void)status;

-

-    /* free the auth timer if there is one */

-

-    if (pAuth->timer) TimerFree(pAuth->timer);

-

-    /* send revoke events */

-

-    while ((pEventClient = pAuth->eventClients))

-    {

-	/* send revocation event event */

-	xSecurityAuthorizationRevokedEvent are;

-	are.type = SecurityEventBase + XSecurityAuthorizationRevoked;

-	are.authId = pAuth->id;

-	WriteEventsToClient(rClient(pEventClient), 1, (xEvent *)&are);

-	FreeResource(pEventClient->resource, RT_NONE);

-    }

-

-    /* kill all clients using this auth */

-

-    for (i = 1; i<currentMaxClients; i++)

-	if (clients[i]) {

-	    SecurityStateRec *state;

-	    state = dixLookupPrivate(&clients[i]->devPrivates, stateKey);

-	    if (state->haveState && state->authId == pAuth->id)

-		CloseDownClient(clients[i]);

-	}

-

-    SecurityAudit("revoked authorization ID %d\n", pAuth->id);

-    free(pAuth);

-    return Success;

-

-} /* SecurityDeleteAuthorization */

-

-

-/* resource delete function for RTEventClient */

-static int

-SecurityDeleteAuthorizationEventClient(

-    pointer value,

-    XID id)

-{

-    OtherClientsPtr pEventClient, prev = NULL;

-    SecurityAuthorizationPtr pAuth = (SecurityAuthorizationPtr)value;

-

-    for (pEventClient = pAuth->eventClients;

-	 pEventClient;

-	 pEventClient = pEventClient->next)

-    {

-	if (pEventClient->resource == id)

-	{

-	    if (prev)

-		prev->next = pEventClient->next;

-	    else

-		pAuth->eventClients = pEventClient->next;

-	    free(pEventClient);

-	    return Success;

-	}

-	prev = pEventClient;

-    }

-    /*NOTREACHED*/

-    return -1; /* make compiler happy */

-} /* SecurityDeleteAuthorizationEventClient */

-

-

-/* SecurityComputeAuthorizationTimeout

- *

- * Arguments:

- *	pAuth is the authorization for which we are computing the timeout

- *	seconds is the number of seconds we want to wait

- *

- * Returns:

- *	the number of milliseconds that the auth timer should be set to

- *

- * Side Effects:

- *	Sets pAuth->secondsRemaining to any "overflow" amount of time

- *	that didn't fit in 32 bits worth of milliseconds

- */

-

-static CARD32

-SecurityComputeAuthorizationTimeout(

-    SecurityAuthorizationPtr pAuth,

-    unsigned int seconds)

-{

-    /* maxSecs is the number of full seconds that can be expressed in

-     * 32 bits worth of milliseconds

-     */

-    CARD32 maxSecs = (CARD32)(~0) / (CARD32)MILLI_PER_SECOND;

-

-    if (seconds > maxSecs)

-    { /* only come here if we want to wait more than 49 days */

-	pAuth->secondsRemaining = seconds - maxSecs;

-	return maxSecs * MILLI_PER_SECOND;

-    }

-    else

-    { /* by far the common case */

-	pAuth->secondsRemaining = 0;

-	return seconds * MILLI_PER_SECOND;

-    }

-} /* SecurityStartAuthorizationTimer */

-

-/* SecurityAuthorizationExpired

- *

- * This function is passed as an argument to TimerSet and gets called from

- * the timer manager in the os layer when its time is up.

- *

- * Arguments:

- *	timer is the timer for this authorization.

- *	time is the current time.

- *	pval is the authorization whose time is up.

- *

- * Returns:

- *	A new time delay in milliseconds if the timer should wait some

- *	more, else zero.

- *

- * Side Effects:

- *	Frees the authorization resource if the timeout period is really

- *	over, otherwise recomputes pAuth->secondsRemaining.

- */

-

-static CARD32

-SecurityAuthorizationExpired(

-    OsTimerPtr timer,

-    CARD32 time,

-    pointer pval)

-{

-    SecurityAuthorizationPtr pAuth = (SecurityAuthorizationPtr)pval;

-

-    assert(pAuth->timer == timer);

-

-    if (pAuth->secondsRemaining)

-    {

-	return SecurityComputeAuthorizationTimeout(pAuth,

-						   pAuth->secondsRemaining);

-    }

-    else

-    {

-	FreeResource(pAuth->id, RT_NONE);

-	return 0;

-    }

-} /* SecurityAuthorizationExpired */

-

-/* SecurityStartAuthorizationTimer

- *

- * Arguments:

- *	pAuth is the authorization whose timer should be started.

- *

- * Returns: nothing.

- *

- * Side Effects:

- *	A timer is started, set to expire after the timeout period for

- *	this authorization.  When it expires, the function

- *	SecurityAuthorizationExpired will be called.

- */

-

-static void

-SecurityStartAuthorizationTimer(

-    SecurityAuthorizationPtr pAuth)

-{

-    pAuth->timer = TimerSet(pAuth->timer, 0,

-	SecurityComputeAuthorizationTimeout(pAuth, pAuth->timeout),

-			    SecurityAuthorizationExpired, pAuth);

-} /* SecurityStartAuthorizationTimer */

-

-

-/* Proc functions all take a client argument, execute the request in

- * client->requestBuffer, and return a protocol error status.

- */

-

-static int

-ProcSecurityQueryVersion(

-    ClientPtr client)

-{

-    /* REQUEST(xSecurityQueryVersionReq); */

-    xSecurityQueryVersionReply 	rep;

-

-    REQUEST_SIZE_MATCH(xSecurityQueryVersionReq);

-    rep.type        	= X_Reply;

-    rep.sequenceNumber 	= client->sequence;

-    rep.length         	= 0;

-    rep.majorVersion  	= SERVER_SECURITY_MAJOR_VERSION;

-    rep.minorVersion  	= SERVER_SECURITY_MINOR_VERSION;

-    if(client->swapped)

-    {

-	char n;

-    	swaps(&rep.sequenceNumber, n);

-	swaps(&rep.majorVersion, n);

-	swaps(&rep.minorVersion, n);

-    }

-    (void)WriteToClient(client, SIZEOF(xSecurityQueryVersionReply),

-			(char *)&rep);

-    return Success;

-} /* ProcSecurityQueryVersion */

-

-

-static int

-SecurityEventSelectForAuthorization(

-    SecurityAuthorizationPtr pAuth,

-    ClientPtr client,

-    Mask mask)

-{

-    OtherClients *pEventClient;

-

-    for (pEventClient = pAuth->eventClients;

-	 pEventClient;

-	 pEventClient = pEventClient->next)

-    {

-	if (SameClient(pEventClient, client))

-	{

-	    if (mask == 0)

-		FreeResource(pEventClient->resource, RT_NONE);

-	    else

-		pEventClient->mask = mask;

-	    return Success;

-	}

-    }

-    

-    pEventClient = malloc(sizeof(OtherClients));

-    if (!pEventClient)

-	return BadAlloc;

-    pEventClient->mask = mask;

-    pEventClient->resource = FakeClientID(client->index);

-    pEventClient->next = pAuth->eventClients;

-    if (!AddResource(pEventClient->resource, RTEventClient,

-		     (pointer)pAuth))

-    {

-	free(pEventClient);

-	return BadAlloc;

-    }

-    pAuth->eventClients = pEventClient;

-

-    return Success;

-} /* SecurityEventSelectForAuthorization */

-

-

-static int

-ProcSecurityGenerateAuthorization(

-    ClientPtr client)

-{

-    REQUEST(xSecurityGenerateAuthorizationReq);

-    int len;			/* request length in CARD32s*/

-    Bool removeAuth = FALSE;	/* if bailout, call RemoveAuthorization? */

-    SecurityAuthorizationPtr pAuth = NULL;  /* auth we are creating */

-    int err;			/* error to return from this function */

-    XID authId;			/* authorization ID assigned by os layer */

-    xSecurityGenerateAuthorizationReply rep; /* reply struct */

-    unsigned int trustLevel;    /* trust level of new auth */

-    XID group;			/* group of new auth */

-    CARD32 timeout;		/* timeout of new auth */

-    CARD32 *values;		/* list of supplied attributes */

-    char *protoname;		/* auth proto name sent in request */

-    char *protodata;		/* auth proto data sent in request */

-    unsigned int authdata_len;  /* # bytes of generated auth data */

-    char *pAuthdata;		/* generated auth data */

-    Mask eventMask;		/* what events on this auth does client want */

-

-    /* check request length */

-

-    REQUEST_AT_LEAST_SIZE(xSecurityGenerateAuthorizationReq);

-    len = bytes_to_int32(SIZEOF(xSecurityGenerateAuthorizationReq));

-    len += bytes_to_int32(stuff->nbytesAuthProto);

-    len += bytes_to_int32(stuff->nbytesAuthData);

-    values = ((CARD32 *)stuff) + len;

-    len += Ones(stuff->valueMask);

-    if (client->req_len != len)

-	return BadLength;

-

-    /* check valuemask */

-    if (stuff->valueMask & ~XSecurityAllAuthorizationAttributes)

-    {

-	client->errorValue = stuff->valueMask;

-	return BadValue;

-    }

-

-    /* check timeout */

-    timeout = 60;

-    if (stuff->valueMask & XSecurityTimeout)

-    {

-	timeout = *values++;

-    }

-

-    /* check trustLevel */

-    trustLevel = XSecurityClientUntrusted;

-    if (stuff->valueMask & XSecurityTrustLevel)

-    {

-	trustLevel = *values++;

-	if (trustLevel != XSecurityClientTrusted &&

-	    trustLevel != XSecurityClientUntrusted)

-	{

-	    client->errorValue = trustLevel;

-	    return BadValue;

-	}

-    }

-

-    /* check group */

-    group = None;

-    if (stuff->valueMask & XSecurityGroup)

-    {

-	group = *values++;

-	if (SecurityValidateGroupCallback)

-	{

-	    SecurityValidateGroupInfoRec vgi;

-	    vgi.group = group;

-	    vgi.valid = FALSE;

-	    CallCallbacks(&SecurityValidateGroupCallback, (pointer)&vgi);

-

-	    /* if nobody said they recognized it, it's an error */

-

-	    if (!vgi.valid)

-	    {

-		client->errorValue = group;

-		return BadValue;

-	    }

-	}

-    }

-

-    /* check event mask */

-    eventMask = 0;

-    if (stuff->valueMask & XSecurityEventMask)

-    {

-	eventMask = *values++;

-	if (eventMask & ~XSecurityAllEventMasks)

-	{

-	    client->errorValue = eventMask;

-	    return BadValue;

-	}

-    }

-

-    protoname = (char *)&stuff[1];

-    protodata = protoname + bytes_to_int32(stuff->nbytesAuthProto);

-

-    /* call os layer to generate the authorization */

-

-    authId = GenerateAuthorization(stuff->nbytesAuthProto, protoname,

-				   stuff->nbytesAuthData,  protodata,

-				   &authdata_len, &pAuthdata);

-    if ((XID) ~0L == authId)

-    {

-	err = SecurityErrorBase + XSecurityBadAuthorizationProtocol;

-	goto bailout;

-    }

-

-    /* now that we've added the auth, remember to remove it if we have to

-     * abort the request for some reason (like allocation failure)

-     */

-    removeAuth = TRUE;

-

-    /* associate additional information with this auth ID */

-

-    pAuth = malloc(sizeof(SecurityAuthorizationRec));

-    if (!pAuth)

-    {

-	err = BadAlloc;

-	goto bailout;

-    }

-

-    /* fill in the auth fields */

-

-    pAuth->id = authId;

-    pAuth->timeout = timeout;

-    pAuth->group = group;

-    pAuth->trustLevel = trustLevel;

-    pAuth->refcnt = 0;	/* the auth was just created; nobody's using it yet */

-    pAuth->secondsRemaining = 0;

-    pAuth->timer = NULL;

-    pAuth->eventClients = NULL;

-

-    /* handle event selection */

-    if (eventMask)

-    {

-	err = SecurityEventSelectForAuthorization(pAuth, client, eventMask);

-	if (err != Success)

-	    goto bailout;

-    }

-

-    if (!AddResource(authId, SecurityAuthorizationResType, pAuth))

-    {

-	err = BadAlloc;

-	goto bailout;

-    }

-

-    /* start the timer ticking */

-

-    if (pAuth->timeout != 0)

-	SecurityStartAuthorizationTimer(pAuth);

-

-    /* tell client the auth id and data */

-

-    rep.type = X_Reply;

-    rep.length = bytes_to_int32(authdata_len);

-    rep.sequenceNumber = client->sequence;

-    rep.authId = authId;

-    rep.dataLength = authdata_len;

-

-    if (client->swapped)

-    {

-	char n;

-    	swapl(&rep.length, n);

-    	swaps(&rep.sequenceNumber, n);

-    	swapl(&rep.authId, n);

-    	swaps(&rep.dataLength, n);

-    }

-

-    WriteToClient(client, SIZEOF(xSecurityGenerateAuthorizationReply),

-		  (char *)&rep);

-    WriteToClient(client, authdata_len, pAuthdata);

-

-    SecurityAudit("client %d generated authorization %d trust %d timeout %d group %d events %d\n",

-		  client->index, pAuth->id, pAuth->trustLevel, pAuth->timeout,

-		  pAuth->group, eventMask);

-

-    /* the request succeeded; don't call RemoveAuthorization or free pAuth */

-    return Success;

-

-bailout:

-    if (removeAuth)

-	RemoveAuthorization(stuff->nbytesAuthProto, protoname,

-			    authdata_len, pAuthdata);

-    free(pAuth);

-    return err;

-

-} /* ProcSecurityGenerateAuthorization */

-

-static int

-ProcSecurityRevokeAuthorization(

-    ClientPtr client)

-{

-    REQUEST(xSecurityRevokeAuthorizationReq);

-    SecurityAuthorizationPtr pAuth;

-    int rc;

-

-    REQUEST_SIZE_MATCH(xSecurityRevokeAuthorizationReq);

-

-    rc = dixLookupResourceByType((pointer *)&pAuth, stuff->authId,

-				 SecurityAuthorizationResType, client,

-				 DixDestroyAccess);

-    if (rc != Success)

-	return rc;

-

-    FreeResource(stuff->authId, RT_NONE);

-    return Success;

-} /* ProcSecurityRevokeAuthorization */

-

-

-static int

-ProcSecurityDispatch(

-    ClientPtr client)

-{

-    REQUEST(xReq);

-

-    switch (stuff->data)

-    {

-	case X_SecurityQueryVersion:

-	    return ProcSecurityQueryVersion(client);

-	case X_SecurityGenerateAuthorization:

-	    return ProcSecurityGenerateAuthorization(client);

-	case X_SecurityRevokeAuthorization:

-	    return ProcSecurityRevokeAuthorization(client);

-	default:

-	    return BadRequest;

-    }

-} /* ProcSecurityDispatch */

-

-static int

-SProcSecurityQueryVersion(

-    ClientPtr client)

-{

-    REQUEST(xSecurityQueryVersionReq);

-    char	n;

-

-    swaps(&stuff->length, n);

-    REQUEST_SIZE_MATCH(xSecurityQueryVersionReq);

-    swaps(&stuff->majorVersion, n);

-    swaps(&stuff->minorVersion,n);

-    return ProcSecurityQueryVersion(client);

-} /* SProcSecurityQueryVersion */

-

-

-static int

-SProcSecurityGenerateAuthorization(

-    ClientPtr client)

-{

-    REQUEST(xSecurityGenerateAuthorizationReq);

-    char	n;

-    CARD32 *values;

-    unsigned long nvalues;

-    int values_offset;

-

-    swaps(&stuff->length, n);

-    REQUEST_AT_LEAST_SIZE(xSecurityGenerateAuthorizationReq);

-    swaps(&stuff->nbytesAuthProto, n);

-    swaps(&stuff->nbytesAuthData, n);

-    swapl(&stuff->valueMask, n);

-    values_offset = bytes_to_int32(stuff->nbytesAuthProto) +

-		    bytes_to_int32(stuff->nbytesAuthData);

-    if (values_offset > 

-	stuff->length - bytes_to_int32(sz_xSecurityGenerateAuthorizationReq))

-	return BadLength;

-    values = (CARD32 *)(&stuff[1]) + values_offset;

-    nvalues = (((CARD32 *)stuff) + stuff->length) - values;

-    SwapLongs(values, nvalues);

-    return ProcSecurityGenerateAuthorization(client);

-} /* SProcSecurityGenerateAuthorization */

-

-

-static int

-SProcSecurityRevokeAuthorization(

-    ClientPtr client)

-{

-    REQUEST(xSecurityRevokeAuthorizationReq);

-    char	n;

-

-    swaps(&stuff->length, n);

-    REQUEST_SIZE_MATCH(xSecurityRevokeAuthorizationReq);

-    swapl(&stuff->authId, n);

-    return ProcSecurityRevokeAuthorization(client);

-} /* SProcSecurityRevokeAuthorization */

-

-

-static int

-SProcSecurityDispatch(

-    ClientPtr client)

-{

-    REQUEST(xReq);

-

-    switch (stuff->data)

-    {

-	case X_SecurityQueryVersion:

-	    return SProcSecurityQueryVersion(client);

-	case X_SecurityGenerateAuthorization:

-	    return SProcSecurityGenerateAuthorization(client);

-	case X_SecurityRevokeAuthorization:

-	    return SProcSecurityRevokeAuthorization(client);

-	default:

-	    return BadRequest;

-    }

-} /* SProcSecurityDispatch */

-

-static void 

-SwapSecurityAuthorizationRevokedEvent(

-    xSecurityAuthorizationRevokedEvent *from,

-    xSecurityAuthorizationRevokedEvent *to)

-{

-    to->type = from->type;

-    to->detail = from->detail;

-    cpswaps(from->sequenceNumber, to->sequenceNumber);

-    cpswapl(from->authId, to->authId);

-}

-

-/* SecurityCheckDeviceAccess

- *

- * Arguments:

- *	client is the client attempting to access a device.

- *	dev is the device being accessed.

- *	fromRequest is TRUE if the device access is a direct result of

- *	  the client executing some request and FALSE if it is a

- *	  result of the server trying to send an event (e.g. KeymapNotify)

- *	  to the client.

- * Returns:

- *	TRUE if the device access should be allowed, else FALSE.

- *

- * Side Effects:

- *	An audit message is generated if access is denied.

- */

-

-static void

-SecurityDevice(CallbackListPtr *pcbl, pointer unused, pointer calldata)

-{

-    XaceDeviceAccessRec *rec = calldata;

-    SecurityStateRec *subj, *obj;

-    Mask requested = rec->access_mode;

-    Mask allowed = SecurityDeviceMask;

-

-    subj = dixLookupPrivate(&rec->client->devPrivates, stateKey);

-    obj = dixLookupPrivate(&serverClient->devPrivates, stateKey);

-

-    if (rec->dev != inputInfo.keyboard)

-	/* this extension only supports the core keyboard */

-	allowed = requested;

-

-    if (SecurityDoCheck(subj, obj, requested, allowed) != Success) {

-	SecurityAudit("Security denied client %d keyboard access on request "

-		      "%s\n", rec->client->index,

-		      SecurityLookupRequestName(rec->client));

-	rec->status = BadAccess;

-    }

-}

-

-/* SecurityResource

- *

- * This function gets plugged into client->CheckAccess and is called from

- * SecurityLookupIDByType/Class to determine if the client can access the

- * resource.

- *

- * Arguments:

- *	client is the client doing the resource access.

- *	id is the resource id.

- *	rtype is its type or class.

- *	access_mode represents the intended use of the resource; see

- *	  resource.h.

- *	res is a pointer to the resource structure for this resource.

- *

- * Returns:

- *	If access is granted, the value of rval that was passed in, else FALSE.

- *

- * Side Effects:

- *	Disallowed resource accesses are audited.

- */

-

-static void

-SecurityResource(CallbackListPtr *pcbl, pointer unused, pointer calldata)

-{

-    XaceResourceAccessRec *rec = calldata;

-    SecurityStateRec *subj, *obj;

-    int cid = CLIENT_ID(rec->id);

-    Mask requested = rec->access_mode;

-    Mask allowed = SecurityResourceMask;

-

-    subj = dixLookupPrivate(&rec->client->devPrivates, stateKey);

-

-    /* disable background None for untrusted windows */

-    if ((requested & DixCreateAccess) && (rec->rtype == RT_WINDOW))

-	if (subj->haveState && subj->trustLevel != XSecurityClientTrusted)

-	    ((WindowPtr)rec->res)->forcedBG = TRUE;

-

-    /* additional permissions for specific resource types */

-    if (rec->rtype == RT_WINDOW)

-	allowed |= SecurityWindowExtraMask;

-

-    /* special checks for server-owned resources */

-    if (cid == 0) {

-	if (rec->rtype & RC_DRAWABLE)

-	    /* additional operations allowed on root windows */

-	    allowed |= SecurityRootWindowExtraMask;

-

-	else if (rec->rtype == RT_COLORMAP)

-	    /* allow access to default colormaps */

-	    allowed = requested;

-

-	else

-	    /* allow read access to other server-owned resources */

-	    allowed |= DixReadAccess;

-    }

-

-    if (clients[cid] != NULL) {

-	obj = dixLookupPrivate(&clients[cid]->devPrivates, stateKey);

-	if (SecurityDoCheck(subj, obj, requested, allowed) == Success)

-	    return;

-    }

-

-    SecurityAudit("Security: denied client %d access %x to resource 0x%x "

-		  "of client %d on request %s\n", rec->client->index,

-		  requested, rec->id, cid,

-		  SecurityLookupRequestName(rec->client));

-    rec->status = BadAccess; /* deny access */

-}

-

-

-static void

-SecurityExtension(CallbackListPtr *pcbl, pointer unused, pointer calldata)

-{

-    XaceExtAccessRec *rec = calldata;

-    SecurityStateRec *subj;

-    int i = 0;

-

-    subj = dixLookupPrivate(&rec->client->devPrivates, stateKey);

-

-    if (subj->haveState && subj->trustLevel == XSecurityClientTrusted)

-	return;

-

-    while (SecurityTrustedExtensions[i])

-	if (!strcmp(SecurityTrustedExtensions[i++], rec->ext->name))

-	    return;

-

-    SecurityAudit("Security: denied client %d access to extension "

-		  "%s on request %s\n",

-		  rec->client->index, rec->ext->name,

-		  SecurityLookupRequestName(rec->client));

-    rec->status = BadAccess;

-}

-

-static void

-SecurityServer(CallbackListPtr *pcbl, pointer unused, pointer calldata)

-{

-    XaceServerAccessRec *rec = calldata;

-    SecurityStateRec *subj, *obj;

-    Mask requested = rec->access_mode;

-    Mask allowed = SecurityServerMask;

-

-    subj = dixLookupPrivate(&rec->client->devPrivates, stateKey);

-    obj = dixLookupPrivate(&serverClient->devPrivates, stateKey);

- 

-    if (SecurityDoCheck(subj, obj, requested, allowed) != Success) {

-	SecurityAudit("Security: denied client %d access to server "

-		      "configuration request %s\n", rec->client->index,

-		      SecurityLookupRequestName(rec->client));

-	rec->status = BadAccess;

-    }

-}

-

-static void

-SecurityClient(CallbackListPtr *pcbl, pointer unused, pointer calldata)

-{

-    XaceClientAccessRec *rec = calldata;

-    SecurityStateRec *subj, *obj;

-    Mask requested = rec->access_mode;

-    Mask allowed = SecurityClientMask;

-

-    subj = dixLookupPrivate(&rec->client->devPrivates, stateKey);

-    obj = dixLookupPrivate(&rec->target->devPrivates, stateKey);

-

-    if (SecurityDoCheck(subj, obj, requested, allowed) != Success) {

-	SecurityAudit("Security: denied client %d access to client %d on "

-		      "request %s\n", rec->client->index, rec->target->index,

-		      SecurityLookupRequestName(rec->client));

-	rec->status = BadAccess;

-    }

-}

-

-static void

-SecurityProperty(CallbackListPtr *pcbl, pointer unused, pointer calldata)

-{    

-    XacePropertyAccessRec *rec = calldata;

-    SecurityStateRec *subj, *obj;

-    ATOM name = (*rec->ppProp)->propertyName;

-    Mask requested = rec->access_mode;

-    Mask allowed = SecurityResourceMask | DixReadAccess;

-

-    subj = dixLookupPrivate(&rec->client->devPrivates, stateKey);

-    obj = dixLookupPrivate(&wClient(rec->pWin)->devPrivates, stateKey);

-

-    if (SecurityDoCheck(subj, obj, requested, allowed) != Success) {

-	SecurityAudit("Security: denied client %d access to property %s "

-		      "(atom 0x%x) window 0x%x of client %d on request %s\n",

-		      rec->client->index, NameForAtom(name), name,

-		      rec->pWin->drawable.id, wClient(rec->pWin)->index,

-		      SecurityLookupRequestName(rec->client));

-	rec->status = BadAccess;

-    }

-}

-

-static void

-SecuritySend(CallbackListPtr *pcbl, pointer unused, pointer calldata)

-{

-    XaceSendAccessRec *rec = calldata;

-    SecurityStateRec *subj, *obj;

-

-    if (rec->client) {

-	int i;

-

-	subj = dixLookupPrivate(&rec->client->devPrivates, stateKey);

-	obj = dixLookupPrivate(&wClient(rec->pWin)->devPrivates, stateKey);

-

-	if (SecurityDoCheck(subj, obj, DixSendAccess, 0) == Success)

-	    return;

-

-	for (i = 0; i < rec->count; i++)

-	    if (rec->events[i].u.u.type != UnmapNotify &&

-		rec->events[i].u.u.type != ConfigureRequest &&

-		rec->events[i].u.u.type != ClientMessage) {

-

-		SecurityAudit("Security: denied client %d from sending event "

-			      "of type %s to window 0x%x of client %d\n",

-			      rec->client->index,

-			      LookupEventName(rec->events[i].u.u.type),

-			      rec->pWin->drawable.id,

-			      wClient(rec->pWin)->index);

-		rec->status = BadAccess;

-		return;

-	    }

-    }

-}

-

-static void

-SecurityReceive(CallbackListPtr *pcbl, pointer unused, pointer calldata)

-{

-    XaceReceiveAccessRec *rec = calldata;

-    SecurityStateRec *subj, *obj;

-

-    subj = dixLookupPrivate(&rec->client->devPrivates, stateKey);

-    obj = dixLookupPrivate(&wClient(rec->pWin)->devPrivates, stateKey);

-

-    if (SecurityDoCheck(subj, obj, DixReceiveAccess, 0) == Success)

-	return;

-

-    SecurityAudit("Security: denied client %d from receiving an event "

-		  "sent to window 0x%x of client %d\n",

-		  rec->client->index, rec->pWin->drawable.id,

-		  wClient(rec->pWin)->index);

-    rec->status = BadAccess;

-}

-

-/* SecurityClientStateCallback

- *

- * Arguments:

- *	pcbl is &ClientStateCallback.

- *	nullata is NULL.

- *	calldata is a pointer to a NewClientInfoRec (include/dixstruct.h)

- *	which contains information about client state changes.

- *

- * Returns: nothing.

- *

- * Side Effects:

- * 

- * If a new client is connecting, its authorization ID is copied to

- * client->authID.  If this is a generated authorization, its reference

- * count is bumped, its timer is cancelled if it was running, and its

- * trustlevel is copied to TRUSTLEVEL(client).

- * 

- * If a client is disconnecting and the client was using a generated

- * authorization, the authorization's reference count is decremented, and

- * if it is now zero, the timer for this authorization is started.

- */

-

-static void

-SecurityClientState(CallbackListPtr *pcbl, pointer unused, pointer calldata)

-{

-    NewClientInfoRec *pci = calldata;

-    SecurityStateRec *state;

-    SecurityAuthorizationPtr pAuth;

-    int rc;

-

-    state = dixLookupPrivate(&pci->client->devPrivates, stateKey);

-

-    switch (pci->client->clientState) {

-    case ClientStateInitial:

-	state->trustLevel = XSecurityClientTrusted;

-	state->authId = None;

-	state->haveState = TRUE;

-	break;

-

-    case ClientStateRunning:

-	state->authId = AuthorizationIDOfClient(pci->client);

-	rc = dixLookupResourceByType((pointer *)&pAuth, state->authId,

-			       SecurityAuthorizationResType, serverClient,

-			       DixGetAttrAccess);

-	if (rc == Success) {

-	    /* it is a generated authorization */

-	    pAuth->refcnt++;

-	    if (pAuth->refcnt == 1 && pAuth->timer)

-		TimerCancel(pAuth->timer);

-

-	    state->trustLevel = pAuth->trustLevel;

-	}

-	break;

-

-    case ClientStateGone:

-    case ClientStateRetained:

-	rc = dixLookupResourceByType((pointer *)&pAuth, state->authId,

-			       SecurityAuthorizationResType, serverClient,

-			       DixGetAttrAccess);

-	if (rc == Success) {

-	    /* it is a generated authorization */

-	    pAuth->refcnt--;

-	    if (pAuth->refcnt == 0)

-		SecurityStartAuthorizationTimer(pAuth);

-	}

-	break;

-

-    default:

-	break;

-    }

-}

-

-/* SecurityResetProc

- *

- * Arguments:

- *	extEntry is the extension information for the security extension.

- *

- * Returns: nothing.

- *

- * Side Effects:

- *	Performs any cleanup needed by Security at server shutdown time.

- */

-

-static void

-SecurityResetProc(

-    ExtensionEntry *extEntry)

-{

-    /* Unregister callbacks */

-    DeleteCallback(&ClientStateCallback, SecurityClientState, NULL);

-

-    XaceDeleteCallback(XACE_EXT_DISPATCH, SecurityExtension, NULL);

-    XaceDeleteCallback(XACE_RESOURCE_ACCESS, SecurityResource, NULL);

-    XaceDeleteCallback(XACE_DEVICE_ACCESS, SecurityDevice, NULL);

-    XaceDeleteCallback(XACE_PROPERTY_ACCESS, SecurityProperty, NULL);

-    XaceDeleteCallback(XACE_SEND_ACCESS, SecuritySend, NULL);

-    XaceDeleteCallback(XACE_RECEIVE_ACCESS, SecurityReceive, NULL);

-    XaceDeleteCallback(XACE_CLIENT_ACCESS, SecurityClient, NULL);

-    XaceDeleteCallback(XACE_EXT_ACCESS, SecurityExtension, NULL);

-    XaceDeleteCallback(XACE_SERVER_ACCESS, SecurityServer, NULL);

-}

-

-

-/* SecurityExtensionInit

- *

- * Arguments: none.

- *

- * Returns: nothing.

- *

- * Side Effects:

- *	Enables the Security extension if possible.

- */

-

-void

-SecurityExtensionInit(INITARGS)

-{

-    ExtensionEntry	*extEntry;

-    int ret = TRUE;

-

-    SecurityAuthorizationResType =

-	CreateNewResourceType(SecurityDeleteAuthorization,

-			      "SecurityAuthorization");

-

-    RTEventClient =

-	CreateNewResourceType(SecurityDeleteAuthorizationEventClient,

-			      "SecurityEventClient");

-

-    if (!SecurityAuthorizationResType || !RTEventClient)

-	return;

-

-    RTEventClient |= RC_NEVERRETAIN;

-

-    /* Allocate the private storage */

-    if (!dixRegisterPrivateKey(stateKey, PRIVATE_CLIENT, sizeof(SecurityStateRec)))

-	FatalError("SecurityExtensionSetup: Can't allocate client private.\n");

-

-    /* Register callbacks */

-    ret &= AddCallback(&ClientStateCallback, SecurityClientState, NULL);

-

-    ret &= XaceRegisterCallback(XACE_EXT_DISPATCH, SecurityExtension, NULL);

-    ret &= XaceRegisterCallback(XACE_RESOURCE_ACCESS, SecurityResource, NULL);

-    ret &= XaceRegisterCallback(XACE_DEVICE_ACCESS, SecurityDevice, NULL);

-    ret &= XaceRegisterCallback(XACE_PROPERTY_ACCESS, SecurityProperty, NULL);

-    ret &= XaceRegisterCallback(XACE_SEND_ACCESS, SecuritySend, NULL);

-    ret &= XaceRegisterCallback(XACE_RECEIVE_ACCESS, SecurityReceive, NULL);

-    ret &= XaceRegisterCallback(XACE_CLIENT_ACCESS, SecurityClient, NULL);

-    ret &= XaceRegisterCallback(XACE_EXT_ACCESS, SecurityExtension, NULL);

-    ret &= XaceRegisterCallback(XACE_SERVER_ACCESS, SecurityServer, NULL);

-

-    if (!ret)

-	FatalError("SecurityExtensionSetup: Failed to register callbacks\n");

-

-    /* Add extension to server */

-    extEntry = AddExtension(SECURITY_EXTENSION_NAME,

-			    XSecurityNumberEvents, XSecurityNumberErrors,

-			    ProcSecurityDispatch, SProcSecurityDispatch,

-                            SecurityResetProc, StandardMinorOpcode);

-

-    SecurityErrorBase = extEntry->errorBase;

-    SecurityEventBase = extEntry->eventBase;

-

-    EventSwapVector[SecurityEventBase + XSecurityAuthorizationRevoked] =

-	(EventSwapPtr)SwapSecurityAuthorizationRevokedEvent;

-

-    SetResourceTypeErrorValue(SecurityAuthorizationResType, SecurityErrorBase + XSecurityBadAuthorization);

-

-    /* Label objects that were created before we could register ourself */

-    SecurityLabelInitial();

-}

+/*
+
+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.
+
+*/
+
+#ifdef HAVE_DIX_CONFIG_H
+#include <dix-config.h>
+#else
+#define XACE
+#endif
+
+#include "scrnintstr.h"
+#include "inputstr.h"
+#include "windowstr.h"
+#include "propertyst.h"
+#include "colormapst.h"
+#include "privates.h"
+#include "registry.h"
+#include "xacestr.h"
+#include "securitysrv.h"
+#include <X11/extensions/securproto.h>
+#include "modinit.h"
+#include "protocol-versions.h"
+
+/* Extension stuff */
+static int SecurityErrorBase;  /* first Security error number */
+static int SecurityEventBase;  /* first Security event number */
+
+RESTYPE SecurityAuthorizationResType; /* resource type for authorizations */
+static RESTYPE RTEventClient;
+
+static CallbackListPtr SecurityValidateGroupCallback = NULL;
+
+/* Private state record */
+static DevPrivateKeyRec stateKeyRec;
+#define stateKey (&stateKeyRec)
+
+/* This is what we store as client security state */
+typedef struct {
+    int haveState;
+    unsigned int trustLevel;
+    XID authId;
+} SecurityStateRec;
+
+/* Extensions that untrusted clients shouldn't have access to */
+static char *SecurityTrustedExtensions[] = {
+    "XC-MISC",
+    "BIG-REQUESTS",
+    "XpExtension",
+    NULL
+};
+
+/*
+ * Access modes that untrusted clients are allowed on trusted objects.
+ */
+static const Mask SecurityResourceMask =
+    DixGetAttrAccess | DixReceiveAccess | DixListPropAccess |
+    DixGetPropAccess | DixListAccess;
+static const Mask SecurityWindowExtraMask = DixRemoveAccess;
+static const Mask SecurityRootWindowExtraMask =
+    DixReceiveAccess | DixSendAccess | DixAddAccess | DixRemoveAccess;
+static const Mask SecurityDeviceMask =
+    DixGetAttrAccess | DixReceiveAccess | DixGetFocusAccess |
+    DixGrabAccess | DixSetAttrAccess | DixUseAccess;
+static const Mask SecurityServerMask = DixGetAttrAccess | DixGrabAccess;
+static const Mask SecurityClientMask = DixGetAttrAccess;
+
+
+/* SecurityAudit
+ *
+ * Arguments:
+ *	format is the formatting string to be used to interpret the
+ *	  remaining arguments.
+ *
+ * Returns: nothing.
+ *
+ * Side Effects:
+ *	Writes the message to the log file if security logging is on.
+ */
+
+static void
+SecurityAudit(char *format, ...)
+{
+    va_list args;
+
+    if (auditTrailLevel < SECURITY_AUDIT_LEVEL)
+	return;
+    va_start(args, format);
+    VAuditF(format, args);
+    va_end(args);
+} /* SecurityAudit */
+
+/*
+ * Performs a Security permission check.
+ */
+static int
+SecurityDoCheck(SecurityStateRec *subj, SecurityStateRec *obj,
+		Mask requested, Mask allowed)
+{
+    if (!subj->haveState || !obj->haveState)
+	return Success;
+    if (subj->trustLevel == XSecurityClientTrusted)
+	return Success;
+    if (obj->trustLevel != XSecurityClientTrusted)
+	return Success;
+    if ((requested | allowed) == allowed)
+	return Success;
+
+    return BadAccess;
+}
+
+/*
+ * Labels initial server objects.
+ */
+static void
+SecurityLabelInitial(void)
+{
+    SecurityStateRec *state;
+
+    /* Do the serverClient */
+    state = dixLookupPrivate(&serverClient->devPrivates, stateKey);
+    state->trustLevel = XSecurityClientTrusted;
+    state->haveState = TRUE;
+}
+
+/*
+ * Looks up a request name
+ */
+static _X_INLINE const char *
+SecurityLookupRequestName(ClientPtr client)
+{
+    int major = ((xReq *)client->requestBuffer)->reqType;
+    int minor = MinorOpcodeOfRequest(client);
+    return LookupRequestName(major, minor);
+}
+
+
+/* SecurityDeleteAuthorization
+ *
+ * Arguments:
+ *	value is the authorization to delete.
+ *	id is its resource ID.
+ *
+ * Returns: Success.
+ *
+ * Side Effects:
+ *	Frees everything associated with the authorization.
+ */
+
+static int
+SecurityDeleteAuthorization(
+    pointer value,
+    XID id)
+{
+    SecurityAuthorizationPtr pAuth = (SecurityAuthorizationPtr)value;
+    unsigned short name_len, data_len;
+    char *name, *data;
+    int status;
+    int i;
+    OtherClientsPtr pEventClient;
+
+    /* Remove the auth using the os layer auth manager */
+
+    status = AuthorizationFromID(pAuth->id, &name_len, &name,
+				 &data_len, &data);
+    assert(status);
+    status = RemoveAuthorization(name_len, name, data_len, data);
+    assert(status);
+    (void)status;
+
+    /* free the auth timer if there is one */
+
+    if (pAuth->timer) TimerFree(pAuth->timer);
+
+    /* send revoke events */
+
+    while ((pEventClient = pAuth->eventClients))
+    {
+	/* send revocation event event */
+	xSecurityAuthorizationRevokedEvent are;
+	are.type = SecurityEventBase + XSecurityAuthorizationRevoked;
+	are.authId = pAuth->id;
+	WriteEventsToClient(rClient(pEventClient), 1, (xEvent *)&are);
+	FreeResource(pEventClient->resource, RT_NONE);
+    }
+
+    /* kill all clients using this auth */
+
+    for (i = 1; i<currentMaxClients; i++)
+	if (clients[i]) {
+	    SecurityStateRec *state;
+	    state = dixLookupPrivate(&clients[i]->devPrivates, stateKey);
+	    if (state->haveState && state->authId == pAuth->id)
+		CloseDownClient(clients[i]);
+	}
+
+    SecurityAudit("revoked authorization ID %d\n", pAuth->id);
+    free(pAuth);
+    return Success;
+
+} /* SecurityDeleteAuthorization */
+
+
+/* resource delete function for RTEventClient */
+static int
+SecurityDeleteAuthorizationEventClient(
+    pointer value,
+    XID id)
+{
+    OtherClientsPtr pEventClient, prev = NULL;
+    SecurityAuthorizationPtr pAuth = (SecurityAuthorizationPtr)value;
+
+    for (pEventClient = pAuth->eventClients;
+	 pEventClient;
+	 pEventClient = pEventClient->next)
+    {
+	if (pEventClient->resource == id)
+	{
+	    if (prev)
+		prev->next = pEventClient->next;
+	    else
+		pAuth->eventClients = pEventClient->next;
+	    free(pEventClient);
+	    return Success;
+	}
+	prev = pEventClient;
+    }
+    /*NOTREACHED*/
+    return -1; /* make compiler happy */
+} /* SecurityDeleteAuthorizationEventClient */
+
+
+/* SecurityComputeAuthorizationTimeout
+ *
+ * Arguments:
+ *	pAuth is the authorization for which we are computing the timeout
+ *	seconds is the number of seconds we want to wait
+ *
+ * Returns:
+ *	the number of milliseconds that the auth timer should be set to
+ *
+ * Side Effects:
+ *	Sets pAuth->secondsRemaining to any "overflow" amount of time
+ *	that didn't fit in 32 bits worth of milliseconds
+ */
+
+static CARD32
+SecurityComputeAuthorizationTimeout(
+    SecurityAuthorizationPtr pAuth,
+    unsigned int seconds)
+{
+    /* maxSecs is the number of full seconds that can be expressed in
+     * 32 bits worth of milliseconds
+     */
+    CARD32 maxSecs = (CARD32)(~0) / (CARD32)MILLI_PER_SECOND;
+
+    if (seconds > maxSecs)
+    { /* only come here if we want to wait more than 49 days */
+	pAuth->secondsRemaining = seconds - maxSecs;
+	return maxSecs * MILLI_PER_SECOND;
+    }
+    else
+    { /* by far the common case */
+	pAuth->secondsRemaining = 0;
+	return seconds * MILLI_PER_SECOND;
+    }
+} /* SecurityStartAuthorizationTimer */
+
+/* SecurityAuthorizationExpired
+ *
+ * This function is passed as an argument to TimerSet and gets called from
+ * the timer manager in the os layer when its time is up.
+ *
+ * Arguments:
+ *	timer is the timer for this authorization.
+ *	time is the current time.
+ *	pval is the authorization whose time is up.
+ *
+ * Returns:
+ *	A new time delay in milliseconds if the timer should wait some
+ *	more, else zero.
+ *
+ * Side Effects:
+ *	Frees the authorization resource if the timeout period is really
+ *	over, otherwise recomputes pAuth->secondsRemaining.
+ */
+
+static CARD32
+SecurityAuthorizationExpired(
+    OsTimerPtr timer,
+    CARD32 time,
+    pointer pval)
+{
+    SecurityAuthorizationPtr pAuth = (SecurityAuthorizationPtr)pval;
+
+    assert(pAuth->timer == timer);
+
+    if (pAuth->secondsRemaining)
+    {
+	return SecurityComputeAuthorizationTimeout(pAuth,
+						   pAuth->secondsRemaining);
+    }
+    else
+    {
+	FreeResource(pAuth->id, RT_NONE);
+	return 0;
+    }
+} /* SecurityAuthorizationExpired */
+
+/* SecurityStartAuthorizationTimer
+ *
+ * Arguments:
+ *	pAuth is the authorization whose timer should be started.
+ *
+ * Returns: nothing.
+ *
+ * Side Effects:
+ *	A timer is started, set to expire after the timeout period for
+ *	this authorization.  When it expires, the function
+ *	SecurityAuthorizationExpired will be called.
+ */
+
+static void
+SecurityStartAuthorizationTimer(
+    SecurityAuthorizationPtr pAuth)
+{
+    pAuth->timer = TimerSet(pAuth->timer, 0,
+	SecurityComputeAuthorizationTimeout(pAuth, pAuth->timeout),
+			    SecurityAuthorizationExpired, pAuth);
+} /* SecurityStartAuthorizationTimer */
+
+
+/* Proc functions all take a client argument, execute the request in
+ * client->requestBuffer, and return a protocol error status.
+ */
+
+static int
+ProcSecurityQueryVersion(
+    ClientPtr client)
+{
+    /* REQUEST(xSecurityQueryVersionReq); */
+    xSecurityQueryVersionReply 	rep;
+
+    REQUEST_SIZE_MATCH(xSecurityQueryVersionReq);
+    rep.type        	= X_Reply;
+    rep.sequenceNumber 	= client->sequence;
+    rep.length         	= 0;
+    rep.majorVersion  	= SERVER_SECURITY_MAJOR_VERSION;
+    rep.minorVersion  	= SERVER_SECURITY_MINOR_VERSION;
+    if(client->swapped)
+    {
+	swaps(&rep.sequenceNumber);
+	swaps(&rep.majorVersion);
+	swaps(&rep.minorVersion);
+    }
+    (void)WriteToClient(client, SIZEOF(xSecurityQueryVersionReply),
+			(char *)&rep);
+    return Success;
+} /* ProcSecurityQueryVersion */
+
+
+static int
+SecurityEventSelectForAuthorization(
+    SecurityAuthorizationPtr pAuth,
+    ClientPtr client,
+    Mask mask)
+{
+    OtherClients *pEventClient;
+
+    for (pEventClient = pAuth->eventClients;
+	 pEventClient;
+	 pEventClient = pEventClient->next)
+    {
+	if (SameClient(pEventClient, client))
+	{
+	    if (mask == 0)
+		FreeResource(pEventClient->resource, RT_NONE);
+	    else
+		pEventClient->mask = mask;
+	    return Success;
+	}
+    }
+    
+    pEventClient = malloc(sizeof(OtherClients));
+    if (!pEventClient)
+	return BadAlloc;
+    pEventClient->mask = mask;
+    pEventClient->resource = FakeClientID(client->index);
+    pEventClient->next = pAuth->eventClients;
+    if (!AddResource(pEventClient->resource, RTEventClient,
+		     (pointer)pAuth))
+    {
+	free(pEventClient);
+	return BadAlloc;
+    }
+    pAuth->eventClients = pEventClient;
+
+    return Success;
+} /* SecurityEventSelectForAuthorization */
+
+
+static int
+ProcSecurityGenerateAuthorization(
+    ClientPtr client)
+{
+    REQUEST(xSecurityGenerateAuthorizationReq);
+    int len;			/* request length in CARD32s*/
+    Bool removeAuth = FALSE;	/* if bailout, call RemoveAuthorization? */
+    SecurityAuthorizationPtr pAuth = NULL;  /* auth we are creating */
+    int err;			/* error to return from this function */
+    XID authId;			/* authorization ID assigned by os layer */
+    xSecurityGenerateAuthorizationReply rep; /* reply struct */
+    unsigned int trustLevel;    /* trust level of new auth */
+    XID group;			/* group of new auth */
+    CARD32 timeout;		/* timeout of new auth */
+    CARD32 *values;		/* list of supplied attributes */
+    char *protoname;		/* auth proto name sent in request */
+    char *protodata;		/* auth proto data sent in request */
+    unsigned int authdata_len;  /* # bytes of generated auth data */
+    char *pAuthdata;		/* generated auth data */
+    Mask eventMask;		/* what events on this auth does client want */
+
+    /* check request length */
+
+    REQUEST_AT_LEAST_SIZE(xSecurityGenerateAuthorizationReq);
+    len = bytes_to_int32(SIZEOF(xSecurityGenerateAuthorizationReq));
+    len += bytes_to_int32(stuff->nbytesAuthProto);
+    len += bytes_to_int32(stuff->nbytesAuthData);
+    values = ((CARD32 *)stuff) + len;
+    len += Ones(stuff->valueMask);
+    if (client->req_len != len)
+	return BadLength;
+
+    /* check valuemask */
+    if (stuff->valueMask & ~XSecurityAllAuthorizationAttributes)
+    {
+	client->errorValue = stuff->valueMask;
+	return BadValue;
+    }
+
+    /* check timeout */
+    timeout = 60;
+    if (stuff->valueMask & XSecurityTimeout)
+    {
+	timeout = *values++;
+    }
+
+    /* check trustLevel */
+    trustLevel = XSecurityClientUntrusted;
+    if (stuff->valueMask & XSecurityTrustLevel)
+    {
+	trustLevel = *values++;
+	if (trustLevel != XSecurityClientTrusted &&
+	    trustLevel != XSecurityClientUntrusted)
+	{
+	    client->errorValue = trustLevel;
+	    return BadValue;
+	}
+    }
+
+    /* check group */
+    group = None;
+    if (stuff->valueMask & XSecurityGroup)
+    {
+	group = *values++;
+	if (SecurityValidateGroupCallback)
+	{
+	    SecurityValidateGroupInfoRec vgi;
+	    vgi.group = group;
+	    vgi.valid = FALSE;
+	    CallCallbacks(&SecurityValidateGroupCallback, (pointer)&vgi);
+
+	    /* if nobody said they recognized it, it's an error */
+
+	    if (!vgi.valid)
+	    {
+		client->errorValue = group;
+		return BadValue;
+	    }
+	}
+    }
+
+    /* check event mask */
+    eventMask = 0;
+    if (stuff->valueMask & XSecurityEventMask)
+    {
+	eventMask = *values++;
+	if (eventMask & ~XSecurityAllEventMasks)
+	{
+	    client->errorValue = eventMask;
+	    return BadValue;
+	}
+    }
+
+    protoname = (char *)&stuff[1];
+    protodata = protoname + bytes_to_int32(stuff->nbytesAuthProto);
+
+    /* call os layer to generate the authorization */
+
+    authId = GenerateAuthorization(stuff->nbytesAuthProto, protoname,
+				   stuff->nbytesAuthData,  protodata,
+				   &authdata_len, &pAuthdata);
+    if ((XID) ~0L == authId)
+    {
+	err = SecurityErrorBase + XSecurityBadAuthorizationProtocol;
+	goto bailout;
+    }
+
+    /* now that we've added the auth, remember to remove it if we have to
+     * abort the request for some reason (like allocation failure)
+     */
+    removeAuth = TRUE;
+
+    /* associate additional information with this auth ID */
+
+    pAuth = malloc(sizeof(SecurityAuthorizationRec));
+    if (!pAuth)
+    {
+	err = BadAlloc;
+	goto bailout;
+    }
+
+    /* fill in the auth fields */
+
+    pAuth->id = authId;
+    pAuth->timeout = timeout;
+    pAuth->group = group;
+    pAuth->trustLevel = trustLevel;
+    pAuth->refcnt = 0;	/* the auth was just created; nobody's using it yet */
+    pAuth->secondsRemaining = 0;
+    pAuth->timer = NULL;
+    pAuth->eventClients = NULL;
+
+    /* handle event selection */
+    if (eventMask)
+    {
+	err = SecurityEventSelectForAuthorization(pAuth, client, eventMask);
+	if (err != Success)
+	    goto bailout;
+    }
+
+    if (!AddResource(authId, SecurityAuthorizationResType, pAuth))
+    {
+	err = BadAlloc;
+	goto bailout;
+    }
+
+    /* start the timer ticking */
+
+    if (pAuth->timeout != 0)
+	SecurityStartAuthorizationTimer(pAuth);
+
+    /* tell client the auth id and data */
+
+    rep.type = X_Reply;
+    rep.length = bytes_to_int32(authdata_len);
+    rep.sequenceNumber = client->sequence;
+    rep.authId = authId;
+    rep.dataLength = authdata_len;
+
+    if (client->swapped)
+    {
+	swapl(&rep.length);
+	swaps(&rep.sequenceNumber);
+	swapl(&rep.authId);
+	swaps(&rep.dataLength);
+    }
+
+    WriteToClient(client, SIZEOF(xSecurityGenerateAuthorizationReply),
+		  (char *)&rep);
+    WriteToClient(client, authdata_len, pAuthdata);
+
+    SecurityAudit("client %d generated authorization %d trust %d timeout %d group %d events %d\n",
+		  client->index, pAuth->id, pAuth->trustLevel, pAuth->timeout,
+		  pAuth->group, eventMask);
+
+    /* the request succeeded; don't call RemoveAuthorization or free pAuth */
+    return Success;
+
+bailout:
+    if (removeAuth)
+	RemoveAuthorization(stuff->nbytesAuthProto, protoname,
+			    authdata_len, pAuthdata);
+    free(pAuth);
+    return err;
+
+} /* ProcSecurityGenerateAuthorization */
+
+static int
+ProcSecurityRevokeAuthorization(
+    ClientPtr client)
+{
+    REQUEST(xSecurityRevokeAuthorizationReq);
+    SecurityAuthorizationPtr pAuth;
+    int rc;
+
+    REQUEST_SIZE_MATCH(xSecurityRevokeAuthorizationReq);
+
+    rc = dixLookupResourceByType((pointer *)&pAuth, stuff->authId,
+				 SecurityAuthorizationResType, client,
+				 DixDestroyAccess);
+    if (rc != Success)
+	return rc;
+
+    FreeResource(stuff->authId, RT_NONE);
+    return Success;
+} /* ProcSecurityRevokeAuthorization */
+
+
+static int
+ProcSecurityDispatch(
+    ClientPtr client)
+{
+    REQUEST(xReq);
+
+    switch (stuff->data)
+    {
+	case X_SecurityQueryVersion:
+	    return ProcSecurityQueryVersion(client);
+	case X_SecurityGenerateAuthorization:
+	    return ProcSecurityGenerateAuthorization(client);
+	case X_SecurityRevokeAuthorization:
+	    return ProcSecurityRevokeAuthorization(client);
+	default:
+	    return BadRequest;
+    }
+} /* ProcSecurityDispatch */
+
+static int
+SProcSecurityQueryVersion(
+    ClientPtr client)
+{
+    REQUEST(xSecurityQueryVersionReq);
+
+    swaps(&stuff->length);
+    REQUEST_SIZE_MATCH(xSecurityQueryVersionReq);
+    swaps(&stuff->majorVersion);
+    swaps(&stuff->minorVersion);
+    return ProcSecurityQueryVersion(client);
+} /* SProcSecurityQueryVersion */
+
+
+static int
+SProcSecurityGenerateAuthorization(
+    ClientPtr client)
+{
+    REQUEST(xSecurityGenerateAuthorizationReq);
+    CARD32 *values;
+    unsigned long nvalues;
+    int values_offset;
+
+    swaps(&stuff->length);
+    REQUEST_AT_LEAST_SIZE(xSecurityGenerateAuthorizationReq);
+    swaps(&stuff->nbytesAuthProto);
+    swaps(&stuff->nbytesAuthData);
+    swapl(&stuff->valueMask);
+    values_offset = bytes_to_int32(stuff->nbytesAuthProto) +
+		    bytes_to_int32(stuff->nbytesAuthData);
+    if (values_offset > 
+	stuff->length - bytes_to_int32(sz_xSecurityGenerateAuthorizationReq))
+	return BadLength;
+    values = (CARD32 *)(&stuff[1]) + values_offset;
+    nvalues = (((CARD32 *)stuff) + stuff->length) - values;
+    SwapLongs(values, nvalues);
+    return ProcSecurityGenerateAuthorization(client);
+} /* SProcSecurityGenerateAuthorization */
+
+
+static int
+SProcSecurityRevokeAuthorization(
+    ClientPtr client)
+{
+    REQUEST(xSecurityRevokeAuthorizationReq);
+
+    swaps(&stuff->length);
+    REQUEST_SIZE_MATCH(xSecurityRevokeAuthorizationReq);
+    swapl(&stuff->authId);
+    return ProcSecurityRevokeAuthorization(client);
+} /* SProcSecurityRevokeAuthorization */
+
+
+static int
+SProcSecurityDispatch(
+    ClientPtr client)
+{
+    REQUEST(xReq);
+
+    switch (stuff->data)
+    {
+	case X_SecurityQueryVersion:
+	    return SProcSecurityQueryVersion(client);
+	case X_SecurityGenerateAuthorization:
+	    return SProcSecurityGenerateAuthorization(client);
+	case X_SecurityRevokeAuthorization:
+	    return SProcSecurityRevokeAuthorization(client);
+	default:
+	    return BadRequest;
+    }
+} /* SProcSecurityDispatch */
+
+static void 
+SwapSecurityAuthorizationRevokedEvent(
+    xSecurityAuthorizationRevokedEvent *from,
+    xSecurityAuthorizationRevokedEvent *to)
+{
+    to->type = from->type;
+    to->detail = from->detail;
+    cpswaps(from->sequenceNumber, to->sequenceNumber);
+    cpswapl(from->authId, to->authId);
+}
+
+/* SecurityCheckDeviceAccess
+ *
+ * Arguments:
+ *	client is the client attempting to access a device.
+ *	dev is the device being accessed.
+ *	fromRequest is TRUE if the device access is a direct result of
+ *	  the client executing some request and FALSE if it is a
+ *	  result of the server trying to send an event (e.g. KeymapNotify)
+ *	  to the client.
+ * Returns:
+ *	TRUE if the device access should be allowed, else FALSE.
+ *
+ * Side Effects:
+ *	An audit message is generated if access is denied.
+ */
+
+static void
+SecurityDevice(CallbackListPtr *pcbl, pointer unused, pointer calldata)
+{
+    XaceDeviceAccessRec *rec = calldata;
+    SecurityStateRec *subj, *obj;
+    Mask requested = rec->access_mode;
+    Mask allowed = SecurityDeviceMask;
+
+    subj = dixLookupPrivate(&rec->client->devPrivates, stateKey);
+    obj = dixLookupPrivate(&serverClient->devPrivates, stateKey);
+
+    if (rec->dev != inputInfo.keyboard)
+	/* this extension only supports the core keyboard */
+	allowed = requested;
+
+    if (SecurityDoCheck(subj, obj, requested, allowed) != Success) {
+	SecurityAudit("Security denied client %d keyboard access on request "
+		      "%s\n", rec->client->index,
+		      SecurityLookupRequestName(rec->client));
+	rec->status = BadAccess;
+    }
+}
+
+/* SecurityResource
+ *
+ * This function gets plugged into client->CheckAccess and is called from
+ * SecurityLookupIDByType/Class to determine if the client can access the
+ * resource.
+ *
+ * Arguments:
+ *	client is the client doing the resource access.
+ *	id is the resource id.
+ *	rtype is its type or class.
+ *	access_mode represents the intended use of the resource; see
+ *	  resource.h.
+ *	res is a pointer to the resource structure for this resource.
+ *
+ * Returns:
+ *	If access is granted, the value of rval that was passed in, else FALSE.
+ *
+ * Side Effects:
+ *	Disallowed resource accesses are audited.
+ */
+
+static void
+SecurityResource(CallbackListPtr *pcbl, pointer unused, pointer calldata)
+{
+    XaceResourceAccessRec *rec = calldata;
+    SecurityStateRec *subj, *obj;
+    int cid = CLIENT_ID(rec->id);
+    Mask requested = rec->access_mode;
+    Mask allowed = SecurityResourceMask;
+
+    subj = dixLookupPrivate(&rec->client->devPrivates, stateKey);
+
+    /* disable background None for untrusted windows */
+    if ((requested & DixCreateAccess) && (rec->rtype == RT_WINDOW))
+	if (subj->haveState && subj->trustLevel != XSecurityClientTrusted)
+	    ((WindowPtr)rec->res)->forcedBG = TRUE;
+
+    /* additional permissions for specific resource types */
+    if (rec->rtype == RT_WINDOW)
+	allowed |= SecurityWindowExtraMask;
+
+    /* special checks for server-owned resources */
+    if (cid == 0) {
+	if (rec->rtype & RC_DRAWABLE)
+	    /* additional operations allowed on root windows */
+	    allowed |= SecurityRootWindowExtraMask;
+
+	else if (rec->rtype == RT_COLORMAP)
+	    /* allow access to default colormaps */
+	    allowed = requested;
+
+	else
+	    /* allow read access to other server-owned resources */
+	    allowed |= DixReadAccess;
+    }
+
+    if (clients[cid] != NULL) {
+	obj = dixLookupPrivate(&clients[cid]->devPrivates, stateKey);
+	if (SecurityDoCheck(subj, obj, requested, allowed) == Success)
+	    return;
+    }
+
+    SecurityAudit("Security: denied client %d access %x to resource 0x%x "
+		  "of client %d on request %s\n", rec->client->index,
+		  requested, rec->id, cid,
+		  SecurityLookupRequestName(rec->client));
+    rec->status = BadAccess; /* deny access */
+}
+
+
+static void
+SecurityExtension(CallbackListPtr *pcbl, pointer unused, pointer calldata)
+{
+    XaceExtAccessRec *rec = calldata;
+    SecurityStateRec *subj;
+    int i = 0;
+
+    subj = dixLookupPrivate(&rec->client->devPrivates, stateKey);
+
+    if (subj->haveState && subj->trustLevel == XSecurityClientTrusted)
+	return;
+
+    while (SecurityTrustedExtensions[i])
+	if (!strcmp(SecurityTrustedExtensions[i++], rec->ext->name))
+	    return;
+
+    SecurityAudit("Security: denied client %d access to extension "
+		  "%s on request %s\n",
+		  rec->client->index, rec->ext->name,
+		  SecurityLookupRequestName(rec->client));
+    rec->status = BadAccess;
+}
+
+static void
+SecurityServer(CallbackListPtr *pcbl, pointer unused, pointer calldata)
+{
+    XaceServerAccessRec *rec = calldata;
+    SecurityStateRec *subj, *obj;
+    Mask requested = rec->access_mode;
+    Mask allowed = SecurityServerMask;
+
+    subj = dixLookupPrivate(&rec->client->devPrivates, stateKey);
+    obj = dixLookupPrivate(&serverClient->devPrivates, stateKey);
+ 
+    if (SecurityDoCheck(subj, obj, requested, allowed) != Success) {
+	SecurityAudit("Security: denied client %d access to server "
+		      "configuration request %s\n", rec->client->index,
+		      SecurityLookupRequestName(rec->client));
+	rec->status = BadAccess;
+    }
+}
+
+static void
+SecurityClient(CallbackListPtr *pcbl, pointer unused, pointer calldata)
+{
+    XaceClientAccessRec *rec = calldata;
+    SecurityStateRec *subj, *obj;
+    Mask requested = rec->access_mode;
+    Mask allowed = SecurityClientMask;
+
+    subj = dixLookupPrivate(&rec->client->devPrivates, stateKey);
+    obj = dixLookupPrivate(&rec->target->devPrivates, stateKey);
+
+    if (SecurityDoCheck(subj, obj, requested, allowed) != Success) {
+	SecurityAudit("Security: denied client %d access to client %d on "
+		      "request %s\n", rec->client->index, rec->target->index,
+		      SecurityLookupRequestName(rec->client));
+	rec->status = BadAccess;
+    }
+}
+
+static void
+SecurityProperty(CallbackListPtr *pcbl, pointer unused, pointer calldata)
+{    
+    XacePropertyAccessRec *rec = calldata;
+    SecurityStateRec *subj, *obj;
+    ATOM name = (*rec->ppProp)->propertyName;
+    Mask requested = rec->access_mode;
+    Mask allowed = SecurityResourceMask | DixReadAccess;
+
+    subj = dixLookupPrivate(&rec->client->devPrivates, stateKey);
+    obj = dixLookupPrivate(&wClient(rec->pWin)->devPrivates, stateKey);
+
+    if (SecurityDoCheck(subj, obj, requested, allowed) != Success) {
+	SecurityAudit("Security: denied client %d access to property %s "
+		      "(atom 0x%x) window 0x%x of client %d on request %s\n",
+		      rec->client->index, NameForAtom(name), name,
+		      rec->pWin->drawable.id, wClient(rec->pWin)->index,
+		      SecurityLookupRequestName(rec->client));
+	rec->status = BadAccess;
+    }
+}
+
+static void
+SecuritySend(CallbackListPtr *pcbl, pointer unused, pointer calldata)
+{
+    XaceSendAccessRec *rec = calldata;
+    SecurityStateRec *subj, *obj;
+
+    if (rec->client) {
+	int i;
+
+	subj = dixLookupPrivate(&rec->client->devPrivates, stateKey);
+	obj = dixLookupPrivate(&wClient(rec->pWin)->devPrivates, stateKey);
+
+	if (SecurityDoCheck(subj, obj, DixSendAccess, 0) == Success)
+	    return;
+
+	for (i = 0; i < rec->count; i++)
+	    if (rec->events[i].u.u.type != UnmapNotify &&
+		rec->events[i].u.u.type != ConfigureRequest &&
+		rec->events[i].u.u.type != ClientMessage) {
+
+		SecurityAudit("Security: denied client %d from sending event "
+			      "of type %s to window 0x%x of client %d\n",
+			      rec->client->index,
+			      LookupEventName(rec->events[i].u.u.type),
+			      rec->pWin->drawable.id,
+			      wClient(rec->pWin)->index);
+		rec->status = BadAccess;
+		return;
+	    }
+    }
+}
+
+static void
+SecurityReceive(CallbackListPtr *pcbl, pointer unused, pointer calldata)
+{
+    XaceReceiveAccessRec *rec = calldata;
+    SecurityStateRec *subj, *obj;
+
+    subj = dixLookupPrivate(&rec->client->devPrivates, stateKey);
+    obj = dixLookupPrivate(&wClient(rec->pWin)->devPrivates, stateKey);
+
+    if (SecurityDoCheck(subj, obj, DixReceiveAccess, 0) == Success)
+	return;
+
+    SecurityAudit("Security: denied client %d from receiving an event "
+		  "sent to window 0x%x of client %d\n",
+		  rec->client->index, rec->pWin->drawable.id,
+		  wClient(rec->pWin)->index);
+    rec->status = BadAccess;
+}
+
+/* SecurityClientStateCallback
+ *
+ * Arguments:
+ *	pcbl is &ClientStateCallback.
+ *	nullata is NULL.
+ *	calldata is a pointer to a NewClientInfoRec (include/dixstruct.h)
+ *	which contains information about client state changes.
+ *
+ * Returns: nothing.
+ *
+ * Side Effects:
+ * 
+ * If a new client is connecting, its authorization ID is copied to
+ * client->authID.  If this is a generated authorization, its reference
+ * count is bumped, its timer is cancelled if it was running, and its
+ * trustlevel is copied to TRUSTLEVEL(client).
+ * 
+ * If a client is disconnecting and the client was using a generated
+ * authorization, the authorization's reference count is decremented, and
+ * if it is now zero, the timer for this authorization is started.
+ */
+
+static void
+SecurityClientState(CallbackListPtr *pcbl, pointer unused, pointer calldata)
+{
+    NewClientInfoRec *pci = calldata;
+    SecurityStateRec *state;
+    SecurityAuthorizationPtr pAuth;
+    int rc;
+
+    state = dixLookupPrivate(&pci->client->devPrivates, stateKey);
+
+    switch (pci->client->clientState) {
+    case ClientStateInitial:
+	state->trustLevel = XSecurityClientTrusted;
+	state->authId = None;
+	state->haveState = TRUE;
+	break;
+
+    case ClientStateRunning:
+	state->authId = AuthorizationIDOfClient(pci->client);
+	rc = dixLookupResourceByType((pointer *)&pAuth, state->authId,
+			       SecurityAuthorizationResType, serverClient,
+			       DixGetAttrAccess);
+	if (rc == Success) {
+	    /* it is a generated authorization */
+	    pAuth->refcnt++;
+	    if (pAuth->refcnt == 1 && pAuth->timer)
+		TimerCancel(pAuth->timer);
+
+	    state->trustLevel = pAuth->trustLevel;
+	}
+	break;
+
+    case ClientStateGone:
+    case ClientStateRetained:
+	rc = dixLookupResourceByType((pointer *)&pAuth, state->authId,
+			       SecurityAuthorizationResType, serverClient,
+			       DixGetAttrAccess);
+	if (rc == Success) {
+	    /* it is a generated authorization */
+	    pAuth->refcnt--;
+	    if (pAuth->refcnt == 0)
+		SecurityStartAuthorizationTimer(pAuth);
+	}
+	break;
+
+    default:
+	break;
+    }
+}
+
+/* SecurityResetProc
+ *
+ * Arguments:
+ *	extEntry is the extension information for the security extension.
+ *
+ * Returns: nothing.
+ *
+ * Side Effects:
+ *	Performs any cleanup needed by Security at server shutdown time.
+ */
+
+static void
+SecurityResetProc(
+    ExtensionEntry *extEntry)
+{
+    /* Unregister callbacks */
+    DeleteCallback(&ClientStateCallback, SecurityClientState, NULL);
+
+    XaceDeleteCallback(XACE_EXT_DISPATCH, SecurityExtension, NULL);
+    XaceDeleteCallback(XACE_RESOURCE_ACCESS, SecurityResource, NULL);
+    XaceDeleteCallback(XACE_DEVICE_ACCESS, SecurityDevice, NULL);
+    XaceDeleteCallback(XACE_PROPERTY_ACCESS, SecurityProperty, NULL);
+    XaceDeleteCallback(XACE_SEND_ACCESS, SecuritySend, NULL);
+    XaceDeleteCallback(XACE_RECEIVE_ACCESS, SecurityReceive, NULL);
+    XaceDeleteCallback(XACE_CLIENT_ACCESS, SecurityClient, NULL);
+    XaceDeleteCallback(XACE_EXT_ACCESS, SecurityExtension, NULL);
+    XaceDeleteCallback(XACE_SERVER_ACCESS, SecurityServer, NULL);
+}
+
+
+/* SecurityExtensionInit
+ *
+ * Arguments: none.
+ *
+ * Returns: nothing.
+ *
+ * Side Effects:
+ *	Enables the Security extension if possible.
+ */
+
+void
+SecurityExtensionInit(INITARGS)
+{
+    ExtensionEntry	*extEntry;
+    int ret = TRUE;
+
+    SecurityAuthorizationResType =
+	CreateNewResourceType(SecurityDeleteAuthorization,
+			      "SecurityAuthorization");
+
+    RTEventClient =
+	CreateNewResourceType(SecurityDeleteAuthorizationEventClient,
+			      "SecurityEventClient");
+
+    if (!SecurityAuthorizationResType || !RTEventClient)
+	return;
+
+    RTEventClient |= RC_NEVERRETAIN;
+
+    /* Allocate the private storage */
+    if (!dixRegisterPrivateKey(stateKey, PRIVATE_CLIENT, sizeof(SecurityStateRec)))
+	FatalError("SecurityExtensionSetup: Can't allocate client private.\n");
+
+    /* Register callbacks */
+    ret &= AddCallback(&ClientStateCallback, SecurityClientState, NULL);
+
+    ret &= XaceRegisterCallback(XACE_EXT_DISPATCH, SecurityExtension, NULL);
+    ret &= XaceRegisterCallback(XACE_RESOURCE_ACCESS, SecurityResource, NULL);
+    ret &= XaceRegisterCallback(XACE_DEVICE_ACCESS, SecurityDevice, NULL);
+    ret &= XaceRegisterCallback(XACE_PROPERTY_ACCESS, SecurityProperty, NULL);
+    ret &= XaceRegisterCallback(XACE_SEND_ACCESS, SecuritySend, NULL);
+    ret &= XaceRegisterCallback(XACE_RECEIVE_ACCESS, SecurityReceive, NULL);
+    ret &= XaceRegisterCallback(XACE_CLIENT_ACCESS, SecurityClient, NULL);
+    ret &= XaceRegisterCallback(XACE_EXT_ACCESS, SecurityExtension, NULL);
+    ret &= XaceRegisterCallback(XACE_SERVER_ACCESS, SecurityServer, NULL);
+
+    if (!ret)
+	FatalError("SecurityExtensionSetup: Failed to register callbacks\n");
+
+    /* Add extension to server */
+    extEntry = AddExtension(SECURITY_EXTENSION_NAME,
+			    XSecurityNumberEvents, XSecurityNumberErrors,
+			    ProcSecurityDispatch, SProcSecurityDispatch,
+                            SecurityResetProc, StandardMinorOpcode);
+
+    SecurityErrorBase = extEntry->errorBase;
+    SecurityEventBase = extEntry->eventBase;
+
+    EventSwapVector[SecurityEventBase + XSecurityAuthorizationRevoked] =
+	(EventSwapPtr)SwapSecurityAuthorizationRevokedEvent;
+
+    SetResourceTypeErrorValue(SecurityAuthorizationResType, SecurityErrorBase + XSecurityBadAuthorization);
+
+    /* Label objects that were created before we could register ourself */
+    SecurityLabelInitial();
+}
diff --git a/xorg-server/Xext/shape.c b/xorg-server/Xext/shape.c
index 6a35a0451..3263c0224 100644
--- a/xorg-server/Xext/shape.c
+++ b/xorg-server/Xext/shape.c
@@ -1,1262 +1,1246 @@
-/************************************************************

-

-Copyright 1989, 1998  The Open Group

-

-Permission to use, copy, modify, distribute, and sell this software and its

-documentation for any purpose is hereby granted without fee, provided that

-the above copyright notice appear in all copies and that both that

-copyright notice and this permission notice appear in supporting

-documentation.

-

-The above copyright notice and this permission notice shall be included in

-all copies or substantial portions of the Software.

-

-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE

-OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN

-AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN

-CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

-

-Except as contained in this notice, the name of The Open Group shall not be

-used in advertising or otherwise to promote the sale, use or other dealings

-in this Software without prior written authorization from The Open Group.

-

-********************************************************/

-

-#ifdef HAVE_DIX_CONFIG_H

-#include <dix-config.h>

-#else

-#define SHAPE

-#endif

-

-#include <stdlib.h>

-

-#include <X11/X.h>

-#include <X11/Xproto.h>

-#include "misc.h"

-#include "os.h"

-#include "windowstr.h"

-#include "scrnintstr.h"

-#include "pixmapstr.h"

-#include "extnsionst.h"

-#include "dixstruct.h"

-#include "resource.h"

-#include "opaque.h"

-#include <X11/extensions/shapeproto.h>

-#include "regionstr.h"

-#include "gcstruct.h"

-#include "modinit.h"

-#include "protocol-versions.h"

-

-typedef	RegionPtr (*CreateDftPtr)(

-	WindowPtr /* pWin */

-	);

-

-static int ShapeFreeClient(

-	pointer /* data */,

-	XID /* id */

-	);

-static int ShapeFreeEvents(

-	pointer /* data */,

-	XID /* id */

-	);

-static void SShapeNotifyEvent(

-	xShapeNotifyEvent * /* from */,

-	xShapeNotifyEvent * /* to */

-	);

-

-/* SendShapeNotify, CreateBoundingShape and CreateClipShape are used

- * externally by the Xfixes extension and are now defined in window.h

- */

-

-

-#ifdef PANORAMIX

-#include "panoramiX.h"

-#include "panoramiXsrv.h"

-#endif

-

-static int ShapeEventBase = 0;

-static RESTYPE ClientType, ShapeEventType; /* resource types for event masks */

-

-/*

- * each window has a list of clients requesting

- * ShapeNotify events.  Each client has a resource

- * for each window it selects ShapeNotify input for,

- * this resource is used to delete the ShapeNotifyRec

- * entry from the per-window queue.

- */

-

-typedef struct _ShapeEvent *ShapeEventPtr;

-

-typedef struct _ShapeEvent {

-    ShapeEventPtr   next;

-    ClientPtr	    client;

-    WindowPtr	    window;

-    XID		    clientResource;

-} ShapeEventRec;

-

-/****************

- * ShapeExtensionInit

- *

- * Called from InitExtensions in main() or from QueryExtension() if the

- * extension is dynamically loaded.

- *

- ****************/

-

-static int

-RegionOperate (

-	ClientPtr client,

-	WindowPtr pWin,

-	int kind,

-	RegionPtr *destRgnp,

-	RegionPtr srcRgn,

-	int op,

-	int xoff, int yoff,

-	CreateDftPtr create)

-{

-    if (srcRgn && (xoff || yoff))

-	RegionTranslate(srcRgn, xoff, yoff);

-    if (!pWin->parent)

-    {

-	if (srcRgn)

-	    RegionDestroy(srcRgn);

-	return Success;

-    }

-

-    /* May/30/2001:

-     * The shape.PS specs say if src is None, existing shape is to be

-     * removed (and so the op-code has no meaning in such removal);

-     * see shape.PS, page 3, ShapeMask.

-     */

-    if (srcRgn == NULL) {

-      if (*destRgnp != NULL) {

-	RegionDestroy(*destRgnp);

-	*destRgnp = 0;

-	/* go on to remove shape and generate ShapeNotify */

-      }

-      else {

-	/* May/30/2001:

-	 * The target currently has no shape in effect, so nothing to

-	 * do here.  The specs say that ShapeNotify is generated whenever

-	 * the client region is "modified"; since no modification is done

-	 * here, we do not generate that event.  The specs does not say

-	 * "it is an error to request removal when there is no shape in

-	 * effect", so we return good status.

-	 */

-	return Success;

-      }

-    }

-    else switch (op) {

-    case ShapeSet:

-	if (*destRgnp)

-	    RegionDestroy(*destRgnp);

-	*destRgnp = srcRgn;

-	srcRgn = 0;

-	break;

-    case ShapeUnion:

-	if (*destRgnp)

-	    RegionUnion(*destRgnp, *destRgnp, srcRgn);

-	break;

-    case ShapeIntersect:

-	if (*destRgnp)

-	    RegionIntersect(*destRgnp, *destRgnp, srcRgn);

-	else {

-	    *destRgnp = srcRgn;

-	    srcRgn = 0;

-	}

-	break;

-    case ShapeSubtract:

-	if (!*destRgnp)

-	    *destRgnp = (*create)(pWin);

-	RegionSubtract(*destRgnp, *destRgnp, srcRgn);

-	break;

-    case ShapeInvert:

-	if (!*destRgnp)

-	    *destRgnp = RegionCreate((BoxPtr) 0, 0);

-	else

-	    RegionSubtract(*destRgnp, srcRgn, *destRgnp);

-	break;

-    default:

-	client->errorValue = op;

-	return BadValue;

-    }

-    if (srcRgn)

-	RegionDestroy(srcRgn);

-    (*pWin->drawable.pScreen->SetShape) (pWin, kind);

-    SendShapeNotify (pWin, kind);

-    return Success;

-}

-

-RegionPtr

-CreateBoundingShape (WindowPtr pWin)

-{

-    BoxRec	extents;

-

-    extents.x1 = -wBorderWidth (pWin);

-    extents.y1 = -wBorderWidth (pWin);

-    extents.x2 = pWin->drawable.width + wBorderWidth (pWin);

-    extents.y2 = pWin->drawable.height + wBorderWidth (pWin);

-    return RegionCreate(&extents, 1);

-}

-

-RegionPtr

-CreateClipShape (WindowPtr pWin)

-{

-    BoxRec	extents;

-

-    extents.x1 = 0;

-    extents.y1 = 0;

-    extents.x2 = pWin->drawable.width;

-    extents.y2 = pWin->drawable.height;

-    return RegionCreate(&extents, 1);

-}

-

-static int

-ProcShapeQueryVersion (ClientPtr client)

-{

-    xShapeQueryVersionReply	rep;

-    int		n;

-

-    REQUEST_SIZE_MATCH (xShapeQueryVersionReq);

-    memset(&rep, 0, sizeof(xShapeQueryVersionReply));

-    rep.type = X_Reply;

-    rep.length = 0;

-    rep.sequenceNumber = client->sequence;

-    rep.majorVersion = SERVER_SHAPE_MAJOR_VERSION;

-    rep.minorVersion = SERVER_SHAPE_MINOR_VERSION;

-    if (client->swapped) {

-    	swaps(&rep.sequenceNumber, n);

-    	swapl(&rep.length, n);

-	swaps(&rep.majorVersion, n);

-	swaps(&rep.minorVersion, n);

-    }

-    WriteToClient(client, sizeof (xShapeQueryVersionReply), (char *)&rep);

-    return Success;

-}

-

-/*****************

- * ProcShapeRectangles

- *

- *****************/

-

-static int

-ProcShapeRectangles (ClientPtr client)

-{

-    WindowPtr		pWin;

-    REQUEST(xShapeRectanglesReq);

-    xRectangle		*prects;

-    int		        nrects, ctype, rc;

-    RegionPtr		srcRgn;

-    RegionPtr		*destRgn;

-    CreateDftPtr	createDefault;

-

-    REQUEST_AT_LEAST_SIZE (xShapeRectanglesReq);

-    UpdateCurrentTime();

-    rc = dixLookupWindow(&pWin, stuff->dest, client, DixSetAttrAccess);

-    if (rc != Success)

-	return rc;

-    switch (stuff->destKind) {

-    case ShapeBounding:

-	createDefault = CreateBoundingShape;

-	break;

-    case ShapeClip:

-	createDefault = CreateClipShape;

-	break;

-    case ShapeInput:

-	createDefault = CreateBoundingShape;

-	break;

-    default:

-	client->errorValue = stuff->destKind;

-	return BadValue;

-    }

-    if ((stuff->ordering != Unsorted) && (stuff->ordering != YSorted) &&

-	(stuff->ordering != YXSorted) && (stuff->ordering != YXBanded))

-    {

-	client->errorValue = stuff->ordering;

-        return BadValue;

-    }

-    nrects = ((stuff->length  << 2) - sizeof(xShapeRectanglesReq));

-    if (nrects & 4)

-	return BadLength;

-    nrects >>= 3;

-    prects = (xRectangle *) &stuff[1];

-    ctype = VerifyRectOrder(nrects, prects, (int)stuff->ordering);

-    if (ctype < 0)

-	return BadMatch;

-    srcRgn = RegionFromRects(nrects, prects, ctype);

-

-    if (!pWin->optional)

-	MakeWindowOptional (pWin);

-    switch (stuff->destKind) {

-    case ShapeBounding:

-	destRgn = &pWin->optional->boundingShape;

-	break;

-    case ShapeClip:

-	destRgn = &pWin->optional->clipShape;

-	break;

-    case ShapeInput:

-	destRgn = &pWin->optional->inputShape;

-	break;

-    default:

-	return BadValue;

-    }

-

-    return RegionOperate (client, pWin, (int)stuff->destKind,

-			  destRgn, srcRgn, (int)stuff->op,

-			  stuff->xOff, stuff->yOff, createDefault);

-}

-

-#ifdef PANORAMIX

-static int

-ProcPanoramiXShapeRectangles(

-    ClientPtr client)

-{

-    REQUEST(xShapeRectanglesReq);

-    PanoramiXRes	*win;

-    int        		j, result;

-

-    REQUEST_AT_LEAST_SIZE (xShapeRectanglesReq);

-

-    result = dixLookupResourceByType((pointer *)&win, stuff->dest, XRT_WINDOW,

-				     client, DixWriteAccess);

-    if (result != Success)

-	return result;

-

-    FOR_NSCREENS(j) {

-	stuff->dest = win->info[j].id;

-	result = ProcShapeRectangles (client);

-	if (result != Success) break;

-    }

-    return result;

-}

-#endif

-

-

-/**************

- * ProcShapeMask

- **************/

-

-

-static int

-ProcShapeMask (ClientPtr client)

-{

-    WindowPtr		pWin;

-    ScreenPtr		pScreen;

-    REQUEST(xShapeMaskReq);

-    RegionPtr		srcRgn;

-    RegionPtr		*destRgn;

-    PixmapPtr		pPixmap;

-    CreateDftPtr	createDefault;

-    int			rc;

-

-    REQUEST_SIZE_MATCH (xShapeMaskReq);

-    UpdateCurrentTime();

-    rc = dixLookupWindow(&pWin, stuff->dest, client, DixSetAttrAccess);

-    if (rc != Success)

-	return rc;

-    switch (stuff->destKind) {

-    case ShapeBounding:

-	createDefault = CreateBoundingShape;

-	break;

-    case ShapeClip:

-	createDefault = CreateClipShape;

-	break;

-    case ShapeInput:

-	createDefault = CreateBoundingShape;

-	break;

-    default:

-	client->errorValue = stuff->destKind;

-	return BadValue;

-    }

-    pScreen = pWin->drawable.pScreen;

-    if (stuff->src == None)

-	srcRgn = 0;

-    else {

-	rc = dixLookupResourceByType((pointer *)&pPixmap, stuff->src, RT_PIXMAP,

-			       client, DixReadAccess);

-        if (rc != Success)

-	    return rc;

-	if (pPixmap->drawable.pScreen != pScreen ||

-	    pPixmap->drawable.depth != 1)

-	    return BadMatch;

-	srcRgn = BitmapToRegion(pScreen, pPixmap);

-	if (!srcRgn)

-	    return BadAlloc;

-    }

-

-    if (!pWin->optional)

-	MakeWindowOptional (pWin);

-    switch (stuff->destKind) {

-    case ShapeBounding:

-	destRgn = &pWin->optional->boundingShape;

-	break;

-    case ShapeClip:

-	destRgn = &pWin->optional->clipShape;

-	break;

-    case ShapeInput:

-	destRgn = &pWin->optional->inputShape;

-	break;

-    default:

-	return BadValue;

-    }

-

-    return RegionOperate (client, pWin, (int)stuff->destKind,

-			  destRgn, srcRgn, (int)stuff->op,

-			  stuff->xOff, stuff->yOff, createDefault);

-}

-

-#ifdef PANORAMIX

-static int

-ProcPanoramiXShapeMask(

-    ClientPtr client)

-{

-    REQUEST(xShapeMaskReq);

-    PanoramiXRes	*win, *pmap;

-    int 		j, result;

-

-    REQUEST_SIZE_MATCH (xShapeMaskReq);

-

-    result = dixLookupResourceByType((pointer *)&win, stuff->dest, XRT_WINDOW,

-				     client, DixWriteAccess);

-    if (result != Success)

-	return result;

-

-    if(stuff->src != None) {

-	result = dixLookupResourceByType((pointer *)&pmap, stuff->src,

-					 XRT_PIXMAP, client, DixReadAccess);

-	if (result != Success)

-	    return result;

-    } else

-	pmap = NULL;

-

-    FOR_NSCREENS(j) {

-	stuff->dest = win->info[j].id;

-	if(pmap)

-	    stuff->src  = pmap->info[j].id;

-	result = ProcShapeMask (client);

-	if (result != Success) break;

-    }

-    return result;

-}

-#endif

-

-

-/************

- * ProcShapeCombine

- ************/

-

-static int

-ProcShapeCombine (ClientPtr client)

-{

-    WindowPtr		pSrcWin, pDestWin;

-    REQUEST(xShapeCombineReq);

-    RegionPtr		srcRgn;

-    RegionPtr		*destRgn;

-    CreateDftPtr	createDefault;

-    CreateDftPtr	createSrc;

-    RegionPtr		tmp;

-    int			rc;

-

-    REQUEST_SIZE_MATCH (xShapeCombineReq);

-    UpdateCurrentTime();

-    rc = dixLookupWindow(&pDestWin, stuff->dest, client, DixSetAttrAccess);

-    if (rc != Success)

-	return rc;

-    if (!pDestWin->optional)

-	MakeWindowOptional (pDestWin);

-    switch (stuff->destKind) {

-    case ShapeBounding:

-	createDefault = CreateBoundingShape;

-	break;

-    case ShapeClip:

-	createDefault = CreateClipShape;

-	break;

-    case ShapeInput:

-	createDefault = CreateBoundingShape;

-	break;

-    default:

-	client->errorValue = stuff->destKind;

-	return BadValue;

-    }

-

-    rc = dixLookupWindow(&pSrcWin, stuff->src, client, DixGetAttrAccess);

-    if (rc != Success)

-	return rc;

-    switch (stuff->srcKind) {

-    case ShapeBounding:

-	srcRgn = wBoundingShape (pSrcWin);

-	createSrc = CreateBoundingShape;

-	break;

-    case ShapeClip:

-	srcRgn = wClipShape (pSrcWin);

-	createSrc = CreateClipShape;

-	break;

-    case ShapeInput:

-	srcRgn = wInputShape (pSrcWin);

-	createSrc = CreateBoundingShape;

-	break;

-    default:

-	client->errorValue = stuff->srcKind;

-	return BadValue;

-    }

-    if (pSrcWin->drawable.pScreen != pDestWin->drawable.pScreen)

-    {

-	return BadMatch;

-    }

-

-    if (srcRgn) {

-        tmp = RegionCreate((BoxPtr) 0, 0);

-        RegionCopy(tmp, srcRgn);

-        srcRgn = tmp;

-    } else

-	srcRgn = (*createSrc) (pSrcWin);

-

-    if (!pDestWin->optional)

-	MakeWindowOptional (pDestWin);

-    switch (stuff->destKind) {

-    case ShapeBounding:

-	destRgn = &pDestWin->optional->boundingShape;

-	break;

-    case ShapeClip:

-	destRgn = &pDestWin->optional->clipShape;

-	break;

-    case ShapeInput:

-	destRgn = &pDestWin->optional->inputShape;

-	break;

-    default:

-	return BadValue;

-    }

-

-    return RegionOperate (client, pDestWin, (int)stuff->destKind,

-			  destRgn, srcRgn, (int)stuff->op,

-			  stuff->xOff, stuff->yOff, createDefault);

-}

-

-

-#ifdef PANORAMIX

-static int

-ProcPanoramiXShapeCombine(

-    ClientPtr client)

-{

-    REQUEST(xShapeCombineReq);

-    PanoramiXRes	*win, *win2;

-    int 		j, result;

-

-    REQUEST_AT_LEAST_SIZE (xShapeCombineReq);

-

-    result = dixLookupResourceByType((pointer *)&win, stuff->dest, XRT_WINDOW,

-				     client, DixWriteAccess);

-    if (result != Success)

-	return result;

-

-    result = dixLookupResourceByType((pointer *)&win2, stuff->src, XRT_WINDOW,

-				     client, DixReadAccess);

-    if (result != Success)

-	return result;

-

-    FOR_NSCREENS(j) {

-	stuff->dest = win->info[j].id;

-	stuff->src =  win2->info[j].id;

-	result = ProcShapeCombine (client);

-	if (result != Success) break;

-    }

-    return result;

-}

-#endif

-

-/*************

- * ProcShapeOffset

- *************/

-

-static int

-ProcShapeOffset (ClientPtr client)

-{

-    WindowPtr		pWin;

-    REQUEST(xShapeOffsetReq);

-    RegionPtr		srcRgn;

-    int			rc;

-

-    REQUEST_SIZE_MATCH (xShapeOffsetReq);

-    UpdateCurrentTime();

-    rc = dixLookupWindow(&pWin, stuff->dest, client, DixSetAttrAccess);

-    if (rc != Success)

-	return rc;

-    switch (stuff->destKind) {

-    case ShapeBounding:

-	srcRgn = wBoundingShape (pWin);

-	break;

-    case ShapeClip:

-	srcRgn = wClipShape(pWin);

-	break;

-    case ShapeInput:

-	srcRgn = wInputShape (pWin);

-	break;

-    default:

-	client->errorValue = stuff->destKind;

-	return BadValue;

-    }

-    if (srcRgn)

-    {

-        RegionTranslate(srcRgn, stuff->xOff, stuff->yOff);

-        (*pWin->drawable.pScreen->SetShape) (pWin, stuff->destKind);

-    }

-    SendShapeNotify (pWin, (int)stuff->destKind);

-    return Success;

-}

-

-

-#ifdef PANORAMIX

-static int

-ProcPanoramiXShapeOffset(

-    ClientPtr client)

-{

-    REQUEST(xShapeOffsetReq);

-    PanoramiXRes *win;

-    int j, result;

-

-    REQUEST_AT_LEAST_SIZE (xShapeOffsetReq);

-   

-    result = dixLookupResourceByType((pointer *)&win, stuff->dest, XRT_WINDOW,

-				     client, DixWriteAccess);

-    if (result != Success)

-	return result;

-

-    FOR_NSCREENS(j) {

-	stuff->dest = win->info[j].id;

-	result = ProcShapeOffset (client);

-	if(result != Success) break;

-    }

-    return result;

-}

-#endif

-

-

-static int

-ProcShapeQueryExtents (ClientPtr client)

-{

-    REQUEST(xShapeQueryExtentsReq);

-    WindowPtr		pWin;

-    xShapeQueryExtentsReply	rep;

-    BoxRec		extents, *pExtents;

-    int	n, rc;

-    RegionPtr		region;

-

-    REQUEST_SIZE_MATCH (xShapeQueryExtentsReq);

-    rc = dixLookupWindow(&pWin, stuff->window, client, DixGetAttrAccess);

-    if (rc != Success)

-	return rc;

-    memset(&rep, 0, sizeof(xShapeQueryExtentsReply));

-    rep.type = X_Reply;

-    rep.length = 0;

-    rep.sequenceNumber = client->sequence;

-    rep.boundingShaped = (wBoundingShape(pWin) != 0);

-    rep.clipShaped = (wClipShape(pWin) != 0);

-    if ((region = wBoundingShape(pWin))) {

-     /* this is done in two steps because of a compiler bug on SunOS 4.1.3 */

-	pExtents = RegionExtents(region);

-	extents = *pExtents;

-    } else {

-	extents.x1 = -wBorderWidth (pWin);

-	extents.y1 = -wBorderWidth (pWin);

-	extents.x2 = pWin->drawable.width + wBorderWidth (pWin);

-	extents.y2 = pWin->drawable.height + wBorderWidth (pWin);

-    }

-    rep.xBoundingShape = extents.x1;

-    rep.yBoundingShape = extents.y1;

-    rep.widthBoundingShape = extents.x2 - extents.x1;

-    rep.heightBoundingShape = extents.y2 - extents.y1;

-    if ((region = wClipShape(pWin))) {

-     /* this is done in two steps because of a compiler bug on SunOS 4.1.3 */

-	pExtents = RegionExtents(region);

-	extents = *pExtents;

-    } else {

-	extents.x1 = 0;

-	extents.y1 = 0;

-	extents.x2 = pWin->drawable.width;

-	extents.y2 = pWin->drawable.height;

-    }

-    rep.xClipShape = extents.x1;

-    rep.yClipShape = extents.y1;

-    rep.widthClipShape = extents.x2 - extents.x1;

-    rep.heightClipShape = extents.y2 - extents.y1;

-    if (client->swapped) {

-    	swaps(&rep.sequenceNumber, n);

-    	swapl(&rep.length, n);

-	swaps(&rep.xBoundingShape, n);

-	swaps(&rep.yBoundingShape, n);

-	swaps(&rep.widthBoundingShape, n);

-	swaps(&rep.heightBoundingShape, n);

-	swaps(&rep.xClipShape, n);

-	swaps(&rep.yClipShape, n);

-	swaps(&rep.widthClipShape, n);

-	swaps(&rep.heightClipShape, n);

-    }

-    WriteToClient(client, sizeof (xShapeQueryExtentsReply), (char *)&rep);

-    return Success;

-}

-

-/*ARGSUSED*/

-static int

-ShapeFreeClient (pointer data, XID id)

-{

-    ShapeEventPtr   pShapeEvent;

-    WindowPtr	    pWin;

-    ShapeEventPtr   *pHead, pCur, pPrev;

-    int rc;

-

-    pShapeEvent = (ShapeEventPtr) data;

-    pWin = pShapeEvent->window;

-    rc = dixLookupResourceByType((pointer *)&pHead, pWin->drawable.id,

-				 ShapeEventType, serverClient, DixReadAccess);

-    if (rc == Success) {

-	pPrev = 0;

-	for (pCur = *pHead; pCur && pCur != pShapeEvent; pCur=pCur->next)

-	    pPrev = pCur;

-	if (pCur)

-	{

-	    if (pPrev)

-	    	pPrev->next = pShapeEvent->next;

-	    else

-	    	*pHead = pShapeEvent->next;

-	}

-    }

-    free((pointer) pShapeEvent);

-    return 1;

-}

-

-/*ARGSUSED*/

-static int

-ShapeFreeEvents (pointer data, XID id)

-{

-    ShapeEventPtr   *pHead, pCur, pNext;

-

-    pHead = (ShapeEventPtr *) data;

-    for (pCur = *pHead; pCur; pCur = pNext) {

-	pNext = pCur->next;

-	FreeResource (pCur->clientResource, ClientType);

-	free((pointer) pCur);

-    }

-    free((pointer) pHead);

-    return 1;

-}

-

-static int

-ProcShapeSelectInput (ClientPtr client)

-{

-    REQUEST(xShapeSelectInputReq);

-    WindowPtr		pWin;

-    ShapeEventPtr	pShapeEvent, pNewShapeEvent, *pHead;

-    XID			clientResource;

-    int			rc;

-

-    REQUEST_SIZE_MATCH (xShapeSelectInputReq);

-    rc = dixLookupWindow(&pWin, stuff->window, client, DixReceiveAccess);

-    if (rc != Success)

-	return rc;

-    rc = dixLookupResourceByType((pointer *)&pHead, pWin->drawable.id,

-				 ShapeEventType, client, DixWriteAccess);

-    if (rc != Success && rc != BadValue)

-	return rc;

-

-    switch (stuff->enable) {

-    case xTrue:

-	if (pHead) {

-

-	    /* check for existing entry. */

-	    for (pShapeEvent = *pHead;

-		 pShapeEvent;

- 		 pShapeEvent = pShapeEvent->next)

-	    {

-		if (pShapeEvent->client == client)

-		    return Success;

-	    }

-	}

-

-	/* build the entry */

-	pNewShapeEvent = malloc(sizeof (ShapeEventRec));

-    	if (!pNewShapeEvent)

-	    return BadAlloc;

-    	pNewShapeEvent->next = 0;

-    	pNewShapeEvent->client = client;

-    	pNewShapeEvent->window = pWin;

-    	/*

- 	 * add a resource that will be deleted when

-     	 * the client goes away

-     	 */

-   	clientResource = FakeClientID (client->index);

-    	pNewShapeEvent->clientResource = clientResource;

-    	if (!AddResource (clientResource, ClientType, (pointer)pNewShapeEvent))

-	    return BadAlloc;

-    	/*

-     	 * create a resource to contain a pointer to the list

-     	 * of clients selecting input.  This must be indirect as

-     	 * the list may be arbitrarily rearranged which cannot be

-     	 * done through the resource database.

-     	 */

-    	if (!pHead)

-    	{

-	    pHead = malloc(sizeof (ShapeEventPtr));

-	    if (!pHead ||

-		!AddResource (pWin->drawable.id, ShapeEventType, (pointer)pHead))

-	    {

-	    	FreeResource (clientResource, RT_NONE);

-	    	return BadAlloc;

-	    }

-	    *pHead = 0;

-    	}

-    	pNewShapeEvent->next = *pHead;

-    	*pHead = pNewShapeEvent;

-	break;

-    case xFalse:

-	/* delete the interest */

-	if (pHead) {

-	    pNewShapeEvent = 0;

-	    for (pShapeEvent = *pHead; pShapeEvent; pShapeEvent = pShapeEvent->next) {

-		if (pShapeEvent->client == client)

-		    break;

-		pNewShapeEvent = pShapeEvent;

-	    }

-	    if (pShapeEvent) {

-		FreeResource (pShapeEvent->clientResource, ClientType);

-		if (pNewShapeEvent)

-		    pNewShapeEvent->next = pShapeEvent->next;

-		else

-		    *pHead = pShapeEvent->next;

-		free(pShapeEvent);

-	    }

-	}

-	break;

-    default:

-	client->errorValue = stuff->enable;

-	return BadValue;

-    }

-    return Success;

-}

-

-/*

- * deliver the event

- */

-

-void

-SendShapeNotify (WindowPtr pWin, int which)

-{

-    ShapeEventPtr	*pHead, pShapeEvent;

-    xShapeNotifyEvent	se;

-    BoxRec		extents;

-    RegionPtr		region;

-    BYTE		shaped;

-    int rc;

-

-    rc = dixLookupResourceByType((pointer *)&pHead, pWin->drawable.id,

-				 ShapeEventType, serverClient, DixReadAccess);

-    if (rc != Success)

-	return;

-    switch (which) {

-    case ShapeBounding:

-	region = wBoundingShape(pWin);

-	if (region) {

-	    extents = *RegionExtents(region);

-	    shaped = xTrue;

-	} else {

-	    extents.x1 = -wBorderWidth (pWin);

-	    extents.y1 = -wBorderWidth (pWin);

-	    extents.x2 = pWin->drawable.width + wBorderWidth (pWin);

-	    extents.y2 = pWin->drawable.height + wBorderWidth (pWin);

-	    shaped = xFalse;

-	}

-	break;

-    case ShapeClip:

-	region = wClipShape(pWin);

-	if (region) {

-	    extents = *RegionExtents(region);

-	    shaped = xTrue;

-	} else {

-	    extents.x1 = 0;

-	    extents.y1 = 0;

-	    extents.x2 = pWin->drawable.width;

-	    extents.y2 = pWin->drawable.height;

-	    shaped = xFalse;

-	}

-	break;

-    case ShapeInput:

-	region = wInputShape(pWin);

-	if (region) {

-	    extents = *RegionExtents(region);

-	    shaped = xTrue;

-	} else {

-	    extents.x1 = -wBorderWidth (pWin);

-	    extents.y1 = -wBorderWidth (pWin);

-	    extents.x2 = pWin->drawable.width + wBorderWidth (pWin);

-	    extents.y2 = pWin->drawable.height + wBorderWidth (pWin);

-	    shaped = xFalse;

-	}

-	break;

-    default:

-	return;

-    }

-    for (pShapeEvent = *pHead; pShapeEvent; pShapeEvent = pShapeEvent->next) {

-	se.type = ShapeNotify + ShapeEventBase;

-	se.kind = which;

-	se.window = pWin->drawable.id;

-	se.x = extents.x1;

-	se.y = extents.y1;

-	se.width = extents.x2 - extents.x1;

-	se.height = extents.y2 - extents.y1;

-	se.time = currentTime.milliseconds;

-	se.shaped = shaped;

-	WriteEventsToClient (pShapeEvent->client, 1, (xEvent *) &se);

-    }

-}

-

-static int

-ProcShapeInputSelected (ClientPtr client)

-{

-    REQUEST(xShapeInputSelectedReq);

-    WindowPtr		pWin;

-    ShapeEventPtr	pShapeEvent, *pHead;

-    int			enabled, rc;

-    xShapeInputSelectedReply	rep;

-    int		n;

-

-    REQUEST_SIZE_MATCH (xShapeInputSelectedReq);

-    rc = dixLookupWindow(&pWin, stuff->window, client, DixGetAttrAccess);

-    if (rc != Success)

-	return rc;

-    rc = dixLookupResourceByType((pointer *)&pHead, pWin->drawable.id,

-				 ShapeEventType, client, DixReadAccess);

-    if (rc != Success && rc != BadValue)

-	return rc;

-    enabled = xFalse;

-    if (pHead) {

-    	for (pShapeEvent = *pHead;

-	     pShapeEvent;

-	     pShapeEvent = pShapeEvent->next)

-    	{

-	    if (pShapeEvent->client == client) {

-	    	enabled = xTrue;

-		break;

-	    }

-    	}

-    }

-    rep.type = X_Reply;

-    rep.length = 0;

-    rep.sequenceNumber = client->sequence;

-    rep.enabled = enabled;

-    if (client->swapped) {

-	swaps (&rep.sequenceNumber, n);

-	swapl (&rep.length, n);

-    }

-    WriteToClient (client, sizeof (xShapeInputSelectedReply), (char *) &rep);

-    return Success;

-}

-

-static int

-ProcShapeGetRectangles (ClientPtr client)

-{

-    REQUEST(xShapeGetRectanglesReq);

-    WindowPtr			pWin;

-    xShapeGetRectanglesReply	rep;

-    xRectangle			*rects;

-    int				nrects, i, rc;

-    RegionPtr			region;

-    int		n;

-

-    REQUEST_SIZE_MATCH(xShapeGetRectanglesReq);

-    rc = dixLookupWindow(&pWin, stuff->window, client, DixGetAttrAccess);

-    if (rc != Success)

-	return rc;

-    switch (stuff->kind) {

-    case ShapeBounding:

-	region = wBoundingShape(pWin);

-	break;

-    case ShapeClip:

-	region = wClipShape(pWin);

-	break;

-    case ShapeInput:

-	region = wInputShape (pWin);

-	break;

-    default:

-	client->errorValue = stuff->kind;

-	return BadValue;

-    }

-    if (!region) {

-	nrects = 1;

-	rects = malloc(sizeof (xRectangle));

-	if (!rects)

-	    return BadAlloc;

-	switch (stuff->kind) {

-	case ShapeBounding:

-	    rects->x = - (int) wBorderWidth (pWin);

-	    rects->y = - (int) wBorderWidth (pWin);

-	    rects->width = pWin->drawable.width + wBorderWidth (pWin);

-	    rects->height = pWin->drawable.height + wBorderWidth (pWin);

-	    break;

-	case ShapeClip:

-	    rects->x = 0;

-	    rects->y = 0;

-	    rects->width = pWin->drawable.width;

-	    rects->height = pWin->drawable.height;

-	    break;

-	case ShapeInput:

-	    rects->x = - (int) wBorderWidth (pWin);

-	    rects->y = - (int) wBorderWidth (pWin);

-	    rects->width = pWin->drawable.width + wBorderWidth (pWin);

-	    rects->height = pWin->drawable.height + wBorderWidth (pWin);

-	    break;

-	}

-    } else {

-	BoxPtr box;

-	nrects = RegionNumRects(region);

-	box = RegionRects(region);

-	rects = malloc(nrects * sizeof (xRectangle));

-	if (!rects && nrects)

-	    return BadAlloc;

-	for (i = 0; i < nrects; i++, box++) {

-	    rects[i].x = box->x1;

-	    rects[i].y = box->y1;

-	    rects[i].width = box->x2 - box->x1;

-	    rects[i].height = box->y2 - box->y1;

-	}

-    }

-    rep.type = X_Reply;

-    rep.sequenceNumber = client->sequence;

-    rep.length = bytes_to_int32(nrects * sizeof (xRectangle));

-    rep.ordering = YXBanded;

-    rep.nrects = nrects;

-    if (client->swapped) {

-	swaps (&rep.sequenceNumber, n);

-	swapl (&rep.length, n);

-	swapl (&rep.nrects, n);

-	SwapShorts ((short *)rects, (unsigned long)nrects * 4);

-    }

-    WriteToClient (client, sizeof (rep), (char *) &rep);

-    WriteToClient (client, nrects * sizeof (xRectangle), (char *) rects);

-    free(rects);

-    return Success;

-}

-

-static int

-ProcShapeDispatch (ClientPtr client)

-{

-    REQUEST(xReq);

-    switch (stuff->data) {

-    case X_ShapeQueryVersion:

-	return ProcShapeQueryVersion (client);

-    case X_ShapeRectangles:

-#ifdef PANORAMIX

-        if ( !noPanoramiXExtension )

-	    return ProcPanoramiXShapeRectangles (client);

-        else 

-#endif

-	return ProcShapeRectangles (client);

-    case X_ShapeMask:

-#ifdef PANORAMIX

-        if ( !noPanoramiXExtension )

-           return ProcPanoramiXShapeMask (client);

-	else

-#endif

-	return ProcShapeMask (client);

-    case X_ShapeCombine:

-#ifdef PANORAMIX

-        if ( !noPanoramiXExtension )

-           return ProcPanoramiXShapeCombine (client);

-	else

-#endif

-	return ProcShapeCombine (client);

-    case X_ShapeOffset:

-#ifdef PANORAMIX

-        if ( !noPanoramiXExtension )

-           return ProcPanoramiXShapeOffset (client);

-	else

-#endif

-	return ProcShapeOffset (client);

-    case X_ShapeQueryExtents:

-	return ProcShapeQueryExtents (client);

-    case X_ShapeSelectInput:

-	return ProcShapeSelectInput (client);

-    case X_ShapeInputSelected:

-	return ProcShapeInputSelected (client);

-    case X_ShapeGetRectangles:

-	return ProcShapeGetRectangles (client);

-    default:

-	return BadRequest;

-    }

-}

-

-static void

-SShapeNotifyEvent(xShapeNotifyEvent *from, xShapeNotifyEvent *to)

-{

-    to->type = from->type;

-    to->kind = from->kind;

-    cpswapl (from->window, to->window);

-    cpswaps (from->sequenceNumber, to->sequenceNumber);

-    cpswaps (from->x, to->x);

-    cpswaps (from->y, to->y);

-    cpswaps (from->width, to->width);

-    cpswaps (from->height, to->height);

-    cpswapl (from->time, to->time);

-    to->shaped = from->shaped;

-}

-

-static int

-SProcShapeQueryVersion (ClientPtr client)

-{

-    int    n;

-    REQUEST (xShapeQueryVersionReq);

-

-    swaps (&stuff->length, n);

-    return ProcShapeQueryVersion (client);

-}

-

-static int

-SProcShapeRectangles (ClientPtr client)

-{

-    char   n;

-    REQUEST (xShapeRectanglesReq);

-

-    swaps (&stuff->length, n);

-    REQUEST_AT_LEAST_SIZE (xShapeRectanglesReq);

-    swapl (&stuff->dest, n);

-    swaps (&stuff->xOff, n);

-    swaps (&stuff->yOff, n);

-    SwapRestS(stuff);

-    return ProcShapeRectangles (client);

-}

-

-static int

-SProcShapeMask (ClientPtr client)

-{

-    char   n;

-    REQUEST (xShapeMaskReq);

-

-    swaps (&stuff->length, n);

-    REQUEST_SIZE_MATCH (xShapeMaskReq);

-    swapl (&stuff->dest, n);

-    swaps (&stuff->xOff, n);

-    swaps (&stuff->yOff, n);

-    swapl (&stuff->src, n);

-    return ProcShapeMask (client);

-}

-

-static int

-SProcShapeCombine (ClientPtr client)

-{

-    char   n;

-    REQUEST (xShapeCombineReq);

-

-    swaps (&stuff->length, n);

-    REQUEST_SIZE_MATCH (xShapeCombineReq);

-    swapl (&stuff->dest, n);

-    swaps (&stuff->xOff, n);

-    swaps (&stuff->yOff, n);

-    swapl (&stuff->src, n);

-    return ProcShapeCombine (client);

-}

-

-static int

-SProcShapeOffset (ClientPtr client)

-{

-    char   n;

-    REQUEST (xShapeOffsetReq);

-

-    swaps (&stuff->length, n);

-    REQUEST_SIZE_MATCH (xShapeOffsetReq);

-    swapl (&stuff->dest, n);

-    swaps (&stuff->xOff, n);

-    swaps (&stuff->yOff, n);

-    return ProcShapeOffset (client);

-}

-

-static int

-SProcShapeQueryExtents (ClientPtr client)

-{

-    char   n;

-    REQUEST (xShapeQueryExtentsReq);

-

-    swaps (&stuff->length, n);

-    REQUEST_SIZE_MATCH (xShapeQueryExtentsReq);

-    swapl (&stuff->window, n);

-    return ProcShapeQueryExtents (client);

-}

-

-static int

-SProcShapeSelectInput (ClientPtr client)

-{

-    char   n;

-    REQUEST (xShapeSelectInputReq);

-

-    swaps (&stuff->length, n);

-    REQUEST_SIZE_MATCH (xShapeSelectInputReq);

-    swapl (&stuff->window, n);

-    return ProcShapeSelectInput (client);

-}

-

-static int

-SProcShapeInputSelected (ClientPtr client)

-{

-    int    n;

-    REQUEST (xShapeInputSelectedReq);

-

-    swaps (&stuff->length, n);

-    REQUEST_SIZE_MATCH (xShapeInputSelectedReq);

-    swapl (&stuff->window, n);

-    return ProcShapeInputSelected (client);

-}

-

-static int

-SProcShapeGetRectangles (ClientPtr client)

-{

-    REQUEST(xShapeGetRectanglesReq);

-    char   n;

-

-    swaps (&stuff->length, n);

-    REQUEST_SIZE_MATCH(xShapeGetRectanglesReq);

-    swapl (&stuff->window, n);

-    return ProcShapeGetRectangles (client);

-}

-

-static int

-SProcShapeDispatch (ClientPtr client)

-{

-    REQUEST(xReq);

-    switch (stuff->data) {

-    case X_ShapeQueryVersion:

-	return SProcShapeQueryVersion (client);

-    case X_ShapeRectangles:

-	return SProcShapeRectangles (client);

-    case X_ShapeMask:

-	return SProcShapeMask (client);

-    case X_ShapeCombine:

-	return SProcShapeCombine (client);

-    case X_ShapeOffset:

-	return SProcShapeOffset (client);

-    case X_ShapeQueryExtents:

-	return SProcShapeQueryExtents (client);

-    case X_ShapeSelectInput:

-	return SProcShapeSelectInput (client);

-    case X_ShapeInputSelected:

-	return SProcShapeInputSelected (client);

-    case X_ShapeGetRectangles:

-	return SProcShapeGetRectangles (client);

-    default:

-	return BadRequest;

-    }

-}

-

-void

-ShapeExtensionInit(void)

-{

-    ExtensionEntry *extEntry;

-

-    ClientType = CreateNewResourceType(ShapeFreeClient, "ShapeClient");

-    ShapeEventType = CreateNewResourceType(ShapeFreeEvents, "ShapeEvent");

-    if (ClientType && ShapeEventType &&

-	(extEntry = AddExtension(SHAPENAME, ShapeNumberEvents, 0,

-				 ProcShapeDispatch, SProcShapeDispatch,

-				 NULL, StandardMinorOpcode)))

-    {

-	ShapeEventBase = extEntry->eventBase;

-	EventSwapVector[ShapeEventBase] = (EventSwapPtr) SShapeNotifyEvent;

-    }

-}

+/************************************************************
+
+Copyright 1989, 1998  The Open Group
+
+Permission to use, copy, modify, distribute, and sell this software and its
+documentation for any purpose is hereby granted without fee, provided that
+the above copyright notice appear in all copies and that both that
+copyright notice and this permission notice appear in supporting
+documentation.
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
+AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+Except as contained in this notice, the name of The Open Group shall not be
+used in advertising or otherwise to promote the sale, use or other dealings
+in this Software without prior written authorization from The Open Group.
+
+********************************************************/
+
+#ifdef HAVE_DIX_CONFIG_H
+#include <dix-config.h>
+#else
+#define SHAPE
+#endif
+
+#include <stdlib.h>
+
+#include <X11/X.h>
+#include <X11/Xproto.h>
+#include "misc.h"
+#include "os.h"
+#include "windowstr.h"
+#include "scrnintstr.h"
+#include "pixmapstr.h"
+#include "extnsionst.h"
+#include "dixstruct.h"
+#include "resource.h"
+#include "opaque.h"
+#include <X11/extensions/shapeproto.h>
+#include "regionstr.h"
+#include "gcstruct.h"
+#include "modinit.h"
+#include "protocol-versions.h"
+
+typedef	RegionPtr (*CreateDftPtr)(
+	WindowPtr /* pWin */
+	);
+
+static int ShapeFreeClient(
+	pointer /* data */,
+	XID /* id */
+	);
+static int ShapeFreeEvents(
+	pointer /* data */,
+	XID /* id */
+	);
+static void SShapeNotifyEvent(
+	xShapeNotifyEvent * /* from */,
+	xShapeNotifyEvent * /* to */
+	);
+
+/* SendShapeNotify, CreateBoundingShape and CreateClipShape are used
+ * externally by the Xfixes extension and are now defined in window.h
+ */
+
+
+#ifdef PANORAMIX
+#include "panoramiX.h"
+#include "panoramiXsrv.h"
+#endif
+
+static int ShapeEventBase = 0;
+static RESTYPE ClientType, ShapeEventType; /* resource types for event masks */
+
+/*
+ * each window has a list of clients requesting
+ * ShapeNotify events.  Each client has a resource
+ * for each window it selects ShapeNotify input for,
+ * this resource is used to delete the ShapeNotifyRec
+ * entry from the per-window queue.
+ */
+
+typedef struct _ShapeEvent *ShapeEventPtr;
+
+typedef struct _ShapeEvent {
+    ShapeEventPtr   next;
+    ClientPtr	    client;
+    WindowPtr	    window;
+    XID		    clientResource;
+} ShapeEventRec;
+
+/****************
+ * ShapeExtensionInit
+ *
+ * Called from InitExtensions in main() or from QueryExtension() if the
+ * extension is dynamically loaded.
+ *
+ ****************/
+
+static int
+RegionOperate (
+	ClientPtr client,
+	WindowPtr pWin,
+	int kind,
+	RegionPtr *destRgnp,
+	RegionPtr srcRgn,
+	int op,
+	int xoff, int yoff,
+	CreateDftPtr create)
+{
+    if (srcRgn && (xoff || yoff))
+	RegionTranslate(srcRgn, xoff, yoff);
+    if (!pWin->parent)
+    {
+	if (srcRgn)
+	    RegionDestroy(srcRgn);
+	return Success;
+    }
+
+    /* May/30/2001:
+     * The shape.PS specs say if src is None, existing shape is to be
+     * removed (and so the op-code has no meaning in such removal);
+     * see shape.PS, page 3, ShapeMask.
+     */
+    if (srcRgn == NULL) {
+      if (*destRgnp != NULL) {
+	RegionDestroy(*destRgnp);
+	*destRgnp = 0;
+	/* go on to remove shape and generate ShapeNotify */
+      }
+      else {
+	/* May/30/2001:
+	 * The target currently has no shape in effect, so nothing to
+	 * do here.  The specs say that ShapeNotify is generated whenever
+	 * the client region is "modified"; since no modification is done
+	 * here, we do not generate that event.  The specs does not say
+	 * "it is an error to request removal when there is no shape in
+	 * effect", so we return good status.
+	 */
+	return Success;
+      }
+    }
+    else switch (op) {
+    case ShapeSet:
+	if (*destRgnp)
+	    RegionDestroy(*destRgnp);
+	*destRgnp = srcRgn;
+	srcRgn = 0;
+	break;
+    case ShapeUnion:
+	if (*destRgnp)
+	    RegionUnion(*destRgnp, *destRgnp, srcRgn);
+	break;
+    case ShapeIntersect:
+	if (*destRgnp)
+	    RegionIntersect(*destRgnp, *destRgnp, srcRgn);
+	else {
+	    *destRgnp = srcRgn;
+	    srcRgn = 0;
+	}
+	break;
+    case ShapeSubtract:
+	if (!*destRgnp)
+	    *destRgnp = (*create)(pWin);
+	RegionSubtract(*destRgnp, *destRgnp, srcRgn);
+	break;
+    case ShapeInvert:
+	if (!*destRgnp)
+	    *destRgnp = RegionCreate((BoxPtr) 0, 0);
+	else
+	    RegionSubtract(*destRgnp, srcRgn, *destRgnp);
+	break;
+    default:
+	client->errorValue = op;
+	return BadValue;
+    }
+    if (srcRgn)
+	RegionDestroy(srcRgn);
+    (*pWin->drawable.pScreen->SetShape) (pWin, kind);
+    SendShapeNotify (pWin, kind);
+    return Success;
+}
+
+RegionPtr
+CreateBoundingShape (WindowPtr pWin)
+{
+    BoxRec	extents;
+
+    extents.x1 = -wBorderWidth (pWin);
+    extents.y1 = -wBorderWidth (pWin);
+    extents.x2 = pWin->drawable.width + wBorderWidth (pWin);
+    extents.y2 = pWin->drawable.height + wBorderWidth (pWin);
+    return RegionCreate(&extents, 1);
+}
+
+RegionPtr
+CreateClipShape (WindowPtr pWin)
+{
+    BoxRec	extents;
+
+    extents.x1 = 0;
+    extents.y1 = 0;
+    extents.x2 = pWin->drawable.width;
+    extents.y2 = pWin->drawable.height;
+    return RegionCreate(&extents, 1);
+}
+
+static int
+ProcShapeQueryVersion (ClientPtr client)
+{
+    xShapeQueryVersionReply	rep;
+    REQUEST_SIZE_MATCH (xShapeQueryVersionReq);
+    memset(&rep, 0, sizeof(xShapeQueryVersionReply));
+    rep.type = X_Reply;
+    rep.length = 0;
+    rep.sequenceNumber = client->sequence;
+    rep.majorVersion = SERVER_SHAPE_MAJOR_VERSION;
+    rep.minorVersion = SERVER_SHAPE_MINOR_VERSION;
+    if (client->swapped) {
+	swaps(&rep.sequenceNumber);
+	swapl(&rep.length);
+	swaps(&rep.majorVersion);
+	swaps(&rep.minorVersion);
+    }
+    WriteToClient(client, sizeof (xShapeQueryVersionReply), (char *)&rep);
+    return Success;
+}
+
+/*****************
+ * ProcShapeRectangles
+ *
+ *****************/
+
+static int
+ProcShapeRectangles (ClientPtr client)
+{
+    WindowPtr		pWin;
+    REQUEST(xShapeRectanglesReq);
+    xRectangle		*prects;
+    int		        nrects, ctype, rc;
+    RegionPtr		srcRgn;
+    RegionPtr		*destRgn;
+    CreateDftPtr	createDefault;
+
+    REQUEST_AT_LEAST_SIZE (xShapeRectanglesReq);
+    UpdateCurrentTime();
+    rc = dixLookupWindow(&pWin, stuff->dest, client, DixSetAttrAccess);
+    if (rc != Success)
+	return rc;
+    switch (stuff->destKind) {
+    case ShapeBounding:
+	createDefault = CreateBoundingShape;
+	break;
+    case ShapeClip:
+	createDefault = CreateClipShape;
+	break;
+    case ShapeInput:
+	createDefault = CreateBoundingShape;
+	break;
+    default:
+	client->errorValue = stuff->destKind;
+	return BadValue;
+    }
+    if ((stuff->ordering != Unsorted) && (stuff->ordering != YSorted) &&
+	(stuff->ordering != YXSorted) && (stuff->ordering != YXBanded))
+    {
+	client->errorValue = stuff->ordering;
+        return BadValue;
+    }
+    nrects = ((stuff->length  << 2) - sizeof(xShapeRectanglesReq));
+    if (nrects & 4)
+	return BadLength;
+    nrects >>= 3;
+    prects = (xRectangle *) &stuff[1];
+    ctype = VerifyRectOrder(nrects, prects, (int)stuff->ordering);
+    if (ctype < 0)
+	return BadMatch;
+    srcRgn = RegionFromRects(nrects, prects, ctype);
+
+    if (!pWin->optional)
+	MakeWindowOptional (pWin);
+    switch (stuff->destKind) {
+    case ShapeBounding:
+	destRgn = &pWin->optional->boundingShape;
+	break;
+    case ShapeClip:
+	destRgn = &pWin->optional->clipShape;
+	break;
+    case ShapeInput:
+	destRgn = &pWin->optional->inputShape;
+	break;
+    default:
+	return BadValue;
+    }
+
+    return RegionOperate (client, pWin, (int)stuff->destKind,
+			  destRgn, srcRgn, (int)stuff->op,
+			  stuff->xOff, stuff->yOff, createDefault);
+}
+
+#ifdef PANORAMIX
+static int
+ProcPanoramiXShapeRectangles(
+    ClientPtr client)
+{
+    REQUEST(xShapeRectanglesReq);
+    PanoramiXRes	*win;
+    int        		j, result;
+
+    REQUEST_AT_LEAST_SIZE (xShapeRectanglesReq);
+
+    result = dixLookupResourceByType((pointer *)&win, stuff->dest, XRT_WINDOW,
+				     client, DixWriteAccess);
+    if (result != Success)
+	return result;
+
+    FOR_NSCREENS(j) {
+	stuff->dest = win->info[j].id;
+	result = ProcShapeRectangles (client);
+	if (result != Success) break;
+    }
+    return result;
+}
+#endif
+
+
+/**************
+ * ProcShapeMask
+ **************/
+
+
+static int
+ProcShapeMask (ClientPtr client)
+{
+    WindowPtr		pWin;
+    ScreenPtr		pScreen;
+    REQUEST(xShapeMaskReq);
+    RegionPtr		srcRgn;
+    RegionPtr		*destRgn;
+    PixmapPtr		pPixmap;
+    CreateDftPtr	createDefault;
+    int			rc;
+
+    REQUEST_SIZE_MATCH (xShapeMaskReq);
+    UpdateCurrentTime();
+    rc = dixLookupWindow(&pWin, stuff->dest, client, DixSetAttrAccess);
+    if (rc != Success)
+	return rc;
+    switch (stuff->destKind) {
+    case ShapeBounding:
+	createDefault = CreateBoundingShape;
+	break;
+    case ShapeClip:
+	createDefault = CreateClipShape;
+	break;
+    case ShapeInput:
+	createDefault = CreateBoundingShape;
+	break;
+    default:
+	client->errorValue = stuff->destKind;
+	return BadValue;
+    }
+    pScreen = pWin->drawable.pScreen;
+    if (stuff->src == None)
+	srcRgn = 0;
+    else {
+	rc = dixLookupResourceByType((pointer *)&pPixmap, stuff->src, RT_PIXMAP,
+			       client, DixReadAccess);
+        if (rc != Success)
+	    return rc;
+	if (pPixmap->drawable.pScreen != pScreen ||
+	    pPixmap->drawable.depth != 1)
+	    return BadMatch;
+	srcRgn = BitmapToRegion(pScreen, pPixmap);
+	if (!srcRgn)
+	    return BadAlloc;
+    }
+
+    if (!pWin->optional)
+	MakeWindowOptional (pWin);
+    switch (stuff->destKind) {
+    case ShapeBounding:
+	destRgn = &pWin->optional->boundingShape;
+	break;
+    case ShapeClip:
+	destRgn = &pWin->optional->clipShape;
+	break;
+    case ShapeInput:
+	destRgn = &pWin->optional->inputShape;
+	break;
+    default:
+	return BadValue;
+    }
+
+    return RegionOperate (client, pWin, (int)stuff->destKind,
+			  destRgn, srcRgn, (int)stuff->op,
+			  stuff->xOff, stuff->yOff, createDefault);
+}
+
+#ifdef PANORAMIX
+static int
+ProcPanoramiXShapeMask(
+    ClientPtr client)
+{
+    REQUEST(xShapeMaskReq);
+    PanoramiXRes	*win, *pmap;
+    int 		j, result;
+
+    REQUEST_SIZE_MATCH (xShapeMaskReq);
+
+    result = dixLookupResourceByType((pointer *)&win, stuff->dest, XRT_WINDOW,
+				     client, DixWriteAccess);
+    if (result != Success)
+	return result;
+
+    if(stuff->src != None) {
+	result = dixLookupResourceByType((pointer *)&pmap, stuff->src,
+					 XRT_PIXMAP, client, DixReadAccess);
+	if (result != Success)
+	    return result;
+    } else
+	pmap = NULL;
+
+    FOR_NSCREENS(j) {
+	stuff->dest = win->info[j].id;
+	if(pmap)
+	    stuff->src  = pmap->info[j].id;
+	result = ProcShapeMask (client);
+	if (result != Success) break;
+    }
+    return result;
+}
+#endif
+
+
+/************
+ * ProcShapeCombine
+ ************/
+
+static int
+ProcShapeCombine (ClientPtr client)
+{
+    WindowPtr		pSrcWin, pDestWin;
+    REQUEST(xShapeCombineReq);
+    RegionPtr		srcRgn;
+    RegionPtr		*destRgn;
+    CreateDftPtr	createDefault;
+    CreateDftPtr	createSrc;
+    RegionPtr		tmp;
+    int			rc;
+
+    REQUEST_SIZE_MATCH (xShapeCombineReq);
+    UpdateCurrentTime();
+    rc = dixLookupWindow(&pDestWin, stuff->dest, client, DixSetAttrAccess);
+    if (rc != Success)
+	return rc;
+    if (!pDestWin->optional)
+	MakeWindowOptional (pDestWin);
+    switch (stuff->destKind) {
+    case ShapeBounding:
+	createDefault = CreateBoundingShape;
+	break;
+    case ShapeClip:
+	createDefault = CreateClipShape;
+	break;
+    case ShapeInput:
+	createDefault = CreateBoundingShape;
+	break;
+    default:
+	client->errorValue = stuff->destKind;
+	return BadValue;
+    }
+
+    rc = dixLookupWindow(&pSrcWin, stuff->src, client, DixGetAttrAccess);
+    if (rc != Success)
+	return rc;
+    switch (stuff->srcKind) {
+    case ShapeBounding:
+	srcRgn = wBoundingShape (pSrcWin);
+	createSrc = CreateBoundingShape;
+	break;
+    case ShapeClip:
+	srcRgn = wClipShape (pSrcWin);
+	createSrc = CreateClipShape;
+	break;
+    case ShapeInput:
+	srcRgn = wInputShape (pSrcWin);
+	createSrc = CreateBoundingShape;
+	break;
+    default:
+	client->errorValue = stuff->srcKind;
+	return BadValue;
+    }
+    if (pSrcWin->drawable.pScreen != pDestWin->drawable.pScreen)
+    {
+	return BadMatch;
+    }
+
+    if (srcRgn) {
+        tmp = RegionCreate((BoxPtr) 0, 0);
+        RegionCopy(tmp, srcRgn);
+        srcRgn = tmp;
+    } else
+	srcRgn = (*createSrc) (pSrcWin);
+
+    if (!pDestWin->optional)
+	MakeWindowOptional (pDestWin);
+    switch (stuff->destKind) {
+    case ShapeBounding:
+	destRgn = &pDestWin->optional->boundingShape;
+	break;
+    case ShapeClip:
+	destRgn = &pDestWin->optional->clipShape;
+	break;
+    case ShapeInput:
+	destRgn = &pDestWin->optional->inputShape;
+	break;
+    default:
+	return BadValue;
+    }
+
+    return RegionOperate (client, pDestWin, (int)stuff->destKind,
+			  destRgn, srcRgn, (int)stuff->op,
+			  stuff->xOff, stuff->yOff, createDefault);
+}
+
+
+#ifdef PANORAMIX
+static int
+ProcPanoramiXShapeCombine(
+    ClientPtr client)
+{
+    REQUEST(xShapeCombineReq);
+    PanoramiXRes	*win, *win2;
+    int 		j, result;
+
+    REQUEST_AT_LEAST_SIZE (xShapeCombineReq);
+
+    result = dixLookupResourceByType((pointer *)&win, stuff->dest, XRT_WINDOW,
+				     client, DixWriteAccess);
+    if (result != Success)
+	return result;
+
+    result = dixLookupResourceByType((pointer *)&win2, stuff->src, XRT_WINDOW,
+				     client, DixReadAccess);
+    if (result != Success)
+	return result;
+
+    FOR_NSCREENS(j) {
+	stuff->dest = win->info[j].id;
+	stuff->src =  win2->info[j].id;
+	result = ProcShapeCombine (client);
+	if (result != Success) break;
+    }
+    return result;
+}
+#endif
+
+/*************
+ * ProcShapeOffset
+ *************/
+
+static int
+ProcShapeOffset (ClientPtr client)
+{
+    WindowPtr		pWin;
+    REQUEST(xShapeOffsetReq);
+    RegionPtr		srcRgn;
+    int			rc;
+
+    REQUEST_SIZE_MATCH (xShapeOffsetReq);
+    UpdateCurrentTime();
+    rc = dixLookupWindow(&pWin, stuff->dest, client, DixSetAttrAccess);
+    if (rc != Success)
+	return rc;
+    switch (stuff->destKind) {
+    case ShapeBounding:
+	srcRgn = wBoundingShape (pWin);
+	break;
+    case ShapeClip:
+	srcRgn = wClipShape(pWin);
+	break;
+    case ShapeInput:
+	srcRgn = wInputShape (pWin);
+	break;
+    default:
+	client->errorValue = stuff->destKind;
+	return BadValue;
+    }
+    if (srcRgn)
+    {
+        RegionTranslate(srcRgn, stuff->xOff, stuff->yOff);
+        (*pWin->drawable.pScreen->SetShape) (pWin, stuff->destKind);
+    }
+    SendShapeNotify (pWin, (int)stuff->destKind);
+    return Success;
+}
+
+
+#ifdef PANORAMIX
+static int
+ProcPanoramiXShapeOffset(
+    ClientPtr client)
+{
+    REQUEST(xShapeOffsetReq);
+    PanoramiXRes *win;
+    int j, result;
+
+    REQUEST_AT_LEAST_SIZE (xShapeOffsetReq);
+   
+    result = dixLookupResourceByType((pointer *)&win, stuff->dest, XRT_WINDOW,
+				     client, DixWriteAccess);
+    if (result != Success)
+	return result;
+
+    FOR_NSCREENS(j) {
+	stuff->dest = win->info[j].id;
+	result = ProcShapeOffset (client);
+	if(result != Success) break;
+    }
+    return result;
+}
+#endif
+
+
+static int
+ProcShapeQueryExtents (ClientPtr client)
+{
+    REQUEST(xShapeQueryExtentsReq);
+    WindowPtr		pWin;
+    xShapeQueryExtentsReply	rep;
+    BoxRec		extents, *pExtents;
+    int	rc;
+    RegionPtr		region;
+
+    REQUEST_SIZE_MATCH (xShapeQueryExtentsReq);
+    rc = dixLookupWindow(&pWin, stuff->window, client, DixGetAttrAccess);
+    if (rc != Success)
+	return rc;
+    memset(&rep, 0, sizeof(xShapeQueryExtentsReply));
+    rep.type = X_Reply;
+    rep.length = 0;
+    rep.sequenceNumber = client->sequence;
+    rep.boundingShaped = (wBoundingShape(pWin) != 0);
+    rep.clipShaped = (wClipShape(pWin) != 0);
+    if ((region = wBoundingShape(pWin))) {
+     /* this is done in two steps because of a compiler bug on SunOS 4.1.3 */
+	pExtents = RegionExtents(region);
+	extents = *pExtents;
+    } else {
+	extents.x1 = -wBorderWidth (pWin);
+	extents.y1 = -wBorderWidth (pWin);
+	extents.x2 = pWin->drawable.width + wBorderWidth (pWin);
+	extents.y2 = pWin->drawable.height + wBorderWidth (pWin);
+    }
+    rep.xBoundingShape = extents.x1;
+    rep.yBoundingShape = extents.y1;
+    rep.widthBoundingShape = extents.x2 - extents.x1;
+    rep.heightBoundingShape = extents.y2 - extents.y1;
+    if ((region = wClipShape(pWin))) {
+     /* this is done in two steps because of a compiler bug on SunOS 4.1.3 */
+	pExtents = RegionExtents(region);
+	extents = *pExtents;
+    } else {
+	extents.x1 = 0;
+	extents.y1 = 0;
+	extents.x2 = pWin->drawable.width;
+	extents.y2 = pWin->drawable.height;
+    }
+    rep.xClipShape = extents.x1;
+    rep.yClipShape = extents.y1;
+    rep.widthClipShape = extents.x2 - extents.x1;
+    rep.heightClipShape = extents.y2 - extents.y1;
+    if (client->swapped) {
+	swaps(&rep.sequenceNumber);
+	swapl(&rep.length);
+	swaps(&rep.xBoundingShape);
+	swaps(&rep.yBoundingShape);
+	swaps(&rep.widthBoundingShape);
+	swaps(&rep.heightBoundingShape);
+	swaps(&rep.xClipShape);
+	swaps(&rep.yClipShape);
+	swaps(&rep.widthClipShape);
+	swaps(&rep.heightClipShape);
+    }
+    WriteToClient(client, sizeof (xShapeQueryExtentsReply), (char *)&rep);
+    return Success;
+}
+
+/*ARGSUSED*/
+static int
+ShapeFreeClient (pointer data, XID id)
+{
+    ShapeEventPtr   pShapeEvent;
+    WindowPtr	    pWin;
+    ShapeEventPtr   *pHead, pCur, pPrev;
+    int rc;
+
+    pShapeEvent = (ShapeEventPtr) data;
+    pWin = pShapeEvent->window;
+    rc = dixLookupResourceByType((pointer *)&pHead, pWin->drawable.id,
+				 ShapeEventType, serverClient, DixReadAccess);
+    if (rc == Success) {
+	pPrev = 0;
+	for (pCur = *pHead; pCur && pCur != pShapeEvent; pCur=pCur->next)
+	    pPrev = pCur;
+	if (pCur)
+	{
+	    if (pPrev)
+	    	pPrev->next = pShapeEvent->next;
+	    else
+	    	*pHead = pShapeEvent->next;
+	}
+    }
+    free((pointer) pShapeEvent);
+    return 1;
+}
+
+/*ARGSUSED*/
+static int
+ShapeFreeEvents (pointer data, XID id)
+{
+    ShapeEventPtr   *pHead, pCur, pNext;
+
+    pHead = (ShapeEventPtr *) data;
+    for (pCur = *pHead; pCur; pCur = pNext) {
+	pNext = pCur->next;
+	FreeResource (pCur->clientResource, ClientType);
+	free((pointer) pCur);
+    }
+    free((pointer) pHead);
+    return 1;
+}
+
+static int
+ProcShapeSelectInput (ClientPtr client)
+{
+    REQUEST(xShapeSelectInputReq);
+    WindowPtr		pWin;
+    ShapeEventPtr	pShapeEvent, pNewShapeEvent, *pHead;
+    XID			clientResource;
+    int			rc;
+
+    REQUEST_SIZE_MATCH (xShapeSelectInputReq);
+    rc = dixLookupWindow(&pWin, stuff->window, client, DixReceiveAccess);
+    if (rc != Success)
+	return rc;
+    rc = dixLookupResourceByType((pointer *)&pHead, pWin->drawable.id,
+				 ShapeEventType, client, DixWriteAccess);
+    if (rc != Success && rc != BadValue)
+	return rc;
+
+    switch (stuff->enable) {
+    case xTrue:
+	if (pHead) {
+
+	    /* check for existing entry. */
+	    for (pShapeEvent = *pHead;
+		 pShapeEvent;
+ 		 pShapeEvent = pShapeEvent->next)
+	    {
+		if (pShapeEvent->client == client)
+		    return Success;
+	    }
+	}
+
+	/* build the entry */
+	pNewShapeEvent = malloc(sizeof (ShapeEventRec));
+    	if (!pNewShapeEvent)
+	    return BadAlloc;
+    	pNewShapeEvent->next = 0;
+    	pNewShapeEvent->client = client;
+    	pNewShapeEvent->window = pWin;
+    	/*
+ 	 * add a resource that will be deleted when
+     	 * the client goes away
+     	 */
+   	clientResource = FakeClientID (client->index);
+    	pNewShapeEvent->clientResource = clientResource;
+    	if (!AddResource (clientResource, ClientType, (pointer)pNewShapeEvent))
+	    return BadAlloc;
+    	/*
+     	 * create a resource to contain a pointer to the list
+     	 * of clients selecting input.  This must be indirect as
+     	 * the list may be arbitrarily rearranged which cannot be
+     	 * done through the resource database.
+     	 */
+    	if (!pHead)
+    	{
+	    pHead = malloc(sizeof (ShapeEventPtr));
+	    if (!pHead ||
+		!AddResource (pWin->drawable.id, ShapeEventType, (pointer)pHead))
+	    {
+	    	FreeResource (clientResource, RT_NONE);
+	    	return BadAlloc;
+	    }
+	    *pHead = 0;
+    	}
+    	pNewShapeEvent->next = *pHead;
+    	*pHead = pNewShapeEvent;
+	break;
+    case xFalse:
+	/* delete the interest */
+	if (pHead) {
+	    pNewShapeEvent = 0;
+	    for (pShapeEvent = *pHead; pShapeEvent; pShapeEvent = pShapeEvent->next) {
+		if (pShapeEvent->client == client)
+		    break;
+		pNewShapeEvent = pShapeEvent;
+	    }
+	    if (pShapeEvent) {
+		FreeResource (pShapeEvent->clientResource, ClientType);
+		if (pNewShapeEvent)
+		    pNewShapeEvent->next = pShapeEvent->next;
+		else
+		    *pHead = pShapeEvent->next;
+		free(pShapeEvent);
+	    }
+	}
+	break;
+    default:
+	client->errorValue = stuff->enable;
+	return BadValue;
+    }
+    return Success;
+}
+
+/*
+ * deliver the event
+ */
+
+void
+SendShapeNotify (WindowPtr pWin, int which)
+{
+    ShapeEventPtr	*pHead, pShapeEvent;
+    xShapeNotifyEvent	se;
+    BoxRec		extents;
+    RegionPtr		region;
+    BYTE		shaped;
+    int rc;
+
+    rc = dixLookupResourceByType((pointer *)&pHead, pWin->drawable.id,
+				 ShapeEventType, serverClient, DixReadAccess);
+    if (rc != Success)
+	return;
+    switch (which) {
+    case ShapeBounding:
+	region = wBoundingShape(pWin);
+	if (region) {
+	    extents = *RegionExtents(region);
+	    shaped = xTrue;
+	} else {
+	    extents.x1 = -wBorderWidth (pWin);
+	    extents.y1 = -wBorderWidth (pWin);
+	    extents.x2 = pWin->drawable.width + wBorderWidth (pWin);
+	    extents.y2 = pWin->drawable.height + wBorderWidth (pWin);
+	    shaped = xFalse;
+	}
+	break;
+    case ShapeClip:
+	region = wClipShape(pWin);
+	if (region) {
+	    extents = *RegionExtents(region);
+	    shaped = xTrue;
+	} else {
+	    extents.x1 = 0;
+	    extents.y1 = 0;
+	    extents.x2 = pWin->drawable.width;
+	    extents.y2 = pWin->drawable.height;
+	    shaped = xFalse;
+	}
+	break;
+    case ShapeInput:
+	region = wInputShape(pWin);
+	if (region) {
+	    extents = *RegionExtents(region);
+	    shaped = xTrue;
+	} else {
+	    extents.x1 = -wBorderWidth (pWin);
+	    extents.y1 = -wBorderWidth (pWin);
+	    extents.x2 = pWin->drawable.width + wBorderWidth (pWin);
+	    extents.y2 = pWin->drawable.height + wBorderWidth (pWin);
+	    shaped = xFalse;
+	}
+	break;
+    default:
+	return;
+    }
+    for (pShapeEvent = *pHead; pShapeEvent; pShapeEvent = pShapeEvent->next) {
+	se.type = ShapeNotify + ShapeEventBase;
+	se.kind = which;
+	se.window = pWin->drawable.id;
+	se.x = extents.x1;
+	se.y = extents.y1;
+	se.width = extents.x2 - extents.x1;
+	se.height = extents.y2 - extents.y1;
+	se.time = currentTime.milliseconds;
+	se.shaped = shaped;
+	WriteEventsToClient (pShapeEvent->client, 1, (xEvent *) &se);
+    }
+}
+
+static int
+ProcShapeInputSelected (ClientPtr client)
+{
+    REQUEST(xShapeInputSelectedReq);
+    WindowPtr		pWin;
+    ShapeEventPtr	pShapeEvent, *pHead;
+    int			enabled, rc;
+    xShapeInputSelectedReply	rep;
+    REQUEST_SIZE_MATCH (xShapeInputSelectedReq);
+    rc = dixLookupWindow(&pWin, stuff->window, client, DixGetAttrAccess);
+    if (rc != Success)
+	return rc;
+    rc = dixLookupResourceByType((pointer *)&pHead, pWin->drawable.id,
+				 ShapeEventType, client, DixReadAccess);
+    if (rc != Success && rc != BadValue)
+	return rc;
+    enabled = xFalse;
+    if (pHead) {
+    	for (pShapeEvent = *pHead;
+	     pShapeEvent;
+	     pShapeEvent = pShapeEvent->next)
+    	{
+	    if (pShapeEvent->client == client) {
+	    	enabled = xTrue;
+		break;
+	    }
+    	}
+    }
+    rep.type = X_Reply;
+    rep.length = 0;
+    rep.sequenceNumber = client->sequence;
+    rep.enabled = enabled;
+    if (client->swapped) {
+	swaps(&rep.sequenceNumber);
+	swapl(&rep.length);
+    }
+    WriteToClient (client, sizeof (xShapeInputSelectedReply), (char *) &rep);
+    return Success;
+}
+
+static int
+ProcShapeGetRectangles (ClientPtr client)
+{
+    REQUEST(xShapeGetRectanglesReq);
+    WindowPtr			pWin;
+    xShapeGetRectanglesReply	rep;
+    xRectangle			*rects;
+    int				nrects, i, rc;
+    RegionPtr			region;
+    REQUEST_SIZE_MATCH(xShapeGetRectanglesReq);
+    rc = dixLookupWindow(&pWin, stuff->window, client, DixGetAttrAccess);
+    if (rc != Success)
+	return rc;
+    switch (stuff->kind) {
+    case ShapeBounding:
+	region = wBoundingShape(pWin);
+	break;
+    case ShapeClip:
+	region = wClipShape(pWin);
+	break;
+    case ShapeInput:
+	region = wInputShape (pWin);
+	break;
+    default:
+	client->errorValue = stuff->kind;
+	return BadValue;
+    }
+    if (!region) {
+	nrects = 1;
+	rects = malloc(sizeof (xRectangle));
+	if (!rects)
+	    return BadAlloc;
+	switch (stuff->kind) {
+	case ShapeBounding:
+	    rects->x = - (int) wBorderWidth (pWin);
+	    rects->y = - (int) wBorderWidth (pWin);
+	    rects->width = pWin->drawable.width + wBorderWidth (pWin);
+	    rects->height = pWin->drawable.height + wBorderWidth (pWin);
+	    break;
+	case ShapeClip:
+	    rects->x = 0;
+	    rects->y = 0;
+	    rects->width = pWin->drawable.width;
+	    rects->height = pWin->drawable.height;
+	    break;
+	case ShapeInput:
+	    rects->x = - (int) wBorderWidth (pWin);
+	    rects->y = - (int) wBorderWidth (pWin);
+	    rects->width = pWin->drawable.width + wBorderWidth (pWin);
+	    rects->height = pWin->drawable.height + wBorderWidth (pWin);
+	    break;
+	}
+    } else {
+	BoxPtr box;
+	nrects = RegionNumRects(region);
+	box = RegionRects(region);
+	rects = malloc(nrects * sizeof (xRectangle));
+	if (!rects && nrects)
+	    return BadAlloc;
+	for (i = 0; i < nrects; i++, box++) {
+	    rects[i].x = box->x1;
+	    rects[i].y = box->y1;
+	    rects[i].width = box->x2 - box->x1;
+	    rects[i].height = box->y2 - box->y1;
+	}
+    }
+    rep.type = X_Reply;
+    rep.sequenceNumber = client->sequence;
+    rep.length = bytes_to_int32(nrects * sizeof (xRectangle));
+    rep.ordering = YXBanded;
+    rep.nrects = nrects;
+    if (client->swapped) {
+	swaps(&rep.sequenceNumber);
+	swapl(&rep.length);
+	swapl(&rep.nrects);
+	SwapShorts ((short *)rects, (unsigned long)nrects * 4);
+    }
+    WriteToClient (client, sizeof (rep), (char *) &rep);
+    WriteToClient (client, nrects * sizeof (xRectangle), (char *) rects);
+    free(rects);
+    return Success;
+}
+
+static int
+ProcShapeDispatch (ClientPtr client)
+{
+    REQUEST(xReq);
+    switch (stuff->data) {
+    case X_ShapeQueryVersion:
+	return ProcShapeQueryVersion (client);
+    case X_ShapeRectangles:
+#ifdef PANORAMIX
+        if ( !noPanoramiXExtension )
+	    return ProcPanoramiXShapeRectangles (client);
+        else 
+#endif
+	return ProcShapeRectangles (client);
+    case X_ShapeMask:
+#ifdef PANORAMIX
+        if ( !noPanoramiXExtension )
+           return ProcPanoramiXShapeMask (client);
+	else
+#endif
+	return ProcShapeMask (client);
+    case X_ShapeCombine:
+#ifdef PANORAMIX
+        if ( !noPanoramiXExtension )
+           return ProcPanoramiXShapeCombine (client);
+	else
+#endif
+	return ProcShapeCombine (client);
+    case X_ShapeOffset:
+#ifdef PANORAMIX
+        if ( !noPanoramiXExtension )
+           return ProcPanoramiXShapeOffset (client);
+	else
+#endif
+	return ProcShapeOffset (client);
+    case X_ShapeQueryExtents:
+	return ProcShapeQueryExtents (client);
+    case X_ShapeSelectInput:
+	return ProcShapeSelectInput (client);
+    case X_ShapeInputSelected:
+	return ProcShapeInputSelected (client);
+    case X_ShapeGetRectangles:
+	return ProcShapeGetRectangles (client);
+    default:
+	return BadRequest;
+    }
+}
+
+static void
+SShapeNotifyEvent(xShapeNotifyEvent *from, xShapeNotifyEvent *to)
+{
+    to->type = from->type;
+    to->kind = from->kind;
+    cpswapl (from->window, to->window);
+    cpswaps (from->sequenceNumber, to->sequenceNumber);
+    cpswaps (from->x, to->x);
+    cpswaps (from->y, to->y);
+    cpswaps (from->width, to->width);
+    cpswaps (from->height, to->height);
+    cpswapl (from->time, to->time);
+    to->shaped = from->shaped;
+}
+
+static int
+SProcShapeQueryVersion (ClientPtr client)
+{
+    REQUEST (xShapeQueryVersionReq);
+
+    swaps(&stuff->length);
+    return ProcShapeQueryVersion (client);
+}
+
+static int
+SProcShapeRectangles (ClientPtr client)
+{
+    REQUEST (xShapeRectanglesReq);
+
+    swaps(&stuff->length);
+    REQUEST_AT_LEAST_SIZE (xShapeRectanglesReq);
+    swapl(&stuff->dest);
+    swaps(&stuff->xOff);
+    swaps(&stuff->yOff);
+    SwapRestS(stuff);
+    return ProcShapeRectangles (client);
+}
+
+static int
+SProcShapeMask (ClientPtr client)
+{
+    REQUEST (xShapeMaskReq);
+
+    swaps(&stuff->length);
+    REQUEST_SIZE_MATCH (xShapeMaskReq);
+    swapl(&stuff->dest);
+    swaps(&stuff->xOff);
+    swaps(&stuff->yOff);
+    swapl(&stuff->src);
+    return ProcShapeMask (client);
+}
+
+static int
+SProcShapeCombine (ClientPtr client)
+{
+    REQUEST (xShapeCombineReq);
+
+    swaps(&stuff->length);
+    REQUEST_SIZE_MATCH (xShapeCombineReq);
+    swapl(&stuff->dest);
+    swaps(&stuff->xOff);
+    swaps(&stuff->yOff);
+    swapl(&stuff->src);
+    return ProcShapeCombine (client);
+}
+
+static int
+SProcShapeOffset (ClientPtr client)
+{
+    REQUEST (xShapeOffsetReq);
+
+    swaps(&stuff->length);
+    REQUEST_SIZE_MATCH (xShapeOffsetReq);
+    swapl(&stuff->dest);
+    swaps(&stuff->xOff);
+    swaps(&stuff->yOff);
+    return ProcShapeOffset (client);
+}
+
+static int
+SProcShapeQueryExtents (ClientPtr client)
+{
+    REQUEST (xShapeQueryExtentsReq);
+
+    swaps(&stuff->length);
+    REQUEST_SIZE_MATCH (xShapeQueryExtentsReq);
+    swapl(&stuff->window);
+    return ProcShapeQueryExtents (client);
+}
+
+static int
+SProcShapeSelectInput (ClientPtr client)
+{
+    REQUEST (xShapeSelectInputReq);
+
+    swaps(&stuff->length);
+    REQUEST_SIZE_MATCH (xShapeSelectInputReq);
+    swapl(&stuff->window);
+    return ProcShapeSelectInput (client);
+}
+
+static int
+SProcShapeInputSelected (ClientPtr client)
+{
+    REQUEST (xShapeInputSelectedReq);
+
+    swaps(&stuff->length);
+    REQUEST_SIZE_MATCH (xShapeInputSelectedReq);
+    swapl(&stuff->window);
+    return ProcShapeInputSelected (client);
+}
+
+static int
+SProcShapeGetRectangles (ClientPtr client)
+{
+    REQUEST(xShapeGetRectanglesReq);
+    swaps(&stuff->length);
+    REQUEST_SIZE_MATCH(xShapeGetRectanglesReq);
+    swapl(&stuff->window);
+    return ProcShapeGetRectangles (client);
+}
+
+static int
+SProcShapeDispatch (ClientPtr client)
+{
+    REQUEST(xReq);
+    switch (stuff->data) {
+    case X_ShapeQueryVersion:
+	return SProcShapeQueryVersion (client);
+    case X_ShapeRectangles:
+	return SProcShapeRectangles (client);
+    case X_ShapeMask:
+	return SProcShapeMask (client);
+    case X_ShapeCombine:
+	return SProcShapeCombine (client);
+    case X_ShapeOffset:
+	return SProcShapeOffset (client);
+    case X_ShapeQueryExtents:
+	return SProcShapeQueryExtents (client);
+    case X_ShapeSelectInput:
+	return SProcShapeSelectInput (client);
+    case X_ShapeInputSelected:
+	return SProcShapeInputSelected (client);
+    case X_ShapeGetRectangles:
+	return SProcShapeGetRectangles (client);
+    default:
+	return BadRequest;
+    }
+}
+
+void
+ShapeExtensionInit(void)
+{
+    ExtensionEntry *extEntry;
+
+    ClientType = CreateNewResourceType(ShapeFreeClient, "ShapeClient");
+    ShapeEventType = CreateNewResourceType(ShapeFreeEvents, "ShapeEvent");
+    if (ClientType && ShapeEventType &&
+	(extEntry = AddExtension(SHAPENAME, ShapeNumberEvents, 0,
+				 ProcShapeDispatch, SProcShapeDispatch,
+				 NULL, StandardMinorOpcode)))
+    {
+	ShapeEventBase = extEntry->eventBase;
+	EventSwapVector[ShapeEventBase] = (EventSwapPtr) SShapeNotifyEvent;
+    }
+}
diff --git a/xorg-server/Xext/shm.c b/xorg-server/Xext/shm.c
index ac1ab3b56..39916df60 100644
--- a/xorg-server/Xext/shm.c
+++ b/xorg-server/Xext/shm.c
@@ -291,7 +291,6 @@ static int
 ProcShmQueryVersion(ClientPtr client)
 {
     xShmQueryVersionReply rep;
-    int n;
 
     REQUEST_SIZE_MATCH(xShmQueryVersionReq);
     memset(&rep, 0, sizeof(xShmQueryVersionReply));
@@ -307,12 +306,12 @@ ProcShmQueryVersion(ClientPtr client)
     rep.gid = getegid();
 #endif
     if (client->swapped) {
-    	swaps(&rep.sequenceNumber, n);
-    	swapl(&rep.length, n);
-	swaps(&rep.majorVersion, n);
-	swaps(&rep.minorVersion, n);
-	swaps(&rep.uid, n);
-	swaps(&rep.gid, n);
+	swaps(&rep.sequenceNumber);
+	swapl(&rep.length);
+	swaps(&rep.majorVersion);
+	swaps(&rep.minorVersion);
+	swaps(&rep.uid);
+	swaps(&rep.gid);
     }
     WriteToClient(client, sizeof(xShmQueryVersionReply), (char *)&rep);
     return Success;
@@ -652,7 +651,7 @@ ProcShmGetImage(ClientPtr client)
     Mask		plane = 0;
     xShmGetImageReply	xgi;
     ShmDescPtr		shmdesc;
-    int			n, rc;
+    int			rc;
 
     REQUEST(xShmGetImageReq);
 
@@ -746,10 +745,10 @@ ProcShmGetImage(ClientPtr client)
     }
 
     if (client->swapped) {
-	swaps(&xgi.sequenceNumber, n);
-	swapl(&xgi.length, n);
-	swapl(&xgi.visual, n);
-	swapl(&xgi.size, n);
+	swaps(&xgi.sequenceNumber);
+	swapl(&xgi.length);
+	swapl(&xgi.visual);
+	swapl(&xgi.size);
     }
     WriteToClient(client, sizeof(xShmGetImageReply), (char *)&xgi);
 
@@ -916,11 +915,10 @@ ProcPanoramiXShmGetImage(ClientPtr client)
     free(drawables);
     
     if (client->swapped) {
-	int n;
-    	swaps(&xgi.sequenceNumber, n);
-    	swapl(&xgi.length, n);
-	swapl(&xgi.visual, n);
-	swapl(&xgi.size, n);
+	swaps(&xgi.sequenceNumber);
+	swapl(&xgi.length);
+	swapl(&xgi.visual);
+	swapl(&xgi.size);
     }
     WriteToClient(client, sizeof(xShmGetImageReply), (char *)&xgi);
 
@@ -1010,7 +1008,6 @@ CreatePmap:
 	    pMap->drawable.serialNumber = NEXT_SERIAL_NUMBER;
 	    pMap->drawable.id = newPix->info[j].id;
 	    if (!AddResource(newPix->info[j].id, RT_PIXMAP, (pointer)pMap)) {
-		(*pScreen->DestroyPixmap)(pMap);
 		result = BadAlloc;
 		break;
 	    }
@@ -1021,10 +1018,8 @@ CreatePmap:
     }
 
     if(result == BadAlloc) {
-	while(j--) {
-	    (*pScreen->DestroyPixmap)(pMap);
+	while(j--)
 	    FreeResource(newPix->info[j].id, RT_NONE);
-	}
 	free(newPix);
     } else 
 	AddResource(stuff->pid, XRT_PIXMAP, newPix);
@@ -1129,7 +1124,6 @@ CreatePmap:
 	{
 	    return Success;
 	}
-	pDraw->pScreen->DestroyPixmap(pMap);
     }
     return BadAlloc;
 }
@@ -1184,89 +1178,83 @@ SShmCompletionEvent(xShmCompletionEvent *from, xShmCompletionEvent *to)
 static int
 SProcShmQueryVersion(ClientPtr client)
 {
-    int n;
     REQUEST(xShmQueryVersionReq);
 
-    swaps(&stuff->length, n);
+    swaps(&stuff->length);
     return ProcShmQueryVersion(client);
 }
 
 static int
 SProcShmAttach(ClientPtr client)
 {
-    int n;
     REQUEST(xShmAttachReq);
-    swaps(&stuff->length, n);
+    swaps(&stuff->length);
     REQUEST_SIZE_MATCH(xShmAttachReq);
-    swapl(&stuff->shmseg, n);
-    swapl(&stuff->shmid, n);
+    swapl(&stuff->shmseg);
+    swapl(&stuff->shmid);
     return ProcShmAttach(client);
 }
 
 static int
 SProcShmDetach(ClientPtr client)
 {
-    int n;
     REQUEST(xShmDetachReq);
-    swaps(&stuff->length, n);
+    swaps(&stuff->length);
     REQUEST_SIZE_MATCH(xShmDetachReq);
-    swapl(&stuff->shmseg, n);
+    swapl(&stuff->shmseg);
     return ProcShmDetach(client);
 }
 
 static int
 SProcShmPutImage(ClientPtr client)
 {
-    int n;
     REQUEST(xShmPutImageReq);
-    swaps(&stuff->length, n);
+    swaps(&stuff->length);
     REQUEST_SIZE_MATCH(xShmPutImageReq);
-    swapl(&stuff->drawable, n);
-    swapl(&stuff->gc, n);
-    swaps(&stuff->totalWidth, n);
-    swaps(&stuff->totalHeight, n);
-    swaps(&stuff->srcX, n);
-    swaps(&stuff->srcY, n);
-    swaps(&stuff->srcWidth, n);
-    swaps(&stuff->srcHeight, n);
-    swaps(&stuff->dstX, n);
-    swaps(&stuff->dstY, n);
-    swapl(&stuff->shmseg, n);
-    swapl(&stuff->offset, n);
+    swapl(&stuff->drawable);
+    swapl(&stuff->gc);
+    swaps(&stuff->totalWidth);
+    swaps(&stuff->totalHeight);
+    swaps(&stuff->srcX);
+    swaps(&stuff->srcY);
+    swaps(&stuff->srcWidth);
+    swaps(&stuff->srcHeight);
+    swaps(&stuff->dstX);
+    swaps(&stuff->dstY);
+    swapl(&stuff->shmseg);
+    swapl(&stuff->offset);
     return ProcShmPutImage(client);
 }
 
 static int
 SProcShmGetImage(ClientPtr client)
 {
-    int n;
     REQUEST(xShmGetImageReq);
-    swaps(&stuff->length, n);
+    swaps(&stuff->length);
     REQUEST_SIZE_MATCH(xShmGetImageReq);
-    swapl(&stuff->drawable, n);
-    swaps(&stuff->x, n);
-    swaps(&stuff->y, n);
-    swaps(&stuff->width, n);
-    swaps(&stuff->height, n);
-    swapl(&stuff->planeMask, n);
-    swapl(&stuff->shmseg, n);
-    swapl(&stuff->offset, n);
+    swapl(&stuff->drawable);
+    swaps(&stuff->x);
+    swaps(&stuff->y);
+    swaps(&stuff->width);
+    swaps(&stuff->height);
+    swapl(&stuff->planeMask);
+    swapl(&stuff->shmseg);
+    swapl(&stuff->offset);
     return ProcShmGetImage(client);
 }
 
 static int
 SProcShmCreatePixmap(ClientPtr client)
 {
-    int n;
     REQUEST(xShmCreatePixmapReq);
-    swaps(&stuff->length, n);
+    swaps(&stuff->length);
     REQUEST_SIZE_MATCH(xShmCreatePixmapReq);
-    swapl(&stuff->pid, n);
-    swapl(&stuff->drawable, n);
-    swaps(&stuff->width, n);
-    swaps(&stuff->height, n);
-    swapl(&stuff->shmseg, n);
-    swapl(&stuff->offset, n);
+    swapl(&stuff->pid);
+    swapl(&stuff->drawable);
+    swaps(&stuff->width);
+    swaps(&stuff->height);
+    swapl(&stuff->shmseg);
+    swapl(&stuff->offset);
     return ProcShmCreatePixmap(client);
 }
 
diff --git a/xorg-server/Xext/sync.c b/xorg-server/Xext/sync.c
index 60bcfe8d8..67fad2d4f 100644
--- a/xorg-server/Xext/sync.c
+++ b/xorg-server/Xext/sync.c
@@ -1,2929 +1,2881 @@
-/*

-

-Copyright 1991, 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.

-

-

-Copyright 1991, 1993 by Digital Equipment Corporation, Maynard, Massachusetts,

-and Olivetti Research Limited, Cambridge, England.

-

-                        All Rights Reserved

-

-Permission to use, copy, modify, and distribute this software and its

-documentation for any purpose and without fee is hereby granted,

-provided that the above copyright notice appear in all copies and that

-both that copyright notice and this permission notice appear in

-supporting documentation, and that the names of Digital or Olivetti

-not be used in advertising or publicity pertaining to distribution of the

-software without specific, written prior permission.  Digital and Olivetti

-make no representations about the suitability of this software

-for any purpose.  It is provided "as is" without express or implied warranty.

-

-DIGITAL AND OLIVETTI DISCLAIM ALL WARRANTIES WITH REGARD TO THIS

-SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND

-FITNESS, IN NO EVENT SHALL THEY BE LIABLE FOR ANY SPECIAL, INDIRECT OR

-CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF

-USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR

-OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR

-PERFORMANCE OF THIS SOFTWARE.

-

-*/

-

-#ifdef HAVE_DIX_CONFIG_H

-#include <dix-config.h>

-#endif

-

-#include <string.h>

-

-#include <X11/X.h>

-#include <X11/Xproto.h>

-#include <X11/Xmd.h>

-#include "scrnintstr.h"

-#include "os.h"

-#include "extnsionst.h"

-#include "dixstruct.h"

-#include "pixmapstr.h"

-#include "resource.h"

-#include "opaque.h"

-#include <X11/extensions/syncproto.h>

-#include "syncsrv.h"

-#include "syncsdk.h"

-#include "protocol-versions.h"

-

-#include <stdio.h>

-#if !defined(WIN32)

-#include <sys/time.h>

-#endif

-

-#include "modinit.h"

-

-/*

- * Local Global Variables

- */

-static int      SyncEventBase;

-static int      SyncErrorBase;

-static RESTYPE  RTCounter = 0;

-static RESTYPE  RTAwait;

-static RESTYPE  RTAlarm;

-static RESTYPE  RTAlarmClient;

-static RESTYPE  RTFence;

-static int SyncNumSystemCounters = 0;

-static SyncCounter **SysCounterList = NULL;

-static int SyncNumInvalidCounterWarnings = 0;

-#define MAX_INVALID_COUNTER_WARNINGS	   5

-

-static const char *WARN_INVALID_COUNTER_COMPARE =

-"Warning: Non-counter XSync object using Counter-only\n"

-"         comparison.  Result will never be true.\n";

-

-static const char *WARN_INVALID_COUNTER_ALARM =

-"Warning: Non-counter XSync object used in alarm.  This is\n"

-"         the result of a programming error in the X server.\n";

-

-#define IsSystemCounter(pCounter) \

-    (pCounter && (pCounter->sync.client == NULL))

-

-/* these are all the alarm attributes that pertain to the alarm's trigger */

-#define XSyncCAAllTrigger \

-    (XSyncCACounter | XSyncCAValueType | XSyncCAValue | XSyncCATestType)

-

-static void SyncComputeBracketValues(SyncCounter *);

-

-static void SyncInitServerTime(void);

-

-static void SyncInitIdleTime(void);

-

-static Bool

-SyncCheckWarnIsCounter(const SyncObject* pSync, const char *warning)

-{

-    if (pSync && (SYNC_COUNTER != pSync->type))

-    {

-	if (SyncNumInvalidCounterWarnings++ < MAX_INVALID_COUNTER_WARNINGS)

-	{

-	    ErrorF("%s", warning);

-	    ErrorF("         Counter type: %d\n", pSync->type);

-	}

-

-	return FALSE;

-    }

-

-    return TRUE;

-}

-

-/*  Each counter maintains a simple linked list of triggers that are

- *  interested in the counter.  The two functions below are used to

- *  delete and add triggers on this list.

- */

-static void

-SyncDeleteTriggerFromSyncObject(SyncTrigger *pTrigger)

-{

-    SyncTriggerList *pCur;

-    SyncTriggerList *pPrev;

-    SyncCounter *pCounter;

-

-    /* pSync needs to be stored in pTrigger before calling here. */

-

-    if (!pTrigger->pSync)

-	return;

-

-    pPrev = NULL;

-    pCur = pTrigger->pSync->pTriglist;

-

-    while (pCur)

-    {

-	if (pCur->pTrigger == pTrigger)

-	{

-	    if (pPrev)

-		pPrev->next = pCur->next;

-	    else

-		pTrigger->pSync->pTriglist = pCur->next;

-

-	    free(pCur);

-	    break;

-	}

-	

-	pPrev = pCur;

-	pCur = pCur->next;

-    }

-

-    if (SYNC_COUNTER == pTrigger->pSync->type)

-    {

-	pCounter = (SyncCounter *)pTrigger->pSync;

-

-	if (IsSystemCounter(pCounter))

-	    SyncComputeBracketValues(pCounter);

-    } else if (SYNC_FENCE == pTrigger->pSync->type) {

-	SyncFence* pFence = (SyncFence*) pTrigger->pSync;

-	pFence->funcs.DeleteTrigger(pTrigger);

-    }

-}

-

-

-static int

-SyncAddTriggerToSyncObject(SyncTrigger *pTrigger)

-{

-    SyncTriggerList *pCur;

-    SyncCounter *pCounter;

-

-    if (!pTrigger->pSync)

-	return Success;

-

-    /* don't do anything if it's already there */

-    for (pCur = pTrigger->pSync->pTriglist; pCur; pCur = pCur->next)

-    {

-	if (pCur->pTrigger == pTrigger)

-	    return Success;

-    }

-

-    if (!(pCur = malloc(sizeof(SyncTriggerList))))

-	return BadAlloc;

-

-    pCur->pTrigger = pTrigger;

-    pCur->next = pTrigger->pSync->pTriglist;

-    pTrigger->pSync->pTriglist = pCur;

-

-    if (SYNC_COUNTER == pTrigger->pSync->type)

-    {

-	pCounter = (SyncCounter *)pTrigger->pSync;

-

-	if (IsSystemCounter(pCounter))

-	    SyncComputeBracketValues(pCounter);

-    } else if (SYNC_FENCE == pTrigger->pSync->type) {

-	SyncFence* pFence = (SyncFence*) pTrigger->pSync;

-	pFence->funcs.AddTrigger(pTrigger);

-    }

-

-    return Success;

-}

-

-

-/*  Below are five possible functions that can be plugged into

- *  pTrigger->CheckTrigger for counter sync objects, corresponding to

- *  the four possible test-types, and the one possible function that

- *  can be plugged into pTrigger->CheckTrigger for fence sync objects.

- *  These functions are called after the sync object's state changes

- *  but are also passed the old state so they can inspect both the old

- *  and new values.  (PositiveTransition and NegativeTransition need to

- *  see both pieces of information.)  These functions return the truth

- *  value of the trigger.

- *

- *  All of them include the condition pTrigger->pSync == NULL.

- *  This is because the spec says that a trigger with a sync value

- *  of None is always TRUE.

- */

-

-static Bool

-SyncCheckTriggerPositiveComparison(SyncTrigger *pTrigger, CARD64 oldval)

-{

-    SyncCounter *pCounter;

-

-    /* Non-counter sync objects should never get here because they

-     * never trigger this comparison. */

-    if (!SyncCheckWarnIsCounter(pTrigger->pSync, WARN_INVALID_COUNTER_COMPARE))

-	return FALSE;

-

-    pCounter = (SyncCounter *)pTrigger->pSync;

-

-    return (pCounter == NULL ||

-	    XSyncValueGreaterOrEqual(pCounter->value, pTrigger->test_value));

-}

-

-static Bool

-SyncCheckTriggerNegativeComparison(SyncTrigger *pTrigger,  CARD64 oldval)

-{

-    SyncCounter *pCounter;

-

-    /* Non-counter sync objects should never get here because they

-     * never trigger this comparison. */

-    if (!SyncCheckWarnIsCounter(pTrigger->pSync, WARN_INVALID_COUNTER_COMPARE))

-	return FALSE;

-

-    pCounter = (SyncCounter *)pTrigger->pSync;

-

-    return (pCounter == NULL ||

-	    XSyncValueLessOrEqual(pCounter->value, pTrigger->test_value));

-}

-

-static Bool

-SyncCheckTriggerPositiveTransition(SyncTrigger *pTrigger, CARD64 oldval)

-{

-    SyncCounter *pCounter;

-

-    /* Non-counter sync objects should never get here because they

-     * never trigger this comparison. */

-    if (!SyncCheckWarnIsCounter(pTrigger->pSync, WARN_INVALID_COUNTER_COMPARE))

-	return FALSE;

-

-    pCounter = (SyncCounter *)pTrigger->pSync;

-

-    return (pCounter == NULL ||

-	    (XSyncValueLessThan(oldval, pTrigger->test_value) &&

-	     XSyncValueGreaterOrEqual(pCounter->value, pTrigger->test_value)));

-}

-

-static Bool

-SyncCheckTriggerNegativeTransition(SyncTrigger *pTrigger, CARD64 oldval)

-{

-    SyncCounter *pCounter;

-

-    /* Non-counter sync objects should never get here because they

-     * never trigger this comparison. */

-    if (!SyncCheckWarnIsCounter(pTrigger->pSync, WARN_INVALID_COUNTER_COMPARE))

-	return FALSE;

-

-    pCounter = (SyncCounter *)pTrigger->pSync;

-

-    return (pCounter == NULL ||

-	    (XSyncValueGreaterThan(oldval, pTrigger->test_value) &&

-	     XSyncValueLessOrEqual(pCounter->value, pTrigger->test_value)));

-}

-

-static Bool

-SyncCheckTriggerFence(SyncTrigger *pTrigger, CARD64 unused)

-{

-    SyncFence* pFence = (SyncFence*) pTrigger->pSync;

-    (void)unused;

-

-    return (pFence == NULL ||

-	    pFence->funcs.CheckTriggered(pFence));

-}

-

-static int

-SyncInitTrigger(ClientPtr client, SyncTrigger *pTrigger, XID syncObject,

-		RESTYPE resType, Mask changes)

-{

-    SyncObject *pSync = pTrigger->pSync;

-    SyncCounter *pCounter = NULL;

-    int		rc;

-    Bool	newSyncObject = FALSE;

-

-    if (changes & XSyncCACounter)

-    {

-	if (syncObject == None)

-	    pSync = NULL;

-	else if (Success != (rc = dixLookupResourceByType ((pointer *)&pSync,

-				syncObject, resType, client, DixReadAccess)))

-	{

-	    client->errorValue = syncObject;

-	    return rc;

-	}

-	if (pSync != pTrigger->pSync)

-	{ /* new counter for trigger */

-	    SyncDeleteTriggerFromSyncObject(pTrigger);

-	    pTrigger->pSync = pSync;

-	    newSyncObject = TRUE;

-	}

-    }

-

-    /* if system counter, ask it what the current value is */

-

-    if (pSync && SYNC_COUNTER == pSync->type)

-    {

-	pCounter = (SyncCounter *)pSync;

-

-	if (IsSystemCounter(pCounter))

-	{

-	    (*pCounter->pSysCounterInfo->QueryValue) ((pointer) pCounter,

-						      &pCounter->value);

-	}

-    }

-

-    if (changes & XSyncCAValueType)

-    {

-	if (pTrigger->value_type != XSyncRelative &&

-	    pTrigger->value_type != XSyncAbsolute)

-	{

-	    client->errorValue = pTrigger->value_type;

-	    return BadValue;

-	}

-    }

-

-    if (changes & XSyncCATestType)

-    {

-

-	if (pSync && SYNC_FENCE == pSync->type)

-	{

-	    pTrigger->CheckTrigger = SyncCheckTriggerFence;

-	}

-	else

-	{

-	    /* select appropriate CheckTrigger function */

-

-	    switch (pTrigger->test_type)

-	    {

-	    case XSyncPositiveTransition:

-		pTrigger->CheckTrigger = SyncCheckTriggerPositiveTransition;

-		break;

-	    case XSyncNegativeTransition:

-		pTrigger->CheckTrigger = SyncCheckTriggerNegativeTransition;

-		break;

-	    case XSyncPositiveComparison:

-		pTrigger->CheckTrigger = SyncCheckTriggerPositiveComparison;

-		break;

-	    case XSyncNegativeComparison:

-		pTrigger->CheckTrigger = SyncCheckTriggerNegativeComparison;

-		break;

-	    default:

-		client->errorValue = pTrigger->test_type;

-		return BadValue;

-	    }

-	}

-    }

-

-    if (changes & (XSyncCAValueType | XSyncCAValue))

-    {

-	if (pTrigger->value_type == XSyncAbsolute)

-	    pTrigger->test_value = pTrigger->wait_value;

-	else /* relative */

-	{

-	    Bool overflow;

-	    if (pCounter == NULL)

-		return BadMatch;

-

-	    XSyncValueAdd(&pTrigger->test_value, pCounter->value,

-			  pTrigger->wait_value, &overflow);

-	    if (overflow)

-	    {

-		client->errorValue = XSyncValueHigh32(pTrigger->wait_value);

-		return BadValue;

-	    }

-	}

-    }

-

-    /*  we wait until we're sure there are no errors before registering

-     *  a new counter on a trigger

-     */

-    if (newSyncObject)

-    {

-	if ((rc = SyncAddTriggerToSyncObject(pTrigger)) != Success)

-	    return rc;

-    }

-    else if (pCounter && IsSystemCounter(pCounter))

-    {

-	SyncComputeBracketValues(pCounter);

-    }

-

-    return Success;

-}

-

-/*  AlarmNotify events happen in response to actions taken on an Alarm or

- *  the counter used by the alarm.  AlarmNotify may be sent to multiple

- *  clients.  The alarm maintains a list of clients interested in events.

- */

-static void

-SyncSendAlarmNotifyEvents(SyncAlarm *pAlarm)

-{

-    SyncAlarmClientList *pcl;

-    xSyncAlarmNotifyEvent ane;

-    SyncTrigger *pTrigger = &pAlarm->trigger;

-    SyncCounter *pCounter;

-

-    if (!SyncCheckWarnIsCounter(pTrigger->pSync, WARN_INVALID_COUNTER_ALARM))

-	return;

-

-    pCounter = (SyncCounter *)pTrigger->pSync;

-

-    UpdateCurrentTime();

-

-    ane.type = SyncEventBase + XSyncAlarmNotify;

-    ane.kind = XSyncAlarmNotify;

-    ane.alarm = pAlarm->alarm_id;

-    if (pTrigger->pSync && SYNC_COUNTER == pTrigger->pSync->type)

-    {

-	ane.counter_value_hi = XSyncValueHigh32(pCounter->value);

-	ane.counter_value_lo = XSyncValueLow32(pCounter->value);

-    }

-    else

-    { /* XXX what else can we do if there's no counter? */

-	ane.counter_value_hi = ane.counter_value_lo = 0;

-    }

-

-    ane.alarm_value_hi = XSyncValueHigh32(pTrigger->test_value);

-    ane.alarm_value_lo = XSyncValueLow32(pTrigger->test_value);

-    ane.time = currentTime.milliseconds;

-    ane.state = pAlarm->state;

-

-    /* send to owner */

-    if (pAlarm->events)

-	WriteEventsToClient(pAlarm->client, 1, (xEvent *) &ane);

-

-    /* send to other interested clients */

-    for (pcl = pAlarm->pEventClients; pcl; pcl = pcl->next)

-	WriteEventsToClient(pcl->client, 1, (xEvent *) &ane);

-}

-

-

-/*  CounterNotify events only occur in response to an Await.  The events

- *  go only to the Awaiting client.

- */

-static void

-SyncSendCounterNotifyEvents(ClientPtr client, SyncAwait **ppAwait,

-			    int num_events)

-{

-    xSyncCounterNotifyEvent *pEvents, *pev;

-    int i;

-

-    if (client->clientGone)

-	return;

-    pev = pEvents = malloc(num_events * sizeof(xSyncCounterNotifyEvent));

-    if (!pEvents)

-	return;

-    UpdateCurrentTime();

-    for (i = 0; i < num_events; i++, ppAwait++, pev++)

-    {

-	SyncTrigger *pTrigger = &(*ppAwait)->trigger;

-	pev->type = SyncEventBase + XSyncCounterNotify;

-	pev->kind = XSyncCounterNotify;

-	pev->counter = pTrigger->pSync->id;

-	pev->wait_value_lo = XSyncValueLow32(pTrigger->test_value);

-	pev->wait_value_hi = XSyncValueHigh32(pTrigger->test_value);

-	if (SYNC_COUNTER == pTrigger->pSync->type)

-	{

-	    SyncCounter *pCounter = (SyncCounter *)pTrigger->pSync;

-

-	    pev->counter_value_lo = XSyncValueLow32(pCounter->value);

-	    pev->counter_value_hi = XSyncValueHigh32(pCounter->value);

-	}

-	else

-	{

-	    pev->counter_value_lo = 0;

-	    pev->counter_value_hi = 0;

-	}

-

-	pev->time = currentTime.milliseconds;

-	pev->count = num_events - i - 1; /* events remaining */

-	pev->destroyed = pTrigger->pSync->beingDestroyed;

-    }

-    /* swapping will be taken care of by this */

-    WriteEventsToClient(client, num_events, (xEvent *)pEvents);

-    free(pEvents);

-}

-

-

-/* This function is called when an alarm's counter is destroyed.

- * It is plugged into pTrigger->CounterDestroyed (for alarm triggers).

- */

-static void

-SyncAlarmCounterDestroyed(SyncTrigger *pTrigger)

-{

-    SyncAlarm *pAlarm = (SyncAlarm *)pTrigger;

-

-    pAlarm->state = XSyncAlarmInactive;

-    SyncSendAlarmNotifyEvents(pAlarm);

-    pTrigger->pSync = NULL;

-}

-

-

-/*  This function is called when an alarm "goes off."

- *  It is plugged into pTrigger->TriggerFired (for alarm triggers).

- */

-static void

-SyncAlarmTriggerFired(SyncTrigger *pTrigger)

-{

-    SyncAlarm *pAlarm = (SyncAlarm *)pTrigger;

-    SyncCounter *pCounter;

-    CARD64 new_test_value;

-

-    if (!SyncCheckWarnIsCounter(pTrigger->pSync, WARN_INVALID_COUNTER_ALARM))

-	return;

-

-    pCounter = (SyncCounter *)pTrigger->pSync;

-

-    /* no need to check alarm unless it's active */

-    if (pAlarm->state != XSyncAlarmActive)

-	return;

-

-    /*  " if the counter value is None, or if the delta is 0 and

-     *    the test-type is PositiveComparison or NegativeComparison,

-     *    no change is made to value (test-value) and the alarm

-     *    state is changed to Inactive before the event is generated."

-     */

-    if (pCounter == NULL

-	|| (XSyncValueIsZero(pAlarm->delta)

-	    && (pAlarm->trigger.test_type == XSyncPositiveComparison

-		|| pAlarm->trigger.test_type == XSyncNegativeComparison)))

-	pAlarm->state = XSyncAlarmInactive;

-

-    new_test_value = pAlarm->trigger.test_value;

-

-    if (pAlarm->state == XSyncAlarmActive)

-    {

-	Bool overflow;

-	CARD64 oldvalue;

-	SyncTrigger *paTrigger = &pAlarm->trigger;

-	SyncCounter *paCounter;

-

-	if (!SyncCheckWarnIsCounter(paTrigger->pSync,

-				    WARN_INVALID_COUNTER_ALARM))

-	    return;

-

-	paCounter = (SyncCounter *)pTrigger->pSync;

-

-	/* "The alarm is updated by repeatedly adding delta to the

-	 *  value of the trigger and re-initializing it until it

-	 *  becomes FALSE."

-	 */

-	oldvalue = paTrigger->test_value;

-

-	/* XXX really should do something smarter here */

-

-	do

-	{

-	    XSyncValueAdd(&paTrigger->test_value, paTrigger->test_value,

-			  pAlarm->delta, &overflow);

-	} while (!overflow &&

-	      (*paTrigger->CheckTrigger)(paTrigger,

-					paCounter->value));

-

-	new_test_value = paTrigger->test_value;

-	paTrigger->test_value = oldvalue;

-

-	/* "If this update would cause value to fall outside the range

-	 *  for an INT64...no change is made to value (test-value) and

-	 *  the alarm state is changed to Inactive before the event is

-	 *  generated."

-	 */

-	if (overflow)

-	{

-	    new_test_value = oldvalue;

-	    pAlarm->state = XSyncAlarmInactive;

-	}

-    }

-    /*  The AlarmNotify event has to have the "new state of the alarm"

-     *  which we can't be sure of until this point.  However, it has

-     *  to have the "old" trigger test value.  That's the reason for

-     *  all the newvalue/oldvalue shuffling above.  After we send the

-     *  events, give the trigger its new test value.

-     */

-    SyncSendAlarmNotifyEvents(pAlarm);

-    pTrigger->test_value = new_test_value;

-}

-

-

-/*  This function is called when an Await unblocks, either as a result

- *  of the trigger firing OR the counter being destroyed.

- *  It goes into pTrigger->TriggerFired AND pTrigger->CounterDestroyed

- *  (for Await triggers).

- */

-static void

-SyncAwaitTriggerFired(SyncTrigger *pTrigger)

-{

-    SyncAwait *pAwait = (SyncAwait *)pTrigger;

-    int numwaits;

-    SyncAwaitUnion *pAwaitUnion;

-    SyncAwait **ppAwait;

-    int num_events = 0;

-

-    pAwaitUnion = (SyncAwaitUnion *)pAwait->pHeader;

-    numwaits = pAwaitUnion->header.num_waitconditions;

-    ppAwait = malloc(numwaits * sizeof(SyncAwait *));

-    if (!ppAwait)

-	goto bail;

-

-    pAwait = &(pAwaitUnion+1)->await;

-

-    /* "When a client is unblocked, all the CounterNotify events for

-     *  the Await request are generated contiguously. If count is 0

-     *  there are no more events to follow for this request. If

-     *  count is n, there are at least n more events to follow."

-     *

-     *  Thus, it is best to find all the counters for which events

-     *  need to be sent first, so that an accurate count field can

-     *  be stored in the events.

-     */

-    for ( ; numwaits; numwaits--, pAwait++)

-    {

-	CARD64 diff;

-	Bool overflow, diffgreater, diffequal;

-

-	/* "A CounterNotify event with the destroyed flag set to TRUE is

-	 *  always generated if the counter for one of the triggers is

-	 *  destroyed."

-	 */

-	if (pAwait->trigger.pSync->beingDestroyed)

-	{

-	    ppAwait[num_events++] = pAwait;

-	    continue;

-	}

-	

-	if (SYNC_COUNTER == pAwait->trigger.pSync->type)

-	{

-	    SyncCounter *pCounter = (SyncCounter *) pAwait->trigger.pSync;

-

-	    /* "The difference between the counter and the test value is

-	     *  calculated by subtracting the test value from the value of

-	     *  the counter."

-	     */

-	    XSyncValueSubtract(&diff, pCounter->value,

-			       pAwait->trigger.test_value, &overflow);

-

-	    /* "If the difference lies outside the range for an INT64, an

-	     *  event is not generated."

-	     */

-	    if (overflow)

-		continue;

-	    diffgreater = XSyncValueGreaterThan(diff, pAwait->event_threshold);

-	    diffequal   = XSyncValueEqual(diff, pAwait->event_threshold);

-

-	    /* "If the test-type is PositiveTransition or

-	     *  PositiveComparison, a CounterNotify event is generated if

-	     *  the difference is at least event-threshold. If the test-type

-	     *  is NegativeTransition or NegativeComparison, a CounterNotify

-	     *  event is generated if the difference is at most

-	     *  event-threshold."

-	     */

-

-	    if ( ((pAwait->trigger.test_type == XSyncPositiveComparison ||

-		   pAwait->trigger.test_type == XSyncPositiveTransition)

-		  && (diffgreater || diffequal))

-		 ||

-		 ((pAwait->trigger.test_type == XSyncNegativeComparison ||

-		   pAwait->trigger.test_type == XSyncNegativeTransition)

-		  && (!diffgreater) /* less or equal */

-		 )

-	       )

-	    {

-		ppAwait[num_events++] = pAwait;

-	    }

-	}

-    }

-    if (num_events)

-	SyncSendCounterNotifyEvents(pAwaitUnion->header.client, ppAwait,

-				    num_events);

-    free(ppAwait);

-

-bail:

-    /* unblock the client */

-    AttendClient(pAwaitUnion->header.client);

-    /* delete the await */

-    FreeResource(pAwaitUnion->header.delete_id, RT_NONE);

-}

-

-

-/*  This function should always be used to change a counter's value so that

- *  any triggers depending on the counter will be checked.

- */

-void

-SyncChangeCounter(SyncCounter *pCounter, CARD64 newval)

-{

-    SyncTriggerList       *ptl, *pnext;

-    CARD64 oldval;

-

-    oldval = pCounter->value;

-    pCounter->value = newval;

-

-    /* run through triggers to see if any become true */

-    for (ptl = pCounter->sync.pTriglist; ptl; ptl = pnext)

-    {

-	pnext = ptl->next;

-	if ((*ptl->pTrigger->CheckTrigger)(ptl->pTrigger, oldval))

-	    (*ptl->pTrigger->TriggerFired)(ptl->pTrigger);

-    }

-

-    if (IsSystemCounter(pCounter))

-    {

-	SyncComputeBracketValues(pCounter);

-    }

-}

-

-

-/* loosely based on dix/events.c/EventSelectForWindow */

-static Bool

-SyncEventSelectForAlarm(SyncAlarm *pAlarm, ClientPtr client, Bool wantevents)

-{

-    SyncAlarmClientList *pClients;

-

-    if (client == pAlarm->client) /* alarm owner */

-    {

-	pAlarm->events = wantevents;

-	return Success;

-    }

-

-    /* see if the client is already on the list (has events selected) */

-

-    for (pClients = pAlarm->pEventClients; pClients;

-	 pClients = pClients->next)

-    {

-	if (pClients->client == client)

-	{

-	    /* client's presence on the list indicates desire for

-	     * events.  If the client doesn't want events, remove it

-	     * from the list.  If the client does want events, do

-	     * nothing, since it's already got them.

-	     */

-	    if (!wantevents)

-	    {

-		FreeResource(pClients->delete_id, RT_NONE);

-	    }

-	    return Success;

-	}

-    }

-

-    /*  if we get here, this client does not currently have

-     *  events selected on the alarm

-     */

-

-    if (!wantevents)

-	/* client doesn't want events, and we just discovered that it

-	 * doesn't have them, so there's nothing to do.

-	 */

-	return Success;

-

-    /* add new client to pAlarm->pEventClients */

-

-    pClients = malloc(sizeof(SyncAlarmClientList));

-    if (!pClients)

-	return BadAlloc;

-

-    /*  register it as a resource so it will be cleaned up

-     *  if the client dies

-     */

-

-    pClients->delete_id = FakeClientID(client->index);

-

-    /* link it into list after we know all the allocations succeed */

-    pClients->next = pAlarm->pEventClients;

-    pAlarm->pEventClients = pClients;

-    pClients->client = client;

-

-    if (!AddResource(pClients->delete_id, RTAlarmClient, pAlarm))

-	return BadAlloc;

-

-    return Success;

-}

-

-/*

- * ** SyncChangeAlarmAttributes ** This is used by CreateAlarm and ChangeAlarm

- */

-static int

-SyncChangeAlarmAttributes(ClientPtr client, SyncAlarm *pAlarm, Mask mask,

-			  CARD32 *values)

-{

-    int		   status;

-    XSyncCounter   counter;

-    Mask	   origmask = mask;

-

-    counter =

-	pAlarm->trigger.pSync ? pAlarm->trigger.pSync->id : None;

-

-    while (mask)

-    {

-	int    index2 = lowbit(mask);

-	mask &= ~index2;

-	switch (index2)

-	{

-	  case XSyncCACounter:

-	    mask &= ~XSyncCACounter;

-	    /* sanity check in SyncInitTrigger */

-	    counter = *values++;

-	    break;

-

-	  case XSyncCAValueType:

-	    mask &= ~XSyncCAValueType;

-	    /* sanity check in SyncInitTrigger */

-	    pAlarm->trigger.value_type = *values++;

-	    break;

-

-	  case XSyncCAValue:

-	    mask &= ~XSyncCAValue;

-	    XSyncIntsToValue(&pAlarm->trigger.wait_value, values[1], values[0]);

-	    values += 2;

-	    break;

-

-	  case XSyncCATestType:

-	    mask &= ~XSyncCATestType;

-	    /* sanity check in SyncInitTrigger */

-	    pAlarm->trigger.test_type = *values++;

-	    break;

-

-	  case XSyncCADelta:

-	    mask &= ~XSyncCADelta;

-	    XSyncIntsToValue(&pAlarm->delta, values[1], values[0]);

-	    values += 2;

-	    break;

-

-	  case XSyncCAEvents:

-	    mask &= ~XSyncCAEvents;

-	    if ((*values != xTrue) && (*values != xFalse))

-	    {

-		client->errorValue = *values;

-		return BadValue;

-	    }

-	    status = SyncEventSelectForAlarm(pAlarm, client,

-					     (Bool)(*values++));

-	    if (status != Success)

-		return status;

-	    break;

-

-	  default:

-	    client->errorValue = mask;

-	    return BadValue;

-	}

-    }

-

-    /* "If the test-type is PositiveComparison or PositiveTransition

-     *  and delta is less than zero, or if the test-type is

-     *  NegativeComparison or NegativeTransition and delta is

-     *  greater than zero, a Match error is generated."

-     */

-    if (origmask & (XSyncCADelta|XSyncCATestType))

-    {

-	CARD64 zero;

-	XSyncIntToValue(&zero, 0);

-	if ((((pAlarm->trigger.test_type == XSyncPositiveComparison) ||

-	      (pAlarm->trigger.test_type == XSyncPositiveTransition))

-	     && XSyncValueLessThan(pAlarm->delta, zero))

-	    ||

-	    (((pAlarm->trigger.test_type == XSyncNegativeComparison) ||

-	      (pAlarm->trigger.test_type == XSyncNegativeTransition))

-	     && XSyncValueGreaterThan(pAlarm->delta, zero))

-	   )

-	{

-	    return BadMatch;

-	}

-    }

-

-    /* postpone this until now, when we're sure nothing else can go wrong */

-    if ((status = SyncInitTrigger(client, &pAlarm->trigger, counter, RTCounter,

-			     origmask & XSyncCAAllTrigger)) != Success)

-	return status;

-

-    /* XXX spec does not really say to do this - needs clarification */

-    pAlarm->state = XSyncAlarmActive;

-    return Success;

-}

-

-static SyncObject *

-SyncCreate(ClientPtr client, XID id, unsigned char type)

-{

-    SyncObject *pSync;

-

-    switch (type) {

-    case SYNC_COUNTER:

-	pSync = malloc(sizeof(SyncCounter));

-	break;

-    case SYNC_FENCE:

-	pSync = (SyncObject*)dixAllocateObjectWithPrivates(SyncFence,

-							   PRIVATE_SYNC_FENCE);

-	break;

-    default:

-	return NULL;

-    }

-

-    if (!pSync)

-	return NULL;

-

-    pSync->client = client;

-    pSync->id = id;

-    pSync->pTriglist = NULL;

-    pSync->beingDestroyed = FALSE;

-    pSync->type = type;

-

-    return pSync;

-}

-

-

-static SyncCounter *

-SyncCreateCounter(ClientPtr client, XSyncCounter id, CARD64 initialvalue)

-{

-    SyncCounter *pCounter;

-

-    if (!(pCounter = (SyncCounter *)SyncCreate(client,

-					       id,

-					       SYNC_COUNTER)))

-	return NULL;

-

-    pCounter->value = initialvalue;

-    pCounter->pSysCounterInfo = NULL;

-

-    if (!AddResource(id, RTCounter, (pointer) pCounter))

-	return NULL;

-

-    return pCounter;

-}

-

-static int FreeCounter(void *, XID);

-

-/*

- * ***** System Counter utilities

- */

-

-pointer

-SyncCreateSystemCounter(

-	char *name,

-	CARD64 initial,

-	CARD64 resolution,

-	SyncCounterType counterType,

-	void (*QueryValue)(pointer /* pCounter */,

-	      	           CARD64 * /* pValue_return */),

-	void (*BracketValues)(pointer /* pCounter */,

-	       	              CARD64 * /* pbracket_less */,

-	                      CARD64 * /* pbracket_greater */)

-	)

-{

-    SyncCounter    *pCounter;

-

-    SysCounterList = realloc(SysCounterList,

-			    (SyncNumSystemCounters+1)*sizeof(SyncCounter *));

-    if (!SysCounterList)

-	return NULL;

-

-    /* this function may be called before SYNC has been initialized, so we

-     * have to make sure RTCounter is created.

-     */

-    if (RTCounter == 0)

-    {

-	RTCounter = CreateNewResourceType(FreeCounter, "SyncCounter");

-	if (RTCounter == 0)

-	{

-	    return NULL;

-	}

-    }

-

-    pCounter = SyncCreateCounter(NULL, FakeClientID(0), initial);

-

-    if (pCounter)

-    {

-	SysCounterInfo *psci;

-

-	psci = malloc(sizeof(SysCounterInfo));

-	if (!psci)

-	{

-	    FreeResource(pCounter->sync.id, RT_NONE);

-	    return pCounter;

-	}

-	pCounter->pSysCounterInfo = psci;

-	psci->name = name;

-	psci->resolution = resolution;

-	psci->counterType = counterType;

-	psci->QueryValue = QueryValue;

-	psci->BracketValues = BracketValues;

-	XSyncMaxValue(&psci->bracket_greater);

-	XSyncMinValue(&psci->bracket_less);

-	SysCounterList[SyncNumSystemCounters++] = pCounter;

-    }

-    return pCounter;

-}

-

-void

-SyncDestroySystemCounter(pointer pSysCounter)

-{

-    SyncCounter *pCounter = (SyncCounter *)pSysCounter;

-    FreeResource(pCounter->sync.id, RT_NONE);

-}

-

-static void

-SyncComputeBracketValues(SyncCounter *pCounter)

-{

-    SyncTriggerList *pCur;

-    SyncTrigger *pTrigger;

-    SysCounterInfo *psci;

-    CARD64 *pnewgtval = NULL;

-    CARD64 *pnewltval = NULL;

-    SyncCounterType ct;

-

-    if (!pCounter)

-	return;

-

-    psci = pCounter->pSysCounterInfo;

-    ct = pCounter->pSysCounterInfo->counterType;

-    if (ct == XSyncCounterNeverChanges)

-	return;

-

-    XSyncMaxValue(&psci->bracket_greater);

-    XSyncMinValue(&psci->bracket_less);

-

-    for (pCur = pCounter->sync.pTriglist; pCur; pCur = pCur->next)

-    {

-	pTrigger = pCur->pTrigger;

-	

-        if (pTrigger->test_type == XSyncPositiveComparison &&

-	    ct != XSyncCounterNeverIncreases)

-	{

-	    if (XSyncValueLessThan(pCounter->value, pTrigger->test_value) &&

-		XSyncValueLessThan(pTrigger->test_value,

-				   psci->bracket_greater))

-	    {

-		psci->bracket_greater = pTrigger->test_value;

-		pnewgtval = &psci->bracket_greater;

-	    }

-	}

-	else if (pTrigger->test_type == XSyncNegativeComparison &&

-		 ct != XSyncCounterNeverDecreases)

-	{

-	    if (XSyncValueGreaterThan(pCounter->value, pTrigger->test_value) &&

-		XSyncValueGreaterThan(pTrigger->test_value,

-				      psci->bracket_less))

-	    {

-		psci->bracket_less = pTrigger->test_value;

-		pnewltval = &psci->bracket_less;

-	    }

-	}

-	else if (pTrigger->test_type == XSyncNegativeTransition &&

-		   ct != XSyncCounterNeverIncreases)

-	{

-	    if (XSyncValueGreaterThan(pCounter->value, pTrigger->test_value) &&

-		XSyncValueGreaterThan(pTrigger->test_value, psci->bracket_less))

-	    {

-		psci->bracket_less = pTrigger->test_value;

-		pnewltval = &psci->bracket_less;

-	    } else if (XSyncValueEqual(pCounter->value, pTrigger->test_value) &&

-		       XSyncValueLessThan(pTrigger->test_value,

-					  psci->bracket_greater))

-	    {

-	        /*

-		 * The value is exactly equal to our threshold.  We want one

-		 * more event in the positive direction to ensure we pick up

-		 * when the value *exceeds* this threshold.

-		 */

-	        psci->bracket_greater = pTrigger->test_value;

-		pnewgtval = &psci->bracket_greater;

-	    }

-	}

-        else if (pTrigger->test_type == XSyncPositiveTransition &&

-		  ct != XSyncCounterNeverDecreases)

-	{

-	    if (XSyncValueLessThan(pCounter->value, pTrigger->test_value) &&

-		XSyncValueLessThan(pTrigger->test_value, psci->bracket_greater))

-	    {

-		psci->bracket_greater = pTrigger->test_value;

-		pnewgtval = &psci->bracket_greater;

-	    } else if (XSyncValueEqual(pCounter->value, pTrigger->test_value) &&

-		       XSyncValueGreaterThan(pTrigger->test_value,

-					     psci->bracket_less))

-	    {

-	        /*

-		 * The value is exactly equal to our threshold.  We want one

-		 * more event in the negative direction to ensure we pick up

-		 * when the value is less than this threshold.

-		 */

-	        psci->bracket_less = pTrigger->test_value;

-		pnewltval = &psci->bracket_less;

-	    }

-	}

-    } /* end for each trigger */

-

-    if (pnewgtval || pnewltval)

-    {

-	(*psci->BracketValues)((pointer)pCounter, pnewltval, pnewgtval);

-    }

-}

-

-/*

- * *****  Resource delete functions

- */

-

-/* ARGSUSED */

-static int

-FreeAlarm(void *addr, XID id)

-{

-    SyncAlarm      *pAlarm = (SyncAlarm *) addr;

-

-    pAlarm->state = XSyncAlarmDestroyed;

-

-    SyncSendAlarmNotifyEvents(pAlarm);

-

-    /* delete event selections */

-

-    while (pAlarm->pEventClients)

-	FreeResource(pAlarm->pEventClients->delete_id, RT_NONE);

-

-    SyncDeleteTriggerFromSyncObject(&pAlarm->trigger);

-

-    free(pAlarm);

-    return Success;

-}

-

-

-/*

- * ** Cleanup after the destruction of a Counter

- */

-/* ARGSUSED */

-static int

-FreeCounter(void *env, XID id)

-{

-    SyncCounter     *pCounter = (SyncCounter *) env;

-    SyncTriggerList *ptl, *pnext;

-

-    pCounter->sync.beingDestroyed = TRUE;

-    /* tell all the counter's triggers that the counter has been destroyed */

-    for (ptl = pCounter->sync.pTriglist; ptl; ptl = pnext)

-    {

-	(*ptl->pTrigger->CounterDestroyed)(ptl->pTrigger);

-	pnext = ptl->next;

-	free(ptl); /* destroy the trigger list as we go */

-    }

-    if (IsSystemCounter(pCounter))

-    {

-	int i, found = 0;

-

-	free(pCounter->pSysCounterInfo);

-

-	/* find the counter in the list of system counters and remove it */

-

-	if (SysCounterList)

-	{

-	    for (i = 0; i < SyncNumSystemCounters; i++)

-	    {

-		if (SysCounterList[i] == pCounter)

-		{

-		    found = i;

-		    break;

-		}

-	    }

-	    if (found < (SyncNumSystemCounters-1))

-	    {

-		for (i = found; i < SyncNumSystemCounters-1; i++)

-		{

-		    SysCounterList[i] = SysCounterList[i+1];

-		}

-	    }

-	}

-	SyncNumSystemCounters--;

-    }

-    free(pCounter);

-    return Success;

-}

-

-/*

- * ** Cleanup after Await

- */

-/* ARGSUSED */

-static int

-FreeAwait(void *addr, XID id)

-{

-    SyncAwaitUnion *pAwaitUnion = (SyncAwaitUnion *) addr;

-    SyncAwait *pAwait;

-    int numwaits;

-

-    pAwait = &(pAwaitUnion+1)->await; /* first await on list */

-

-    /* remove triggers from counters */

-

-    for (numwaits = pAwaitUnion->header.num_waitconditions; numwaits;

-	 numwaits--, pAwait++)

-    {

-	/* If the counter is being destroyed, FreeCounter will delete

-	 * the trigger list itself, so don't do it here.

-	 */

-	SyncObject *pSync = pAwait->trigger.pSync;

-	if (pSync && !pSync->beingDestroyed)

-	    SyncDeleteTriggerFromSyncObject(&pAwait->trigger);

-    }

-    free(pAwaitUnion);

-    return Success;

-}

-

-#ifdef _MSC_VER

-#pragma warning(disable:4715) /* Not all control paths return a value */

-#endif

-

-/* loosely based on dix/events.c/OtherClientGone */

-static int

-FreeAlarmClient(void *value, XID id)

-{

-    SyncAlarm *pAlarm = (SyncAlarm *)value;

-    SyncAlarmClientList *pCur, *pPrev;

-

-    for (pPrev = NULL, pCur = pAlarm->pEventClients;

-	 pCur;

-	 pPrev = pCur, pCur = pCur->next)

-    {

-	if (pCur->delete_id == id)

-	{

-	    if (pPrev)

-		pPrev->next = pCur->next;

-	    else

-		pAlarm->pEventClients = pCur->next;

-	    free(pCur);

-	    return Success;

-	}

-    }

-    FatalError("alarm client not on event list");

-    /*NOTREACHED*/

-}

-

-

-/*

- * *****  Proc functions

- */

-

-

-/*

- * ** Initialize the extension

- */

-static int

-ProcSyncInitialize(ClientPtr client)

-{

-    xSyncInitializeReply  rep;

-    int   n;

-

-    REQUEST_SIZE_MATCH(xSyncInitializeReq);

-

-    memset(&rep, 0, sizeof(xSyncInitializeReply));

-    rep.type = X_Reply;

-    rep.sequenceNumber = client->sequence;

-    rep.majorVersion = SERVER_SYNC_MAJOR_VERSION;

-    rep.minorVersion = SERVER_SYNC_MINOR_VERSION;

-    rep.length = 0;

-

-    if (client->swapped)

-    {

-	swaps(&rep.sequenceNumber, n);

-    }

-    WriteToClient(client, sizeof(rep), (char *) &rep);

-    return Success;

-}

-

-/*

- * ** Get list of system counters available through the extension

- */

-static int

-ProcSyncListSystemCounters(ClientPtr client)

-{

-    xSyncListSystemCountersReply  rep;

-    int i, len;

-    xSyncSystemCounter *list = NULL, *walklist = NULL;

-

-    REQUEST_SIZE_MATCH(xSyncListSystemCountersReq);

-

-    rep.type = X_Reply;

-    rep.sequenceNumber = client->sequence;

-    rep.nCounters = SyncNumSystemCounters;

-

-    for (i = len = 0; i < SyncNumSystemCounters; i++)

-    {

-	char *name = SysCounterList[i]->pSysCounterInfo->name;

-	/* pad to 4 byte boundary */

-	len += pad_to_int32(sz_xSyncSystemCounter + strlen(name));

-    }

-

-    if (len)

-    {

-	walklist = list = malloc(len);

-	if (!list)

-	    return BadAlloc;

-    }

-

-    rep.length = bytes_to_int32(len);

-

-    if (client->swapped)

-    {

-	char n;

-	swaps(&rep.sequenceNumber, n);

-	swapl(&rep.length, n);

-	swapl(&rep.nCounters, n);

-    }

-

-    for (i = 0; i < SyncNumSystemCounters; i++)

-    {

-	int namelen;

-	char *pname_in_reply;

-	SysCounterInfo *psci = SysCounterList[i]->pSysCounterInfo;

-

-	walklist->counter = SysCounterList[i]->sync.id;

-	walklist->resolution_hi = XSyncValueHigh32(psci->resolution);

-	walklist->resolution_lo = XSyncValueLow32(psci->resolution);

-	namelen = strlen(psci->name);

-	walklist->name_length = namelen;

-

-	if (client->swapped)

-	{

-	    char n;

-	    swapl(&walklist->counter, n);

-	    swapl(&walklist->resolution_hi, n);

-	    swapl(&walklist->resolution_lo, n);

-	    swaps(&walklist->name_length, n);

-	}

-

-	pname_in_reply = ((char *)walklist) + sz_xSyncSystemCounter;

-	strncpy(pname_in_reply, psci->name, namelen);

-	walklist = (xSyncSystemCounter *) (((char *)walklist) +

-				pad_to_int32(sz_xSyncSystemCounter + namelen));

-    }

-

-    WriteToClient(client, sizeof(rep), (char *) &rep);

-    if (len)

-    {

-	WriteToClient(client, len, (char *) list);

-	free(list);

-    }

-

-    return Success;

-}

-

-/*

- * ** Set client Priority

- */

-static int

-ProcSyncSetPriority(ClientPtr client)

-{

-    REQUEST(xSyncSetPriorityReq);

-    ClientPtr priorityclient;

-    int rc;

-

-    REQUEST_SIZE_MATCH(xSyncSetPriorityReq);

-

-    if (stuff->id == None)

-	priorityclient = client;

-    else {

-	rc = dixLookupClient(&priorityclient, stuff->id, client,

-			     DixSetAttrAccess);

-	if (rc != Success)

-	    return rc;

-    }

-

-    if (priorityclient->priority != stuff->priority)

-    {

-	priorityclient->priority = stuff->priority;

-

-	/*  The following will force the server back into WaitForSomething

-	 *  so that the change in this client's priority is immediately

-	 *  reflected.

-	 */

-	isItTimeToYield = TRUE;

-	dispatchException |= DE_PRIORITYCHANGE;

-    }

-    return Success;

-}

-

-/*

- * ** Get client Priority

- */

-static int

-ProcSyncGetPriority(ClientPtr client)

-{

-    REQUEST(xSyncGetPriorityReq);

-    xSyncGetPriorityReply rep;

-    ClientPtr priorityclient;

-    int rc;

-

-    REQUEST_SIZE_MATCH(xSyncGetPriorityReq);

-

-    if (stuff->id == None)

-	priorityclient = client;

-    else {

-	rc = dixLookupClient(&priorityclient, stuff->id, client,

-			     DixGetAttrAccess);

-	if (rc != Success)

-	    return rc;

-    }

-

-    rep.type = X_Reply;

-    rep.length = 0;

-    rep.sequenceNumber = client->sequence;

-    rep.priority = priorityclient->priority;

-

-    if (client->swapped)

-    {

-	char n;

-	swaps(&rep.sequenceNumber, n);

-	swapl(&rep.priority, n);

-    }

-

-    WriteToClient(client, sizeof(xSyncGetPriorityReply), (char *) &rep);

-

-    return Success;

-}

-

-/*

- * ** Create a new counter

- */

-static int

-ProcSyncCreateCounter(ClientPtr client)

-{

-    REQUEST(xSyncCreateCounterReq);

-    CARD64          initial;

-

-    REQUEST_SIZE_MATCH(xSyncCreateCounterReq);

-

-    LEGAL_NEW_RESOURCE(stuff->cid, client);

-

-    XSyncIntsToValue(&initial, stuff->initial_value_lo, stuff->initial_value_hi);

-    if (!SyncCreateCounter(client, stuff->cid, initial))

-	return BadAlloc;

-

-    return Success;

-}

-

-/*

- * ** Set Counter value

- */

-static int

-ProcSyncSetCounter(ClientPtr client)

-{

-    REQUEST(xSyncSetCounterReq);

-    SyncCounter    *pCounter;

-    CARD64	   newvalue;

-    int	rc;

-

-    REQUEST_SIZE_MATCH(xSyncSetCounterReq);

-

-    rc = dixLookupResourceByType((pointer *)&pCounter, stuff->cid, RTCounter,

-				 client, DixWriteAccess);

-    if (rc != Success)

-	return rc;

-

-    if (IsSystemCounter(pCounter))

-    {

-	client->errorValue = stuff->cid;

-	return BadAccess;

-    }

-

-    XSyncIntsToValue(&newvalue, stuff->value_lo, stuff->value_hi);

-    SyncChangeCounter(pCounter, newvalue);

-    return Success;

-}

-

-/*

- * ** Change Counter value

- */

-static int

-ProcSyncChangeCounter(ClientPtr client)

-{

-    REQUEST(xSyncChangeCounterReq);

-    SyncCounter    *pCounter;

-    CARD64          newvalue;

-    Bool	    overflow;

-    int	rc;

-

-    REQUEST_SIZE_MATCH(xSyncChangeCounterReq);

-

-    rc = dixLookupResourceByType((pointer *)&pCounter, stuff->cid, RTCounter,

-				 client, DixWriteAccess);

-    if (rc != Success)

-	return rc;

-

-    if (IsSystemCounter(pCounter))

-    {

-	client->errorValue = stuff->cid;

-	return BadAccess;

-    }

-

-    XSyncIntsToValue(&newvalue, stuff->value_lo, stuff->value_hi);

-    XSyncValueAdd(&newvalue, pCounter->value, newvalue, &overflow);

-    if (overflow)

-    {

-	/* XXX 64 bit value can't fit in 32 bits; do the best we can */

-	client->errorValue = stuff->value_hi;

-	return BadValue;

-    }

-    SyncChangeCounter(pCounter, newvalue);

-    return Success;

-}

-

-/*

- * ** Destroy a counter

- */

-static int

-ProcSyncDestroyCounter(ClientPtr client)

-{

-    REQUEST(xSyncDestroyCounterReq);

-    SyncCounter    *pCounter;

-    int rc;

-

-    REQUEST_SIZE_MATCH(xSyncDestroyCounterReq);

-

-    rc = dixLookupResourceByType((pointer *)&pCounter, stuff->counter, RTCounter,

-				 client, DixDestroyAccess);

-    if (rc != Success)

-	return rc;

-

-    if (IsSystemCounter(pCounter))

-    {

-	client->errorValue = stuff->counter;

-	return BadAccess;

-    }

-    FreeResource(pCounter->sync.id, RT_NONE);

-    return Success;

-}

-

-static SyncAwaitUnion*

-SyncAwaitPrologue(ClientPtr client, int items)

-{

-    SyncAwaitUnion *pAwaitUnion;

-

-    /*  all the memory for the entire await list is allocated

-     *  here in one chunk

-     */

-    pAwaitUnion = malloc((items+1) * sizeof(SyncAwaitUnion));

-    if (!pAwaitUnion)

-	return NULL;

-

-    /* first item is the header, remainder are real wait conditions */

-

-    pAwaitUnion->header.delete_id = FakeClientID(client->index);

-    pAwaitUnion->header.client = client;

-    pAwaitUnion->header.num_waitconditions = 0;

-

-    if (!AddResource(pAwaitUnion->header.delete_id, RTAwait, pAwaitUnion))

-	return NULL;

-

-    return pAwaitUnion;

-}

-

-static void

-SyncAwaitEpilogue(ClientPtr client, int items, SyncAwaitUnion *pAwaitUnion)

-{

-    SyncAwait *pAwait;

-    int i;

-

-    IgnoreClient(client);

-

-    /* see if any of the triggers are already true */

-

-    pAwait = &(pAwaitUnion+1)->await; /* skip over header */

-    for (i = 0; i < items; i++, pAwait++)

-    {

-	CARD64 value;

-

-	/*  don't have to worry about NULL counters because the request

-	 *  errors before we get here out if they occur

-	 */

-	switch (pAwait->trigger.pSync->type) {

-	case SYNC_COUNTER:

-	    value = ((SyncCounter *)pAwait->trigger.pSync)->value;

-	    break;

-	default:

-	    XSyncIntToValue(&value, 0);

-	}

-

-	if ((*pAwait->trigger.CheckTrigger)(&pAwait->trigger, value))

-	{

-	    (*pAwait->trigger.TriggerFired)(&pAwait->trigger);

-	    break; /* once is enough */

-	}

-    }

-}

-

-/*

- * ** Await

- */

-static int

-ProcSyncAwait(ClientPtr client)

-{

-    REQUEST(xSyncAwaitReq);

-    int             len, items;

-    int             i;

-    xSyncWaitCondition *pProtocolWaitConds;

-    SyncAwaitUnion *pAwaitUnion;

-    SyncAwait	   *pAwait;

-    int		   status;

-

-    REQUEST_AT_LEAST_SIZE(xSyncAwaitReq);

-

-    len = client->req_len << 2;

-    len -= sz_xSyncAwaitReq;

-    items = len / sz_xSyncWaitCondition;

-

-    if (items * sz_xSyncWaitCondition != len)

-    {

-	return BadLength;

-    }

-    if (items == 0)

-    {

-	client->errorValue = items; /* XXX protocol change */

-	return BadValue;

-    }

-

-    if (!(pAwaitUnion = SyncAwaitPrologue(client, items)))

-	return BadAlloc;

-

-    /* don't need to do any more memory allocation for this request! */

-

-    pProtocolWaitConds = (xSyncWaitCondition *) & stuff[1];

-

-    pAwait = &(pAwaitUnion+1)->await; /* skip over header */

-    for (i = 0; i < items; i++, pProtocolWaitConds++, pAwait++)

-    {

-	if (pProtocolWaitConds->counter == None) /* XXX protocol change */

-	{

-	    /*  this should take care of removing any triggers created by

-	     *  this request that have already been registered on sync objects

-	     */

-	    FreeResource(pAwaitUnion->header.delete_id, RT_NONE);

-	    client->errorValue = pProtocolWaitConds->counter;

-	    return SyncErrorBase + XSyncBadCounter;

-	}

-

-	/* sanity checks are in SyncInitTrigger */

-	pAwait->trigger.pSync = NULL;

-	pAwait->trigger.value_type = pProtocolWaitConds->value_type;

-	XSyncIntsToValue(&pAwait->trigger.wait_value,

-			 pProtocolWaitConds->wait_value_lo,

-			 pProtocolWaitConds->wait_value_hi);

-	pAwait->trigger.test_type = pProtocolWaitConds->test_type;

-

-	status = SyncInitTrigger(client, &pAwait->trigger,

-				 pProtocolWaitConds->counter, RTCounter,

-				 XSyncCAAllTrigger);

-	if (status != Success)

-	{

-	    /*  this should take care of removing any triggers created by

-	     *  this request that have already been registered on sync objects

-	     */

-	    FreeResource(pAwaitUnion->header.delete_id, RT_NONE);

-	    return status;

-	}

-	/* this is not a mistake -- same function works for both cases */

-	pAwait->trigger.TriggerFired = SyncAwaitTriggerFired;

-	pAwait->trigger.CounterDestroyed = SyncAwaitTriggerFired;

-	XSyncIntsToValue(&pAwait->event_threshold,

-			 pProtocolWaitConds->event_threshold_lo,

-			 pProtocolWaitConds->event_threshold_hi);

-	pAwait->pHeader = &pAwaitUnion->header;

-	pAwaitUnion->header.num_waitconditions++;

-    }

-

-    SyncAwaitEpilogue(client, items, pAwaitUnion);

-

-    return Success;

-}

-

-

-/*

- * ** Query a counter

- */

-static int

-ProcSyncQueryCounter(ClientPtr client)

-{

-    REQUEST(xSyncQueryCounterReq);

-    xSyncQueryCounterReply rep;

-    SyncCounter    *pCounter;

-    int rc;

-

-    REQUEST_SIZE_MATCH(xSyncQueryCounterReq);

-

-    rc = dixLookupResourceByType((pointer *)&pCounter, stuff->counter,

-				 RTCounter, client, DixReadAccess);

-    if (rc != Success)

-	return rc;

-

-    rep.type = X_Reply;

-    rep.length = 0;

-    rep.sequenceNumber = client->sequence;

-

-    /* if system counter, ask it what the current value is */

-

-    if (IsSystemCounter(pCounter))

-    {

-	(*pCounter->pSysCounterInfo->QueryValue) ((pointer) pCounter,

-						  &pCounter->value);

-    }

-

-    rep.value_hi = XSyncValueHigh32(pCounter->value);

-    rep.value_lo = XSyncValueLow32(pCounter->value);

-    if (client->swapped)

-    {

-	char n;

-	swaps(&rep.sequenceNumber, n);

-	swapl(&rep.length, n);

-	swapl(&rep.value_hi, n);

-	swapl(&rep.value_lo, n);

-    }

-    WriteToClient(client, sizeof(xSyncQueryCounterReply), (char *) &rep);

-    return Success;

-}

-

-

-/*

- * ** Create Alarm

- */

-static int

-ProcSyncCreateAlarm(ClientPtr client)

-{

-    REQUEST(xSyncCreateAlarmReq);

-    SyncAlarm      *pAlarm;

-    int             status;

-    unsigned long   len, vmask;

-    SyncTrigger	    *pTrigger;

-

-    REQUEST_AT_LEAST_SIZE(xSyncCreateAlarmReq);

-

-    LEGAL_NEW_RESOURCE(stuff->id, client);

-

-    vmask = stuff->valueMask;

-    len = client->req_len - bytes_to_int32(sizeof(xSyncCreateAlarmReq));

-    /* the "extra" call to Ones accounts for the presence of 64 bit values */

-    if (len != (Ones(vmask) + Ones(vmask & (XSyncCAValue|XSyncCADelta))))

-	return BadLength;

-

-    if (!(pAlarm = malloc(sizeof(SyncAlarm))))

-    {

-	return BadAlloc;

-    }

-

-    /* set up defaults */

-

-    pTrigger = &pAlarm->trigger;

-    pTrigger->pSync = NULL;

-    pTrigger->value_type = XSyncAbsolute;

-    XSyncIntToValue(&pTrigger->wait_value, 0L);

-    pTrigger->test_type = XSyncPositiveComparison;

-    pTrigger->TriggerFired = SyncAlarmTriggerFired;

-    pTrigger->CounterDestroyed = SyncAlarmCounterDestroyed;

-    status = SyncInitTrigger(client, pTrigger, None, RTCounter,

-			     XSyncCAAllTrigger);

-    if (status != Success)

-    {

-	free(pAlarm);

-	return status;

-    }

-

-    pAlarm->client = client;

-    pAlarm->alarm_id = stuff->id;

-    XSyncIntToValue(&pAlarm->delta, 1L);

-    pAlarm->events = TRUE;

-    pAlarm->state = XSyncAlarmInactive;

-    pAlarm->pEventClients = NULL;

-    status = SyncChangeAlarmAttributes(client, pAlarm, vmask,

-				       (CARD32 *)&stuff[1]);

-    if (status != Success)

-    {

-	free(pAlarm);

-	return status;

-    }

-

-    if (!AddResource(stuff->id, RTAlarm, pAlarm))

-	return BadAlloc;

-

-    /*  see if alarm already triggered.  NULL counter will not trigger

-     *  in CreateAlarm and sets alarm state to Inactive.

-     */

-

-    if (!pTrigger->pSync)

-    {

-	pAlarm->state = XSyncAlarmInactive; /* XXX protocol change */

-    }

-    else

-    {

-	SyncCounter *pCounter;

-

-	if (!SyncCheckWarnIsCounter(pTrigger->pSync,

-				    WARN_INVALID_COUNTER_ALARM))

-	{

-	    FreeResource(stuff->id, RT_NONE);

-	    return BadAlloc;

-	}

-

-	pCounter = (SyncCounter *)pTrigger->pSync;

-

-	if ((*pTrigger->CheckTrigger)(pTrigger, pCounter->value))

-	    (*pTrigger->TriggerFired)(pTrigger);

-    }

-

-    return Success;

-}

-

-/*

- * ** Change Alarm

- */

-static int

-ProcSyncChangeAlarm(ClientPtr client)

-{

-    REQUEST(xSyncChangeAlarmReq);

-    SyncAlarm   *pAlarm;

-    SyncCounter *pCounter = NULL;

-    long        vmask;

-    int         len, status;

-

-    REQUEST_AT_LEAST_SIZE(xSyncChangeAlarmReq);

-

-    status = dixLookupResourceByType((pointer *)&pAlarm, stuff->alarm, RTAlarm,

-				     client, DixWriteAccess);

-    if (status != Success)

-	return status;

-

-    vmask = stuff->valueMask;

-    len = client->req_len - bytes_to_int32(sizeof(xSyncChangeAlarmReq));

-    /* the "extra" call to Ones accounts for the presence of 64 bit values */

-    if (len != (Ones(vmask) + Ones(vmask & (XSyncCAValue|XSyncCADelta))))

-	return BadLength;

-

-    if ((status = SyncChangeAlarmAttributes(client, pAlarm, vmask,

-					    (CARD32 *)&stuff[1])) != Success)

-	return status;

-

-    if (SyncCheckWarnIsCounter(pAlarm->trigger.pSync,

-			       WARN_INVALID_COUNTER_ALARM))

-	pCounter = (SyncCounter *)pAlarm->trigger.pSync;

-

-    /*  see if alarm already triggered.  NULL counter WILL trigger

-     *  in ChangeAlarm.

-     */

-

-    if (!pCounter ||

-	(*pAlarm->trigger.CheckTrigger)(&pAlarm->trigger, pCounter->value))

-    {

-	(*pAlarm->trigger.TriggerFired)(&pAlarm->trigger);

-    }

-    return Success;

-}

-

-static int

-ProcSyncQueryAlarm(ClientPtr client)

-{

-    REQUEST(xSyncQueryAlarmReq);

-    SyncAlarm      *pAlarm;

-    xSyncQueryAlarmReply rep;

-    SyncTrigger    *pTrigger;

-    int rc;

-

-    REQUEST_SIZE_MATCH(xSyncQueryAlarmReq);

-

-    rc = dixLookupResourceByType((pointer *)&pAlarm, stuff->alarm, RTAlarm,

-				 client, DixReadAccess);

-    if (rc != Success)

-	return rc;

-

-    rep.type = X_Reply;

-    rep.length = bytes_to_int32(sizeof(xSyncQueryAlarmReply) - sizeof(xGenericReply));

-    rep.sequenceNumber = client->sequence;

-

-    pTrigger = &pAlarm->trigger;

-    rep.counter = (pTrigger->pSync) ? pTrigger->pSync->id : None;

-

-#if 0 /* XXX unclear what to do, depends on whether relative value-types

-       * are "consumed" immediately and are considered absolute from then

-       * on.

-       */

-    rep.value_type = pTrigger->value_type;

-    rep.wait_value_hi = XSyncValueHigh32(pTrigger->wait_value);

-    rep.wait_value_lo = XSyncValueLow32(pTrigger->wait_value);

-#else

-    rep.value_type = XSyncAbsolute;

-    rep.wait_value_hi = XSyncValueHigh32(pTrigger->test_value);

-    rep.wait_value_lo = XSyncValueLow32(pTrigger->test_value);

-#endif

-

-    rep.test_type = pTrigger->test_type;

-    rep.delta_hi = XSyncValueHigh32(pAlarm->delta);

-    rep.delta_lo = XSyncValueLow32(pAlarm->delta);

-    rep.events = pAlarm->events;

-    rep.state = pAlarm->state;

-

-    if (client->swapped)

-    {

-	char n;

-	swaps(&rep.sequenceNumber, n);

-	swapl(&rep.length, n);

-	swapl(&rep.counter, n);

-	swapl(&rep.wait_value_hi, n);

-	swapl(&rep.wait_value_lo, n);

-	swapl(&rep.test_type, n);

-	swapl(&rep.delta_hi, n);

-	swapl(&rep.delta_lo, n);

-    }

-

-    WriteToClient(client, sizeof(xSyncQueryAlarmReply), (char *) &rep);

-    return Success;

-}

-

-static int

-ProcSyncDestroyAlarm(ClientPtr client)

-{

-    SyncAlarm *pAlarm;

-    int rc;

-    REQUEST(xSyncDestroyAlarmReq);

-

-    REQUEST_SIZE_MATCH(xSyncDestroyAlarmReq);

-

-    rc = dixLookupResourceByType((pointer *)&pAlarm, stuff->alarm, RTAlarm,

-				 client, DixDestroyAccess);

-    if (rc != Success)

-	return rc;

-

-    FreeResource(stuff->alarm, RT_NONE);

-    return Success;

-}

-

-static int

-ProcSyncCreateFence(ClientPtr client)

-{

-    REQUEST(xSyncCreateFenceReq);

-    DrawablePtr pDraw;

-    SyncFence *pFence;

-    int rc;

-

-    REQUEST_SIZE_MATCH(xSyncCreateFenceReq);

-

-    rc = dixLookupDrawable(&pDraw, stuff->d, client, M_ANY, DixGetAttrAccess);

-    if (rc != Success)

-	return rc;

-

-    LEGAL_NEW_RESOURCE(stuff->fid, client);

-

-    if (!(pFence = (SyncFence *)SyncCreate(client,

-					   stuff->fid,

-					   SYNC_FENCE)))

-	return BadAlloc;

-

-    miSyncInitFence(pDraw->pScreen, pFence, stuff->initially_triggered);

-

-    if (!AddResource(stuff->fid, RTFence, (pointer) pFence))

-	return BadAlloc;

-

-    return client->noClientException;

-}

-

-static int

-FreeFence(void *obj, XID id)

-{

-    SyncFence *pFence = (SyncFence *) obj;

-

-    miSyncDestroyFence(pFence);

-

-    return Success;

-}

-

-int SyncVerifyFence(SyncFence **ppSyncFence, XID fid,

-		    ClientPtr client, Mask mode)

-{

-    int rc = dixLookupResourceByType((pointer *)ppSyncFence, fid, RTFence,

-				     client, mode);

-

-    if (rc != Success)

-	client->errorValue = fid;

-

-    return rc;

-}

-

-static int

-ProcSyncTriggerFence(ClientPtr client)

-{

-    REQUEST(xSyncTriggerFenceReq);

-    SyncFence *pFence;

-    int rc;

-

-    REQUEST_SIZE_MATCH(xSyncTriggerFenceReq);

-

-    rc = dixLookupResourceByType((pointer *)&pFence, stuff->fid, RTFence,

-				 client, DixWriteAccess);

-    if (rc != Success)

-	return rc;

-

-    miSyncTriggerFence(pFence);

-

-    return client->noClientException;

-}

-

-static int

-ProcSyncResetFence(ClientPtr client)

-{

-    REQUEST(xSyncResetFenceReq);

-    SyncFence *pFence;

-    int rc;

-

-    REQUEST_SIZE_MATCH(xSyncResetFenceReq);

-

-    rc = dixLookupResourceByType((pointer *)&pFence, stuff->fid, RTFence,

-				 client, DixWriteAccess);

-    if (rc != Success)

-	return rc;

-

-    if (pFence->funcs.CheckTriggered(pFence) != TRUE)

-	return BadMatch;

-

-    pFence->funcs.Reset(pFence);

-

-    return client->noClientException;

-}

-

-static int

-ProcSyncDestroyFence(ClientPtr client)

-{

-    REQUEST(xSyncDestroyFenceReq);

-    SyncFence *pFence;

-    int rc;

-

-    REQUEST_SIZE_MATCH(xSyncDestroyFenceReq);

-

-    rc = dixLookupResourceByType((pointer *)&pFence, stuff->fid, RTFence,

-				 client, DixDestroyAccess);

-    if (rc != Success)

-	return rc;

-

-    FreeResource(stuff->fid, RT_NONE);

-    return client->noClientException;

-}

-

-static int

-ProcSyncQueryFence(ClientPtr client)

-{

-    REQUEST(xSyncQueryFenceReq);

-    xSyncQueryFenceReply rep;

-    SyncFence *pFence;

-    int rc;

-

-    REQUEST_SIZE_MATCH(xSyncQueryFenceReq);

-

-    rc = dixLookupResourceByType((pointer *)&pFence, stuff->fid,

-				 RTFence, client, DixReadAccess);

-    if (rc != Success)

-	return rc;

-

-    rep.type = X_Reply;

-    rep.length = 0;

-    rep.sequenceNumber = client->sequence;

-

-    rep.triggered = pFence->funcs.CheckTriggered(pFence);

-

-    if (client->swapped)

-    {

-	char n;

-	swaps(&rep.sequenceNumber, n);

-	swapl(&rep.length, n);

-    }

-

-    WriteToClient(client, sizeof(xSyncQueryFenceReply), (char *) &rep);

-    return client->noClientException;

-}

-

-static int

-ProcSyncAwaitFence(ClientPtr client)

-{

-    REQUEST(xSyncAwaitFenceReq);

-    SyncAwaitUnion *pAwaitUnion;

-    SyncAwait *pAwait;

-    /* Use CARD32 rather than XSyncFence because XIDs are hard-coded to

-     * CARD32 in protocol definitions */

-    CARD32 *pProtocolFences;

-    int status;

-    int len;

-    int items;

-    int i;

-

-    REQUEST_AT_LEAST_SIZE(xSyncAwaitFenceReq);

-

-    len = client->req_len << 2;

-    len -= sz_xSyncAwaitFenceReq;

-    items = len / sizeof(CARD32);

-

-    if (items * sizeof(CARD32) != len)

-    {

-	return BadLength;

-    }

-    if (items == 0)

-    {

-	client->errorValue = items;

-	return BadValue;

-    }

-

-    if (!(pAwaitUnion = SyncAwaitPrologue(client, items)))

-	return BadAlloc;

-

-    /* don't need to do any more memory allocation for this request! */

-

-    pProtocolFences = (CARD32 *) & stuff[1];

-

-    pAwait = &(pAwaitUnion+1)->await; /* skip over header */

-    for (i = 0; i < items; i++, pProtocolFences++, pAwait++)

-    {

-	if (*pProtocolFences == None)

-	{

-	    /*  this should take care of removing any triggers created by

-	     *  this request that have already been registered on sync objects

-	     */

-	    FreeResource(pAwaitUnion->header.delete_id, RT_NONE);

-	    client->errorValue = *pProtocolFences;

-	    return SyncErrorBase + XSyncBadFence;

-	}

-

-	pAwait->trigger.pSync = NULL;

-	/* Provide acceptable values for these unused fields to

-	 * satisfy SyncInitTrigger's validation logic

-	 */

-	pAwait->trigger.value_type = XSyncAbsolute;

-	XSyncIntToValue(&pAwait->trigger.wait_value, 0);

-	pAwait->trigger.test_type = 0;

-

-	status = SyncInitTrigger(client, &pAwait->trigger,

-				 *pProtocolFences, RTFence,

-				 XSyncCAAllTrigger);

-	if (status != Success)

-	{

-	    /*  this should take care of removing any triggers created by

-	     *  this request that have already been registered on sync objects

-	     */

-	    FreeResource(pAwaitUnion->header.delete_id, RT_NONE);

-	    return status;

-	}

-	/* this is not a mistake -- same function works for both cases */

-	pAwait->trigger.TriggerFired = SyncAwaitTriggerFired;

-	pAwait->trigger.CounterDestroyed = SyncAwaitTriggerFired;

-	/* event_threshold is unused for fence syncs */

-	XSyncIntToValue(&pAwait->event_threshold, 0);

-	pAwait->pHeader = &pAwaitUnion->header;

-	pAwaitUnion->header.num_waitconditions++;

-    }

-

-    SyncAwaitEpilogue(client, items, pAwaitUnion);

-

-    return client->noClientException;

-}

-

-/*

- * ** Given an extension request, call the appropriate request procedure

- */

-static int

-ProcSyncDispatch(ClientPtr client)

-{

-    REQUEST(xReq);

-

-    switch (stuff->data)

-    {

-      case X_SyncInitialize:

-	return ProcSyncInitialize(client);

-      case X_SyncListSystemCounters:

-	return ProcSyncListSystemCounters(client);

-      case X_SyncCreateCounter:

-	return ProcSyncCreateCounter(client);

-      case X_SyncSetCounter:

-	return ProcSyncSetCounter(client);

-      case X_SyncChangeCounter:

-	return ProcSyncChangeCounter(client);

-      case X_SyncQueryCounter:

-	return ProcSyncQueryCounter(client);

-      case X_SyncDestroyCounter:

-	return ProcSyncDestroyCounter(client);

-      case X_SyncAwait:

-	return ProcSyncAwait(client);

-      case X_SyncCreateAlarm:

-	return ProcSyncCreateAlarm(client);

-      case X_SyncChangeAlarm:

-	return ProcSyncChangeAlarm(client);

-      case X_SyncQueryAlarm:

-	return ProcSyncQueryAlarm(client);

-      case X_SyncDestroyAlarm:

-	return ProcSyncDestroyAlarm(client);

-      case X_SyncSetPriority:

-	return ProcSyncSetPriority(client);

-      case X_SyncGetPriority:

-	return ProcSyncGetPriority(client);

-      case X_SyncCreateFence:

-	return ProcSyncCreateFence(client);

-      case X_SyncTriggerFence:

-	return ProcSyncTriggerFence(client);

-      case X_SyncResetFence:

-	return ProcSyncResetFence(client);

-      case X_SyncDestroyFence:

-	return ProcSyncDestroyFence(client);

-      case X_SyncQueryFence:

-	return ProcSyncQueryFence(client);

-      case X_SyncAwaitFence:

-	return ProcSyncAwaitFence(client);

-      default:

-	return BadRequest;

-    }

-}

-

-/*

- * Boring Swapping stuff ...

- */

-

-static int

-SProcSyncInitialize(ClientPtr client)

-{

-    REQUEST(xSyncInitializeReq);

-    char   n;

-

-    swaps(&stuff->length, n);

-    REQUEST_SIZE_MATCH (xSyncInitializeReq);

-

-    return ProcSyncInitialize(client);

-}

-

-static int

-SProcSyncListSystemCounters(ClientPtr client)

-{

-    REQUEST(xSyncListSystemCountersReq);

-    char   n;

-

-    swaps(&stuff->length, n);

-    REQUEST_SIZE_MATCH (xSyncListSystemCountersReq);

-

-    return ProcSyncListSystemCounters(client);

-}

-

-static int

-SProcSyncCreateCounter(ClientPtr client)

-{

-    REQUEST(xSyncCreateCounterReq);

-    char   n;

-

-    swaps(&stuff->length, n);

-    REQUEST_SIZE_MATCH (xSyncCreateCounterReq);

-    swapl(&stuff->cid, n);

-    swapl(&stuff->initial_value_lo, n);

-    swapl(&stuff->initial_value_hi, n);

-

-    return ProcSyncCreateCounter(client);

-}

-

-static int

-SProcSyncSetCounter(ClientPtr client)

-{

-    REQUEST(xSyncSetCounterReq);

-    char   n;

-

-    swaps(&stuff->length, n);

-    REQUEST_SIZE_MATCH (xSyncSetCounterReq);

-    swapl(&stuff->cid, n);

-    swapl(&stuff->value_lo, n);

-    swapl(&stuff->value_hi, n);

-

-    return ProcSyncSetCounter(client);

-}

-

-static int

-SProcSyncChangeCounter(ClientPtr client)

-{

-    REQUEST(xSyncChangeCounterReq);

-    char   n;

-

-    swaps(&stuff->length, n);

-    REQUEST_SIZE_MATCH (xSyncChangeCounterReq);

-    swapl(&stuff->cid, n);

-    swapl(&stuff->value_lo, n);

-    swapl(&stuff->value_hi, n);

-

-    return ProcSyncChangeCounter(client);

-}

-

-static int

-SProcSyncQueryCounter(ClientPtr client)

-{

-    REQUEST(xSyncQueryCounterReq);

-    char   n;

-

-    swaps(&stuff->length, n);

-    REQUEST_SIZE_MATCH (xSyncQueryCounterReq);

-    swapl(&stuff->counter, n);

-

-    return ProcSyncQueryCounter(client);

-}

-

-static int

-SProcSyncDestroyCounter(ClientPtr client)

-{

-    REQUEST(xSyncDestroyCounterReq);

-    char   n;

-

-    swaps(&stuff->length, n);

-    REQUEST_SIZE_MATCH (xSyncDestroyCounterReq);

-    swapl(&stuff->counter, n);

-

-    return ProcSyncDestroyCounter(client);

-}

-

-static int

-SProcSyncAwait(ClientPtr client)

-{

-    REQUEST(xSyncAwaitReq);

-    char   n;

-

-    swaps(&stuff->length, n);

-    REQUEST_AT_LEAST_SIZE(xSyncAwaitReq);

-    SwapRestL(stuff);

-

-    return ProcSyncAwait(client);

-}

-

-static int

-SProcSyncCreateAlarm(ClientPtr client)

-{

-    REQUEST(xSyncCreateAlarmReq);

-    char   n;

-

-    swaps(&stuff->length, n);

-    REQUEST_AT_LEAST_SIZE(xSyncCreateAlarmReq);

-    swapl(&stuff->id, n);

-    swapl(&stuff->valueMask, n);

-    SwapRestL(stuff);

-

-    return ProcSyncCreateAlarm(client);

-}

-

-static int

-SProcSyncChangeAlarm(ClientPtr client)

-{

-    REQUEST(xSyncChangeAlarmReq);

-    char   n;

-

-    swaps(&stuff->length, n);

-    REQUEST_AT_LEAST_SIZE(xSyncChangeAlarmReq);

-    swapl(&stuff->alarm, n);

-    swapl(&stuff->valueMask, n);

-    SwapRestL(stuff);

-    return ProcSyncChangeAlarm(client);

-}

-

-static int

-SProcSyncQueryAlarm(ClientPtr client)

-{

-    REQUEST(xSyncQueryAlarmReq);

-    char   n;

-

-    swaps(&stuff->length, n);

-    REQUEST_SIZE_MATCH (xSyncQueryAlarmReq);

-    swapl(&stuff->alarm, n);

-

-    return ProcSyncQueryAlarm(client);

-}

-

-static int

-SProcSyncDestroyAlarm(ClientPtr client)

-{

-    REQUEST(xSyncDestroyAlarmReq);

-    char   n;

-

-    swaps(&stuff->length, n);

-    REQUEST_SIZE_MATCH (xSyncDestroyAlarmReq);

-    swapl(&stuff->alarm, n);

-

-    return ProcSyncDestroyAlarm(client);

-}

-

-static int

-SProcSyncSetPriority(ClientPtr client)

-{

-    REQUEST(xSyncSetPriorityReq);

-    char   n;

-

-    swaps(&stuff->length, n);

-    REQUEST_SIZE_MATCH (xSyncSetPriorityReq);

-    swapl(&stuff->id, n);

-    swapl(&stuff->priority, n);

-

-    return ProcSyncSetPriority(client);

-}

-

-static int

-SProcSyncGetPriority(ClientPtr client)

-{

-    REQUEST(xSyncGetPriorityReq);

-    char   n;

-

-    swaps(&stuff->length, n);

-    REQUEST_SIZE_MATCH (xSyncGetPriorityReq);

-    swapl(&stuff->id, n);

-

-    return ProcSyncGetPriority(client);

-}

-

-static int

-SProcSyncCreateFence(ClientPtr client)

-{

-    REQUEST(xSyncCreateFenceReq);

-    char n;

-

-    swaps(&stuff->length, n);

-    REQUEST_SIZE_MATCH (xSyncCreateFenceReq);

-    swapl(&stuff->fid, n);

-

-    return ProcSyncCreateFence(client);

-}

-

-static int

-SProcSyncTriggerFence(ClientPtr client)

-{

-    REQUEST(xSyncTriggerFenceReq);

-    char n;

-

-    swaps(&stuff->length, n);

-    REQUEST_SIZE_MATCH (xSyncTriggerFenceReq);

-    swapl(&stuff->fid, n);

-

-    return ProcSyncTriggerFence(client);

-}

-

-static int

-SProcSyncResetFence(ClientPtr client)

-{

-    REQUEST(xSyncResetFenceReq);

-    char n;

-

-    swaps(&stuff->length, n);

-    REQUEST_SIZE_MATCH (xSyncResetFenceReq);

-    swapl(&stuff->fid, n);

-

-    return ProcSyncResetFence(client);

-}

-

-static int

-SProcSyncDestroyFence(ClientPtr client)

-{

-    REQUEST(xSyncDestroyFenceReq);

-    char n;

-

-    swaps(&stuff->length, n);

-    REQUEST_SIZE_MATCH (xSyncDestroyFenceReq);

-    swapl(&stuff->fid, n);

-

-    return ProcSyncDestroyFence(client);

-}

-

-static int

-SProcSyncQueryFence(ClientPtr client)

-{

-    REQUEST(xSyncQueryFenceReq);

-    char   n;

-

-    swaps(&stuff->length, n);

-    REQUEST_SIZE_MATCH (xSyncQueryFenceReq);

-    swapl(&stuff->fid, n);

-

-    return ProcSyncQueryFence(client);

-}

-

-static int

-SProcSyncAwaitFence(ClientPtr client)

-{

-    REQUEST(xSyncAwaitFenceReq);

-    char   n;

-

-    swaps(&stuff->length, n);

-    REQUEST_AT_LEAST_SIZE(xSyncAwaitFenceReq);

-    SwapRestL(stuff);

-

-    return ProcSyncAwaitFence(client);

-}

-

-static int

-SProcSyncDispatch(ClientPtr client)

-{

-    REQUEST(xReq);

-

-    switch (stuff->data)

-    {

-      case X_SyncInitialize:

-	return SProcSyncInitialize(client);

-      case X_SyncListSystemCounters:

-	return SProcSyncListSystemCounters(client);

-      case X_SyncCreateCounter:

-	return SProcSyncCreateCounter(client);

-      case X_SyncSetCounter:

-	return SProcSyncSetCounter(client);

-      case X_SyncChangeCounter:

-	return SProcSyncChangeCounter(client);

-      case X_SyncQueryCounter:

-	return SProcSyncQueryCounter(client);

-      case X_SyncDestroyCounter:

-	return SProcSyncDestroyCounter(client);

-      case X_SyncAwait:

-	return SProcSyncAwait(client);

-      case X_SyncCreateAlarm:

-	return SProcSyncCreateAlarm(client);

-      case X_SyncChangeAlarm:

-	return SProcSyncChangeAlarm(client);

-      case X_SyncQueryAlarm:

-	return SProcSyncQueryAlarm(client);

-      case X_SyncDestroyAlarm:

-	return SProcSyncDestroyAlarm(client);

-      case X_SyncSetPriority:

-	return SProcSyncSetPriority(client);

-      case X_SyncGetPriority:

-	return SProcSyncGetPriority(client);

-      case X_SyncCreateFence:

-	return SProcSyncCreateFence(client);

-      case X_SyncTriggerFence:

-	return SProcSyncTriggerFence(client);

-      case X_SyncResetFence:

-	return SProcSyncResetFence(client);

-      case X_SyncDestroyFence:

-	return SProcSyncDestroyFence(client);

-      case X_SyncQueryFence:

-	return SProcSyncQueryFence(client);

-      case X_SyncAwaitFence:

-	return SProcSyncAwaitFence(client);

-      default:

-	return BadRequest;

-    }

-}

-

-/*

- * Event Swapping

- */

-

-static void

-SCounterNotifyEvent(xSyncCounterNotifyEvent *from, xSyncCounterNotifyEvent *to)

-{

-    to->type = from->type;

-    to->kind = from->kind;

-    cpswaps(from->sequenceNumber, to->sequenceNumber);

-    cpswapl(from->counter, to->counter);

-    cpswapl(from->wait_value_lo, to->wait_value_lo);

-    cpswapl(from->wait_value_hi, to->wait_value_hi);

-    cpswapl(from->counter_value_lo, to->counter_value_lo);

-    cpswapl(from->counter_value_hi, to->counter_value_hi);

-    cpswapl(from->time, to->time);

-    cpswaps(from->count, to->count);

-    to->destroyed = from->destroyed;

-}

-

-

-static void

-SAlarmNotifyEvent(xSyncAlarmNotifyEvent *from, xSyncAlarmNotifyEvent *to)

-{

-    to->type = from->type;

-    to->kind = from->kind;

-    cpswaps(from->sequenceNumber, to->sequenceNumber);

-    cpswapl(from->alarm, to->alarm);

-    cpswapl(from->counter_value_lo, to->counter_value_lo);

-    cpswapl(from->counter_value_hi, to->counter_value_hi);

-    cpswapl(from->alarm_value_lo, to->alarm_value_lo);

-    cpswapl(from->alarm_value_hi, to->alarm_value_hi);

-    cpswapl(from->time, to->time);

-    to->state = from->state;

-}

-

-/*

- * ** Close everything down. ** This is fairly simple for now.

- */

-/* ARGSUSED */

-static void

-SyncResetProc(ExtensionEntry *extEntry)

-{

-    free(SysCounterList);

-    SysCounterList = NULL;

-    RTCounter = 0;

-}

-

-/*

- * ** Initialise the extension.

- */

-void

-SyncExtensionInit(void)

-{

-    ExtensionEntry *extEntry;

-    int 	    s;

-

-    for (s = 0; s < screenInfo.numScreens; s++)

-	miSyncSetup(screenInfo.screens[s]);

-

-    if (RTCounter == 0)

-    {

-	RTCounter = CreateNewResourceType(FreeCounter, "SyncCounter");

-    }

-    RTAlarm = CreateNewResourceType(FreeAlarm, "SyncAlarm");

-    RTAwait = CreateNewResourceType(FreeAwait, "SyncAwait");

-    RTFence = CreateNewResourceType(FreeFence, "SyncFence");

-    if (RTAwait)

-	RTAwait |= RC_NEVERRETAIN;

-    RTAlarmClient = CreateNewResourceType(FreeAlarmClient, "SyncAlarmClient");

-    if (RTAlarmClient)

-	RTAlarmClient |= RC_NEVERRETAIN;

-

-    if (RTCounter == 0 || RTAwait == 0 || RTAlarm == 0 ||

-	RTAlarmClient == 0 ||

-	(extEntry = AddExtension(SYNC_NAME,

-				 XSyncNumberEvents, XSyncNumberErrors,

-				 ProcSyncDispatch, SProcSyncDispatch,

-				 SyncResetProc,

-				 StandardMinorOpcode)) == NULL)

-    {

-	ErrorF("Sync Extension %d.%d failed to Initialise\n",

-		SYNC_MAJOR_VERSION, SYNC_MINOR_VERSION);

-	return;

-    }

-

-    SyncEventBase = extEntry->eventBase;

-    SyncErrorBase = extEntry->errorBase;

-    EventSwapVector[SyncEventBase + XSyncCounterNotify] = (EventSwapPtr) SCounterNotifyEvent;

-    EventSwapVector[SyncEventBase + XSyncAlarmNotify] = (EventSwapPtr) SAlarmNotifyEvent;

-

-    SetResourceTypeErrorValue(RTCounter, SyncErrorBase + XSyncBadCounter);

-    SetResourceTypeErrorValue(RTAlarm, SyncErrorBase + XSyncBadAlarm);

-    SetResourceTypeErrorValue(RTFence, SyncErrorBase + XSyncBadFence);

-

-    /*

-     * Although SERVERTIME is implemented by the OS layer, we initialise it

-     * here because doing it in OsInit() is too early. The resource database

-     * is not initialised when OsInit() is called. This is just about OK

-     * because there is always a servertime counter.

-     */

-    SyncInitServerTime();

-    SyncInitIdleTime();

-

-#ifdef DEBUG

-    fprintf(stderr, "Sync Extension %d.%d\n",

-	    SYNC_MAJOR_VERSION, SYNC_MINOR_VERSION);

-#endif

-}

-

-

-/*

- * ***** SERVERTIME implementation - should go in its own file in OS directory?

- */

-

-

-

-static pointer ServertimeCounter;

-static XSyncValue Now;

-static XSyncValue *pnext_time;

-

-#define GetTime()\

-{\

-    unsigned long millis = GetTimeInMillis();\

-    unsigned long maxis = XSyncValueHigh32(Now);\

-    if (millis < XSyncValueLow32(Now)) maxis++;\

-    XSyncIntsToValue(&Now, millis, maxis);\

-}

-

-/*

-*** Server Block Handler

-*** code inspired by multibuffer extension (now deprecated)

- */

-/*ARGSUSED*/

-static void

-ServertimeBlockHandler(void *env, struct timeval **wt, void *LastSelectMask)

-{

-    XSyncValue delay;

-    unsigned long timeout;

-

-    if (pnext_time)

-    {

-        GetTime();

-

-        if (XSyncValueGreaterOrEqual(Now, *pnext_time))

-	{

-            timeout = 0;

-        }

-	else

-	{

-	    Bool overflow;

-            XSyncValueSubtract(&delay, *pnext_time, Now, &overflow);

-	    (void)overflow;

-            timeout = XSyncValueLow32(delay);

-        }

-        AdjustWaitForDelay(wt, timeout); /* os/utils.c */

-    }

-}

-

-/*

-*** Wakeup Handler

- */

-/*ARGSUSED*/

-static void

-ServertimeWakeupHandler(void *env, int rc, void *LastSelectMask)

-{

-    if (pnext_time)

-    {

-        GetTime();

-

-        if (XSyncValueGreaterOrEqual(Now, *pnext_time))

-	{

-            SyncChangeCounter(ServertimeCounter, Now);

-        }

-    }

-}

-

-static void

-ServertimeQueryValue(void *pCounter, CARD64 *pValue_return)

-{

-    GetTime();

-    *pValue_return = Now;

-}

-

-static void

-ServertimeBracketValues(void *pCounter, CARD64 *pbracket_less,

-			CARD64 *pbracket_greater)

-{

-    if (!pnext_time && pbracket_greater)

-    {

-	RegisterBlockAndWakeupHandlers(ServertimeBlockHandler,

-				       ServertimeWakeupHandler,

-				       NULL);

-    }

-    else if (pnext_time && !pbracket_greater)

-    {

-	RemoveBlockAndWakeupHandlers(ServertimeBlockHandler,

-				     ServertimeWakeupHandler,

-				     NULL);

-    }

-    pnext_time = pbracket_greater;

-}

-

-static void

-SyncInitServerTime(void)

-{

-    CARD64 resolution;

-

-    XSyncIntsToValue(&Now, GetTimeInMillis(), 0);

-    XSyncIntToValue(&resolution, 4);

-    ServertimeCounter = SyncCreateSystemCounter("SERVERTIME", Now, resolution,

-			    XSyncCounterNeverDecreases,

-			    ServertimeQueryValue, ServertimeBracketValues);

-    pnext_time = NULL;

-}

-

-

-

-/*

- * IDLETIME implementation

- */

-

-static SyncCounter *IdleTimeCounter;

-static XSyncValue *pIdleTimeValueLess;

-static XSyncValue *pIdleTimeValueGreater;

-

-static void

-IdleTimeQueryValue (pointer pCounter, CARD64 *pValue_return)

-{

-    CARD32 idle = GetTimeInMillis() - lastDeviceEventTime.milliseconds;

-    XSyncIntsToValue (pValue_return, idle, 0);

-}

-

-static void

-IdleTimeBlockHandler(pointer env, struct timeval **wt, pointer LastSelectMask)

-{

-    XSyncValue idle, old_idle;

-    SyncTriggerList *list = IdleTimeCounter->sync.pTriglist;

-    SyncTrigger *trig;

-

-    if (!pIdleTimeValueLess && !pIdleTimeValueGreater)

-	return;

-

-    old_idle = IdleTimeCounter->value;

-    IdleTimeQueryValue (NULL, &idle);

-    IdleTimeCounter->value = idle; /* push, so CheckTrigger works */

-

-    if (pIdleTimeValueLess &&

-        XSyncValueLessOrEqual (idle, *pIdleTimeValueLess))

-    {

-	/*

-	 * We've been idle for less than the threshold value, and someone

-	 * wants to know about that, but now we need to know whether they

-	 * want level or edge trigger.  Check the trigger list against the

-	 * current idle time, and if any succeed, bomb out of select()

-	 * immediately so we can reschedule.

-	 */

-

-	for (list = IdleTimeCounter->sync.pTriglist; list; list = list->next) {

-	    trig = list->pTrigger;

-	    if (trig->CheckTrigger(trig, old_idle)) {

-		AdjustWaitForDelay(wt, 0);

-		break;

-	    }

-	}

-	/* 

-	 * We've been called exactly on the idle time, but we have a

-	 * NegativeTransition trigger which requires a transition from an

-	 * idle time greater than this.  Schedule a wakeup for the next

-	 * millisecond so we won't miss a transition.

-	 */

-	if (XSyncValueEqual (idle, *pIdleTimeValueLess))

-	    AdjustWaitForDelay(wt, 1);

-    }

-    else if (pIdleTimeValueGreater)

-    {

-	/*

-	 * There's a threshold in the positive direction.  If we've been

-	 * idle less than it, schedule a wakeup for sometime in the future.

-	 * If we've been idle more than it, and someone wants to know about

-	 * that level-triggered, schedule an immediate wakeup.

-	 */

-	unsigned long timeout = -1;

-

-	if (XSyncValueLessThan (idle, *pIdleTimeValueGreater)) {

-	    XSyncValue value;

-	    Bool overflow;

-

-	    XSyncValueSubtract (&value, *pIdleTimeValueGreater,

-	                        idle, &overflow);

-	    timeout = min(timeout, XSyncValueLow32 (value));

-	} else {

-	    for (list = IdleTimeCounter->sync.pTriglist; list; list = list->next) {

-		trig = list->pTrigger;

-		if (trig->CheckTrigger(trig, old_idle)) {

-		    timeout = min(timeout, 0);

-		    break;

-		}

-	    }

-	}

-

-	AdjustWaitForDelay (wt, timeout);

-    }

-

-    IdleTimeCounter->value = old_idle; /* pop */

-}

-

-static void

-IdleTimeWakeupHandler (pointer env, int rc, pointer LastSelectMask)

-{

-    XSyncValue idle;

-

-    if (!pIdleTimeValueLess && !pIdleTimeValueGreater)

-	return;

-

-    IdleTimeQueryValue (NULL, &idle);

-

-    if ((pIdleTimeValueGreater &&

-         XSyncValueGreaterOrEqual (idle, *pIdleTimeValueGreater)) ||

-        (pIdleTimeValueLess &&

-	 XSyncValueLessOrEqual (idle, *pIdleTimeValueLess)))

-    {

-	SyncChangeCounter (IdleTimeCounter, idle);

-    }

-}

-

-static void

-IdleTimeBracketValues (pointer pCounter, CARD64 *pbracket_less,

-                       CARD64 *pbracket_greater)

-{

-    Bool registered = (pIdleTimeValueLess || pIdleTimeValueGreater);

-

-    if (registered && !pbracket_less && !pbracket_greater)

-    {

-	RemoveBlockAndWakeupHandlers(IdleTimeBlockHandler,

-	                             IdleTimeWakeupHandler,

-	                             NULL);

-    }

-    else if (!registered && (pbracket_less || pbracket_greater))

-    {

-	RegisterBlockAndWakeupHandlers(IdleTimeBlockHandler,

-	                               IdleTimeWakeupHandler,

-	                               NULL);

-    }

-

-    pIdleTimeValueGreater = pbracket_greater;

-    pIdleTimeValueLess    = pbracket_less;

-}

-

-static void

-SyncInitIdleTime (void)

-{

-    CARD64 resolution;

-    XSyncValue idle;

-

-    IdleTimeQueryValue (NULL, &idle);

-    XSyncIntToValue (&resolution, 4);

-

-    IdleTimeCounter = SyncCreateSystemCounter ("IDLETIME", idle, resolution,

-                                               XSyncCounterUnrestricted,

-                                               IdleTimeQueryValue,

-                                               IdleTimeBracketValues);

-

-    pIdleTimeValueLess = pIdleTimeValueGreater = NULL;

-}

+/*
+
+Copyright 1991, 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.
+
+
+Copyright 1991, 1993 by Digital Equipment Corporation, Maynard, Massachusetts,
+and Olivetti Research Limited, Cambridge, England.
+
+                        All Rights Reserved
+
+Permission to use, copy, modify, and distribute this software and its
+documentation for any purpose and without fee is hereby granted,
+provided that the above copyright notice appear in all copies and that
+both that copyright notice and this permission notice appear in
+supporting documentation, and that the names of Digital or Olivetti
+not be used in advertising or publicity pertaining to distribution of the
+software without specific, written prior permission.  Digital and Olivetti
+make no representations about the suitability of this software
+for any purpose.  It is provided "as is" without express or implied warranty.
+
+DIGITAL AND OLIVETTI DISCLAIM ALL WARRANTIES WITH REGARD TO THIS
+SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
+FITNESS, IN NO EVENT SHALL THEY BE LIABLE FOR ANY SPECIAL, INDIRECT OR
+CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF
+USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+
+*/
+
+#ifdef HAVE_DIX_CONFIG_H
+#include <dix-config.h>
+#endif
+
+#include <string.h>
+
+#include <X11/X.h>
+#include <X11/Xproto.h>
+#include <X11/Xmd.h>
+#include "scrnintstr.h"
+#include "os.h"
+#include "extnsionst.h"
+#include "dixstruct.h"
+#include "pixmapstr.h"
+#include "resource.h"
+#include "opaque.h"
+#include <X11/extensions/syncproto.h>
+#include "syncsrv.h"
+#include "syncsdk.h"
+#include "protocol-versions.h"
+
+#include <stdio.h>
+#if !defined(WIN32)
+#include <sys/time.h>
+#endif
+
+#include "modinit.h"
+
+/*
+ * Local Global Variables
+ */
+static int      SyncEventBase;
+static int      SyncErrorBase;
+static RESTYPE  RTCounter = 0;
+static RESTYPE  RTAwait;
+static RESTYPE  RTAlarm;
+static RESTYPE  RTAlarmClient;
+static RESTYPE  RTFence;
+static int SyncNumSystemCounters = 0;
+static SyncCounter **SysCounterList = NULL;
+static int SyncNumInvalidCounterWarnings = 0;
+#define MAX_INVALID_COUNTER_WARNINGS	   5
+
+static const char *WARN_INVALID_COUNTER_COMPARE =
+"Warning: Non-counter XSync object using Counter-only\n"
+"         comparison.  Result will never be true.\n";
+
+static const char *WARN_INVALID_COUNTER_ALARM =
+"Warning: Non-counter XSync object used in alarm.  This is\n"
+"         the result of a programming error in the X server.\n";
+
+#define IsSystemCounter(pCounter) \
+    (pCounter && (pCounter->sync.client == NULL))
+
+/* these are all the alarm attributes that pertain to the alarm's trigger */
+#define XSyncCAAllTrigger \
+    (XSyncCACounter | XSyncCAValueType | XSyncCAValue | XSyncCATestType)
+
+static void SyncComputeBracketValues(SyncCounter *);
+
+static void SyncInitServerTime(void);
+
+static void SyncInitIdleTime(void);
+
+static Bool
+SyncCheckWarnIsCounter(const SyncObject* pSync, const char *warning)
+{
+    if (pSync && (SYNC_COUNTER != pSync->type))
+    {
+	if (SyncNumInvalidCounterWarnings++ < MAX_INVALID_COUNTER_WARNINGS)
+	{
+	    ErrorF("%s", warning);
+	    ErrorF("         Counter type: %d\n", pSync->type);
+	}
+
+	return FALSE;
+    }
+
+    return TRUE;
+}
+
+/*  Each counter maintains a simple linked list of triggers that are
+ *  interested in the counter.  The two functions below are used to
+ *  delete and add triggers on this list.
+ */
+static void
+SyncDeleteTriggerFromSyncObject(SyncTrigger *pTrigger)
+{
+    SyncTriggerList *pCur;
+    SyncTriggerList *pPrev;
+    SyncCounter *pCounter;
+
+    /* pSync needs to be stored in pTrigger before calling here. */
+
+    if (!pTrigger->pSync)
+	return;
+
+    pPrev = NULL;
+    pCur = pTrigger->pSync->pTriglist;
+
+    while (pCur)
+    {
+	if (pCur->pTrigger == pTrigger)
+	{
+	    if (pPrev)
+		pPrev->next = pCur->next;
+	    else
+		pTrigger->pSync->pTriglist = pCur->next;
+
+	    free(pCur);
+	    break;
+	}
+	
+	pPrev = pCur;
+	pCur = pCur->next;
+    }
+
+    if (SYNC_COUNTER == pTrigger->pSync->type)
+    {
+	pCounter = (SyncCounter *)pTrigger->pSync;
+
+	if (IsSystemCounter(pCounter))
+	    SyncComputeBracketValues(pCounter);
+    } else if (SYNC_FENCE == pTrigger->pSync->type) {
+	SyncFence* pFence = (SyncFence*) pTrigger->pSync;
+	pFence->funcs.DeleteTrigger(pTrigger);
+    }
+}
+
+
+static int
+SyncAddTriggerToSyncObject(SyncTrigger *pTrigger)
+{
+    SyncTriggerList *pCur;
+    SyncCounter *pCounter;
+
+    if (!pTrigger->pSync)
+	return Success;
+
+    /* don't do anything if it's already there */
+    for (pCur = pTrigger->pSync->pTriglist; pCur; pCur = pCur->next)
+    {
+	if (pCur->pTrigger == pTrigger)
+	    return Success;
+    }
+
+    if (!(pCur = malloc(sizeof(SyncTriggerList))))
+	return BadAlloc;
+
+    pCur->pTrigger = pTrigger;
+    pCur->next = pTrigger->pSync->pTriglist;
+    pTrigger->pSync->pTriglist = pCur;
+
+    if (SYNC_COUNTER == pTrigger->pSync->type)
+    {
+	pCounter = (SyncCounter *)pTrigger->pSync;
+
+	if (IsSystemCounter(pCounter))
+	    SyncComputeBracketValues(pCounter);
+    } else if (SYNC_FENCE == pTrigger->pSync->type) {
+	SyncFence* pFence = (SyncFence*) pTrigger->pSync;
+	pFence->funcs.AddTrigger(pTrigger);
+    }
+
+    return Success;
+}
+
+
+/*  Below are five possible functions that can be plugged into
+ *  pTrigger->CheckTrigger for counter sync objects, corresponding to
+ *  the four possible test-types, and the one possible function that
+ *  can be plugged into pTrigger->CheckTrigger for fence sync objects.
+ *  These functions are called after the sync object's state changes
+ *  but are also passed the old state so they can inspect both the old
+ *  and new values.  (PositiveTransition and NegativeTransition need to
+ *  see both pieces of information.)  These functions return the truth
+ *  value of the trigger.
+ *
+ *  All of them include the condition pTrigger->pSync == NULL.
+ *  This is because the spec says that a trigger with a sync value
+ *  of None is always TRUE.
+ */
+
+static Bool
+SyncCheckTriggerPositiveComparison(SyncTrigger *pTrigger, CARD64 oldval)
+{
+    SyncCounter *pCounter;
+
+    /* Non-counter sync objects should never get here because they
+     * never trigger this comparison. */
+    if (!SyncCheckWarnIsCounter(pTrigger->pSync, WARN_INVALID_COUNTER_COMPARE))
+	return FALSE;
+
+    pCounter = (SyncCounter *)pTrigger->pSync;
+
+    return (pCounter == NULL ||
+	    XSyncValueGreaterOrEqual(pCounter->value, pTrigger->test_value));
+}
+
+static Bool
+SyncCheckTriggerNegativeComparison(SyncTrigger *pTrigger,  CARD64 oldval)
+{
+    SyncCounter *pCounter;
+
+    /* Non-counter sync objects should never get here because they
+     * never trigger this comparison. */
+    if (!SyncCheckWarnIsCounter(pTrigger->pSync, WARN_INVALID_COUNTER_COMPARE))
+	return FALSE;
+
+    pCounter = (SyncCounter *)pTrigger->pSync;
+
+    return (pCounter == NULL ||
+	    XSyncValueLessOrEqual(pCounter->value, pTrigger->test_value));
+}
+
+static Bool
+SyncCheckTriggerPositiveTransition(SyncTrigger *pTrigger, CARD64 oldval)
+{
+    SyncCounter *pCounter;
+
+    /* Non-counter sync objects should never get here because they
+     * never trigger this comparison. */
+    if (!SyncCheckWarnIsCounter(pTrigger->pSync, WARN_INVALID_COUNTER_COMPARE))
+	return FALSE;
+
+    pCounter = (SyncCounter *)pTrigger->pSync;
+
+    return (pCounter == NULL ||
+	    (XSyncValueLessThan(oldval, pTrigger->test_value) &&
+	     XSyncValueGreaterOrEqual(pCounter->value, pTrigger->test_value)));
+}
+
+static Bool
+SyncCheckTriggerNegativeTransition(SyncTrigger *pTrigger, CARD64 oldval)
+{
+    SyncCounter *pCounter;
+
+    /* Non-counter sync objects should never get here because they
+     * never trigger this comparison. */
+    if (!SyncCheckWarnIsCounter(pTrigger->pSync, WARN_INVALID_COUNTER_COMPARE))
+	return FALSE;
+
+    pCounter = (SyncCounter *)pTrigger->pSync;
+
+    return (pCounter == NULL ||
+	    (XSyncValueGreaterThan(oldval, pTrigger->test_value) &&
+	     XSyncValueLessOrEqual(pCounter->value, pTrigger->test_value)));
+}
+
+static Bool
+SyncCheckTriggerFence(SyncTrigger *pTrigger, CARD64 unused)
+{
+    SyncFence* pFence = (SyncFence*) pTrigger->pSync;
+    (void)unused;
+
+    return (pFence == NULL ||
+	    pFence->funcs.CheckTriggered(pFence));
+}
+
+static int
+SyncInitTrigger(ClientPtr client, SyncTrigger *pTrigger, XID syncObject,
+		RESTYPE resType, Mask changes)
+{
+    SyncObject *pSync = pTrigger->pSync;
+    SyncCounter *pCounter = NULL;
+    int		rc;
+    Bool	newSyncObject = FALSE;
+
+    if (changes & XSyncCACounter)
+    {
+	if (syncObject == None)
+	    pSync = NULL;
+	else if (Success != (rc = dixLookupResourceByType ((pointer *)&pSync,
+				syncObject, resType, client, DixReadAccess)))
+	{
+	    client->errorValue = syncObject;
+	    return rc;
+	}
+	if (pSync != pTrigger->pSync)
+	{ /* new counter for trigger */
+	    SyncDeleteTriggerFromSyncObject(pTrigger);
+	    pTrigger->pSync = pSync;
+	    newSyncObject = TRUE;
+	}
+    }
+
+    /* if system counter, ask it what the current value is */
+
+    if (pSync && SYNC_COUNTER == pSync->type)
+    {
+	pCounter = (SyncCounter *)pSync;
+
+	if (IsSystemCounter(pCounter))
+	{
+	    (*pCounter->pSysCounterInfo->QueryValue) ((pointer) pCounter,
+						      &pCounter->value);
+	}
+    }
+
+    if (changes & XSyncCAValueType)
+    {
+	if (pTrigger->value_type != XSyncRelative &&
+	    pTrigger->value_type != XSyncAbsolute)
+	{
+	    client->errorValue = pTrigger->value_type;
+	    return BadValue;
+	}
+    }
+
+    if (changes & XSyncCATestType)
+    {
+
+	if (pSync && SYNC_FENCE == pSync->type)
+	{
+	    pTrigger->CheckTrigger = SyncCheckTriggerFence;
+	}
+	else
+	{
+	    /* select appropriate CheckTrigger function */
+
+	    switch (pTrigger->test_type)
+	    {
+	    case XSyncPositiveTransition:
+		pTrigger->CheckTrigger = SyncCheckTriggerPositiveTransition;
+		break;
+	    case XSyncNegativeTransition:
+		pTrigger->CheckTrigger = SyncCheckTriggerNegativeTransition;
+		break;
+	    case XSyncPositiveComparison:
+		pTrigger->CheckTrigger = SyncCheckTriggerPositiveComparison;
+		break;
+	    case XSyncNegativeComparison:
+		pTrigger->CheckTrigger = SyncCheckTriggerNegativeComparison;
+		break;
+	    default:
+		client->errorValue = pTrigger->test_type;
+		return BadValue;
+	    }
+	}
+    }
+
+    if (changes & (XSyncCAValueType | XSyncCAValue))
+    {
+	if (pTrigger->value_type == XSyncAbsolute)
+	    pTrigger->test_value = pTrigger->wait_value;
+	else /* relative */
+	{
+	    Bool overflow;
+	    if (pCounter == NULL)
+		return BadMatch;
+
+	    XSyncValueAdd(&pTrigger->test_value, pCounter->value,
+			  pTrigger->wait_value, &overflow);
+	    if (overflow)
+	    {
+		client->errorValue = XSyncValueHigh32(pTrigger->wait_value);
+		return BadValue;
+	    }
+	}
+    }
+
+    /*  we wait until we're sure there are no errors before registering
+     *  a new counter on a trigger
+     */
+    if (newSyncObject)
+    {
+	if ((rc = SyncAddTriggerToSyncObject(pTrigger)) != Success)
+	    return rc;
+    }
+    else if (pCounter && IsSystemCounter(pCounter))
+    {
+	SyncComputeBracketValues(pCounter);
+    }
+
+    return Success;
+}
+
+/*  AlarmNotify events happen in response to actions taken on an Alarm or
+ *  the counter used by the alarm.  AlarmNotify may be sent to multiple
+ *  clients.  The alarm maintains a list of clients interested in events.
+ */
+static void
+SyncSendAlarmNotifyEvents(SyncAlarm *pAlarm)
+{
+    SyncAlarmClientList *pcl;
+    xSyncAlarmNotifyEvent ane;
+    SyncTrigger *pTrigger = &pAlarm->trigger;
+    SyncCounter *pCounter;
+
+    if (!SyncCheckWarnIsCounter(pTrigger->pSync, WARN_INVALID_COUNTER_ALARM))
+	return;
+
+    pCounter = (SyncCounter *)pTrigger->pSync;
+
+    UpdateCurrentTime();
+
+    ane.type = SyncEventBase + XSyncAlarmNotify;
+    ane.kind = XSyncAlarmNotify;
+    ane.alarm = pAlarm->alarm_id;
+    if (pTrigger->pSync && SYNC_COUNTER == pTrigger->pSync->type)
+    {
+	ane.counter_value_hi = XSyncValueHigh32(pCounter->value);
+	ane.counter_value_lo = XSyncValueLow32(pCounter->value);
+    }
+    else
+    { /* XXX what else can we do if there's no counter? */
+	ane.counter_value_hi = ane.counter_value_lo = 0;
+    }
+
+    ane.alarm_value_hi = XSyncValueHigh32(pTrigger->test_value);
+    ane.alarm_value_lo = XSyncValueLow32(pTrigger->test_value);
+    ane.time = currentTime.milliseconds;
+    ane.state = pAlarm->state;
+
+    /* send to owner */
+    if (pAlarm->events)
+	WriteEventsToClient(pAlarm->client, 1, (xEvent *) &ane);
+
+    /* send to other interested clients */
+    for (pcl = pAlarm->pEventClients; pcl; pcl = pcl->next)
+	WriteEventsToClient(pcl->client, 1, (xEvent *) &ane);
+}
+
+
+/*  CounterNotify events only occur in response to an Await.  The events
+ *  go only to the Awaiting client.
+ */
+static void
+SyncSendCounterNotifyEvents(ClientPtr client, SyncAwait **ppAwait,
+			    int num_events)
+{
+    xSyncCounterNotifyEvent *pEvents, *pev;
+    int i;
+
+    if (client->clientGone)
+	return;
+    pev = pEvents = malloc(num_events * sizeof(xSyncCounterNotifyEvent));
+    if (!pEvents)
+	return;
+    UpdateCurrentTime();
+    for (i = 0; i < num_events; i++, ppAwait++, pev++)
+    {
+	SyncTrigger *pTrigger = &(*ppAwait)->trigger;
+	pev->type = SyncEventBase + XSyncCounterNotify;
+	pev->kind = XSyncCounterNotify;
+	pev->counter = pTrigger->pSync->id;
+	pev->wait_value_lo = XSyncValueLow32(pTrigger->test_value);
+	pev->wait_value_hi = XSyncValueHigh32(pTrigger->test_value);
+	if (SYNC_COUNTER == pTrigger->pSync->type)
+	{
+	    SyncCounter *pCounter = (SyncCounter *)pTrigger->pSync;
+
+	    pev->counter_value_lo = XSyncValueLow32(pCounter->value);
+	    pev->counter_value_hi = XSyncValueHigh32(pCounter->value);
+	}
+	else
+	{
+	    pev->counter_value_lo = 0;
+	    pev->counter_value_hi = 0;
+	}
+
+	pev->time = currentTime.milliseconds;
+	pev->count = num_events - i - 1; /* events remaining */
+	pev->destroyed = pTrigger->pSync->beingDestroyed;
+    }
+    /* swapping will be taken care of by this */
+    WriteEventsToClient(client, num_events, (xEvent *)pEvents);
+    free(pEvents);
+}
+
+
+/* This function is called when an alarm's counter is destroyed.
+ * It is plugged into pTrigger->CounterDestroyed (for alarm triggers).
+ */
+static void
+SyncAlarmCounterDestroyed(SyncTrigger *pTrigger)
+{
+    SyncAlarm *pAlarm = (SyncAlarm *)pTrigger;
+
+    pAlarm->state = XSyncAlarmInactive;
+    SyncSendAlarmNotifyEvents(pAlarm);
+    pTrigger->pSync = NULL;
+}
+
+
+/*  This function is called when an alarm "goes off."
+ *  It is plugged into pTrigger->TriggerFired (for alarm triggers).
+ */
+static void
+SyncAlarmTriggerFired(SyncTrigger *pTrigger)
+{
+    SyncAlarm *pAlarm = (SyncAlarm *)pTrigger;
+    SyncCounter *pCounter;
+    CARD64 new_test_value;
+
+    if (!SyncCheckWarnIsCounter(pTrigger->pSync, WARN_INVALID_COUNTER_ALARM))
+	return;
+
+    pCounter = (SyncCounter *)pTrigger->pSync;
+
+    /* no need to check alarm unless it's active */
+    if (pAlarm->state != XSyncAlarmActive)
+	return;
+
+    /*  " if the counter value is None, or if the delta is 0 and
+     *    the test-type is PositiveComparison or NegativeComparison,
+     *    no change is made to value (test-value) and the alarm
+     *    state is changed to Inactive before the event is generated."
+     */
+    if (pCounter == NULL
+	|| (XSyncValueIsZero(pAlarm->delta)
+	    && (pAlarm->trigger.test_type == XSyncPositiveComparison
+		|| pAlarm->trigger.test_type == XSyncNegativeComparison)))
+	pAlarm->state = XSyncAlarmInactive;
+
+    new_test_value = pAlarm->trigger.test_value;
+
+    if (pAlarm->state == XSyncAlarmActive)
+    {
+	Bool overflow;
+	CARD64 oldvalue;
+	SyncTrigger *paTrigger = &pAlarm->trigger;
+	SyncCounter *paCounter;
+
+	if (!SyncCheckWarnIsCounter(paTrigger->pSync,
+				    WARN_INVALID_COUNTER_ALARM))
+	    return;
+
+	paCounter = (SyncCounter *)pTrigger->pSync;
+
+	/* "The alarm is updated by repeatedly adding delta to the
+	 *  value of the trigger and re-initializing it until it
+	 *  becomes FALSE."
+	 */
+	oldvalue = paTrigger->test_value;
+
+	/* XXX really should do something smarter here */
+
+	do
+	{
+	    XSyncValueAdd(&paTrigger->test_value, paTrigger->test_value,
+			  pAlarm->delta, &overflow);
+	} while (!overflow &&
+	      (*paTrigger->CheckTrigger)(paTrigger,
+					paCounter->value));
+
+	new_test_value = paTrigger->test_value;
+	paTrigger->test_value = oldvalue;
+
+	/* "If this update would cause value to fall outside the range
+	 *  for an INT64...no change is made to value (test-value) and
+	 *  the alarm state is changed to Inactive before the event is
+	 *  generated."
+	 */
+	if (overflow)
+	{
+	    new_test_value = oldvalue;
+	    pAlarm->state = XSyncAlarmInactive;
+	}
+    }
+    /*  The AlarmNotify event has to have the "new state of the alarm"
+     *  which we can't be sure of until this point.  However, it has
+     *  to have the "old" trigger test value.  That's the reason for
+     *  all the newvalue/oldvalue shuffling above.  After we send the
+     *  events, give the trigger its new test value.
+     */
+    SyncSendAlarmNotifyEvents(pAlarm);
+    pTrigger->test_value = new_test_value;
+}
+
+
+/*  This function is called when an Await unblocks, either as a result
+ *  of the trigger firing OR the counter being destroyed.
+ *  It goes into pTrigger->TriggerFired AND pTrigger->CounterDestroyed
+ *  (for Await triggers).
+ */
+static void
+SyncAwaitTriggerFired(SyncTrigger *pTrigger)
+{
+    SyncAwait *pAwait = (SyncAwait *)pTrigger;
+    int numwaits;
+    SyncAwaitUnion *pAwaitUnion;
+    SyncAwait **ppAwait;
+    int num_events = 0;
+
+    pAwaitUnion = (SyncAwaitUnion *)pAwait->pHeader;
+    numwaits = pAwaitUnion->header.num_waitconditions;
+    ppAwait = malloc(numwaits * sizeof(SyncAwait *));
+    if (!ppAwait)
+	goto bail;
+
+    pAwait = &(pAwaitUnion+1)->await;
+
+    /* "When a client is unblocked, all the CounterNotify events for
+     *  the Await request are generated contiguously. If count is 0
+     *  there are no more events to follow for this request. If
+     *  count is n, there are at least n more events to follow."
+     *
+     *  Thus, it is best to find all the counters for which events
+     *  need to be sent first, so that an accurate count field can
+     *  be stored in the events.
+     */
+    for ( ; numwaits; numwaits--, pAwait++)
+    {
+	CARD64 diff;
+	Bool overflow, diffgreater, diffequal;
+
+	/* "A CounterNotify event with the destroyed flag set to TRUE is
+	 *  always generated if the counter for one of the triggers is
+	 *  destroyed."
+	 */
+	if (pAwait->trigger.pSync->beingDestroyed)
+	{
+	    ppAwait[num_events++] = pAwait;
+	    continue;
+	}
+	
+	if (SYNC_COUNTER == pAwait->trigger.pSync->type)
+	{
+	    SyncCounter *pCounter = (SyncCounter *) pAwait->trigger.pSync;
+
+	    /* "The difference between the counter and the test value is
+	     *  calculated by subtracting the test value from the value of
+	     *  the counter."
+	     */
+	    XSyncValueSubtract(&diff, pCounter->value,
+			       pAwait->trigger.test_value, &overflow);
+
+	    /* "If the difference lies outside the range for an INT64, an
+	     *  event is not generated."
+	     */
+	    if (overflow)
+		continue;
+	    diffgreater = XSyncValueGreaterThan(diff, pAwait->event_threshold);
+	    diffequal   = XSyncValueEqual(diff, pAwait->event_threshold);
+
+	    /* "If the test-type is PositiveTransition or
+	     *  PositiveComparison, a CounterNotify event is generated if
+	     *  the difference is at least event-threshold. If the test-type
+	     *  is NegativeTransition or NegativeComparison, a CounterNotify
+	     *  event is generated if the difference is at most
+	     *  event-threshold."
+	     */
+
+	    if ( ((pAwait->trigger.test_type == XSyncPositiveComparison ||
+		   pAwait->trigger.test_type == XSyncPositiveTransition)
+		  && (diffgreater || diffequal))
+		 ||
+		 ((pAwait->trigger.test_type == XSyncNegativeComparison ||
+		   pAwait->trigger.test_type == XSyncNegativeTransition)
+		  && (!diffgreater) /* less or equal */
+		 )
+	       )
+	    {
+		ppAwait[num_events++] = pAwait;
+	    }
+	}
+    }
+    if (num_events)
+	SyncSendCounterNotifyEvents(pAwaitUnion->header.client, ppAwait,
+				    num_events);
+    free(ppAwait);
+
+bail:
+    /* unblock the client */
+    AttendClient(pAwaitUnion->header.client);
+    /* delete the await */
+    FreeResource(pAwaitUnion->header.delete_id, RT_NONE);
+}
+
+
+/*  This function should always be used to change a counter's value so that
+ *  any triggers depending on the counter will be checked.
+ */
+void
+SyncChangeCounter(SyncCounter *pCounter, CARD64 newval)
+{
+    SyncTriggerList       *ptl, *pnext;
+    CARD64 oldval;
+
+    oldval = pCounter->value;
+    pCounter->value = newval;
+
+    /* run through triggers to see if any become true */
+    for (ptl = pCounter->sync.pTriglist; ptl; ptl = pnext)
+    {
+	pnext = ptl->next;
+	if ((*ptl->pTrigger->CheckTrigger)(ptl->pTrigger, oldval))
+	    (*ptl->pTrigger->TriggerFired)(ptl->pTrigger);
+    }
+
+    if (IsSystemCounter(pCounter))
+    {
+	SyncComputeBracketValues(pCounter);
+    }
+}
+
+
+/* loosely based on dix/events.c/EventSelectForWindow */
+static Bool
+SyncEventSelectForAlarm(SyncAlarm *pAlarm, ClientPtr client, Bool wantevents)
+{
+    SyncAlarmClientList *pClients;
+
+    if (client == pAlarm->client) /* alarm owner */
+    {
+	pAlarm->events = wantevents;
+	return Success;
+    }
+
+    /* see if the client is already on the list (has events selected) */
+
+    for (pClients = pAlarm->pEventClients; pClients;
+	 pClients = pClients->next)
+    {
+	if (pClients->client == client)
+	{
+	    /* client's presence on the list indicates desire for
+	     * events.  If the client doesn't want events, remove it
+	     * from the list.  If the client does want events, do
+	     * nothing, since it's already got them.
+	     */
+	    if (!wantevents)
+	    {
+		FreeResource(pClients->delete_id, RT_NONE);
+	    }
+	    return Success;
+	}
+    }
+
+    /*  if we get here, this client does not currently have
+     *  events selected on the alarm
+     */
+
+    if (!wantevents)
+	/* client doesn't want events, and we just discovered that it
+	 * doesn't have them, so there's nothing to do.
+	 */
+	return Success;
+
+    /* add new client to pAlarm->pEventClients */
+
+    pClients = malloc(sizeof(SyncAlarmClientList));
+    if (!pClients)
+	return BadAlloc;
+
+    /*  register it as a resource so it will be cleaned up
+     *  if the client dies
+     */
+
+    pClients->delete_id = FakeClientID(client->index);
+
+    /* link it into list after we know all the allocations succeed */
+    pClients->next = pAlarm->pEventClients;
+    pAlarm->pEventClients = pClients;
+    pClients->client = client;
+
+    if (!AddResource(pClients->delete_id, RTAlarmClient, pAlarm))
+	return BadAlloc;
+
+    return Success;
+}
+
+/*
+ * ** SyncChangeAlarmAttributes ** This is used by CreateAlarm and ChangeAlarm
+ */
+static int
+SyncChangeAlarmAttributes(ClientPtr client, SyncAlarm *pAlarm, Mask mask,
+			  CARD32 *values)
+{
+    int		   status;
+    XSyncCounter   counter;
+    Mask	   origmask = mask;
+
+    counter =
+	pAlarm->trigger.pSync ? pAlarm->trigger.pSync->id : None;
+
+    while (mask)
+    {
+	int    index2 = lowbit(mask);
+	mask &= ~index2;
+	switch (index2)
+	{
+	  case XSyncCACounter:
+	    mask &= ~XSyncCACounter;
+	    /* sanity check in SyncInitTrigger */
+	    counter = *values++;
+	    break;
+
+	  case XSyncCAValueType:
+	    mask &= ~XSyncCAValueType;
+	    /* sanity check in SyncInitTrigger */
+	    pAlarm->trigger.value_type = *values++;
+	    break;
+
+	  case XSyncCAValue:
+	    mask &= ~XSyncCAValue;
+	    XSyncIntsToValue(&pAlarm->trigger.wait_value, values[1], values[0]);
+	    values += 2;
+	    break;
+
+	  case XSyncCATestType:
+	    mask &= ~XSyncCATestType;
+	    /* sanity check in SyncInitTrigger */
+	    pAlarm->trigger.test_type = *values++;
+	    break;
+
+	  case XSyncCADelta:
+	    mask &= ~XSyncCADelta;
+	    XSyncIntsToValue(&pAlarm->delta, values[1], values[0]);
+	    values += 2;
+	    break;
+
+	  case XSyncCAEvents:
+	    mask &= ~XSyncCAEvents;
+	    if ((*values != xTrue) && (*values != xFalse))
+	    {
+		client->errorValue = *values;
+		return BadValue;
+	    }
+	    status = SyncEventSelectForAlarm(pAlarm, client,
+					     (Bool)(*values++));
+	    if (status != Success)
+		return status;
+	    break;
+
+	  default:
+	    client->errorValue = mask;
+	    return BadValue;
+	}
+    }
+
+    /* "If the test-type is PositiveComparison or PositiveTransition
+     *  and delta is less than zero, or if the test-type is
+     *  NegativeComparison or NegativeTransition and delta is
+     *  greater than zero, a Match error is generated."
+     */
+    if (origmask & (XSyncCADelta|XSyncCATestType))
+    {
+	CARD64 zero;
+	XSyncIntToValue(&zero, 0);
+	if ((((pAlarm->trigger.test_type == XSyncPositiveComparison) ||
+	      (pAlarm->trigger.test_type == XSyncPositiveTransition))
+	     && XSyncValueLessThan(pAlarm->delta, zero))
+	    ||
+	    (((pAlarm->trigger.test_type == XSyncNegativeComparison) ||
+	      (pAlarm->trigger.test_type == XSyncNegativeTransition))
+	     && XSyncValueGreaterThan(pAlarm->delta, zero))
+	   )
+	{
+	    return BadMatch;
+	}
+    }
+
+    /* postpone this until now, when we're sure nothing else can go wrong */
+    if ((status = SyncInitTrigger(client, &pAlarm->trigger, counter, RTCounter,
+			     origmask & XSyncCAAllTrigger)) != Success)
+	return status;
+
+    /* XXX spec does not really say to do this - needs clarification */
+    pAlarm->state = XSyncAlarmActive;
+    return Success;
+}
+
+static SyncObject *
+SyncCreate(ClientPtr client, XID id, unsigned char type)
+{
+    SyncObject *pSync;
+
+    switch (type) {
+    case SYNC_COUNTER:
+	pSync = malloc(sizeof(SyncCounter));
+	break;
+    case SYNC_FENCE:
+	pSync = (SyncObject*)dixAllocateObjectWithPrivates(SyncFence,
+							   PRIVATE_SYNC_FENCE);
+	break;
+    default:
+	return NULL;
+    }
+
+    if (!pSync)
+	return NULL;
+
+    pSync->client = client;
+    pSync->id = id;
+    pSync->pTriglist = NULL;
+    pSync->beingDestroyed = FALSE;
+    pSync->type = type;
+
+    return pSync;
+}
+
+
+static SyncCounter *
+SyncCreateCounter(ClientPtr client, XSyncCounter id, CARD64 initialvalue)
+{
+    SyncCounter *pCounter;
+
+    if (!(pCounter = (SyncCounter *)SyncCreate(client,
+					       id,
+					       SYNC_COUNTER)))
+	return NULL;
+
+    pCounter->value = initialvalue;
+    pCounter->pSysCounterInfo = NULL;
+
+    if (!AddResource(id, RTCounter, (pointer) pCounter))
+	return NULL;
+
+    return pCounter;
+}
+
+static int FreeCounter(void *, XID);
+
+/*
+ * ***** System Counter utilities
+ */
+
+pointer
+SyncCreateSystemCounter(
+	char *name,
+	CARD64 initial,
+	CARD64 resolution,
+	SyncCounterType counterType,
+	void (*QueryValue)(pointer /* pCounter */,
+	      	           CARD64 * /* pValue_return */),
+	void (*BracketValues)(pointer /* pCounter */,
+	       	              CARD64 * /* pbracket_less */,
+	                      CARD64 * /* pbracket_greater */)
+	)
+{
+    SyncCounter    *pCounter;
+
+    SysCounterList = realloc(SysCounterList,
+			    (SyncNumSystemCounters+1)*sizeof(SyncCounter *));
+    if (!SysCounterList)
+	return NULL;
+
+    /* this function may be called before SYNC has been initialized, so we
+     * have to make sure RTCounter is created.
+     */
+    if (RTCounter == 0)
+    {
+	RTCounter = CreateNewResourceType(FreeCounter, "SyncCounter");
+	if (RTCounter == 0)
+	{
+	    return NULL;
+	}
+    }
+
+    pCounter = SyncCreateCounter(NULL, FakeClientID(0), initial);
+
+    if (pCounter)
+    {
+	SysCounterInfo *psci;
+
+	psci = malloc(sizeof(SysCounterInfo));
+	if (!psci)
+	{
+	    FreeResource(pCounter->sync.id, RT_NONE);
+	    return pCounter;
+	}
+	pCounter->pSysCounterInfo = psci;
+	psci->name = name;
+	psci->resolution = resolution;
+	psci->counterType = counterType;
+	psci->QueryValue = QueryValue;
+	psci->BracketValues = BracketValues;
+	XSyncMaxValue(&psci->bracket_greater);
+	XSyncMinValue(&psci->bracket_less);
+	SysCounterList[SyncNumSystemCounters++] = pCounter;
+    }
+    return pCounter;
+}
+
+void
+SyncDestroySystemCounter(pointer pSysCounter)
+{
+    SyncCounter *pCounter = (SyncCounter *)pSysCounter;
+    FreeResource(pCounter->sync.id, RT_NONE);
+}
+
+static void
+SyncComputeBracketValues(SyncCounter *pCounter)
+{
+    SyncTriggerList *pCur;
+    SyncTrigger *pTrigger;
+    SysCounterInfo *psci;
+    CARD64 *pnewgtval = NULL;
+    CARD64 *pnewltval = NULL;
+    SyncCounterType ct;
+
+    if (!pCounter)
+	return;
+
+    psci = pCounter->pSysCounterInfo;
+    ct = pCounter->pSysCounterInfo->counterType;
+    if (ct == XSyncCounterNeverChanges)
+	return;
+
+    XSyncMaxValue(&psci->bracket_greater);
+    XSyncMinValue(&psci->bracket_less);
+
+    for (pCur = pCounter->sync.pTriglist; pCur; pCur = pCur->next)
+    {
+	pTrigger = pCur->pTrigger;
+	
+        if (pTrigger->test_type == XSyncPositiveComparison &&
+	    ct != XSyncCounterNeverIncreases)
+	{
+	    if (XSyncValueLessThan(pCounter->value, pTrigger->test_value) &&
+		XSyncValueLessThan(pTrigger->test_value,
+				   psci->bracket_greater))
+	    {
+		psci->bracket_greater = pTrigger->test_value;
+		pnewgtval = &psci->bracket_greater;
+	    }
+	}
+	else if (pTrigger->test_type == XSyncNegativeComparison &&
+		 ct != XSyncCounterNeverDecreases)
+	{
+	    if (XSyncValueGreaterThan(pCounter->value, pTrigger->test_value) &&
+		XSyncValueGreaterThan(pTrigger->test_value,
+				      psci->bracket_less))
+	    {
+		psci->bracket_less = pTrigger->test_value;
+		pnewltval = &psci->bracket_less;
+	    }
+	}
+	else if (pTrigger->test_type == XSyncNegativeTransition &&
+		   ct != XSyncCounterNeverIncreases)
+	{
+	    if (XSyncValueGreaterThan(pCounter->value, pTrigger->test_value) &&
+		XSyncValueGreaterThan(pTrigger->test_value, psci->bracket_less))
+	    {
+		psci->bracket_less = pTrigger->test_value;
+		pnewltval = &psci->bracket_less;
+	    } else if (XSyncValueEqual(pCounter->value, pTrigger->test_value) &&
+		       XSyncValueLessThan(pTrigger->test_value,
+					  psci->bracket_greater))
+	    {
+	        /*
+		 * The value is exactly equal to our threshold.  We want one
+		 * more event in the positive direction to ensure we pick up
+		 * when the value *exceeds* this threshold.
+		 */
+	        psci->bracket_greater = pTrigger->test_value;
+		pnewgtval = &psci->bracket_greater;
+	    }
+	}
+        else if (pTrigger->test_type == XSyncPositiveTransition &&
+		  ct != XSyncCounterNeverDecreases)
+	{
+	    if (XSyncValueLessThan(pCounter->value, pTrigger->test_value) &&
+		XSyncValueLessThan(pTrigger->test_value, psci->bracket_greater))
+	    {
+		psci->bracket_greater = pTrigger->test_value;
+		pnewgtval = &psci->bracket_greater;
+	    } else if (XSyncValueEqual(pCounter->value, pTrigger->test_value) &&
+		       XSyncValueGreaterThan(pTrigger->test_value,
+					     psci->bracket_less))
+	    {
+	        /*
+		 * The value is exactly equal to our threshold.  We want one
+		 * more event in the negative direction to ensure we pick up
+		 * when the value is less than this threshold.
+		 */
+	        psci->bracket_less = pTrigger->test_value;
+		pnewltval = &psci->bracket_less;
+	    }
+	}
+    } /* end for each trigger */
+
+    if (pnewgtval || pnewltval)
+    {
+	(*psci->BracketValues)((pointer)pCounter, pnewltval, pnewgtval);
+    }
+}
+
+/*
+ * *****  Resource delete functions
+ */
+
+/* ARGSUSED */
+static int
+FreeAlarm(void *addr, XID id)
+{
+    SyncAlarm      *pAlarm = (SyncAlarm *) addr;
+
+    pAlarm->state = XSyncAlarmDestroyed;
+
+    SyncSendAlarmNotifyEvents(pAlarm);
+
+    /* delete event selections */
+
+    while (pAlarm->pEventClients)
+	FreeResource(pAlarm->pEventClients->delete_id, RT_NONE);
+
+    SyncDeleteTriggerFromSyncObject(&pAlarm->trigger);
+
+    free(pAlarm);
+    return Success;
+}
+
+
+/*
+ * ** Cleanup after the destruction of a Counter
+ */
+/* ARGSUSED */
+static int
+FreeCounter(void *env, XID id)
+{
+    SyncCounter     *pCounter = (SyncCounter *) env;
+    SyncTriggerList *ptl, *pnext;
+
+    pCounter->sync.beingDestroyed = TRUE;
+    /* tell all the counter's triggers that the counter has been destroyed */
+    for (ptl = pCounter->sync.pTriglist; ptl; ptl = pnext)
+    {
+	(*ptl->pTrigger->CounterDestroyed)(ptl->pTrigger);
+	pnext = ptl->next;
+	free(ptl); /* destroy the trigger list as we go */
+    }
+    if (IsSystemCounter(pCounter))
+    {
+	int i, found = 0;
+
+	free(pCounter->pSysCounterInfo);
+
+	/* find the counter in the list of system counters and remove it */
+
+	if (SysCounterList)
+	{
+	    for (i = 0; i < SyncNumSystemCounters; i++)
+	    {
+		if (SysCounterList[i] == pCounter)
+		{
+		    found = i;
+		    break;
+		}
+	    }
+	    if (found < (SyncNumSystemCounters-1))
+	    {
+		for (i = found; i < SyncNumSystemCounters-1; i++)
+		{
+		    SysCounterList[i] = SysCounterList[i+1];
+		}
+	    }
+	}
+	SyncNumSystemCounters--;
+    }
+    free(pCounter);
+    return Success;
+}
+
+/*
+ * ** Cleanup after Await
+ */
+/* ARGSUSED */
+static int
+FreeAwait(void *addr, XID id)
+{
+    SyncAwaitUnion *pAwaitUnion = (SyncAwaitUnion *) addr;
+    SyncAwait *pAwait;
+    int numwaits;
+
+    pAwait = &(pAwaitUnion+1)->await; /* first await on list */
+
+    /* remove triggers from counters */
+
+    for (numwaits = pAwaitUnion->header.num_waitconditions; numwaits;
+	 numwaits--, pAwait++)
+    {
+	/* If the counter is being destroyed, FreeCounter will delete
+	 * the trigger list itself, so don't do it here.
+	 */
+	SyncObject *pSync = pAwait->trigger.pSync;
+	if (pSync && !pSync->beingDestroyed)
+	    SyncDeleteTriggerFromSyncObject(&pAwait->trigger);
+    }
+    free(pAwaitUnion);
+    return Success;
+}
+
+#ifdef _MSC_VER
+#pragma warning(disable:4715) /* Not all control paths return a value */
+#endif
+
+/* loosely based on dix/events.c/OtherClientGone */
+static int
+FreeAlarmClient(void *value, XID id)
+{
+    SyncAlarm *pAlarm = (SyncAlarm *)value;
+    SyncAlarmClientList *pCur, *pPrev;
+
+    for (pPrev = NULL, pCur = pAlarm->pEventClients;
+	 pCur;
+	 pPrev = pCur, pCur = pCur->next)
+    {
+	if (pCur->delete_id == id)
+	{
+	    if (pPrev)
+		pPrev->next = pCur->next;
+	    else
+		pAlarm->pEventClients = pCur->next;
+	    free(pCur);
+	    return Success;
+	}
+    }
+    FatalError("alarm client not on event list");
+    /*NOTREACHED*/
+}
+
+
+/*
+ * *****  Proc functions
+ */
+
+
+/*
+ * ** Initialize the extension
+ */
+static int
+ProcSyncInitialize(ClientPtr client)
+{
+    xSyncInitializeReply  rep;
+    REQUEST_SIZE_MATCH(xSyncInitializeReq);
+
+    memset(&rep, 0, sizeof(xSyncInitializeReply));
+    rep.type = X_Reply;
+    rep.sequenceNumber = client->sequence;
+    rep.majorVersion = SERVER_SYNC_MAJOR_VERSION;
+    rep.minorVersion = SERVER_SYNC_MINOR_VERSION;
+    rep.length = 0;
+
+    if (client->swapped)
+    {
+	swaps(&rep.sequenceNumber);
+    }
+    WriteToClient(client, sizeof(rep), (char *) &rep);
+    return Success;
+}
+
+/*
+ * ** Get list of system counters available through the extension
+ */
+static int
+ProcSyncListSystemCounters(ClientPtr client)
+{
+    xSyncListSystemCountersReply  rep;
+    int i, len;
+    xSyncSystemCounter *list = NULL, *walklist = NULL;
+
+    REQUEST_SIZE_MATCH(xSyncListSystemCountersReq);
+
+    rep.type = X_Reply;
+    rep.sequenceNumber = client->sequence;
+    rep.nCounters = SyncNumSystemCounters;
+
+    for (i = len = 0; i < SyncNumSystemCounters; i++)
+    {
+	char *name = SysCounterList[i]->pSysCounterInfo->name;
+	/* pad to 4 byte boundary */
+	len += pad_to_int32(sz_xSyncSystemCounter + strlen(name));
+    }
+
+    if (len)
+    {
+	walklist = list = malloc(len);
+	if (!list)
+	    return BadAlloc;
+    }
+
+    rep.length = bytes_to_int32(len);
+
+    if (client->swapped)
+    {
+	swaps(&rep.sequenceNumber);
+	swapl(&rep.length);
+	swapl(&rep.nCounters);
+    }
+
+    for (i = 0; i < SyncNumSystemCounters; i++)
+    {
+	int namelen;
+	char *pname_in_reply;
+	SysCounterInfo *psci = SysCounterList[i]->pSysCounterInfo;
+
+	walklist->counter = SysCounterList[i]->sync.id;
+	walklist->resolution_hi = XSyncValueHigh32(psci->resolution);
+	walklist->resolution_lo = XSyncValueLow32(psci->resolution);
+	namelen = strlen(psci->name);
+	walklist->name_length = namelen;
+
+	if (client->swapped)
+	{
+	    swapl(&walklist->counter);
+	    swapl(&walklist->resolution_hi);
+	    swapl(&walklist->resolution_lo);
+	    swaps(&walklist->name_length);
+	}
+
+	pname_in_reply = ((char *)walklist) + sz_xSyncSystemCounter;
+	strncpy(pname_in_reply, psci->name, namelen);
+	walklist = (xSyncSystemCounter *) (((char *)walklist) +
+				pad_to_int32(sz_xSyncSystemCounter + namelen));
+    }
+
+    WriteToClient(client, sizeof(rep), (char *) &rep);
+    if (len)
+    {
+	WriteToClient(client, len, (char *) list);
+	free(list);
+    }
+
+    return Success;
+}
+
+/*
+ * ** Set client Priority
+ */
+static int
+ProcSyncSetPriority(ClientPtr client)
+{
+    REQUEST(xSyncSetPriorityReq);
+    ClientPtr priorityclient;
+    int rc;
+
+    REQUEST_SIZE_MATCH(xSyncSetPriorityReq);
+
+    if (stuff->id == None)
+	priorityclient = client;
+    else {
+	rc = dixLookupClient(&priorityclient, stuff->id, client,
+			     DixSetAttrAccess);
+	if (rc != Success)
+	    return rc;
+    }
+
+    if (priorityclient->priority != stuff->priority)
+    {
+	priorityclient->priority = stuff->priority;
+
+	/*  The following will force the server back into WaitForSomething
+	 *  so that the change in this client's priority is immediately
+	 *  reflected.
+	 */
+	isItTimeToYield = TRUE;
+	dispatchException |= DE_PRIORITYCHANGE;
+    }
+    return Success;
+}
+
+/*
+ * ** Get client Priority
+ */
+static int
+ProcSyncGetPriority(ClientPtr client)
+{
+    REQUEST(xSyncGetPriorityReq);
+    xSyncGetPriorityReply rep;
+    ClientPtr priorityclient;
+    int rc;
+
+    REQUEST_SIZE_MATCH(xSyncGetPriorityReq);
+
+    if (stuff->id == None)
+	priorityclient = client;
+    else {
+	rc = dixLookupClient(&priorityclient, stuff->id, client,
+			     DixGetAttrAccess);
+	if (rc != Success)
+	    return rc;
+    }
+
+    rep.type = X_Reply;
+    rep.length = 0;
+    rep.sequenceNumber = client->sequence;
+    rep.priority = priorityclient->priority;
+
+    if (client->swapped)
+    {
+	swaps(&rep.sequenceNumber);
+	swapl(&rep.priority);
+    }
+
+    WriteToClient(client, sizeof(xSyncGetPriorityReply), (char *) &rep);
+
+    return Success;
+}
+
+/*
+ * ** Create a new counter
+ */
+static int
+ProcSyncCreateCounter(ClientPtr client)
+{
+    REQUEST(xSyncCreateCounterReq);
+    CARD64          initial;
+
+    REQUEST_SIZE_MATCH(xSyncCreateCounterReq);
+
+    LEGAL_NEW_RESOURCE(stuff->cid, client);
+
+    XSyncIntsToValue(&initial, stuff->initial_value_lo, stuff->initial_value_hi);
+    if (!SyncCreateCounter(client, stuff->cid, initial))
+	return BadAlloc;
+
+    return Success;
+}
+
+/*
+ * ** Set Counter value
+ */
+static int
+ProcSyncSetCounter(ClientPtr client)
+{
+    REQUEST(xSyncSetCounterReq);
+    SyncCounter    *pCounter;
+    CARD64	   newvalue;
+    int	rc;
+
+    REQUEST_SIZE_MATCH(xSyncSetCounterReq);
+
+    rc = dixLookupResourceByType((pointer *)&pCounter, stuff->cid, RTCounter,
+				 client, DixWriteAccess);
+    if (rc != Success)
+	return rc;
+
+    if (IsSystemCounter(pCounter))
+    {
+	client->errorValue = stuff->cid;
+	return BadAccess;
+    }
+
+    XSyncIntsToValue(&newvalue, stuff->value_lo, stuff->value_hi);
+    SyncChangeCounter(pCounter, newvalue);
+    return Success;
+}
+
+/*
+ * ** Change Counter value
+ */
+static int
+ProcSyncChangeCounter(ClientPtr client)
+{
+    REQUEST(xSyncChangeCounterReq);
+    SyncCounter    *pCounter;
+    CARD64          newvalue;
+    Bool	    overflow;
+    int	rc;
+
+    REQUEST_SIZE_MATCH(xSyncChangeCounterReq);
+
+    rc = dixLookupResourceByType((pointer *)&pCounter, stuff->cid, RTCounter,
+				 client, DixWriteAccess);
+    if (rc != Success)
+	return rc;
+
+    if (IsSystemCounter(pCounter))
+    {
+	client->errorValue = stuff->cid;
+	return BadAccess;
+    }
+
+    XSyncIntsToValue(&newvalue, stuff->value_lo, stuff->value_hi);
+    XSyncValueAdd(&newvalue, pCounter->value, newvalue, &overflow);
+    if (overflow)
+    {
+	/* XXX 64 bit value can't fit in 32 bits; do the best we can */
+	client->errorValue = stuff->value_hi;
+	return BadValue;
+    }
+    SyncChangeCounter(pCounter, newvalue);
+    return Success;
+}
+
+/*
+ * ** Destroy a counter
+ */
+static int
+ProcSyncDestroyCounter(ClientPtr client)
+{
+    REQUEST(xSyncDestroyCounterReq);
+    SyncCounter    *pCounter;
+    int rc;
+
+    REQUEST_SIZE_MATCH(xSyncDestroyCounterReq);
+
+    rc = dixLookupResourceByType((pointer *)&pCounter, stuff->counter, RTCounter,
+				 client, DixDestroyAccess);
+    if (rc != Success)
+	return rc;
+
+    if (IsSystemCounter(pCounter))
+    {
+	client->errorValue = stuff->counter;
+	return BadAccess;
+    }
+    FreeResource(pCounter->sync.id, RT_NONE);
+    return Success;
+}
+
+static SyncAwaitUnion*
+SyncAwaitPrologue(ClientPtr client, int items)
+{
+    SyncAwaitUnion *pAwaitUnion;
+
+    /*  all the memory for the entire await list is allocated
+     *  here in one chunk
+     */
+    pAwaitUnion = malloc((items+1) * sizeof(SyncAwaitUnion));
+    if (!pAwaitUnion)
+	return NULL;
+
+    /* first item is the header, remainder are real wait conditions */
+
+    pAwaitUnion->header.delete_id = FakeClientID(client->index);
+    pAwaitUnion->header.client = client;
+    pAwaitUnion->header.num_waitconditions = 0;
+
+    if (!AddResource(pAwaitUnion->header.delete_id, RTAwait, pAwaitUnion))
+	return NULL;
+
+    return pAwaitUnion;
+}
+
+static void
+SyncAwaitEpilogue(ClientPtr client, int items, SyncAwaitUnion *pAwaitUnion)
+{
+    SyncAwait *pAwait;
+    int i;
+
+    IgnoreClient(client);
+
+    /* see if any of the triggers are already true */
+
+    pAwait = &(pAwaitUnion+1)->await; /* skip over header */
+    for (i = 0; i < items; i++, pAwait++)
+    {
+	CARD64 value;
+
+	/*  don't have to worry about NULL counters because the request
+	 *  errors before we get here out if they occur
+	 */
+	switch (pAwait->trigger.pSync->type) {
+	case SYNC_COUNTER:
+	    value = ((SyncCounter *)pAwait->trigger.pSync)->value;
+	    break;
+	default:
+	    XSyncIntToValue(&value, 0);
+	}
+
+	if ((*pAwait->trigger.CheckTrigger)(&pAwait->trigger, value))
+	{
+	    (*pAwait->trigger.TriggerFired)(&pAwait->trigger);
+	    break; /* once is enough */
+	}
+    }
+}
+
+/*
+ * ** Await
+ */
+static int
+ProcSyncAwait(ClientPtr client)
+{
+    REQUEST(xSyncAwaitReq);
+    int             len, items;
+    int             i;
+    xSyncWaitCondition *pProtocolWaitConds;
+    SyncAwaitUnion *pAwaitUnion;
+    SyncAwait	   *pAwait;
+    int		   status;
+
+    REQUEST_AT_LEAST_SIZE(xSyncAwaitReq);
+
+    len = client->req_len << 2;
+    len -= sz_xSyncAwaitReq;
+    items = len / sz_xSyncWaitCondition;
+
+    if (items * sz_xSyncWaitCondition != len)
+    {
+	return BadLength;
+    }
+    if (items == 0)
+    {
+	client->errorValue = items; /* XXX protocol change */
+	return BadValue;
+    }
+
+    if (!(pAwaitUnion = SyncAwaitPrologue(client, items)))
+	return BadAlloc;
+
+    /* don't need to do any more memory allocation for this request! */
+
+    pProtocolWaitConds = (xSyncWaitCondition *) & stuff[1];
+
+    pAwait = &(pAwaitUnion+1)->await; /* skip over header */
+    for (i = 0; i < items; i++, pProtocolWaitConds++, pAwait++)
+    {
+	if (pProtocolWaitConds->counter == None) /* XXX protocol change */
+	{
+	    /*  this should take care of removing any triggers created by
+	     *  this request that have already been registered on sync objects
+	     */
+	    FreeResource(pAwaitUnion->header.delete_id, RT_NONE);
+	    client->errorValue = pProtocolWaitConds->counter;
+	    return SyncErrorBase + XSyncBadCounter;
+	}
+
+	/* sanity checks are in SyncInitTrigger */
+	pAwait->trigger.pSync = NULL;
+	pAwait->trigger.value_type = pProtocolWaitConds->value_type;
+	XSyncIntsToValue(&pAwait->trigger.wait_value,
+			 pProtocolWaitConds->wait_value_lo,
+			 pProtocolWaitConds->wait_value_hi);
+	pAwait->trigger.test_type = pProtocolWaitConds->test_type;
+
+	status = SyncInitTrigger(client, &pAwait->trigger,
+				 pProtocolWaitConds->counter, RTCounter,
+				 XSyncCAAllTrigger);
+	if (status != Success)
+	{
+	    /*  this should take care of removing any triggers created by
+	     *  this request that have already been registered on sync objects
+	     */
+	    FreeResource(pAwaitUnion->header.delete_id, RT_NONE);
+	    return status;
+	}
+	/* this is not a mistake -- same function works for both cases */
+	pAwait->trigger.TriggerFired = SyncAwaitTriggerFired;
+	pAwait->trigger.CounterDestroyed = SyncAwaitTriggerFired;
+	XSyncIntsToValue(&pAwait->event_threshold,
+			 pProtocolWaitConds->event_threshold_lo,
+			 pProtocolWaitConds->event_threshold_hi);
+	pAwait->pHeader = &pAwaitUnion->header;
+	pAwaitUnion->header.num_waitconditions++;
+    }
+
+    SyncAwaitEpilogue(client, items, pAwaitUnion);
+
+    return Success;
+}
+
+
+/*
+ * ** Query a counter
+ */
+static int
+ProcSyncQueryCounter(ClientPtr client)
+{
+    REQUEST(xSyncQueryCounterReq);
+    xSyncQueryCounterReply rep;
+    SyncCounter    *pCounter;
+    int rc;
+
+    REQUEST_SIZE_MATCH(xSyncQueryCounterReq);
+
+    rc = dixLookupResourceByType((pointer *)&pCounter, stuff->counter,
+				 RTCounter, client, DixReadAccess);
+    if (rc != Success)
+	return rc;
+
+    rep.type = X_Reply;
+    rep.length = 0;
+    rep.sequenceNumber = client->sequence;
+
+    /* if system counter, ask it what the current value is */
+
+    if (IsSystemCounter(pCounter))
+    {
+	(*pCounter->pSysCounterInfo->QueryValue) ((pointer) pCounter,
+						  &pCounter->value);
+    }
+
+    rep.value_hi = XSyncValueHigh32(pCounter->value);
+    rep.value_lo = XSyncValueLow32(pCounter->value);
+    if (client->swapped)
+    {
+	swaps(&rep.sequenceNumber);
+	swapl(&rep.length);
+	swapl(&rep.value_hi);
+	swapl(&rep.value_lo);
+    }
+    WriteToClient(client, sizeof(xSyncQueryCounterReply), (char *) &rep);
+    return Success;
+}
+
+
+/*
+ * ** Create Alarm
+ */
+static int
+ProcSyncCreateAlarm(ClientPtr client)
+{
+    REQUEST(xSyncCreateAlarmReq);
+    SyncAlarm      *pAlarm;
+    int             status;
+    unsigned long   len, vmask;
+    SyncTrigger	    *pTrigger;
+
+    REQUEST_AT_LEAST_SIZE(xSyncCreateAlarmReq);
+
+    LEGAL_NEW_RESOURCE(stuff->id, client);
+
+    vmask = stuff->valueMask;
+    len = client->req_len - bytes_to_int32(sizeof(xSyncCreateAlarmReq));
+    /* the "extra" call to Ones accounts for the presence of 64 bit values */
+    if (len != (Ones(vmask) + Ones(vmask & (XSyncCAValue|XSyncCADelta))))
+	return BadLength;
+
+    if (!(pAlarm = malloc(sizeof(SyncAlarm))))
+    {
+	return BadAlloc;
+    }
+
+    /* set up defaults */
+
+    pTrigger = &pAlarm->trigger;
+    pTrigger->pSync = NULL;
+    pTrigger->value_type = XSyncAbsolute;
+    XSyncIntToValue(&pTrigger->wait_value, 0L);
+    pTrigger->test_type = XSyncPositiveComparison;
+    pTrigger->TriggerFired = SyncAlarmTriggerFired;
+    pTrigger->CounterDestroyed = SyncAlarmCounterDestroyed;
+    status = SyncInitTrigger(client, pTrigger, None, RTCounter,
+			     XSyncCAAllTrigger);
+    if (status != Success)
+    {
+	free(pAlarm);
+	return status;
+    }
+
+    pAlarm->client = client;
+    pAlarm->alarm_id = stuff->id;
+    XSyncIntToValue(&pAlarm->delta, 1L);
+    pAlarm->events = TRUE;
+    pAlarm->state = XSyncAlarmInactive;
+    pAlarm->pEventClients = NULL;
+    status = SyncChangeAlarmAttributes(client, pAlarm, vmask,
+				       (CARD32 *)&stuff[1]);
+    if (status != Success)
+    {
+	free(pAlarm);
+	return status;
+    }
+
+    if (!AddResource(stuff->id, RTAlarm, pAlarm))
+	return BadAlloc;
+
+    /*  see if alarm already triggered.  NULL counter will not trigger
+     *  in CreateAlarm and sets alarm state to Inactive.
+     */
+
+    if (!pTrigger->pSync)
+    {
+	pAlarm->state = XSyncAlarmInactive; /* XXX protocol change */
+    }
+    else
+    {
+	SyncCounter *pCounter;
+
+	if (!SyncCheckWarnIsCounter(pTrigger->pSync,
+				    WARN_INVALID_COUNTER_ALARM))
+	{
+	    FreeResource(stuff->id, RT_NONE);
+	    return BadAlloc;
+	}
+
+	pCounter = (SyncCounter *)pTrigger->pSync;
+
+	if ((*pTrigger->CheckTrigger)(pTrigger, pCounter->value))
+	    (*pTrigger->TriggerFired)(pTrigger);
+    }
+
+    return Success;
+}
+
+/*
+ * ** Change Alarm
+ */
+static int
+ProcSyncChangeAlarm(ClientPtr client)
+{
+    REQUEST(xSyncChangeAlarmReq);
+    SyncAlarm   *pAlarm;
+    SyncCounter *pCounter = NULL;
+    long        vmask;
+    int         len, status;
+
+    REQUEST_AT_LEAST_SIZE(xSyncChangeAlarmReq);
+
+    status = dixLookupResourceByType((pointer *)&pAlarm, stuff->alarm, RTAlarm,
+				     client, DixWriteAccess);
+    if (status != Success)
+	return status;
+
+    vmask = stuff->valueMask;
+    len = client->req_len - bytes_to_int32(sizeof(xSyncChangeAlarmReq));
+    /* the "extra" call to Ones accounts for the presence of 64 bit values */
+    if (len != (Ones(vmask) + Ones(vmask & (XSyncCAValue|XSyncCADelta))))
+	return BadLength;
+
+    if ((status = SyncChangeAlarmAttributes(client, pAlarm, vmask,
+					    (CARD32 *)&stuff[1])) != Success)
+	return status;
+
+    if (SyncCheckWarnIsCounter(pAlarm->trigger.pSync,
+			       WARN_INVALID_COUNTER_ALARM))
+	pCounter = (SyncCounter *)pAlarm->trigger.pSync;
+
+    /*  see if alarm already triggered.  NULL counter WILL trigger
+     *  in ChangeAlarm.
+     */
+
+    if (!pCounter ||
+	(*pAlarm->trigger.CheckTrigger)(&pAlarm->trigger, pCounter->value))
+    {
+	(*pAlarm->trigger.TriggerFired)(&pAlarm->trigger);
+    }
+    return Success;
+}
+
+static int
+ProcSyncQueryAlarm(ClientPtr client)
+{
+    REQUEST(xSyncQueryAlarmReq);
+    SyncAlarm      *pAlarm;
+    xSyncQueryAlarmReply rep;
+    SyncTrigger    *pTrigger;
+    int rc;
+
+    REQUEST_SIZE_MATCH(xSyncQueryAlarmReq);
+
+    rc = dixLookupResourceByType((pointer *)&pAlarm, stuff->alarm, RTAlarm,
+				 client, DixReadAccess);
+    if (rc != Success)
+	return rc;
+
+    rep.type = X_Reply;
+    rep.length = bytes_to_int32(sizeof(xSyncQueryAlarmReply) - sizeof(xGenericReply));
+    rep.sequenceNumber = client->sequence;
+
+    pTrigger = &pAlarm->trigger;
+    rep.counter = (pTrigger->pSync) ? pTrigger->pSync->id : None;
+
+#if 0 /* XXX unclear what to do, depends on whether relative value-types
+       * are "consumed" immediately and are considered absolute from then
+       * on.
+       */
+    rep.value_type = pTrigger->value_type;
+    rep.wait_value_hi = XSyncValueHigh32(pTrigger->wait_value);
+    rep.wait_value_lo = XSyncValueLow32(pTrigger->wait_value);
+#else
+    rep.value_type = XSyncAbsolute;
+    rep.wait_value_hi = XSyncValueHigh32(pTrigger->test_value);
+    rep.wait_value_lo = XSyncValueLow32(pTrigger->test_value);
+#endif
+
+    rep.test_type = pTrigger->test_type;
+    rep.delta_hi = XSyncValueHigh32(pAlarm->delta);
+    rep.delta_lo = XSyncValueLow32(pAlarm->delta);
+    rep.events = pAlarm->events;
+    rep.state = pAlarm->state;
+
+    if (client->swapped)
+    {
+	swaps(&rep.sequenceNumber);
+	swapl(&rep.length);
+	swapl(&rep.counter);
+	swapl(&rep.wait_value_hi);
+	swapl(&rep.wait_value_lo);
+	swapl(&rep.test_type);
+	swapl(&rep.delta_hi);
+	swapl(&rep.delta_lo);
+    }
+
+    WriteToClient(client, sizeof(xSyncQueryAlarmReply), (char *) &rep);
+    return Success;
+}
+
+static int
+ProcSyncDestroyAlarm(ClientPtr client)
+{
+    SyncAlarm *pAlarm;
+    int rc;
+    REQUEST(xSyncDestroyAlarmReq);
+
+    REQUEST_SIZE_MATCH(xSyncDestroyAlarmReq);
+
+    rc = dixLookupResourceByType((pointer *)&pAlarm, stuff->alarm, RTAlarm,
+				 client, DixDestroyAccess);
+    if (rc != Success)
+	return rc;
+
+    FreeResource(stuff->alarm, RT_NONE);
+    return Success;
+}
+
+static int
+ProcSyncCreateFence(ClientPtr client)
+{
+    REQUEST(xSyncCreateFenceReq);
+    DrawablePtr pDraw;
+    SyncFence *pFence;
+    int rc;
+
+    REQUEST_SIZE_MATCH(xSyncCreateFenceReq);
+
+    rc = dixLookupDrawable(&pDraw, stuff->d, client, M_ANY, DixGetAttrAccess);
+    if (rc != Success)
+	return rc;
+
+    LEGAL_NEW_RESOURCE(stuff->fid, client);
+
+    if (!(pFence = (SyncFence *)SyncCreate(client,
+					   stuff->fid,
+					   SYNC_FENCE)))
+	return BadAlloc;
+
+    miSyncInitFence(pDraw->pScreen, pFence, stuff->initially_triggered);
+
+    if (!AddResource(stuff->fid, RTFence, (pointer) pFence))
+	return BadAlloc;
+
+    return client->noClientException;
+}
+
+static int
+FreeFence(void *obj, XID id)
+{
+    SyncFence *pFence = (SyncFence *) obj;
+
+    miSyncDestroyFence(pFence);
+
+    return Success;
+}
+
+int SyncVerifyFence(SyncFence **ppSyncFence, XID fid,
+		    ClientPtr client, Mask mode)
+{
+    int rc = dixLookupResourceByType((pointer *)ppSyncFence, fid, RTFence,
+				     client, mode);
+
+    if (rc != Success)
+	client->errorValue = fid;
+
+    return rc;
+}
+
+static int
+ProcSyncTriggerFence(ClientPtr client)
+{
+    REQUEST(xSyncTriggerFenceReq);
+    SyncFence *pFence;
+    int rc;
+
+    REQUEST_SIZE_MATCH(xSyncTriggerFenceReq);
+
+    rc = dixLookupResourceByType((pointer *)&pFence, stuff->fid, RTFence,
+				 client, DixWriteAccess);
+    if (rc != Success)
+	return rc;
+
+    miSyncTriggerFence(pFence);
+
+    return client->noClientException;
+}
+
+static int
+ProcSyncResetFence(ClientPtr client)
+{
+    REQUEST(xSyncResetFenceReq);
+    SyncFence *pFence;
+    int rc;
+
+    REQUEST_SIZE_MATCH(xSyncResetFenceReq);
+
+    rc = dixLookupResourceByType((pointer *)&pFence, stuff->fid, RTFence,
+				 client, DixWriteAccess);
+    if (rc != Success)
+	return rc;
+
+    if (pFence->funcs.CheckTriggered(pFence) != TRUE)
+	return BadMatch;
+
+    pFence->funcs.Reset(pFence);
+
+    return client->noClientException;
+}
+
+static int
+ProcSyncDestroyFence(ClientPtr client)
+{
+    REQUEST(xSyncDestroyFenceReq);
+    SyncFence *pFence;
+    int rc;
+
+    REQUEST_SIZE_MATCH(xSyncDestroyFenceReq);
+
+    rc = dixLookupResourceByType((pointer *)&pFence, stuff->fid, RTFence,
+				 client, DixDestroyAccess);
+    if (rc != Success)
+	return rc;
+
+    FreeResource(stuff->fid, RT_NONE);
+    return client->noClientException;
+}
+
+static int
+ProcSyncQueryFence(ClientPtr client)
+{
+    REQUEST(xSyncQueryFenceReq);
+    xSyncQueryFenceReply rep;
+    SyncFence *pFence;
+    int rc;
+
+    REQUEST_SIZE_MATCH(xSyncQueryFenceReq);
+
+    rc = dixLookupResourceByType((pointer *)&pFence, stuff->fid,
+				 RTFence, client, DixReadAccess);
+    if (rc != Success)
+	return rc;
+
+    rep.type = X_Reply;
+    rep.length = 0;
+    rep.sequenceNumber = client->sequence;
+
+    rep.triggered = pFence->funcs.CheckTriggered(pFence);
+
+    if (client->swapped)
+    {
+	swaps(&rep.sequenceNumber);
+	swapl(&rep.length);
+    }
+
+    WriteToClient(client, sizeof(xSyncQueryFenceReply), (char *) &rep);
+    return client->noClientException;
+}
+
+static int
+ProcSyncAwaitFence(ClientPtr client)
+{
+    REQUEST(xSyncAwaitFenceReq);
+    SyncAwaitUnion *pAwaitUnion;
+    SyncAwait *pAwait;
+    /* Use CARD32 rather than XSyncFence because XIDs are hard-coded to
+     * CARD32 in protocol definitions */
+    CARD32 *pProtocolFences;
+    int status;
+    int len;
+    int items;
+    int i;
+
+    REQUEST_AT_LEAST_SIZE(xSyncAwaitFenceReq);
+
+    len = client->req_len << 2;
+    len -= sz_xSyncAwaitFenceReq;
+    items = len / sizeof(CARD32);
+
+    if (items * sizeof(CARD32) != len)
+    {
+	return BadLength;
+    }
+    if (items == 0)
+    {
+	client->errorValue = items;
+	return BadValue;
+    }
+
+    if (!(pAwaitUnion = SyncAwaitPrologue(client, items)))
+	return BadAlloc;
+
+    /* don't need to do any more memory allocation for this request! */
+
+    pProtocolFences = (CARD32 *) & stuff[1];
+
+    pAwait = &(pAwaitUnion+1)->await; /* skip over header */
+    for (i = 0; i < items; i++, pProtocolFences++, pAwait++)
+    {
+	if (*pProtocolFences == None)
+	{
+	    /*  this should take care of removing any triggers created by
+	     *  this request that have already been registered on sync objects
+	     */
+	    FreeResource(pAwaitUnion->header.delete_id, RT_NONE);
+	    client->errorValue = *pProtocolFences;
+	    return SyncErrorBase + XSyncBadFence;
+	}
+
+	pAwait->trigger.pSync = NULL;
+	/* Provide acceptable values for these unused fields to
+	 * satisfy SyncInitTrigger's validation logic
+	 */
+	pAwait->trigger.value_type = XSyncAbsolute;
+	XSyncIntToValue(&pAwait->trigger.wait_value, 0);
+	pAwait->trigger.test_type = 0;
+
+	status = SyncInitTrigger(client, &pAwait->trigger,
+				 *pProtocolFences, RTFence,
+				 XSyncCAAllTrigger);
+	if (status != Success)
+	{
+	    /*  this should take care of removing any triggers created by
+	     *  this request that have already been registered on sync objects
+	     */
+	    FreeResource(pAwaitUnion->header.delete_id, RT_NONE);
+	    return status;
+	}
+	/* this is not a mistake -- same function works for both cases */
+	pAwait->trigger.TriggerFired = SyncAwaitTriggerFired;
+	pAwait->trigger.CounterDestroyed = SyncAwaitTriggerFired;
+	/* event_threshold is unused for fence syncs */
+	XSyncIntToValue(&pAwait->event_threshold, 0);
+	pAwait->pHeader = &pAwaitUnion->header;
+	pAwaitUnion->header.num_waitconditions++;
+    }
+
+    SyncAwaitEpilogue(client, items, pAwaitUnion);
+
+    return client->noClientException;
+}
+
+/*
+ * ** Given an extension request, call the appropriate request procedure
+ */
+static int
+ProcSyncDispatch(ClientPtr client)
+{
+    REQUEST(xReq);
+
+    switch (stuff->data)
+    {
+      case X_SyncInitialize:
+	return ProcSyncInitialize(client);
+      case X_SyncListSystemCounters:
+	return ProcSyncListSystemCounters(client);
+      case X_SyncCreateCounter:
+	return ProcSyncCreateCounter(client);
+      case X_SyncSetCounter:
+	return ProcSyncSetCounter(client);
+      case X_SyncChangeCounter:
+	return ProcSyncChangeCounter(client);
+      case X_SyncQueryCounter:
+	return ProcSyncQueryCounter(client);
+      case X_SyncDestroyCounter:
+	return ProcSyncDestroyCounter(client);
+      case X_SyncAwait:
+	return ProcSyncAwait(client);
+      case X_SyncCreateAlarm:
+	return ProcSyncCreateAlarm(client);
+      case X_SyncChangeAlarm:
+	return ProcSyncChangeAlarm(client);
+      case X_SyncQueryAlarm:
+	return ProcSyncQueryAlarm(client);
+      case X_SyncDestroyAlarm:
+	return ProcSyncDestroyAlarm(client);
+      case X_SyncSetPriority:
+	return ProcSyncSetPriority(client);
+      case X_SyncGetPriority:
+	return ProcSyncGetPriority(client);
+      case X_SyncCreateFence:
+	return ProcSyncCreateFence(client);
+      case X_SyncTriggerFence:
+	return ProcSyncTriggerFence(client);
+      case X_SyncResetFence:
+	return ProcSyncResetFence(client);
+      case X_SyncDestroyFence:
+	return ProcSyncDestroyFence(client);
+      case X_SyncQueryFence:
+	return ProcSyncQueryFence(client);
+      case X_SyncAwaitFence:
+	return ProcSyncAwaitFence(client);
+      default:
+	return BadRequest;
+    }
+}
+
+/*
+ * Boring Swapping stuff ...
+ */
+
+static int
+SProcSyncInitialize(ClientPtr client)
+{
+    REQUEST(xSyncInitializeReq);
+    swaps(&stuff->length);
+    REQUEST_SIZE_MATCH (xSyncInitializeReq);
+
+    return ProcSyncInitialize(client);
+}
+
+static int
+SProcSyncListSystemCounters(ClientPtr client)
+{
+    REQUEST(xSyncListSystemCountersReq);
+    swaps(&stuff->length);
+    REQUEST_SIZE_MATCH (xSyncListSystemCountersReq);
+
+    return ProcSyncListSystemCounters(client);
+}
+
+static int
+SProcSyncCreateCounter(ClientPtr client)
+{
+    REQUEST(xSyncCreateCounterReq);
+    swaps(&stuff->length);
+    REQUEST_SIZE_MATCH (xSyncCreateCounterReq);
+    swapl(&stuff->cid);
+    swapl(&stuff->initial_value_lo);
+    swapl(&stuff->initial_value_hi);
+
+    return ProcSyncCreateCounter(client);
+}
+
+static int
+SProcSyncSetCounter(ClientPtr client)
+{
+    REQUEST(xSyncSetCounterReq);
+    swaps(&stuff->length);
+    REQUEST_SIZE_MATCH (xSyncSetCounterReq);
+    swapl(&stuff->cid);
+    swapl(&stuff->value_lo);
+    swapl(&stuff->value_hi);
+
+    return ProcSyncSetCounter(client);
+}
+
+static int
+SProcSyncChangeCounter(ClientPtr client)
+{
+    REQUEST(xSyncChangeCounterReq);
+    swaps(&stuff->length);
+    REQUEST_SIZE_MATCH (xSyncChangeCounterReq);
+    swapl(&stuff->cid);
+    swapl(&stuff->value_lo);
+    swapl(&stuff->value_hi);
+
+    return ProcSyncChangeCounter(client);
+}
+
+static int
+SProcSyncQueryCounter(ClientPtr client)
+{
+    REQUEST(xSyncQueryCounterReq);
+    swaps(&stuff->length);
+    REQUEST_SIZE_MATCH (xSyncQueryCounterReq);
+    swapl(&stuff->counter);
+
+    return ProcSyncQueryCounter(client);
+}
+
+static int
+SProcSyncDestroyCounter(ClientPtr client)
+{
+    REQUEST(xSyncDestroyCounterReq);
+    swaps(&stuff->length);
+    REQUEST_SIZE_MATCH (xSyncDestroyCounterReq);
+    swapl(&stuff->counter);
+
+    return ProcSyncDestroyCounter(client);
+}
+
+static int
+SProcSyncAwait(ClientPtr client)
+{
+    REQUEST(xSyncAwaitReq);
+    swaps(&stuff->length);
+    REQUEST_AT_LEAST_SIZE(xSyncAwaitReq);
+    SwapRestL(stuff);
+
+    return ProcSyncAwait(client);
+}
+
+static int
+SProcSyncCreateAlarm(ClientPtr client)
+{
+    REQUEST(xSyncCreateAlarmReq);
+    swaps(&stuff->length);
+    REQUEST_AT_LEAST_SIZE(xSyncCreateAlarmReq);
+    swapl(&stuff->id);
+    swapl(&stuff->valueMask);
+    SwapRestL(stuff);
+
+    return ProcSyncCreateAlarm(client);
+}
+
+static int
+SProcSyncChangeAlarm(ClientPtr client)
+{
+    REQUEST(xSyncChangeAlarmReq);
+    swaps(&stuff->length);
+    REQUEST_AT_LEAST_SIZE(xSyncChangeAlarmReq);
+    swapl(&stuff->alarm);
+    swapl(&stuff->valueMask);
+    SwapRestL(stuff);
+    return ProcSyncChangeAlarm(client);
+}
+
+static int
+SProcSyncQueryAlarm(ClientPtr client)
+{
+    REQUEST(xSyncQueryAlarmReq);
+    swaps(&stuff->length);
+    REQUEST_SIZE_MATCH (xSyncQueryAlarmReq);
+    swapl(&stuff->alarm);
+
+    return ProcSyncQueryAlarm(client);
+}
+
+static int
+SProcSyncDestroyAlarm(ClientPtr client)
+{
+    REQUEST(xSyncDestroyAlarmReq);
+    swaps(&stuff->length);
+    REQUEST_SIZE_MATCH (xSyncDestroyAlarmReq);
+    swapl(&stuff->alarm);
+
+    return ProcSyncDestroyAlarm(client);
+}
+
+static int
+SProcSyncSetPriority(ClientPtr client)
+{
+    REQUEST(xSyncSetPriorityReq);
+    swaps(&stuff->length);
+    REQUEST_SIZE_MATCH (xSyncSetPriorityReq);
+    swapl(&stuff->id);
+    swapl(&stuff->priority);
+
+    return ProcSyncSetPriority(client);
+}
+
+static int
+SProcSyncGetPriority(ClientPtr client)
+{
+    REQUEST(xSyncGetPriorityReq);
+    swaps(&stuff->length);
+    REQUEST_SIZE_MATCH (xSyncGetPriorityReq);
+    swapl(&stuff->id);
+
+    return ProcSyncGetPriority(client);
+}
+
+static int
+SProcSyncCreateFence(ClientPtr client)
+{
+    REQUEST(xSyncCreateFenceReq);
+    swaps(&stuff->length);
+    REQUEST_SIZE_MATCH (xSyncCreateFenceReq);
+    swapl(&stuff->fid);
+
+    return ProcSyncCreateFence(client);
+}
+
+static int
+SProcSyncTriggerFence(ClientPtr client)
+{
+    REQUEST(xSyncTriggerFenceReq);
+    swaps(&stuff->length);
+    REQUEST_SIZE_MATCH (xSyncTriggerFenceReq);
+    swapl(&stuff->fid);
+
+    return ProcSyncTriggerFence(client);
+}
+
+static int
+SProcSyncResetFence(ClientPtr client)
+{
+    REQUEST(xSyncResetFenceReq);
+    swaps(&stuff->length);
+    REQUEST_SIZE_MATCH (xSyncResetFenceReq);
+    swapl(&stuff->fid);
+
+    return ProcSyncResetFence(client);
+}
+
+static int
+SProcSyncDestroyFence(ClientPtr client)
+{
+    REQUEST(xSyncDestroyFenceReq);
+    swaps(&stuff->length);
+    REQUEST_SIZE_MATCH (xSyncDestroyFenceReq);
+    swapl(&stuff->fid);
+
+    return ProcSyncDestroyFence(client);
+}
+
+static int
+SProcSyncQueryFence(ClientPtr client)
+{
+    REQUEST(xSyncQueryFenceReq);
+    swaps(&stuff->length);
+    REQUEST_SIZE_MATCH (xSyncQueryFenceReq);
+    swapl(&stuff->fid);
+
+    return ProcSyncQueryFence(client);
+}
+
+static int
+SProcSyncAwaitFence(ClientPtr client)
+{
+    REQUEST(xSyncAwaitFenceReq);
+    swaps(&stuff->length);
+    REQUEST_AT_LEAST_SIZE(xSyncAwaitFenceReq);
+    SwapRestL(stuff);
+
+    return ProcSyncAwaitFence(client);
+}
+
+static int
+SProcSyncDispatch(ClientPtr client)
+{
+    REQUEST(xReq);
+
+    switch (stuff->data)
+    {
+      case X_SyncInitialize:
+	return SProcSyncInitialize(client);
+      case X_SyncListSystemCounters:
+	return SProcSyncListSystemCounters(client);
+      case X_SyncCreateCounter:
+	return SProcSyncCreateCounter(client);
+      case X_SyncSetCounter:
+	return SProcSyncSetCounter(client);
+      case X_SyncChangeCounter:
+	return SProcSyncChangeCounter(client);
+      case X_SyncQueryCounter:
+	return SProcSyncQueryCounter(client);
+      case X_SyncDestroyCounter:
+	return SProcSyncDestroyCounter(client);
+      case X_SyncAwait:
+	return SProcSyncAwait(client);
+      case X_SyncCreateAlarm:
+	return SProcSyncCreateAlarm(client);
+      case X_SyncChangeAlarm:
+	return SProcSyncChangeAlarm(client);
+      case X_SyncQueryAlarm:
+	return SProcSyncQueryAlarm(client);
+      case X_SyncDestroyAlarm:
+	return SProcSyncDestroyAlarm(client);
+      case X_SyncSetPriority:
+	return SProcSyncSetPriority(client);
+      case X_SyncGetPriority:
+	return SProcSyncGetPriority(client);
+      case X_SyncCreateFence:
+	return SProcSyncCreateFence(client);
+      case X_SyncTriggerFence:
+	return SProcSyncTriggerFence(client);
+      case X_SyncResetFence:
+	return SProcSyncResetFence(client);
+      case X_SyncDestroyFence:
+	return SProcSyncDestroyFence(client);
+      case X_SyncQueryFence:
+	return SProcSyncQueryFence(client);
+      case X_SyncAwaitFence:
+	return SProcSyncAwaitFence(client);
+      default:
+	return BadRequest;
+    }
+}
+
+/*
+ * Event Swapping
+ */
+
+static void
+SCounterNotifyEvent(xSyncCounterNotifyEvent *from, xSyncCounterNotifyEvent *to)
+{
+    to->type = from->type;
+    to->kind = from->kind;
+    cpswaps(from->sequenceNumber, to->sequenceNumber);
+    cpswapl(from->counter, to->counter);
+    cpswapl(from->wait_value_lo, to->wait_value_lo);
+    cpswapl(from->wait_value_hi, to->wait_value_hi);
+    cpswapl(from->counter_value_lo, to->counter_value_lo);
+    cpswapl(from->counter_value_hi, to->counter_value_hi);
+    cpswapl(from->time, to->time);
+    cpswaps(from->count, to->count);
+    to->destroyed = from->destroyed;
+}
+
+
+static void
+SAlarmNotifyEvent(xSyncAlarmNotifyEvent *from, xSyncAlarmNotifyEvent *to)
+{
+    to->type = from->type;
+    to->kind = from->kind;
+    cpswaps(from->sequenceNumber, to->sequenceNumber);
+    cpswapl(from->alarm, to->alarm);
+    cpswapl(from->counter_value_lo, to->counter_value_lo);
+    cpswapl(from->counter_value_hi, to->counter_value_hi);
+    cpswapl(from->alarm_value_lo, to->alarm_value_lo);
+    cpswapl(from->alarm_value_hi, to->alarm_value_hi);
+    cpswapl(from->time, to->time);
+    to->state = from->state;
+}
+
+/*
+ * ** Close everything down. ** This is fairly simple for now.
+ */
+/* ARGSUSED */
+static void
+SyncResetProc(ExtensionEntry *extEntry)
+{
+    free(SysCounterList);
+    SysCounterList = NULL;
+    RTCounter = 0;
+}
+
+/*
+ * ** Initialise the extension.
+ */
+void
+SyncExtensionInit(void)
+{
+    ExtensionEntry *extEntry;
+    int 	    s;
+
+    for (s = 0; s < screenInfo.numScreens; s++)
+	miSyncSetup(screenInfo.screens[s]);
+
+    if (RTCounter == 0)
+    {
+	RTCounter = CreateNewResourceType(FreeCounter, "SyncCounter");
+    }
+    RTAlarm = CreateNewResourceType(FreeAlarm, "SyncAlarm");
+    RTAwait = CreateNewResourceType(FreeAwait, "SyncAwait");
+    RTFence = CreateNewResourceType(FreeFence, "SyncFence");
+    if (RTAwait)
+	RTAwait |= RC_NEVERRETAIN;
+    RTAlarmClient = CreateNewResourceType(FreeAlarmClient, "SyncAlarmClient");
+    if (RTAlarmClient)
+	RTAlarmClient |= RC_NEVERRETAIN;
+
+    if (RTCounter == 0 || RTAwait == 0 || RTAlarm == 0 ||
+	RTAlarmClient == 0 ||
+	(extEntry = AddExtension(SYNC_NAME,
+				 XSyncNumberEvents, XSyncNumberErrors,
+				 ProcSyncDispatch, SProcSyncDispatch,
+				 SyncResetProc,
+				 StandardMinorOpcode)) == NULL)
+    {
+	ErrorF("Sync Extension %d.%d failed to Initialise\n",
+		SYNC_MAJOR_VERSION, SYNC_MINOR_VERSION);
+	return;
+    }
+
+    SyncEventBase = extEntry->eventBase;
+    SyncErrorBase = extEntry->errorBase;
+    EventSwapVector[SyncEventBase + XSyncCounterNotify] = (EventSwapPtr) SCounterNotifyEvent;
+    EventSwapVector[SyncEventBase + XSyncAlarmNotify] = (EventSwapPtr) SAlarmNotifyEvent;
+
+    SetResourceTypeErrorValue(RTCounter, SyncErrorBase + XSyncBadCounter);
+    SetResourceTypeErrorValue(RTAlarm, SyncErrorBase + XSyncBadAlarm);
+    SetResourceTypeErrorValue(RTFence, SyncErrorBase + XSyncBadFence);
+
+    /*
+     * Although SERVERTIME is implemented by the OS layer, we initialise it
+     * here because doing it in OsInit() is too early. The resource database
+     * is not initialised when OsInit() is called. This is just about OK
+     * because there is always a servertime counter.
+     */
+    SyncInitServerTime();
+    SyncInitIdleTime();
+
+#ifdef DEBUG
+    fprintf(stderr, "Sync Extension %d.%d\n",
+	    SYNC_MAJOR_VERSION, SYNC_MINOR_VERSION);
+#endif
+}
+
+
+/*
+ * ***** SERVERTIME implementation - should go in its own file in OS directory?
+ */
+
+
+
+static pointer ServertimeCounter;
+static XSyncValue Now;
+static XSyncValue *pnext_time;
+
+#define GetTime()\
+{\
+    unsigned long millis = GetTimeInMillis();\
+    unsigned long maxis = XSyncValueHigh32(Now);\
+    if (millis < XSyncValueLow32(Now)) maxis++;\
+    XSyncIntsToValue(&Now, millis, maxis);\
+}
+
+/*
+*** Server Block Handler
+*** code inspired by multibuffer extension (now deprecated)
+ */
+/*ARGSUSED*/
+static void
+ServertimeBlockHandler(void *env, struct timeval **wt, void *LastSelectMask)
+{
+    XSyncValue delay;
+    unsigned long timeout;
+
+    if (pnext_time)
+    {
+        GetTime();
+
+        if (XSyncValueGreaterOrEqual(Now, *pnext_time))
+	{
+            timeout = 0;
+        }
+	else
+	{
+	    Bool overflow;
+            XSyncValueSubtract(&delay, *pnext_time, Now, &overflow);
+	    (void)overflow;
+            timeout = XSyncValueLow32(delay);
+        }
+        AdjustWaitForDelay(wt, timeout); /* os/utils.c */
+    }
+}
+
+/*
+*** Wakeup Handler
+ */
+/*ARGSUSED*/
+static void
+ServertimeWakeupHandler(void *env, int rc, void *LastSelectMask)
+{
+    if (pnext_time)
+    {
+        GetTime();
+
+        if (XSyncValueGreaterOrEqual(Now, *pnext_time))
+	{
+            SyncChangeCounter(ServertimeCounter, Now);
+        }
+    }
+}
+
+static void
+ServertimeQueryValue(void *pCounter, CARD64 *pValue_return)
+{
+    GetTime();
+    *pValue_return = Now;
+}
+
+static void
+ServertimeBracketValues(void *pCounter, CARD64 *pbracket_less,
+			CARD64 *pbracket_greater)
+{
+    if (!pnext_time && pbracket_greater)
+    {
+	RegisterBlockAndWakeupHandlers(ServertimeBlockHandler,
+				       ServertimeWakeupHandler,
+				       NULL);
+    }
+    else if (pnext_time && !pbracket_greater)
+    {
+	RemoveBlockAndWakeupHandlers(ServertimeBlockHandler,
+				     ServertimeWakeupHandler,
+				     NULL);
+    }
+    pnext_time = pbracket_greater;
+}
+
+static void
+SyncInitServerTime(void)
+{
+    CARD64 resolution;
+
+    XSyncIntsToValue(&Now, GetTimeInMillis(), 0);
+    XSyncIntToValue(&resolution, 4);
+    ServertimeCounter = SyncCreateSystemCounter("SERVERTIME", Now, resolution,
+			    XSyncCounterNeverDecreases,
+			    ServertimeQueryValue, ServertimeBracketValues);
+    pnext_time = NULL;
+}
+
+
+
+/*
+ * IDLETIME implementation
+ */
+
+static SyncCounter *IdleTimeCounter;
+static XSyncValue *pIdleTimeValueLess;
+static XSyncValue *pIdleTimeValueGreater;
+
+static void
+IdleTimeQueryValue (pointer pCounter, CARD64 *pValue_return)
+{
+    CARD32 idle = GetTimeInMillis() - lastDeviceEventTime.milliseconds;
+    XSyncIntsToValue (pValue_return, idle, 0);
+}
+
+static void
+IdleTimeBlockHandler(pointer env, struct timeval **wt, pointer LastSelectMask)
+{
+    XSyncValue idle, old_idle;
+    SyncTriggerList *list = IdleTimeCounter->sync.pTriglist;
+    SyncTrigger *trig;
+
+    if (!pIdleTimeValueLess && !pIdleTimeValueGreater)
+	return;
+
+    old_idle = IdleTimeCounter->value;
+    IdleTimeQueryValue (NULL, &idle);
+    IdleTimeCounter->value = idle; /* push, so CheckTrigger works */
+
+    if (pIdleTimeValueLess &&
+        XSyncValueLessOrEqual (idle, *pIdleTimeValueLess))
+    {
+	/*
+	 * We've been idle for less than the threshold value, and someone
+	 * wants to know about that, but now we need to know whether they
+	 * want level or edge trigger.  Check the trigger list against the
+	 * current idle time, and if any succeed, bomb out of select()
+	 * immediately so we can reschedule.
+	 */
+
+	for (list = IdleTimeCounter->sync.pTriglist; list; list = list->next) {
+	    trig = list->pTrigger;
+	    if (trig->CheckTrigger(trig, old_idle)) {
+		AdjustWaitForDelay(wt, 0);
+		break;
+	    }
+	}
+	/* 
+	 * We've been called exactly on the idle time, but we have a
+	 * NegativeTransition trigger which requires a transition from an
+	 * idle time greater than this.  Schedule a wakeup for the next
+	 * millisecond so we won't miss a transition.
+	 */
+	if (XSyncValueEqual (idle, *pIdleTimeValueLess))
+	    AdjustWaitForDelay(wt, 1);
+    }
+    else if (pIdleTimeValueGreater)
+    {
+	/*
+	 * There's a threshold in the positive direction.  If we've been
+	 * idle less than it, schedule a wakeup for sometime in the future.
+	 * If we've been idle more than it, and someone wants to know about
+	 * that level-triggered, schedule an immediate wakeup.
+	 */
+	unsigned long timeout = -1;
+
+	if (XSyncValueLessThan (idle, *pIdleTimeValueGreater)) {
+	    XSyncValue value;
+	    Bool overflow;
+
+	    XSyncValueSubtract (&value, *pIdleTimeValueGreater,
+	                        idle, &overflow);
+	    timeout = min(timeout, XSyncValueLow32 (value));
+	} else {
+	    for (list = IdleTimeCounter->sync.pTriglist; list; list = list->next) {
+		trig = list->pTrigger;
+		if (trig->CheckTrigger(trig, old_idle)) {
+		    timeout = min(timeout, 0);
+		    break;
+		}
+	    }
+	}
+
+	AdjustWaitForDelay (wt, timeout);
+    }
+
+    IdleTimeCounter->value = old_idle; /* pop */
+}
+
+static void
+IdleTimeWakeupHandler (pointer env, int rc, pointer LastSelectMask)
+{
+    XSyncValue idle;
+
+    if (!pIdleTimeValueLess && !pIdleTimeValueGreater)
+	return;
+
+    IdleTimeQueryValue (NULL, &idle);
+
+    if ((pIdleTimeValueGreater &&
+         XSyncValueGreaterOrEqual (idle, *pIdleTimeValueGreater)) ||
+        (pIdleTimeValueLess &&
+	 XSyncValueLessOrEqual (idle, *pIdleTimeValueLess)))
+    {
+	SyncChangeCounter (IdleTimeCounter, idle);
+    }
+}
+
+static void
+IdleTimeBracketValues (pointer pCounter, CARD64 *pbracket_less,
+                       CARD64 *pbracket_greater)
+{
+    Bool registered = (pIdleTimeValueLess || pIdleTimeValueGreater);
+
+    if (registered && !pbracket_less && !pbracket_greater)
+    {
+	RemoveBlockAndWakeupHandlers(IdleTimeBlockHandler,
+	                             IdleTimeWakeupHandler,
+	                             NULL);
+    }
+    else if (!registered && (pbracket_less || pbracket_greater))
+    {
+	RegisterBlockAndWakeupHandlers(IdleTimeBlockHandler,
+	                               IdleTimeWakeupHandler,
+	                               NULL);
+    }
+
+    pIdleTimeValueGreater = pbracket_greater;
+    pIdleTimeValueLess    = pbracket_less;
+}
+
+static void
+SyncInitIdleTime (void)
+{
+    CARD64 resolution;
+    XSyncValue idle;
+
+    IdleTimeQueryValue (NULL, &idle);
+    XSyncIntToValue (&resolution, 4);
+
+    IdleTimeCounter = SyncCreateSystemCounter ("IDLETIME", idle, resolution,
+                                               XSyncCounterUnrestricted,
+                                               IdleTimeQueryValue,
+                                               IdleTimeBracketValues);
+
+    pIdleTimeValueLess = pIdleTimeValueGreater = NULL;
+}
diff --git a/xorg-server/Xext/xcmisc.c b/xorg-server/Xext/xcmisc.c
index 8dfe4d136..8e3c9cd80 100644
--- a/xorg-server/Xext/xcmisc.c
+++ b/xorg-server/Xext/xcmisc.c
@@ -1,207 +1,201 @@
-/*

-

-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.

-

-*/

-

-#ifdef HAVE_DIX_CONFIG_H

-#include <dix-config.h>

-#endif

-

-#include <X11/X.h>

-#include <X11/Xproto.h>

-#include "misc.h"

-#include "os.h"

-#include "dixstruct.h"

-#include "extnsionst.h"

-#include "swaprep.h"

-#include <X11/extensions/xcmiscproto.h>

-#include "modinit.h"

-

-#if HAVE_STDINT_H

-#include <stdint.h>

-#elif !defined(UINT32_MAX)

-#define UINT32_MAX 0xffffffffU

-#endif

-

-

-static int

-ProcXCMiscGetVersion(ClientPtr client)

-{

-    xXCMiscGetVersionReply rep;

-    int n;

-

-    REQUEST_SIZE_MATCH(xXCMiscGetVersionReq);

-    rep.type = X_Reply;

-    rep.length = 0;

-    rep.sequenceNumber = client->sequence;

-    rep.majorVersion = XCMiscMajorVersion;

-    rep.minorVersion = XCMiscMinorVersion;

-    if (client->swapped) {

-    	swaps(&rep.sequenceNumber, n);

-	swaps(&rep.majorVersion, n);

-	swaps(&rep.minorVersion, n);

-    }

-    WriteToClient(client, sizeof(xXCMiscGetVersionReply), (char *)&rep);

-    return Success;

-}

-

-static int

-ProcXCMiscGetXIDRange(ClientPtr client)

-{

-    xXCMiscGetXIDRangeReply rep;

-    int n;

-    XID min_id, max_id;

-

-    REQUEST_SIZE_MATCH(xXCMiscGetXIDRangeReq);

-    GetXIDRange(client->index, FALSE, &min_id, &max_id);

-    rep.type = X_Reply;

-    rep.length = 0;

-    rep.sequenceNumber = client->sequence;

-    rep.start_id = min_id;

-    rep.count = max_id - min_id + 1;

-    if (client->swapped) {

-    	swaps(&rep.sequenceNumber, n);

-	swapl(&rep.start_id, n);

-	swapl(&rep.count, n);

-    }

-    WriteToClient(client, sizeof(xXCMiscGetXIDRangeReply), (char *)&rep);

-    return Success;

-}

-

-static int

-ProcXCMiscGetXIDList(ClientPtr client)

-{

-    REQUEST(xXCMiscGetXIDListReq);

-    xXCMiscGetXIDListReply rep;

-    int n;

-    XID *pids;

-    unsigned int count;

-

-    REQUEST_SIZE_MATCH(xXCMiscGetXIDListReq);

-

-    if (stuff->count > UINT32_MAX / sizeof(XID))

-	    return BadAlloc;

-

-    pids = (XID *)malloc(stuff->count * sizeof(XID));

-    if (!pids)

-    {

-	return BadAlloc;

-    }

-    count = GetXIDList(client, stuff->count, pids);

-    rep.type = X_Reply;

-    rep.sequenceNumber = client->sequence;

-    rep.length = count;

-    rep.count = count;

-    if (client->swapped) {

-    	swaps(&rep.sequenceNumber, n);

-	swapl(&rep.length, n);

-	swapl(&rep.count, n);

-    }

-    WriteToClient(client, sizeof(xXCMiscGetXIDListReply), (char *)&rep);

-    if (count)

-    {

-    	client->pSwapReplyFunc = (ReplySwapPtr) Swap32Write;

-	WriteSwappedDataToClient(client, count * sizeof(XID), pids);

-    }

-    free(pids);

-    return Success;

-}

-

-static int

-ProcXCMiscDispatch (ClientPtr client)

-{

-    REQUEST(xReq);

-    switch (stuff->data)

-    {

-    case X_XCMiscGetVersion:

-	return ProcXCMiscGetVersion(client);

-    case X_XCMiscGetXIDRange:

-	return ProcXCMiscGetXIDRange(client);

-    case X_XCMiscGetXIDList:

-	return ProcXCMiscGetXIDList(client);

-    default:

-	return BadRequest;

-    }

-}

-

-static int

-SProcXCMiscGetVersion(ClientPtr client)

-{

-    int n;

-    REQUEST(xXCMiscGetVersionReq);

-

-    swaps(&stuff->length, n);

-    REQUEST_SIZE_MATCH(xXCMiscGetVersionReq);

-    swaps(&stuff->majorVersion, n);

-    swaps(&stuff->minorVersion, n);

-    return ProcXCMiscGetVersion(client);

-}

-

-static int

-SProcXCMiscGetXIDRange(ClientPtr client)

-{

-    int n;

-    REQUEST(xReq);

-

-    swaps(&stuff->length, n);

-    return ProcXCMiscGetXIDRange(client);

-}

-

-static int

-SProcXCMiscGetXIDList(ClientPtr client)

-{

-    int n;

-    REQUEST(xXCMiscGetXIDListReq);

-

-    swaps(&stuff->length, n);

-    swapl(&stuff->count, n);

-    return ProcXCMiscGetXIDList(client);

-}

-

-static int

-SProcXCMiscDispatch (ClientPtr client)

-{

-    REQUEST(xReq);

-    switch (stuff->data)

-    {

-    case X_XCMiscGetVersion:

-	return SProcXCMiscGetVersion(client);

-    case X_XCMiscGetXIDRange:

-	return SProcXCMiscGetXIDRange(client);

-    case X_XCMiscGetXIDList:

-	return SProcXCMiscGetXIDList(client);

-    default:

-	return BadRequest;

-    }

-}

-

-void

-XCMiscExtensionInit(INITARGS)

-{

-    AddExtension(XCMiscExtensionName, 0, 0,

-		 ProcXCMiscDispatch, SProcXCMiscDispatch,

-		 NULL, StandardMinorOpcode);

-}

+/*
+
+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.
+
+*/
+
+#ifdef HAVE_DIX_CONFIG_H
+#include <dix-config.h>
+#endif
+
+#include <X11/X.h>
+#include <X11/Xproto.h>
+#include "misc.h"
+#include "os.h"
+#include "dixstruct.h"
+#include "extnsionst.h"
+#include "swaprep.h"
+#include <X11/extensions/xcmiscproto.h>
+#include "modinit.h"
+
+#if HAVE_STDINT_H
+#include <stdint.h>
+#elif !defined(UINT32_MAX)
+#define UINT32_MAX 0xffffffffU
+#endif
+
+
+static int
+ProcXCMiscGetVersion(ClientPtr client)
+{
+    xXCMiscGetVersionReply rep;
+
+    REQUEST_SIZE_MATCH(xXCMiscGetVersionReq);
+    rep.type = X_Reply;
+    rep.length = 0;
+    rep.sequenceNumber = client->sequence;
+    rep.majorVersion = XCMiscMajorVersion;
+    rep.minorVersion = XCMiscMinorVersion;
+    if (client->swapped) {
+	swaps(&rep.sequenceNumber);
+	swaps(&rep.majorVersion);
+	swaps(&rep.minorVersion);
+    }
+    WriteToClient(client, sizeof(xXCMiscGetVersionReply), (char *)&rep);
+    return Success;
+}
+
+static int
+ProcXCMiscGetXIDRange(ClientPtr client)
+{
+    xXCMiscGetXIDRangeReply rep;
+    XID min_id, max_id;
+
+    REQUEST_SIZE_MATCH(xXCMiscGetXIDRangeReq);
+    GetXIDRange(client->index, FALSE, &min_id, &max_id);
+    rep.type = X_Reply;
+    rep.length = 0;
+    rep.sequenceNumber = client->sequence;
+    rep.start_id = min_id;
+    rep.count = max_id - min_id + 1;
+    if (client->swapped) {
+	swaps(&rep.sequenceNumber);
+	swapl(&rep.start_id);
+	swapl(&rep.count);
+    }
+    WriteToClient(client, sizeof(xXCMiscGetXIDRangeReply), (char *)&rep);
+    return Success;
+}
+
+static int
+ProcXCMiscGetXIDList(ClientPtr client)
+{
+    REQUEST(xXCMiscGetXIDListReq);
+    xXCMiscGetXIDListReply rep;
+    XID *pids;
+    unsigned int count;
+
+    REQUEST_SIZE_MATCH(xXCMiscGetXIDListReq);
+
+    if (stuff->count > UINT32_MAX / sizeof(XID))
+	    return BadAlloc;
+
+    pids = (XID *)malloc(stuff->count * sizeof(XID));
+    if (!pids)
+    {
+	return BadAlloc;
+    }
+    count = GetXIDList(client, stuff->count, pids);
+    rep.type = X_Reply;
+    rep.sequenceNumber = client->sequence;
+    rep.length = count;
+    rep.count = count;
+    if (client->swapped) {
+	swaps(&rep.sequenceNumber);
+	swapl(&rep.length);
+	swapl(&rep.count);
+    }
+    WriteToClient(client, sizeof(xXCMiscGetXIDListReply), (char *)&rep);
+    if (count)
+    {
+    	client->pSwapReplyFunc = (ReplySwapPtr) Swap32Write;
+	WriteSwappedDataToClient(client, count * sizeof(XID), pids);
+    }
+    free(pids);
+    return Success;
+}
+
+static int
+ProcXCMiscDispatch (ClientPtr client)
+{
+    REQUEST(xReq);
+    switch (stuff->data)
+    {
+    case X_XCMiscGetVersion:
+	return ProcXCMiscGetVersion(client);
+    case X_XCMiscGetXIDRange:
+	return ProcXCMiscGetXIDRange(client);
+    case X_XCMiscGetXIDList:
+	return ProcXCMiscGetXIDList(client);
+    default:
+	return BadRequest;
+    }
+}
+
+static int
+SProcXCMiscGetVersion(ClientPtr client)
+{
+    REQUEST(xXCMiscGetVersionReq);
+
+    swaps(&stuff->length);
+    REQUEST_SIZE_MATCH(xXCMiscGetVersionReq);
+    swaps(&stuff->majorVersion);
+    swaps(&stuff->minorVersion);
+    return ProcXCMiscGetVersion(client);
+}
+
+static int
+SProcXCMiscGetXIDRange(ClientPtr client)
+{
+    REQUEST(xReq);
+
+    swaps(&stuff->length);
+    return ProcXCMiscGetXIDRange(client);
+}
+
+static int
+SProcXCMiscGetXIDList(ClientPtr client)
+{
+    REQUEST(xXCMiscGetXIDListReq);
+
+    swaps(&stuff->length);
+    swapl(&stuff->count);
+    return ProcXCMiscGetXIDList(client);
+}
+
+static int
+SProcXCMiscDispatch (ClientPtr client)
+{
+    REQUEST(xReq);
+    switch (stuff->data)
+    {
+    case X_XCMiscGetVersion:
+	return SProcXCMiscGetVersion(client);
+    case X_XCMiscGetXIDRange:
+	return SProcXCMiscGetXIDRange(client);
+    case X_XCMiscGetXIDList:
+	return SProcXCMiscGetXIDList(client);
+    default:
+	return BadRequest;
+    }
+}
+
+void
+XCMiscExtensionInit(INITARGS)
+{
+    AddExtension(XCMiscExtensionName, 0, 0,
+		 ProcXCMiscDispatch, SProcXCMiscDispatch,
+		 NULL, StandardMinorOpcode);
+}
diff --git a/xorg-server/Xext/xf86bigfont.c b/xorg-server/Xext/xf86bigfont.c
index de8274469..4b63a13a1 100644
--- a/xorg-server/Xext/xf86bigfont.c
+++ b/xorg-server/Xext/xf86bigfont.c
@@ -307,13 +307,13 @@ ProcXF86BigfontQueryVersion(
 	; /* may add more bits here in future versions */
     if (client->swapped) {
 	char tmp;
-	swaps(&reply.sequenceNumber, tmp);
-	swapl(&reply.length, tmp);
-	swaps(&reply.majorVersion, tmp);
-	swaps(&reply.minorVersion, tmp);
-	swapl(&reply.uid, tmp);
-	swapl(&reply.gid, tmp);
-	swapl(&reply.signature, tmp);
+	swaps(&reply.sequenceNumber);
+	swapl(&reply.length);
+	swaps(&reply.majorVersion);
+	swaps(&reply.minorVersion);
+	swapl(&reply.uid);
+	swapl(&reply.gid);
+	swapl(&reply.signature);
     }
     WriteToClient(client,
 		  sizeof(xXF86BigfontQueryVersionReply), (char *)&reply);
@@ -326,12 +326,12 @@ swapCharInfo(
 {
     char tmp;
 
-    swaps(&pCI->leftSideBearing, tmp);
-    swaps(&pCI->rightSideBearing, tmp);
-    swaps(&pCI->characterWidth, tmp);
-    swaps(&pCI->ascent, tmp);
-    swaps(&pCI->descent, tmp);
-    swaps(&pCI->attributes, tmp);
+    swaps(&pCI->leftSideBearing);
+    swaps(&pCI->rightSideBearing);
+    swaps(&pCI->characterWidth);
+    swaps(&pCI->ascent);
+    swaps(&pCI->descent);
+    swaps(&pCI->attributes);
 }
 
 /* static CARD32 hashCI (xCharInfo *p); */
@@ -587,20 +587,20 @@ ProcXF86BigfontQueryFont(
 	reply->shmsegoffset = 0;
 	if (client->swapped) {
 	    char tmp;
-	    swaps(&reply->sequenceNumber, tmp);
-	    swapl(&reply->length, tmp);
+	    swaps(&reply->sequenceNumber);
+	    swapl(&reply->length);
 	    swapCharInfo(&reply->minBounds);
 	    swapCharInfo(&reply->maxBounds);
-	    swaps(&reply->minCharOrByte2, tmp);
-	    swaps(&reply->maxCharOrByte2, tmp);
-	    swaps(&reply->defaultChar, tmp);
-	    swaps(&reply->nFontProps, tmp);
-	    swaps(&reply->fontAscent, tmp);
-	    swaps(&reply->fontDescent, tmp);
-	    swapl(&reply->nCharInfos, tmp);
-	    swapl(&reply->nUniqCharInfos, tmp);
-	    swapl(&reply->shmid, tmp);
-	    swapl(&reply->shmsegoffset, tmp);
+	    swaps(&reply->minCharOrByte2);
+	    swaps(&reply->maxCharOrByte2);
+	    swaps(&reply->defaultChar);
+	    swaps(&reply->nFontProps);
+	    swaps(&reply->fontAscent);
+	    swaps(&reply->fontDescent);
+	    swapl(&reply->nCharInfos);
+	    swapl(&reply->nUniqCharInfos);
+	    swapl(&reply->shmid);
+	    swapl(&reply->shmsegoffset);
 	}
 	p = (char*) &reply[1];
 	{
@@ -614,8 +614,8 @@ ProcXF86BigfontQueryFont(
 		prFP->value = pFP->value;
 		if (client->swapped) {
 		    char tmp;
-		    swapl(&prFP->name, tmp);
-		    swapl(&prFP->value, tmp);
+		    swapl(&prFP->name);
+		    swapl(&prFP->value);
 		}
 	    }
 	    p = (char*) prFP;
@@ -635,7 +635,7 @@ ProcXF86BigfontQueryFont(
 		*ps = pIndex2UniqIndex[j];
 		if (client->swapped) {
 		    char tmp;
-		    swaps(ps, tmp);
+		    swaps(ps);
 		}
 	    }
 	}
@@ -672,7 +672,7 @@ SProcXF86BigfontQueryVersion(
     REQUEST(xXF86BigfontQueryVersionReq);
     char tmp;
 
-    swaps(&stuff->length, tmp);
+    swaps(&stuff->length);
     return ProcXF86BigfontQueryVersion(client);
 }
 
@@ -683,9 +683,9 @@ SProcXF86BigfontQueryFont(
     REQUEST(xXF86BigfontQueryFontReq);
     char tmp;
 
-    swaps(&stuff->length, tmp);
+    swaps(&stuff->length);
     REQUEST_SIZE_MATCH(xXF86BigfontQueryFontReq);
-    swapl(&stuff->id, tmp);
+    swapl(&stuff->id);
     return ProcXF86BigfontQueryFont(client);
 }
 
diff --git a/xorg-server/Xext/xres.c b/xorg-server/Xext/xres.c
index 4a5bffa81..b95272882 100644
--- a/xorg-server/Xext/xres.c
+++ b/xorg-server/Xext/xres.c
@@ -1,383 +1,361 @@
-/*

-   Copyright (c) 2002  XFree86 Inc

-*/

-

-#ifdef HAVE_DIX_CONFIG_H

-#include <dix-config.h>

-#endif

-

-#include <stdio.h>

-#include <string.h>

-#include <X11/X.h>

-#include <X11/Xproto.h>

-#include "misc.h"

-#include "os.h"

-#include "dixstruct.h"

-#include "extnsionst.h"

-#include "swaprep.h"

-#include "registry.h"

-#include <X11/extensions/XResproto.h>

-#include "pixmapstr.h"

-#include "windowstr.h"

-#include "gcstruct.h"

-#include "modinit.h"

-#include "protocol-versions.h"

-

-static int

-ProcXResQueryVersion (ClientPtr client)

-{

-    REQUEST(xXResQueryVersionReq);

-    xXResQueryVersionReply rep;

-    CARD16 client_major, client_minor;  /* not used */

-

-    REQUEST_SIZE_MATCH (xXResQueryVersionReq);

-

-    client_major = stuff->client_major;

-    client_minor = stuff->client_minor;

-    (void) client_major;

-    (void) client_minor;

-

-    rep.type = X_Reply;

-    rep.length = 0;

-    rep.sequenceNumber = client->sequence;

-    rep.server_major = SERVER_XRES_MAJOR_VERSION;

-    rep.server_minor = SERVER_XRES_MINOR_VERSION;

-    if (client->swapped) { 

-        int n;

-        swaps(&rep.sequenceNumber, n);

-        swapl(&rep.length, n);     

-        swaps(&rep.server_major, n);

-        swaps(&rep.server_minor, n);

-    }

-    WriteToClient(client, sizeof (xXResQueryVersionReply), (char *)&rep);

-    return Success;

-}

-

-static int

-ProcXResQueryClients (ClientPtr client)

-{

-    /* REQUEST(xXResQueryClientsReq); */

-    xXResQueryClientsReply rep;

-    int *current_clients;

-    int i, num_clients;

-

-    REQUEST_SIZE_MATCH(xXResQueryClientsReq);

-

-    current_clients = malloc(currentMaxClients * sizeof(int));

-

-    num_clients = 0;

-    for(i = 0; i < currentMaxClients; i++) {

-       if(clients[i]) {

-           current_clients[num_clients] = i;

-           num_clients++;   

-       }

-    }

-

-    rep.type = X_Reply;

-    rep.sequenceNumber = client->sequence;

-    rep.num_clients = num_clients;

-    rep.length = bytes_to_int32(rep.num_clients * sz_xXResClient);

-    if (client->swapped) {

-        int n;

-        swaps (&rep.sequenceNumber, n);

-        swapl (&rep.length, n);

-        swapl (&rep.num_clients, n);

-    }   

-    WriteToClient (client, sizeof (xXResQueryClientsReply), (char *) &rep);

-

-    if(num_clients) {

-        xXResClient scratch;

-

-        for(i = 0; i < num_clients; i++) {

-            scratch.resource_base = clients[current_clients[i]]->clientAsMask;

-            scratch.resource_mask = RESOURCE_ID_MASK;

-        

-            if(client->swapped) {

-                int n;

-                swapl (&scratch.resource_base, n);

-                swapl (&scratch.resource_mask, n);

-            }

-            WriteToClient (client, sz_xXResClient, (char *) &scratch);

-        }

-    }

-

-    free(current_clients);

-

-    return Success;

-}

-

-

-static void

-ResFindAllRes (pointer value, XID id, RESTYPE type, pointer cdata)

-{

-    int *counts = (int *)cdata;

-

-    counts[(type & TypeMask) - 1]++;

-}

-

-static int

-ProcXResQueryClientResources (ClientPtr client)

-{

-    REQUEST(xXResQueryClientResourcesReq);

-    xXResQueryClientResourcesReply rep;

-    int i, clientID, num_types;

-    int *counts;

-

-    REQUEST_SIZE_MATCH(xXResQueryClientResourcesReq);

-

-    clientID = CLIENT_ID(stuff->xid);

-

-    if((clientID >= currentMaxClients) || !clients[clientID]) {

-        client->errorValue = stuff->xid;

-        return BadValue;

-    }

-

-    counts = calloc(lastResourceType + 1, sizeof(int));

-

-    FindAllClientResources(clients[clientID], ResFindAllRes, counts);

-

-    num_types = 0;

-

-    for(i = 0; i <= lastResourceType; i++) {

-       if(counts[i]) num_types++;

-    }

-

-    rep.type = X_Reply;

-    rep.sequenceNumber = client->sequence;

-    rep.num_types = num_types;

-    rep.length = bytes_to_int32(rep.num_types * sz_xXResType);

-    if (client->swapped) {

-        int n;

-        swaps (&rep.sequenceNumber, n);

-        swapl (&rep.length, n);

-        swapl (&rep.num_types, n);

-    }   

-

-    WriteToClient (client,sizeof(xXResQueryClientResourcesReply),(char*)&rep);

-

-    if(num_types) {

-        xXResType scratch;

-	char *name;

-

-        for(i = 0; i < lastResourceType; i++) {

-            if(!counts[i]) continue;

-

-	    name = (char *)LookupResourceName(i + 1);

-            if (strcmp(name, XREGISTRY_UNKNOWN))

-		scratch.resource_type = MakeAtom(name, strlen(name), TRUE);

-	    else {

-                char buf[40];

-                snprintf(buf, sizeof(buf), "Unregistered resource %i", i + 1);

-		scratch.resource_type = MakeAtom(buf, strlen(buf), TRUE);

-            }

-

-            scratch.count = counts[i];

-

-            if(client->swapped) {

-                int n;

-                swapl (&scratch.resource_type, n);

-                swapl (&scratch.count, n);

-            }

-            WriteToClient (client, sz_xXResType, (char *) &scratch);

-        }

-    }

-

-    free(counts);

-    

-    return Success;

-}

-

-static unsigned long

-ResGetApproxPixmapBytes (PixmapPtr pix)

-{

-   unsigned long nPixels;

-   int           bytesPerPixel; 

-

-   bytesPerPixel = pix->drawable.bitsPerPixel>>3;

-   nPixels       = pix->drawable.width * pix->drawable.height;

-

-   /* Divide by refcnt as pixmap could be shared between clients,  

-    * so total pixmap mem is shared between these. 

-   */

-   return ( nPixels * bytesPerPixel ) / pix->refcnt;

-}

-

-static void 

-ResFindPixmaps (pointer value, XID id, pointer cdata)

-{

-   unsigned long *bytes = (unsigned long *)cdata;

-   PixmapPtr pix = (PixmapPtr)value;

-

-   *bytes += ResGetApproxPixmapBytes(pix);

-}

-

-static void

-ResFindWindowPixmaps (pointer value, XID id, pointer cdata)

-{

-   unsigned long *bytes = (unsigned long *)cdata;

-   WindowPtr pWin = (WindowPtr)value;

-

-   if (pWin->backgroundState == BackgroundPixmap)

-     *bytes += ResGetApproxPixmapBytes(pWin->background.pixmap);

-

-   if (pWin->border.pixmap != NULL && !pWin->borderIsPixel)

-     *bytes += ResGetApproxPixmapBytes(pWin->border.pixmap);

-}

-

-static void

-ResFindGCPixmaps (pointer value, XID id, pointer cdata)

-{

-   unsigned long *bytes = (unsigned long *)cdata;

-   GCPtr pGC = (GCPtr)value;

-

-   if (pGC->stipple != NULL)

-     *bytes += ResGetApproxPixmapBytes(pGC->stipple);

-

-   if (pGC->tile.pixmap != NULL && !pGC->tileIsPixel)

-     *bytes += ResGetApproxPixmapBytes(pGC->tile.pixmap);

-}

-

-static int

-ProcXResQueryClientPixmapBytes (ClientPtr client)

-{

-    REQUEST(xXResQueryClientPixmapBytesReq);

-    xXResQueryClientPixmapBytesReply rep;

-    int clientID;

-    unsigned long bytes;

-

-    REQUEST_SIZE_MATCH(xXResQueryClientPixmapBytesReq);

-

-    clientID = CLIENT_ID(stuff->xid);

-

-    if((clientID >= currentMaxClients) || !clients[clientID]) {

-        client->errorValue = stuff->xid;

-        return BadValue;

-    }

-

-    bytes = 0;

-

-    FindClientResourcesByType(clients[clientID], RT_PIXMAP, ResFindPixmaps, 

-                              (pointer)(&bytes));

-

-    /* 

-     * Make sure win background pixmaps also held to account. 

-     */

-    FindClientResourcesByType(clients[clientID], RT_WINDOW, 

-			      ResFindWindowPixmaps, 

-                              (pointer)(&bytes));

-

-    /* 

-     * GC Tile & Stipple pixmaps too.

-    */

-    FindClientResourcesByType(clients[clientID], RT_GC, 

-			      ResFindGCPixmaps, 

-                              (pointer)(&bytes));

-

-#ifdef COMPOSITE

-    /* FIXME: include composite pixmaps too */

-#endif

-

-    rep.type = X_Reply;

-    rep.sequenceNumber = client->sequence;

-    rep.length = 0;

-    rep.bytes = bytes;

-#ifdef _XSERVER64

-    rep.bytes_overflow = bytes >> 32;

-#else

-    rep.bytes_overflow = 0;

-#endif

-    if (client->swapped) {

-        int n;

-        swaps (&rep.sequenceNumber, n);

-        swapl (&rep.length, n);

-        swapl (&rep.bytes, n);

-        swapl (&rep.bytes_overflow, n);

-    }

-    WriteToClient (client,sizeof(xXResQueryClientPixmapBytesReply),(char*)&rep);

-

-    return Success;

-}

-

-static int

-ProcResDispatch (ClientPtr client)

-{

-    REQUEST(xReq);

-    switch (stuff->data) {

-    case X_XResQueryVersion:

-        return ProcXResQueryVersion(client);

-    case X_XResQueryClients:

-        return ProcXResQueryClients(client);

-    case X_XResQueryClientResources:

-        return ProcXResQueryClientResources(client);

-    case X_XResQueryClientPixmapBytes:

-        return ProcXResQueryClientPixmapBytes(client);

-    default: break;

-    }

-

-    return BadRequest;

-}

-

-static int

-SProcXResQueryVersion (ClientPtr client)

-{

-    REQUEST(xXResQueryVersionReq);

-    int n;

-

-    REQUEST_SIZE_MATCH (xXResQueryVersionReq);

-    swaps(&stuff->client_major,n);

-    swaps(&stuff->client_minor,n);

-    return ProcXResQueryVersion(client);

-}

-

-static int

-SProcXResQueryClientResources (ClientPtr client)

-{

-    REQUEST(xXResQueryClientResourcesReq);

-    int n;

-

-    REQUEST_SIZE_MATCH (xXResQueryClientResourcesReq);

-    swaps(&stuff->xid,n);

-    return ProcXResQueryClientResources(client);

-}

-

-static int

-SProcXResQueryClientPixmapBytes (ClientPtr client)

-{

-    REQUEST(xXResQueryClientPixmapBytesReq);

-    int n;

-

-    REQUEST_SIZE_MATCH (xXResQueryClientPixmapBytesReq);

-    swaps(&stuff->xid,n);

-    return ProcXResQueryClientPixmapBytes(client);

-}

-

-static int

-SProcResDispatch (ClientPtr client)

-{

-    REQUEST(xReq);

-    int n;

-

-    swaps(&stuff->length,n);

-

-    switch (stuff->data) {

-    case X_XResQueryVersion:

-        return SProcXResQueryVersion(client);

-    case X_XResQueryClients:  /* nothing to swap */

-        return ProcXResQueryClients(client);

-    case X_XResQueryClientResources:

-        return SProcXResQueryClientResources(client);

-    case X_XResQueryClientPixmapBytes:

-        return SProcXResQueryClientPixmapBytes(client);

-    default: break;

-    }

-

-    return BadRequest;

-}

-

-void

-ResExtensionInit(INITARGS)

-{

-    (void) AddExtension(XRES_NAME, 0, 0,

-                            ProcResDispatch, SProcResDispatch,

-                            NULL, StandardMinorOpcode);

-}

+/*
+   Copyright (c) 2002  XFree86 Inc
+*/
+
+#ifdef HAVE_DIX_CONFIG_H
+#include <dix-config.h>
+#endif
+
+#include <stdio.h>
+#include <string.h>
+#include <X11/X.h>
+#include <X11/Xproto.h>
+#include "misc.h"
+#include "os.h"
+#include "dixstruct.h"
+#include "extnsionst.h"
+#include "swaprep.h"
+#include "registry.h"
+#include <X11/extensions/XResproto.h>
+#include "pixmapstr.h"
+#include "windowstr.h"
+#include "gcstruct.h"
+#include "modinit.h"
+#include "protocol-versions.h"
+
+static int
+ProcXResQueryVersion (ClientPtr client)
+{
+    REQUEST(xXResQueryVersionReq);
+    xXResQueryVersionReply rep;
+
+    REQUEST_SIZE_MATCH (xXResQueryVersionReq);
+
+    rep.type = X_Reply;
+    rep.length = 0;
+    rep.sequenceNumber = client->sequence;
+    rep.server_major = SERVER_XRES_MAJOR_VERSION;
+    rep.server_minor = SERVER_XRES_MINOR_VERSION;
+    if (client->swapped) { 
+        swaps(&rep.sequenceNumber);
+        swapl(&rep.length);
+        swaps(&rep.server_major);
+        swaps(&rep.server_minor);
+    }
+    WriteToClient(client, sizeof (xXResQueryVersionReply), (char *)&rep);
+    return Success;
+}
+
+static int
+ProcXResQueryClients (ClientPtr client)
+{
+    /* REQUEST(xXResQueryClientsReq); */
+    xXResQueryClientsReply rep;
+    int *current_clients;
+    int i, num_clients;
+
+    REQUEST_SIZE_MATCH(xXResQueryClientsReq);
+
+    current_clients = malloc(currentMaxClients * sizeof(int));
+
+    num_clients = 0;
+    for(i = 0; i < currentMaxClients; i++) {
+       if(clients[i]) {
+           current_clients[num_clients] = i;
+           num_clients++;   
+       }
+    }
+
+    rep.type = X_Reply;
+    rep.sequenceNumber = client->sequence;
+    rep.num_clients = num_clients;
+    rep.length = bytes_to_int32(rep.num_clients * sz_xXResClient);
+    if (client->swapped) {
+        swaps(&rep.sequenceNumber);
+        swapl(&rep.length);
+        swapl(&rep.num_clients);
+    }   
+    WriteToClient (client, sizeof (xXResQueryClientsReply), (char *) &rep);
+
+    if(num_clients) {
+        xXResClient scratch;
+
+        for(i = 0; i < num_clients; i++) {
+            scratch.resource_base = clients[current_clients[i]]->clientAsMask;
+            scratch.resource_mask = RESOURCE_ID_MASK;
+        
+            if(client->swapped) {
+                swapl(&scratch.resource_base);
+                swapl(&scratch.resource_mask);
+            }
+            WriteToClient (client, sz_xXResClient, (char *) &scratch);
+        }
+    }
+
+    free(current_clients);
+
+    return Success;
+}
+
+
+static void
+ResFindAllRes (pointer value, XID id, RESTYPE type, pointer cdata)
+{
+    int *counts = (int *)cdata;
+
+    counts[(type & TypeMask) - 1]++;
+}
+
+static int
+ProcXResQueryClientResources (ClientPtr client)
+{
+    REQUEST(xXResQueryClientResourcesReq);
+    xXResQueryClientResourcesReply rep;
+    int i, clientID, num_types;
+    int *counts;
+
+    REQUEST_SIZE_MATCH(xXResQueryClientResourcesReq);
+
+    clientID = CLIENT_ID(stuff->xid);
+
+    if((clientID >= currentMaxClients) || !clients[clientID]) {
+        client->errorValue = stuff->xid;
+        return BadValue;
+    }
+
+    counts = calloc(lastResourceType + 1, sizeof(int));
+
+    FindAllClientResources(clients[clientID], ResFindAllRes, counts);
+
+    num_types = 0;
+
+    for(i = 0; i <= lastResourceType; i++) {
+       if(counts[i]) num_types++;
+    }
+
+    rep.type = X_Reply;
+    rep.sequenceNumber = client->sequence;
+    rep.num_types = num_types;
+    rep.length = bytes_to_int32(rep.num_types * sz_xXResType);
+    if (client->swapped) {
+        swaps(&rep.sequenceNumber);
+        swapl(&rep.length);
+        swapl(&rep.num_types);
+    }   
+
+    WriteToClient (client,sizeof(xXResQueryClientResourcesReply),(char*)&rep);
+
+    if(num_types) {
+        xXResType scratch;
+	char *name;
+
+        for(i = 0; i < lastResourceType; i++) {
+            if(!counts[i]) continue;
+
+	    name = (char *)LookupResourceName(i + 1);
+            if (strcmp(name, XREGISTRY_UNKNOWN))
+		scratch.resource_type = MakeAtom(name, strlen(name), TRUE);
+	    else {
+                char buf[40];
+                snprintf(buf, sizeof(buf), "Unregistered resource %i", i + 1);
+		scratch.resource_type = MakeAtom(buf, strlen(buf), TRUE);
+            }
+
+            scratch.count = counts[i];
+
+            if(client->swapped) {
+                swapl(&scratch.resource_type);
+                swapl(&scratch.count);
+            }
+            WriteToClient (client, sz_xXResType, (char *) &scratch);
+        }
+    }
+
+    free(counts);
+    
+    return Success;
+}
+
+static unsigned long
+ResGetApproxPixmapBytes (PixmapPtr pix)
+{
+   unsigned long nPixels;
+   int           bytesPerPixel; 
+
+   bytesPerPixel = pix->drawable.bitsPerPixel>>3;
+   nPixels       = pix->drawable.width * pix->drawable.height;
+
+   /* Divide by refcnt as pixmap could be shared between clients,  
+    * so total pixmap mem is shared between these. 
+   */
+   return ( nPixels * bytesPerPixel ) / pix->refcnt;
+}
+
+static void 
+ResFindPixmaps (pointer value, XID id, pointer cdata)
+{
+   unsigned long *bytes = (unsigned long *)cdata;
+   PixmapPtr pix = (PixmapPtr)value;
+
+   *bytes += ResGetApproxPixmapBytes(pix);
+}
+
+static void
+ResFindWindowPixmaps (pointer value, XID id, pointer cdata)
+{
+   unsigned long *bytes = (unsigned long *)cdata;
+   WindowPtr pWin = (WindowPtr)value;
+
+   if (pWin->backgroundState == BackgroundPixmap)
+     *bytes += ResGetApproxPixmapBytes(pWin->background.pixmap);
+
+   if (pWin->border.pixmap != NULL && !pWin->borderIsPixel)
+     *bytes += ResGetApproxPixmapBytes(pWin->border.pixmap);
+}
+
+static void
+ResFindGCPixmaps (pointer value, XID id, pointer cdata)
+{
+   unsigned long *bytes = (unsigned long *)cdata;
+   GCPtr pGC = (GCPtr)value;
+
+   if (pGC->stipple != NULL)
+     *bytes += ResGetApproxPixmapBytes(pGC->stipple);
+
+   if (pGC->tile.pixmap != NULL && !pGC->tileIsPixel)
+     *bytes += ResGetApproxPixmapBytes(pGC->tile.pixmap);
+}
+
+static int
+ProcXResQueryClientPixmapBytes (ClientPtr client)
+{
+    REQUEST(xXResQueryClientPixmapBytesReq);
+    xXResQueryClientPixmapBytesReply rep;
+    int clientID;
+    unsigned long bytes;
+
+    REQUEST_SIZE_MATCH(xXResQueryClientPixmapBytesReq);
+
+    clientID = CLIENT_ID(stuff->xid);
+
+    if((clientID >= currentMaxClients) || !clients[clientID]) {
+        client->errorValue = stuff->xid;
+        return BadValue;
+    }
+
+    bytes = 0;
+
+    FindClientResourcesByType(clients[clientID], RT_PIXMAP, ResFindPixmaps, 
+                              (pointer)(&bytes));
+
+    /* 
+     * Make sure win background pixmaps also held to account. 
+     */
+    FindClientResourcesByType(clients[clientID], RT_WINDOW, 
+			      ResFindWindowPixmaps, 
+                              (pointer)(&bytes));
+
+    /* 
+     * GC Tile & Stipple pixmaps too.
+    */
+    FindClientResourcesByType(clients[clientID], RT_GC, 
+			      ResFindGCPixmaps, 
+                              (pointer)(&bytes));
+
+#ifdef COMPOSITE
+    /* FIXME: include composite pixmaps too */
+#endif
+
+    rep.type = X_Reply;
+    rep.sequenceNumber = client->sequence;
+    rep.length = 0;
+    rep.bytes = bytes;
+#ifdef _XSERVER64
+    rep.bytes_overflow = bytes >> 32;
+#else
+    rep.bytes_overflow = 0;
+#endif
+    if (client->swapped) {
+        swaps(&rep.sequenceNumber);
+        swapl(&rep.length);
+        swapl(&rep.bytes);
+        swapl(&rep.bytes_overflow);
+    }
+    WriteToClient (client,sizeof(xXResQueryClientPixmapBytesReply),(char*)&rep);
+
+    return Success;
+}
+
+static int
+ProcResDispatch (ClientPtr client)
+{
+    REQUEST(xReq);
+    switch (stuff->data) {
+    case X_XResQueryVersion:
+        return ProcXResQueryVersion(client);
+    case X_XResQueryClients:
+        return ProcXResQueryClients(client);
+    case X_XResQueryClientResources:
+        return ProcXResQueryClientResources(client);
+    case X_XResQueryClientPixmapBytes:
+        return ProcXResQueryClientPixmapBytes(client);
+    default: break;
+    }
+
+    return BadRequest;
+}
+
+static int
+SProcXResQueryVersion (ClientPtr client)
+{
+    REQUEST(xXResQueryVersionReq);
+    REQUEST_SIZE_MATCH (xXResQueryVersionReq);
+    return ProcXResQueryVersion(client);
+}
+
+static int
+SProcXResQueryClientResources (ClientPtr client)
+{
+    REQUEST(xXResQueryClientResourcesReq);
+    REQUEST_SIZE_MATCH (xXResQueryClientResourcesReq);
+    swapl(&stuff->xid);
+    return ProcXResQueryClientResources(client);
+}
+
+static int
+SProcXResQueryClientPixmapBytes (ClientPtr client)
+{
+    REQUEST(xXResQueryClientPixmapBytesReq);
+    REQUEST_SIZE_MATCH (xXResQueryClientPixmapBytesReq);
+    swapl(&stuff->xid);
+    return ProcXResQueryClientPixmapBytes(client);
+}
+
+static int
+SProcResDispatch (ClientPtr client)
+{
+    REQUEST(xReq);
+    swaps(&stuff->length);
+
+    switch (stuff->data) {
+    case X_XResQueryVersion:
+        return SProcXResQueryVersion(client);
+    case X_XResQueryClients:  /* nothing to swap */
+        return ProcXResQueryClients(client);
+    case X_XResQueryClientResources:
+        return SProcXResQueryClientResources(client);
+    case X_XResQueryClientPixmapBytes:
+        return SProcXResQueryClientPixmapBytes(client);
+    default: break;
+    }
+
+    return BadRequest;
+}
+
+void
+ResExtensionInit(INITARGS)
+{
+    (void) AddExtension(XRES_NAME, 0, 0,
+                            ProcResDispatch, SProcResDispatch,
+                            NULL, StandardMinorOpcode);
+}
diff --git a/xorg-server/Xext/xselinux_ext.c b/xorg-server/Xext/xselinux_ext.c
index 374571c4b..56f2d1ff2 100644
--- a/xorg-server/Xext/xselinux_ext.c
+++ b/xorg-server/Xext/xselinux_ext.c
@@ -71,11 +71,10 @@ ProcSELinuxQueryVersion(ClientPtr client)
     rep.server_major = SELINUX_MAJOR_VERSION;
     rep.server_minor = SELINUX_MINOR_VERSION;
     if (client->swapped) {
-	int n;
-	swaps(&rep.sequenceNumber, n);
-	swapl(&rep.length, n);
-	swaps(&rep.server_major, n);
-	swaps(&rep.server_minor, n);
+	swaps(&rep.sequenceNumber);
+	swapl(&rep.length);
+	swaps(&rep.server_major);
+	swaps(&rep.server_minor);
     }
     WriteToClient(client, sizeof(rep), (char *)&rep);
     return Success;
@@ -100,10 +99,9 @@ SELinuxSendContextReply(ClientPtr client, security_id_t sid)
     rep.context_len = len;
 
     if (client->swapped) {
-	int n;
-	swapl(&rep.length, n);
-	swaps(&rep.sequenceNumber, n);
-	swapl(&rep.context_len, n);
+	swapl(&rep.length);
+	swaps(&rep.sequenceNumber);
+	swapl(&rep.context_len);
     }
 
     WriteToClient(client, sizeof(SELinuxGetContextReply), (char *)&rep);
@@ -353,17 +351,17 @@ SELinuxSendItemsToClient(ClientPtr client, SELinuxListItemRec *items,
     for (k = 0; k < count; k++) {
 	buf[pos] = items[k].id;
 	if (client->swapped)
-	    swapl(buf + pos, n);
+	    swapl(buf + pos);
 	pos++;
 
 	buf[pos] = items[k].octx_len * 4;
 	if (client->swapped)
-	    swapl(buf + pos, n);
+	    swapl(buf + pos);
 	pos++;
 
 	buf[pos] = items[k].dctx_len * 4;
 	if (client->swapped)
-	    swapl(buf + pos, n);
+	    swapl(buf + pos);
 	pos++;
 
 	memcpy((char *)(buf + pos), items[k].octx, strlen(items[k].octx) + 1);
@@ -379,9 +377,9 @@ SELinuxSendItemsToClient(ClientPtr client, SELinuxListItemRec *items,
     rep.count = count;
 
     if (client->swapped) {
-	swapl(&rep.length, n);
-	swaps(&rep.sequenceNumber, n);
-	swapl(&rep.count, n);
+	swapl(&rep.length);
+	swaps(&rep.sequenceNumber);
+	swapl(&rep.count);
     }
 
     WriteToClient(client, sizeof(SELinuxListItemsReply), (char *)&rep);
@@ -529,11 +527,10 @@ static int
 SProcSELinuxQueryVersion(ClientPtr client)
 {
     REQUEST(SELinuxQueryVersionReq);
-    int n;
 
     REQUEST_SIZE_MATCH(SELinuxQueryVersionReq);
-    swaps(&stuff->client_major, n);
-    swaps(&stuff->client_minor, n);
+    swaps(&stuff->client_major);
+    swaps(&stuff->client_minor);
     return ProcSELinuxQueryVersion(client);
 }
 
@@ -541,10 +538,9 @@ static int
 SProcSELinuxSetCreateContext(ClientPtr client, unsigned offset)
 {
     REQUEST(SELinuxSetCreateContextReq);
-    int n;
 
     REQUEST_AT_LEAST_SIZE(SELinuxSetCreateContextReq);
-    swapl(&stuff->context_len, n);
+    swapl(&stuff->context_len);
     return ProcSELinuxSetCreateContext(client, offset);
 }
 
@@ -552,11 +548,10 @@ static int
 SProcSELinuxSetDeviceContext(ClientPtr client)
 {
     REQUEST(SELinuxSetContextReq);
-    int n;
 
     REQUEST_AT_LEAST_SIZE(SELinuxSetContextReq);
-    swapl(&stuff->id, n);
-    swapl(&stuff->context_len, n);
+    swapl(&stuff->id);
+    swapl(&stuff->context_len);
     return ProcSELinuxSetDeviceContext(client);
 }
 
@@ -564,10 +559,9 @@ static int
 SProcSELinuxGetDeviceContext(ClientPtr client)
 {
     REQUEST(SELinuxGetContextReq);
-    int n;
 
     REQUEST_SIZE_MATCH(SELinuxGetContextReq);
-    swapl(&stuff->id, n);
+    swapl(&stuff->id);
     return ProcSELinuxGetDeviceContext(client);
 }
 
@@ -575,10 +569,9 @@ static int
 SProcSELinuxGetDrawableContext(ClientPtr client)
 {
     REQUEST(SELinuxGetContextReq);
-    int n;
 
     REQUEST_SIZE_MATCH(SELinuxGetContextReq);
-    swapl(&stuff->id, n);
+    swapl(&stuff->id);
     return ProcSELinuxGetDrawableContext(client);
 }
 
@@ -586,11 +579,10 @@ static int
 SProcSELinuxGetPropertyContext(ClientPtr client, pointer privKey)
 {
     REQUEST(SELinuxGetPropertyContextReq);
-    int n;
 
     REQUEST_SIZE_MATCH(SELinuxGetPropertyContextReq);
-    swapl(&stuff->window, n);
-    swapl(&stuff->property, n);
+    swapl(&stuff->window);
+    swapl(&stuff->property);
     return ProcSELinuxGetPropertyContext(client, privKey);
 }
 
@@ -598,10 +590,9 @@ static int
 SProcSELinuxGetSelectionContext(ClientPtr client, pointer privKey)
 {
     REQUEST(SELinuxGetContextReq);
-    int n;
 
     REQUEST_SIZE_MATCH(SELinuxGetContextReq);
-    swapl(&stuff->id, n);
+    swapl(&stuff->id);
     return ProcSELinuxGetSelectionContext(client, privKey);
 }
 
@@ -609,10 +600,9 @@ static int
 SProcSELinuxListProperties(ClientPtr client)
 {
     REQUEST(SELinuxGetContextReq);
-    int n;
 
     REQUEST_SIZE_MATCH(SELinuxGetContextReq);
-    swapl(&stuff->id, n);
+    swapl(&stuff->id);
     return ProcSELinuxListProperties(client);
 }
 
@@ -620,10 +610,9 @@ static int
 SProcSELinuxGetClientContext(ClientPtr client)
 {
     REQUEST(SELinuxGetContextReq);
-    int n;
 
     REQUEST_SIZE_MATCH(SELinuxGetContextReq);
-    swapl(&stuff->id, n);
+    swapl(&stuff->id);
     return ProcSELinuxGetClientContext(client);
 }
 
@@ -631,9 +620,8 @@ static int
 SProcSELinuxDispatch(ClientPtr client)
 {
     REQUEST(xReq);
-    int n;
 
-    swaps(&stuff->length, n);
+    swaps(&stuff->length);
 
     switch (stuff->data) {
     case X_SELinuxQueryVersion:
diff --git a/xorg-server/Xext/xtest.c b/xorg-server/Xext/xtest.c
index cc675c116..945e202d6 100644
--- a/xorg-server/Xext/xtest.c
+++ b/xorg-server/Xext/xtest.c
@@ -91,7 +91,6 @@ static int
 ProcXTestGetVersion(ClientPtr client)
 {
     xXTestGetVersionReply rep;
-    int n;
 
     REQUEST_SIZE_MATCH(xXTestGetVersionReq);
     rep.type = X_Reply;
@@ -100,8 +99,8 @@ ProcXTestGetVersion(ClientPtr client)
     rep.majorVersion = XTestMajorVersion;
     rep.minorVersion = XTestMinorVersion;
     if (client->swapped) {
-        swaps(&rep.sequenceNumber, n);
-        swaps(&rep.minorVersion, n);
+        swaps(&rep.sequenceNumber);
+        swaps(&rep.minorVersion);
     }
     WriteToClient(client, sizeof(xXTestGetVersionReply), (char *)&rep);
     return Success;
@@ -114,7 +113,7 @@ ProcXTestCompareCursor(ClientPtr client)
     xXTestCompareCursorReply rep;
     WindowPtr pWin;
     CursorPtr pCursor;
-    int n, rc;
+    int rc;
     DeviceIntPtr ptr = PickPointer(client);
 
     REQUEST_SIZE_MATCH(xXTestCompareCursorReq);
@@ -139,7 +138,7 @@ ProcXTestCompareCursor(ClientPtr client)
     rep.sequenceNumber = client->sequence;
     rep.same = (wCursor(pWin) == pCursor);
     if (client->swapped) {
-        swaps(&rep.sequenceNumber, n);
+        swaps(&rep.sequenceNumber);
     }
     WriteToClient(client, sizeof(xXTestCompareCursorReply), (char *)&rep);
     return Success;
@@ -348,7 +347,7 @@ ProcXTestFakeInput(ClientPtr client)
         if (client->swapped)
         {
             (void) XTestSwapFakeInput(client, (xReq *)stuff);
-            swaps(&stuff->length, n);
+            swaps(&stuff->length);
         }
         ResetCurrentRequest (client);
         client->sequence--;
@@ -476,25 +475,23 @@ ProcXTestDispatch (ClientPtr client)
 static int
 SProcXTestGetVersion(ClientPtr client)
 {
-    int n;
     REQUEST(xXTestGetVersionReq);
 
-    swaps(&stuff->length, n);
+    swaps(&stuff->length);
     REQUEST_SIZE_MATCH(xXTestGetVersionReq);
-    swaps(&stuff->minorVersion, n);
+    swaps(&stuff->minorVersion);
     return ProcXTestGetVersion(client);
 }
 
 static int
 SProcXTestCompareCursor(ClientPtr client)
 {
-    int n;
     REQUEST(xXTestCompareCursorReq);
 
-    swaps(&stuff->length, n);
+    swaps(&stuff->length);
     REQUEST_SIZE_MATCH(xXTestCompareCursorReq);
-    swapl(&stuff->window, n);
-    swapl(&stuff->cursor, n);
+    swapl(&stuff->window);
+    swapl(&stuff->cursor);
     return ProcXTestCompareCursor(client);
 }
 
@@ -525,10 +522,10 @@ XTestSwapFakeInput(ClientPtr client, xReq *req)
 static int
 SProcXTestFakeInput(ClientPtr client)
 {
-    int n;
+	int n;
     REQUEST(xReq);
 
-    swaps(&stuff->length, n);
+    swaps(&stuff->length);
     n = XTestSwapFakeInput(client, stuff);
     if (n != Success)
         return n;
@@ -538,10 +535,9 @@ SProcXTestFakeInput(ClientPtr client)
 static int
 SProcXTestGrabControl(ClientPtr client)
 {
-    int n;
     REQUEST(xXTestGrabControlReq);
 
-    swaps(&stuff->length, n);
+    swaps(&stuff->length);
     REQUEST_SIZE_MATCH(xXTestGrabControlReq);
     return ProcXTestGrabControl(client);
 }
diff --git a/xorg-server/Xext/xvdisp.c b/xorg-server/Xext/xvdisp.c
index b96843159..364a90cf2 100644
--- a/xorg-server/Xext/xvdisp.c
+++ b/xorg-server/Xext/xvdisp.c
@@ -59,12 +59,10 @@ SWriteQueryExtensionReply(
    ClientPtr client,
    xvQueryExtensionReply *rep
 ){
-  char n;
-
-  swaps(&rep->sequenceNumber, n);
-  swapl(&rep->length, n);
-  swaps(&rep->version, n);
-  swaps(&rep->revision, n);
+  swaps(&rep->sequenceNumber);
+  swapl(&rep->length);
+  swaps(&rep->version);
+  swaps(&rep->revision);
   
   (void)WriteToClient(client, sz_xvQueryExtensionReply, (char *)rep);
 
@@ -76,11 +74,9 @@ SWriteQueryAdaptorsReply(
    ClientPtr client,
    xvQueryAdaptorsReply *rep
 ){
-  char n;
-
-  swaps(&rep->sequenceNumber, n);
-  swapl(&rep->length, n);
-  swaps(&rep->num_adaptors, n);
+  swaps(&rep->sequenceNumber);
+  swapl(&rep->length);
+  swaps(&rep->num_adaptors);
   
   (void)WriteToClient(client, sz_xvQueryAdaptorsReply, (char *)rep);
 
@@ -92,11 +88,9 @@ SWriteQueryEncodingsReply(
    ClientPtr client,
    xvQueryEncodingsReply *rep
 ){
-  char n;
-
-  swaps(&rep->sequenceNumber, n);
-  swapl(&rep->length, n);
-  swaps(&rep->num_encodings, n);
+  swaps(&rep->sequenceNumber);
+  swapl(&rep->length);
+  swaps(&rep->num_encodings);
   
   (void)WriteToClient(client, sz_xvQueryEncodingsReply, (char *)rep);
 
@@ -108,12 +102,10 @@ SWriteAdaptorInfo(
    ClientPtr client,
    xvAdaptorInfo *pAdaptor
 ){
-  char n;
-
-  swapl(&pAdaptor->base_id, n);
-  swaps(&pAdaptor->name_size, n);
-  swaps(&pAdaptor->num_ports, n);
-  swaps(&pAdaptor->num_formats, n);
+  swapl(&pAdaptor->base_id);
+  swaps(&pAdaptor->name_size);
+  swaps(&pAdaptor->num_ports);
+  swaps(&pAdaptor->num_formats);
 
   (void)WriteToClient(client, sz_xvAdaptorInfo, (char *)pAdaptor);
 
@@ -125,14 +117,13 @@ SWriteEncodingInfo(
    ClientPtr client,
    xvEncodingInfo *pEncoding
 ){
-  char n;
   
-  swapl(&pEncoding->encoding, n);
-  swaps(&pEncoding->name_size, n);
-  swaps(&pEncoding->width, n);
-  swaps(&pEncoding->height, n);
-  swapl(&pEncoding->rate.numerator, n);
-  swapl(&pEncoding->rate.denominator, n);
+  swapl(&pEncoding->encoding);
+  swaps(&pEncoding->name_size);
+  swaps(&pEncoding->width);
+  swaps(&pEncoding->height);
+  swapl(&pEncoding->rate.numerator);
+  swapl(&pEncoding->rate.denominator);
   (void)WriteToClient(client, sz_xvEncodingInfo, (char *)pEncoding);
 
   return Success;
@@ -143,9 +134,7 @@ SWriteFormat(
    ClientPtr client,
    xvFormat *pFormat
 ){
-  char n;
-
-  swapl(&pFormat->visual, n);
+  swapl(&pFormat->visual);
   (void)WriteToClient(client, sz_xvFormat, (char *)pFormat);
 
   return Success;
@@ -156,12 +145,10 @@ SWriteAttributeInfo(
    ClientPtr client,
    xvAttributeInfo *pAtt
 ){
-  char n;
-
-  swapl(&pAtt->flags, n);
-  swapl(&pAtt->size, n);
-  swapl(&pAtt->min, n);
-  swapl(&pAtt->max, n);
+  swapl(&pAtt->flags);
+  swapl(&pAtt->size);
+  swapl(&pAtt->min);
+  swapl(&pAtt->max);
   (void)WriteToClient(client, sz_xvAttributeInfo, (char *)pAtt);
 
   return Success;
@@ -172,21 +159,19 @@ SWriteImageFormatInfo(
    ClientPtr client,
    xvImageFormatInfo *pImage
 ){
-  char n;
-
-  swapl(&pImage->id, n);
-  swapl(&pImage->red_mask, n);
-  swapl(&pImage->green_mask, n);
-  swapl(&pImage->blue_mask, n);
-  swapl(&pImage->y_sample_bits, n);
-  swapl(&pImage->u_sample_bits, n);
-  swapl(&pImage->v_sample_bits, n);
-  swapl(&pImage->horz_y_period, n);
-  swapl(&pImage->horz_u_period, n);
-  swapl(&pImage->horz_v_period, n);
-  swapl(&pImage->vert_y_period, n);
-  swapl(&pImage->vert_u_period, n);
-  swapl(&pImage->vert_v_period, n);
+  swapl(&pImage->id);
+  swapl(&pImage->red_mask);
+  swapl(&pImage->green_mask);
+  swapl(&pImage->blue_mask);
+  swapl(&pImage->y_sample_bits);
+  swapl(&pImage->u_sample_bits);
+  swapl(&pImage->v_sample_bits);
+  swapl(&pImage->horz_y_period);
+  swapl(&pImage->horz_u_period);
+  swapl(&pImage->horz_v_period);
+  swapl(&pImage->vert_y_period);
+  swapl(&pImage->vert_u_period);
+  swapl(&pImage->vert_v_period);
 
   (void)WriteToClient(client, sz_xvImageFormatInfo, (char *)pImage);
 
@@ -198,10 +183,8 @@ SWriteGrabPortReply(
    ClientPtr client,
    xvGrabPortReply *rep
 ){
-  char n;
-
-  swaps(&rep->sequenceNumber, n);
-  swapl(&rep->length, n);
+  swaps(&rep->sequenceNumber);
+  swapl(&rep->length);
 
   (void)WriteToClient(client, sz_xvGrabPortReply, (char *)rep);
 
@@ -213,11 +196,9 @@ SWriteGetPortAttributeReply(
    ClientPtr client,
    xvGetPortAttributeReply *rep
 ){
-  char n;
-
-  swaps(&rep->sequenceNumber, n);
-  swapl(&rep->length, n);
-  swapl(&rep->value, n);
+  swaps(&rep->sequenceNumber);
+  swapl(&rep->length);
+  swapl(&rep->value);
 
   (void)WriteToClient(client, sz_xvGetPortAttributeReply, (char *)rep);
 
@@ -229,12 +210,10 @@ SWriteQueryBestSizeReply(
    ClientPtr client,
    xvQueryBestSizeReply *rep
 ){
-  char n;
-
-  swaps(&rep->sequenceNumber, n);
-  swapl(&rep->length, n);
-  swaps(&rep->actual_width, n);
-  swaps(&rep->actual_height, n);
+  swaps(&rep->sequenceNumber);
+  swapl(&rep->length);
+  swaps(&rep->actual_width);
+  swaps(&rep->actual_height);
 
   (void)WriteToClient(client, sz_xvQueryBestSizeReply, (char *)rep);
 
@@ -246,12 +225,10 @@ SWriteQueryPortAttributesReply(
    ClientPtr client,
    xvQueryPortAttributesReply *rep
 ){
-  char n;
-
-  swaps(&rep->sequenceNumber, n);
-  swapl(&rep->length, n);
-  swapl(&rep->num_attributes, n);
-  swapl(&rep->text_size, n);
+  swaps(&rep->sequenceNumber);
+  swapl(&rep->length);
+  swapl(&rep->num_attributes);
+  swapl(&rep->text_size);
 
   (void)WriteToClient(client, sz_xvQueryPortAttributesReply, (char *)rep);
 
@@ -263,14 +240,12 @@ SWriteQueryImageAttributesReply(
    ClientPtr client,
    xvQueryImageAttributesReply *rep
 ){
-  char n;
-
-  swaps(&rep->sequenceNumber, n);
-  swapl(&rep->length, n);
-  swapl(&rep->num_planes, n);
-  swapl(&rep->data_size, n);
-  swaps(&rep->width, n);
-  swaps(&rep->height, n);
+  swaps(&rep->sequenceNumber);
+  swapl(&rep->length);
+  swapl(&rep->num_planes);
+  swapl(&rep->data_size);
+  swaps(&rep->width);
+  swaps(&rep->height);
 
   (void)WriteToClient(client, sz_xvQueryImageAttributesReply, (char *)rep);
 
@@ -282,11 +257,9 @@ SWriteListImageFormatsReply(
    ClientPtr client,
    xvListImageFormatsReply *rep
 ){
-  char n;
-
-  swaps(&rep->sequenceNumber, n);
-  swapl(&rep->length, n);
-  swapl(&rep->num_formats, n);
+  swaps(&rep->sequenceNumber);
+  swapl(&rep->length);
+  swapl(&rep->num_formats);
 
   (void)WriteToClient(client, sz_xvListImageFormatsReply, (char *)rep);
 
@@ -1278,154 +1251,144 @@ ProcXvDispatch(ClientPtr client)
 static int
 SProcXvQueryExtension(ClientPtr client)
 {
-  char n;
   REQUEST(xvQueryExtensionReq);
-  swaps(&stuff->length, n);
+  swaps(&stuff->length);
   return XvProcVector[xv_QueryExtension](client);
 }
 
 static int
 SProcXvQueryAdaptors(ClientPtr client)
 {
-  char n;
   REQUEST(xvQueryAdaptorsReq);
-  swaps(&stuff->length, n);
-  swapl(&stuff->window, n);
+  swaps(&stuff->length);
+  swapl(&stuff->window);
   return XvProcVector[xv_QueryAdaptors](client);
 }
 
 static int
 SProcXvQueryEncodings(ClientPtr client)
 {
-  char n;
   REQUEST(xvQueryEncodingsReq);
-  swaps(&stuff->length, n);
-  swapl(&stuff->port, n);
+  swaps(&stuff->length);
+  swapl(&stuff->port);
   return XvProcVector[xv_QueryEncodings](client);
 }
 
 static int
 SProcXvGrabPort(ClientPtr client)
 {
-  char n;
   REQUEST(xvGrabPortReq);
-  swaps(&stuff->length, n);
-  swapl(&stuff->port, n);
-  swapl(&stuff->time, n);
+  swaps(&stuff->length);
+  swapl(&stuff->port);
+  swapl(&stuff->time);
   return XvProcVector[xv_GrabPort](client);
 }
 
 static int
 SProcXvUngrabPort(ClientPtr client)
 {
-  char n;
   REQUEST(xvUngrabPortReq);
-  swaps(&stuff->length, n);
-  swapl(&stuff->port, n);
-  swapl(&stuff->time, n);
+  swaps(&stuff->length);
+  swapl(&stuff->port);
+  swapl(&stuff->time);
   return XvProcVector[xv_UngrabPort](client);
 }
 
 static int
 SProcXvPutVideo(ClientPtr client)
 {
-  char n;
   REQUEST(xvPutVideoReq);
-  swaps(&stuff->length, n);
-  swapl(&stuff->port, n);
-  swapl(&stuff->drawable, n);
-  swapl(&stuff->gc, n);
-  swaps(&stuff->vid_x, n);
-  swaps(&stuff->vid_y, n);
-  swaps(&stuff->vid_w, n);
-  swaps(&stuff->vid_h, n);
-  swaps(&stuff->drw_x, n);
-  swaps(&stuff->drw_y, n);
-  swaps(&stuff->drw_w, n);
-  swaps(&stuff->drw_h, n);
+  swaps(&stuff->length);
+  swapl(&stuff->port);
+  swapl(&stuff->drawable);
+  swapl(&stuff->gc);
+  swaps(&stuff->vid_x);
+  swaps(&stuff->vid_y);
+  swaps(&stuff->vid_w);
+  swaps(&stuff->vid_h);
+  swaps(&stuff->drw_x);
+  swaps(&stuff->drw_y);
+  swaps(&stuff->drw_w);
+  swaps(&stuff->drw_h);
   return XvProcVector[xv_PutVideo](client);
 }
 
 static int
 SProcXvPutStill(ClientPtr client)
 {
-  char n;
   REQUEST(xvPutStillReq);
-  swaps(&stuff->length, n);
-  swapl(&stuff->port, n);
-  swapl(&stuff->drawable, n);
-  swapl(&stuff->gc, n);
-  swaps(&stuff->vid_x, n);
-  swaps(&stuff->vid_y, n);
-  swaps(&stuff->vid_w, n);
-  swaps(&stuff->vid_h, n);
-  swaps(&stuff->drw_x, n);
-  swaps(&stuff->drw_y, n);
-  swaps(&stuff->drw_w, n);
-  swaps(&stuff->drw_h, n);
+  swaps(&stuff->length);
+  swapl(&stuff->port);
+  swapl(&stuff->drawable);
+  swapl(&stuff->gc);
+  swaps(&stuff->vid_x);
+  swaps(&stuff->vid_y);
+  swaps(&stuff->vid_w);
+  swaps(&stuff->vid_h);
+  swaps(&stuff->drw_x);
+  swaps(&stuff->drw_y);
+  swaps(&stuff->drw_w);
+  swaps(&stuff->drw_h);
   return XvProcVector[xv_PutStill](client);
 }
 
 static int
 SProcXvGetVideo(ClientPtr client)
 {
-  char n;
   REQUEST(xvGetVideoReq);
-  swaps(&stuff->length, n);
-  swapl(&stuff->port, n);
-  swapl(&stuff->drawable, n);
-  swapl(&stuff->gc, n);
-  swaps(&stuff->vid_x, n);
-  swaps(&stuff->vid_y, n);
-  swaps(&stuff->vid_w, n);
-  swaps(&stuff->vid_h, n);
-  swaps(&stuff->drw_x, n);
-  swaps(&stuff->drw_y, n);
-  swaps(&stuff->drw_w, n);
-  swaps(&stuff->drw_h, n);
+  swaps(&stuff->length);
+  swapl(&stuff->port);
+  swapl(&stuff->drawable);
+  swapl(&stuff->gc);
+  swaps(&stuff->vid_x);
+  swaps(&stuff->vid_y);
+  swaps(&stuff->vid_w);
+  swaps(&stuff->vid_h);
+  swaps(&stuff->drw_x);
+  swaps(&stuff->drw_y);
+  swaps(&stuff->drw_w);
+  swaps(&stuff->drw_h);
   return XvProcVector[xv_GetVideo](client);
 }
 
 static int
 SProcXvGetStill(ClientPtr client)
 {
-  char n;
   REQUEST(xvGetStillReq);
-  swaps(&stuff->length, n);
-  swapl(&stuff->port, n);
-  swapl(&stuff->drawable, n);
-  swapl(&stuff->gc, n);
-  swaps(&stuff->vid_x, n);
-  swaps(&stuff->vid_y, n);
-  swaps(&stuff->vid_w, n);
-  swaps(&stuff->vid_h, n);
-  swaps(&stuff->drw_x, n);
-  swaps(&stuff->drw_y, n);
-  swaps(&stuff->drw_w, n);
-  swaps(&stuff->drw_h, n);
+  swaps(&stuff->length);
+  swapl(&stuff->port);
+  swapl(&stuff->drawable);
+  swapl(&stuff->gc);
+  swaps(&stuff->vid_x);
+  swaps(&stuff->vid_y);
+  swaps(&stuff->vid_w);
+  swaps(&stuff->vid_h);
+  swaps(&stuff->drw_x);
+  swaps(&stuff->drw_y);
+  swaps(&stuff->drw_w);
+  swaps(&stuff->drw_h);
   return XvProcVector[xv_GetStill](client);
 }
 
 static int
 SProcXvPutImage(ClientPtr client)
 {
-  char n;
   REQUEST(xvPutImageReq);
-  swaps(&stuff->length, n);
-  swapl(&stuff->port, n);
-  swapl(&stuff->drawable, n);
-  swapl(&stuff->gc, n);
-  swapl(&stuff->id, n);
-  swaps(&stuff->src_x, n);
-  swaps(&stuff->src_y, n);
-  swaps(&stuff->src_w, n);
-  swaps(&stuff->src_h, n);
-  swaps(&stuff->drw_x, n);
-  swaps(&stuff->drw_y, n);
-  swaps(&stuff->drw_w, n);
-  swaps(&stuff->drw_h, n);
-  swaps(&stuff->width, n);
-  swaps(&stuff->height, n);
+  swaps(&stuff->length);
+  swapl(&stuff->port);
+  swapl(&stuff->drawable);
+  swapl(&stuff->gc);
+  swapl(&stuff->id);
+  swaps(&stuff->src_x);
+  swaps(&stuff->src_y);
+  swaps(&stuff->src_w);
+  swaps(&stuff->src_h);
+  swaps(&stuff->drw_x);
+  swaps(&stuff->drw_y);
+  swaps(&stuff->drw_w);
+  swaps(&stuff->drw_h);
+  swaps(&stuff->width);
+  swaps(&stuff->height);
   return XvProcVector[xv_PutImage](client);
 }
 
@@ -1433,25 +1396,24 @@ SProcXvPutImage(ClientPtr client)
 static int
 SProcXvShmPutImage(ClientPtr client)
 {
-  char n;
   REQUEST(xvShmPutImageReq);
-  swaps(&stuff->length, n);
-  swapl(&stuff->port, n);
-  swapl(&stuff->drawable, n);
-  swapl(&stuff->gc, n);
-  swapl(&stuff->shmseg, n);
-  swapl(&stuff->id, n);
-  swapl(&stuff->offset, n);
-  swaps(&stuff->src_x, n);
-  swaps(&stuff->src_y, n);
-  swaps(&stuff->src_w, n);
-  swaps(&stuff->src_h, n);
-  swaps(&stuff->drw_x, n);
-  swaps(&stuff->drw_y, n);
-  swaps(&stuff->drw_w, n);
-  swaps(&stuff->drw_h, n);
-  swaps(&stuff->width, n);
-  swaps(&stuff->height, n);
+  swaps(&stuff->length);
+  swapl(&stuff->port);
+  swapl(&stuff->drawable);
+  swapl(&stuff->gc);
+  swapl(&stuff->shmseg);
+  swapl(&stuff->id);
+  swapl(&stuff->offset);
+  swaps(&stuff->src_x);
+  swaps(&stuff->src_y);
+  swaps(&stuff->src_w);
+  swaps(&stuff->src_h);
+  swaps(&stuff->drw_x);
+  swaps(&stuff->drw_y);
+  swaps(&stuff->drw_w);
+  swaps(&stuff->drw_h);
+  swaps(&stuff->width);
+  swaps(&stuff->height);
   return XvProcVector[xv_ShmPutImage](client);
 }
 #else /* MITSHM */
@@ -1461,101 +1423,92 @@ SProcXvShmPutImage(ClientPtr client)
 static int
 SProcXvSelectVideoNotify(ClientPtr client)
 {
-  char n;
   REQUEST(xvSelectVideoNotifyReq);
-  swaps(&stuff->length, n);
-  swapl(&stuff->drawable, n);
+  swaps(&stuff->length);
+  swapl(&stuff->drawable);
   return XvProcVector[xv_SelectVideoNotify](client);
 }
 
 static int
 SProcXvSelectPortNotify(ClientPtr client)
 {
-  char n;
   REQUEST(xvSelectPortNotifyReq);
-  swaps(&stuff->length, n);
-  swapl(&stuff->port, n);
+  swaps(&stuff->length);
+  swapl(&stuff->port);
   return XvProcVector[xv_SelectPortNotify](client);
 }
 
 static int
 SProcXvStopVideo(ClientPtr client)
 {
-  char n;
   REQUEST(xvStopVideoReq);
-  swaps(&stuff->length, n);
-  swapl(&stuff->port, n);
-  swapl(&stuff->drawable, n);
+  swaps(&stuff->length);
+  swapl(&stuff->port);
+  swapl(&stuff->drawable);
   return XvProcVector[xv_StopVideo](client);
 }
 
 static int
 SProcXvSetPortAttribute(ClientPtr client)
 {
-  char n;
   REQUEST(xvSetPortAttributeReq);
-  swaps(&stuff->length, n);
-  swapl(&stuff->port, n);
-  swapl(&stuff->attribute, n);
-  swapl(&stuff->value, n);
+  swaps(&stuff->length);
+  swapl(&stuff->port);
+  swapl(&stuff->attribute);
+  swapl(&stuff->value);
   return XvProcVector[xv_SetPortAttribute](client);
 }
 
 static int
 SProcXvGetPortAttribute(ClientPtr client)
 {
-  char n;
   REQUEST(xvGetPortAttributeReq);
-  swaps(&stuff->length, n);
-  swapl(&stuff->port, n);
-  swapl(&stuff->attribute, n);
+  swaps(&stuff->length);
+  swapl(&stuff->port);
+  swapl(&stuff->attribute);
   return XvProcVector[xv_GetPortAttribute](client);
 }
 
 static int
 SProcXvQueryBestSize(ClientPtr client)
 {
-  char n;
   REQUEST(xvQueryBestSizeReq);
-  swaps(&stuff->length, n);
-  swapl(&stuff->port, n);
-  swaps(&stuff->vid_w, n);
-  swaps(&stuff->vid_h, n);
-  swaps(&stuff->drw_w, n);
-  swaps(&stuff->drw_h, n);
+  swaps(&stuff->length);
+  swapl(&stuff->port);
+  swaps(&stuff->vid_w);
+  swaps(&stuff->vid_h);
+  swaps(&stuff->drw_w);
+  swaps(&stuff->drw_h);
   return XvProcVector[xv_QueryBestSize](client);
 }
 
 static int
 SProcXvQueryPortAttributes(ClientPtr client)
 {
-  char n;
   REQUEST(xvQueryPortAttributesReq);
-  swaps(&stuff->length, n);
-  swapl(&stuff->port, n);
+  swaps(&stuff->length);
+  swapl(&stuff->port);
   return XvProcVector[xv_QueryPortAttributes](client);
 }
 
 static int
 SProcXvQueryImageAttributes(ClientPtr client)
 {
-  char n;
   REQUEST(xvQueryImageAttributesReq);
-  swaps(&stuff->length, n);
-  swapl(&stuff->port, n);
-  swapl(&stuff->id, n);
-  swaps(&stuff->width, n);
-  swaps(&stuff->height, n);
+  swaps(&stuff->length);
+  swapl(&stuff->port);
+  swapl(&stuff->id);
+  swaps(&stuff->width);
+  swaps(&stuff->height);
   return XvProcVector[xv_QueryImageAttributes](client);
 }
 
 static int
 SProcXvListImageFormats(ClientPtr client)
 {
-  char n;
   REQUEST(xvListImageFormatsReq);
-  swaps(&stuff->length, n);
-  swapl(&stuff->port, n);
+  swaps(&stuff->length);
+  swapl(&stuff->port);
   return XvProcVector[xv_ListImageFormats](client);
 }