[deb_xorg-server.git] / hw / xquartz / xpr / appledri.c

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

   Copyright 1998-1999 Precision Insight, Inc., Cedar Park, Texas.
   Copyright 2000 VA Linux Systems, Inc.
   Copyright (c) 2002, 2009-2012 Apple 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, sub license, 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 NON-INFRINGEMENT.
   IN NO EVENT SHALL PRECISION INSIGHT AND/OR ITS SUPPLIERS 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.

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

/*
 * Authors:
 *   Kevin E. Martin <martin@valinux.com>
 *   Jens Owen <jens@valinux.com>
 *   Rickard E. (Rik) Faith <faith@valinux.com>
 *   Jeremy Huddleston <jeremyhu@apple.com>
 *
 */

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

#include <X11/X.h>
#include <X11/Xproto.h>
#include "misc.h"
#include "dixstruct.h"
#include "extnsionst.h"
#include "colormapst.h"
#include "cursorstr.h"
#include "scrnintstr.h"
#include "servermd.h"
#define _APPLEDRI_SERVER_
#include "appledristr.h"
#include "swaprep.h"
#include "dri.h"
#include "dristruct.h"
#include "xpr.h"
#include "x-hash.h"
#include "protocol-versions.h"

static int DRIErrorBase = 0;

static void
AppleDRIResetProc(ExtensionEntry* extEntry);
static int
ProcAppleDRICreatePixmap(ClientPtr client);

static unsigned char DRIReqCode = 0;
static int DRIEventBase = 0;

static void
SNotifyEvent(xAppleDRINotifyEvent *from, xAppleDRINotifyEvent *to);

typedef struct _DRIEvent *DRIEventPtr;
typedef struct _DRIEvent {
    DRIEventPtr next;
    ClientPtr client;
    XID clientResource;
    unsigned int mask;
} DRIEventRec;

/*ARGSUSED*/
static void
AppleDRIResetProc(ExtensionEntry* extEntry)
{
    DRIReset();
}

static int
ProcAppleDRIQueryVersion(register ClientPtr client)
{
    xAppleDRIQueryVersionReply rep;

    REQUEST_SIZE_MATCH(xAppleDRIQueryVersionReq);
    rep.type = X_Reply;
    rep.length = 0;
    rep.sequenceNumber = client->sequence;
    rep.majorVersion = SERVER_APPLEDRI_MAJOR_VERSION;
    rep.minorVersion = SERVER_APPLEDRI_MINOR_VERSION;
    rep.patchVersion = SERVER_APPLEDRI_PATCH_VERSION;
    if (client->swapped) {
        swaps(&rep.sequenceNumber);
        swapl(&rep.length);
        swaps(&rep.majorVersion);
        swaps(&rep.minorVersion);
        swapl(&rep.patchVersion);
    }
    WriteToClient(client, sizeof(xAppleDRIQueryVersionReply), &rep);
    return Success;
}

/* surfaces */

static int
ProcAppleDRIQueryDirectRenderingCapable(register ClientPtr client)
{
    xAppleDRIQueryDirectRenderingCapableReply rep;
    Bool isCapable;

    REQUEST(xAppleDRIQueryDirectRenderingCapableReq);
    REQUEST_SIZE_MATCH(xAppleDRIQueryDirectRenderingCapableReq);
    rep.type = X_Reply;
    rep.length = 0;
    rep.sequenceNumber = client->sequence;

    if (stuff->screen >= screenInfo.numScreens) {
        return BadValue;
    }

    if (!DRIQueryDirectRenderingCapable(screenInfo.screens[stuff->screen],
                                        &isCapable)) {
        return BadValue;
    }
    rep.isCapable = isCapable;

    if (!client->local)
        rep.isCapable = 0;

    if (client->swapped) {
        swaps(&rep.sequenceNumber);
        swapl(&rep.length);
    }

    WriteToClient(client,
                  sizeof(xAppleDRIQueryDirectRenderingCapableReply),
                  &rep);
    return Success;
}

