1/************************************************************
2
3Copyright 1987, 1998  The Open Group
4
5Permission to use, copy, modify, distribute, and sell this software and its
6documentation for any purpose is hereby granted without fee, provided that
7the above copyright notice appear in all copies and that both that
8copyright notice and this permission notice appear in supporting
9documentation.
10
11The above copyright notice and this permission notice shall be included in
12all copies or substantial portions of the Software.
13
14THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
15IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
16FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
17OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
18AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
19CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
20
21Except as contained in this notice, the name of The Open Group shall not be
22used in advertising or otherwise to promote the sale, use or other dealings
23in this Software without prior written authorization from The Open Group.
24
25Copyright 1987 by Digital Equipment Corporation, Maynard, Massachusetts.
26
27                        All Rights Reserved
28
29Permission to use, copy, modify, and distribute this software and its
30documentation for any purpose and without fee is hereby granted,
31provided that the above copyright notice appear in all copies and that
32both that copyright notice and this permission notice appear in
33supporting documentation, and that the name of Digital not be
34used in advertising or publicity pertaining to distribution of the
35software without specific, written prior permission.
36
37DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
38ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
39DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
40ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
41WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
42ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
43SOFTWARE.
44
45********************************************************/
46
47#ifdef HAVE_DIX_CONFIG_H
48#include <dix-config.h>
49#endif
50
51#include <X11/X.h>
52#include <X11/Xproto.h>
53#include <X11/Xprotostr.h>
54#include "misc.h"
55#include "dixstruct.h"
56#include "extnsionst.h"         /* for SendEvent */
57#include "swapreq.h"
58
59/* Thanks to Jack Palevich for testing and subsequently rewriting all this */
60
61/* Byte swap a list of longs */
62void
63SwapLongs(CARD32 *list, unsigned long count)
64{
65    while (count >= 8) {
66        swapl(list + 0);
67        swapl(list + 1);
68        swapl(list + 2);
69        swapl(list + 3);
70        swapl(list + 4);
71        swapl(list + 5);
72        swapl(list + 6);
73        swapl(list + 7);
74        list += 8;
75        count -= 8;
76    }
77    if (count != 0) {
78        do {
79            swapl(list);
80            list++;
81        } while (--count != 0);
82    }
83}
84
85/* Byte swap a list of shorts */
86void
87SwapShorts(short *list, unsigned long count)
88{
89    while (count >= 16) {
90        swaps(list + 0);
91        swaps(list + 1);
92        swaps(list + 2);
93        swaps(list + 3);
94        swaps(list + 4);
95        swaps(list + 5);
96        swaps(list + 6);
97        swaps(list + 7);
98        swaps(list + 8);
99        swaps(list + 9);
100        swaps(list + 10);
101        swaps(list + 11);
102        swaps(list + 12);
103        swaps(list + 13);
104        swaps(list + 14);
105        swaps(list + 15);
106        list += 16;
107        count -= 16;
108    }
109    if (count != 0) {
110        do {
111            swaps(list);
112            list++;
113        } while (--count != 0);
114    }
115}
116
117/* The following is used for all requests that have
118   no fields to be swapped (except "length") */
119int _X_COLD
120SProcSimpleReq(ClientPtr client)
121{
122    REQUEST(xReq);
123    swaps(&stuff->length);
124    return (*ProcVector[stuff->reqType]) (client);
125}
126
127/* The following is used for all requests that have
128   only a single 32-bit field to be swapped, coming
129   right after the "length" field */
130int _X_COLD
131SProcResourceReq(ClientPtr client)
132{
133    REQUEST(xResourceReq);
134    swaps(&stuff->length);
135    REQUEST_AT_LEAST_SIZE(xResourceReq);        /* not EXACT */
136    swapl(&stuff->id);
137    return (*ProcVector[stuff->reqType]) (client);
138}
139
140int _X_COLD
141SProcCreateWindow(ClientPtr client)
142{
143    REQUEST(xCreateWindowReq);
144    swaps(&stuff->length);
145    REQUEST_AT_LEAST_SIZE(xCreateWindowReq);
146    swapl(&stuff->wid);
147    swapl(&stuff->parent);
148    swaps(&stuff->x);
149    swaps(&stuff->y);
150    swaps(&stuff->width);
151    swaps(&stuff->height);
152    swaps(&stuff->borderWidth);
153    swaps(&stuff->class);
154    swapl(&stuff->visual);
155    swapl(&stuff->mask);
156    SwapRestL(stuff);
157    return ((*ProcVector[X_CreateWindow]) (client));
158}
159
160int _X_COLD
161SProcChangeWindowAttributes(ClientPtr client)
162{
163    REQUEST(xChangeWindowAttributesReq);
164    swaps(&stuff->length);
165    REQUEST_AT_LEAST_SIZE(xChangeWindowAttributesReq);
166    swapl(&stuff->window);
167    swapl(&stuff->valueMask);
168    SwapRestL(stuff);
169    return ((*ProcVector[X_ChangeWindowAttributes]) (client));
170}
171
172int _X_COLD
173SProcReparentWindow(ClientPtr client)
174{
175    REQUEST(xReparentWindowReq);
176    swaps(&stuff->length);
177    REQUEST_SIZE_MATCH(xReparentWindowReq);
178    swapl(&stuff->window);
179    swapl(&stuff->parent);
180    swaps(&stuff->x);
181    swaps(&stuff->y);
182    return ((*ProcVector[X_ReparentWindow]) (client));
183}
184
185int _X_COLD
186SProcConfigureWindow(ClientPtr client)
187{
188    REQUEST(xConfigureWindowReq);
189    swaps(&stuff->length);
190    REQUEST_AT_LEAST_SIZE(xConfigureWindowReq);
191    swapl(&stuff->window);
192    swaps(&stuff->mask);
193    SwapRestL(stuff);
194    return ((*ProcVector[X_ConfigureWindow]) (client));
195
196}
197
198int _X_COLD
199SProcInternAtom(ClientPtr client)
200{
201    REQUEST(xInternAtomReq);
202    swaps(&stuff->length);
203    REQUEST_AT_LEAST_SIZE(xInternAtomReq);
204    swaps(&stuff->nbytes);
205    return ((*ProcVector[X_InternAtom]) (client));
206}
207
208int _X_COLD
209SProcChangeProperty(ClientPtr client)
210{
211    REQUEST(xChangePropertyReq);
212    swaps(&stuff->length);
213    REQUEST_AT_LEAST_SIZE(xChangePropertyReq);
214    swapl(&stuff->window);
215    swapl(&stuff->property);
216    swapl(&stuff->type);
217    swapl(&stuff->nUnits);
218    switch (stuff->format) {
219    case 8:
220        break;
221    case 16:
222        SwapRestS(stuff);
223        break;
224    case 32:
225        SwapRestL(stuff);
226        break;
227    }
228    return ((*ProcVector[X_ChangeProperty]) (client));
229}
230
231int _X_COLD
232SProcDeleteProperty(ClientPtr client)
233{
234    REQUEST(xDeletePropertyReq);
235    swaps(&stuff->length);
236    REQUEST_SIZE_MATCH(xDeletePropertyReq);
237    swapl(&stuff->window);
238    swapl(&stuff->property);
239    return ((*ProcVector[X_DeleteProperty]) (client));
240
241}
242
243int _X_COLD
244SProcGetProperty(ClientPtr client)
245{
246    REQUEST(xGetPropertyReq);
247    swaps(&stuff->length);
248    REQUEST_SIZE_MATCH(xGetPropertyReq);
249    swapl(&stuff->window);
250    swapl(&stuff->property);
251    swapl(&stuff->type);
252    swapl(&stuff->longOffset);
253    swapl(&stuff->longLength);
254    return ((*ProcVector[X_GetProperty]) (client));
255}
256
257int _X_COLD
258SProcSetSelectionOwner(ClientPtr client)
259{
260    REQUEST(xSetSelectionOwnerReq);
261    swaps(&stuff->length);
262    REQUEST_SIZE_MATCH(xSetSelectionOwnerReq);
263    swapl(&stuff->window);
264    swapl(&stuff->selection);
265    swapl(&stuff->time);
266    return ((*ProcVector[X_SetSelectionOwner]) (client));
267}
268
269int _X_COLD
270SProcConvertSelection(ClientPtr client)
271{
272    REQUEST(xConvertSelectionReq);
273    swaps(&stuff->length);
274    REQUEST_SIZE_MATCH(xConvertSelectionReq);
275    swapl(&stuff->requestor);
276    swapl(&stuff->selection);
277    swapl(&stuff->target);
278    swapl(&stuff->property);
279    swapl(&stuff->time);
280    return ((*ProcVector[X_ConvertSelection]) (client));
281}
282
283int _X_COLD
284SProcSendEvent(ClientPtr client)
285{
286    xEvent eventT = { .u.u.type = 0 };
287    EventSwapPtr proc;
288
289    REQUEST(xSendEventReq);
290    swaps(&stuff->length);
291    REQUEST_SIZE_MATCH(xSendEventReq);
292    swapl(&stuff->destination);
293    swapl(&stuff->eventMask);
294
295    /* Generic events can have variable size, but SendEvent request holds
296       exactly 32B of event data. */
297    if (stuff->event.u.u.type == GenericEvent) {
298        client->errorValue = stuff->event.u.u.type;
299        return BadValue;
300    }
301
302    /* Swap event */
303    proc = EventSwapVector[stuff->event.u.u.type & 0177];
304    if (!proc || proc == NotImplemented)        /* no swapping proc; invalid event type? */
305        return BadValue;
306    (*proc) (&stuff->event, &eventT);
307    stuff->event = eventT;
308
309    return ((*ProcVector[X_SendEvent]) (client));
310}
311
312int _X_COLD
313SProcGrabPointer(ClientPtr client)
314{
315    REQUEST(xGrabPointerReq);
316    swaps(&stuff->length);
317    REQUEST_SIZE_MATCH(xGrabPointerReq);
318    swapl(&stuff->grabWindow);
319    swaps(&stuff->eventMask);
320    swapl(&stuff->confineTo);
321    swapl(&stuff->cursor);
322    swapl(&stuff->time);
323    return ((*ProcVector[X_GrabPointer]) (client));
324}
325
326int _X_COLD
327SProcGrabButton(ClientPtr client)
328{
329    REQUEST(xGrabButtonReq);
330    swaps(&stuff->length);
331    REQUEST_SIZE_MATCH(xGrabButtonReq);
332    swapl(&stuff->grabWindow);
333    swaps(&stuff->eventMask);
334    swapl(&stuff->confineTo);
335    swapl(&stuff->cursor);
336    swaps(&stuff->modifiers);
337    return ((*ProcVector[X_GrabButton]) (client));
338}
339
340int _X_COLD
341SProcUngrabButton(ClientPtr client)
342{
343    REQUEST(xUngrabButtonReq);
344    swaps(&stuff->length);
345    REQUEST_SIZE_MATCH(xUngrabButtonReq);
346    swapl(&stuff->grabWindow);
347    swaps(&stuff->modifiers);
348    return ((*ProcVector[X_UngrabButton]) (client));
349}
350
351int _X_COLD
352SProcChangeActivePointerGrab(ClientPtr client)
353{
354    REQUEST(xChangeActivePointerGrabReq);
355    swaps(&stuff->length);
356    REQUEST_SIZE_MATCH(xChangeActivePointerGrabReq);
357    swapl(&stuff->cursor);
358    swapl(&stuff->time);
359    swaps(&stuff->eventMask);
360    return ((*ProcVector[X_ChangeActivePointerGrab]) (client));
361}
362
363int _X_COLD
364SProcGrabKeyboard(ClientPtr client)
365{
366    REQUEST(xGrabKeyboardReq);
367    swaps(&stuff->length);
368    REQUEST_SIZE_MATCH(xGrabKeyboardReq);
369    swapl(&stuff->grabWindow);
370    swapl(&stuff->time);
371    return ((*ProcVector[X_GrabKeyboard]) (client));
372}
373
374int _X_COLD
375SProcGrabKey(ClientPtr client)
376{
377    REQUEST(xGrabKeyReq);
378    swaps(&stuff->length);
379    REQUEST_SIZE_MATCH(xGrabKeyReq);
380    swapl(&stuff->grabWindow);
381    swaps(&stuff->modifiers);
382    return ((*ProcVector[X_GrabKey]) (client));
383}
384
385int _X_COLD
386SProcUngrabKey(ClientPtr client)
387{
388    REQUEST(xUngrabKeyReq);
389    swaps(&stuff->length);
390    REQUEST_SIZE_MATCH(xUngrabKeyReq);
391    swapl(&stuff->grabWindow);
392    swaps(&stuff->modifiers);
393    return ((*ProcVector[X_UngrabKey]) (client));
394}
395
396int _X_COLD
397SProcGetMotionEvents(ClientPtr client)
398{
399    REQUEST(xGetMotionEventsReq);
400    swaps(&stuff->length);
401    REQUEST_SIZE_MATCH(xGetMotionEventsReq);
402    swapl(&stuff->window);
403    swapl(&stuff->start);
404    swapl(&stuff->stop);
405    return ((*ProcVector[X_GetMotionEvents]) (client));
406}
407
408int _X_COLD
409SProcTranslateCoords(ClientPtr client)
410{
411    REQUEST(xTranslateCoordsReq);
412    swaps(&stuff->length);
413    REQUEST_SIZE_MATCH(xTranslateCoordsReq);
414    swapl(&stuff->srcWid);
415    swapl(&stuff->dstWid);
416    swaps(&stuff->srcX);
417    swaps(&stuff->srcY);
418    return ((*ProcVector[X_TranslateCoords]) (client));
419}
420
421int _X_COLD
422SProcWarpPointer(ClientPtr client)
423{
424    REQUEST(xWarpPointerReq);
425    swaps(&stuff->length);
426    REQUEST_SIZE_MATCH(xWarpPointerReq);
427    swapl(&stuff->srcWid);
428    swapl(&stuff->dstWid);
429    swaps(&stuff->srcX);
430    swaps(&stuff->srcY);
431    swaps(&stuff->srcWidth);
432    swaps(&stuff->srcHeight);
433    swaps(&stuff->dstX);
434    swaps(&stuff->dstY);
435    return ((*ProcVector[X_WarpPointer]) (client));
436}
437
438int _X_COLD
439SProcSetInputFocus(ClientPtr client)
440{
441    REQUEST(xSetInputFocusReq);
442    swaps(&stuff->length);
443    REQUEST_SIZE_MATCH(xSetInputFocusReq);
444    swapl(&stuff->focus);
445    swapl(&stuff->time);
446    return ((*ProcVector[X_SetInputFocus]) (client));
447}
448
449int _X_COLD
450SProcOpenFont(ClientPtr client)
451{
452    REQUEST(xOpenFontReq);
453    swaps(&stuff->length);
454    REQUEST_AT_LEAST_SIZE(xOpenFontReq);
455    swapl(&stuff->fid);
456    swaps(&stuff->nbytes);
457    return ((*ProcVector[X_OpenFont]) (client));
458}
459
460int _X_COLD
461SProcListFonts(ClientPtr client)
462{
463    REQUEST(xListFontsReq);
464    swaps(&stuff->length);
465    REQUEST_AT_LEAST_SIZE(xListFontsReq);
466    swaps(&stuff->maxNames);
467    swaps(&stuff->nbytes);
468    return ((*ProcVector[X_ListFonts]) (client));
469}
470
471int _X_COLD
472SProcListFontsWithInfo(ClientPtr client)
473{
474    REQUEST(xListFontsWithInfoReq);
475    swaps(&stuff->length);
476    REQUEST_AT_LEAST_SIZE(xListFontsWithInfoReq);
477    swaps(&stuff->maxNames);
478    swaps(&stuff->nbytes);
479    return ((*ProcVector[X_ListFontsWithInfo]) (client));
480}
481
482int _X_COLD
483SProcSetFontPath(ClientPtr client)
484{
485    REQUEST(xSetFontPathReq);
486    swaps(&stuff->length);
487    REQUEST_AT_LEAST_SIZE(xSetFontPathReq);
488    swaps(&stuff->nFonts);
489    return ((*ProcVector[X_SetFontPath]) (client));
490}
491
492int _X_COLD
493SProcCreatePixmap(ClientPtr client)
494{
495    REQUEST(xCreatePixmapReq);
496
497    swaps(&stuff->length);
498    REQUEST_SIZE_MATCH(xCreatePixmapReq);
499    swapl(&stuff->pid);
500    swapl(&stuff->drawable);
501    swaps(&stuff->width);
502    swaps(&stuff->height);
503    return ((*ProcVector[X_CreatePixmap]) (client));
504}
505
506int _X_COLD
507SProcCreateGC(ClientPtr client)
508{
509    REQUEST(xCreateGCReq);
510    swaps(&stuff->length);
511    REQUEST_AT_LEAST_SIZE(xCreateGCReq);
512    swapl(&stuff->gc);
513    swapl(&stuff->drawable);
514    swapl(&stuff->mask);
515    SwapRestL(stuff);
516    return ((*ProcVector[X_CreateGC]) (client));
517}
518
519int _X_COLD
520SProcChangeGC(ClientPtr client)
521{
522    REQUEST(xChangeGCReq);
523    swaps(&stuff->length);
524    REQUEST_AT_LEAST_SIZE(xChangeGCReq);
525    swapl(&stuff->gc);
526    swapl(&stuff->mask);
527    SwapRestL(stuff);
528    return ((*ProcVector[X_ChangeGC]) (client));
529}
530
531int _X_COLD
532SProcCopyGC(ClientPtr client)
533{
534    REQUEST(xCopyGCReq);
535    swaps(&stuff->length);
536    REQUEST_SIZE_MATCH(xCopyGCReq);
537    swapl(&stuff->srcGC);
538    swapl(&stuff->dstGC);
539    swapl(&stuff->mask);
540    return ((*ProcVector[X_CopyGC]) (client));
541}
542
543int _X_COLD
544SProcSetDashes(ClientPtr client)
545{
546    REQUEST(xSetDashesReq);
547    swaps(&stuff->length);
548    REQUEST_AT_LEAST_SIZE(xSetDashesReq);
549    swapl(&stuff->gc);
550    swaps(&stuff->dashOffset);
551    swaps(&stuff->nDashes);
552    return ((*ProcVector[X_SetDashes]) (client));
553
554}
555
556int _X_COLD
557SProcSetClipRectangles(ClientPtr client)
558{
559    REQUEST(xSetClipRectanglesReq);
560    swaps(&stuff->length);
561    REQUEST_AT_LEAST_SIZE(xSetClipRectanglesReq);
562    swapl(&stuff->gc);
563    swaps(&stuff->xOrigin);
564    swaps(&stuff->yOrigin);
565    SwapRestS(stuff);
566    return ((*ProcVector[X_SetClipRectangles]) (client));
567}
568
569int _X_COLD
570SProcClearToBackground(ClientPtr client)
571{
572    REQUEST(xClearAreaReq);
573    swaps(&stuff->length);
574    REQUEST_SIZE_MATCH(xClearAreaReq);
575    swapl(&stuff->window);
576    swaps(&stuff->x);
577    swaps(&stuff->y);
578    swaps(&stuff->width);
579    swaps(&stuff->height);
580    return ((*ProcVector[X_ClearArea]) (client));
581}
582
583int _X_COLD
584SProcCopyArea(ClientPtr client)
585{
586    REQUEST(xCopyAreaReq);
587    swaps(&stuff->length);
588    REQUEST_SIZE_MATCH(xCopyAreaReq);
589    swapl(&stuff->srcDrawable);
590    swapl(&stuff->dstDrawable);
591    swapl(&stuff->gc);
592    swaps(&stuff->srcX);
593    swaps(&stuff->srcY);
594    swaps(&stuff->dstX);
595    swaps(&stuff->dstY);
596    swaps(&stuff->width);
597    swaps(&stuff->height);
598    return ((*ProcVector[X_CopyArea]) (client));
599}
600
601int _X_COLD
602SProcCopyPlane(ClientPtr client)
603{
604    REQUEST(xCopyPlaneReq);
605    swaps(&stuff->length);
606    REQUEST_SIZE_MATCH(xCopyPlaneReq);
607    swapl(&stuff->srcDrawable);
608    swapl(&stuff->dstDrawable);
609    swapl(&stuff->gc);
610    swaps(&stuff->srcX);
611    swaps(&stuff->srcY);
612    swaps(&stuff->dstX);
613    swaps(&stuff->dstY);
614    swaps(&stuff->width);
615    swaps(&stuff->height);
616    swapl(&stuff->bitPlane);
617    return ((*ProcVector[X_CopyPlane]) (client));
618}
619
620/* The following routine is used for all Poly drawing requests
621   (except FillPoly, which uses a different request format) */
622int _X_COLD
623SProcPoly(ClientPtr client)
624{
625    REQUEST(xPolyPointReq);
626    swaps(&stuff->length);
627    REQUEST_AT_LEAST_SIZE(xPolyPointReq);
628    swapl(&stuff->drawable);
629    swapl(&stuff->gc);
630    SwapRestS(stuff);
631    return ((*ProcVector[stuff->reqType]) (client));
632}
633
634/* cannot use SProcPoly for this one, because xFillPolyReq
635   is longer than xPolyPointReq, and we don't want to swap
636   the difference as shorts! */
637int _X_COLD
638SProcFillPoly(ClientPtr client)
639{
640    REQUEST(xFillPolyReq);
641    swaps(&stuff->length);
642    REQUEST_AT_LEAST_SIZE(xFillPolyReq);
643    swapl(&stuff->drawable);
644    swapl(&stuff->gc);
645    SwapRestS(stuff);
646    return ((*ProcVector[X_FillPoly]) (client));
647}
648
649int _X_COLD
650SProcPutImage(ClientPtr client)
651{
652    REQUEST(xPutImageReq);
653    swaps(&stuff->length);
654    REQUEST_AT_LEAST_SIZE(xPutImageReq);
655    swapl(&stuff->drawable);
656    swapl(&stuff->gc);
657    swaps(&stuff->width);
658    swaps(&stuff->height);
659    swaps(&stuff->dstX);
660    swaps(&stuff->dstY);
661    /* Image should already be swapped */
662    return ((*ProcVector[X_PutImage]) (client));
663
664}
665
666int _X_COLD
667SProcGetImage(ClientPtr client)
668{
669    REQUEST(xGetImageReq);
670    swaps(&stuff->length);
671    REQUEST_SIZE_MATCH(xGetImageReq);
672    swapl(&stuff->drawable);
673    swaps(&stuff->x);
674    swaps(&stuff->y);
675    swaps(&stuff->width);
676    swaps(&stuff->height);
677    swapl(&stuff->planeMask);
678    return ((*ProcVector[X_GetImage]) (client));
679}
680
681/* ProcPolyText used for both PolyText8 and PolyText16 */
682
683int _X_COLD
684SProcPolyText(ClientPtr client)
685{
686    REQUEST(xPolyTextReq);
687    swaps(&stuff->length);
688    REQUEST_AT_LEAST_SIZE(xPolyTextReq);
689    swapl(&stuff->drawable);
690    swapl(&stuff->gc);
691    swaps(&stuff->x);
692    swaps(&stuff->y);
693    return ((*ProcVector[stuff->reqType]) (client));
694}
695
696/* ProcImageText used for both ImageText8 and ImageText16 */
697
698int _X_COLD
699SProcImageText(ClientPtr client)
700{
701    REQUEST(xImageTextReq);
702    swaps(&stuff->length);
703    REQUEST_AT_LEAST_SIZE(xImageTextReq);
704    swapl(&stuff->drawable);
705    swapl(&stuff->gc);
706    swaps(&stuff->x);
707    swaps(&stuff->y);
708    return ((*ProcVector[stuff->reqType]) (client));
709}
710
711int _X_COLD
712SProcCreateColormap(ClientPtr client)
713{
714    REQUEST(xCreateColormapReq);
715    swaps(&stuff->length);
716    REQUEST_SIZE_MATCH(xCreateColormapReq);
717    swapl(&stuff->mid);
718    swapl(&stuff->window);
719    swapl(&stuff->visual);
720    return ((*ProcVector[X_CreateColormap]) (client));
721}
722
723int _X_COLD
724SProcCopyColormapAndFree(ClientPtr client)
725{
726    REQUEST(xCopyColormapAndFreeReq);
727    swaps(&stuff->length);
728    REQUEST_SIZE_MATCH(xCopyColormapAndFreeReq);
729    swapl(&stuff->mid);
730    swapl(&stuff->srcCmap);
731    return ((*ProcVector[X_CopyColormapAndFree]) (client));
732
733}
734
735int _X_COLD
736SProcAllocColor(ClientPtr client)
737{
738    REQUEST(xAllocColorReq);
739    swaps(&stuff->length);
740    REQUEST_SIZE_MATCH(xAllocColorReq);
741    swapl(&stuff->cmap);
742    swaps(&stuff->red);
743    swaps(&stuff->green);
744    swaps(&stuff->blue);
745    return ((*ProcVector[X_AllocColor]) (client));
746}
747
748int _X_COLD
749SProcAllocNamedColor(ClientPtr client)
750{
751    REQUEST(xAllocNamedColorReq);
752    swaps(&stuff->length);
753    REQUEST_AT_LEAST_SIZE(xAllocNamedColorReq);
754    swapl(&stuff->cmap);
755    swaps(&stuff->nbytes);
756    return ((*ProcVector[X_AllocNamedColor]) (client));
757}
758
759int _X_COLD
760SProcAllocColorCells(ClientPtr client)
761{
762    REQUEST(xAllocColorCellsReq);
763    swaps(&stuff->length);
764    REQUEST_SIZE_MATCH(xAllocColorCellsReq);
765    swapl(&stuff->cmap);
766    swaps(&stuff->colors);
767    swaps(&stuff->planes);
768    return ((*ProcVector[X_AllocColorCells]) (client));
769}
770
771int _X_COLD
772SProcAllocColorPlanes(ClientPtr client)
773{
774    REQUEST(xAllocColorPlanesReq);
775    swaps(&stuff->length);
776    REQUEST_SIZE_MATCH(xAllocColorPlanesReq);
777    swapl(&stuff->cmap);
778    swaps(&stuff->colors);
779    swaps(&stuff->red);
780    swaps(&stuff->green);
781    swaps(&stuff->blue);
782    return ((*ProcVector[X_AllocColorPlanes]) (client));
783}
784
785int _X_COLD
786SProcFreeColors(ClientPtr client)
787{
788    REQUEST(xFreeColorsReq);
789    swaps(&stuff->length);
790    REQUEST_AT_LEAST_SIZE(xFreeColorsReq);
791    swapl(&stuff->cmap);
792    swapl(&stuff->planeMask);
793    SwapRestL(stuff);
794    return ((*ProcVector[X_FreeColors]) (client));
795
796}
797
798void _X_COLD
799SwapColorItem(xColorItem * pItem)
800{
801    swapl(&pItem->pixel);
802    swaps(&pItem->red);
803    swaps(&pItem->green);
804    swaps(&pItem->blue);
805}
806
807int _X_COLD
808SProcStoreColors(ClientPtr client)
809{
810    long count;
811    xColorItem *pItem;
812
813    REQUEST(xStoreColorsReq);
814    swaps(&stuff->length);
815    REQUEST_AT_LEAST_SIZE(xStoreColorsReq);
816    swapl(&stuff->cmap);
817    pItem = (xColorItem *) &stuff[1];
818    for (count = LengthRestB(stuff) / sizeof(xColorItem); --count >= 0;)
819        SwapColorItem(pItem++);
820    return ((*ProcVector[X_StoreColors]) (client));
821}
822
823int _X_COLD
824SProcStoreNamedColor(ClientPtr client)
825{
826    REQUEST(xStoreNamedColorReq);
827    swaps(&stuff->length);
828    REQUEST_AT_LEAST_SIZE(xStoreNamedColorReq);
829    swapl(&stuff->cmap);
830    swapl(&stuff->pixel);
831    swaps(&stuff->nbytes);
832    return ((*ProcVector[X_StoreNamedColor]) (client));
833}
834
835int _X_COLD
836SProcQueryColors(ClientPtr client)
837{
838    REQUEST(xQueryColorsReq);
839    swaps(&stuff->length);
840    REQUEST_AT_LEAST_SIZE(xQueryColorsReq);
841    swapl(&stuff->cmap);
842    SwapRestL(stuff);
843    return ((*ProcVector[X_QueryColors]) (client));
844}
845
846int _X_COLD
847SProcLookupColor(ClientPtr client)
848{
849    REQUEST(xLookupColorReq);
850    swaps(&stuff->length);
851    REQUEST_AT_LEAST_SIZE(xLookupColorReq);
852    swapl(&stuff->cmap);
853    swaps(&stuff->nbytes);
854    return ((*ProcVector[X_LookupColor]) (client));
855}
856
857int _X_COLD
858SProcCreateCursor(ClientPtr client)
859{
860    REQUEST(xCreateCursorReq);
861    swaps(&stuff->length);
862    REQUEST_SIZE_MATCH(xCreateCursorReq);
863    swapl(&stuff->cid);
864    swapl(&stuff->source);
865    swapl(&stuff->mask);
866    swaps(&stuff->foreRed);
867    swaps(&stuff->foreGreen);
868    swaps(&stuff->foreBlue);
869    swaps(&stuff->backRed);
870    swaps(&stuff->backGreen);
871    swaps(&stuff->backBlue);
872    swaps(&stuff->x);
873    swaps(&stuff->y);
874    return ((*ProcVector[X_CreateCursor]) (client));
875}
876
877int _X_COLD
878SProcCreateGlyphCursor(ClientPtr client)
879{
880    REQUEST(xCreateGlyphCursorReq);
881    swaps(&stuff->length);
882    REQUEST_SIZE_MATCH(xCreateGlyphCursorReq);
883    swapl(&stuff->cid);
884    swapl(&stuff->source);
885    swapl(&stuff->mask);
886    swaps(&stuff->sourceChar);
887    swaps(&stuff->maskChar);
888    swaps(&stuff->foreRed);
889    swaps(&stuff->foreGreen);
890    swaps(&stuff->foreBlue);
891    swaps(&stuff->backRed);
892    swaps(&stuff->backGreen);
893    swaps(&stuff->backBlue);
894    return ((*ProcVector[X_CreateGlyphCursor]) (client));
895}
896
897int _X_COLD
898SProcRecolorCursor(ClientPtr client)
899{
900    REQUEST(xRecolorCursorReq);
901    swaps(&stuff->length);
902    REQUEST_SIZE_MATCH(xRecolorCursorReq);
903    swapl(&stuff->cursor);
904    swaps(&stuff->foreRed);
905    swaps(&stuff->foreGreen);
906    swaps(&stuff->foreBlue);
907    swaps(&stuff->backRed);
908    swaps(&stuff->backGreen);
909    swaps(&stuff->backBlue);
910    return ((*ProcVector[X_RecolorCursor]) (client));
911}
912
913int _X_COLD
914SProcQueryBestSize(ClientPtr client)
915{
916    REQUEST(xQueryBestSizeReq);
917    swaps(&stuff->length);
918    REQUEST_SIZE_MATCH(xQueryBestSizeReq);
919    swapl(&stuff->drawable);
920    swaps(&stuff->width);
921    swaps(&stuff->height);
922    return ((*ProcVector[X_QueryBestSize]) (client));
923
924}
925
926int _X_COLD
927SProcQueryExtension(ClientPtr client)
928{
929    REQUEST(xQueryExtensionReq);
930    swaps(&stuff->length);
931    REQUEST_AT_LEAST_SIZE(xQueryExtensionReq);
932    swaps(&stuff->nbytes);
933    return ((*ProcVector[X_QueryExtension]) (client));
934}
935
936int _X_COLD
937SProcChangeKeyboardMapping(ClientPtr client)
938{
939    REQUEST(xChangeKeyboardMappingReq);
940    swaps(&stuff->length);
941    REQUEST_AT_LEAST_SIZE(xChangeKeyboardMappingReq);
942    SwapRestL(stuff);
943    return ((*ProcVector[X_ChangeKeyboardMapping]) (client));
944}
945
946int _X_COLD
947SProcChangeKeyboardControl(ClientPtr client)
948{
949    REQUEST(xChangeKeyboardControlReq);
950    swaps(&stuff->length);
951    REQUEST_AT_LEAST_SIZE(xChangeKeyboardControlReq);
952    swapl(&stuff->mask);
953    SwapRestL(stuff);
954    return ((*ProcVector[X_ChangeKeyboardControl]) (client));
955}
956
957int _X_COLD
958SProcChangePointerControl(ClientPtr client)
959{
960    REQUEST(xChangePointerControlReq);
961    swaps(&stuff->length);
962    REQUEST_SIZE_MATCH(xChangePointerControlReq);
963    swaps(&stuff->accelNum);
964    swaps(&stuff->accelDenum);
965    swaps(&stuff->threshold);
966    return ((*ProcVector[X_ChangePointerControl]) (client));
967}
968
969int _X_COLD
970SProcSetScreenSaver(ClientPtr client)
971{
972    REQUEST(xSetScreenSaverReq);
973    swaps(&stuff->length);
974    REQUEST_SIZE_MATCH(xSetScreenSaverReq);
975    swaps(&stuff->timeout);
976    swaps(&stuff->interval);
977    return ((*ProcVector[X_SetScreenSaver]) (client));
978}
979
980int _X_COLD
981SProcChangeHosts(ClientPtr client)
982{
983    REQUEST(xChangeHostsReq);
984    swaps(&stuff->length);
985    REQUEST_AT_LEAST_SIZE(xChangeHostsReq);
986    swaps(&stuff->hostLength);
987    return ((*ProcVector[X_ChangeHosts]) (client));
988
989}
990
991int _X_COLD
992SProcRotateProperties(ClientPtr client)
993{
994    REQUEST(xRotatePropertiesReq);
995    swaps(&stuff->length);
996    REQUEST_AT_LEAST_SIZE(xRotatePropertiesReq);
997    swapl(&stuff->window);
998    swaps(&stuff->nAtoms);
999    swaps(&stuff->nPositions);
1000    SwapRestL(stuff);
1001    return ((*ProcVector[X_RotateProperties]) (client));
1002}
1003
1004int _X_COLD
1005SProcNoOperation(ClientPtr client)
1006{
1007    REQUEST(xReq);
1008    swaps(&stuff->length);
1009    return ((*ProcVector[X_NoOperation]) (client));
1010}
1011
1012void _X_COLD
1013SwapConnClientPrefix(xConnClientPrefix * pCCP)
1014{
1015    swaps(&pCCP->majorVersion);
1016    swaps(&pCCP->minorVersion);
1017    swaps(&pCCP->nbytesAuthProto);
1018    swaps(&pCCP->nbytesAuthString);
1019}
1020