svn merge ^/branches/released

40 files changed, 7219 insertions, 7374 deletions

diff --git a/xorg-server/COPYING b/xorg-server/COPYING
index 0878c7a76..3fb06b8df 100644
--- a/xorg-server/COPYING
+++ b/xorg-server/COPYING
@@ -1,10 +1,12 @@
 The following is the 'standard copyright' agreed upon by most contributors,
-and is currently the canonical license, though a modification is currently
-under discussion.  Copyright holders of new code should use this license
-statement where possible, and append their name to this list.  Please sort
-by surname for people, and by the full name for other entities (e.g.
-Juliusz Chroboczek sorts before Intel Corporation sorts before Daniel
-Stone).
+and is currently the canonical license preferred by the X.Org Foundation.
+This is a slight variant of the common MIT license form published by the
+Open Source Initiative at http://www.opensource.org/licenses/mit-license.php
+
+Copyright holders of new code should use this license statement where
+possible, and insert their name to this list.  Please sort by surname
+for people, and by the full name for other entities (e.g.  Juliusz
+Chroboczek sorts before Intel Corporation sorts before Daniel Stone).
 
 Copyright © 2000-2001 Juliusz Chroboczek
 Copyright © 1998 Egbert Eich
@@ -17,6 +19,7 @@ Copyright © 1999 Keith Packard
 Copyright © 2007-2009 Red Hat, Inc.
 Copyright © 2005-2008 Daniel Stone
 Copyright © 2006-2009 Simon Thum
+Copyright © 1987, 2003-2006, 2008-2009 Sun Microsystems, Inc.
 Copyright © 2006 Luc Verhaegen
 
 Permission is hereby granted, free of charge, to any person obtaining a
@@ -162,32 +165,6 @@ OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
 CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 
 
-Copyright 1987 by Sun Microsystems, Inc. Mountain View, CA.
-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 no-
-tice  appear  in all copies and that both that copyright no-
-tice and this permission notice appear in  supporting  docu-
-mentation,  and  that the names of Sun or X Consortium
-not be used in advertising or publicity pertaining to
-distribution  of  the software  without specific prior
-written permission. Sun and X Consortium make no
-representations about the suitability of this software for
-any purpose. It is provided "as is" without any express or
-implied warranty.
-
-SUN DISCLAIMS ALL WARRANTIES WITH REGARD TO  THIS  SOFTWARE,
-INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FIT-
-NESS FOR A PARTICULAR PURPOSE. IN NO EVENT SHALL SUN BE  LI-
-ABLE  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.
-
-
 Copyright 1987-1991, 1993 by Digital Equipment Corporation, Maynard, Massachusetts.
 Copyright 1991 Massachusetts Institute of Technology, Cambridge, Massachusetts.
 Copyright 1991, 1993 Olivetti Research Limited, Cambridge, England.
@@ -1383,7 +1360,6 @@ Copyright 1987, 1998  The Open Group
 Copyright © 1998-1999, 2001 The XFree86 Project, Inc.
 Copyright © 2000 VA Linux Systems, Inc.
 Copyright (c) 2000, 2001 Nokia Home Communications
-Copyright 2003-2006, 2008 Sun Microsystems, Inc.
 Copyright © 2007, 2008 Red Hat, Inc.
 All rights reserved.
 
diff --git a/xorg-server/composite/compalloc.c b/xorg-server/composite/compalloc.c
index 560a1a24c..978fe5c17 100644
--- a/xorg-server/composite/compalloc.c
+++ b/xorg-server/composite/compalloc.c
@@ -1,653 +1,647 @@
-/*
- * Copyright © 2006 Sun Microsystems, Inc.  All rights reserved.
- *
- * 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, and/or sell copies of the Software, and to permit persons
- * to whom the Software is furnished to do so, provided that the above
- * copyright notice(s) and this permission notice appear in all copies of
- * the Software and that both the above copyright notice(s) and this
- * permission notice appear in supporting documentation.
- *
- * 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
- * OF THIRD PARTY RIGHTS. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
- * HOLDERS INCLUDED IN THIS NOTICE BE LIABLE FOR ANY CLAIM, OR 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.
- *
- * Except as contained in this notice, the name of a copyright holder
- * shall not be used in advertising or otherwise to promote the sale, use
- * or other dealings in this Software without prior written authorization
- * of the copyright holder.
- *
- * Copyright © 2003 Keith Packard
- *
- * 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, and that the name of Keith Packard not be used in
- * advertising or publicity pertaining to distribution of the software without
- * specific, written prior permission.  Keith Packard makes no
- * representations about the suitability of this software for any purpose.  It
- * is provided "as is" without express or implied warranty.
- *
- * KEITH PACKARD DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
- * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
- * EVENT SHALL KEITH PACKARD 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 "compint.h"
-
-static void
-compReportDamage (DamagePtr pDamage, RegionPtr pRegion, void *closure)
-{
-    WindowPtr	    pWin = (WindowPtr) closure;
-    ScreenPtr	    pScreen = pWin->drawable.pScreen;
-    CompScreenPtr   cs = GetCompScreen (pScreen);
-    CompWindowPtr   cw = GetCompWindow (pWin);
-
-    cs->damaged = TRUE;
-    cw->damaged = TRUE;
-}
-
-static void
-compDestroyDamage (DamagePtr pDamage, void *closure)
-{
-    WindowPtr	    pWin = (WindowPtr) closure;
-    CompWindowPtr   cw = GetCompWindow (pWin);
-
-    cw->damage = 0;
-}
-
-/*
- * Redirect one window for one client
- */
-int
-compRedirectWindow (ClientPtr pClient, WindowPtr pWin, int update)
-{
-    CompWindowPtr	cw = GetCompWindow (pWin);
-    CompClientWindowPtr	ccw;
-    Bool		wasMapped = pWin->mapped;
-    CompScreenPtr       cs = GetCompScreen(pWin->drawable.pScreen);
-    
-    if (pWin == cs->pOverlayWin) {
-	return Success;
-    }
-
-    if (!pWin->parent)
-	return BadMatch;
-
-    /*
-     * Only one Manual update is allowed
-     */
-    if (cw && update == CompositeRedirectManual)
-	for (ccw = cw->clients; ccw; ccw = ccw->next)
-	    if (ccw->update == CompositeRedirectManual)
-		return BadAccess;
-    
-    /*
-     * Allocate per-client per-window structure 
-     * The client *could* allocate multiple, but while supported,
-     * it is not expected to be common
-     */
-    ccw = xalloc (sizeof (CompClientWindowRec));
-    if (!ccw)
-	return BadAlloc;
-    ccw->id = FakeClientID (pClient->index);
-    ccw->update = update;
-    /*
-     * Now make sure there's a per-window structure to hang this from
-     */
-    if (!cw)
-    {
-	cw = xcalloc (1,sizeof (CompWindowRec));
-	if (!cw)
-	{
-	    xfree (ccw);
-	    return BadAlloc;
-	}
-	cw->damage = DamageCreate (compReportDamage,
-				   compDestroyDamage,
-				   DamageReportNonEmpty,
-				   FALSE,
-				   pWin->drawable.pScreen,
-				   pWin);
-	if (!cw->damage)
-	{
-	    xfree (ccw);
-	    xfree (cw);
-	    return BadAlloc;
-	}
-	if (wasMapped)
-	{
-	    DisableMapUnmapEvents (pWin);
-	    UnmapWindow (pWin, FALSE);
-	    EnableMapUnmapEvents (pWin);
-	}
-
-	REGION_NULL (pScreen, &cw->borderClip);
-	cw->borderClipX = 0;
-	cw->borderClipY = 0;
-	cw->update = CompositeRedirectAutomatic;
-	cw->clients = 0;
-	cw->oldx = COMP_ORIGIN_INVALID;
-	cw->oldy = COMP_ORIGIN_INVALID;
-	cw->damageRegistered = FALSE;
-	cw->damaged = FALSE;
-	dixSetPrivate(&pWin->devPrivates, CompWindowPrivateKey, cw);
-    }
-    ccw->next = cw->clients;
-    cw->clients = ccw;
-    if (!AddResource (ccw->id, CompositeClientWindowType, pWin))
-	return BadAlloc;
-    if (ccw->update == CompositeRedirectManual)
-    {
-	/* If the window was CompositeRedirectAutomatic, then
-	 * unmap the window so that the parent clip list will
-	 * be correctly recomputed.
-	 */
-	if (pWin->mapped) 
-	{
-	    DisableMapUnmapEvents (pWin);
-	    UnmapWindow (pWin, FALSE);
-	    EnableMapUnmapEvents (pWin);
-	}
-	if (cw->damageRegistered)
-	{
-	    DamageUnregister (&pWin->drawable, cw->damage);
-	    cw->damageRegistered = FALSE;
-	}
-	cw->update = CompositeRedirectManual;
-    }
-
-    if (!compCheckRedirect (pWin))
-    {
-	FreeResource (ccw->id, RT_NONE);
-	return BadAlloc;
-    }
-    if (wasMapped && !pWin->mapped)
-    {
-	Bool	overrideRedirect = pWin->overrideRedirect;
-	pWin->overrideRedirect = TRUE;
-	DisableMapUnmapEvents (pWin);
-	MapWindow (pWin, pClient);
-	EnableMapUnmapEvents (pWin);
-	pWin->overrideRedirect = overrideRedirect;
-    }
-    
-    return Success;
-}
-
-/*
- * Free one of the per-client per-window resources, clearing
- * redirect and the per-window pointer as appropriate
- */
-void
-compFreeClientWindow (WindowPtr pWin, XID id)
-{
-    CompWindowPtr	cw = GetCompWindow (pWin);
-    CompClientWindowPtr	ccw, *prev;
-    Bool		wasMapped = pWin->mapped;
-
-    if (!cw)
-	return;
-    for (prev = &cw->clients; (ccw = *prev); prev = &ccw->next)
-    {
-	if (ccw->id == id)
-	{
-	    *prev = ccw->next;
-	    if (ccw->update == CompositeRedirectManual)
-		cw->update = CompositeRedirectAutomatic;
-	    xfree (ccw);
-	    break;
-	}
-    }
-    if (!cw->clients)
-    {
-	if (wasMapped)
-	{
-	    DisableMapUnmapEvents (pWin);
-	    UnmapWindow (pWin, FALSE);
-	    EnableMapUnmapEvents (pWin);
-	}
-    
-	if (pWin->redirectDraw != RedirectDrawNone)
-	    compFreePixmap (pWin);
-
-	if (cw->damage)
-	    DamageDestroy (cw->damage);
-	
-	REGION_UNINIT (pScreen, &cw->borderClip);
-    
-	dixSetPrivate(&pWin->devPrivates, CompWindowPrivateKey, NULL);
-	xfree (cw);
-    }
-    else if (cw->update == CompositeRedirectAutomatic &&
-	     !cw->damageRegistered && pWin->redirectDraw != RedirectDrawNone)
-    {
-	DamageRegister (&pWin->drawable, cw->damage);
-	cw->damageRegistered = TRUE;
-	pWin->redirectDraw = RedirectDrawAutomatic;
-	DamageRegionAppend(&pWin->drawable, &pWin->borderSize);
-    }
-    if (wasMapped && !pWin->mapped)
-    {
-	Bool	overrideRedirect = pWin->overrideRedirect;
-	pWin->overrideRedirect = TRUE;
-	DisableMapUnmapEvents (pWin);
-	MapWindow (pWin, clients[CLIENT_ID(id)]);
-	EnableMapUnmapEvents (pWin);
-	pWin->overrideRedirect = overrideRedirect;
-    }
-}
-
-/*
- * This is easy, just free the appropriate resource.
- */
-
-int
-compUnredirectWindow (ClientPtr pClient, WindowPtr pWin, int update)
-{
-    CompWindowPtr	cw = GetCompWindow (pWin);
-    CompClientWindowPtr	ccw;
-
-    if (!cw)
-	return BadValue;
-
-    for (ccw = cw->clients; ccw; ccw = ccw->next)
-	if (ccw->update == update && CLIENT_ID(ccw->id) == pClient->index)
-	{
-	    FreeResource (ccw->id, RT_NONE);
-	    return Success;
-	}
-    return BadValue;
-}
-	
-/*
- * Redirect all subwindows for one client
- */
-
-int
-compRedirectSubwindows (ClientPtr pClient, WindowPtr pWin, int update)
-{
-    CompSubwindowsPtr	csw = GetCompSubwindows (pWin);
-    CompClientWindowPtr	ccw;
-    WindowPtr		pChild;
-
-    /*
-     * Only one Manual update is allowed
-     */
-    if (csw && update == CompositeRedirectManual)
-	for (ccw = csw->clients; ccw; ccw = ccw->next)
-	    if (ccw->update == CompositeRedirectManual)
-		return BadAccess;
-    /*
-     * Allocate per-client per-window structure 
-     * The client *could* allocate multiple, but while supported,
-     * it is not expected to be common
-     */
-    ccw = xalloc (sizeof (CompClientWindowRec));
-    if (!ccw)
-	return BadAlloc;
-    ccw->id = FakeClientID (pClient->index);
-    ccw->update = update;
-    /*
-     * Now make sure there's a per-window structure to hang this from
-     */
-    if (!csw)
-    {
-	csw = xalloc (sizeof (CompSubwindowsRec));
-	if (!csw)
-	{
-	    xfree (ccw);
-	    return BadAlloc;
-	}
-	csw->update = CompositeRedirectAutomatic;
-	csw->clients = 0;
-	dixSetPrivate(&pWin->devPrivates, CompSubwindowsPrivateKey, csw);
-    }
-    /*
-     * Redirect all existing windows
-     */
-    for (pChild = pWin->lastChild; pChild; pChild = pChild->prevSib)
-    {
-	int ret = compRedirectWindow (pClient, pChild, update);
-	if (ret != Success)
-	{
-	    for (pChild = pChild->nextSib; pChild; pChild = pChild->nextSib)
-		(void) compUnredirectWindow (pClient, pChild, update);
-	    if (!csw->clients)
-	    {
-		xfree (csw);
-		dixSetPrivate(&pWin->devPrivates, CompSubwindowsPrivateKey, 0);
-	    }
-	    xfree (ccw);
-	    return ret;
-	}
-    }
-    /*
-     * Hook into subwindows list
-     */
-    ccw->next = csw->clients;
-    csw->clients = ccw;
-    if (!AddResource (ccw->id, CompositeClientSubwindowsType, pWin))
-	return BadAlloc;
-    if (ccw->update == CompositeRedirectManual)
-    {
-	csw->update = CompositeRedirectManual;
-	/* 
-	 * tell damage extension that damage events for this client are
-	 * critical output
-	 */
-	DamageExtSetCritical (pClient, TRUE);
-    }
-    return Success;
-}
-
-/*
- * Free one of the per-client per-subwindows resources,
- * which frees one redirect per subwindow
- */
-void
-compFreeClientSubwindows (WindowPtr pWin, XID id)
-{
-    CompSubwindowsPtr	csw = GetCompSubwindows (pWin);
-    CompClientWindowPtr	ccw, *prev;
-    WindowPtr		pChild;
-
-    if (!csw)
-	return;
-    for (prev = &csw->clients; (ccw = *prev); prev = &ccw->next)
-    {
-	if (ccw->id == id)
-	{
-	    ClientPtr	pClient = clients[CLIENT_ID(id)];
-	    
-	    *prev = ccw->next;
-	    if (ccw->update == CompositeRedirectManual)
-	    {
-		/* 
-		 * tell damage extension that damage events for this client are
-		 * critical output
-		 */
-		DamageExtSetCritical (pClient, FALSE);
-		csw->update = CompositeRedirectAutomatic;
-		if (pWin->mapped)
-		    (*pWin->drawable.pScreen->ClearToBackground)(pWin, 0, 0, 0, 0, TRUE);
-	    }
-
-	    /*
-	     * Unredirect all existing subwindows
-	     */
-	    for (pChild = pWin->lastChild; pChild; pChild = pChild->prevSib)
-		(void) compUnredirectWindow (pClient, pChild, ccw->update);
-
-	    xfree (ccw);
-	    break;
-	}
-    }
-
-    /*
-     * Check if all of the per-client records are gone
-     */
-    if (!csw->clients)
-    {
-	dixSetPrivate(&pWin->devPrivates, CompSubwindowsPrivateKey, NULL);
-	xfree (csw);
-    }
-}
-
-/*
- * This is easy, just free the appropriate resource.
- */
-
-int
-compUnredirectSubwindows (ClientPtr pClient, WindowPtr pWin, int update)
-{
-    CompSubwindowsPtr	csw = GetCompSubwindows (pWin);
-    CompClientWindowPtr	ccw;
-    
-    if (!csw)
-	return BadValue;
-    for (ccw = csw->clients; ccw; ccw = ccw->next)
-	if (ccw->update == update && CLIENT_ID(ccw->id) == pClient->index)
-	{
-	    FreeResource (ccw->id, RT_NONE);
-	    return Success;
-	}
-    return BadValue;
-}
-
-/*
- * Add redirection information for one subwindow (during reparent)
- */
-
-int
-compRedirectOneSubwindow (WindowPtr pParent, WindowPtr pWin)
-{
-    CompSubwindowsPtr	csw = GetCompSubwindows (pParent);
-    CompClientWindowPtr	ccw;
-
-    if (!csw)
-	return Success;
-    for (ccw = csw->clients; ccw; ccw = ccw->next)
-    {
-	int ret = compRedirectWindow (clients[CLIENT_ID(ccw->id)],
-				      pWin, ccw->update);
-	if (ret != Success)
-	    return ret;
-    }
-    return Success;
-}
-
-/*
- * Remove redirection information for one subwindow (during reparent)
- */
-
-int
-compUnredirectOneSubwindow (WindowPtr pParent, WindowPtr pWin)
-{
-    CompSubwindowsPtr	csw = GetCompSubwindows (pParent);
-    CompClientWindowPtr	ccw;
-
-    if (!csw)
-	return Success;
-    for (ccw = csw->clients; ccw; ccw = ccw->next)
-    {
-	int ret = compUnredirectWindow (clients[CLIENT_ID(ccw->id)],
-					pWin, ccw->update);
-	if (ret != Success)
-	    return ret;
-    }
-    return Success;
-}
-
-static PixmapPtr
-compNewPixmap (WindowPtr pWin, int x, int y, int w, int h)
-{
-    ScreenPtr	    pScreen = pWin->drawable.pScreen;
-    WindowPtr	    pParent = pWin->parent;
-    PixmapPtr	    pPixmap;
-
-    pPixmap = (*pScreen->CreatePixmap) (pScreen, w, h, pWin->drawable.depth,
-					CREATE_PIXMAP_USAGE_BACKING_PIXMAP);
-
-    if (!pPixmap)
-	return 0;
-    
-    pPixmap->screen_x = x;
-    pPixmap->screen_y = y;
-    
-    if (pParent->drawable.depth == pWin->drawable.depth)
-    {
-	GCPtr	pGC = GetScratchGC (pWin->drawable.depth, pScreen);
-	
-	/*
-	 * Copy bits from the parent into the new pixmap so that it will
-	 * have "reasonable" contents in case for background None areas.
-	 */
-	if (pGC)
-	{
-	    XID val = IncludeInferiors;
-	    
-	    ValidateGC(&pPixmap->drawable, pGC);
-	    dixChangeGC (serverClient, pGC, GCSubwindowMode, &val, NULL);
-	    (*pGC->ops->CopyArea) (&pParent->drawable,
-				   &pPixmap->drawable,
-				   pGC,
-				   x - pParent->drawable.x,
-				   y - pParent->drawable.y,
-				   w, h, 0, 0);
-	    FreeScratchGC (pGC);
-	}
-    }
-    else
-    {
-	PictFormatPtr	pSrcFormat = compWindowFormat (pParent);
-	PictFormatPtr	pDstFormat = compWindowFormat (pWin);
-	XID		inferiors = IncludeInferiors;
-	int		error;
-
-	PicturePtr	pSrcPicture = CreatePicture (None,
-						     &pParent->drawable,
-						     pSrcFormat,
-						     CPSubwindowMode,
-						     &inferiors,
-						     serverClient, &error);
-						    
-	PicturePtr	pDstPicture = CreatePicture (None,
-						     &pPixmap->drawable,
-						     pDstFormat,
-						     0, 0,
-						     serverClient, &error);
-
-	if (pSrcPicture && pDstPicture)
-	{
-	    CompositePicture (PictOpSrc,
-			      pSrcPicture,
-			      NULL,
-			      pDstPicture,
-			      x - pParent->drawable.x,
-			      y - pParent->drawable.y,
-			      0, 0, 0, 0, w, h);
-	}
-	if (pSrcPicture)
-	    FreePicture (pSrcPicture, 0);
-	if (pDstPicture)
-	    FreePicture (pDstPicture, 0);
-    }
-    return pPixmap;
-}
-
-Bool
-compAllocPixmap (WindowPtr pWin)
-{
-    int		    bw = (int) pWin->borderWidth;
-    int		    x = pWin->drawable.x - bw;
-    int		    y = pWin->drawable.y - bw;
-    int		    w = pWin->drawable.width + (bw << 1);
-    int		    h = pWin->drawable.height + (bw << 1);
-    PixmapPtr	    pPixmap = compNewPixmap (pWin, x, y, w, h);
-    CompWindowPtr   cw = GetCompWindow (pWin);
-
-    if (!pPixmap)
-	return FALSE;
-    if (cw->update == CompositeRedirectAutomatic)
-	pWin->redirectDraw = RedirectDrawAutomatic;
-    else
-	pWin->redirectDraw = RedirectDrawManual;
-
-    compSetPixmap (pWin, pPixmap);
-    cw->oldx = COMP_ORIGIN_INVALID;
-    cw->oldy = COMP_ORIGIN_INVALID;
-    cw->damageRegistered = FALSE;
-    if (cw->update == CompositeRedirectAutomatic)
-    {
-	DamageRegister (&pWin->drawable, cw->damage);
-	cw->damageRegistered = TRUE;
-    }
-    return TRUE;
-}
-
-void
-compFreePixmap (WindowPtr pWin)
-{
-    ScreenPtr	    pScreen = pWin->drawable.pScreen;
-    PixmapPtr	    pRedirectPixmap, pParentPixmap;
-    CompWindowPtr   cw = GetCompWindow (pWin);
-
-    if (cw->damageRegistered)
-    {
-	DamageUnregister (&pWin->drawable, cw->damage);
-	cw->damageRegistered = FALSE;
-	DamageEmpty (cw->damage);
-    }
-    /*
-     * Move the parent-constrained border clip region back into
-     * the window so that ValidateTree will handle the unmap
-     * case correctly.  Unmap adds the window borderClip to the
-     * parent exposed area; regions beyond the parent cause crashes
-     */
-    REGION_COPY (pScreen, &pWin->borderClip, &cw->borderClip);
-    pRedirectPixmap = (*pScreen->GetWindowPixmap) (pWin);
-    pParentPixmap = (*pScreen->GetWindowPixmap) (pWin->parent);
-    pWin->redirectDraw = RedirectDrawNone;
-    compSetPixmap (pWin, pParentPixmap);
-    (*pScreen->DestroyPixmap) (pRedirectPixmap);
-}
-
-/*
- * Make sure the pixmap is the right size and offset.  Allocate a new
- * pixmap to change size, adjust origin to change offset, leaving the
- * old pixmap in cw->pOldPixmap so bits can be recovered
- */
-Bool
-compReallocPixmap (WindowPtr pWin, int draw_x, int draw_y,
-		   unsigned int w, unsigned int h, int bw)
-{
-    ScreenPtr	    pScreen = pWin->drawable.pScreen;
-    PixmapPtr	    pOld = (*pScreen->GetWindowPixmap) (pWin);
-    PixmapPtr	    pNew;
-    CompWindowPtr   cw = GetCompWindow (pWin);
-    int		    pix_x, pix_y;
-    int		    pix_w, pix_h;
-
-    assert (cw && pWin->redirectDraw != RedirectDrawNone);
-    cw->oldx = pOld->screen_x;
-    cw->oldy = pOld->screen_y;
-    pix_x = draw_x - bw;
-    pix_y = draw_y - bw;
-    pix_w = w + (bw << 1);
-    pix_h = h + (bw << 1);
-    if (pix_w != pOld->drawable.width || pix_h != pOld->drawable.height)
-    {
-	pNew = compNewPixmap (pWin, pix_x, pix_y, pix_w, pix_h);
-	if (!pNew)
-	    return FALSE;
-	cw->pOldPixmap = pOld;
-	compSetPixmap (pWin, pNew);
-    }
-    else
-    {
-	pNew = pOld;
-	cw->pOldPixmap = 0;
-    }
-    pNew->screen_x = pix_x;
-    pNew->screen_y = pix_y;
-    return TRUE;
-}
+/*

+ * Copyright © 2006 Sun Microsystems, Inc.  All rights reserved.

+ *

+ * 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 (including the next

+ * paragraph) 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 AUTHORS OR COPYRIGHT HOLDERS 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.

+ *

+ * Copyright © 2003 Keith Packard

+ *

+ * 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, and that the name of Keith Packard not be used in

+ * advertising or publicity pertaining to distribution of the software without

+ * specific, written prior permission.  Keith Packard makes no

+ * representations about the suitability of this software for any purpose.  It

+ * is provided "as is" without express or implied warranty.

+ *

+ * KEITH PACKARD DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,

+ * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO

+ * EVENT SHALL KEITH PACKARD 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 "compint.h"

+

+static void

+compReportDamage (DamagePtr pDamage, RegionPtr pRegion, void *closure)

+{

+    WindowPtr	    pWin = (WindowPtr) closure;

+    ScreenPtr	    pScreen = pWin->drawable.pScreen;

+    CompScreenPtr   cs = GetCompScreen (pScreen);

+    CompWindowPtr   cw = GetCompWindow (pWin);

+

+    cs->damaged = TRUE;

+    cw->damaged = TRUE;

+}

+

+static void

+compDestroyDamage (DamagePtr pDamage, void *closure)

+{

+    WindowPtr	    pWin = (WindowPtr) closure;

+    CompWindowPtr   cw = GetCompWindow (pWin);

+

+    cw->damage = 0;

+}

+

+/*

+ * Redirect one window for one client

+ */

+int

+compRedirectWindow (ClientPtr pClient, WindowPtr pWin, int update)

+{

+    CompWindowPtr	cw = GetCompWindow (pWin);

+    CompClientWindowPtr	ccw;

+    Bool		wasMapped = pWin->mapped;

+    CompScreenPtr       cs = GetCompScreen(pWin->drawable.pScreen);

+    

+    if (pWin == cs->pOverlayWin) {

+	return Success;

+    }

+

+    if (!pWin->parent)

+	return BadMatch;

+

+    /*

+     * Only one Manual update is allowed

+     */

+    if (cw && update == CompositeRedirectManual)

+	for (ccw = cw->clients; ccw; ccw = ccw->next)

+	    if (ccw->update == CompositeRedirectManual)

+		return BadAccess;

+    

+    /*

+     * Allocate per-client per-window structure 

+     * The client *could* allocate multiple, but while supported,

+     * it is not expected to be common

+     */

+    ccw = xalloc (sizeof (CompClientWindowRec));

+    if (!ccw)

+	return BadAlloc;

+    ccw->id = FakeClientID (pClient->index);

+    ccw->update = update;

+    /*

+     * Now make sure there's a per-window structure to hang this from

+     */

+    if (!cw)

+    {

+	cw = xcalloc (1,sizeof (CompWindowRec));

+	if (!cw)

+	{

+	    xfree (ccw);

+	    return BadAlloc;

+	}

+	cw->damage = DamageCreate (compReportDamage,

+				   compDestroyDamage,

+				   DamageReportNonEmpty,

+				   FALSE,

+				   pWin->drawable.pScreen,

+				   pWin);

+	if (!cw->damage)

+	{

+	    xfree (ccw);

+	    xfree (cw);

+	    return BadAlloc;

+	}

+	if (wasMapped)

+	{

+	    DisableMapUnmapEvents (pWin);

+	    UnmapWindow (pWin, FALSE);

+	    EnableMapUnmapEvents (pWin);

+	}

+

+	REGION_NULL (pScreen, &cw->borderClip);

+	cw->borderClipX = 0;

+	cw->borderClipY = 0;

+	cw->update = CompositeRedirectAutomatic;

+	cw->clients = 0;

+	cw->oldx = COMP_ORIGIN_INVALID;

+	cw->oldy = COMP_ORIGIN_INVALID;

+	cw->damageRegistered = FALSE;

+	cw->damaged = FALSE;

+	dixSetPrivate(&pWin->devPrivates, CompWindowPrivateKey, cw);

+    }

+    ccw->next = cw->clients;

+    cw->clients = ccw;

+    if (!AddResource (ccw->id, CompositeClientWindowType, pWin))

+	return BadAlloc;

+    if (ccw->update == CompositeRedirectManual)

+    {

+	/* If the window was CompositeRedirectAutomatic, then

+	 * unmap the window so that the parent clip list will

+	 * be correctly recomputed.

+	 */

+	if (pWin->mapped) 

+	{

+	    DisableMapUnmapEvents (pWin);

+	    UnmapWindow (pWin, FALSE);

+	    EnableMapUnmapEvents (pWin);

+	}

+	if (cw->damageRegistered)

+	{

+	    DamageUnregister (&pWin->drawable, cw->damage);

+	    cw->damageRegistered = FALSE;

+	}

+	cw->update = CompositeRedirectManual;

+    }

+

+    if (!compCheckRedirect (pWin))

+    {

+	FreeResource (ccw->id, RT_NONE);

+	return BadAlloc;

+    }

+    if (wasMapped && !pWin->mapped)

+    {

+	Bool	overrideRedirect = pWin->overrideRedirect;

+	pWin->overrideRedirect = TRUE;

+	DisableMapUnmapEvents (pWin);

+	MapWindow (pWin, pClient);

+	EnableMapUnmapEvents (pWin);

+	pWin->overrideRedirect = overrideRedirect;

+    }

+    

+    return Success;

+}

+

+/*

+ * Free one of the per-client per-window resources, clearing

+ * redirect and the per-window pointer as appropriate

+ */

+void

+compFreeClientWindow (WindowPtr pWin, XID id)

+{

+    CompWindowPtr	cw = GetCompWindow (pWin);

+    CompClientWindowPtr	ccw, *prev;

+    Bool		wasMapped = pWin->mapped;

+

+    if (!cw)

+	return;

+    for (prev = &cw->clients; (ccw = *prev); prev = &ccw->next)

+    {

+	if (ccw->id == id)

+	{

+	    *prev = ccw->next;

+	    if (ccw->update == CompositeRedirectManual)

+		cw->update = CompositeRedirectAutomatic;

+	    xfree (ccw);

+	    break;

+	}

+    }

+    if (!cw->clients)

+    {

+	if (wasMapped)

+	{

+	    DisableMapUnmapEvents (pWin);

+	    UnmapWindow (pWin, FALSE);

+	    EnableMapUnmapEvents (pWin);

+	}

+    

+	if (pWin->redirectDraw != RedirectDrawNone)

+	    compFreePixmap (pWin);

+

+	if (cw->damage)

+	    DamageDestroy (cw->damage);

+	

+	REGION_UNINIT (pScreen, &cw->borderClip);

+    

+	dixSetPrivate(&pWin->devPrivates, CompWindowPrivateKey, NULL);

+	xfree (cw);

+    }

+    else if (cw->update == CompositeRedirectAutomatic &&

+	     !cw->damageRegistered && pWin->redirectDraw != RedirectDrawNone)

+    {

+	DamageRegister (&pWin->drawable, cw->damage);

+	cw->damageRegistered = TRUE;

+	pWin->redirectDraw = RedirectDrawAutomatic;

+	DamageRegionAppend(&pWin->drawable, &pWin->borderSize);

+    }

+    if (wasMapped && !pWin->mapped)

+    {

+	Bool	overrideRedirect = pWin->overrideRedirect;

+	pWin->overrideRedirect = TRUE;

+	DisableMapUnmapEvents (pWin);

+	MapWindow (pWin, clients[CLIENT_ID(id)]);

+	EnableMapUnmapEvents (pWin);

+	pWin->overrideRedirect = overrideRedirect;

+    }

+}

+

+/*

+ * This is easy, just free the appropriate resource.

+ */

+

+int

+compUnredirectWindow (ClientPtr pClient, WindowPtr pWin, int update)

+{

+    CompWindowPtr	cw = GetCompWindow (pWin);

+    CompClientWindowPtr	ccw;

+

+    if (!cw)

+	return BadValue;

+

+    for (ccw = cw->clients; ccw; ccw = ccw->next)

+	if (ccw->update == update && CLIENT_ID(ccw->id) == pClient->index)

+	{

+	    FreeResource (ccw->id, RT_NONE);

+	    return Success;

+	}

+    return BadValue;

+}

+	

+/*

+ * Redirect all subwindows for one client

+ */

+

+int

+compRedirectSubwindows (ClientPtr pClient, WindowPtr pWin, int update)

+{

+    CompSubwindowsPtr	csw = GetCompSubwindows (pWin);

+    CompClientWindowPtr	ccw;

+    WindowPtr		pChild;

+

+    /*

+     * Only one Manual update is allowed

+     */

+    if (csw && update == CompositeRedirectManual)

+	for (ccw = csw->clients; ccw; ccw = ccw->next)

+	    if (ccw->update == CompositeRedirectManual)

+		return BadAccess;

+    /*

+     * Allocate per-client per-window structure 

+     * The client *could* allocate multiple, but while supported,

+     * it is not expected to be common

+     */

+    ccw = xalloc (sizeof (CompClientWindowRec));

+    if (!ccw)

+	return BadAlloc;

+    ccw->id = FakeClientID (pClient->index);

+    ccw->update = update;

+    /*

+     * Now make sure there's a per-window structure to hang this from

+     */

+    if (!csw)

+    {

+	csw = xalloc (sizeof (CompSubwindowsRec));

+	if (!csw)

+	{

+	    xfree (ccw);

+	    return BadAlloc;

+	}

+	csw->update = CompositeRedirectAutomatic;

+	csw->clients = 0;

+	dixSetPrivate(&pWin->devPrivates, CompSubwindowsPrivateKey, csw);

+    }

+    /*

+     * Redirect all existing windows

+     */

+    for (pChild = pWin->lastChild; pChild; pChild = pChild->prevSib)

+    {

+	int ret = compRedirectWindow (pClient, pChild, update);

+	if (ret != Success)

+	{

+	    for (pChild = pChild->nextSib; pChild; pChild = pChild->nextSib)

+		(void) compUnredirectWindow (pClient, pChild, update);

+	    if (!csw->clients)

+	    {

+		xfree (csw);

+		dixSetPrivate(&pWin->devPrivates, CompSubwindowsPrivateKey, 0);

+	    }

+	    xfree (ccw);

+	    return ret;

+	}

+    }

+    /*

+     * Hook into subwindows list

+     */

+    ccw->next = csw->clients;

+    csw->clients = ccw;

+    if (!AddResource (ccw->id, CompositeClientSubwindowsType, pWin))

+	return BadAlloc;

+    if (ccw->update == CompositeRedirectManual)

+    {

+	csw->update = CompositeRedirectManual;

+	/* 

+	 * tell damage extension that damage events for this client are

+	 * critical output

+	 */

+	DamageExtSetCritical (pClient, TRUE);

+    }

+    return Success;

+}

+

+/*

+ * Free one of the per-client per-subwindows resources,

+ * which frees one redirect per subwindow

+ */

+void

+compFreeClientSubwindows (WindowPtr pWin, XID id)

+{

+    CompSubwindowsPtr	csw = GetCompSubwindows (pWin);

+    CompClientWindowPtr	ccw, *prev;

+    WindowPtr		pChild;

+

+    if (!csw)

+	return;

+    for (prev = &csw->clients; (ccw = *prev); prev = &ccw->next)

+    {

+	if (ccw->id == id)

+	{

+	    ClientPtr	pClient = clients[CLIENT_ID(id)];

+	    

+	    *prev = ccw->next;

+	    if (ccw->update == CompositeRedirectManual)

+	    {

+		/* 

+		 * tell damage extension that damage events for this client are

+		 * critical output

+		 */

+		DamageExtSetCritical (pClient, FALSE);

+		csw->update = CompositeRedirectAutomatic;

+		if (pWin->mapped)

+		    (*pWin->drawable.pScreen->ClearToBackground)(pWin, 0, 0, 0, 0, TRUE);

+	    }

+

+	    /*

+	     * Unredirect all existing subwindows

+	     */

+	    for (pChild = pWin->lastChild; pChild; pChild = pChild->prevSib)

+		(void) compUnredirectWindow (pClient, pChild, ccw->update);

+

+	    xfree (ccw);

+	    break;

+	}

+    }

+

+    /*

+     * Check if all of the per-client records are gone

+     */

+    if (!csw->clients)

+    {

+	dixSetPrivate(&pWin->devPrivates, CompSubwindowsPrivateKey, NULL);

+	xfree (csw);

+    }

+}

+

+/*

+ * This is easy, just free the appropriate resource.

+ */

+

+int

+compUnredirectSubwindows (ClientPtr pClient, WindowPtr pWin, int update)

+{

+    CompSubwindowsPtr	csw = GetCompSubwindows (pWin);

+    CompClientWindowPtr	ccw;

+    

+    if (!csw)

+	return BadValue;

+    for (ccw = csw->clients; ccw; ccw = ccw->next)

+	if (ccw->update == update && CLIENT_ID(ccw->id) == pClient->index)

+	{

+	    FreeResource (ccw->id, RT_NONE);

+	    return Success;

+	}

+    return BadValue;

+}

+

+/*

+ * Add redirection information for one subwindow (during reparent)

+ */

+

+int

+compRedirectOneSubwindow (WindowPtr pParent, WindowPtr pWin)

+{

+    CompSubwindowsPtr	csw = GetCompSubwindows (pParent);

+    CompClientWindowPtr	ccw;

+

+    if (!csw)

+	return Success;

+    for (ccw = csw->clients; ccw; ccw = ccw->next)

+    {

+	int ret = compRedirectWindow (clients[CLIENT_ID(ccw->id)],

+				      pWin, ccw->update);

+	if (ret != Success)

+	    return ret;

+    }

+    return Success;

+}

+

+/*

+ * Remove redirection information for one subwindow (during reparent)

+ */

+

+int

+compUnredirectOneSubwindow (WindowPtr pParent, WindowPtr pWin)

+{

+    CompSubwindowsPtr	csw = GetCompSubwindows (pParent);

+    CompClientWindowPtr	ccw;

+

+    if (!csw)

+	return Success;

+    for (ccw = csw->clients; ccw; ccw = ccw->next)

+    {

+	int ret = compUnredirectWindow (clients[CLIENT_ID(ccw->id)],

+					pWin, ccw->update);

+	if (ret != Success)

+	    return ret;

+    }

+    return Success;

+}

+

+static PixmapPtr

+compNewPixmap (WindowPtr pWin, int x, int y, int w, int h)

+{

+    ScreenPtr	    pScreen = pWin->drawable.pScreen;

+    WindowPtr	    pParent = pWin->parent;

+    PixmapPtr	    pPixmap;

+

+    pPixmap = (*pScreen->CreatePixmap) (pScreen, w, h, pWin->drawable.depth,

+					CREATE_PIXMAP_USAGE_BACKING_PIXMAP);

+

+    if (!pPixmap)

+	return 0;

+    

+    pPixmap->screen_x = x;

+    pPixmap->screen_y = y;

+    

+    if (pParent->drawable.depth == pWin->drawable.depth)

+    {

+	GCPtr	pGC = GetScratchGC (pWin->drawable.depth, pScreen);

+	

+	/*

+	 * Copy bits from the parent into the new pixmap so that it will

+	 * have "reasonable" contents in case for background None areas.

+	 */

+	if (pGC)

+	{

+	    XID val = IncludeInferiors;

+	    

+	    ValidateGC(&pPixmap->drawable, pGC);

+	    dixChangeGC (serverClient, pGC, GCSubwindowMode, &val, NULL);

+	    (*pGC->ops->CopyArea) (&pParent->drawable,

+				   &pPixmap->drawable,

+				   pGC,

+				   x - pParent->drawable.x,

+				   y - pParent->drawable.y,

+				   w, h, 0, 0);

+	    FreeScratchGC (pGC);

+	}

+    }

+    else

+    {

+	PictFormatPtr	pSrcFormat = compWindowFormat (pParent);

+	PictFormatPtr	pDstFormat = compWindowFormat (pWin);

+	XID		inferiors = IncludeInferiors;

+	int		error;

+

+	PicturePtr	pSrcPicture = CreatePicture (None,

+						     &pParent->drawable,

+						     pSrcFormat,

+						     CPSubwindowMode,

+						     &inferiors,

+						     serverClient, &error);

+						    

+	PicturePtr	pDstPicture = CreatePicture (None,

+						     &pPixmap->drawable,

+						     pDstFormat,

+						     0, 0,

+						     serverClient, &error);

+

+	if (pSrcPicture && pDstPicture)

+	{

+	    CompositePicture (PictOpSrc,

+			      pSrcPicture,

+			      NULL,

+			      pDstPicture,

+			      x - pParent->drawable.x,

+			      y - pParent->drawable.y,

+			      0, 0, 0, 0, w, h);

+	}

+	if (pSrcPicture)

+	    FreePicture (pSrcPicture, 0);

+	if (pDstPicture)

+	    FreePicture (pDstPicture, 0);

+    }

+    return pPixmap;

+}

+

+Bool

+compAllocPixmap (WindowPtr pWin)

+{

+    int		    bw = (int) pWin->borderWidth;

+    int		    x = pWin->drawable.x - bw;

+    int		    y = pWin->drawable.y - bw;

+    int		    w = pWin->drawable.width + (bw << 1);

+    int		    h = pWin->drawable.height + (bw << 1);

+    PixmapPtr	    pPixmap = compNewPixmap (pWin, x, y, w, h);

+    CompWindowPtr   cw = GetCompWindow (pWin);

+

+    if (!pPixmap)

+	return FALSE;

+    if (cw->update == CompositeRedirectAutomatic)

+	pWin->redirectDraw = RedirectDrawAutomatic;

+    else

+	pWin->redirectDraw = RedirectDrawManual;

+

+    compSetPixmap (pWin, pPixmap);

+    cw->oldx = COMP_ORIGIN_INVALID;

+    cw->oldy = COMP_ORIGIN_INVALID;

+    cw->damageRegistered = FALSE;

+    if (cw->update == CompositeRedirectAutomatic)

+    {

+	DamageRegister (&pWin->drawable, cw->damage);

+	cw->damageRegistered = TRUE;

+    }

+    return TRUE;

+}

+

+void

+compFreePixmap (WindowPtr pWin)

+{

+    ScreenPtr	    pScreen = pWin->drawable.pScreen;

+    PixmapPtr	    pRedirectPixmap, pParentPixmap;

+    CompWindowPtr   cw = GetCompWindow (pWin);

+

+    if (cw->damageRegistered)

+    {

+	DamageUnregister (&pWin->drawable, cw->damage);

+	cw->damageRegistered = FALSE;

+	DamageEmpty (cw->damage);

+    }

+    /*

+     * Move the parent-constrained border clip region back into

+     * the window so that ValidateTree will handle the unmap

+     * case correctly.  Unmap adds the window borderClip to the

+     * parent exposed area; regions beyond the parent cause crashes

+     */

+    REGION_COPY (pScreen, &pWin->borderClip, &cw->borderClip);

+    pRedirectPixmap = (*pScreen->GetWindowPixmap) (pWin);

+    pParentPixmap = (*pScreen->GetWindowPixmap) (pWin->parent);

+    pWin->redirectDraw = RedirectDrawNone;

+    compSetPixmap (pWin, pParentPixmap);

+    (*pScreen->DestroyPixmap) (pRedirectPixmap);

+}

+

+/*

+ * Make sure the pixmap is the right size and offset.  Allocate a new

+ * pixmap to change size, adjust origin to change offset, leaving the

+ * old pixmap in cw->pOldPixmap so bits can be recovered

+ */

+Bool

+compReallocPixmap (WindowPtr pWin, int draw_x, int draw_y,

+		   unsigned int w, unsigned int h, int bw)

+{

+    ScreenPtr	    pScreen = pWin->drawable.pScreen;

+    PixmapPtr	    pOld = (*pScreen->GetWindowPixmap) (pWin);

+    PixmapPtr	    pNew;

+    CompWindowPtr   cw = GetCompWindow (pWin);

+    int		    pix_x, pix_y;

+    int		    pix_w, pix_h;

+

+    assert (cw && pWin->redirectDraw != RedirectDrawNone);

+    cw->oldx = pOld->screen_x;

+    cw->oldy = pOld->screen_y;

+    pix_x = draw_x - bw;

+    pix_y = draw_y - bw;

+    pix_w = w + (bw << 1);

+    pix_h = h + (bw << 1);

+    if (pix_w != pOld->drawable.width || pix_h != pOld->drawable.height)

+    {

+	pNew = compNewPixmap (pWin, pix_x, pix_y, pix_w, pix_h);

+	if (!pNew)

+	    return FALSE;

+	cw->pOldPixmap = pOld;

+	compSetPixmap (pWin, pNew);

+    }

+    else

+    {

+	pNew = pOld;

+	cw->pOldPixmap = 0;

+    }

+    pNew->screen_x = pix_x;

+    pNew->screen_y = pix_y;

+    return TRUE;

+}

diff --git a/xorg-server/composite/compext.c b/xorg-server/composite/compext.c
index 976d00242..b5afdd372 100644
--- a/xorg-server/composite/compext.c
+++ b/xorg-server/composite/compext.c
@@ -2,29 +2,23 @@
  * Copyright © 2006 Sun Microsystems, Inc.  All rights reserved.
  *
  * 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, and/or sell copies of the Software, and to permit persons
- * to whom the Software is furnished to do so, provided that the above
- * copyright notice(s) and this permission notice appear in all copies of
- * the Software and that both the above copyright notice(s) and this
- * permission notice appear in supporting documentation.
+ * 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 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
- * OF THIRD PARTY RIGHTS. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
- * HOLDERS INCLUDED IN THIS NOTICE BE LIABLE FOR ANY CLAIM, OR 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.
+ * The above copyright notice and this permission notice (including the next
+ * paragraph) shall be included in all copies or substantial portions of the
+ * Software.
  *
- * Except as contained in this notice, the name of a copyright holder
- * shall not be used in advertising or otherwise to promote the sale, use
- * or other dealings in this Software without prior written authorization
- * of the copyright holder.
+ * 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 AUTHORS OR COPYRIGHT HOLDERS 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.
  *
  * Copyright © 2003 Keith Packard
  *
diff --git a/xorg-server/composite/compinit.c b/xorg-server/composite/compinit.c
index 9b033c8d2..e8b563de6 100644
--- a/xorg-server/composite/compinit.c
+++ b/xorg-server/composite/compinit.c
@@ -2,29 +2,23 @@
  * Copyright © 2006 Sun Microsystems, Inc.  All rights reserved.
  *
  * 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, and/or sell copies of the Software, and to permit persons
- * to whom the Software is furnished to do so, provided that the above
- * copyright notice(s) and this permission notice appear in all copies of
- * the Software and that both the above copyright notice(s) and this
- * permission notice appear in supporting documentation.
+ * 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 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
- * OF THIRD PARTY RIGHTS. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
- * HOLDERS INCLUDED IN THIS NOTICE BE LIABLE FOR ANY CLAIM, OR 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.
+ * The above copyright notice and this permission notice (including the next
+ * paragraph) shall be included in all copies or substantial portions of the
+ * Software.
  *
- * Except as contained in this notice, the name of a copyright holder
- * shall not be used in advertising or otherwise to promote the sale, use
- * or other dealings in this Software without prior written authorization
- * of the copyright holder.
+ * 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 AUTHORS OR COPYRIGHT HOLDERS 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.
  *
  * Copyright © 2003 Keith Packard
  *
diff --git a/xorg-server/composite/compint.h b/xorg-server/composite/compint.h
index 852c277c2..845a196f6 100644
--- a/xorg-server/composite/compint.h
+++ b/xorg-server/composite/compint.h
@@ -2,29 +2,23 @@
  * Copyright © 2006 Sun Microsystems, Inc.  All rights reserved.
  *
  * 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, and/or sell copies of the Software, and to permit persons
- * to whom the Software is furnished to do so, provided that the above
- * copyright notice(s) and this permission notice appear in all copies of
- * the Software and that both the above copyright notice(s) and this
- * permission notice appear in supporting documentation.
+ * 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 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
- * OF THIRD PARTY RIGHTS. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
- * HOLDERS INCLUDED IN THIS NOTICE BE LIABLE FOR ANY CLAIM, OR 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.
+ * The above copyright notice and this permission notice (including the next
+ * paragraph) shall be included in all copies or substantial portions of the
+ * Software.
  *
- * Except as contained in this notice, the name of a copyright holder
- * shall not be used in advertising or otherwise to promote the sale, use
- * or other dealings in this Software without prior written authorization
- * of the copyright holder.
+ * 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 AUTHORS OR COPYRIGHT HOLDERS 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.
  *
  * Copyright © 2003 Keith Packard
  *
diff --git a/xorg-server/composite/compoverlay.c b/xorg-server/composite/compoverlay.c
index edc1283b4..ce6db9977 100644
--- a/xorg-server/composite/compoverlay.c
+++ b/xorg-server/composite/compoverlay.c
@@ -1,170 +1,164 @@
-/*
- * Copyright © 2006 Sun Microsystems, Inc.  All rights reserved.
- *
- * 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, and/or sell copies of the Software, and to permit persons
- * to whom the Software is furnished to do so, provided that the above
- * copyright notice(s) and this permission notice appear in all copies of
- * the Software and that both the above copyright notice(s) and this
- * permission notice appear in supporting documentation.
- *
- * 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
- * OF THIRD PARTY RIGHTS. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
- * HOLDERS INCLUDED IN THIS NOTICE BE LIABLE FOR ANY CLAIM, OR 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.
- *
- * Except as contained in this notice, the name of a copyright holder
- * shall not be used in advertising or otherwise to promote the sale, use
- * or other dealings in this Software without prior written authorization
- * of the copyright holder.
- *
- * Copyright © 2003 Keith Packard
- *
- * 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, and that the name of Keith Packard not be used in
- * advertising or publicity pertaining to distribution of the software without
- * specific, written prior permission.  Keith Packard makes no
- * representations about the suitability of this software for any purpose.  It
- * is provided "as is" without express or implied warranty.
- *
- * KEITH PACKARD DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
- * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
- * EVENT SHALL KEITH PACKARD 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
-
-#ifdef CreateWindow
-#undef CreateWindow
-#endif
-
-#include "compint.h"
-#include "xace.h"
-
-/* 
- * Delete the given overlay client list element from its screen list.
- */
-void
-compFreeOverlayClient (CompOverlayClientPtr pOcToDel)
-{
-    ScreenPtr		    pScreen = pOcToDel->pScreen;
-    CompScreenPtr	    cs = GetCompScreen (pScreen);
-    CompOverlayClientPtr    *pPrev, pOc;
-
-    for (pPrev = &cs->pOverlayClients; (pOc = *pPrev); pPrev = &pOc->pNext)
-    {
-	if (pOc == pOcToDel) {
-	    *pPrev = pOc->pNext;
-	    xfree (pOc);
-	    break;
-	}
-    }
-    
-    /* Destroy overlay window when there are no more clients using it */
-    if (cs->pOverlayClients == NULL)
-	compDestroyOverlayWindow (pScreen);
-}
-
-/*
- * Return the client's first overlay client rec from the given screen
- */
-CompOverlayClientPtr
-compFindOverlayClient (ScreenPtr pScreen, ClientPtr pClient)
-{
-    CompScreenPtr	    cs = GetCompScreen(pScreen);
-    CompOverlayClientPtr    pOc;
-
-    for (pOc = cs->pOverlayClients; pOc != NULL; pOc = pOc->pNext)
-	if (pOc->pClient == pClient)
-	    return pOc;
-
-    return NULL;           
-}
-
-/*
- * Create an overlay client object for the given client
- */
-CompOverlayClientPtr
-compCreateOverlayClient (ScreenPtr pScreen, ClientPtr pClient)
-{
-    CompScreenPtr    cs = GetCompScreen(pScreen);
-    CompOverlayClientPtr pOc;
-
-    pOc = (CompOverlayClientPtr) xalloc(sizeof(CompOverlayClientRec));
-    if (pOc == NULL)
-	return NULL;
-
-    pOc->pClient = pClient;
-    pOc->pScreen = pScreen;
-    pOc->resource = FakeClientID(pClient->index);
-    pOc->pNext = cs->pOverlayClients;
-    cs->pOverlayClients = pOc;
-
-    /* 
-     * Create a resource for this element so it can be deleted
-     * when the client goes away.
-     */
-    if (!AddResource (pOc->resource, CompositeClientOverlayType, (pointer) pOc))
-	return NULL;
-
-    return pOc;
-}
-
-/*
- * Create the overlay window and map it
- */
-Bool
-compCreateOverlayWindow (ScreenPtr pScreen)
-{
-    CompScreenPtr   cs = GetCompScreen(pScreen);
-    WindowPtr	    pRoot = WindowTable[pScreen->myNum];
-    WindowPtr	    pWin;
-    XID		    attrs[] = { None, TRUE }; /* backPixmap, overrideRedirect */
-    int		    result;
-
-    pWin = cs->pOverlayWin = 
-	CreateWindow (cs->overlayWid, pRoot,
-		      0, 0, pScreen->width, pScreen->height, 0, 
-		      InputOutput, CWBackPixmap | CWOverrideRedirect, &attrs[0],
-		      pRoot->drawable.depth, 
-		      serverClient, pScreen->rootVisual, &result);
-    if (pWin == NULL)
-	return FALSE;
-
-    if (!AddResource(pWin->drawable.id, RT_WINDOW, (pointer)pWin))
-	return FALSE;
-
-    MapWindow(pWin, serverClient);
-
-    return TRUE;
-}
-
-/*
- * Destroy the overlay window
- */
-void
-compDestroyOverlayWindow (ScreenPtr pScreen)
-{
-    CompScreenPtr cs = GetCompScreen(pScreen);
-
-    cs->pOverlayWin = NullWindow;
-    FreeResource (cs->overlayWid, RT_NONE);
-}
-
+/*

+ * Copyright © 2006 Sun Microsystems, Inc.  All rights reserved.

+ *

+ * 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 (including the next

+ * paragraph) 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 AUTHORS OR COPYRIGHT HOLDERS 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.

+ *

+ * Copyright © 2003 Keith Packard

+ *

+ * 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, and that the name of Keith Packard not be used in

+ * advertising or publicity pertaining to distribution of the software without

+ * specific, written prior permission.  Keith Packard makes no

+ * representations about the suitability of this software for any purpose.  It

+ * is provided "as is" without express or implied warranty.

+ *

+ * KEITH PACKARD DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,

+ * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO

+ * EVENT SHALL KEITH PACKARD 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

+

+#ifdef CreateWindow

+#undef CreateWindow

+#endif

+

+#include "compint.h"

+#include "xace.h"

+

+/* 

+ * Delete the given overlay client list element from its screen list.

+ */

+void

+compFreeOverlayClient (CompOverlayClientPtr pOcToDel)

+{

+    ScreenPtr		    pScreen = pOcToDel->pScreen;

+    CompScreenPtr	    cs = GetCompScreen (pScreen);

+    CompOverlayClientPtr    *pPrev, pOc;

+

+    for (pPrev = &cs->pOverlayClients; (pOc = *pPrev); pPrev = &pOc->pNext)

+    {

+	if (pOc == pOcToDel) {

+	    *pPrev = pOc->pNext;

+	    xfree (pOc);

+	    break;

+	}

+    }

+    

+    /* Destroy overlay window when there are no more clients using it */

+    if (cs->pOverlayClients == NULL)

+	compDestroyOverlayWindow (pScreen);

+}

+

+/*

+ * Return the client's first overlay client rec from the given screen

+ */

+CompOverlayClientPtr

+compFindOverlayClient (ScreenPtr pScreen, ClientPtr pClient)

+{

+    CompScreenPtr	    cs = GetCompScreen(pScreen);

+    CompOverlayClientPtr    pOc;

+

+    for (pOc = cs->pOverlayClients; pOc != NULL; pOc = pOc->pNext)

+	if (pOc->pClient == pClient)

+	    return pOc;

+

+    return NULL;           

+}

+

+/*

+ * Create an overlay client object for the given client

+ */

+CompOverlayClientPtr

+compCreateOverlayClient (ScreenPtr pScreen, ClientPtr pClient)

+{

+    CompScreenPtr    cs = GetCompScreen(pScreen);

+    CompOverlayClientPtr pOc;

+

+    pOc = (CompOverlayClientPtr) xalloc(sizeof(CompOverlayClientRec));

+    if (pOc == NULL)

+	return NULL;

+

+    pOc->pClient = pClient;

+    pOc->pScreen = pScreen;

+    pOc->resource = FakeClientID(pClient->index);

+    pOc->pNext = cs->pOverlayClients;

+    cs->pOverlayClients = pOc;

+

+    /* 

+     * Create a resource for this element so it can be deleted

+     * when the client goes away.

+     */

+    if (!AddResource (pOc->resource, CompositeClientOverlayType, (pointer) pOc))

+	return NULL;

+

+    return pOc;

+}

+

+/*

+ * Create the overlay window and map it

+ */

+Bool

+compCreateOverlayWindow (ScreenPtr pScreen)

+{

+    CompScreenPtr   cs = GetCompScreen(pScreen);

+    WindowPtr	    pRoot = WindowTable[pScreen->myNum];

+    WindowPtr	    pWin;

+    XID		    attrs[] = { None, TRUE }; /* backPixmap, overrideRedirect */

+    int		    result;

+

+    pWin = cs->pOverlayWin = 

+	CreateWindow (cs->overlayWid, pRoot,

+		      0, 0, pScreen->width, pScreen->height, 0, 

+		      InputOutput, CWBackPixmap | CWOverrideRedirect, &attrs[0],

+		      pRoot->drawable.depth, 

+		      serverClient, pScreen->rootVisual, &result);

+    if (pWin == NULL)

+	return FALSE;

+

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

+	return FALSE;

+

+    MapWindow(pWin, serverClient);

+

+    return TRUE;

+}

+

+/*

+ * Destroy the overlay window

+ */

+void

+compDestroyOverlayWindow (ScreenPtr pScreen)

+{

+    CompScreenPtr cs = GetCompScreen(pScreen);

+

+    cs->pOverlayWin = NullWindow;

+    FreeResource (cs->overlayWid, RT_NONE);

+}

+

diff --git a/xorg-server/composite/compwindow.c b/xorg-server/composite/compwindow.c
index 9bc43b05b..c10cb9ee9 100644
--- a/xorg-server/composite/compwindow.c
+++ b/xorg-server/composite/compwindow.c
@@ -2,29 +2,23 @@
  * Copyright © 2006 Sun Microsystems, Inc.  All rights reserved.
  *
  * 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, and/or sell copies of the Software, and to permit persons
- * to whom the Software is furnished to do so, provided that the above
- * copyright notice(s) and this permission notice appear in all copies of
- * the Software and that both the above copyright notice(s) and this
- * permission notice appear in supporting documentation.
+ * 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 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
- * OF THIRD PARTY RIGHTS. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
- * HOLDERS INCLUDED IN THIS NOTICE BE LIABLE FOR ANY CLAIM, OR 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.
+ * The above copyright notice and this permission notice (including the next
+ * paragraph) shall be included in all copies or substantial portions of the
+ * Software.
  *
- * Except as contained in this notice, the name of a copyright holder
- * shall not be used in advertising or otherwise to promote the sale, use
- * or other dealings in this Software without prior written authorization
- * of the copyright holder.
+ * 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 AUTHORS OR COPYRIGHT HOLDERS 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.
  *
  * Copyright © 2003 Keith Packard
  *
diff --git a/xorg-server/configure.ac b/xorg-server/configure.ac
index 6cdef15fb..55763f5f6 100644
--- a/xorg-server/configure.ac
+++ b/xorg-server/configure.ac
@@ -1282,7 +1282,7 @@ AC_DEFINE(BIGREQS, 1, [Support BigRequests extension])
 
 if test "x$SPECIAL_DTRACE_OBJECTS" = "xyes" ; then
   DIX_LIB='$(top_builddir)/dix/dix.O'
-  OS_LIB='$(top_builddir)/os/os.O'
+  OS_LIB='$(top_builddir)/os/os.O $(SHA1_LIBS)'
 else
   DIX_LIB='$(top_builddir)/dix/libdix.la'
   OS_LIB='$(top_builddir)/os/libos.la'
diff --git a/xorg-server/dix/Makefile.am b/xorg-server/dix/Makefile.am
index b29f2e189..42b5121fe 100644
--- a/xorg-server/dix/Makefile.am
+++ b/xorg-server/dix/Makefile.am
@@ -70,4 +70,4 @@ endif
 dix.c:
 	touch $@
 
-CLEANFILES = dix.c
+CLEANFILES = dix.c Xserver-dtrace.h
diff --git a/xorg-server/dix/Xserver-dtrace.h.in b/xorg-server/dix/Xserver-dtrace.h.in
index 26a8b4099..fce28362a 100644
--- a/xorg-server/dix/Xserver-dtrace.h.in
+++ b/xorg-server/dix/Xserver-dtrace.h.in
@@ -1,29 +1,23 @@
 /* Copyright 2006 Sun Microsystems, Inc.  All rights reserved.
  *
  * 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, and/or sell copies of the Software, and to permit persons
- * to whom the Software is furnished to do so, provided that the above
- * copyright notice(s) and this permission notice appear in all copies of
- * the Software and that both the above copyright notice(s) and this
- * permission notice appear in supporting documentation.
+ * 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 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
- * OF THIRD PARTY RIGHTS. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
- * HOLDERS INCLUDED IN THIS NOTICE BE LIABLE FOR ANY CLAIM, OR 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.
+ * The above copyright notice and this permission notice (including the next
+ * paragraph) shall be included in all copies or substantial portions of the
+ * Software.
  *
- * Except as contained in this notice, the name of a copyright holder
- * shall not be used in advertising or otherwise to promote the sale, use
- * or other dealings in this Software without prior written authorization
- * of the copyright holder.
+ * 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 AUTHORS OR COPYRIGHT HOLDERS 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.
  */ 
 
 /*
diff --git a/xorg-server/dix/Xserver.d b/xorg-server/dix/Xserver.d
index cea97e908..4bc0b9a84 100644
--- a/xorg-server/dix/Xserver.d
+++ b/xorg-server/dix/Xserver.d
@@ -1,29 +1,23 @@
 /* Copyright 2005-2006 Sun Microsystems, Inc.  All rights reserved.
  *
  * 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, and/or sell copies of the Software, and to permit persons
- * to whom the Software is furnished to do so, provided that the above
- * copyright notice(s) and this permission notice appear in all copies of
- * the Software and that both the above copyright notice(s) and this
- * permission notice appear in supporting documentation.
- * 
- * 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
- * OF THIRD PARTY RIGHTS. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
- * HOLDERS INCLUDED IN THIS NOTICE BE LIABLE FOR ANY CLAIM, OR 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.
- * 
- * Except as contained in this notice, the name of a copyright holder
- * shall not be used in advertising or otherwise to promote the sale, use
- * or other dealings in this Software without prior written authorization
- * of the copyright holder.
+ * 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 (including the next
+ * paragraph) 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 AUTHORS OR COPYRIGHT HOLDERS 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.
  */
 
 /*
diff --git a/xorg-server/dix/dispatch.c b/xorg-server/dix/dispatch.c
index 3d5baeb4d..d431d4f75 100644
--- a/xorg-server/dix/dispatch.c
+++ b/xorg-server/dix/dispatch.c
@@ -1,4104 +1,4098 @@
-/************************************************************
-
-Copyright 1987, 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.
-
-
-Copyright 1987, 1989 by Digital Equipment Corporation, Maynard, Massachusetts.
-
-                        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 name of Digital not be
-used in advertising or publicity pertaining to distribution of the
-software without specific, written prior permission.  
-
-DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
-ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
-DIGITAL 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.
-
-********************************************************/
-
-/* The panoramix components contained the following notice */
-/*****************************************************************
-
-Copyright (c) 1991, 1997 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.
-
-******************************************************************/
-
-/* XSERVER_DTRACE additions:
- * Copyright 2005-2006 Sun Microsystems, Inc.  All rights reserved.
- *
- * 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, and/or sell copies of the Software, and to permit persons
- * to whom the Software is furnished to do so, provided that the above
- * copyright notice(s) and this permission notice appear in all copies of
- * the Software and that both the above copyright notice(s) and this
- * permission notice appear in supporting documentation.
- * 
- * 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
- * OF THIRD PARTY RIGHTS. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
- * HOLDERS INCLUDED IN THIS NOTICE BE LIABLE FOR ANY CLAIM, OR 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.
- * 
- * Except as contained in this notice, the name of a copyright holder
- * shall not be used in advertising or otherwise to promote the sale, use
- * or other dealings in this Software without prior written authorization
- * of the copyright holder.
- */
-
-
-
-#ifdef HAVE_DIX_CONFIG_H
-#include <dix-config.h>
-#include <version-config.h>
-#endif
-
-#ifdef CreateWindow
-#undef CreateWindow
-#endif
-
-#ifdef PANORAMIX_DEBUG
-#include <stdio.h>
-int ProcInitialConnection();
-#endif
-
-#include "windowstr.h"
-#include <X11/fonts/fontstruct.h>
-#include "dixfontstr.h"
-#include "gcstruct.h"
-#include "selection.h"
-#include "colormapst.h"
-#include "cursorstr.h"
-#include "scrnintstr.h"
-#include "opaque.h"
-#include "input.h"
-#include "servermd.h"
-#include "extnsionst.h"
-#include "dixfont.h"
-#include "dispatch.h"
-#include "swaprep.h"
-#include "swapreq.h"
-#include "privates.h"
-#include "xace.h"
-#include "inputstr.h"
-#include "xkbsrv.h"
-#include "site.h"
-
-#ifdef XSERVER_DTRACE
-#include "registry.h"
-#include <sys/types.h>
-typedef const char *string;
-#include "Xserver-dtrace.h"
-#endif
-
-#define mskcnt ((MAXCLIENTS + 31) / 32)
-#define BITMASK(i) (1U << ((i) & 31))
-#define MASKIDX(i) ((i) >> 5)
-#define MASKWORD(buf, i) buf[MASKIDX(i)]
-#define BITSET(buf, i) MASKWORD(buf, i) |= BITMASK(i)
-#define BITCLEAR(buf, i) MASKWORD(buf, i) &= ~BITMASK(i)
-#define GETBIT(buf, i) (MASKWORD(buf, i) & BITMASK(i))
-
-xConnSetupPrefix connSetupPrefix;
-
-PaddingInfo PixmapWidthPaddingInfo[33];
-
-static ClientPtr grabClient;
-#define GrabNone 0
-#define GrabActive 1
-#define GrabKickout 2
-static int grabState = GrabNone;
-static long grabWaiters[mskcnt];
-CallbackListPtr ServerGrabCallback = NULL;
-HWEventQueuePtr checkForInput[2];
-int connBlockScreenStart;
-
-static void KillAllClients(void);
-
-static int nextFreeClientID; /* always MIN free client ID */
-
-static int	nClients;	/* number of authorized clients */
-
-CallbackListPtr ClientStateCallback;
-
-/* dispatchException & isItTimeToYield must be declared volatile since they
- * are modified by signal handlers - otherwise optimizer may assume it doesn't
- * need to actually check value in memory when used and may miss changes from
- * signal handlers.
- */
-volatile char dispatchException = 0;
-volatile char isItTimeToYield;
-
-/* Various of the DIX function interfaces were not designed to allow
- * the client->errorValue to be set on BadValue and other errors.
- * Rather than changing interfaces and breaking untold code we introduce
- * a new global that dispatch can use.
- */
-XID clientErrorValue;   /* XXX this is a kludge */
-
-#define SAME_SCREENS(a, b) (\
-    (a.pScreen == b.pScreen))
-
-void
-SetInputCheck(HWEventQueuePtr c0, HWEventQueuePtr c1)
-{
-    checkForInput[0] = c0;
-    checkForInput[1] = c1;
-}
-
-void
-UpdateCurrentTime(void)
-{
-    TimeStamp systime;
-
-    /* To avoid time running backwards, we must call GetTimeInMillis before
-     * calling ProcessInputEvents.
-     */
-    systime.months = currentTime.months;
-    systime.milliseconds = GetTimeInMillis();
-    if (systime.milliseconds < currentTime.milliseconds)
-	systime.months++;
-    if (*checkForInput[0] != *checkForInput[1])
-	ProcessInputEvents();
-    if (CompareTimeStamps(systime, currentTime) == LATER)
-	currentTime = systime;
-}
-
-/* Like UpdateCurrentTime, but can't call ProcessInputEvents */
-void
-UpdateCurrentTimeIf(void)
-{
-    TimeStamp systime;
-
-    systime.months = currentTime.months;
-    systime.milliseconds = GetTimeInMillis();
-    if (systime.milliseconds < currentTime.milliseconds)
-	systime.months++;
-    if (*checkForInput[0] == *checkForInput[1])
-	currentTime = systime;
-}
-
-
-#undef SMART_DEBUG
-
-#define SMART_SCHEDULE_DEFAULT_INTERVAL	20	    /* ms */
-#define SMART_SCHEDULE_MAX_SLICE	200	    /* ms */
-
-Bool SmartScheduleDisable = FALSE;
-long SmartScheduleSlice = SMART_SCHEDULE_DEFAULT_INTERVAL;
-long SmartScheduleInterval = SMART_SCHEDULE_DEFAULT_INTERVAL;
-long SmartScheduleMaxSlice = SMART_SCHEDULE_MAX_SLICE;
-long SmartScheduleTime;
-int SmartScheduleLatencyLimited = 0;
-static ClientPtr   SmartLastClient;
-static int	   SmartLastIndex[SMART_MAX_PRIORITY-SMART_MIN_PRIORITY+1];
-
-#ifdef SMART_DEBUG
-long	    SmartLastPrint;
-#endif
-
-void        Dispatch(void);
-void        InitProcVectors(void);
-
-static int
-SmartScheduleClient (int *clientReady, int nready)
-{
-    ClientPtr	pClient;
-    int		i;
-    int		client;
-    int		bestPrio, best = 0;
-    int		bestRobin, robin;
-    long	now = SmartScheduleTime;
-    long	idle;
-
-    bestPrio = -0x7fffffff;
-    bestRobin = 0;
-    idle = 2 * SmartScheduleSlice;
-    for (i = 0; i < nready; i++)
-    {
-	client = clientReady[i];
-	pClient = clients[client];
-	/* Praise clients which are idle */
-	if ((now - pClient->smart_check_tick) >= idle)
-	{
-	    if (pClient->smart_priority < 0)
-		pClient->smart_priority++;
-	}
-	pClient->smart_check_tick = now;
-	
-	/* check priority to select best client */
-	robin = (pClient->index - SmartLastIndex[pClient->smart_priority-SMART_MIN_PRIORITY]) & 0xff;
-	if (pClient->smart_priority > bestPrio ||
-	    (pClient->smart_priority == bestPrio && robin > bestRobin))
-	{
-	    bestPrio = pClient->smart_priority;
-	    bestRobin = robin;
-	    best = client;
-	}
-#ifdef SMART_DEBUG
-	if ((now - SmartLastPrint) >= 5000)
-	    fprintf (stderr, " %2d: %3d", client, pClient->smart_priority);
-#endif
-    }
-#ifdef SMART_DEBUG
-    if ((now - SmartLastPrint) >= 5000)
-    {
-	fprintf (stderr, " use %2d\n", best);
-	SmartLastPrint = now;
-    }
-#endif
-    pClient = clients[best];
-    SmartLastIndex[bestPrio-SMART_MIN_PRIORITY] = pClient->index;
-    /*
-     * Set current client pointer
-     */
-    if (SmartLastClient != pClient)
-    {
-	pClient->smart_start_tick = now;
-	SmartLastClient = pClient;
-    }
-    /*
-     * Adjust slice
-     */
-    if (nready == 1 && SmartScheduleLatencyLimited == 0)
-    {
-	/*
-	 * If it's been a long time since another client
-	 * has run, bump the slice up to get maximal
-	 * performance from a single client
-	 */
-	if ((now - pClient->smart_start_tick) > 1000 &&
-	    SmartScheduleSlice < SmartScheduleMaxSlice)
-	{
-	    SmartScheduleSlice += SmartScheduleInterval;
-	}
-    }
-    else
-    {
-	SmartScheduleSlice = SmartScheduleInterval;
-    }
-    return best;
-}
-
-void
-EnableLimitedSchedulingLatency(void)
-{
-    ++SmartScheduleLatencyLimited;
-    SmartScheduleSlice = SmartScheduleInterval;
-}
-
-void
-DisableLimitedSchedulingLatency(void)
-{
-    --SmartScheduleLatencyLimited;
-
-    /* protect against bugs */
-    if (SmartScheduleLatencyLimited < 0)
-	SmartScheduleLatencyLimited = 0;
-}
-
-#define MAJOROP ((xReq *)client->requestBuffer)->reqType
-
-void
-Dispatch(void)
-{
-    int        *clientReady;     /* array of request ready clients */
-    int	result;
-    ClientPtr	client;
-    int	nready;
-    HWEventQueuePtr* icheck = checkForInput;
-    long			start_tick;
-
-    nextFreeClientID = 1;
-    nClients = 0;
-
-    clientReady = xalloc(sizeof(int) * MaxClients);
-    if (!clientReady)
-	return;
-
-    SmartScheduleSlice = SmartScheduleInterval;
-    while (!dispatchException)
-    {
-        if (*icheck[0] != *icheck[1])
-	{
-	    ProcessInputEvents();
-	    FlushIfCriticalOutputPending();
-	}
-
-	nready = WaitForSomething(clientReady);
-
-	if (nready && !SmartScheduleDisable)
-	{
-	    clientReady[0] = SmartScheduleClient (clientReady, nready);
-	    nready = 1;
-	}
-       /***************** 
-	*  Handle events in round robin fashion, doing input between 
-	*  each round 
-	*****************/
-
-	while (!dispatchException && (--nready >= 0))
-	{
-	    client = clients[clientReady[nready]];
-	    if (! client)
-	    {
-		/* KillClient can cause this to happen */
-		continue;
-	    }
-	    /* GrabServer activation can cause this to be true */
-	    if (grabState == GrabKickout)
-	    {
-		grabState = GrabActive;
-		break;
-	    }
-	    isItTimeToYield = FALSE;
- 
-	    start_tick = SmartScheduleTime;
-	    while (!isItTimeToYield)
-	    {
-#ifdef XSERVER_DTRACE
-	      CARD8 StartMajorOp;
-#endif
-	        if (*icheck[0] != *icheck[1])
-		    ProcessInputEvents();
-		
-		FlushIfCriticalOutputPending();
-		if (!SmartScheduleDisable && 
-		    (SmartScheduleTime - start_tick) >= SmartScheduleSlice)
-		{
-		    /* Penalize clients which consume ticks */
-		    if (client->smart_priority > SMART_MIN_PRIORITY)
-			client->smart_priority--;
-		    break;
-		}
-		/* now, finally, deal with client requests */
-
-	        result = ReadRequestFromClient(client);
-	        if (result <= 0) 
-	        {
-		    if (result < 0)
-			CloseDownClient(client);
-		    break;
-	        }
-
-		client->sequence++;
-#ifdef XSERVER_DTRACE
-		StartMajorOp=MAJOROP;
-		XSERVER_REQUEST_START(LookupMajorName(StartMajorOp), StartMajorOp,
-			      ((xReq *)client->requestBuffer)->length,
-			      client->index, client->requestBuffer);
-#endif
-		if (result > (maxBigRequestSize << 2))
-		    result = BadLength;
-		else {
-		    result = XaceHookDispatch(client, MAJOROP);
-		    if (result == Success)
-			result = (* client->requestVector[MAJOROP])(client);
-		    XaceHookAuditEnd(client, result);
-		}
-#ifdef XSERVER_DTRACE
-		if (result!=Success)
-		{
-		  char Message[255];
-		  sprintf(Message,"ERROR: %s (0x%x)",LookupMajorName(StartMajorOp),client->errorValue);
-		  XSERVER_REQUEST_DONE(Message, MAJOROP,
-		                       client->sequence, client->index, result);
-		}
-		else
-		{
-		  if (StartMajorOp!=MAJOROP)
-		  {
-		    char Message[255];
-		    sprintf(Message,"Changed request: %s -> %s",LookupMajorName(StartMajorOp),LookupMajorName(MAJOROP));
-		    XSERVER_REQUEST_DONE(Message, MAJOROP,
-		                         client->sequence, client->index, result);
-		  }
-		  else
-		  {
-		    XSERVER_REQUEST_DONE(LookupMajorName(MAJOROP), MAJOROP,
-		                         client->sequence, client->index, result);
-		  }
-		}
-#endif
-
-		if (result != Success) 
-		{
-		    if (client->noClientException != Success)
-                        CloseDownClient(client);
-                    else
-		        SendErrorToClient(client, MAJOROP,
-					  MinorOpcodeOfRequest(client),
-					  client->errorValue, result);
-		    break;
-	        }
-	    }
-	    FlushAllOutput();
-	    client = clients[clientReady[nready]];
-	    if (client)
-		client->smart_stop_tick = SmartScheduleTime;
-	}
-	dispatchException &= ~DE_PRIORITYCHANGE;
-    }
-#if defined(DDXBEFORERESET)
-    ddxBeforeReset ();
-#endif
-    KillAllClients();
-    xfree(clientReady);
-    dispatchException &= ~DE_RESET;
-    SmartScheduleLatencyLimited = 0;
-}
-
-#undef MAJOROP
-
-static int  VendorRelease = VENDOR_RELEASE;
-static char *VendorString = VENDOR_NAME;
-
-static const int padlength[4] = {0, 3, 2, 1};
-
-void
-SetVendorRelease(int release)
-{
-    VendorRelease = release;
-}
-
-void
-SetVendorString(char *string)
-{
-    VendorString = string;
-}
-
-Bool
-CreateConnectionBlock(void)
-{
-    xConnSetup setup;
-    xWindowRoot root;
-    xDepth	depth;
-    xVisualType visual;
-    xPixmapFormat format;
-    unsigned long vid;
-    int i, j, k,
-        lenofblock,
-        sizesofar = 0;
-    char *pBuf;
-
-
-    memset(&setup, 0, sizeof(xConnSetup));
-    /* Leave off the ridBase and ridMask, these must be sent with
-       connection */
-
-    setup.release = VendorRelease;
-    /*
-     * per-server image and bitmap parameters are defined in Xmd.h
-     */
-    setup.imageByteOrder = screenInfo.imageByteOrder;
-
-    setup.bitmapScanlineUnit = screenInfo.bitmapScanlineUnit;
-    setup.bitmapScanlinePad = screenInfo.bitmapScanlinePad;
-
-    setup.bitmapBitOrder = screenInfo.bitmapBitOrder;
-    setup.motionBufferSize = NumMotionEvents();
-    setup.numRoots = screenInfo.numScreens;
-    setup.nbytesVendor = strlen(VendorString);
-    setup.numFormats = screenInfo.numPixmapFormats;
-    setup.maxRequestSize = MAX_REQUEST_SIZE;
-    QueryMinMaxKeyCodes(&setup.minKeyCode, &setup.maxKeyCode);
-
-    lenofblock = sizeof(xConnSetup) +
-            pad_to_int32(setup.nbytesVendor) +
-	    (setup.numFormats * sizeof(xPixmapFormat)) +
-            (setup.numRoots * sizeof(xWindowRoot));
-    ConnectionInfo = xalloc(lenofblock);
-    if (!ConnectionInfo)
-	return FALSE;
-
-    memmove(ConnectionInfo, (char *)&setup, sizeof(xConnSetup));
-    sizesofar = sizeof(xConnSetup);
-    pBuf = ConnectionInfo + sizeof(xConnSetup);
-
-    memmove(pBuf, VendorString, (int)setup.nbytesVendor);
-    sizesofar += setup.nbytesVendor;
-    pBuf += setup.nbytesVendor;
-    i = padlength[setup.nbytesVendor & 3];
-    sizesofar += i;
-    while (--i >= 0)
-	*pBuf++ = 0;
-
-    memset(&format, 0, sizeof(xPixmapFormat));
-    for (i=0; i<screenInfo.numPixmapFormats; i++)
-    {
-	format.depth = screenInfo.formats[i].depth;
-	format.bitsPerPixel = screenInfo.formats[i].bitsPerPixel;
-	format.scanLinePad = screenInfo.formats[i].scanlinePad;
-	memmove(pBuf, (char *)&format, sizeof(xPixmapFormat));
-	pBuf += sizeof(xPixmapFormat);
-	sizesofar += sizeof(xPixmapFormat);
-    }
-
-    connBlockScreenStart = sizesofar;
-    memset(&depth, 0, sizeof(xDepth));
-    memset(&visual, 0, sizeof(xVisualType));
-    for (i=0; i<screenInfo.numScreens; i++)
-    {
-	ScreenPtr	pScreen;
-	DepthPtr	pDepth;
-	VisualPtr	pVisual;
-
-	pScreen = screenInfo.screens[i];
-	root.windowId = WindowTable[i]->drawable.id;
-	root.defaultColormap = pScreen->defColormap;
-	root.whitePixel = pScreen->whitePixel;
-	root.blackPixel = pScreen->blackPixel;
-	root.currentInputMask = 0;    /* filled in when sent */
-	root.pixWidth = pScreen->width;
-	root.pixHeight = pScreen->height;
-	root.mmWidth = pScreen->mmWidth;
-	root.mmHeight = pScreen->mmHeight;
-	root.minInstalledMaps = pScreen->minInstalledCmaps;
-	root.maxInstalledMaps = pScreen->maxInstalledCmaps;
-	root.rootVisualID = pScreen->rootVisual;
-	root.backingStore = pScreen->backingStoreSupport;
-	root.saveUnders = FALSE;
-	root.rootDepth = pScreen->rootDepth;
-	root.nDepths = pScreen->numDepths;
-	memmove(pBuf, (char *)&root, sizeof(xWindowRoot));
-	sizesofar += sizeof(xWindowRoot);
-	pBuf += sizeof(xWindowRoot);
-
-	pDepth = pScreen->allowedDepths;
-	for(j = 0; j < pScreen->numDepths; j++, pDepth++)
-	{
-	    lenofblock += sizeof(xDepth) +
-		    (pDepth->numVids * sizeof(xVisualType));
-	    pBuf = (char *)xrealloc(ConnectionInfo, lenofblock);
-	    if (!pBuf)
-	    {
-		xfree(ConnectionInfo);
-		return FALSE;
-	    }
-	    ConnectionInfo = pBuf;
-	    pBuf += sizesofar;
-	    depth.depth = pDepth->depth;
-	    depth.nVisuals = pDepth->numVids;
-	    memmove(pBuf, (char *)&depth, sizeof(xDepth));
-	    pBuf += sizeof(xDepth);
-	    sizesofar += sizeof(xDepth);
-	    for(k = 0; k < pDepth->numVids; k++)
-	    {
-		vid = pDepth->vids[k];
-		for (pVisual = pScreen->visuals;
-		     pVisual->vid != vid;
-		     pVisual++)
-		    ;
-		visual.visualID = vid;
-		visual.class = pVisual->class;
-		visual.bitsPerRGB = pVisual->bitsPerRGBValue;
-		visual.colormapEntries = pVisual->ColormapEntries;
-		visual.redMask = pVisual->redMask;
-		visual.greenMask = pVisual->greenMask;
-		visual.blueMask = pVisual->blueMask;
-		memmove(pBuf, (char *)&visual, sizeof(xVisualType));
-		pBuf += sizeof(xVisualType);
-		sizesofar += sizeof(xVisualType);
-	    }
-	}
-    }
-    connSetupPrefix.success = xTrue;
-    connSetupPrefix.length = lenofblock/4;
-    connSetupPrefix.majorVersion = X_PROTOCOL;
-    connSetupPrefix.minorVersion = X_PROTOCOL_REVISION;
-    return TRUE;
-}
-
-
-int
-ProcBadRequest(ClientPtr client)
-{
-    return (BadRequest);
-}
-
-int
-ProcCreateWindow(ClientPtr client)
-{
-    WindowPtr pParent, pWin;
-    REQUEST(xCreateWindowReq);
-    int len, rc;
-
-    REQUEST_AT_LEAST_SIZE(xCreateWindowReq);
-    
-    LEGAL_NEW_RESOURCE(stuff->wid, client);
-    rc = dixLookupWindow(&pParent, stuff->parent, client, DixAddAccess);
-    if (rc != Success)
-        return rc;
-    len = client->req_len - bytes_to_int32(sizeof(xCreateWindowReq));
-    if (Ones(stuff->mask) != len)
-        return BadLength;
-    if (!stuff->width || !stuff->height)
-    {
-	client->errorValue = 0;
-        return BadValue;
-    }
-    pWin = CreateWindow(stuff->wid, pParent, stuff->x,
-			      stuff->y, stuff->width, stuff->height, 
-			      stuff->borderWidth, stuff->class,
-			      stuff->mask, (XID *) &stuff[1], 
-			      (int)stuff->depth, 
-			      client, stuff->visual, &rc);
-    if (pWin)
-    {
-	Mask mask = pWin->eventMask;
-
-	pWin->eventMask = 0; /* subterfuge in case AddResource fails */
-	if (!AddResource(stuff->wid, RT_WINDOW, (pointer)pWin))
-	    return BadAlloc;
-	pWin->eventMask = mask;
-    }
-    if (client->noClientException != Success)
-        return(client->noClientException);
-    else
-        return rc;
-}
-
-int
-ProcChangeWindowAttributes(ClientPtr client)
-{
-    WindowPtr pWin;
-    REQUEST(xChangeWindowAttributesReq);
-    int result, len, rc;
-    Mask access_mode = 0;
-
-    REQUEST_AT_LEAST_SIZE(xChangeWindowAttributesReq);
-    access_mode |= (stuff->valueMask & CWEventMask) ? DixReceiveAccess : 0;
-    access_mode |= (stuff->valueMask & ~CWEventMask) ? DixSetAttrAccess : 0;
-    rc = dixLookupWindow(&pWin, stuff->window, client, access_mode);
-    if (rc != Success)
-        return rc;
-    len = client->req_len - bytes_to_int32(sizeof(xChangeWindowAttributesReq));
-    if (len != Ones(stuff->valueMask))
-        return BadLength;
-    result =  ChangeWindowAttributes(pWin, 
-				  stuff->valueMask, 
-				  (XID *) &stuff[1], 
-				  client);
-    if (client->noClientException != Success)
-        return(client->noClientException);
-    else
-        return(result);
-}
-
-int
-ProcGetWindowAttributes(ClientPtr client)
-{
-    WindowPtr pWin;
-    REQUEST(xResourceReq);
-    xGetWindowAttributesReply wa;
-    int rc;
-
-    REQUEST_SIZE_MATCH(xResourceReq);
-    rc = dixLookupWindow(&pWin, stuff->id, client, DixGetAttrAccess);
-    if (rc != Success)
-	return rc;
-    memset(&wa, 0, sizeof(xGetWindowAttributesReply));
-    GetWindowAttributes(pWin, client, &wa);
-    WriteReplyToClient(client, sizeof(xGetWindowAttributesReply), &wa);
-    return(client->noClientException);
-}
-
-int
-ProcDestroyWindow(ClientPtr client)
-{
-    WindowPtr pWin;
-    REQUEST(xResourceReq);
-    int rc;
-
-    REQUEST_SIZE_MATCH(xResourceReq);
-    rc = dixLookupWindow(&pWin, stuff->id, client, DixDestroyAccess);
-    if (rc != Success)
-	return rc;
-    if (pWin->parent) {
-	rc = dixLookupWindow(&pWin, pWin->parent->drawable.id, client,
-			     DixRemoveAccess);
-	if (rc != Success)
-	    return rc;
-	FreeResource(stuff->id, RT_NONE);
-    }
-    return(client->noClientException);
-}
-
-int
-ProcDestroySubwindows(ClientPtr client)
-{
-    WindowPtr pWin;
-    REQUEST(xResourceReq);
-    int rc;
-
-    REQUEST_SIZE_MATCH(xResourceReq);
-    rc = dixLookupWindow(&pWin, stuff->id, client, DixRemoveAccess);
-    if (rc != Success)
-	return rc;
-    DestroySubwindows(pWin, client);
-    return(client->noClientException);
-}
-
-int
-ProcChangeSaveSet(ClientPtr client)
-{
-    WindowPtr pWin;
-    REQUEST(xChangeSaveSetReq);
-    int result, rc;
-		  
-    REQUEST_SIZE_MATCH(xChangeSaveSetReq);
-    rc = dixLookupWindow(&pWin, stuff->window, client, DixManageAccess);
-    if (rc != Success)
-        return rc;
-    if (client->clientAsMask == (CLIENT_BITS(pWin->drawable.id)))
-        return BadMatch;
-    if ((stuff->mode == SetModeInsert) || (stuff->mode == SetModeDelete))
-    {
-        result = AlterSaveSetForClient(client, pWin, stuff->mode, FALSE, TRUE);
-	if (client->noClientException != Success)
-	    return(client->noClientException);
-	else
-            return(result);
-    }
-    else
-    {
-	client->errorValue = stuff->mode;
-	return( BadValue );
-    }
-}
-
-int
-ProcReparentWindow(ClientPtr client)
-{
-    WindowPtr pWin, pParent;
-    REQUEST(xReparentWindowReq);
-    int result, rc;
-
-    REQUEST_SIZE_MATCH(xReparentWindowReq);
-    rc = dixLookupWindow(&pWin, stuff->window, client, DixManageAccess);
-    if (rc != Success)
-        return rc;
-    rc = dixLookupWindow(&pParent, stuff->parent, client, DixAddAccess);
-    if (rc != Success)
-        return rc;
-    if (SAME_SCREENS(pWin->drawable, pParent->drawable))
-    {
-        if ((pWin->backgroundState == ParentRelative) &&
-            (pParent->drawable.depth != pWin->drawable.depth))
-            return BadMatch;
-	if ((pWin->drawable.class != InputOnly) &&
-	    (pParent->drawable.class == InputOnly))
-	    return BadMatch;
-        result =  ReparentWindow(pWin, pParent, 
-			 (short)stuff->x, (short)stuff->y, client);
-	if (client->noClientException != Success)
-            return(client->noClientException);
-	else
-            return(result);
-    }
-    else 
-        return (BadMatch);
-}
-
-int
-ProcMapWindow(ClientPtr client)
-{
-    WindowPtr pWin;
-    REQUEST(xResourceReq);
-    int rc;
-
-    REQUEST_SIZE_MATCH(xResourceReq);
-    rc = dixLookupWindow(&pWin, stuff->id, client, DixShowAccess);
-    if (rc != Success)
-        return rc;
-    MapWindow(pWin, client);
-           /* update cache to say it is mapped */
-    return(client->noClientException);
-}
-
-int
-ProcMapSubwindows(ClientPtr client)
-{
-    WindowPtr pWin;
-    REQUEST(xResourceReq);
-    int rc;
-
-    REQUEST_SIZE_MATCH(xResourceReq);
-    rc = dixLookupWindow(&pWin, stuff->id, client, DixListAccess);
-    if (rc != Success)
-        return rc;
-    MapSubwindows(pWin, client);
-           /* update cache to say it is mapped */
-    return(client->noClientException);
-}
-
-int
-ProcUnmapWindow(ClientPtr client)
-{
-    WindowPtr pWin;
-    REQUEST(xResourceReq);
-    int rc;
-
-    REQUEST_SIZE_MATCH(xResourceReq);
-    rc = dixLookupWindow(&pWin, stuff->id, client, DixHideAccess);
-    if (rc != Success)
-        return rc;
-    UnmapWindow(pWin, FALSE);
-           /* update cache to say it is mapped */
-    return(client->noClientException);
-}
-
-int
-ProcUnmapSubwindows(ClientPtr client)
-{
-    WindowPtr pWin;
-    REQUEST(xResourceReq);
-    int rc;
-
-    REQUEST_SIZE_MATCH(xResourceReq);
-    rc = dixLookupWindow(&pWin, stuff->id, client, DixListAccess);
-    if (rc != Success)
-        return rc;
-    UnmapSubwindows(pWin);
-    return(client->noClientException);
-}
-
-int
-ProcConfigureWindow(ClientPtr client)
-{
-    WindowPtr pWin;
-    REQUEST(xConfigureWindowReq);
-    int result;
-    int len, rc;
-
-    REQUEST_AT_LEAST_SIZE(xConfigureWindowReq);
-    rc = dixLookupWindow(&pWin, stuff->window, client,
-			 DixManageAccess|DixSetAttrAccess);
-    if (rc != Success)
-        return rc;
-    len = client->req_len - bytes_to_int32(sizeof(xConfigureWindowReq));
-    if (Ones((Mask)stuff->mask) != len)
-        return BadLength;
-    result =  ConfigureWindow(pWin, (Mask)stuff->mask, (XID *) &stuff[1], 
-			      client);
-    if (client->noClientException != Success)
-        return(client->noClientException);
-    else
-        return(result);
-}
-
-int
-ProcCirculateWindow(ClientPtr client)
-{
-    WindowPtr pWin;
-    REQUEST(xCirculateWindowReq);
-    int rc;
-
-    REQUEST_SIZE_MATCH(xCirculateWindowReq);
-    if ((stuff->direction != RaiseLowest) &&
-	(stuff->direction != LowerHighest))
-    {
-	client->errorValue = stuff->direction;
-        return BadValue;
-    }
-    rc = dixLookupWindow(&pWin, stuff->window, client, DixManageAccess);
-    if (rc != Success)
-        return rc;
-    CirculateWindow(pWin, (int)stuff->direction, client);
-    return(client->noClientException);
-}
-
-static int
-GetGeometry(ClientPtr client, xGetGeometryReply *rep)
-{
-    DrawablePtr pDraw;
-    int rc;
-    REQUEST(xResourceReq);
-    REQUEST_SIZE_MATCH(xResourceReq);
-
-    rc = dixLookupDrawable(&pDraw, stuff->id, client, M_ANY, DixGetAttrAccess);
-    if (rc != Success)
-	return rc;
-
-    rep->type = X_Reply;
-    rep->length = 0;
-    rep->sequenceNumber = client->sequence;
-    rep->root = WindowTable[pDraw->pScreen->myNum]->drawable.id;
-    rep->depth = pDraw->depth;
-    rep->width = pDraw->width;
-    rep->height = pDraw->height;
-
-    /* XXX - Because the pixmap-implementation of the multibuffer extension 
-     *       may have the buffer-id's drawable resource value be a pointer
-     *       to the buffer's window instead of the buffer itself
-     *       (this happens if the buffer is the displayed buffer),
-     *       we also have to check that the id matches before we can
-     *       truly say that it is a DRAWABLE_WINDOW.
-     */
-
-    if ((pDraw->type == UNDRAWABLE_WINDOW) ||
-        ((pDraw->type == DRAWABLE_WINDOW) && (stuff->id == pDraw->id)))
-    {
-        WindowPtr pWin = (WindowPtr)pDraw;
-	rep->x = pWin->origin.x - wBorderWidth (pWin);
-	rep->y = pWin->origin.y - wBorderWidth (pWin);
-	rep->borderWidth = pWin->borderWidth;
-    }
-    else /* DRAWABLE_PIXMAP or DRAWABLE_BUFFER */
-    {
-	rep->x = rep->y = rep->borderWidth = 0;
-    }
-
-    return Success;
-}
-
-
-int
-ProcGetGeometry(ClientPtr client)
-{
-    xGetGeometryReply rep;
-    int status;
-
-    memset(&rep, 0, sizeof(xGetGeometryReply));
-    if ((status = GetGeometry(client, &rep)) != Success)
-	return status;
-
-    WriteReplyToClient(client, sizeof(xGetGeometryReply), &rep);
-    return(client->noClientException);
-}
-
-
-int
-ProcQueryTree(ClientPtr client)
-{
-    xQueryTreeReply reply;
-    int rc, numChildren = 0;
-    WindowPtr pChild, pWin, pHead;
-    Window  *childIDs = (Window *)NULL;
-    REQUEST(xResourceReq);
-
-    REQUEST_SIZE_MATCH(xResourceReq);
-    rc = dixLookupWindow(&pWin, stuff->id, client, DixListAccess);
-    if (rc != Success)
-        return rc;
-    memset(&reply, 0, sizeof(xQueryTreeReply));
-    reply.type = X_Reply;
-    reply.root = WindowTable[pWin->drawable.pScreen->myNum]->drawable.id;
-    reply.sequenceNumber = client->sequence;
-    if (pWin->parent)
-	reply.parent = pWin->parent->drawable.id;
-    else
-        reply.parent = (Window)None;
-    pHead = RealChildHead(pWin);
-    for (pChild = pWin->lastChild; pChild != pHead; pChild = pChild->prevSib)
-	numChildren++;
-    if (numChildren)
-    {
-	int curChild = 0;
-
-	childIDs = xalloc(numChildren * sizeof(Window));
-	if (!childIDs)
-	    return BadAlloc;
-	for (pChild = pWin->lastChild; pChild != pHead; pChild = pChild->prevSib)
-	    childIDs[curChild++] = pChild->drawable.id;
-    }
-    
-    reply.nChildren = numChildren;
-    reply.length = bytes_to_int32(numChildren * sizeof(Window));
-    
-    WriteReplyToClient(client, sizeof(xQueryTreeReply), &reply);
-    if (numChildren)
-    {
-    	client->pSwapReplyFunc = (ReplySwapPtr) Swap32Write;
-	WriteSwappedDataToClient(client, numChildren * sizeof(Window), childIDs);
-	xfree(childIDs);
-    }
-
-    return(client->noClientException);
-}
-
-int
-ProcInternAtom(ClientPtr client)
-{
-    Atom atom;
-    char *tchar;
-    REQUEST(xInternAtomReq);
-
-    REQUEST_FIXED_SIZE(xInternAtomReq, stuff->nbytes);
-    if ((stuff->onlyIfExists != xTrue) && (stuff->onlyIfExists != xFalse))
-    {
-	client->errorValue = stuff->onlyIfExists;
-        return(BadValue);
-    }
-    tchar = (char *) &stuff[1];
-    atom = MakeAtom(tchar, stuff->nbytes, !stuff->onlyIfExists);
-    if (atom != BAD_RESOURCE)
-    {
-	xInternAtomReply reply;
-	memset(&reply, 0, sizeof(xInternAtomReply));
-	reply.type = X_Reply;
-	reply.length = 0;
-	reply.sequenceNumber = client->sequence;
-	reply.atom = atom;
-	WriteReplyToClient(client, sizeof(xInternAtomReply), &reply);
-	return(client->noClientException);
-    }
-    else
-	return (BadAlloc);
-}
-
-int
-ProcGetAtomName(ClientPtr client)
-{
-    const char *str;
-    xGetAtomNameReply reply;
-    int len;
-    REQUEST(xResourceReq);
-
-    REQUEST_SIZE_MATCH(xResourceReq);
-    if ( (str = NameForAtom(stuff->id)) )
-    {
-	len = strlen(str);
-	memset(&reply, 0, sizeof(xGetAtomNameReply));
-	reply.type = X_Reply;
-	reply.length = bytes_to_int32(len);
-	reply.sequenceNumber = client->sequence;
-	reply.nameLength = len;
-	WriteReplyToClient(client, sizeof(xGetAtomNameReply), &reply);
-	(void)WriteToClient(client, len, str);
-	return(client->noClientException);
-    }
-    else 
-    { 
-	client->errorValue = stuff->id;
-	return (BadAtom);
-    }
-}
-
-int
-ProcGrabServer(ClientPtr client)
-{
-    int rc;
-    REQUEST_SIZE_MATCH(xReq);
-    if (grabState != GrabNone && client != grabClient)
-    {
-	ResetCurrentRequest(client);
-	client->sequence--;
-	BITSET(grabWaiters, client->index);
-	IgnoreClient(client);
-	return(client->noClientException);
-    }
-    rc = OnlyListenToOneClient(client);
-    if (rc != Success)
-	return rc;
-    grabState = GrabKickout;
-    grabClient = client;
-
-    if (ServerGrabCallback)
-    {
-	ServerGrabInfoRec grabinfo;
-	grabinfo.client = client;
-	grabinfo.grabstate  = SERVER_GRABBED;
-	CallCallbacks(&ServerGrabCallback, (pointer)&grabinfo);
-    }
-
-    return(client->noClientException);
-}
-
-static void
-UngrabServer(ClientPtr client)
-{
-    int i;
-
-    grabState = GrabNone;
-    ListenToAllClients();
-    for (i = mskcnt; --i >= 0 && !grabWaiters[i]; )
-	;
-    if (i >= 0)
-    {
-	i <<= 5;
-	while (!GETBIT(grabWaiters, i))
-	    i++;
-	BITCLEAR(grabWaiters, i);
-	AttendClient(clients[i]);
-    }
-
-    if (ServerGrabCallback)
-    {
-	ServerGrabInfoRec grabinfo;
-	grabinfo.client = client;
-	grabinfo.grabstate  = SERVER_UNGRABBED;
-	CallCallbacks(&ServerGrabCallback, (pointer)&grabinfo);
-    }
-}
-
-int
-ProcUngrabServer(ClientPtr client)
-{
-    REQUEST_SIZE_MATCH(xReq);
-    UngrabServer(client);
-    return(client->noClientException);
-}
-
-int
-ProcTranslateCoords(ClientPtr client)
-{
-    REQUEST(xTranslateCoordsReq);
-
-    WindowPtr pWin, pDst;
-    xTranslateCoordsReply rep;
-    int rc;
-
-    REQUEST_SIZE_MATCH(xTranslateCoordsReq);
-    rc = dixLookupWindow(&pWin, stuff->srcWid, client, DixGetAttrAccess);
-    if (rc != Success)
-        return rc;
-    rc = dixLookupWindow(&pDst, stuff->dstWid, client, DixGetAttrAccess);
-    if (rc != Success)
-        return rc;
-    memset(&rep, 0, sizeof(xTranslateCoordsReply));
-    rep.type = X_Reply;
-    rep.length = 0;
-    rep.sequenceNumber = client->sequence;
-    if (!SAME_SCREENS(pWin->drawable, pDst->drawable))
-    {
-	rep.sameScreen = xFalse;
-        rep.child = None;
-	rep.dstX = rep.dstY = 0;
-    }
-    else
-    {
-	INT16 x, y;
-	rep.sameScreen = xTrue;
-	rep.child = None;
-	/* computing absolute coordinates -- adjust to destination later */
-	x = pWin->drawable.x + stuff->srcX;
-	y = pWin->drawable.y + stuff->srcY;
-	pWin = pDst->firstChild;
-	while (pWin)
-	{
-	    BoxRec  box;
-	    if ((pWin->mapped) &&
-		(x >= pWin->drawable.x - wBorderWidth (pWin)) &&
-		(x < pWin->drawable.x + (int)pWin->drawable.width +
-		 wBorderWidth (pWin)) &&
-		(y >= pWin->drawable.y - wBorderWidth (pWin)) &&
-		(y < pWin->drawable.y + (int)pWin->drawable.height +
-		 wBorderWidth (pWin))
-		/* When a window is shaped, a further check
-		 * is made to see if the point is inside
-		 * borderSize
-		 */
-		&& (!wBoundingShape(pWin) ||
-		    POINT_IN_REGION(pWin->drawable.pScreen, 
-					&pWin->borderSize, x, y, &box))
-		
-		&& (!wInputShape(pWin) ||
-		    POINT_IN_REGION(pWin->drawable.pScreen,
-				    wInputShape(pWin),
-				    x - pWin->drawable.x,
-				    y - pWin->drawable.y, &box))
-		)
-            {
-		rep.child = pWin->drawable.id;
-		pWin = (WindowPtr) NULL;
-	    }
-	    else
-		pWin = pWin->nextSib;
-	}
-	/* adjust to destination coordinates */
-	rep.dstX = x - pDst->drawable.x;
-	rep.dstY = y - pDst->drawable.y;
-    }
-    WriteReplyToClient(client, sizeof(xTranslateCoordsReply), &rep);
-    return(client->noClientException);
-}
-
-int
-ProcOpenFont(ClientPtr client)
-{
-    int	err;
-    REQUEST(xOpenFontReq);
-
-    REQUEST_FIXED_SIZE(xOpenFontReq, stuff->nbytes);
-    client->errorValue = stuff->fid;
-    LEGAL_NEW_RESOURCE(stuff->fid, client);
-    err = OpenFont(client, stuff->fid, (Mask) 0,
-		stuff->nbytes, (char *)&stuff[1]);
-    if (err == Success)
-    {
-	return(client->noClientException);
-    }
-    else
-	return err;
-}
-
-int
-ProcCloseFont(ClientPtr client)
-{
-    FontPtr pFont;
-    int rc;
-    REQUEST(xResourceReq);
-
-    REQUEST_SIZE_MATCH(xResourceReq);
-    rc = dixLookupResourceByType((pointer *)&pFont, stuff->id, RT_FONT,
-				 client, DixDestroyAccess);
-    if (rc == Success)
-    {
-        FreeResource(stuff->id, RT_NONE);
-	return(client->noClientException);
-    }
-    else
-    {
-	client->errorValue = stuff->id;
-        return (rc == BadValue) ? BadFont : rc;
-    }
-}
-
-int
-ProcQueryFont(ClientPtr client)
-{
-    xQueryFontReply	*reply;
-    FontPtr pFont;
-    GC *pGC;
-    int rc;
-    REQUEST(xResourceReq);
-    REQUEST_SIZE_MATCH(xResourceReq);
-
-    client->errorValue = stuff->id;		/* EITHER font or gc */
-    rc = dixLookupResourceByType((pointer *)&pFont, stuff->id, RT_FONT, client,
-				 DixGetAttrAccess);
-    if (rc == BadValue) {
-	rc = dixLookupResourceByType((pointer *)&pGC, stuff->id, RT_GC, client,
-				     DixGetAttrAccess);
-	if (rc == Success)
-	    pFont = pGC->font;
-    }
-    if (rc != Success)
-	return (rc == BadValue) ? BadFont: rc;
-
-    {
-	xCharInfo	*pmax = FONTINKMAX(pFont);
-	xCharInfo	*pmin = FONTINKMIN(pFont);
-	int		nprotoxcistructs;
-	int		rlength;
-
-	nprotoxcistructs = (
-	   pmax->rightSideBearing == pmin->rightSideBearing &&
-	   pmax->leftSideBearing == pmin->leftSideBearing &&
-	   pmax->descent == pmin->descent &&
-	   pmax->ascent == pmin->ascent &&
-	   pmax->characterWidth == pmin->characterWidth) ?
-		0 : N2dChars(pFont);
-
-	rlength = sizeof(xQueryFontReply) +
-	             FONTINFONPROPS(FONTCHARSET(pFont)) * sizeof(xFontProp)  +
-		     nprotoxcistructs * sizeof(xCharInfo);
-	reply = xcalloc(1, rlength);
-	if(!reply)
-	{
-	    return(BadAlloc);
-	}
-
-	reply->type = X_Reply;
-	reply->length = bytes_to_int32(rlength - sizeof(xGenericReply));
-	reply->sequenceNumber = client->sequence;
-	QueryFont( pFont, reply, nprotoxcistructs);
-
-        WriteReplyToClient(client, rlength, reply);
-	xfree(reply);
-	return(client->noClientException);
-    }
-}
-
-int
-ProcQueryTextExtents(ClientPtr client)
-{
-    xQueryTextExtentsReply reply;
-    FontPtr pFont;
-    GC *pGC;
-    ExtentInfoRec info;
-    unsigned long length;
-    int rc;
-    REQUEST(xQueryTextExtentsReq);
-    REQUEST_AT_LEAST_SIZE(xQueryTextExtentsReq);
-        
-    client->errorValue = stuff->fid;		/* EITHER font or gc */
-    rc = dixLookupResourceByType((pointer *)&pFont, stuff->fid, RT_FONT, client,
-				 DixGetAttrAccess);
-    if (rc == BadValue) {
-	rc = dixLookupResourceByType((pointer *)&pGC, stuff->fid, RT_GC, client,
-			       DixGetAttrAccess);
-	if (rc == Success)
-	    pFont = pGC->font;
-    }
-    if (rc != Success)
-	return (rc == BadValue) ? BadFont: rc;
-
-    length = client->req_len - bytes_to_int32(sizeof(xQueryTextExtentsReq));
-    length = length << 1;
-    if (stuff->oddLength)
-    {
-	if (length == 0)
-	    return(BadLength);
-        length--;
-    }
-    if (!QueryTextExtents(pFont, length, (unsigned char *)&stuff[1], &info))
-	return(BadAlloc);
-    reply.type = X_Reply;
-    reply.length = 0;
-    reply.sequenceNumber = client->sequence;
-    reply.drawDirection = info.drawDirection;
-    reply.fontAscent = info.fontAscent;
-    reply.fontDescent = info.fontDescent;
-    reply.overallAscent = info.overallAscent;
-    reply.overallDescent = info.overallDescent;
-    reply.overallWidth = info.overallWidth;
-    reply.overallLeft = info.overallLeft;
-    reply.overallRight = info.overallRight;
-    WriteReplyToClient(client, sizeof(xQueryTextExtentsReply), &reply);
-    return(client->noClientException);
-}
-
-int
-ProcListFonts(ClientPtr client)
-{
-    REQUEST(xListFontsReq);
-
-    REQUEST_FIXED_SIZE(xListFontsReq, stuff->nbytes);
-
-    return ListFonts(client, (unsigned char *) &stuff[1], stuff->nbytes, 
-	stuff->maxNames);
-}
-
-int
-ProcListFontsWithInfo(ClientPtr client)
-{
-    REQUEST(xListFontsWithInfoReq);
-
-    REQUEST_FIXED_SIZE(xListFontsWithInfoReq, stuff->nbytes);
-
-    return StartListFontsWithInfo(client, stuff->nbytes,
-				  (unsigned char *) &stuff[1], stuff->maxNames);
-}
-
-/**
- *
- *  \param value must conform to DeleteType
- */
-int
-dixDestroyPixmap(pointer value, XID pid)
-{
-    PixmapPtr pPixmap = (PixmapPtr)value;
-    return (*pPixmap->drawable.pScreen->DestroyPixmap)(pPixmap);
-}
-
-int
-ProcCreatePixmap(ClientPtr client)
-{
-    PixmapPtr pMap;
-    DrawablePtr pDraw;
-    REQUEST(xCreatePixmapReq);
-    DepthPtr pDepth;
-    int i, rc;
-
-    REQUEST_SIZE_MATCH(xCreatePixmapReq);
-    client->errorValue = stuff->pid;
-    LEGAL_NEW_RESOURCE(stuff->pid, client);
-    
-    rc = dixLookupDrawable(&pDraw, stuff->drawable, client, M_ANY,
-			   DixGetAttrAccess);
-    if (rc != Success)
-	return rc;
-
-    if (!stuff->width || !stuff->height)
-    {
-	client->errorValue = 0;
-        return BadValue;
-    }
-    if (stuff->width > 32767 || stuff->height > 32767)
-    {
-	/* It is allowed to try and allocate a pixmap which is larger than
-	 * 32767 in either dimension. However, all of the framebuffer code
-	 * is buggy and does not reliably draw to such big pixmaps, basically
-	 * because the Region data structure operates with signed shorts
-	 * for the rectangles in it.
-	 *
-	 * Furthermore, several places in the X server computes the
-	 * size in bytes of the pixmap and tries to store it in an
-	 * integer. This integer can overflow and cause the allocated size
-	 * to be much smaller.
-	 *
-	 * So, such big pixmaps are rejected here with a BadAlloc
-	 */
-	return BadAlloc;
-    }
-    if (stuff->depth != 1)
-    {
-        pDepth = pDraw->pScreen->allowedDepths;
-        for (i=0; i<pDraw->pScreen->numDepths; i++, pDepth++)
-	   if (pDepth->depth == stuff->depth)
-               goto CreatePmap;
-	client->errorValue = stuff->depth;
-        return BadValue;
-    }
-CreatePmap:
-    pMap = (PixmapPtr)(*pDraw->pScreen->CreatePixmap)
-		(pDraw->pScreen, stuff->width,
-		 stuff->height, stuff->depth, 0);
-    if (pMap)
-    {
-	pMap->drawable.serialNumber = NEXT_SERIAL_NUMBER;
-	pMap->drawable.id = stuff->pid;
-	/* security creation/labeling check */
-	rc = XaceHook(XACE_RESOURCE_ACCESS, client, stuff->pid, RT_PIXMAP,
-		      pMap, RT_NONE, NULL, DixCreateAccess);
-	if (rc != Success) {
-	    (*pDraw->pScreen->DestroyPixmap)(pMap);
-	    return rc;
-	}
-	if (AddResource(stuff->pid, RT_PIXMAP, (pointer)pMap))
-	    return(client->noClientException);
-	(*pDraw->pScreen->DestroyPixmap)(pMap);
-    }
-    return (BadAlloc);
-}
-
-int
-ProcFreePixmap(ClientPtr client)
-{
-    PixmapPtr pMap;
-    int rc;
-    REQUEST(xResourceReq);
-    REQUEST_SIZE_MATCH(xResourceReq);
-
-    rc = dixLookupResourceByType((pointer *)&pMap, stuff->id, RT_PIXMAP, client,
-			   DixDestroyAccess);
-    if (rc == Success)
-    {
-	FreeResource(stuff->id, RT_NONE);
-	return(client->noClientException);
-    }
-    else 
-    {
-	client->errorValue = stuff->id;
-	return (rc == BadValue) ? BadPixmap : rc;
-    }
-}
-
-int
-ProcCreateGC(ClientPtr client)
-{
-    int error, rc;
-    GC *pGC;
-    DrawablePtr pDraw;
-    unsigned len;
-    REQUEST(xCreateGCReq);
-
-    REQUEST_AT_LEAST_SIZE(xCreateGCReq);
-    client->errorValue = stuff->gc;
-    LEGAL_NEW_RESOURCE(stuff->gc, client);
-    rc = dixLookupDrawable(&pDraw, stuff->drawable, client, 0,
-			   DixGetAttrAccess);
-    if (rc != Success)
-	return rc;
-
-    len = client->req_len -  bytes_to_int32(sizeof(xCreateGCReq));
-    if (len != Ones(stuff->mask))
-        return BadLength;
-    pGC = (GC *)CreateGC(pDraw, stuff->mask, (XID *) &stuff[1], &error,
-			 stuff->gc, client);
-    if (error != Success)
-        return error;
-    if (!AddResource(stuff->gc, RT_GC, (pointer)pGC))
-	return (BadAlloc);
-    return(client->noClientException);
-}
-
-int
-ProcChangeGC(ClientPtr client)
-{
-    GC *pGC;
-    int result;
-    unsigned len;
-    REQUEST(xChangeGCReq);
-    REQUEST_AT_LEAST_SIZE(xChangeGCReq);
-
-    result = dixLookupGC(&pGC, stuff->gc, client, DixSetAttrAccess);
-    if (result != Success)
-	return result;
-
-    len = client->req_len -  bytes_to_int32(sizeof(xChangeGCReq));
-    if (len != Ones(stuff->mask))
-        return BadLength;
-
-    result = dixChangeGC(client, pGC, stuff->mask, (CARD32 *) &stuff[1], 0);
-    if (client->noClientException != Success)
-        return(client->noClientException);
-    else
-    {
-	client->errorValue = clientErrorValue;
-        return(result);
-    }
-}
-
-int
-ProcCopyGC(ClientPtr client)
-{
-    GC *dstGC;
-    GC *pGC;
-    int result;
-    REQUEST(xCopyGCReq);
-    REQUEST_SIZE_MATCH(xCopyGCReq);
-
-    result = dixLookupGC(&pGC, stuff->srcGC, client, DixGetAttrAccess);
-    if (result != Success)
-	return result;
-    result = dixLookupGC(&dstGC, stuff->dstGC, client, DixSetAttrAccess);
-    if (result != Success)
-	return result;
-    if ((dstGC->pScreen != pGC->pScreen) || (dstGC->depth != pGC->depth))
-        return (BadMatch);    
-    result = CopyGC(pGC, dstGC, stuff->mask);
-    if (client->noClientException != Success)
-        return(client->noClientException);
-    else
-    {
-	client->errorValue = clientErrorValue;
-        return(result);
-    }
-}
-
-int
-ProcSetDashes(ClientPtr client)
-{
-    GC *pGC;
-    int result;
-    REQUEST(xSetDashesReq);
-
-    REQUEST_FIXED_SIZE(xSetDashesReq, stuff->nDashes);
-    if (stuff->nDashes == 0)
-    {
-	 client->errorValue = 0;
-         return BadValue;
-    }
-
-    result = dixLookupGC(&pGC,stuff->gc, client, DixSetAttrAccess);
-    if (result != Success)
-	return result;
-
-    result = SetDashes(pGC, stuff->dashOffset, stuff->nDashes,
-		       (unsigned char *)&stuff[1]);
-    if (client->noClientException != Success)
-        return(client->noClientException);
-    else
-    {
-	client->errorValue = clientErrorValue;
-        return(result);
-    }
-}
-
-int
-ProcSetClipRectangles(ClientPtr client)
-{
-    int	nr, result;
-    GC *pGC;
-    REQUEST(xSetClipRectanglesReq);
-
-    REQUEST_AT_LEAST_SIZE(xSetClipRectanglesReq);
-    if ((stuff->ordering != Unsorted) && (stuff->ordering != YSorted) &&
-	(stuff->ordering != YXSorted) && (stuff->ordering != YXBanded))
-    {
-	client->errorValue = stuff->ordering;
-        return BadValue;
-    }
-    result = dixLookupGC(&pGC,stuff->gc, client, DixSetAttrAccess);
-    if (result != Success)
-	return result;
-		 
-    nr = (client->req_len << 2) - sizeof(xSetClipRectanglesReq);
-    if (nr & 4)
-	return(BadLength);
-    nr >>= 3;
-    result = SetClipRects(pGC, stuff->xOrigin, stuff->yOrigin,
-			  nr, (xRectangle *)&stuff[1], (int)stuff->ordering);
-    if (client->noClientException != Success)
-        return(client->noClientException);
-    else
-        return(result);
-}
-
-int
-ProcFreeGC(ClientPtr client)
-{
-    GC *pGC;
-    int rc;
-    REQUEST(xResourceReq);
-    REQUEST_SIZE_MATCH(xResourceReq);
-
-    rc = dixLookupGC(&pGC, stuff->id, client, DixDestroyAccess);
-    if (rc != Success)
-	return rc;
-
-    FreeResource(stuff->id, RT_NONE);
-    return(client->noClientException);
-}
-
-int
-ProcClearToBackground(ClientPtr client)
-{
-    REQUEST(xClearAreaReq);
-    WindowPtr pWin;
-    int rc;
-
-    REQUEST_SIZE_MATCH(xClearAreaReq);
-    rc = dixLookupWindow(&pWin, stuff->window, client, DixWriteAccess);
-    if (rc != Success)
-        return rc;
-    if (pWin->drawable.class == InputOnly)
-    {
-	client->errorValue = stuff->window;
-	return (BadMatch);
-    }		    
-    if ((stuff->exposures != xTrue) && (stuff->exposures != xFalse))
-    {
-	client->errorValue = stuff->exposures;
-        return(BadValue);
-    }
-    (*pWin->drawable.pScreen->ClearToBackground)(pWin, stuff->x, stuff->y,
-			       stuff->width, stuff->height,
-			       (Bool)stuff->exposures);
-    return(client->noClientException);
-}
-
-int
-ProcCopyArea(ClientPtr client)
-{
-    DrawablePtr pDst;
-    DrawablePtr pSrc;
-    GC *pGC;
-    REQUEST(xCopyAreaReq);
-    RegionPtr pRgn;
-    int rc;
-
-    REQUEST_SIZE_MATCH(xCopyAreaReq);
-
-    VALIDATE_DRAWABLE_AND_GC(stuff->dstDrawable, pDst, DixWriteAccess); 
-    if (stuff->dstDrawable != stuff->srcDrawable)
-    {
-	rc = dixLookupDrawable(&pSrc, stuff->srcDrawable, client, 0,
-				 DixReadAccess);
-	if (rc != Success)
-	    return rc;
-	if ((pDst->pScreen != pSrc->pScreen) || (pDst->depth != pSrc->depth))
-	{
-	    client->errorValue = stuff->dstDrawable;
-	    return (BadMatch);
-	}
-    }
-    else
-        pSrc = pDst;
-
-    pRgn = (*pGC->ops->CopyArea)(pSrc, pDst, pGC, stuff->srcX, stuff->srcY,
-				 stuff->width, stuff->height, 
-				 stuff->dstX, stuff->dstY);
-    if (pGC->graphicsExposures)
-    {
-	(*pDst->pScreen->SendGraphicsExpose)
- 		(client, pRgn, stuff->dstDrawable, X_CopyArea, 0);
-	if (pRgn)
-	    REGION_DESTROY(pDst->pScreen, pRgn);
-    }
-
-    return(client->noClientException);
-}
-
-int
-ProcCopyPlane(ClientPtr client)
-{
-    DrawablePtr psrcDraw, pdstDraw;
-    GC *pGC;
-    REQUEST(xCopyPlaneReq);
-    RegionPtr pRgn;
-    int rc;
-
-    REQUEST_SIZE_MATCH(xCopyPlaneReq);
-
-    VALIDATE_DRAWABLE_AND_GC(stuff->dstDrawable, pdstDraw, DixWriteAccess);
-    if (stuff->dstDrawable != stuff->srcDrawable)
-    {
-	rc = dixLookupDrawable(&psrcDraw, stuff->srcDrawable, client, 0,
-			       DixReadAccess);
-	if (rc != Success)
-	    return rc;
-
-	if (pdstDraw->pScreen != psrcDraw->pScreen)
-	{
-	    client->errorValue = stuff->dstDrawable;
-	    return (BadMatch);
-	}
-    }
-    else
-        psrcDraw = pdstDraw;
-
-    /* Check to see if stuff->bitPlane has exactly ONE good bit set */
-    if(stuff->bitPlane == 0 || (stuff->bitPlane & (stuff->bitPlane - 1)) ||
-       (stuff->bitPlane > (1L << (psrcDraw->depth - 1))))
-    {
-       client->errorValue = stuff->bitPlane;
-       return(BadValue);
-    }
-
-    pRgn = (*pGC->ops->CopyPlane)(psrcDraw, pdstDraw, pGC, stuff->srcX, stuff->srcY,
-				 stuff->width, stuff->height, 
-				 stuff->dstX, stuff->dstY, stuff->bitPlane);
-    if (pGC->graphicsExposures)
-    {
-	(*pdstDraw->pScreen->SendGraphicsExpose)
- 		(client, pRgn, stuff->dstDrawable, X_CopyPlane, 0);
-	if (pRgn)
-	    REGION_DESTROY(pdstDraw->pScreen, pRgn);
-    }
-    return(client->noClientException);
-}
-
-int
-ProcPolyPoint(ClientPtr client)
-{
-    int npoint;
-    GC *pGC;
-    DrawablePtr pDraw;
-    REQUEST(xPolyPointReq);
-
-    REQUEST_AT_LEAST_SIZE(xPolyPointReq);
-    if ((stuff->coordMode != CoordModeOrigin) && 
-	(stuff->coordMode != CoordModePrevious))
-    {
-	client->errorValue = stuff->coordMode;
-        return BadValue;
-    }
-    VALIDATE_DRAWABLE_AND_GC(stuff->drawable, pDraw, DixWriteAccess); 
-    npoint = bytes_to_int32((client->req_len << 2) - sizeof(xPolyPointReq));
-    if (npoint)
-        (*pGC->ops->PolyPoint)(pDraw, pGC, stuff->coordMode, npoint,
-			  (xPoint *) &stuff[1]);
-    return (client->noClientException);
-}
-
-int
-ProcPolyLine(ClientPtr client)
-{
-    int npoint;
-    GC *pGC;
-    DrawablePtr pDraw;
-    REQUEST(xPolyLineReq);
-
-    REQUEST_AT_LEAST_SIZE(xPolyLineReq);
-    if ((stuff->coordMode != CoordModeOrigin) && 
-	(stuff->coordMode != CoordModePrevious))
-    {
-	client->errorValue = stuff->coordMode;
-        return BadValue;
-    }
-    VALIDATE_DRAWABLE_AND_GC(stuff->drawable, pDraw, DixWriteAccess);
-    npoint = bytes_to_int32((client->req_len << 2) - sizeof(xPolyLineReq));
-    if (npoint > 1)
-	(*pGC->ops->Polylines)(pDraw, pGC, stuff->coordMode, npoint, 
-			      (DDXPointPtr) &stuff[1]);
-    return(client->noClientException);
-}
-
-int
-ProcPolySegment(ClientPtr client)
-{
-    int nsegs;
-    GC *pGC;
-    DrawablePtr pDraw;
-    REQUEST(xPolySegmentReq);
-
-    REQUEST_AT_LEAST_SIZE(xPolySegmentReq);
-    VALIDATE_DRAWABLE_AND_GC(stuff->drawable, pDraw, DixWriteAccess);
-    nsegs = (client->req_len << 2) - sizeof(xPolySegmentReq);
-    if (nsegs & 4)
-	return(BadLength);
-    nsegs >>= 3;
-    if (nsegs)
-        (*pGC->ops->PolySegment)(pDraw, pGC, nsegs, (xSegment *) &stuff[1]);
-    return (client->noClientException);
-}
-
-int
-ProcPolyRectangle (ClientPtr client)
-{
-    int nrects;
-    GC *pGC;
-    DrawablePtr pDraw;
-    REQUEST(xPolyRectangleReq);
-
-    REQUEST_AT_LEAST_SIZE(xPolyRectangleReq);
-    VALIDATE_DRAWABLE_AND_GC(stuff->drawable, pDraw, DixWriteAccess);
-    nrects = (client->req_len << 2) - sizeof(xPolyRectangleReq);
-    if (nrects & 4)
-	return(BadLength);
-    nrects >>= 3;
-    if (nrects)
-        (*pGC->ops->PolyRectangle)(pDraw, pGC, 
-		    nrects, (xRectangle *) &stuff[1]);
-    return(client->noClientException);
-}
-
-int
-ProcPolyArc(ClientPtr client)
-{
-    int		narcs;
-    GC *pGC;
-    DrawablePtr pDraw;
-    REQUEST(xPolyArcReq);
-
-    REQUEST_AT_LEAST_SIZE(xPolyArcReq);
-    VALIDATE_DRAWABLE_AND_GC(stuff->drawable, pDraw, DixWriteAccess);
-    narcs = (client->req_len << 2) - sizeof(xPolyArcReq);
-    if (narcs % sizeof(xArc))
-	return(BadLength);
-    narcs /= sizeof(xArc);
-    if (narcs)
-        (*pGC->ops->PolyArc)(pDraw, pGC, narcs, (xArc *) &stuff[1]);
-    return (client->noClientException);
-}
-
-int
-ProcFillPoly(ClientPtr client)
-{
-    int          things;
-    GC *pGC;
-    DrawablePtr pDraw;
-    REQUEST(xFillPolyReq);
-
-    REQUEST_AT_LEAST_SIZE(xFillPolyReq);
-    if ((stuff->shape != Complex) && (stuff->shape != Nonconvex) &&  
-	(stuff->shape != Convex))
-    {
-	client->errorValue = stuff->shape;
-        return BadValue;
-    }
-    if ((stuff->coordMode != CoordModeOrigin) && 
-	(stuff->coordMode != CoordModePrevious))
-    {
-	client->errorValue = stuff->coordMode;
-        return BadValue;
-    }
-
-    VALIDATE_DRAWABLE_AND_GC(stuff->drawable, pDraw, DixWriteAccess);
-    things = bytes_to_int32((client->req_len << 2) - sizeof(xFillPolyReq));
-    if (things)
-        (*pGC->ops->FillPolygon) (pDraw, pGC, stuff->shape,
-			 stuff->coordMode, things,
-			 (DDXPointPtr) &stuff[1]);
-    return(client->noClientException);
-}
-
-int
-ProcPolyFillRectangle(ClientPtr client)
-{
-    int             things;
-    GC *pGC;
-    DrawablePtr pDraw;
-    REQUEST(xPolyFillRectangleReq);
-
-    REQUEST_AT_LEAST_SIZE(xPolyFillRectangleReq);
-    VALIDATE_DRAWABLE_AND_GC(stuff->drawable, pDraw, DixWriteAccess);
-    things = (client->req_len << 2) - sizeof(xPolyFillRectangleReq);
-    if (things & 4)
-	return(BadLength);
-    things >>= 3;
-
-    if (things)
-        (*pGC->ops->PolyFillRect) (pDraw, pGC, things,
-		      (xRectangle *) &stuff[1]);
-    return (client->noClientException);
-}
-
-int
-ProcPolyFillArc(ClientPtr client)
-{
-    int		narcs;
-    GC *pGC;
-    DrawablePtr pDraw;
-    REQUEST(xPolyFillArcReq);
-
-    REQUEST_AT_LEAST_SIZE(xPolyFillArcReq);
-    VALIDATE_DRAWABLE_AND_GC(stuff->drawable, pDraw, DixWriteAccess);
-    narcs = (client->req_len << 2) - sizeof(xPolyFillArcReq);
-    if (narcs % sizeof(xArc))
-	return(BadLength);
-    narcs /= sizeof(xArc);
-    if (narcs)
-        (*pGC->ops->PolyFillArc) (pDraw, pGC, narcs, (xArc *) &stuff[1]);
-    return (client->noClientException);
-}
-
-#ifdef MATCH_CLIENT_ENDIAN
-
-int
-ServerOrder (void)
-{
-    int	    whichbyte = 1;
-
-    if (*((char *) &whichbyte))
-	return LSBFirst;
-    return MSBFirst;
-}
-
-#define ClientOrder(client) ((client)->swapped ? !ServerOrder() : ServerOrder())
-
-void
-ReformatImage (char *base, int nbytes, int bpp, int order)
-{
-    switch (bpp) {
-    case 1:	/* yuck */
-	if (BITMAP_BIT_ORDER != order)
-	    BitOrderInvert ((unsigned char *) base, nbytes);
-#if IMAGE_BYTE_ORDER != BITMAP_BIT_ORDER && BITMAP_SCANLINE_UNIT != 8
-	ReformatImage (base, nbytes, BITMAP_SCANLINE_UNIT, order);
-#endif
-	break;
-    case 4:
-	break;  /* yuck */
-    case 8:
-	break;
-    case 16:
-	if (IMAGE_BYTE_ORDER != order)
-	    TwoByteSwap ((unsigned char *) base, nbytes);
-	break;
-    case 32:
-	if (IMAGE_BYTE_ORDER != order)
-	    FourByteSwap ((unsigned char *) base, nbytes);
-	break;
-    }
-}
-#else
-#define ReformatImage(b,n,bpp,o)
-#endif
-
-/* 64-bit server notes: the protocol restricts padding of images to
- * 8-, 16-, or 32-bits. We would like to have 64-bits for the server
- * to use internally. Removes need for internal alignment checking.
- * All of the PutImage functions could be changed individually, but
- * as currently written, they call other routines which require things
- * to be 64-bit padded on scanlines, so we changed things here.
- * If an image would be padded differently for 64- versus 32-, then
- * copy each scanline to a 64-bit padded scanline.
- * Also, we need to make sure that the image is aligned on a 64-bit
- * boundary, even if the scanlines are padded to our satisfaction.
- */
-int
-ProcPutImage(ClientPtr client)
-{
-    GC *pGC;
-    DrawablePtr pDraw;
-    long	length; 	/* length of scanline server padded */
-    long 	lengthProto; 	/* length of scanline protocol padded */
-    char	*tmpImage;
-    REQUEST(xPutImageReq);
-
-    REQUEST_AT_LEAST_SIZE(xPutImageReq);
-    VALIDATE_DRAWABLE_AND_GC(stuff->drawable, pDraw, DixWriteAccess);
-    if (stuff->format == XYBitmap)
-    {
-        if ((stuff->depth != 1) ||
-	    (stuff->leftPad >= (unsigned int)screenInfo.bitmapScanlinePad))
-            return BadMatch;
-        length 	    = BitmapBytePad(stuff->width + stuff->leftPad);
-    }
-    else if (stuff->format == XYPixmap)
-    {
-        if ((pDraw->depth != stuff->depth) || 
-	    (stuff->leftPad >= (unsigned int)screenInfo.bitmapScanlinePad))
-            return BadMatch;
-        length      = BitmapBytePad(stuff->width + stuff->leftPad);
-	length      *= stuff->depth;
-    }
-    else if (stuff->format == ZPixmap)
-    {
-        if ((pDraw->depth != stuff->depth) || (stuff->leftPad != 0))
-            return BadMatch;
-        length      = PixmapBytePad(stuff->width, stuff->depth);
-    }
-    else
-    {
-	client->errorValue = stuff->format;
-        return BadValue;
-    }
-
-    tmpImage = (char *)&stuff[1];
-    lengthProto = length;
-	
-    if ((bytes_to_int32(lengthProto * stuff->height) +
-	bytes_to_int32(sizeof(xPutImageReq))) != client->req_len)
-	return BadLength;
-
-    ReformatImage (tmpImage, lengthProto * stuff->height, 
-		   stuff->format == ZPixmap ? BitsPerPixel (stuff->depth) : 1,
-		   ClientOrder(client));
-    
-    (*pGC->ops->PutImage) (pDraw, pGC, stuff->depth, stuff->dstX, stuff->dstY,
-		  stuff->width, stuff->height, 
-		  stuff->leftPad, stuff->format, tmpImage);
-
-     return (client->noClientException);
-}
-
-static int
-DoGetImage(ClientPtr client, int format, Drawable drawable, 
-           int x, int y, int width, int height, 
-           Mask planemask, xGetImageReply **im_return)
-{
-    DrawablePtr		pDraw, pBoundingDraw;
-    int			nlines, linesPerBuf, rc;
-    int			linesDone;
-    /* coordinates relative to the bounding drawable */
-    int			relx, rely;
-    long		widthBytesLine, length;
-    Mask		plane = 0;
-    char		*pBuf;
-    xGetImageReply	xgi;
-    RegionPtr pVisibleRegion = NULL;
-
-    if ((format != XYPixmap) && (format != ZPixmap))
-    {
-	client->errorValue = format;
-        return(BadValue);
-    }
-    rc = dixLookupDrawable(&pDraw, drawable, client, 0, DixReadAccess);
-    if (rc != Success)
-	return rc;
-
-    memset(&xgi, 0, sizeof(xGetImageReply));
-
-    relx = x;
-    rely = y;
-
-    if(pDraw->type == DRAWABLE_WINDOW)
-    {
-	WindowPtr pWin = (WindowPtr)pDraw;
-
-	/* "If the drawable is a window, the window must be viewable ... or a
-	 * BadMatch error results" */
-	if (!pWin->viewable)
-	    return BadMatch;
-
-	relx += pDraw->x;
-	rely += pDraw->y;
-
-	if (pDraw->pScreen->GetWindowPixmap) {
-	    PixmapPtr pPix = (*pDraw->pScreen->GetWindowPixmap) (pWin);
-
-	    pBoundingDraw = &pPix->drawable;
-#ifdef COMPOSITE
-	    relx -= pPix->screen_x;
-	    rely -= pPix->screen_y;
-#endif
-	}
-	else
-	{
-	    pBoundingDraw = (DrawablePtr)WindowTable[pDraw->pScreen->myNum];
-	}
-
-	xgi.visual = wVisual (pWin);
-    }
-    else
-    {
-	pBoundingDraw = pDraw;
-	xgi.visual = None;
-    }
-
-    /* "If the drawable is a pixmap, the given rectangle must be wholly
-     *  contained within the pixmap, or a BadMatch error results.  If the
-     *  drawable is a window [...] it must be the case that if there were no
-     *  inferiors or overlapping windows, the specified rectangle of the window
-     *  would be fully visible on the screen and wholly contained within the
-     *  outside edges of the window, or a BadMatch error results."
-     *
-     * We relax the window case slightly to mean that the rectangle must exist
-     * within the bounds of the window's backing pixmap.  In particular, this
-     * means that a GetImage request may succeed or fail with BadMatch depending
-     * on whether any of its ancestor windows are redirected.  */
-    if(relx < 0 || relx + width > (int)pBoundingDraw->width ||
-       rely < 0 || rely + height > (int)pBoundingDraw->height)
-	return BadMatch;
-
-    xgi.type = X_Reply;
-    xgi.sequenceNumber = client->sequence;
-    xgi.depth = pDraw->depth;
-    if(format == ZPixmap)
-    {
-	widthBytesLine = PixmapBytePad(width, pDraw->depth);
-	length = widthBytesLine * height;
-
-    }
-    else 
-    {
-	widthBytesLine = BitmapBytePad(width);
-	plane = ((Mask)1) << (pDraw->depth - 1);
-	/* only planes asked for */
-	length = widthBytesLine * height *
-		 Ones(planemask & (plane | (plane - 1)));
-
-    }
-
-    xgi.length = length;
-
-    if (im_return) {
-	pBuf = xcalloc(1, sz_xGetImageReply + length);
-	if (!pBuf)
-	    return (BadAlloc);
-	if (widthBytesLine == 0)
-	    linesPerBuf = 0;
-	else
-	    linesPerBuf = height;
-	*im_return = (xGetImageReply *)pBuf;
-	*(xGetImageReply *)pBuf = xgi;
-	pBuf += sz_xGetImageReply;
-    } else {
-	xgi.length = bytes_to_int32(xgi.length);
-	if (widthBytesLine == 0 || height == 0)
-	    linesPerBuf = 0;
-	else if (widthBytesLine >= IMAGE_BUFSIZE)
-	    linesPerBuf = 1;
-	else
-	{
-	    linesPerBuf = IMAGE_BUFSIZE / widthBytesLine;
-	    if (linesPerBuf > height)
-		linesPerBuf = height;
-	}
-	length = linesPerBuf * widthBytesLine;
-	if (linesPerBuf < height)
-	{
-	    /* we have to make sure intermediate buffers don't need padding */
-	    while ((linesPerBuf > 1) &&
-		   (length & ((1L << LOG2_BYTES_PER_SCANLINE_PAD)-1)))
-	    {
-		linesPerBuf--;
-		length -= widthBytesLine;
-	    }
-	    while (length & ((1L << LOG2_BYTES_PER_SCANLINE_PAD)-1))
-	    {
-		linesPerBuf++;
-		length += widthBytesLine;
-	    }
-	}
-	if(!(pBuf = xcalloc(1, length)))
-	    return (BadAlloc);
-	WriteReplyToClient(client, sizeof (xGetImageReply), &xgi);
-    }
-
-    if (pDraw->type == DRAWABLE_WINDOW)
-    {
-	pVisibleRegion = NotClippedByChildren((WindowPtr)pDraw);
-	if (pVisibleRegion)
-	{
-	    REGION_TRANSLATE(pDraw->pScreen, pVisibleRegion,
-			     -pDraw->x, -pDraw->y);
-	}
-    }
-
-    if (linesPerBuf == 0)
-    {
-	/* nothing to do */
-    }
-    else if (format == ZPixmap)
-    {
-        linesDone = 0;
-        while (height - linesDone > 0)
-        {
-	    nlines = min(linesPerBuf, height - linesDone);
-	    (*pDraw->pScreen->GetImage) (pDraw,
-	                                 x,
-				         y + linesDone,
-				         width, 
-				         nlines,
-				         format,
-				         planemask,
-				         (pointer) pBuf);
-	    if (pVisibleRegion)
-		XaceCensorImage(client, pVisibleRegion, widthBytesLine,
-			pDraw, x, y + linesDone, width, 
-			nlines, format, pBuf);
-
-	    /* Note that this is NOT a call to WriteSwappedDataToClient,
-               as we do NOT byte swap */
-	    if (!im_return)
-	    {
-		ReformatImage (pBuf, (int)(nlines * widthBytesLine),
-			       BitsPerPixel (pDraw->depth),
-			       ClientOrder(client));
-
-/* Don't split me, gcc pukes when you do */
-		(void)WriteToClient(client,
-				    (int)(nlines * widthBytesLine),
-				    pBuf);
-	    }
-	    linesDone += nlines;
-        }
-    }
-    else /* XYPixmap */
-    {
-        for (; plane; plane >>= 1)
-	{
-	    if (planemask & plane)
-	    {
-	        linesDone = 0;
-	        while (height - linesDone > 0)
-	        {
-		    nlines = min(linesPerBuf, height - linesDone);
-	            (*pDraw->pScreen->GetImage) (pDraw,
-	                                         x,
-				                 y + linesDone,
-				                 width, 
-				                 nlines,
-				                 format,
-				                 plane,
-				                 (pointer)pBuf);
-		    if (pVisibleRegion)
-			XaceCensorImage(client, pVisibleRegion,
-				widthBytesLine,
-				pDraw, x, y + linesDone, width, 
-				nlines, format, pBuf);
-
-		    /* Note: NOT a call to WriteSwappedDataToClient,
-		       as we do NOT byte swap */
-		    if (im_return) {
-			pBuf += nlines * widthBytesLine;
-		    } else {
-			ReformatImage (pBuf, 
-				       (int)(nlines * widthBytesLine), 
-				       1,
-				       ClientOrder (client));
-
-/* Don't split me, gcc pukes when you do */
-			(void)WriteToClient(client,
-					(int)(nlines * widthBytesLine),
-					pBuf);
-		    }
-		    linesDone += nlines;
-		}
-            }
-	}
-    }
-    if (pVisibleRegion)
-	REGION_DESTROY(pDraw->pScreen, pVisibleRegion);
-    if (!im_return)
-	xfree(pBuf);
-    return (client->noClientException);
-}
-
-int
-ProcGetImage(ClientPtr client)
-{
-    REQUEST(xGetImageReq);
-
-    REQUEST_SIZE_MATCH(xGetImageReq);
-
-    return DoGetImage(client, stuff->format, stuff->drawable,
-		      stuff->x, stuff->y,
-		      (int)stuff->width, (int)stuff->height,
-		      stuff->planeMask, (xGetImageReply **)NULL);
-}
-
-int
-ProcPolyText(ClientPtr client)
-{
-    int	err;
-    REQUEST(xPolyTextReq);
-    DrawablePtr pDraw;
-    GC *pGC;
-
-    REQUEST_AT_LEAST_SIZE(xPolyTextReq);
-    VALIDATE_DRAWABLE_AND_GC(stuff->drawable, pDraw, DixWriteAccess);
-
-    err = PolyText(client,
-		   pDraw,
-		   pGC,
-		   (unsigned char *)&stuff[1],
-		   ((unsigned char *) stuff) + (client->req_len << 2),
-		   stuff->x,
-		   stuff->y,
-		   stuff->reqType,
-		   stuff->drawable);
-
-    if (err == Success)
-    {
-	return(client->noClientException);
-    }
-    else
-	return err;
-}
-
-int
-ProcImageText8(ClientPtr client)
-{
-    int	err;
-    DrawablePtr pDraw;
-    GC *pGC;
-
-    REQUEST(xImageTextReq);
-
-    REQUEST_FIXED_SIZE(xImageTextReq, stuff->nChars);
-    VALIDATE_DRAWABLE_AND_GC(stuff->drawable, pDraw, DixWriteAccess);
-
-    err = ImageText(client,
-		    pDraw,
-		    pGC,
-		    stuff->nChars,
-		    (unsigned char *)&stuff[1],
-		    stuff->x,
-		    stuff->y,
-		    stuff->reqType,
-		    stuff->drawable);
-
-    if (err == Success)
-    {
-	return(client->noClientException);
-    }
-    else
-	return err;
-}
-
-int
-ProcImageText16(ClientPtr client)
-{
-    int	err;
-    DrawablePtr pDraw;
-    GC *pGC;
-
-    REQUEST(xImageTextReq);
-
-    REQUEST_FIXED_SIZE(xImageTextReq, stuff->nChars << 1);
-    VALIDATE_DRAWABLE_AND_GC(stuff->drawable, pDraw, DixWriteAccess);
-
-    err = ImageText(client,
-		    pDraw,
-		    pGC,
-		    stuff->nChars,
-		    (unsigned char *)&stuff[1],
-		    stuff->x,
-		    stuff->y,
-		    stuff->reqType,
-		    stuff->drawable);
-
-    if (err == Success)
-    {
-	return(client->noClientException);
-    }
-    else
-	return err;
-}
-
-
-int
-ProcCreateColormap(ClientPtr client)
-{
-    VisualPtr	pVisual;
-    ColormapPtr	pmap;
-    Colormap	mid;
-    WindowPtr   pWin;
-    ScreenPtr pScreen;
-    REQUEST(xCreateColormapReq);
-    int i, result;
-
-    REQUEST_SIZE_MATCH(xCreateColormapReq);
-
-    if ((stuff->alloc != AllocNone) && (stuff->alloc != AllocAll))
-    {
-	client->errorValue = stuff->alloc;
-        return(BadValue);
-    }
-    mid = stuff->mid;
-    LEGAL_NEW_RESOURCE(mid, client);
-    result = dixLookupWindow(&pWin, stuff->window, client, DixGetAttrAccess);
-    if (result != Success)
-        return result;
-
-    pScreen = pWin->drawable.pScreen;
-    for (i = 0, pVisual = pScreen->visuals;
-	 i < pScreen->numVisuals;
-	 i++, pVisual++)
-    {
-	if (pVisual->vid != stuff->visual)
-	    continue;
-	result =  CreateColormap(mid, pScreen, pVisual, &pmap,
-				 (int)stuff->alloc, client->index);
-	if (client->noClientException != Success)
-	    return(client->noClientException);
-	else
-	    return(result);
-    }
-    client->errorValue = stuff->visual;
-    return(BadMatch);
-}
-
-int
-ProcFreeColormap(ClientPtr client)
-{
-    ColormapPtr pmap;
-    int rc;
-    REQUEST(xResourceReq);
-
-    REQUEST_SIZE_MATCH(xResourceReq);
-    rc = dixLookupResourceByType((pointer *)&pmap, stuff->id, RT_COLORMAP, client,
-			   DixDestroyAccess);
-    if (rc == Success)
-    {
-	/* Freeing a default colormap is a no-op */
-	if (!(pmap->flags & IsDefault))
-	    FreeResource(stuff->id, RT_NONE);
-	return (client->noClientException);
-    }
-    else 
-    {
-	client->errorValue = stuff->id;
-	return (rc == BadValue) ? BadColor : rc;
-    }
-}
-
-
-int
-ProcCopyColormapAndFree(ClientPtr client)
-{
-    Colormap	mid;
-    ColormapPtr	pSrcMap;
-    REQUEST(xCopyColormapAndFreeReq);
-    int rc;
-
-    REQUEST_SIZE_MATCH(xCopyColormapAndFreeReq);
-    mid = stuff->mid;
-    LEGAL_NEW_RESOURCE(mid, client);
-    rc = dixLookupResourceByType((pointer *)&pSrcMap, stuff->srcCmap, RT_COLORMAP,
-			   client, DixReadAccess|DixRemoveAccess);
-    if (rc == Success)
-    {
-	rc = CopyColormapAndFree(mid, pSrcMap, client->index);
-	if (client->noClientException != Success)
-            return(client->noClientException);
-	else
-            return rc;
-    }
-    else
-    {
-	client->errorValue = stuff->srcCmap;
-	return (rc == BadValue) ? BadColor : rc;
-    }
-}
-
-int
-ProcInstallColormap(ClientPtr client)
-{
-    ColormapPtr pcmp;
-    int rc;
-    REQUEST(xResourceReq);
-    REQUEST_SIZE_MATCH(xResourceReq);
-
-    rc = dixLookupResourceByType((pointer *)&pcmp, stuff->id, RT_COLORMAP, client,
-			   DixInstallAccess);
-    if (rc != Success)
-	goto out;
-
-    rc = XaceHook(XACE_SCREEN_ACCESS, client, pcmp->pScreen, DixSetAttrAccess);
-    if (rc != Success)
-	goto out;
-
-    (*(pcmp->pScreen->InstallColormap)) (pcmp);
-
-    rc = client->noClientException;
-out:
-    client->errorValue = stuff->id;
-    return (rc == BadValue) ? BadColor : rc;
-}
-
-int
-ProcUninstallColormap(ClientPtr client)
-{
-    ColormapPtr pcmp;
-    int rc;
-    REQUEST(xResourceReq);
-    REQUEST_SIZE_MATCH(xResourceReq);
-
-    rc = dixLookupResourceByType((pointer *)&pcmp, stuff->id, RT_COLORMAP, client,
-			   DixUninstallAccess);
-    if (rc != Success)
-	goto out;
-
-    rc = XaceHook(XACE_SCREEN_ACCESS, client, pcmp->pScreen, DixSetAttrAccess);
-    if (rc != Success)
-	goto out;
-
-    if(pcmp->mid != pcmp->pScreen->defColormap)
-	(*(pcmp->pScreen->UninstallColormap)) (pcmp);
-
-    rc = client->noClientException;
-out:
-    client->errorValue = stuff->id;
-    return (rc == BadValue) ? BadColor : rc;
-}
-
-int
-ProcListInstalledColormaps(ClientPtr client)
-{
-    xListInstalledColormapsReply *preply; 
-    int nummaps, rc;
-    WindowPtr pWin;
-    REQUEST(xResourceReq);
-    REQUEST_SIZE_MATCH(xResourceReq);
-
-    rc = dixLookupWindow(&pWin, stuff->id, client, DixGetAttrAccess);
-    if (rc != Success)
-	goto out;
-
-    rc = XaceHook(XACE_SCREEN_ACCESS, client, pWin->drawable.pScreen,
-		  DixGetAttrAccess);
-    if (rc != Success)
-	goto out;
-
-    preply = xalloc(sizeof(xListInstalledColormapsReply) +
-		     pWin->drawable.pScreen->maxInstalledCmaps *
-		     sizeof(Colormap));
-    if(!preply)
-        return(BadAlloc);
-
-    preply->type = X_Reply;
-    preply->sequenceNumber = client->sequence;
-    nummaps = (*pWin->drawable.pScreen->ListInstalledColormaps)
-        (pWin->drawable.pScreen, (Colormap *)&preply[1]);
-    preply->nColormaps = nummaps;
-    preply->length = nummaps;
-    WriteReplyToClient(client, sizeof (xListInstalledColormapsReply), preply);
-    client->pSwapReplyFunc = (ReplySwapPtr) Swap32Write;
-    WriteSwappedDataToClient(client, nummaps * sizeof(Colormap), &preply[1]);
-    xfree(preply);
-    rc = client->noClientException;
-out:
-    return rc;
-}
-
-int
-ProcAllocColor (ClientPtr client)
-{
-    ColormapPtr pmap;
-    int rc;
-    xAllocColorReply acr;
-    REQUEST(xAllocColorReq);
-
-    REQUEST_SIZE_MATCH(xAllocColorReq);
-    rc = dixLookupResourceByType((pointer *)&pmap, stuff->cmap, RT_COLORMAP, client,
-			   DixAddAccess);
-    if (rc == Success)
-    {
-	acr.type = X_Reply;
-	acr.length = 0;
-	acr.sequenceNumber = client->sequence;
-	acr.red = stuff->red;
-	acr.green = stuff->green;
-	acr.blue = stuff->blue;
-	acr.pixel = 0;
-	if( (rc = AllocColor(pmap, &acr.red, &acr.green, &acr.blue,
-	                       &acr.pixel, client->index)) )
-	{
-            if (client->noClientException != Success)
-                return(client->noClientException);
-	    else
-	        return rc;
-	}
-#ifdef PANORAMIX
-	if (noPanoramiXExtension || !pmap->pScreen->myNum)
-#endif
-        WriteReplyToClient(client, sizeof(xAllocColorReply), &acr);
-	return (client->noClientException);
-
-    }
-    else
-    {
-        client->errorValue = stuff->cmap;
-        return (rc == BadValue) ? BadColor : rc;
-    }
-}
-
-int
-ProcAllocNamedColor (ClientPtr client)
-{
-    ColormapPtr pcmp;
-    int rc;
-    REQUEST(xAllocNamedColorReq);
-
-    REQUEST_FIXED_SIZE(xAllocNamedColorReq, stuff->nbytes);
-    rc = dixLookupResourceByType((pointer *)&pcmp, stuff->cmap, RT_COLORMAP, client,
-			   DixAddAccess);
-    if (rc == Success)
-    {
-	xAllocNamedColorReply ancr;
-
-	ancr.type = X_Reply;
-	ancr.length = 0;
-	ancr.sequenceNumber = client->sequence;
-
-	if(OsLookupColor(pcmp->pScreen->myNum, (char *)&stuff[1], stuff->nbytes,
-	                 &ancr.exactRed, &ancr.exactGreen, &ancr.exactBlue))
-	{
-	    ancr.screenRed = ancr.exactRed;
-	    ancr.screenGreen = ancr.exactGreen;
-	    ancr.screenBlue = ancr.exactBlue;
-	    ancr.pixel = 0;
-	    if( (rc = AllocColor(pcmp,
-	                 &ancr.screenRed, &ancr.screenGreen, &ancr.screenBlue,
-			 &ancr.pixel, client->index)) )
-	    {
-                if (client->noClientException != Success)
-                    return(client->noClientException);
-                else
-		    return rc;
-	    }
-#ifdef PANORAMIX
-	    if (noPanoramiXExtension || !pcmp->pScreen->myNum)
-#endif
-            WriteReplyToClient(client, sizeof (xAllocNamedColorReply), &ancr);
-	    return (client->noClientException);
-	}
-	else
-	    return(BadName);
-	
-    }
-    else
-    {
-        client->errorValue = stuff->cmap;
-        return (rc == BadValue) ? BadColor : rc;
-    }
-}
-
-int
-ProcAllocColorCells (ClientPtr client)
-{
-    ColormapPtr pcmp;
-    int rc;
-    REQUEST(xAllocColorCellsReq);
-
-    REQUEST_SIZE_MATCH(xAllocColorCellsReq);
-    rc = dixLookupResourceByType((pointer *)&pcmp, stuff->cmap, RT_COLORMAP, client,
-			   DixAddAccess);
-    if (rc == Success)
-    {
-	xAllocColorCellsReply	accr;
-	int			npixels, nmasks;
-	long			length;
-	Pixel			*ppixels, *pmasks;
-
-	npixels = stuff->colors;
-	if (!npixels)
-	{
-	    client->errorValue = npixels;
-	    return (BadValue);
-	}
-	if (stuff->contiguous != xTrue && stuff->contiguous != xFalse)
-	{
-	    client->errorValue = stuff->contiguous;
-	    return (BadValue);
-	}
-	nmasks = stuff->planes;
-	length = ((long)npixels + (long)nmasks) * sizeof(Pixel);
-	ppixels = xalloc(length);
-	if(!ppixels)
-            return(BadAlloc);
-	pmasks = ppixels + npixels;
-
-	if( (rc = AllocColorCells(client->index, pcmp, npixels, nmasks, 
-				    (Bool)stuff->contiguous, ppixels, pmasks)) )
-	{
-	    xfree(ppixels);
-            if (client->noClientException != Success)
-                return(client->noClientException);
-	    else
-	        return rc;
-	}
-#ifdef PANORAMIX
-	if (noPanoramiXExtension || !pcmp->pScreen->myNum)
-#endif
-	{
-	    accr.type = X_Reply;
-	    accr.length = bytes_to_int32(length);
-	    accr.sequenceNumber = client->sequence;
-	    accr.nPixels = npixels;
-	    accr.nMasks = nmasks;
-	    WriteReplyToClient(client, sizeof (xAllocColorCellsReply), &accr);
-	    client->pSwapReplyFunc = (ReplySwapPtr) Swap32Write;
-	    WriteSwappedDataToClient(client, length, ppixels);
-	}
-	xfree(ppixels);
-        return (client->noClientException);        
-    }
-    else
-    {
-        client->errorValue = stuff->cmap;
-        return (rc == BadValue) ? BadColor : rc;
-    }
-}
-
-int
-ProcAllocColorPlanes(ClientPtr client)
-{
-    ColormapPtr pcmp;
-    int rc;
-    REQUEST(xAllocColorPlanesReq);
-
-    REQUEST_SIZE_MATCH(xAllocColorPlanesReq);
-    rc = dixLookupResourceByType((pointer *)&pcmp, stuff->cmap, RT_COLORMAP, client,
-			   DixAddAccess);
-    if (rc == Success)
-    {
-	xAllocColorPlanesReply	acpr;
-	int			npixels;
-	long			length;
-	Pixel			*ppixels;
-
-	npixels = stuff->colors;
-	if (!npixels)
-	{
-	    client->errorValue = npixels;
-	    return (BadValue);
-	}
-	if (stuff->contiguous != xTrue && stuff->contiguous != xFalse)
-	{
-	    client->errorValue = stuff->contiguous;
-	    return (BadValue);
-	}
-	acpr.type = X_Reply;
-	acpr.sequenceNumber = client->sequence;
-	acpr.nPixels = npixels;
-	length = (long)npixels * sizeof(Pixel);
-	ppixels = xalloc(length);
-	if(!ppixels)
-            return(BadAlloc);
-	if( (rc = AllocColorPlanes(client->index, pcmp, npixels,
-	    (int)stuff->red, (int)stuff->green, (int)stuff->blue,
-	    (Bool)stuff->contiguous, ppixels,
-	    &acpr.redMask, &acpr.greenMask, &acpr.blueMask)) )
-	{
-            xfree(ppixels);
-            if (client->noClientException != Success)
-                return(client->noClientException);
-	    else
-	        return rc;
-	}
-	acpr.length = bytes_to_int32(length);
-#ifdef PANORAMIX
-	if (noPanoramiXExtension || !pcmp->pScreen->myNum)
-#endif
-	{
-	    WriteReplyToClient(client, sizeof(xAllocColorPlanesReply), &acpr);
-	    client->pSwapReplyFunc = (ReplySwapPtr) Swap32Write;
-	    WriteSwappedDataToClient(client, length, ppixels);
-	}
-	xfree(ppixels);
-        return (client->noClientException);        
-    }
-    else
-    {
-        client->errorValue = stuff->cmap;
-        return (rc == BadValue) ? BadColor : rc;
-    }
-}
-
-int
-ProcFreeColors(ClientPtr client)
-{
-    ColormapPtr pcmp;
-    int rc;
-    REQUEST(xFreeColorsReq);
-
-    REQUEST_AT_LEAST_SIZE(xFreeColorsReq);
-    rc = dixLookupResourceByType((pointer *)&pcmp, stuff->cmap, RT_COLORMAP, client,
-			   DixRemoveAccess);
-    if (rc == Success)
-    {
-	int	count;
-
-	if(pcmp->flags & AllAllocated)
-	    return(BadAccess);
-	count = bytes_to_int32((client->req_len << 2) - sizeof(xFreeColorsReq));
-	rc = FreeColors(pcmp, client->index, count,
-	    (Pixel *)&stuff[1], (Pixel)stuff->planeMask);
-        if (client->noClientException != Success)
-            return(client->noClientException);
-        else
-	{
-	    client->errorValue = clientErrorValue;
-            return rc;
-	}
-
-    }
-    else
-    {
-        client->errorValue = stuff->cmap;
-        return (rc == BadValue) ? BadColor : rc;
-    }
-}
-
-int
-ProcStoreColors (ClientPtr client)
-{
-    ColormapPtr pcmp;
-    int rc;
-    REQUEST(xStoreColorsReq);
-
-    REQUEST_AT_LEAST_SIZE(xStoreColorsReq);
-    rc = dixLookupResourceByType((pointer *)&pcmp, stuff->cmap, RT_COLORMAP, client,
-			   DixWriteAccess);
-    if (rc == Success)
-    {
-	int	count;
-
-        count = (client->req_len << 2) - sizeof(xStoreColorsReq);
-	if (count % sizeof(xColorItem))
-	    return(BadLength);
-	count /= sizeof(xColorItem);
-	rc = StoreColors(pcmp, count, (xColorItem *)&stuff[1]);
-        if (client->noClientException != Success)
-            return(client->noClientException);
-        else
-	{
-	    client->errorValue = clientErrorValue;
-            return rc;
-	}
-    }
-    else
-    {
-        client->errorValue = stuff->cmap;
-        return (rc == BadValue) ? BadColor : rc;
-    }
-}
-
-int
-ProcStoreNamedColor (ClientPtr client)
-{
-    ColormapPtr pcmp;
-    int rc;
-    REQUEST(xStoreNamedColorReq);
-
-    REQUEST_FIXED_SIZE(xStoreNamedColorReq, stuff->nbytes);
-    rc = dixLookupResourceByType((pointer *)&pcmp, stuff->cmap, RT_COLORMAP, client,
-			   DixWriteAccess);
-    if (rc == Success)
-    {
-	xColorItem	def;
-
-	if(OsLookupColor(pcmp->pScreen->myNum, (char *)&stuff[1],
-	                 stuff->nbytes, &def.red, &def.green, &def.blue))
-	{
-	    def.flags = stuff->flags;
-	    def.pixel = stuff->pixel;
-	    rc = StoreColors(pcmp, 1, &def);
-            if (client->noClientException != Success)
-                return(client->noClientException);
-	    else
-		return rc;
-	}
-        return (BadName);        
-    }
-    else
-    {
-        client->errorValue = stuff->cmap;
-        return (rc == BadValue) ? BadColor : rc;
-    }
-}
-
-int
-ProcQueryColors(ClientPtr client)
-{
-    ColormapPtr pcmp;
-    int rc;
-    REQUEST(xQueryColorsReq);
-
-    REQUEST_AT_LEAST_SIZE(xQueryColorsReq);
-    rc = dixLookupResourceByType((pointer *)&pcmp, stuff->cmap, RT_COLORMAP, client,
-			   DixReadAccess);
-    if (rc == Success)
-    {
-	int			count;
-	xrgb 			*prgbs;
-	xQueryColorsReply	qcr;
-
-	count = bytes_to_int32((client->req_len << 2) - sizeof(xQueryColorsReq));
-	prgbs = xcalloc(1, count * sizeof(xrgb));
-	if(!prgbs && count)
-            return(BadAlloc);
-	if( (rc = QueryColors(pcmp, count, (Pixel *)&stuff[1], prgbs)) )
-	{
-   	    if (prgbs) xfree(prgbs);
-	    if (client->noClientException != Success)
-                return(client->noClientException);
-	    else
-	    {
-		client->errorValue = clientErrorValue;
-	        return rc;
-	    }
-	}
-	memset(&qcr, 0, sizeof(xQueryColorsReply));
-	qcr.type = X_Reply;
-	qcr.length = bytes_to_int32(count * sizeof(xrgb));
-	qcr.sequenceNumber = client->sequence;
-	qcr.nColors = count;
-	WriteReplyToClient(client, sizeof(xQueryColorsReply), &qcr);
-	if (count)
-	{
-	    client->pSwapReplyFunc = (ReplySwapPtr) SQColorsExtend;
-	    WriteSwappedDataToClient(client, count * sizeof(xrgb), prgbs);
-	}
-	if (prgbs) xfree(prgbs);
-	return(client->noClientException);
-	
-    }
-    else
-    {
-        client->errorValue = stuff->cmap;
-        return (rc == BadValue) ? BadColor : rc;
-    }
-} 
-
-int
-ProcLookupColor(ClientPtr client)
-{
-    ColormapPtr pcmp;
-    int rc;
-    REQUEST(xLookupColorReq);
-
-    REQUEST_FIXED_SIZE(xLookupColorReq, stuff->nbytes);
-    rc = dixLookupResourceByType((pointer *)&pcmp, stuff->cmap, RT_COLORMAP, client,
-			   DixReadAccess);
-    if (rc == Success)
-    {
-	xLookupColorReply lcr;
-
-	if(OsLookupColor(pcmp->pScreen->myNum, (char *)&stuff[1], stuff->nbytes,
-	                 &lcr.exactRed, &lcr.exactGreen, &lcr.exactBlue))
-	{
-	    lcr.type = X_Reply;
-	    lcr.length = 0;
-	    lcr.sequenceNumber = client->sequence;
-	    lcr.screenRed = lcr.exactRed;
-	    lcr.screenGreen = lcr.exactGreen;
-	    lcr.screenBlue = lcr.exactBlue;
-	    (*pcmp->pScreen->ResolveColor)(&lcr.screenRed,
-	                                   &lcr.screenGreen,
-					   &lcr.screenBlue,
-					   pcmp->pVisual);
-	    WriteReplyToClient(client, sizeof(xLookupColorReply), &lcr);
-	    return(client->noClientException);
-	}
-        return (BadName);        
-    }
-    else
-    {
-        client->errorValue = stuff->cmap;
-        return (rc == BadValue) ? BadColor : rc;
-    }
-}
-
-int
-ProcCreateCursor (ClientPtr client)
-{
-    CursorPtr		pCursor;
-    PixmapPtr 		src;
-    PixmapPtr 		msk;
-    unsigned char *	srcbits;
-    unsigned char *	mskbits;
-    unsigned short	width, height;
-    long		n;
-    CursorMetricRec 	cm;
-    int rc;
-
-    REQUEST(xCreateCursorReq);
-
-    REQUEST_SIZE_MATCH(xCreateCursorReq);
-    LEGAL_NEW_RESOURCE(stuff->cid, client);
-
-    rc = dixLookupResourceByType((pointer *)&src, stuff->source, RT_PIXMAP, client,
-			   DixReadAccess);
-    if (rc != Success) {
-	client->errorValue = stuff->source;
-	return (rc == BadValue) ? BadPixmap : rc;
-    }
-
-    rc = dixLookupResourceByType((pointer *)&msk, stuff->mask, RT_PIXMAP, client,
-			   DixReadAccess);
-    if (rc != Success)
-    {
-	if (stuff->mask != None)
-	{
-	    client->errorValue = stuff->mask;
-	    return (rc == BadValue) ? BadPixmap : rc;
-	}
-    }
-    else if (  src->drawable.width != msk->drawable.width
-	    || src->drawable.height != msk->drawable.height
-	    || src->drawable.depth != 1
-	    || msk->drawable.depth != 1)
-	return (BadMatch);
-
-    width = src->drawable.width;
-    height = src->drawable.height;
-
-    if ( stuff->x > width 
-      || stuff->y > height )
-	return (BadMatch);
-
-    n = BitmapBytePad(width)*height;
-    srcbits = xcalloc(1, n);
-    if (!srcbits)
-	return (BadAlloc);
-    mskbits = xalloc(n);
-    if (!mskbits)
-    {
-	xfree(srcbits);
-	return (BadAlloc);
-    }
-
-    (* src->drawable.pScreen->GetImage)( (DrawablePtr)src, 0, 0, width, height,
-					 XYPixmap, 1, (pointer)srcbits);
-    if ( msk == (PixmapPtr)NULL)
-    {
-	unsigned char *bits = mskbits;
-	while (--n >= 0)
-	    *bits++ = ~0;
-    }
-    else
-    {
-	/* zeroing the (pad) bits helps some ddx cursor handling */
-	bzero((char *)mskbits, n);
-	(* msk->drawable.pScreen->GetImage)( (DrawablePtr)msk, 0, 0, width,
-					height, XYPixmap, 1, (pointer)mskbits);
-    }
-    cm.width = width;
-    cm.height = height;
-    cm.xhot = stuff->x;
-    cm.yhot = stuff->y;
-    rc = AllocARGBCursor(srcbits, mskbits, NULL, &cm,
-			 stuff->foreRed, stuff->foreGreen, stuff->foreBlue,
-			 stuff->backRed, stuff->backGreen, stuff->backBlue,
-			 &pCursor, client, stuff->cid);
-
-    if (rc != Success)
-	return rc;
-    if (!AddResource(stuff->cid, RT_CURSOR, (pointer)pCursor))
-	return BadAlloc;
-
-    return client->noClientException;
-}
-
-int
-ProcCreateGlyphCursor (ClientPtr client)
-{
-    CursorPtr pCursor;
-    int res;
-
-    REQUEST(xCreateGlyphCursorReq);
-
-    REQUEST_SIZE_MATCH(xCreateGlyphCursorReq);
-    LEGAL_NEW_RESOURCE(stuff->cid, client);
-
-    res = AllocGlyphCursor(stuff->source, stuff->sourceChar,
-			   stuff->mask, stuff->maskChar,
-			   stuff->foreRed, stuff->foreGreen, stuff->foreBlue,
-			   stuff->backRed, stuff->backGreen, stuff->backBlue,
-			   &pCursor, client, stuff->cid);
-    if (res != Success)
-	return res;
-    if (AddResource(stuff->cid, RT_CURSOR, (pointer)pCursor))
-	return client->noClientException;
-    return BadAlloc;
-}
-
-
-int
-ProcFreeCursor (ClientPtr client)
-{
-    CursorPtr pCursor;
-    int rc;
-    REQUEST(xResourceReq);
-
-    REQUEST_SIZE_MATCH(xResourceReq);
-    rc = dixLookupResourceByType((pointer *)&pCursor, stuff->id, RT_CURSOR, client,
-			   DixDestroyAccess);
-    if (rc == Success) 
-    {
-	FreeResource(stuff->id, RT_NONE);
-	return (client->noClientException);
-    }
-    else 
-    {
-	client->errorValue = stuff->id;
-	return (rc == BadValue) ? BadCursor : rc;
-    }
-}
-
-int
-ProcQueryBestSize (ClientPtr client)
-{
-    xQueryBestSizeReply	reply;
-    DrawablePtr pDraw;
-    ScreenPtr pScreen;
-    int rc;
-    REQUEST(xQueryBestSizeReq);
-    REQUEST_SIZE_MATCH(xQueryBestSizeReq);
-
-    if ((stuff->class != CursorShape) && 
-	(stuff->class != TileShape) && 
-	(stuff->class != StippleShape))
-    {
-	client->errorValue = stuff->class;
-        return(BadValue);
-    }
-
-    rc = dixLookupDrawable(&pDraw, stuff->drawable, client, M_ANY,
-			   DixGetAttrAccess);
-    if (rc != Success)
-	return rc;
-    if (stuff->class != CursorShape && pDraw->type == UNDRAWABLE_WINDOW)
-	return (BadMatch);
-    pScreen = pDraw->pScreen;
-    rc = XaceHook(XACE_SCREEN_ACCESS, client, pScreen, DixGetAttrAccess);
-    if (rc != Success)
-	return rc;
-    (* pScreen->QueryBestSize)(stuff->class, &stuff->width,
-			       &stuff->height, pScreen);
-    memset(&reply, 0, sizeof(xQueryBestSizeReply));
-    reply.type = X_Reply;
-    reply.length = 0;
-    reply.sequenceNumber = client->sequence;
-    reply.width = stuff->width;
-    reply.height = stuff->height;
-    WriteReplyToClient(client, sizeof(xQueryBestSizeReply), &reply);
-    return (client->noClientException);
-}
-
-
-int
-ProcSetScreenSaver (ClientPtr client)
-{
-    int rc, i, blankingOption, exposureOption;
-    REQUEST(xSetScreenSaverReq);
-    REQUEST_SIZE_MATCH(xSetScreenSaverReq);
-
-    for (i = 0; i < screenInfo.numScreens; i++) {
-	rc = XaceHook(XACE_SCREENSAVER_ACCESS, client, screenInfo.screens[i],
-		      DixSetAttrAccess);
-	if (rc != Success)
-	    return rc;
-    }
-
-    blankingOption = stuff->preferBlank;
-    if ((blankingOption != DontPreferBlanking) &&
-        (blankingOption != PreferBlanking) &&
-        (blankingOption != DefaultBlanking))
-    {
-	client->errorValue = blankingOption;
-        return BadValue;
-    }
-    exposureOption = stuff->allowExpose;
-    if ((exposureOption != DontAllowExposures) &&
-        (exposureOption != AllowExposures) &&
-        (exposureOption != DefaultExposures))
-    {
-	client->errorValue = exposureOption;
-        return BadValue;
-    }
-    if (stuff->timeout < -1)
-    {
-	client->errorValue = stuff->timeout;
-        return BadValue;
-    }
-    if (stuff->interval < -1)
-    {
-	client->errorValue = stuff->interval;
-        return BadValue;
-    }
-
-    if (blankingOption == DefaultBlanking)
-	ScreenSaverBlanking = defaultScreenSaverBlanking;
-    else
-	ScreenSaverBlanking = blankingOption; 
-    if (exposureOption == DefaultExposures)
-	ScreenSaverAllowExposures = defaultScreenSaverAllowExposures;
-    else
-	ScreenSaverAllowExposures = exposureOption;
-
-    if (stuff->timeout >= 0)
-	ScreenSaverTime = stuff->timeout * MILLI_PER_SECOND;
-    else 
-	ScreenSaverTime = defaultScreenSaverTime;
-    if (stuff->interval >= 0)
-	ScreenSaverInterval = stuff->interval * MILLI_PER_SECOND;
-    else
-	ScreenSaverInterval = defaultScreenSaverInterval;
-
-    SetScreenSaverTimer();
-    return (client->noClientException);
-}
-
-int
-ProcGetScreenSaver(ClientPtr client)
-{
-    xGetScreenSaverReply rep;
-    int rc, i;
-    REQUEST_SIZE_MATCH(xReq);
-
-    for (i = 0; i < screenInfo.numScreens; i++) {
-	rc = XaceHook(XACE_SCREENSAVER_ACCESS, client, screenInfo.screens[i],
-		      DixGetAttrAccess);
-	if (rc != Success)
-	    return rc;
-    }
-
-    rep.type = X_Reply;
-    rep.length = 0;
-    rep.sequenceNumber = client->sequence;
-    rep.timeout = ScreenSaverTime / MILLI_PER_SECOND;
-    rep.interval = ScreenSaverInterval / MILLI_PER_SECOND;
-    rep.preferBlanking = ScreenSaverBlanking;
-    rep.allowExposures = ScreenSaverAllowExposures;
-    WriteReplyToClient(client, sizeof(xGetScreenSaverReply), &rep);
-    return (client->noClientException);
-}
-
-int
-ProcChangeHosts(ClientPtr client)
-{
-    REQUEST(xChangeHostsReq);
-    int result;
-
-    REQUEST_FIXED_SIZE(xChangeHostsReq, stuff->hostLength);
-
-    if(stuff->mode == HostInsert)
-	result = AddHost(client, (int)stuff->hostFamily,
-			 stuff->hostLength, (pointer)&stuff[1]);
-    else if (stuff->mode == HostDelete)
-	result = RemoveHost(client, (int)stuff->hostFamily, 
-			    stuff->hostLength, (pointer)&stuff[1]);  
-    else
-    {
-	client->errorValue = stuff->mode;
-        return BadValue;
-    }
-    if (!result)
-	result = client->noClientException;
-    return (result);
-}
-
-int
-ProcListHosts(ClientPtr client)
-{
-    xListHostsReply reply;
-    int	len, nHosts, result;
-    pointer	pdata;
-    /* REQUEST(xListHostsReq); */
-
-    REQUEST_SIZE_MATCH(xListHostsReq);
-
-    /* untrusted clients can't list hosts */
-    result = XaceHook(XACE_SERVER_ACCESS, client, DixReadAccess);
-    if (result != Success)
-	return result;
-
-    result = GetHosts(&pdata, &nHosts, &len, &reply.enabled);
-    if (result != Success)
-	return(result);
-    reply.type = X_Reply;
-    reply.sequenceNumber = client->sequence;
-    reply.nHosts = nHosts;
-    reply.length = bytes_to_int32(len);
-    WriteReplyToClient(client, sizeof(xListHostsReply), &reply);
-    if (nHosts)
-    {
-	client->pSwapReplyFunc = (ReplySwapPtr) SLHostsExtend;
-	WriteSwappedDataToClient(client, len, pdata);
-    }
-    xfree(pdata);
-    return (client->noClientException);
-}
-
-int
-ProcChangeAccessControl(ClientPtr client)
-{
-    int result;
-    REQUEST(xSetAccessControlReq);
-
-    REQUEST_SIZE_MATCH(xSetAccessControlReq);
-    if ((stuff->mode != EnableAccess) && (stuff->mode != DisableAccess))
-    {
-	client->errorValue = stuff->mode;
-        return BadValue;
-    }
-    result = ChangeAccessControl(client, stuff->mode == EnableAccess);
-    if (!result)
-	result = client->noClientException;
-    return (result);
-}
-
-/*********************
- * CloseDownRetainedResources
- *
- *    Find all clients that are gone and have terminated in RetainTemporary 
- *    and destroy their resources.
- *********************/
-
-static void
-CloseDownRetainedResources(void)
-{
-    int i;
-    ClientPtr client;
-
-    for (i=1; i<currentMaxClients; i++)
-    {
-        client = clients[i];
-        if (client && (client->closeDownMode == RetainTemporary)
-	    && (client->clientGone))
-	    CloseDownClient(client);
-    }
-}
-
-int
-ProcKillClient(ClientPtr client)
-{
-    REQUEST(xResourceReq);
-    ClientPtr killclient;
-    int rc;
-
-    REQUEST_SIZE_MATCH(xResourceReq);
-    if (stuff->id == AllTemporary)
-    {
-	CloseDownRetainedResources();
-        return (client->noClientException);
-    }
-
-    rc = dixLookupClient(&killclient, stuff->id, client, DixDestroyAccess);
-    if (rc == Success) {
-	CloseDownClient(killclient);
-	/* if an LBX proxy gets killed, isItTimeToYield will be set */
-	if (isItTimeToYield || (client == killclient))
-	{
-	    /* force yield and return Success, so that Dispatch()
-	     * doesn't try to touch client
-	     */
-	    isItTimeToYield = TRUE;
-	    return (Success);
-	}
-	return (client->noClientException);
-    }
-    else
-	return rc;
-}
-
-int
-ProcSetFontPath(ClientPtr client)
-{
-    unsigned char *ptr;
-    unsigned long nbytes, total;
-    long nfonts;
-    int n, result;
-    int error;
-    REQUEST(xSetFontPathReq);
-    
-    REQUEST_AT_LEAST_SIZE(xSetFontPathReq);
-    
-    nbytes = (client->req_len << 2) - sizeof(xSetFontPathReq);
-    total = nbytes;
-    ptr = (unsigned char *)&stuff[1];
-    nfonts = stuff->nFonts;
-    while (--nfonts >= 0)
-    {
-	if ((total == 0) || (total < (n = (*ptr + 1))))
-	    return(BadLength);
-	total -= n;
-	ptr += n;
-    }
-    if (total >= 4)
-	return(BadLength);
-    result = SetFontPath(client, stuff->nFonts, (unsigned char *)&stuff[1],
-			 &error);
-    if (!result)
-    {
-	result = client->noClientException;
-	client->errorValue = error;
-    }
-    return (result);
-}
-
-int
-ProcGetFontPath(ClientPtr client)
-{
-    xGetFontPathReply reply;
-    int rc, stringLens, numpaths;
-    unsigned char *bufferStart;
-    /* REQUEST (xReq); */
-
-    REQUEST_SIZE_MATCH(xReq);
-    rc = GetFontPath(client, &numpaths, &stringLens, &bufferStart);
-    if (rc != Success)
-	return rc;
-
-    reply.type = X_Reply;
-    reply.sequenceNumber = client->sequence;
-    reply.length = bytes_to_int32(stringLens + numpaths);
-    reply.nPaths = numpaths;
-
-    WriteReplyToClient(client, sizeof(xGetFontPathReply), &reply);
-    if (stringLens || numpaths)
-	(void)WriteToClient(client, stringLens + numpaths, (char *)bufferStart);
-    return(client->noClientException);
-}
-
-int
-ProcChangeCloseDownMode(ClientPtr client)
-{
-    int rc;
-    REQUEST(xSetCloseDownModeReq);
-    REQUEST_SIZE_MATCH(xSetCloseDownModeReq);
-
-    rc = XaceHook(XACE_CLIENT_ACCESS, client, client, DixManageAccess);
-    if (rc != Success)
-	return rc;
-
-    if ((stuff->mode == AllTemporary) ||
-	(stuff->mode == RetainPermanent) ||
-	(stuff->mode == RetainTemporary))
-    {
-	client->closeDownMode = stuff->mode;
-	return (client->noClientException);
-    }
-    else   
-    {
-	client->errorValue = stuff->mode;
-	return (BadValue);
-    }
-}
-
-int ProcForceScreenSaver(ClientPtr client)
-{    
-    int rc;
-    REQUEST(xForceScreenSaverReq);
-
-    REQUEST_SIZE_MATCH(xForceScreenSaverReq);
-    
-    if ((stuff->mode != ScreenSaverReset) && 
-	(stuff->mode != ScreenSaverActive))
-    {
-	client->errorValue = stuff->mode;
-        return BadValue;
-    }
-    rc = dixSaveScreens(client, SCREEN_SAVER_FORCER, (int)stuff->mode);
-    if (rc != Success)
-	return rc;
-    return client->noClientException;
-}
-
-int ProcNoOperation(ClientPtr client)
-{
-    REQUEST_AT_LEAST_SIZE(xReq);
-    
-    /* noop -- don't do anything */
-    return(client->noClientException);
-}
-
-void
-InitProcVectors(void)
-{
-    int i;
-    for (i = 0; i<256; i++)
-    {
-	if(!ProcVector[i])
-	{
-            ProcVector[i] = SwappedProcVector[i] = ProcBadRequest;
-	    ReplySwapVector[i] = ReplyNotSwappd;
-	}
-    }
-    for(i = LASTEvent; i < 128; i++)
-    {
-	EventSwapVector[i] = NotImplemented;
-    }
-    
-}
-
-/**********************
- * CloseDownClient
- *
- *  Client can either mark his resources destroy or retain.  If retained and
- *  then killed again, the client is really destroyed.
- *********************/
-
-char dispatchExceptionAtReset = DE_RESET;
-
-void
-CloseDownClient(ClientPtr client)
-{
-    Bool really_close_down = client->clientGone ||
-			     client->closeDownMode == DestroyAll;
-
-    if (!client->clientGone)
-    {
-	/* ungrab server if grabbing client dies */
-	if (grabState != GrabNone && grabClient == client)
-	{
-	    UngrabServer(client);
-	}
-	BITCLEAR(grabWaiters, client->index);
-	DeleteClientFromAnySelections(client);
-	ReleaseActiveGrabs(client);
-	DeleteClientFontStuff(client);
-	if (!really_close_down)
-	{
-	    /*  This frees resources that should never be retained
-	     *  no matter what the close down mode is.  Actually we
-	     *  could do this unconditionally, but it's probably
-	     *  better not to traverse all the client's resources
-	     *  twice (once here, once a few lines down in
-	     *  FreeClientResources) in the common case of
-	     *  really_close_down == TRUE.
-	     */
-	    FreeClientNeverRetainResources(client);
-	    client->clientState = ClientStateRetained;
-  	    if (ClientStateCallback)
-            {
-		NewClientInfoRec clientinfo;
-
-		clientinfo.client = client; 
-		clientinfo.prefix = (xConnSetupPrefix *)NULL;  
-		clientinfo.setup = (xConnSetup *) NULL;
-		CallCallbacks((&ClientStateCallback), (pointer)&clientinfo);
-            } 
-	}
-	client->clientGone = TRUE;  /* so events aren't sent to client */
-	if (ClientIsAsleep(client))
-	    ClientSignal (client);
-	ProcessWorkQueueZombies();
-	CloseDownConnection(client);
-
-	/* If the client made it to the Running stage, nClients has
-	 * been incremented on its behalf, so we need to decrement it
-	 * now.  If it hasn't gotten to Running, nClients has *not*
-	 * been incremented, so *don't* decrement it.
-	 */
-	if (client->clientState != ClientStateInitial &&
-	    client->clientState != ClientStateAuthenticating )
-	{
-	    --nClients;
-	}
-    }
-
-    if (really_close_down)
-    {
-	if (client->clientState == ClientStateRunning && nClients == 0)
-	    dispatchException |= dispatchExceptionAtReset;
-
-	client->clientState = ClientStateGone;
-	if (ClientStateCallback)
-	{
-	    NewClientInfoRec clientinfo;
-
-	    clientinfo.client = client; 
-	    clientinfo.prefix = (xConnSetupPrefix *)NULL;  
-	    clientinfo.setup = (xConnSetup *) NULL;
-	    CallCallbacks((&ClientStateCallback), (pointer)&clientinfo);
-	} 	    
-	FreeClientResources(client);
-#ifdef XSERVER_DTRACE
-	XSERVER_CLIENT_DISCONNECT(client->index);
-#endif	
-	if (client->index < nextFreeClientID)
-	    nextFreeClientID = client->index;
-	clients[client->index] = NullClient;
-	SmartLastClient = NullClient;
-	dixFreePrivates(client->devPrivates);
-	xfree(client);
-
-	while (!clients[currentMaxClients-1])
-	    currentMaxClients--;
-    }
-}
-
-static void
-KillAllClients(void)
-{
-    int i;
-    for (i=1; i<currentMaxClients; i++)
-        if (clients[i]) {
-            /* Make sure Retained clients are released. */
-            clients[i]->closeDownMode = DestroyAll;
-            CloseDownClient(clients[i]);     
-        }
-}
-
-void InitClient(ClientPtr client, int i, pointer ospriv)
-{
-    memset(client, 0, sizeof(*client));
-    client->index = i;
-    client->clientAsMask = ((Mask)i) << CLIENTOFFSET;
-    client->closeDownMode = i ? DestroyAll : RetainPermanent;
-    client->requestVector = InitialVector;
-    client->osPrivate = ospriv;
-    QueryMinMaxKeyCodes(&client->minKC,&client->maxKC);
-    client->smart_start_tick = SmartScheduleTime;
-    client->smart_stop_tick = SmartScheduleTime;
-    client->smart_check_tick = SmartScheduleTime;
-}
-
-/************************
- * int NextAvailableClient(ospriv)
- *
- * OS dependent portion can't assign client id's because of CloseDownModes.
- * Returns NULL if there are no free clients.
- *************************/
-
-ClientPtr NextAvailableClient(pointer ospriv)
-{
-    int i;
-    ClientPtr client;
-    xReq data;
-
-    i = nextFreeClientID;
-    if (i == MAXCLIENTS)
-	return (ClientPtr)NULL;
-    clients[i] = client = xalloc(sizeof(ClientRec));
-    if (!client)
-	return (ClientPtr)NULL;
-    InitClient(client, i, ospriv);
-    if (!InitClientResources(client))
-    {
-	xfree(client);
-	return (ClientPtr)NULL;
-    }
-    data.reqType = 1;
-    data.length = bytes_to_int32(sz_xReq + sz_xConnClientPrefix);
-    if (!InsertFakeRequest(client, (char *)&data, sz_xReq))
-    {
-	FreeClientResources(client);
-	xfree(client);
-	return (ClientPtr)NULL;
-    }
-    if (i == currentMaxClients)
-	currentMaxClients++;
-    while ((nextFreeClientID < MAXCLIENTS) && clients[nextFreeClientID])
-	nextFreeClientID++;
-    if (ClientStateCallback)
-    {
-	NewClientInfoRec clientinfo;
-
-        clientinfo.client = client; 
-        clientinfo.prefix = (xConnSetupPrefix *)NULL;  
-        clientinfo.setup = (xConnSetup *) NULL;
-	CallCallbacks((&ClientStateCallback), (pointer)&clientinfo);
-    } 	
-    return(client);
-}
-
-int
-ProcInitialConnection(ClientPtr client)
-{
-    REQUEST(xReq);
-    xConnClientPrefix *prefix;
-    int whichbyte = 1;
-
-    prefix = (xConnClientPrefix *)((char *)stuff + sz_xReq);
-    if ((prefix->byteOrder != 'l') && (prefix->byteOrder != 'B'))
-	return (client->noClientException = -1);
-    if (((*(char *) &whichbyte) && (prefix->byteOrder == 'B')) ||
-	(!(*(char *) &whichbyte) && (prefix->byteOrder == 'l')))
-    {
-	client->swapped = TRUE;
-	SwapConnClientPrefix(prefix);
-    }
-    stuff->reqType = 2;
-    stuff->length += bytes_to_int32(prefix->nbytesAuthProto) +
-		     bytes_to_int32(prefix->nbytesAuthString);
-    if (client->swapped)
-    {
-	swaps(&stuff->length, whichbyte);
-    }
-    ResetCurrentRequest(client);
-    return (client->noClientException);
-}
-
-static int
-SendConnSetup(ClientPtr client, char *reason)
-{
-    xWindowRoot *root;
-    int i;
-    int numScreens;
-    char* lConnectionInfo;
-    xConnSetupPrefix* lconnSetupPrefix;
-
-    if (reason)
-    {
-	xConnSetupPrefix csp;
-
-	csp.success = xFalse;
-	csp.lengthReason = strlen(reason);
-	csp.length = bytes_to_int32(csp.lengthReason);
-	csp.majorVersion = X_PROTOCOL;
-	csp.minorVersion = X_PROTOCOL_REVISION;
-	if (client->swapped)
-	    WriteSConnSetupPrefix(client, &csp);
-	else
-	    (void)WriteToClient(client, sz_xConnSetupPrefix, (char *) &csp);
-        (void)WriteToClient(client, (int)csp.lengthReason, reason);
-	return (client->noClientException = -1);
-    }
-
-    numScreens = screenInfo.numScreens;
-    lConnectionInfo = ConnectionInfo;
-    lconnSetupPrefix = &connSetupPrefix;
-
-    /* We're about to start speaking X protocol back to the client by
-     * sending the connection setup info.  This means the authorization
-     * step is complete, and we can count the client as an
-     * authorized one.
-     */
-    nClients++;
-
-    client->requestVector = client->swapped ? SwappedProcVector : ProcVector;
-    client->sequence = 0;
-    ((xConnSetup *)lConnectionInfo)->ridBase = client->clientAsMask;
-    ((xConnSetup *)lConnectionInfo)->ridMask = RESOURCE_ID_MASK;
-#ifdef MATCH_CLIENT_ENDIAN
-    ((xConnSetup *)lConnectionInfo)->imageByteOrder = ClientOrder (client);
-    ((xConnSetup *)lConnectionInfo)->bitmapBitOrder = ClientOrder (client);
-#endif
-    /* fill in the "currentInputMask" */
-    root = (xWindowRoot *)(lConnectionInfo + connBlockScreenStart);
-#ifdef PANORAMIX
-    if (noPanoramiXExtension)
-	numScreens = screenInfo.numScreens;
-    else 
-        numScreens = ((xConnSetup *)ConnectionInfo)->numRoots;
-#endif
-
-    for (i=0; i<numScreens; i++) 
-    {
-	unsigned int j;
-	xDepth *pDepth;
-
-        root->currentInputMask = WindowTable[i]->eventMask |
-			         wOtherEventMasks (WindowTable[i]);
-	pDepth = (xDepth *)(root + 1);
-	for (j = 0; j < root->nDepths; j++)
-	{
-	    pDepth = (xDepth *)(((char *)(pDepth + 1)) +
-				pDepth->nVisuals * sizeof(xVisualType));
-	}
-	root = (xWindowRoot *)pDepth;
-    }
-
-    if (client->swapped)
-    {
-	WriteSConnSetupPrefix(client, lconnSetupPrefix);
-	WriteSConnectionInfo(client,
-			     (unsigned long)(lconnSetupPrefix->length << 2),
-			     lConnectionInfo);
-    }
-    else
-    {
-	(void)WriteToClient(client, sizeof(xConnSetupPrefix),
-			    (char *) lconnSetupPrefix);
-	(void)WriteToClient(client, (int)(lconnSetupPrefix->length << 2),
-			    lConnectionInfo);
-    }
-    client->clientState = ClientStateRunning;
-    if (ClientStateCallback)
-    {
-	NewClientInfoRec clientinfo;
-
-        clientinfo.client = client; 
-        clientinfo.prefix = lconnSetupPrefix;  
-        clientinfo.setup = (xConnSetup *)lConnectionInfo;
-	CallCallbacks((&ClientStateCallback), (pointer)&clientinfo);
-    } 	
-    return (client->noClientException);
-}
-
-int
-ProcEstablishConnection(ClientPtr client)
-{
-    char *reason, *auth_proto, *auth_string;
-    xConnClientPrefix *prefix;
-    REQUEST(xReq);
-
-    prefix = (xConnClientPrefix *)((char *)stuff + sz_xReq);
-    auth_proto = (char *)prefix + sz_xConnClientPrefix;
-    auth_string = auth_proto + pad_to_int32(prefix->nbytesAuthProto);
-    if ((prefix->majorVersion != X_PROTOCOL) ||
-	(prefix->minorVersion != X_PROTOCOL_REVISION))
-	reason = "Protocol version mismatch";
-    else
-	reason = ClientAuthorized(client,
-				  (unsigned short)prefix->nbytesAuthProto,
-				  auth_proto,
-				  (unsigned short)prefix->nbytesAuthString,
-				  auth_string);
-    /*
-     * If Kerberos is being used for this client, the clientState
-     * will be set to ClientStateAuthenticating at this point.
-     * More messages need to be exchanged among the X server, Kerberos
-     * server, and client to figure out if everyone is authorized.
-     * So we don't want to send the connection setup info yet, since
-     * the auth step isn't really done.
-     */
-    if (client->clientState == ClientStateCheckingSecurity)
-	client->clientState = ClientStateCheckedSecurity;
-    else if (client->clientState != ClientStateAuthenticating)
-	return(SendConnSetup(client, reason));
-    return(client->noClientException);
-}
-
-void
-SendErrorToClient(ClientPtr client, unsigned majorCode, unsigned minorCode, 
-                  XID resId, int errorCode)
-{
-    xError rep;
-
-    memset(&rep, 0, sizeof(xError));
-    rep.type = X_Error;
-    rep.sequenceNumber = client->sequence;
-    rep.errorCode = errorCode;
-    rep.majorCode = majorCode;
-    rep.minorCode = minorCode;
-    rep.resourceID = resId;
-
-    WriteEventsToClient (client, 1, (xEvent *)&rep);
-}
-
-void
-MarkClientException(ClientPtr client)
-{
-    client->noClientException = -1;
-}
-
-/*
- * This array encodes the answer to the question "what is the log base 2
- * of the number of pixels that fit in a scanline pad unit?"
- * Note that ~0 is an invalid entry (mostly for the benefit of the reader).
- */
-static int answer[6][4] = {
-	/* pad   pad   pad     pad*/
-	/*  8     16    32    64 */
-
-	{   3,     4,    5 ,   6 },	/* 1 bit per pixel */
-	{   1,     2,    3 ,   4 },	/* 4 bits per pixel */
-	{   0,     1,    2 ,   3 },	/* 8 bits per pixel */
-	{   ~0,    0,    1 ,   2 },	/* 16 bits per pixel */
-	{   ~0,    ~0,   0 ,   1 },	/* 24 bits per pixel */
-	{   ~0,    ~0,   0 ,   1 }	/* 32 bits per pixel */
-};
-
-/*
- * This array gives the answer to the question "what is the first index for
- * the answer array above given the number of bits per pixel?"
- * Note that ~0 is an invalid entry (mostly for the benefit of the reader).
- */
-static int indexForBitsPerPixel[ 33 ] = {
-	~0, 0, ~0, ~0,	/* 1 bit per pixel */
-	1, ~0, ~0, ~0,	/* 4 bits per pixel */
-	2, ~0, ~0, ~0,	/* 8 bits per pixel */
-	~0,~0, ~0, ~0,
-	3, ~0, ~0, ~0,	/* 16 bits per pixel */
-	~0,~0, ~0, ~0,
-	4, ~0, ~0, ~0,	/* 24 bits per pixel */
-	~0,~0, ~0, ~0,
-	5		/* 32 bits per pixel */
-};
-
-/*
- * This array gives the bytesperPixel value for cases where the number
- * of bits per pixel is a multiple of 8 but not a power of 2.
- */
-static int answerBytesPerPixel[ 33 ] = {
-	~0, 0, ~0, ~0,	/* 1 bit per pixel */
-	0, ~0, ~0, ~0,	/* 4 bits per pixel */
-	0, ~0, ~0, ~0,	/* 8 bits per pixel */
-	~0,~0, ~0, ~0,
-	0, ~0, ~0, ~0,	/* 16 bits per pixel */
-	~0,~0, ~0, ~0,
-	3, ~0, ~0, ~0,	/* 24 bits per pixel */
-	~0,~0, ~0, ~0,
-	0		/* 32 bits per pixel */
-};
-
-/*
- * This array gives the answer to the question "what is the second index for
- * the answer array above given the number of bits per scanline pad unit?"
- * Note that ~0 is an invalid entry (mostly for the benefit of the reader).
- */
-static int indexForScanlinePad[ 65 ] = {
-	~0, ~0, ~0, ~0,
-	~0, ~0, ~0, ~0,
-	 0, ~0, ~0, ~0,	/* 8 bits per scanline pad unit */
-	~0, ~0, ~0, ~0,
-	 1, ~0, ~0, ~0,	/* 16 bits per scanline pad unit */
-	~0, ~0, ~0, ~0,
-	~0, ~0, ~0, ~0,
-	~0, ~0, ~0, ~0,
-	 2, ~0, ~0, ~0,	/* 32 bits per scanline pad unit */
-	~0, ~0, ~0, ~0,
-	~0, ~0, ~0, ~0,
-	~0, ~0, ~0, ~0,
-	~0, ~0, ~0, ~0,
-	~0, ~0, ~0, ~0,
-	~0, ~0, ~0, ~0,
-	~0, ~0, ~0, ~0,
-	 3		/* 64 bits per scanline pad unit */
-};
-
-/*
-	grow the array of screenRecs if necessary.
-	call the device-supplied initialization procedure
-with its screen number, a pointer to its ScreenRec, argc, and argv.
-	return the number of successfully installed screens.
-
-*/
-
-int
-AddScreen(
-    Bool	(* pfnInit)(
-	int /*index*/,
-	ScreenPtr /*pScreen*/,
-	int /*argc*/,
-	char ** /*argv*/
-		),
-    int argc,
-    char **argv)
-{
-
-    int i;
-    int scanlinepad, format, depth, bitsPerPixel, j, k;
-    ScreenPtr pScreen;
-
-    i = screenInfo.numScreens;
-    if (i == MAXSCREENS)
-	return -1;
-
-    pScreen = (ScreenPtr) xcalloc(1, sizeof(ScreenRec));
-    if (!pScreen)
-	return -1;
-
-    pScreen->devPrivates = NULL;
-    pScreen->myNum = i;
-    pScreen->totalPixmapSize = BitmapBytePad(sizeof(PixmapRec)*8);
-    pScreen->ClipNotify = 0;	/* for R4 ddx compatibility */
-    pScreen->CreateScreenResources = 0;
-
-    /*
-     * This loop gets run once for every Screen that gets added,
-     * but thats ok.  If the ddx layer initializes the formats
-     * one at a time calling AddScreen() after each, then each
-     * iteration will make it a little more accurate.  Worst case
-     * we do this loop N * numPixmapFormats where N is # of screens.
-     * Anyway, this must be called after InitOutput and before the
-     * screen init routine is called.
-     */
-    for (format=0; format<screenInfo.numPixmapFormats; format++)
-    {
-	depth = screenInfo.formats[format].depth;
-	bitsPerPixel = screenInfo.formats[format].bitsPerPixel;
-	scanlinepad = screenInfo.formats[format].scanlinePad;
-	j = indexForBitsPerPixel[ bitsPerPixel ];
-	k = indexForScanlinePad[ scanlinepad ];
-	PixmapWidthPaddingInfo[ depth ].padPixelsLog2 = answer[j][k];
-	PixmapWidthPaddingInfo[ depth ].padRoundUp =
-	    (scanlinepad/bitsPerPixel) - 1;
-	j = indexForBitsPerPixel[ 8 ]; /* bits per byte */
-	PixmapWidthPaddingInfo[ depth ].padBytesLog2 = answer[j][k];
-	PixmapWidthPaddingInfo[ depth ].bitsPerPixel = bitsPerPixel;
-	if (answerBytesPerPixel[bitsPerPixel])
-	{
-	    PixmapWidthPaddingInfo[ depth ].notPower2 = 1;
-	    PixmapWidthPaddingInfo[ depth ].bytesPerPixel =
-		answerBytesPerPixel[bitsPerPixel];
-	}
-	else
-	{
-	    PixmapWidthPaddingInfo[ depth ].notPower2 = 0;
-	}
-    }
-
-    /* This is where screen specific stuff gets initialized.  Load the
-       screen structure, call the hardware, whatever.
-       This is also where the default colormap should be allocated and
-       also pixel values for blackPixel, whitePixel, and the cursor
-       Note that InitScreen is NOT allowed to modify argc, argv, or
-       any of the strings pointed to by argv.  They may be passed to
-       multiple screens.
-    */
-    pScreen->rgf = ~0L;  /* there are no scratch GCs yet*/
-    WindowTable[i] = NullWindow;
-    screenInfo.screens[i] = pScreen;
-    screenInfo.numScreens++;
-    if (!(*pfnInit)(i, pScreen, argc, argv))
-    {
-	dixFreePrivates(pScreen->devPrivates);
-	xfree(pScreen);
-	screenInfo.numScreens--;
-	return -1;
-    }
-    return i;
-}
+/************************************************************

+

+Copyright 1987, 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.

+

+

+Copyright 1987, 1989 by Digital Equipment Corporation, Maynard, Massachusetts.

+

+                        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 name of Digital not be

+used in advertising or publicity pertaining to distribution of the

+software without specific, written prior permission.  

+

+DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING

+ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL

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

+

+********************************************************/

+

+/* The panoramix components contained the following notice */

+/*****************************************************************

+

+Copyright (c) 1991, 1997 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.

+

+******************************************************************/

+

+/* XSERVER_DTRACE additions:

+ * Copyright 2005-2006 Sun Microsystems, Inc.  All rights reserved.

+ *

+ * 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 (including the next

+ * paragraph) 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 AUTHORS OR COPYRIGHT HOLDERS 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.

+ */

+

+

+

+#ifdef HAVE_DIX_CONFIG_H

+#include <dix-config.h>

+#include <version-config.h>

+#endif

+

+#ifdef CreateWindow

+#undef CreateWindow

+#endif

+

+#ifdef PANORAMIX_DEBUG

+#include <stdio.h>

+int ProcInitialConnection();

+#endif

+

+#include "windowstr.h"

+#include <X11/fonts/fontstruct.h>

+#include "dixfontstr.h"

+#include "gcstruct.h"

+#include "selection.h"

+#include "colormapst.h"

+#include "cursorstr.h"

+#include "scrnintstr.h"

+#include "opaque.h"

+#include "input.h"

+#include "servermd.h"

+#include "extnsionst.h"

+#include "dixfont.h"

+#include "dispatch.h"

+#include "swaprep.h"

+#include "swapreq.h"

+#include "privates.h"

+#include "xace.h"

+#include "inputstr.h"

+#include "xkbsrv.h"

+#include "site.h"

+

+#ifdef XSERVER_DTRACE

+#include "registry.h"

+#include <sys/types.h>

+typedef const char *string;

+#include "Xserver-dtrace.h"

+#endif

+

+#define mskcnt ((MAXCLIENTS + 31) / 32)

+#define BITMASK(i) (1U << ((i) & 31))

+#define MASKIDX(i) ((i) >> 5)

+#define MASKWORD(buf, i) buf[MASKIDX(i)]

+#define BITSET(buf, i) MASKWORD(buf, i) |= BITMASK(i)

+#define BITCLEAR(buf, i) MASKWORD(buf, i) &= ~BITMASK(i)

+#define GETBIT(buf, i) (MASKWORD(buf, i) & BITMASK(i))

+

+xConnSetupPrefix connSetupPrefix;

+

+PaddingInfo PixmapWidthPaddingInfo[33];

+

+static ClientPtr grabClient;

+#define GrabNone 0

+#define GrabActive 1

+#define GrabKickout 2

+static int grabState = GrabNone;

+static long grabWaiters[mskcnt];

+CallbackListPtr ServerGrabCallback = NULL;

+HWEventQueuePtr checkForInput[2];

+int connBlockScreenStart;

+

+static void KillAllClients(void);

+

+static int nextFreeClientID; /* always MIN free client ID */

+

+static int	nClients;	/* number of authorized clients */

+

+CallbackListPtr ClientStateCallback;

+

+/* dispatchException & isItTimeToYield must be declared volatile since they

+ * are modified by signal handlers - otherwise optimizer may assume it doesn't

+ * need to actually check value in memory when used and may miss changes from

+ * signal handlers.

+ */

+volatile char dispatchException = 0;

+volatile char isItTimeToYield;

+

+/* Various of the DIX function interfaces were not designed to allow

+ * the client->errorValue to be set on BadValue and other errors.

+ * Rather than changing interfaces and breaking untold code we introduce

+ * a new global that dispatch can use.

+ */

+XID clientErrorValue;   /* XXX this is a kludge */

+

+#define SAME_SCREENS(a, b) (\

+    (a.pScreen == b.pScreen))

+

+void

+SetInputCheck(HWEventQueuePtr c0, HWEventQueuePtr c1)

+{

+    checkForInput[0] = c0;

+    checkForInput[1] = c1;

+}

+

+void

+UpdateCurrentTime(void)

+{

+    TimeStamp systime;

+

+    /* To avoid time running backwards, we must call GetTimeInMillis before

+     * calling ProcessInputEvents.

+     */

+    systime.months = currentTime.months;

+    systime.milliseconds = GetTimeInMillis();

+    if (systime.milliseconds < currentTime.milliseconds)

+	systime.months++;

+    if (*checkForInput[0] != *checkForInput[1])

+	ProcessInputEvents();

+    if (CompareTimeStamps(systime, currentTime) == LATER)

+	currentTime = systime;

+}

+

+/* Like UpdateCurrentTime, but can't call ProcessInputEvents */

+void

+UpdateCurrentTimeIf(void)

+{

+    TimeStamp systime;

+

+    systime.months = currentTime.months;

+    systime.milliseconds = GetTimeInMillis();

+    if (systime.milliseconds < currentTime.milliseconds)

+	systime.months++;

+    if (*checkForInput[0] == *checkForInput[1])

+	currentTime = systime;

+}

+

+

+#undef SMART_DEBUG

+

+#define SMART_SCHEDULE_DEFAULT_INTERVAL	20	    /* ms */

+#define SMART_SCHEDULE_MAX_SLICE	200	    /* ms */

+

+Bool SmartScheduleDisable = FALSE;

+long SmartScheduleSlice = SMART_SCHEDULE_DEFAULT_INTERVAL;

+long SmartScheduleInterval = SMART_SCHEDULE_DEFAULT_INTERVAL;

+long SmartScheduleMaxSlice = SMART_SCHEDULE_MAX_SLICE;

+long SmartScheduleTime;

+int SmartScheduleLatencyLimited = 0;

+static ClientPtr   SmartLastClient;

+static int	   SmartLastIndex[SMART_MAX_PRIORITY-SMART_MIN_PRIORITY+1];

+

+#ifdef SMART_DEBUG

+long	    SmartLastPrint;

+#endif

+

+void        Dispatch(void);

+void        InitProcVectors(void);

+

+static int

+SmartScheduleClient (int *clientReady, int nready)

+{

+    ClientPtr	pClient;

+    int		i;

+    int		client;

+    int		bestPrio, best = 0;

+    int		bestRobin, robin;

+    long	now = SmartScheduleTime;

+    long	idle;

+

+    bestPrio = -0x7fffffff;

+    bestRobin = 0;

+    idle = 2 * SmartScheduleSlice;

+    for (i = 0; i < nready; i++)

+    {

+	client = clientReady[i];

+	pClient = clients[client];

+	/* Praise clients which are idle */

+	if ((now - pClient->smart_check_tick) >= idle)

+	{

+	    if (pClient->smart_priority < 0)

+		pClient->smart_priority++;

+	}

+	pClient->smart_check_tick = now;

+	

+	/* check priority to select best client */

+	robin = (pClient->index - SmartLastIndex[pClient->smart_priority-SMART_MIN_PRIORITY]) & 0xff;

+	if (pClient->smart_priority > bestPrio ||

+	    (pClient->smart_priority == bestPrio && robin > bestRobin))

+	{

+	    bestPrio = pClient->smart_priority;

+	    bestRobin = robin;

+	    best = client;

+	}

+#ifdef SMART_DEBUG

+	if ((now - SmartLastPrint) >= 5000)

+	    fprintf (stderr, " %2d: %3d", client, pClient->smart_priority);

+#endif

+    }

+#ifdef SMART_DEBUG

+    if ((now - SmartLastPrint) >= 5000)

+    {

+	fprintf (stderr, " use %2d\n", best);

+	SmartLastPrint = now;

+    }

+#endif

+    pClient = clients[best];

+    SmartLastIndex[bestPrio-SMART_MIN_PRIORITY] = pClient->index;

+    /*

+     * Set current client pointer

+     */

+    if (SmartLastClient != pClient)

+    {

+	pClient->smart_start_tick = now;

+	SmartLastClient = pClient;

+    }

+    /*

+     * Adjust slice

+     */

+    if (nready == 1 && SmartScheduleLatencyLimited == 0)

+    {

+	/*

+	 * If it's been a long time since another client

+	 * has run, bump the slice up to get maximal

+	 * performance from a single client

+	 */

+	if ((now - pClient->smart_start_tick) > 1000 &&

+	    SmartScheduleSlice < SmartScheduleMaxSlice)

+	{

+	    SmartScheduleSlice += SmartScheduleInterval;

+	}

+    }

+    else

+    {

+	SmartScheduleSlice = SmartScheduleInterval;

+    }

+    return best;

+}

+

+void

+EnableLimitedSchedulingLatency(void)

+{

+    ++SmartScheduleLatencyLimited;

+    SmartScheduleSlice = SmartScheduleInterval;

+}

+

+void

+DisableLimitedSchedulingLatency(void)

+{

+    --SmartScheduleLatencyLimited;

+

+    /* protect against bugs */

+    if (SmartScheduleLatencyLimited < 0)

+	SmartScheduleLatencyLimited = 0;

+}

+

+#define MAJOROP ((xReq *)client->requestBuffer)->reqType

+

+void

+Dispatch(void)

+{

+    int        *clientReady;     /* array of request ready clients */

+    int	result;

+    ClientPtr	client;

+    int	nready;

+    HWEventQueuePtr* icheck = checkForInput;

+    long			start_tick;

+

+    nextFreeClientID = 1;

+    nClients = 0;

+

+    clientReady = xalloc(sizeof(int) * MaxClients);

+    if (!clientReady)

+	return;

+

+    SmartScheduleSlice = SmartScheduleInterval;

+    while (!dispatchException)

+    {

+        if (*icheck[0] != *icheck[1])

+	{

+	    ProcessInputEvents();

+	    FlushIfCriticalOutputPending();

+	}

+

+	nready = WaitForSomething(clientReady);

+

+	if (nready && !SmartScheduleDisable)

+	{

+	    clientReady[0] = SmartScheduleClient (clientReady, nready);

+	    nready = 1;

+	}

+       /***************** 

+	*  Handle events in round robin fashion, doing input between 

+	*  each round 

+	*****************/

+

+	while (!dispatchException && (--nready >= 0))

+	{

+	    client = clients[clientReady[nready]];

+	    if (! client)

+	    {

+		/* KillClient can cause this to happen */

+		continue;

+	    }

+	    /* GrabServer activation can cause this to be true */

+	    if (grabState == GrabKickout)

+	    {

+		grabState = GrabActive;

+		break;

+	    }

+	    isItTimeToYield = FALSE;

+ 

+	    start_tick = SmartScheduleTime;

+	    while (!isItTimeToYield)

+	    {

+#ifdef XSERVER_DTRACE

+	      CARD8 StartMajorOp;

+#endif

+	        if (*icheck[0] != *icheck[1])

+		    ProcessInputEvents();

+		

+		FlushIfCriticalOutputPending();

+		if (!SmartScheduleDisable && 

+		    (SmartScheduleTime - start_tick) >= SmartScheduleSlice)

+		{

+		    /* Penalize clients which consume ticks */

+		    if (client->smart_priority > SMART_MIN_PRIORITY)

+			client->smart_priority--;

+		    break;

+		}

+		/* now, finally, deal with client requests */

+

+	        result = ReadRequestFromClient(client);

+	        if (result <= 0) 

+	        {

+		    if (result < 0)

+			CloseDownClient(client);

+		    break;

+	        }

+

+		client->sequence++;

+#ifdef XSERVER_DTRACE

+		StartMajorOp=MAJOROP;

+		XSERVER_REQUEST_START(LookupMajorName(StartMajorOp), StartMajorOp,

+			      ((xReq *)client->requestBuffer)->length,

+			      client->index, client->requestBuffer);

+#endif

+		if (result > (maxBigRequestSize << 2))

+		    result = BadLength;

+		else {

+		    result = XaceHookDispatch(client, MAJOROP);

+		    if (result == Success)

+			result = (* client->requestVector[MAJOROP])(client);

+		    XaceHookAuditEnd(client, result);

+		}

+#ifdef XSERVER_DTRACE

+		if (result!=Success)

+		{

+		  char Message[255];

+		  sprintf(Message,"ERROR: %s (0x%x)",LookupMajorName(StartMajorOp),client->errorValue);

+		  XSERVER_REQUEST_DONE(Message, MAJOROP,

+		                       client->sequence, client->index, result);

+		}

+		else

+		{

+		  if (StartMajorOp!=MAJOROP)

+		  {

+		    char Message[255];

+		    sprintf(Message,"Changed request: %s -> %s",LookupMajorName(StartMajorOp),LookupMajorName(MAJOROP));

+		    XSERVER_REQUEST_DONE(Message, MAJOROP,

+		                         client->sequence, client->index, result);

+		  }

+		  else

+		  {

+		    XSERVER_REQUEST_DONE(LookupMajorName(MAJOROP), MAJOROP,

+		                         client->sequence, client->index, result);

+		  }

+		}

+#endif

+

+		if (result != Success) 

+		{

+		    if (client->noClientException != Success)

+                        CloseDownClient(client);

+                    else

+		        SendErrorToClient(client, MAJOROP,

+					  MinorOpcodeOfRequest(client),

+					  client->errorValue, result);

+		    break;

+	        }

+	    }

+	    FlushAllOutput();

+	    client = clients[clientReady[nready]];

+	    if (client)

+		client->smart_stop_tick = SmartScheduleTime;

+	}

+	dispatchException &= ~DE_PRIORITYCHANGE;

+    }

+#if defined(DDXBEFORERESET)

+    ddxBeforeReset ();

+#endif

+    KillAllClients();

+    xfree(clientReady);

+    dispatchException &= ~DE_RESET;

+    SmartScheduleLatencyLimited = 0;

+}

+

+#undef MAJOROP

+

+static int  VendorRelease = VENDOR_RELEASE;

+static char *VendorString = VENDOR_NAME;

+

+static const int padlength[4] = {0, 3, 2, 1};

+

+void

+SetVendorRelease(int release)

+{

+    VendorRelease = release;

+}

+

+void

+SetVendorString(char *string)

+{

+    VendorString = string;

+}

+

+Bool

+CreateConnectionBlock(void)

+{

+    xConnSetup setup;

+    xWindowRoot root;

+    xDepth	depth;

+    xVisualType visual;

+    xPixmapFormat format;

+    unsigned long vid;

+    int i, j, k,

+        lenofblock,

+        sizesofar = 0;

+    char *pBuf;

+

+

+    memset(&setup, 0, sizeof(xConnSetup));

+    /* Leave off the ridBase and ridMask, these must be sent with

+       connection */

+

+    setup.release = VendorRelease;

+    /*

+     * per-server image and bitmap parameters are defined in Xmd.h

+     */

+    setup.imageByteOrder = screenInfo.imageByteOrder;

+

+    setup.bitmapScanlineUnit = screenInfo.bitmapScanlineUnit;

+    setup.bitmapScanlinePad = screenInfo.bitmapScanlinePad;

+

+    setup.bitmapBitOrder = screenInfo.bitmapBitOrder;

+    setup.motionBufferSize = NumMotionEvents();

+    setup.numRoots = screenInfo.numScreens;

+    setup.nbytesVendor = strlen(VendorString);

+    setup.numFormats = screenInfo.numPixmapFormats;

+    setup.maxRequestSize = MAX_REQUEST_SIZE;

+    QueryMinMaxKeyCodes(&setup.minKeyCode, &setup.maxKeyCode);

+

+    lenofblock = sizeof(xConnSetup) +

+            pad_to_int32(setup.nbytesVendor) +

+	    (setup.numFormats * sizeof(xPixmapFormat)) +

+            (setup.numRoots * sizeof(xWindowRoot));

+    ConnectionInfo = xalloc(lenofblock);

+    if (!ConnectionInfo)

+	return FALSE;

+

+    memmove(ConnectionInfo, (char *)&setup, sizeof(xConnSetup));

+    sizesofar = sizeof(xConnSetup);

+    pBuf = ConnectionInfo + sizeof(xConnSetup);

+

+    memmove(pBuf, VendorString, (int)setup.nbytesVendor);

+    sizesofar += setup.nbytesVendor;

+    pBuf += setup.nbytesVendor;

+    i = padlength[setup.nbytesVendor & 3];

+    sizesofar += i;

+    while (--i >= 0)

+	*pBuf++ = 0;

+

+    memset(&format, 0, sizeof(xPixmapFormat));

+    for (i=0; i<screenInfo.numPixmapFormats; i++)

+    {

+	format.depth = screenInfo.formats[i].depth;

+	format.bitsPerPixel = screenInfo.formats[i].bitsPerPixel;

+	format.scanLinePad = screenInfo.formats[i].scanlinePad;

+	memmove(pBuf, (char *)&format, sizeof(xPixmapFormat));

+	pBuf += sizeof(xPixmapFormat);

+	sizesofar += sizeof(xPixmapFormat);

+    }

+

+    connBlockScreenStart = sizesofar;

+    memset(&depth, 0, sizeof(xDepth));

+    memset(&visual, 0, sizeof(xVisualType));

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

+    {

+	ScreenPtr	pScreen;

+	DepthPtr	pDepth;

+	VisualPtr	pVisual;

+

+	pScreen = screenInfo.screens[i];

+	root.windowId = WindowTable[i]->drawable.id;

+	root.defaultColormap = pScreen->defColormap;

+	root.whitePixel = pScreen->whitePixel;

+	root.blackPixel = pScreen->blackPixel;

+	root.currentInputMask = 0;    /* filled in when sent */

+	root.pixWidth = pScreen->width;

+	root.pixHeight = pScreen->height;

+	root.mmWidth = pScreen->mmWidth;

+	root.mmHeight = pScreen->mmHeight;

+	root.minInstalledMaps = pScreen->minInstalledCmaps;

+	root.maxInstalledMaps = pScreen->maxInstalledCmaps;

+	root.rootVisualID = pScreen->rootVisual;

+	root.backingStore = pScreen->backingStoreSupport;

+	root.saveUnders = FALSE;

+	root.rootDepth = pScreen->rootDepth;

+	root.nDepths = pScreen->numDepths;

+	memmove(pBuf, (char *)&root, sizeof(xWindowRoot));

+	sizesofar += sizeof(xWindowRoot);

+	pBuf += sizeof(xWindowRoot);

+

+	pDepth = pScreen->allowedDepths;

+	for(j = 0; j < pScreen->numDepths; j++, pDepth++)

+	{

+	    lenofblock += sizeof(xDepth) +

+		    (pDepth->numVids * sizeof(xVisualType));

+	    pBuf = (char *)xrealloc(ConnectionInfo, lenofblock);

+	    if (!pBuf)

+	    {

+		xfree(ConnectionInfo);

+		return FALSE;

+	    }

+	    ConnectionInfo = pBuf;

+	    pBuf += sizesofar;

+	    depth.depth = pDepth->depth;

+	    depth.nVisuals = pDepth->numVids;

+	    memmove(pBuf, (char *)&depth, sizeof(xDepth));

+	    pBuf += sizeof(xDepth);

+	    sizesofar += sizeof(xDepth);

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

+	    {

+		vid = pDepth->vids[k];

+		for (pVisual = pScreen->visuals;

+		     pVisual->vid != vid;

+		     pVisual++)

+		    ;

+		visual.visualID = vid;

+		visual.class = pVisual->class;

+		visual.bitsPerRGB = pVisual->bitsPerRGBValue;

+		visual.colormapEntries = pVisual->ColormapEntries;

+		visual.redMask = pVisual->redMask;

+		visual.greenMask = pVisual->greenMask;

+		visual.blueMask = pVisual->blueMask;

+		memmove(pBuf, (char *)&visual, sizeof(xVisualType));

+		pBuf += sizeof(xVisualType);

+		sizesofar += sizeof(xVisualType);

+	    }

+	}

+    }

+    connSetupPrefix.success = xTrue;

+    connSetupPrefix.length = lenofblock/4;

+    connSetupPrefix.majorVersion = X_PROTOCOL;

+    connSetupPrefix.minorVersion = X_PROTOCOL_REVISION;

+    return TRUE;

+}

+

+

+int

+ProcBadRequest(ClientPtr client)

+{

+    return (BadRequest);

+}

+

+int

+ProcCreateWindow(ClientPtr client)

+{

+    WindowPtr pParent, pWin;

+    REQUEST(xCreateWindowReq);

+    int len, rc;

+

+    REQUEST_AT_LEAST_SIZE(xCreateWindowReq);

+    

+    LEGAL_NEW_RESOURCE(stuff->wid, client);

+    rc = dixLookupWindow(&pParent, stuff->parent, client, DixAddAccess);

+    if (rc != Success)

+        return rc;

+    len = client->req_len - bytes_to_int32(sizeof(xCreateWindowReq));

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

+        return BadLength;

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

+    {

+	client->errorValue = 0;

+        return BadValue;

+    }

+    pWin = CreateWindow(stuff->wid, pParent, stuff->x,

+			      stuff->y, stuff->width, stuff->height, 

+			      stuff->borderWidth, stuff->class,

+			      stuff->mask, (XID *) &stuff[1], 

+			      (int)stuff->depth, 

+			      client, stuff->visual, &rc);

+    if (pWin)

+    {

+	Mask mask = pWin->eventMask;

+

+	pWin->eventMask = 0; /* subterfuge in case AddResource fails */

+	if (!AddResource(stuff->wid, RT_WINDOW, (pointer)pWin))

+	    return BadAlloc;

+	pWin->eventMask = mask;

+    }

+    if (client->noClientException != Success)

+        return(client->noClientException);

+    else

+        return rc;

+}

+

+int

+ProcChangeWindowAttributes(ClientPtr client)

+{

+    WindowPtr pWin;

+    REQUEST(xChangeWindowAttributesReq);

+    int result, len, rc;

+    Mask access_mode = 0;

+

+    REQUEST_AT_LEAST_SIZE(xChangeWindowAttributesReq);

+    access_mode |= (stuff->valueMask & CWEventMask) ? DixReceiveAccess : 0;

+    access_mode |= (stuff->valueMask & ~CWEventMask) ? DixSetAttrAccess : 0;

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

+    if (rc != Success)

+        return rc;

+    len = client->req_len - bytes_to_int32(sizeof(xChangeWindowAttributesReq));

+    if (len != Ones(stuff->valueMask))

+        return BadLength;

+    result =  ChangeWindowAttributes(pWin, 

+				  stuff->valueMask, 

+				  (XID *) &stuff[1], 

+				  client);

+    if (client->noClientException != Success)

+        return(client->noClientException);

+    else

+        return(result);

+}

+

+int

+ProcGetWindowAttributes(ClientPtr client)

+{

+    WindowPtr pWin;

+    REQUEST(xResourceReq);

+    xGetWindowAttributesReply wa;

+    int rc;

+

+    REQUEST_SIZE_MATCH(xResourceReq);

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

+    if (rc != Success)

+	return rc;

+    memset(&wa, 0, sizeof(xGetWindowAttributesReply));

+    GetWindowAttributes(pWin, client, &wa);

+    WriteReplyToClient(client, sizeof(xGetWindowAttributesReply), &wa);

+    return(client->noClientException);

+}

+

+int

+ProcDestroyWindow(ClientPtr client)

+{

+    WindowPtr pWin;

+    REQUEST(xResourceReq);

+    int rc;

+

+    REQUEST_SIZE_MATCH(xResourceReq);

+    rc = dixLookupWindow(&pWin, stuff->id, client, DixDestroyAccess);

+    if (rc != Success)

+	return rc;

+    if (pWin->parent) {

+	rc = dixLookupWindow(&pWin, pWin->parent->drawable.id, client,

+			     DixRemoveAccess);

+	if (rc != Success)

+	    return rc;

+	FreeResource(stuff->id, RT_NONE);

+    }

+    return(client->noClientException);

+}

+

+int

+ProcDestroySubwindows(ClientPtr client)

+{

+    WindowPtr pWin;

+    REQUEST(xResourceReq);

+    int rc;

+

+    REQUEST_SIZE_MATCH(xResourceReq);

+    rc = dixLookupWindow(&pWin, stuff->id, client, DixRemoveAccess);

+    if (rc != Success)

+	return rc;

+    DestroySubwindows(pWin, client);

+    return(client->noClientException);

+}

+

+int

+ProcChangeSaveSet(ClientPtr client)

+{

+    WindowPtr pWin;

+    REQUEST(xChangeSaveSetReq);

+    int result, rc;

+		  

+    REQUEST_SIZE_MATCH(xChangeSaveSetReq);

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

+    if (rc != Success)

+        return rc;

+    if (client->clientAsMask == (CLIENT_BITS(pWin->drawable.id)))

+        return BadMatch;

+    if ((stuff->mode == SetModeInsert) || (stuff->mode == SetModeDelete))

+    {

+        result = AlterSaveSetForClient(client, pWin, stuff->mode, FALSE, TRUE);

+	if (client->noClientException != Success)

+	    return(client->noClientException);

+	else

+            return(result);

+    }

+    else

+    {

+	client->errorValue = stuff->mode;

+	return( BadValue );

+    }

+}

+

+int

+ProcReparentWindow(ClientPtr client)

+{

+    WindowPtr pWin, pParent;

+    REQUEST(xReparentWindowReq);

+    int result, rc;

+

+    REQUEST_SIZE_MATCH(xReparentWindowReq);

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

+    if (rc != Success)

+        return rc;

+    rc = dixLookupWindow(&pParent, stuff->parent, client, DixAddAccess);

+    if (rc != Success)

+        return rc;

+    if (SAME_SCREENS(pWin->drawable, pParent->drawable))

+    {

+        if ((pWin->backgroundState == ParentRelative) &&

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

+            return BadMatch;

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

+	    (pParent->drawable.class == InputOnly))

+	    return BadMatch;

+        result =  ReparentWindow(pWin, pParent, 

+			 (short)stuff->x, (short)stuff->y, client);

+	if (client->noClientException != Success)

+            return(client->noClientException);

+	else

+            return(result);

+    }

+    else 

+        return (BadMatch);

+}

+

+int

+ProcMapWindow(ClientPtr client)

+{

+    WindowPtr pWin;

+    REQUEST(xResourceReq);

+    int rc;

+

+    REQUEST_SIZE_MATCH(xResourceReq);

+    rc = dixLookupWindow(&pWin, stuff->id, client, DixShowAccess);

+    if (rc != Success)

+        return rc;

+    MapWindow(pWin, client);

+           /* update cache to say it is mapped */

+    return(client->noClientException);

+}

+

+int

+ProcMapSubwindows(ClientPtr client)

+{

+    WindowPtr pWin;

+    REQUEST(xResourceReq);

+    int rc;

+

+    REQUEST_SIZE_MATCH(xResourceReq);

+    rc = dixLookupWindow(&pWin, stuff->id, client, DixListAccess);

+    if (rc != Success)

+        return rc;

+    MapSubwindows(pWin, client);

+           /* update cache to say it is mapped */

+    return(client->noClientException);

+}

+

+int

+ProcUnmapWindow(ClientPtr client)

+{

+    WindowPtr pWin;

+    REQUEST(xResourceReq);

+    int rc;

+

+    REQUEST_SIZE_MATCH(xResourceReq);

+    rc = dixLookupWindow(&pWin, stuff->id, client, DixHideAccess);

+    if (rc != Success)

+        return rc;

+    UnmapWindow(pWin, FALSE);

+           /* update cache to say it is mapped */

+    return(client->noClientException);

+}

+

+int

+ProcUnmapSubwindows(ClientPtr client)

+{

+    WindowPtr pWin;

+    REQUEST(xResourceReq);

+    int rc;

+

+    REQUEST_SIZE_MATCH(xResourceReq);

+    rc = dixLookupWindow(&pWin, stuff->id, client, DixListAccess);

+    if (rc != Success)

+        return rc;

+    UnmapSubwindows(pWin);

+    return(client->noClientException);

+}

+

+int

+ProcConfigureWindow(ClientPtr client)

+{

+    WindowPtr pWin;

+    REQUEST(xConfigureWindowReq);

+    int result;

+    int len, rc;

+

+    REQUEST_AT_LEAST_SIZE(xConfigureWindowReq);

+    rc = dixLookupWindow(&pWin, stuff->window, client,

+			 DixManageAccess|DixSetAttrAccess);

+    if (rc != Success)

+        return rc;

+    len = client->req_len - bytes_to_int32(sizeof(xConfigureWindowReq));

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

+        return BadLength;

+    result =  ConfigureWindow(pWin, (Mask)stuff->mask, (XID *) &stuff[1], 

+			      client);

+    if (client->noClientException != Success)

+        return(client->noClientException);

+    else

+        return(result);

+}

+

+int

+ProcCirculateWindow(ClientPtr client)

+{

+    WindowPtr pWin;

+    REQUEST(xCirculateWindowReq);

+    int rc;

+

+    REQUEST_SIZE_MATCH(xCirculateWindowReq);

+    if ((stuff->direction != RaiseLowest) &&

+	(stuff->direction != LowerHighest))

+    {

+	client->errorValue = stuff->direction;

+        return BadValue;

+    }

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

+    if (rc != Success)

+        return rc;

+    CirculateWindow(pWin, (int)stuff->direction, client);

+    return(client->noClientException);

+}

+

+static int

+GetGeometry(ClientPtr client, xGetGeometryReply *rep)

+{

+    DrawablePtr pDraw;

+    int rc;

+    REQUEST(xResourceReq);

+    REQUEST_SIZE_MATCH(xResourceReq);

+

+    rc = dixLookupDrawable(&pDraw, stuff->id, client, M_ANY, DixGetAttrAccess);

+    if (rc != Success)

+	return rc;

+

+    rep->type = X_Reply;

+    rep->length = 0;

+    rep->sequenceNumber = client->sequence;

+    rep->root = WindowTable[pDraw->pScreen->myNum]->drawable.id;

+    rep->depth = pDraw->depth;

+    rep->width = pDraw->width;

+    rep->height = pDraw->height;

+

+    /* XXX - Because the pixmap-implementation of the multibuffer extension 

+     *       may have the buffer-id's drawable resource value be a pointer

+     *       to the buffer's window instead of the buffer itself

+     *       (this happens if the buffer is the displayed buffer),

+     *       we also have to check that the id matches before we can

+     *       truly say that it is a DRAWABLE_WINDOW.

+     */

+

+    if ((pDraw->type == UNDRAWABLE_WINDOW) ||

+        ((pDraw->type == DRAWABLE_WINDOW) && (stuff->id == pDraw->id)))

+    {

+        WindowPtr pWin = (WindowPtr)pDraw;

+	rep->x = pWin->origin.x - wBorderWidth (pWin);

+	rep->y = pWin->origin.y - wBorderWidth (pWin);

+	rep->borderWidth = pWin->borderWidth;

+    }

+    else /* DRAWABLE_PIXMAP or DRAWABLE_BUFFER */

+    {

+	rep->x = rep->y = rep->borderWidth = 0;

+    }

+

+    return Success;

+}

+

+

+int

+ProcGetGeometry(ClientPtr client)

+{

+    xGetGeometryReply rep;

+    int status;

+

+    memset(&rep, 0, sizeof(xGetGeometryReply));

+    if ((status = GetGeometry(client, &rep)) != Success)

+	return status;

+

+    WriteReplyToClient(client, sizeof(xGetGeometryReply), &rep);

+    return(client->noClientException);

+}

+

+

+int

+ProcQueryTree(ClientPtr client)

+{

+    xQueryTreeReply reply;

+    int rc, numChildren = 0;

+    WindowPtr pChild, pWin, pHead;

+    Window  *childIDs = (Window *)NULL;

+    REQUEST(xResourceReq);

+

+    REQUEST_SIZE_MATCH(xResourceReq);

+    rc = dixLookupWindow(&pWin, stuff->id, client, DixListAccess);

+    if (rc != Success)

+        return rc;

+    memset(&reply, 0, sizeof(xQueryTreeReply));

+    reply.type = X_Reply;

+    reply.root = WindowTable[pWin->drawable.pScreen->myNum]->drawable.id;

+    reply.sequenceNumber = client->sequence;

+    if (pWin->parent)

+	reply.parent = pWin->parent->drawable.id;

+    else

+        reply.parent = (Window)None;

+    pHead = RealChildHead(pWin);

+    for (pChild = pWin->lastChild; pChild != pHead; pChild = pChild->prevSib)

+	numChildren++;

+    if (numChildren)

+    {

+	int curChild = 0;

+

+	childIDs = xalloc(numChildren * sizeof(Window));

+	if (!childIDs)

+	    return BadAlloc;

+	for (pChild = pWin->lastChild; pChild != pHead; pChild = pChild->prevSib)

+	    childIDs[curChild++] = pChild->drawable.id;

+    }

+    

+    reply.nChildren = numChildren;

+    reply.length = bytes_to_int32(numChildren * sizeof(Window));

+    

+    WriteReplyToClient(client, sizeof(xQueryTreeReply), &reply);

+    if (numChildren)

+    {

+    	client->pSwapReplyFunc = (ReplySwapPtr) Swap32Write;

+	WriteSwappedDataToClient(client, numChildren * sizeof(Window), childIDs);

+	xfree(childIDs);

+    }

+

+    return(client->noClientException);

+}

+

+int

+ProcInternAtom(ClientPtr client)

+{

+    Atom atom;

+    char *tchar;

+    REQUEST(xInternAtomReq);

+

+    REQUEST_FIXED_SIZE(xInternAtomReq, stuff->nbytes);

+    if ((stuff->onlyIfExists != xTrue) && (stuff->onlyIfExists != xFalse))

+    {

+	client->errorValue = stuff->onlyIfExists;

+        return(BadValue);

+    }

+    tchar = (char *) &stuff[1];

+    atom = MakeAtom(tchar, stuff->nbytes, !stuff->onlyIfExists);

+    if (atom != BAD_RESOURCE)

+    {

+	xInternAtomReply reply;

+	memset(&reply, 0, sizeof(xInternAtomReply));

+	reply.type = X_Reply;

+	reply.length = 0;

+	reply.sequenceNumber = client->sequence;

+	reply.atom = atom;

+	WriteReplyToClient(client, sizeof(xInternAtomReply), &reply);

+	return(client->noClientException);

+    }

+    else

+	return (BadAlloc);

+}

+

+int

+ProcGetAtomName(ClientPtr client)

+{

+    const char *str;

+    xGetAtomNameReply reply;

+    int len;

+    REQUEST(xResourceReq);

+

+    REQUEST_SIZE_MATCH(xResourceReq);

+    if ( (str = NameForAtom(stuff->id)) )

+    {

+	len = strlen(str);

+	memset(&reply, 0, sizeof(xGetAtomNameReply));

+	reply.type = X_Reply;

+	reply.length = bytes_to_int32(len);

+	reply.sequenceNumber = client->sequence;

+	reply.nameLength = len;

+	WriteReplyToClient(client, sizeof(xGetAtomNameReply), &reply);

+	(void)WriteToClient(client, len, str);

+	return(client->noClientException);

+    }

+    else 

+    { 

+	client->errorValue = stuff->id;

+	return (BadAtom);

+    }

+}

+

+int

+ProcGrabServer(ClientPtr client)

+{

+    int rc;

+    REQUEST_SIZE_MATCH(xReq);

+    if (grabState != GrabNone && client != grabClient)

+    {

+	ResetCurrentRequest(client);

+	client->sequence--;

+	BITSET(grabWaiters, client->index);

+	IgnoreClient(client);

+	return(client->noClientException);

+    }

+    rc = OnlyListenToOneClient(client);

+    if (rc != Success)

+	return rc;

+    grabState = GrabKickout;

+    grabClient = client;

+

+    if (ServerGrabCallback)

+    {

+	ServerGrabInfoRec grabinfo;

+	grabinfo.client = client;

+	grabinfo.grabstate  = SERVER_GRABBED;

+	CallCallbacks(&ServerGrabCallback, (pointer)&grabinfo);

+    }

+

+    return(client->noClientException);

+}

+

+static void

+UngrabServer(ClientPtr client)

+{

+    int i;

+

+    grabState = GrabNone;

+    ListenToAllClients();

+    for (i = mskcnt; --i >= 0 && !grabWaiters[i]; )

+	;

+    if (i >= 0)

+    {

+	i <<= 5;

+	while (!GETBIT(grabWaiters, i))

+	    i++;

+	BITCLEAR(grabWaiters, i);

+	AttendClient(clients[i]);

+    }

+

+    if (ServerGrabCallback)

+    {

+	ServerGrabInfoRec grabinfo;

+	grabinfo.client = client;

+	grabinfo.grabstate  = SERVER_UNGRABBED;

+	CallCallbacks(&ServerGrabCallback, (pointer)&grabinfo);

+    }

+}

+

+int

+ProcUngrabServer(ClientPtr client)

+{

+    REQUEST_SIZE_MATCH(xReq);

+    UngrabServer(client);

+    return(client->noClientException);

+}

+

+int

+ProcTranslateCoords(ClientPtr client)

+{

+    REQUEST(xTranslateCoordsReq);

+

+    WindowPtr pWin, pDst;

+    xTranslateCoordsReply rep;

+    int rc;

+

+    REQUEST_SIZE_MATCH(xTranslateCoordsReq);

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

+    if (rc != Success)

+        return rc;

+    rc = dixLookupWindow(&pDst, stuff->dstWid, client, DixGetAttrAccess);

+    if (rc != Success)

+        return rc;

+    memset(&rep, 0, sizeof(xTranslateCoordsReply));

+    rep.type = X_Reply;

+    rep.length = 0;

+    rep.sequenceNumber = client->sequence;

+    if (!SAME_SCREENS(pWin->drawable, pDst->drawable))

+    {

+	rep.sameScreen = xFalse;

+        rep.child = None;

+	rep.dstX = rep.dstY = 0;

+    }

+    else

+    {

+	INT16 x, y;

+	rep.sameScreen = xTrue;

+	rep.child = None;

+	/* computing absolute coordinates -- adjust to destination later */

+	x = pWin->drawable.x + stuff->srcX;

+	y = pWin->drawable.y + stuff->srcY;

+	pWin = pDst->firstChild;

+	while (pWin)

+	{

+	    BoxRec  box;

+	    if ((pWin->mapped) &&

+		(x >= pWin->drawable.x - wBorderWidth (pWin)) &&

+		(x < pWin->drawable.x + (int)pWin->drawable.width +

+		 wBorderWidth (pWin)) &&

+		(y >= pWin->drawable.y - wBorderWidth (pWin)) &&

+		(y < pWin->drawable.y + (int)pWin->drawable.height +

+		 wBorderWidth (pWin))

+		/* When a window is shaped, a further check

+		 * is made to see if the point is inside

+		 * borderSize

+		 */

+		&& (!wBoundingShape(pWin) ||

+		    POINT_IN_REGION(pWin->drawable.pScreen, 

+					&pWin->borderSize, x, y, &box))

+		

+		&& (!wInputShape(pWin) ||

+		    POINT_IN_REGION(pWin->drawable.pScreen,

+				    wInputShape(pWin),

+				    x - pWin->drawable.x,

+				    y - pWin->drawable.y, &box))

+		)

+            {

+		rep.child = pWin->drawable.id;

+		pWin = (WindowPtr) NULL;

+	    }

+	    else

+		pWin = pWin->nextSib;

+	}

+	/* adjust to destination coordinates */

+	rep.dstX = x - pDst->drawable.x;

+	rep.dstY = y - pDst->drawable.y;

+    }

+    WriteReplyToClient(client, sizeof(xTranslateCoordsReply), &rep);

+    return(client->noClientException);

+}

+

+int

+ProcOpenFont(ClientPtr client)

+{

+    int	err;

+    REQUEST(xOpenFontReq);

+

+    REQUEST_FIXED_SIZE(xOpenFontReq, stuff->nbytes);

+    client->errorValue = stuff->fid;

+    LEGAL_NEW_RESOURCE(stuff->fid, client);

+    err = OpenFont(client, stuff->fid, (Mask) 0,

+		stuff->nbytes, (char *)&stuff[1]);

+    if (err == Success)

+    {

+	return(client->noClientException);

+    }

+    else

+	return err;

+}

+

+int

+ProcCloseFont(ClientPtr client)

+{

+    FontPtr pFont;

+    int rc;

+    REQUEST(xResourceReq);

+

+    REQUEST_SIZE_MATCH(xResourceReq);

+    rc = dixLookupResourceByType((pointer *)&pFont, stuff->id, RT_FONT,

+				 client, DixDestroyAccess);

+    if (rc == Success)

+    {

+        FreeResource(stuff->id, RT_NONE);

+	return(client->noClientException);

+    }

+    else

+    {

+	client->errorValue = stuff->id;

+        return (rc == BadValue) ? BadFont : rc;

+    }

+}

+

+int

+ProcQueryFont(ClientPtr client)

+{

+    xQueryFontReply	*reply;

+    FontPtr pFont;

+    GC *pGC;

+    int rc;

+    REQUEST(xResourceReq);

+    REQUEST_SIZE_MATCH(xResourceReq);

+

+    client->errorValue = stuff->id;		/* EITHER font or gc */

+    rc = dixLookupResourceByType((pointer *)&pFont, stuff->id, RT_FONT, client,

+				 DixGetAttrAccess);

+    if (rc == BadValue) {

+	rc = dixLookupResourceByType((pointer *)&pGC, stuff->id, RT_GC, client,

+				     DixGetAttrAccess);

+	if (rc == Success)

+	    pFont = pGC->font;

+    }

+    if (rc != Success)

+	return (rc == BadValue) ? BadFont: rc;

+

+    {

+	xCharInfo	*pmax = FONTINKMAX(pFont);

+	xCharInfo	*pmin = FONTINKMIN(pFont);

+	int		nprotoxcistructs;

+	int		rlength;

+

+	nprotoxcistructs = (

+	   pmax->rightSideBearing == pmin->rightSideBearing &&

+	   pmax->leftSideBearing == pmin->leftSideBearing &&

+	   pmax->descent == pmin->descent &&

+	   pmax->ascent == pmin->ascent &&

+	   pmax->characterWidth == pmin->characterWidth) ?

+		0 : N2dChars(pFont);

+

+	rlength = sizeof(xQueryFontReply) +

+	             FONTINFONPROPS(FONTCHARSET(pFont)) * sizeof(xFontProp)  +

+		     nprotoxcistructs * sizeof(xCharInfo);

+	reply = xcalloc(1, rlength);

+	if(!reply)

+	{

+	    return(BadAlloc);

+	}

+

+	reply->type = X_Reply;

+	reply->length = bytes_to_int32(rlength - sizeof(xGenericReply));

+	reply->sequenceNumber = client->sequence;

+	QueryFont( pFont, reply, nprotoxcistructs);

+

+        WriteReplyToClient(client, rlength, reply);

+	xfree(reply);

+	return(client->noClientException);

+    }

+}

+

+int

+ProcQueryTextExtents(ClientPtr client)

+{

+    xQueryTextExtentsReply reply;

+    FontPtr pFont;

+    GC *pGC;

+    ExtentInfoRec info;

+    unsigned long length;

+    int rc;

+    REQUEST(xQueryTextExtentsReq);

+    REQUEST_AT_LEAST_SIZE(xQueryTextExtentsReq);

+        

+    client->errorValue = stuff->fid;		/* EITHER font or gc */

+    rc = dixLookupResourceByType((pointer *)&pFont, stuff->fid, RT_FONT, client,

+				 DixGetAttrAccess);

+    if (rc == BadValue) {

+	rc = dixLookupResourceByType((pointer *)&pGC, stuff->fid, RT_GC, client,

+			       DixGetAttrAccess);

+	if (rc == Success)

+	    pFont = pGC->font;

+    }

+    if (rc != Success)

+	return (rc == BadValue) ? BadFont: rc;

+

+    length = client->req_len - bytes_to_int32(sizeof(xQueryTextExtentsReq));

+    length = length << 1;

+    if (stuff->oddLength)

+    {

+	if (length == 0)

+	    return(BadLength);

+        length--;

+    }

+    if (!QueryTextExtents(pFont, length, (unsigned char *)&stuff[1], &info))

+	return(BadAlloc);

+    reply.type = X_Reply;

+    reply.length = 0;

+    reply.sequenceNumber = client->sequence;

+    reply.drawDirection = info.drawDirection;

+    reply.fontAscent = info.fontAscent;

+    reply.fontDescent = info.fontDescent;

+    reply.overallAscent = info.overallAscent;

+    reply.overallDescent = info.overallDescent;

+    reply.overallWidth = info.overallWidth;

+    reply.overallLeft = info.overallLeft;

+    reply.overallRight = info.overallRight;

+    WriteReplyToClient(client, sizeof(xQueryTextExtentsReply), &reply);

+    return(client->noClientException);

+}

+

+int

+ProcListFonts(ClientPtr client)

+{

+    REQUEST(xListFontsReq);

+

+    REQUEST_FIXED_SIZE(xListFontsReq, stuff->nbytes);

+

+    return ListFonts(client, (unsigned char *) &stuff[1], stuff->nbytes, 

+	stuff->maxNames);

+}

+

+int

+ProcListFontsWithInfo(ClientPtr client)

+{

+    REQUEST(xListFontsWithInfoReq);

+

+    REQUEST_FIXED_SIZE(xListFontsWithInfoReq, stuff->nbytes);

+

+    return StartListFontsWithInfo(client, stuff->nbytes,

+				  (unsigned char *) &stuff[1], stuff->maxNames);

+}

+

+/**

+ *

+ *  \param value must conform to DeleteType

+ */

+int

+dixDestroyPixmap(pointer value, XID pid)

+{

+    PixmapPtr pPixmap = (PixmapPtr)value;

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

+}

+

+int

+ProcCreatePixmap(ClientPtr client)

+{

+    PixmapPtr pMap;

+    DrawablePtr pDraw;

+    REQUEST(xCreatePixmapReq);

+    DepthPtr pDepth;

+    int i, rc;

+

+    REQUEST_SIZE_MATCH(xCreatePixmapReq);

+    client->errorValue = stuff->pid;

+    LEGAL_NEW_RESOURCE(stuff->pid, client);

+    

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

+			   DixGetAttrAccess);

+    if (rc != Success)

+	return rc;

+

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

+    {

+	client->errorValue = 0;

+        return BadValue;

+    }

+    if (stuff->width > 32767 || stuff->height > 32767)

+    {

+	/* It is allowed to try and allocate a pixmap which is larger than

+	 * 32767 in either dimension. However, all of the framebuffer code

+	 * is buggy and does not reliably draw to such big pixmaps, basically

+	 * because the Region data structure operates with signed shorts

+	 * for the rectangles in it.

+	 *

+	 * Furthermore, several places in the X server computes the

+	 * size in bytes of the pixmap and tries to store it in an

+	 * integer. This integer can overflow and cause the allocated size

+	 * to be much smaller.

+	 *

+	 * So, such big pixmaps are rejected here with a BadAlloc

+	 */

+	return BadAlloc;

+    }

+    if (stuff->depth != 1)

+    {

+        pDepth = pDraw->pScreen->allowedDepths;

+        for (i=0; i<pDraw->pScreen->numDepths; i++, pDepth++)

+	   if (pDepth->depth == stuff->depth)

+               goto CreatePmap;

+	client->errorValue = stuff->depth;

+        return BadValue;

+    }

+CreatePmap:

+    pMap = (PixmapPtr)(*pDraw->pScreen->CreatePixmap)

+		(pDraw->pScreen, stuff->width,

+		 stuff->height, stuff->depth, 0);

+    if (pMap)

+    {

+	pMap->drawable.serialNumber = NEXT_SERIAL_NUMBER;

+	pMap->drawable.id = stuff->pid;

+	/* security creation/labeling check */

+	rc = XaceHook(XACE_RESOURCE_ACCESS, client, stuff->pid, RT_PIXMAP,

+		      pMap, RT_NONE, NULL, DixCreateAccess);

+	if (rc != Success) {

+	    (*pDraw->pScreen->DestroyPixmap)(pMap);

+	    return rc;

+	}

+	if (AddResource(stuff->pid, RT_PIXMAP, (pointer)pMap))

+	    return(client->noClientException);

+	(*pDraw->pScreen->DestroyPixmap)(pMap);

+    }

+    return (BadAlloc);

+}

+

+int

+ProcFreePixmap(ClientPtr client)

+{

+    PixmapPtr pMap;

+    int rc;

+    REQUEST(xResourceReq);

+    REQUEST_SIZE_MATCH(xResourceReq);

+

+    rc = dixLookupResourceByType((pointer *)&pMap, stuff->id, RT_PIXMAP, client,

+			   DixDestroyAccess);

+    if (rc == Success)

+    {

+	FreeResource(stuff->id, RT_NONE);

+	return(client->noClientException);

+    }

+    else 

+    {

+	client->errorValue = stuff->id;

+	return (rc == BadValue) ? BadPixmap : rc;

+    }

+}

+

+int

+ProcCreateGC(ClientPtr client)

+{

+    int error, rc;

+    GC *pGC;

+    DrawablePtr pDraw;

+    unsigned len;

+    REQUEST(xCreateGCReq);

+

+    REQUEST_AT_LEAST_SIZE(xCreateGCReq);

+    client->errorValue = stuff->gc;

+    LEGAL_NEW_RESOURCE(stuff->gc, client);

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

+			   DixGetAttrAccess);

+    if (rc != Success)

+	return rc;

+

+    len = client->req_len -  bytes_to_int32(sizeof(xCreateGCReq));

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

+        return BadLength;

+    pGC = (GC *)CreateGC(pDraw, stuff->mask, (XID *) &stuff[1], &error,

+			 stuff->gc, client);

+    if (error != Success)

+        return error;

+    if (!AddResource(stuff->gc, RT_GC, (pointer)pGC))

+	return (BadAlloc);

+    return(client->noClientException);

+}

+

+int

+ProcChangeGC(ClientPtr client)

+{

+    GC *pGC;

+    int result;

+    unsigned len;

+    REQUEST(xChangeGCReq);

+    REQUEST_AT_LEAST_SIZE(xChangeGCReq);

+

+    result = dixLookupGC(&pGC, stuff->gc, client, DixSetAttrAccess);

+    if (result != Success)

+	return result;

+

+    len = client->req_len -  bytes_to_int32(sizeof(xChangeGCReq));

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

+        return BadLength;

+

+    result = dixChangeGC(client, pGC, stuff->mask, (CARD32 *) &stuff[1], 0);

+    if (client->noClientException != Success)

+        return(client->noClientException);

+    else

+    {

+	client->errorValue = clientErrorValue;

+        return(result);

+    }

+}

+

+int

+ProcCopyGC(ClientPtr client)

+{

+    GC *dstGC;

+    GC *pGC;

+    int result;

+    REQUEST(xCopyGCReq);

+    REQUEST_SIZE_MATCH(xCopyGCReq);

+

+    result = dixLookupGC(&pGC, stuff->srcGC, client, DixGetAttrAccess);

+    if (result != Success)

+	return result;

+    result = dixLookupGC(&dstGC, stuff->dstGC, client, DixSetAttrAccess);

+    if (result != Success)

+	return result;

+    if ((dstGC->pScreen != pGC->pScreen) || (dstGC->depth != pGC->depth))

+        return (BadMatch);    

+    result = CopyGC(pGC, dstGC, stuff->mask);

+    if (client->noClientException != Success)

+        return(client->noClientException);

+    else

+    {

+	client->errorValue = clientErrorValue;

+        return(result);

+    }

+}

+

+int

+ProcSetDashes(ClientPtr client)

+{

+    GC *pGC;

+    int result;

+    REQUEST(xSetDashesReq);

+

+    REQUEST_FIXED_SIZE(xSetDashesReq, stuff->nDashes);

+    if (stuff->nDashes == 0)

+    {

+	 client->errorValue = 0;

+         return BadValue;

+    }

+

+    result = dixLookupGC(&pGC,stuff->gc, client, DixSetAttrAccess);

+    if (result != Success)

+	return result;

+

+    result = SetDashes(pGC, stuff->dashOffset, stuff->nDashes,

+		       (unsigned char *)&stuff[1]);

+    if (client->noClientException != Success)

+        return(client->noClientException);

+    else

+    {

+	client->errorValue = clientErrorValue;

+        return(result);

+    }

+}

+

+int

+ProcSetClipRectangles(ClientPtr client)

+{

+    int	nr, result;

+    GC *pGC;

+    REQUEST(xSetClipRectanglesReq);

+

+    REQUEST_AT_LEAST_SIZE(xSetClipRectanglesReq);

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

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

+    {

+	client->errorValue = stuff->ordering;

+        return BadValue;

+    }

+    result = dixLookupGC(&pGC,stuff->gc, client, DixSetAttrAccess);

+    if (result != Success)

+	return result;

+		 

+    nr = (client->req_len << 2) - sizeof(xSetClipRectanglesReq);

+    if (nr & 4)

+	return(BadLength);

+    nr >>= 3;

+    result = SetClipRects(pGC, stuff->xOrigin, stuff->yOrigin,

+			  nr, (xRectangle *)&stuff[1], (int)stuff->ordering);

+    if (client->noClientException != Success)

+        return(client->noClientException);

+    else

+        return(result);

+}

+

+int

+ProcFreeGC(ClientPtr client)

+{

+    GC *pGC;

+    int rc;

+    REQUEST(xResourceReq);

+    REQUEST_SIZE_MATCH(xResourceReq);

+

+    rc = dixLookupGC(&pGC, stuff->id, client, DixDestroyAccess);

+    if (rc != Success)

+	return rc;

+

+    FreeResource(stuff->id, RT_NONE);

+    return(client->noClientException);

+}

+

+int

+ProcClearToBackground(ClientPtr client)

+{

+    REQUEST(xClearAreaReq);

+    WindowPtr pWin;

+    int rc;

+

+    REQUEST_SIZE_MATCH(xClearAreaReq);

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

+    if (rc != Success)

+        return rc;

+    if (pWin->drawable.class == InputOnly)

+    {

+	client->errorValue = stuff->window;

+	return (BadMatch);

+    }		    

+    if ((stuff->exposures != xTrue) && (stuff->exposures != xFalse))

+    {

+	client->errorValue = stuff->exposures;

+        return(BadValue);

+    }

+    (*pWin->drawable.pScreen->ClearToBackground)(pWin, stuff->x, stuff->y,

+			       stuff->width, stuff->height,

+			       (Bool)stuff->exposures);

+    return(client->noClientException);

+}

+

+int

+ProcCopyArea(ClientPtr client)

+{

+    DrawablePtr pDst;

+    DrawablePtr pSrc;

+    GC *pGC;

+    REQUEST(xCopyAreaReq);

+    RegionPtr pRgn;

+    int rc;

+

+    REQUEST_SIZE_MATCH(xCopyAreaReq);

+

+    VALIDATE_DRAWABLE_AND_GC(stuff->dstDrawable, pDst, DixWriteAccess); 

+    if (stuff->dstDrawable != stuff->srcDrawable)

+    {

+	rc = dixLookupDrawable(&pSrc, stuff->srcDrawable, client, 0,

+				 DixReadAccess);

+	if (rc != Success)

+	    return rc;

+	if ((pDst->pScreen != pSrc->pScreen) || (pDst->depth != pSrc->depth))

+	{

+	    client->errorValue = stuff->dstDrawable;

+	    return (BadMatch);

+	}

+    }

+    else

+        pSrc = pDst;

+

+    pRgn = (*pGC->ops->CopyArea)(pSrc, pDst, pGC, stuff->srcX, stuff->srcY,

+				 stuff->width, stuff->height, 

+				 stuff->dstX, stuff->dstY);

+    if (pGC->graphicsExposures)

+    {

+	(*pDst->pScreen->SendGraphicsExpose)

+ 		(client, pRgn, stuff->dstDrawable, X_CopyArea, 0);

+	if (pRgn)

+	    REGION_DESTROY(pDst->pScreen, pRgn);

+    }

+

+    return(client->noClientException);

+}

+

+int

+ProcCopyPlane(ClientPtr client)

+{

+    DrawablePtr psrcDraw, pdstDraw;

+    GC *pGC;

+    REQUEST(xCopyPlaneReq);

+    RegionPtr pRgn;

+    int rc;

+

+    REQUEST_SIZE_MATCH(xCopyPlaneReq);

+

+    VALIDATE_DRAWABLE_AND_GC(stuff->dstDrawable, pdstDraw, DixWriteAccess);

+    if (stuff->dstDrawable != stuff->srcDrawable)

+    {

+	rc = dixLookupDrawable(&psrcDraw, stuff->srcDrawable, client, 0,

+			       DixReadAccess);

+	if (rc != Success)

+	    return rc;

+

+	if (pdstDraw->pScreen != psrcDraw->pScreen)

+	{

+	    client->errorValue = stuff->dstDrawable;

+	    return (BadMatch);

+	}

+    }

+    else

+        psrcDraw = pdstDraw;

+

+    /* Check to see if stuff->bitPlane has exactly ONE good bit set */

+    if(stuff->bitPlane == 0 || (stuff->bitPlane & (stuff->bitPlane - 1)) ||

+       (stuff->bitPlane > (1L << (psrcDraw->depth - 1))))

+    {

+       client->errorValue = stuff->bitPlane;

+       return(BadValue);

+    }

+

+    pRgn = (*pGC->ops->CopyPlane)(psrcDraw, pdstDraw, pGC, stuff->srcX, stuff->srcY,

+				 stuff->width, stuff->height, 

+				 stuff->dstX, stuff->dstY, stuff->bitPlane);

+    if (pGC->graphicsExposures)

+    {

+	(*pdstDraw->pScreen->SendGraphicsExpose)

+ 		(client, pRgn, stuff->dstDrawable, X_CopyPlane, 0);

+	if (pRgn)

+	    REGION_DESTROY(pdstDraw->pScreen, pRgn);

+    }

+    return(client->noClientException);

+}

+

+int

+ProcPolyPoint(ClientPtr client)

+{

+    int npoint;

+    GC *pGC;

+    DrawablePtr pDraw;

+    REQUEST(xPolyPointReq);

+

+    REQUEST_AT_LEAST_SIZE(xPolyPointReq);

+    if ((stuff->coordMode != CoordModeOrigin) && 

+	(stuff->coordMode != CoordModePrevious))

+    {

+	client->errorValue = stuff->coordMode;

+        return BadValue;

+    }

+    VALIDATE_DRAWABLE_AND_GC(stuff->drawable, pDraw, DixWriteAccess); 

+    npoint = bytes_to_int32((client->req_len << 2) - sizeof(xPolyPointReq));

+    if (npoint)

+        (*pGC->ops->PolyPoint)(pDraw, pGC, stuff->coordMode, npoint,

+			  (xPoint *) &stuff[1]);

+    return (client->noClientException);

+}

+

+int

+ProcPolyLine(ClientPtr client)

+{

+    int npoint;

+    GC *pGC;

+    DrawablePtr pDraw;

+    REQUEST(xPolyLineReq);

+

+    REQUEST_AT_LEAST_SIZE(xPolyLineReq);

+    if ((stuff->coordMode != CoordModeOrigin) && 

+	(stuff->coordMode != CoordModePrevious))

+    {

+	client->errorValue = stuff->coordMode;

+        return BadValue;

+    }

+    VALIDATE_DRAWABLE_AND_GC(stuff->drawable, pDraw, DixWriteAccess);

+    npoint = bytes_to_int32((client->req_len << 2) - sizeof(xPolyLineReq));

+    if (npoint > 1)

+	(*pGC->ops->Polylines)(pDraw, pGC, stuff->coordMode, npoint, 

+			      (DDXPointPtr) &stuff[1]);

+    return(client->noClientException);

+}

+

+int

+ProcPolySegment(ClientPtr client)

+{

+    int nsegs;

+    GC *pGC;

+    DrawablePtr pDraw;

+    REQUEST(xPolySegmentReq);

+

+    REQUEST_AT_LEAST_SIZE(xPolySegmentReq);

+    VALIDATE_DRAWABLE_AND_GC(stuff->drawable, pDraw, DixWriteAccess);

+    nsegs = (client->req_len << 2) - sizeof(xPolySegmentReq);

+    if (nsegs & 4)

+	return(BadLength);

+    nsegs >>= 3;

+    if (nsegs)

+        (*pGC->ops->PolySegment)(pDraw, pGC, nsegs, (xSegment *) &stuff[1]);

+    return (client->noClientException);

+}

+

+int

+ProcPolyRectangle (ClientPtr client)

+{

+    int nrects;

+    GC *pGC;

+    DrawablePtr pDraw;

+    REQUEST(xPolyRectangleReq);

+

+    REQUEST_AT_LEAST_SIZE(xPolyRectangleReq);

+    VALIDATE_DRAWABLE_AND_GC(stuff->drawable, pDraw, DixWriteAccess);

+    nrects = (client->req_len << 2) - sizeof(xPolyRectangleReq);

+    if (nrects & 4)

+	return(BadLength);

+    nrects >>= 3;

+    if (nrects)

+        (*pGC->ops->PolyRectangle)(pDraw, pGC, 

+		    nrects, (xRectangle *) &stuff[1]);

+    return(client->noClientException);

+}

+

+int

+ProcPolyArc(ClientPtr client)

+{

+    int		narcs;

+    GC *pGC;

+    DrawablePtr pDraw;

+    REQUEST(xPolyArcReq);

+

+    REQUEST_AT_LEAST_SIZE(xPolyArcReq);

+    VALIDATE_DRAWABLE_AND_GC(stuff->drawable, pDraw, DixWriteAccess);

+    narcs = (client->req_len << 2) - sizeof(xPolyArcReq);

+    if (narcs % sizeof(xArc))

+	return(BadLength);

+    narcs /= sizeof(xArc);

+    if (narcs)

+        (*pGC->ops->PolyArc)(pDraw, pGC, narcs, (xArc *) &stuff[1]);

+    return (client->noClientException);

+}

+

+int

+ProcFillPoly(ClientPtr client)

+{

+    int          things;

+    GC *pGC;

+    DrawablePtr pDraw;

+    REQUEST(xFillPolyReq);

+

+    REQUEST_AT_LEAST_SIZE(xFillPolyReq);

+    if ((stuff->shape != Complex) && (stuff->shape != Nonconvex) &&  

+	(stuff->shape != Convex))

+    {

+	client->errorValue = stuff->shape;

+        return BadValue;

+    }

+    if ((stuff->coordMode != CoordModeOrigin) && 

+	(stuff->coordMode != CoordModePrevious))

+    {

+	client->errorValue = stuff->coordMode;

+        return BadValue;

+    }

+

+    VALIDATE_DRAWABLE_AND_GC(stuff->drawable, pDraw, DixWriteAccess);

+    things = bytes_to_int32((client->req_len << 2) - sizeof(xFillPolyReq));

+    if (things)

+        (*pGC->ops->FillPolygon) (pDraw, pGC, stuff->shape,

+			 stuff->coordMode, things,

+			 (DDXPointPtr) &stuff[1]);

+    return(client->noClientException);

+}

+

+int

+ProcPolyFillRectangle(ClientPtr client)

+{

+    int             things;

+    GC *pGC;

+    DrawablePtr pDraw;

+    REQUEST(xPolyFillRectangleReq);

+

+    REQUEST_AT_LEAST_SIZE(xPolyFillRectangleReq);

+    VALIDATE_DRAWABLE_AND_GC(stuff->drawable, pDraw, DixWriteAccess);

+    things = (client->req_len << 2) - sizeof(xPolyFillRectangleReq);

+    if (things & 4)

+	return(BadLength);

+    things >>= 3;

+

+    if (things)

+        (*pGC->ops->PolyFillRect) (pDraw, pGC, things,

+		      (xRectangle *) &stuff[1]);

+    return (client->noClientException);

+}

+

+int

+ProcPolyFillArc(ClientPtr client)

+{

+    int		narcs;

+    GC *pGC;

+    DrawablePtr pDraw;

+    REQUEST(xPolyFillArcReq);

+

+    REQUEST_AT_LEAST_SIZE(xPolyFillArcReq);

+    VALIDATE_DRAWABLE_AND_GC(stuff->drawable, pDraw, DixWriteAccess);

+    narcs = (client->req_len << 2) - sizeof(xPolyFillArcReq);

+    if (narcs % sizeof(xArc))

+	return(BadLength);

+    narcs /= sizeof(xArc);

+    if (narcs)

+        (*pGC->ops->PolyFillArc) (pDraw, pGC, narcs, (xArc *) &stuff[1]);

+    return (client->noClientException);

+}

+

+#ifdef MATCH_CLIENT_ENDIAN

+

+int

+ServerOrder (void)

+{

+    int	    whichbyte = 1;

+

+    if (*((char *) &whichbyte))

+	return LSBFirst;

+    return MSBFirst;

+}

+

+#define ClientOrder(client) ((client)->swapped ? !ServerOrder() : ServerOrder())

+

+void

+ReformatImage (char *base, int nbytes, int bpp, int order)

+{

+    switch (bpp) {

+    case 1:	/* yuck */

+	if (BITMAP_BIT_ORDER != order)

+	    BitOrderInvert ((unsigned char *) base, nbytes);

+#if IMAGE_BYTE_ORDER != BITMAP_BIT_ORDER && BITMAP_SCANLINE_UNIT != 8

+	ReformatImage (base, nbytes, BITMAP_SCANLINE_UNIT, order);

+#endif

+	break;

+    case 4:

+	break;  /* yuck */

+    case 8:

+	break;

+    case 16:

+	if (IMAGE_BYTE_ORDER != order)

+	    TwoByteSwap ((unsigned char *) base, nbytes);

+	break;

+    case 32:

+	if (IMAGE_BYTE_ORDER != order)

+	    FourByteSwap ((unsigned char *) base, nbytes);

+	break;

+    }

+}

+#else

+#define ReformatImage(b,n,bpp,o)

+#endif

+

+/* 64-bit server notes: the protocol restricts padding of images to

+ * 8-, 16-, or 32-bits. We would like to have 64-bits for the server

+ * to use internally. Removes need for internal alignment checking.

+ * All of the PutImage functions could be changed individually, but

+ * as currently written, they call other routines which require things

+ * to be 64-bit padded on scanlines, so we changed things here.

+ * If an image would be padded differently for 64- versus 32-, then

+ * copy each scanline to a 64-bit padded scanline.

+ * Also, we need to make sure that the image is aligned on a 64-bit

+ * boundary, even if the scanlines are padded to our satisfaction.

+ */

+int

+ProcPutImage(ClientPtr client)

+{

+    GC *pGC;

+    DrawablePtr pDraw;

+    long	length; 	/* length of scanline server padded */

+    long 	lengthProto; 	/* length of scanline protocol padded */

+    char	*tmpImage;

+    REQUEST(xPutImageReq);

+

+    REQUEST_AT_LEAST_SIZE(xPutImageReq);

+    VALIDATE_DRAWABLE_AND_GC(stuff->drawable, pDraw, DixWriteAccess);

+    if (stuff->format == XYBitmap)

+    {

+        if ((stuff->depth != 1) ||

+	    (stuff->leftPad >= (unsigned int)screenInfo.bitmapScanlinePad))

+            return BadMatch;

+        length 	    = BitmapBytePad(stuff->width + stuff->leftPad);

+    }

+    else if (stuff->format == XYPixmap)

+    {

+        if ((pDraw->depth != stuff->depth) || 

+	    (stuff->leftPad >= (unsigned int)screenInfo.bitmapScanlinePad))

+            return BadMatch;

+        length      = BitmapBytePad(stuff->width + stuff->leftPad);

+	length      *= stuff->depth;

+    }

+    else if (stuff->format == ZPixmap)

+    {

+        if ((pDraw->depth != stuff->depth) || (stuff->leftPad != 0))

+            return BadMatch;

+        length      = PixmapBytePad(stuff->width, stuff->depth);

+    }

+    else

+    {

+	client->errorValue = stuff->format;

+        return BadValue;

+    }

+

+    tmpImage = (char *)&stuff[1];

+    lengthProto = length;

+	

+    if ((bytes_to_int32(lengthProto * stuff->height) +

+	bytes_to_int32(sizeof(xPutImageReq))) != client->req_len)

+	return BadLength;

+

+    ReformatImage (tmpImage, lengthProto * stuff->height, 

+		   stuff->format == ZPixmap ? BitsPerPixel (stuff->depth) : 1,

+		   ClientOrder(client));

+    

+    (*pGC->ops->PutImage) (pDraw, pGC, stuff->depth, stuff->dstX, stuff->dstY,

+		  stuff->width, stuff->height, 

+		  stuff->leftPad, stuff->format, tmpImage);

+

+     return (client->noClientException);

+}

+

+static int

+DoGetImage(ClientPtr client, int format, Drawable drawable, 

+           int x, int y, int width, int height, 

+           Mask planemask, xGetImageReply **im_return)

+{

+    DrawablePtr		pDraw, pBoundingDraw;

+    int			nlines, linesPerBuf, rc;

+    int			linesDone;

+    /* coordinates relative to the bounding drawable */

+    int			relx, rely;

+    long		widthBytesLine, length;

+    Mask		plane = 0;

+    char		*pBuf;

+    xGetImageReply	xgi;

+    RegionPtr pVisibleRegion = NULL;

+

+    if ((format != XYPixmap) && (format != ZPixmap))

+    {

+	client->errorValue = format;

+        return(BadValue);

+    }

+    rc = dixLookupDrawable(&pDraw, drawable, client, 0, DixReadAccess);

+    if (rc != Success)

+	return rc;

+

+    memset(&xgi, 0, sizeof(xGetImageReply));

+

+    relx = x;

+    rely = y;

+

+    if(pDraw->type == DRAWABLE_WINDOW)

+    {

+	WindowPtr pWin = (WindowPtr)pDraw;

+

+	/* "If the drawable is a window, the window must be viewable ... or a

+	 * BadMatch error results" */

+	if (!pWin->viewable)

+	    return BadMatch;

+

+	relx += pDraw->x;

+	rely += pDraw->y;

+

+	if (pDraw->pScreen->GetWindowPixmap) {

+	    PixmapPtr pPix = (*pDraw->pScreen->GetWindowPixmap) (pWin);

+

+	    pBoundingDraw = &pPix->drawable;

+#ifdef COMPOSITE

+	    relx -= pPix->screen_x;

+	    rely -= pPix->screen_y;

+#endif

+	}

+	else

+	{

+	    pBoundingDraw = (DrawablePtr)WindowTable[pDraw->pScreen->myNum];

+	}

+

+	xgi.visual = wVisual (pWin);

+    }

+    else

+    {

+	pBoundingDraw = pDraw;

+	xgi.visual = None;

+    }

+

+    /* "If the drawable is a pixmap, the given rectangle must be wholly

+     *  contained within the pixmap, or a BadMatch error results.  If the

+     *  drawable is a window [...] it must be the case that if there were no

+     *  inferiors or overlapping windows, the specified rectangle of the window

+     *  would be fully visible on the screen and wholly contained within the

+     *  outside edges of the window, or a BadMatch error results."

+     *

+     * We relax the window case slightly to mean that the rectangle must exist

+     * within the bounds of the window's backing pixmap.  In particular, this

+     * means that a GetImage request may succeed or fail with BadMatch depending

+     * on whether any of its ancestor windows are redirected.  */

+    if(relx < 0 || relx + width > (int)pBoundingDraw->width ||

+       rely < 0 || rely + height > (int)pBoundingDraw->height)

+	return BadMatch;

+

+    xgi.type = X_Reply;

+    xgi.sequenceNumber = client->sequence;

+    xgi.depth = pDraw->depth;

+    if(format == ZPixmap)

+    {

+	widthBytesLine = PixmapBytePad(width, pDraw->depth);

+	length = widthBytesLine * height;

+

+    }

+    else 

+    {

+	widthBytesLine = BitmapBytePad(width);

+	plane = ((Mask)1) << (pDraw->depth - 1);

+	/* only planes asked for */

+	length = widthBytesLine * height *

+		 Ones(planemask & (plane | (plane - 1)));

+

+    }

+

+    xgi.length = length;

+

+    if (im_return) {

+	pBuf = xcalloc(1, sz_xGetImageReply + length);

+	if (!pBuf)

+	    return (BadAlloc);

+	if (widthBytesLine == 0)

+	    linesPerBuf = 0;

+	else

+	    linesPerBuf = height;

+	*im_return = (xGetImageReply *)pBuf;

+	*(xGetImageReply *)pBuf = xgi;

+	pBuf += sz_xGetImageReply;

+    } else {

+	xgi.length = bytes_to_int32(xgi.length);

+	if (widthBytesLine == 0 || height == 0)

+	    linesPerBuf = 0;

+	else if (widthBytesLine >= IMAGE_BUFSIZE)

+	    linesPerBuf = 1;

+	else

+	{

+	    linesPerBuf = IMAGE_BUFSIZE / widthBytesLine;

+	    if (linesPerBuf > height)

+		linesPerBuf = height;

+	}

+	length = linesPerBuf * widthBytesLine;

+	if (linesPerBuf < height)

+	{

+	    /* we have to make sure intermediate buffers don't need padding */

+	    while ((linesPerBuf > 1) &&

+		   (length & ((1L << LOG2_BYTES_PER_SCANLINE_PAD)-1)))

+	    {

+		linesPerBuf--;

+		length -= widthBytesLine;

+	    }

+	    while (length & ((1L << LOG2_BYTES_PER_SCANLINE_PAD)-1))

+	    {

+		linesPerBuf++;

+		length += widthBytesLine;

+	    }

+	}

+	if(!(pBuf = xcalloc(1, length)))

+	    return (BadAlloc);

+	WriteReplyToClient(client, sizeof (xGetImageReply), &xgi);

+    }

+

+    if (pDraw->type == DRAWABLE_WINDOW)

+    {

+	pVisibleRegion = NotClippedByChildren((WindowPtr)pDraw);

+	if (pVisibleRegion)

+	{

+	    REGION_TRANSLATE(pDraw->pScreen, pVisibleRegion,

+			     -pDraw->x, -pDraw->y);

+	}

+    }

+

+    if (linesPerBuf == 0)

+    {

+	/* nothing to do */

+    }

+    else if (format == ZPixmap)

+    {

+        linesDone = 0;

+        while (height - linesDone > 0)

+        {

+	    nlines = min(linesPerBuf, height - linesDone);

+	    (*pDraw->pScreen->GetImage) (pDraw,

+	                                 x,

+				         y + linesDone,

+				         width, 

+				         nlines,

+				         format,

+				         planemask,

+				         (pointer) pBuf);

+	    if (pVisibleRegion)

+		XaceCensorImage(client, pVisibleRegion, widthBytesLine,

+			pDraw, x, y + linesDone, width, 

+			nlines, format, pBuf);

+

+	    /* Note that this is NOT a call to WriteSwappedDataToClient,

+               as we do NOT byte swap */

+	    if (!im_return)

+	    {

+		ReformatImage (pBuf, (int)(nlines * widthBytesLine),

+			       BitsPerPixel (pDraw->depth),

+			       ClientOrder(client));

+

+/* Don't split me, gcc pukes when you do */

+		(void)WriteToClient(client,

+				    (int)(nlines * widthBytesLine),

+				    pBuf);

+	    }

+	    linesDone += nlines;

+        }

+    }

+    else /* XYPixmap */

+    {

+        for (; plane; plane >>= 1)

+	{

+	    if (planemask & plane)

+	    {

+	        linesDone = 0;

+	        while (height - linesDone > 0)

+	        {

+		    nlines = min(linesPerBuf, height - linesDone);

+	            (*pDraw->pScreen->GetImage) (pDraw,

+	                                         x,

+				                 y + linesDone,

+				                 width, 

+				                 nlines,

+				                 format,

+				                 plane,

+				                 (pointer)pBuf);

+		    if (pVisibleRegion)

+			XaceCensorImage(client, pVisibleRegion,

+				widthBytesLine,

+				pDraw, x, y + linesDone, width, 

+				nlines, format, pBuf);

+

+		    /* Note: NOT a call to WriteSwappedDataToClient,

+		       as we do NOT byte swap */

+		    if (im_return) {

+			pBuf += nlines * widthBytesLine;

+		    } else {

+			ReformatImage (pBuf, 

+				       (int)(nlines * widthBytesLine), 

+				       1,

+				       ClientOrder (client));

+

+/* Don't split me, gcc pukes when you do */

+			(void)WriteToClient(client,

+					(int)(nlines * widthBytesLine),

+					pBuf);

+		    }

+		    linesDone += nlines;

+		}

+            }

+	}

+    }

+    if (pVisibleRegion)

+	REGION_DESTROY(pDraw->pScreen, pVisibleRegion);

+    if (!im_return)

+	xfree(pBuf);

+    return (client->noClientException);

+}

+

+int

+ProcGetImage(ClientPtr client)

+{

+    REQUEST(xGetImageReq);

+

+    REQUEST_SIZE_MATCH(xGetImageReq);

+

+    return DoGetImage(client, stuff->format, stuff->drawable,

+		      stuff->x, stuff->y,

+		      (int)stuff->width, (int)stuff->height,

+		      stuff->planeMask, (xGetImageReply **)NULL);

+}

+

+int

+ProcPolyText(ClientPtr client)

+{

+    int	err;

+    REQUEST(xPolyTextReq);

+    DrawablePtr pDraw;

+    GC *pGC;

+

+    REQUEST_AT_LEAST_SIZE(xPolyTextReq);

+    VALIDATE_DRAWABLE_AND_GC(stuff->drawable, pDraw, DixWriteAccess);

+

+    err = PolyText(client,

+		   pDraw,

+		   pGC,

+		   (unsigned char *)&stuff[1],

+		   ((unsigned char *) stuff) + (client->req_len << 2),

+		   stuff->x,

+		   stuff->y,

+		   stuff->reqType,

+		   stuff->drawable);

+

+    if (err == Success)

+    {

+	return(client->noClientException);

+    }

+    else

+	return err;

+}

+

+int

+ProcImageText8(ClientPtr client)

+{

+    int	err;

+    DrawablePtr pDraw;

+    GC *pGC;

+

+    REQUEST(xImageTextReq);

+

+    REQUEST_FIXED_SIZE(xImageTextReq, stuff->nChars);

+    VALIDATE_DRAWABLE_AND_GC(stuff->drawable, pDraw, DixWriteAccess);

+

+    err = ImageText(client,

+		    pDraw,

+		    pGC,

+		    stuff->nChars,

+		    (unsigned char *)&stuff[1],

+		    stuff->x,

+		    stuff->y,

+		    stuff->reqType,

+		    stuff->drawable);

+

+    if (err == Success)

+    {

+	return(client->noClientException);

+    }

+    else

+	return err;

+}

+

+int

+ProcImageText16(ClientPtr client)

+{

+    int	err;

+    DrawablePtr pDraw;

+    GC *pGC;

+

+    REQUEST(xImageTextReq);

+

+    REQUEST_FIXED_SIZE(xImageTextReq, stuff->nChars << 1);

+    VALIDATE_DRAWABLE_AND_GC(stuff->drawable, pDraw, DixWriteAccess);

+

+    err = ImageText(client,

+		    pDraw,

+		    pGC,

+		    stuff->nChars,

+		    (unsigned char *)&stuff[1],

+		    stuff->x,

+		    stuff->y,

+		    stuff->reqType,

+		    stuff->drawable);

+

+    if (err == Success)

+    {

+	return(client->noClientException);

+    }

+    else

+	return err;

+}

+

+

+int

+ProcCreateColormap(ClientPtr client)

+{

+    VisualPtr	pVisual;

+    ColormapPtr	pmap;

+    Colormap	mid;

+    WindowPtr   pWin;

+    ScreenPtr pScreen;

+    REQUEST(xCreateColormapReq);

+    int i, result;

+

+    REQUEST_SIZE_MATCH(xCreateColormapReq);

+

+    if ((stuff->alloc != AllocNone) && (stuff->alloc != AllocAll))

+    {

+	client->errorValue = stuff->alloc;

+        return(BadValue);

+    }

+    mid = stuff->mid;

+    LEGAL_NEW_RESOURCE(mid, client);

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

+    if (result != Success)

+        return result;

+

+    pScreen = pWin->drawable.pScreen;

+    for (i = 0, pVisual = pScreen->visuals;

+	 i < pScreen->numVisuals;

+	 i++, pVisual++)

+    {

+	if (pVisual->vid != stuff->visual)

+	    continue;

+	result =  CreateColormap(mid, pScreen, pVisual, &pmap,

+				 (int)stuff->alloc, client->index);

+	if (client->noClientException != Success)

+	    return(client->noClientException);

+	else

+	    return(result);

+    }

+    client->errorValue = stuff->visual;

+    return(BadMatch);

+}

+

+int

+ProcFreeColormap(ClientPtr client)

+{

+    ColormapPtr pmap;

+    int rc;

+    REQUEST(xResourceReq);

+

+    REQUEST_SIZE_MATCH(xResourceReq);

+    rc = dixLookupResourceByType((pointer *)&pmap, stuff->id, RT_COLORMAP, client,

+			   DixDestroyAccess);

+    if (rc == Success)

+    {

+	/* Freeing a default colormap is a no-op */

+	if (!(pmap->flags & IsDefault))

+	    FreeResource(stuff->id, RT_NONE);

+	return (client->noClientException);

+    }

+    else 

+    {

+	client->errorValue = stuff->id;

+	return (rc == BadValue) ? BadColor : rc;

+    }

+}

+

+

+int

+ProcCopyColormapAndFree(ClientPtr client)

+{

+    Colormap	mid;

+    ColormapPtr	pSrcMap;

+    REQUEST(xCopyColormapAndFreeReq);

+    int rc;

+

+    REQUEST_SIZE_MATCH(xCopyColormapAndFreeReq);

+    mid = stuff->mid;

+    LEGAL_NEW_RESOURCE(mid, client);

+    rc = dixLookupResourceByType((pointer *)&pSrcMap, stuff->srcCmap, RT_COLORMAP,

+			   client, DixReadAccess|DixRemoveAccess);

+    if (rc == Success)

+    {

+	rc = CopyColormapAndFree(mid, pSrcMap, client->index);

+	if (client->noClientException != Success)

+            return(client->noClientException);

+	else

+            return rc;

+    }

+    else

+    {

+	client->errorValue = stuff->srcCmap;

+	return (rc == BadValue) ? BadColor : rc;

+    }

+}

+

+int

+ProcInstallColormap(ClientPtr client)

+{

+    ColormapPtr pcmp;

+    int rc;

+    REQUEST(xResourceReq);

+    REQUEST_SIZE_MATCH(xResourceReq);

+

+    rc = dixLookupResourceByType((pointer *)&pcmp, stuff->id, RT_COLORMAP, client,

+			   DixInstallAccess);

+    if (rc != Success)

+	goto out;

+

+    rc = XaceHook(XACE_SCREEN_ACCESS, client, pcmp->pScreen, DixSetAttrAccess);

+    if (rc != Success)

+	goto out;

+

+    (*(pcmp->pScreen->InstallColormap)) (pcmp);

+

+    rc = client->noClientException;

+out:

+    client->errorValue = stuff->id;

+    return (rc == BadValue) ? BadColor : rc;

+}

+

+int

+ProcUninstallColormap(ClientPtr client)

+{

+    ColormapPtr pcmp;

+    int rc;

+    REQUEST(xResourceReq);

+    REQUEST_SIZE_MATCH(xResourceReq);

+

+    rc = dixLookupResourceByType((pointer *)&pcmp, stuff->id, RT_COLORMAP, client,

+			   DixUninstallAccess);

+    if (rc != Success)

+	goto out;

+

+    rc = XaceHook(XACE_SCREEN_ACCESS, client, pcmp->pScreen, DixSetAttrAccess);

+    if (rc != Success)

+	goto out;

+

+    if(pcmp->mid != pcmp->pScreen->defColormap)

+	(*(pcmp->pScreen->UninstallColormap)) (pcmp);

+

+    rc = client->noClientException;

+out:

+    client->errorValue = stuff->id;

+    return (rc == BadValue) ? BadColor : rc;

+}

+

+int

+ProcListInstalledColormaps(ClientPtr client)

+{

+    xListInstalledColormapsReply *preply; 

+    int nummaps, rc;

+    WindowPtr pWin;

+    REQUEST(xResourceReq);

+    REQUEST_SIZE_MATCH(xResourceReq);

+

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

+    if (rc != Success)

+	goto out;

+

+    rc = XaceHook(XACE_SCREEN_ACCESS, client, pWin->drawable.pScreen,

+		  DixGetAttrAccess);

+    if (rc != Success)

+	goto out;

+

+    preply = xalloc(sizeof(xListInstalledColormapsReply) +

+		     pWin->drawable.pScreen->maxInstalledCmaps *

+		     sizeof(Colormap));

+    if(!preply)

+        return(BadAlloc);

+

+    preply->type = X_Reply;

+    preply->sequenceNumber = client->sequence;

+    nummaps = (*pWin->drawable.pScreen->ListInstalledColormaps)

+        (pWin->drawable.pScreen, (Colormap *)&preply[1]);

+    preply->nColormaps = nummaps;

+    preply->length = nummaps;

+    WriteReplyToClient(client, sizeof (xListInstalledColormapsReply), preply);

+    client->pSwapReplyFunc = (ReplySwapPtr) Swap32Write;

+    WriteSwappedDataToClient(client, nummaps * sizeof(Colormap), &preply[1]);

+    xfree(preply);

+    rc = client->noClientException;

+out:

+    return rc;

+}

+

+int

+ProcAllocColor (ClientPtr client)

+{

+    ColormapPtr pmap;

+    int rc;

+    xAllocColorReply acr;

+    REQUEST(xAllocColorReq);

+

+    REQUEST_SIZE_MATCH(xAllocColorReq);

+    rc = dixLookupResourceByType((pointer *)&pmap, stuff->cmap, RT_COLORMAP, client,

+			   DixAddAccess);

+    if (rc == Success)

+    {

+	acr.type = X_Reply;

+	acr.length = 0;

+	acr.sequenceNumber = client->sequence;

+	acr.red = stuff->red;

+	acr.green = stuff->green;

+	acr.blue = stuff->blue;

+	acr.pixel = 0;

+	if( (rc = AllocColor(pmap, &acr.red, &acr.green, &acr.blue,

+	                       &acr.pixel, client->index)) )

+	{

+            if (client->noClientException != Success)

+                return(client->noClientException);

+	    else

+	        return rc;

+	}

+#ifdef PANORAMIX

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

+#endif

+        WriteReplyToClient(client, sizeof(xAllocColorReply), &acr);

+	return (client->noClientException);

+

+    }

+    else

+    {

+        client->errorValue = stuff->cmap;

+        return (rc == BadValue) ? BadColor : rc;

+    }

+}

+

+int

+ProcAllocNamedColor (ClientPtr client)

+{

+    ColormapPtr pcmp;

+    int rc;

+    REQUEST(xAllocNamedColorReq);

+

+    REQUEST_FIXED_SIZE(xAllocNamedColorReq, stuff->nbytes);

+    rc = dixLookupResourceByType((pointer *)&pcmp, stuff->cmap, RT_COLORMAP, client,

+			   DixAddAccess);

+    if (rc == Success)

+    {

+	xAllocNamedColorReply ancr;

+

+	ancr.type = X_Reply;

+	ancr.length = 0;

+	ancr.sequenceNumber = client->sequence;

+

+	if(OsLookupColor(pcmp->pScreen->myNum, (char *)&stuff[1], stuff->nbytes,

+	                 &ancr.exactRed, &ancr.exactGreen, &ancr.exactBlue))

+	{

+	    ancr.screenRed = ancr.exactRed;

+	    ancr.screenGreen = ancr.exactGreen;

+	    ancr.screenBlue = ancr.exactBlue;

+	    ancr.pixel = 0;

+	    if( (rc = AllocColor(pcmp,

+	                 &ancr.screenRed, &ancr.screenGreen, &ancr.screenBlue,

+			 &ancr.pixel, client->index)) )

+	    {

+                if (client->noClientException != Success)

+                    return(client->noClientException);

+                else

+		    return rc;

+	    }

+#ifdef PANORAMIX

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

+#endif

+            WriteReplyToClient(client, sizeof (xAllocNamedColorReply), &ancr);

+	    return (client->noClientException);

+	}

+	else

+	    return(BadName);

+	

+    }

+    else

+    {

+        client->errorValue = stuff->cmap;

+        return (rc == BadValue) ? BadColor : rc;

+    }

+}

+

+int

+ProcAllocColorCells (ClientPtr client)

+{

+    ColormapPtr pcmp;

+    int rc;

+    REQUEST(xAllocColorCellsReq);

+

+    REQUEST_SIZE_MATCH(xAllocColorCellsReq);

+    rc = dixLookupResourceByType((pointer *)&pcmp, stuff->cmap, RT_COLORMAP, client,

+			   DixAddAccess);

+    if (rc == Success)

+    {

+	xAllocColorCellsReply	accr;

+	int			npixels, nmasks;

+	long			length;

+	Pixel			*ppixels, *pmasks;

+

+	npixels = stuff->colors;

+	if (!npixels)

+	{

+	    client->errorValue = npixels;

+	    return (BadValue);

+	}

+	if (stuff->contiguous != xTrue && stuff->contiguous != xFalse)

+	{

+	    client->errorValue = stuff->contiguous;

+	    return (BadValue);

+	}

+	nmasks = stuff->planes;

+	length = ((long)npixels + (long)nmasks) * sizeof(Pixel);

+	ppixels = xalloc(length);

+	if(!ppixels)

+            return(BadAlloc);

+	pmasks = ppixels + npixels;

+

+	if( (rc = AllocColorCells(client->index, pcmp, npixels, nmasks, 

+				    (Bool)stuff->contiguous, ppixels, pmasks)) )

+	{

+	    xfree(ppixels);

+            if (client->noClientException != Success)

+                return(client->noClientException);

+	    else

+	        return rc;

+	}

+#ifdef PANORAMIX

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

+#endif

+	{

+	    accr.type = X_Reply;

+	    accr.length = bytes_to_int32(length);

+	    accr.sequenceNumber = client->sequence;

+	    accr.nPixels = npixels;

+	    accr.nMasks = nmasks;

+	    WriteReplyToClient(client, sizeof (xAllocColorCellsReply), &accr);

+	    client->pSwapReplyFunc = (ReplySwapPtr) Swap32Write;

+	    WriteSwappedDataToClient(client, length, ppixels);

+	}

+	xfree(ppixels);

+        return (client->noClientException);        

+    }

+    else

+    {

+        client->errorValue = stuff->cmap;

+        return (rc == BadValue) ? BadColor : rc;

+    }

+}

+

+int

+ProcAllocColorPlanes(ClientPtr client)

+{

+    ColormapPtr pcmp;

+    int rc;

+    REQUEST(xAllocColorPlanesReq);

+

+    REQUEST_SIZE_MATCH(xAllocColorPlanesReq);

+    rc = dixLookupResourceByType((pointer *)&pcmp, stuff->cmap, RT_COLORMAP, client,

+			   DixAddAccess);

+    if (rc == Success)

+    {

+	xAllocColorPlanesReply	acpr;

+	int			npixels;

+	long			length;

+	Pixel			*ppixels;

+

+	npixels = stuff->colors;

+	if (!npixels)

+	{

+	    client->errorValue = npixels;

+	    return (BadValue);

+	}

+	if (stuff->contiguous != xTrue && stuff->contiguous != xFalse)

+	{

+	    client->errorValue = stuff->contiguous;

+	    return (BadValue);

+	}

+	acpr.type = X_Reply;

+	acpr.sequenceNumber = client->sequence;

+	acpr.nPixels = npixels;

+	length = (long)npixels * sizeof(Pixel);

+	ppixels = xalloc(length);

+	if(!ppixels)

+            return(BadAlloc);

+	if( (rc = AllocColorPlanes(client->index, pcmp, npixels,

+	    (int)stuff->red, (int)stuff->green, (int)stuff->blue,

+	    (Bool)stuff->contiguous, ppixels,

+	    &acpr.redMask, &acpr.greenMask, &acpr.blueMask)) )

+	{

+            xfree(ppixels);

+            if (client->noClientException != Success)

+                return(client->noClientException);

+	    else

+	        return rc;

+	}

+	acpr.length = bytes_to_int32(length);

+#ifdef PANORAMIX

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

+#endif

+	{

+	    WriteReplyToClient(client, sizeof(xAllocColorPlanesReply), &acpr);

+	    client->pSwapReplyFunc = (ReplySwapPtr) Swap32Write;

+	    WriteSwappedDataToClient(client, length, ppixels);

+	}

+	xfree(ppixels);

+        return (client->noClientException);        

+    }

+    else

+    {

+        client->errorValue = stuff->cmap;

+        return (rc == BadValue) ? BadColor : rc;

+    }

+}

+

+int

+ProcFreeColors(ClientPtr client)

+{

+    ColormapPtr pcmp;

+    int rc;

+    REQUEST(xFreeColorsReq);

+

+    REQUEST_AT_LEAST_SIZE(xFreeColorsReq);

+    rc = dixLookupResourceByType((pointer *)&pcmp, stuff->cmap, RT_COLORMAP, client,

+			   DixRemoveAccess);

+    if (rc == Success)

+    {

+	int	count;

+

+	if(pcmp->flags & AllAllocated)

+	    return(BadAccess);

+	count = bytes_to_int32((client->req_len << 2) - sizeof(xFreeColorsReq));

+	rc = FreeColors(pcmp, client->index, count,

+	    (Pixel *)&stuff[1], (Pixel)stuff->planeMask);

+        if (client->noClientException != Success)

+            return(client->noClientException);

+        else

+	{

+	    client->errorValue = clientErrorValue;

+            return rc;

+	}

+

+    }

+    else

+    {

+        client->errorValue = stuff->cmap;

+        return (rc == BadValue) ? BadColor : rc;

+    }

+}

+

+int

+ProcStoreColors (ClientPtr client)

+{

+    ColormapPtr pcmp;

+    int rc;

+    REQUEST(xStoreColorsReq);

+

+    REQUEST_AT_LEAST_SIZE(xStoreColorsReq);

+    rc = dixLookupResourceByType((pointer *)&pcmp, stuff->cmap, RT_COLORMAP, client,

+			   DixWriteAccess);

+    if (rc == Success)

+    {

+	int	count;

+

+        count = (client->req_len << 2) - sizeof(xStoreColorsReq);

+	if (count % sizeof(xColorItem))

+	    return(BadLength);

+	count /= sizeof(xColorItem);

+	rc = StoreColors(pcmp, count, (xColorItem *)&stuff[1]);

+        if (client->noClientException != Success)

+            return(client->noClientException);

+        else

+	{

+	    client->errorValue = clientErrorValue;

+            return rc;

+	}

+    }

+    else

+    {

+        client->errorValue = stuff->cmap;

+        return (rc == BadValue) ? BadColor : rc;

+    }

+}

+

+int

+ProcStoreNamedColor (ClientPtr client)

+{

+    ColormapPtr pcmp;

+    int rc;

+    REQUEST(xStoreNamedColorReq);

+

+    REQUEST_FIXED_SIZE(xStoreNamedColorReq, stuff->nbytes);

+    rc = dixLookupResourceByType((pointer *)&pcmp, stuff->cmap, RT_COLORMAP, client,

+			   DixWriteAccess);

+    if (rc == Success)

+    {

+	xColorItem	def;

+

+	if(OsLookupColor(pcmp->pScreen->myNum, (char *)&stuff[1],

+	                 stuff->nbytes, &def.red, &def.green, &def.blue))

+	{

+	    def.flags = stuff->flags;

+	    def.pixel = stuff->pixel;

+	    rc = StoreColors(pcmp, 1, &def);

+            if (client->noClientException != Success)

+                return(client->noClientException);

+	    else

+		return rc;

+	}

+        return (BadName);        

+    }

+    else

+    {

+        client->errorValue = stuff->cmap;

+        return (rc == BadValue) ? BadColor : rc;

+    }

+}

+

+int

+ProcQueryColors(ClientPtr client)

+{

+    ColormapPtr pcmp;

+    int rc;

+    REQUEST(xQueryColorsReq);

+

+    REQUEST_AT_LEAST_SIZE(xQueryColorsReq);

+    rc = dixLookupResourceByType((pointer *)&pcmp, stuff->cmap, RT_COLORMAP, client,

+			   DixReadAccess);

+    if (rc == Success)

+    {

+	int			count;

+	xrgb 			*prgbs;

+	xQueryColorsReply	qcr;

+

+	count = bytes_to_int32((client->req_len << 2) - sizeof(xQueryColorsReq));

+	prgbs = xcalloc(1, count * sizeof(xrgb));

+	if(!prgbs && count)

+            return(BadAlloc);

+	if( (rc = QueryColors(pcmp, count, (Pixel *)&stuff[1], prgbs)) )

+	{

+   	    if (prgbs) xfree(prgbs);

+	    if (client->noClientException != Success)

+                return(client->noClientException);

+	    else

+	    {

+		client->errorValue = clientErrorValue;

+	        return rc;

+	    }

+	}

+	memset(&qcr, 0, sizeof(xQueryColorsReply));

+	qcr.type = X_Reply;

+	qcr.length = bytes_to_int32(count * sizeof(xrgb));

+	qcr.sequenceNumber = client->sequence;

+	qcr.nColors = count;

+	WriteReplyToClient(client, sizeof(xQueryColorsReply), &qcr);

+	if (count)

+	{

+	    client->pSwapReplyFunc = (ReplySwapPtr) SQColorsExtend;

+	    WriteSwappedDataToClient(client, count * sizeof(xrgb), prgbs);

+	}

+	if (prgbs) xfree(prgbs);

+	return(client->noClientException);

+	

+    }

+    else

+    {

+        client->errorValue = stuff->cmap;

+        return (rc == BadValue) ? BadColor : rc;

+    }

+} 

+

+int

+ProcLookupColor(ClientPtr client)

+{

+    ColormapPtr pcmp;

+    int rc;

+    REQUEST(xLookupColorReq);

+

+    REQUEST_FIXED_SIZE(xLookupColorReq, stuff->nbytes);

+    rc = dixLookupResourceByType((pointer *)&pcmp, stuff->cmap, RT_COLORMAP, client,

+			   DixReadAccess);

+    if (rc == Success)

+    {

+	xLookupColorReply lcr;

+

+	if(OsLookupColor(pcmp->pScreen->myNum, (char *)&stuff[1], stuff->nbytes,

+	                 &lcr.exactRed, &lcr.exactGreen, &lcr.exactBlue))

+	{

+	    lcr.type = X_Reply;

+	    lcr.length = 0;

+	    lcr.sequenceNumber = client->sequence;

+	    lcr.screenRed = lcr.exactRed;

+	    lcr.screenGreen = lcr.exactGreen;

+	    lcr.screenBlue = lcr.exactBlue;

+	    (*pcmp->pScreen->ResolveColor)(&lcr.screenRed,

+	                                   &lcr.screenGreen,

+					   &lcr.screenBlue,

+					   pcmp->pVisual);

+	    WriteReplyToClient(client, sizeof(xLookupColorReply), &lcr);

+	    return(client->noClientException);

+	}

+        return (BadName);        

+    }

+    else

+    {

+        client->errorValue = stuff->cmap;

+        return (rc == BadValue) ? BadColor : rc;

+    }

+}

+

+int

+ProcCreateCursor (ClientPtr client)

+{

+    CursorPtr		pCursor;

+    PixmapPtr 		src;

+    PixmapPtr 		msk;

+    unsigned char *	srcbits;

+    unsigned char *	mskbits;

+    unsigned short	width, height;

+    long		n;

+    CursorMetricRec 	cm;

+    int rc;

+

+    REQUEST(xCreateCursorReq);

+

+    REQUEST_SIZE_MATCH(xCreateCursorReq);

+    LEGAL_NEW_RESOURCE(stuff->cid, client);

+

+    rc = dixLookupResourceByType((pointer *)&src, stuff->source, RT_PIXMAP, client,

+			   DixReadAccess);

+    if (rc != Success) {

+	client->errorValue = stuff->source;

+	return (rc == BadValue) ? BadPixmap : rc;

+    }

+

+    rc = dixLookupResourceByType((pointer *)&msk, stuff->mask, RT_PIXMAP, client,

+			   DixReadAccess);

+    if (rc != Success)

+    {

+	if (stuff->mask != None)

+	{

+	    client->errorValue = stuff->mask;

+	    return (rc == BadValue) ? BadPixmap : rc;

+	}

+    }

+    else if (  src->drawable.width != msk->drawable.width

+	    || src->drawable.height != msk->drawable.height

+	    || src->drawable.depth != 1

+	    || msk->drawable.depth != 1)

+	return (BadMatch);

+

+    width = src->drawable.width;

+    height = src->drawable.height;

+

+    if ( stuff->x > width 

+      || stuff->y > height )

+	return (BadMatch);

+

+    n = BitmapBytePad(width)*height;

+    srcbits = xcalloc(1, n);

+    if (!srcbits)

+	return (BadAlloc);

+    mskbits = xalloc(n);

+    if (!mskbits)

+    {

+	xfree(srcbits);

+	return (BadAlloc);

+    }

+

+    (* src->drawable.pScreen->GetImage)( (DrawablePtr)src, 0, 0, width, height,

+					 XYPixmap, 1, (pointer)srcbits);

+    if ( msk == (PixmapPtr)NULL)

+    {

+	unsigned char *bits = mskbits;

+	while (--n >= 0)

+	    *bits++ = ~0;

+    }

+    else

+    {

+	/* zeroing the (pad) bits helps some ddx cursor handling */

+	bzero((char *)mskbits, n);

+	(* msk->drawable.pScreen->GetImage)( (DrawablePtr)msk, 0, 0, width,

+					height, XYPixmap, 1, (pointer)mskbits);

+    }

+    cm.width = width;

+    cm.height = height;

+    cm.xhot = stuff->x;

+    cm.yhot = stuff->y;

+    rc = AllocARGBCursor(srcbits, mskbits, NULL, &cm,

+			 stuff->foreRed, stuff->foreGreen, stuff->foreBlue,

+			 stuff->backRed, stuff->backGreen, stuff->backBlue,

+			 &pCursor, client, stuff->cid);

+

+    if (rc != Success)

+	return rc;

+    if (!AddResource(stuff->cid, RT_CURSOR, (pointer)pCursor))

+	return BadAlloc;

+

+    return client->noClientException;

+}

+

+int

+ProcCreateGlyphCursor (ClientPtr client)

+{

+    CursorPtr pCursor;

+    int res;

+

+    REQUEST(xCreateGlyphCursorReq);

+

+    REQUEST_SIZE_MATCH(xCreateGlyphCursorReq);

+    LEGAL_NEW_RESOURCE(stuff->cid, client);

+

+    res = AllocGlyphCursor(stuff->source, stuff->sourceChar,

+			   stuff->mask, stuff->maskChar,

+			   stuff->foreRed, stuff->foreGreen, stuff->foreBlue,

+			   stuff->backRed, stuff->backGreen, stuff->backBlue,

+			   &pCursor, client, stuff->cid);

+    if (res != Success)

+	return res;

+    if (AddResource(stuff->cid, RT_CURSOR, (pointer)pCursor))

+	return client->noClientException;

+    return BadAlloc;

+}

+

+

+int

+ProcFreeCursor (ClientPtr client)

+{

+    CursorPtr pCursor;

+    int rc;

+    REQUEST(xResourceReq);

+

+    REQUEST_SIZE_MATCH(xResourceReq);

+    rc = dixLookupResourceByType((pointer *)&pCursor, stuff->id, RT_CURSOR, client,

+			   DixDestroyAccess);

+    if (rc == Success) 

+    {

+	FreeResource(stuff->id, RT_NONE);

+	return (client->noClientException);

+    }

+    else 

+    {

+	client->errorValue = stuff->id;

+	return (rc == BadValue) ? BadCursor : rc;

+    }

+}

+

+int

+ProcQueryBestSize (ClientPtr client)

+{

+    xQueryBestSizeReply	reply;

+    DrawablePtr pDraw;

+    ScreenPtr pScreen;

+    int rc;

+    REQUEST(xQueryBestSizeReq);

+    REQUEST_SIZE_MATCH(xQueryBestSizeReq);

+

+    if ((stuff->class != CursorShape) && 

+	(stuff->class != TileShape) && 

+	(stuff->class != StippleShape))

+    {

+	client->errorValue = stuff->class;

+        return(BadValue);

+    }

+

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

+			   DixGetAttrAccess);

+    if (rc != Success)

+	return rc;

+    if (stuff->class != CursorShape && pDraw->type == UNDRAWABLE_WINDOW)

+	return (BadMatch);

+    pScreen = pDraw->pScreen;

+    rc = XaceHook(XACE_SCREEN_ACCESS, client, pScreen, DixGetAttrAccess);

+    if (rc != Success)

+	return rc;

+    (* pScreen->QueryBestSize)(stuff->class, &stuff->width,

+			       &stuff->height, pScreen);

+    memset(&reply, 0, sizeof(xQueryBestSizeReply));

+    reply.type = X_Reply;

+    reply.length = 0;

+    reply.sequenceNumber = client->sequence;

+    reply.width = stuff->width;

+    reply.height = stuff->height;

+    WriteReplyToClient(client, sizeof(xQueryBestSizeReply), &reply);

+    return (client->noClientException);

+}

+

+

+int

+ProcSetScreenSaver (ClientPtr client)

+{

+    int rc, i, blankingOption, exposureOption;

+    REQUEST(xSetScreenSaverReq);

+    REQUEST_SIZE_MATCH(xSetScreenSaverReq);

+

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

+	rc = XaceHook(XACE_SCREENSAVER_ACCESS, client, screenInfo.screens[i],

+		      DixSetAttrAccess);

+	if (rc != Success)

+	    return rc;

+    }

+

+    blankingOption = stuff->preferBlank;

+    if ((blankingOption != DontPreferBlanking) &&

+        (blankingOption != PreferBlanking) &&

+        (blankingOption != DefaultBlanking))

+    {

+	client->errorValue = blankingOption;

+        return BadValue;

+    }

+    exposureOption = stuff->allowExpose;

+    if ((exposureOption != DontAllowExposures) &&

+        (exposureOption != AllowExposures) &&

+        (exposureOption != DefaultExposures))

+    {

+	client->errorValue = exposureOption;

+        return BadValue;

+    }

+    if (stuff->timeout < -1)

+    {

+	client->errorValue = stuff->timeout;

+        return BadValue;

+    }

+    if (stuff->interval < -1)

+    {

+	client->errorValue = stuff->interval;

+        return BadValue;

+    }

+

+    if (blankingOption == DefaultBlanking)

+	ScreenSaverBlanking = defaultScreenSaverBlanking;

+    else

+	ScreenSaverBlanking = blankingOption; 

+    if (exposureOption == DefaultExposures)

+	ScreenSaverAllowExposures = defaultScreenSaverAllowExposures;

+    else

+	ScreenSaverAllowExposures = exposureOption;

+

+    if (stuff->timeout >= 0)

+	ScreenSaverTime = stuff->timeout * MILLI_PER_SECOND;

+    else 

+	ScreenSaverTime = defaultScreenSaverTime;

+    if (stuff->interval >= 0)

+	ScreenSaverInterval = stuff->interval * MILLI_PER_SECOND;

+    else

+	ScreenSaverInterval = defaultScreenSaverInterval;

+

+    SetScreenSaverTimer();

+    return (client->noClientException);

+}

+

+int

+ProcGetScreenSaver(ClientPtr client)

+{

+    xGetScreenSaverReply rep;

+    int rc, i;

+    REQUEST_SIZE_MATCH(xReq);

+

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

+	rc = XaceHook(XACE_SCREENSAVER_ACCESS, client, screenInfo.screens[i],

+		      DixGetAttrAccess);

+	if (rc != Success)

+	    return rc;

+    }

+

+    rep.type = X_Reply;

+    rep.length = 0;

+    rep.sequenceNumber = client->sequence;

+    rep.timeout = ScreenSaverTime / MILLI_PER_SECOND;

+    rep.interval = ScreenSaverInterval / MILLI_PER_SECOND;

+    rep.preferBlanking = ScreenSaverBlanking;

+    rep.allowExposures = ScreenSaverAllowExposures;

+    WriteReplyToClient(client, sizeof(xGetScreenSaverReply), &rep);

+    return (client->noClientException);

+}

+

+int

+ProcChangeHosts(ClientPtr client)

+{

+    REQUEST(xChangeHostsReq);

+    int result;

+

+    REQUEST_FIXED_SIZE(xChangeHostsReq, stuff->hostLength);

+

+    if(stuff->mode == HostInsert)

+	result = AddHost(client, (int)stuff->hostFamily,

+			 stuff->hostLength, (pointer)&stuff[1]);

+    else if (stuff->mode == HostDelete)

+	result = RemoveHost(client, (int)stuff->hostFamily, 

+			    stuff->hostLength, (pointer)&stuff[1]);  

+    else

+    {

+	client->errorValue = stuff->mode;

+        return BadValue;

+    }

+    if (!result)

+	result = client->noClientException;

+    return (result);

+}

+

+int

+ProcListHosts(ClientPtr client)

+{

+    xListHostsReply reply;

+    int	len, nHosts, result;

+    pointer	pdata;

+    /* REQUEST(xListHostsReq); */

+

+    REQUEST_SIZE_MATCH(xListHostsReq);

+

+    /* untrusted clients can't list hosts */

+    result = XaceHook(XACE_SERVER_ACCESS, client, DixReadAccess);

+    if (result != Success)

+	return result;

+

+    result = GetHosts(&pdata, &nHosts, &len, &reply.enabled);

+    if (result != Success)

+	return(result);

+    reply.type = X_Reply;

+    reply.sequenceNumber = client->sequence;

+    reply.nHosts = nHosts;

+    reply.length = bytes_to_int32(len);

+    WriteReplyToClient(client, sizeof(xListHostsReply), &reply);

+    if (nHosts)

+    {

+	client->pSwapReplyFunc = (ReplySwapPtr) SLHostsExtend;

+	WriteSwappedDataToClient(client, len, pdata);

+    }

+    xfree(pdata);

+    return (client->noClientException);

+}

+

+int

+ProcChangeAccessControl(ClientPtr client)

+{

+    int result;

+    REQUEST(xSetAccessControlReq);

+

+    REQUEST_SIZE_MATCH(xSetAccessControlReq);

+    if ((stuff->mode != EnableAccess) && (stuff->mode != DisableAccess))

+    {

+	client->errorValue = stuff->mode;

+        return BadValue;

+    }

+    result = ChangeAccessControl(client, stuff->mode == EnableAccess);

+    if (!result)

+	result = client->noClientException;

+    return (result);

+}

+

+/*********************

+ * CloseDownRetainedResources

+ *

+ *    Find all clients that are gone and have terminated in RetainTemporary 

+ *    and destroy their resources.

+ *********************/

+

+static void

+CloseDownRetainedResources(void)

+{

+    int i;

+    ClientPtr client;

+

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

+    {

+        client = clients[i];

+        if (client && (client->closeDownMode == RetainTemporary)

+	    && (client->clientGone))

+	    CloseDownClient(client);

+    }

+}

+

+int

+ProcKillClient(ClientPtr client)

+{

+    REQUEST(xResourceReq);

+    ClientPtr killclient;

+    int rc;

+

+    REQUEST_SIZE_MATCH(xResourceReq);

+    if (stuff->id == AllTemporary)

+    {

+	CloseDownRetainedResources();

+        return (client->noClientException);

+    }

+

+    rc = dixLookupClient(&killclient, stuff->id, client, DixDestroyAccess);

+    if (rc == Success) {

+	CloseDownClient(killclient);

+	/* if an LBX proxy gets killed, isItTimeToYield will be set */

+	if (isItTimeToYield || (client == killclient))

+	{

+	    /* force yield and return Success, so that Dispatch()

+	     * doesn't try to touch client

+	     */

+	    isItTimeToYield = TRUE;

+	    return (Success);

+	}

+	return (client->noClientException);

+    }

+    else

+	return rc;

+}

+

+int

+ProcSetFontPath(ClientPtr client)

+{

+    unsigned char *ptr;

+    unsigned long nbytes, total;

+    long nfonts;

+    int n, result;

+    int error;

+    REQUEST(xSetFontPathReq);

+    

+    REQUEST_AT_LEAST_SIZE(xSetFontPathReq);

+    

+    nbytes = (client->req_len << 2) - sizeof(xSetFontPathReq);

+    total = nbytes;

+    ptr = (unsigned char *)&stuff[1];

+    nfonts = stuff->nFonts;

+    while (--nfonts >= 0)

+    {

+	if ((total == 0) || (total < (n = (*ptr + 1))))

+	    return(BadLength);

+	total -= n;

+	ptr += n;

+    }

+    if (total >= 4)

+	return(BadLength);

+    result = SetFontPath(client, stuff->nFonts, (unsigned char *)&stuff[1],

+			 &error);

+    if (!result)

+    {

+	result = client->noClientException;

+	client->errorValue = error;

+    }

+    return (result);

+}

+

+int

+ProcGetFontPath(ClientPtr client)

+{

+    xGetFontPathReply reply;

+    int rc, stringLens, numpaths;

+    unsigned char *bufferStart;

+    /* REQUEST (xReq); */

+

+    REQUEST_SIZE_MATCH(xReq);

+    rc = GetFontPath(client, &numpaths, &stringLens, &bufferStart);

+    if (rc != Success)

+	return rc;

+

+    reply.type = X_Reply;

+    reply.sequenceNumber = client->sequence;

+    reply.length = bytes_to_int32(stringLens + numpaths);

+    reply.nPaths = numpaths;

+

+    WriteReplyToClient(client, sizeof(xGetFontPathReply), &reply);

+    if (stringLens || numpaths)

+	(void)WriteToClient(client, stringLens + numpaths, (char *)bufferStart);

+    return(client->noClientException);

+}

+

+int

+ProcChangeCloseDownMode(ClientPtr client)

+{

+    int rc;

+    REQUEST(xSetCloseDownModeReq);

+    REQUEST_SIZE_MATCH(xSetCloseDownModeReq);

+

+    rc = XaceHook(XACE_CLIENT_ACCESS, client, client, DixManageAccess);

+    if (rc != Success)

+	return rc;

+

+    if ((stuff->mode == AllTemporary) ||

+	(stuff->mode == RetainPermanent) ||

+	(stuff->mode == RetainTemporary))

+    {

+	client->closeDownMode = stuff->mode;

+	return (client->noClientException);

+    }

+    else   

+    {

+	client->errorValue = stuff->mode;

+	return (BadValue);

+    }

+}

+

+int ProcForceScreenSaver(ClientPtr client)

+{    

+    int rc;

+    REQUEST(xForceScreenSaverReq);

+

+    REQUEST_SIZE_MATCH(xForceScreenSaverReq);

+    

+    if ((stuff->mode != ScreenSaverReset) && 

+	(stuff->mode != ScreenSaverActive))

+    {

+	client->errorValue = stuff->mode;

+        return BadValue;

+    }

+    rc = dixSaveScreens(client, SCREEN_SAVER_FORCER, (int)stuff->mode);

+    if (rc != Success)

+	return rc;

+    return client->noClientException;

+}

+

+int ProcNoOperation(ClientPtr client)

+{

+    REQUEST_AT_LEAST_SIZE(xReq);

+    

+    /* noop -- don't do anything */

+    return(client->noClientException);

+}

+

+void

+InitProcVectors(void)

+{

+    int i;

+    for (i = 0; i<256; i++)

+    {

+	if(!ProcVector[i])

+	{

+            ProcVector[i] = SwappedProcVector[i] = ProcBadRequest;

+	    ReplySwapVector[i] = ReplyNotSwappd;

+	}

+    }

+    for(i = LASTEvent; i < 128; i++)

+    {

+	EventSwapVector[i] = NotImplemented;

+    }

+    

+}

+

+/**********************

+ * CloseDownClient

+ *

+ *  Client can either mark his resources destroy or retain.  If retained and

+ *  then killed again, the client is really destroyed.

+ *********************/

+

+char dispatchExceptionAtReset = DE_RESET;

+

+void

+CloseDownClient(ClientPtr client)

+{

+    Bool really_close_down = client->clientGone ||

+			     client->closeDownMode == DestroyAll;

+

+    if (!client->clientGone)

+    {

+	/* ungrab server if grabbing client dies */

+	if (grabState != GrabNone && grabClient == client)

+	{

+	    UngrabServer(client);

+	}

+	BITCLEAR(grabWaiters, client->index);

+	DeleteClientFromAnySelections(client);

+	ReleaseActiveGrabs(client);

+	DeleteClientFontStuff(client);

+	if (!really_close_down)

+	{

+	    /*  This frees resources that should never be retained

+	     *  no matter what the close down mode is.  Actually we

+	     *  could do this unconditionally, but it's probably

+	     *  better not to traverse all the client's resources

+	     *  twice (once here, once a few lines down in

+	     *  FreeClientResources) in the common case of

+	     *  really_close_down == TRUE.

+	     */

+	    FreeClientNeverRetainResources(client);

+	    client->clientState = ClientStateRetained;

+  	    if (ClientStateCallback)

+            {

+		NewClientInfoRec clientinfo;

+

+		clientinfo.client = client; 

+		clientinfo.prefix = (xConnSetupPrefix *)NULL;  

+		clientinfo.setup = (xConnSetup *) NULL;

+		CallCallbacks((&ClientStateCallback), (pointer)&clientinfo);

+            } 

+	}

+	client->clientGone = TRUE;  /* so events aren't sent to client */

+	if (ClientIsAsleep(client))

+	    ClientSignal (client);

+	ProcessWorkQueueZombies();

+	CloseDownConnection(client);

+

+	/* If the client made it to the Running stage, nClients has

+	 * been incremented on its behalf, so we need to decrement it

+	 * now.  If it hasn't gotten to Running, nClients has *not*

+	 * been incremented, so *don't* decrement it.

+	 */

+	if (client->clientState != ClientStateInitial &&

+	    client->clientState != ClientStateAuthenticating )

+	{

+	    --nClients;

+	}

+    }

+

+    if (really_close_down)

+    {

+	if (client->clientState == ClientStateRunning && nClients == 0)

+	    dispatchException |= dispatchExceptionAtReset;

+

+	client->clientState = ClientStateGone;

+	if (ClientStateCallback)

+	{

+	    NewClientInfoRec clientinfo;

+

+	    clientinfo.client = client; 

+	    clientinfo.prefix = (xConnSetupPrefix *)NULL;  

+	    clientinfo.setup = (xConnSetup *) NULL;

+	    CallCallbacks((&ClientStateCallback), (pointer)&clientinfo);

+	} 	    

+	FreeClientResources(client);

+#ifdef XSERVER_DTRACE

+	XSERVER_CLIENT_DISCONNECT(client->index);

+#endif	

+	if (client->index < nextFreeClientID)

+	    nextFreeClientID = client->index;

+	clients[client->index] = NullClient;

+	SmartLastClient = NullClient;

+	dixFreePrivates(client->devPrivates);

+	xfree(client);

+

+	while (!clients[currentMaxClients-1])

+	    currentMaxClients--;

+    }

+}

+

+static void

+KillAllClients(void)

+{

+    int i;

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

+        if (clients[i]) {

+            /* Make sure Retained clients are released. */

+            clients[i]->closeDownMode = DestroyAll;

+            CloseDownClient(clients[i]);     

+        }

+}

+

+void InitClient(ClientPtr client, int i, pointer ospriv)

+{

+    memset(client, 0, sizeof(*client));

+    client->index = i;

+    client->clientAsMask = ((Mask)i) << CLIENTOFFSET;

+    client->closeDownMode = i ? DestroyAll : RetainPermanent;

+    client->requestVector = InitialVector;

+    client->osPrivate = ospriv;

+    QueryMinMaxKeyCodes(&client->minKC,&client->maxKC);

+    client->smart_start_tick = SmartScheduleTime;

+    client->smart_stop_tick = SmartScheduleTime;

+    client->smart_check_tick = SmartScheduleTime;

+}

+

+/************************

+ * int NextAvailableClient(ospriv)

+ *

+ * OS dependent portion can't assign client id's because of CloseDownModes.

+ * Returns NULL if there are no free clients.

+ *************************/

+

+ClientPtr NextAvailableClient(pointer ospriv)

+{

+    int i;

+    ClientPtr client;

+    xReq data;

+

+    i = nextFreeClientID;

+    if (i == MAXCLIENTS)

+	return (ClientPtr)NULL;

+    clients[i] = client = xalloc(sizeof(ClientRec));

+    if (!client)

+	return (ClientPtr)NULL;

+    InitClient(client, i, ospriv);

+    if (!InitClientResources(client))

+    {

+	xfree(client);

+	return (ClientPtr)NULL;

+    }

+    data.reqType = 1;

+    data.length = bytes_to_int32(sz_xReq + sz_xConnClientPrefix);

+    if (!InsertFakeRequest(client, (char *)&data, sz_xReq))

+    {

+	FreeClientResources(client);

+	xfree(client);

+	return (ClientPtr)NULL;

+    }

+    if (i == currentMaxClients)

+	currentMaxClients++;

+    while ((nextFreeClientID < MAXCLIENTS) && clients[nextFreeClientID])

+	nextFreeClientID++;

+    if (ClientStateCallback)

+    {

+	NewClientInfoRec clientinfo;

+

+        clientinfo.client = client; 

+        clientinfo.prefix = (xConnSetupPrefix *)NULL;  

+        clientinfo.setup = (xConnSetup *) NULL;

+	CallCallbacks((&ClientStateCallback), (pointer)&clientinfo);

+    } 	

+    return(client);

+}

+

+int

+ProcInitialConnection(ClientPtr client)

+{

+    REQUEST(xReq);

+    xConnClientPrefix *prefix;

+    int whichbyte = 1;

+

+    prefix = (xConnClientPrefix *)((char *)stuff + sz_xReq);

+    if ((prefix->byteOrder != 'l') && (prefix->byteOrder != 'B'))

+	return (client->noClientException = -1);

+    if (((*(char *) &whichbyte) && (prefix->byteOrder == 'B')) ||

+	(!(*(char *) &whichbyte) && (prefix->byteOrder == 'l')))

+    {

+	client->swapped = TRUE;

+	SwapConnClientPrefix(prefix);

+    }

+    stuff->reqType = 2;

+    stuff->length += bytes_to_int32(prefix->nbytesAuthProto) +

+		     bytes_to_int32(prefix->nbytesAuthString);

+    if (client->swapped)

+    {

+	swaps(&stuff->length, whichbyte);

+    }

+    ResetCurrentRequest(client);

+    return (client->noClientException);

+}

+

+static int

+SendConnSetup(ClientPtr client, char *reason)

+{

+    xWindowRoot *root;

+    int i;

+    int numScreens;

+    char* lConnectionInfo;

+    xConnSetupPrefix* lconnSetupPrefix;

+

+    if (reason)

+    {

+	xConnSetupPrefix csp;

+

+	csp.success = xFalse;

+	csp.lengthReason = strlen(reason);

+	csp.length = bytes_to_int32(csp.lengthReason);

+	csp.majorVersion = X_PROTOCOL;

+	csp.minorVersion = X_PROTOCOL_REVISION;

+	if (client->swapped)

+	    WriteSConnSetupPrefix(client, &csp);

+	else

+	    (void)WriteToClient(client, sz_xConnSetupPrefix, (char *) &csp);

+        (void)WriteToClient(client, (int)csp.lengthReason, reason);

+	return (client->noClientException = -1);

+    }

+

+    numScreens = screenInfo.numScreens;

+    lConnectionInfo = ConnectionInfo;

+    lconnSetupPrefix = &connSetupPrefix;

+

+    /* We're about to start speaking X protocol back to the client by

+     * sending the connection setup info.  This means the authorization

+     * step is complete, and we can count the client as an

+     * authorized one.

+     */

+    nClients++;

+

+    client->requestVector = client->swapped ? SwappedProcVector : ProcVector;

+    client->sequence = 0;

+    ((xConnSetup *)lConnectionInfo)->ridBase = client->clientAsMask;

+    ((xConnSetup *)lConnectionInfo)->ridMask = RESOURCE_ID_MASK;

+#ifdef MATCH_CLIENT_ENDIAN

+    ((xConnSetup *)lConnectionInfo)->imageByteOrder = ClientOrder (client);

+    ((xConnSetup *)lConnectionInfo)->bitmapBitOrder = ClientOrder (client);

+#endif

+    /* fill in the "currentInputMask" */

+    root = (xWindowRoot *)(lConnectionInfo + connBlockScreenStart);

+#ifdef PANORAMIX

+    if (noPanoramiXExtension)

+	numScreens = screenInfo.numScreens;

+    else 

+        numScreens = ((xConnSetup *)ConnectionInfo)->numRoots;

+#endif

+

+    for (i=0; i<numScreens; i++) 

+    {

+	unsigned int j;

+	xDepth *pDepth;

+

+        root->currentInputMask = WindowTable[i]->eventMask |

+			         wOtherEventMasks (WindowTable[i]);

+	pDepth = (xDepth *)(root + 1);

+	for (j = 0; j < root->nDepths; j++)

+	{

+	    pDepth = (xDepth *)(((char *)(pDepth + 1)) +

+				pDepth->nVisuals * sizeof(xVisualType));

+	}

+	root = (xWindowRoot *)pDepth;

+    }

+

+    if (client->swapped)

+    {

+	WriteSConnSetupPrefix(client, lconnSetupPrefix);

+	WriteSConnectionInfo(client,

+			     (unsigned long)(lconnSetupPrefix->length << 2),

+			     lConnectionInfo);

+    }

+    else

+    {

+	(void)WriteToClient(client, sizeof(xConnSetupPrefix),

+			    (char *) lconnSetupPrefix);

+	(void)WriteToClient(client, (int)(lconnSetupPrefix->length << 2),

+			    lConnectionInfo);

+    }

+    client->clientState = ClientStateRunning;

+    if (ClientStateCallback)

+    {

+	NewClientInfoRec clientinfo;

+

+        clientinfo.client = client; 

+        clientinfo.prefix = lconnSetupPrefix;  

+        clientinfo.setup = (xConnSetup *)lConnectionInfo;

+	CallCallbacks((&ClientStateCallback), (pointer)&clientinfo);

+    } 	

+    return (client->noClientException);

+}

+

+int

+ProcEstablishConnection(ClientPtr client)

+{

+    char *reason, *auth_proto, *auth_string;

+    xConnClientPrefix *prefix;

+    REQUEST(xReq);

+

+    prefix = (xConnClientPrefix *)((char *)stuff + sz_xReq);

+    auth_proto = (char *)prefix + sz_xConnClientPrefix;

+    auth_string = auth_proto + pad_to_int32(prefix->nbytesAuthProto);

+    if ((prefix->majorVersion != X_PROTOCOL) ||

+	(prefix->minorVersion != X_PROTOCOL_REVISION))

+	reason = "Protocol version mismatch";

+    else

+	reason = ClientAuthorized(client,

+				  (unsigned short)prefix->nbytesAuthProto,

+				  auth_proto,

+				  (unsigned short)prefix->nbytesAuthString,

+				  auth_string);

+    /*

+     * If Kerberos is being used for this client, the clientState

+     * will be set to ClientStateAuthenticating at this point.

+     * More messages need to be exchanged among the X server, Kerberos

+     * server, and client to figure out if everyone is authorized.

+     * So we don't want to send the connection setup info yet, since

+     * the auth step isn't really done.

+     */

+    if (client->clientState == ClientStateCheckingSecurity)

+	client->clientState = ClientStateCheckedSecurity;

+    else if (client->clientState != ClientStateAuthenticating)

+	return(SendConnSetup(client, reason));

+    return(client->noClientException);

+}

+

+void

+SendErrorToClient(ClientPtr client, unsigned majorCode, unsigned minorCode, 

+                  XID resId, int errorCode)

+{

+    xError rep;

+

+    memset(&rep, 0, sizeof(xError));

+    rep.type = X_Error;

+    rep.sequenceNumber = client->sequence;

+    rep.errorCode = errorCode;

+    rep.majorCode = majorCode;

+    rep.minorCode = minorCode;

+    rep.resourceID = resId;

+

+    WriteEventsToClient (client, 1, (xEvent *)&rep);

+}

+

+void

+MarkClientException(ClientPtr client)

+{

+    client->noClientException = -1;

+}

+

+/*

+ * This array encodes the answer to the question "what is the log base 2

+ * of the number of pixels that fit in a scanline pad unit?"

+ * Note that ~0 is an invalid entry (mostly for the benefit of the reader).

+ */

+static int answer[6][4] = {

+	/* pad   pad   pad     pad*/

+	/*  8     16    32    64 */

+

+	{   3,     4,    5 ,   6 },	/* 1 bit per pixel */

+	{   1,     2,    3 ,   4 },	/* 4 bits per pixel */

+	{   0,     1,    2 ,   3 },	/* 8 bits per pixel */

+	{   ~0,    0,    1 ,   2 },	/* 16 bits per pixel */

+	{   ~0,    ~0,   0 ,   1 },	/* 24 bits per pixel */

+	{   ~0,    ~0,   0 ,   1 }	/* 32 bits per pixel */

+};

+

+/*

+ * This array gives the answer to the question "what is the first index for

+ * the answer array above given the number of bits per pixel?"

+ * Note that ~0 is an invalid entry (mostly for the benefit of the reader).

+ */

+static int indexForBitsPerPixel[ 33 ] = {

+	~0, 0, ~0, ~0,	/* 1 bit per pixel */

+	1, ~0, ~0, ~0,	/* 4 bits per pixel */

+	2, ~0, ~0, ~0,	/* 8 bits per pixel */

+	~0,~0, ~0, ~0,

+	3, ~0, ~0, ~0,	/* 16 bits per pixel */

+	~0,~0, ~0, ~0,

+	4, ~0, ~0, ~0,	/* 24 bits per pixel */

+	~0,~0, ~0, ~0,

+	5		/* 32 bits per pixel */

+};

+

+/*

+ * This array gives the bytesperPixel value for cases where the number

+ * of bits per pixel is a multiple of 8 but not a power of 2.

+ */

+static int answerBytesPerPixel[ 33 ] = {

+	~0, 0, ~0, ~0,	/* 1 bit per pixel */

+	0, ~0, ~0, ~0,	/* 4 bits per pixel */

+	0, ~0, ~0, ~0,	/* 8 bits per pixel */

+	~0,~0, ~0, ~0,

+	0, ~0, ~0, ~0,	/* 16 bits per pixel */

+	~0,~0, ~0, ~0,

+	3, ~0, ~0, ~0,	/* 24 bits per pixel */

+	~0,~0, ~0, ~0,

+	0		/* 32 bits per pixel */

+};

+

+/*

+ * This array gives the answer to the question "what is the second index for

+ * the answer array above given the number of bits per scanline pad unit?"

+ * Note that ~0 is an invalid entry (mostly for the benefit of the reader).

+ */

+static int indexForScanlinePad[ 65 ] = {

+	~0, ~0, ~0, ~0,

+	~0, ~0, ~0, ~0,

+	 0, ~0, ~0, ~0,	/* 8 bits per scanline pad unit */

+	~0, ~0, ~0, ~0,

+	 1, ~0, ~0, ~0,	/* 16 bits per scanline pad unit */

+	~0, ~0, ~0, ~0,

+	~0, ~0, ~0, ~0,

+	~0, ~0, ~0, ~0,

+	 2, ~0, ~0, ~0,	/* 32 bits per scanline pad unit */

+	~0, ~0, ~0, ~0,

+	~0, ~0, ~0, ~0,

+	~0, ~0, ~0, ~0,

+	~0, ~0, ~0, ~0,

+	~0, ~0, ~0, ~0,

+	~0, ~0, ~0, ~0,

+	~0, ~0, ~0, ~0,

+	 3		/* 64 bits per scanline pad unit */

+};

+

+/*

+	grow the array of screenRecs if necessary.

+	call the device-supplied initialization procedure

+with its screen number, a pointer to its ScreenRec, argc, and argv.

+	return the number of successfully installed screens.

+

+*/

+

+int

+AddScreen(

+    Bool	(* pfnInit)(

+	int /*index*/,

+	ScreenPtr /*pScreen*/,

+	int /*argc*/,

+	char ** /*argv*/

+		),

+    int argc,

+    char **argv)

+{

+

+    int i;

+    int scanlinepad, format, depth, bitsPerPixel, j, k;

+    ScreenPtr pScreen;

+

+    i = screenInfo.numScreens;

+    if (i == MAXSCREENS)

+	return -1;

+

+    pScreen = (ScreenPtr) xcalloc(1, sizeof(ScreenRec));

+    if (!pScreen)

+	return -1;

+

+    pScreen->devPrivates = NULL;

+    pScreen->myNum = i;

+    pScreen->totalPixmapSize = BitmapBytePad(sizeof(PixmapRec)*8);

+    pScreen->ClipNotify = 0;	/* for R4 ddx compatibility */

+    pScreen->CreateScreenResources = 0;

+

+    /*

+     * This loop gets run once for every Screen that gets added,

+     * but thats ok.  If the ddx layer initializes the formats

+     * one at a time calling AddScreen() after each, then each

+     * iteration will make it a little more accurate.  Worst case

+     * we do this loop N * numPixmapFormats where N is # of screens.

+     * Anyway, this must be called after InitOutput and before the

+     * screen init routine is called.

+     */

+    for (format=0; format<screenInfo.numPixmapFormats; format++)

+    {

+	depth = screenInfo.formats[format].depth;

+	bitsPerPixel = screenInfo.formats[format].bitsPerPixel;

+	scanlinepad = screenInfo.formats[format].scanlinePad;

+	j = indexForBitsPerPixel[ bitsPerPixel ];

+	k = indexForScanlinePad[ scanlinepad ];

+	PixmapWidthPaddingInfo[ depth ].padPixelsLog2 = answer[j][k];

+	PixmapWidthPaddingInfo[ depth ].padRoundUp =

+	    (scanlinepad/bitsPerPixel) - 1;

+	j = indexForBitsPerPixel[ 8 ]; /* bits per byte */

+	PixmapWidthPaddingInfo[ depth ].padBytesLog2 = answer[j][k];

+	PixmapWidthPaddingInfo[ depth ].bitsPerPixel = bitsPerPixel;

+	if (answerBytesPerPixel[bitsPerPixel])

+	{

+	    PixmapWidthPaddingInfo[ depth ].notPower2 = 1;

+	    PixmapWidthPaddingInfo[ depth ].bytesPerPixel =

+		answerBytesPerPixel[bitsPerPixel];

+	}

+	else

+	{

+	    PixmapWidthPaddingInfo[ depth ].notPower2 = 0;

+	}

+    }

+

+    /* This is where screen specific stuff gets initialized.  Load the

+       screen structure, call the hardware, whatever.

+       This is also where the default colormap should be allocated and

+       also pixel values for blackPixel, whitePixel, and the cursor

+       Note that InitScreen is NOT allowed to modify argc, argv, or

+       any of the strings pointed to by argv.  They may be passed to

+       multiple screens.

+    */

+    pScreen->rgf = ~0L;  /* there are no scratch GCs yet*/

+    WindowTable[i] = NullWindow;

+    screenInfo.screens[i] = pScreen;

+    screenInfo.numScreens++;

+    if (!(*pfnInit)(i, pScreen, argc, argv))

+    {

+	dixFreePrivates(pScreen->devPrivates);

+	xfree(pScreen);

+	screenInfo.numScreens--;

+	return -1;

+    }

+    return i;

+}

diff --git a/xorg-server/dix/events.c b/xorg-server/dix/events.c
index 93ca66ac7..1a78c5499 100644
--- a/xorg-server/dix/events.c
+++ b/xorg-server/dix/events.c
@@ -74,38 +74,28 @@ Equipment Corporation.
 

 ******************************************************************/

 

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

-

-Copyright 2003-2005 Sun Microsystems, Inc.

-

-All rights reserved.

-

-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, and/or sell copies of the Software, and to permit persons

-to whom the Software is furnished to do so, provided that the above

-copyright notice(s) and this permission notice appear in all copies of

-the Software and that both the above copyright notice(s) and this

-permission notice appear in supporting documentation.

-

-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

-OF THIRD PARTY RIGHTS. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR

-HOLDERS INCLUDED IN THIS NOTICE BE LIABLE FOR ANY CLAIM, OR 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.

-

-Except as contained in this notice, the name of a copyright holder

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

-or other dealings in this Software without prior written authorization

-of the copyright holder.

-

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

+/*

+ * Copyright © 2003-2005 Sun Microsystems, Inc.  All rights reserved.

+ *

+ * 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 (including the next

+ * paragraph) 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 AUTHORS OR COPYRIGHT HOLDERS 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.

+ */

 

 /** @file events.c

  * This file handles event delivery and a big part of the server-side protocol

diff --git a/xorg-server/dix/resource.c b/xorg-server/dix/resource.c
index d3641df8d..e1fdad4fb 100644
--- a/xorg-server/dix/resource.c
+++ b/xorg-server/dix/resource.c
@@ -76,29 +76,23 @@ Equipment Corporation.
  * Copyright 2005-2006 Sun Microsystems, Inc.  All rights reserved.
  *
  * 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, and/or sell copies of the Software, and to permit persons
- * to whom the Software is furnished to do so, provided that the above
- * copyright notice(s) and this permission notice appear in all copies of
- * the Software and that both the above copyright notice(s) and this
- * permission notice appear in supporting documentation.
- * 
- * 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
- * OF THIRD PARTY RIGHTS. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
- * HOLDERS INCLUDED IN THIS NOTICE BE LIABLE FOR ANY CLAIM, OR 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.
- * 
- * Except as contained in this notice, the name of a copyright holder
- * shall not be used in advertising or otherwise to promote the sale, use
- * or other dealings in this Software without prior written authorization
- * of the copyright holder.
+ * 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 (including the next
+ * paragraph) 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 AUTHORS OR COPYRIGHT HOLDERS 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.
  */
 
 /*	Routines to manage various kinds of resources:
diff --git a/xorg-server/fb/fbcmap.c b/xorg-server/fb/fbcmap.c
index 207c6aefc..2ff3234b5 100644
--- a/xorg-server/fb/fbcmap.c
+++ b/xorg-server/fb/fbcmap.c
@@ -1,32 +1,25 @@
-/************************************************************
-Copyright 1987 by Sun Microsystems, Inc. Mountain View, CA.
-
-                    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 no-
-tice  appear  in all copies and that both that copyright no-
-tice and this permission notice appear in  supporting  docu-
-mentation,  and  that the names of Sun or X Consortium
-not be used in advertising or publicity pertaining to 
-distribution  of  the software  without specific prior 
-written permission. Sun and X Consortium make no 
-representations about the suitability of this software for 
-any purpose. It is provided "as is" without any express or 
-implied warranty.
-
-SUN DISCLAIMS ALL WARRANTIES WITH REGARD TO  THIS  SOFTWARE,
-INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FIT-
-NESS FOR A PARTICULAR PURPOSE. IN NO EVENT SHALL SUN BE  LI-
-ABLE  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.
-
-********************************************************/
-
+/*
+ * Copyright © 1987 Sun Microsystems, Inc.  All rights reserved.
+ *
+ * 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 (including the next
+ * paragraph) 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 AUTHORS OR COPYRIGHT HOLDERS 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.
+ */
 
 #ifdef HAVE_DIX_CONFIG_H
 #include <dix-config.h>
diff --git a/xorg-server/fb/fbcmap_mi.c b/xorg-server/fb/fbcmap_mi.c
index 188decd4c..d75a38fa2 100644
--- a/xorg-server/fb/fbcmap_mi.c
+++ b/xorg-server/fb/fbcmap_mi.c
@@ -1,32 +1,25 @@
-/************************************************************
-Copyright 1987 by Sun Microsystems, Inc. Mountain View, CA.
-
-                    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 no-
-tice  appear  in all copies and that both that copyright no-
-tice and this permission notice appear in  supporting  docu-
-mentation,  and  that the names of Sun or X Consortium
-not be used in advertising or publicity pertaining to 
-distribution  of  the software  without specific prior 
-written permission. Sun and X Consortium make no 
-representations about the suitability of this software for 
-any purpose. It is provided "as is" without any express or 
-implied warranty.
-
-SUN DISCLAIMS ALL WARRANTIES WITH REGARD TO  THIS  SOFTWARE,
-INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FIT-
-NESS FOR A PARTICULAR PURPOSE. IN NO EVENT SHALL SUN BE  LI-
-ABLE  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.
-
-********************************************************/
-
+/*
+ * Copyright © 1987 Sun Microsystems, Inc.  All rights reserved.
+ *
+ * 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 (including the next
+ * paragraph) 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 AUTHORS OR COPYRIGHT HOLDERS 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.
+ */
 
 /**
  * This version of fbcmap.c is implemented in terms of mi functions.
diff --git a/xorg-server/glx/glxdriswrast.c b/xorg-server/glx/glxdriswrast.c
index 5ff18a574..ece3426a3 100644
--- a/xorg-server/glx/glxdriswrast.c
+++ b/xorg-server/glx/glxdriswrast.c
@@ -1,567 +1,568 @@
-/*
- * Copyright © 2008 George Sapountzis <gsap7@yahoo.gr>
- * Copyright © 2008 Red Hat, Inc
- *
- * 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, and that the name of the
- * copyright holders not be used in advertising or publicity
- * pertaining to distribution of the software without specific,
- * written prior permission.  The copyright holders make no
- * representations about the suitability of this software for any
- * purpose.  It is provided "as is" without express or implied
- * warranty.
- *
- * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS
- * SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
- * FITNESS, IN NO EVENT SHALL THE COPYRIGHT HOLDERS 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>
-#else
-
-#include "glheader.h"
-
-#endif
-
-#include <stdint.h>
-#include <stdio.h>
-#include <string.h>
-#include <errno.h>
-#include <sys/time.h>
-#include <dlfcn.h>
-
-#include <GL/gl.h>
-#include <GL/internal/dri_interface.h>
-#include <GL/glxtokens.h>
-
-#include "scrnintstr.h"
-#include "pixmapstr.h"
-#include "gcstruct.h"
-#include "os.h"
-
-#include "glxserver.h"
-#include "glxutil.h"
-#include "glxdricommon.h"
-
-#include "g_disptab.h"
-#include "glapitable.h"
-#include "glapi.h"
-#include "glthread.h"
-#include "dispatch.h"
-#include "extension_string.h"
-
-/* RTLD_LOCAL is not defined on Cygwin */
-#ifdef __CYGWIN__
-#ifndef RTLD_LOCAL
-#define RTLD_LOCAL 0
-#endif
-#endif
-
-#ifdef _MSC_VER
-#define dlerror() "Getting loadlibrary error string not implemented"
-#endif
-
-typedef struct __GLXDRIscreen   __GLXDRIscreen;
-typedef struct __GLXDRIcontext  __GLXDRIcontext;
-typedef struct __GLXDRIdrawable __GLXDRIdrawable;
-
-struct __GLXDRIscreen {
-    __GLXscreen		 base;
-    __DRIscreen		*driScreen;
-    void		*driver;
-
-    const __DRIcoreExtension *core;
-    const __DRIswrastExtension *swrast;
-    const __DRIcopySubBufferExtension *copySubBuffer;
-    const __DRItexBufferExtension *texBuffer;
-};
-
-struct __GLXDRIcontext {
-    __GLXcontext	 base;
-    __DRIcontext	*driContext;
-};
-
-struct __GLXDRIdrawable {
-    __GLXdrawable	 base;
-    __DRIdrawable	*driDrawable;
-    __GLXDRIscreen	*screen;
-
-    GCPtr gc;		/* scratch GC for span drawing */
-    GCPtr swapgc;	/* GC for swapping the color buffers */
-};
-
-static void
-__glXDRIdrawableDestroy(__GLXdrawable *drawable)
-{
-    __GLXDRIdrawable *private = (__GLXDRIdrawable *) drawable;
-    const __DRIcoreExtension *core = private->screen->core;
-
-    (*core->destroyDrawable)(private->driDrawable);
-
-    FreeScratchGC(private->gc);
-    FreeScratchGC(private->swapgc);
-
-    __glXDrawableRelease(drawable);
-
-    xfree(private);
-}
-
-static GLboolean
-__glXDRIdrawableSwapBuffers(__GLXdrawable *drawable)
-{
-    __GLXDRIdrawable *private = (__GLXDRIdrawable *) drawable;
-    const __DRIcoreExtension *core = private->screen->core;
-
-    (*core->swapBuffers)(private->driDrawable);
-
-    return TRUE;
-}
-
-static void
-__glXDRIdrawableCopySubBuffer(__GLXdrawable *basePrivate,
-			       int x, int y, int w, int h)
-{
-    __GLXDRIdrawable *private = (__GLXDRIdrawable *) basePrivate;
-    const __DRIcopySubBufferExtension *copySubBuffer =
-	    private->screen->copySubBuffer;
-
-    if (copySubBuffer)
-	(*copySubBuffer->copySubBuffer)(private->driDrawable, x, y, w, h);
-}
-
-static void
-__glXDRIcontextDestroy(__GLXcontext *baseContext)
-{
-    __GLXDRIcontext *context = (__GLXDRIcontext *) baseContext;
-    __GLXDRIscreen *screen = (__GLXDRIscreen *) context->base.pGlxScreen;
-
-    (*screen->core->destroyContext)(context->driContext);
-    __glXContextDestroy(&context->base);
-    xfree(context);
-}
-
-static int
-__glXDRIcontextMakeCurrent(__GLXcontext *baseContext)
-{
-    __GLXDRIcontext *context = (__GLXDRIcontext *) baseContext;
-    __GLXDRIdrawable *draw = (__GLXDRIdrawable *) baseContext->drawPriv;
-    __GLXDRIdrawable *read = (__GLXDRIdrawable *) baseContext->readPriv;
-    __GLXDRIscreen *screen = (__GLXDRIscreen *) context->base.pGlxScreen;
-
-    return (*screen->core->bindContext)(context->driContext,
-					draw->driDrawable,
-					read->driDrawable);
-}
-
-static int
-__glXDRIcontextLoseCurrent(__GLXcontext *baseContext)
-{
-    __GLXDRIcontext *context = (__GLXDRIcontext *) baseContext;
-    __GLXDRIscreen *screen = (__GLXDRIscreen *) context->base.pGlxScreen;
-
-    return (*screen->core->unbindContext)(context->driContext);
-}
-
-static int
-__glXDRIcontextCopy(__GLXcontext *baseDst, __GLXcontext *baseSrc,
-		    unsigned long mask)
-{
-    __GLXDRIcontext *dst = (__GLXDRIcontext *) baseDst;
-    __GLXDRIcontext *src = (__GLXDRIcontext *) baseSrc;
-    __GLXDRIscreen *screen = (__GLXDRIscreen *) dst->base.pGlxScreen;
-
-    return (*screen->core->copyContext)(dst->driContext,
-					src->driContext, mask);
-}
-
-static int
-__glXDRIcontextForceCurrent(__GLXcontext *baseContext)
-{
-    __GLXDRIcontext *context = (__GLXDRIcontext *) baseContext;
-    __GLXDRIdrawable *draw = (__GLXDRIdrawable *) baseContext->drawPriv;
-    __GLXDRIdrawable *read = (__GLXDRIdrawable *) baseContext->readPriv;
-    __GLXDRIscreen *screen = (__GLXDRIscreen *) context->base.pGlxScreen;
-
-    return (*screen->core->bindContext)(context->driContext,
-					draw->driDrawable,
-					read->driDrawable);
-}
-
-#ifdef __DRI_TEX_BUFFER
-
-static int
-__glXDRIbindTexImage(__GLXcontext *baseContext,
-		     int buffer,
-		     __GLXdrawable *glxPixmap)
-{
-    __GLXDRIdrawable *drawable = (__GLXDRIdrawable *) glxPixmap;
-    const __DRItexBufferExtension *texBuffer = drawable->screen->texBuffer;
-    __GLXDRIcontext *context = (__GLXDRIcontext *) baseContext;
-
-    if (texBuffer == NULL)
-        return Success;
-
-    texBuffer->setTexBuffer(context->driContext,
-			    glxPixmap->target,
-			    drawable->driDrawable);
-
-    return Success;
-}
-
-static int
-__glXDRIreleaseTexImage(__GLXcontext *baseContext,
-			int buffer,
-			__GLXdrawable *pixmap)
-{
-    /* FIXME: Just unbind the texture? */
-    return Success;
-}
-
-#else
-
-static int
-__glXDRIbindTexImage(__GLXcontext *baseContext,
-		     int buffer,
-		     __GLXdrawable *glxPixmap)
-{
-    return Success;
-}
-
-static int
-__glXDRIreleaseTexImage(__GLXcontext *baseContext,
-			int buffer,
-			__GLXdrawable *pixmap)
-{
-    return Success;
-}
-
-#endif
-
-static __GLXtextureFromPixmap __glXDRItextureFromPixmap = {
-    __glXDRIbindTexImage,
-    __glXDRIreleaseTexImage
-};
-
-static void
-__glXDRIscreenDestroy(__GLXscreen *baseScreen)
-{
-    __GLXDRIscreen *screen = (__GLXDRIscreen *) baseScreen;
-
-    (*screen->core->destroyScreen)(screen->driScreen);
-
-#ifdef _MSC_VER
-    FreeLibrary(screen->driver);
-#else
-    dlclose(screen->driver);
-#endif
-
-    __glXScreenDestroy(baseScreen);
-
-    xfree(screen);
-}
-
-static __GLXcontext *
-__glXDRIscreenCreateContext(__GLXscreen *baseScreen,
-			    __GLXconfig *glxConfig,
-			    __GLXcontext *baseShareContext)
-{
-    __GLXDRIscreen *screen = (__GLXDRIscreen *) baseScreen;
-    __GLXDRIcontext *context, *shareContext;
-    __GLXDRIconfig *config = (__GLXDRIconfig *) glxConfig;
-    const __DRIcoreExtension *core = screen->core;
-    __DRIcontext *driShare;
-
-    shareContext = (__GLXDRIcontext *) baseShareContext;
-    if (shareContext)
-	driShare = shareContext->driContext;
-    else
-	driShare = NULL;
-
-    context = xcalloc(1, sizeof *context);
-    if (context == NULL)
-	return NULL;
-
-    context->base.destroy           = __glXDRIcontextDestroy;
-    context->base.makeCurrent       = __glXDRIcontextMakeCurrent;
-    context->base.loseCurrent       = __glXDRIcontextLoseCurrent;
-    context->base.copy              = __glXDRIcontextCopy;
-    context->base.forceCurrent      = __glXDRIcontextForceCurrent;
-    context->base.textureFromPixmap = &__glXDRItextureFromPixmap;
-
-    context->driContext =
-	(*core->createNewContext)(screen->driScreen,
-				  config->driConfig, driShare, context);
-
-    return &context->base;
-}
-
-static void
-glxChangeGC(GCPtr gc, BITS32 mask, CARD32 val)
-{
-    CARD32 v[1];
-    v[0] = val;
-    dixChangeGC(NullClient, gc, mask, v, NULL);
-}
-
-static __GLXdrawable *
-__glXDRIscreenCreateDrawable(__GLXscreen *screen,
-			     DrawablePtr pDraw,
-			     int type,
-			     XID drawId,
-			     __GLXconfig *glxConfig)
-{
-    __GLXDRIscreen *driScreen = (__GLXDRIscreen *) screen;
-    __GLXDRIconfig *config = (__GLXDRIconfig *) glxConfig;
-    __GLXDRIdrawable *private;
-
-    ScreenPtr pScreen = driScreen->base.pScreen;
-
-    private = xcalloc(1, sizeof *private);
-    if (private == NULL)
-	return NULL;
-
-    private->screen = driScreen;
-    if (!__glXDrawableInit(&private->base, screen,
-			   pDraw, type, drawId, glxConfig)) {
-        xfree(private);
-	return NULL;
-    }
-
-    private->base.destroy       = __glXDRIdrawableDestroy;
-    private->base.swapBuffers   = __glXDRIdrawableSwapBuffers;
-    private->base.copySubBuffer = __glXDRIdrawableCopySubBuffer;
-
-    private->gc = CreateScratchGC(pScreen, pDraw->depth);
-    private->swapgc = CreateScratchGC(pScreen, pDraw->depth);
-
-    glxChangeGC(private->gc, GCFunction, GXcopy);
-    glxChangeGC(private->swapgc, GCFunction, GXcopy);
-    glxChangeGC(private->swapgc, GCGraphicsExposures, FALSE);
-
-    private->driDrawable =
-	(*driScreen->swrast->createNewDrawable)(driScreen->driScreen,
-						config->driConfig,
-						private);
-
-    return &private->base;
-}
-
-static void
-swrastGetDrawableInfo(__DRIdrawable *draw,
-		      int *x, int *y, int *w, int *h,
-		      void *loaderPrivate)
-{
-    __GLXDRIdrawable *drawable = loaderPrivate;
-    DrawablePtr pDraw = drawable->base.pDraw;
-
-    *x = pDraw->x;
-    *y = pDraw->x;
-    *w = pDraw->width;
-    *h = pDraw->height;
-}
-
-static void
-swrastPutImage(__DRIdrawable *draw, int op,
-	     int x, int y, int w, int h, char *data,
-	     void *loaderPrivate)
-{
-    __GLXDRIdrawable *drawable = loaderPrivate;
-    DrawablePtr pDraw = drawable->base.pDraw;
-    GCPtr gc;
-
-    switch (op) {
-    case __DRI_SWRAST_IMAGE_OP_DRAW:
-	gc = drawable->gc;
-	break;
-    case __DRI_SWRAST_IMAGE_OP_SWAP:
-	gc = drawable->swapgc;
-	break;
-    default:
-	return;
-    }
-
-    ValidateGC(pDraw, gc);
-
-    gc->ops->PutImage(pDraw, gc, pDraw->depth,
-		      x, y, w, h, 0, ZPixmap, data);
-}
-
-static void
-swrastGetImage(__DRIdrawable *draw,
-	     int x, int y, int w, int h, char *data,
-	     void *loaderPrivate)
-{
-    __GLXDRIdrawable *drawable = loaderPrivate;
-    DrawablePtr pDraw = drawable->base.pDraw;
-    ScreenPtr pScreen = pDraw->pScreen;
-
-    pScreen->GetImage(pDraw, x, y, w, h, ZPixmap, ~0L, data);
-}
-
-static const __DRIswrastLoaderExtension swrastLoaderExtension = {
-    { __DRI_SWRAST_LOADER, __DRI_SWRAST_LOADER_VERSION },
-    swrastGetDrawableInfo,
-    swrastPutImage,
-    swrastGetImage
-};
-
-static const __DRIextension *loader_extensions[] = {
-    &systemTimeExtension.base,
-    &swrastLoaderExtension.base,
-    NULL
-};
-
-static void
-initializeExtensions(__GLXDRIscreen *screen)
-{
-    const __DRIextension **extensions;
-    int i;
-
-    extensions = screen->core->getExtensions(screen->driScreen);
-
-    for (i = 0; extensions[i]; i++) {
-#ifdef __DRI_COPY_SUB_BUFFER
-	if (strcmp(extensions[i]->name, __DRI_COPY_SUB_BUFFER) == 0) {
-	    screen->copySubBuffer =
-		(const __DRIcopySubBufferExtension *) extensions[i];
-	    /* GLX_MESA_copy_sub_buffer is always enabled. */
-	}
-#endif
-
-#ifdef __DRI_TEX_BUFFER
-	if (strcmp(extensions[i]->name, __DRI_TEX_BUFFER) == 0) {
-	    screen->texBuffer =
-		(const __DRItexBufferExtension *) extensions[i];
-	    /* GLX_EXT_texture_from_pixmap is always enabled. */
-	}
-#endif
-	/* Ignore unknown extensions */
-    }
-}
-
-static const char dri_driver_path[] = DRI_DRIVER_PATH;
-
-static __GLXscreen *
-__glXDRIscreenProbe(ScreenPtr pScreen)
-{
-    const char *driverName = "swrast";
-    __GLXDRIscreen *screen;
-    char filename[128];
-    const __DRIextension **extensions;
-    const __DRIconfig **driConfigs;
-    int i;
-
-    screen = xcalloc(1, sizeof *screen);
-    if (screen == NULL)
-	return NULL;
-
-    screen->base.destroy        = __glXDRIscreenDestroy;
-    screen->base.createContext  = __glXDRIscreenCreateContext;
-    screen->base.createDrawable = __glXDRIscreenCreateDrawable;
-    screen->base.swapInterval   = NULL;
-    screen->base.pScreen       = pScreen;
-
-#ifdef _MSC_VER
-#ifdef _DEBUG
-#define DLLNAME "%s%s_dri_dbg.dll"
-#else
-#define DLLNAME "%s%s_dri.dll"
-#endif
-    snprintf(filename, sizeof filename,
-	     DLLNAME, dri_driver_path, driverName);
-
-    screen->driver = LoadLibrary(filename);
-#else
-    snprintf(filename, sizeof filename,
-	     "%s/%s_dri.so", dri_driver_path, driverName);
-
-    screen->driver = dlopen(filename, RTLD_LAZY | RTLD_LOCAL);
-#endif
-    if (screen->driver == NULL) {
-	LogMessage(X_ERROR, "AIGLX error: dlopen of %s failed (%s)\n",
-		   filename, dlerror());
-        goto handle_error;
-    }
-
-#ifdef _MSC_VER
-    extensions = (const __DRIextension **)GetProcAddress(screen->driver, __DRI_DRIVER_EXTENSIONS);
-#else
-    extensions = dlsym(screen->driver, __DRI_DRIVER_EXTENSIONS);
-#endif
-    if (extensions == NULL) {
-	LogMessage(X_ERROR, "AIGLX error: %s exports no extensions (%s)\n",
-		   driverName, dlerror());
-	goto handle_error;
-    }
-
-    for (i = 0; extensions[i]; i++) {
-        if (strcmp(extensions[i]->name, __DRI_CORE) == 0 &&
-	    extensions[i]->version >= __DRI_CORE_VERSION) {
-		screen->core = (const __DRIcoreExtension *) extensions[i];
-	}
-        if (strcmp(extensions[i]->name, __DRI_SWRAST) == 0 &&
-	    extensions[i]->version >= __DRI_SWRAST_VERSION) {
-		screen->swrast = (const __DRIswrastExtension *) extensions[i];
-	}
-    }
-
-    if (screen->core == NULL || screen->swrast == NULL) {
-	LogMessage(X_ERROR, "AIGLX error: %s exports no DRI extension\n",
-		   driverName);
-	goto handle_error;
-    }
-
-    screen->driScreen =
-	(*screen->swrast->createNewScreen)(pScreen->myNum,
-					   loader_extensions,
-					   &driConfigs,
-					   screen);
-
-    if (screen->driScreen == NULL) {
-	LogMessage(X_ERROR,
-		   "AIGLX error: Calling driver entry point failed\n");
-	goto handle_error;
-    }
-
-    initializeExtensions(screen);
-
-    screen->base.fbconfigs = glxConvertConfigs(screen->core, driConfigs);
-
-    __glXScreenInit(&screen->base, pScreen);
-    screen->base.GLXmajor = 1;
-    screen->base.GLXminor = 4;
-
-    LogMessage(X_INFO,
-	       "AIGLX: Loaded and initialized %s\n", filename);
-
-    return &screen->base;
-
- handle_error:
-    if (screen->driver)
-#ifdef _MSC_VER
-    FreeLibrary(screen->driver);
-#else
-        dlclose(screen->driver);
-#endif
-
-    xfree(screen);
-
-    LogMessage(X_ERROR, "GLX: could not load software renderer\n");
-
-    return NULL;
-}
-
-_X_EXPORT __GLXprovider __glXDRISWRastProvider = {
-    __glXDRIscreenProbe,
-    "DRISWRAST",
-    NULL
-};
+/*

+ * Copyright © 2008 George Sapountzis <gsap7@yahoo.gr>

+ * Copyright © 2008 Red Hat, Inc

+ *

+ * 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, and that the name of the

+ * copyright holders not be used in advertising or publicity

+ * pertaining to distribution of the software without specific,

+ * written prior permission.  The copyright holders make no

+ * representations about the suitability of this software for any

+ * purpose.  It is provided "as is" without express or implied

+ * warranty.

+ *

+ * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS

+ * SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND

+ * FITNESS, IN NO EVENT SHALL THE COPYRIGHT HOLDERS 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>

+#else

+

+#include "glheader.h"

+

+#endif

+

+#include <stdint.h>

+#include <stdio.h>

+#include <string.h>

+#include <errno.h>

+#include <sys/time.h>

+#include <dlfcn.h>

+

+#include <GL/gl.h>

+#include <GL/internal/dri_interface.h>

+#include <GL/glxtokens.h>

+

+#include "scrnintstr.h"

+#include "pixmapstr.h"

+#include "gcstruct.h"

+#include "os.h"

+

+#include "glxserver.h"

+#include "glxutil.h"

+#include "glxdricommon.h"

+

+#include "g_disptab.h"

+#include "glapitable.h"

+#include "glapi.h"

+#include "glthread.h"

+#include "dispatch.h"

+#include "extension_string.h"

+

+/* RTLD_LOCAL is not defined on Cygwin */

+#ifdef __CYGWIN__

+#ifndef RTLD_LOCAL

+#define RTLD_LOCAL 0

+#endif

+#endif

+

+#ifdef _MSC_VER

+#define dlerror() "Getting loadlibrary error string not implemented"

+#endif

+

+typedef struct __GLXDRIscreen   __GLXDRIscreen;

+typedef struct __GLXDRIcontext  __GLXDRIcontext;

+typedef struct __GLXDRIdrawable __GLXDRIdrawable;

+

+struct __GLXDRIscreen {

+    __GLXscreen		 base;

+    __DRIscreen		*driScreen;

+    void		*driver;

+

+    const __DRIcoreExtension *core;

+    const __DRIswrastExtension *swrast;

+    const __DRIcopySubBufferExtension *copySubBuffer;

+    const __DRItexBufferExtension *texBuffer;

+};

+

+struct __GLXDRIcontext {

+    __GLXcontext	 base;

+    __DRIcontext	*driContext;

+};

+

+struct __GLXDRIdrawable {

+    __GLXdrawable	 base;

+    __DRIdrawable	*driDrawable;

+    __GLXDRIscreen	*screen;

+

+    GCPtr gc;		/* scratch GC for span drawing */

+    GCPtr swapgc;	/* GC for swapping the color buffers */

+};

+

+static void

+__glXDRIdrawableDestroy(__GLXdrawable *drawable)

+{

+    __GLXDRIdrawable *private = (__GLXDRIdrawable *) drawable;

+    const __DRIcoreExtension *core = private->screen->core;

+

+    (*core->destroyDrawable)(private->driDrawable);

+

+    FreeScratchGC(private->gc);

+    FreeScratchGC(private->swapgc);

+

+    __glXDrawableRelease(drawable);

+

+    xfree(private);

+}

+

+static GLboolean

+__glXDRIdrawableSwapBuffers(__GLXdrawable *drawable)

+{

+    __GLXDRIdrawable *private = (__GLXDRIdrawable *) drawable;

+    const __DRIcoreExtension *core = private->screen->core;

+

+    (*core->swapBuffers)(private->driDrawable);

+

+    return TRUE;

+}

+

+static void

+__glXDRIdrawableCopySubBuffer(__GLXdrawable *basePrivate,

+			       int x, int y, int w, int h)

+{

+    __GLXDRIdrawable *private = (__GLXDRIdrawable *) basePrivate;

+    const __DRIcopySubBufferExtension *copySubBuffer =

+	    private->screen->copySubBuffer;

+

+    if (copySubBuffer)

+	(*copySubBuffer->copySubBuffer)(private->driDrawable, x, y, w, h);

+}

+

+static void

+__glXDRIcontextDestroy(__GLXcontext *baseContext)

+{

+    __GLXDRIcontext *context = (__GLXDRIcontext *) baseContext;

+    __GLXDRIscreen *screen = (__GLXDRIscreen *) context->base.pGlxScreen;

+

+    (*screen->core->destroyContext)(context->driContext);

+    __glXContextDestroy(&context->base);

+    xfree(context);

+}

+

+static int

+__glXDRIcontextMakeCurrent(__GLXcontext *baseContext)

+{

+    __GLXDRIcontext *context = (__GLXDRIcontext *) baseContext;

+    __GLXDRIdrawable *draw = (__GLXDRIdrawable *) baseContext->drawPriv;

+    __GLXDRIdrawable *read = (__GLXDRIdrawable *) baseContext->readPriv;

+    __GLXDRIscreen *screen = (__GLXDRIscreen *) context->base.pGlxScreen;

+

+    return (*screen->core->bindContext)(context->driContext,

+					draw->driDrawable,

+					read->driDrawable);

+}

+

+static int

+__glXDRIcontextLoseCurrent(__GLXcontext *baseContext)

+{

+    __GLXDRIcontext *context = (__GLXDRIcontext *) baseContext;

+    __GLXDRIscreen *screen = (__GLXDRIscreen *) context->base.pGlxScreen;

+

+    return (*screen->core->unbindContext)(context->driContext);

+}

+

+static int

+__glXDRIcontextCopy(__GLXcontext *baseDst, __GLXcontext *baseSrc,

+		    unsigned long mask)

+{

+    __GLXDRIcontext *dst = (__GLXDRIcontext *) baseDst;

+    __GLXDRIcontext *src = (__GLXDRIcontext *) baseSrc;

+    __GLXDRIscreen *screen = (__GLXDRIscreen *) dst->base.pGlxScreen;

+

+    return (*screen->core->copyContext)(dst->driContext,

+					src->driContext, mask);

+}

+

+static int

+__glXDRIcontextForceCurrent(__GLXcontext *baseContext)

+{

+    __GLXDRIcontext *context = (__GLXDRIcontext *) baseContext;

+    __GLXDRIdrawable *draw = (__GLXDRIdrawable *) baseContext->drawPriv;

+    __GLXDRIdrawable *read = (__GLXDRIdrawable *) baseContext->readPriv;

+    __GLXDRIscreen *screen = (__GLXDRIscreen *) context->base.pGlxScreen;

+

+    return (*screen->core->bindContext)(context->driContext,

+					draw->driDrawable,

+					read->driDrawable);

+}

+

+#ifdef __DRI_TEX_BUFFER

+

+static int

+__glXDRIbindTexImage(__GLXcontext *baseContext,

+		     int buffer,

+		     __GLXdrawable *glxPixmap)

+{

+    __GLXDRIdrawable *drawable = (__GLXDRIdrawable *) glxPixmap;

+    const __DRItexBufferExtension *texBuffer = drawable->screen->texBuffer;

+    __GLXDRIcontext *context = (__GLXDRIcontext *) baseContext;

+

+    if (texBuffer == NULL)

+        return Success;

+

+    texBuffer->setTexBuffer(context->driContext,

+			    glxPixmap->target,

+			    drawable->driDrawable);

+

+    return Success;

+}

+

+static int

+__glXDRIreleaseTexImage(__GLXcontext *baseContext,

+			int buffer,

+			__GLXdrawable *pixmap)

+{

+    /* FIXME: Just unbind the texture? */

+    return Success;

+}

+

+#else

+

+static int

+__glXDRIbindTexImage(__GLXcontext *baseContext,

+		     int buffer,

+		     __GLXdrawable *glxPixmap)

+{

+    return Success;

+}

+

+static int

+__glXDRIreleaseTexImage(__GLXcontext *baseContext,

+			int buffer,

+			__GLXdrawable *pixmap)

+{

+    return Success;

+}

+

+#endif

+

+static __GLXtextureFromPixmap __glXDRItextureFromPixmap = {

+    __glXDRIbindTexImage,

+    __glXDRIreleaseTexImage

+};

+

+static void

+__glXDRIscreenDestroy(__GLXscreen *baseScreen)

+{

+    __GLXDRIscreen *screen = (__GLXDRIscreen *) baseScreen;

+

+    (*screen->core->destroyScreen)(screen->driScreen);

+

+#ifdef _MSC_VER

+    FreeLibrary(screen->driver);

+#else

+    dlclose(screen->driver);

+#endif

+

+    __glXScreenDestroy(baseScreen);

+

+    xfree(screen);

+}

+

+static __GLXcontext *

+__glXDRIscreenCreateContext(__GLXscreen *baseScreen,

+			    __GLXconfig *glxConfig,

+			    __GLXcontext *baseShareContext)

+{

+    __GLXDRIscreen *screen = (__GLXDRIscreen *) baseScreen;

+    __GLXDRIcontext *context, *shareContext;

+    __GLXDRIconfig *config = (__GLXDRIconfig *) glxConfig;

+    const __DRIcoreExtension *core = screen->core;

+    __DRIcontext *driShare;

+

+    shareContext = (__GLXDRIcontext *) baseShareContext;

+    if (shareContext)

+	driShare = shareContext->driContext;

+    else

+	driShare = NULL;

+

+    context = xcalloc(1, sizeof *context);

+    if (context == NULL)

+	return NULL;

+

+    context->base.destroy           = __glXDRIcontextDestroy;

+    context->base.makeCurrent       = __glXDRIcontextMakeCurrent;

+    context->base.loseCurrent       = __glXDRIcontextLoseCurrent;

+    context->base.copy              = __glXDRIcontextCopy;

+    context->base.forceCurrent      = __glXDRIcontextForceCurrent;

+    context->base.textureFromPixmap = &__glXDRItextureFromPixmap;

+

+    context->driContext =

+	(*core->createNewContext)(screen->driScreen,

+				  config->driConfig, driShare, context);

+

+    return &context->base;

+}

+

+static void

+glxChangeGC(GCPtr gc, BITS32 mask, CARD32 val)

+{

+    CARD32 v[1];

+    v[0] = val;

+    dixChangeGC(NullClient, gc, mask, v, NULL);

+}

+

+static __GLXdrawable *

+__glXDRIscreenCreateDrawable(__GLXscreen *screen,

+			     DrawablePtr pDraw,

+			     int type,

+			     XID drawId,

+			     __GLXconfig *glxConfig)

+{

+    __GLXDRIscreen *driScreen = (__GLXDRIscreen *) screen;

+    __GLXDRIconfig *config = (__GLXDRIconfig *) glxConfig;

+    __GLXDRIdrawable *private;

+

+    ScreenPtr pScreen = driScreen->base.pScreen;

+

+    private = xcalloc(1, sizeof *private);

+    if (private == NULL)

+	return NULL;

+

+    private->screen = driScreen;

+    if (!__glXDrawableInit(&private->base, screen,

+			   pDraw, type, drawId, glxConfig)) {

+        xfree(private);

+	return NULL;

+    }

+

+    private->base.destroy       = __glXDRIdrawableDestroy;

+    private->base.swapBuffers   = __glXDRIdrawableSwapBuffers;

+    private->base.copySubBuffer = __glXDRIdrawableCopySubBuffer;

+

+    private->gc = CreateScratchGC(pScreen, pDraw->depth);

+    private->swapgc = CreateScratchGC(pScreen, pDraw->depth);

+

+    glxChangeGC(private->gc, GCFunction, GXcopy);

+    glxChangeGC(private->swapgc, GCFunction, GXcopy);

+    glxChangeGC(private->swapgc, GCGraphicsExposures, FALSE);

+

+    private->driDrawable =

+	(*driScreen->swrast->createNewDrawable)(driScreen->driScreen,

+						config->driConfig,

+						private);

+

+    return &private->base;

+}

+

+static void

+swrastGetDrawableInfo(__DRIdrawable *draw,

+		      int *x, int *y, int *w, int *h,

+		      void *loaderPrivate)

+{

+    __GLXDRIdrawable *drawable = loaderPrivate;

+    DrawablePtr pDraw = drawable->base.pDraw;

+

+    *x = pDraw->x;

+    *y = pDraw->x;

+    *w = pDraw->width;

+    *h = pDraw->height;

+}

+

+static void

+swrastPutImage(__DRIdrawable *draw, int op,

+	     int x, int y, int w, int h, char *data,

+	     void *loaderPrivate)

+{

+    __GLXDRIdrawable *drawable = loaderPrivate;

+    DrawablePtr pDraw = drawable->base.pDraw;

+    GCPtr gc;

+

+    switch (op) {

+    case __DRI_SWRAST_IMAGE_OP_DRAW:

+	gc = drawable->gc;

+	break;

+    case __DRI_SWRAST_IMAGE_OP_SWAP:

+	gc = drawable->swapgc;

+	break;

+    default:

+	return;

+    }

+

+    ValidateGC(pDraw, gc);

+

+    gc->ops->PutImage(pDraw, gc, pDraw->depth,

+		      x, y, w, h, 0, ZPixmap, data);

+}

+

+static void

+swrastGetImage(__DRIdrawable *draw,

+	     int x, int y, int w, int h, char *data,

+	     void *loaderPrivate)

+{

+    __GLXDRIdrawable *drawable = loaderPrivate;

+    DrawablePtr pDraw = drawable->base.pDraw;

+    ScreenPtr pScreen = pDraw->pScreen;

+

+    pScreen->GetImage(pDraw, x, y, w, h, ZPixmap, ~0L, data);

+}

+

+static const __DRIswrastLoaderExtension swrastLoaderExtension = {

+    { __DRI_SWRAST_LOADER, __DRI_SWRAST_LOADER_VERSION },

+    swrastGetDrawableInfo,

+    swrastPutImage,

+    swrastGetImage

+};

+

+static const __DRIextension *loader_extensions[] = {

+    &systemTimeExtension.base,

+    &swrastLoaderExtension.base,

+    NULL

+};

+

+static void

+initializeExtensions(__GLXDRIscreen *screen)

+{

+    const __DRIextension **extensions;

+    int i;

+

+    extensions = screen->core->getExtensions(screen->driScreen);

+

+    for (i = 0; extensions[i]; i++) {

+#ifdef __DRI_COPY_SUB_BUFFER

+	if (strcmp(extensions[i]->name, __DRI_COPY_SUB_BUFFER) == 0) {

+	    screen->copySubBuffer =

+		(const __DRIcopySubBufferExtension *) extensions[i];

+	    /* GLX_MESA_copy_sub_buffer is always enabled. */

+	}

+#endif

+

+#ifdef __DRI_TEX_BUFFER

+	if (strcmp(extensions[i]->name, __DRI_TEX_BUFFER) == 0) {

+	    screen->texBuffer =

+		(const __DRItexBufferExtension *) extensions[i];

+	    /* GLX_EXT_texture_from_pixmap is always enabled. */

+	}

+#endif

+	/* Ignore unknown extensions */

+    }

+}

+

+static const char dri_driver_path[] = DRI_DRIVER_PATH;

+

+static __GLXscreen *

+__glXDRIscreenProbe(ScreenPtr pScreen)

+{

+    const char *driverName = "swrast";

+    __GLXDRIscreen *screen;

+    char filename[128];

+    const __DRIextension **extensions;

+    const __DRIconfig **driConfigs;

+    int i;

+

+    screen = xcalloc(1, sizeof *screen);

+    if (screen == NULL)

+	return NULL;

+

+    screen->base.destroy        = __glXDRIscreenDestroy;

+    screen->base.createContext  = __glXDRIscreenCreateContext;

+    screen->base.createDrawable = __glXDRIscreenCreateDrawable;

+    screen->base.swapInterval   = NULL;

+    screen->base.pScreen       = pScreen;

+

+#ifdef _MSC_VER

+#ifdef _DEBUG

+#define DLLNAME "%s%s_dri_dbg.dll"

+#else

+#define DLLNAME "%s%s_dri.dll"

+#endif

+    snprintf(filename, sizeof filename,

+	     DLLNAME, dri_driver_path, driverName);

+

+    screen->driver = LoadLibrary(filename);

+#else

+    snprintf(filename, sizeof filename,

+	     "%s/%s_dri.so", dri_driver_path, driverName);

+

+    screen->driver = dlopen(filename, RTLD_LAZY | RTLD_LOCAL);

+#endif

+    if (screen->driver == NULL) {

+	LogMessage(X_ERROR, "AIGLX error: dlopen of %s failed (%s)\n",

+		   filename, dlerror());

+        goto handle_error;

+    }

+

+#ifdef _MSC_VER

+    extensions = (const __DRIextension **)GetProcAddress(screen->driver, __DRI_DRIVER_EXTENSIONS);

+#else

+    extensions = dlsym(screen->driver, __DRI_DRIVER_EXTENSIONS);

+#endif

+    if (extensions == NULL) {

+	LogMessage(X_ERROR, "AIGLX error: %s exports no extensions (%s)\n",

+		   driverName, dlerror());

+	goto handle_error;

+    }

+

+    for (i = 0; extensions[i]; i++) {

+        if (strcmp(extensions[i]->name, __DRI_CORE) == 0 &&

+	    extensions[i]->version >= __DRI_CORE_VERSION) {

+		screen->core = (const __DRIcoreExtension *) extensions[i];

+	}

+        if (strcmp(extensions[i]->name, __DRI_SWRAST) == 0 &&

+	    extensions[i]->version >= __DRI_SWRAST_VERSION) {

+		screen->swrast = (const __DRIswrastExtension *) extensions[i];

+	}

+    }

+

+    if (screen->core == NULL || screen->swrast == NULL) {

+	LogMessage(X_ERROR, "AIGLX error: %s exports no DRI extension\n",

+		   driverName);

+	goto handle_error;

+    }

+

+    screen->driScreen =

+	(*screen->swrast->createNewScreen)(pScreen->myNum,

+					   loader_extensions,

+					   &driConfigs,

+					   screen);

+

+    if (screen->driScreen == NULL) {

+	LogMessage(X_ERROR,

+		   "AIGLX error: Calling driver entry point failed\n");

+	goto handle_error;

+    }

+

+    initializeExtensions(screen);

+

+    screen->base.fbconfigs = glxConvertConfigs(screen->core, driConfigs);

+

+    __glXScreenInit(&screen->base, pScreen);

+

+    screen->base.GLXmajor = 1;

+    screen->base.GLXminor = 4;

+

+    LogMessage(X_INFO,

+	       "AIGLX: Loaded and initialized %s\n", filename);

+

+    return &screen->base;

+

+ handle_error:

+    if (screen->driver)

+#ifdef _MSC_VER

+    FreeLibrary(screen->driver);

+#else

+        dlclose(screen->driver);

+#endif

+

+    xfree(screen);

+

+    LogMessage(X_ERROR, "GLX: could not load software renderer\n");

+

+    return NULL;

+}

+

+_X_EXPORT __GLXprovider __glXDRISWRastProvider = {

+    __glXDRIscreenProbe,

+    "DRISWRAST",

+    NULL

+};

diff --git a/xorg-server/hw/kdrive/fake/Makefile.am b/xorg-server/hw/kdrive/fake/Makefile.am
index 71b24b7e6..be0fa42a2 100644
--- a/xorg-server/hw/kdrive/fake/Makefile.am
+++ b/xorg-server/hw/kdrive/fake/Makefile.am
@@ -20,7 +20,7 @@ Xfake_LDADD = 						\
 	libfake.la					\
 	@KDRIVE_LIBS@
 
-Xfake_LDFLAGS = $(LD_EXPORT_SYMBOLS_FLAG) -Wl,-undefined=InitExtensions
+Xfake_LDFLAGS = $(LD_EXPORT_SYMBOLS_FLAG)
 
 Xfake_DEPENDENCIES =	\
 	libfake.la					\
diff --git a/xorg-server/hw/xfree86/common/xf86Config.c b/xorg-server/hw/xfree86/common/xf86Config.c
index e1283f97f..a6d66f35a 100644
--- a/xorg-server/hw/xfree86/common/xf86Config.c
+++ b/xorg-server/hw/xfree86/common/xf86Config.c
@@ -249,7 +249,9 @@ xf86ModulelistFromConfig(pointer **optlist)
 {
     int count = 0, i = 0;
     char **modulearray;
-    char *ignore[] = { "GLcore", "speedo", "bitmap", "drm", NULL };
+    char *ignore[] = { "GLcore", "speedo", "bitmap", "drm",
+		       "freetype", "type1",
+		       NULL };
     pointer *optarray;
     XF86LoadPtr modp;
     Bool found;
diff --git a/xorg-server/hw/xfree86/common/xf86Init.c b/xorg-server/hw/xfree86/common/xf86Init.c
index 30f0c8559..3b25c89a6 100644
--- a/xorg-server/hw/xfree86/common/xf86Init.c
+++ b/xorg-server/hw/xfree86/common/xf86Init.c
@@ -133,7 +133,7 @@ static void
 xf86PrintBanner(void)
 {
 #if PRE_RELEASE
-  ErrorF("\n"
+  xf86ErrorFVerb(0, "\n"
     "This is a pre-release version of the X server from " XVENDORNAME ".\n"
     "It is not supported in any way.\n"
     "Bugs may be filed in the bugzilla at http://bugs.freedesktop.org/.\n"
@@ -142,12 +142,12 @@ xf86PrintBanner(void)
     "latest version in the X.Org Foundation git repository.\n"
     "See http://wiki.x.org/wiki/GitPage for git access instructions.\n");
 #endif
-  ErrorF("\nX.Org X Server %d.%d.%d",
+  xf86ErrorFVerb(0, "\nX.Org X Server %d.%d.%d",
 	 XORG_VERSION_MAJOR,
 	 XORG_VERSION_MINOR,
 	 XORG_VERSION_PATCH);
 #if XORG_VERSION_SNAP > 0
-  ErrorF(".%d", XORG_VERSION_SNAP);
+  xf86ErrorFVerb(0, ".%d", XORG_VERSION_SNAP);
 #endif
 
 #if XORG_VERSION_SNAP >= 900
@@ -159,26 +159,28 @@ xf86PrintBanner(void)
    * candidate for the next point release.  (X.Y.Z)
    */
 #if XORG_VERSION_MINOR >= 99
-  ErrorF(" (%d.0.0 RC %d)", XORG_VERSION_MAJOR+1, XORG_VERSION_SNAP - 900);
+  xf86ErrorFVerb(0, " (%d.0.0 RC %d)", XORG_VERSION_MAJOR+1,
+                 XORG_VERSION_SNAP - 900);
 #elif XORG_VERSION_PATCH == 99
-  ErrorF(" (%d.%d.0 RC %d)", XORG_VERSION_MAJOR, XORG_VERSION_MINOR + 1,
-				XORG_VERSION_SNAP - 900);
+  xf86ErrorFVerb(0, " (%d.%d.0 RC %d)", XORG_VERSION_MAJOR,
+                 XORG_VERSION_MINOR + 1, XORG_VERSION_SNAP - 900);
 #else
-  ErrorF(" (%d.%d.%d RC %d)", XORG_VERSION_MAJOR, XORG_VERSION_MINOR,
- 			 XORG_VERSION_PATCH + 1, XORG_VERSION_SNAP - 900);
+  xf86ErrorFVerb(0, " (%d.%d.%d RC %d)", XORG_VERSION_MAJOR,
+                 XORG_VERSION_MINOR, XORG_VERSION_PATCH + 1,
+                 XORG_VERSION_SNAP - 900);
 #endif
 #endif
 
 #ifdef XORG_CUSTOM_VERSION
-  ErrorF(" (%s)", XORG_CUSTOM_VERSION);
+  xf86ErrorFVerb(0, " (%s)", XORG_CUSTOM_VERSION);
 #endif
 #ifndef XORG_DATE
 # define XORG_DATE "Unknown"
 #endif
-  ErrorF("\nRelease Date: %s\n", XORG_DATE);
-  ErrorF("X Protocol Version %d, Revision %d\n",
+  xf86ErrorFVerb(0, "\nRelease Date: %s\n", XORG_DATE);
+  xf86ErrorFVerb(0, "X Protocol Version %d, Revision %d\n",
          X_PROTOCOL, X_PROTOCOL_REVISION);
-  ErrorF("Build Operating System: %s %s\n", OSNAME, OSVENDOR);
+  xf86ErrorFVerb(0, "Build Operating System: %s %s\n", OSNAME, OSVENDOR);
 #ifdef HAS_UTSNAME
   {
     struct utsname name;
@@ -188,17 +190,17 @@ xf86PrintBanner(void)
        All agree that failure is represented by a negative number.
      */
     if (uname(&name) >= 0) {
-      ErrorF("Current Operating System: %s %s %s %s %s\n",
+      xf86ErrorFVerb(0, "Current Operating System: %s %s %s %s %s\n",
 	name.sysname, name.nodename, name.release, name.version, name.machine);
 #ifdef linux
       do {
 	  char buf[80];
 	  int fd = open("/proc/cmdline", O_RDONLY);
 	  if (fd != -1) {
-	    ErrorF("Kernel command line: ");
+	    xf86ErrorFVerb(0, "Kernel command line: ");
 	    memset(buf, 0, 80);
 	    while (read(fd, buf, 80) > 0) {
-		ErrorF("%.80s", buf);
+		xf86ErrorFVerb(0, "%.80s", buf);
 		memset(buf, 0, 80);
 	    }
 	    close(fd);
@@ -223,19 +225,21 @@ xf86PrintBanner(void)
     t.tm_min = (BUILD_TIME / 100) % 100;
     t.tm_hour = (BUILD_TIME / 10000) % 100;
     if (strftime(buf, sizeof(buf), "%d %B %Y  %I:%M:%S%p", &t))
-       ErrorF("Build Date: %s\n", buf);
+       xf86ErrorFVerb(0, "Build Date: %s\n", buf);
 #else
     if (strftime(buf, sizeof(buf), "%d %B %Y", &t))
-       ErrorF("Build Date: %s\n", buf);
+       xf86ErrorFVerb(0, "Build Date: %s\n", buf);
 #endif
   }
 #endif
 #if defined(BUILDERSTRING)
-  ErrorF("%s \n",BUILDERSTRING);
+  xf86ErrorFVerb(0, "%s \n", BUILDERSTRING);
 #endif
-  ErrorF("Current version of pixman: %s\n", pixman_version_string());
-  ErrorF("\tBefore reporting problems, check "__VENDORDWEBSUPPORT__"\n"
-	 "\tto make sure that you have the latest version.\n");
+  xf86ErrorFVerb(0, "Current version of pixman: %s\n",
+                 pixman_version_string());
+  xf86ErrorFVerb(0, "\tBefore reporting problems, check "
+                 ""__VENDORDWEBSUPPORT__"\n"
+                 "\tto make sure that you have the latest version.\n");
 }
 
 static void
@@ -1444,7 +1448,7 @@ ddxProcessArgument(int argc, char **argv, int i)
   }
   if (!strcmp(argv[i],"-quiet"))
   {
-    xf86SetVerbosity(0);
+    xf86SetVerbosity(-1);
     return 1;
   }
   if (!strcmp(argv[i],"-showconfig") || !strcmp(argv[i],"-version"))
diff --git a/xorg-server/hw/xfree86/common/xf86xv.c b/xorg-server/hw/xfree86/common/xf86xv.c
index 82216598b..bdcc4fc2b 100644
--- a/xorg-server/hw/xfree86/common/xf86xv.c
+++ b/xorg-server/hw/xfree86/common/xf86xv.c
@@ -787,8 +787,8 @@ xf86XVReputVideo(XvPortRecPrivatePtr portPriv)
 
      VPBox.x1 = portPriv->pScrn->frameX0;
      VPBox.y1 = portPriv->pScrn->frameY0;
-     VPBox.x2 = portPriv->pScrn->frameX1;
-     VPBox.y2 = portPriv->pScrn->frameY1;
+     VPBox.x2 = portPriv->pScrn->frameX1 + 1;
+     VPBox.y2 = portPriv->pScrn->frameY1 + 1;
 
      REGION_INIT(pScreen, &VPReg, &VPBox, 1);
      REGION_INTERSECT(pScreen, &ClipRegion, &ClipRegion, &VPReg);
@@ -877,8 +877,8 @@ xf86XVReputImage(XvPortRecPrivatePtr portPriv)
 
      VPBox.x1 = portPriv->pScrn->frameX0;
      VPBox.y1 = portPriv->pScrn->frameY0;
-     VPBox.x2 = portPriv->pScrn->frameX1;
-     VPBox.y2 = portPriv->pScrn->frameY1;
+     VPBox.x2 = portPriv->pScrn->frameX1 + 1;
+     VPBox.y2 = portPriv->pScrn->frameY1 + 1;
 
      REGION_INIT(pScreen, &VPReg, &VPBox, 1);
      REGION_INTERSECT(pScreen, &ClipRegion, &ClipRegion, &VPReg);
@@ -1433,8 +1433,8 @@ xf86XVPutStill(
 
      VPBox.x1 = portPriv->pScrn->frameX0;
      VPBox.y1 = portPriv->pScrn->frameY0;
-     VPBox.x2 = portPriv->pScrn->frameX1;
-     VPBox.y2 = portPriv->pScrn->frameY1;
+     VPBox.x2 = portPriv->pScrn->frameX1 + 1;
+     VPBox.y2 = portPriv->pScrn->frameY1 + 1;
 
      REGION_INIT(pScreen, &VPReg, &VPBox, 1);
      REGION_INTERSECT(pScreen, &ClipRegion, &ClipRegion, &VPReg);
diff --git a/xorg-server/hw/xfree86/int10/Makefile.am b/xorg-server/hw/xfree86/int10/Makefile.am
index 78bef2515..36d2ad0bb 100644
--- a/xorg-server/hw/xfree86/int10/Makefile.am
+++ b/xorg-server/hw/xfree86/int10/Makefile.am
@@ -38,6 +38,7 @@ endif
 
 if INT10_STUB
 AM_CFLAGS = $(I386_VIDEO_CFLAGS) -D_VM86_LINUX $(DIX_CFLAGS) $(XORG_CFLAGS) $(EXTRA_CFLAGS)
+INCLUDES = $(XORG_INCS)
 libint10_la_SOURCES = stub.c xf86int10module.c
 endif
 
diff --git a/xorg-server/hw/xfree86/modes/xf86RandR12.c b/xorg-server/hw/xfree86/modes/xf86RandR12.c
index 6ea9d26b6..1fc63c4dc 100644
--- a/xorg-server/hw/xfree86/modes/xf86RandR12.c
+++ b/xorg-server/hw/xfree86/modes/xf86RandR12.c
@@ -871,7 +871,12 @@ xf86RandR12Init (ScreenPtr pScreen)
 #ifdef PANORAMIX
     /* XXX disable RandR when using Xinerama */
     if (!noPanoramiXExtension)
-	return TRUE;
+    {
+        if (xf86NumScreens == 1)
+            noPanoramiXExtension = TRUE;
+        else
+            return TRUE;
+    }
 #endif
 
     if (xf86RandR12Generation != serverGeneration)
diff --git a/xorg-server/hw/xfree86/os-support/solaris/solaris-amd64.S b/xorg-server/hw/xfree86/os-support/solaris/solaris-amd64.S
index 4a0e0f48a..94ffa40e7 100644
--- a/xorg-server/hw/xfree86/os-support/solaris/solaris-amd64.S
+++ b/xorg-server/hw/xfree86/os-support/solaris/solaris-amd64.S
@@ -1,29 +1,23 @@
 / Copyright 2005 Sun Microsystems, Inc.  All rights reserved.
 / 
 / 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, and/or sell copies of the Software, and to permit persons
-/ to whom the Software is furnished to do so, provided that the above
-/ copyright notice(s) and this permission notice appear in all copies of
-/ the Software and that both the above copyright notice(s) and this
-/ permission notice appear in supporting documentation.
-/ 
-/ 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
-/ OF THIRD PARTY RIGHTS. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
-/ HOLDERS INCLUDED IN THIS NOTICE BE LIABLE FOR ANY CLAIM, OR 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.
-/ 
-/ Except as contained in this notice, the name of a copyright holder
-/ shall not be used in advertising or otherwise to promote the sale, use
-/ or other dealings in this Software without prior written authorization
-/ of the copyright holder.
+/ 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 (including the next
+/ paragraph) 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 AUTHORS OR COPYRIGHT HOLDERS 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.
 
 #ifdef INLINE_ASM
 #define FUNCTION_START(f,n)	.inline f,n
diff --git a/xorg-server/hw/xfree86/os-support/solaris/solaris-ia32.S b/xorg-server/hw/xfree86/os-support/solaris/solaris-ia32.S
index 280154bab..4dadf7ffd 100644
--- a/xorg-server/hw/xfree86/os-support/solaris/solaris-ia32.S
+++ b/xorg-server/hw/xfree86/os-support/solaris/solaris-ia32.S
@@ -1,29 +1,23 @@
 / Copyright 2004 Sun Microsystems, Inc.  All rights reserved.
 / 
 / 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, and/or sell copies of the Software, and to permit persons
-/ to whom the Software is furnished to do so, provided that the above
-/ copyright notice(s) and this permission notice appear in all copies of
-/ the Software and that both the above copyright notice(s) and this
-/ permission notice appear in supporting documentation.
-/ 
-/ 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
-/ OF THIRD PARTY RIGHTS. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
-/ HOLDERS INCLUDED IN THIS NOTICE BE LIABLE FOR ANY CLAIM, OR 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.
-/ 
-/ Except as contained in this notice, the name of a copyright holder
-/ shall not be used in advertising or otherwise to promote the sale, use
-/ or other dealings in this Software without prior written authorization
-/ of the copyright holder.
+/ 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 (including the next
+/ paragraph) 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 AUTHORS OR COPYRIGHT HOLDERS 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.
 
 #ifdef INLINE_ASM
 #define FUNCTION_START(f,n)	.inline f,n
diff --git a/xorg-server/hw/xfree86/os-support/solaris/solaris-sparcv8plus.S b/xorg-server/hw/xfree86/os-support/solaris/solaris-sparcv8plus.S
index dbaa0308b..0f6d694fd 100644
--- a/xorg-server/hw/xfree86/os-support/solaris/solaris-sparcv8plus.S
+++ b/xorg-server/hw/xfree86/os-support/solaris/solaris-sparcv8plus.S
@@ -1,29 +1,23 @@
 /* Copyright 2004 Sun Microsystems, Inc.  All rights reserved.
  * 
  * 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, and/or sell copies of the Software, and to permit persons
- * to whom the Software is furnished to do so, provided that the above
- * copyright notice(s) and this permission notice appear in all copies of
- * the Software and that both the above copyright notice(s) and this
- * permission notice appear in supporting documentation.
- * 
- * 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
- * OF THIRD PARTY RIGHTS. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
- * HOLDERS INCLUDED IN THIS NOTICE BE LIABLE FOR ANY CLAIM, OR 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.
- * 
- * Except as contained in this notice, the name of a copyright holder
- * shall not be used in advertising or otherwise to promote the sale, use
- * or other dealings in this Software without prior written authorization
- * of the copyright holder.
+ * 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 (including the next
+ * paragraph) 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 AUTHORS OR COPYRIGHT HOLDERS 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.
  */
 
 #ifdef INLINE_ASM
diff --git a/xorg-server/hw/xfree86/os-support/solaris/sun_VTsw.c b/xorg-server/hw/xfree86/os-support/solaris/sun_VTsw.c
index 0dc76b8b5..ded2f271e 100644
--- a/xorg-server/hw/xfree86/os-support/solaris/sun_VTsw.c
+++ b/xorg-server/hw/xfree86/os-support/solaris/sun_VTsw.c
@@ -2,29 +2,23 @@
  * Copyright 2009 Sun Microsystems, Inc.  All rights reserved.
  *
  * 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, and/or sell copies of the Software, and to permit persons
- * to whom the Software is furnished to do so, provided that the above
- * copyright notice(s) and this permission notice appear in all copies of
- * the Software and that both the above copyright notice(s) and this
- * permission notice appear in supporting documentation.
+ * 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 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
- * OF THIRD PARTY RIGHTS. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
- * HOLDERS INCLUDED IN THIS NOTICE BE LIABLE FOR ANY CLAIM, OR 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.
+ * The above copyright notice and this permission notice (including the next
+ * paragraph) shall be included in all copies or substantial portions of the
+ * Software.
  *
- * Except as contained in this notice, the name of a copyright holder
- * shall not be used in advertising or otherwise to promote the sale, use
- * or other dealings in this Software without prior written authorization
- * of the copyright holder.
+ * 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 AUTHORS OR COPYRIGHT HOLDERS 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.
  */
 
 #ifdef HAVE_XORG_CONFIG_H
diff --git a/xorg-server/hw/xfree86/os-support/solaris/sun_agp.c b/xorg-server/hw/xfree86/os-support/solaris/sun_agp.c
index 376f98edd..e6a55a48b 100644
--- a/xorg-server/hw/xfree86/os-support/solaris/sun_agp.c
+++ b/xorg-server/hw/xfree86/os-support/solaris/sun_agp.c
@@ -9,29 +9,23 @@
 /* Copyright 2005 Sun Microsystems, Inc.  All rights reserved.
  *
  * 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, and/or sell copies of the Software, and to permit persons
- * to whom the Software is furnished to do so, provided that the above
- * copyright notice(s) and this permission notice appear in all copies of
- * the Software and that both the above copyright notice(s) and this
- * permission notice appear in supporting documentation.
+ * 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 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
- * OF THIRD PARTY RIGHTS. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
- * HOLDERS INCLUDED IN THIS NOTICE BE LIABLE FOR ANY CLAIM, OR 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.
+ * The above copyright notice and this permission notice (including the next
+ * paragraph) shall be included in all copies or substantial portions of the
+ * Software.
  *
- * Except as contained in this notice, the name of a copyright holder
- * shall not be used in advertising or otherwise to promote the sale, use
- * or other dealings in this Software without prior written authorization
- * of the copyright holder.
+ * 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 AUTHORS OR COPYRIGHT HOLDERS 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.
  */
 
 #ifdef HAVE_XORG_CONFIG_H
diff --git a/xorg-server/hw/xfree86/os-support/solaris/sun_apm.c b/xorg-server/hw/xfree86/os-support/solaris/sun_apm.c
index e128c13d0..23e14f17e 100644
--- a/xorg-server/hw/xfree86/os-support/solaris/sun_apm.c
+++ b/xorg-server/hw/xfree86/os-support/solaris/sun_apm.c
@@ -30,29 +30,23 @@
 /* Copyright 2005 Sun Microsystems, Inc.  All rights reserved.
  *
  * 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, and/or sell copies of the Software, and to permit persons
- * to whom the Software is furnished to do so, provided that the above
- * copyright notice(s) and this permission notice appear in all copies of
- * the Software and that both the above copyright notice(s) and this
- * permission notice appear in supporting documentation.
+ * 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 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
- * OF THIRD PARTY RIGHTS. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
- * HOLDERS INCLUDED IN THIS NOTICE BE LIABLE FOR ANY CLAIM, OR 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.
+ * The above copyright notice and this permission notice (including the next
+ * paragraph) shall be included in all copies or substantial portions of the
+ * Software.
  *
- * Except as contained in this notice, the name of a copyright holder
- * shall not be used in advertising or otherwise to promote the sale, use
- * or other dealings in this Software without prior written authorization
- * of the copyright holder.
+ * 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 AUTHORS OR COPYRIGHT HOLDERS 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.
  */
 
 #ifdef HAVE_XORG_CONFIG_H
diff --git a/xorg-server/hw/xfree86/os-support/solaris/sun_bell.c b/xorg-server/hw/xfree86/os-support/solaris/sun_bell.c
index b25f40d8e..7f146eaaf 100644
--- a/xorg-server/hw/xfree86/os-support/solaris/sun_bell.c
+++ b/xorg-server/hw/xfree86/os-support/solaris/sun_bell.c
@@ -1,29 +1,23 @@
 /* Copyright 2004-2005 Sun Microsystems, Inc.  All rights reserved.
  *
  * 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, and/or sell copies of the Software, and to permit persons
- * to whom the Software is furnished to do so, provided that the above
- * copyright notice(s) and this permission notice appear in all copies of
- * the Software and that both the above copyright notice(s) and this
- * permission notice appear in supporting documentation.
- * 
- * 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
- * OF THIRD PARTY RIGHTS. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
- * HOLDERS INCLUDED IN THIS NOTICE BE LIABLE FOR ANY CLAIM, OR 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.
- * 
- * Except as contained in this notice, the name of a copyright holder
- * shall not be used in advertising or otherwise to promote the sale, use
- * or other dealings in this Software without prior written authorization
- * of the copyright holder.
+ * 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 (including the next
+ * paragraph) 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 AUTHORS OR COPYRIGHT HOLDERS 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.
  */
 
 #ifdef HAVE_XORG_CONFIG_H
diff --git a/xorg-server/hw/xfree86/os-support/solaris/sun_vid.c b/xorg-server/hw/xfree86/os-support/solaris/sun_vid.c
index 2078646b1..5089ae74d 100644
--- a/xorg-server/hw/xfree86/os-support/solaris/sun_vid.c
+++ b/xorg-server/hw/xfree86/os-support/solaris/sun_vid.c
@@ -25,29 +25,23 @@
 /* Copyright 2008 Sun Microsystems, Inc.  All rights reserved.
  *
  * 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, and/or sell copies of the Software, and to permit persons
- * to whom the Software is furnished to do so, provided that the above
- * copyright notice(s) and this permission notice appear in all copies of
- * the Software and that both the above copyright notice(s) and this
- * permission notice appear in supporting documentation.
+ * 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 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
- * OF THIRD PARTY RIGHTS. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
- * HOLDERS INCLUDED IN THIS NOTICE BE LIABLE FOR ANY CLAIM, OR 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.
+ * The above copyright notice and this permission notice (including the next
+ * paragraph) shall be included in all copies or substantial portions of the
+ * Software.
  *
- * Except as contained in this notice, the name of a copyright holder
- * shall not be used in advertising or otherwise to promote the sale, use
- * or other dealings in this Software without prior written authorization
- * of the copyright holder.
+ * 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 AUTHORS OR COPYRIGHT HOLDERS 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.
  */
 
 #ifdef HAVE_XORG_CONFIG_H
diff --git a/xorg-server/hw/xfree86/utils/cvt/Makefile.am b/xorg-server/hw/xfree86/utils/cvt/Makefile.am
index 5db1d7cf9..6b99cbd5f 100644
--- a/xorg-server/hw/xfree86/utils/cvt/Makefile.am
+++ b/xorg-server/hw/xfree86/utils/cvt/Makefile.am
@@ -1,29 +1,23 @@
 # Copyright 2005 Sun Microsystems, Inc.  All rights reserved.
-# 
+#
 # 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, and/or sell copies of the Software, and to permit persons
-# to whom the Software is furnished to do so, provided that the above
-# copyright notice(s) and this permission notice appear in all copies of
-# the Software and that both the above copyright notice(s) and this
-# permission notice appear in supporting documentation.
-# 
-# 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
-# OF THIRD PARTY RIGHTS. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
-# HOLDERS INCLUDED IN THIS NOTICE BE LIABLE FOR ANY CLAIM, OR 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.
-# 
-# Except as contained in this notice, the name of a copyright holder
-# shall not be used in advertising or otherwise to promote the sale, use
-# or other dealings in this Software without prior written authorization
-# of the copyright holder.
+# 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 (including the next
+# paragraph) 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 AUTHORS OR COPYRIGHT HOLDERS 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.
 # 
 
 bin_PROGRAMS = cvt
diff --git a/xorg-server/hw/xfree86/utils/gtf/Makefile.am b/xorg-server/hw/xfree86/utils/gtf/Makefile.am
index b14d0c13c..3ca568d74 100644
--- a/xorg-server/hw/xfree86/utils/gtf/Makefile.am
+++ b/xorg-server/hw/xfree86/utils/gtf/Makefile.am
@@ -1,29 +1,23 @@
 # Copyright 2005 Sun Microsystems, Inc.  All rights reserved.
-# 
+#
 # 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, and/or sell copies of the Software, and to permit persons
-# to whom the Software is furnished to do so, provided that the above
-# copyright notice(s) and this permission notice appear in all copies of
-# the Software and that both the above copyright notice(s) and this
-# permission notice appear in supporting documentation.
-# 
-# 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
-# OF THIRD PARTY RIGHTS. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
-# HOLDERS INCLUDED IN THIS NOTICE BE LIABLE FOR ANY CLAIM, OR 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.
-# 
-# Except as contained in this notice, the name of a copyright holder
-# shall not be used in advertising or otherwise to promote the sale, use
-# or other dealings in this Software without prior written authorization
-# of the copyright holder.
+# 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 (including the next
+# paragraph) 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 AUTHORS OR COPYRIGHT HOLDERS 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.
 # 
 
 bin_PROGRAMS = gtf
diff --git a/xorg-server/hw/xfree86/x86emu/Makefile.am b/xorg-server/hw/xfree86/x86emu/Makefile.am
index bcacb331c..e7368f531 100644
--- a/xorg-server/hw/xfree86/x86emu/Makefile.am
+++ b/xorg-server/hw/xfree86/x86emu/Makefile.am
@@ -1,4 +1,6 @@
+if INT10_X86EMU
 noinst_LTLIBRARIES = libx86emu.la
+endif
 
 libx86emu_la_SOURCES = debug.c \
                       decode.c \
diff --git a/xorg-server/mi/micmap.c b/xorg-server/mi/micmap.c
index f6d760b2f..5a1e60a16 100644
--- a/xorg-server/mi/micmap.c
+++ b/xorg-server/mi/micmap.c
@@ -1,684 +1,678 @@
-/************************************************************
-Copyright 1987 by Sun Microsystems, Inc. Mountain View, CA.
-
-                    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 no-
-tice  appear  in all copies and that both that copyright no-
-tice and this permission notice appear in  supporting  docu-
-mentation,  and  that the names of Sun or X Consortium
-not be used in advertising or publicity pertaining to 
-distribution  of  the software  without specific prior 
-written permission. Sun and X Consortium make no 
-representations about the suitability of this software for 
-any purpose. It is provided "as is" without any express or 
-implied warranty.
-
-SUN DISCLAIMS ALL WARRANTIES WITH REGARD TO  THIS  SOFTWARE,
-INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FIT-
-NESS FOR A PARTICULAR PURPOSE. IN NO EVENT SHALL SUN BE  LI-
-ABLE  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.
-
-********************************************************/
-
-/*
- * This is based on cfbcmap.c.  The functions here are useful independently
- * of cfb, which is the reason for including them here.  How "mi" these
- * are may be debatable.
- */
-
-
-#ifdef HAVE_DIX_CONFIG_H
-#include <dix-config.h>
-#endif
-
-#include <X11/X.h>
-#include <X11/Xproto.h>
-#include "scrnintstr.h"
-#include "colormapst.h"
-#include "resource.h"
-#include "globals.h"
-#include "micmap.h"
-
-ColormapPtr miInstalledMaps[MAXSCREENS];
-
-int
-miListInstalledColormaps(ScreenPtr pScreen, Colormap *pmaps)
-{
-    if (miInstalledMaps[pScreen->myNum]) {
-	*pmaps = miInstalledMaps[pScreen->myNum]->mid;
-	return (1);
-    }
-    return 0;
-}
-
-void
-miInstallColormap(ColormapPtr pmap)
-{
-    int index = pmap->pScreen->myNum;
-    ColormapPtr oldpmap = miInstalledMaps[index];
-
-    if(pmap != oldpmap)
-    {
-	/* Uninstall pInstalledMap. No hardware changes required, just
-	 * notify all interested parties. */
-	if(oldpmap != (ColormapPtr)None)
-	    WalkTree(pmap->pScreen, TellLostMap, (char *)&oldpmap->mid);
-	/* Install pmap */
-	miInstalledMaps[index] = pmap;
-	WalkTree(pmap->pScreen, TellGainedMap, (char *)&pmap->mid);
-
-    }
-}
-
-void
-miUninstallColormap(ColormapPtr pmap)
-{
-    int index = pmap->pScreen->myNum;
-    ColormapPtr curpmap = miInstalledMaps[index];
-
-    if(pmap == curpmap)
-    {
-	if (pmap->mid != pmap->pScreen->defColormap)
-	{
-	    dixLookupResourceByType((pointer *)&curpmap,
-				    pmap->pScreen->defColormap,
-				    RT_COLORMAP, serverClient,
-				    DixUseAccess);
-	    (*pmap->pScreen->InstallColormap)(curpmap);
-	}
-    }
-}
-
-void
-miResolveColor(unsigned short *pred, unsigned short *pgreen,
-		unsigned short *pblue, VisualPtr pVisual)
-{
-    int shift = 16 - pVisual->bitsPerRGBValue;
-    unsigned lim = (1 << pVisual->bitsPerRGBValue) - 1;
-
-    if ((pVisual->class | DynamicClass) == GrayScale)
-    {
-	/* rescale to gray then rgb bits */
-	*pred = (30L * *pred + 59L * *pgreen + 11L * *pblue) / 100;
-	*pblue = *pgreen = *pred = ((*pred >> shift) * 65535) / lim;
-    }
-    else
-    {
-	/* rescale to rgb bits */
-	*pred = ((*pred >> shift) * 65535) / lim;
-	*pgreen = ((*pgreen >> shift) * 65535) / lim;
-	*pblue = ((*pblue >> shift) * 65535) / lim;
-    }
-}
-
-Bool
-miInitializeColormap(ColormapPtr pmap)
-{
-    unsigned i;
-    VisualPtr pVisual;
-    unsigned lim, maxent, shift;
-
-    pVisual = pmap->pVisual;
-    lim = (1 << pVisual->bitsPerRGBValue) - 1;
-    shift = 16 - pVisual->bitsPerRGBValue;
-    maxent = pVisual->ColormapEntries - 1;
-    if (pVisual->class == TrueColor)
-    {
-	unsigned limr, limg, limb;
-
-	limr = pVisual->redMask >> pVisual->offsetRed;
-	for(i = 0; i <= min(limr,maxent); i++)
-	{
-	    /* rescale to [0..65535] then rgb bits */
-	    pmap->red[i].co.local.red =
-		((((i * 65535) / limr) >> shift) * 65535) / lim;
-	}
-	for(; i <= maxent; i++) pmap->red[i].co.local.red = 65535;
-	limg = pVisual->greenMask >> pVisual->offsetGreen;
-	for(i = 0; i <= min(limg,maxent); i++)
-	{
-	    /* rescale to [0..65535] then rgb bits */
-	    pmap->green[i].co.local.green =
-		((((i * 65535) / limg) >> shift) * 65535) / lim;
-	}
-	for(; i <= maxent; i++) pmap->green[i].co.local.green = 65535;
-	limb = pVisual->blueMask >> pVisual->offsetBlue;
-	for(i = 0; i <= min(limb,maxent); i++)
-	{
-	    /* rescale to [0..65535] then rgb bits */
-	    pmap->blue[i].co.local.blue =
-		((((i * 65535) / limb) >> shift) * 65535) / lim;
-	}
-	for(; i <= maxent; i++) pmap->blue[i].co.local.blue = 65535;
-    }
-    else if (pVisual->class == StaticColor)
-    {
-	unsigned limr, limg, limb;
-
-	limr = pVisual->redMask >> pVisual->offsetRed;
-	limg = pVisual->greenMask >> pVisual->offsetGreen;
-	limb = pVisual->blueMask >> pVisual->offsetBlue;
-	for(i = 0; i <= maxent; i++)
-	{
-	    /* rescale to [0..65535] then rgb bits */
-	    pmap->red[i].co.local.red =
-		((((((i & pVisual->redMask) >> pVisual->offsetRed)
-		    * 65535) / limr) >> shift) * 65535) / lim;
-	    pmap->red[i].co.local.green =
-		((((((i & pVisual->greenMask) >> pVisual->offsetGreen)
-		    * 65535) / limg) >> shift) * 65535) / lim;
-	    pmap->red[i].co.local.blue =
-		((((((i & pVisual->blueMask) >> pVisual->offsetBlue)
-		    * 65535) / limb) >> shift) * 65535) / lim;
-	}
-    }
-    else if (pVisual->class == StaticGray)
-    {
-	for(i = 0; i <= maxent; i++)
-	{
-	    /* rescale to [0..65535] then rgb bits */
-	    pmap->red[i].co.local.red = ((((i * 65535) / maxent) >> shift)
-					 * 65535) / lim;
-	    pmap->red[i].co.local.green = pmap->red[i].co.local.red;
-	    pmap->red[i].co.local.blue = pmap->red[i].co.local.red;
-	}
-    }
-    return TRUE;
-}
-
-/* When simulating DirectColor on PseudoColor hardware, multiple
-   entries of the colormap must be updated
- */
-
-#define AddElement(mask) { \
-    pixel = red | green | blue; \
-    for (i = 0; i < nresult; i++) \
-  	if (outdefs[i].pixel == pixel) \
-    	    break; \
-    if (i == nresult) \
-    { \
-   	nresult++; \
-	outdefs[i].pixel = pixel; \
-	outdefs[i].flags = 0; \
-    } \
-    outdefs[i].flags |= (mask); \
-    outdefs[i].red = pmap->red[red >> pVisual->offsetRed].co.local.red; \
-    outdefs[i].green = pmap->green[green >> pVisual->offsetGreen].co.local.green; \
-    outdefs[i].blue = pmap->blue[blue >> pVisual->offsetBlue].co.local.blue; \
-}
-
-int
-miExpandDirectColors(ColormapPtr pmap, int ndef, xColorItem *indefs,
-			xColorItem *outdefs)
-{
-    int	        red, green, blue;
-    int	        maxred, maxgreen, maxblue;
-    int	        stepred, stepgreen, stepblue;
-    VisualPtr   pVisual;
-    int         pixel;
-    int         nresult;
-    int         i;
-
-    pVisual = pmap->pVisual;
-
-    stepred = 1 << pVisual->offsetRed;
-    stepgreen = 1 << pVisual->offsetGreen;
-    stepblue = 1 << pVisual->offsetBlue;
-    maxred = pVisual->redMask;
-    maxgreen = pVisual->greenMask;
-    maxblue = pVisual->blueMask;
-    nresult = 0;
-    for (;ndef--; indefs++)
-    {
-	if (indefs->flags & DoRed)
-	{
-	    red = indefs->pixel & pVisual->redMask;
-    	    for (green = 0; green <= maxgreen; green += stepgreen)
-    	    {
-	    	for (blue = 0; blue <= maxblue; blue += stepblue)
-	    	{
-		    AddElement (DoRed)
-	    	}
-    	    }
-	}
-	if (indefs->flags & DoGreen)
-	{
-	    green = indefs->pixel & pVisual->greenMask;
-    	    for (red = 0; red <= maxred; red += stepred)
-    	    {
-	    	for (blue = 0; blue <= maxblue; blue += stepblue)
-	    	{
-		    AddElement (DoGreen)
-	    	}
-    	    }
-	}
-	if (indefs->flags & DoBlue)
-	{
-	    blue = indefs->pixel & pVisual->blueMask;
-    	    for (red = 0; red <= maxred; red += stepred)
-    	    {
-	    	for (green = 0; green <= maxgreen; green += stepgreen)
-	    	{
-		    AddElement (DoBlue)
-	    	}
-    	    }
-	}
-    }
-    return nresult;
-}
-
-Bool
-miCreateDefColormap(ScreenPtr pScreen)
-{
-/* 
- * In the following sources PC X server vendors may want to delete 
- * "_not_tog" from "#ifdef WIN32_not_tog"
- */
-#ifdef WIN32_not_tog
-    /*  
-     * these are the MS-Windows desktop colors, adjusted for X's 16-bit 
-     * color specifications.
-     */
-    static xColorItem citems[] = {
-	{   0,      0,      0,      0, 0, 0 },
-	{   1, 0x8000,      0,      0, 0, 0 },
-	{   2,      0, 0x8000,      0, 0, 0 },
-	{   3, 0x8000, 0x8000,      0, 0, 0 },
-	{   4,      0,      0, 0x8000, 0, 0 },
-	{   5, 0x8000,      0, 0x8000, 0, 0 },
-	{   6,      0, 0x8000, 0x8000, 0, 0 },
-	{   7, 0xc000, 0xc000, 0xc000, 0, 0 },
-	{   8, 0xc000, 0xdc00, 0xc000, 0, 0 },
-	{   9, 0xa600, 0xca00, 0xf000, 0, 0 },
-	{ 246, 0xff00, 0xfb00, 0xf000, 0, 0 },
-	{ 247, 0xa000, 0xa000, 0xa400, 0, 0 },
-	{ 248, 0x8000, 0x8000, 0x8000, 0, 0 },
-	{ 249, 0xff00,      0,      0, 0, 0 },
-	{ 250,      0, 0xff00,      0, 0, 0 },
-	{ 251, 0xff00, 0xff00,      0, 0, 0 },
-	{ 252,      0,      0, 0xff00, 0, 0 },
-	{ 253, 0xff00,      0, 0xff00, 0, 0 },
-	{ 254,      0, 0xff00, 0xff00, 0, 0 },
-	{ 255, 0xff00, 0xff00, 0xff00, 0, 0 }
-    };
-#define NUM_DESKTOP_COLORS sizeof citems / sizeof citems[0]
-    int i;
-#else
-    unsigned short	zero = 0, ones = 0xFFFF;
-#endif
-    Pixel wp, bp;
-    VisualPtr	pVisual;
-    ColormapPtr	cmap;
-    int alloctype;
-    
-    for (pVisual = pScreen->visuals;
-	 pVisual->vid != pScreen->rootVisual;
-	 pVisual++)
-	;
-
-    if (pScreen->rootDepth == 1 || (pVisual->class & DynamicClass))
-	alloctype = AllocNone;
-    else
-	alloctype = AllocAll;
-
-    if (CreateColormap(pScreen->defColormap, pScreen, pVisual, &cmap,
-		       alloctype, 0) != Success)
-	return FALSE;
-
-    if (pScreen->rootDepth > 1) {
-	wp = pScreen->whitePixel;
-	bp = pScreen->blackPixel;
-#ifdef WIN32_not_tog
-	for (i = 0; i < NUM_DESKTOP_COLORS; i++) {
-	    if (AllocColor (cmap,
-			    &citems[i].red, &citems[i].green, &citems[i].blue,
-			    &citems[i].pixel, 0) != Success)
-		return FALSE;
-	}
-#else
-	if ((AllocColor(cmap, &ones, &ones, &ones, &wp, 0) !=
-       	       Success) ||
-	    (AllocColor(cmap, &zero, &zero, &zero, &bp, 0) !=
-       	       Success))
-    	    return FALSE;
-	pScreen->whitePixel = wp;
-	pScreen->blackPixel = bp;
-#endif
-    }
-
-    (*pScreen->InstallColormap)(cmap);
-    return TRUE;
-}
-
-/*
- * Default true color bitmasks, should be overridden by
- * driver
- */
-
-#define _RZ(d) ((d + 2) / 3)
-#define _RS(d) 0
-#define _RM(d) ((1 << _RZ(d)) - 1)
-#define _GZ(d) ((d - _RZ(d) + 1) / 2)
-#define _GS(d) _RZ(d)
-#define _GM(d) (((1 << _GZ(d)) - 1) << _GS(d))
-#define _BZ(d) (d - _RZ(d) - _GZ(d))
-#define _BS(d) (_RZ(d) + _GZ(d))
-#define _BM(d) (((1 << _BZ(d)) - 1) << _BS(d))
-#define _CE(d) (1 << _RZ(d))
-
-typedef struct _miVisuals {
-    struct _miVisuals	*next;
-    int			depth;
-    int			bitsPerRGB;
-    int			visuals;
-    int			count;
-    int			preferredCVC;
-    Pixel		redMask, greenMask, blueMask;
-} miVisualsRec, *miVisualsPtr;
-
-static int  miVisualPriority[] = {
-    PseudoColor, GrayScale, StaticColor, TrueColor, DirectColor, StaticGray
-};
-
-#define NUM_PRIORITY	6
-
-static miVisualsPtr	miVisuals;
-
-void
-miClearVisualTypes(void)
-{
-    miVisualsPtr v;
-
-    while ((v = miVisuals)) {
-	miVisuals = v->next;
-	xfree(v);
-    }
-}
-
-
-Bool
-miSetVisualTypesAndMasks(int depth, int visuals, int bitsPerRGB, 
-			 int preferredCVC,
-			 Pixel redMask, Pixel greenMask, Pixel blueMask)
-{
-    miVisualsPtr   new, *prev, v;
-    int		    count;
-
-    new = xalloc (sizeof *new);
-    if (!new)
-	return FALSE;
-    if (!redMask || !greenMask || !blueMask)
-    {
-	redMask = _RM(depth);
-	greenMask = _GM(depth);
-	blueMask = _BM(depth);
-    }
-    new->next = 0;
-    new->depth = depth;
-    new->visuals = visuals;
-    new->bitsPerRGB = bitsPerRGB;
-    new->preferredCVC = preferredCVC;
-    new->redMask = redMask;
-    new->greenMask = greenMask;
-    new->blueMask = blueMask;
-    count = (visuals >> 1) & 033333333333;
-    count = visuals - count - ((count >> 1) & 033333333333);
-    count = (((count + (count >> 3)) & 030707070707) % 077);	/* HAKMEM 169 */
-    new->count = count;
-    for (prev = &miVisuals; (v = *prev); prev = &v->next);
-    *prev = new;
-    return TRUE;
-}
-
-Bool
-miSetVisualTypes(int depth, int visuals, int bitsPerRGB, int preferredCVC)
-{
-    return miSetVisualTypesAndMasks (depth, visuals, bitsPerRGB,
-				     preferredCVC, 0, 0, 0);
-}
-
-int
-miGetDefaultVisualMask(int depth)
-{
-    if (depth > MAX_PSEUDO_DEPTH)
-	return LARGE_VISUALS;
-    else if (depth >= MIN_TRUE_DEPTH)
-	return ALL_VISUALS;
-    else if (depth == 1)
-	return StaticGrayMask;
-    else
-	return SMALL_VISUALS;
-}
-
-static Bool
-miVisualTypesSet (int depth)
-{
-    miVisualsPtr    visuals;
-
-    for (visuals = miVisuals; visuals; visuals = visuals->next)
-	if (visuals->depth == depth)
-	    return TRUE;
-    return FALSE;
-}
-
-Bool
-miSetPixmapDepths (void)
-{
-    int	d, f;
-    
-    /* Add any unlisted depths from the pixmap formats */
-    for (f = 0; f < screenInfo.numPixmapFormats; f++) 
-    {
-	d = screenInfo.formats[f].depth;
-	if (!miVisualTypesSet (d))
-	{
-	    if (!miSetVisualTypes (d, 0, 0, -1))
-		return FALSE;
-	}
-    }
-    return TRUE;
-}
-
-/*
- * Distance to least significant one bit
- */
-static int
-maskShift (Pixel p)
-{
-    int	s;
-
-    if (!p) return 0;
-    s = 0;
-    while (!(p & 1))
-    {
-	s++;
-	p >>= 1;
-    }
-    return s;
-}
-
-/*
- * Given a list of formats for a screen, create a list
- * of visuals and depths for the screen which corespond to
- * the set which can be used with this version of cfb.
- */
-
-Bool
-miInitVisuals(VisualPtr *visualp, DepthPtr *depthp, int *nvisualp,
-		int *ndepthp, int *rootDepthp, VisualID *defaultVisp,
-		unsigned long sizes, int bitsPerRGB, int preferredVis)
-
-{
-    int		i, j = 0, k;
-    VisualPtr	visual;
-    DepthPtr	depth;
-    VisualID	*vid;
-    int		d, b;
-    int		f;
-    int		ndepth, nvisual;
-    int		nvtype;
-    int		vtype;
-    miVisualsPtr   visuals, nextVisuals;
-    int		*preferredCVCs, *prefp;
-    int		first_depth;
-
-    /* none specified, we'll guess from pixmap formats */
-    if (!miVisuals) 
-    {
-    	for (f = 0; f < screenInfo.numPixmapFormats; f++) 
-    	{
-	    d = screenInfo.formats[f].depth;
-	    b = screenInfo.formats[f].bitsPerPixel;
-	    if (sizes & (1 << (b - 1)))
-		vtype = miGetDefaultVisualMask(d);
-	    else
-		vtype = 0;
-	    if (!miSetVisualTypes (d, vtype, bitsPerRGB, -1))
-		return FALSE;
-    	}
-    }
-    nvisual = 0;
-    ndepth = 0;
-    for (visuals = miVisuals; visuals; visuals = nextVisuals) 
-    {
-	nextVisuals = visuals->next;
-	ndepth++;
-	nvisual += visuals->count;
-    }
-    depth = xalloc (ndepth * sizeof (DepthRec));
-    visual = xalloc (nvisual * sizeof (VisualRec));
-    preferredCVCs = xalloc(ndepth * sizeof(int));
-    if (!depth || !visual || !preferredCVCs)
-    {
-	xfree (depth);
-	xfree (visual);
-	xfree (preferredCVCs);
-	return FALSE;
-    }
-    *depthp = depth;
-    *visualp = visual;
-    *ndepthp = ndepth;
-    *nvisualp = nvisual;
-    prefp = preferredCVCs;
-    for (visuals = miVisuals; visuals; visuals = nextVisuals) 
-    {
-	nextVisuals = visuals->next;
-	d = visuals->depth;
-	vtype = visuals->visuals;
-	nvtype = visuals->count;
-	*prefp = visuals->preferredCVC;
-	prefp++;
-	vid = NULL;
-	if (nvtype)
-	{
-	    vid = xalloc (nvtype * sizeof (VisualID));
-	    if (!vid) {
-		xfree(preferredCVCs);
-		return FALSE;
-	    }
-	}
-	depth->depth = d;
-	depth->numVids = nvtype;
-	depth->vids = vid;
-	depth++;
-	for (i = 0; i < NUM_PRIORITY; i++) {
-	    if (! (vtype & (1 << miVisualPriority[i])))
-		continue;
-	    visual->class = miVisualPriority[i];
-	    visual->bitsPerRGBValue = visuals->bitsPerRGB;
-	    visual->ColormapEntries = 1 << d;
-	    visual->nplanes = d;
-	    visual->vid = *vid = FakeClientID (0);
-	    switch (visual->class) {
-	    case PseudoColor:
-	    case GrayScale:
-	    case StaticGray:
-		visual->redMask = 0;
-		visual->greenMask =  0;
-		visual->blueMask =  0;
-		visual->offsetRed  =  0;
-		visual->offsetGreen = 0;
-		visual->offsetBlue =  0;
-		break;
-	    case DirectColor:
-	    case TrueColor:
-		visual->ColormapEntries = _CE(d);
-		/* fall through */
-	    case StaticColor:
-		visual->redMask =  visuals->redMask;
-		visual->greenMask =  visuals->greenMask;
-		visual->blueMask =  visuals->blueMask;
-		visual->offsetRed  =  maskShift (visuals->redMask);
-		visual->offsetGreen = maskShift (visuals->greenMask);
-		visual->offsetBlue =  maskShift (visuals->blueMask);
-	    }
-	    vid++;
-	    visual++;
-	}
-	xfree (visuals);
-    }
-    miVisuals = NULL;
-    visual = *visualp;
-    depth = *depthp;
-
-    /*
-     * if we did not supplyied by a preferred visual class
-     * check if there is a preferred class in one of the depth
-     * structures - if there is, we want to start looking for the
-     * default visual/depth from that depth.
-     */
-    first_depth = 0;
-    if (preferredVis < 0 && defaultColorVisualClass < 0 ) {
-       for (i = 0; i < ndepth; i++) {
-	  if (preferredCVCs[i] >= 0) {
-	     first_depth = i;
-	     break;
-	  }
-       }
-    }
-
-    for (i = first_depth; i < ndepth; i++)
-    {
-	int prefColorVisualClass = -1;
-
-	if (defaultColorVisualClass >= 0)
-	    prefColorVisualClass = defaultColorVisualClass;
-	else if (preferredVis >= 0)
-	    prefColorVisualClass = preferredVis;
-	else if (preferredCVCs[i] >= 0)
-	    prefColorVisualClass = preferredCVCs[i];
-
-	if (*rootDepthp && *rootDepthp != depth[i].depth)
-	    continue;
-	
-	for (j = 0; j < depth[i].numVids; j++)
-	{
-	    for (k = 0; k < nvisual; k++)
-		if (visual[k].vid == depth[i].vids[j])
-		    break;
-	    if (k == nvisual)
-		continue;
-	    if (prefColorVisualClass < 0 ||
-		visual[k].class == prefColorVisualClass)
-		break;
-	}
-	if (j != depth[i].numVids)
-	    break;
-    }
-    if (i == ndepth) {
-	i = 0;
-	j = 0;
-    }
-    *rootDepthp = depth[i].depth;
-    *defaultVisp = depth[i].vids[j];
-    xfree(preferredCVCs);
-
-    return TRUE;
-}
+/*

+ * Copyright © 1987 Sun Microsystems, Inc.  All rights reserved.

+ *

+ * 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 (including the next

+ * paragraph) 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 AUTHORS OR COPYRIGHT HOLDERS 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.

+ */

+

+/*

+ * This is based on cfbcmap.c.  The functions here are useful independently

+ * of cfb, which is the reason for including them here.  How "mi" these

+ * are may be debatable.

+ */

+

+

+#ifdef HAVE_DIX_CONFIG_H

+#include <dix-config.h>

+#endif

+

+#include <X11/X.h>

+#include <X11/Xproto.h>

+#include "scrnintstr.h"

+#include "colormapst.h"

+#include "resource.h"

+#include "globals.h"

+#include "micmap.h"

+

+ColormapPtr miInstalledMaps[MAXSCREENS];

+

+int

+miListInstalledColormaps(ScreenPtr pScreen, Colormap *pmaps)

+{

+    if (miInstalledMaps[pScreen->myNum]) {

+	*pmaps = miInstalledMaps[pScreen->myNum]->mid;

+	return (1);

+    }

+    return 0;

+}

+

+void

+miInstallColormap(ColormapPtr pmap)

+{

+    int index = pmap->pScreen->myNum;

+    ColormapPtr oldpmap = miInstalledMaps[index];

+

+    if(pmap != oldpmap)

+    {

+	/* Uninstall pInstalledMap. No hardware changes required, just

+	 * notify all interested parties. */

+	if(oldpmap != (ColormapPtr)None)

+	    WalkTree(pmap->pScreen, TellLostMap, (char *)&oldpmap->mid);

+	/* Install pmap */

+	miInstalledMaps[index] = pmap;

+	WalkTree(pmap->pScreen, TellGainedMap, (char *)&pmap->mid);

+

+    }

+}

+

+void

+miUninstallColormap(ColormapPtr pmap)

+{

+    int index = pmap->pScreen->myNum;

+    ColormapPtr curpmap = miInstalledMaps[index];

+

+    if(pmap == curpmap)

+    {

+	if (pmap->mid != pmap->pScreen->defColormap)

+	{

+	    dixLookupResourceByType((pointer *)&curpmap,

+				    pmap->pScreen->defColormap,

+				    RT_COLORMAP, serverClient,

+				    DixUseAccess);

+	    (*pmap->pScreen->InstallColormap)(curpmap);

+	}

+    }

+}

+

+void

+miResolveColor(unsigned short *pred, unsigned short *pgreen,

+		unsigned short *pblue, VisualPtr pVisual)

+{

+    int shift = 16 - pVisual->bitsPerRGBValue;

+    unsigned lim = (1 << pVisual->bitsPerRGBValue) - 1;

+

+    if ((pVisual->class | DynamicClass) == GrayScale)

+    {

+	/* rescale to gray then rgb bits */

+	*pred = (30L * *pred + 59L * *pgreen + 11L * *pblue) / 100;

+	*pblue = *pgreen = *pred = ((*pred >> shift) * 65535) / lim;

+    }

+    else

+    {

+	/* rescale to rgb bits */

+	*pred = ((*pred >> shift) * 65535) / lim;

+	*pgreen = ((*pgreen >> shift) * 65535) / lim;

+	*pblue = ((*pblue >> shift) * 65535) / lim;

+    }

+}

+

+Bool

+miInitializeColormap(ColormapPtr pmap)

+{

+    unsigned i;

+    VisualPtr pVisual;

+    unsigned lim, maxent, shift;

+

+    pVisual = pmap->pVisual;

+    lim = (1 << pVisual->bitsPerRGBValue) - 1;

+    shift = 16 - pVisual->bitsPerRGBValue;

+    maxent = pVisual->ColormapEntries - 1;

+    if (pVisual->class == TrueColor)

+    {

+	unsigned limr, limg, limb;

+

+	limr = pVisual->redMask >> pVisual->offsetRed;

+	for(i = 0; i <= min(limr,maxent); i++)

+	{

+	    /* rescale to [0..65535] then rgb bits */

+	    pmap->red[i].co.local.red =

+		((((i * 65535) / limr) >> shift) * 65535) / lim;

+	}

+	for(; i <= maxent; i++) pmap->red[i].co.local.red = 65535;

+	limg = pVisual->greenMask >> pVisual->offsetGreen;

+	for(i = 0; i <= min(limg,maxent); i++)

+	{

+	    /* rescale to [0..65535] then rgb bits */

+	    pmap->green[i].co.local.green =

+		((((i * 65535) / limg) >> shift) * 65535) / lim;

+	}

+	for(; i <= maxent; i++) pmap->green[i].co.local.green = 65535;

+	limb = pVisual->blueMask >> pVisual->offsetBlue;

+	for(i = 0; i <= min(limb,maxent); i++)

+	{

+	    /* rescale to [0..65535] then rgb bits */

+	    pmap->blue[i].co.local.blue =

+		((((i * 65535) / limb) >> shift) * 65535) / lim;

+	}

+	for(; i <= maxent; i++) pmap->blue[i].co.local.blue = 65535;

+    }

+    else if (pVisual->class == StaticColor)

+    {

+	unsigned limr, limg, limb;

+

+	limr = pVisual->redMask >> pVisual->offsetRed;

+	limg = pVisual->greenMask >> pVisual->offsetGreen;

+	limb = pVisual->blueMask >> pVisual->offsetBlue;

+	for(i = 0; i <= maxent; i++)

+	{

+	    /* rescale to [0..65535] then rgb bits */

+	    pmap->red[i].co.local.red =

+		((((((i & pVisual->redMask) >> pVisual->offsetRed)

+		    * 65535) / limr) >> shift) * 65535) / lim;

+	    pmap->red[i].co.local.green =

+		((((((i & pVisual->greenMask) >> pVisual->offsetGreen)

+		    * 65535) / limg) >> shift) * 65535) / lim;

+	    pmap->red[i].co.local.blue =

+		((((((i & pVisual->blueMask) >> pVisual->offsetBlue)

+		    * 65535) / limb) >> shift) * 65535) / lim;

+	}

+    }

+    else if (pVisual->class == StaticGray)

+    {

+	for(i = 0; i <= maxent; i++)

+	{

+	    /* rescale to [0..65535] then rgb bits */

+	    pmap->red[i].co.local.red = ((((i * 65535) / maxent) >> shift)

+					 * 65535) / lim;

+	    pmap->red[i].co.local.green = pmap->red[i].co.local.red;

+	    pmap->red[i].co.local.blue = pmap->red[i].co.local.red;

+	}

+    }

+    return TRUE;

+}

+

+/* When simulating DirectColor on PseudoColor hardware, multiple

+   entries of the colormap must be updated

+ */

+

+#define AddElement(mask) { \

+    pixel = red | green | blue; \

+    for (i = 0; i < nresult; i++) \

+  	if (outdefs[i].pixel == pixel) \

+    	    break; \

+    if (i == nresult) \

+    { \

+   	nresult++; \

+	outdefs[i].pixel = pixel; \

+	outdefs[i].flags = 0; \

+    } \

+    outdefs[i].flags |= (mask); \

+    outdefs[i].red = pmap->red[red >> pVisual->offsetRed].co.local.red; \

+    outdefs[i].green = pmap->green[green >> pVisual->offsetGreen].co.local.green; \

+    outdefs[i].blue = pmap->blue[blue >> pVisual->offsetBlue].co.local.blue; \

+}

+

+int

+miExpandDirectColors(ColormapPtr pmap, int ndef, xColorItem *indefs,

+			xColorItem *outdefs)

+{

+    int	        red, green, blue;

+    int	        maxred, maxgreen, maxblue;

+    int	        stepred, stepgreen, stepblue;

+    VisualPtr   pVisual;

+    int         pixel;

+    int         nresult;

+    int         i;

+

+    pVisual = pmap->pVisual;

+

+    stepred = 1 << pVisual->offsetRed;

+    stepgreen = 1 << pVisual->offsetGreen;

+    stepblue = 1 << pVisual->offsetBlue;

+    maxred = pVisual->redMask;

+    maxgreen = pVisual->greenMask;

+    maxblue = pVisual->blueMask;

+    nresult = 0;

+    for (;ndef--; indefs++)

+    {

+	if (indefs->flags & DoRed)

+	{

+	    red = indefs->pixel & pVisual->redMask;

+    	    for (green = 0; green <= maxgreen; green += stepgreen)

+    	    {

+	    	for (blue = 0; blue <= maxblue; blue += stepblue)

+	    	{

+		    AddElement (DoRed)

+	    	}

+    	    }

+	}

+	if (indefs->flags & DoGreen)

+	{

+	    green = indefs->pixel & pVisual->greenMask;

+    	    for (red = 0; red <= maxred; red += stepred)

+    	    {

+	    	for (blue = 0; blue <= maxblue; blue += stepblue)

+	    	{

+		    AddElement (DoGreen)

+	    	}

+    	    }

+	}

+	if (indefs->flags & DoBlue)

+	{

+	    blue = indefs->pixel & pVisual->blueMask;

+    	    for (red = 0; red <= maxred; red += stepred)

+    	    {

+	    	for (green = 0; green <= maxgreen; green += stepgreen)

+	    	{

+		    AddElement (DoBlue)

+	    	}

+    	    }

+	}

+    }

+    return nresult;

+}

+

+Bool

+miCreateDefColormap(ScreenPtr pScreen)

+{

+/* 

+ * In the following sources PC X server vendors may want to delete 

+ * "_not_tog" from "#ifdef WIN32_not_tog"

+ */

+#ifdef WIN32_not_tog

+    /*  

+     * these are the MS-Windows desktop colors, adjusted for X's 16-bit 

+     * color specifications.

+     */

+    static xColorItem citems[] = {

+	{   0,      0,      0,      0, 0, 0 },

+	{   1, 0x8000,      0,      0, 0, 0 },

+	{   2,      0, 0x8000,      0, 0, 0 },

+	{   3, 0x8000, 0x8000,      0, 0, 0 },

+	{   4,      0,      0, 0x8000, 0, 0 },

+	{   5, 0x8000,      0, 0x8000, 0, 0 },

+	{   6,      0, 0x8000, 0x8000, 0, 0 },

+	{   7, 0xc000, 0xc000, 0xc000, 0, 0 },

+	{   8, 0xc000, 0xdc00, 0xc000, 0, 0 },

+	{   9, 0xa600, 0xca00, 0xf000, 0, 0 },

+	{ 246, 0xff00, 0xfb00, 0xf000, 0, 0 },

+	{ 247, 0xa000, 0xa000, 0xa400, 0, 0 },

+	{ 248, 0x8000, 0x8000, 0x8000, 0, 0 },

+	{ 249, 0xff00,      0,      0, 0, 0 },

+	{ 250,      0, 0xff00,      0, 0, 0 },

+	{ 251, 0xff00, 0xff00,      0, 0, 0 },

+	{ 252,      0,      0, 0xff00, 0, 0 },

+	{ 253, 0xff00,      0, 0xff00, 0, 0 },

+	{ 254,      0, 0xff00, 0xff00, 0, 0 },

+	{ 255, 0xff00, 0xff00, 0xff00, 0, 0 }

+    };

+#define NUM_DESKTOP_COLORS sizeof citems / sizeof citems[0]

+    int i;

+#else

+    unsigned short	zero = 0, ones = 0xFFFF;

+#endif

+    Pixel wp, bp;

+    VisualPtr	pVisual;

+    ColormapPtr	cmap;

+    int alloctype;

+    

+    for (pVisual = pScreen->visuals;

+	 pVisual->vid != pScreen->rootVisual;

+	 pVisual++)

+	;

+

+    if (pScreen->rootDepth == 1 || (pVisual->class & DynamicClass))

+	alloctype = AllocNone;

+    else

+	alloctype = AllocAll;

+

+    if (CreateColormap(pScreen->defColormap, pScreen, pVisual, &cmap,

+		       alloctype, 0) != Success)

+	return FALSE;

+

+    if (pScreen->rootDepth > 1) {

+	wp = pScreen->whitePixel;

+	bp = pScreen->blackPixel;

+#ifdef WIN32_not_tog

+	for (i = 0; i < NUM_DESKTOP_COLORS; i++) {

+	    if (AllocColor (cmap,

+			    &citems[i].red, &citems[i].green, &citems[i].blue,

+			    &citems[i].pixel, 0) != Success)

+		return FALSE;

+	}

+#else

+	if ((AllocColor(cmap, &ones, &ones, &ones, &wp, 0) !=

+       	       Success) ||

+	    (AllocColor(cmap, &zero, &zero, &zero, &bp, 0) !=

+       	       Success))

+    	    return FALSE;

+	pScreen->whitePixel = wp;

+	pScreen->blackPixel = bp;

+#endif

+    }

+

+    (*pScreen->InstallColormap)(cmap);

+    return TRUE;

+}

+

+/*

+ * Default true color bitmasks, should be overridden by

+ * driver

+ */

+

+#define _RZ(d) ((d + 2) / 3)

+#define _RS(d) 0

+#define _RM(d) ((1 << _RZ(d)) - 1)

+#define _GZ(d) ((d - _RZ(d) + 1) / 2)

+#define _GS(d) _RZ(d)

+#define _GM(d) (((1 << _GZ(d)) - 1) << _GS(d))

+#define _BZ(d) (d - _RZ(d) - _GZ(d))

+#define _BS(d) (_RZ(d) + _GZ(d))

+#define _BM(d) (((1 << _BZ(d)) - 1) << _BS(d))

+#define _CE(d) (1 << _RZ(d))

+

+typedef struct _miVisuals {

+    struct _miVisuals	*next;

+    int			depth;

+    int			bitsPerRGB;

+    int			visuals;

+    int			count;

+    int			preferredCVC;

+    Pixel		redMask, greenMask, blueMask;

+} miVisualsRec, *miVisualsPtr;

+

+static int  miVisualPriority[] = {

+    PseudoColor, GrayScale, StaticColor, TrueColor, DirectColor, StaticGray

+};

+

+#define NUM_PRIORITY	6

+

+static miVisualsPtr	miVisuals;

+

+void

+miClearVisualTypes(void)

+{

+    miVisualsPtr v;

+

+    while ((v = miVisuals)) {

+	miVisuals = v->next;

+	xfree(v);

+    }

+}

+

+

+Bool

+miSetVisualTypesAndMasks(int depth, int visuals, int bitsPerRGB, 

+			 int preferredCVC,

+			 Pixel redMask, Pixel greenMask, Pixel blueMask)

+{

+    miVisualsPtr   new, *prev, v;

+    int		    count;

+

+    new = xalloc (sizeof *new);

+    if (!new)

+	return FALSE;

+    if (!redMask || !greenMask || !blueMask)

+    {

+	redMask = _RM(depth);

+	greenMask = _GM(depth);

+	blueMask = _BM(depth);

+    }

+    new->next = 0;

+    new->depth = depth;

+    new->visuals = visuals;

+    new->bitsPerRGB = bitsPerRGB;

+    new->preferredCVC = preferredCVC;

+    new->redMask = redMask;

+    new->greenMask = greenMask;

+    new->blueMask = blueMask;

+    count = (visuals >> 1) & 033333333333;

+    count = visuals - count - ((count >> 1) & 033333333333);

+    count = (((count + (count >> 3)) & 030707070707) % 077);	/* HAKMEM 169 */

+    new->count = count;

+    for (prev = &miVisuals; (v = *prev); prev = &v->next);

+    *prev = new;

+    return TRUE;

+}

+

+Bool

+miSetVisualTypes(int depth, int visuals, int bitsPerRGB, int preferredCVC)

+{

+    return miSetVisualTypesAndMasks (depth, visuals, bitsPerRGB,

+				     preferredCVC, 0, 0, 0);

+}

+

+int

+miGetDefaultVisualMask(int depth)

+{

+    if (depth > MAX_PSEUDO_DEPTH)

+	return LARGE_VISUALS;

+    else if (depth >= MIN_TRUE_DEPTH)

+	return ALL_VISUALS;

+    else if (depth == 1)

+	return StaticGrayMask;

+    else

+	return SMALL_VISUALS;

+}

+

+static Bool

+miVisualTypesSet (int depth)

+{

+    miVisualsPtr    visuals;

+

+    for (visuals = miVisuals; visuals; visuals = visuals->next)

+	if (visuals->depth == depth)

+	    return TRUE;

+    return FALSE;

+}

+

+Bool

+miSetPixmapDepths (void)

+{

+    int	d, f;

+    

+    /* Add any unlisted depths from the pixmap formats */

+    for (f = 0; f < screenInfo.numPixmapFormats; f++) 

+    {

+	d = screenInfo.formats[f].depth;

+	if (!miVisualTypesSet (d))

+	{

+	    if (!miSetVisualTypes (d, 0, 0, -1))

+		return FALSE;

+	}

+    }

+    return TRUE;

+}

+

+/*

+ * Distance to least significant one bit

+ */

+static int

+maskShift (Pixel p)

+{

+    int	s;

+

+    if (!p) return 0;

+    s = 0;

+    while (!(p & 1))

+    {

+	s++;

+	p >>= 1;

+    }

+    return s;

+}

+

+/*

+ * Given a list of formats for a screen, create a list

+ * of visuals and depths for the screen which corespond to

+ * the set which can be used with this version of cfb.

+ */

+

+Bool

+miInitVisuals(VisualPtr *visualp, DepthPtr *depthp, int *nvisualp,

+		int *ndepthp, int *rootDepthp, VisualID *defaultVisp,

+		unsigned long sizes, int bitsPerRGB, int preferredVis)

+

+{

+    int		i, j = 0, k;

+    VisualPtr	visual;

+    DepthPtr	depth;

+    VisualID	*vid;

+    int		d, b;

+    int		f;

+    int		ndepth, nvisual;

+    int		nvtype;

+    int		vtype;

+    miVisualsPtr   visuals, nextVisuals;

+    int		*preferredCVCs, *prefp;

+    int		first_depth;

+

+    /* none specified, we'll guess from pixmap formats */

+    if (!miVisuals) 

+    {

+    	for (f = 0; f < screenInfo.numPixmapFormats; f++) 

+    	{

+	    d = screenInfo.formats[f].depth;

+	    b = screenInfo.formats[f].bitsPerPixel;

+	    if (sizes & (1 << (b - 1)))

+		vtype = miGetDefaultVisualMask(d);

+	    else

+		vtype = 0;

+	    if (!miSetVisualTypes (d, vtype, bitsPerRGB, -1))

+		return FALSE;

+    	}

+    }

+    nvisual = 0;

+    ndepth = 0;

+    for (visuals = miVisuals; visuals; visuals = nextVisuals) 

+    {

+	nextVisuals = visuals->next;

+	ndepth++;

+	nvisual += visuals->count;

+    }

+    depth = xalloc (ndepth * sizeof (DepthRec));

+    visual = xalloc (nvisual * sizeof (VisualRec));

+    preferredCVCs = xalloc(ndepth * sizeof(int));

+    if (!depth || !visual || !preferredCVCs)

+    {

+	xfree (depth);

+	xfree (visual);

+	xfree (preferredCVCs);

+	return FALSE;

+    }

+    *depthp = depth;

+    *visualp = visual;

+    *ndepthp = ndepth;

+    *nvisualp = nvisual;

+    prefp = preferredCVCs;

+    for (visuals = miVisuals; visuals; visuals = nextVisuals) 

+    {

+	nextVisuals = visuals->next;

+	d = visuals->depth;

+	vtype = visuals->visuals;

+	nvtype = visuals->count;

+	*prefp = visuals->preferredCVC;

+	prefp++;

+	vid = NULL;

+	if (nvtype)

+	{

+	    vid = xalloc (nvtype * sizeof (VisualID));

+	    if (!vid) {

+		xfree(preferredCVCs);

+		return FALSE;

+	    }

+	}

+	depth->depth = d;

+	depth->numVids = nvtype;

+	depth->vids = vid;

+	depth++;

+	for (i = 0; i < NUM_PRIORITY; i++) {

+	    if (! (vtype & (1 << miVisualPriority[i])))

+		continue;

+	    visual->class = miVisualPriority[i];

+	    visual->bitsPerRGBValue = visuals->bitsPerRGB;

+	    visual->ColormapEntries = 1 << d;

+	    visual->nplanes = d;

+	    visual->vid = *vid = FakeClientID (0);

+	    switch (visual->class) {

+	    case PseudoColor:

+	    case GrayScale:

+	    case StaticGray:

+		visual->redMask = 0;

+		visual->greenMask =  0;

+		visual->blueMask =  0;

+		visual->offsetRed  =  0;

+		visual->offsetGreen = 0;

+		visual->offsetBlue =  0;

+		break;

+	    case DirectColor:

+	    case TrueColor:

+		visual->ColormapEntries = _CE(d);

+		/* fall through */

+	    case StaticColor:

+		visual->redMask =  visuals->redMask;

+		visual->greenMask =  visuals->greenMask;

+		visual->blueMask =  visuals->blueMask;

+		visual->offsetRed  =  maskShift (visuals->redMask);

+		visual->offsetGreen = maskShift (visuals->greenMask);

+		visual->offsetBlue =  maskShift (visuals->blueMask);

+	    }

+	    vid++;

+	    visual++;

+	}

+	xfree (visuals);

+    }

+    miVisuals = NULL;

+    visual = *visualp;

+    depth = *depthp;

+

+    /*

+     * if we did not supplyied by a preferred visual class

+     * check if there is a preferred class in one of the depth

+     * structures - if there is, we want to start looking for the

+     * default visual/depth from that depth.

+     */

+    first_depth = 0;

+    if (preferredVis < 0 && defaultColorVisualClass < 0 ) {

+       for (i = 0; i < ndepth; i++) {

+	  if (preferredCVCs[i] >= 0) {

+	     first_depth = i;

+	     break;

+	  }

+       }

+    }

+

+    for (i = first_depth; i < ndepth; i++)

+    {

+	int prefColorVisualClass = -1;

+

+	if (defaultColorVisualClass >= 0)

+	    prefColorVisualClass = defaultColorVisualClass;

+	else if (preferredVis >= 0)

+	    prefColorVisualClass = preferredVis;

+	else if (preferredCVCs[i] >= 0)

+	    prefColorVisualClass = preferredCVCs[i];

+

+	if (*rootDepthp && *rootDepthp != depth[i].depth)

+	    continue;

+	

+	for (j = 0; j < depth[i].numVids; j++)

+	{

+	    for (k = 0; k < nvisual; k++)

+		if (visual[k].vid == depth[i].vids[j])

+		    break;

+	    if (k == nvisual)

+		continue;

+	    if (prefColorVisualClass < 0 ||

+		visual[k].class == prefColorVisualClass)

+		break;

+	}

+	if (j != depth[i].numVids)

+	    break;

+    }

+    if (i == ndepth) {

+	i = 0;

+	j = 0;

+    }

+    *rootDepthp = depth[i].depth;

+    *defaultVisp = depth[i].vids[j];

+    xfree(preferredCVCs);

+

+    return TRUE;

+}

diff --git a/xorg-server/os/access.c b/xorg-server/os/access.c
index 2a171fa70..74c340a43 100644
--- a/xorg-server/os/access.c
+++ b/xorg-server/os/access.c
@@ -1,7 +1,6 @@
 /***********************************************************
 
 Copyright 1987, 1998  The Open Group
-Copyright 2004 Sun Microsystems, Inc.
 
 All rights reserved.
 
@@ -54,6 +53,29 @@ SOFTWARE.
 
 ******************************************************************/
 
+/*
+ * Copyright © 2004 Sun Microsystems, Inc.  All rights reserved.
+ *
+ * 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 (including the next
+ * paragraph) 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 AUTHORS OR COPYRIGHT HOLDERS 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.
+ */
+
 #ifdef HAVE_DIX_CONFIG_H
 #include <dix-config.h>
 #endif
diff --git a/xorg-server/os/log.c b/xorg-server/os/log.c
index c0fdb5703..e3a184721 100644
--- a/xorg-server/os/log.c
+++ b/xorg-server/os/log.c
@@ -1,601 +1,601 @@
-/*
-
-Copyright 1987, 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 1987 by Digital Equipment Corporation, Maynard, Massachusetts,
-Copyright 1994 Quarterdeck Office Systems.
-
-                        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 and
-Quarterdeck not be used in advertising or publicity pertaining to
-distribution of the software without specific, written prior
-permission.
-
-DIGITAL AND QUARTERDECK DISCLAIM ALL WARRANTIES WITH REGARD TO THIS
-SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
-FITNESS, IN NO EVENT SHALL DIGITAL 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.
-
-*/
-
-/*
- * Copyright (c) 1997-2003 by The XFree86 Project, Inc.
- *
- * 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 COPYRIGHT HOLDER(S) OR AUTHOR(S) 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 copyright holder(s)
- * and author(s) 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 copyright holder(s) and author(s).
- */
-
-
-#ifdef HAVE_DIX_CONFIG_H
-#include <dix-config.h>
-#endif
-
-#include <X11/Xos.h>
-#include <stdio.h>
-#include <time.h>
-#include <sys/stat.h>
-#include <stdarg.h>
-#include <stdlib.h>	/* for malloc() */
-#include <errno.h>
-
-#include "input.h"
-#include "site.h"
-#include "opaque.h"
-
-#ifdef WIN32
-#include <process.h>
-#ifndef _MSC_VER
-#define getpid(x) _getpid(x)
-#endif
-#endif
-
-#ifdef _MSC_VER
-#define S_ISREG(m)  (((m)&_S_IFMT) == _S_IFREG)
-#endif
-
-#ifdef XF86BIGFONT
-#define _XF86BIGFONT_SERVER_
-#include <X11/extensions/xf86bigfont.h>
-#endif
-
-#ifdef DDXOSVERRORF
-void (*OsVendorVErrorFProc)(const char *, va_list args) = NULL;
-#endif
-
-static FILE *logFile = NULL;
-static Bool logFlush = FALSE;
-static Bool logSync = FALSE;
-static int logVerbosity = DEFAULT_LOG_VERBOSITY;
-static int logFileVerbosity = DEFAULT_LOG_FILE_VERBOSITY;
-
-/* Buffer to information logged before the log file is opened. */
-static char *saveBuffer = NULL;
-static int bufferSize = 0, bufferUnused = 0, bufferPos = 0;
-static Bool needBuffer = TRUE;
-
-/* Prefix strings for log messages. */
-#ifndef X_UNKNOWN_STRING
-#define X_UNKNOWN_STRING		"(\?\?)"
-#endif
-#ifndef X_PROBE_STRING
-#define X_PROBE_STRING			"(--)"
-#endif
-#ifndef X_CONFIG_STRING
-#define X_CONFIG_STRING			"(**)"
-#endif
-#ifndef X_DEFAULT_STRING
-#define X_DEFAULT_STRING		"(==)"
-#endif
-#ifndef X_CMDLINE_STRING
-#define X_CMDLINE_STRING		"(++)"
-#endif
-#ifndef X_NOTICE_STRING
-#define X_NOTICE_STRING			"(!!)"
-#endif
-#ifndef X_ERROR_STRING
-#define X_ERROR_STRING			"(EE)"
-#endif
-#ifndef X_WARNING_STRING
-#define X_WARNING_STRING		"(WW)"
-#endif
-#ifndef X_INFO_STRING
-#define X_INFO_STRING			"(II)"
-#endif
-#ifndef X_NOT_IMPLEMENTED_STRING
-#define X_NOT_IMPLEMENTED_STRING	"(NI)"
-#endif
-
-/*
- * LogInit is called to start logging to a file.  It is also called (with
- * NULL arguments) when logging to a file is not wanted.  It must always be
- * called, otherwise log messages will continue to accumulate in a buffer.
- *
- * %s, if present in the fname or backup strings, is expanded to the display
- * string.
- */
-
-const char *
-LogInit(const char *fname, const char *backup)
-{
-    char *logFileName = NULL;
-
-    if (fname && *fname) {
-	/* xalloc() can't be used yet. */
-	logFileName = malloc(strlen(fname) + strlen(display) + 1);
-	if (!logFileName)
-	    FatalError("Cannot allocate space for the log file name\n");
-	sprintf(logFileName, fname, display);
-
-	if (backup && *backup) {
-	    struct stat buf;
-
-	    if (!stat(logFileName, &buf) && S_ISREG(buf.st_mode)) {
-		char *suffix;
-		char *oldLog;
-
-		oldLog = malloc(strlen(logFileName) + strlen(backup) +
-				strlen(display) + 1);
-		suffix = malloc(strlen(backup) + strlen(display) + 1);
-		if (!oldLog || !suffix)
-		    FatalError("Cannot allocate space for the log file name\n");
-		sprintf(suffix, backup, display);
-		sprintf(oldLog, "%s%s", logFileName, suffix);
-		free(suffix);
-		if (rename(logFileName, oldLog) == -1) {
-		    FatalError("Cannot move old log file (\"%s\" to \"%s\"\n",
-			       logFileName, oldLog);
-		}
-		free(oldLog);
-	    }
-	}
-	if ((logFile = fopen(logFileName, "w")) == NULL)
-	    FatalError("Cannot open log file \"%s\"\n", logFileName);
-	setvbuf(logFile, NULL, _IONBF, 0);
-
-	/* Flush saved log information. */
-	if (saveBuffer && bufferSize > 0) {
-	    fwrite(saveBuffer, bufferPos, 1, logFile);
-	    fflush(logFile);
-#ifndef WIN32
-	    fsync(fileno(logFile));
-#endif
-	}
-    }
-
-    /*
-     * Unconditionally free the buffer, and flag that the buffer is no longer
-     * needed.
-     */
-    if (saveBuffer && bufferSize > 0) {
-	free(saveBuffer);	/* Must be free(), not xfree() */
-	saveBuffer = NULL;
-	bufferSize = 0;
-    }
-    needBuffer = FALSE;
-
-    return logFileName;
-}
-
-void
-LogClose(void)
-{
-    if (logFile) {
-	fclose(logFile);
-	logFile = NULL;
-    }
-}
-
-Bool
-LogSetParameter(LogParameter param, int value)
-{
-    switch (param) {
-    case XLOG_FLUSH:
-	logFlush = value ? TRUE : FALSE;
-	return TRUE;
-    case XLOG_SYNC:
-	logSync = value ? TRUE : FALSE;
-	return TRUE;
-    case XLOG_VERBOSITY:
-	logVerbosity = value;
-	return TRUE;
-    case XLOG_FILE_VERBOSITY:
-	logFileVerbosity = value;
-	return TRUE;
-    default:
-	return FALSE;
-    }
-}
-
-/* This function does the actual log message writes. */
-
-void
-LogVWrite(int verb, const char *f, va_list args)
-{
-    char tmpBuffer[1024];
-    int len = 0;
-
-    /*
-     * Since a va_list can only be processed once, write the string to a
-     * buffer, and then write the buffer out to the appropriate output
-     * stream(s).
-     */
-    if (verb < 0 || logFileVerbosity >= verb || logVerbosity >= verb) {
-	vsnprintf(tmpBuffer, sizeof(tmpBuffer)-1, f, args);
-        tmpBuffer[sizeof(tmpBuffer)-1]=0;
-	len = strlen(tmpBuffer);
-    }
-    if ((verb < 0 || logVerbosity >= verb) && len > 0)
-	fwrite(tmpBuffer, len, 1, stderr);
-    if ((verb < 0 || logFileVerbosity >= verb) && len > 0) {
-	if (logFile) {
-	    fwrite(tmpBuffer, len, 1, logFile);
-	    if (logFlush) {
-		fflush(logFile);
-#ifndef WIN32
-		if (logSync)
-		    fsync(fileno(logFile));
-#endif
-	    }
-	} else if (needBuffer) {
-	    /*
-	     * Note, this code is used before OsInit() has been called, so
-	     * xalloc() and friends can't be used.
-	     */
-	    if (len > bufferUnused) {
-		bufferSize += 1024;
-		bufferUnused += 1024;
-		if (saveBuffer)
-		    saveBuffer = realloc(saveBuffer, bufferSize);
-		else
-		    saveBuffer = malloc(bufferSize);
-		if (!saveBuffer)
-		    FatalError("realloc() failed while saving log messages\n");
-	    }
-	    bufferUnused -= len;
-	    memcpy(saveBuffer + bufferPos, tmpBuffer, len);
-	    bufferPos += len;
-	}
-    }
-}
-
-void
-LogWrite(int verb, const char *f, ...)
-{
-    va_list args;
-
-    va_start(args, f);
-    LogVWrite(verb, f, args);
-    va_end(args);
-}
-
-void
-LogVMessageVerb(MessageType type, int verb, const char *format, va_list args)
-{
-    const char *s  = X_UNKNOWN_STRING;
-    char tmpBuf[1024];
-
-    /* Ignore verbosity for X_ERROR */
-    if (logVerbosity >= verb || logFileVerbosity >= verb || type == X_ERROR) {
-	switch (type) {
-	case X_PROBED:
-	    s = X_PROBE_STRING;
-	    break;
-	case X_CONFIG:
-	    s = X_CONFIG_STRING;
-	    break;
-	case X_DEFAULT:
-	    s = X_DEFAULT_STRING;
-	    break;
-	case X_CMDLINE:
-	    s = X_CMDLINE_STRING;
-	    break;
-	case X_NOTICE:
-	    s = X_NOTICE_STRING;
-	    break;
-	case X_ERROR:
-	    s = X_ERROR_STRING;
-	    if (verb > 0)
-		verb = 0;
-	    break;
-	case X_WARNING:
-	    s = X_WARNING_STRING;
-	    break;
-	case X_INFO:
-	    s = X_INFO_STRING;
-	    break;
-	case X_NOT_IMPLEMENTED:
-	    s = X_NOT_IMPLEMENTED_STRING;
-	    break;
-	case X_UNKNOWN:
-	    s = X_UNKNOWN_STRING;
-	    break;
-	case X_NONE:
-	    s = NULL;
-	    break;
-	}
-
-        /* if s is not NULL we need a space before format */
-        snprintf(tmpBuf, sizeof(tmpBuf), "%s%s%s", s ? s : "",
-                                                   s ? " " : "",
-                                                   format);
-        LogVWrite(verb, tmpBuf, args);
-    }
-}
-
-/* Log message with verbosity level specified. */
-void
-LogMessageVerb(MessageType type, int verb, const char *format, ...)
-{
-    va_list ap;
-
-    va_start(ap, format);
-    LogVMessageVerb(type, verb, format, ap);
-    va_end(ap);
-}
-
-/* Log a message with the standard verbosity level of 1. */
-void
-LogMessage(MessageType type, const char *format, ...)
-{
-    va_list ap;
-
-    va_start(ap, format);
-    LogVMessageVerb(type, 1, format, ap);
-    va_end(ap);
-}
-
-#ifdef __GNUC__
-void AbortServer(void) __attribute__((noreturn));
-#endif
-
-void
-AbortServer(void)
-{
-#ifdef XF86BIGFONT
-    XF86BigfontCleanup();
-#endif
-    CloseWellKnownConnections();
-    OsCleanup(TRUE);
-    CloseDownDevices();
-    AbortDDX();
-    fflush(stderr);
-    if (CoreDump)
-	abort();
-    exit (1);
-}
-
-#define AUDIT_PREFIX "AUDIT: %s: %ld: "
-#ifndef AUDIT_TIMEOUT
-#define AUDIT_TIMEOUT ((CARD32)(120 * 1000)) /* 2 mn */
-#endif
-
-static int nrepeat = 0;
-static int oldlen = -1;
-static OsTimerPtr auditTimer = NULL;
-
-void
-FreeAuditTimer(void)
-{
-    if (auditTimer != NULL) {
-	/* Force output of pending messages */
-	TimerForce(auditTimer);
-	TimerFree(auditTimer);
-	auditTimer = NULL;
-    }
-}
-
-static char *
-AuditPrefix(void)
-{
-    time_t tm;
-    char *autime, *s;
-    char *tmpBuf;
-    int len;
-
-    time(&tm);
-    autime = ctime(&tm);
-    if ((s = strchr(autime, '\n')))
-	*s = '\0';
-    len = strlen(AUDIT_PREFIX) + strlen(autime) + 10 + 1;
-    tmpBuf = malloc(len);
-    if (!tmpBuf)
-	return NULL;
-    snprintf(tmpBuf, len, AUDIT_PREFIX, autime, (unsigned long)getpid());
-    return tmpBuf;
-}
-
-void
-AuditF(const char * f, ...)
-{
-    va_list args;
-
-    va_start(args, f);
-
-    VAuditF(f, args);
-    va_end(args);
-}
-
-static CARD32
-AuditFlush(OsTimerPtr timer, CARD32 now, pointer arg)
-{
-    char *prefix;
-
-    if (nrepeat > 0) {
-	prefix = AuditPrefix();
-	ErrorF("%slast message repeated %d times\n",
-	       prefix != NULL ? prefix : "", nrepeat);
-	nrepeat = 0;
-	if (prefix != NULL)
-	    free(prefix);
-	return AUDIT_TIMEOUT;
-    } else {
-	/* if the timer expires without anything to print, flush the message */
-	oldlen = -1;
-	return 0;
-    }
-}
-
-void
-VAuditF(const char *f, va_list args)
-{
-    char *prefix;
-    char buf[1024];
-    int len;
-    static char oldbuf[1024];
-
-    prefix = AuditPrefix();
-    len = vsnprintf(buf, sizeof(buf), f, args);
-
-    if (len == oldlen && strcmp(buf, oldbuf) == 0) {
-	/* Message already seen */
-	nrepeat++;
-    } else {
-	/* new message */
-	if (auditTimer != NULL)
-	    TimerForce(auditTimer);
-	ErrorF("%s%s", prefix != NULL ? prefix : "", buf);
-	strlcpy(oldbuf, buf, sizeof(oldbuf));
-	oldlen = len;
-	nrepeat = 0;
-	auditTimer = TimerSet(auditTimer, 0, AUDIT_TIMEOUT, AuditFlush, NULL);
-    }
-    if (prefix != NULL)
-	free(prefix);
-}
-
-void
-FatalError(const char *f, ...)
-{
-    va_list args;
-    static Bool beenhere = FALSE;
-
-    if (beenhere)
-	ErrorF("\nFatalError re-entered, aborting\n");
-    else
-	ErrorF("\nFatal server error:\n");
-
-    va_start(args, f);
-    VErrorF(f, args);
-    va_end(args);
-    ErrorF("\n");
-    if (!beenhere)
-	OsVendorFatalError();
-    if (!beenhere) {
-	beenhere = TRUE;
-	AbortServer();
-    } else
-	abort();
-    /*NOTREACHED*/
-}
-
-void
-VErrorF(const char *f, va_list args)
-{
-#ifdef DDXOSVERRORF
-    if (OsVendorVErrorFProc)
-	OsVendorVErrorFProc(f, args);
-    else
-	LogVWrite(-1, f, args);
-#else
-    LogVWrite(-1, f, args);
-#endif
-}
-
-void
-ErrorF(const char * f, ...)
-{
-    va_list args;
-
-    va_start(args, f);
-    VErrorF(f, args);
-    va_end(args);
-}
-
-/* A perror() workalike. */
-
-void
-Error(char *str)
-{
-    char *err = NULL;
-    int saveErrno = errno;
-
-    if (str) {
-	err = malloc(strlen(strerror(saveErrno)) + strlen(str) + 2 + 1);
-	if (!err)
-	    return;
-	sprintf(err, "%s: ", str);
-	strcat(err, strerror(saveErrno));
-	LogWrite(-1, "%s", err);
-	free(err);
-    } else
-	LogWrite(-1, "%s", strerror(saveErrno));
-}
-
-void
-LogPrintMarkers(void)
-{
-    /* Show what the message marker symbols mean. */
-    ErrorF("Markers: ");
-    LogMessageVerb(X_PROBED, -1, "probed, ");
-    LogMessageVerb(X_CONFIG, -1, "from config file, ");
-    LogMessageVerb(X_DEFAULT, -1, "default setting,\n\t");
-    LogMessageVerb(X_CMDLINE, -1, "from command line, ");
-    LogMessageVerb(X_NOTICE, -1, "notice, ");
-    LogMessageVerb(X_INFO, -1, "informational,\n\t");
-    LogMessageVerb(X_WARNING, -1, "warning, ");
-    LogMessageVerb(X_ERROR, -1, "error, ");
-    LogMessageVerb(X_NOT_IMPLEMENTED, -1, "not implemented, ");
-    LogMessageVerb(X_UNKNOWN, -1, "unknown.\n");
-}
-
+/*

+

+Copyright 1987, 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 1987 by Digital Equipment Corporation, Maynard, Massachusetts,

+Copyright 1994 Quarterdeck Office Systems.

+

+                        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 and

+Quarterdeck not be used in advertising or publicity pertaining to

+distribution of the software without specific, written prior

+permission.

+

+DIGITAL AND QUARTERDECK DISCLAIM ALL WARRANTIES WITH REGARD TO THIS

+SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND

+FITNESS, IN NO EVENT SHALL DIGITAL 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.

+

+*/

+

+/*

+ * Copyright (c) 1997-2003 by The XFree86 Project, Inc.

+ *

+ * 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 COPYRIGHT HOLDER(S) OR AUTHOR(S) 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 copyright holder(s)

+ * and author(s) 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 copyright holder(s) and author(s).

+ */

+

+

+#ifdef HAVE_DIX_CONFIG_H

+#include <dix-config.h>

+#endif

+

+#include <X11/Xos.h>

+#include <stdio.h>

+#include <time.h>

+#include <sys/stat.h>

+#include <stdarg.h>

+#include <stdlib.h>	/* for malloc() */

+#include <errno.h>

+

+#include "input.h"

+#include "site.h"

+#include "opaque.h"

+

+#ifdef WIN32

+#include <process.h>

+#ifndef _MSC_VER

+#define getpid(x) _getpid(x)

+#endif

+#endif

+

+#ifdef _MSC_VER

+#define S_ISREG(m)  (((m)&_S_IFMT) == _S_IFREG)

+#endif

+

+#ifdef XF86BIGFONT

+#define _XF86BIGFONT_SERVER_

+#include <X11/extensions/xf86bigfont.h>

+#endif

+

+#ifdef DDXOSVERRORF

+void (*OsVendorVErrorFProc)(const char *, va_list args) = NULL;

+#endif

+

+static FILE *logFile = NULL;

+static Bool logFlush = FALSE;

+static Bool logSync = FALSE;

+static int logVerbosity = DEFAULT_LOG_VERBOSITY;

+static int logFileVerbosity = DEFAULT_LOG_FILE_VERBOSITY;

+

+/* Buffer to information logged before the log file is opened. */

+static char *saveBuffer = NULL;

+static int bufferSize = 0, bufferUnused = 0, bufferPos = 0;

+static Bool needBuffer = TRUE;

+

+/* Prefix strings for log messages. */

+#ifndef X_UNKNOWN_STRING

+#define X_UNKNOWN_STRING		"(\?\?)"

+#endif

+#ifndef X_PROBE_STRING

+#define X_PROBE_STRING			"(--)"

+#endif

+#ifndef X_CONFIG_STRING

+#define X_CONFIG_STRING			"(**)"

+#endif

+#ifndef X_DEFAULT_STRING

+#define X_DEFAULT_STRING		"(==)"

+#endif

+#ifndef X_CMDLINE_STRING

+#define X_CMDLINE_STRING		"(++)"

+#endif

+#ifndef X_NOTICE_STRING

+#define X_NOTICE_STRING			"(!!)"

+#endif

+#ifndef X_ERROR_STRING

+#define X_ERROR_STRING			"(EE)"

+#endif

+#ifndef X_WARNING_STRING

+#define X_WARNING_STRING		"(WW)"

+#endif

+#ifndef X_INFO_STRING

+#define X_INFO_STRING			"(II)"

+#endif

+#ifndef X_NOT_IMPLEMENTED_STRING

+#define X_NOT_IMPLEMENTED_STRING	"(NI)"

+#endif

+

+/*

+ * LogInit is called to start logging to a file.  It is also called (with

+ * NULL arguments) when logging to a file is not wanted.  It must always be

+ * called, otherwise log messages will continue to accumulate in a buffer.

+ *

+ * %s, if present in the fname or backup strings, is expanded to the display

+ * string.

+ */

+

+const char *

+LogInit(const char *fname, const char *backup)

+{

+    char *logFileName = NULL;

+

+    if (fname && *fname) {

+	/* xalloc() can't be used yet. */

+	logFileName = malloc(strlen(fname) + strlen(display) + 1);

+	if (!logFileName)

+	    FatalError("Cannot allocate space for the log file name\n");

+	sprintf(logFileName, fname, display);

+

+	if (backup && *backup) {

+	    struct stat buf;

+

+	    if (!stat(logFileName, &buf) && S_ISREG(buf.st_mode)) {

+		char *suffix;

+		char *oldLog;

+

+		oldLog = malloc(strlen(logFileName) + strlen(backup) +

+				strlen(display) + 1);

+		suffix = malloc(strlen(backup) + strlen(display) + 1);

+		if (!oldLog || !suffix)

+		    FatalError("Cannot allocate space for the log file name\n");

+		sprintf(suffix, backup, display);

+		sprintf(oldLog, "%s%s", logFileName, suffix);

+		free(suffix);

+		if (rename(logFileName, oldLog) == -1) {

+		    FatalError("Cannot move old log file (\"%s\" to \"%s\"\n",

+			       logFileName, oldLog);

+		}

+		free(oldLog);

+	    }

+	}

+	if ((logFile = fopen(logFileName, "w")) == NULL)

+	    FatalError("Cannot open log file \"%s\"\n", logFileName);

+	setvbuf(logFile, NULL, _IONBF, 0);

+

+	/* Flush saved log information. */

+	if (saveBuffer && bufferSize > 0) {

+	    fwrite(saveBuffer, bufferPos, 1, logFile);

+	    fflush(logFile);

+#ifndef WIN32

+	    fsync(fileno(logFile));

+#endif

+	}

+    }

+

+    /*

+     * Unconditionally free the buffer, and flag that the buffer is no longer

+     * needed.

+     */

+    if (saveBuffer && bufferSize > 0) {

+	free(saveBuffer);	/* Must be free(), not xfree() */

+	saveBuffer = NULL;

+	bufferSize = 0;

+    }

+    needBuffer = FALSE;

+

+    return logFileName;

+}

+

+void

+LogClose(void)

+{

+    if (logFile) {

+	fclose(logFile);

+	logFile = NULL;

+    }

+}

+

+Bool

+LogSetParameter(LogParameter param, int value)

+{

+    switch (param) {

+    case XLOG_FLUSH:

+	logFlush = value ? TRUE : FALSE;

+	return TRUE;

+    case XLOG_SYNC:

+	logSync = value ? TRUE : FALSE;

+	return TRUE;

+    case XLOG_VERBOSITY:

+	logVerbosity = value;

+	return TRUE;

+    case XLOG_FILE_VERBOSITY:

+	logFileVerbosity = value;

+	return TRUE;

+    default:

+	return FALSE;

+    }

+}

+

+/* This function does the actual log message writes. */

+

+void

+LogVWrite(int verb, const char *f, va_list args)

+{

+    char tmpBuffer[1024];

+    int len = 0;

+

+    /*

+     * Since a va_list can only be processed once, write the string to a

+     * buffer, and then write the buffer out to the appropriate output

+     * stream(s).

+     */

+    if (verb < 0 || logFileVerbosity >= verb || logVerbosity >= verb) {

+	vsnprintf(tmpBuffer, sizeof(tmpBuffer)-1, f, args);

+        tmpBuffer[sizeof(tmpBuffer)-1]=0;

+	len = strlen(tmpBuffer);

+    }

+    if ((verb < 0 || logVerbosity >= verb) && len > 0)

+	fwrite(tmpBuffer, len, 1, stderr);

+    if ((verb < 0 || logFileVerbosity >= verb) && len > 0) {

+	if (logFile) {

+	    fwrite(tmpBuffer, len, 1, logFile);

+	    if (logFlush) {

+		fflush(logFile);

+#ifndef WIN32

+		if (logSync)

+		    fsync(fileno(logFile));

+#endif

+	    }

+	} else if (needBuffer) {

+	    /*

+	     * Note, this code is used before OsInit() has been called, so

+	     * xalloc() and friends can't be used.

+	     */

+	    if (len > bufferUnused) {

+		bufferSize += 1024;

+		bufferUnused += 1024;

+		if (saveBuffer)

+		    saveBuffer = realloc(saveBuffer, bufferSize);

+		else

+		    saveBuffer = malloc(bufferSize);

+		if (!saveBuffer)

+		    FatalError("realloc() failed while saving log messages\n");

+	    }

+	    bufferUnused -= len;

+	    memcpy(saveBuffer + bufferPos, tmpBuffer, len);

+	    bufferPos += len;

+	}

+    }

+}

+

+void

+LogWrite(int verb, const char *f, ...)

+{

+    va_list args;

+

+    va_start(args, f);

+    LogVWrite(verb, f, args);

+    va_end(args);

+}

+

+void

+LogVMessageVerb(MessageType type, int verb, const char *format, va_list args)

+{

+    const char *s  = X_UNKNOWN_STRING;

+    char tmpBuf[1024];

+

+    /* Ignore verbosity for X_ERROR */

+    if (logVerbosity >= verb || logFileVerbosity >= verb || type == X_ERROR) {

+	switch (type) {

+	case X_PROBED:

+	    s = X_PROBE_STRING;

+	    break;

+	case X_CONFIG:

+	    s = X_CONFIG_STRING;

+	    break;

+	case X_DEFAULT:

+	    s = X_DEFAULT_STRING;

+	    break;

+	case X_CMDLINE:

+	    s = X_CMDLINE_STRING;

+	    break;

+	case X_NOTICE:

+	    s = X_NOTICE_STRING;

+	    break;

+	case X_ERROR:

+	    s = X_ERROR_STRING;

+	    if (verb > 0)

+		verb = 0;

+	    break;

+	case X_WARNING:

+	    s = X_WARNING_STRING;

+	    break;

+	case X_INFO:

+	    s = X_INFO_STRING;

+	    break;

+	case X_NOT_IMPLEMENTED:

+	    s = X_NOT_IMPLEMENTED_STRING;

+	    break;

+	case X_UNKNOWN:

+	    s = X_UNKNOWN_STRING;

+	    break;

+	case X_NONE:

+	    s = NULL;

+	    break;

+	}

+

+        /* if s is not NULL we need a space before format */

+        snprintf(tmpBuf, sizeof(tmpBuf), "%s%s%s", s ? s : "",

+                                                   s ? " " : "",

+                                                   format);

+        LogVWrite(verb, tmpBuf, args);

+    }

+}

+

+/* Log message with verbosity level specified. */

+void

+LogMessageVerb(MessageType type, int verb, const char *format, ...)

+{

+    va_list ap;

+

+    va_start(ap, format);

+    LogVMessageVerb(type, verb, format, ap);

+    va_end(ap);

+}

+

+/* Log a message with the standard verbosity level of 1. */

+void

+LogMessage(MessageType type, const char *format, ...)

+{

+    va_list ap;

+

+    va_start(ap, format);

+    LogVMessageVerb(type, 1, format, ap);

+    va_end(ap);

+}

+

+#ifdef __GNUC__

+void AbortServer(void) __attribute__((noreturn));

+#endif

+

+void

+AbortServer(void)

+{

+#ifdef XF86BIGFONT

+    XF86BigfontCleanup();

+#endif

+    CloseWellKnownConnections();

+    OsCleanup(TRUE);

+    CloseDownDevices();

+    AbortDDX();

+    fflush(stderr);

+    if (CoreDump)

+	abort();

+    exit (1);

+}

+

+#define AUDIT_PREFIX "AUDIT: %s: %ld: "

+#ifndef AUDIT_TIMEOUT

+#define AUDIT_TIMEOUT ((CARD32)(120 * 1000)) /* 2 mn */

+#endif

+

+static int nrepeat = 0;

+static int oldlen = -1;

+static OsTimerPtr auditTimer = NULL;

+

+void

+FreeAuditTimer(void)

+{

+    if (auditTimer != NULL) {

+	/* Force output of pending messages */

+	TimerForce(auditTimer);

+	TimerFree(auditTimer);

+	auditTimer = NULL;

+    }

+}

+

+static char *

+AuditPrefix(void)

+{

+    time_t tm;

+    char *autime, *s;

+    char *tmpBuf;

+    int len;

+

+    time(&tm);

+    autime = ctime(&tm);

+    if ((s = strchr(autime, '\n')))

+	*s = '\0';

+    len = strlen(AUDIT_PREFIX) + strlen(autime) + 10 + 1;

+    tmpBuf = malloc(len);

+    if (!tmpBuf)

+	return NULL;

+    snprintf(tmpBuf, len, AUDIT_PREFIX, autime, (unsigned long)getpid());

+    return tmpBuf;

+}

+

+void

+AuditF(const char * f, ...)

+{

+    va_list args;

+

+    va_start(args, f);

+

+    VAuditF(f, args);

+    va_end(args);

+}

+

+static CARD32

+AuditFlush(OsTimerPtr timer, CARD32 now, pointer arg)

+{

+    char *prefix;

+

+    if (nrepeat > 0) {

+	prefix = AuditPrefix();

+	ErrorF("%slast message repeated %d times\n",

+	       prefix != NULL ? prefix : "", nrepeat);

+	nrepeat = 0;

+	if (prefix != NULL)

+	    free(prefix);

+	return AUDIT_TIMEOUT;

+    } else {

+	/* if the timer expires without anything to print, flush the message */

+	oldlen = -1;

+	return 0;

+    }

+}

+

+void

+VAuditF(const char *f, va_list args)

+{

+    char *prefix;

+    char buf[1024];

+    int len;

+    static char oldbuf[1024];

+

+    prefix = AuditPrefix();

+    len = vsnprintf(buf, sizeof(buf), f, args);

+

+    if (len == oldlen && strcmp(buf, oldbuf) == 0) {

+	/* Message already seen */

+	nrepeat++;

+    } else {

+	/* new message */

+	if (auditTimer != NULL)

+	    TimerForce(auditTimer);

+	ErrorF("%s%s", prefix != NULL ? prefix : "", buf);

+	strlcpy(oldbuf, buf, sizeof(oldbuf));

+	oldlen = len;

+	nrepeat = 0;

+	auditTimer = TimerSet(auditTimer, 0, AUDIT_TIMEOUT, AuditFlush, NULL);

+    }

+    if (prefix != NULL)

+	free(prefix);

+}

+

+void

+FatalError(const char *f, ...)

+{

+    va_list args;

+    static Bool beenhere = FALSE;

+

+    if (beenhere)

+	ErrorF("\nFatalError re-entered, aborting\n");

+    else

+	ErrorF("\nFatal server error:\n");

+

+    va_start(args, f);

+    VErrorF(f, args);

+    va_end(args);

+    ErrorF("\n");

+    if (!beenhere)

+	OsVendorFatalError();

+    if (!beenhere) {

+	beenhere = TRUE;

+	AbortServer();

+    } else

+	abort();

+    /*NOTREACHED*/

+}

+

+void

+VErrorF(const char *f, va_list args)

+{

+#ifdef DDXOSVERRORF

+    if (OsVendorVErrorFProc)

+	OsVendorVErrorFProc(f, args);

+    else

+	LogVWrite(-1, f, args);

+#else

+    LogVWrite(-1, f, args);

+#endif

+}

+

+void

+ErrorF(const char * f, ...)

+{

+    va_list args;

+

+    va_start(args, f);

+    VErrorF(f, args);

+    va_end(args);

+}

+

+/* A perror() workalike. */

+

+void

+Error(char *str)

+{

+    char *err = NULL;

+    int saveErrno = errno;

+

+    if (str) {

+	err = malloc(strlen(strerror(saveErrno)) + strlen(str) + 2 + 1);

+	if (!err)

+	    return;

+	sprintf(err, "%s: ", str);

+	strcat(err, strerror(saveErrno));

+	LogWrite(-1, "%s", err);

+	free(err);

+    } else

+	LogWrite(-1, "%s", strerror(saveErrno));

+}

+

+void

+LogPrintMarkers(void)

+{

+    /* Show what the message marker symbols mean. */

+    LogWrite(0, "Markers: ");

+    LogMessageVerb(X_PROBED, 0, "probed, ");

+    LogMessageVerb(X_CONFIG, 0, "from config file, ");

+    LogMessageVerb(X_DEFAULT, 0, "default setting,\n\t");

+    LogMessageVerb(X_CMDLINE, 0, "from command line, ");

+    LogMessageVerb(X_NOTICE, 0, "notice, ");

+    LogMessageVerb(X_INFO, 0, "informational,\n\t");

+    LogMessageVerb(X_WARNING, 0, "warning, ");

+    LogMessageVerb(X_ERROR, 0, "error, ");

+    LogMessageVerb(X_NOT_IMPLEMENTED, 0, "not implemented, ");

+    LogMessageVerb(X_UNKNOWN, 0, "unknown.\n");

+}

+

diff --git a/xorg-server/xfixes/cursor.c b/xorg-server/xfixes/cursor.c
index 6be1761fa..c98ef1ef4 100644
--- a/xorg-server/xfixes/cursor.c
+++ b/xorg-server/xfixes/cursor.c
@@ -2,29 +2,23 @@
  * Copyright © 2006 Sun Microsystems, Inc.  All rights reserved.

  *

  * 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, and/or sell copies of the Software, and to permit persons

- * to whom the Software is furnished to do so, provided that the above

- * copyright notice(s) and this permission notice appear in all copies of

- * the Software and that both the above copyright notice(s) and this

- * permission notice appear in supporting documentation.

+ * 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 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

- * OF THIRD PARTY RIGHTS. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR

- * HOLDERS INCLUDED IN THIS NOTICE BE LIABLE FOR ANY CLAIM, OR 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.

+ * The above copyright notice and this permission notice (including the next

+ * paragraph) shall be included in all copies or substantial portions of the

+ * Software.

  *

- * Except as contained in this notice, the name of a copyright holder

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

- * or other dealings in this Software without prior written authorization

- * of the copyright holder.

+ * 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 AUTHORS OR COPYRIGHT HOLDERS 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.

  *

  * Copyright © 2002 Keith Packard

  *

diff --git a/xorg-server/xfixes/xfixes.c b/xorg-server/xfixes/xfixes.c
index fa360b88e..5163dc11e 100644
--- a/xorg-server/xfixes/xfixes.c
+++ b/xorg-server/xfixes/xfixes.c
@@ -2,29 +2,23 @@
  * Copyright © 2006 Sun Microsystems, Inc.  All rights reserved.
  *
  * 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, and/or sell copies of the Software, and to permit persons
- * to whom the Software is furnished to do so, provided that the above
- * copyright notice(s) and this permission notice appear in all copies of
- * the Software and that both the above copyright notice(s) and this
- * permission notice appear in supporting documentation.
+ * 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 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
- * OF THIRD PARTY RIGHTS. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
- * HOLDERS INCLUDED IN THIS NOTICE BE LIABLE FOR ANY CLAIM, OR 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.
+ * The above copyright notice and this permission notice (including the next
+ * paragraph) shall be included in all copies or substantial portions of the
+ * Software.
  *
- * Except as contained in this notice, the name of a copyright holder
- * shall not be used in advertising or otherwise to promote the sale, use
- * or other dealings in this Software without prior written authorization
- * of the copyright holder.
+ * 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 AUTHORS OR COPYRIGHT HOLDERS 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.
  *
  * Copyright © 2002 Keith Packard
  *
diff --git a/xorg-server/xfixes/xfixesint.h b/xorg-server/xfixes/xfixesint.h
index d7c53ee07..f3d53614f 100644
--- a/xorg-server/xfixes/xfixesint.h
+++ b/xorg-server/xfixes/xfixesint.h
@@ -2,29 +2,23 @@
  * Copyright © 2006 Sun Microsystems, Inc.  All rights reserved.
  *
  * 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, and/or sell copies of the Software, and to permit persons
- * to whom the Software is furnished to do so, provided that the above
- * copyright notice(s) and this permission notice appear in all copies of
- * the Software and that both the above copyright notice(s) and this
- * permission notice appear in supporting documentation.
+ * 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 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
- * OF THIRD PARTY RIGHTS. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
- * HOLDERS INCLUDED IN THIS NOTICE BE LIABLE FOR ANY CLAIM, OR 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.
+ * The above copyright notice and this permission notice (including the next
+ * paragraph) shall be included in all copies or substantial portions of the
+ * Software.
  *
- * Except as contained in this notice, the name of a copyright holder
- * shall not be used in advertising or otherwise to promote the sale, use
- * or other dealings in this Software without prior written authorization
- * of the copyright holder.
+ * 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 AUTHORS OR COPYRIGHT HOLDERS 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.
  *
  * Copyright © 2002 Keith Packard
  *