static int
ProcAppleDRIAuthConnection(register ClientPtr client)
{
    xAppleDRIAuthConnectionReply rep;

    REQUEST(xAppleDRIAuthConnectionReq);
    REQUEST_SIZE_MATCH(xAppleDRIAuthConnectionReq);

    rep.type = X_Reply;
    rep.length = 0;
    rep.sequenceNumber = client->sequence;
    rep.authenticated = 1;

    if (!DRIAuthConnection(screenInfo.screens[stuff->screen],
                           stuff->magic)) {
        ErrorF("Failed to authenticate %u\n", (unsigned int)stuff->magic);
        rep.authenticated = 0;
    }

    if (client->swapped) {
        swaps(&rep.sequenceNumber);
        swapl(&rep.length);
        swapl(&rep.authenticated); /* Yes, this is a CARD32 ... sigh */
    }

    WriteToClient(client, sizeof(xAppleDRIAuthConnectionReply), &rep);
    return Success;
}

static void
surface_notify(void *_arg,
               void *data)
{
    DRISurfaceNotifyArg *arg = _arg;
    int client_index = (int)x_cvt_vptr_to_uint(data);
    xAppleDRINotifyEvent se;

    if (client_index < 0 || client_index >= currentMaxClients)
        return;

    se.type = DRIEventBase + AppleDRISurfaceNotify;
    se.kind = arg->kind;
    se.arg = arg->id;
    se.time = currentTime.milliseconds;
    WriteEventsToClient(clients[client_index], 1, (xEvent *)&se);
}

static int
ProcAppleDRICreateSurface(ClientPtr client)
{
    xAppleDRICreateSurfaceReply rep;
    DrawablePtr pDrawable;
    xp_surface_id sid;
    unsigned int key[2];
    int rc;

    REQUEST(xAppleDRICreateSurfaceReq);
    REQUEST_SIZE_MATCH(xAppleDRICreateSurfaceReq);
    rep.type = X_Reply;
    rep.length = 0;
    rep.sequenceNumber = client->sequence;

    rc = dixLookupDrawable(&pDrawable, stuff->drawable, client, 0,
                           DixReadAccess);
    if (rc != Success)
        return rc;

    rep.key_0 = rep.key_1 = rep.uid = 0;

    if (!DRICreateSurface(screenInfo.screens[stuff->screen],
                          (Drawable)stuff->drawable, pDrawable,
                          stuff->client_id, &sid, key,
                          surface_notify,
                          x_cvt_uint_to_vptr(client->index))) {
        return BadValue;
    }

    rep.key_0 = key[0];
    rep.key_1 = key[1];
    rep.uid = sid;

    if (client->swapped) {
        swaps(&rep.sequenceNumber);
        swapl(&rep.length);
        swapl(&rep.key_0);
        swapl(&rep.key_1);
        swapl(&rep.uid);
    }

    WriteToClient(client, sizeof(xAppleDRICreateSurfaceReply), &rep);
    return Success;
}

static int
ProcAppleDRIDestroySurface(register ClientPtr client)
{
    int rc;
    REQUEST(xAppleDRIDestroySurfaceReq);
    DrawablePtr pDrawable;
    REQUEST_SIZE_MATCH(xAppleDRIDestroySurfaceReq);

    rc = dixLookupDrawable(&pDrawable, stuff->drawable, client, 0,
                           DixReadAccess);
    if (rc != Success)
        return rc;

    if (!DRIDestroySurface(screenInfo.screens[stuff->screen],
                           (Drawable)stuff->drawable,
                           pDrawable, NULL, NULL)) {
        return BadValue;
    }

    return Success;
}

