/*
 * SGI FREE SOFTWARE LICENSE B (Version 2.0, Sept. 18, 2008)
 * Copyright (C) 1991-2000 Silicon Graphics, 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 including the dates of first publication and
 * either this permission notice or a reference to
 * http://oss.sgi.com/projects/FreeB/
 * 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
 * SILICON GRAPHICS, INC. 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 Silicon Graphics, Inc.
 * shall not be used in advertising or otherwise to promote the sale, use or
 * other dealings in this Software without prior written authorization from
 * Silicon Graphics, Inc.
 */

#ifdef HAVE_DIX_CONFIG_H
#include <dix-config.h>
#endif

#include <string.h>
#include <assert.h>

#include "glxserver.h"
#include <GL/glxtokens.h>
#include <X11/extensions/presenttokens.h>
#include <unpack.h>
#include <pixmapstr.h>
#include <windowstr.h>
#include "glxutil.h"
#include "glxext.h"
#include "indirect_dispatch.h"
#include "indirect_table.h"
#include "indirect_util.h"
#include "protocol-versions.h"
#include "glxvndabi.h"

static char GLXServerVendorName[] = "SGI";

_X_HIDDEN int
validGlxScreen(ClientPtr client, int screen, __GLXscreen ** pGlxScreen,
               int *err)
{
    /*
     ** Check if screen exists.
     */
    if (screen < 0 || screen >= screenInfo.numScreens) {
        client->errorValue = screen;
        *err = BadValue;
        return FALSE;
    }
    *pGlxScreen = glxGetScreen(screenInfo.screens[screen]);

    return TRUE;
}

_X_HIDDEN int
validGlxFBConfig(ClientPtr client, __GLXscreen * pGlxScreen, XID id,
                 __GLXconfig ** config, int *err)
{
    __GLXconfig *m;

    for (m = pGlxScreen->fbconfigs; m != NULL; m = m->next)
        if (m->fbconfigID == id) {
            *config = m;
            return TRUE;
        }

    client->errorValue = id;
    *err = __glXError(GLXBadFBConfig);

    return FALSE;
}

static int
validGlxVisual(ClientPtr client, __GLXscreen * pGlxScreen, XID id,
               __GLXconfig ** config, int *err)
{
    int i;

    for (i = 0; i < pGlxScreen->numVisuals; i++)
        if (pGlxScreen->visuals[i]->visualID == id) {
            *config = pGlxScreen->visuals[i];
            return TRUE;
        }

    client->errorValue = id;
    *err = BadValue;

    return FALSE;
}

static int
validGlxFBConfigForWindow(ClientPtr client, __GLXconfig * config,
                          DrawablePtr pDraw, int *err)
{
    ScreenPtr pScreen = pDraw->pScreen;
    VisualPtr pVisual = NULL;
    XID vid;
    int i;

    vid = wVisual((WindowPtr) pDraw);
    for (i = 0; i < pScreen->numVisuals; i++) {
        if (pScreen->visuals[i].vid == vid) {
            pVisual = &pScreen->visuals[i];
            break;
        }
    }

    /* FIXME: What exactly should we check here... */
    if (pVisual->class != glxConvertToXVisualType(config->visualType) ||
        !(config->drawableType & GLX_WINDOW_BIT)) {
        client->errorValue = pDraw->id;
        *err = BadMatch;
        return FALSE;
    }

    return TRUE;
}

_X_HIDDEN int
validGlxContext(ClientPtr client, XID id, int access_mode,
                __GLXcontext ** context, int *err)
{
    /* no ghost contexts */
    if (id & SERVER_BIT) {
        *err = __glXError(GLXBadContext);
        return FALSE;
    }

    *err = dixLookupResourceByType((void **) context, id,
                                   __glXContextRes, client, access_mode);
    if (*err != Success || (*context)->idExists == GL_FALSE) {
        client->errorValue = id;
        if (*err == BadValue || *err == Success)
            *err = __glXError(GLXBadContext);
        return FALSE;
    }

    return TRUE;
}

int
validGlxDrawable(ClientPtr client, XID id, int type, int access_mode,
                 __GLXdrawable ** drawable, int *err)
{
    int rc;

    rc = dixLookupResourceByType((void **) drawable, id,
                                 __glXDrawableRes, client, access_mode);
    if (rc != Success && rc != BadValue) {
        *err = rc;
        client->errorValue = id;
        return FALSE;
    }

    /* If the ID of the glx drawable we looked up doesn't match the id
     * we looked for, it's because we looked it up under the X
     * drawable ID (see DoCreateGLXDrawable). */
    if (rc == BadValue ||
        (*drawable)->drawId != id ||
        (type != GLX_DRAWABLE_ANY && type != (*drawable)->type)) {
        client->errorValue = id;
        switch (type) {
        case GLX_DRAWABLE_WINDOW:
            *err = __glXError(GLXBadWindow);
            return FALSE;
        case GLX_DRAWABLE_PIXMAP:
            *err = __glXError(GLXBadPixmap);
            return FALSE;
        case GLX_DRAWABLE_PBUFFER:
            *err = __glXError(GLXBadPbuffer);
            return FALSE;
        case GLX_DRAWABLE_ANY:
            *err = __glXError(GLXBadDrawable);
            return FALSE;
        }
    }

    return TRUE;
}

void
__glXContextDestroy(__GLXcontext * context)
{
    lastGLContext = NULL;
}

static void
__glXdirectContextDestroy(__GLXcontext * context)
{
    __glXContextDestroy(context);
    free(context);
}

static int
__glXdirectContextLoseCurrent(__GLXcontext * context)
{
    return GL_TRUE;
}

_X_HIDDEN __GLXcontext *
__glXdirectContextCreate(__GLXscreen * screen,
                         __GLXconfig * modes, __GLXcontext * shareContext)
{
    __GLXcontext *context;

    context = calloc(1, sizeof(__GLXcontext));
    if (context == NULL)
        return NULL;

    context->config = modes;
    context->destroy = __glXdirectContextDestroy;
    context->loseCurrent = __glXdirectContextLoseCurrent;

    return context;
}

/**
 * Create a GL context with the given properties.  This routine is used
 * to implement \c glXCreateContext, \c glXCreateNewContext, and
 * \c glXCreateContextWithConfigSGIX.  This works because of the hack way
 * that GLXFBConfigs are implemented.  Basically, the FBConfigID is the
 * same as the VisualID.
 */

static int
DoCreateContext(__GLXclientState * cl, GLXContextID gcId,
                GLXContextID shareList, __GLXconfig * config,
                __GLXscreen * pGlxScreen, GLboolean isDirect,
                int renderType)
{
    ClientPtr client = cl->client;
    __GLXcontext *glxc, *shareglxc;
    int err;

    /*
     ** Find the display list space that we want to share.
     **
     ** NOTE: In a multithreaded X server, we would need to keep a reference
     ** count for each display list so that if one client destroyed a list that
     ** another client was using, the list would not really be freed until it
     ** was no longer in use.  Since this sample implementation has no support
     ** for multithreaded servers, we don't do this.
     */
    if (shareList == None) {
        shareglxc = 0;
    }
    else {
        if (!validGlxContext(client, shareList, DixReadAccess,
                             &shareglxc, &err))
            return err;

        /* Page 26 (page 32 of the PDF) of the GLX 1.4 spec says:
         *
         *     "The server context state for all sharing contexts must exist
         *     in a single address space or a BadMatch error is generated."
         *
         * If the share context is indirect, force the new context to also be
         * indirect.  If the shard context is direct but the new context
         * cannot be direct, generate BadMatch.
         */
        if (shareglxc->isDirect && !isDirect) {
            client->errorValue = shareList;
            return BadMatch;
        }
        else if (!shareglxc->isDirect) {
            /*
             ** Create an indirect context regardless of what the client asked
             ** for; this way we can share display list space with shareList.
             */
            isDirect = GL_FALSE;
        }

        /* Core GLX doesn't explicitly require this, but GLX_ARB_create_context
         * does (see glx/createcontext.c), and it's assumed by our
         * implementation anyway, so let's be consistent about it.
         */
        if (shareglxc->pGlxScreen != pGlxScreen) {
            client->errorValue = shareglxc->pGlxScreen->pScreen->myNum;
            return BadMatch;
        }
    }

    /*
     ** Allocate memory for the new context
     */
    if (!isDirect) {
        /* Only allow creating indirect GLX contexts if allowed by
         * server command line.  Indirect GLX is of limited use (since
         * it's only GL 1.4), it's slower than direct contexts, and
         * it's a massive attack surface for buffer overflow type
         * errors.
         */
        if (!enableIndirectGLX) {
            client->errorValue = isDirect;
            return BadValue;
        }

        /* Without any attributes, the only error that the driver should be
         * able to generate is BadAlloc.  As result, just drop the error
         * returned from the driver on the floor.
         */
        glxc = pGlxScreen->createContext(pGlxScreen, config, shareglxc,
                                         0, NULL, &err);
    }
    else
        glxc = __glXdirectContextCreate(pGlxScreen, config, shareglxc);
    if (!glxc) {
        return BadAlloc;
    }

    /* Initialize the GLXcontext structure.
     */
    glxc->pGlxScreen = pGlxScreen;
    glxc->config = config;
    glxc->id = gcId;
    glxc->share_id = shareList;
    glxc->idExists = GL_TRUE;
    glxc->isDirect = isDirect;
    glxc->renderMode = GL_RENDER;
    glxc->renderType = renderType;

    /* The GLX_ARB_create_context_robustness spec says:
     *
     *     "The default value for GLX_CONTEXT_RESET_NOTIFICATION_STRATEGY_ARB
     *     is GLX_NO_RESET_NOTIFICATION_ARB."
     *
     * Without using glXCreateContextAttribsARB, there is no way to specify a
     * non-default reset notification strategy.
     */
    glxc->resetNotificationStrategy = GLX_NO_RESET_NOTIFICATION_ARB;

#ifdef GLX_CONTEXT_RELEASE_BEHAVIOR_ARB
    /* The GLX_ARB_context_flush_control spec says:
     *
     *     "The default value [for GLX_CONTEXT_RELEASE_BEHAVIOR] is
     *     CONTEXT_RELEASE_BEHAVIOR_FLUSH, and may in some cases be changed
     *     using platform-specific context creation extensions."
     *
     * Without using glXCreateContextAttribsARB, there is no way to specify a
     * non-default release behavior.
     */
    glxc->releaseBehavior = GLX_CONTEXT_RELEASE_BEHAVIOR_FLUSH_ARB;
#endif

    /* Add the new context to the various global tables of GLX contexts.
     */
    if (!__glXAddContext(glxc)) {
        (*glxc->destroy) (glxc);
        client->errorValue = gcId;
        return BadAlloc;
    }

    return Success;
}

