Commit | Line | Data |
---|---|---|
a09e091a JB |
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 "indirect_dispatch.h" | |
44 | #include "indirect_table.h" | |
45 | #include "indirect_util.h" | |
46 | ||
47 | /************************************************************************/ | |
48 | ||
49 | /* | |
50 | ** Byteswapping versions of GLX commands. In most cases they just swap | |
51 | ** the incoming arguments and then call the unswapped routine. For commands | |
52 | ** that have replies, a separate swapping routine for the reply is provided; | |
53 | ** it is called at the end of the unswapped routine. | |
54 | */ | |
55 | ||
56 | int | |
57 | __glXDispSwap_CreateContext(__GLXclientState * cl, GLbyte * pc) | |
58 | { | |
59 | ClientPtr client = cl->client; | |
60 | xGLXCreateContextReq *req = (xGLXCreateContextReq *) pc; | |
61 | ||
62 | __GLX_DECLARE_SWAP_VARIABLES; | |
63 | ||
64 | REQUEST_SIZE_MATCH(xGLXCreateContextReq); | |
65 | ||
66 | __GLX_SWAP_SHORT(&req->length); | |
67 | __GLX_SWAP_INT(&req->context); | |
68 | __GLX_SWAP_INT(&req->visual); | |
69 | __GLX_SWAP_INT(&req->screen); | |
70 | __GLX_SWAP_INT(&req->shareList); | |
71 | ||
72 | return __glXDisp_CreateContext(cl, pc); | |
73 | } | |
74 | ||
75 | int | |
76 | __glXDispSwap_CreateNewContext(__GLXclientState * cl, GLbyte * pc) | |
77 | { | |
78 | ClientPtr client = cl->client; | |
79 | xGLXCreateNewContextReq *req = (xGLXCreateNewContextReq *) pc; | |
80 | ||
81 | __GLX_DECLARE_SWAP_VARIABLES; | |
82 | ||
83 | REQUEST_SIZE_MATCH(xGLXCreateNewContextReq); | |
84 | ||
85 | __GLX_SWAP_SHORT(&req->length); | |
86 | __GLX_SWAP_INT(&req->context); | |
87 | __GLX_SWAP_INT(&req->fbconfig); | |
88 | __GLX_SWAP_INT(&req->screen); | |
89 | __GLX_SWAP_INT(&req->renderType); | |
90 | __GLX_SWAP_INT(&req->shareList); | |
91 | ||
92 | return __glXDisp_CreateNewContext(cl, pc); | |
93 | } | |
94 | ||
95 | int | |
96 | __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 | ||
115 | int | |
116 | __glXDispSwap_DestroyContext(__GLXclientState * cl, GLbyte * pc) | |
117 | { | |
118 | ClientPtr client = cl->client; | |
119 | xGLXDestroyContextReq *req = (xGLXDestroyContextReq *) pc; | |
120 | ||
121 | __GLX_DECLARE_SWAP_VARIABLES; | |
122 | ||
123 | REQUEST_SIZE_MATCH(xGLXDestroyContextReq); | |
124 | ||
125 | __GLX_SWAP_SHORT(&req->length); | |
126 | __GLX_SWAP_INT(&req->context); | |
127 | ||
128 | return __glXDisp_DestroyContext(cl, pc); | |
129 | } | |
130 | ||
131 | int | |
132 | __glXDispSwap_MakeCurrent(__GLXclientState * cl, GLbyte * pc) | |
133 | { | |
134 | ClientPtr client = cl->client; | |
135 | xGLXMakeCurrentReq *req = (xGLXMakeCurrentReq *) pc; | |
136 | ||
137 | __GLX_DECLARE_SWAP_VARIABLES; | |
138 | ||
139 | REQUEST_SIZE_MATCH(xGLXMakeCurrentReq); | |
140 | ||
141 | __GLX_SWAP_SHORT(&req->length); | |
142 | __GLX_SWAP_INT(&req->drawable); | |
143 | __GLX_SWAP_INT(&req->context); | |
144 | __GLX_SWAP_INT(&req->oldContextTag); | |
145 | ||
146 | return __glXDisp_MakeCurrent(cl, pc); | |
147 | } | |
148 | ||
149 | int | |
150 | __glXDispSwap_MakeContextCurrent(__GLXclientState * cl, GLbyte * pc) | |
151 | { | |
152 | ClientPtr client = cl->client; | |
153 | xGLXMakeContextCurrentReq *req = (xGLXMakeContextCurrentReq *) pc; | |
154 | ||
155 | __GLX_DECLARE_SWAP_VARIABLES; | |
156 | ||
157 | REQUEST_SIZE_MATCH(xGLXMakeContextCurrentReq); | |
158 | ||
159 | __GLX_SWAP_SHORT(&req->length); | |
160 | __GLX_SWAP_INT(&req->drawable); | |
161 | __GLX_SWAP_INT(&req->readdrawable); | |
162 | __GLX_SWAP_INT(&req->context); | |
163 | __GLX_SWAP_INT(&req->oldContextTag); | |
164 | ||
165 | return __glXDisp_MakeContextCurrent(cl, pc); | |
166 | } | |
167 | ||
168 | int | |
169 | __glXDispSwap_MakeCurrentReadSGI(__GLXclientState * cl, GLbyte * pc) | |
170 | { | |
171 | ClientPtr client = cl->client; | |
172 | xGLXMakeCurrentReadSGIReq *req = (xGLXMakeCurrentReadSGIReq *) pc; | |
173 | ||
174 | __GLX_DECLARE_SWAP_VARIABLES; | |
175 | ||
176 | REQUEST_SIZE_MATCH(xGLXMakeCurrentReadSGIReq); | |
177 | ||
178 | __GLX_SWAP_SHORT(&req->length); | |
179 | __GLX_SWAP_INT(&req->drawable); | |
180 | __GLX_SWAP_INT(&req->readable); | |
181 | __GLX_SWAP_INT(&req->context); | |
182 | __GLX_SWAP_INT(&req->oldContextTag); | |
183 | ||
184 | return __glXDisp_MakeCurrentReadSGI(cl, pc); | |
185 | } | |
186 | ||
187 | int | |
188 | __glXDispSwap_IsDirect(__GLXclientState * cl, GLbyte * pc) | |
189 | { | |
190 | ClientPtr client = cl->client; | |
191 | xGLXIsDirectReq *req = (xGLXIsDirectReq *) pc; | |
192 | ||
193 | __GLX_DECLARE_SWAP_VARIABLES; | |
194 | ||
195 | REQUEST_SIZE_MATCH(xGLXIsDirectReq); | |
196 | ||
197 | __GLX_SWAP_SHORT(&req->length); | |
198 | __GLX_SWAP_INT(&req->context); | |
199 | ||
200 | return __glXDisp_IsDirect(cl, pc); | |
201 | } | |
202 | ||
203 | int | |
204 | __glXDispSwap_QueryVersion(__GLXclientState * cl, GLbyte * pc) | |
205 | { | |
206 | ClientPtr client = cl->client; | |
207 | xGLXQueryVersionReq *req = (xGLXQueryVersionReq *) pc; | |
208 | ||
209 | __GLX_DECLARE_SWAP_VARIABLES; | |
210 | ||
211 | REQUEST_SIZE_MATCH(xGLXQueryVersionReq); | |
212 | ||
213 | __GLX_SWAP_SHORT(&req->length); | |
214 | __GLX_SWAP_INT(&req->majorVersion); | |
215 | __GLX_SWAP_INT(&req->minorVersion); | |
216 | ||
217 | return __glXDisp_QueryVersion(cl, pc); | |
218 | } | |
219 | ||
220 | int | |
221 | __glXDispSwap_WaitGL(__GLXclientState * cl, GLbyte * pc) | |
222 | { | |
223 | ClientPtr client = cl->client; | |
224 | xGLXWaitGLReq *req = (xGLXWaitGLReq *) pc; | |
225 | ||
226 | __GLX_DECLARE_SWAP_VARIABLES; | |
227 | ||
228 | REQUEST_SIZE_MATCH(xGLXWaitGLReq); | |
229 | ||
230 | __GLX_SWAP_SHORT(&req->length); | |
231 | __GLX_SWAP_INT(&req->contextTag); | |
232 | ||
233 | return __glXDisp_WaitGL(cl, pc); | |
234 | } | |
235 | ||
236 | int | |
237 | __glXDispSwap_WaitX(__GLXclientState * cl, GLbyte * pc) | |
238 | { | |
239 | ClientPtr client = cl->client; | |
240 | xGLXWaitXReq *req = (xGLXWaitXReq *) pc; | |
241 | ||
242 | __GLX_DECLARE_SWAP_VARIABLES; | |
243 | ||
244 | REQUEST_SIZE_MATCH(xGLXWaitXReq); | |
245 | ||
246 | __GLX_SWAP_SHORT(&req->length); | |
247 | __GLX_SWAP_INT(&req->contextTag); | |
248 | ||
249 | return __glXDisp_WaitX(cl, pc); | |
250 | } | |
251 | ||
252 | int | |
253 | __glXDispSwap_CopyContext(__GLXclientState * cl, GLbyte * pc) | |
254 | { | |
255 | ClientPtr client = cl->client; | |
256 | xGLXCopyContextReq *req = (xGLXCopyContextReq *) pc; | |
257 | ||
258 | __GLX_DECLARE_SWAP_VARIABLES; | |
259 | ||
260 | REQUEST_SIZE_MATCH(xGLXCopyContextReq); | |
261 | ||
262 | __GLX_SWAP_SHORT(&req->length); | |
263 | __GLX_SWAP_INT(&req->source); | |
264 | __GLX_SWAP_INT(&req->dest); | |
265 | __GLX_SWAP_INT(&req->mask); | |
266 | ||
267 | return __glXDisp_CopyContext(cl, pc); | |
268 | } | |
269 | ||
270 | int | |
271 | __glXDispSwap_GetVisualConfigs(__GLXclientState * cl, GLbyte * pc) | |
272 | { | |
273 | ClientPtr client = cl->client; | |
274 | xGLXGetVisualConfigsReq *req = (xGLXGetVisualConfigsReq *) pc; | |
275 | ||
276 | __GLX_DECLARE_SWAP_VARIABLES; | |
277 | ||
278 | REQUEST_SIZE_MATCH(xGLXGetVisualConfigsReq); | |
279 | ||
280 | __GLX_SWAP_INT(&req->screen); | |
281 | return __glXDisp_GetVisualConfigs(cl, pc); | |
282 | } | |
283 | ||
284 | int | |
285 | __glXDispSwap_GetFBConfigs(__GLXclientState * cl, GLbyte * pc) | |
286 | { | |
287 | ClientPtr client = cl->client; | |
288 | xGLXGetFBConfigsReq *req = (xGLXGetFBConfigsReq *) pc; | |
289 | ||
290 | __GLX_DECLARE_SWAP_VARIABLES; | |
291 | ||
292 | REQUEST_SIZE_MATCH(xGLXGetFBConfigsReq); | |
293 | ||
294 | __GLX_SWAP_INT(&req->screen); | |
295 | return __glXDisp_GetFBConfigs(cl, pc); | |
296 | } | |
297 | ||
298 | int | |
299 | __glXDispSwap_GetFBConfigsSGIX(__GLXclientState * cl, GLbyte * pc) | |
300 | { | |
301 | ClientPtr client = cl->client; | |
302 | xGLXGetFBConfigsSGIXReq *req = (xGLXGetFBConfigsSGIXReq *) pc; | |
303 | ||
304 | __GLX_DECLARE_SWAP_VARIABLES; | |
305 | ||
306 | REQUEST_AT_LEAST_SIZE(xGLXGetFBConfigsSGIXReq); | |
307 | ||
308 | __GLX_SWAP_INT(&req->screen); | |
309 | return __glXDisp_GetFBConfigsSGIX(cl, pc); | |
310 | } | |
311 | ||
312 | int | |
313 | __glXDispSwap_CreateGLXPixmap(__GLXclientState * cl, GLbyte * pc) | |
314 | { | |
315 | ClientPtr client = cl->client; | |
316 | xGLXCreateGLXPixmapReq *req = (xGLXCreateGLXPixmapReq *) pc; | |
317 | ||
318 | __GLX_DECLARE_SWAP_VARIABLES; | |
319 | ||
320 | REQUEST_SIZE_MATCH(xGLXCreateGLXPixmapReq); | |
321 | ||
322 | __GLX_SWAP_SHORT(&req->length); | |
323 | __GLX_SWAP_INT(&req->screen); | |
324 | __GLX_SWAP_INT(&req->visual); | |
325 | __GLX_SWAP_INT(&req->pixmap); | |
326 | __GLX_SWAP_INT(&req->glxpixmap); | |
327 | ||
328 | return __glXDisp_CreateGLXPixmap(cl, pc); | |
329 | } | |
330 | ||
331 | int | |
332 | __glXDispSwap_CreatePixmap(__GLXclientState * cl, GLbyte * pc) | |
333 | { | |
334 | ClientPtr client = cl->client; | |
335 | xGLXCreatePixmapReq *req = (xGLXCreatePixmapReq *) pc; | |
336 | CARD32 *attribs; | |
337 | ||
338 | __GLX_DECLARE_SWAP_VARIABLES; | |
339 | __GLX_DECLARE_SWAP_ARRAY_VARIABLES; | |
340 | ||
341 | REQUEST_AT_LEAST_SIZE(xGLXCreatePixmapReq); | |
342 | ||
343 | __GLX_SWAP_SHORT(&req->length); | |
344 | __GLX_SWAP_INT(&req->screen); | |
345 | __GLX_SWAP_INT(&req->fbconfig); | |
346 | __GLX_SWAP_INT(&req->pixmap); | |
347 | __GLX_SWAP_INT(&req->glxpixmap); | |
348 | __GLX_SWAP_INT(&req->numAttribs); | |
349 | ||
350 | if (req->numAttribs > (UINT32_MAX >> 3)) { | |
351 | client->errorValue = req->numAttribs; | |
352 | return BadValue; | |
353 | } | |
354 | REQUEST_FIXED_SIZE(xGLXCreatePixmapReq, req->numAttribs << 3); | |
355 | attribs = (CARD32 *) (req + 1); | |
356 | __GLX_SWAP_INT_ARRAY(attribs, req->numAttribs << 1); | |
357 | ||
358 | return __glXDisp_CreatePixmap(cl, pc); | |
359 | } | |
360 | ||
361 | int | |
362 | __glXDispSwap_CreateGLXPixmapWithConfigSGIX(__GLXclientState * cl, GLbyte * pc) | |
363 | { | |
364 | ClientPtr client = cl->client; | |
365 | xGLXCreateGLXPixmapWithConfigSGIXReq *req = | |
366 | (xGLXCreateGLXPixmapWithConfigSGIXReq *) pc; | |
367 | __GLX_DECLARE_SWAP_VARIABLES; | |
368 | ||
369 | REQUEST_SIZE_MATCH(xGLXCreateGLXPixmapWithConfigSGIXReq); | |
370 | ||
371 | __GLX_SWAP_SHORT(&req->length); | |
372 | __GLX_SWAP_INT(&req->screen); | |
373 | __GLX_SWAP_INT(&req->fbconfig); | |
374 | __GLX_SWAP_INT(&req->pixmap); | |
375 | __GLX_SWAP_INT(&req->glxpixmap); | |
376 | ||
377 | return __glXDisp_CreateGLXPixmapWithConfigSGIX(cl, pc); | |
378 | } | |
379 | ||
380 | int | |
381 | __glXDispSwap_DestroyGLXPixmap(__GLXclientState * cl, GLbyte * pc) | |
382 | { | |
383 | ClientPtr client = cl->client; | |
384 | xGLXDestroyGLXPixmapReq *req = (xGLXDestroyGLXPixmapReq *) pc; | |
385 | ||
386 | __GLX_DECLARE_SWAP_VARIABLES; | |
387 | ||
388 | REQUEST_SIZE_MATCH(xGLXDestroyGLXPixmapReq); | |
389 | ||
390 | __GLX_SWAP_SHORT(&req->length); | |
391 | __GLX_SWAP_INT(&req->glxpixmap); | |
392 | ||
393 | return __glXDisp_DestroyGLXPixmap(cl, pc); | |
394 | } | |
395 | ||
396 | int | |
397 | __glXDispSwap_DestroyPixmap(__GLXclientState * cl, GLbyte * pc) | |
398 | { | |
399 | ClientPtr client = cl->client; | |
400 | xGLXDestroyGLXPixmapReq *req = (xGLXDestroyGLXPixmapReq *) pc; | |
401 | ||
402 | __GLX_DECLARE_SWAP_VARIABLES; | |
403 | ||
404 | REQUEST_AT_LEAST_SIZE(xGLXDestroyGLXPixmapReq); | |
405 | ||
406 | __GLX_SWAP_SHORT(&req->length); | |
407 | __GLX_SWAP_INT(&req->glxpixmap); | |
408 | ||
409 | return __glXDisp_DestroyGLXPixmap(cl, pc); | |
410 | } | |
411 | ||
412 | int | |
413 | __glXDispSwap_QueryContext(__GLXclientState * cl, GLbyte * pc) | |
414 | { | |
415 | ClientPtr client = cl->client; | |
416 | xGLXQueryContextReq *req = (xGLXQueryContextReq *) pc; | |
417 | ||
418 | __GLX_DECLARE_SWAP_VARIABLES; | |
419 | ||
420 | REQUEST_SIZE_MATCH(xGLXQueryContextReq); | |
421 | ||
422 | __GLX_SWAP_INT(&req->context); | |
423 | ||
424 | return __glXDisp_QueryContext(cl, pc); | |
425 | } | |
426 | ||
427 | int | |
428 | __glXDispSwap_CreatePbuffer(__GLXclientState * cl, GLbyte * pc) | |
429 | { | |
430 | ClientPtr client = cl->client; | |
431 | xGLXCreatePbufferReq *req = (xGLXCreatePbufferReq *) pc; | |
432 | ||
433 | __GLX_DECLARE_SWAP_VARIABLES; | |
434 | __GLX_DECLARE_SWAP_ARRAY_VARIABLES; | |
435 | CARD32 *attribs; | |
436 | ||
437 | REQUEST_AT_LEAST_SIZE(xGLXCreatePbufferReq); | |
438 | ||
439 | __GLX_SWAP_INT(&req->screen); | |
440 | __GLX_SWAP_INT(&req->fbconfig); | |
441 | __GLX_SWAP_INT(&req->pbuffer); | |
442 | __GLX_SWAP_INT(&req->numAttribs); | |
443 | ||
444 | if (req->numAttribs > (UINT32_MAX >> 3)) { | |
445 | client->errorValue = req->numAttribs; | |
446 | return BadValue; | |
447 | } | |
448 | REQUEST_FIXED_SIZE(xGLXCreatePbufferReq, req->numAttribs << 3); | |
449 | attribs = (CARD32 *) (req + 1); | |
450 | __GLX_SWAP_INT_ARRAY(attribs, req->numAttribs << 1); | |
451 | ||
452 | return __glXDisp_CreatePbuffer(cl, pc); | |
453 | } | |
454 | ||
455 | int | |
456 | __glXDispSwap_CreateGLXPbufferSGIX(__GLXclientState * cl, GLbyte * pc) | |
457 | { | |
458 | ClientPtr client = cl->client; | |
459 | xGLXCreateGLXPbufferSGIXReq *req = (xGLXCreateGLXPbufferSGIXReq *) pc; | |
460 | ||
461 | __GLX_DECLARE_SWAP_VARIABLES; | |
462 | ||
463 | REQUEST_AT_LEAST_SIZE(xGLXCreateGLXPbufferSGIXReq); | |
464 | ||
465 | __GLX_SWAP_INT(&req->screen); | |
466 | __GLX_SWAP_INT(&req->fbconfig); | |
467 | __GLX_SWAP_INT(&req->pbuffer); | |
468 | __GLX_SWAP_INT(&req->width); | |
469 | __GLX_SWAP_INT(&req->height); | |
470 | ||
471 | return __glXDisp_CreateGLXPbufferSGIX(cl, pc); | |
472 | } | |
473 | ||
474 | int | |
475 | __glXDispSwap_DestroyPbuffer(__GLXclientState * cl, GLbyte * pc) | |
476 | { | |
477 | ClientPtr client = cl->client; | |
478 | xGLXDestroyPbufferReq *req = (xGLXDestroyPbufferReq *) pc; | |
479 | ||
480 | __GLX_DECLARE_SWAP_VARIABLES; | |
481 | ||
482 | REQUEST_SIZE_MATCH(xGLXDestroyPbufferReq); | |
483 | ||
484 | __GLX_SWAP_INT(&req->pbuffer); | |
485 | ||
486 | return __glXDisp_DestroyPbuffer(cl, pc); | |
487 | } | |
488 | ||
489 | int | |
490 | __glXDispSwap_DestroyGLXPbufferSGIX(__GLXclientState * cl, GLbyte * pc) | |
491 | { | |
492 | ClientPtr client = cl->client; | |
493 | xGLXDestroyGLXPbufferSGIXReq *req = (xGLXDestroyGLXPbufferSGIXReq *) pc; | |
494 | ||
495 | __GLX_DECLARE_SWAP_VARIABLES; | |
496 | ||
497 | REQUEST_SIZE_MATCH(xGLXDestroyGLXPbufferSGIXReq); | |
498 | ||
499 | __GLX_SWAP_INT(&req->pbuffer); | |
500 | ||
501 | return __glXDisp_DestroyGLXPbufferSGIX(cl, pc); | |
502 | } | |
503 | ||
504 | int | |
505 | __glXDispSwap_ChangeDrawableAttributes(__GLXclientState * cl, GLbyte * pc) | |
506 | { | |
507 | ClientPtr client = cl->client; | |
508 | xGLXChangeDrawableAttributesReq *req = | |
509 | (xGLXChangeDrawableAttributesReq *) pc; | |
510 | __GLX_DECLARE_SWAP_VARIABLES; | |
511 | __GLX_DECLARE_SWAP_ARRAY_VARIABLES; | |
512 | CARD32 *attribs; | |
513 | ||
514 | REQUEST_AT_LEAST_SIZE(xGLXChangeDrawableAttributesReq); | |
515 | ||
516 | __GLX_SWAP_INT(&req->drawable); | |
517 | __GLX_SWAP_INT(&req->numAttribs); | |
518 | ||
519 | if (req->numAttribs > (UINT32_MAX >> 3)) { | |
520 | client->errorValue = req->numAttribs; | |
521 | return BadValue; | |
522 | } | |
523 | if (((sizeof(xGLXChangeDrawableAttributesReq) + | |
524 | (req->numAttribs << 3)) >> 2) < client->req_len) | |
525 | return BadLength; | |
526 | ||
527 | attribs = (CARD32 *) (req + 1); | |
528 | __GLX_SWAP_INT_ARRAY(attribs, req->numAttribs << 1); | |
529 | ||
530 | return __glXDisp_ChangeDrawableAttributes(cl, pc); | |
531 | } | |
532 | ||
533 | int | |
534 | __glXDispSwap_ChangeDrawableAttributesSGIX(__GLXclientState * cl, GLbyte * pc) | |
535 | { | |
536 | ClientPtr client = cl->client; | |
537 | xGLXChangeDrawableAttributesSGIXReq *req = | |
538 | (xGLXChangeDrawableAttributesSGIXReq *) pc; | |
539 | __GLX_DECLARE_SWAP_VARIABLES; | |
540 | __GLX_DECLARE_SWAP_ARRAY_VARIABLES; | |
541 | CARD32 *attribs; | |
542 | ||
543 | REQUEST_AT_LEAST_SIZE(xGLXChangeDrawableAttributesSGIXReq); | |
544 | ||
545 | __GLX_SWAP_INT(&req->drawable); | |
546 | __GLX_SWAP_INT(&req->numAttribs); | |
547 | ||
548 | if (req->numAttribs > (UINT32_MAX >> 3)) { | |
549 | client->errorValue = req->numAttribs; | |
550 | return BadValue; | |
551 | } | |
552 | REQUEST_FIXED_SIZE(xGLXChangeDrawableAttributesSGIXReq, | |
553 | req->numAttribs << 3); | |
554 | attribs = (CARD32 *) (req + 1); | |
555 | __GLX_SWAP_INT_ARRAY(attribs, req->numAttribs << 1); | |
556 | ||
557 | return __glXDisp_ChangeDrawableAttributesSGIX(cl, pc); | |
558 | } | |
559 | ||
560 | int | |
561 | __glXDispSwap_CreateWindow(__GLXclientState * cl, GLbyte * pc) | |
562 | { | |
563 | ClientPtr client = cl->client; | |
564 | xGLXCreateWindowReq *req = (xGLXCreateWindowReq *) pc; | |
565 | ||
566 | __GLX_DECLARE_SWAP_VARIABLES; | |
567 | __GLX_DECLARE_SWAP_ARRAY_VARIABLES; | |
568 | CARD32 *attribs; | |
569 | ||
570 | REQUEST_AT_LEAST_SIZE(xGLXCreateWindowReq); | |
571 | ||
572 | __GLX_SWAP_INT(&req->screen); | |
573 | __GLX_SWAP_INT(&req->fbconfig); | |
574 | __GLX_SWAP_INT(&req->window); | |
575 | __GLX_SWAP_INT(&req->glxwindow); | |
576 | __GLX_SWAP_INT(&req->numAttribs); | |
577 | ||
578 | if (req->numAttribs > (UINT32_MAX >> 3)) { | |
579 | client->errorValue = req->numAttribs; | |
580 | return BadValue; | |
581 | } | |
582 | REQUEST_FIXED_SIZE(xGLXCreateWindowReq, req->numAttribs << 3); | |
583 | attribs = (CARD32 *) (req + 1); | |
584 | __GLX_SWAP_INT_ARRAY(attribs, req->numAttribs << 1); | |
585 | ||
586 | return __glXDisp_CreateWindow(cl, pc); | |
587 | } | |
588 | ||
589 | int | |
590 | __glXDispSwap_DestroyWindow(__GLXclientState * cl, GLbyte * pc) | |
591 | { | |
592 | ClientPtr client = cl->client; | |
593 | xGLXDestroyWindowReq *req = (xGLXDestroyWindowReq *) pc; | |
594 | ||
595 | __GLX_DECLARE_SWAP_VARIABLES; | |
596 | ||
597 | REQUEST_AT_LEAST_SIZE(xGLXDestroyWindowReq); | |
598 | ||
599 | __GLX_SWAP_INT(&req->glxwindow); | |
600 | ||
601 | return __glXDisp_DestroyWindow(cl, pc); | |
602 | } | |
603 | ||
604 | int | |
605 | __glXDispSwap_SwapBuffers(__GLXclientState * cl, GLbyte * pc) | |
606 | { | |
607 | ClientPtr client = cl->client; | |
608 | xGLXSwapBuffersReq *req = (xGLXSwapBuffersReq *) pc; | |
609 | ||
610 | __GLX_DECLARE_SWAP_VARIABLES; | |
611 | ||
612 | REQUEST_SIZE_MATCH(xGLXSwapBuffersReq); | |
613 | ||
614 | __GLX_SWAP_SHORT(&req->length); | |
615 | __GLX_SWAP_INT(&req->contextTag); | |
616 | __GLX_SWAP_INT(&req->drawable); | |
617 | ||
618 | return __glXDisp_SwapBuffers(cl, pc); | |
619 | } | |
620 | ||
621 | int | |
622 | __glXDispSwap_UseXFont(__GLXclientState * cl, GLbyte * pc) | |
623 | { | |
624 | ClientPtr client = cl->client; | |
625 | xGLXUseXFontReq *req = (xGLXUseXFontReq *) pc; | |
626 | ||
627 | __GLX_DECLARE_SWAP_VARIABLES; | |
628 | ||
629 | REQUEST_SIZE_MATCH(xGLXUseXFontReq); | |
630 | ||
631 | __GLX_SWAP_SHORT(&req->length); | |
632 | __GLX_SWAP_INT(&req->contextTag); | |
633 | __GLX_SWAP_INT(&req->font); | |
634 | __GLX_SWAP_INT(&req->first); | |
635 | __GLX_SWAP_INT(&req->count); | |
636 | __GLX_SWAP_INT(&req->listBase); | |
637 | ||
638 | return __glXDisp_UseXFont(cl, pc); | |
639 | } | |
640 | ||
641 | int | |
642 | __glXDispSwap_QueryExtensionsString(__GLXclientState * cl, GLbyte * pc) | |
643 | { | |
644 | ClientPtr client = cl->client; | |
645 | xGLXQueryExtensionsStringReq *req = (xGLXQueryExtensionsStringReq *) pc; | |
646 | ||
647 | __GLX_DECLARE_SWAP_VARIABLES; | |
648 | ||
649 | REQUEST_SIZE_MATCH(xGLXQueryExtensionsStringReq); | |
650 | ||
651 | __GLX_SWAP_SHORT(&req->length); | |
652 | __GLX_SWAP_INT(&req->screen); | |
653 | ||
654 | return __glXDisp_QueryExtensionsString(cl, pc); | |
655 | } | |
656 | ||
657 | int | |
658 | __glXDispSwap_QueryServerString(__GLXclientState * cl, GLbyte * pc) | |
659 | { | |
660 | ClientPtr client = cl->client; | |
661 | xGLXQueryServerStringReq *req = (xGLXQueryServerStringReq *) pc; | |
662 | ||
663 | __GLX_DECLARE_SWAP_VARIABLES; | |
664 | ||
665 | REQUEST_SIZE_MATCH(xGLXQueryServerStringReq); | |
666 | ||
667 | __GLX_SWAP_SHORT(&req->length); | |
668 | __GLX_SWAP_INT(&req->screen); | |
669 | __GLX_SWAP_INT(&req->name); | |
670 | ||
671 | return __glXDisp_QueryServerString(cl, pc); | |
672 | } | |
673 | ||
674 | int | |
675 | __glXDispSwap_ClientInfo(__GLXclientState * cl, GLbyte * pc) | |
676 | { | |
677 | ClientPtr client = cl->client; | |
678 | xGLXClientInfoReq *req = (xGLXClientInfoReq *) pc; | |
679 | ||
680 | __GLX_DECLARE_SWAP_VARIABLES; | |
681 | ||
682 | REQUEST_AT_LEAST_SIZE(xGLXClientInfoReq); | |
683 | ||
684 | __GLX_SWAP_SHORT(&req->length); | |
685 | __GLX_SWAP_INT(&req->major); | |
686 | __GLX_SWAP_INT(&req->minor); | |
687 | __GLX_SWAP_INT(&req->numbytes); | |
688 | ||
689 | return __glXDisp_ClientInfo(cl, pc); | |
690 | } | |
691 | ||
692 | int | |
693 | __glXDispSwap_QueryContextInfoEXT(__GLXclientState * cl, GLbyte * pc) | |
694 | { | |
695 | ClientPtr client = cl->client; | |
696 | xGLXQueryContextInfoEXTReq *req = (xGLXQueryContextInfoEXTReq *) pc; | |
697 | ||
698 | __GLX_DECLARE_SWAP_VARIABLES; | |
699 | ||
700 | REQUEST_SIZE_MATCH(xGLXQueryContextInfoEXTReq); | |
701 | ||
702 | __GLX_SWAP_SHORT(&req->length); | |
703 | __GLX_SWAP_INT(&req->context); | |
704 | ||
705 | return __glXDisp_QueryContextInfoEXT(cl, pc); | |
706 | } | |
707 | ||
708 | int | |
709 | __glXDispSwap_BindTexImageEXT(__GLXclientState * cl, GLbyte * pc) | |
710 | { | |
711 | ClientPtr client = cl->client; | |
712 | xGLXVendorPrivateReq *req = (xGLXVendorPrivateReq *) pc; | |
713 | GLXDrawable *drawId; | |
714 | int *buffer; | |
715 | CARD32 *num_attribs; | |
716 | ||
717 | __GLX_DECLARE_SWAP_VARIABLES; | |
718 | ||
719 | if ((sizeof(xGLXVendorPrivateReq) + 12) >> 2 > client->req_len) | |
720 | return BadLength; | |
721 | ||
722 | pc += __GLX_VENDPRIV_HDR_SIZE; | |
723 | ||
724 | drawId = ((GLXDrawable *) (pc)); | |
725 | buffer = ((int *) (pc + 4)); | |
726 | num_attribs = ((CARD32 *) (pc + 8)); | |
727 | ||
728 | __GLX_SWAP_SHORT(&req->length); | |
729 | __GLX_SWAP_INT(&req->contextTag); | |
730 | __GLX_SWAP_INT(drawId); | |
731 | __GLX_SWAP_INT(buffer); | |
732 | __GLX_SWAP_INT(num_attribs); | |
733 | ||
734 | return __glXDisp_BindTexImageEXT(cl, (GLbyte *) pc); | |
735 | } | |
736 | ||
737 | int | |
738 | __glXDispSwap_ReleaseTexImageEXT(__GLXclientState * cl, GLbyte * pc) | |
739 | { | |
740 | ClientPtr client = cl->client; | |
741 | xGLXVendorPrivateReq *req = (xGLXVendorPrivateReq *) pc; | |
742 | GLXDrawable *drawId; | |
743 | int *buffer; | |
744 | ||
745 | __GLX_DECLARE_SWAP_VARIABLES; | |
746 | ||
747 | REQUEST_FIXED_SIZE(xGLXVendorPrivateReq, 8); | |
748 | ||
749 | pc += __GLX_VENDPRIV_HDR_SIZE; | |
750 | ||
751 | drawId = ((GLXDrawable *) (pc)); | |
752 | buffer = ((int *) (pc + 4)); | |
753 | ||
754 | __GLX_SWAP_SHORT(&req->length); | |
755 | __GLX_SWAP_INT(&req->contextTag); | |
756 | __GLX_SWAP_INT(drawId); | |
757 | __GLX_SWAP_INT(buffer); | |
758 | ||
759 | return __glXDisp_ReleaseTexImageEXT(cl, (GLbyte *) pc); | |
760 | } | |
761 | ||
762 | int | |
763 | __glXDispSwap_CopySubBufferMESA(__GLXclientState * cl, GLbyte * pc) | |
764 | { | |
765 | ClientPtr client = cl->client; | |
766 | xGLXVendorPrivateReq *req = (xGLXVendorPrivateReq *) pc; | |
767 | GLXDrawable *drawId; | |
768 | int *buffer; | |
769 | ||
770 | __GLX_DECLARE_SWAP_VARIABLES; | |
771 | ||
772 | REQUEST_FIXED_SIZE(xGLXVendorPrivateReq, 20); | |
773 | ||
774 | (void) drawId; | |
775 | (void) buffer; | |
776 | ||
777 | pc += __GLX_VENDPRIV_HDR_SIZE; | |
778 | ||
779 | __GLX_SWAP_SHORT(&req->length); | |
780 | __GLX_SWAP_INT(&req->contextTag); | |
781 | __GLX_SWAP_INT(pc); | |
782 | __GLX_SWAP_INT(pc + 4); | |
783 | __GLX_SWAP_INT(pc + 8); | |
784 | __GLX_SWAP_INT(pc + 12); | |
785 | __GLX_SWAP_INT(pc + 16); | |
786 | ||
787 | return __glXDisp_CopySubBufferMESA(cl, pc); | |
788 | ||
789 | } | |
790 | ||
791 | int | |
792 | __glXDispSwap_GetDrawableAttributesSGIX(__GLXclientState * cl, GLbyte * pc) | |
793 | { | |
794 | ClientPtr client = cl->client; | |
795 | xGLXVendorPrivateWithReplyReq *req = (xGLXVendorPrivateWithReplyReq *) pc; | |
796 | CARD32 *data; | |
797 | ||
798 | __GLX_DECLARE_SWAP_VARIABLES; | |
799 | ||
800 | REQUEST_SIZE_MATCH(xGLXGetDrawableAttributesSGIXReq); | |
801 | ||
802 | data = (CARD32 *) (req + 1); | |
803 | __GLX_SWAP_SHORT(&req->length); | |
804 | __GLX_SWAP_INT(&req->contextTag); | |
805 | __GLX_SWAP_INT(data); | |
806 | ||
807 | return __glXDisp_GetDrawableAttributesSGIX(cl, pc); | |
808 | } | |
809 | ||
810 | int | |
811 | __glXDispSwap_GetDrawableAttributes(__GLXclientState * cl, GLbyte * pc) | |
812 | { | |
813 | ClientPtr client = cl->client; | |
814 | xGLXGetDrawableAttributesReq *req = (xGLXGetDrawableAttributesReq *) pc; | |
815 | ||
816 | __GLX_DECLARE_SWAP_VARIABLES; | |
817 | ||
818 | REQUEST_AT_LEAST_SIZE(xGLXGetDrawableAttributesReq); | |
819 | ||
820 | __GLX_SWAP_SHORT(&req->length); | |
821 | __GLX_SWAP_INT(&req->drawable); | |
822 | ||
823 | return __glXDisp_GetDrawableAttributes(cl, pc); | |
824 | } | |
825 | ||
826 | /************************************************************************/ | |
827 | ||
828 | /* | |
829 | ** Swap replies. | |
830 | */ | |
831 | ||
832 | void | |
833 | __glXSwapMakeCurrentReply(ClientPtr client, xGLXMakeCurrentReply * reply) | |
834 | { | |
835 | __GLX_DECLARE_SWAP_VARIABLES; | |
836 | __GLX_SWAP_SHORT(&reply->sequenceNumber); | |
837 | __GLX_SWAP_INT(&reply->length); | |
838 | __GLX_SWAP_INT(&reply->contextTag); | |
839 | WriteToClient(client, sz_xGLXMakeCurrentReply, reply); | |
840 | } | |
841 | ||
842 | void | |
843 | __glXSwapIsDirectReply(ClientPtr client, xGLXIsDirectReply * reply) | |
844 | { | |
845 | __GLX_DECLARE_SWAP_VARIABLES; | |
846 | __GLX_SWAP_SHORT(&reply->sequenceNumber); | |
847 | __GLX_SWAP_INT(&reply->length); | |
848 | WriteToClient(client, sz_xGLXIsDirectReply, reply); | |
849 | } | |
850 | ||
851 | void | |
852 | __glXSwapQueryVersionReply(ClientPtr client, xGLXQueryVersionReply * reply) | |
853 | { | |
854 | __GLX_DECLARE_SWAP_VARIABLES; | |
855 | __GLX_SWAP_SHORT(&reply->sequenceNumber); | |
856 | __GLX_SWAP_INT(&reply->length); | |
857 | __GLX_SWAP_INT(&reply->majorVersion); | |
858 | __GLX_SWAP_INT(&reply->minorVersion); | |
859 | WriteToClient(client, sz_xGLXQueryVersionReply, reply); | |
860 | } | |
861 | ||
862 | void | |
863 | glxSwapQueryExtensionsStringReply(ClientPtr client, | |
864 | xGLXQueryExtensionsStringReply * reply, | |
865 | char *buf) | |
866 | { | |
867 | int length = reply->length; | |
868 | ||
869 | __GLX_DECLARE_SWAP_VARIABLES; | |
870 | __GLX_DECLARE_SWAP_ARRAY_VARIABLES; | |
871 | __GLX_SWAP_SHORT(&reply->sequenceNumber); | |
872 | __GLX_SWAP_INT(&reply->length); | |
873 | __GLX_SWAP_INT(&reply->n); | |
874 | WriteToClient(client, sz_xGLXQueryExtensionsStringReply, reply); | |
875 | __GLX_SWAP_INT_ARRAY((int *) buf, length); | |
876 | WriteToClient(client, length << 2, buf); | |
877 | } | |
878 | ||
879 | void | |
880 | glxSwapQueryServerStringReply(ClientPtr client, | |
881 | xGLXQueryServerStringReply * reply, char *buf) | |
882 | { | |
883 | int length = reply->length; | |
884 | ||
885 | __GLX_DECLARE_SWAP_VARIABLES; | |
886 | __GLX_SWAP_SHORT(&reply->sequenceNumber); | |
887 | __GLX_SWAP_INT(&reply->length); | |
888 | __GLX_SWAP_INT(&reply->n); | |
889 | WriteToClient(client, sz_xGLXQueryServerStringReply, reply); | |
890 | /** no swap is needed for an array of chars **/ | |
891 | /* __GLX_SWAP_INT_ARRAY((int *)buf, length); */ | |
892 | WriteToClient(client, length << 2, buf); | |
893 | } | |
894 | ||
895 | void | |
896 | __glXSwapQueryContextInfoEXTReply(ClientPtr client, | |
897 | xGLXQueryContextInfoEXTReply * reply, | |
898 | int *buf) | |
899 | { | |
900 | int length = reply->length; | |
901 | ||
902 | __GLX_DECLARE_SWAP_VARIABLES; | |
903 | __GLX_DECLARE_SWAP_ARRAY_VARIABLES; | |
904 | __GLX_SWAP_SHORT(&reply->sequenceNumber); | |
905 | __GLX_SWAP_INT(&reply->length); | |
906 | __GLX_SWAP_INT(&reply->n); | |
907 | WriteToClient(client, sz_xGLXQueryContextInfoEXTReply, reply); | |
908 | __GLX_SWAP_INT_ARRAY((int *) buf, length); | |
909 | WriteToClient(client, length << 2, buf); | |
910 | } | |
911 | ||
912 | void | |
913 | __glXSwapGetDrawableAttributesReply(ClientPtr client, | |
914 | xGLXGetDrawableAttributesReply * reply, | |
915 | CARD32 *buf) | |
916 | { | |
917 | int length = reply->length; | |
918 | ||
919 | __GLX_DECLARE_SWAP_VARIABLES; | |
920 | __GLX_DECLARE_SWAP_ARRAY_VARIABLES; | |
921 | __GLX_SWAP_SHORT(&reply->sequenceNumber); | |
922 | __GLX_SWAP_INT(&reply->length); | |
923 | __GLX_SWAP_INT(&reply->numAttribs); | |
924 | WriteToClient(client, sz_xGLXGetDrawableAttributesReply, reply); | |
925 | __GLX_SWAP_INT_ARRAY((int *) buf, length); | |
926 | WriteToClient(client, length << 2, buf); | |
927 | } | |
928 | ||
929 | /************************************************************************/ | |
930 | ||
931 | /* | |
932 | ** Render and Renderlarge are not in the GLX API. They are used by the GLX | |
933 | ** client library to send batches of GL rendering commands. | |
934 | */ | |
935 | ||
936 | int | |
937 | __glXDispSwap_Render(__GLXclientState * cl, GLbyte * pc) | |
938 | { | |
939 | return __glXDisp_Render(cl, pc); | |
940 | } | |
941 | ||
942 | /* | |
943 | ** Execute a large rendering request (one that spans multiple X requests). | |
944 | */ | |
945 | int | |
946 | __glXDispSwap_RenderLarge(__GLXclientState * cl, GLbyte * pc) | |
947 | { | |
948 | return __glXDisp_RenderLarge(cl, pc); | |
949 | } | |
950 | ||
951 | /************************************************************************/ | |
952 | ||
953 | /* | |
954 | ** No support is provided for the vendor-private requests other than | |
955 | ** allocating these entry points in the dispatch table. | |
956 | */ | |
957 | ||
958 | int | |
959 | __glXDispSwap_VendorPrivate(__GLXclientState * cl, GLbyte * pc) | |
960 | { | |
961 | xGLXVendorPrivateReq *req; | |
962 | GLint vendorcode; | |
963 | __GLXdispatchVendorPrivProcPtr proc; | |
964 | ||
965 | __GLX_DECLARE_SWAP_VARIABLES; | |
966 | ||
967 | req = (xGLXVendorPrivateReq *) pc; | |
968 | __GLX_SWAP_SHORT(&req->length); | |
969 | __GLX_SWAP_INT(&req->vendorCode); | |
970 | ||
971 | vendorcode = req->vendorCode; | |
972 | ||
973 | proc = (__GLXdispatchVendorPrivProcPtr) | |
974 | __glXGetProtocolDecodeFunction(&VendorPriv_dispatch_info, | |
975 | vendorcode, 1); | |
976 | if (proc != NULL) { | |
977 | (*proc) (cl, (GLbyte *) req); | |
978 | return Success; | |
979 | } | |
980 | ||
981 | cl->client->errorValue = req->vendorCode; | |
982 | return __glXError(GLXUnsupportedPrivateRequest); | |
983 | } | |
984 | ||
985 | int | |
986 | __glXDispSwap_VendorPrivateWithReply(__GLXclientState * cl, GLbyte * pc) | |
987 | { | |
988 | xGLXVendorPrivateWithReplyReq *req; | |
989 | GLint vendorcode; | |
990 | __GLXdispatchVendorPrivProcPtr proc; | |
991 | ||
992 | __GLX_DECLARE_SWAP_VARIABLES; | |
993 | ||
994 | req = (xGLXVendorPrivateWithReplyReq *) pc; | |
995 | __GLX_SWAP_SHORT(&req->length); | |
996 | __GLX_SWAP_INT(&req->vendorCode); | |
997 | ||
998 | vendorcode = req->vendorCode; | |
999 | ||
1000 | proc = (__GLXdispatchVendorPrivProcPtr) | |
1001 | __glXGetProtocolDecodeFunction(&VendorPriv_dispatch_info, | |
1002 | vendorcode, 1); | |
1003 | if (proc != NULL) { | |
1004 | return (*proc) (cl, (GLbyte *) req); | |
1005 | } | |
1006 | ||
1007 | cl->client->errorValue = req->vendorCode; | |
1008 | return __glXError(GLXUnsupportedPrivateRequest); | |
1009 | } |