static int
ProcAppleDRICreatePixmap(ClientPtr client)
{
    REQUEST(xAppleDRICreatePixmapReq);
    DrawablePtr pDrawable;
    int rc;
    char path[PATH_MAX];
    xAppleDRICreatePixmapReply rep;
    int width, height, pitch, bpp;
    void *ptr;

    REQUEST_SIZE_MATCH(xAppleDRICreatePixmapReq);

    rc = dixLookupDrawable(&pDrawable, stuff->drawable, client, 0,
                           DixReadAccess);

    if (rc != Success)
        return rc;

    if (!DRICreatePixmap(screenInfo.screens[stuff->screen],
                         (Drawable)stuff->drawable,
                         pDrawable,
                         path, PATH_MAX)) {
        return BadValue;
    }

    if (!DRIGetPixmapData(pDrawable, &width, &height,
                          &pitch, &bpp, &ptr)) {
        return BadValue;
    }

    rep.stringLength = strlen(path) + 1;

    rep.type = X_Reply;
    rep.length = bytes_to_int32(rep.stringLength);
    rep.sequenceNumber = client->sequence;
    rep.width = width;
    rep.height = height;
    rep.pitch = pitch;
    rep.bpp = bpp;
    rep.size = pitch * height;

    if (sizeof(rep) != sz_xAppleDRICreatePixmapReply)
        ErrorF("error sizeof(rep) is %zu\n", sizeof(rep));

    if (client->swapped) {
        swaps(&rep.sequenceNumber);
        swapl(&rep.length);
        swapl(&rep.stringLength);
        swapl(&rep.width);
        swapl(&rep.height);
        swapl(&rep.pitch);
        swapl(&rep.bpp);
        swapl(&rep.size);
    }

    WriteToClient(client, sizeof(rep), &rep);
    WriteToClient(client, rep.stringLength, path);

    return Success;
}

static int
ProcAppleDRIDestroyPixmap(ClientPtr client)
{
    DrawablePtr pDrawable;
    int rc;
    REQUEST(xAppleDRIDestroyPixmapReq);
    REQUEST_SIZE_MATCH(xAppleDRIDestroyPixmapReq);

    rc = dixLookupDrawable(&pDrawable, stuff->drawable, client, 0,
                           DixReadAccess);

    if (rc != Success)
        return rc;

    DRIDestroyPixmap(pDrawable);

    return Success;
}

/* dispatch */

static int
ProcAppleDRIDispatch(register ClientPtr client)
{
    REQUEST(xReq);

    switch (stuff->data) {
    case X_AppleDRIQueryVersion:
        return ProcAppleDRIQueryVersion(client);

    case X_AppleDRIQueryDirectRenderingCapable:
        return ProcAppleDRIQueryDirectRenderingCapable(client);
    }

    if (!client->local)
        return DRIErrorBase + AppleDRIClientNotLocal;

    switch (stuff->data) {
    case X_AppleDRIAuthConnection:
        return ProcAppleDRIAuthConnection(client);

    case X_AppleDRICreateSurface:
        return ProcAppleDRICreateSurface(client);

    case X_AppleDRIDestroySurface:
        return ProcAppleDRIDestroySurface(client);

    case X_AppleDRICreatePixmap:
        return ProcAppleDRICreatePixmap(client);

    case X_AppleDRIDestroyPixmap:
        return ProcAppleDRIDestroyPixmap(client);

    default:
        return BadRequest;
    }
}

static void
SNotifyEvent(xAppleDRINotifyEvent *from,
             xAppleDRINotifyEvent *to)
{
    to->type = from->type;
    to->kind = from->kind;
    cpswaps(from->sequenceNumber, to->sequenceNumber);
    cpswapl(from->time, to->time);
    cpswapl(from->arg, to->arg);
}

static int
SProcAppleDRIQueryVersion(register ClientPtr client)
{
    REQUEST(xAppleDRIQueryVersionReq);
    swaps(&stuff->length);
    return ProcAppleDRIQueryVersion(client);
}

static int
SProcAppleDRIQueryDirectRenderingCapable(register ClientPtr client)
{
    REQUEST(xAppleDRIQueryDirectRenderingCapableReq);
    swaps(&stuff->length);
    REQUEST_SIZE_MATCH(xAppleDRIQueryDirectRenderingCapableReq);
    swapl(&stuff->screen);
    return ProcAppleDRIQueryDirectRenderingCapable(client);
}

static int
SProcAppleDRIAuthConnection(register ClientPtr client)
{
    REQUEST(xAppleDRIAuthConnectionReq);
    swaps(&stuff->length);
    REQUEST_SIZE_MATCH(xAppleDRIAuthConnectionReq);
    swapl(&stuff->screen);
    swapl(&stuff->magic);
    return ProcAppleDRIAuthConnection(client);
}

static int
SProcAppleDRICreateSurface(register ClientPtr client)
{
    REQUEST(xAppleDRICreateSurfaceReq);
    swaps(&stuff->length);
    REQUEST_SIZE_MATCH(xAppleDRICreateSurfaceReq);
    swapl(&stuff->screen);
    swapl(&stuff->drawable);
    swapl(&stuff->client_id);
    return ProcAppleDRICreateSurface(client);
}

