![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to swaprep.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv9 / X11 / src / X.V11R1 / server / dix|
Return to swaprep.c CVS log | Up to [Research Unix] / researchv9 / X11 / src / X.V11R1 / server / dix |
1.1 ! root 1: /************************************************************ ! 2: Copyright 1987 by Digital Equipment Corporation, Maynard, Massachusetts, ! 3: and the Massachusetts Institute of Technology, Cambridge, Massachusetts. ! 4: ! 5: All Rights Reserved ! 6: ! 7: Permission to use, copy, modify, and distribute this software and its ! 8: documentation for any purpose and without fee is hereby granted, ! 9: provided that the above copyright notice appear in all copies and that ! 10: both that copyright notice and this permission notice appear in ! 11: supporting documentation, and that the names of Digital or MIT not be ! 12: used in advertising or publicity pertaining to distribution of the ! 13: software without specific, written prior permission. ! 14: ! 15: DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ! 16: ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL ! 17: DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ! 18: ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, ! 19: WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ! 20: ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS ! 21: SOFTWARE. ! 22: ! 23: ********************************************************/ ! 24: ! 25: /* $Header: swaprep.c,v 1.27 87/09/05 17:57:32 toddb Exp $ */ ! 26: ! 27: #include "X.h" ! 28: #define NEED_REPLIES ! 29: #define NEED_EVENTS ! 30: #include "Xproto.h" ! 31: #include "misc.h" ! 32: #include "dixstruct.h" ! 33: #include "scrnintstr.h" ! 34: ! 35: void SwapVisual(), SwapConnSetup(), SwapWinRoot(), WriteToClient(); ! 36: ! 37: /* copy long from src to dst byteswapping on the way */ ! 38: #define cpswapl(src, dst) \ ! 39: ((char *)&(dst))[0] = ((char *) &(src))[3];\ ! 40: ((char *)&(dst))[1] = ((char *) &(src))[2];\ ! 41: ((char *)&(dst))[2] = ((char *) &(src))[1];\ ! 42: ((char *)&(dst))[3] = ((char *) &(src))[0]; ! 43: ! 44: /* copy short from src to dst byteswapping on the way */ ! 45: #define cpswaps(src, dst)\ ! 46: ((char *) &(dst))[0] = ((char *) &(src))[1];\ ! 47: ((char *) &(dst))[1] = ((char *) &(src))[0]; ! 48: ! 49: /* Thanks to Jack Palevich for testing and subsequently rewriting all this */ ! 50: void ! 51: Swap32Write(pClient, size, pbuf) ! 52: ClientPtr pClient; ! 53: int size; /* in bytes */ ! 54: register long *pbuf; ! 55: { ! 56: int n, i; ! 57: ! 58: size >>= 2; ! 59: for(i = 0; i < size; i++) ! 60: /* brackets are mandatory here, because "swapl" macro expands ! 61: to several statements */ ! 62: { ! 63: swapl(&pbuf[i], n); ! 64: } ! 65: WriteToClient(pClient, size << 2, (char *) pbuf); ! 66: } ! 67: ! 68: void ! 69: CopySwap32Write(pClient, size, pbuf) ! 70: ClientPtr pClient; ! 71: int size; /* in bytes */ ! 72: long *pbuf; ! 73: { ! 74: int bufsize = size; ! 75: long *pbufT; ! 76: register long *from, *to, *fromLast, *toLast; ! 77: ! 78: /* Allocate as big a buffer as we can... */ ! 79: while ((pbufT = (long *) ALLOCATE_LOCAL(bufsize)) == NULL) ! 80: bufsize >>= 1; ! 81: ! 82: /* convert lengths from # of bytes to # of longs */ ! 83: size >>= 2; ! 84: bufsize >>= 2; ! 85: ! 86: from = pbuf; ! 87: fromLast = from + size; ! 88: while (from < fromLast) { ! 89: int nbytes; ! 90: to = pbufT; ! 91: toLast = to + min (bufsize, fromLast - from); ! 92: nbytes = (toLast - to) << 2; ! 93: while (to < toLast) { ! 94: /* can't write "cpswapl(*from++, *to++)" because cpswapl is a macro ! 95: that evaulates its args more than once */ ! 96: cpswapl(*from, *to); ! 97: from++; ! 98: to++; ! 99: } ! 100: WriteToClient (pClient, nbytes, (char *) pbufT); ! 101: } ! 102: ! 103: DEALLOCATE_LOCAL ((char *) pbufT); ! 104: } ! 105: ! 106: void ! 107: CopySwap16Write(pClient, size, pbuf) ! 108: ClientPtr pClient; ! 109: int size; /* in bytes */ ! 110: short *pbuf; ! 111: { ! 112: int bufsize = size; ! 113: short *pbufT; ! 114: register short *from, *to, *fromLast, *toLast; ! 115: ! 116: /* Allocate as big a buffer as we can... */ ! 117: while ((pbufT = (short *) ALLOCATE_LOCAL(bufsize)) == NULL) ! 118: bufsize >>= 1; ! 119: ! 120: /* convert lengths from # of bytes to # of shorts */ ! 121: size >>= 1; ! 122: bufsize >>= 1; ! 123: ! 124: from = pbuf; ! 125: fromLast = from + size; ! 126: while (from < fromLast) { ! 127: int nbytes; ! 128: to = pbufT; ! 129: toLast = to + min (bufsize, fromLast - from); ! 130: nbytes = (toLast - to) << 1; ! 131: while (to < toLast) { ! 132: /* can't write "cpswaps(*from++, *to++)" because cpswaps is a macro ! 133: that evaulates its args more than once */ ! 134: cpswaps(*from, *to); ! 135: from++; ! 136: to++; ! 137: } ! 138: WriteToClient (pClient, nbytes, (char *) pbufT); ! 139: } ! 140: ! 141: DEALLOCATE_LOCAL ((char *) pbufT); ! 142: } ! 143: ! 144: ! 145: /* Extra-small reply */ ! 146: void ! 147: SGenericReply(pClient, size, pRep) ! 148: ClientPtr pClient; ! 149: int size; ! 150: xGenericReply *pRep; ! 151: { ! 152: int n; ! 153: ! 154: swaps(&pRep->sequenceNumber, n); ! 155: WriteToClient(pClient, size, (char *) pRep); ! 156: } ! 157: ! 158: /* Extra-large reply */ ! 159: void ! 160: SGetWindowAttributesReply(pClient, size, pRep) ! 161: ClientPtr pClient; ! 162: int size; ! 163: xGetWindowAttributesReply *pRep; ! 164: { ! 165: int n; ! 166: ! 167: swaps(&pRep->sequenceNumber, n); ! 168: swapl(&pRep->length, n); ! 169: swapl(&pRep->visualID, n); ! 170: swaps(&pRep->class, n); ! 171: swapl(&pRep->backingBitPlanes, n); ! 172: swapl(&pRep->backingPixel, n); ! 173: swapl(&pRep->colormap, n); ! 174: swapl(&pRep->allEventMasks, n); ! 175: swapl(&pRep->yourEventMask, n); ! 176: swaps(&pRep->doNotPropagateMask, n); ! 177: WriteToClient(pClient, size, (char *) pRep); ! 178: } ! 179: ! 180: void ! 181: SGetGeometryReply(pClient, size, pRep) ! 182: ClientPtr pClient; ! 183: int size; ! 184: xGetGeometryReply *pRep; ! 185: { ! 186: int n; ! 187: ! 188: swaps(&pRep->sequenceNumber, n); ! 189: swapl(&pRep->root, n); ! 190: swaps(&pRep->x, n); ! 191: swaps(&pRep->y, n); ! 192: swaps(&pRep->width, n); ! 193: swaps(&pRep->height, n); ! 194: swaps(&pRep->borderWidth, n); ! 195: WriteToClient(pClient, size, (char *) pRep); ! 196: } ! 197: ! 198: void ! 199: SQueryTreeReply(pClient, size, pRep) ! 200: ClientPtr pClient; ! 201: int size; ! 202: xQueryTreeReply *pRep; ! 203: { ! 204: int n; ! 205: ! 206: swaps(&pRep->sequenceNumber, n); ! 207: swapl(&pRep->length, n); ! 208: swapl(&pRep->root, n); ! 209: swapl(&pRep->parent, n); ! 210: swaps(&pRep->nChildren, n); ! 211: WriteToClient(pClient, size, (char *) pRep); ! 212: } ! 213: ! 214: void ! 215: SInternAtomReply(pClient, size, pRep) ! 216: ClientPtr pClient; ! 217: int size; ! 218: xInternAtomReply *pRep; ! 219: { ! 220: int n; ! 221: ! 222: swaps(&pRep->sequenceNumber, n); ! 223: swapl(&pRep->atom, n); ! 224: WriteToClient(pClient, size, (char *) pRep); ! 225: } ! 226: ! 227: void ! 228: SGetAtomNameReply(pClient, size, pRep) ! 229: ClientPtr pClient; ! 230: int size; ! 231: xGetAtomNameReply *pRep; ! 232: { ! 233: int n; ! 234: ! 235: swaps(&pRep->sequenceNumber, n); ! 236: swapl(&pRep->length, n); ! 237: swaps(&pRep->nameLength, n); ! 238: WriteToClient(pClient, size, (char *) pRep); ! 239: } ! 240: ! 241: ! 242: void ! 243: SGetPropertyReply(pClient, size, pRep) ! 244: ClientPtr pClient; ! 245: int size; ! 246: xGetPropertyReply *pRep; ! 247: { ! 248: int n; ! 249: ! 250: swaps(&pRep->sequenceNumber, n); ! 251: swapl(&pRep->length, n); ! 252: swapl(&pRep->propertyType, n); ! 253: swapl(&pRep->bytesAfter, n); ! 254: swapl(&pRep->nItems, n); ! 255: WriteToClient(pClient, size, (char *) pRep); ! 256: } ! 257: ! 258: void ! 259: SListPropertiesReply(pClient, size, pRep) ! 260: ClientPtr pClient; ! 261: int size; ! 262: xListPropertiesReply *pRep; ! 263: { ! 264: int n; ! 265: ! 266: swaps(&pRep->sequenceNumber, n); ! 267: swapl(&pRep->length, n); ! 268: swaps(&pRep->nProperties, n); ! 269: WriteToClient(pClient, size, (char *) pRep); ! 270: } ! 271: ! 272: void ! 273: SGetSelectionOwnerReply(pClient, size, pRep) ! 274: ClientPtr pClient; ! 275: int size; ! 276: xGetSelectionOwnerReply *pRep; ! 277: { ! 278: int n; ! 279: ! 280: swaps(&pRep->sequenceNumber, n); ! 281: swapl(&pRep->owner, n); ! 282: WriteToClient(pClient, size, (char *) pRep); ! 283: } ! 284: ! 285: ! 286: void ! 287: SQueryPointerReply(pClient, size, pRep) ! 288: ClientPtr pClient; ! 289: int size; ! 290: xQueryPointerReply *pRep; ! 291: { ! 292: int n; ! 293: ! 294: swaps(&pRep->sequenceNumber, n); ! 295: swapl(&pRep->root, n); ! 296: swapl(&pRep->child, n); ! 297: swaps(&pRep->rootX, n); ! 298: swaps(&pRep->rootY, n); ! 299: swaps(&pRep->winX, n); ! 300: swaps(&pRep->winY, n); ! 301: swaps(&pRep->mask, n); ! 302: WriteToClient(pClient, size, (char *) pRep); ! 303: } ! 304: ! 305: void ! 306: SwapTimeCoordWrite(pClient, size, pRep) ! 307: ClientPtr pClient; ! 308: int size; ! 309: xTimecoord *pRep; ! 310: { ! 311: int i, n; ! 312: xTimecoord *pRepT; ! 313: ! 314: n = size / sizeof(xTimecoord); ! 315: pRepT = pRep; ! 316: for(i = 0; i < n; i++) ! 317: { ! 318: SwapTimecoord(pRepT); ! 319: pRepT++; ! 320: } ! 321: WriteToClient(pClient, size, (char *) pRep); ! 322: ! 323: } ! 324: void ! 325: SGetMotionEventsReply(pClient, size, pRep) ! 326: ClientPtr pClient; ! 327: int size; ! 328: xGetMotionEventsReply *pRep; ! 329: { ! 330: int n; ! 331: ! 332: swaps(&pRep->sequenceNumber, n); ! 333: swapl(&pRep->length, n); ! 334: swapl(&pRep->nEvents, n); ! 335: WriteToClient(pClient, size, (char *) pRep); ! 336: } ! 337: ! 338: void ! 339: STranslateCoordsReply(pClient, size, pRep) ! 340: ClientPtr pClient; ! 341: int size; ! 342: xTranslateCoordsReply *pRep; ! 343: { ! 344: int n; ! 345: ! 346: swaps(&pRep->sequenceNumber, n); ! 347: swapl(&pRep->child, n); ! 348: swaps(&pRep->dstX, n); ! 349: swaps(&pRep->dstY, n); ! 350: WriteToClient(pClient, size, (char *) pRep); ! 351: } ! 352: ! 353: void ! 354: SGetInputFocusReply(pClient, size, pRep) ! 355: ClientPtr pClient; ! 356: int size; ! 357: xGetInputFocusReply *pRep; ! 358: { ! 359: int n; ! 360: ! 361: swaps(&pRep->sequenceNumber, n); ! 362: swapl(&pRep->focus, n); ! 363: WriteToClient(pClient, size, (char *) pRep); ! 364: } ! 365: ! 366: /* extra long reply */ ! 367: void ! 368: SQueryKeymapReply(pClient, size, pRep) ! 369: ClientPtr pClient; ! 370: int size; ! 371: xQueryKeymapReply *pRep; ! 372: { ! 373: int n; ! 374: ! 375: swaps(&pRep->sequenceNumber, n); ! 376: swapl(&pRep->length, n); ! 377: WriteToClient(pClient, size, (char *) pRep); ! 378: } ! 379: ! 380: void ! 381: SQueryFontReply(pClient, size, pRep) ! 382: ClientPtr pClient; ! 383: int size; ! 384: xQueryFontReply *pRep; ! 385: { ! 386: SwapFont(pRep, TRUE); ! 387: WriteToClient(pClient, size, (char *) pRep); ! 388: } ! 389: ! 390: void ! 391: SQueryTextExtentsReply(pClient, size, pRep) ! 392: ClientPtr pClient; ! 393: int size; ! 394: xQueryTextExtentsReply *pRep; ! 395: { ! 396: int n; ! 397: ! 398: swaps(&pRep->sequenceNumber, n); ! 399: swaps(&pRep->fontAscent, n); ! 400: swaps(&pRep->fontDescent, n); ! 401: swaps(&pRep->overallAscent, n); ! 402: swaps(&pRep->overallDescent, n); ! 403: swapl(&pRep->overallWidth, n); ! 404: swapl(&pRep->overallLeft, n); ! 405: swapl(&pRep->overallRight, n); ! 406: WriteToClient(pClient, size, (char *) pRep); ! 407: } ! 408: ! 409: void ! 410: SListFontsReply(pClient, size, pRep) ! 411: ClientPtr pClient; ! 412: int size; ! 413: xListFontsReply *pRep; ! 414: { ! 415: int n; ! 416: ! 417: swaps(&pRep->sequenceNumber, n); ! 418: swapl(&pRep->length, n); ! 419: swaps(&pRep->nFonts, n); ! 420: WriteToClient(pClient, size, (char *) pRep); ! 421: } ! 422: ! 423: void ! 424: SListFontsWithInfoReply(pClient, size, pRep) ! 425: ClientPtr pClient; ! 426: int size; ! 427: xListFontsWithInfoReply *pRep; ! 428: { ! 429: SwapFont((xQueryFontReply *)pRep, FALSE); ! 430: WriteToClient(pClient, size, (char *) pRep); ! 431: } ! 432: ! 433: void ! 434: SGetFontPathReply(pClient, size, pRep) ! 435: ClientPtr pClient; ! 436: int size; ! 437: xGetFontPathReply *pRep; ! 438: { ! 439: int n; ! 440: ! 441: swaps(&pRep->sequenceNumber, n); ! 442: swapl(&pRep->length, n); ! 443: swaps(&pRep->nPaths, n); ! 444: WriteToClient(pClient, size, (char *) pRep); ! 445: } ! 446: ! 447: void ! 448: SGetImageReply(pClient, size, pRep) ! 449: ClientPtr pClient; ! 450: int size; ! 451: xGetImageReply *pRep; ! 452: { ! 453: int n; ! 454: ! 455: swaps(&pRep->sequenceNumber, n); ! 456: swapl(&pRep->length, n); ! 457: swapl(&pRep->visual, n); ! 458: WriteToClient(pClient, size, (char *) pRep); ! 459: /* Fortunately, image doesn't need swapping */ ! 460: } ! 461: ! 462: void ! 463: SListInstalledColormapsReply(pClient, size, pRep) ! 464: ClientPtr pClient; ! 465: int size; ! 466: xListInstalledColormapsReply *pRep; ! 467: { ! 468: int n; ! 469: ! 470: swaps(&pRep->sequenceNumber, n); ! 471: swapl(&pRep->length, n); ! 472: swaps(&pRep->nColormaps, n); ! 473: WriteToClient(pClient, size, (char *) pRep); ! 474: } ! 475: ! 476: void ! 477: SAllocColorReply(pClient, size, pRep) ! 478: ClientPtr pClient; ! 479: int size; ! 480: xAllocColorReply *pRep; ! 481: { ! 482: int n; ! 483: ! 484: swaps(&pRep->sequenceNumber, n); ! 485: swaps(&pRep->red, n); ! 486: swaps(&pRep->green, n); ! 487: swaps(&pRep->blue, n); ! 488: swapl(&pRep->pixel, n); ! 489: WriteToClient(pClient, size, (char *) pRep); ! 490: } ! 491: ! 492: void ! 493: SAllocNamedColorReply(pClient, size, pRep) ! 494: ClientPtr pClient; ! 495: int size; ! 496: xAllocNamedColorReply *pRep; ! 497: { ! 498: int n; ! 499: ! 500: swaps(&pRep->sequenceNumber, n); ! 501: swapl(&pRep->pixel, n); ! 502: swaps(&pRep->exactRed, n); ! 503: swaps(&pRep->exactGreen, n); ! 504: swaps(&pRep->exactBlue, n); ! 505: swaps(&pRep->screenRed, n); ! 506: swaps(&pRep->screenGreen, n); ! 507: swaps(&pRep->screenBlue, n); ! 508: WriteToClient(pClient, size, (char *) pRep); ! 509: } ! 510: ! 511: void ! 512: SAllocColorCellsReply(pClient, size, pRep) ! 513: ClientPtr pClient; ! 514: int size; ! 515: xAllocColorCellsReply *pRep; ! 516: { ! 517: int n; ! 518: ! 519: swaps(&pRep->sequenceNumber, n); ! 520: swapl(&pRep->length, n); ! 521: swaps(&pRep->nPixels, n); ! 522: swaps(&pRep->nMasks, n); ! 523: WriteToClient(pClient, size, (char *) pRep); ! 524: } ! 525: ! 526: ! 527: void ! 528: SAllocColorPlanesReply(pClient, size, pRep) ! 529: ClientPtr pClient; ! 530: int size; ! 531: xAllocColorPlanesReply *pRep; ! 532: { ! 533: int n; ! 534: ! 535: swaps(&pRep->sequenceNumber, n); ! 536: swapl(&pRep->length, n); ! 537: swaps(&pRep->nPixels, n); ! 538: swapl(&pRep->redMask, n); ! 539: swapl(&pRep->greenMask, n); ! 540: swapl(&pRep->blueMask, n); ! 541: WriteToClient(pClient, size, (char *) pRep); ! 542: } ! 543: ! 544: void ! 545: SQColorsExtend(pClient, size, prgb) ! 546: ClientPtr pClient; ! 547: int size; ! 548: xrgb *prgb; ! 549: { ! 550: int i, n; ! 551: xrgb *prgbT; ! 552: ! 553: n = size / sizeof(xrgb); ! 554: prgbT = prgb; ! 555: for(i = 0; i < n; i++) ! 556: { ! 557: SwapRGB(prgbT); ! 558: prgbT++; ! 559: } ! 560: WriteToClient(pClient, size, (char *) prgb); ! 561: } ! 562: ! 563: void ! 564: SQueryColorsReply(pClient, size, pRep) ! 565: ClientPtr pClient; ! 566: int size; ! 567: xQueryColorsReply *pRep; ! 568: { ! 569: int n; ! 570: ! 571: swaps(&pRep->sequenceNumber, n); ! 572: swapl(&pRep->length, n); ! 573: swaps(&pRep->nColors, n); ! 574: WriteToClient(pClient, size, (char *) pRep); ! 575: } ! 576: ! 577: void ! 578: SLookupColorReply(pClient, size, pRep) ! 579: ClientPtr pClient; ! 580: int size; ! 581: xLookupColorReply *pRep; ! 582: { ! 583: int n; ! 584: ! 585: swaps(&pRep->sequenceNumber, n); ! 586: swaps(&pRep->exactRed, n); ! 587: swaps(&pRep->exactGreen, n); ! 588: swaps(&pRep->exactBlue, n); ! 589: swaps(&pRep->screenRed, n); ! 590: swaps(&pRep->screenGreen, n); ! 591: swaps(&pRep->screenBlue, n); ! 592: WriteToClient(pClient, size, (char *) pRep); ! 593: } ! 594: ! 595: void ! 596: SQueryBestSizeReply(pClient, size, pRep) ! 597: ClientPtr pClient; ! 598: int size; ! 599: xQueryBestSizeReply *pRep; ! 600: { ! 601: int n; ! 602: ! 603: swaps(&pRep->sequenceNumber, n); ! 604: swaps(&pRep->width, n); ! 605: swaps(&pRep->height, n); ! 606: WriteToClient(pClient, size, (char *) pRep); ! 607: } ! 608: ! 609: void ! 610: SListExtensionsReply(pClient, size, pRep) ! 611: ClientPtr pClient; ! 612: int size; ! 613: xListExtensionsReply *pRep; ! 614: { ! 615: int n; ! 616: ! 617: swaps(&pRep->sequenceNumber, n); ! 618: swapl(&pRep->length, n); ! 619: WriteToClient(pClient, size, (char *) pRep); ! 620: } ! 621: ! 622: void ! 623: SGetKeyboardMappingReply(pClient, size, pRep) ! 624: ClientPtr pClient; ! 625: int size; ! 626: xGetKeyboardMappingReply *pRep; ! 627: { ! 628: int n; ! 629: ! 630: swaps(&pRep->sequenceNumber, n); ! 631: swapl(&pRep->length, n); ! 632: WriteToClient(pClient, size, (char *) pRep); ! 633: } ! 634: ! 635: void ! 636: SGetPointerMappingReply(pClient, size, pRep) ! 637: ClientPtr pClient; ! 638: int size; ! 639: xGetPointerMappingReply *pRep; ! 640: { ! 641: int n; ! 642: ! 643: swaps(&pRep->sequenceNumber, n); ! 644: swapl(&pRep->length, n); ! 645: WriteToClient(pClient, size, (char *) pRep); ! 646: } ! 647: ! 648: void ! 649: SGetModifierMappingReply(pClient, size, pRep) ! 650: ClientPtr pClient; ! 651: int size; ! 652: xGetModifierMappingReply *pRep; ! 653: { ! 654: int n; ! 655: ! 656: swaps(&pRep->sequenceNumber, n); ! 657: swapl(&pRep->length, n); ! 658: WriteToClient(pClient, size, (char *) pRep); ! 659: } ! 660: ! 661: void ! 662: SGetKeyboardControlReply(pClient, size, pRep) ! 663: ClientPtr pClient; ! 664: int size; ! 665: xGetKeyboardControlReply *pRep; ! 666: { ! 667: int n; ! 668: ! 669: swaps(&pRep->sequenceNumber, n); ! 670: swapl(&pRep->length, n); ! 671: swapl(&pRep->ledMask, n); ! 672: swaps(&pRep->bellPitch, n); ! 673: swaps(&pRep->bellDuration, n); ! 674: WriteToClient(pClient, size, (char *) pRep); ! 675: } ! 676: ! 677: void ! 678: SGetPointerControlReply(pClient, size, pRep) ! 679: ClientPtr pClient; ! 680: int size; ! 681: xGetPointerControlReply *pRep; ! 682: { ! 683: int n; ! 684: ! 685: swaps(&pRep->sequenceNumber, n); ! 686: swaps(&pRep->accelNumerator, n); ! 687: swaps(&pRep->accelDenominator, n); ! 688: swaps(&pRep->threshold, n); ! 689: WriteToClient(pClient, size, (char *) pRep); ! 690: } ! 691: ! 692: void ! 693: SGetScreenSaverReply(pClient, size, pRep) ! 694: ClientPtr pClient; ! 695: int size; ! 696: xGetScreenSaverReply *pRep; ! 697: { ! 698: int n; ! 699: ! 700: swaps(&pRep->sequenceNumber, n); ! 701: swaps(&pRep->timeout, n); ! 702: swaps(&pRep->interval, n); ! 703: WriteToClient(pClient, size, (char *) pRep); ! 704: } ! 705: ! 706: void ! 707: SLHostsExtend(pClient, size, buf) ! 708: ClientPtr pClient; ! 709: int size; ! 710: char *buf; ! 711: { ! 712: char *bufT = buf; ! 713: char *endbuf = buf + size; ! 714: while (bufT < endbuf) { ! 715: xHostEntry *host = (xHostEntry *) bufT; ! 716: int len = host->length; ! 717: int n; ! 718: swaps (&host->length, n); ! 719: bufT += sizeof (xHostEntry) + (((len + 3) >> 2) << 2); ! 720: } ! 721: WriteToClient (pClient, size, buf); ! 722: } ! 723: ! 724: void ! 725: SListHostsReply(pClient, size, pRep) ! 726: ClientPtr pClient; ! 727: int size; ! 728: xListHostsReply *pRep; ! 729: { ! 730: int n; ! 731: ! 732: swaps(&pRep->sequenceNumber, n); ! 733: swapl(&pRep->length, n); ! 734: swaps(&pRep->nHosts, n); ! 735: WriteToClient(pClient, size, (char *) pRep); ! 736: } ! 737: ! 738: ! 739: ! 740: void ! 741: SErrorEvent(from, to) ! 742: xError *from, *to; ! 743: { ! 744: to->type = X_Error; ! 745: to->errorCode = from->errorCode; ! 746: cpswaps(from->sequenceNumber, to->sequenceNumber); ! 747: cpswapl(from->resourceID, to->resourceID); ! 748: cpswaps(from->minorCode, to->minorCode); ! 749: to->majorCode = from->majorCode; ! 750: } ! 751: ! 752: void ! 753: SKeyButtonPtrEvent(from, to) ! 754: xEvent *from, *to; ! 755: { ! 756: to->u.u.type = from->u.u.type; ! 757: to->u.u.detail = from->u.u.detail; ! 758: cpswaps(from->u.u.sequenceNumber, to->u.u.sequenceNumber); ! 759: cpswapl(from->u.keyButtonPointer.time, ! 760: to->u.keyButtonPointer.time); ! 761: cpswapl(from->u.keyButtonPointer.root, ! 762: to->u.keyButtonPointer.root); ! 763: cpswapl(from->u.keyButtonPointer.event, ! 764: to->u.keyButtonPointer.event); ! 765: cpswapl(from->u.keyButtonPointer.child, ! 766: to->u.keyButtonPointer.child); ! 767: cpswaps(from->u.keyButtonPointer.rootX, ! 768: to->u.keyButtonPointer.rootX); ! 769: cpswaps(from->u.keyButtonPointer.rootY, ! 770: to->u.keyButtonPointer.rootY); ! 771: cpswaps(from->u.keyButtonPointer.eventX, ! 772: to->u.keyButtonPointer.eventX); ! 773: cpswaps(from->u.keyButtonPointer.eventY, ! 774: to->u.keyButtonPointer.eventY); ! 775: cpswaps(from->u.keyButtonPointer.state, ! 776: to->u.keyButtonPointer.state); ! 777: to->u.keyButtonPointer.sameScreen = ! 778: from->u.keyButtonPointer.sameScreen; ! 779: } ! 780: ! 781: void ! 782: SEnterLeaveEvent(from, to) ! 783: xEvent *from, *to; ! 784: { ! 785: to->u.u.type = from->u.u.type; ! 786: to->u.u.detail = from->u.u.detail; ! 787: cpswaps(from->u.u.sequenceNumber, to->u.u.sequenceNumber); ! 788: cpswapl(from->u.enterLeave.time, to->u.enterLeave.time); ! 789: cpswapl(from->u.enterLeave.root, to->u.enterLeave.root); ! 790: cpswapl(from->u.enterLeave.event, to->u.enterLeave.event); ! 791: cpswapl(from->u.enterLeave.child, to->u.enterLeave.child); ! 792: cpswaps(from->u.enterLeave.rootX, to->u.enterLeave.rootX); ! 793: cpswaps(from->u.enterLeave.rootY, to->u.enterLeave.rootY); ! 794: cpswaps(from->u.enterLeave.eventX, to->u.enterLeave.eventX); ! 795: cpswaps(from->u.enterLeave.eventY, to->u.enterLeave.eventY); ! 796: cpswaps(from->u.enterLeave.state, to->u.enterLeave.state); ! 797: to->u.enterLeave.mode = from->u.enterLeave.mode; ! 798: to->u.enterLeave.flags = from->u.enterLeave.flags; ! 799: } ! 800: ! 801: void ! 802: SFocusEvent(from, to) ! 803: xEvent *from, *to; ! 804: { ! 805: to->u.u.type = from->u.u.type; ! 806: to->u.u.detail = from->u.u.detail; ! 807: cpswaps(from->u.u.sequenceNumber, to->u.u.sequenceNumber); ! 808: cpswapl(from->u.focus.window, to->u.focus.window); ! 809: to->u.focus.mode = from->u.focus.mode; ! 810: } ! 811: ! 812: void ! 813: SExposeEvent(from, to) ! 814: xEvent *from, *to; ! 815: { ! 816: to->u.u.type = from->u.u.type; ! 817: cpswaps(from->u.u.sequenceNumber, to->u.u.sequenceNumber); ! 818: cpswapl(from->u.expose.window, to->u.expose.window); ! 819: cpswaps(from->u.expose.x, to->u.expose.x); ! 820: cpswaps(from->u.expose.y, to->u.expose.y); ! 821: cpswaps(from->u.expose.width, to->u.expose.width); ! 822: cpswaps(from->u.expose.height, to->u.expose.height); ! 823: cpswaps(from->u.expose.count, to->u.expose.count); ! 824: } ! 825: ! 826: void ! 827: SGraphicsExposureEvent(from, to) ! 828: xEvent *from, *to; ! 829: { ! 830: to->u.u.type = from->u.u.type; ! 831: cpswaps(from->u.u.sequenceNumber, to->u.u.sequenceNumber); ! 832: cpswapl(from->u.graphicsExposure.drawable, ! 833: to->u.graphicsExposure.drawable); ! 834: cpswaps(from->u.graphicsExposure.x, ! 835: to->u.graphicsExposure.x); ! 836: cpswaps(from->u.graphicsExposure.y, ! 837: to->u.graphicsExposure.y); ! 838: cpswaps(from->u.graphicsExposure.width, ! 839: to->u.graphicsExposure.width); ! 840: cpswaps(from->u.graphicsExposure.height, ! 841: to->u.graphicsExposure.height); ! 842: cpswaps(from->u.graphicsExposure.minorEvent, ! 843: to->u.graphicsExposure.minorEvent); ! 844: cpswaps(from->u.graphicsExposure.count, ! 845: to->u.graphicsExposure.count); ! 846: to->u.graphicsExposure.majorEvent = ! 847: from->u.graphicsExposure.majorEvent; ! 848: } ! 849: ! 850: void ! 851: SNoExposureEvent(from, to) ! 852: xEvent *from, *to; ! 853: { ! 854: to->u.u.type = from->u.u.type; ! 855: cpswaps(from->u.u.sequenceNumber, to->u.u.sequenceNumber); ! 856: cpswapl(from->u.noExposure.drawable, to->u.noExposure.drawable); ! 857: cpswaps(from->u.noExposure.minorEvent, to->u.noExposure.minorEvent); ! 858: to->u.noExposure.majorEvent = from->u.noExposure.majorEvent; ! 859: } ! 860: ! 861: void ! 862: SVisibilityEvent(from, to) ! 863: xEvent *from, *to; ! 864: { ! 865: to->u.u.type = from->u.u.type; ! 866: cpswaps(from->u.u.sequenceNumber, to->u.u.sequenceNumber); ! 867: cpswapl(from->u.visibility.window, to->u.visibility.window); ! 868: to->u.visibility.state = from->u.visibility.state; ! 869: } ! 870: ! 871: void ! 872: SCreateNotifyEvent(from, to) ! 873: xEvent *from, *to; ! 874: { ! 875: to->u.u.type = from->u.u.type; ! 876: cpswaps(from->u.u.sequenceNumber, to->u.u.sequenceNumber); ! 877: cpswapl(from->u.createNotify.window, to->u.createNotify.window); ! 878: cpswapl(from->u.createNotify.parent, to->u.createNotify.parent); ! 879: cpswaps(from->u.createNotify.x, to->u.createNotify.x); ! 880: cpswaps(from->u.createNotify.y, to->u.createNotify.y); ! 881: cpswaps(from->u.createNotify.width, to->u.createNotify.width); ! 882: cpswaps(from->u.createNotify.height, to->u.createNotify.height); ! 883: cpswaps(from->u.createNotify.borderWidth, ! 884: to->u.createNotify.borderWidth); ! 885: to->u.createNotify.override = from->u.createNotify.override; ! 886: } ! 887: ! 888: void ! 889: SDestroyNotifyEvent(from, to) ! 890: xEvent *from, *to; ! 891: { ! 892: to->u.u.type = from->u.u.type; ! 893: cpswaps(from->u.u.sequenceNumber, to->u.u.sequenceNumber); ! 894: cpswapl(from->u.destroyNotify.event, to->u.destroyNotify.event); ! 895: cpswapl(from->u.destroyNotify.window, to->u.destroyNotify.window); ! 896: } ! 897: ! 898: void ! 899: SUnmapNotifyEvent(from, to) ! 900: xEvent *from, *to; ! 901: { ! 902: to->u.u.type = from->u.u.type; ! 903: cpswaps(from->u.u.sequenceNumber, to->u.u.sequenceNumber); ! 904: cpswapl(from->u.unmapNotify.event, to->u.unmapNotify.event); ! 905: cpswapl(from->u.unmapNotify.window, to->u.unmapNotify.window); ! 906: to->u.unmapNotify.fromConfigure = from->u.unmapNotify.fromConfigure; ! 907: } ! 908: ! 909: void ! 910: SMapNotifyEvent(from, to) ! 911: xEvent *from, *to; ! 912: { ! 913: to->u.u.type = from->u.u.type; ! 914: cpswaps(from->u.u.sequenceNumber, to->u.u.sequenceNumber); ! 915: cpswapl(from->u.mapNotify.event, to->u.mapNotify.event); ! 916: cpswapl(from->u.mapNotify.window, to->u.mapNotify.window); ! 917: to->u.mapNotify.override = from->u.mapNotify.override; ! 918: } ! 919: ! 920: void ! 921: SMapRequestEvent(from, to) ! 922: xEvent *from, *to; ! 923: { ! 924: to->u.u.type = from->u.u.type; ! 925: cpswaps(from->u.u.sequenceNumber, to->u.u.sequenceNumber); ! 926: cpswapl(from->u.mapRequest.parent, to->u.mapRequest.parent); ! 927: cpswapl(from->u.mapRequest.window, to->u.mapRequest.window); ! 928: } ! 929: ! 930: void ! 931: SReparentEvent(from, to) ! 932: xEvent *from, *to; ! 933: { ! 934: to->u.u.type = from->u.u.type; ! 935: cpswaps(from->u.u.sequenceNumber, to->u.u.sequenceNumber); ! 936: cpswapl(from->u.reparent.event, to->u.reparent.event); ! 937: cpswapl(from->u.reparent.window, to->u.reparent.window); ! 938: cpswapl(from->u.reparent.parent, to->u.reparent.parent); ! 939: cpswaps(from->u.reparent.x, to->u.reparent.x); ! 940: cpswaps(from->u.reparent.y, to->u.reparent.y); ! 941: to->u.reparent.override = from->u.reparent.override; ! 942: } ! 943: ! 944: void ! 945: SConfigureNotifyEvent(from, to) ! 946: xEvent *from, *to; ! 947: { ! 948: to->u.u.type = from->u.u.type; ! 949: cpswaps(from->u.u.sequenceNumber, to->u.u.sequenceNumber); ! 950: cpswapl(from->u.configureNotify.event, ! 951: to->u.configureNotify.event); ! 952: cpswapl(from->u.configureNotify.window, ! 953: to->u.configureNotify.window); ! 954: cpswapl(from->u.configureNotify.aboveSibling, ! 955: to->u.configureNotify.aboveSibling); ! 956: cpswaps(from->u.configureNotify.x, to->u.configureNotify.x); ! 957: cpswaps(from->u.configureNotify.y, to->u.configureNotify.y); ! 958: cpswaps(from->u.configureNotify.width, to->u.configureNotify.width); ! 959: cpswaps(from->u.configureNotify.height, ! 960: to->u.configureNotify.height); ! 961: cpswaps(from->u.configureNotify.borderWidth, ! 962: to->u.configureNotify.borderWidth); ! 963: to->u.configureNotify.override = from->u.configureNotify.override; ! 964: } ! 965: ! 966: void ! 967: SConfigureRequestEvent(from, to) ! 968: xEvent *from, *to; ! 969: { ! 970: to->u.u.type = from->u.u.type; ! 971: to->u.u.detail = from->u.u.detail; /* actually stack-mode */ ! 972: cpswaps(from->u.u.sequenceNumber, to->u.u.sequenceNumber); ! 973: cpswapl(from->u.configureRequest.parent, ! 974: to->u.configureRequest.parent); ! 975: cpswapl(from->u.configureRequest.window, ! 976: to->u.configureRequest.window); ! 977: cpswapl(from->u.configureRequest.sibling, ! 978: to->u.configureRequest.sibling); ! 979: cpswaps(from->u.configureRequest.x, to->u.configureRequest.x); ! 980: cpswaps(from->u.configureRequest.y, to->u.configureRequest.y); ! 981: cpswaps(from->u.configureRequest.width, ! 982: to->u.configureRequest.width); ! 983: cpswaps(from->u.configureRequest.height, ! 984: to->u.configureRequest.height); ! 985: cpswaps(from->u.configureRequest.borderWidth, ! 986: to->u.configureRequest.borderWidth); ! 987: cpswaps(from->u.configureRequest.valueMask, ! 988: to->u.configureRequest.valueMask); ! 989: } ! 990: ! 991: ! 992: void ! 993: SGravityEvent(from, to) ! 994: xEvent *from, *to; ! 995: { ! 996: to->u.u.type = from->u.u.type; ! 997: cpswaps(from->u.u.sequenceNumber, to->u.u.sequenceNumber); ! 998: cpswapl(from->u.gravity.event, to->u.gravity.event); ! 999: cpswapl(from->u.gravity.window, to->u.gravity.window); ! 1000: cpswaps(from->u.gravity.x, to->u.gravity.x); ! 1001: cpswaps(from->u.gravity.y, to->u.gravity.y); ! 1002: } ! 1003: ! 1004: void ! 1005: SResizeRequestEvent(from, to) ! 1006: xEvent *from, *to; ! 1007: { ! 1008: to->u.u.type = from->u.u.type; ! 1009: cpswaps(from->u.u.sequenceNumber, to->u.u.sequenceNumber); ! 1010: cpswapl(from->u.resizeRequest.window, to->u.resizeRequest.window); ! 1011: cpswaps(from->u.resizeRequest.width, to->u.resizeRequest.width); ! 1012: cpswaps(from->u.resizeRequest.height, to->u.resizeRequest.height); ! 1013: } ! 1014: ! 1015: void ! 1016: SCirculateEvent(from, to) ! 1017: xEvent *from, *to; ! 1018: { ! 1019: to->u.u.type = from->u.u.type; ! 1020: to->u.u.detail = from->u.u.detail; ! 1021: cpswaps(from->u.u.sequenceNumber, to->u.u.sequenceNumber); ! 1022: cpswapl(from->u.circulate.event, to->u.circulate.event); ! 1023: cpswapl(from->u.circulate.window, to->u.circulate.window); ! 1024: cpswapl(from->u.circulate.parent, to->u.circulate.parent); ! 1025: to->u.circulate.place = from->u.circulate.place; ! 1026: } ! 1027: ! 1028: void ! 1029: SPropertyEvent(from, to) ! 1030: xEvent *from, *to; ! 1031: { ! 1032: to->u.u.type = from->u.u.type; ! 1033: cpswaps(from->u.u.sequenceNumber, to->u.u.sequenceNumber); ! 1034: cpswapl(from->u.property.window, to->u.property.window); ! 1035: cpswapl(from->u.property.atom, to->u.property.atom); ! 1036: cpswapl(from->u.property.time, to->u.property.time); ! 1037: to->u.property.state = from->u.property.state; ! 1038: } ! 1039: ! 1040: void ! 1041: SSelectionClearEvent(from, to) ! 1042: xEvent *from, *to; ! 1043: { ! 1044: to->u.u.type = from->u.u.type; ! 1045: cpswaps(from->u.u.sequenceNumber, to->u.u.sequenceNumber); ! 1046: cpswapl(from->u.selectionClear.time, to->u.selectionClear.time); ! 1047: cpswapl(from->u.selectionClear.window, to->u.selectionClear.window); ! 1048: cpswapl(from->u.selectionClear.atom, to->u.selectionClear.atom); ! 1049: } ! 1050: ! 1051: void ! 1052: SSelectionRequestEvent(from, to) ! 1053: xEvent *from, *to; ! 1054: { ! 1055: to->u.u.type = from->u.u.type; ! 1056: cpswaps(from->u.u.sequenceNumber, to->u.u.sequenceNumber); ! 1057: cpswapl(from->u.selectionRequest.time, to->u.selectionRequest.time); ! 1058: cpswapl(from->u.selectionRequest.owner, ! 1059: to->u.selectionRequest.owner); ! 1060: cpswapl(from->u.selectionRequest.requestor, ! 1061: to->u.selectionRequest.requestor); ! 1062: cpswapl(from->u.selectionRequest.selection, ! 1063: to->u.selectionRequest.selection); ! 1064: cpswapl(from->u.selectionRequest.target, ! 1065: to->u.selectionRequest.target); ! 1066: cpswapl(from->u.selectionRequest.property, ! 1067: to->u.selectionRequest.property); ! 1068: } ! 1069: ! 1070: void ! 1071: SSelectionNotifyEvent(from, to) ! 1072: xEvent *from, *to; ! 1073: { ! 1074: to->u.u.type = from->u.u.type; ! 1075: cpswaps(from->u.u.sequenceNumber, to->u.u.sequenceNumber); ! 1076: cpswapl(from->u.selectionNotify.time, to->u.selectionNotify.time); ! 1077: cpswapl(from->u.selectionNotify.requestor, ! 1078: to->u.selectionNotify.requestor); ! 1079: cpswapl(from->u.selectionNotify.selection, ! 1080: to->u.selectionNotify.selection); ! 1081: cpswapl(from->u.selectionNotify.target, ! 1082: to->u.selectionNotify.target); ! 1083: cpswapl(from->u.selectionNotify.property, ! 1084: to->u.selectionNotify.property); ! 1085: } ! 1086: ! 1087: void ! 1088: SColormapEvent(from, to) ! 1089: xEvent *from, *to; ! 1090: { ! 1091: to->u.u.type = from->u.u.type; ! 1092: cpswaps(from->u.u.sequenceNumber, to->u.u.sequenceNumber); ! 1093: cpswapl(from->u.colormap.window, to->u.colormap.window); ! 1094: cpswapl(from->u.colormap.colormap, to->u.colormap.colormap); ! 1095: to->u.colormap.new = from->u.colormap.new; ! 1096: to->u.colormap.state = from->u.colormap.state; ! 1097: } ! 1098: ! 1099: void ! 1100: SMappingEvent(from, to) ! 1101: xEvent *from, *to; ! 1102: { ! 1103: to->u.u.type = from->u.u.type; ! 1104: cpswaps(from->u.u.sequenceNumber, to->u.u.sequenceNumber); ! 1105: to->u.mappingNotify.request = from->u.mappingNotify.request; ! 1106: to->u.mappingNotify.firstKeyCode = ! 1107: from->u.mappingNotify.firstKeyCode; ! 1108: to->u.mappingNotify.count = from->u.mappingNotify.count; ! 1109: } ! 1110: ! 1111: void ! 1112: SClientMessageEvent(from, to) ! 1113: xEvent *from, *to; ! 1114: { ! 1115: to->u.u.type = from->u.u.type; ! 1116: to->u.u.detail = from->u.u.detail; /* actually format */ ! 1117: cpswaps(from->u.u.sequenceNumber, to->u.u.sequenceNumber); ! 1118: cpswapl(from->u.clientMessage.window, to->u.clientMessage.window); ! 1119: cpswapl(from->u.clientMessage.u.l.type, ! 1120: to->u.clientMessage.u.l.type); ! 1121: switch (from->u.u.detail) { ! 1122: case 8: ! 1123: bcopy(from->u.clientMessage.u.b.bytes, ! 1124: to->u.clientMessage.u.b.bytes, 20); ! 1125: break; ! 1126: case 16: ! 1127: cpswaps(from->u.clientMessage.u.s.shorts0, ! 1128: to->u.clientMessage.u.s.shorts0); ! 1129: cpswaps(from->u.clientMessage.u.s.shorts1, ! 1130: to->u.clientMessage.u.s.shorts1); ! 1131: cpswaps(from->u.clientMessage.u.s.shorts2, ! 1132: to->u.clientMessage.u.s.shorts2); ! 1133: cpswaps(from->u.clientMessage.u.s.shorts3, ! 1134: to->u.clientMessage.u.s.shorts3); ! 1135: cpswaps(from->u.clientMessage.u.s.shorts4, ! 1136: to->u.clientMessage.u.s.shorts4); ! 1137: cpswaps(from->u.clientMessage.u.s.shorts5, ! 1138: to->u.clientMessage.u.s.shorts5); ! 1139: cpswaps(from->u.clientMessage.u.s.shorts6, ! 1140: to->u.clientMessage.u.s.shorts6); ! 1141: cpswaps(from->u.clientMessage.u.s.shorts7, ! 1142: to->u.clientMessage.u.s.shorts7); ! 1143: cpswaps(from->u.clientMessage.u.s.shorts8, ! 1144: to->u.clientMessage.u.s.shorts8); ! 1145: cpswaps(from->u.clientMessage.u.s.shorts9, ! 1146: to->u.clientMessage.u.s.shorts9); ! 1147: break; ! 1148: case 32: ! 1149: cpswaps(from->u.clientMessage.u.l.longs0, ! 1150: to->u.clientMessage.u.l.longs0); ! 1151: cpswaps(from->u.clientMessage.u.l.longs1, ! 1152: to->u.clientMessage.u.l.longs1); ! 1153: cpswaps(from->u.clientMessage.u.l.longs2, ! 1154: to->u.clientMessage.u.l.longs2); ! 1155: cpswaps(from->u.clientMessage.u.l.longs3, ! 1156: to->u.clientMessage.u.l.longs3); ! 1157: cpswaps(from->u.clientMessage.u.l.longs4, ! 1158: to->u.clientMessage.u.l.longs4); ! 1159: break; ! 1160: } ! 1161: } ! 1162: ! 1163: void ! 1164: SKeymapNotifyEvent(from, to) ! 1165: xEvent *from, *to; ! 1166: { ! 1167: /* Keymap notify events are special; they have no ! 1168: sequence number field, and contain entirely 8-bit data */ ! 1169: *to = *from; ! 1170: } ! 1171: ! 1172: void ! 1173: WriteSConnectionInfo(pClient, size, pInfo) ! 1174: ClientPtr pClient; ! 1175: int size; ! 1176: char *pInfo; ! 1177: { ! 1178: int i, j, k; ! 1179: ScreenPtr pScreen; ! 1180: DepthPtr pDepth; ! 1181: char *pInfoT, *pInfoTBase; ! 1182: xConnSetup *pConnSetup = (xConnSetup *)pInfo; ! 1183: ! 1184: pInfoT = pInfoTBase = (char *) ALLOCATE_LOCAL(size); ! 1185: ! 1186: SwapConnSetup(pInfo, pInfoT); ! 1187: pInfo += sizeof(xConnSetup); ! 1188: pInfoT += sizeof(xConnSetup); ! 1189: ! 1190: /* Copy the vendor string */ ! 1191: i = (pConnSetup->nbytesVendor + 3) & ~3; ! 1192: bcopy(pInfo, pInfoT, i); ! 1193: pInfo += i; ! 1194: pInfoT += i; ! 1195: ! 1196: /* The Pixmap formats don't need to be swapped, just copied. */ ! 1197: i = sizeof(xPixmapFormat) * screenInfo.numPixmapFormats; ! 1198: bcopy(pInfo, pInfoT, i); ! 1199: pInfo += i; ! 1200: pInfoT += i; ! 1201: ! 1202: for(i = 0; i < screenInfo.numScreens; i++) ! 1203: { ! 1204: pScreen = (ScreenPtr)&screenInfo.screen[i]; ! 1205: SwapWinRoot(pInfo, pInfoT); ! 1206: pInfo += sizeof(xWindowRoot); ! 1207: pInfoT += sizeof(xWindowRoot); ! 1208: pDepth = pScreen->allowedDepths; ! 1209: for(j = 0; j < pScreen->numDepths; j++, pDepth++) ! 1210: { ! 1211: ((xDepth *)pInfoT)->depth = ((xDepth *)pInfo)->depth; ! 1212: cpswaps(((xDepth *)pInfo)->nVisuals, ((xDepth *)pInfoT)->nVisuals); ! 1213: pInfo += sizeof(xDepth); ! 1214: pInfoT += sizeof(xDepth); ! 1215: for(k = 0; k < pDepth->numVids; k++) ! 1216: { ! 1217: SwapVisual(pInfo, pInfoT); ! 1218: pInfo += sizeof(xVisualType); ! 1219: pInfoT += sizeof(xVisualType); ! 1220: } ! 1221: } ! 1222: } ! 1223: WriteToClient(pClient, size, (char *) pInfoTBase); ! 1224: DEALLOCATE_LOCAL(pInfoTBase); ! 1225: } ! 1226: ! 1227: void ! 1228: SwapConnSetup(pConnSetup, pConnSetupT) ! 1229: xConnSetup *pConnSetup, *pConnSetupT; ! 1230: { ! 1231: cpswapl(pConnSetup->release, pConnSetupT->release); ! 1232: cpswapl(pConnSetup->ridBase, pConnSetupT->ridBase); ! 1233: cpswapl(pConnSetup->ridMask, pConnSetupT->ridMask); ! 1234: cpswapl(pConnSetup->motionBufferSize, pConnSetupT->motionBufferSize); ! 1235: cpswaps(pConnSetup->nbytesVendor, pConnSetupT->nbytesVendor); ! 1236: cpswaps(pConnSetup->maxRequestSize, pConnSetupT->maxRequestSize); ! 1237: pConnSetupT->minKeyCode = pConnSetup->minKeyCode; ! 1238: pConnSetupT->maxKeyCode = pConnSetup->maxKeyCode; ! 1239: pConnSetupT->numRoots = pConnSetup->numRoots; ! 1240: pConnSetupT->numFormats = pConnSetup->numFormats; ! 1241: pConnSetupT->imageByteOrder = pConnSetup->imageByteOrder; ! 1242: pConnSetupT->bitmapBitOrder = pConnSetup->bitmapBitOrder; ! 1243: pConnSetupT->bitmapScanlineUnit = pConnSetup->bitmapScanlineUnit; ! 1244: pConnSetupT->bitmapScanlinePad = pConnSetup->bitmapScanlinePad; ! 1245: } ! 1246: ! 1247: void ! 1248: SwapWinRoot(pRoot, pRootT) ! 1249: xWindowRoot *pRoot, *pRootT; ! 1250: { ! 1251: cpswapl(pRoot->windowId, pRootT->windowId); ! 1252: cpswapl(pRoot->defaultColormap, pRootT->defaultColormap); ! 1253: cpswapl(pRoot->whitePixel, pRootT->whitePixel); ! 1254: cpswapl(pRoot->blackPixel, pRootT->blackPixel); ! 1255: cpswapl(pRoot->currentInputMask, pRootT->currentInputMask); ! 1256: cpswaps(pRoot->pixWidth, pRootT->pixWidth); ! 1257: cpswaps(pRoot->pixHeight, pRootT->pixHeight); ! 1258: cpswaps(pRoot->mmWidth, pRootT->mmWidth); ! 1259: cpswaps(pRoot->mmHeight, pRootT->mmHeight); ! 1260: cpswaps(pRoot->minInstalledMaps, pRootT->minInstalledMaps); ! 1261: cpswaps(pRoot->maxInstalledMaps, pRootT->maxInstalledMaps); ! 1262: cpswapl(pRoot->rootVisualID, pRootT->rootVisualID); ! 1263: pRootT->backingStore = pRoot->backingStore; ! 1264: pRootT->saveUnders = pRoot->saveUnders; ! 1265: pRootT->rootDepth = pRoot->rootDepth; ! 1266: pRootT->nDepths = pRoot->nDepths; ! 1267: } ! 1268: ! 1269: void ! 1270: SwapVisual(pVis, pVisT) ! 1271: xVisualType *pVis, *pVisT; ! 1272: { ! 1273: cpswapl(pVis->visualID, pVisT->visualID); ! 1274: pVisT->class = pVis->class; ! 1275: pVisT->bitsPerRGB = pVis->bitsPerRGB; ! 1276: cpswaps(pVis->colormapEntries, pVisT->colormapEntries); ! 1277: cpswapl(pVis->redMask, pVisT->redMask); ! 1278: cpswapl(pVis->greenMask, pVisT->greenMask); ! 1279: cpswapl(pVis->blueMask, pVisT->blueMask); ! 1280: } ! 1281: ! 1282: void ! 1283: WriteSConnSetupPrefix(pClient, pcsp) ! 1284: ClientPtr pClient; ! 1285: xConnSetupPrefix *pcsp; ! 1286: { ! 1287: xConnSetupPrefix cspT; ! 1288: ! 1289: cspT.success = pcsp->success; ! 1290: cpswaps(pcsp->majorVersion, cspT.majorVersion); ! 1291: cpswaps(pcsp->minorVersion, cspT.minorVersion); ! 1292: cpswaps(pcsp->length, cspT.length); ! 1293: WriteToClient(pClient, sizeof(cspT), (char *) &cspT); ! 1294: } ! 1295:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.