1/*
2 * SGI FREE SOFTWARE LICENSE B (Version 2.0, Sept. 18, 2008)
3 * Copyright (C) 1991-2000 Silicon Graphics, Inc. All Rights Reserved.
4 *
5 * Permission is hereby granted, free of charge, to any person obtaining a
6 * copy of this software and associated documentation files (the "Software"),
7 * to deal in the Software without restriction, including without limitation
8 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
9 * and/or sell copies of the Software, and to permit persons to whom the
10 * Software is furnished to do so, subject to the following conditions:
11 *
12 * The above copyright notice including the dates of first publication and
13 * either this permission notice or a reference to
14 * http://oss.sgi.com/projects/FreeB/
15 * shall be included in all copies or substantial portions of the Software.
16 *
17 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
18 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
19 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
20 * SILICON GRAPHICS, INC. BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
21 * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF
22 * OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
23 * SOFTWARE.
24 *
25 * Except as contained in this notice, the name of Silicon Graphics, Inc.
26 * shall not be used in advertising or otherwise to promote the sale, use or
27 * other dealings in this Software without prior written authorization from
28 * Silicon Graphics, Inc.
29 */
30
31#ifdef HAVE_DIX_CONFIG_H
32#include <dix-config.h>
33#endif
34
35#include <string.h>
36#include "glxserver.h"
37#include "glxutil.h"
38#include <GL/glxtokens.h>
39#include <unpack.h>
40#include <pixmapstr.h>
41#include <windowstr.h>
42#include "glxext.h"
43#include "glapitable.h"
44#include "glapi.h"
45#include "glthread.h"
46#include "dispatch.h"
47#include "indirect_dispatch.h"
48#include "indirect_table.h"
49#include "indirect_util.h"
50
51
52/************************************************************************/
53
54/*
55** Byteswapping versions of GLX commands.  In most cases they just swap
56** the incoming arguments and then call the unswapped routine.  For commands
57** that have replies, a separate swapping routine for the reply is provided;
58** it is called at the end of the unswapped routine.
59*/
60
61int __glXDispSwap_CreateContext(__GLXclientState *cl, GLbyte *pc)
62{
63    ClientPtr client = cl->client;
64    xGLXCreateContextReq *req = (xGLXCreateContextReq *) pc;
65    __GLX_DECLARE_SWAP_VARIABLES;
66
67    REQUEST_SIZE_MATCH(xGLXCreateContextReq);
68
69    __GLX_SWAP_SHORT(&req->length);
70    __GLX_SWAP_INT(&req->context);
71    __GLX_SWAP_INT(&req->visual);
72    __GLX_SWAP_INT(&req->screen);
73    __GLX_SWAP_INT(&req->shareList);
74
75    return __glXDisp_CreateContext(cl, pc);
76}
77
78int __glXDispSwap_CreateNewContext(__GLXclientState *cl, GLbyte *pc)
79{
80    ClientPtr client = cl->client;
81    xGLXCreateNewContextReq *req = (xGLXCreateNewContextReq *) pc;
82    __GLX_DECLARE_SWAP_VARIABLES;
83
84    REQUEST_SIZE_MATCH(xGLXCreateNewContextReq);
85
86    __GLX_SWAP_SHORT(&req->length);
87    __GLX_SWAP_INT(&req->context);
88    __GLX_SWAP_INT(&req->fbconfig);
89    __GLX_SWAP_INT(&req->screen);
90    __GLX_SWAP_INT(&req->renderType);
91    __GLX_SWAP_INT(&req->shareList);
92
93    return __glXDisp_CreateNewContext(cl, pc);
94}
95
96int __glXDispSwap_CreateContextWithConfigSGIX(__GLXclientState *cl, GLbyte *pc)
97{
98    ClientPtr client = cl->client;
99    xGLXCreateContextWithConfigSGIXReq *req =
100	(xGLXCreateContextWithConfigSGIXReq *) pc;
101    __GLX_DECLARE_SWAP_VARIABLES;
102
103    REQUEST_SIZE_MATCH(xGLXCreateContextWithConfigSGIXReq);
104
105    __GLX_SWAP_SHORT(&req->length);
106    __GLX_SWAP_INT(&req->context);
107    __GLX_SWAP_INT(&req->fbconfig);
108    __GLX_SWAP_INT(&req->screen);
109    __GLX_SWAP_INT(&req->renderType);
110    __GLX_SWAP_INT(&req->shareList);
111
112    return __glXDisp_CreateContextWithConfigSGIX(cl, pc);
113}
114
115int __glXDispSwap_DestroyContext(__GLXclientState *cl, GLbyte *pc)
116{
117    ClientPtr client = cl->client;
118    xGLXDestroyContextReq *req = (xGLXDestroyContextReq *) pc;
119    __GLX_DECLARE_SWAP_VARIABLES;
120
121    REQUEST_SIZE_MATCH(xGLXDestroyContextReq);
122
123    __GLX_SWAP_SHORT(&req->length);
124    __GLX_SWAP_INT(&req->context);
125
126    return __glXDisp_DestroyContext(cl, pc);
127}
128
129int __glXDispSwap_MakeCurrent(__GLXclientState *cl, GLbyte *pc)
130{
131    ClientPtr client = cl->client;
132    xGLXMakeCurrentReq *req = (xGLXMakeCurrentReq *) pc;
133    __GLX_DECLARE_SWAP_VARIABLES;
134
135    REQUEST_SIZE_MATCH(xGLXMakeCurrentReq);
136
137    __GLX_SWAP_SHORT(&req->length);
138    __GLX_SWAP_INT(&req->drawable);
139    __GLX_SWAP_INT(&req->context);
140    __GLX_SWAP_INT(&req->oldContextTag);
141
142    return __glXDisp_MakeCurrent(cl, pc);
143}
144
145int __glXDispSwap_MakeContextCurrent(__GLXclientState *cl, GLbyte *pc)
146{
147    ClientPtr client = cl->client;
148    xGLXMakeContextCurrentReq *req = (xGLXMakeContextCurrentReq *) pc;
149    __GLX_DECLARE_SWAP_VARIABLES;
150
151    REQUEST_SIZE_MATCH(xGLXMakeContextCurrentReq);
152
153    __GLX_SWAP_SHORT(&req->length);
154    __GLX_SWAP_INT(&req->drawable);
155    __GLX_SWAP_INT(&req->readdrawable);
156    __GLX_SWAP_INT(&req->context);
157    __GLX_SWAP_INT(&req->oldContextTag);
158
159    return __glXDisp_MakeContextCurrent(cl, pc);
160}
161
162int __glXDispSwap_MakeCurrentReadSGI(__GLXclientState *cl, GLbyte *pc)
163{
164    ClientPtr client = cl->client;
165    xGLXMakeCurrentReadSGIReq *req = (xGLXMakeCurrentReadSGIReq *) pc;
166    __GLX_DECLARE_SWAP_VARIABLES;
167
168    REQUEST_SIZE_MATCH(xGLXMakeCurrentReadSGIReq);
169
170    __GLX_SWAP_SHORT(&req->length);
171    __GLX_SWAP_INT(&req->drawable);
172    __GLX_SWAP_INT(&req->readable);
173    __GLX_SWAP_INT(&req->context);
174    __GLX_SWAP_INT(&req->oldContextTag);
175
176    return __glXDisp_MakeCurrentReadSGI(cl, pc);
177}
178
179int __glXDispSwap_IsDirect(__GLXclientState *cl, GLbyte *pc)
180{
181    ClientPtr client = cl->client;
182    xGLXIsDirectReq *req = (xGLXIsDirectReq *) pc;
183    __GLX_DECLARE_SWAP_VARIABLES;
184
185    REQUEST_SIZE_MATCH(xGLXIsDirectReq);
186
187    __GLX_SWAP_SHORT(&req->length);
188    __GLX_SWAP_INT(&req->context);
189
190    return __glXDisp_IsDirect(cl, pc);
191}
192
193int __glXDispSwap_QueryVersion(__GLXclientState *cl, GLbyte *pc)
194{
195    ClientPtr client = cl->client;
196    xGLXQueryVersionReq *req = (xGLXQueryVersionReq *) pc;
197    __GLX_DECLARE_SWAP_VARIABLES;
198
199    REQUEST_SIZE_MATCH(xGLXQueryVersionReq);
200
201    __GLX_SWAP_SHORT(&req->length);
202    __GLX_SWAP_INT(&req->majorVersion);
203    __GLX_SWAP_INT(&req->minorVersion);
204
205    return __glXDisp_QueryVersion(cl, pc);
206}
207
208int __glXDispSwap_WaitGL(__GLXclientState *cl, GLbyte *pc)
209{
210    ClientPtr client = cl->client;
211    xGLXWaitGLReq *req = (xGLXWaitGLReq *) pc;
212    __GLX_DECLARE_SWAP_VARIABLES;
213
214    REQUEST_SIZE_MATCH(xGLXWaitGLReq);
215
216    __GLX_SWAP_SHORT(&req->length);
217    __GLX_SWAP_INT(&req->contextTag);
218
219    return __glXDisp_WaitGL(cl, pc);
220}
221
222int __glXDispSwap_WaitX(__GLXclientState *cl, GLbyte *pc)
223{
224    ClientPtr client = cl->client;
225    xGLXWaitXReq *req = (xGLXWaitXReq *) pc;
226    __GLX_DECLARE_SWAP_VARIABLES;
227
228    REQUEST_SIZE_MATCH(xGLXWaitXReq);
229
230    __GLX_SWAP_SHORT(&req->length);
231    __GLX_SWAP_INT(&req->contextTag);
232
233    return __glXDisp_WaitX(cl, pc);
234}
235
236int __glXDispSwap_CopyContext(__GLXclientState *cl, GLbyte *pc)
237{
238    ClientPtr client = cl->client;
239    xGLXCopyContextReq *req = (xGLXCopyContextReq *) pc;
240    __GLX_DECLARE_SWAP_VARIABLES;
241
242    REQUEST_SIZE_MATCH(xGLXCopyContextReq);
243
244    __GLX_SWAP_SHORT(&req->length);
245    __GLX_SWAP_INT(&req->source);
246    __GLX_SWAP_INT(&req->dest);
247    __GLX_SWAP_INT(&req->mask);
248
249    return __glXDisp_CopyContext(cl, pc);
250}
251
252int __glXDispSwap_GetVisualConfigs(__GLXclientState *cl, GLbyte *pc)
253{
254    ClientPtr client = cl->client;
255    xGLXGetVisualConfigsReq *req = (xGLXGetVisualConfigsReq *) pc;
256    __GLX_DECLARE_SWAP_VARIABLES;
257
258    REQUEST_SIZE_MATCH(xGLXGetVisualConfigsReq);
259
260    __GLX_SWAP_INT(&req->screen);
261    return __glXDisp_GetVisualConfigs(cl, pc);
262}
263
264int __glXDispSwap_GetFBConfigs(__GLXclientState *cl, GLbyte *pc)
265{
266    ClientPtr client = cl->client;
267    xGLXGetFBConfigsReq *req = (xGLXGetFBConfigsReq *) pc;
268    __GLX_DECLARE_SWAP_VARIABLES;
269
270    REQUEST_SIZE_MATCH(xGLXGetFBConfigsReq);
271
272    __GLX_SWAP_INT(&req->screen);
273    return __glXDisp_GetFBConfigs(cl, pc);
274}
275
276int __glXDispSwap_GetFBConfigsSGIX(__GLXclientState *cl, GLbyte *pc)
277{
278    ClientPtr client = cl->client;
279    xGLXGetFBConfigsSGIXReq *req = (xGLXGetFBConfigsSGIXReq *) pc;
280    __GLX_DECLARE_SWAP_VARIABLES;
281
282    REQUEST_AT_LEAST_SIZE(xGLXGetFBConfigsSGIXReq);
283
284    __GLX_SWAP_INT(&req->screen);
285    return __glXDisp_GetFBConfigsSGIX(cl, pc);
286}
287
288int __glXDispSwap_CreateGLXPixmap(__GLXclientState *cl, GLbyte *pc)
289{
290    ClientPtr client = cl->client;
291    xGLXCreateGLXPixmapReq *req = (xGLXCreateGLXPixmapReq *) pc;
292    __GLX_DECLARE_SWAP_VARIABLES;
293
294    REQUEST_SIZE_MATCH(xGLXCreateGLXPixmapReq);
295
296    __GLX_SWAP_SHORT(&req->length);
297    __GLX_SWAP_INT(&req->screen);
298    __GLX_SWAP_INT(&req->visual);
299    __GLX_SWAP_INT(&req->pixmap);
300    __GLX_SWAP_INT(&req->glxpixmap);
301
302    return __glXDisp_CreateGLXPixmap(cl, pc);
303}
304
305int __glXDispSwap_CreatePixmap(__GLXclientState *cl, GLbyte *pc)
306{
307    ClientPtr client = cl->client;
308    xGLXCreatePixmapReq *req = (xGLXCreatePixmapReq *) pc;
309    CARD32 *attribs;
310    __GLX_DECLARE_SWAP_VARIABLES;
311    __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
312
313    REQUEST_AT_LEAST_SIZE(xGLXCreatePixmapReq);
314
315    __GLX_SWAP_SHORT(&req->length);
316    __GLX_SWAP_INT(&req->screen);
317    __GLX_SWAP_INT(&req->fbconfig);
318    __GLX_SWAP_INT(&req->pixmap);
319    __GLX_SWAP_INT(&req->glxpixmap);
320    __GLX_SWAP_INT(&req->numAttribs);
321
322    if (req->numAttribs > (UINT32_MAX >> 3)) {
323	client->errorValue = req->numAttribs;
324	return BadValue;
325    }
326    REQUEST_FIXED_SIZE(xGLXCreatePixmapReq, req->numAttribs << 3);
327    attribs = (CARD32*)(req + 1);
328    __GLX_SWAP_INT_ARRAY(attribs, req->numAttribs << 1);
329
330    return __glXDisp_CreatePixmap(cl, pc);
331}
332
333int __glXDispSwap_CreateGLXPixmapWithConfigSGIX(__GLXclientState *cl, GLbyte *pc)
334{
335    ClientPtr client = cl->client;
336    xGLXCreateGLXPixmapWithConfigSGIXReq *req =
337	(xGLXCreateGLXPixmapWithConfigSGIXReq *) pc;
338    __GLX_DECLARE_SWAP_VARIABLES;
339
340    REQUEST_SIZE_MATCH(xGLXCreateGLXPixmapWithConfigSGIXReq);
341
342    __GLX_SWAP_SHORT(&req->length);
343    __GLX_SWAP_INT(&req->screen);
344    __GLX_SWAP_INT(&req->fbconfig);
345    __GLX_SWAP_INT(&req->pixmap);
346    __GLX_SWAP_INT(&req->glxpixmap);
347
348    return __glXDisp_CreateGLXPixmapWithConfigSGIX(cl, pc);
349}
350
351int __glXDispSwap_DestroyGLXPixmap(__GLXclientState *cl, GLbyte *pc)
352{
353    ClientPtr client = cl->client;
354    xGLXDestroyGLXPixmapReq *req = (xGLXDestroyGLXPixmapReq *) pc;
355    __GLX_DECLARE_SWAP_VARIABLES;
356
357    REQUEST_SIZE_MATCH(xGLXDestroyGLXPixmapReq);
358
359    __GLX_SWAP_SHORT(&req->length);
360    __GLX_SWAP_INT(&req->glxpixmap);
361
362    return __glXDisp_DestroyGLXPixmap(cl, pc);
363}
364
365int __glXDispSwap_DestroyPixmap(__GLXclientState *cl, GLbyte *pc)
366{
367    ClientPtr client = cl->client;
368    xGLXDestroyGLXPixmapReq *req = (xGLXDestroyGLXPixmapReq *) pc;
369    __GLX_DECLARE_SWAP_VARIABLES;
370
371    REQUEST_AT_LEAST_SIZE(xGLXDestroyGLXPixmapReq);
372
373    __GLX_SWAP_SHORT(&req->length);
374    __GLX_SWAP_INT(&req->glxpixmap);
375
376    return __glXDisp_DestroyGLXPixmap(cl, pc);
377}
378
379int __glXDispSwap_QueryContext(__GLXclientState *cl, GLbyte *pc)
380{
381    ClientPtr client = cl->client;
382    xGLXQueryContextReq *req = (xGLXQueryContextReq *) pc;
383    __GLX_DECLARE_SWAP_VARIABLES;
384
385    REQUEST_SIZE_MATCH(xGLXQueryContextReq);
386
387    __GLX_SWAP_INT(&req->context);
388
389    return __glXDisp_QueryContext(cl, pc);
390}
391
392int __glXDispSwap_CreatePbuffer(__GLXclientState *cl, GLbyte *pc)
393{
394    ClientPtr client = cl->client;
395    xGLXCreatePbufferReq *req = (xGLXCreatePbufferReq *) pc;
396    __GLX_DECLARE_SWAP_VARIABLES;
397    __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
398    CARD32 *attribs;
399
400    REQUEST_AT_LEAST_SIZE(xGLXCreatePbufferReq);
401
402    __GLX_SWAP_INT(&req->screen);
403    __GLX_SWAP_INT(&req->fbconfig);
404    __GLX_SWAP_INT(&req->pbuffer);
405    __GLX_SWAP_INT(&req->numAttribs);
406
407    if (req->numAttribs > (UINT32_MAX >> 3)) {
408	client->errorValue = req->numAttribs;
409	return BadValue;
410    }
411    REQUEST_FIXED_SIZE(xGLXCreatePbufferReq, req->numAttribs << 3);
412    attribs = (CARD32*)(req + 1);
413    __GLX_SWAP_INT_ARRAY(attribs, req->numAttribs << 1);
414
415    return __glXDisp_CreatePbuffer(cl, pc);
416}
417
418int __glXDispSwap_CreateGLXPbufferSGIX(__GLXclientState *cl, GLbyte *pc)
419{
420    ClientPtr client = cl->client;
421    xGLXCreateGLXPbufferSGIXReq *req = (xGLXCreateGLXPbufferSGIXReq *) pc;
422    __GLX_DECLARE_SWAP_VARIABLES;
423
424    REQUEST_AT_LEAST_SIZE(xGLXCreateGLXPbufferSGIXReq);
425
426    __GLX_SWAP_INT(&req->screen);
427    __GLX_SWAP_INT(&req->fbconfig);
428    __GLX_SWAP_INT(&req->pbuffer);
429    __GLX_SWAP_INT(&req->width);
430    __GLX_SWAP_INT(&req->height);
431
432    return __glXDisp_CreateGLXPbufferSGIX(cl, pc);
433}
434
435int __glXDispSwap_DestroyPbuffer(__GLXclientState *cl, GLbyte *pc)
436{
437    ClientPtr client = cl->client;
438    xGLXDestroyPbufferReq *req = (xGLXDestroyPbufferReq *) pc;
439    __GLX_DECLARE_SWAP_VARIABLES;
440
441    REQUEST_SIZE_MATCH(xGLXDestroyPbufferReq);
442
443    __GLX_SWAP_INT(&req->pbuffer);
444
445    return __glXDisp_DestroyPbuffer(cl, pc);
446}
447
448int __glXDispSwap_DestroyGLXPbufferSGIX(__GLXclientState *cl, GLbyte *pc)
449{
450    ClientPtr client = cl->client;
451    xGLXDestroyGLXPbufferSGIXReq *req = (xGLXDestroyGLXPbufferSGIXReq *) pc;
452    __GLX_DECLARE_SWAP_VARIABLES;
453
454    REQUEST_SIZE_MATCH(xGLXDestroyGLXPbufferSGIXReq);
455
456    __GLX_SWAP_INT(&req->pbuffer);
457
458    return __glXDisp_DestroyGLXPbufferSGIX(cl, pc);
459}
460
461int __glXDispSwap_ChangeDrawableAttributes(__GLXclientState *cl, GLbyte *pc)
462{
463    ClientPtr client = cl->client;
464    xGLXChangeDrawableAttributesReq *req =
465	(xGLXChangeDrawableAttributesReq *) pc;
466    __GLX_DECLARE_SWAP_VARIABLES;
467    __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
468    CARD32 *attribs;
469
470    REQUEST_AT_LEAST_SIZE(xGLXChangeDrawableAttributesReq);
471
472    __GLX_SWAP_INT(&req->drawable);
473    __GLX_SWAP_INT(&req->numAttribs);
474
475    if (req->numAttribs > (UINT32_MAX >> 3)) {
476	client->errorValue = req->numAttribs;
477	return BadValue;
478    }
479    if (((sizeof(xGLXChangeDrawableAttributesReq) + (req->numAttribs << 3)) >> 2) < client->req_len)
480	return BadLength;
481
482    attribs = (CARD32*)(req + 1);
483    __GLX_SWAP_INT_ARRAY(attribs, req->numAttribs << 1);
484
485    return __glXDisp_ChangeDrawableAttributes(cl, pc);
486}
487
488int __glXDispSwap_ChangeDrawableAttributesSGIX(__GLXclientState *cl,
489					       GLbyte *pc)
490{
491    ClientPtr client = cl->client;
492    xGLXChangeDrawableAttributesSGIXReq *req =
493	(xGLXChangeDrawableAttributesSGIXReq *) pc;
494    __GLX_DECLARE_SWAP_VARIABLES;
495    __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
496    CARD32 *attribs;
497
498    REQUEST_AT_LEAST_SIZE(xGLXChangeDrawableAttributesSGIXReq);
499
500    __GLX_SWAP_INT(&req->drawable);
501    __GLX_SWAP_INT(&req->numAttribs);
502
503    if (req->numAttribs > (UINT32_MAX >> 3)) {
504	client->errorValue = req->numAttribs;
505	return BadValue;
506    }
507    REQUEST_FIXED_SIZE(xGLXChangeDrawableAttributesSGIXReq, req->numAttribs << 3);
508    attribs = (CARD32*)(req + 1);
509    __GLX_SWAP_INT_ARRAY(attribs, req->numAttribs << 1);
510
511    return __glXDisp_ChangeDrawableAttributesSGIX(cl, pc);
512}
513
514int __glXDispSwap_CreateWindow(__GLXclientState *cl, GLbyte *pc)
515{
516    ClientPtr client = cl->client;
517    xGLXCreateWindowReq *req = (xGLXCreateWindowReq *) pc;
518    __GLX_DECLARE_SWAP_VARIABLES;
519    __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
520    CARD32 *attribs;
521
522    REQUEST_AT_LEAST_SIZE(xGLXCreateWindowReq);
523
524    __GLX_SWAP_INT(&req->screen);
525    __GLX_SWAP_INT(&req->fbconfig);
526    __GLX_SWAP_INT(&req->window);
527    __GLX_SWAP_INT(&req->glxwindow);
528    __GLX_SWAP_INT(&req->numAttribs);
529
530    if (req->numAttribs > (UINT32_MAX >> 3)) {
531	client->errorValue = req->numAttribs;
532	return BadValue;
533    }
534    REQUEST_FIXED_SIZE(xGLXCreateWindowReq, req->numAttribs << 3);
535    attribs = (CARD32*)(req + 1);
536    __GLX_SWAP_INT_ARRAY(attribs, req->numAttribs << 1);
537
538    return __glXDisp_CreateWindow(cl, pc);
539}
540
541int __glXDispSwap_DestroyWindow(__GLXclientState *cl, GLbyte *pc)
542{
543    ClientPtr client = cl->client;
544    xGLXDestroyWindowReq *req = (xGLXDestroyWindowReq *) pc;
545    __GLX_DECLARE_SWAP_VARIABLES;
546
547    REQUEST_AT_LEAST_SIZE(xGLXDestroyWindowReq);
548
549    __GLX_SWAP_INT(&req->glxwindow);
550
551    return __glXDisp_DestroyWindow(cl, pc);
552}
553
554int __glXDispSwap_SwapBuffers(__GLXclientState *cl, GLbyte *pc)
555{
556    ClientPtr client = cl->client;
557    xGLXSwapBuffersReq *req = (xGLXSwapBuffersReq *) pc;
558    __GLX_DECLARE_SWAP_VARIABLES;
559
560    REQUEST_SIZE_MATCH(xGLXSwapBuffersReq);
561
562    __GLX_SWAP_SHORT(&req->length);
563    __GLX_SWAP_INT(&req->contextTag);
564    __GLX_SWAP_INT(&req->drawable);
565
566    return __glXDisp_SwapBuffers(cl, pc);
567}
568
569int __glXDispSwap_UseXFont(__GLXclientState *cl, GLbyte *pc)
570{
571    ClientPtr client = cl->client;
572    xGLXUseXFontReq *req = (xGLXUseXFontReq *) pc;
573    __GLX_DECLARE_SWAP_VARIABLES;
574
575    REQUEST_SIZE_MATCH(xGLXUseXFontReq);
576
577    __GLX_SWAP_SHORT(&req->length);
578    __GLX_SWAP_INT(&req->contextTag);
579    __GLX_SWAP_INT(&req->font);
580    __GLX_SWAP_INT(&req->first);
581    __GLX_SWAP_INT(&req->count);
582    __GLX_SWAP_INT(&req->listBase);
583
584    return __glXDisp_UseXFont(cl, pc);
585}
586
587
588int __glXDispSwap_QueryExtensionsString(__GLXclientState *cl, GLbyte *pc)
589{
590    ClientPtr client = cl->client;
591    xGLXQueryExtensionsStringReq *req = (xGLXQueryExtensionsStringReq *)pc;
592    __GLX_DECLARE_SWAP_VARIABLES;
593
594    REQUEST_SIZE_MATCH(xGLXQueryExtensionsStringReq);
595
596    __GLX_SWAP_SHORT(&req->length);
597    __GLX_SWAP_INT(&req->screen);
598
599    return __glXDisp_QueryExtensionsString(cl, pc);
600}
601
602int __glXDispSwap_QueryServerString(__GLXclientState *cl, GLbyte *pc)
603{
604    ClientPtr client = cl->client;
605    xGLXQueryServerStringReq *req = (xGLXQueryServerStringReq *)pc;
606    __GLX_DECLARE_SWAP_VARIABLES;
607
608    REQUEST_SIZE_MATCH(xGLXQueryServerStringReq);
609
610    __GLX_SWAP_SHORT(&req->length);
611    __GLX_SWAP_INT(&req->screen);
612    __GLX_SWAP_INT(&req->name);
613
614    return __glXDisp_QueryServerString(cl, pc);
615}
616
617int __glXDispSwap_ClientInfo(__GLXclientState *cl, GLbyte *pc)
618{
619    ClientPtr client = cl->client;
620    xGLXClientInfoReq *req = (xGLXClientInfoReq *)pc;
621    __GLX_DECLARE_SWAP_VARIABLES;
622
623    REQUEST_AT_LEAST_SIZE(xGLXClientInfoReq);
624
625    __GLX_SWAP_SHORT(&req->length);
626    __GLX_SWAP_INT(&req->major);
627    __GLX_SWAP_INT(&req->minor);
628    __GLX_SWAP_INT(&req->numbytes);
629
630    return __glXDisp_ClientInfo(cl, pc);
631}
632
633int __glXDispSwap_QueryContextInfoEXT(__GLXclientState *cl, GLbyte *pc)
634{
635    ClientPtr client = cl->client;
636    xGLXQueryContextInfoEXTReq *req = (xGLXQueryContextInfoEXTReq *) pc;
637    __GLX_DECLARE_SWAP_VARIABLES;
638
639    REQUEST_SIZE_MATCH(xGLXQueryContextInfoEXTReq);
640
641    __GLX_SWAP_SHORT(&req->length);
642    __GLX_SWAP_INT(&req->context);
643
644    return __glXDisp_QueryContextInfoEXT(cl, pc);
645}
646
647int __glXDispSwap_BindTexImageEXT(__GLXclientState *cl, GLbyte *pc)
648{
649    ClientPtr client = cl->client;
650    xGLXVendorPrivateReq *req = (xGLXVendorPrivateReq *) pc;
651    GLXDrawable		 *drawId;
652    int			 *buffer;
653    CARD32		 *num_attribs;
654    __GLX_DECLARE_SWAP_VARIABLES;
655
656    if ((sizeof(xGLXVendorPrivateReq) + 12) >> 2 > client->req_len)
657	return BadLength;
658
659    pc += __GLX_VENDPRIV_HDR_SIZE;
660
661    drawId = ((GLXDrawable *) (pc));
662    buffer = ((int *)	      (pc + 4));
663    num_attribs = ((CARD32 *) (pc + 8));
664
665    __GLX_SWAP_SHORT(&req->length);
666    __GLX_SWAP_INT(&req->contextTag);
667    __GLX_SWAP_INT(drawId);
668    __GLX_SWAP_INT(buffer);
669    __GLX_SWAP_INT(num_attribs);
670
671    return __glXDisp_BindTexImageEXT(cl, (GLbyte *)pc);
672}
673
674int __glXDispSwap_ReleaseTexImageEXT(__GLXclientState *cl, GLbyte *pc)
675{
676    ClientPtr client = cl->client;
677    xGLXVendorPrivateReq *req = (xGLXVendorPrivateReq *) pc;
678    GLXDrawable		 *drawId;
679    int			 *buffer;
680    __GLX_DECLARE_SWAP_VARIABLES;
681
682    REQUEST_FIXED_SIZE(xGLXVendorPrivateReq, 8);
683
684    pc += __GLX_VENDPRIV_HDR_SIZE;
685
686    drawId = ((GLXDrawable *) (pc));
687    buffer = ((int *)	      (pc + 4));
688
689    __GLX_SWAP_SHORT(&req->length);
690    __GLX_SWAP_INT(&req->contextTag);
691    __GLX_SWAP_INT(drawId);
692    __GLX_SWAP_INT(buffer);
693
694    return __glXDisp_ReleaseTexImageEXT(cl, (GLbyte *)pc);
695}
696
697int __glXDispSwap_CopySubBufferMESA(__GLXclientState *cl, GLbyte *pc)
698{
699    ClientPtr client = cl->client;
700    xGLXVendorPrivateReq *req = (xGLXVendorPrivateReq *) pc;
701    GLXDrawable		 *drawId;
702    int			 *buffer;
703    __GLX_DECLARE_SWAP_VARIABLES;
704
705    REQUEST_FIXED_SIZE(xGLXVendorPrivateReq, 20);
706
707    (void) drawId;
708    (void) buffer;
709
710    pc += __GLX_VENDPRIV_HDR_SIZE;
711
712    __GLX_SWAP_SHORT(&req->length);
713    __GLX_SWAP_INT(&req->contextTag);
714    __GLX_SWAP_INT(pc);
715    __GLX_SWAP_INT(pc + 4);
716    __GLX_SWAP_INT(pc + 8);
717    __GLX_SWAP_INT(pc + 12);
718    __GLX_SWAP_INT(pc + 16);
719
720    return __glXDisp_CopySubBufferMESA(cl, pc);
721
722}
723
724int __glXDispSwap_GetDrawableAttributesSGIX(__GLXclientState *cl, GLbyte *pc)
725{
726    ClientPtr client = cl->client;
727    xGLXVendorPrivateWithReplyReq *req = (xGLXVendorPrivateWithReplyReq *)pc;
728    CARD32 *data;
729    __GLX_DECLARE_SWAP_VARIABLES;
730
731    REQUEST_SIZE_MATCH(xGLXGetDrawableAttributesSGIXReq);
732
733    data = (CARD32 *) (req + 1);
734    __GLX_SWAP_SHORT(&req->length);
735    __GLX_SWAP_INT(&req->contextTag);
736    __GLX_SWAP_INT(data);
737
738    return __glXDisp_GetDrawableAttributesSGIX(cl, pc);
739}
740
741int __glXDispSwap_GetDrawableAttributes(__GLXclientState *cl, GLbyte *pc)
742{
743    ClientPtr client = cl->client;
744    xGLXGetDrawableAttributesReq *req = (xGLXGetDrawableAttributesReq *)pc;
745    __GLX_DECLARE_SWAP_VARIABLES;
746
747    REQUEST_AT_LEAST_SIZE(xGLXGetDrawableAttributesReq);
748
749    __GLX_SWAP_SHORT(&req->length);
750    __GLX_SWAP_INT(&req->drawable);
751
752    return __glXDisp_GetDrawableAttributes(cl, pc);
753}
754
755
756/************************************************************************/
757
758/*
759** Swap replies.
760*/
761
762void __glXSwapMakeCurrentReply(ClientPtr client, xGLXMakeCurrentReply *reply)
763{
764    __GLX_DECLARE_SWAP_VARIABLES;
765    __GLX_SWAP_SHORT(&reply->sequenceNumber);
766    __GLX_SWAP_INT(&reply->length);
767    __GLX_SWAP_INT(&reply->contextTag);
768    WriteToClient(client, sz_xGLXMakeCurrentReply, (char *)reply);
769}
770
771void __glXSwapIsDirectReply(ClientPtr client, xGLXIsDirectReply *reply)
772{
773    __GLX_DECLARE_SWAP_VARIABLES;
774    __GLX_SWAP_SHORT(&reply->sequenceNumber);
775    __GLX_SWAP_INT(&reply->length);
776    WriteToClient(client, sz_xGLXIsDirectReply, (char *)reply);
777}
778
779void __glXSwapQueryVersionReply(ClientPtr client, xGLXQueryVersionReply *reply)
780{
781    __GLX_DECLARE_SWAP_VARIABLES;
782    __GLX_SWAP_SHORT(&reply->sequenceNumber);
783    __GLX_SWAP_INT(&reply->length);
784    __GLX_SWAP_INT(&reply->majorVersion);
785    __GLX_SWAP_INT(&reply->minorVersion);
786    WriteToClient(client, sz_xGLXQueryVersionReply, (char *)reply);
787}
788
789void glxSwapQueryExtensionsStringReply(ClientPtr client,
790				       xGLXQueryExtensionsStringReply *reply, char *buf)
791{
792    int length = reply->length;
793    __GLX_DECLARE_SWAP_VARIABLES;
794    __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
795    __GLX_SWAP_SHORT(&reply->sequenceNumber);
796    __GLX_SWAP_INT(&reply->length);
797    __GLX_SWAP_INT(&reply->n);
798    WriteToClient(client, sz_xGLXQueryExtensionsStringReply, (char *)reply);
799    __GLX_SWAP_INT_ARRAY((int *)buf, length);
800    WriteToClient(client, length << 2, buf);
801}
802
803void glxSwapQueryServerStringReply(ClientPtr client,
804				   xGLXQueryServerStringReply *reply, char *buf)
805{
806    int length = reply->length;
807    __GLX_DECLARE_SWAP_VARIABLES;
808    __GLX_SWAP_SHORT(&reply->sequenceNumber);
809    __GLX_SWAP_INT(&reply->length);
810    __GLX_SWAP_INT(&reply->n);
811    WriteToClient(client, sz_xGLXQueryServerStringReply, (char *)reply);
812    /** no swap is needed for an array of chars **/
813    /* __GLX_SWAP_INT_ARRAY((int *)buf, length); */
814    WriteToClient(client, length << 2, buf);
815}
816
817void __glXSwapQueryContextInfoEXTReply(ClientPtr client, xGLXQueryContextInfoEXTReply *reply, int *buf)
818{
819    int length = reply->length;
820    __GLX_DECLARE_SWAP_VARIABLES;
821    __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
822    __GLX_SWAP_SHORT(&reply->sequenceNumber);
823    __GLX_SWAP_INT(&reply->length);
824    __GLX_SWAP_INT(&reply->n);
825    WriteToClient(client, sz_xGLXQueryContextInfoEXTReply, (char *)reply);
826    __GLX_SWAP_INT_ARRAY((int *)buf, length);
827    WriteToClient(client, length << 2, (char *)buf);
828}
829
830void __glXSwapGetDrawableAttributesReply(ClientPtr client,
831					 xGLXGetDrawableAttributesReply *reply, CARD32 *buf)
832{
833    int length = reply->length;
834    __GLX_DECLARE_SWAP_VARIABLES;
835    __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
836    __GLX_SWAP_SHORT(&reply->sequenceNumber);
837    __GLX_SWAP_INT(&reply->length);
838    __GLX_SWAP_INT(&reply->numAttribs);
839    WriteToClient(client, sz_xGLXGetDrawableAttributesReply, (char *)reply);
840    __GLX_SWAP_INT_ARRAY((int *)buf, length);
841    WriteToClient(client, length << 2, (char *)buf);
842}
843
844/************************************************************************/
845
846/*
847** Render and Renderlarge are not in the GLX API.  They are used by the GLX
848** client library to send batches of GL rendering commands.
849*/
850
851int __glXDispSwap_Render(__GLXclientState *cl, GLbyte *pc)
852{
853    return __glXDisp_Render(cl, pc);
854}
855
856/*
857** Execute a large rendering request (one that spans multiple X requests).
858*/
859int __glXDispSwap_RenderLarge(__GLXclientState *cl, GLbyte *pc)
860{
861    return __glXDisp_RenderLarge(cl, pc);
862}
863
864/************************************************************************/
865
866/*
867** No support is provided for the vendor-private requests other than
868** allocating these entry points in the dispatch table.
869*/
870
871int __glXDispSwap_VendorPrivate(__GLXclientState *cl, GLbyte *pc)
872{
873    ClientPtr client = cl->client;
874    xGLXVendorPrivateReq *req;
875    GLint vendorcode;
876    __GLXdispatchVendorPrivProcPtr proc;
877
878    __GLX_DECLARE_SWAP_VARIABLES;
879    REQUEST_AT_LEAST_SIZE(xGLXVendorPrivateReq);
880
881    req = (xGLXVendorPrivateReq *) pc;
882    __GLX_SWAP_SHORT(&req->length);
883    __GLX_SWAP_INT(&req->vendorCode);
884
885    vendorcode = req->vendorCode;
886
887    proc = (__GLXdispatchVendorPrivProcPtr)
888      __glXGetProtocolDecodeFunction(& VendorPriv_dispatch_info,
889				     vendorcode, 1);
890    if (proc != NULL) {
891	(*proc)(cl, (GLbyte*)req);
892	return Success;
893    }
894
895    cl->client->errorValue = req->vendorCode;
896    return __glXError(GLXUnsupportedPrivateRequest);
897}
898
899
900int __glXDispSwap_VendorPrivateWithReply(__GLXclientState *cl, GLbyte *pc)
901{
902    ClientPtr client = cl->client;
903    xGLXVendorPrivateWithReplyReq *req;
904    GLint vendorcode;
905    __GLXdispatchVendorPrivProcPtr proc;
906
907    __GLX_DECLARE_SWAP_VARIABLES;
908    REQUEST_AT_LEAST_SIZE(xGLXVendorPrivateWithReplyReq);
909
910    req = (xGLXVendorPrivateWithReplyReq *) pc;
911    __GLX_SWAP_SHORT(&req->length);
912    __GLX_SWAP_INT(&req->vendorCode);
913
914    vendorcode = req->vendorCode;
915
916    proc = (__GLXdispatchVendorPrivProcPtr)
917      __glXGetProtocolDecodeFunction(& VendorPriv_dispatch_info,
918				     vendorcode, 1);
919    if (proc != NULL) {
920	return (*proc)(cl, (GLbyte*)req);
921    }
922
923    cl->client->errorValue = req->vendorCode;
924    return __glXError(GLXUnsupportedPrivateRequest);
925}
926