← Back to branch summary

~ubuntu-branches/ubuntu/precise/xorg-server/precise

« back to all changes in this revision

Viewing changes to glx/glxcmdsswap.c

  • Committer: Bazaar Package Importer
  • Author(s): Christopher James Halse Rogers
  • Date: 2011-01-31 19:45:19 UTC
  • mfrom: (1.1.38 upstream) (0.1.19 experimental)
  • Revision ID: james.westby@ubuntu.com-20110131194519-fx30d1zsg83invba
Tags: 2:1.9.99.901+git20110131.be3be758-0ubuntu1
https://launchpad.net/bugs/406226
https://launchpad.net/bugs/247537
https://launchpad.net/bugs/500102
https://launchpad.net/bugs/614993
https://launchpad.net/bugs/371405
https://launchpad.net/bugs/459512
https://launchpad.net/bugs/633593
* Merge from (unreleased) debian-experimental.  Remaining Ubuntu changes:
  - rules:
    + Disable SELinux, libaudit-dev is not in main yet. (LP: #406226)
    + Enable xcsecurity. (LP: #247537)
    + Add --with-extra-module-dir to support GL alternatives.
  - control: 
    + Xvfb depends on xauth, x11-xkb-utils. (LP: #500102)
    + Add breaks for incompatible drivers. (LP: #614993)
    + Drop libaudit-dev from build-deps.
  - local/xvfb-run*: Add correct docs about error codes. (LP #328205)
  - debian/patches:
    + 100_rethrow_signals.patch:
      When aborting, re-raise signals for apport
    + 109_fix-swcursor-crash.patch:
      Avoid dereferencing null pointer while reloading cursors during
      resume. (LP: #371405)
    + 111_armel-drv-fallbacks.patch:
      Add support for armel driver fallbacks.
    + 121_only_switch_vt_when_active.diff:
      Add a check to prevent the X server from changing the VT when killing
      GDM from the console.
    + 122_xext_fix_card32_overflow_in_xauth.patch:
      Fix server crash when “xauth generate” is called with large timeout.
    + 157_check_null_modes.patch, 162_null_crtc_in_rotation.patch,
      166_nullptr_xinerama_keyrepeat.patch, 167_nullptr_xisbread.patch
      169_mipointer_nullptr_checks.patch,
      172_cwgetbackingpicture_nullptr_check.patch:
      Fix various segfaults in xserver by checking pointers for NULL
      values before dereferencing them.
    + 165_man_xorg_conf_no_device_ident.patch
      Correct man page
    + 168_glibc_trace_to_stderr.patch:
      Report abort traces to stderr instead of terminal
    + 184_virtual_devices_autodetect.patch:
      Use vesa for qemu device, which is not supported by cirrus
    + 188_default_primary_to_first_busid.patch:
      Pick the first device and carry on (LP: #459512)
    + 190_cache-xkbcomp_output_for_fast_start_up.patch:
    + 191-Xorg-add-an-extra-module-path.patch:
      Add support for the alternatives module path.
    + 198_nohwaccess.patch:
      Adds a -nohwaccess argument to make X not access the hardware
      ports directly.
    + 200_randr-null.patch:
      Clarify a pointer initialization.
    + 206_intel_8xx_default_to_fbdev.patch:
      Makes 8xx class intel GPUs default to fbdev for stability. (LP: #633593)
* Refresh 121_only_switch_vt_when_active.diff for new upstream.
* Drop 187_edid_quirk_hp_nc8430.patch; upstream.
* Drop 189_xserver_1.5.0_bg_none_root.patch; functionality now upstream.
* Refresh 190_cache-xkbcomp_output_for_fast_start_up.patch for new upstream.
* Drop 197_xvfb-randr.patch:
  - miRandR, which this used, has been removed from the server. 
* Drop 204_fix-neg-sync-transition.patch; upstream.
* Drop 207_dga_master_device.patch; upstream.
* Drop 208_switch_on_release.diff; upstream.
* debian/patches/209_add_legacy_bgnone_option.patch:
  - Add "-nr" as a synonym for "-background none" to ease the transition from
    the old 189_xserver_1.5.0_bg_none_root.patch patch.  Can be dropped once
    all the ?DM have been updated to use the new option.
* debian/control:
  - Add Breaks: to xserver-xorg-video-8 and current fglrx.  These proprietary
    drivers don't yet have appropriate dependency information, so manually
    handle them here to prevent broken upgrades.

Show diffs side-by-side

added added

removed removed

Lines of Context:
glx/glxcmdsswap.c
37
37
#include "glxutil.h"
38
38
#include <GL/glxtokens.h>
39
39
#include <unpack.h>
40
 
#include "g_disptab.h"
41
40
#include <pixmapstr.h>
42
41
#include <windowstr.h>
43
42
#include "glxext.h"
61
60
 
62
61
int __glXDispSwap_CreateContext(__GLXclientState *cl, GLbyte *pc)
63
62
{
 
63
    ClientPtr client = cl->client;
64
64
    xGLXCreateContextReq *req = (xGLXCreateContextReq *) pc;
65
65
    __GLX_DECLARE_SWAP_VARIABLES;
66
66
 
 
67
    REQUEST_SIZE_MATCH(xGLXCreateContextReq);
 
68
 
67
69
    __GLX_SWAP_SHORT(&req->length);
68
70
    __GLX_SWAP_INT(&req->context);
69
71
    __GLX_SWAP_INT(&req->visual);
75
77
 
76
78
int __glXDispSwap_CreateNewContext(__GLXclientState *cl, GLbyte *pc)
77
79
{
 
80
    ClientPtr client = cl->client;
78
81
    xGLXCreateNewContextReq *req = (xGLXCreateNewContextReq *) pc;
79
82
    __GLX_DECLARE_SWAP_VARIABLES;
80
83
 
 
84
    REQUEST_SIZE_MATCH(xGLXCreateNewContextReq);
 
85
 
81
86
    __GLX_SWAP_SHORT(&req->length);
82
87
    __GLX_SWAP_INT(&req->context);
83
88
    __GLX_SWAP_INT(&req->fbconfig);
90
95
 
91
96
int __glXDispSwap_CreateContextWithConfigSGIX(__GLXclientState *cl, GLbyte *pc)
92
97
{
 
98
    ClientPtr client = cl->client;
93
99
    xGLXCreateContextWithConfigSGIXReq *req =
94
100
        (xGLXCreateContextWithConfigSGIXReq *) pc;
95
101
    __GLX_DECLARE_SWAP_VARIABLES;
96
102
 
 
103
    REQUEST_SIZE_MATCH(xGLXCreateContextWithConfigSGIXReq);
 
104
 
97
105
    __GLX_SWAP_SHORT(&req->length);
98
106
    __GLX_SWAP_INT(&req->context);
99
107
    __GLX_SWAP_INT(&req->fbconfig);
106
114
 
107
115
int __glXDispSwap_DestroyContext(__GLXclientState *cl, GLbyte *pc)
108
116
{
 
117
    ClientPtr client = cl->client;
109
118
    xGLXDestroyContextReq *req = (xGLXDestroyContextReq *) pc;
110
119
    __GLX_DECLARE_SWAP_VARIABLES;
111
120
 
 
121
    REQUEST_SIZE_MATCH(xGLXDestroyContextReq);
 
122
 
112
123
    __GLX_SWAP_SHORT(&req->length);
113
124
    __GLX_SWAP_INT(&req->context);
114
125
 
117
128
 
118
129
int __glXDispSwap_MakeCurrent(__GLXclientState *cl, GLbyte *pc)
119
130
{
 
131
    ClientPtr client = cl->client;
120
132
    xGLXMakeCurrentReq *req = (xGLXMakeCurrentReq *) pc;
121
133
    __GLX_DECLARE_SWAP_VARIABLES;
122
134
 
 
135
    REQUEST_SIZE_MATCH(xGLXMakeCurrentReq);
 
136
 
123
137
    __GLX_SWAP_SHORT(&req->length);
124
138
    __GLX_SWAP_INT(&req->drawable);
125
139
    __GLX_SWAP_INT(&req->context);
130
144
 
131
145
int __glXDispSwap_MakeContextCurrent(__GLXclientState *cl, GLbyte *pc)
132
146
{
 
147
    ClientPtr client = cl->client;
133
148
    xGLXMakeContextCurrentReq *req = (xGLXMakeContextCurrentReq *) pc;
134
149
    __GLX_DECLARE_SWAP_VARIABLES;
135
150
 
 
151
    REQUEST_SIZE_MATCH(xGLXMakeContextCurrentReq);
 
152
 
136
153
    __GLX_SWAP_SHORT(&req->length);
137
154
    __GLX_SWAP_INT(&req->drawable);
138
155
    __GLX_SWAP_INT(&req->readdrawable);
144
161
 
145
162
int __glXDispSwap_MakeCurrentReadSGI(__GLXclientState *cl, GLbyte *pc)
146
163
{
 
164
    ClientPtr client = cl->client;
147
165
    xGLXMakeCurrentReadSGIReq *req = (xGLXMakeCurrentReadSGIReq *) pc;
148
166
    __GLX_DECLARE_SWAP_VARIABLES;
149
167
 
 
168
    REQUEST_SIZE_MATCH(xGLXMakeCurrentReadSGIReq);
 
169
 
150
170
    __GLX_SWAP_SHORT(&req->length);
151
171
    __GLX_SWAP_INT(&req->drawable);
152
172
    __GLX_SWAP_INT(&req->readable);
158
178
 
159
179
int __glXDispSwap_IsDirect(__GLXclientState *cl, GLbyte *pc)
160
180
{
 
181
    ClientPtr client = cl->client;
161
182
    xGLXIsDirectReq *req = (xGLXIsDirectReq *) pc;
162
183
    __GLX_DECLARE_SWAP_VARIABLES;
163
184
 
 
185
    REQUEST_SIZE_MATCH(xGLXIsDirectReq);
 
186
 
164
187
    __GLX_SWAP_SHORT(&req->length);
165
188
    __GLX_SWAP_INT(&req->context);
166
189
 
169
192
 
170
193
int __glXDispSwap_QueryVersion(__GLXclientState *cl, GLbyte *pc)
171
194
{
 
195
    ClientPtr client = cl->client;
172
196
    xGLXQueryVersionReq *req = (xGLXQueryVersionReq *) pc;
173
197
    __GLX_DECLARE_SWAP_VARIABLES;
174
198
 
 
199
    REQUEST_SIZE_MATCH(xGLXQueryVersionReq);
 
200
 
175
201
    __GLX_SWAP_SHORT(&req->length);
176
202
    __GLX_SWAP_INT(&req->majorVersion);
177
203
    __GLX_SWAP_INT(&req->minorVersion);
181
207
 
182
208
int __glXDispSwap_WaitGL(__GLXclientState *cl, GLbyte *pc)
183
209
{
 
210
    ClientPtr client = cl->client;
184
211
    xGLXWaitGLReq *req = (xGLXWaitGLReq *) pc;
185
212
    __GLX_DECLARE_SWAP_VARIABLES;
186
213
 
 
214
    REQUEST_SIZE_MATCH(xGLXWaitGLReq);
 
215
 
187
216
    __GLX_SWAP_SHORT(&req->length);
188
217
    __GLX_SWAP_INT(&req->contextTag);
189
218
 
192
221
 
193
222
int __glXDispSwap_WaitX(__GLXclientState *cl, GLbyte *pc)
194
223
{
 
224
    ClientPtr client = cl->client;
195
225
    xGLXWaitXReq *req = (xGLXWaitXReq *) pc;
196
226
    __GLX_DECLARE_SWAP_VARIABLES;
197
227
 
 
228
    REQUEST_SIZE_MATCH(xGLXWaitXReq);
 
229
 
198
230
    __GLX_SWAP_SHORT(&req->length);
199
231
    __GLX_SWAP_INT(&req->contextTag);
200
232
 
203
235
 
204
236
int __glXDispSwap_CopyContext(__GLXclientState *cl, GLbyte *pc)
205
237
{
 
238
    ClientPtr client = cl->client;
206
239
    xGLXCopyContextReq *req = (xGLXCopyContextReq *) pc;
207
240
    __GLX_DECLARE_SWAP_VARIABLES;
208
241
 
 
242
    REQUEST_SIZE_MATCH(xGLXCopyContextReq);
 
243
 
209
244
    __GLX_SWAP_SHORT(&req->length);
210
245
    __GLX_SWAP_INT(&req->source);
211
246
    __GLX_SWAP_INT(&req->dest);
216
251
 
217
252
int __glXDispSwap_GetVisualConfigs(__GLXclientState *cl, GLbyte *pc)
218
253
{
 
254
    ClientPtr client = cl->client;
219
255
    xGLXGetVisualConfigsReq *req = (xGLXGetVisualConfigsReq *) pc;
220
256
    __GLX_DECLARE_SWAP_VARIABLES;
221
257
 
 
258
    REQUEST_SIZE_MATCH(xGLXGetVisualConfigsReq);
 
259
 
222
260
    __GLX_SWAP_INT(&req->screen);
223
261
    return __glXDisp_GetVisualConfigs(cl, pc);
224
262
}
225
263
 
226
264
int __glXDispSwap_GetFBConfigs(__GLXclientState *cl, GLbyte *pc)
227
265
{
 
266
    ClientPtr client = cl->client;
228
267
    xGLXGetFBConfigsReq *req = (xGLXGetFBConfigsReq *) pc;
229
268
    __GLX_DECLARE_SWAP_VARIABLES;
230
269
 
 
270
    REQUEST_SIZE_MATCH(xGLXGetFBConfigsReq);
 
271
 
231
272
    __GLX_SWAP_INT(&req->screen);
232
273
    return __glXDisp_GetFBConfigs(cl, pc);
233
274
}
234
275
 
235
276
int __glXDispSwap_GetFBConfigsSGIX(__GLXclientState *cl, GLbyte *pc)
236
277
{
 
278
    ClientPtr client = cl->client;
237
279
    xGLXGetFBConfigsSGIXReq *req = (xGLXGetFBConfigsSGIXReq *) pc;
238
280
    __GLX_DECLARE_SWAP_VARIABLES;
239
281
 
 
282
    REQUEST_SIZE_MATCH(xGLXGetFBConfigsSGIXReq);
 
283
 
240
284
    __GLX_SWAP_INT(&req->screen);
241
285
    return __glXDisp_GetFBConfigsSGIX(cl, pc);
242
286
}
243
287
 
244
288
int __glXDispSwap_CreateGLXPixmap(__GLXclientState *cl, GLbyte *pc)
245
289
{
 
290
    ClientPtr client = cl->client;
246
291
    xGLXCreateGLXPixmapReq *req = (xGLXCreateGLXPixmapReq *) pc;
247
292
    __GLX_DECLARE_SWAP_VARIABLES;
248
293
 
 
294
    REQUEST_SIZE_MATCH(xGLXCreateGLXPixmapReq);
 
295
 
249
296
    __GLX_SWAP_SHORT(&req->length);
250
297
    __GLX_SWAP_INT(&req->screen);
251
298
    __GLX_SWAP_INT(&req->visual);
257
304
 
258
305
int __glXDispSwap_CreatePixmap(__GLXclientState *cl, GLbyte *pc)
259
306
{
 
307
    ClientPtr client = cl->client;
260
308
    xGLXCreatePixmapReq *req = (xGLXCreatePixmapReq *) pc;
261
309
    CARD32 *attribs;
262
310
    __GLX_DECLARE_SWAP_VARIABLES;
263
311
    __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
264
312
 
 
313
    REQUEST_AT_LEAST_SIZE(xGLXCreatePixmapReq);
 
314
 
265
315
    __GLX_SWAP_SHORT(&req->length);
266
316
    __GLX_SWAP_INT(&req->screen);
267
317
    __GLX_SWAP_INT(&req->fbconfig);
268
318
    __GLX_SWAP_INT(&req->pixmap);
269
319
    __GLX_SWAP_INT(&req->glxpixmap);
270
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);
271
327
    attribs = (CARD32*)(req + 1);
272
 
    __GLX_SWAP_INT_ARRAY(attribs, req->numAttribs);
 
328
    __GLX_SWAP_INT_ARRAY(attribs, req->numAttribs << 1);
273
329
 
274
330
    return __glXDisp_CreatePixmap(cl, pc);
275
331
}
276
332
 
277
333
int __glXDispSwap_CreateGLXPixmapWithConfigSGIX(__GLXclientState *cl, GLbyte *pc)
278
334
{
 
335
    ClientPtr client = cl->client;
279
336
    xGLXCreateGLXPixmapWithConfigSGIXReq *req = 
280
337
        (xGLXCreateGLXPixmapWithConfigSGIXReq *) pc;
281
338
    __GLX_DECLARE_SWAP_VARIABLES;
282
339
 
 
340
    REQUEST_SIZE_MATCH(xGLXCreateGLXPixmapWithConfigSGIXReq);
 
341
 
283
342
    __GLX_SWAP_SHORT(&req->length);
284
343
    __GLX_SWAP_INT(&req->screen);
285
344
    __GLX_SWAP_INT(&req->fbconfig);
291
350
 
292
351
int __glXDispSwap_DestroyGLXPixmap(__GLXclientState *cl, GLbyte *pc)
293
352
{
 
353
    ClientPtr client = cl->client;
294
354
    xGLXDestroyGLXPixmapReq *req = (xGLXDestroyGLXPixmapReq *) pc;
295
355
    __GLX_DECLARE_SWAP_VARIABLES;
296
356
 
 
357
    REQUEST_SIZE_MATCH(xGLXDestroyGLXPixmapReq);
 
358
 
297
359
    __GLX_SWAP_SHORT(&req->length);
298
360
    __GLX_SWAP_INT(&req->glxpixmap);
299
361
 
302
364
 
303
365
int __glXDispSwap_DestroyPixmap(__GLXclientState *cl, GLbyte *pc)
304
366
{
 
367
    ClientPtr client = cl->client;
305
368
    xGLXDestroyGLXPixmapReq *req = (xGLXDestroyGLXPixmapReq *) pc;
306
369
    __GLX_DECLARE_SWAP_VARIABLES;
307
370
 
 
371
    REQUEST_SIZE_MATCH(xGLXDestroyGLXPixmapReq);
 
372
 
308
373
    __GLX_SWAP_SHORT(&req->length);
309
374
    __GLX_SWAP_INT(&req->glxpixmap);
310
375
 
313
378
 
314
379
int __glXDispSwap_QueryContext(__GLXclientState *cl, GLbyte *pc)
315
380
{
 
381
    ClientPtr client = cl->client;
316
382
    xGLXQueryContextReq *req = (xGLXQueryContextReq *) pc;    
317
383
    __GLX_DECLARE_SWAP_VARIABLES;
318
384
 
 
385
    REQUEST_SIZE_MATCH(xGLXQueryContextReq);
 
386
 
319
387
    __GLX_SWAP_INT(&req->context);
320
388
 
321
389
    return __glXDisp_QueryContext(cl, pc);
323
391
 
324
392
int __glXDispSwap_CreatePbuffer(__GLXclientState *cl, GLbyte *pc)
325
393
{
 
394
    ClientPtr client = cl->client;
326
395
    xGLXCreatePbufferReq *req = (xGLXCreatePbufferReq *) pc;    
327
396
    __GLX_DECLARE_SWAP_VARIABLES;
328
397
    __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
329
398
    CARD32 *attribs;
330
399
 
 
400
    REQUEST_AT_LEAST_SIZE(xGLXCreatePbufferReq);
 
401
 
331
402
    __GLX_SWAP_INT(&req->screen);
332
403
    __GLX_SWAP_INT(&req->fbconfig);
333
404
    __GLX_SWAP_INT(&req->pbuffer);
334
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);
335
412
    attribs = (CARD32*)(req + 1);
336
 
    __GLX_SWAP_INT_ARRAY(attribs, req->numAttribs);
 
413
    __GLX_SWAP_INT_ARRAY(attribs, req->numAttribs << 1);
337
414
 
338
415
    return __glXDisp_CreatePbuffer(cl, pc);
339
416
}
340
417
 
341
418
int __glXDispSwap_CreateGLXPbufferSGIX(__GLXclientState *cl, GLbyte *pc)
342
419
{
 
420
    ClientPtr client = cl->client;
343
421
    xGLXCreateGLXPbufferSGIXReq *req = (xGLXCreateGLXPbufferSGIXReq *) pc;    
344
422
    __GLX_DECLARE_SWAP_VARIABLES;
345
423
 
 
424
    REQUEST_SIZE_MATCH(xGLXCreateGLXPbufferSGIXReq);
 
425
 
346
426
    __GLX_SWAP_INT(&req->screen);
347
427
    __GLX_SWAP_INT(&req->fbconfig);
348
428
    __GLX_SWAP_INT(&req->pbuffer);
354
434
 
355
435
int __glXDispSwap_DestroyPbuffer(__GLXclientState *cl, GLbyte *pc)
356
436
{
 
437
    ClientPtr client = cl->client;
357
438
    xGLXDestroyPbufferReq *req = (xGLXDestroyPbufferReq *) pc;
358
439
    __GLX_DECLARE_SWAP_VARIABLES;
359
440
 
 
441
    REQUEST_SIZE_MATCH(xGLXDestroyPbufferReq);
 
442
 
360
443
    __GLX_SWAP_INT(&req->pbuffer);
361
444
 
362
445
    return __glXDisp_DestroyPbuffer(cl, pc);
364
447
 
365
448
int __glXDispSwap_DestroyGLXPbufferSGIX(__GLXclientState *cl, GLbyte *pc)
366
449
{
 
450
    ClientPtr client = cl->client;
367
451
    xGLXDestroyGLXPbufferSGIXReq *req = (xGLXDestroyGLXPbufferSGIXReq *) pc;
368
452
    __GLX_DECLARE_SWAP_VARIABLES;
369
453
 
 
454
    REQUEST_SIZE_MATCH(xGLXDestroyGLXPbufferSGIXReq);
 
455
 
370
456
    __GLX_SWAP_INT(&req->pbuffer);
371
457
 
372
458
    return __glXDisp_DestroyGLXPbufferSGIX(cl, pc);
374
460
 
375
461
int __glXDispSwap_ChangeDrawableAttributes(__GLXclientState *cl, GLbyte *pc)
376
462
{
 
463
    ClientPtr client = cl->client;
377
464
    xGLXChangeDrawableAttributesReq *req =
378
465
        (xGLXChangeDrawableAttributesReq *) pc;
379
466
    __GLX_DECLARE_SWAP_VARIABLES;
380
467
    __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
381
468
    CARD32 *attribs;
382
469
 
 
470
    REQUEST_AT_LEAST_SIZE(xGLXChangeDrawableAttributesReq);
 
471
 
383
472
    __GLX_SWAP_INT(&req->drawable);
384
473
    __GLX_SWAP_INT(&req->numAttribs);
 
474
 
 
475
    if (req->numAttribs > (UINT32_MAX >> 3)) {
 
476
        client->errorValue = req->numAttribs;
 
477
        return BadValue;
 
478
    }
 
479
    REQUEST_FIXED_SIZE(xGLXChangeDrawableAttributesReq, req->numAttribs << 3);
385
480
    attribs = (CARD32*)(req + 1);
386
 
    __GLX_SWAP_INT_ARRAY(attribs, req->numAttribs);
 
481
    __GLX_SWAP_INT_ARRAY(attribs, req->numAttribs << 1);
387
482
 
388
483
    return __glXDisp_ChangeDrawableAttributes(cl, pc);
389
484
}
391
486
int __glXDispSwap_ChangeDrawableAttributesSGIX(__GLXclientState *cl,
392
487
                                               GLbyte *pc)
393
488
{
 
489
    ClientPtr client = cl->client;
394
490
    xGLXChangeDrawableAttributesSGIXReq *req =
395
491
        (xGLXChangeDrawableAttributesSGIXReq *) pc;
396
492
    __GLX_DECLARE_SWAP_VARIABLES;
397
493
    __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
398
494
    CARD32 *attribs;
399
495
 
 
496
    REQUEST_AT_LEAST_SIZE(xGLXChangeDrawableAttributesSGIXReq);
 
497
 
400
498
    __GLX_SWAP_INT(&req->drawable);
401
499
    __GLX_SWAP_INT(&req->numAttribs);
 
500
 
 
501
    if (req->numAttribs > (UINT32_MAX >> 3)) {
 
502
        client->errorValue = req->numAttribs;
 
503
        return BadValue;
 
504
    }
 
505
    REQUEST_FIXED_SIZE(xGLXChangeDrawableAttributesSGIXReq, req->numAttribs << 3);
402
506
    attribs = (CARD32*)(req + 1);
403
 
    __GLX_SWAP_INT_ARRAY(attribs, req->numAttribs);
 
507
    __GLX_SWAP_INT_ARRAY(attribs, req->numAttribs << 1);
404
508
 
405
509
    return __glXDisp_ChangeDrawableAttributesSGIX(cl, pc);
406
510
}
407
511
 
408
512
int __glXDispSwap_CreateWindow(__GLXclientState *cl, GLbyte *pc)
409
513
{
 
514
    ClientPtr client = cl->client;
410
515
    xGLXCreateWindowReq *req = (xGLXCreateWindowReq *) pc;
411
516
    __GLX_DECLARE_SWAP_VARIABLES;
412
517
    __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
413
518
    CARD32 *attribs;
414
519
 
 
520
    REQUEST_AT_LEAST_SIZE(xGLXCreateWindowReq);
 
521
 
415
522
    __GLX_SWAP_INT(&req->screen);
416
523
    __GLX_SWAP_INT(&req->fbconfig);
417
524
    __GLX_SWAP_INT(&req->window);
418
525
    __GLX_SWAP_INT(&req->glxwindow);
419
526
    __GLX_SWAP_INT(&req->numAttribs);
 
527
 
 
528
    if (req->numAttribs > (UINT32_MAX >> 3)) {
 
529
        client->errorValue = req->numAttribs;
 
530
        return BadValue;
 
531
    }
 
532
    REQUEST_FIXED_SIZE(xGLXCreateWindowReq, req->numAttribs << 3);
420
533
    attribs = (CARD32*)(req + 1);
421
 
    __GLX_SWAP_INT_ARRAY(attribs, req->numAttribs);
 
534
    __GLX_SWAP_INT_ARRAY(attribs, req->numAttribs << 1);
422
535
 
423
536
    return __glXDisp_CreateWindow(cl, pc);
424
537
}
425
538
 
426
539
int __glXDispSwap_DestroyWindow(__GLXclientState *cl, GLbyte *pc)
427
540
{
 
541
    ClientPtr client = cl->client;
428
542
    xGLXDestroyWindowReq *req = (xGLXDestroyWindowReq *) pc;
429
543
    __GLX_DECLARE_SWAP_VARIABLES;
430
544
 
 
545
    REQUEST_SIZE_MATCH(xGLXDestroyWindowReq);
 
546
 
431
547
    __GLX_SWAP_INT(&req->glxwindow);
432
548
 
433
549
    return __glXDisp_DestroyWindow(cl, pc);
435
551
 
436
552
int __glXDispSwap_SwapBuffers(__GLXclientState *cl, GLbyte *pc)
437
553
{
 
554
    ClientPtr client = cl->client;
438
555
    xGLXSwapBuffersReq *req = (xGLXSwapBuffersReq *) pc;
439
556
    __GLX_DECLARE_SWAP_VARIABLES;
440
557
 
 
558
    REQUEST_SIZE_MATCH(xGLXSwapBuffersReq);
 
559
 
441
560
    __GLX_SWAP_SHORT(&req->length);
442
561
    __GLX_SWAP_INT(&req->contextTag);
443
562
    __GLX_SWAP_INT(&req->drawable);
447
566
 
448
567
int __glXDispSwap_UseXFont(__GLXclientState *cl, GLbyte *pc)
449
568
{
 
569
    ClientPtr client = cl->client;
450
570
    xGLXUseXFontReq *req = (xGLXUseXFontReq *) pc;
451
571
    __GLX_DECLARE_SWAP_VARIABLES;
452
572
 
 
573
    REQUEST_SIZE_MATCH(xGLXUseXFontReq);
 
574
 
453
575
    __GLX_SWAP_SHORT(&req->length);
454
576
    __GLX_SWAP_INT(&req->contextTag);
455
577
    __GLX_SWAP_INT(&req->font);
463
585
 
464
586
int __glXDispSwap_QueryExtensionsString(__GLXclientState *cl, GLbyte *pc)
465
587
{
 
588
    ClientPtr client = cl->client;
466
589
    xGLXQueryExtensionsStringReq *req = (xGLXQueryExtensionsStringReq *)pc;
467
590
    __GLX_DECLARE_SWAP_VARIABLES;
468
591
 
 
592
    REQUEST_SIZE_MATCH(xGLXQueryExtensionsStringReq);
 
593
 
469
594
    __GLX_SWAP_SHORT(&req->length);
470
595
    __GLX_SWAP_INT(&req->screen);
471
596
 
474
599
 
475
600
int __glXDispSwap_QueryServerString(__GLXclientState *cl, GLbyte *pc)
476
601
{
 
602
    ClientPtr client = cl->client;
477
603
    xGLXQueryServerStringReq *req = (xGLXQueryServerStringReq *)pc;
478
604
    __GLX_DECLARE_SWAP_VARIABLES;
479
605
 
 
606
    REQUEST_SIZE_MATCH(xGLXQueryServerStringReq);
 
607
 
480
608
    __GLX_SWAP_SHORT(&req->length);
481
609
    __GLX_SWAP_INT(&req->screen);
482
610
    __GLX_SWAP_INT(&req->name);
486
614
 
487
615
int __glXDispSwap_ClientInfo(__GLXclientState *cl, GLbyte *pc)
488
616
{
 
617
    ClientPtr client = cl->client;
489
618
    xGLXClientInfoReq *req = (xGLXClientInfoReq *)pc;
490
619
    __GLX_DECLARE_SWAP_VARIABLES;
491
620
 
 
621
    REQUEST_AT_LEAST_SIZE(xGLXClientInfoReq);
 
622
 
492
623
    __GLX_SWAP_SHORT(&req->length);
493
624
    __GLX_SWAP_INT(&req->major);
494
625
    __GLX_SWAP_INT(&req->minor);
499
630
 
500
631
int __glXDispSwap_QueryContextInfoEXT(__GLXclientState *cl, GLbyte *pc)
501
632
{
 
633
    ClientPtr client = cl->client;
502
634
    xGLXQueryContextInfoEXTReq *req = (xGLXQueryContextInfoEXTReq *) pc;
503
635
    __GLX_DECLARE_SWAP_VARIABLES;
504
636
 
 
637
    REQUEST_SIZE_MATCH(xGLXQueryContextInfoEXTReq);
 
638
 
505
639
    __GLX_SWAP_SHORT(&req->length);
506
640
    __GLX_SWAP_INT(&req->context);
507
641
 
510
644
 
511
645
int __glXDispSwap_BindTexImageEXT(__GLXclientState *cl, GLbyte *pc)
512
646
{
 
647
    ClientPtr client = cl->client;
513
648
    xGLXVendorPrivateReq *req = (xGLXVendorPrivateReq *) pc;
514
649
    GLXDrawable          *drawId;
515
650
    int                  *buffer;
516
 
    
517
651
    __GLX_DECLARE_SWAP_VARIABLES;
518
652
 
 
653
    REQUEST_FIXED_SIZE(xGLXVendorPrivateReq, 8);
 
654
 
519
655
    pc += __GLX_VENDPRIV_HDR_SIZE;
520
656
 
521
657
    drawId = ((GLXDrawable *) (pc));
531
667
 
532
668
int __glXDispSwap_ReleaseTexImageEXT(__GLXclientState *cl, GLbyte *pc)
533
669
{
 
670
    ClientPtr client = cl->client;
534
671
    xGLXVendorPrivateReq *req = (xGLXVendorPrivateReq *) pc;
535
672
    GLXDrawable          *drawId;
536
673
    int                  *buffer;
537
 
    
538
674
    __GLX_DECLARE_SWAP_VARIABLES;
539
675
 
 
676
    REQUEST_FIXED_SIZE(xGLXVendorPrivateReq, 8);
 
677
 
540
678
    pc += __GLX_VENDPRIV_HDR_SIZE;
541
679
 
542
680
    drawId = ((GLXDrawable *) (pc));
552
690
 
553
691
int __glXDispSwap_CopySubBufferMESA(__GLXclientState *cl, GLbyte *pc)
554
692
{
 
693
    ClientPtr client = cl->client;
555
694
    xGLXVendorPrivateReq *req = (xGLXVendorPrivateReq *) pc;
556
695
    GLXDrawable          *drawId;
557
696
    int                  *buffer;
558
 
 
559
697
    __GLX_DECLARE_SWAP_VARIABLES;
560
698
 
 
699
    REQUEST_FIXED_SIZE(xGLXVendorPrivateReq, 20);
 
700
 
561
701
    (void) drawId;
562
702
    (void) buffer;
563
703
 
577
717
 
578
718
int __glXDispSwap_GetDrawableAttributesSGIX(__GLXclientState *cl, GLbyte *pc)
579
719
{
 
720
    ClientPtr client = cl->client;
580
721
    xGLXVendorPrivateWithReplyReq *req = (xGLXVendorPrivateWithReplyReq *)pc;
581
722
    CARD32 *data;
582
 
    
583
723
    __GLX_DECLARE_SWAP_VARIABLES;
584
724
 
 
725
    REQUEST_SIZE_MATCH(xGLXGetDrawableAttributesSGIXReq);
 
726
 
585
727
    data = (CARD32 *) (req + 1);
586
728
    __GLX_SWAP_SHORT(&req->length);
587
729
    __GLX_SWAP_INT(&req->contextTag);
592
734
 
593
735
int __glXDispSwap_GetDrawableAttributes(__GLXclientState *cl, GLbyte *pc)
594
736
{
 
737
    ClientPtr client = cl->client;
595
738
    xGLXGetDrawableAttributesReq *req = (xGLXGetDrawableAttributesReq *)pc;
596
 
    
597
739
    __GLX_DECLARE_SWAP_VARIABLES;
598
740
 
 
741
    REQUEST_SIZE_MATCH(xGLXGetDrawableAttributesReq);
 
742
 
599
743
    __GLX_SWAP_SHORT(&req->length);
600
744
    __GLX_SWAP_INT(&req->drawable);
601
745