[deb_xorg-server.git] / randr / rrsdispatch.c

/*
 * Copyright © 2006 Keith Packard
 *
 * Permission to use, copy, modify, distribute, and sell this software and its
 * documentation for any purpose is hereby granted without fee, provided that
 * the above copyright notice appear in all copies and that both that copyright
 * notice and this permission notice appear in supporting documentation, and
 * that the name of the copyright holders not be used in advertising or
 * publicity pertaining to distribution of the software without specific,
 * written prior permission.  The copyright holders make no representations
 * about the suitability of this software for any purpose.  It is provided "as
 * is" without express or implied warranty.
 *
 * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
 * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
 * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY SPECIAL, INDIRECT OR
 * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
 * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
 * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
 * OF THIS SOFTWARE.
 */

#include "randrstr.h"

static int
SProcRRQueryVersion(ClientPtr client)
{
    REQUEST(xRRQueryVersionReq);

    swaps(&stuff->length);
    swapl(&stuff->majorVersion);
    swapl(&stuff->minorVersion);
    return (*ProcRandrVector[stuff->randrReqType]) (client);
}

static int
SProcRRGetScreenInfo(ClientPtr client)
{
    REQUEST(xRRGetScreenInfoReq);

    swaps(&stuff->length);
    swapl(&stuff->window);
    return (*ProcRandrVector[stuff->randrReqType]) (client);
}

static int
SProcRRSetScreenConfig(ClientPtr client)
{
    REQUEST(xRRSetScreenConfigReq);

    if (RRClientKnowsRates(client)) {
        REQUEST_SIZE_MATCH(xRRSetScreenConfigReq);
        swaps(&stuff->rate);
    }
    else {
        REQUEST_SIZE_MATCH(xRR1_0SetScreenConfigReq);
    }

    swaps(&stuff->length);
    swapl(&stuff->drawable);
    swapl(&stuff->timestamp);
    swaps(&stuff->sizeID);
    swaps(&stuff->rotation);
    return (*ProcRandrVector[stuff->randrReqType]) (client);
}

static int
SProcRRSelectInput(ClientPtr client)
{
    REQUEST(xRRSelectInputReq);

    swaps(&stuff->length);
    swapl(&stuff->window);
    swaps(&stuff->enable);
    return (*ProcRandrVector[stuff->randrReqType]) (client);
}

static int
SProcRRGetScreenSizeRange(ClientPtr client)
{
    REQUEST(xRRGetScreenSizeRangeReq);

    REQUEST_SIZE_MATCH(xRRGetScreenSizeRangeReq);
    swaps(&stuff->length);
    swapl(&stuff->window);
    return (*ProcRandrVector[stuff->randrReqType]) (client);
}

static int
SProcRRSetScreenSize(ClientPtr client)
{
    REQUEST(xRRSetScreenSizeReq);

    REQUEST_SIZE_MATCH(xRRSetScreenSizeReq);
    swaps(&stuff->length);
    swapl(&stuff->window);
    swaps(&stuff->width);
    swaps(&stuff->height);
    swapl(&stuff->widthInMillimeters);
    swapl(&stuff->heightInMillimeters);
    return (*ProcRandrVector[stuff->randrReqType]) (client);
}

static int
SProcRRGetScreenResources(ClientPtr client)
{
    REQUEST(xRRGetScreenResourcesReq);

    REQUEST_SIZE_MATCH(xRRGetScreenResourcesReq);
    swaps(&stuff->length);
    swapl(&stuff->window);
    return (*ProcRandrVector[stuff->randrReqType]) (client);
}

static int
SProcRRGetOutputInfo(ClientPtr client)
{
    REQUEST(xRRGetOutputInfoReq);

    REQUEST_SIZE_MATCH(xRRGetOutputInfoReq);
    swaps(&stuff->length);
    swapl(&stuff->output);
    swapl(&stuff->configTimestamp);
    return (*ProcRandrVector[stuff->randrReqType]) (client);
}

static int
SProcRRListOutputProperties(ClientPtr client)
{
    REQUEST(xRRListOutputPropertiesReq);

    REQUEST_SIZE_MATCH(xRRListOutputPropertiesReq);
    swaps(&stuff->length);
    swapl(&stuff->output);
    return (*ProcRandrVector[stuff->randrReqType]) (client);
}