int
__glXDisp_CreateContext(__GLXclientState * cl, GLbyte * pc)
{
    xGLXCreateContextReq *req = (xGLXCreateContextReq *) pc;
    __GLXconfig *config;
    __GLXscreen *pGlxScreen;
    int err;

    if (!validGlxScreen(cl->client, req->screen, &pGlxScreen, &err))
        return err;
    if (!validGlxVisual(cl->client, pGlxScreen, req->visual, &config, &err))
        return err;

    return DoCreateContext(cl, req->context, req->shareList,
                           config, pGlxScreen, req->isDirect,
                           GLX_RGBA_TYPE);
}

int
__glXDisp_CreateNewContext(__GLXclientState * cl, GLbyte * pc)
{
    xGLXCreateNewContextReq *req = (xGLXCreateNewContextReq *) pc;
    __GLXconfig *config;
    __GLXscreen *pGlxScreen;
    int err;

    if (!validGlxScreen(cl->client, req->screen, &pGlxScreen, &err))
        return err;
    if (!validGlxFBConfig(cl->client, pGlxScreen, req->fbconfig, &config, &err))
        return err;

    return DoCreateContext(cl, req->context, req->shareList,
                           config, pGlxScreen, req->isDirect,
                           req->renderType);
}

int
__glXDisp_CreateContextWithConfigSGIX(__GLXclientState * cl, GLbyte * pc)
{
    ClientPtr client = cl->client;
    xGLXCreateContextWithConfigSGIXReq *req =
        (xGLXCreateContextWithConfigSGIXReq *) pc;
    __GLXconfig *config;
    __GLXscreen *pGlxScreen;
    int err;

    REQUEST_SIZE_MATCH(xGLXCreateContextWithConfigSGIXReq);

    if (!validGlxScreen(cl->client, req->screen, &pGlxScreen, &err))
        return err;
    if (!validGlxFBConfig(cl->client, pGlxScreen, req->fbconfig, &config, &err))
        return err;

    return DoCreateContext(cl, req->context, req->shareList,
                           config, pGlxScreen, req->isDirect,
                           req->renderType);
}

int
__glXDisp_DestroyContext(__GLXclientState * cl, GLbyte * pc)
{
    xGLXDestroyContextReq *req = (xGLXDestroyContextReq *) pc;
    __GLXcontext *glxc;
    int err;

    if (!validGlxContext(cl->client, req->context, DixDestroyAccess,
                         &glxc, &err))
        return err;

    glxc->idExists = GL_FALSE;
    if (glxc->currentClient) {
        XID ghost = FakeClientID(glxc->currentClient->index);

        if (!AddResource(ghost, __glXContextRes, glxc))
            return BadAlloc;
        ChangeResourceValue(glxc->id, __glXContextRes, NULL);
        glxc->id = ghost;
    }

    FreeResourceByType(req->context, __glXContextRes, FALSE);

    return Success;
}

__GLXcontext *
__glXLookupContextByTag(__GLXclientState * cl, GLXContextTag tag)
{
    return glxServer.getContextTagPrivate(cl->client, tag);
}

static __GLXconfig *
inferConfigForWindow(__GLXscreen *pGlxScreen, WindowPtr pWin)
{
    int i, vid = wVisual(pWin);

    for (i = 0; i < pGlxScreen->numVisuals; i++)
        if (pGlxScreen->visuals[i]->visualID == vid)
            return pGlxScreen->visuals[i];

    return NULL;
}

/**
 * This is a helper function to handle the legacy (pre GLX 1.3) cases
 * where passing an X window to glXMakeCurrent is valid.  Given a
 * resource ID, look up the GLX drawable if available, otherwise, make
 * sure it's an X window and create a GLX drawable one the fly.
 */
static __GLXdrawable *
__glXGetDrawable(__GLXcontext * glxc, GLXDrawable drawId, ClientPtr client,
                 int *error)
{
    DrawablePtr pDraw;
    __GLXdrawable *pGlxDraw;
    __GLXconfig *config;
    __GLXscreen *pGlxScreen;
    int rc;

    if (validGlxDrawable(client, drawId, GLX_DRAWABLE_ANY,
                         DixWriteAccess, &pGlxDraw, &rc)) {
        if (glxc != NULL &&
            glxc->config != NULL &&
            glxc->config != pGlxDraw->config) {
            client->errorValue = drawId;
            *error = BadMatch;
            return NULL;
        }

        return pGlxDraw;
    }

    /* No active context and an unknown drawable, bail. */
    if (glxc == NULL) {
        client->errorValue = drawId;
        *error = BadMatch;
        return NULL;
    }

    /* The drawId wasn't a GLX drawable.  Make sure it's a window and
     * create a GLXWindow for it.  Check that the drawable screen
     * matches the context screen and that the context fbconfig is
     * compatible with the window visual. */

    rc = dixLookupDrawable(&pDraw, drawId, client, 0, DixGetAttrAccess);
    if (rc != Success || pDraw->type != DRAWABLE_WINDOW) {
        client->errorValue = drawId;
        *error = __glXError(GLXBadDrawable);
        return NULL;
    }

    pGlxScreen = glxc->pGlxScreen;
    if (pDraw->pScreen != pGlxScreen->pScreen) {
        client->errorValue = pDraw->pScreen->myNum;
        *error = BadMatch;
        return NULL;
    }

    config = glxc->config;
    if (!config)
        config = inferConfigForWindow(pGlxScreen, (WindowPtr)pDraw);
    if (!config) {
        /*
         * If we get here, we've tried to bind a no-config context to a
         * window without a corresponding fbconfig, presumably because
         * we don't support GL on it (PseudoColor perhaps). From GLX Section
         * 3.3.7 "Rendering Contexts":
         *
         * "If draw or read are not compatible with ctx a BadMatch error
         * is generated."
         */
        *error = BadMatch;
        return NULL;
    }

    if (!validGlxFBConfigForWindow(client, config, pDraw, error))
        return NULL;

    pGlxDraw = pGlxScreen->createDrawable(client, pGlxScreen, pDraw, drawId,
                                          GLX_DRAWABLE_WINDOW, drawId, config);
    if (!pGlxDraw) {
	*error = BadAlloc;
	return NULL;
    }

    /* since we are creating the drawablePrivate, drawId should be new */
    if (!AddResource(drawId, __glXDrawableRes, pGlxDraw)) {
        *error = BadAlloc;
        return NULL;
    }

    return pGlxDraw;
}

/*****************************************************************************/
/*
** Make an OpenGL context and drawable current.
*/

int
xorgGlxMakeCurrent(ClientPtr client, GLXContextTag tag, XID drawId, XID readId,
                   XID contextId, GLXContextTag newContextTag)
{
    __GLXclientState *cl = glxGetClient(client);
    __GLXcontext *glxc = NULL, *prevglxc = NULL;
    __GLXdrawable *drawPriv = NULL;
    __GLXdrawable *readPriv = NULL;
    int error;

    /* Drawables but no context makes no sense */
    if (!contextId && (drawId || readId))
        return BadMatch;

    /* If either drawable is null, the other must be too */
    if ((drawId == None) != (readId == None))
        return BadMatch;

    /* Look up old context. If we have one, it must be in a usable state. */
    if (tag != 0) {
        prevglxc = glxServer.getContextTagPrivate(client, tag);

        if (prevglxc && prevglxc->renderMode != GL_RENDER) {
            /* Oops.  Not in render mode render. */
            client->errorValue = prevglxc->id;
            return __glXError(GLXBadContextState);
        }
    }

    /* Look up new context. It must not be current for someone else. */
    if (contextId != None) {
        int status;

        if (!validGlxContext(client, contextId, DixUseAccess, &glxc, &error))
            return error;

        if ((glxc != prevglxc) && glxc->currentClient)
            return BadAccess;

        if (drawId) {
            drawPriv = __glXGetDrawable(glxc, drawId, client, &status);
            if (drawPriv == NULL)
                return status;
        }

        if (readId) {
            readPriv = __glXGetDrawable(glxc, readId, client, &status);
            if (readPriv == NULL)
                return status;
        }
    }

    if (prevglxc) {
        /* Flush the previous context if needed. */
        Bool need_flush = !prevglxc->isDirect;
#ifdef GLX_CONTEXT_RELEASE_BEHAVIOR_ARB
        if (prevglxc->releaseBehavior == GLX_CONTEXT_RELEASE_BEHAVIOR_NONE_ARB)
            need_flush = GL_FALSE;
#endif
        if (need_flush) {
            if (!__glXForceCurrent(cl, tag, (int *) &error))
                return error;
            glFlush();
        }

        /* Make the previous context not current. */
        if (!(*prevglxc->loseCurrent) (prevglxc))
            return __glXError(GLXBadContext);

        lastGLContext = NULL;
        if (!prevglxc->isDirect) {
            prevglxc->drawPriv = NULL;
            prevglxc->readPriv = NULL;
        }
    }

    if (glxc && !glxc->isDirect) {
        glxc->drawPriv = drawPriv;
        glxc->readPriv = readPriv;

        /* make the context current */
        lastGLContext = glxc;
        if (!(*glxc->makeCurrent) (glxc)) {
            lastGLContext = NULL;
            glxc->drawPriv = NULL;
            glxc->readPriv = NULL;
            return __glXError(GLXBadContext);
        }

        glxc->currentClient = client;
        glxServer.setContextTagPrivate(client, newContextTag, glxc);
    }

    if (prevglxc) {
        prevglxc->currentClient = NULL;
        if (!prevglxc->idExists) {
            FreeResourceByType(prevglxc->id, __glXContextRes, FALSE);
        }
    }

    return Success;
}

int
__glXDisp_MakeCurrent(__GLXclientState * cl, GLbyte * pc)
{
    return BadImplementation;
}

int
__glXDisp_MakeContextCurrent(__GLXclientState * cl, GLbyte * pc)
{
    return BadImplementation;
}

int
__glXDisp_MakeCurrentReadSGI(__GLXclientState * cl, GLbyte * pc)
{
    return BadImplementation;
}

int
__glXDisp_IsDirect(__GLXclientState * cl, GLbyte * pc)
{
    ClientPtr client = cl->client;
    xGLXIsDirectReq *req = (xGLXIsDirectReq *) pc;
    xGLXIsDirectReply reply;
    __GLXcontext *glxc;
    int err;

    if (!validGlxContext(cl->client, req->context, DixReadAccess, &glxc, &err))
        return err;

    reply = (xGLXIsDirectReply) {
        .type = X_Reply,
        .sequenceNumber = client->sequence,
        .length = 0,
        .isDirect = glxc->isDirect
    };

    if (client->swapped) {
        __GLX_DECLARE_SWAP_VARIABLES;
        __GLX_SWAP_SHORT(&reply.sequenceNumber);
        __GLX_SWAP_INT(&reply.length);
    }
    WriteToClient(client, sz_xGLXIsDirectReply, &reply);

    return Success;
}

