1
2 #include <dix-config.h>
3 #include <dix.h>
4 #include "vndserver.h"
5
6 // HACK: The opcode in old glxproto.h has a typo in it.
7 #if !defined(X_GLXCreateContextAttribsARB)
8 #define X_GLXCreateContextAttribsARB X_GLXCreateContextAtrribsARB
9 #endif
10
dispatch_Render(ClientPtr client)11 static int dispatch_Render(ClientPtr client)
12 {
13 REQUEST(xGLXRenderReq);
14 CARD32 contextTag;
15 GlxServerVendor *vendor = NULL;
16 REQUEST_AT_LEAST_SIZE(*stuff);
17 contextTag = GlxCheckSwap(client, stuff->contextTag);
18 vendor = glxServer.getContextTag(client, contextTag);
19 if (vendor != NULL) {
20 int ret;
21 ret = glxServer.forwardRequest(vendor, client);
22 return ret;
23 } else {
24 client->errorValue = contextTag;
25 return GlxErrorBase + GLXBadContextTag;
26 }
27 }
dispatch_RenderLarge(ClientPtr client)28 static int dispatch_RenderLarge(ClientPtr client)
29 {
30 REQUEST(xGLXRenderLargeReq);
31 CARD32 contextTag;
32 GlxServerVendor *vendor = NULL;
33 REQUEST_AT_LEAST_SIZE(*stuff);
34 contextTag = GlxCheckSwap(client, stuff->contextTag);
35 vendor = glxServer.getContextTag(client, contextTag);
36 if (vendor != NULL) {
37 int ret;
38 ret = glxServer.forwardRequest(vendor, client);
39 return ret;
40 } else {
41 client->errorValue = contextTag;
42 return GlxErrorBase + GLXBadContextTag;
43 }
44 }
dispatch_CreateContext(ClientPtr client)45 static int dispatch_CreateContext(ClientPtr client)
46 {
47 REQUEST(xGLXCreateContextReq);
48 CARD32 screen, context;
49 GlxServerVendor *vendor = NULL;
50 REQUEST_SIZE_MATCH(*stuff);
51 screen = GlxCheckSwap(client, stuff->screen);
52 context = GlxCheckSwap(client, stuff->context);
53 LEGAL_NEW_RESOURCE(context, client);
54 if (screen < screenInfo.numScreens) {
55 vendor = glxServer.getVendorForScreen(client, screenInfo.screens[screen]);
56 }
57 if (vendor != NULL) {
58 int ret;
59 if (!glxServer.addXIDMap(context, vendor)) {
60 return BadAlloc;
61 }
62 ret = glxServer.forwardRequest(vendor, client);
63 if (ret != Success) {
64 glxServer.removeXIDMap(context);
65 }
66 return ret;
67 } else {
68 client->errorValue = screen;
69 return BadMatch;
70 }
71 }
dispatch_DestroyContext(ClientPtr client)72 static int dispatch_DestroyContext(ClientPtr client)
73 {
74 REQUEST(xGLXDestroyContextReq);
75 CARD32 context;
76 GlxServerVendor *vendor = NULL;
77 REQUEST_SIZE_MATCH(*stuff);
78 context = GlxCheckSwap(client, stuff->context);
79 vendor = glxServer.getXIDMap(context);
80 if (vendor != NULL) {
81 int ret;
82 ret = glxServer.forwardRequest(vendor, client);
83 if (ret == Success) {
84 glxServer.removeXIDMap(context);
85 }
86 return ret;
87 } else {
88 client->errorValue = context;
89 return GlxErrorBase + GLXBadContext;
90 }
91 }
dispatch_WaitGL(ClientPtr client)92 static int dispatch_WaitGL(ClientPtr client)
93 {
94 REQUEST(xGLXWaitGLReq);
95 CARD32 contextTag;
96 GlxServerVendor *vendor = NULL;
97 REQUEST_SIZE_MATCH(*stuff);
98 contextTag = GlxCheckSwap(client, stuff->contextTag);
99 vendor = glxServer.getContextTag(client, contextTag);
100 if (vendor != NULL) {
101 int ret;
102 ret = glxServer.forwardRequest(vendor, client);
103 return ret;
104 } else {
105 client->errorValue = contextTag;
106 return GlxErrorBase + GLXBadContextTag;
107 }
108 }
dispatch_WaitX(ClientPtr client)109 static int dispatch_WaitX(ClientPtr client)
110 {
111 REQUEST(xGLXWaitXReq);
112 CARD32 contextTag;
113 GlxServerVendor *vendor = NULL;
114 REQUEST_SIZE_MATCH(*stuff);
115 contextTag = GlxCheckSwap(client, stuff->contextTag);
116 vendor = glxServer.getContextTag(client, contextTag);
117 if (vendor != NULL) {
118 int ret;
119 ret = glxServer.forwardRequest(vendor, client);
120 return ret;
121 } else {
122 client->errorValue = contextTag;
123 return GlxErrorBase + GLXBadContextTag;
124 }
125 }
dispatch_UseXFont(ClientPtr client)126 static int dispatch_UseXFont(ClientPtr client)
127 {
128 REQUEST(xGLXUseXFontReq);
129 CARD32 contextTag;
130 GlxServerVendor *vendor = NULL;
131 REQUEST_SIZE_MATCH(*stuff);
132 contextTag = GlxCheckSwap(client, stuff->contextTag);
133 vendor = glxServer.getContextTag(client, contextTag);
134 if (vendor != NULL) {
135 int ret;
136 ret = glxServer.forwardRequest(vendor, client);
137 return ret;
138 } else {
139 client->errorValue = contextTag;
140 return GlxErrorBase + GLXBadContextTag;
141 }
142 }
dispatch_CreateGLXPixmap(ClientPtr client)143 static int dispatch_CreateGLXPixmap(ClientPtr client)
144 {
145 REQUEST(xGLXCreateGLXPixmapReq);
146 CARD32 screen, glxpixmap;
147 GlxServerVendor *vendor = NULL;
148 REQUEST_SIZE_MATCH(*stuff);
149 screen = GlxCheckSwap(client, stuff->screen);
150 glxpixmap = GlxCheckSwap(client, stuff->glxpixmap);
151 LEGAL_NEW_RESOURCE(glxpixmap, client);
152 if (screen < screenInfo.numScreens) {
153 vendor = glxServer.getVendorForScreen(client, screenInfo.screens[screen]);
154 }
155 if (vendor != NULL) {
156 int ret;
157 if (!glxServer.addXIDMap(glxpixmap, vendor)) {
158 return BadAlloc;
159 }
160 ret = glxServer.forwardRequest(vendor, client);
161 if (ret != Success) {
162 glxServer.removeXIDMap(glxpixmap);
163 }
164 return ret;
165 } else {
166 client->errorValue = screen;
167 return BadMatch;
168 }
169 }
dispatch_GetVisualConfigs(ClientPtr client)170 static int dispatch_GetVisualConfigs(ClientPtr client)
171 {
172 REQUEST(xGLXGetVisualConfigsReq);
173 CARD32 screen;
174 GlxServerVendor *vendor = NULL;
175 REQUEST_SIZE_MATCH(*stuff);
176 screen = GlxCheckSwap(client, stuff->screen);
177 if (screen < screenInfo.numScreens) {
178 vendor = glxServer.getVendorForScreen(client, screenInfo.screens[screen]);
179 }
180 if (vendor != NULL) {
181 int ret;
182 ret = glxServer.forwardRequest(vendor, client);
183 return ret;
184 } else {
185 client->errorValue = screen;
186 return BadMatch;
187 }
188 }
dispatch_DestroyGLXPixmap(ClientPtr client)189 static int dispatch_DestroyGLXPixmap(ClientPtr client)
190 {
191 REQUEST(xGLXDestroyGLXPixmapReq);
192 CARD32 glxpixmap;
193 GlxServerVendor *vendor = NULL;
194 REQUEST_SIZE_MATCH(*stuff);
195 glxpixmap = GlxCheckSwap(client, stuff->glxpixmap);
196 vendor = glxServer.getXIDMap(glxpixmap);
197 if (vendor != NULL) {
198 int ret;
199 ret = glxServer.forwardRequest(vendor, client);
200 return ret;
201 } else {
202 client->errorValue = glxpixmap;
203 return GlxErrorBase + GLXBadPixmap;
204 }
205 }
dispatch_QueryExtensionsString(ClientPtr client)206 static int dispatch_QueryExtensionsString(ClientPtr client)
207 {
208 REQUEST(xGLXQueryExtensionsStringReq);
209 CARD32 screen;
210 GlxServerVendor *vendor = NULL;
211 REQUEST_SIZE_MATCH(*stuff);
212 screen = GlxCheckSwap(client, stuff->screen);
213 if (screen < screenInfo.numScreens) {
214 vendor = glxServer.getVendorForScreen(client, screenInfo.screens[screen]);
215 }
216 if (vendor != NULL) {
217 int ret;
218 ret = glxServer.forwardRequest(vendor, client);
219 return ret;
220 } else {
221 client->errorValue = screen;
222 return BadMatch;
223 }
224 }
dispatch_QueryServerString(ClientPtr client)225 static int dispatch_QueryServerString(ClientPtr client)
226 {
227 REQUEST(xGLXQueryServerStringReq);
228 CARD32 screen;
229 GlxServerVendor *vendor = NULL;
230 REQUEST_SIZE_MATCH(*stuff);
231 screen = GlxCheckSwap(client, stuff->screen);
232 if (screen < screenInfo.numScreens) {
233 vendor = glxServer.getVendorForScreen(client, screenInfo.screens[screen]);
234 }
235 if (vendor != NULL) {
236 int ret;
237 ret = glxServer.forwardRequest(vendor, client);
238 return ret;
239 } else {
240 client->errorValue = screen;
241 return BadMatch;
242 }
243 }
dispatch_ChangeDrawableAttributes(ClientPtr client)244 static int dispatch_ChangeDrawableAttributes(ClientPtr client)
245 {
246 REQUEST(xGLXChangeDrawableAttributesReq);
247 CARD32 drawable;
248 GlxServerVendor *vendor = NULL;
249 REQUEST_AT_LEAST_SIZE(*stuff);
250 drawable = GlxCheckSwap(client, stuff->drawable);
251 vendor = glxServer.getXIDMap(drawable);
252 if (vendor != NULL) {
253 int ret;
254 ret = glxServer.forwardRequest(vendor, client);
255 return ret;
256 } else {
257 client->errorValue = drawable;
258 return BadDrawable;
259 }
260 }
dispatch_CreateNewContext(ClientPtr client)261 static int dispatch_CreateNewContext(ClientPtr client)
262 {
263 REQUEST(xGLXCreateNewContextReq);
264 CARD32 screen, context;
265 GlxServerVendor *vendor = NULL;
266 REQUEST_SIZE_MATCH(*stuff);
267 screen = GlxCheckSwap(client, stuff->screen);
268 context = GlxCheckSwap(client, stuff->context);
269 LEGAL_NEW_RESOURCE(context, client);
270 if (screen < screenInfo.numScreens) {
271 vendor = glxServer.getVendorForScreen(client, screenInfo.screens[screen]);
272 }
273 if (vendor != NULL) {
274 int ret;
275 if (!glxServer.addXIDMap(context, vendor)) {
276 return BadAlloc;
277 }
278 ret = glxServer.forwardRequest(vendor, client);
279 if (ret != Success) {
280 glxServer.removeXIDMap(context);
281 }
282 return ret;
283 } else {
284 client->errorValue = screen;
285 return BadMatch;
286 }
287 }
dispatch_CreatePbuffer(ClientPtr client)288 static int dispatch_CreatePbuffer(ClientPtr client)
289 {
290 REQUEST(xGLXCreatePbufferReq);
291 CARD32 screen, pbuffer;
292 GlxServerVendor *vendor = NULL;
293 REQUEST_AT_LEAST_SIZE(*stuff);
294 screen = GlxCheckSwap(client, stuff->screen);
295 pbuffer = GlxCheckSwap(client, stuff->pbuffer);
296 LEGAL_NEW_RESOURCE(pbuffer, client);
297 if (screen < screenInfo.numScreens) {
298 vendor = glxServer.getVendorForScreen(client, screenInfo.screens[screen]);
299 }
300 if (vendor != NULL) {
301 int ret;
302 if (!glxServer.addXIDMap(pbuffer, vendor)) {
303 return BadAlloc;
304 }
305 ret = glxServer.forwardRequest(vendor, client);
306 if (ret != Success) {
307 glxServer.removeXIDMap(pbuffer);
308 }
309 return ret;
310 } else {
311 client->errorValue = screen;
312 return BadMatch;
313 }
314 }
dispatch_CreatePixmap(ClientPtr client)315 static int dispatch_CreatePixmap(ClientPtr client)
316 {
317 REQUEST(xGLXCreatePixmapReq);
318 CARD32 screen, glxpixmap;
319 GlxServerVendor *vendor = NULL;
320 REQUEST_AT_LEAST_SIZE(*stuff);
321 screen = GlxCheckSwap(client, stuff->screen);
322 glxpixmap = GlxCheckSwap(client, stuff->glxpixmap);
323 LEGAL_NEW_RESOURCE(glxpixmap, client);
324 if (screen < screenInfo.numScreens) {
325 vendor = glxServer.getVendorForScreen(client, screenInfo.screens[screen]);
326 }
327 if (vendor != NULL) {
328 int ret;
329 if (!glxServer.addXIDMap(glxpixmap, vendor)) {
330 return BadAlloc;
331 }
332 ret = glxServer.forwardRequest(vendor, client);
333 if (ret != Success) {
334 glxServer.removeXIDMap(glxpixmap);
335 }
336 return ret;
337 } else {
338 client->errorValue = screen;
339 return BadMatch;
340 }
341 }
dispatch_CreateWindow(ClientPtr client)342 static int dispatch_CreateWindow(ClientPtr client)
343 {
344 REQUEST(xGLXCreateWindowReq);
345 CARD32 screen, glxwindow;
346 GlxServerVendor *vendor = NULL;
347 REQUEST_AT_LEAST_SIZE(*stuff);
348 screen = GlxCheckSwap(client, stuff->screen);
349 glxwindow = GlxCheckSwap(client, stuff->glxwindow);
350 LEGAL_NEW_RESOURCE(glxwindow, client);
351 if (screen < screenInfo.numScreens) {
352 vendor = glxServer.getVendorForScreen(client, screenInfo.screens[screen]);
353 }
354 if (vendor != NULL) {
355 int ret;
356 if (!glxServer.addXIDMap(glxwindow, vendor)) {
357 return BadAlloc;
358 }
359 ret = glxServer.forwardRequest(vendor, client);
360 if (ret != Success) {
361 glxServer.removeXIDMap(glxwindow);
362 }
363 return ret;
364 } else {
365 client->errorValue = screen;
366 return BadMatch;
367 }
368 }
dispatch_CreateContextAttribsARB(ClientPtr client)369 static int dispatch_CreateContextAttribsARB(ClientPtr client)
370 {
371 REQUEST(xGLXCreateContextAttribsARBReq);
372 CARD32 screen, context;
373 GlxServerVendor *vendor = NULL;
374 REQUEST_AT_LEAST_SIZE(*stuff);
375 screen = GlxCheckSwap(client, stuff->screen);
376 context = GlxCheckSwap(client, stuff->context);
377 LEGAL_NEW_RESOURCE(context, client);
378 if (screen < screenInfo.numScreens) {
379 vendor = glxServer.getVendorForScreen(client, screenInfo.screens[screen]);
380 }
381 if (vendor != NULL) {
382 int ret;
383 if (!glxServer.addXIDMap(context, vendor)) {
384 return BadAlloc;
385 }
386 ret = glxServer.forwardRequest(vendor, client);
387 if (ret != Success) {
388 glxServer.removeXIDMap(context);
389 }
390 return ret;
391 } else {
392 client->errorValue = screen;
393 return BadMatch;
394 }
395 }
dispatch_DestroyPbuffer(ClientPtr client)396 static int dispatch_DestroyPbuffer(ClientPtr client)
397 {
398 REQUEST(xGLXDestroyPbufferReq);
399 CARD32 pbuffer;
400 GlxServerVendor *vendor = NULL;
401 REQUEST_SIZE_MATCH(*stuff);
402 pbuffer = GlxCheckSwap(client, stuff->pbuffer);
403 vendor = glxServer.getXIDMap(pbuffer);
404 if (vendor != NULL) {
405 int ret;
406 ret = glxServer.forwardRequest(vendor, client);
407 if (ret == Success) {
408 glxServer.removeXIDMap(pbuffer);
409 }
410 return ret;
411 } else {
412 client->errorValue = pbuffer;
413 return GlxErrorBase + GLXBadPbuffer;
414 }
415 }
dispatch_DestroyPixmap(ClientPtr client)416 static int dispatch_DestroyPixmap(ClientPtr client)
417 {
418 REQUEST(xGLXDestroyPixmapReq);
419 CARD32 glxpixmap;
420 GlxServerVendor *vendor = NULL;
421 REQUEST_SIZE_MATCH(*stuff);
422 glxpixmap = GlxCheckSwap(client, stuff->glxpixmap);
423 vendor = glxServer.getXIDMap(glxpixmap);
424 if (vendor != NULL) {
425 int ret;
426 ret = glxServer.forwardRequest(vendor, client);
427 if (ret == Success) {
428 glxServer.removeXIDMap(glxpixmap);
429 }
430 return ret;
431 } else {
432 client->errorValue = glxpixmap;
433 return GlxErrorBase + GLXBadPixmap;
434 }
435 }
dispatch_DestroyWindow(ClientPtr client)436 static int dispatch_DestroyWindow(ClientPtr client)
437 {
438 REQUEST(xGLXDestroyWindowReq);
439 CARD32 glxwindow;
440 GlxServerVendor *vendor = NULL;
441 REQUEST_SIZE_MATCH(*stuff);
442 glxwindow = GlxCheckSwap(client, stuff->glxwindow);
443 vendor = glxServer.getXIDMap(glxwindow);
444 if (vendor != NULL) {
445 int ret;
446 ret = glxServer.forwardRequest(vendor, client);
447 if (ret == Success) {
448 glxServer.removeXIDMap(glxwindow);
449 }
450 return ret;
451 } else {
452 client->errorValue = glxwindow;
453 return GlxErrorBase + GLXBadWindow;
454 }
455 }
dispatch_GetDrawableAttributes(ClientPtr client)456 static int dispatch_GetDrawableAttributes(ClientPtr client)
457 {
458 REQUEST(xGLXGetDrawableAttributesReq);
459 CARD32 drawable;
460 GlxServerVendor *vendor = NULL;
461 REQUEST_SIZE_MATCH(*stuff);
462 drawable = GlxCheckSwap(client, stuff->drawable);
463 vendor = glxServer.getXIDMap(drawable);
464 if (vendor != NULL) {
465 int ret;
466 ret = glxServer.forwardRequest(vendor, client);
467 return ret;
468 } else {
469 client->errorValue = drawable;
470 return BadDrawable;
471 }
472 }
dispatch_GetFBConfigs(ClientPtr client)473 static int dispatch_GetFBConfigs(ClientPtr client)
474 {
475 REQUEST(xGLXGetFBConfigsReq);
476 CARD32 screen;
477 GlxServerVendor *vendor = NULL;
478 REQUEST_SIZE_MATCH(*stuff);
479 screen = GlxCheckSwap(client, stuff->screen);
480 if (screen < screenInfo.numScreens) {
481 vendor = glxServer.getVendorForScreen(client, screenInfo.screens[screen]);
482 }
483 if (vendor != NULL) {
484 int ret;
485 ret = glxServer.forwardRequest(vendor, client);
486 return ret;
487 } else {
488 client->errorValue = screen;
489 return BadMatch;
490 }
491 }
dispatch_QueryContext(ClientPtr client)492 static int dispatch_QueryContext(ClientPtr client)
493 {
494 REQUEST(xGLXQueryContextReq);
495 CARD32 context;
496 GlxServerVendor *vendor = NULL;
497 REQUEST_SIZE_MATCH(*stuff);
498 context = GlxCheckSwap(client, stuff->context);
499 vendor = glxServer.getXIDMap(context);
500 if (vendor != NULL) {
501 int ret;
502 ret = glxServer.forwardRequest(vendor, client);
503 return ret;
504 } else {
505 client->errorValue = context;
506 return GlxErrorBase + GLXBadContext;
507 }
508 }
dispatch_IsDirect(ClientPtr client)509 static int dispatch_IsDirect(ClientPtr client)
510 {
511 REQUEST(xGLXIsDirectReq);
512 CARD32 context;
513 GlxServerVendor *vendor = NULL;
514 REQUEST_SIZE_MATCH(*stuff);
515 context = GlxCheckSwap(client, stuff->context);
516 vendor = glxServer.getXIDMap(context);
517 if (vendor != NULL) {
518 int ret;
519 ret = glxServer.forwardRequest(vendor, client);
520 return ret;
521 } else {
522 client->errorValue = context;
523 return GlxErrorBase + GLXBadContext;
524 }
525 }
526