static int
SProcRRQueryOutputProperty(ClientPtr client)
{
    REQUEST(xRRQueryOutputPropertyReq);

    REQUEST_SIZE_MATCH(xRRQueryOutputPropertyReq);
    swaps(&stuff->length);
    swapl(&stuff->output);
    swapl(&stuff->property);
    return (*ProcRandrVector[stuff->randrReqType]) (client);
}

static int
SProcRRConfigureOutputProperty(ClientPtr client)
{
    REQUEST(xRRConfigureOutputPropertyReq);

    swaps(&stuff->length);
    swapl(&stuff->output);
    swapl(&stuff->property);
    SwapRestL(stuff);
    return (*ProcRandrVector[stuff->randrReqType]) (client);
}

static int
SProcRRChangeOutputProperty(ClientPtr client)
{
    REQUEST(xRRChangeOutputPropertyReq);

    REQUEST_AT_LEAST_SIZE(xRRChangeOutputPropertyReq);
    swaps(&stuff->length);
    swapl(&stuff->output);
    swapl(&stuff->property);
    swapl(&stuff->type);
    swapl(&stuff->nUnits);
    switch (stuff->format) {
    case 8:
        break;
    case 16:
        SwapRestS(stuff);
        break;
    case 32:
        SwapRestL(stuff);
        break;
    default:
        client->errorValue = stuff->format;
        return BadValue;
    }
    return (*ProcRandrVector[stuff->randrReqType]) (client);
}

static int
SProcRRDeleteOutputProperty(ClientPtr client)
{
    REQUEST(xRRDeleteOutputPropertyReq);

    REQUEST_SIZE_MATCH(xRRDeleteOutputPropertyReq);
    swaps(&stuff->length);
    swapl(&stuff->output);
    swapl(&stuff->property);
    return (*ProcRandrVector[stuff->randrReqType]) (client);
}

static int
SProcRRGetOutputProperty(ClientPtr client)
{
    REQUEST(xRRGetOutputPropertyReq);

    REQUEST_SIZE_MATCH(xRRGetOutputPropertyReq);
    swaps(&stuff->length);
    swapl(&stuff->output);
    swapl(&stuff->property);
    swapl(&stuff->type);
    swapl(&stuff->longOffset);
    swapl(&stuff->longLength);
    return (*ProcRandrVector[stuff->randrReqType]) (client);
}

static int
SProcRRCreateMode(ClientPtr client)
{
    xRRModeInfo *modeinfo;

    REQUEST(xRRCreateModeReq);

    REQUEST_AT_LEAST_SIZE(xRRCreateModeReq);
    swaps(&stuff->length);
    swapl(&stuff->window);

    modeinfo = &stuff->modeInfo;
    swapl(&modeinfo->id);
    swaps(&modeinfo->width);
    swaps(&modeinfo->height);
    swapl(&modeinfo->dotClock);
    swaps(&modeinfo->hSyncStart);
    swaps(&modeinfo->hSyncEnd);
    swaps(&modeinfo->hTotal);
    swaps(&modeinfo->vSyncStart);
    swaps(&modeinfo->vSyncEnd);
    swaps(&modeinfo->vTotal);
    swaps(&modeinfo->nameLength);
    swapl(&modeinfo->modeFlags);
    return (*ProcRandrVector[stuff->randrReqType]) (client);
}

static int
SProcRRDestroyMode(ClientPtr client)
{
    REQUEST(xRRDestroyModeReq);

    REQUEST_SIZE_MATCH(xRRDestroyModeReq);
    swaps(&stuff->length);
    swapl(&stuff->mode);
    return (*ProcRandrVector[stuff->randrReqType]) (client);
}

static int
SProcRRAddOutputMode(ClientPtr client)
{
    REQUEST(xRRAddOutputModeReq);

    REQUEST_SIZE_MATCH(xRRAddOutputModeReq);
    swaps(&stuff->length);
    swapl(&stuff->output);
    swapl(&stuff->mode);
    return (*ProcRandrVector[stuff->randrReqType]) (client);
}

static int
SProcRRDeleteOutputMode(ClientPtr client)
{
    REQUEST(xRRDeleteOutputModeReq);

    REQUEST_SIZE_MATCH(xRRDeleteOutputModeReq);
    swaps(&stuff->length);
    swapl(&stuff->output);
    swapl(&stuff->mode);
    return (*ProcRandrVector[stuff->randrReqType]) (client);
}