int
__glXDisp_QueryVersion(__GLXclientState * cl, GLbyte * pc)
{
    ClientPtr client = cl->client;
    xGLXQueryVersionReq *req = (xGLXQueryVersionReq *) pc;
    xGLXQueryVersionReply reply;
    GLuint major, minor;

    REQUEST_SIZE_MATCH(xGLXQueryVersionReq);

    major = req->majorVersion;
    minor = req->minorVersion;
    (void) major;
    (void) minor;

    /*
     ** Server should take into consideration the version numbers sent by the
     ** client if it wants to work with older clients; however, in this
     ** implementation the server just returns its version number.
     */
    reply = (xGLXQueryVersionReply) {
        .type = X_Reply,
        .sequenceNumber = client->sequence,
        .length = 0,
        .majorVersion = SERVER_GLX_MAJOR_VERSION,
        .minorVersion = SERVER_GLX_MINOR_VERSION
    };

    if (client->swapped) {
        __GLX_DECLARE_SWAP_VARIABLES;
        __GLX_SWAP_SHORT(&reply.sequenceNumber);
        __GLX_SWAP_INT(&reply.length);
        __GLX_SWAP_INT(&reply.majorVersion);
        __GLX_SWAP_INT(&reply.minorVersion);
    }

    WriteToClient(client, sz_xGLXQueryVersionReply, &reply);
    return Success;
}

int
__glXDisp_WaitGL(__GLXclientState * cl, GLbyte * pc)
{
    xGLXWaitGLReq *req = (xGLXWaitGLReq *) pc;
    GLXContextTag tag;
    __GLXcontext *glxc = NULL;
    int error;

    tag = req->contextTag;
    if (tag) {
        glxc = __glXLookupContextByTag(cl, tag);
        if (!glxc)
            return __glXError(GLXBadContextTag);

        if (!__glXForceCurrent(cl, req->contextTag, &error))
            return error;

        glFinish();
    }

    if (glxc && glxc->drawPriv && glxc->drawPriv->waitGL)
        (*glxc->drawPriv->waitGL) (glxc->drawPriv);

    return Success;
}

int
__glXDisp_WaitX(__GLXclientState * cl, GLbyte * pc)
{
    xGLXWaitXReq *req = (xGLXWaitXReq *) pc;
    GLXContextTag tag;
    __GLXcontext *glxc = NULL;
    int error;

    tag = req->contextTag;
    if (tag) {
        glxc = __glXLookupContextByTag(cl, tag);
        if (!glxc)
            return __glXError(GLXBadContextTag);

        if (!__glXForceCurrent(cl, req->contextTag, &error))
            return error;
    }

    if (glxc && glxc->drawPriv && glxc->drawPriv->waitX)
        (*glxc->drawPriv->waitX) (glxc->drawPriv);

    return Success;
}

int
__glXDisp_CopyContext(__GLXclientState * cl, GLbyte * pc)
{
    ClientPtr client = cl->client;
    xGLXCopyContextReq *req = (xGLXCopyContextReq *) pc;
    GLXContextID source;
    GLXContextID dest;
    GLXContextTag tag;
    unsigned long mask;
    __GLXcontext *src, *dst;
    int error;

    source = req->source;
    dest = req->dest;
    tag = req->contextTag;
    mask = req->mask;
    if (!validGlxContext(cl->client, source, DixReadAccess, &src, &error))
        return error;
    if (!validGlxContext(cl->client, dest, DixWriteAccess, &dst, &error))
        return error;

    /*
     ** They must be in the same address space, and same screen.
     ** NOTE: no support for direct rendering contexts here.
     */
    if (src->isDirect || dst->isDirect || (src->pGlxScreen != dst->pGlxScreen)) {
        client->errorValue = source;
        return BadMatch;
    }

    /*
     ** The destination context must not be current for any client.
     */
    if (dst->currentClient) {
        client->errorValue = dest;
        return BadAccess;
    }

    if (tag) {
        __GLXcontext *tagcx = __glXLookupContextByTag(cl, tag);

        if (!tagcx) {
            return __glXError(GLXBadContextTag);
        }
        if (tagcx != src) {
            /*
             ** This would be caused by a faulty implementation of the client
             ** library.
             */
            return BadMatch;
        }
        /*
         ** In this case, glXCopyContext is in both GL and X streams, in terms
         ** of sequentiality.
         */
        if (__glXForceCurrent(cl, tag, &error)) {
            /*
             ** Do whatever is needed to make sure that all preceding requests
             ** in both streams are completed before the copy is executed.
             */
            glFinish();
        }
        else {
            return error;
        }
    }
    /*
     ** Issue copy.  The only reason for failure is a bad mask.
     */
    if (!(*dst->copy) (dst, src, mask)) {
        client->errorValue = mask;
        return BadValue;
    }
    return Success;
}

enum {
    GLX_VIS_CONFIG_UNPAIRED = 18,
    GLX_VIS_CONFIG_PAIRED = 22
};

enum {
    GLX_VIS_CONFIG_TOTAL = GLX_VIS_CONFIG_UNPAIRED + GLX_VIS_CONFIG_PAIRED
};

int
__glXDisp_GetVisualConfigs(__GLXclientState * cl, GLbyte * pc)
{
    xGLXGetVisualConfigsReq *req = (xGLXGetVisualConfigsReq *) pc;
    ClientPtr client = cl->client;
    xGLXGetVisualConfigsReply reply;
    __GLXscreen *pGlxScreen;
    __GLXconfig *modes;
    CARD32 buf[GLX_VIS_CONFIG_TOTAL];
    int p, i, err;

    __GLX_DECLARE_SWAP_VARIABLES;
    __GLX_DECLARE_SWAP_ARRAY_VARIABLES;

    if (!validGlxScreen(cl->client, req->screen, &pGlxScreen, &err))
        return err;

    reply = (xGLXGetVisualConfigsReply) {
        .type = X_Reply,
        .sequenceNumber = client->sequence,
        .length = (pGlxScreen->numVisuals *
                   __GLX_SIZE_CARD32 * GLX_VIS_CONFIG_TOTAL) >> 2,
        .numVisuals = pGlxScreen->numVisuals,
        .numProps = GLX_VIS_CONFIG_TOTAL
    };

    if (client->swapped) {
        __GLX_SWAP_SHORT(&reply.sequenceNumber);
        __GLX_SWAP_INT(&reply.length);
        __GLX_SWAP_INT(&reply.numVisuals);
        __GLX_SWAP_INT(&reply.numProps);
    }

    WriteToClient(client, sz_xGLXGetVisualConfigsReply, &reply);

    for (i = 0; i < pGlxScreen->numVisuals; i++) {
        modes = pGlxScreen->visuals[i];

        p = 0;
        buf[p++] = modes->visualID;
        buf[p++] = glxConvertToXVisualType(modes->visualType);
        buf[p++] = (modes->renderType & GLX_RGBA_BIT) ? GL_TRUE : GL_FALSE;

        buf[p++] = modes->redBits;
        buf[p++] = modes->greenBits;
        buf[p++] = modes->blueBits;
        buf[p++] = modes->alphaBits;
        buf[p++] = modes->accumRedBits;
        buf[p++] = modes->accumGreenBits;
        buf[p++] = modes->accumBlueBits;
        buf[p++] = modes->accumAlphaBits;

        buf[p++] = modes->doubleBufferMode;
        buf[p++] = modes->stereoMode;

        buf[p++] = modes->rgbBits;
        buf[p++] = modes->depthBits;
        buf[p++] = modes->stencilBits;
        buf[p++] = modes->numAuxBuffers;
        buf[p++] = modes->level;

        assert(p == GLX_VIS_CONFIG_UNPAIRED);
        /*
         ** Add token/value pairs for extensions.
         */
        buf[p++] = GLX_VISUAL_CAVEAT_EXT;
        buf[p++] = modes->visualRating;
        buf[p++] = GLX_TRANSPARENT_TYPE;
        buf[p++] = modes->transparentPixel;
        buf[p++] = GLX_TRANSPARENT_RED_VALUE;
        buf[p++] = modes->transparentRed;
        buf[p++] = GLX_TRANSPARENT_GREEN_VALUE;
        buf[p++] = modes->transparentGreen;
        buf[p++] = GLX_TRANSPARENT_BLUE_VALUE;
        buf[p++] = modes->transparentBlue;
        buf[p++] = GLX_TRANSPARENT_ALPHA_VALUE;
        buf[p++] = modes->transparentAlpha;
        buf[p++] = GLX_TRANSPARENT_INDEX_VALUE;
        buf[p++] = modes->transparentIndex;
        buf[p++] = GLX_SAMPLES_SGIS;
        buf[p++] = modes->samples;
        buf[p++] = GLX_SAMPLE_BUFFERS_SGIS;
        buf[p++] = modes->sampleBuffers;
        buf[p++] = GLX_VISUAL_SELECT_GROUP_SGIX;
        buf[p++] = modes->visualSelectGroup;
        /* Add attribute only if its value is not default. */
        if (modes->sRGBCapable != GL_FALSE) {
            buf[p++] = GLX_FRAMEBUFFER_SRGB_CAPABLE_EXT;
            buf[p++] = modes->sRGBCapable;
        }
        /* Pad with zeroes, so that attributes count is constant. */
        while (p < GLX_VIS_CONFIG_TOTAL) {
            buf[p++] = 0;
            buf[p++] = 0;
        }

        assert(p == GLX_VIS_CONFIG_TOTAL);
        if (client->swapped) {
            __GLX_SWAP_INT_ARRAY(buf, p);
        }
        WriteToClient(client, __GLX_SIZE_CARD32 * p, buf);
    }
    return Success;
}

#define __GLX_TOTAL_FBCONFIG_ATTRIBS (44)
#define __GLX_FBCONFIG_ATTRIBS_LENGTH (__GLX_TOTAL_FBCONFIG_ATTRIBS * 2)
/**
 * Send the set of GLXFBConfigs to the client.  There is not currently
 * and interface into the driver on the server-side to get GLXFBConfigs,
 * so we "invent" some based on the \c __GLXvisualConfig structures that
 * the driver does supply.
 *
 * The reply format for both \c glXGetFBConfigs and \c glXGetFBConfigsSGIX
 * is the same, so this routine pulls double duty.
 */

