glx/glxcmdsswap.c

   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 }