static int
SProcRRGetCrtcInfo(ClientPtr client)
{
    REQUEST(xRRGetCrtcInfoReq);

    REQUEST_SIZE_MATCH(xRRGetCrtcInfoReq);
    swaps(&stuff->length);
    swapl(&stuff->crtc);
    swapl(&stuff->configTimestamp);
    return (*ProcRandrVector[stuff->randrReqType]) (client);
}

static int
SProcRRSetCrtcConfig(ClientPtr client)
{
    REQUEST(xRRSetCrtcConfigReq);

    REQUEST_AT_LEAST_SIZE(xRRSetCrtcConfigReq);
    swaps(&stuff->length);
    swapl(&stuff->crtc);
    swapl(&stuff->timestamp);
    swapl(&stuff->configTimestamp);
    swaps(&stuff->x);
    swaps(&stuff->y);
    swapl(&stuff->mode);
    swaps(&stuff->rotation);
    SwapRestL(stuff);
    return (*ProcRandrVector[stuff->randrReqType]) (client);
}

static int
SProcRRGetCrtcGammaSize(ClientPtr client)
{
    REQUEST(xRRGetCrtcGammaSizeReq);

    REQUEST_SIZE_MATCH(xRRGetCrtcGammaSizeReq);
    swaps(&stuff->length);
    swapl(&stuff->crtc);
    return (*ProcRandrVector[stuff->randrReqType]) (client);
}

static int
SProcRRGetCrtcGamma(ClientPtr client)
{
    REQUEST(xRRGetCrtcGammaReq);

    REQUEST_SIZE_MATCH(xRRGetCrtcGammaReq);
    swaps(&stuff->length);
    swapl(&stuff->crtc);
    return (*ProcRandrVector[stuff->randrReqType]) (client);
}

static int
SProcRRSetCrtcGamma(ClientPtr client)
{
    REQUEST(xRRSetCrtcGammaReq);

    REQUEST_AT_LEAST_SIZE(xRRSetCrtcGammaReq);
    swaps(&stuff->length);
    swapl(&stuff->crtc);
    swaps(&stuff->size);
    SwapRestS(stuff);
    return (*ProcRandrVector[stuff->randrReqType]) (client);
}

static int
SProcRRSetCrtcTransform(ClientPtr client)
{
    int nparams;
    char *filter;
    CARD32 *params;

    REQUEST(xRRSetCrtcTransformReq);

    REQUEST_AT_LEAST_SIZE(xRRSetCrtcTransformReq);
    swaps(&stuff->length);
    swapl(&stuff->crtc);
    SwapLongs((CARD32 *) &stuff->transform,
              bytes_to_int32(sizeof(xRenderTransform)));
    swaps(&stuff->nbytesFilter);
    filter = (char *) (stuff + 1);
    params = (CARD32 *) (filter + pad_to_int32(stuff->nbytesFilter));
    nparams = ((CARD32 *) stuff + client->req_len) - params;
    if (nparams < 0)
        return BadLength;

    SwapLongs(params, nparams);
    return (*ProcRandrVector[stuff->randrReqType]) (client);
}

static int
SProcRRGetCrtcTransform(ClientPtr client)
{
    REQUEST(xRRGetCrtcTransformReq);

    REQUEST_SIZE_MATCH(xRRGetCrtcTransformReq);
    swaps(&stuff->length);
    swapl(&stuff->crtc);
    return (*ProcRandrVector[stuff->randrReqType]) (client);
}

static int
SProcRRGetPanning(ClientPtr client)
{
    REQUEST(xRRGetPanningReq);

    REQUEST_SIZE_MATCH(xRRGetPanningReq);
    swaps(&stuff->length);
    swapl(&stuff->crtc);
    return (*ProcRandrVector[stuff->randrReqType]) (client);
}