static int
DoGetFBConfigs(__GLXclientState * cl, unsigned screen)
{
    ClientPtr client = cl->client;
    xGLXGetFBConfigsReply reply;
    __GLXscreen *pGlxScreen;
    CARD32 buf[__GLX_FBCONFIG_ATTRIBS_LENGTH];
    int p, err;
    __GLXconfig *modes;

    __GLX_DECLARE_SWAP_VARIABLES;
    __GLX_DECLARE_SWAP_ARRAY_VARIABLES;

    if (!validGlxScreen(cl->client, screen, &pGlxScreen, &err))
        return err;

    reply = (xGLXGetFBConfigsReply) {
        .type = X_Reply,
        .sequenceNumber = client->sequence,
        .length = __GLX_FBCONFIG_ATTRIBS_LENGTH * pGlxScreen->numFBConfigs,
        .numFBConfigs = pGlxScreen->numFBConfigs,
        .numAttribs = __GLX_TOTAL_FBCONFIG_ATTRIBS
    };

    if (client->swapped) {
        __GLX_SWAP_SHORT(&reply.sequenceNumber);
        __GLX_SWAP_INT(&reply.length);
        __GLX_SWAP_INT(&reply.numFBConfigs);
        __GLX_SWAP_INT(&reply.numAttribs);
    }

    WriteToClient(client, sz_xGLXGetFBConfigsReply, &reply);

    for (modes = pGlxScreen->fbconfigs; modes != NULL; modes = modes->next) {
        p = 0;

#define WRITE_PAIR(tag,value) \
    do { buf[p++] = tag ; buf[p++] = value ; } while( 0 )

        WRITE_PAIR(GLX_VISUAL_ID, modes->visualID);
        WRITE_PAIR(GLX_FBCONFIG_ID, modes->fbconfigID);
        WRITE_PAIR(GLX_X_RENDERABLE,
                   (modes->drawableType & (GLX_WINDOW_BIT | GLX_PIXMAP_BIT)
                    ? GL_TRUE
                    : GL_FALSE));

        WRITE_PAIR(GLX_RGBA,
                   (modes->renderType & GLX_RGBA_BIT) ? GL_TRUE : GL_FALSE);
        WRITE_PAIR(GLX_RENDER_TYPE, modes->renderType);
        WRITE_PAIR(GLX_DOUBLEBUFFER, modes->doubleBufferMode);
        WRITE_PAIR(GLX_STEREO, modes->stereoMode);

        WRITE_PAIR(GLX_BUFFER_SIZE, modes->rgbBits);
        WRITE_PAIR(GLX_LEVEL, modes->level);
        WRITE_PAIR(GLX_AUX_BUFFERS, modes->numAuxBuffers);
        WRITE_PAIR(GLX_RED_SIZE, modes->redBits);
        WRITE_PAIR(GLX_GREEN_SIZE, modes->greenBits);
        WRITE_PAIR(GLX_BLUE_SIZE, modes->blueBits);
        WRITE_PAIR(GLX_ALPHA_SIZE, modes->alphaBits);
        WRITE_PAIR(GLX_ACCUM_RED_SIZE, modes->accumRedBits);
        WRITE_PAIR(GLX_ACCUM_GREEN_SIZE, modes->accumGreenBits);
        WRITE_PAIR(GLX_ACCUM_BLUE_SIZE, modes->accumBlueBits);
        WRITE_PAIR(GLX_ACCUM_ALPHA_SIZE, modes->accumAlphaBits);
        WRITE_PAIR(GLX_DEPTH_SIZE, modes->depthBits);
        WRITE_PAIR(GLX_STENCIL_SIZE, modes->stencilBits);
        WRITE_PAIR(GLX_X_VISUAL_TYPE, modes->visualType);
        WRITE_PAIR(GLX_CONFIG_CAVEAT, modes->visualRating);
        WRITE_PAIR(GLX_TRANSPARENT_TYPE, modes->transparentPixel);
        WRITE_PAIR(GLX_TRANSPARENT_RED_VALUE, modes->transparentRed);
        WRITE_PAIR(GLX_TRANSPARENT_GREEN_VALUE, modes->transparentGreen);
        WRITE_PAIR(GLX_TRANSPARENT_BLUE_VALUE, modes->transparentBlue);
        WRITE_PAIR(GLX_TRANSPARENT_ALPHA_VALUE, modes->transparentAlpha);
        WRITE_PAIR(GLX_TRANSPARENT_INDEX_VALUE, modes->transparentIndex);
        WRITE_PAIR(GLX_SWAP_METHOD_OML, modes->swapMethod);
        WRITE_PAIR(GLX_SAMPLES_SGIS, modes->samples);
        WRITE_PAIR(GLX_SAMPLE_BUFFERS_SGIS, modes->sampleBuffers);
        WRITE_PAIR(GLX_VISUAL_SELECT_GROUP_SGIX, modes->visualSelectGroup);
        WRITE_PAIR(GLX_DRAWABLE_TYPE, modes->drawableType);
        WRITE_PAIR(GLX_BIND_TO_TEXTURE_RGB_EXT, modes->bindToTextureRgb);
        WRITE_PAIR(GLX_BIND_TO_TEXTURE_RGBA_EXT, modes->bindToTextureRgba);
        WRITE_PAIR(GLX_BIND_TO_MIPMAP_TEXTURE_EXT, modes->bindToMipmapTexture);
        WRITE_PAIR(GLX_BIND_TO_TEXTURE_TARGETS_EXT,
                   modes->bindToTextureTargets);
	/* can't report honestly until mesa is fixed */
	WRITE_PAIR(GLX_Y_INVERTED_EXT, GLX_DONT_CARE);
	if (modes->drawableType & GLX_PBUFFER_BIT) {
	    WRITE_PAIR(GLX_MAX_PBUFFER_WIDTH, modes->maxPbufferWidth);
	    WRITE_PAIR(GLX_MAX_PBUFFER_HEIGHT, modes->maxPbufferHeight);
	    WRITE_PAIR(GLX_MAX_PBUFFER_PIXELS, modes->maxPbufferPixels);
	    WRITE_PAIR(GLX_OPTIMAL_PBUFFER_WIDTH_SGIX,
		       modes->optimalPbufferWidth);
	    WRITE_PAIR(GLX_OPTIMAL_PBUFFER_HEIGHT_SGIX,
		       modes->optimalPbufferHeight);
	}
        /* Add attribute only if its value is not default. */
        if (modes->sRGBCapable != GL_FALSE) {
            WRITE_PAIR(GLX_FRAMEBUFFER_SRGB_CAPABLE_EXT, modes->sRGBCapable);
        }
        /* Pad the remaining place with zeroes, so that attributes count is constant. */
        while (p < __GLX_FBCONFIG_ATTRIBS_LENGTH) {
            WRITE_PAIR(0, 0);
        }
        assert(p == __GLX_FBCONFIG_ATTRIBS_LENGTH);

        if (client->swapped) {
            __GLX_SWAP_INT_ARRAY(buf, __GLX_FBCONFIG_ATTRIBS_LENGTH);
        }
        WriteToClient(client, __GLX_SIZE_CARD32 * __GLX_FBCONFIG_ATTRIBS_LENGTH,
                      (char *) buf);
    }
    return Success;
}

int
__glXDisp_GetFBConfigs(__GLXclientState * cl, GLbyte * pc)
{
    xGLXGetFBConfigsReq *req = (xGLXGetFBConfigsReq *) pc;

    return DoGetFBConfigs(cl, req->screen);
}

int
__glXDisp_GetFBConfigsSGIX(__GLXclientState * cl, GLbyte * pc)
{
    ClientPtr client = cl->client;
    xGLXGetFBConfigsSGIXReq *req = (xGLXGetFBConfigsSGIXReq *) pc;

    /* work around mesa bug, don't use REQUEST_SIZE_MATCH */
    REQUEST_AT_LEAST_SIZE(xGLXGetFBConfigsSGIXReq);
    return DoGetFBConfigs(cl, req->screen);
}

GLboolean
__glXDrawableInit(__GLXdrawable * drawable,
                  __GLXscreen * screen, DrawablePtr pDraw, int type,
                  XID drawId, __GLXconfig * config)
{
    drawable->pDraw = pDraw;
    drawable->type = type;
    drawable->drawId = drawId;
    drawable->config = config;
    drawable->eventMask = 0;

    return GL_TRUE;
}

void
__glXDrawableRelease(__GLXdrawable * drawable)
{
}

static int
DoCreateGLXDrawable(ClientPtr client, __GLXscreen * pGlxScreen,
                    __GLXconfig * config, DrawablePtr pDraw, XID drawableId,
                    XID glxDrawableId, int type)
{
    __GLXdrawable *pGlxDraw;

    if (pGlxScreen->pScreen != pDraw->pScreen)
        return BadMatch;

    pGlxDraw = pGlxScreen->createDrawable(client, pGlxScreen, pDraw,
                                          drawableId, type,
                                          glxDrawableId, config);
    if (pGlxDraw == NULL)
        return BadAlloc;

    if (!AddResource(glxDrawableId, __glXDrawableRes, pGlxDraw))
        return BadAlloc;

    /*
     * Windows aren't refcounted, so track both the X and the GLX window
     * so we get called regardless of destruction order.
     */
    if (drawableId != glxDrawableId && type == GLX_DRAWABLE_WINDOW &&
        !AddResource(pDraw->id, __glXDrawableRes, pGlxDraw))
        return BadAlloc;

    return Success;
}

static int
DoCreateGLXPixmap(ClientPtr client, __GLXscreen * pGlxScreen,
                  __GLXconfig * config, XID drawableId, XID glxDrawableId)
{
    DrawablePtr pDraw;
    int err;

    err = dixLookupDrawable(&pDraw, drawableId, client, 0, DixAddAccess);
    if (err != Success) {
        client->errorValue = drawableId;
        return err;
    }
    if (pDraw->type != DRAWABLE_PIXMAP) {
        client->errorValue = drawableId;
        return BadPixmap;
    }

    err = DoCreateGLXDrawable(client, pGlxScreen, config, pDraw, drawableId,
                              glxDrawableId, GLX_DRAWABLE_PIXMAP);

    if (err == Success)
        ((PixmapPtr) pDraw)->refcnt++;

    return err;
}

static void
determineTextureTarget(ClientPtr client, XID glxDrawableID,
                       CARD32 *attribs, CARD32 numAttribs)
{
    GLenum target = 0;
    GLenum format = 0;
    int i, err;
    __GLXdrawable *pGlxDraw;

    if (!validGlxDrawable(client, glxDrawableID, GLX_DRAWABLE_PIXMAP,
                          DixWriteAccess, &pGlxDraw, &err))
        /* We just added it in CreatePixmap, so we should never get here. */
        return;

    for (i = 0; i < numAttribs; i++) {
        if (attribs[2 * i] == GLX_TEXTURE_TARGET_EXT) {
            switch (attribs[2 * i + 1]) {
            case GLX_TEXTURE_2D_EXT:
                target = GL_TEXTURE_2D;
                break;
            case GLX_TEXTURE_RECTANGLE_EXT:
                target = GL_TEXTURE_RECTANGLE_ARB;
                break;
            }
        }

        if (attribs[2 * i] == GLX_TEXTURE_FORMAT_EXT)
            format = attribs[2 * i + 1];
    }

    if (!target) {
        int w = pGlxDraw->pDraw->width, h = pGlxDraw->pDraw->height;

        if (h & (h - 1) || w & (w - 1))
            target = GL_TEXTURE_RECTANGLE_ARB;
        else
            target = GL_TEXTURE_2D;
    }

    pGlxDraw->target = target;
    pGlxDraw->format = format;
}

int
__glXDisp_CreateGLXPixmap(__GLXclientState * cl, GLbyte * pc)
{
    xGLXCreateGLXPixmapReq *req = (xGLXCreateGLXPixmapReq *) pc;
    __GLXconfig *config;
    __GLXscreen *pGlxScreen;
    int err;

    if (!validGlxScreen(cl->client, req->screen, &pGlxScreen, &err))
        return err;
    if (!validGlxVisual(cl->client, pGlxScreen, req->visual, &config, &err))
        return err;

    return DoCreateGLXPixmap(cl->client, pGlxScreen, config,
                             req->pixmap, req->glxpixmap);
}