static int
SProcAppleDRIDestroySurface(register ClientPtr client)
{
    REQUEST(xAppleDRIDestroySurfaceReq);
    swaps(&stuff->length);
    REQUEST_SIZE_MATCH(xAppleDRIDestroySurfaceReq);
    swapl(&stuff->screen);
    swapl(&stuff->drawable);
    return ProcAppleDRIDestroySurface(client);
}

static int
SProcAppleDRICreatePixmap(register ClientPtr client)
{
    REQUEST(xAppleDRICreatePixmapReq);
    swaps(&stuff->length);
    REQUEST_SIZE_MATCH(xAppleDRICreatePixmapReq);
    swapl(&stuff->screen);
    swapl(&stuff->drawable);
    return ProcAppleDRICreatePixmap(client);
}

static int
SProcAppleDRIDestroyPixmap(register ClientPtr client)
{
    REQUEST(xAppleDRIDestroyPixmapReq);
    swaps(&stuff->length);
    REQUEST_SIZE_MATCH(xAppleDRIDestroyPixmapReq);
    swapl(&stuff->drawable);
    return ProcAppleDRIDestroyPixmap(client);
}

static int
SProcAppleDRIDispatch(register ClientPtr client)
{
    REQUEST(xReq);

    switch (stuff->data) {
    case X_AppleDRIQueryVersion:
        return SProcAppleDRIQueryVersion(client);

    case X_AppleDRIQueryDirectRenderingCapable:
        return SProcAppleDRIQueryDirectRenderingCapable(client);
    }

    if (!client->local)
        return DRIErrorBase + AppleDRIClientNotLocal;

    switch (stuff->data) {
    case X_AppleDRIAuthConnection:
        return SProcAppleDRIAuthConnection(client);

    case X_AppleDRICreateSurface:
        return SProcAppleDRICreateSurface(client);

    case X_AppleDRIDestroySurface:
        return SProcAppleDRIDestroySurface(client);

    case X_AppleDRICreatePixmap:
        return SProcAppleDRICreatePixmap(client);

    case X_AppleDRIDestroyPixmap:
        return SProcAppleDRIDestroyPixmap(client);

    default:
        return BadRequest;
    }
}

void
AppleDRIExtensionInit(void)
{
    ExtensionEntry* extEntry;

    if (DRIExtensionInit() &&
        (extEntry = AddExtension(APPLEDRINAME,
                                 AppleDRINumberEvents,
                                 AppleDRINumberErrors,
                                 ProcAppleDRIDispatch,
                                 SProcAppleDRIDispatch,
                                 AppleDRIResetProc,
                                 StandardMinorOpcode))) {
        size_t i;
        DRIReqCode = (unsigned char)extEntry->base;
        DRIErrorBase = extEntry->errorBase;
        DRIEventBase = extEntry->eventBase;
        for (i = 0; i < AppleDRINumberEvents; i++)
            EventSwapVector[DRIEventBase + i] = (EventSwapPtr)SNotifyEvent;
    }
}
Commit	Line	Data
a09e091a JB	1	/**************************************************************************
	2
	3	Copyright 1998-1999 Precision Insight, Inc., Cedar Park, Texas.
	4	Copyright 2000 VA Linux Systems, Inc.
	5	Copyright (c) 2002, 2009-2012 Apple Inc.
	6	All Rights Reserved.
	7
	8	Permission is hereby granted, free of charge, to any person obtaining a
	9	copy of this software and associated documentation files (the
	10	"Software"), to deal in the Software without restriction, including
	11	without limitation the rights to use, copy, modify, merge, publish,
	12	distribute, sub license, and/or sell copies of the Software, and to
	13	permit persons to whom the Software is furnished to do so, subject to
	14	the following conditions:
	15
	16	The above copyright notice and this permission notice (including the
	17	next paragraph) shall be included in all copies or substantial portions
	18	of the Software.
	19
	20	THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
	21	OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
	22	MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
	23	IN NO EVENT SHALL PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR
	24	ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
	25	TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
	26	SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
	27
	28	**************************************************************************/
	29
	30	/*
	31	* Authors:
	32	* Kevin E. Martin <martin@valinux.com>
	33	* Jens Owen <jens@valinux.com>
	34	* Rickard E. (Rik) Faith <faith@valinux.com>
	35	* Jeremy Huddleston <jeremyhu@apple.com>
	36	*
	37	*/
	38
	39	#ifdef HAVE_DIX_CONFIG_H
	40	#include <dix-config.h>
	41	#endif
	42
	43	#include <X11/X.h>
	44	#include <X11/Xproto.h>
	45	#include "misc.h"
	46	#include "dixstruct.h"
	47	#include "extnsionst.h"
	48	#include "colormapst.h"
	49	#include "cursorstr.h"
	50	#include "scrnintstr.h"
	51	#include "servermd.h"
	52	#define _APPLEDRI_SERVER_
	53	#include "appledristr.h"
	54	#include "swaprep.h"
	55	#include "dri.h"
	56	#include "dristruct.h"
	57	#include "xpr.h"
	58	#include "x-hash.h"
	59	#include "protocol-versions.h"
	60
	61	static int DRIErrorBase = 0;
	62
	63	static void
	64	AppleDRIResetProc(ExtensionEntry* extEntry);