static int
SProcRRSetPanning(ClientPtr client)
{
    REQUEST(xRRSetPanningReq);

    REQUEST_SIZE_MATCH(xRRSetPanningReq);
    swaps(&stuff->length);
    swapl(&stuff->crtc);
    swapl(&stuff->timestamp);
    swaps(&stuff->left);
    swaps(&stuff->top);
    swaps(&stuff->width);
    swaps(&stuff->height);
    swaps(&stuff->track_left);
    swaps(&stuff->track_top);
    swaps(&stuff->track_width);
    swaps(&stuff->track_height);
    swaps(&stuff->border_left);
    swaps(&stuff->border_top);
    swaps(&stuff->border_right);
    swaps(&stuff->border_bottom);
    return (*ProcRandrVector[stuff->randrReqType]) (client);
}

static int
SProcRRSetOutputPrimary(ClientPtr client)
{
    REQUEST(xRRSetOutputPrimaryReq);

    REQUEST_SIZE_MATCH(xRRSetOutputPrimaryReq);
    swaps(&stuff->length);
    swapl(&stuff->window);
    swapl(&stuff->output);
    return ProcRandrVector[stuff->randrReqType] (client);
}

static int
SProcRRGetOutputPrimary(ClientPtr client)
{
    REQUEST(xRRGetOutputPrimaryReq);

    REQUEST_SIZE_MATCH(xRRGetOutputPrimaryReq);
    swaps(&stuff->length);
    swapl(&stuff->window);
    return ProcRandrVector[stuff->randrReqType] (client);
}

