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