65	static int
66	ProcAppleDRICreatePixmap(ClientPtr client);
67
68	static unsigned char DRIReqCode = 0;
69	static int DRIEventBase = 0;
70
71	static void
72	SNotifyEvent(xAppleDRINotifyEvent from, xAppleDRINotifyEvent to);
73
74	typedef struct _DRIEvent *DRIEventPtr;
75	typedef struct _DRIEvent {
76	DRIEventPtr next;
77	ClientPtr client;
78	XID clientResource;
79	unsigned int mask;
80	} DRIEventRec;
81
82	/ARGSUSED/
83	static void
84	AppleDRIResetProc(ExtensionEntry* extEntry)
85	{
86	DRIReset();
87	}
88
89	static int
90	ProcAppleDRIQueryVersion(register ClientPtr client)
91	{
92	xAppleDRIQueryVersionReply rep;
93
94	REQUEST_SIZE_MATCH(xAppleDRIQueryVersionReq);
95	rep.type = X_Reply;
96	rep.length = 0;
97	rep.sequenceNumber = client->sequence;
98	rep.majorVersion = SERVER_APPLEDRI_MAJOR_VERSION;
99	rep.minorVersion = SERVER_APPLEDRI_MINOR_VERSION;
100	rep.patchVersion = SERVER_APPLEDRI_PATCH_VERSION;
101	if (client->swapped) {
102	swaps(&rep.sequenceNumber);
103	swapl(&rep.length);
104	swaps(&rep.majorVersion);
105	swaps(&rep.minorVersion);
106	swapl(&rep.patchVersion);
107	}
108	WriteToClient(client, sizeof(xAppleDRIQueryVersionReply), &rep);
109	return Success;
110	}
111
112	/* surfaces */
113
114	static int
115	ProcAppleDRIQueryDirectRenderingCapable(register ClientPtr client)
116	{
117	xAppleDRIQueryDirectRenderingCapableReply rep;
118	Bool isCapable;
119
120	REQUEST(xAppleDRIQueryDirectRenderingCapableReq);
121	REQUEST_SIZE_MATCH(xAppleDRIQueryDirectRenderingCapableReq);
122	rep.type = X_Reply;
123	rep.length = 0;
124	rep.sequenceNumber = client->sequence;
125
126	if (stuff->screen >= screenInfo.numScreens) {
127	return BadValue;
128	}
129
130	if (!DRIQueryDirectRenderingCapable(screenInfo.screens[stuff->screen],
131	&isCapable)) {
132	return BadValue;
133	}
134	rep.isCapable = isCapable;
135
136	if (!client->local)
137	rep.isCapable = 0;
138
139	if (client->swapped) {
140	swaps(&rep.sequenceNumber);
141	swapl(&rep.length);
142	}
143
144	WriteToClient(client,
145	sizeof(xAppleDRIQueryDirectRenderingCapableReply),
146	&rep);
147	return Success;
148	}
149
150	static int
151	ProcAppleDRIAuthConnection(register ClientPtr client)
152	{
153	xAppleDRIAuthConnectionReply rep;
154
155	REQUEST(xAppleDRIAuthConnectionReq);
156	REQUEST_SIZE_MATCH(xAppleDRIAuthConnectionReq);
157
158	rep.type = X_Reply;
159	rep.length = 0;
160	rep.sequenceNumber = client->sequence;
161	rep.authenticated = 1;
162
163	if (!DRIAuthConnection(screenInfo.screens[stuff->screen],
164	stuff->magic)) {
165	ErrorF("Failed to authenticate %u\n", (unsigned int)stuff->magic);
166	rep.authenticated = 0;
167	}
168
169	if (client->swapped) {
170	swaps(&rep.sequenceNumber);
171	swapl(&rep.length);
172	swapl(&rep.authenticated); /* Yes, this is a CARD32 ... sigh */
173	}
174
175	WriteToClient(client, sizeof(xAppleDRIAuthConnectionReply), &rep);
176	return Success;
177	}
178
179	static void
180	surface_notify(void *_arg,
181	void *data)
182	{
183	DRISurfaceNotifyArg *arg = _arg;
184	int client_index = (int)x_cvt_vptr_to_uint(data);
185	xAppleDRINotifyEvent se;
186
187	if (client_index < 0 \|\| client_index >= currentMaxClients)
188	return;
189
190	se.type = DRIEventBase + AppleDRISurfaceNotify;
191	se.kind = arg->kind;
192	se.arg = arg->id;
193	se.time = currentTime.milliseconds;
194	WriteEventsToClient(clients[client_index], 1, (xEvent *)&se);
195	}
196
197	static int
198	ProcAppleDRICreateSurface(ClientPtr client)
199	{
200	xAppleDRICreateSurfaceReply rep;
201	DrawablePtr pDrawable;
202	xp_surface_id sid;
203	unsigned int key[2];
204	int rc;
205
206	REQUEST(xAppleDRICreateSurfaceReq);
207	REQUEST_SIZE_MATCH(xAppleDRICreateSurfaceReq);
208	rep.type = X_Reply;
209	rep.length = 0;
210	rep.sequenceNumber = client->sequence;
211
212	rc = dixLookupDrawable(&pDrawable, stuff->drawable, client, 0,
213	DixReadAccess);
214	if (rc != Success)
215	return rc;
216
217	rep.key_0 = rep.key_1 = rep.uid = 0;
218
219	if (!DRICreateSurface(screenInfo.screens[stuff->screen],
220	(Drawable)stuff->drawable, pDrawable,
221	stuff->client_id, &sid, key,
222	surface_notify,
223	x_cvt_uint_to_vptr(client->index))) {
224	return BadValue;
225	}
226
227	rep.key_0 = key[0];
228	rep.key_1 = key[1];
229	rep.uid = sid;
230
231	if (client->swapped) {
232	swaps(&rep.sequenceNumber);
233	swapl(&rep.length);
234	swapl(&rep.key_0);
235	swapl(&rep.key_1);
236	swapl(&rep.uid);
237	}
238
239	WriteToClient(client, sizeof(xAppleDRICreateSurfaceReply), &rep);
240	return Success;
241	}
242
243	static int
244	ProcAppleDRIDestroySurface(register ClientPtr client)
245	{
246	int rc;
247	REQUEST(xAppleDRIDestroySurfaceReq);
248	DrawablePtr pDrawable;
249	REQUEST_SIZE_MATCH(xAppleDRIDestroySurfaceReq);
250
251	rc = dixLookupDrawable(&pDrawable, stuff->drawable, client, 0,
252	DixReadAccess);
253	if (rc != Success)
254	return rc;
255
256	if (!DRIDestroySurface(screenInfo.screens[stuff->screen],
257	(Drawable)stuff->drawable,
258	pDrawable, NULL, NULL)) {
259	return BadValue;
260	}
261
262	return Success;
263	}
264
265	static int
266	ProcAppleDRICreatePixmap(ClientPtr client)
267	{
268	REQUEST(xAppleDRICreatePixmapReq);
269	DrawablePtr pDrawable;
270	int rc;
271	char path[PATH_MAX];
272	xAppleDRICreatePixmapReply rep;
273	int width, height, pitch, bpp;
274	void *ptr;
275
276	REQUEST_SIZE_MATCH(xAppleDRICreatePixmapReq);
277
278	rc = dixLookupDrawable(&pDrawable, stuff->drawable, client, 0,
279	DixReadAccess);
280
281	if (rc != Success)
282	return rc;
283
284	if (!DRICreatePixmap(screenInfo.screens[stuff->screen],
285	(Drawable)stuff->drawable,
286	pDrawable,
287	path, PATH_MAX)) {
288	return BadValue;
289	}
290
291	if (!DRIGetPixmapData(pDrawable, &width, &height,
292	&pitch, &bpp, &ptr)) {
293	return BadValue;
294	}
295
296	rep.stringLength = strlen(path) + 1;
297
298	rep.type = X_Reply;
299	rep.length = bytes_to_int32(rep.stringLength);
300	rep.sequenceNumber = client->sequence;
301	rep.width = width;
302	rep.height = height;
303	rep.pitch = pitch;
304	rep.bpp = bpp;
305	rep.size = pitch * height;
306
307	if (sizeof(rep) != sz_xAppleDRICreatePixmapReply)
308	ErrorF("error sizeof(rep) is %zu\n", sizeof(rep));
309
310	if (client->swapped) {
311	swaps(&rep.sequenceNumber);
312	swapl(&rep.length);
313	swapl(&rep.stringLength);
314	swapl(&rep.width);
315	swapl(&rep.height);
316	swapl(&rep.pitch);
317	swapl(&rep.bpp);
318	swapl(&rep.size);
319	}
320
321	WriteToClient(client, sizeof(rep), &rep);
322	WriteToClient(client, rep.stringLength, path);
323
324	return Success;
325	}
326
327	static int
328	ProcAppleDRIDestroyPixmap(ClientPtr client)
329	{
330	DrawablePtr pDrawable;
331	int rc;
332	REQUEST(xAppleDRIDestroyPixmapReq);
333	REQUEST_SIZE_MATCH(xAppleDRIDestroyPixmapReq);
334
335	rc = dixLookupDrawable(&pDrawable, stuff->drawable, client, 0,
336	DixReadAccess);
337
338	if (rc != Success)
339	return rc;
340
341	DRIDestroyPixmap(pDrawable);
342
343	return Success;
344	}
345
346	/* dispatch */
347
348	static int
349	ProcAppleDRIDispatch(register ClientPtr client)
350	{
351	REQUEST(xReq);
352
353	switch (stuff->data) {
354	case X_AppleDRIQueryVersion:
355	return ProcAppleDRIQueryVersion(client);
356
357	case X_AppleDRIQueryDirectRenderingCapable:
358	return ProcAppleDRIQueryDirectRenderingCapable(client);
359	}
360
361	if (!client->local)
362	return DRIErrorBase + AppleDRIClientNotLocal;
363
364	switch (stuff->data) {
365	case X_AppleDRIAuthConnection:
366	return ProcAppleDRIAuthConnection(client);
367
368	case X_AppleDRICreateSurface:
369	return ProcAppleDRICreateSurface(client);
370
371	case X_AppleDRIDestroySurface:
372	return ProcAppleDRIDestroySurface(client);
373
374	case X_AppleDRICreatePixmap:
375	return ProcAppleDRICreatePixmap(client);
376
377	case X_AppleDRIDestroyPixmap:
378	return ProcAppleDRIDestroyPixmap(client);
379
380	default:
381	return BadRequest;
382	}
383	}
384
385	static void
386	SNotifyEvent(xAppleDRINotifyEvent *from,
387	xAppleDRINotifyEvent *to)
388	{
389	to->type = from->type;
390	to->kind = from->kind;
391	cpswaps(from->sequenceNumber, to->sequenceNumber);
392	cpswapl(from->time, to->time);
393	cpswapl(from->arg, to->arg);
394	}
395
396	static int
397	SProcAppleDRIQueryVersion(register ClientPtr client)
398	{
399	REQUEST(xAppleDRIQueryVersionReq);
400	swaps(&stuff->length);
401	return ProcAppleDRIQueryVersion(client);
402	}
403
404	static int
405	SProcAppleDRIQueryDirectRenderingCapable(register ClientPtr client)
406	{
407	REQUEST(xAppleDRIQueryDirectRenderingCapableReq);
408	swaps(&stuff->length);
409	REQUEST_SIZE_MATCH(xAppleDRIQueryDirectRenderingCapableReq);
410	swapl(&stuff->screen);
411	return ProcAppleDRIQueryDirectRenderingCapable(client);
412	}
413
414	static int
415	SProcAppleDRIAuthConnection(register ClientPtr client)
416	{
417	REQUEST(xAppleDRIAuthConnectionReq);
418	swaps(&stuff->length);
419	REQUEST_SIZE_MATCH(xAppleDRIAuthConnectionReq);
420	swapl(&stuff->screen);
421	swapl(&stuff->magic);
422	return ProcAppleDRIAuthConnection(client);
423	}
424
425	static int
426	SProcAppleDRICreateSurface(register ClientPtr client)
427	{
428	REQUEST(xAppleDRICreateSurfaceReq);
429	swaps(&stuff->length);
430	REQUEST_SIZE_MATCH(xAppleDRICreateSurfaceReq);
431	swapl(&stuff->screen);
432	swapl(&stuff->drawable);
433	swapl(&stuff->client_id);
434	return ProcAppleDRICreateSurface(client);
435	}
436
437	static int
438	SProcAppleDRIDestroySurface(register ClientPtr client)
439	{
440	REQUEST(xAppleDRIDestroySurfaceReq);
441	swaps(&stuff->length);
442	REQUEST_SIZE_MATCH(xAppleDRIDestroySurfaceReq);
443	swapl(&stuff->screen);
444	swapl(&stuff->drawable);
445	return ProcAppleDRIDestroySurface(client);
446	}
447
448	static int
449	SProcAppleDRICreatePixmap(register ClientPtr client)
450	{
451	REQUEST(xAppleDRICreatePixmapReq);
452	swaps(&stuff->length);
453	REQUEST_SIZE_MATCH(xAppleDRICreatePixmapReq);
454	swapl(&stuff->screen);
455	swapl(&stuff->drawable);
456	return ProcAppleDRICreatePixmap(client);
457	}
458
459	static int
460	SProcAppleDRIDestroyPixmap(register ClientPtr client)
461	{
462	REQUEST(xAppleDRIDestroyPixmapReq);
463	swaps(&stuff->length);
464	REQUEST_SIZE_MATCH(xAppleDRIDestroyPixmapReq);
465	swapl(&stuff->drawable);
466	return ProcAppleDRIDestroyPixmap(client);
467	}
468
469	static int
470	SProcAppleDRIDispatch(register ClientPtr client)
471	{
472	REQUEST(xReq);
473
474	switch (stuff->data) {
475	case X_AppleDRIQueryVersion:
476	return SProcAppleDRIQueryVersion(client);
477
478	case X_AppleDRIQueryDirectRenderingCapable:
479	return SProcAppleDRIQueryDirectRenderingCapable(client);
480	}
481
482	if (!client->local)
483	return DRIErrorBase + AppleDRIClientNotLocal;
484
485	switch (stuff->data) {
486	case X_AppleDRIAuthConnection:
487	return SProcAppleDRIAuthConnection(client);
488
489	case X_AppleDRICreateSurface:
490	return SProcAppleDRICreateSurface(client);
491
492	case X_AppleDRIDestroySurface:
493	return SProcAppleDRIDestroySurface(client);
494
495	case X_AppleDRICreatePixmap:
496	return SProcAppleDRICreatePixmap(client);
497
498	case X_AppleDRIDestroyPixmap:
499	return SProcAppleDRIDestroyPixmap(client);
500
501	default:
502	return BadRequest;
503	}
504	}
505
506	void
507	AppleDRIExtensionInit(void)
508	{
509	ExtensionEntry* extEntry;
510
511	if (DRIExtensionInit() &&
512	(extEntry = AddExtension(APPLEDRINAME,
513	AppleDRINumberEvents,
514	AppleDRINumberErrors,
515	ProcAppleDRIDispatch,
516	SProcAppleDRIDispatch,
517	AppleDRIResetProc,
518	StandardMinorOpcode))) {
519	size_t i;
520	DRIReqCode = (unsigned char)extEntry->base;
521	DRIErrorBase = extEntry->errorBase;
522	DRIEventBase = extEntry->eventBase;
523	for (i = 0; i < AppleDRINumberEvents; i++)
524	EventSwapVector[DRIEventBase + i] = (EventSwapPtr)SNotifyEvent;
525	}
526	}