int
__glXDisp_CreatePixmap(__GLXclientState * cl, GLbyte * pc)
{
    ClientPtr client = cl->client;
    xGLXCreatePixmapReq *req = (xGLXCreatePixmapReq *) pc;
    __GLXconfig *config;
    __GLXscreen *pGlxScreen;
    int err;

    REQUEST_AT_LEAST_SIZE(xGLXCreatePixmapReq);
    if (req->numAttribs > (UINT32_MAX >> 3)) {
        client->errorValue = req->numAttribs;
        return BadValue;
    }
    REQUEST_FIXED_SIZE(xGLXCreatePixmapReq, req->numAttribs << 3);

    if (!validGlxScreen(cl->client, req->screen, &pGlxScreen, &err))
        return err;
    if (!validGlxFBConfig(cl->client, pGlxScreen, req->fbconfig, &config, &err))
        return err;

    err = DoCreateGLXPixmap(cl->client, pGlxScreen, config,
                            req->pixmap, req->glxpixmap);
    if (err != Success)
        return err;

    determineTextureTarget(cl->client, req->glxpixmap,
                           (CARD32 *) (req + 1), req->numAttribs);

    return Success;
}

int
__glXDisp_CreateGLXPixmapWithConfigSGIX(__GLXclientState * cl, GLbyte * pc)
{
    ClientPtr client = cl->client;
    xGLXCreateGLXPixmapWithConfigSGIXReq *req =
        (xGLXCreateGLXPixmapWithConfigSGIXReq *) pc;
    __GLXconfig *config;
    __GLXscreen *pGlxScreen;
    int err;

    REQUEST_SIZE_MATCH(xGLXCreateGLXPixmapWithConfigSGIXReq);

    if (!validGlxScreen(cl->client, req->screen, &pGlxScreen, &err))
        return err;
    if (!validGlxFBConfig(cl->client, pGlxScreen, req->fbconfig, &config, &err))
        return err;

    return DoCreateGLXPixmap(cl->client, pGlxScreen,
                             config, req->pixmap, req->glxpixmap);
}

static int
DoDestroyDrawable(__GLXclientState * cl, XID glxdrawable, int type)
{
    __GLXdrawable *pGlxDraw;
    int err;

    if (!validGlxDrawable(cl->client, glxdrawable, type,
                          DixDestroyAccess, &pGlxDraw, &err))
        return err;

    FreeResource(glxdrawable, FALSE);

    return Success;
}

int
__glXDisp_DestroyGLXPixmap(__GLXclientState * cl, GLbyte * pc)
{
    xGLXDestroyGLXPixmapReq *req = (xGLXDestroyGLXPixmapReq *) pc;

    return DoDestroyDrawable(cl, req->glxpixmap, GLX_DRAWABLE_PIXMAP);
}

int
__glXDisp_DestroyPixmap(__GLXclientState * cl, GLbyte * pc)
{
    ClientPtr client = cl->client;
    xGLXDestroyPixmapReq *req = (xGLXDestroyPixmapReq *) pc;

    /* should be REQUEST_SIZE_MATCH, but mesa's glXDestroyPixmap used to set
     * length to 3 instead of 2 */
    REQUEST_AT_LEAST_SIZE(xGLXDestroyPixmapReq);

    return DoDestroyDrawable(cl, req->glxpixmap, GLX_DRAWABLE_PIXMAP);
}

static int
DoCreatePbuffer(ClientPtr client, int screenNum, XID fbconfigId,
                int width, int height, XID glxDrawableId)
{
    __GLXconfig *config;
    __GLXscreen *pGlxScreen;
    PixmapPtr pPixmap;
    int err;

    if (!validGlxScreen(client, screenNum, &pGlxScreen, &err))
        return err;
    if (!validGlxFBConfig(client, pGlxScreen, fbconfigId, &config, &err))
        return err;

    pPixmap = (*pGlxScreen->pScreen->CreatePixmap) (pGlxScreen->pScreen,
                                                    width, height,
                                                    config->rgbBits, 0);
    if (!pPixmap)
        return BadAlloc;

    /* Assign the pixmap the same id as the pbuffer and add it as a
     * resource so it and the DRI2 drawable will be reclaimed when the
     * pbuffer is destroyed. */
    pPixmap->drawable.id = glxDrawableId;
    if (!AddResource(pPixmap->drawable.id, RT_PIXMAP, pPixmap))
        return BadAlloc;

    return DoCreateGLXDrawable(client, pGlxScreen, config, &pPixmap->drawable,
                               glxDrawableId, glxDrawableId,
                               GLX_DRAWABLE_PBUFFER);
}

int
__glXDisp_CreatePbuffer(__GLXclientState * cl, GLbyte * pc)
{
    ClientPtr client = cl->client;
    xGLXCreatePbufferReq *req = (xGLXCreatePbufferReq *) pc;
    CARD32 *attrs;
    int width, height, i;

    REQUEST_AT_LEAST_SIZE(xGLXCreatePbufferReq);
    if (req->numAttribs > (UINT32_MAX >> 3)) {
        client->errorValue = req->numAttribs;
        return BadValue;
    }
    REQUEST_FIXED_SIZE(xGLXCreatePbufferReq, req->numAttribs << 3);

    attrs = (CARD32 *) (req + 1);
    width = 0;
    height = 0;

    for (i = 0; i < req->numAttribs; i++) {
        switch (attrs[i * 2]) {
        case GLX_PBUFFER_WIDTH:
            width = attrs[i * 2 + 1];
            break;
        case GLX_PBUFFER_HEIGHT:
            height = attrs[i * 2 + 1];
            break;
        case GLX_LARGEST_PBUFFER:
            /* FIXME: huh... */
            break;
        }
    }

    return DoCreatePbuffer(cl->client, req->screen, req->fbconfig,
                           width, height, req->pbuffer);
}

int
__glXDisp_CreateGLXPbufferSGIX(__GLXclientState * cl, GLbyte * pc)
{
    ClientPtr client = cl->client;
    xGLXCreateGLXPbufferSGIXReq *req = (xGLXCreateGLXPbufferSGIXReq *) pc;

    REQUEST_AT_LEAST_SIZE(xGLXCreateGLXPbufferSGIXReq);

    /*
     * We should really handle attributes correctly, but this extension
     * is so rare I have difficulty caring.
     */
    return DoCreatePbuffer(cl->client, req->screen, req->fbconfig,
                           req->width, req->height, req->pbuffer);
}

int
__glXDisp_DestroyPbuffer(__GLXclientState * cl, GLbyte * pc)
{
    ClientPtr client = cl->client;
    xGLXDestroyPbufferReq *req = (xGLXDestroyPbufferReq *) pc;

    REQUEST_SIZE_MATCH(xGLXDestroyPbufferReq);

    return DoDestroyDrawable(cl, req->pbuffer, GLX_DRAWABLE_PBUFFER);
}

int
__glXDisp_DestroyGLXPbufferSGIX(__GLXclientState * cl, GLbyte * pc)
{
    ClientPtr client = cl->client;
    xGLXDestroyGLXPbufferSGIXReq *req = (xGLXDestroyGLXPbufferSGIXReq *) pc;

    REQUEST_SIZE_MATCH(xGLXDestroyGLXPbufferSGIXReq);

    return DoDestroyDrawable(cl, req->pbuffer, GLX_DRAWABLE_PBUFFER);
}

static int
DoChangeDrawableAttributes(ClientPtr client, XID glxdrawable,
                           int numAttribs, CARD32 *attribs)
{
    __GLXdrawable *pGlxDraw;
    int i, err;

    if (!validGlxDrawable(client, glxdrawable, GLX_DRAWABLE_ANY,
                          DixSetAttrAccess, &pGlxDraw, &err))
        return err;

    for (i = 0; i < numAttribs; i++) {
        switch (attribs[i * 2]) {
        case GLX_EVENT_MASK:
            /* All we do is to record the event mask so we can send it
             * back when queried.  We never actually clobber the
             * pbuffers, so we never need to send out the event. */
            pGlxDraw->eventMask = attribs[i * 2 + 1];
            break;
        }
    }

    return Success;
}

int
__glXDisp_ChangeDrawableAttributes(__GLXclientState * cl, GLbyte * pc)
{
    ClientPtr client = cl->client;
    xGLXChangeDrawableAttributesReq *req =
        (xGLXChangeDrawableAttributesReq *) pc;

    REQUEST_AT_LEAST_SIZE(xGLXChangeDrawableAttributesReq);
    if (req->numAttribs > (UINT32_MAX >> 3)) {
        client->errorValue = req->numAttribs;
        return BadValue;
    }
#if 0
    /* mesa sends an additional 8 bytes */
    REQUEST_FIXED_SIZE(xGLXChangeDrawableAttributesReq, req->numAttribs << 3);
#else
    if (((sizeof(xGLXChangeDrawableAttributesReq) +
          (req->numAttribs << 3)) >> 2) < client->req_len)
        return BadLength;
#endif

    return DoChangeDrawableAttributes(cl->client, req->drawable,
                                      req->numAttribs, (CARD32 *) (req + 1));
}

int
__glXDisp_ChangeDrawableAttributesSGIX(__GLXclientState * cl, GLbyte * pc)
{
    ClientPtr client = cl->client;
    xGLXChangeDrawableAttributesSGIXReq *req =
        (xGLXChangeDrawableAttributesSGIXReq *) pc;

    REQUEST_AT_LEAST_SIZE(xGLXChangeDrawableAttributesSGIXReq);
    if (req->numAttribs > (UINT32_MAX >> 3)) {
        client->errorValue = req->numAttribs;
        return BadValue;
    }
    REQUEST_FIXED_SIZE(xGLXChangeDrawableAttributesSGIXReq,
                       req->numAttribs << 3);

    return DoChangeDrawableAttributes(cl->client, req->drawable,
                                      req->numAttribs, (CARD32 *) (req + 1));
}

int
__glXDisp_CreateWindow(__GLXclientState * cl, GLbyte * pc)
{
    xGLXCreateWindowReq *req = (xGLXCreateWindowReq *) pc;
    __GLXconfig *config;
    __GLXscreen *pGlxScreen;
    ClientPtr client = cl->client;
    DrawablePtr pDraw;
    int err;

    REQUEST_AT_LEAST_SIZE(xGLXCreateWindowReq);
    if (req->numAttribs > (UINT32_MAX >> 3)) {
        client->errorValue = req->numAttribs;
        return BadValue;
    }
    REQUEST_FIXED_SIZE(xGLXCreateWindowReq, req->numAttribs << 3);

    if (!validGlxScreen(client, req->screen, &pGlxScreen, &err))
        return err;
    if (!validGlxFBConfig(client, pGlxScreen, req->fbconfig, &config, &err))
        return err;

    err = dixLookupDrawable(&pDraw, req->window, client, 0, DixAddAccess);
    if (err != Success || pDraw->type != DRAWABLE_WINDOW) {
        client->errorValue = req->window;
        return BadWindow;
    }

    if (!validGlxFBConfigForWindow(client, config, pDraw, &err))
        return err;

    return DoCreateGLXDrawable(client, pGlxScreen, config,
                               pDraw, req->window,
                               req->glxwindow, GLX_DRAWABLE_WINDOW);
}