int (*SProcRandrVector[RRNumberRequests]) (ClientPtr) = {
    SProcRRQueryVersion,        /* 0 */
/* we skip 1 to make old clients fail pretty immediately */
        NULL,                   /* 1 SProcRandrOldGetScreenInfo */
/* V1.0 apps share the same set screen config request id */
        SProcRRSetScreenConfig, /* 2 */
        NULL,                   /* 3 SProcRandrOldScreenChangeSelectInput */
/* 3 used to be ScreenChangeSelectInput; deprecated */
        SProcRRSelectInput,     /* 4 */
        SProcRRGetScreenInfo,   /* 5 */
/* V1.2 additions */
        SProcRRGetScreenSizeRange,      /* 6 */
        SProcRRSetScreenSize,   /* 7 */
        SProcRRGetScreenResources,      /* 8 */
        SProcRRGetOutputInfo,   /* 9 */
        SProcRRListOutputProperties,    /* 10 */
        SProcRRQueryOutputProperty,     /* 11 */
        SProcRRConfigureOutputProperty, /* 12 */
        SProcRRChangeOutputProperty,    /* 13 */
        SProcRRDeleteOutputProperty,    /* 14 */
        SProcRRGetOutputProperty,       /* 15 */
        SProcRRCreateMode,      /* 16 */
        SProcRRDestroyMode,     /* 17 */
        SProcRRAddOutputMode,   /* 18 */
        SProcRRDeleteOutputMode,        /* 19 */
        SProcRRGetCrtcInfo,     /* 20 */
        SProcRRSetCrtcConfig,   /* 21 */
        SProcRRGetCrtcGammaSize,        /* 22 */
        SProcRRGetCrtcGamma,    /* 23 */
        SProcRRSetCrtcGamma,    /* 24 */
/* V1.3 additions */
        SProcRRGetScreenResources,      /* 25 GetScreenResourcesCurrent */
        SProcRRSetCrtcTransform,        /* 26 */
        SProcRRGetCrtcTransform,        /* 27 */
        SProcRRGetPanning,      /* 28 */
        SProcRRSetPanning,      /* 29 */
        SProcRRSetOutputPrimary,        /* 30 */
        SProcRRGetOutputPrimary,        /* 31 */
};
Commit	Line	Data
a09e091a JB	1	/*
	2	* Copyright © 2006 Keith Packard
	3	*
	4	* Permission to use, copy, modify, distribute, and sell this software and its
	5	* documentation for any purpose is hereby granted without fee, provided that
	6	* the above copyright notice appear in all copies and that both that copyright
	7	* notice and this permission notice appear in supporting documentation, and
	8	* that the name of the copyright holders not be used in advertising or
	9	* publicity pertaining to distribution of the software without specific,
	10	* written prior permission. The copyright holders make no representations
	11	* about the suitability of this software for any purpose. It is provided "as
	12	* is" without express or implied warranty.
	13	*
	14	* THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
	15	* INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
	16	* EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY SPECIAL, INDIRECT OR
	17	* CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
	18	* DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
	19	* TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
	20	* OF THIS SOFTWARE.
	21	*/
	22
	23	#include "randrstr.h"
	24
	25	static int
	26	SProcRRQueryVersion(ClientPtr client)
	27	{
	28	REQUEST(xRRQueryVersionReq);
	29
	30	swaps(&stuff->length);
	31	swapl(&stuff->majorVersion);
	32	swapl(&stuff->minorVersion);
	33	return (*ProcRandrVector[stuff->randrReqType]) (client);
	34	}
	35
	36	static int
	37	SProcRRGetScreenInfo(ClientPtr client)
	38	{
	39	REQUEST(xRRGetScreenInfoReq);
	40
	41	swaps(&stuff->length);
	42	swapl(&stuff->window);
	43	return (*ProcRandrVector[stuff->randrReqType]) (client);
	44	}
	45
	46	static int
	47	SProcRRSetScreenConfig(ClientPtr client)
	48	{
	49	REQUEST(xRRSetScreenConfigReq);
	50
	51	if (RRClientKnowsRates(client)) {
	52	REQUEST_SIZE_MATCH(xRRSetScreenConfigReq);
	53	swaps(&stuff->rate);
	54	}
	55	else {
	56	REQUEST_SIZE_MATCH(xRR1_0SetScreenConfigReq);
	57	}
	58
	59	swaps(&stuff->length);
	60	swapl(&stuff->drawable);
	61	swapl(&stuff->timestamp);
	62	swaps(&stuff->sizeID);
	63	swaps(&stuff->rotation);
	64	return (*ProcRandrVector[stuff->randrReqType]) (client);
65	}
66
67	static int
68	SProcRRSelectInput(ClientPtr client)
69	{
70	REQUEST(xRRSelectInputReq);
71
72	swaps(&stuff->length);
73	swapl(&stuff->window);
74	swaps(&stuff->enable);
75	return (*ProcRandrVector[stuff->randrReqType]) (client);
76	}
77
78	static int
79	SProcRRGetScreenSizeRange(ClientPtr client)
80	{
81	REQUEST(xRRGetScreenSizeRangeReq);
82
83	REQUEST_SIZE_MATCH(xRRGetScreenSizeRangeReq);
84	swaps(&stuff->length);
85	swapl(&stuff->window);
86	return (*ProcRandrVector[stuff->randrReqType]) (client);
87	}
88
89	static int
90	SProcRRSetScreenSize(ClientPtr client)
91	{
92	REQUEST(xRRSetScreenSizeReq);
93
94	REQUEST_SIZE_MATCH(xRRSetScreenSizeReq);
95	swaps(&stuff->length);
96	swapl(&stuff->window);
97	swaps(&stuff->width);
98	swaps(&stuff->height);
99	swapl(&stuff->widthInMillimeters);
100	swapl(&stuff->heightInMillimeters);
101	return (*ProcRandrVector[stuff->randrReqType]) (client);
102	}
103
104	static int
105	SProcRRGetScreenResources(ClientPtr client)
106	{
107	REQUEST(xRRGetScreenResourcesReq);
108
109	REQUEST_SIZE_MATCH(xRRGetScreenResourcesReq);
110	swaps(&stuff->length);
111	swapl(&stuff->window);
112	return (*ProcRandrVector[stuff->randrReqType]) (client);
113	}
114
115	static int
116	SProcRRGetOutputInfo(ClientPtr client)
117	{
118	REQUEST(xRRGetOutputInfoReq);
119
120	REQUEST_SIZE_MATCH(xRRGetOutputInfoReq);
121	swaps(&stuff->length);
122	swapl(&stuff->output);
123	swapl(&stuff->configTimestamp);
124	return (*ProcRandrVector[stuff->randrReqType]) (client);
125	}
126
127	static int
128	SProcRRListOutputProperties(ClientPtr client)
129	{
130	REQUEST(xRRListOutputPropertiesReq);
131
132	REQUEST_SIZE_MATCH(xRRListOutputPropertiesReq);
133	swaps(&stuff->length);
134	swapl(&stuff->output);
135	return (*ProcRandrVector[stuff->randrReqType]) (client);
136	}
137
138	static int
139	SProcRRQueryOutputProperty(ClientPtr client)
140	{
141	REQUEST(xRRQueryOutputPropertyReq);
142
143	REQUEST_SIZE_MATCH(xRRQueryOutputPropertyReq);
144	swaps(&stuff->length);
145	swapl(&stuff->output);
146	swapl(&stuff->property);
147	return (*ProcRandrVector[stuff->randrReqType]) (client);
148	}
149
150	static int
151	SProcRRConfigureOutputProperty(ClientPtr client)
152	{
153	REQUEST(xRRConfigureOutputPropertyReq);
154
155	swaps(&stuff->length);
156	swapl(&stuff->output);
157	swapl(&stuff->property);
158	SwapRestL(stuff);
159	return (*ProcRandrVector[stuff->randrReqType]) (client);
160	}
161
162	static int
163	SProcRRChangeOutputProperty(ClientPtr client)
164	{
165	REQUEST(xRRChangeOutputPropertyReq);
166
167	REQUEST_AT_LEAST_SIZE(xRRChangeOutputPropertyReq);
168	swaps(&stuff->length);
169	swapl(&stuff->output);
170	swapl(&stuff->property);
171	swapl(&stuff->type);
172	swapl(&stuff->nUnits);
173	switch (stuff->format) {
174	case 8:
175	break;
176	case 16:
177	SwapRestS(stuff);
178	break;
179	case 32:
180	SwapRestL(stuff);
181	break;
182	default:
183	client->errorValue = stuff->format;
184	return BadValue;
185	}
186	return (*ProcRandrVector[stuff->randrReqType]) (client);
187	}
188
189	static int
190	SProcRRDeleteOutputProperty(ClientPtr client)
191	{
192	REQUEST(xRRDeleteOutputPropertyReq);
193
194	REQUEST_SIZE_MATCH(xRRDeleteOutputPropertyReq);
195	swaps(&stuff->length);
196	swapl(&stuff->output);
197	swapl(&stuff->property);
198	return (*ProcRandrVector[stuff->randrReqType]) (client);
199	}
200
201	static int
202	SProcRRGetOutputProperty(ClientPtr client)
203	{
204	REQUEST(xRRGetOutputPropertyReq);
205
206	REQUEST_SIZE_MATCH(xRRGetOutputPropertyReq);
207	swaps(&stuff->length);
208	swapl(&stuff->output);
209	swapl(&stuff->property);
210	swapl(&stuff->type);
211	swapl(&stuff->longOffset);
212	swapl(&stuff->longLength);
213	return (*ProcRandrVector[stuff->randrReqType]) (client);
214	}
215
216	static int
217	SProcRRCreateMode(ClientPtr client)
218	{
219	xRRModeInfo *modeinfo;
220
221	REQUEST(xRRCreateModeReq);
222
223	REQUEST_AT_LEAST_SIZE(xRRCreateModeReq);
224	swaps(&stuff->length);
225	swapl(&stuff->window);
226
227	modeinfo = &stuff->modeInfo;
228	swapl(&modeinfo->id);
229	swaps(&modeinfo->width);
230	swaps(&modeinfo->height);
231	swapl(&modeinfo->dotClock);
232	swaps(&modeinfo->hSyncStart);
233	swaps(&modeinfo->hSyncEnd);
234	swaps(&modeinfo->hTotal);
235	swaps(&modeinfo->vSyncStart);
236	swaps(&modeinfo->vSyncEnd);
237	swaps(&modeinfo->vTotal);
238	swaps(&modeinfo->nameLength);
239	swapl(&modeinfo->modeFlags);
240	return (*ProcRandrVector[stuff->randrReqType]) (client);
241	}
242
243	static int
244	SProcRRDestroyMode(ClientPtr client)
245	{
246	REQUEST(xRRDestroyModeReq);
247
248	REQUEST_SIZE_MATCH(xRRDestroyModeReq);
249	swaps(&stuff->length);
250	swapl(&stuff->mode);
251	return (*ProcRandrVector[stuff->randrReqType]) (client);
252	}
253
254	static int
255	SProcRRAddOutputMode(ClientPtr client)
256	{
257	REQUEST(xRRAddOutputModeReq);
258
259	REQUEST_SIZE_MATCH(xRRAddOutputModeReq);
260	swaps(&stuff->length);
261	swapl(&stuff->output);
262	swapl(&stuff->mode);
263	return (*ProcRandrVector[stuff->randrReqType]) (client);
264	}
265
266	static int
267	SProcRRDeleteOutputMode(ClientPtr client)
268	{
269	REQUEST(xRRDeleteOutputModeReq);
270
271	REQUEST_SIZE_MATCH(xRRDeleteOutputModeReq);
272	swaps(&stuff->length);
273	swapl(&stuff->output);
274	swapl(&stuff->mode);
275	return (*ProcRandrVector[stuff->randrReqType]) (client);
276	}
277
278	static int
279	SProcRRGetCrtcInfo(ClientPtr client)
280	{
281	REQUEST(xRRGetCrtcInfoReq);
282
283	REQUEST_SIZE_MATCH(xRRGetCrtcInfoReq);
284	swaps(&stuff->length);
285	swapl(&stuff->crtc);
286	swapl(&stuff->configTimestamp);
287	return (*ProcRandrVector[stuff->randrReqType]) (client);
288	}
289
290	static int
291	SProcRRSetCrtcConfig(ClientPtr client)
292	{
293	REQUEST(xRRSetCrtcConfigReq);
294
295	REQUEST_AT_LEAST_SIZE(xRRSetCrtcConfigReq);
296	swaps(&stuff->length);
297	swapl(&stuff->crtc);
298	swapl(&stuff->timestamp);
299	swapl(&stuff->configTimestamp);
300	swaps(&stuff->x);
301	swaps(&stuff->y);
302	swapl(&stuff->mode);
303	swaps(&stuff->rotation);
304	SwapRestL(stuff);
305	return (*ProcRandrVector[stuff->randrReqType]) (client);
306	}
307
308	static int
309	SProcRRGetCrtcGammaSize(ClientPtr client)
310	{
311	REQUEST(xRRGetCrtcGammaSizeReq);
312
313	REQUEST_SIZE_MATCH(xRRGetCrtcGammaSizeReq);
314	swaps(&stuff->length);
315	swapl(&stuff->crtc);
316	return (*ProcRandrVector[stuff->randrReqType]) (client);
317	}
318
319	static int
320	SProcRRGetCrtcGamma(ClientPtr client)
321	{
322	REQUEST(xRRGetCrtcGammaReq);
323
324	REQUEST_SIZE_MATCH(xRRGetCrtcGammaReq);
325	swaps(&stuff->length);
326	swapl(&stuff->crtc);
327	return (*ProcRandrVector[stuff->randrReqType]) (client);
328	}
329
330	static int
331	SProcRRSetCrtcGamma(ClientPtr client)
332	{
333	REQUEST(xRRSetCrtcGammaReq);
334
335	REQUEST_AT_LEAST_SIZE(xRRSetCrtcGammaReq);
336	swaps(&stuff->length);
337	swapl(&stuff->crtc);
338	swaps(&stuff->size);
339	SwapRestS(stuff);
340	return (*ProcRandrVector[stuff->randrReqType]) (client);
341	}
342
343	static int
344	SProcRRSetCrtcTransform(ClientPtr client)
345	{
346	int nparams;
347	char *filter;
348	CARD32 *params;
349
350	REQUEST(xRRSetCrtcTransformReq);
351
352	REQUEST_AT_LEAST_SIZE(xRRSetCrtcTransformReq);
353	swaps(&stuff->length);
354	swapl(&stuff->crtc);
355	SwapLongs((CARD32 *) &stuff->transform,
356	bytes_to_int32(sizeof(xRenderTransform)));
357	swaps(&stuff->nbytesFilter);
358	filter = (char *) (stuff + 1);
359	params = (CARD32 *) (filter + pad_to_int32(stuff->nbytesFilter));
360	nparams = ((CARD32 *) stuff + client->req_len) - params;
361	if (nparams < 0)
362	return BadLength;
363
364	SwapLongs(params, nparams);
365	return (*ProcRandrVector[stuff->randrReqType]) (client);
366	}
367
368	static int
369	SProcRRGetCrtcTransform(ClientPtr client)
370	{
371	REQUEST(xRRGetCrtcTransformReq);
372
373	REQUEST_SIZE_MATCH(xRRGetCrtcTransformReq);
374	swaps(&stuff->length);
375	swapl(&stuff->crtc);
376	return (*ProcRandrVector[stuff->randrReqType]) (client);
377	}
378
379	static int
380	SProcRRGetPanning(ClientPtr client)
381	{
382	REQUEST(xRRGetPanningReq);
383
384	REQUEST_SIZE_MATCH(xRRGetPanningReq);
385	swaps(&stuff->length);
386	swapl(&stuff->crtc);
387	return (*ProcRandrVector[stuff->randrReqType]) (client);
388	}
389
390	static int
391	SProcRRSetPanning(ClientPtr client)
392	{
393	REQUEST(xRRSetPanningReq);
394
395	REQUEST_SIZE_MATCH(xRRSetPanningReq);
396	swaps(&stuff->length);
397	swapl(&stuff->crtc);
398	swapl(&stuff->timestamp);
399	swaps(&stuff->left);
400	swaps(&stuff->top);
401	swaps(&stuff->width);
402	swaps(&stuff->height);
403	swaps(&stuff->track_left);
404	swaps(&stuff->track_top);
405	swaps(&stuff->track_width);
406	swaps(&stuff->track_height);
407	swaps(&stuff->border_left);
408	swaps(&stuff->border_top);
409	swaps(&stuff->border_right);
410	swaps(&stuff->border_bottom);
411	return (*ProcRandrVector[stuff->randrReqType]) (client);
412	}
413
414	static int
415	SProcRRSetOutputPrimary(ClientPtr client)
416	{
417	REQUEST(xRRSetOutputPrimaryReq);
418
419	REQUEST_SIZE_MATCH(xRRSetOutputPrimaryReq);
420	swaps(&stuff->length);
421	swapl(&stuff->window);
422	swapl(&stuff->output);
423	return ProcRandrVector[stuff->randrReqType] (client);
424	}
425
426	static int
427	SProcRRGetOutputPrimary(ClientPtr client)
428	{
429	REQUEST(xRRGetOutputPrimaryReq);
430
431	REQUEST_SIZE_MATCH(xRRGetOutputPrimaryReq);
432	swaps(&stuff->length);
433	swapl(&stuff->window);
434	return ProcRandrVector[stuff->randrReqType] (client);
435	}
436
437	int (*SProcRandrVector[RRNumberRequests]) (ClientPtr) = {
438	SProcRRQueryVersion, /* 0 */
439	/* we skip 1 to make old clients fail pretty immediately */
440	NULL, /* 1 SProcRandrOldGetScreenInfo */
441	/* V1.0 apps share the same set screen config request id */
442	SProcRRSetScreenConfig, /* 2 */
443	NULL, /* 3 SProcRandrOldScreenChangeSelectInput */
444	/* 3 used to be ScreenChangeSelectInput; deprecated */
445	SProcRRSelectInput, /* 4 */
446	SProcRRGetScreenInfo, /* 5 */
447	/* V1.2 additions */
448	SProcRRGetScreenSizeRange, /* 6 */
449	SProcRRSetScreenSize, /* 7 */
450	SProcRRGetScreenResources, /* 8 */
451	SProcRRGetOutputInfo, /* 9 */
452	SProcRRListOutputProperties, /* 10 */
453	SProcRRQueryOutputProperty, /* 11 */
454	SProcRRConfigureOutputProperty, /* 12 */
455	SProcRRChangeOutputProperty, /* 13 */
456	SProcRRDeleteOutputProperty, /* 14 */
457	SProcRRGetOutputProperty, /* 15 */
458	SProcRRCreateMode, /* 16 */
459	SProcRRDestroyMode, /* 17 */
460	SProcRRAddOutputMode, /* 18 */
461	SProcRRDeleteOutputMode, /* 19 */
462	SProcRRGetCrtcInfo, /* 20 */
463	SProcRRSetCrtcConfig, /* 21 */
464	SProcRRGetCrtcGammaSize, /* 22 */
465	SProcRRGetCrtcGamma, /* 23 */
466	SProcRRSetCrtcGamma, /* 24 */
467	/* V1.3 additions */
468	SProcRRGetScreenResources, /* 25 GetScreenResourcesCurrent */
469	SProcRRSetCrtcTransform, /* 26 */
470	SProcRRGetCrtcTransform, /* 27 */
471	SProcRRGetPanning, /* 28 */
472	SProcRRSetPanning, /* 29 */
473	SProcRRSetOutputPrimary, /* 30 */
474	SProcRRGetOutputPrimary, /* 31 */
475	};