int
__glXDisp_DestroyWindow(__GLXclientState * cl, GLbyte * pc)
{
    ClientPtr client = cl->client;
    xGLXDestroyWindowReq *req = (xGLXDestroyWindowReq *) pc;

    /* mesa's glXDestroyWindow used to set length to 3 instead of 2 */
    REQUEST_AT_LEAST_SIZE(xGLXDestroyWindowReq);

    return DoDestroyDrawable(cl, req->glxwindow, GLX_DRAWABLE_WINDOW);
}

/*****************************************************************************/

/*
** NOTE: There is no portable implementation for swap buffers as of
** this time that is of value.  Consequently, this code must be
** implemented by somebody other than SGI.
*/
int
__glXDisp_SwapBuffers(__GLXclientState * cl, GLbyte * pc)
{
    ClientPtr client = cl->client;
    xGLXSwapBuffersReq *req = (xGLXSwapBuffersReq *) pc;
    GLXContextTag tag;
    XID drawId;
    __GLXcontext *glxc = NULL;
    __GLXdrawable *pGlxDraw;
    int error;

    tag = req->contextTag;
    drawId = req->drawable;
    if (tag) {
        glxc = __glXLookupContextByTag(cl, tag);
        if (!glxc) {
            return __glXError(GLXBadContextTag);
        }
        /*
         ** The calling thread is swapping its current drawable.  In this case,
         ** glxSwapBuffers is in both GL and X streams, in terms of
         ** sequentiality.
         */
        if (__glXForceCurrent(cl, tag, &error)) {
            /*
             ** Do whatever is needed to make sure that all preceding requests
             ** in both streams are completed before the swap is executed.
             */
            glFinish();
        }
        else {
            return error;
        }
    }

    pGlxDraw = __glXGetDrawable(glxc, drawId, client, &error);
    if (pGlxDraw == NULL)
        return error;

    if (pGlxDraw->type == DRAWABLE_WINDOW &&
        (*pGlxDraw->swapBuffers) (cl->client, pGlxDraw) == GL_FALSE)
        return __glXError(GLXBadDrawable);

    return Success;
}

static int
DoQueryContext(__GLXclientState * cl, GLXContextID gcId)
{
    ClientPtr client = cl->client;
    __GLXcontext *ctx;
    xGLXQueryContextInfoEXTReply reply;
    int nProps = 5;
    int sendBuf[nProps * 2];
    int nReplyBytes;
    int err;

    if (!validGlxContext(cl->client, gcId, DixReadAccess, &ctx, &err))
        return err;

    reply = (xGLXQueryContextInfoEXTReply) {
        .type = X_Reply,
        .sequenceNumber = client->sequence,
        .length = nProps << 1,
        .n = nProps
    };

    nReplyBytes = reply.length << 2;
    sendBuf[0] = GLX_SHARE_CONTEXT_EXT;
    sendBuf[1] = (int) (ctx->share_id);
    sendBuf[2] = GLX_VISUAL_ID_EXT;
    sendBuf[3] = (int) (ctx->config ? ctx->config->visualID : 0);
    sendBuf[4] = GLX_SCREEN_EXT;
    sendBuf[5] = (int) (ctx->pGlxScreen->pScreen->myNum);
    sendBuf[6] = GLX_FBCONFIG_ID;
    sendBuf[7] = (int) (ctx->config ? ctx->config->fbconfigID : 0);
    sendBuf[8] = GLX_RENDER_TYPE;
    sendBuf[9] = (int) (ctx->renderType);

    if (client->swapped) {
        int length = reply.length;

        __GLX_DECLARE_SWAP_VARIABLES;
        __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
        __GLX_SWAP_SHORT(&reply.sequenceNumber);
        __GLX_SWAP_INT(&reply.length);
        __GLX_SWAP_INT(&reply.n);
        WriteToClient(client, sz_xGLXQueryContextInfoEXTReply, &reply);
        __GLX_SWAP_INT_ARRAY((int *) sendBuf, length);
        WriteToClient(client, length << 2, sendBuf);
    }
    else {
        WriteToClient(client, sz_xGLXQueryContextInfoEXTReply, &reply);
        WriteToClient(client, nReplyBytes, sendBuf);
    }

    return Success;
}

int
__glXDisp_QueryContextInfoEXT(__GLXclientState * cl, GLbyte * pc)
{
    ClientPtr client = cl->client;
    xGLXQueryContextInfoEXTReq *req = (xGLXQueryContextInfoEXTReq *) pc;

    REQUEST_SIZE_MATCH(xGLXQueryContextInfoEXTReq);

    return DoQueryContext(cl, req->context);
}

int
__glXDisp_QueryContext(__GLXclientState * cl, GLbyte * pc)
{
    xGLXQueryContextReq *req = (xGLXQueryContextReq *) pc;

    return DoQueryContext(cl, req->context);
}

int
__glXDisp_BindTexImageEXT(__GLXclientState * cl, GLbyte * pc)
{
    xGLXVendorPrivateReq *req = (xGLXVendorPrivateReq *) pc;
    ClientPtr client = cl->client;
    __GLXcontext *context;
    __GLXdrawable *pGlxDraw;
    GLXDrawable drawId;
    int buffer;
    int error;
    CARD32 num_attribs;

    if ((sizeof(xGLXVendorPrivateReq) + 12) >> 2 > client->req_len)
        return BadLength;

    pc += __GLX_VENDPRIV_HDR_SIZE;

    drawId = *((CARD32 *) (pc));
    buffer = *((INT32 *) (pc + 4));
    num_attribs = *((CARD32 *) (pc + 8));
    if (num_attribs > (UINT32_MAX >> 3)) {
        client->errorValue = num_attribs;
        return BadValue;
    }
    REQUEST_FIXED_SIZE(xGLXVendorPrivateReq, 12 + (num_attribs << 3));

    if (buffer != GLX_FRONT_LEFT_EXT)
        return __glXError(GLXBadPixmap);

    context = __glXForceCurrent(cl, req->contextTag, &error);
    if (!context)
        return error;

    if (!validGlxDrawable(client, drawId, GLX_DRAWABLE_PIXMAP,
                          DixReadAccess, &pGlxDraw, &error))
        return error;

    if (!context->bindTexImage)
        return __glXError(GLXUnsupportedPrivateRequest);

    return context->bindTexImage(context, buffer, pGlxDraw);
}

int
__glXDisp_ReleaseTexImageEXT(__GLXclientState * cl, GLbyte * pc)
{
    xGLXVendorPrivateReq *req = (xGLXVendorPrivateReq *) pc;
    ClientPtr client = cl->client;
    __GLXdrawable *pGlxDraw;
    __GLXcontext *context;
    GLXDrawable drawId;
    int buffer;
    int error;

    REQUEST_FIXED_SIZE(xGLXVendorPrivateReq, 8);

    pc += __GLX_VENDPRIV_HDR_SIZE;

    drawId = *((CARD32 *) (pc));
    buffer = *((INT32 *) (pc + 4));

    context = __glXForceCurrent(cl, req->contextTag, &error);
    if (!context)
        return error;

    if (!validGlxDrawable(client, drawId, GLX_DRAWABLE_PIXMAP,
                          DixReadAccess, &pGlxDraw, &error))
        return error;

    if (!context->releaseTexImage)
        return __glXError(GLXUnsupportedPrivateRequest);

    return context->releaseTexImage(context, buffer, pGlxDraw);
}

int
__glXDisp_CopySubBufferMESA(__GLXclientState * cl, GLbyte * pc)
{
    xGLXVendorPrivateReq *req = (xGLXVendorPrivateReq *) pc;
    GLXContextTag tag = req->contextTag;
    __GLXcontext *glxc = NULL;
    __GLXdrawable *pGlxDraw;
    ClientPtr client = cl->client;
    GLXDrawable drawId;
    int error;
    int x, y, width, height;

    (void) client;
    (void) req;

    REQUEST_FIXED_SIZE(xGLXVendorPrivateReq, 20);

    pc += __GLX_VENDPRIV_HDR_SIZE;

    drawId = *((CARD32 *) (pc));
    x = *((INT32 *) (pc + 4));
    y = *((INT32 *) (pc + 8));
    width = *((INT32 *) (pc + 12));
    height = *((INT32 *) (pc + 16));

    if (tag) {
        glxc = __glXLookupContextByTag(cl, tag);
        if (!glxc) {
            return __glXError(GLXBadContextTag);
        }
        /*
         ** The calling thread is swapping its current drawable.  In this case,
         ** glxSwapBuffers is in both GL and X streams, in terms of
         ** sequentiality.
         */
        if (__glXForceCurrent(cl, tag, &error)) {
            /*
             ** Do whatever is needed to make sure that all preceding requests
             ** in both streams are completed before the swap is executed.
             */
            glFinish();
        }
        else {
            return error;
        }
    }

    pGlxDraw = __glXGetDrawable(glxc, drawId, client, &error);
    if (!pGlxDraw)
        return error;

    if (pGlxDraw == NULL ||
        pGlxDraw->type != GLX_DRAWABLE_WINDOW ||
        pGlxDraw->copySubBuffer == NULL)
        return __glXError(GLXBadDrawable);

    (*pGlxDraw->copySubBuffer) (pGlxDraw, x, y, width, height);

    return Success;
}

/* hack for old glxext.h */
#ifndef GLX_STEREO_TREE_EXT
#define GLX_STEREO_TREE_EXT                 0x20F5
#endif

/*
** Get drawable attributes
*/
static int
DoGetDrawableAttributes(__GLXclientState * cl, XID drawId)
{
    ClientPtr client = cl->client;
    xGLXGetDrawableAttributesReply reply;
    __GLXdrawable *pGlxDraw = NULL;
    DrawablePtr pDraw;
    CARD32 attributes[20];
    int num = 0, error;

    if (!validGlxDrawable(client, drawId, GLX_DRAWABLE_ANY,
                          DixGetAttrAccess, &pGlxDraw, &error)) {
        /* hack for GLX 1.2 naked windows */
        int err = dixLookupWindow((WindowPtr *)&pDraw, drawId, client,
                                  DixGetAttrAccess);
        if (err != Success)
            return error;
    }
    if (pGlxDraw)
        pDraw = pGlxDraw->pDraw;

#define ATTRIB(a, v) do { \
    attributes[2*num] = (a); \
    attributes[2*num+1] = (v); \
    num++; \
    } while (0)

    ATTRIB(GLX_Y_INVERTED_EXT, GL_FALSE);
    ATTRIB(GLX_WIDTH, pDraw->width);
    ATTRIB(GLX_HEIGHT, pDraw->height);
    ATTRIB(GLX_SCREEN, pDraw->pScreen->myNum);
    if (pGlxDraw) {
        ATTRIB(GLX_TEXTURE_TARGET_EXT,
               pGlxDraw->target == GL_TEXTURE_2D ?
                GLX_TEXTURE_2D_EXT : GLX_TEXTURE_RECTANGLE_EXT);
        ATTRIB(GLX_EVENT_MASK, pGlxDraw->eventMask);
        ATTRIB(GLX_FBCONFIG_ID, pGlxDraw->config->fbconfigID);
        if (pGlxDraw->type == GLX_DRAWABLE_PBUFFER) {
            ATTRIB(GLX_PRESERVED_CONTENTS, GL_TRUE);
        }
        if (pGlxDraw->type == GLX_DRAWABLE_WINDOW) {
            ATTRIB(GLX_STEREO_TREE_EXT, 0);
        }
    }

    /* GLX_EXT_get_drawable_type */
    if (!pGlxDraw || pGlxDraw->type == GLX_DRAWABLE_WINDOW)
        ATTRIB(GLX_DRAWABLE_TYPE, GLX_WINDOW_BIT);
    else if (pGlxDraw->type == GLX_DRAWABLE_PIXMAP)
        ATTRIB(GLX_DRAWABLE_TYPE, GLX_PIXMAP_BIT);
    else if (pGlxDraw->type == GLX_DRAWABLE_PBUFFER)
        ATTRIB(GLX_DRAWABLE_TYPE, GLX_PBUFFER_BIT);
#undef ATTRIB

    reply = (xGLXGetDrawableAttributesReply) {
        .type = X_Reply,
        .sequenceNumber = client->sequence,
        .length = num << 1,
        .numAttribs = num
    };

    if (client->swapped) {
        int length = reply.length;

        __GLX_DECLARE_SWAP_VARIABLES;
        __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
        __GLX_SWAP_SHORT(&reply.sequenceNumber);
        __GLX_SWAP_INT(&reply.length);
        __GLX_SWAP_INT(&reply.numAttribs);
        WriteToClient(client, sz_xGLXGetDrawableAttributesReply, &reply);
        __GLX_SWAP_INT_ARRAY((int *) attributes, length);
        WriteToClient(client, length << 2, attributes);
    }
    else {
        WriteToClient(client, sz_xGLXGetDrawableAttributesReply, &reply);
        WriteToClient(client, reply.length * sizeof(CARD32), attributes);
    }

    return Success;
}

int
__glXDisp_GetDrawableAttributes(__GLXclientState * cl, GLbyte * pc)
{
    ClientPtr client = cl->client;
    xGLXGetDrawableAttributesReq *req = (xGLXGetDrawableAttributesReq *) pc;

    /* this should be REQUEST_SIZE_MATCH, but mesa sends an additional 4 bytes */
    REQUEST_AT_LEAST_SIZE(xGLXGetDrawableAttributesReq);

    return DoGetDrawableAttributes(cl, req->drawable);
}

int
__glXDisp_GetDrawableAttributesSGIX(__GLXclientState * cl, GLbyte * pc)
{
    ClientPtr client = cl->client;
    xGLXGetDrawableAttributesSGIXReq *req =
        (xGLXGetDrawableAttributesSGIXReq *) pc;

    REQUEST_SIZE_MATCH(xGLXGetDrawableAttributesSGIXReq);

    return DoGetDrawableAttributes(cl, req->drawable);
}

/************************************************************************/

/*
** Render and Renderlarge are not in the GLX API.  They are used by the GLX
** client library to send batches of GL rendering commands.
*/

/*
** Reset state used to keep track of large (multi-request) commands.
*/
static void
ResetLargeCommandStatus(__GLXcontext *cx)
{
    cx->largeCmdBytesSoFar = 0;
    cx->largeCmdBytesTotal = 0;
    cx->largeCmdRequestsSoFar = 0;
    cx->largeCmdRequestsTotal = 0;
}

/*
** Execute all the drawing commands in a request.
*/
int
__glXDisp_Render(__GLXclientState * cl, GLbyte * pc)
{
    xGLXRenderReq *req;
    ClientPtr client = cl->client;
    int left, cmdlen, error;
    int commandsDone;
    CARD16 opcode;
    __GLXrenderHeader *hdr;
    __GLXcontext *glxc;

    __GLX_DECLARE_SWAP_VARIABLES;

    REQUEST_AT_LEAST_SIZE(xGLXRenderReq);

    req = (xGLXRenderReq *) pc;
    if (client->swapped) {
        __GLX_SWAP_SHORT(&req->length);
        __GLX_SWAP_INT(&req->contextTag);
    }

    glxc = __glXForceCurrent(cl, req->contextTag, &error);
    if (!glxc) {
        return error;
    }

    commandsDone = 0;
    pc += sz_xGLXRenderReq;
    left = (req->length << 2) - sz_xGLXRenderReq;
    while (left > 0) {
        __GLXrenderSizeData entry;
        int extra = 0;
        __GLXdispatchRenderProcPtr proc;
        int err;

        if (left < sizeof(__GLXrenderHeader))
            return BadLength;

        /*
         ** Verify that the header length and the overall length agree.
         ** Also, each command must be word aligned.
         */
        hdr = (__GLXrenderHeader *) pc;
        if (client->swapped) {
            __GLX_SWAP_SHORT(&hdr->length);
            __GLX_SWAP_SHORT(&hdr->opcode);
        }
        cmdlen = hdr->length;
        opcode = hdr->opcode;

        if (left < cmdlen)
            return BadLength;

        /*
         ** Check for core opcodes and grab entry data.
         */
        err = __glXGetProtocolSizeData(&Render_dispatch_info, opcode, &entry);
        proc = (__GLXdispatchRenderProcPtr)
            __glXGetProtocolDecodeFunction(&Render_dispatch_info,
                                           opcode, client->swapped);

        if ((err < 0) || (proc == NULL)) {
            client->errorValue = commandsDone;
            return __glXError(GLXBadRenderRequest);
        }

        if (cmdlen < entry.bytes) {
            return BadLength;
        }

        if (entry.varsize) {
            /* variable size command */
            extra = (*entry.varsize) (pc + __GLX_RENDER_HDR_SIZE,
                                      client->swapped,
                                      left - __GLX_RENDER_HDR_SIZE);
            if (extra < 0) {
                return BadLength;
            }
        }

        if (cmdlen != safe_pad(safe_add(entry.bytes, extra))) {
            return BadLength;
        }

        /*
         ** Skip over the header and execute the command.  We allow the
         ** caller to trash the command memory.  This is useful especially
         ** for things that require double alignment - they can just shift
         ** the data towards lower memory (trashing the header) by 4 bytes
         ** and achieve the required alignment.
         */
        (*proc) (pc + __GLX_RENDER_HDR_SIZE);
        pc += cmdlen;
        left -= cmdlen;
        commandsDone++;
    }
    return Success;
}

/*
** Execute a large rendering request (one that spans multiple X requests).
*/
int
__glXDisp_RenderLarge(__GLXclientState * cl, GLbyte * pc)
{
    xGLXRenderLargeReq *req;
    ClientPtr client = cl->client;
    size_t dataBytes;
    __GLXrenderLargeHeader *hdr;
    __GLXcontext *glxc;
    int error;
    CARD16 opcode;

    __GLX_DECLARE_SWAP_VARIABLES;

    REQUEST_AT_LEAST_SIZE(xGLXRenderLargeReq);

    req = (xGLXRenderLargeReq *) pc;
    if (client->swapped) {
        __GLX_SWAP_SHORT(&req->length);
        __GLX_SWAP_INT(&req->contextTag);
        __GLX_SWAP_INT(&req->dataBytes);
        __GLX_SWAP_SHORT(&req->requestNumber);
        __GLX_SWAP_SHORT(&req->requestTotal);
    }

    glxc = __glXForceCurrent(cl, req->contextTag, &error);
    if (!glxc) {
        return error;
    }
    if (safe_pad(req->dataBytes) < 0)
        return BadLength;
    dataBytes = req->dataBytes;

    /*
     ** Check the request length.
     */
    if ((req->length << 2) != safe_pad(dataBytes) + sz_xGLXRenderLargeReq) {
        client->errorValue = req->length;
        /* Reset in case this isn't 1st request. */
        ResetLargeCommandStatus(glxc);
        return BadLength;
    }
    pc += sz_xGLXRenderLargeReq;

    if (glxc->largeCmdRequestsSoFar == 0) {
        __GLXrenderSizeData entry;
        int extra = 0;
        int left = (req->length << 2) - sz_xGLXRenderLargeReq;
        int cmdlen;
        int err;

        /*
         ** This is the first request of a multi request command.
         ** Make enough space in the buffer, then copy the entire request.
         */
        if (req->requestNumber != 1) {
            client->errorValue = req->requestNumber;
            return __glXError(GLXBadLargeRequest);
        }

        if (dataBytes < __GLX_RENDER_LARGE_HDR_SIZE)
            return BadLength;

        hdr = (__GLXrenderLargeHeader *) pc;
        if (client->swapped) {
            __GLX_SWAP_INT(&hdr->length);
            __GLX_SWAP_INT(&hdr->opcode);
        }
        opcode = hdr->opcode;
        if ((cmdlen = safe_pad(hdr->length)) < 0)
            return BadLength;

        /*
         ** Check for core opcodes and grab entry data.
         */
        err = __glXGetProtocolSizeData(&Render_dispatch_info, opcode, &entry);
        if (err < 0) {
            client->errorValue = opcode;
            return __glXError(GLXBadLargeRequest);
        }

        if (entry.varsize) {
            /*
             ** If it's a variable-size command (a command whose length must
             ** be computed from its parameters), all the parameters needed
             ** will be in the 1st request, so it's okay to do this.
             */
            extra = (*entry.varsize) (pc + __GLX_RENDER_LARGE_HDR_SIZE,
                                      client->swapped,
                                      left - __GLX_RENDER_LARGE_HDR_SIZE);
            if (extra < 0) {
                return BadLength;
            }
        }

        /* the +4 is safe because we know entry.bytes is small */
        if (cmdlen != safe_pad(safe_add(entry.bytes + 4, extra))) {
            return BadLength;
        }

        /*
         ** Make enough space in the buffer, then copy the entire request.
         */
        if (glxc->largeCmdBufSize < cmdlen) {
	    GLbyte *newbuf = glxc->largeCmdBuf;

	    if (!(newbuf = realloc(newbuf, cmdlen)))
		return BadAlloc;

	    glxc->largeCmdBuf = newbuf;
            glxc->largeCmdBufSize = cmdlen;
        }
        memcpy(glxc->largeCmdBuf, pc, dataBytes);

        glxc->largeCmdBytesSoFar = dataBytes;
        glxc->largeCmdBytesTotal = cmdlen;
        glxc->largeCmdRequestsSoFar = 1;
        glxc->largeCmdRequestsTotal = req->requestTotal;
        return Success;

    }
    else {
        /*
         ** We are receiving subsequent (i.e. not the first) requests of a
         ** multi request command.
         */
        int bytesSoFar; /* including this packet */

        /*
         ** Check the request number and the total request count.
         */
        if (req->requestNumber != glxc->largeCmdRequestsSoFar + 1) {
            client->errorValue = req->requestNumber;
            ResetLargeCommandStatus(glxc);
            return __glXError(GLXBadLargeRequest);
        }
        if (req->requestTotal != glxc->largeCmdRequestsTotal) {
            client->errorValue = req->requestTotal;
            ResetLargeCommandStatus(glxc);
            return __glXError(GLXBadLargeRequest);
        }

        /*
         ** Check that we didn't get too much data.
         */
        if ((bytesSoFar = safe_add(glxc->largeCmdBytesSoFar, dataBytes)) < 0) {
            client->errorValue = dataBytes;
            ResetLargeCommandStatus(glxc);
            return __glXError(GLXBadLargeRequest);
        }

        if (bytesSoFar > glxc->largeCmdBytesTotal) {
            client->errorValue = dataBytes;
            ResetLargeCommandStatus(glxc);
            return __glXError(GLXBadLargeRequest);
        }

        memcpy(glxc->largeCmdBuf + glxc->largeCmdBytesSoFar, pc, dataBytes);
        glxc->largeCmdBytesSoFar += dataBytes;
        glxc->largeCmdRequestsSoFar++;

        if (req->requestNumber == glxc->largeCmdRequestsTotal) {
            __GLXdispatchRenderProcPtr proc;

            /*
             ** This is the last request; it must have enough bytes to complete
             ** the command.
             */
            /* NOTE: the pad macro below is needed because the client library
             ** pads the total byte count, but not the per-request byte counts.
             ** The Protocol Encoding says the total byte count should not be
             ** padded, so a proposal will be made to the ARB to relax the
             ** padding constraint on the total byte count, thus preserving
             ** backward compatibility.  Meanwhile, the padding done below
             ** fixes a bug that did not allow large commands of odd sizes to
             ** be accepted by the server.
             */
            if (safe_pad(glxc->largeCmdBytesSoFar) != glxc->largeCmdBytesTotal) {
                client->errorValue = dataBytes;
                ResetLargeCommandStatus(glxc);
                return __glXError(GLXBadLargeRequest);
            }
            hdr = (__GLXrenderLargeHeader *) glxc->largeCmdBuf;
            /*
             ** The opcode and length field in the header had already been
             ** swapped when the first request was received.
             **
             ** Use the opcode to index into the procedure table.
             */
            opcode = hdr->opcode;

            proc = (__GLXdispatchRenderProcPtr)
                __glXGetProtocolDecodeFunction(&Render_dispatch_info, opcode,
                                               client->swapped);
            if (proc == NULL) {
                client->errorValue = opcode;
                return __glXError(GLXBadLargeRequest);
            }

            /*
             ** Skip over the header and execute the command.
             */
            (*proc) (glxc->largeCmdBuf + __GLX_RENDER_LARGE_HDR_SIZE);

            /*
             ** Reset for the next RenderLarge series.
             */
            ResetLargeCommandStatus(glxc);
        }
        else {
            /*
             ** This is neither the first nor the last request.
             */
        }
        return Success;
    }
}

/************************************************************************/

/*
** No support is provided for the vendor-private requests other than
** allocating the entry points in the dispatch table.
*/

int
__glXDisp_VendorPrivate(__GLXclientState * cl, GLbyte * pc)
{
    ClientPtr client = cl->client;
    xGLXVendorPrivateReq *req = (xGLXVendorPrivateReq *) pc;
    GLint vendorcode = req->vendorCode;
    __GLXdispatchVendorPrivProcPtr proc;

    REQUEST_AT_LEAST_SIZE(xGLXVendorPrivateReq);

    proc = (__GLXdispatchVendorPrivProcPtr)
        __glXGetProtocolDecodeFunction(&VendorPriv_dispatch_info,
                                       vendorcode, 0);
    if (proc != NULL) {
        return (*proc) (cl, (GLbyte *) req);
    }

    cl->client->errorValue = req->vendorCode;
    return __glXError(GLXUnsupportedPrivateRequest);
}

int
__glXDisp_VendorPrivateWithReply(__GLXclientState * cl, GLbyte * pc)
{
    ClientPtr client = cl->client;
    xGLXVendorPrivateReq *req = (xGLXVendorPrivateReq *) pc;
    GLint vendorcode = req->vendorCode;
    __GLXdispatchVendorPrivProcPtr proc;

    REQUEST_AT_LEAST_SIZE(xGLXVendorPrivateReq);

    proc = (__GLXdispatchVendorPrivProcPtr)
        __glXGetProtocolDecodeFunction(&VendorPriv_dispatch_info,
                                       vendorcode, 0);
    if (proc != NULL) {
        return (*proc) (cl, (GLbyte *) req);
    }

    cl->client->errorValue = vendorcode;
    return __glXError(GLXUnsupportedPrivateRequest);
}

int
__glXDisp_QueryExtensionsString(__GLXclientState * cl, GLbyte * pc)
{
    ClientPtr client = cl->client;
    xGLXQueryExtensionsStringReq *req = (xGLXQueryExtensionsStringReq *) pc;
    xGLXQueryExtensionsStringReply reply;
    __GLXscreen *pGlxScreen;
    size_t n, length;
    char *buf;
    int err;

    if (!validGlxScreen(client, req->screen, &pGlxScreen, &err))
        return err;

    n = strlen(pGlxScreen->GLXextensions) + 1;
    length = __GLX_PAD(n) >> 2;
    reply = (xGLXQueryExtensionsStringReply) {
        .type = X_Reply,
        .sequenceNumber = client->sequence,
        .length = length,
        .n = n
    };

    /* Allocate buffer to make sure it's a multiple of 4 bytes big. */
    buf = calloc(length, 4);
    if (buf == NULL)
        return BadAlloc;
    memcpy(buf, pGlxScreen->GLXextensions, n);

    if (client->swapped) {
        __GLX_DECLARE_SWAP_VARIABLES;
        __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
        __GLX_SWAP_SHORT(&reply.sequenceNumber);
        __GLX_SWAP_INT(&reply.length);
        __GLX_SWAP_INT(&reply.n);
        WriteToClient(client, sz_xGLXQueryExtensionsStringReply, &reply);
        __GLX_SWAP_INT_ARRAY((int *) buf, length);
        WriteToClient(client, length << 2, buf);
    }
    else {
        WriteToClient(client, sz_xGLXQueryExtensionsStringReply, &reply);
        WriteToClient(client, (int) (length << 2), buf);
    }

    free(buf);
    return Success;
}

#ifndef GLX_VENDOR_NAMES_EXT
#define GLX_VENDOR_NAMES_EXT 0x20F6
#endif

int
__glXDisp_QueryServerString(__GLXclientState * cl, GLbyte * pc)
{
    ClientPtr client = cl->client;
    xGLXQueryServerStringReq *req = (xGLXQueryServerStringReq *) pc;
    xGLXQueryServerStringReply reply;
    size_t n, length;
    const char *ptr;
    char *buf;
    __GLXscreen *pGlxScreen;
    int err;

    if (!validGlxScreen(client, req->screen, &pGlxScreen, &err))
        return err;

    switch (req->name) {
    case GLX_VENDOR:
        ptr = GLXServerVendorName;
        break;
    case GLX_VERSION:
        ptr = "1.4";
        break;
    case GLX_EXTENSIONS:
        ptr = pGlxScreen->GLXextensions;
        break;
    case GLX_VENDOR_NAMES_EXT:
        if (pGlxScreen->glvnd) {
            ptr = pGlxScreen->glvnd;
            break;
        }
        /* else fall through */
    default:
        return BadValue;
    }

    n = strlen(ptr) + 1;
    length = __GLX_PAD(n) >> 2;
    reply = (xGLXQueryServerStringReply) {
        .type = X_Reply,
        .sequenceNumber = client->sequence,
        .length = length,
        .n = n
    };

    buf = calloc(length, 4);
    if (buf == NULL) {
        return BadAlloc;
    }
    memcpy(buf, ptr, n);

    if (client->swapped) {
        __GLX_DECLARE_SWAP_VARIABLES;
        __GLX_SWAP_SHORT(&reply.sequenceNumber);
        __GLX_SWAP_INT(&reply.length);
        __GLX_SWAP_INT(&reply.n);
        WriteToClient(client, sz_xGLXQueryServerStringReply, &reply);
        /** no swap is needed for an array of chars **/
        /* __GLX_SWAP_INT_ARRAY((int *)buf, length); */
        WriteToClient(client, length << 2, buf);
    }
    else {
        WriteToClient(client, sz_xGLXQueryServerStringReply, &reply);
        WriteToClient(client, (int) (length << 2), buf);
    }

    free(buf);
    return Success;
}

int
__glXDisp_ClientInfo(__GLXclientState * cl, GLbyte * pc)
{
    ClientPtr client = cl->client;
    xGLXClientInfoReq *req = (xGLXClientInfoReq *) pc;
    const char *buf;

    REQUEST_AT_LEAST_SIZE(xGLXClientInfoReq);

    buf = (const char *) (req + 1);
    if (!memchr(buf, 0, (client->req_len << 2) - sizeof(xGLXClientInfoReq)))
        return BadLength;

    free(cl->GLClientextensions);
    cl->GLClientextensions = strdup(buf);

    return Success;
}

#include <GL/glxtokens.h>

void
__glXsendSwapEvent(__GLXdrawable *drawable, int type, CARD64 ust,
                   CARD64 msc, CARD32 sbc)
{
    ClientPtr client = clients[CLIENT_ID(drawable->drawId)];

    xGLXBufferSwapComplete2 wire =  {
        .type = __glXEventBase + GLX_BufferSwapComplete
    };

    if (!client)
        return;

    if (!(drawable->eventMask & GLX_BUFFER_SWAP_COMPLETE_INTEL_MASK))
        return;

    wire.event_type = type;
    wire.drawable = drawable->drawId;
    wire.ust_hi = ust >> 32;
    wire.ust_lo = ust & 0xffffffff;
    wire.msc_hi = msc >> 32;
    wire.msc_lo = msc & 0xffffffff;
    wire.sbc = sbc;

    WriteEventsToClient(client, 1, (xEvent *) &wire);
}

#if PRESENT
static void
__glXpresentCompleteNotify(WindowPtr window, CARD8 present_kind, CARD8 present_mode,
                           CARD32 serial, uint64_t ust, uint64_t msc)
{
    __GLXdrawable *drawable;
    int glx_type;
    int rc;

    if (present_kind != PresentCompleteKindPixmap)
        return;

    rc = dixLookupResourceByType((void **) &drawable, window->drawable.id,
                                 __glXDrawableRes, serverClient, DixGetAttrAccess);

    if (rc != Success)
        return;

    if (present_mode == PresentCompleteModeFlip)
        glx_type = GLX_FLIP_COMPLETE_INTEL;
    else
        glx_type = GLX_BLIT_COMPLETE_INTEL;

    __glXsendSwapEvent(drawable, glx_type, ust, msc, serial);
}

#include <present.h>

void
__glXregisterPresentCompleteNotify(void)
{
    present_register_complete_notify(__glXpresentCompleteNotify);
}
#endif
