![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to dispatch.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv9 / X11 / src / X.V11R1 / server / dix|
Return to dispatch.c CVS log | Up to [Research Unix] / researchv9 / X11 / src / X.V11R1 / server / dix |
1.1 ! root 1: /* $Header: dispatch.c,v 1.16 87/09/12 21:40:28 sun Exp $ */ ! 2: /************************************************************ ! 3: Copyright 1987 by Digital Equipment Corporation, Maynard, Massachusetts, ! 4: and the Massachusetts Institute of Technology, Cambridge, Massachusetts. ! 5: ! 6: All Rights Reserved ! 7: ! 8: Permission to use, copy, modify, and distribute this software and its ! 9: documentation for any purpose and without fee is hereby granted, ! 10: provided that the above copyright notice appear in all copies and that ! 11: both that copyright notice and this permission notice appear in ! 12: supporting documentation, and that the names of Digital or MIT not be ! 13: used in advertising or publicity pertaining to distribution of the ! 14: software without specific, written prior permission. ! 15: ! 16: DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ! 17: ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL ! 18: DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ! 19: ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, ! 20: WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ! 21: ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS ! 22: SOFTWARE. ! 23: ! 24: ********************************************************/ ! 25: ! 26: #include "X.h" ! 27: #define NEED_REPLIES ! 28: #define NEED_EVENTS ! 29: #include "Xproto.h" ! 30: #include "windowstr.h" ! 31: #include "fontstruct.h" ! 32: #include "dixfontstr.h" ! 33: #include "gcstruct.h" ! 34: #include "osstruct.h" ! 35: #include "selection.h" ! 36: #include "colormapst.h" ! 37: #include "cursorstr.h" ! 38: #include "scrnintstr.h" ! 39: #include "opaque.h" ! 40: #include "input.h" ! 41: #include "servermd.h" ! 42: ! 43: extern WindowRec WindowTable[]; ! 44: extern xConnSetupPrefix connSetupPrefix; ! 45: extern char *ConnectionInfo; ! 46: extern void ProcessInputEvents(); ! 47: extern void ValidateGC(); ! 48: ! 49: Selection *CurrentSelections = (Selection *)NULL; ! 50: int NumCurrentSelections = 0; ! 51: ! 52: extern long ScreenSaverTime; ! 53: extern long ScreenSaverInterval; ! 54: extern int ScreenSaverBlanking; ! 55: extern int ScreenSaverAllowExposures; ! 56: static ClientPtr onlyClient; ! 57: static Bool grabbingClient = FALSE; ! 58: static long *checkForInput[2]; ! 59: extern Bool clientsDoomed; ! 60: extern int connBlockScreenStart; ! 61: ! 62: extern int (* ProcVector[256]) (); ! 63: extern int (* SwappedProcVector[256]) (); ! 64: extern void (* EventSwapVector[128]) (); ! 65: extern void (* ReplySwapVector[256]) (); ! 66: extern void Swap32Write(), SLHostsExtend(), SQColorsExtend(), WriteSConnectionInfo(); ! 67: void KillAllClients(); ! 68: ! 69: /* buffers for clients. legal values below */ ! 70: static int nextFreeClientID=1; /* 0 is for the server */ ! 71: ! 72: static int nClients = 0; /* number active clients */ ! 73: ! 74: #define SAME_SCREENS(a, b) (\ ! 75: (a.pScreen == b.pScreen)) ! 76: ! 77: #define VALIDATE(pGC, pDraw, rt) {\ ! 78: if (pGC->serialNumber != pDraw->serialNumber)\ ! 79: {\ ! 80: ValidateGC(pDraw, pGC);\ ! 81: } \ ! 82: } ! 83: ! 84: #define LEGAL_NEW_RESOURCE(id)\ ! 85: if ((LookupID(id, RT_ANY, RC_CORE) != 0) || (id & SERVER_BIT) \ ! 86: || (client->clientAsMask != CLIENT_BITS(id)))\ ! 87: return(BadIDChoice) ! 88: ! 89: ! 90: #define LOOKUP_DRAWABLE(did, client)\ ! 91: ((client->lastDrawableID == did) ? \ ! 92: (DrawablePtr)client->lastDrawable : (DrawablePtr)LookupDrawable(did, client)) ! 93: ! 94: #define VERIFY_GC(pGC, rid, client)\ ! 95: if (client->lastGCID == rid)\ ! 96: {\ ! 97: pGC = (GC *) client->lastGC;\ ! 98: }\ ! 99: else\ ! 100: {\ ! 101: pGC = (GC *)LookupID(rid, RT_GC, RC_CORE);\ ! 102: if (!pGC)\ ! 103: {\ ! 104: client->errorValue = rid;\ ! 105: return (BadGC);\ ! 106: }\ ! 107: } ! 108: ! 109: #define VALIDATE_DRAWABLE_AND_GC(drawID, pDraw, pGC, client)\ ! 110: if ((client->lastDrawableID != drawID) || (client->lastGCID != stuff->gc))\ ! 111: {\ ! 112: if (client->lastDrawableID != drawID)\ ! 113: {\ ! 114: pDraw = (DrawablePtr)LookupID(drawID, RT_DRAWABLE, RC_CORE);\ ! 115: if (!pDraw)\ ! 116: {\ ! 117: client->errorValue = drawID; \ ! 118: return (BadDrawable);\ ! 119: }\ ! 120: if ((pDraw->type == DRAWABLE_WINDOW) || \ ! 121: (pDraw->type == DRAWABLE_PIXMAP))\ ! 122: {\ ! 123: client->lastDrawable = (DrawablePtr)pDraw;\ ! 124: client->lastDrawableID = drawID;\ ! 125: }\ ! 126: else\ ! 127: {\ ! 128: client->errorValue = drawID;\ ! 129: return (BadDrawable);\ ! 130: }\ ! 131: }\ ! 132: else\ ! 133: pDraw = (DrawablePtr)client->lastDrawable;\ ! 134: if (client->lastGCID != stuff->gc)\ ! 135: {\ ! 136: pGC = (GC *)LookupID(stuff->gc, RT_GC, RC_CORE);\ ! 137: if (!pGC)\ ! 138: {\ ! 139: client->errorValue = stuff->gc;\ ! 140: return (BadGC);\ ! 141: }\ ! 142: client->lastGC = (GCPtr)pGC;\ ! 143: client->lastGCID = stuff->gc;\ ! 144: }\ ! 145: else\ ! 146: pGC = (GC *) client->lastGC;\ ! 147: if ((pGC->depth != pDraw->depth) || (pGC->pScreen != pDraw->pScreen))\ ! 148: {\ ! 149: client->errorValue = stuff->gc;\ ! 150: client->lastGCID = -1;\ ! 151: return (BadMatch);\ ! 152: }\ ! 153: }\ ! 154: else\ ! 155: {\ ! 156: pGC = (GC *) client->lastGC;\ ! 157: pDraw = (DrawablePtr)client->lastDrawable;\ ! 158: }\ ! 159: if (pGC->serialNumber != pDraw->serialNumber)\ ! 160: { \ ! 161: ValidateGC(pDraw, pGC);\ ! 162: } ! 163: ! 164: void ! 165: SetInputCheck(c0, c1) ! 166: long *c0, *c1; ! 167: { ! 168: checkForInput[0] = c0; ! 169: checkForInput[1] = c1; ! 170: } ! 171: ! 172: void ! 173: InitSelections() ! 174: { ! 175: int i; ! 176: ! 177: if (NumCurrentSelections == 0) ! 178: { ! 179: CurrentSelections = (Selection *)Xalloc(sizeof(Selection)); ! 180: NumCurrentSelections = 1; ! 181: } ! 182: for (i = 0; i< NumCurrentSelections; i++) ! 183: CurrentSelections[i].window = None; ! 184: } ! 185: ! 186: void ! 187: FlushClientCaches(id) ! 188: int id; ! 189: { ! 190: int i; ! 191: register ClientPtr client; ! 192: ! 193: client = clients[CLIENT_ID(id)]; ! 194: if (client == NullClient) ! 195: return ; ! 196: for (i=0; i<currentMaxClients; i++) ! 197: { ! 198: if (client == clients[i]) ! 199: { ! 200: if (client->lastDrawableID == id) ! 201: client->lastDrawableID = INVALID; ! 202: else if (client->lastGCID == id) ! 203: client->lastGCID = -1; ! 204: } ! 205: } ! 206: } ! 207: ! 208: Dispatch() ! 209: { ! 210: ClientPtr *clientReady; /* mask of request ready clients */ ! 211: ClientPtr *newClients; /* mask of new clients */ ! 212: int result; ! 213: xReq *request; ! 214: int ErrorStatus; ! 215: ClientPtr client; ! 216: int nready, nnew; ! 217: ! 218: nextFreeClientID = 1; ! 219: InitSelections(); ! 220: nClients = 0; ! 221: clientsDoomed = FALSE; ! 222: ! 223: clientReady = (ClientPtr *) ALLOCATE_LOCAL(sizeof(ClientPtr) * MaxClients); ! 224: newClients = (ClientPtr *)ALLOCATE_LOCAL(sizeof(ClientPtr) * MaxClients); ! 225: ! 226: while (1) ! 227: { ! 228: StartOver: ! 229: if (*checkForInput[0] != *checkForInput[1]) ! 230: ProcessInputEvents(); ! 231: ! 232: WaitForSomething(clientReady, &nready, newClients, &nnew); ! 233: ! 234: /***************** ! 235: * Establish any new connections ! 236: *****************/ ! 237: ! 238: while (nnew--) ! 239: { ! 240: client = newClients[nnew]; ! 241: client->requestLogIndex = 0; ! 242: InitClientResources(client); ! 243: SendConnectionSetupInfo(client); ! 244: nClients++; ! 245: } ! 246: ! 247: /***************** ! 248: * Handle events in round robin fashion, doing input between ! 249: * each round ! 250: *****************/ ! 251: ! 252: while ((nready--) > 0) ! 253: { ! 254: client = clientReady[nready]; ! 255: if (! client) ! 256: { ! 257: ErrorF( "HORRIBLE ERROR, unused client %d\n", nready); ! 258: continue; ! 259: } ! 260: isItTimeToYield = FALSE; ! 261: ! 262: requestingClient = client; ! 263: while (! isItTimeToYield) ! 264: { ! 265: if (*checkForInput[0] != *checkForInput[1]) ! 266: ProcessInputEvents(); ! 267: ! 268: /* now, finally, deal with client requests */ ! 269: ! 270: request = (xReq *)ReadRequestFromClient( ! 271: client, &result, request); ! 272: if (result < 0) ! 273: { ! 274: CloseDownClient(client); ! 275: isItTimeToYield = TRUE; ! 276: continue; ! 277: } ! 278: else if (result == 0) ! 279: { ! 280: #ifdef notdef ! 281: ErrorF( "Blocked read in dispatcher\n"); ! 282: ErrorF( "reqType %d %d\n", ! 283: (request ? request->reqType : -1), ! 284: nready); ! 285: #endif ! 286: if (nready > 0) ! 287: continue; ! 288: else ! 289: goto StartOver; ! 290: } ! 291: ! 292: client->sequence++; ! 293: client->requestBuffer = (pointer)request; ! 294: if (client->requestLogIndex == MAX_REQUEST_LOG) ! 295: client->requestLogIndex = 0; ! 296: client->requestLog[client->requestLogIndex] = request->reqType; ! 297: client->requestLogIndex++; ! 298: ErrorStatus = (* (client->swapped ? ! 299: SwappedProcVector : ProcVector)[request->reqType])(client); ! 300: ! 301: if (ErrorStatus != Success) ! 302: { ! 303: if (client->noClientException != Success) ! 304: CloseDownClient(client); ! 305: else ! 306: Oops(client, request->reqType, 0, ErrorStatus); ! 307: isItTimeToYield = TRUE; ! 308: continue; ! 309: } ! 310: } ! 311: } ! 312: /* Not an error, we just need to know to restart */ ! 313: if((nClients == -1) || clientsDoomed) ! 314: break; /* so that DEALLOCATE_LOCALs happen */ ! 315: } ! 316: if (clientsDoomed) ! 317: KillAllClients(); ! 318: DEALLOCATE_LOCAL(newClients); ! 319: DEALLOCATE_LOCAL(clientReady); ! 320: } ! 321: ! 322: int ! 323: ProcBadRequest(client) ! 324: ClientPtr client; ! 325: { ! 326: return (BadRequest); ! 327: } ! 328: ! 329: extern int Ones(); ! 330: ! 331: int ! 332: ProcCreateWindow(client) ! 333: register ClientPtr client; ! 334: { ! 335: register WindowPtr pParent, pWin; ! 336: REQUEST(xCreateWindowReq); ! 337: int result; ! 338: int len; ! 339: ! 340: REQUEST_AT_LEAST_SIZE(xCreateWindowReq); ! 341: ! 342: LEGAL_NEW_RESOURCE(stuff->wid); ! 343: if (!(pParent = (WindowPtr)LookupWindow(stuff->parent, client))) ! 344: return BadWindow; ! 345: len = stuff->length - (sizeof(xCreateWindowReq) >> 2); ! 346: if (Ones(stuff->mask) != len) ! 347: return BadLength; ! 348: if (!stuff->width || !stuff->height) ! 349: return BadValue; ! 350: pWin = CreateWindow(stuff->wid, pParent, stuff->x, ! 351: stuff->y, stuff->width, stuff->height, ! 352: stuff->borderWidth, stuff->class, ! 353: stuff->mask, (long *) &stuff[1], ! 354: stuff->depth, ! 355: client, stuff->visual, &result); ! 356: if (pWin) ! 357: AddResource(stuff->wid, RT_WINDOW, pWin, DeleteWindow, RC_CORE); ! 358: if (client->noClientException != Success) ! 359: return(client->noClientException); ! 360: else ! 361: return(result); ! 362: } ! 363: ! 364: int ! 365: ProcChangeWindowAttributes(client) ! 366: register ClientPtr client; ! 367: { ! 368: register WindowPtr pWin; ! 369: REQUEST(xChangeWindowAttributesReq); ! 370: register int result; ! 371: int len; ! 372: ! 373: REQUEST_AT_LEAST_SIZE(xChangeWindowAttributesReq); ! 374: pWin = (WindowPtr)LookupWindow(stuff->window, client); ! 375: if (!pWin) ! 376: return(BadWindow); ! 377: len = stuff->length - (sizeof(xChangeWindowAttributesReq) >> 2); ! 378: if (len != Ones(stuff->valueMask)) ! 379: return BadLength; ! 380: client->lastDrawableID = INVALID; ! 381: result = ChangeWindowAttributes(pWin, ! 382: stuff->valueMask, ! 383: (long *) &stuff[1], ! 384: client); ! 385: if (client->noClientException != Success) ! 386: return(client->noClientException); ! 387: else ! 388: return(result); ! 389: } ! 390: ! 391: int ! 392: ProcGetWindowAttributes(client) ! 393: register ClientPtr client; ! 394: { ! 395: register WindowPtr pWin; ! 396: REQUEST(xResourceReq); ! 397: ! 398: REQUEST_SIZE_MATCH(xResourceReq); ! 399: pWin = (WindowPtr)LookupWindow(stuff->id, client); ! 400: if (!pWin) ! 401: return(BadWindow); ! 402: GetWindowAttributes(pWin, client); ! 403: return(client->noClientException); ! 404: } ! 405: ! 406: int ! 407: ProcDestroyWindow(client) ! 408: register ClientPtr client; ! 409: { ! 410: register WindowPtr pWin; ! 411: REQUEST(xResourceReq); ! 412: ! 413: REQUEST_SIZE_MATCH(xResourceReq); ! 414: pWin = (WindowPtr)LookupWindow(stuff->id, client); ! 415: if (!pWin) ! 416: return(BadWindow); ! 417: FreeResource(stuff->id, RC_NONE); ! 418: return(client->noClientException); ! 419: } ! 420: ! 421: int ! 422: ProcDestroySubwindows(client) ! 423: register ClientPtr client; ! 424: { ! 425: register WindowPtr pWin; ! 426: REQUEST(xResourceReq); ! 427: ! 428: REQUEST_SIZE_MATCH(xResourceReq); ! 429: pWin = (WindowPtr)LookupWindow(stuff->id, client); ! 430: if (!pWin) ! 431: return(BadWindow); ! 432: DestroySubwindows(pWin, client); ! 433: return(client->noClientException); ! 434: } ! 435: ! 436: int ! 437: ProcChangeSaveSet(client) ! 438: register ClientPtr client; ! 439: { ! 440: register WindowPtr pWin; ! 441: REQUEST(xChangeSaveSetReq); ! 442: register result; ! 443: ! 444: REQUEST_SIZE_MATCH(xChangeSaveSetReq); ! 445: pWin = (WindowPtr)LookupWindow(stuff->window, client); ! 446: if (!pWin) ! 447: return(BadWindow); ! 448: if (client->clientAsMask == (CLIENT_ID(pWin->wid))) ! 449: return BadMatch; ! 450: if ((stuff->mode == SetModeInsert) || (stuff->mode == SetModeDelete)) ! 451: { ! 452: result = AlterSaveSetForClient(client, pWin, stuff->mode); ! 453: if (client->noClientException != Success) ! 454: return(client->noClientException); ! 455: else ! 456: return(result); ! 457: } ! 458: else ! 459: return( BadValue ); ! 460: } ! 461: ! 462: int ! 463: ProcReparentWindow(client) ! 464: register ClientPtr client; ! 465: { ! 466: register WindowPtr pWin, pParent; ! 467: REQUEST(xReparentWindowReq); ! 468: register int result; ! 469: ! 470: REQUEST_SIZE_MATCH(xReparentWindowReq); ! 471: pWin = (WindowPtr)LookupWindow(stuff->window, client); ! 472: if (!pWin) ! 473: return(BadWindow); ! 474: pParent = (WindowPtr)LookupWindow(stuff->parent, client); ! 475: if (!pParent) ! 476: return(BadWindow); ! 477: if (SAME_SCREENS(pWin->drawable, pParent->drawable)) ! 478: { ! 479: if ((pWin->backgroundTile == (PixmapPtr)ParentRelative) && ! 480: (pParent->drawable.depth != pWin->drawable.depth)) ! 481: return BadMatch; ! 482: result = ReparentWindow(pWin, pParent, ! 483: (short)stuff->x, (short)stuff->y, client); ! 484: if (client->noClientException != Success) ! 485: return(client->noClientException); ! 486: else ! 487: return(result); ! 488: } ! 489: else ! 490: return (BadMatch); ! 491: } ! 492: ! 493: int ! 494: ProcMapWindow(client) ! 495: register ClientPtr client; ! 496: { ! 497: register WindowPtr pWin; ! 498: REQUEST(xResourceReq); ! 499: ! 500: REQUEST_SIZE_MATCH(xResourceReq); ! 501: pWin = (WindowPtr)LookupWindow(stuff->id, client); ! 502: if (!pWin) ! 503: return(BadWindow); ! 504: MapWindow(pWin, HANDLE_EXPOSURES, BITS_DISCARDED, ! 505: SEND_NOTIFICATION, client); ! 506: /* update cache to say it is mapped */ ! 507: return(client->noClientException); ! 508: } ! 509: ! 510: int ! 511: ProcMapSubwindows(client) ! 512: register ClientPtr client; ! 513: { ! 514: register WindowPtr pWin; ! 515: REQUEST(xResourceReq); ! 516: ! 517: REQUEST_SIZE_MATCH(xResourceReq); ! 518: pWin = (WindowPtr)LookupWindow( stuff->id, client); ! 519: if (!pWin) ! 520: return(BadWindow); ! 521: MapSubwindows(pWin, HANDLE_EXPOSURES, client); ! 522: /* update cache to say it is mapped */ ! 523: return(client->noClientException); ! 524: } ! 525: ! 526: int ! 527: ProcUnmapWindow(client) ! 528: register ClientPtr client; ! 529: { ! 530: register WindowPtr pWin; ! 531: REQUEST(xResourceReq); ! 532: ! 533: REQUEST_SIZE_MATCH(xResourceReq); ! 534: pWin = (WindowPtr)LookupWindow( stuff->id, client); ! 535: if (!pWin) ! 536: return(BadWindow); ! 537: UnmapWindow(pWin, HANDLE_EXPOSURES, SEND_NOTIFICATION, FALSE); ! 538: /* update cache to say it is mapped */ ! 539: return(client->noClientException); ! 540: } ! 541: ! 542: int ! 543: ProcUnmapSubwindows(client) ! 544: register ClientPtr client; ! 545: { ! 546: register WindowPtr pWin; ! 547: REQUEST(xResourceReq); ! 548: ! 549: REQUEST_SIZE_MATCH(xResourceReq); ! 550: pWin = (WindowPtr)LookupWindow( stuff->id, client); ! 551: if (!pWin) ! 552: return(BadWindow); ! 553: UnmapSubwindows(pWin, HANDLE_EXPOSURES, FALSE); ! 554: return(client->noClientException); ! 555: } ! 556: ! 557: int ! 558: ProcConfigureWindow(client) ! 559: register ClientPtr client; ! 560: { ! 561: register WindowPtr pWin; ! 562: REQUEST(xConfigureWindowReq); ! 563: register int result; ! 564: int len; ! 565: ! 566: REQUEST_AT_LEAST_SIZE(xConfigureWindowReq); ! 567: pWin = (WindowPtr)LookupWindow( stuff->window, client); ! 568: if (!pWin) ! 569: return(BadWindow); ! 570: len = stuff->length - (sizeof(xConfigureWindowReq) >> 2); ! 571: if (Ones(stuff->mask) != len) ! 572: return BadLength; ! 573: result = ConfigureWindow(pWin, stuff->mask, (char *) &stuff[1], ! 574: client); ! 575: if (client->noClientException != Success) ! 576: return(client->noClientException); ! 577: else ! 578: return(result); ! 579: } ! 580: ! 581: int ! 582: ProcCirculateWindow(client) ! 583: register ClientPtr client; ! 584: { ! 585: register WindowPtr pWin; ! 586: REQUEST(xCirculateWindowReq); ! 587: ! 588: REQUEST_SIZE_MATCH(xCirculateWindowReq); ! 589: if ((stuff->direction != RaiseLowest) && ! 590: (stuff->direction != LowerHighest)) ! 591: return BadValue; ! 592: pWin = (WindowPtr)LookupWindow(stuff->window, client); ! 593: if (!pWin) ! 594: return(BadWindow); ! 595: CirculateWindow(pWin, stuff->direction, client); ! 596: return(client->noClientException); ! 597: } ! 598: ! 599: int ! 600: ProcGetGeometry(client) ! 601: register ClientPtr client; ! 602: { ! 603: xGetGeometryReply rep; ! 604: register DrawablePtr pDraw; ! 605: REQUEST(xResourceReq); ! 606: ! 607: REQUEST_SIZE_MATCH(xResourceReq); ! 608: if (!(pDraw = LOOKUP_DRAWABLE(stuff->id, client))) ! 609: { /* can be inputonly */ ! 610: if (!(pDraw = (DrawablePtr)LookupWindow(stuff->id, client))) ! 611: return (BadDrawable); ! 612: } ! 613: rep.type = X_Reply; ! 614: rep.length = 0; ! 615: rep.sequenceNumber = client->sequence; ! 616: rep.root = WindowTable[pDraw->pScreen->myNum].wid; ! 617: rep.depth = pDraw->depth; ! 618: ! 619: if (pDraw->type == DRAWABLE_PIXMAP) ! 620: { ! 621: PixmapPtr pPixmap = (PixmapPtr)pDraw; ! 622: ! 623: rep.x = rep.y = rep.borderWidth = 0; ! 624: rep.width = pPixmap->width; ! 625: rep.height = pPixmap->height; ! 626: } ! 627: else ! 628: { ! 629: register WindowPtr pWin = (WindowPtr)pDraw; ! 630: rep.x = pWin->clientWinSize.x - pWin->borderWidth; ! 631: rep.y = pWin->clientWinSize.y - pWin->borderWidth; ! 632: rep.borderWidth = pWin->borderWidth; ! 633: rep.width = pWin->clientWinSize.width; ! 634: rep.height = pWin->clientWinSize.height; ! 635: } ! 636: WriteReplyToClient(client, sizeof(xGetGeometryReply), &rep); ! 637: return(client->noClientException); ! 638: } ! 639: ! 640: int ! 641: ProcQueryTree(client) ! 642: register ClientPtr client; ! 643: { ! 644: ! 645: xQueryTreeReply reply; ! 646: int numChildren = 0; ! 647: register WindowPtr pChild, pWin; ! 648: Window *childIDs = (Window *)NULL; ! 649: REQUEST(xResourceReq); ! 650: ! 651: REQUEST_SIZE_MATCH(xResourceReq); ! 652: pWin = (WindowPtr)LookupWindow(stuff->id, client); ! 653: if (!pWin) ! 654: return(BadWindow); ! 655: reply.type = X_Reply; ! 656: reply.root = WindowTable[pWin->drawable.pScreen->myNum].wid; ! 657: reply.sequenceNumber = client->sequence; ! 658: if (pWin->parent) ! 659: reply.parent = pWin->parent->wid; ! 660: else ! 661: reply.parent = (Window)None; ! 662: ! 663: for (pChild = pWin->lastChild; pChild; pChild = pChild->prevSib) ! 664: numChildren++; ! 665: if (numChildren) ! 666: { ! 667: int curChild = 0; ! 668: ! 669: childIDs = (Window *) Xalloc(numChildren * sizeof(Window)); ! 670: for (pChild = pWin->lastChild; pChild; pChild = pChild->prevSib) ! 671: childIDs[curChild++] = pChild->wid; ! 672: } ! 673: ! 674: reply.nChildren = numChildren; ! 675: reply.length = (numChildren * sizeof(Window)) >> 2; ! 676: ! 677: WriteReplyToClient(client, sizeof(xQueryTreeReply), &reply); ! 678: if (numChildren) ! 679: { ! 680: client->pSwapReplyFunc = Swap32Write; ! 681: WriteSwappedDataToClient(client, numChildren * sizeof(Window), childIDs); ! 682: Xfree(childIDs); ! 683: } ! 684: ! 685: return(client->noClientException); ! 686: } ! 687: ! 688: int ! 689: ProcInternAtom(client) ! 690: register ClientPtr client; ! 691: { ! 692: Atom atom; ! 693: char *tchar; ! 694: REQUEST(xInternAtomReq); ! 695: ! 696: REQUEST_AT_LEAST_SIZE(xInternAtomReq); ! 697: tchar = (char *) &stuff[1]; ! 698: atom = MakeAtom(tchar, stuff->nbytes, !stuff->onlyIfExists); ! 699: if (atom || stuff->onlyIfExists) ! 700: { ! 701: xInternAtomReply reply; ! 702: reply.type = X_Reply; ! 703: reply.length = 0; ! 704: reply.sequenceNumber = client->sequence; ! 705: reply.atom = (atom ? atom : None); ! 706: WriteReplyToClient(client, sizeof(xInternAtomReply), &reply); ! 707: return(client->noClientException); ! 708: } ! 709: else ! 710: return (BadAlloc); ! 711: } ! 712: ! 713: int ! 714: ProcGetAtomName(client) ! 715: register ClientPtr client; ! 716: { ! 717: char *str; ! 718: xGetAtomNameReply reply; ! 719: int len; ! 720: REQUEST(xResourceReq); ! 721: ! 722: REQUEST_SIZE_MATCH(xResourceReq); ! 723: if (str = (char *)NameForAtom(stuff->id)) ! 724: { ! 725: len = strlen(str); ! 726: reply.type = X_Reply; ! 727: reply.length = (len + 3) >> 2; ! 728: reply.sequenceNumber = client->sequence; ! 729: reply.nameLength = len; ! 730: WriteReplyToClient(client, sizeof(xGetAtomNameReply), &reply); ! 731: WriteToClient(client, len, str); ! 732: return(client->noClientException); ! 733: } ! 734: else ! 735: { ! 736: client->errorValue = stuff->id; ! 737: return (BadAtom); ! 738: } ! 739: } ! 740: ! 741: int ! 742: ProcDeleteProperty(client) ! 743: register ClientPtr client; ! 744: { ! 745: WindowPtr pWin; ! 746: REQUEST(xDeletePropertyReq); ! 747: int result; ! 748: ! 749: REQUEST_SIZE_MATCH(xDeletePropertyReq); ! 750: pWin = (WindowPtr)LookupWindow(stuff->window, client); ! 751: if (!pWin) ! 752: return(BadWindow); ! 753: if (ValidAtom(stuff->property)) ! 754: { ! 755: result = DeleteProperty(pWin, stuff->property); ! 756: if (client->noClientException != Success) ! 757: return(client->noClientException); ! 758: else ! 759: return(result); ! 760: } ! 761: else ! 762: return (BadAtom); ! 763: } ! 764: ! 765: ! 766: int ! 767: ProcSetSelectionOwner(client) ! 768: register ClientPtr client; ! 769: { ! 770: WindowPtr pWin; ! 771: TimeStamp time; ! 772: REQUEST(xSetSelectionOwnerReq); ! 773: ! 774: REQUEST_SIZE_MATCH(xSetSelectionOwnerReq); ! 775: time = ClientTimeToServerTime(stuff->time); ! 776: ! 777: /* If the client's time stamp is in the future relative to the server's ! 778: time stamp, do not set the selection, just return success. */ ! 779: if (CompareTimeStamps(time, currentTime) == LATER) ! 780: return Success; ! 781: if (stuff->window != None) ! 782: { ! 783: pWin = (WindowPtr)LookupWindow(stuff->window, client); ! 784: if (!pWin) ! 785: return(BadWindow); ! 786: } ! 787: else ! 788: pWin = (WindowPtr)None; ! 789: if (ValidAtom(stuff->selection)) ! 790: { ! 791: int i = 0; ! 792: ! 793: /* ! 794: * First, see if the selection is already set... ! 795: */ ! 796: while ((i < NumCurrentSelections) && ! 797: CurrentSelections[i].selection != stuff->selection) ! 798: i++; ! 799: if (i < NumCurrentSelections) ! 800: { ! 801: xEvent event; ! 802: ! 803: /* If the timestamp in client's request is in the past relative ! 804: to the time stamp indicating the last time the owner of the ! 805: selection was set, do not set the selection, just return ! 806: success. */ ! 807: if (CompareTimeStamps(time, CurrentSelections[i].lastTimeChanged) ! 808: == EARLIER) ! 809: return Success; ! 810: if (CurrentSelections[i].pWin != (WindowPtr)None) ! 811: { ! 812: event.u.u.type = SelectionClear; ! 813: event.u.selectionClear.time = time.milliseconds; ! 814: event.u.selectionClear.window = CurrentSelections[i].window; ! 815: event.u.selectionClear.atom = CurrentSelections[i].selection; ! 816: DeliverEvents(CurrentSelections[i].pWin, &event, 1); ! 817: } ! 818: CurrentSelections[i].selection = stuff->selection; ! 819: CurrentSelections[i].lastTimeChanged = time; ! 820: CurrentSelections[i].window = stuff->window; ! 821: CurrentSelections[i].pWin = pWin; ! 822: CurrentSelections[i].client = client; ! 823: return (client->noClientException); ! 824: } ! 825: /* ! 826: * It doesn't exist, so add it... ! 827: */ ! 828: NumCurrentSelections++; ! 829: CurrentSelections = ! 830: (Selection *)Xrealloc(CurrentSelections, ! 831: NumCurrentSelections * sizeof(Selection)); ! 832: ! 833: CurrentSelections[i].selection = stuff->selection; ! 834: CurrentSelections[i].lastTimeChanged = time; ! 835: CurrentSelections[i].window = stuff->window; ! 836: CurrentSelections[i].pWin = pWin; ! 837: CurrentSelections[i].client = client; ! 838: return (client->noClientException); ! 839: } ! 840: else ! 841: return (BadAtom); ! 842: } ! 843: ! 844: int ! 845: ProcGetSelectionOwner(client) ! 846: register ClientPtr client; ! 847: { ! 848: REQUEST(xResourceReq); ! 849: ! 850: REQUEST_SIZE_MATCH(xResourceReq); ! 851: if (ValidAtom(stuff->id)) ! 852: { ! 853: int i; ! 854: xGetSelectionOwnerReply reply; ! 855: ! 856: i = 0; ! 857: while ((i < NumCurrentSelections) && ! 858: CurrentSelections[i].selection != stuff->id) i++; ! 859: reply.type = X_Reply; ! 860: reply.length = 0; ! 861: reply.sequenceNumber = client->sequence; ! 862: if (i < NumCurrentSelections) ! 863: reply.owner = CurrentSelections[i].window; ! 864: else ! 865: reply.owner = None; ! 866: WriteReplyToClient(client, sizeof(xGetSelectionOwnerReply), &reply); ! 867: return(client->noClientException); ! 868: } ! 869: else ! 870: return (BadAtom); ! 871: } ! 872: ! 873: int ! 874: ProcConvertSelection(client) ! 875: register ClientPtr client; ! 876: { ! 877: Bool paramsOkay = TRUE; ! 878: xEvent event; ! 879: WindowPtr pWin; ! 880: REQUEST(xConvertSelectionReq); ! 881: ! 882: REQUEST_SIZE_MATCH(xConvertSelectionReq); ! 883: pWin = (WindowPtr)LookupWindow(stuff->requestor, client); ! 884: if (!pWin) ! 885: return(BadWindow); ! 886: ! 887: paramsOkay = (ValidAtom(stuff->selection) && ValidAtom(stuff->target)); ! 888: if (stuff->property != None) ! 889: paramsOkay &= ValidAtom(stuff->property); ! 890: if (paramsOkay) ! 891: { ! 892: int i; ! 893: ! 894: i = 0; ! 895: while ((i < NumCurrentSelections) && ! 896: CurrentSelections[i].selection != stuff->selection) i++; ! 897: if ((i < NumCurrentSelections) && ! 898: (CurrentSelections[i].window != None)) ! 899: { ! 900: event.u.u.type = SelectionRequest; ! 901: event.u.selectionRequest.time = stuff->time; ! 902: event.u.selectionRequest.owner = ! 903: CurrentSelections[i].window; ! 904: event.u.selectionRequest.requestor = stuff->requestor; ! 905: event.u.selectionRequest.selection = stuff->selection; ! 906: event.u.selectionRequest.target = stuff->target; ! 907: event.u.selectionRequest.property = stuff->property; ! 908: if (TryClientEvents( ! 909: CurrentSelections[i].client, &event, 1, NoEventMask, ! 910: NoEventMask, NullGrab)) ! 911: return (client->noClientException); ! 912: } ! 913: event.u.u.type = SelectionNotify; ! 914: event.u.selectionNotify.time = stuff->time; ! 915: event.u.selectionNotify.requestor = stuff->requestor; ! 916: event.u.selectionNotify.selection = stuff->selection; ! 917: event.u.selectionNotify.target = stuff->target; ! 918: event.u.selectionNotify.property = None; ! 919: DeliverEvents(pWin, &event, 1); ! 920: return (client->noClientException); ! 921: } ! 922: else ! 923: return (BadAtom); ! 924: } ! 925: ! 926: int ! 927: ProcGrabServer(client) ! 928: register ClientPtr client; ! 929: { ! 930: OnlyListenToOneClient(client); ! 931: grabbingClient = TRUE; ! 932: onlyClient = client; ! 933: return(client->noClientException); ! 934: } ! 935: ! 936: int ! 937: ProcUngrabServer(client) ! 938: register ClientPtr client; ! 939: { ! 940: REQUEST(xReq); ! 941: REQUEST_SIZE_MATCH(xReq); ! 942: grabbingClient = FALSE; ! 943: ListenToAllClients(); ! 944: return(client->noClientException); ! 945: } ! 946: ! 947: int ! 948: ProcTranslateCoords(client) ! 949: register ClientPtr client; ! 950: { ! 951: REQUEST(xTranslateCoordsReq); ! 952: ! 953: register WindowPtr pWin, pDst; ! 954: xTranslateCoordsReply rep; ! 955: ! 956: REQUEST_SIZE_MATCH(xTranslateCoordsReq); ! 957: pWin = (WindowPtr)LookupWindow(stuff->srcWid, client); ! 958: if (!pWin) ! 959: return(BadWindow); ! 960: pDst = (WindowPtr)LookupWindow(stuff->dstWid, client); ! 961: if (!pDst) ! 962: return(BadWindow); ! 963: rep.type = X_Reply; ! 964: rep.length = 0; ! 965: rep.sequenceNumber = client->sequence; ! 966: if (!SAME_SCREENS(pWin->drawable, pDst->drawable)) ! 967: { ! 968: rep.sameScreen = xFalse; ! 969: rep.child = None; ! 970: rep.dstX = rep.dstY = 0; ! 971: } ! 972: else ! 973: { ! 974: INT16 x, y; ! 975: rep.sameScreen = xTrue; ! 976: rep.child = None; ! 977: /* computing absolute coordinates -- adjust to destination later */ ! 978: x = pWin->absCorner.x + stuff->srcX; ! 979: y = pWin->absCorner.y + stuff->srcY; ! 980: pWin = pDst->firstChild; ! 981: while (pWin) ! 982: { ! 983: if ((pWin->mapped) && ! 984: (x >= pWin->absCorner.x - pWin->borderWidth) && ! 985: (x < pWin->absCorner.x + pWin->clientWinSize.width + ! 986: pWin->borderWidth) && ! 987: (y >= pWin->absCorner.y - pWin->borderWidth) && ! 988: (y < pWin->absCorner.y + pWin->clientWinSize.height ! 989: + pWin->borderWidth)) ! 990: { ! 991: rep.child = pWin->wid; ! 992: pWin = (WindowPtr) NULL; ! 993: } ! 994: else ! 995: pWin = pWin->nextSib; ! 996: } ! 997: /* adjust to destination coordinates */ ! 998: rep.dstX = x - pDst->absCorner.x; ! 999: rep.dstY = y - pDst->absCorner.y; ! 1000: } ! 1001: WriteReplyToClient(client, sizeof(xTranslateCoordsReply), &rep); ! 1002: return(client->noClientException); ! 1003: } ! 1004: ! 1005: int ! 1006: ProcOpenFont(client) ! 1007: register ClientPtr client; ! 1008: { ! 1009: FontPtr pFont; ! 1010: REQUEST(xOpenFontReq); ! 1011: ! 1012: REQUEST_AT_LEAST_SIZE(xOpenFontReq); ! 1013: client->errorValue = stuff->fid; ! 1014: LEGAL_NEW_RESOURCE(stuff->fid); ! 1015: if ( pFont = OpenFont( stuff->nbytes, (char *)&stuff[1])) ! 1016: { ! 1017: AddResource( stuff->fid, RT_FONT, pFont, CloseFont,RC_CORE); ! 1018: return(client->noClientException); ! 1019: } ! 1020: else ! 1021: return (BadName); ! 1022: } ! 1023: ! 1024: int ! 1025: ProcCloseFont(client) ! 1026: register ClientPtr client; ! 1027: { ! 1028: FontPtr pFont; ! 1029: REQUEST(xResourceReq); ! 1030: ! 1031: REQUEST_SIZE_MATCH(xResourceReq); ! 1032: pFont = (FontPtr)LookupID(stuff->id, RT_FONT, RC_CORE); ! 1033: if ( pFont != (FontPtr)NULL) /* id was valid */ ! 1034: { ! 1035: FreeResource( stuff->id, RC_NONE); ! 1036: return(client->noClientException); ! 1037: } ! 1038: else ! 1039: return (BadFont); ! 1040: } ! 1041: ! 1042: int ! 1043: ProcQueryFont(client) ! 1044: register ClientPtr client; ! 1045: { ! 1046: xQueryFontReply *reply; ! 1047: FontPtr pFont; ! 1048: register GC *pGC; ! 1049: REQUEST(xResourceReq); ! 1050: ! 1051: REQUEST_SIZE_MATCH(xResourceReq); ! 1052: client->errorValue = stuff->id; /* EITHER font or gc */ ! 1053: pFont = (FontPtr)LookupID(stuff->id, RT_FONT, RC_CORE); ! 1054: if (!pFont) ! 1055: { ! 1056: /* can't use VERIFY_GC because it might return BadGC */ ! 1057: pGC = (GC *) LookupID(stuff->id, RT_GC, RC_CORE); ! 1058: if (!pGC) ! 1059: return(BadFont); /* procotol spec says only error is BadFont */ ! 1060: pFont = pGC->font; ! 1061: } ! 1062: ! 1063: { ! 1064: CharInfoPtr pmax = &pFont->pFI->maxbounds; ! 1065: CharInfoPtr pmin = &pFont->pFI->minbounds; ! 1066: int nprotoxcistructs; ! 1067: int rlength; ! 1068: ! 1069: nprotoxcistructs = ( ! 1070: pmax->metrics.rightSideBearing == pmin->metrics.rightSideBearing && ! 1071: pmax->metrics.leftSideBearing == pmin->metrics.leftSideBearing && ! 1072: pmax->metrics.descent == pmin->metrics.descent && ! 1073: pmax->metrics.ascent == pmin->metrics.ascent && ! 1074: pmax->metrics.characterWidth == pmin->metrics.characterWidth) ? ! 1075: 0 : n2dChars(pFont->pFI); ! 1076: ! 1077: rlength = sizeof(xQueryFontReply) + ! 1078: pFont->pFI->nProps * sizeof(xFontProp) + ! 1079: nprotoxcistructs * sizeof(xCharInfo); ! 1080: reply = (xQueryFontReply *)ALLOCATE_LOCAL(rlength); ! 1081: if(!reply) ! 1082: { ! 1083: return(client->noClientException = BadAlloc); ! 1084: } ! 1085: ! 1086: reply->type = X_Reply; ! 1087: reply->length = (rlength - sizeof(xGenericReply)) >> 2; ! 1088: reply->sequenceNumber = client->sequence; ! 1089: QueryFont( pFont, reply, nprotoxcistructs); ! 1090: ! 1091: WriteReplyToClient(client, rlength, reply); ! 1092: DEALLOCATE_LOCAL(reply); ! 1093: return(client->noClientException); ! 1094: } ! 1095: } ! 1096: ! 1097: int ! 1098: ProcQueryTextExtents(client) ! 1099: register ClientPtr client; ! 1100: { ! 1101: REQUEST(xQueryTextExtentsReq); ! 1102: xQueryTextExtentsReply reply; ! 1103: FontPtr pFont; ! 1104: GC *pGC; ! 1105: ExtentInfoRec info; ! 1106: short length; ! 1107: ! 1108: REQUEST_AT_LEAST_SIZE(xQueryTextExtentsReq); ! 1109: ! 1110: pFont = (FontPtr)LookupID( stuff->fid, RT_FONT, RC_CORE); ! 1111: if (!pFont) ! 1112: { ! 1113: pGC = (GC *)LookupID( stuff->fid, RT_GC, RC_CORE); ! 1114: if (!pGC) ! 1115: return(BadFont); ! 1116: pFont = pGC->font; ! 1117: } ! 1118: length = stuff->length - (sizeof(xQueryTextExtentsReq) >> 2); ! 1119: length = length << 1; ! 1120: if (stuff->oddLength) ! 1121: length--; ! 1122: QueryTextExtents(pFont, length, &stuff[1], &info); ! 1123: reply.type = X_Reply; ! 1124: reply.length = 0; ! 1125: reply.sequenceNumber = client->sequence; ! 1126: reply.drawDirection = info.drawDirection; ! 1127: reply.fontAscent = info.fontAscent; ! 1128: reply.fontDescent = info.fontDescent; ! 1129: reply.overallAscent = info.overallAscent; ! 1130: reply.overallDescent = info.overallDescent; ! 1131: reply.overallWidth = info.overallWidth; ! 1132: reply.overallLeft = info.overallLeft; ! 1133: reply.overallRight = info.overallRight; ! 1134: WriteReplyToClient(client, sizeof(xQueryTextExtentsReply), &reply); ! 1135: return(client->noClientException); ! 1136: } ! 1137: ! 1138: int ! 1139: ProcListFonts(client) ! 1140: register ClientPtr client; ! 1141: { ! 1142: xListFontsReply reply; ! 1143: FontPathPtr fpr; ! 1144: int stringLens, i; ! 1145: char *bufptr, *bufferStart; ! 1146: REQUEST(xListFontsReq); ! 1147: ! 1148: REQUEST_AT_LEAST_SIZE(xListFontsReq); ! 1149: ! 1150: fpr = ExpandFontNamePattern( stuff->nbytes, ! 1151: &stuff[1], stuff->maxNames); ! 1152: stringLens = 0; ! 1153: for (i=0; i<fpr->npaths; i++) ! 1154: stringLens += fpr->length[i]; ! 1155: ! 1156: reply.type = X_Reply; ! 1157: reply.length = (stringLens + fpr->npaths + 3) >> 2; ! 1158: reply.nFonts = fpr->npaths; ! 1159: reply.sequenceNumber = client->sequence; ! 1160: ! 1161: bufptr = bufferStart = (char *)ALLOCATE_LOCAL(reply.length << 2); ! 1162: if(!bufptr) ! 1163: return(client->noClientException = BadAlloc); ! 1164: ! 1165: /* since WriteToClient long word aligns things, ! 1166: copy to temp buffer and write all at once */ ! 1167: for (i=0; i<fpr->npaths; i++) ! 1168: { ! 1169: *bufptr++ = fpr->length[i]; ! 1170: bcopy(fpr->paths[i], bufptr, fpr->length[i]); ! 1171: bufptr += fpr->length[i]; ! 1172: } ! 1173: WriteReplyToClient(client, sizeof(xListFontsReply), &reply); ! 1174: WriteToClient(client, stringLens + fpr->npaths, bufferStart); ! 1175: FreeFontRecord(fpr); ! 1176: DEALLOCATE_LOCAL(bufferStart); ! 1177: ! 1178: return(client->noClientException); ! 1179: } ! 1180: ! 1181: int ! 1182: ProcListFontsWithInfo(client) ! 1183: register ClientPtr client; ! 1184: { ! 1185: register xListFontsWithInfoReply *reply; ! 1186: xListFontsWithInfoReply last_reply; ! 1187: FontRec font; ! 1188: FontInfoRec finfo; ! 1189: register FontPathPtr fpaths; ! 1190: register char **path; ! 1191: register int n, *length; ! 1192: int rlength; ! 1193: REQUEST(xListFontsWithInfoReq); ! 1194: ! 1195: REQUEST_AT_LEAST_SIZE(xListFontsWithInfoReq); ! 1196: ! 1197: fpaths = ExpandFontNamePattern( stuff->nbytes, &stuff[1], stuff->maxNames); ! 1198: font.pFI = &finfo; ! 1199: for (n = fpaths->npaths, path = fpaths->paths, length = fpaths->length; ! 1200: --n >= 0; ! 1201: path++, length++) ! 1202: { ! 1203: if (!(DescribeFont(*path, *length, &finfo, &font.pFP))) ! 1204: continue; ! 1205: rlength = sizeof(xListFontsWithInfoReply) ! 1206: + finfo.nProps * sizeof(xFontProp); ! 1207: if (reply = (xListFontsWithInfoReply *)ALLOCATE_LOCAL(rlength)) ! 1208: { ! 1209: reply->type = X_Reply; ! 1210: reply->sequenceNumber = client->sequence; ! 1211: reply->length = (rlength - sizeof(xGenericReply) ! 1212: + *length + 3) >> 2; ! 1213: QueryFont(&font, (xQueryFontReply *) reply, 0); ! 1214: reply->nameLength = *length; ! 1215: reply->nReplies = n; ! 1216: WriteReplyToClient(client, rlength, reply); ! 1217: WriteToClient(client, *length, *path); ! 1218: DEALLOCATE_LOCAL(reply); ! 1219: } ! 1220: Xfree((char *)font.pFP); ! 1221: } ! 1222: FreeFontRecord(fpaths); ! 1223: bzero((char *)&last_reply, sizeof(xListFontsWithInfoReply)); ! 1224: last_reply.type = X_Reply; ! 1225: last_reply.sequenceNumber = client->sequence; ! 1226: last_reply.length = (sizeof(xListFontsWithInfoReply) ! 1227: - sizeof(xGenericReply)) >> 2; ! 1228: WriteReplyToClient(client, sizeof(xListFontsWithInfoReply), &last_reply); ! 1229: return(client->noClientException); ! 1230: } ! 1231: ! 1232: int ! 1233: ProcCreatePixmap(client) ! 1234: register ClientPtr client; ! 1235: { ! 1236: PixmapPtr pMap; ! 1237: register DrawablePtr pDraw; ! 1238: REQUEST(xCreatePixmapReq); ! 1239: DepthPtr pDepth; ! 1240: register int i; ! 1241: ! 1242: REQUEST_AT_LEAST_SIZE(xCreatePixmapReq); ! 1243: client->errorValue = stuff->pid; ! 1244: LEGAL_NEW_RESOURCE(stuff->pid); ! 1245: if (!(pDraw = LOOKUP_DRAWABLE(stuff->drawable, client))) ! 1246: { /* can be inputonly */ ! 1247: if (!(pDraw = (DrawablePtr)LookupWindow(stuff->drawable, client))) ! 1248: return (BadDrawable); ! 1249: } ! 1250: ! 1251: if (!stuff->width || !stuff->height) ! 1252: return BadValue; ! 1253: if (stuff->depth != 1) ! 1254: { ! 1255: pDepth = pDraw->pScreen->allowedDepths; ! 1256: for (i=0; i<pDraw->pScreen->numDepths; i++, pDepth++) ! 1257: if (pDepth->depth == stuff->depth) ! 1258: goto CreatePmap; ! 1259: return BadValue; ! 1260: } ! 1261: CreatePmap: ! 1262: pMap = (PixmapPtr)(*pDraw->pScreen->CreatePixmap) ! 1263: (pDraw->pScreen, stuff->width, ! 1264: stuff->height, stuff->depth); ! 1265: if (pMap) ! 1266: { ! 1267: pMap->drawable.serialNumber = NEXT_SERIAL_NUMBER; ! 1268: AddResource( ! 1269: stuff->pid, RT_PIXMAP, pMap, pDraw->pScreen->DestroyPixmap, ! 1270: RC_CORE); ! 1271: return(client->noClientException); ! 1272: } ! 1273: else ! 1274: return (BadAlloc); ! 1275: } ! 1276: ! 1277: int ! 1278: ProcFreePixmap(client) ! 1279: register ClientPtr client; ! 1280: { ! 1281: PixmapPtr pMap; ! 1282: ! 1283: REQUEST(xResourceReq); ! 1284: ! 1285: REQUEST_SIZE_MATCH(xResourceReq); ! 1286: pMap = (PixmapPtr)LookupID(stuff->id, RT_PIXMAP, RC_CORE); ! 1287: if (pMap) ! 1288: { ! 1289: FreeResource(stuff->id, RC_NONE); ! 1290: return(client->noClientException); ! 1291: } ! 1292: else ! 1293: { ! 1294: client->errorValue = stuff->id; ! 1295: return (BadPixmap); ! 1296: } ! 1297: } ! 1298: ! 1299: int ! 1300: ProcCreateGC(client) ! 1301: register ClientPtr client; ! 1302: { ! 1303: int error; ! 1304: GC *pGC; ! 1305: register DrawablePtr pDraw; ! 1306: int len; ! 1307: REQUEST(xCreateGCReq); ! 1308: ! 1309: REQUEST_AT_LEAST_SIZE(xCreateGCReq); ! 1310: client->errorValue = stuff->gc; ! 1311: LEGAL_NEW_RESOURCE(stuff->gc); ! 1312: if (!(pDraw = LOOKUP_DRAWABLE( stuff->drawable, client) )) ! 1313: return (BadDrawable); ! 1314: len = stuff->length - (sizeof(xCreateGCReq) >> 2); ! 1315: if (len != Ones(stuff->mask)) ! 1316: return BadLength; ! 1317: pGC = (GC *)CreateGC(pDraw, stuff->mask, ! 1318: (char *) &stuff[1], &error); ! 1319: if (error != Success) ! 1320: return error; ! 1321: if (pGC) ! 1322: { ! 1323: AddResource(stuff->gc, RT_GC, pGC, FreeGC, RC_CORE); ! 1324: return(client->noClientException); ! 1325: } ! 1326: else ! 1327: return (BadAlloc); ! 1328: } ! 1329: ! 1330: int ! 1331: ProcChangeGC(client) ! 1332: register ClientPtr client; ! 1333: { ! 1334: GC *pGC; ! 1335: REQUEST(xChangeGCReq); ! 1336: int result, len; ! 1337: ! 1338: REQUEST_AT_LEAST_SIZE(xChangeGCReq); ! 1339: VERIFY_GC(pGC, stuff->gc, client); ! 1340: len = stuff->length - (sizeof(xChangeGCReq) >> 2); ! 1341: if (len != Ones(stuff->mask)) ! 1342: return BadLength; ! 1343: result = DoChangeGC(pGC, stuff->mask, (int *) &stuff[1], 0); ! 1344: if (client->noClientException != Success) ! 1345: return(client->noClientException); ! 1346: else ! 1347: return(result); ! 1348: } ! 1349: ! 1350: int ! 1351: ProcCopyGC(client) ! 1352: register ClientPtr client; ! 1353: { ! 1354: register GC *dstGC; ! 1355: register GC *pGC; ! 1356: REQUEST(xCopyGCReq); ! 1357: ! 1358: REQUEST_SIZE_MATCH(xCopyGCReq); ! 1359: VERIFY_GC( pGC, stuff->srcGC, client); ! 1360: VERIFY_GC( dstGC, stuff->dstGC, client); ! 1361: if ((dstGC->pScreen != pGC->pScreen) || (dstGC->depth != pGC->depth)) ! 1362: return (BadMatch); ! 1363: CopyGC(pGC, dstGC, stuff->mask); ! 1364: return (client->noClientException); ! 1365: } ! 1366: ! 1367: int ! 1368: ProcSetDashes(client) ! 1369: register ClientPtr client; ! 1370: { ! 1371: register GC *pGC; ! 1372: int result; ! 1373: REQUEST(xSetDashesReq); ! 1374: ! 1375: REQUEST_AT_LEAST_SIZE(xSetDashesReq); ! 1376: if ((sizeof(xSetDashesReq) >> 2) == stuff->length) ! 1377: return BadValue; ! 1378: ! 1379: VERIFY_GC(pGC,stuff->gc, client); ! 1380: ! 1381: result = SetDashes(pGC, stuff->dashOffset, stuff->nDashes, &stuff[1]); ! 1382: if (client->noClientException != Success) ! 1383: return(client->noClientException); ! 1384: else ! 1385: return(result); ! 1386: } ! 1387: ! 1388: int ! 1389: ProcSetClipRectangles(client) ! 1390: register ClientPtr client; ! 1391: { ! 1392: int nr; ! 1393: register GC *pGC; ! 1394: REQUEST(xSetClipRectanglesReq); ! 1395: ! 1396: REQUEST_AT_LEAST_SIZE(xSetClipRectanglesReq); ! 1397: if ((stuff->ordering != Unsorted) && (stuff->ordering != YSorted) && ! 1398: (stuff->ordering != YXSorted) && (stuff->ordering != YXBanded)) ! 1399: return BadValue; ! 1400: VERIFY_GC(pGC,stuff->gc, client); ! 1401: pGC->clipOrg.x = stuff->xOrigin; ! 1402: pGC->stateChanges |= GCClipXOrigin; ! 1403: ! 1404: pGC->clipOrg.y = stuff->yOrigin; ! 1405: pGC->stateChanges |= GCClipYOrigin; ! 1406: ! 1407: nr = ((stuff->length << 2) - sizeof(xSetClipRectanglesReq)) >> 3; ! 1408: SetClipRects(pGC, nr, &stuff[1], stuff->ordering); ! 1409: pGC->stateChanges |= GCClipMask; ! 1410: pGC->serialNumber = 0; ! 1411: return(client->noClientException); ! 1412: } ! 1413: ! 1414: int ! 1415: ProcFreeGC(client) ! 1416: register ClientPtr client; ! 1417: { ! 1418: register GC *pGC; ! 1419: REQUEST(xResourceReq); ! 1420: ! 1421: REQUEST_SIZE_MATCH(xResourceReq); ! 1422: VERIFY_GC(pGC,stuff->id,client); ! 1423: FreeResource(stuff->id, RC_NONE); ! 1424: return(client->noClientException); ! 1425: } ! 1426: ! 1427: int ! 1428: ProcClearToBackground(client) ! 1429: register ClientPtr client; ! 1430: { ! 1431: REQUEST(xClearAreaReq); ! 1432: register WindowPtr pWin; ! 1433: ! 1434: REQUEST_SIZE_MATCH(xClearAreaReq); ! 1435: pWin = (WindowPtr)LookupWindow( stuff->window, client); ! 1436: if (!pWin) ! 1437: return(BadWindow); ! 1438: if (pWin->class == InputOnly) ! 1439: { ! 1440: client->errorValue = stuff->window; ! 1441: return (BadWindow); ! 1442: } ! 1443: if ((stuff->exposures != xTrue) && (stuff->exposures != xFalse)) ! 1444: return(BadValue); ! 1445: (*pWin->ClearToBackground)(pWin, stuff->x, stuff->y, ! 1446: stuff->width, stuff->height, ! 1447: (Bool)stuff->exposures); ! 1448: return(client->noClientException); ! 1449: } ! 1450: ! 1451: int ! 1452: ProcCopyArea(client) ! 1453: register ClientPtr client; ! 1454: { ! 1455: register DrawablePtr pDst; ! 1456: register DrawablePtr pSrc; ! 1457: register GC *pGC; ! 1458: REQUEST(xCopyAreaReq); ! 1459: ! 1460: REQUEST_SIZE_MATCH(xCopyAreaReq); ! 1461: ! 1462: VALIDATE_DRAWABLE_AND_GC(stuff->dstDrawable, pDst, pGC, client); ! 1463: if (stuff->dstDrawable != stuff->srcDrawable) ! 1464: { ! 1465: if (!(pSrc = LOOKUP_DRAWABLE(stuff->srcDrawable, client))) ! 1466: return(BadDrawable); ! 1467: if ((pDst->pScreen != pSrc->pScreen) || (pDst->depth != pSrc->depth)) ! 1468: { ! 1469: client->errorValue = stuff->dstDrawable; ! 1470: return (BadMatch); ! 1471: } ! 1472: } ! 1473: else ! 1474: pSrc = pDst; ! 1475: (*pGC->CopyArea)(pSrc, pDst, pGC, stuff->srcX, stuff->srcY, ! 1476: stuff->width, stuff->height, ! 1477: stuff->dstX, stuff->dstY); ! 1478: ! 1479: return(client->noClientException); ! 1480: } ! 1481: ! 1482: int ! 1483: ProcCopyPlane(client) ! 1484: register ClientPtr client; ! 1485: { ! 1486: register DrawablePtr psrcDraw, pdstDraw; ! 1487: register GC *pGC; ! 1488: REQUEST(xCopyPlaneReq); ! 1489: ! 1490: REQUEST_SIZE_MATCH(xCopyPlaneReq); ! 1491: ! 1492: /* Check to see if stuff->bitPlane has exactly ONE bit set */ ! 1493: if(stuff->bitPlane == 0 || stuff->bitPlane & (stuff->bitPlane - 1)) ! 1494: return(BadValue); ! 1495: ! 1496: VALIDATE_DRAWABLE_AND_GC(stuff->dstDrawable, pdstDraw, pGC, client); ! 1497: if (stuff->dstDrawable != stuff->srcDrawable) ! 1498: { ! 1499: if (!(psrcDraw = LOOKUP_DRAWABLE(stuff->srcDrawable, client))) ! 1500: return(BadDrawable); ! 1501: if (pdstDraw->pScreen != psrcDraw->pScreen) ! 1502: { ! 1503: client->errorValue = stuff->dstDrawable; ! 1504: return (BadMatch); ! 1505: } ! 1506: } ! 1507: else ! 1508: psrcDraw = pdstDraw; ! 1509: (*pGC->CopyPlane)(psrcDraw, pdstDraw, pGC, stuff->srcX, stuff->srcY, ! 1510: stuff->width, stuff->height, ! 1511: stuff->dstX, stuff->dstY, stuff->bitPlane); ! 1512: return(client->noClientException); ! 1513: } ! 1514: ! 1515: int ! 1516: ProcPolyPoint(client) ! 1517: register ClientPtr client; ! 1518: { ! 1519: int npoint; ! 1520: register GC *pGC; ! 1521: register DrawablePtr pDraw; ! 1522: REQUEST(xPolyPointReq); ! 1523: ! 1524: REQUEST_AT_LEAST_SIZE(xPolyPointReq); ! 1525: if ((stuff->coordMode != CoordModeOrigin) && ! 1526: (stuff->coordMode != CoordModePrevious)) ! 1527: return BadValue; ! 1528: VALIDATE_DRAWABLE_AND_GC(stuff->drawable, pDraw, pGC, client); ! 1529: npoint = ((stuff->length << 2) - sizeof(xPolyPointReq)) >> 2; ! 1530: if (npoint) ! 1531: (*pGC->PolyPoint)(pDraw, pGC, stuff->coordMode, npoint, ! 1532: (xPoint *) &stuff[1]); ! 1533: return (client->noClientException); ! 1534: } ! 1535: ! 1536: int ! 1537: ProcPolyLine(client) ! 1538: register ClientPtr client; ! 1539: { ! 1540: int npoint; ! 1541: register GC *pGC; ! 1542: register DrawablePtr pDraw; ! 1543: REQUEST(xPolyLineReq); ! 1544: ! 1545: REQUEST_AT_LEAST_SIZE(xPolyLineReq); ! 1546: if ((stuff->coordMode != CoordModeOrigin) && ! 1547: (stuff->coordMode != CoordModePrevious)) ! 1548: return BadValue; ! 1549: VALIDATE_DRAWABLE_AND_GC(stuff->drawable, pDraw, pGC, client); ! 1550: npoint = ((stuff->length << 2) - sizeof(xPolyLineReq)); ! 1551: if(npoint % sizeof(xPoint) != 0) ! 1552: return(BadLength); ! 1553: npoint >>= 2; ! 1554: if (npoint < 1) ! 1555: return(BadLength); ! 1556: ! 1557: (*pGC->Polylines)(pDraw, pGC, stuff->coordMode, npoint, ! 1558: (xPoint *) &stuff[1]); ! 1559: return(client->noClientException); ! 1560: } ! 1561: ! 1562: int ! 1563: ProcPolySegment(client) ! 1564: register ClientPtr client; ! 1565: { ! 1566: int nsegs; ! 1567: register GC *pGC; ! 1568: register DrawablePtr pDraw; ! 1569: REQUEST(xPolySegmentReq); ! 1570: ! 1571: REQUEST_AT_LEAST_SIZE(xPolySegmentReq); ! 1572: VALIDATE_DRAWABLE_AND_GC(stuff->drawable, pDraw, pGC, client); ! 1573: nsegs = (stuff->length << 2) - sizeof(xPolySegmentReq); ! 1574: if(nsegs % sizeof(xSegment) != 0) ! 1575: return(BadLength); ! 1576: nsegs >>= 3; ! 1577: if (nsegs) ! 1578: (*pGC->PolySegment)(pDraw, pGC, nsegs, (xSegment *) &stuff[1]); ! 1579: return (client->noClientException); ! 1580: } ! 1581: ! 1582: int ! 1583: ProcPolyRectangle (client) ! 1584: register ClientPtr client; ! 1585: { ! 1586: int nrects; ! 1587: register GC *pGC; ! 1588: register DrawablePtr pDraw; ! 1589: REQUEST(xPolyRectangleReq); ! 1590: ! 1591: REQUEST_AT_LEAST_SIZE(xPolyRectangleReq); ! 1592: VALIDATE_DRAWABLE_AND_GC(stuff->drawable, pDraw, pGC, client); ! 1593: nrects = ((stuff->length << 2) - sizeof(xPolyRectangleReq)) >> 3; ! 1594: if (nrects) ! 1595: (*pGC->PolyRectangle)(pDraw, pGC, ! 1596: nrects, (xRectangle *) &stuff[1]); ! 1597: return(client->noClientException); ! 1598: } ! 1599: ! 1600: int ! 1601: ProcPolyArc(client) ! 1602: register ClientPtr client; ! 1603: { ! 1604: int narcs; ! 1605: register GC *pGC; ! 1606: register DrawablePtr pDraw; ! 1607: REQUEST(xPolyArcReq); ! 1608: ! 1609: REQUEST_AT_LEAST_SIZE(xPolyArcReq); ! 1610: VALIDATE_DRAWABLE_AND_GC(stuff->drawable, pDraw, pGC, client); ! 1611: narcs = ((stuff->length << 2) - sizeof(xPolyArcReq)) / ! 1612: sizeof(xArc); ! 1613: if (narcs) ! 1614: (*pGC->PolyArc)(pDraw, pGC, narcs, (xArc *) &stuff[1]); ! 1615: return (client->noClientException); ! 1616: } ! 1617: ! 1618: int ! 1619: ProcFillPoly(client) ! 1620: register ClientPtr client; ! 1621: { ! 1622: int things; ! 1623: register GC *pGC; ! 1624: register DrawablePtr pDraw; ! 1625: REQUEST(xFillPolyReq); ! 1626: ! 1627: REQUEST_AT_LEAST_SIZE(xFillPolyReq); ! 1628: if ((stuff->shape != Complex) && (stuff->shape != Nonconvex) && ! 1629: (stuff->shape != Convex) && (stuff->coordMode != CoordModeOrigin) && ! 1630: (stuff->coordMode != CoordModePrevious)) ! 1631: return BadValue; ! 1632: ! 1633: VALIDATE_DRAWABLE_AND_GC(stuff->drawable, pDraw, pGC, client); ! 1634: things = ((stuff->length << 2) - sizeof(xFillPolyReq)) >> 2; ! 1635: if (things) ! 1636: (*pGC->FillPolygon) (pDraw, pGC, stuff->shape, ! 1637: stuff->coordMode, things, ! 1638: (DDXPointPtr) &stuff[1]); ! 1639: return(client->noClientException); ! 1640: } ! 1641: ! 1642: int ! 1643: ProcPolyFillRectangle(client) ! 1644: register ClientPtr client; ! 1645: { ! 1646: int things; ! 1647: register GC *pGC; ! 1648: register DrawablePtr pDraw; ! 1649: REQUEST(xPolyFillRectangleReq); ! 1650: ! 1651: REQUEST_AT_LEAST_SIZE(xPolyFillRectangleReq); ! 1652: VALIDATE_DRAWABLE_AND_GC(stuff->drawable, pDraw, pGC, client); ! 1653: things = ((stuff->length << 2) - ! 1654: sizeof(xPolyFillRectangleReq)) >> 3; ! 1655: if (things) ! 1656: (*pGC->PolyFillRect) (pDraw, pGC, things, ! 1657: (xRectangle *) &stuff[1]); ! 1658: return (client->noClientException); ! 1659: } ! 1660: ! 1661: int ! 1662: ProcPolyFillArc (client) ! 1663: register ClientPtr client; ! 1664: { ! 1665: int narcs; ! 1666: register GC *pGC; ! 1667: register DrawablePtr pDraw; ! 1668: REQUEST(xPolyFillArcReq); ! 1669: ! 1670: REQUEST_AT_LEAST_SIZE(xPolyFillArcReq); ! 1671: VALIDATE_DRAWABLE_AND_GC(stuff->drawable, pDraw, pGC, client); ! 1672: narcs = ((stuff->length << 2) - ! 1673: sizeof(xPolyFillArcReq)) / sizeof(xArc); ! 1674: if (narcs) ! 1675: (*pGC->PolyFillArc) (pDraw, pGC, narcs, (xArc *) &stuff[1]); ! 1676: return (client->noClientException); ! 1677: } ! 1678: ! 1679: int ! 1680: ProcPutImage(client) ! 1681: register ClientPtr client; ! 1682: { ! 1683: register GC *pGC; ! 1684: register DrawablePtr pDraw; ! 1685: REQUEST(xPutImageReq); ! 1686: ! 1687: REQUEST_AT_LEAST_SIZE(xPutImageReq); ! 1688: VALIDATE_DRAWABLE_AND_GC(stuff->drawable, pDraw, pGC, client); ! 1689: if (stuff->format == XYBitmap) ! 1690: { ! 1691: if ((stuff->depth != 1) || (stuff->leftPad > screenInfo.bitmapScanlineUnit)) ! 1692: return BadMatch; ! 1693: } ! 1694: else if (stuff->format == XYPixmap) ! 1695: { ! 1696: if ((pDraw->depth != stuff->depth) || ! 1697: (stuff->leftPad > screenInfo.bitmapScanlineUnit)) ! 1698: return BadMatch; ! 1699: } ! 1700: else if (stuff->format == ZPixmap) ! 1701: { ! 1702: if ((pDraw->depth != stuff->depth) || (stuff->leftPad != 0)) ! 1703: return BadMatch; ! 1704: } ! 1705: else ! 1706: return BadValue; ! 1707: (*pGC->PutImage) (pDraw, pGC, stuff->depth, stuff->dstX, stuff->dstY, ! 1708: stuff->width, stuff->height, ! 1709: stuff->leftPad, stuff->format, ! 1710: (char *) &stuff[1]); ! 1711: return (client->noClientException); ! 1712: } ! 1713: ! 1714: int ! 1715: ProcGetImage(client) ! 1716: register ClientPtr client; ! 1717: { ! 1718: register DrawablePtr pDraw; ! 1719: int nlines, linesPerBuf, widthBytesLine; ! 1720: register int height, linesDone; ! 1721: int plane; ! 1722: char *pBuf; ! 1723: xGetImageReply xgi; ! 1724: ! 1725: REQUEST(xGetImageReq); ! 1726: ! 1727: height = stuff->height; ! 1728: REQUEST_SIZE_MATCH(xGetImageReq); ! 1729: if ((stuff->format != XYPixmap) && (stuff->format != ZPixmap)) ! 1730: return(BadValue); ! 1731: if(!(pDraw = LOOKUP_DRAWABLE(stuff->drawable, client) )) ! 1732: return (BadDrawable); ! 1733: if(pDraw->type == DRAWABLE_WINDOW) ! 1734: { ! 1735: if( /* check for being on screen */ ! 1736: ((WindowPtr) pDraw)->absCorner.x + stuff->x < 0 || ! 1737: ((WindowPtr) pDraw)->absCorner.x + stuff->x + stuff->width > ! 1738: pDraw->pScreen->width || ! 1739: ((WindowPtr) pDraw)->absCorner.y + stuff->y < 0 || ! 1740: ((WindowPtr) pDraw)->absCorner.y + stuff->y + height > ! 1741: pDraw->pScreen->height || ! 1742: /* check for being inside of border */ ! 1743: stuff->x < -((WindowPtr)pDraw)->borderWidth || ! 1744: stuff->x + stuff->width > ! 1745: ((WindowPtr)pDraw)->borderWidth + ! 1746: ((WindowPtr)pDraw)->clientWinSize.width || ! 1747: stuff->y < -((WindowPtr)pDraw)->borderWidth || ! 1748: stuff->y + stuff->height > ! 1749: ((WindowPtr)pDraw)->borderWidth + ! 1750: ((WindowPtr)pDraw)->clientWinSize.height ! 1751: ) ! 1752: return(BadMatch); ! 1753: xgi.visual = ((WindowPtr) pDraw)->visual; ! 1754: } ! 1755: else ! 1756: { ! 1757: if((stuff->x < 0) || ! 1758: (stuff->x+stuff->width > ((PixmapPtr) pDraw)->width) || ! 1759: (stuff->y < 0) || ! 1760: (stuff->y+stuff->height > ((PixmapPtr) pDraw)->height) ! 1761: ) ! 1762: return(BadMatch); ! 1763: xgi.visual = None; ! 1764: } ! 1765: xgi.type = X_Reply; ! 1766: /* should this be set??? */ ! 1767: xgi.sequenceNumber = client->sequence; ! 1768: xgi.depth = pDraw->depth; ! 1769: if(stuff->format == ZPixmap) ! 1770: { ! 1771: widthBytesLine = PixmapBytePad(stuff->width, pDraw->depth); ! 1772: xgi.length = (widthBytesLine >> 2) * stuff->height; ! 1773: } ! 1774: else ! 1775: { ! 1776: widthBytesLine = PixmapBytePad(stuff->width, 1); ! 1777: xgi.length = (widthBytesLine >> 2) * stuff->height * ! 1778: /* only planes asked for */ ! 1779: Ones(stuff->planeMask & ((1 << pDraw->depth) - 1)); ! 1780: } ! 1781: linesPerBuf = IMAGE_BUFSIZE / widthBytesLine; ! 1782: if(!(pBuf = (char *) ALLOCATE_LOCAL(IMAGE_BUFSIZE))) ! 1783: return (client->noClientException = BadAlloc); ! 1784: ! 1785: WriteReplyToClient(client, sizeof (xGetImageReply), &xgi); ! 1786: ! 1787: if (stuff->format == ZPixmap) ! 1788: { ! 1789: linesDone = 0; ! 1790: while (height - linesDone > 0) ! 1791: { ! 1792: nlines = min(linesPerBuf, height - linesDone); ! 1793: (*pDraw->pScreen->GetImage) (pDraw, ! 1794: stuff->x, ! 1795: stuff->y + linesDone, ! 1796: stuff->width, ! 1797: nlines, ! 1798: stuff->format, ! 1799: stuff->planeMask, ! 1800: pBuf); ! 1801: /* Note that this is NOT a call to WriteSwappedDataToClient, ! 1802: as we do NOT byte swap */ ! 1803: WriteToClient(client, nlines * widthBytesLine, pBuf); ! 1804: linesDone += nlines; ! 1805: } ! 1806: } ! 1807: else ! 1808: { ! 1809: for (plane = 1 << (pDraw->depth - 1); plane; plane >>= 1) ! 1810: { ! 1811: if (stuff->planeMask & plane) ! 1812: { ! 1813: linesDone = 0; ! 1814: while (height - linesDone > 0) ! 1815: { ! 1816: nlines = min(linesPerBuf, height - linesDone); ! 1817: (*pDraw->pScreen->GetImage) (pDraw, ! 1818: stuff->x, ! 1819: stuff->y + linesDone, ! 1820: stuff->width, ! 1821: nlines, ! 1822: stuff->format, ! 1823: plane, ! 1824: pBuf); ! 1825: /* Note: NOT a call to WriteSwappedDataToClient, ! 1826: as we do NOT byte swap */ ! 1827: WriteToClient(client, nlines * widthBytesLine, pBuf); ! 1828: linesDone += nlines; ! 1829: } ! 1830: } ! 1831: } ! 1832: } ! 1833: DEALLOCATE_LOCAL(pBuf); ! 1834: return (client->noClientException); ! 1835: } ! 1836: ! 1837: ! 1838: int ! 1839: ProcPolyText(client) ! 1840: register ClientPtr client; ! 1841: { ! 1842: int xorg; ! 1843: REQUEST(xPolyTextReq); ! 1844: register DrawablePtr pDraw; ! 1845: register GC *pGC; ! 1846: register FontPtr pFont; ! 1847: ! 1848: int (* polyText)(); ! 1849: register unsigned char *pElt; ! 1850: unsigned char *pNextElt; ! 1851: unsigned char *endReq; ! 1852: int itemSize; ! 1853: ! 1854: #define TextEltHeader 2 ! 1855: #define FontShiftSize 5 ! 1856: ! 1857: REQUEST_AT_LEAST_SIZE(xPolyTextReq); ! 1858: VALIDATE_DRAWABLE_AND_GC(stuff->drawable, pDraw, pGC, client); ! 1859: ! 1860: pElt = (unsigned char *)&stuff[1]; ! 1861: endReq = ((unsigned char *) stuff) + (stuff->length <<2); ! 1862: xorg = stuff->x; ! 1863: if (stuff->reqType == X_PolyText8) ! 1864: { ! 1865: polyText = pGC->PolyText8; ! 1866: itemSize = 1; ! 1867: } ! 1868: else ! 1869: { ! 1870: polyText = pGC->PolyText16; ! 1871: itemSize = 2; ! 1872: } ! 1873: ! 1874: while (endReq - pElt > TextEltHeader) ! 1875: { ! 1876: if (*pElt == FontChange) ! 1877: { ! 1878: Font fid; ! 1879: ! 1880: if (endReq - pElt < FontShiftSize) ! 1881: return (BadLength); ! 1882: fid = *(pElt+4) /* big-endian */ ! 1883: | *(pElt+3) << 8 ! 1884: | *(pElt+2) << 16 ! 1885: | *(pElt+1) << 24; ! 1886: pFont = (FontPtr)LookupID(fid, RT_FONT, RC_CORE); ! 1887: if (!pFont) ! 1888: { ! 1889: client->errorValue = fid; ! 1890: return (BadFont); ! 1891: } ! 1892: if (pFont != pGC->font) ! 1893: { ! 1894: DoChangeGC( pGC, GCFont, &fid, 0); ! 1895: ValidateGC(pDraw, pGC); ! 1896: } ! 1897: pElt += FontShiftSize; ! 1898: } ! 1899: else /* print a string */ ! 1900: { ! 1901: pNextElt = pElt + TextEltHeader + (*pElt)*itemSize; ! 1902: if ( pNextElt > endReq) ! 1903: return( BadLength); ! 1904: xorg += *((char *)(pElt + 1)); /* must be signed */ ! 1905: xorg = (* polyText)(pDraw, pGC, xorg, stuff->y, *pElt, ! 1906: pElt + TextEltHeader); ! 1907: pElt = pNextElt; ! 1908: } ! 1909: } ! 1910: return (client->noClientException); ! 1911: #undef TextEltHeader ! 1912: #undef FontShiftSize ! 1913: } ! 1914: ! 1915: int ! 1916: ProcImageText(client) ! 1917: register ClientPtr client; ! 1918: { ! 1919: register DrawablePtr pDraw; ! 1920: register GC *pGC; ! 1921: ! 1922: REQUEST(xImageTextReq); ! 1923: ! 1924: REQUEST_AT_LEAST_SIZE(xImageTextReq); ! 1925: VALIDATE_DRAWABLE_AND_GC(stuff->drawable, pDraw, pGC, client); ! 1926: ! 1927: (*((stuff->reqType == X_ImageText8) ? pGC->ImageText8 : pGC->ImageText16)) ! 1928: (pDraw, pGC, stuff->x, stuff->y, stuff->nChars, &stuff[1]); ! 1929: return (client->noClientException); ! 1930: } ! 1931: ! 1932: ! 1933: int ! 1934: ProcCreateColormap(client) ! 1935: register ClientPtr client; ! 1936: { ! 1937: VisualPtr pVisual; ! 1938: ColormapPtr pmap; ! 1939: int mid; ! 1940: register WindowPtr pWin; ! 1941: REQUEST(xCreateColormapReq); ! 1942: int result; ! 1943: ! 1944: REQUEST_SIZE_MATCH(xCreateColormapReq); ! 1945: ! 1946: if ((stuff->alloc != AllocNone) && (stuff->alloc != AllocAll)) ! 1947: return(BadValue); ! 1948: mid = stuff->mid; ! 1949: LEGAL_NEW_RESOURCE(mid); ! 1950: pWin = (WindowPtr)LookupWindow(stuff->window, client); ! 1951: if (!pWin) ! 1952: return(BadWindow); ! 1953: ! 1954: pVisual = (VisualPtr)LookupID(stuff->visual, RT_VISUALID, RC_CORE); ! 1955: if ((!pVisual) || pVisual->screen != pWin->drawable.pScreen->myNum) ! 1956: { ! 1957: client->errorValue = stuff->visual; ! 1958: return(BadValue); ! 1959: } ! 1960: result = CreateColormap(mid, pWin->drawable.pScreen, ! 1961: pVisual, &pmap, stuff->alloc, client->index); ! 1962: if (client->noClientException != Success) ! 1963: return(client->noClientException); ! 1964: else ! 1965: return(result); ! 1966: } ! 1967: ! 1968: int ! 1969: ProcFreeColormap(client) ! 1970: register ClientPtr client; ! 1971: { ! 1972: ColormapPtr pmap; ! 1973: REQUEST(xResourceReq); ! 1974: ! 1975: REQUEST_SIZE_MATCH(xResourceReq); ! 1976: pmap = (ColormapPtr )LookupID(stuff->id, RT_COLORMAP, RC_CORE); ! 1977: if (pmap) ! 1978: { ! 1979: FreeColormap(pmap, (client->index << CLIENTOFFSET)); ! 1980: FreeResource(stuff->id, RC_NONE); ! 1981: return (client->noClientException); ! 1982: } ! 1983: else ! 1984: { ! 1985: client->errorValue = stuff->id; ! 1986: return (BadColor); ! 1987: } ! 1988: } ! 1989: ! 1990: ! 1991: int ! 1992: ProcCopyColormapAndFree(client) ! 1993: register ClientPtr client; ! 1994: { ! 1995: int mid; ! 1996: ColormapPtr pSrcMap; ! 1997: REQUEST(xCopyColormapAndFreeReq); ! 1998: int result; ! 1999: ! 2000: REQUEST_SIZE_MATCH(xCopyColormapAndFreeReq); ! 2001: mid = stuff->mid; ! 2002: LEGAL_NEW_RESOURCE(mid); ! 2003: if(pSrcMap = (ColormapPtr )LookupID(stuff->srcCmap, RT_COLORMAP, RC_CORE)) ! 2004: { ! 2005: result = CopyColormapAndFree(mid, pSrcMap, client->index); ! 2006: if (client->noClientException != Success) ! 2007: return(client->noClientException); ! 2008: else ! 2009: return(result); ! 2010: } ! 2011: else ! 2012: { ! 2013: client->errorValue = stuff->srcCmap; ! 2014: return(BadColor); ! 2015: } ! 2016: } ! 2017: ! 2018: int ! 2019: ProcInstallColormap(client) ! 2020: register ClientPtr client; ! 2021: { ! 2022: ColormapPtr pcmp; ! 2023: REQUEST(xResourceReq); ! 2024: ! 2025: REQUEST_SIZE_MATCH(xResourceReq); ! 2026: pcmp = (ColormapPtr )LookupID(stuff->id, RT_COLORMAP, RC_CORE); ! 2027: if (pcmp) ! 2028: { ! 2029: (*(pcmp->pScreen->InstallColormap)) (pcmp); ! 2030: return (client->noClientException); ! 2031: } ! 2032: else ! 2033: { ! 2034: client->errorValue = stuff->id; ! 2035: return (BadColor); ! 2036: } ! 2037: } ! 2038: ! 2039: int ! 2040: ProcUninstallColormap(client) ! 2041: register ClientPtr client; ! 2042: { ! 2043: ColormapPtr pcmp; ! 2044: REQUEST(xResourceReq); ! 2045: ! 2046: REQUEST_SIZE_MATCH(xResourceReq); ! 2047: pcmp = (ColormapPtr )LookupID(stuff->id, RT_COLORMAP, RC_CORE); ! 2048: if (pcmp) ! 2049: { ! 2050: if(pcmp->mid != pcmp->pScreen->defColormap) ! 2051: (*(pcmp->pScreen->UninstallColormap)) (pcmp); ! 2052: return (client->noClientException); ! 2053: } ! 2054: else ! 2055: { ! 2056: client->errorValue = stuff->id; ! 2057: return (BadColor); ! 2058: } ! 2059: } ! 2060: ! 2061: int ! 2062: ProcListInstalledColormaps(client) ! 2063: register ClientPtr client; ! 2064: { ! 2065: xListInstalledColormapsReply *preply; ! 2066: int nummaps; ! 2067: WindowPtr pWin; ! 2068: REQUEST(xResourceReq); ! 2069: ! 2070: REQUEST_SIZE_MATCH(xResourceReq); ! 2071: pWin = (WindowPtr)LookupWindow(stuff->id, client); ! 2072: ! 2073: if (!pWin) ! 2074: return(BadWindow); ! 2075: ! 2076: preply = (xListInstalledColormapsReply *) ! 2077: ALLOCATE_LOCAL(sizeof(xListInstalledColormapsReply) + ! 2078: pWin->drawable.pScreen->maxInstalledCmaps * ! 2079: sizeof(Colormap)); ! 2080: if(!preply) ! 2081: return(client->noClientException = BadAlloc); ! 2082: ! 2083: preply->type = X_Reply; ! 2084: preply->sequenceNumber = client->sequence; ! 2085: nummaps = (*pWin->drawable.pScreen->ListInstalledColormaps) ! 2086: (pWin->drawable.pScreen, (Colormap *)&preply[1]); ! 2087: preply->nColormaps = nummaps; ! 2088: preply->length = nummaps; ! 2089: WriteReplyToClient(client, sizeof (xListInstalledColormapsReply), preply); ! 2090: client->pSwapReplyFunc = Swap32Write; ! 2091: WriteSwappedDataToClient(client, nummaps * sizeof(Colormap), &preply[1]); ! 2092: DEALLOCATE_LOCAL(preply); ! 2093: return(client->noClientException); ! 2094: } ! 2095: ! 2096: int ! 2097: ProcAllocColor (client) ! 2098: register ClientPtr client; ! 2099: { ! 2100: ColormapPtr pmap; ! 2101: int retval; ! 2102: xAllocColorReply acr; ! 2103: REQUEST(xAllocColorReq); ! 2104: ! 2105: REQUEST_SIZE_MATCH(xAllocColorReq); ! 2106: pmap = (ColormapPtr )LookupID(stuff->cmap, RT_COLORMAP, RC_CORE); ! 2107: if (pmap) ! 2108: { ! 2109: acr.type = X_Reply; ! 2110: acr.length = 0; ! 2111: acr.sequenceNumber = client->sequence; ! 2112: acr.red = stuff->red; ! 2113: acr.green = stuff->green; ! 2114: acr.blue = stuff->blue; ! 2115: acr.pixel = 0; ! 2116: if(retval = AllocColor(pmap, &acr.red, &acr.green, &acr.blue, ! 2117: &acr.pixel, client->index)) ! 2118: { ! 2119: if (client->noClientException != Success) ! 2120: return(client->noClientException); ! 2121: else ! 2122: return (retval); ! 2123: } ! 2124: WriteReplyToClient(client, sizeof(xAllocColorReply), &acr); ! 2125: return (client->noClientException); ! 2126: ! 2127: } ! 2128: else ! 2129: { ! 2130: client->errorValue = stuff->cmap; ! 2131: return (BadColor); ! 2132: } ! 2133: } ! 2134: ! 2135: int ! 2136: ProcAllocNamedColor (client) ! 2137: register ClientPtr client; ! 2138: { ! 2139: ColormapPtr pcmp; ! 2140: REQUEST(xAllocNamedColorReq); ! 2141: ! 2142: REQUEST_AT_LEAST_SIZE(xAllocNamedColorReq); ! 2143: pcmp = (ColormapPtr )LookupID(stuff->cmap, RT_COLORMAP, RC_CORE); ! 2144: if (pcmp) ! 2145: { ! 2146: int retval; ! 2147: ! 2148: xAllocNamedColorReply ancr; ! 2149: ! 2150: ancr.type = X_Reply; ! 2151: ancr.length = 0; ! 2152: ancr.sequenceNumber = client->sequence; ! 2153: ! 2154: if(OsLookupColor(pcmp->pScreen->myNum, (char *)&stuff[1], stuff->nbytes, ! 2155: &ancr.exactRed, &ancr.exactGreen, &ancr.exactBlue)) ! 2156: { ! 2157: ancr.screenRed = ancr.exactRed; ! 2158: ancr.screenGreen = ancr.exactGreen; ! 2159: ancr.screenBlue = ancr.exactBlue; ! 2160: ancr.pixel = 0; ! 2161: if(retval = AllocColor(pcmp, ! 2162: &ancr.screenRed, &ancr.screenGreen, &ancr.screenBlue, ! 2163: &ancr.pixel, client->index)) ! 2164: { ! 2165: if (client->noClientException != Success) ! 2166: return(client->noClientException); ! 2167: else ! 2168: return(retval); ! 2169: } ! 2170: WriteReplyToClient(client, sizeof (xAllocNamedColorReply), &ancr); ! 2171: return (client->noClientException); ! 2172: } ! 2173: else ! 2174: return(BadName); ! 2175: ! 2176: } ! 2177: else ! 2178: { ! 2179: client->errorValue = stuff->cmap; ! 2180: return (BadColor); ! 2181: } ! 2182: } ! 2183: ! 2184: int ! 2185: ProcAllocColorCells (client) ! 2186: register ClientPtr client; ! 2187: { ! 2188: ColormapPtr pcmp; ! 2189: REQUEST(xAllocColorCellsReq); ! 2190: ! 2191: REQUEST_SIZE_MATCH(xAllocColorCellsReq); ! 2192: pcmp = (ColormapPtr )LookupID(stuff->cmap, RT_COLORMAP, RC_CORE); ! 2193: if (pcmp) ! 2194: { ! 2195: xAllocColorCellsReply accr; ! 2196: int npixels, nmasks, retval; ! 2197: unsigned long *ppixels, *pmasks; ! 2198: ! 2199: npixels = stuff->colors; ! 2200: nmasks = stuff->planes; ! 2201: ppixels = (unsigned long *)ALLOCATE_LOCAL(npixels * sizeof(long) + ! 2202: nmasks * sizeof(long)); ! 2203: if(!ppixels) ! 2204: return(client->noClientException = BadAlloc); ! 2205: pmasks = ppixels + npixels; ! 2206: ! 2207: if(retval = AllocColorCells(client->index, pcmp, npixels, nmasks, ! 2208: stuff->contiguous, ppixels, pmasks)) ! 2209: { ! 2210: DEALLOCATE_LOCAL(ppixels); ! 2211: if (client->noClientException != Success) ! 2212: return(client->noClientException); ! 2213: else ! 2214: return(retval); ! 2215: } ! 2216: accr.type = X_Reply; ! 2217: accr.length = ( (npixels + nmasks) * sizeof(long)) >> 2; ! 2218: accr.sequenceNumber = client->sequence; ! 2219: accr.nPixels = npixels; ! 2220: accr.nMasks = nmasks; ! 2221: WriteReplyToClient(client, sizeof (xAllocColorCellsReply), &accr); ! 2222: client->pSwapReplyFunc = Swap32Write; ! 2223: WriteSwappedDataToClient(client, (npixels + nmasks) * sizeof (long), ppixels); ! 2224: DEALLOCATE_LOCAL(ppixels); ! 2225: return (client->noClientException); ! 2226: } ! 2227: else ! 2228: { ! 2229: client->errorValue = stuff->cmap; ! 2230: return (BadColor); ! 2231: } ! 2232: } ! 2233: ! 2234: int ! 2235: ProcAllocColorPlanes(client) ! 2236: register ClientPtr client; ! 2237: { ! 2238: ColormapPtr pcmp; ! 2239: REQUEST(xAllocColorPlanesReq); ! 2240: ! 2241: REQUEST_SIZE_MATCH(xAllocColorPlanesReq); ! 2242: pcmp = (ColormapPtr )LookupID(stuff->cmap, RT_COLORMAP, RC_CORE); ! 2243: if (pcmp) ! 2244: { ! 2245: xAllocColorPlanesReply acpr; ! 2246: int npixels, retval; ! 2247: unsigned long *ppixels; ! 2248: ! 2249: npixels = stuff->colors; ! 2250: acpr.type = X_Reply; ! 2251: acpr.sequenceNumber = client->sequence; ! 2252: acpr.nPixels = npixels; ! 2253: npixels *= sizeof(long); ! 2254: ppixels = (unsigned long *)ALLOCATE_LOCAL(npixels); ! 2255: if(!ppixels) ! 2256: return(client->noClientException = BadAlloc); ! 2257: if(retval = AllocColorPlanes(client->index, pcmp, stuff->colors, ! 2258: stuff->red, stuff->green, stuff->blue, stuff->contiguous, ppixels, ! 2259: &acpr.redMask, &acpr.greenMask, &acpr.blueMask)) ! 2260: { ! 2261: DEALLOCATE_LOCAL(ppixels); ! 2262: if (client->noClientException != Success) ! 2263: return(client->noClientException); ! 2264: else ! 2265: return(retval); ! 2266: } ! 2267: acpr.length = npixels >> 2; ! 2268: WriteReplyToClient(client, sizeof(xAllocColorPlanesReply), &acpr); ! 2269: client->pSwapReplyFunc = Swap32Write; ! 2270: WriteSwappedDataToClient(client, npixels, ppixels); ! 2271: DEALLOCATE_LOCAL(ppixels); ! 2272: return (client->noClientException); ! 2273: } ! 2274: else ! 2275: { ! 2276: client->errorValue = stuff->cmap; ! 2277: return (BadColor); ! 2278: } ! 2279: } ! 2280: ! 2281: int ! 2282: ProcFreeColors (client) ! 2283: register ClientPtr client; ! 2284: { ! 2285: ColormapPtr pcmp; ! 2286: REQUEST(xFreeColorsReq); ! 2287: ! 2288: REQUEST_AT_LEAST_SIZE(xFreeColorsReq); ! 2289: pcmp = (ColormapPtr )LookupID(stuff->cmap, RT_COLORMAP, RC_CORE); ! 2290: if (pcmp) ! 2291: { ! 2292: int count; ! 2293: int retval; ! 2294: ! 2295: if(pcmp->flags & AllAllocated) ! 2296: return(BadAccess); ! 2297: count = ((stuff->length << 2)- sizeof(xFreeColorsReq)) >> 2; ! 2298: retval = FreeColors(pcmp, client->index, count, ! 2299: (unsigned long *)&stuff[1], stuff->planeMask); ! 2300: if (client->noClientException != Success) ! 2301: return(client->noClientException); ! 2302: else ! 2303: return(retval); ! 2304: ! 2305: } ! 2306: else ! 2307: { ! 2308: client->errorValue = stuff->cmap; ! 2309: return (BadColor); ! 2310: } ! 2311: } ! 2312: ! 2313: int ! 2314: ProcStoreColors (client) ! 2315: register ClientPtr client; ! 2316: { ! 2317: ColormapPtr pcmp; ! 2318: REQUEST(xStoreColorsReq); ! 2319: ! 2320: REQUEST_AT_LEAST_SIZE(xStoreColorsReq); ! 2321: pcmp = (ColormapPtr )LookupID(stuff->cmap, RT_COLORMAP, RC_CORE); ! 2322: if (pcmp) ! 2323: { ! 2324: int count; ! 2325: int retval; ! 2326: ! 2327: if(pcmp->flags & AllAllocated) ! 2328: if(CLIENT_ID(stuff->cmap) != client->index) ! 2329: return(BadAccess); ! 2330: count = ! 2331: ((stuff->length << 2) - sizeof(xStoreColorsReq)) / sizeof(xColorItem); ! 2332: retval = StoreColors(pcmp, count, (xColorItem *)&stuff[1]); ! 2333: if (client->noClientException != Success) ! 2334: return(client->noClientException); ! 2335: else ! 2336: return(retval); ! 2337: } ! 2338: else ! 2339: { ! 2340: client->errorValue = stuff->cmap; ! 2341: return (BadColor); ! 2342: } ! 2343: } ! 2344: ! 2345: int ! 2346: ProcStoreNamedColor (client) ! 2347: register ClientPtr client; ! 2348: { ! 2349: ColormapPtr pcmp; ! 2350: REQUEST(xStoreNamedColorReq); ! 2351: ! 2352: REQUEST_AT_LEAST_SIZE(xStoreNamedColorReq); ! 2353: pcmp = (ColormapPtr )LookupID(stuff->cmap, RT_COLORMAP, RC_CORE); ! 2354: if (pcmp) ! 2355: { ! 2356: xColorItem def; ! 2357: int retval; ! 2358: ! 2359: if(pcmp->flags & AllAllocated) ! 2360: if(CLIENT_ID(stuff->cmap) != client->index) ! 2361: return(BadAccess); ! 2362: ! 2363: if(OsLookupColor(pcmp->pScreen->myNum, (char *)&stuff[1], ! 2364: stuff->nbytes, &def.red, &def.green, &def.blue)) ! 2365: { ! 2366: def.flags = stuff->flags; ! 2367: retval = StoreColors(pcmp, 1, &def); ! 2368: if (client->noClientException != Success) ! 2369: return(client->noClientException); ! 2370: else ! 2371: return(retval); ! 2372: } ! 2373: return (BadName); ! 2374: } ! 2375: else ! 2376: { ! 2377: client->errorValue = stuff->cmap; ! 2378: return (BadColor); ! 2379: } ! 2380: } ! 2381: ! 2382: int ! 2383: ProcQueryColors(client) ! 2384: register ClientPtr client; ! 2385: { ! 2386: ColormapPtr pcmp; ! 2387: REQUEST(xQueryColorsReq); ! 2388: ! 2389: REQUEST_AT_LEAST_SIZE(xQueryColorsReq); ! 2390: pcmp = (ColormapPtr )LookupID(stuff->cmap, RT_COLORMAP, RC_CORE); ! 2391: if (pcmp) ! 2392: { ! 2393: int count, retval; ! 2394: xrgb *prgbs; ! 2395: xQueryColorsReply qcr; ! 2396: ! 2397: count = ((stuff->length << 2) - sizeof(xQueryColorsReq)) >> 2; ! 2398: if(!(prgbs = (xrgb *)ALLOCATE_LOCAL(count * sizeof(xrgb)))) ! 2399: return(client->noClientException = BadAlloc); ! 2400: if(retval = QueryColors(pcmp, count, (unsigned long *)&stuff[1], prgbs)) ! 2401: { ! 2402: DEALLOCATE_LOCAL(prgbs); ! 2403: if (client->noClientException != Success) ! 2404: return(client->noClientException); ! 2405: else ! 2406: return (retval); ! 2407: } ! 2408: qcr.type = X_Reply; ! 2409: qcr.length = (count * sizeof(xrgb)) >> 2; ! 2410: qcr.sequenceNumber = client->sequence; ! 2411: qcr.nColors = count; ! 2412: WriteReplyToClient(client, sizeof(xQueryColorsReply), &qcr); ! 2413: client->pSwapReplyFunc = SQColorsExtend; ! 2414: WriteSwappedDataToClient(client, count * sizeof(xrgb), prgbs); ! 2415: DEALLOCATE_LOCAL(prgbs); ! 2416: return(client->noClientException); ! 2417: ! 2418: } ! 2419: else ! 2420: { ! 2421: client->errorValue = stuff->cmap; ! 2422: return (BadColor); ! 2423: } ! 2424: } ! 2425: ! 2426: int ! 2427: ProcLookupColor(client) ! 2428: register ClientPtr client; ! 2429: { ! 2430: ColormapPtr pcmp; ! 2431: REQUEST(xLookupColorReq); ! 2432: ! 2433: REQUEST_AT_LEAST_SIZE(xLookupColorReq); ! 2434: pcmp = (ColormapPtr )LookupID(stuff->cmap, RT_COLORMAP, RC_CORE); ! 2435: if (pcmp) ! 2436: { ! 2437: xLookupColorReply lcr; ! 2438: ! 2439: if(OsLookupColor(pcmp->pScreen->myNum, (char *)&stuff[1], stuff->nbytes, ! 2440: &lcr.exactRed, &lcr.exactGreen, &lcr.exactBlue)) ! 2441: { ! 2442: lcr.type = X_Reply; ! 2443: lcr.length = 0; ! 2444: lcr.sequenceNumber = client->sequence; ! 2445: lcr.screenRed = lcr.exactRed; ! 2446: lcr.screenGreen = lcr.exactGreen; ! 2447: lcr.screenBlue = lcr.exactBlue; ! 2448: (*pcmp->pScreen->ResolveColor)(&lcr.screenRed, ! 2449: &lcr.screenGreen, ! 2450: &lcr.screenBlue); ! 2451: WriteReplyToClient(client, sizeof(xLookupColorReply), &lcr); ! 2452: return(client->noClientException); ! 2453: } ! 2454: return (BadName); ! 2455: } ! 2456: else ! 2457: { ! 2458: client->errorValue = stuff->cmap; ! 2459: return (BadColor); ! 2460: } ! 2461: } ! 2462: ! 2463: int ! 2464: ProcCreateCursor( client) ! 2465: register ClientPtr client; ! 2466: { ! 2467: CursorPtr pCursor; ! 2468: ! 2469: register PixmapPtr src; ! 2470: register PixmapPtr msk; ! 2471: unsigned int * srcbits; ! 2472: unsigned int * mskbits; ! 2473: int width, height; ! 2474: CursorMetricRec cm; ! 2475: ! 2476: ! 2477: REQUEST(xCreateCursorReq); ! 2478: ! 2479: REQUEST_SIZE_MATCH(xCreateCursorReq); ! 2480: LEGAL_NEW_RESOURCE(stuff->cid); ! 2481: ! 2482: src = (PixmapPtr)LookupID( stuff->source, RT_PIXMAP, RC_CORE); ! 2483: msk = (PixmapPtr)LookupID( stuff->mask, RT_PIXMAP, RC_CORE); ! 2484: if ( src == (PixmapPtr)NULL) ! 2485: return (BadPixmap); ! 2486: if ( msk == (PixmapPtr)NULL) ! 2487: msk = src; ! 2488: ! 2489: if ( src->width != msk->width ! 2490: || src->height != msk->height ! 2491: || src->drawable.depth != 1 ! 2492: || msk->drawable.depth != 1) ! 2493: return (BadMatch); ! 2494: ! 2495: width = src->width; ! 2496: height = src->height; ! 2497: ! 2498: if ( stuff->x > width ! 2499: || stuff->y > height ) ! 2500: return (BadMatch); ! 2501: ! 2502: srcbits = (unsigned int *)Xalloc( PixmapBytePad(width, 1)*height); ! 2503: mskbits = (unsigned int *)Xalloc( PixmapBytePad(width, 1)*height); ! 2504: ! 2505: (* src->drawable.pScreen->GetImage)( src, 0, 0, width, height, ! 2506: XYBitmap, 0xffffffff, srcbits); ! 2507: (* msk->drawable.pScreen->GetImage)( msk, 0, 0, width, height, ! 2508: XYBitmap, 0xffffffff, mskbits); ! 2509: cm.width = width; ! 2510: cm.height = height; ! 2511: cm.xhot = stuff->x; ! 2512: cm.yhot = stuff->y; ! 2513: pCursor = AllocCursor( srcbits, mskbits, &cm, ! 2514: stuff->foreRed, stuff->foreGreen, stuff->foreBlue, ! 2515: stuff->backRed, stuff->backGreen, stuff->backBlue); ! 2516: ! 2517: AddResource( stuff->cid, RT_CURSOR, pCursor, FreeCursor, RC_CORE); ! 2518: return (client->noClientException); ! 2519: } ! 2520: ! 2521: /* ! 2522: * protocol requires positioning of glyphs so hot-spots are coincident XXX ! 2523: */ ! 2524: int ! 2525: ProcCreateGlyphCursor( client) ! 2526: register ClientPtr client; ! 2527: { ! 2528: FontPtr sourcefont; ! 2529: FontPtr maskfont; ! 2530: char *srcbits; ! 2531: char *mskbits; ! 2532: CursorPtr pCursor; ! 2533: CursorMetricRec cm; ! 2534: int res; ! 2535: ! 2536: REQUEST(xCreateGlyphCursorReq); ! 2537: ! 2538: REQUEST_SIZE_MATCH(xCreateGlyphCursorReq); ! 2539: LEGAL_NEW_RESOURCE(stuff->cid); ! 2540: ! 2541: sourcefont = (FontPtr) LookupID(stuff->source, RT_FONT, RC_CORE); ! 2542: maskfont = (FontPtr) LookupID(stuff->mask, RT_FONT, RC_CORE); ! 2543: ! 2544: if (sourcefont == (FontPtr) NULL) ! 2545: { ! 2546: client->errorValue = stuff->source; ! 2547: return(BadFont); ! 2548: } ! 2549: ! 2550: if (maskfont == (FontPtr) NULL) ! 2551: { ! 2552: client->errorValue = stuff->mask; ! 2553: return(BadFont); ! 2554: } ! 2555: ! 2556: if (!CursorMetricsFromGlyph(maskfont, stuff->maskChar, &cm)) ! 2557: { ! 2558: client->errorValue = stuff->mask; ! 2559: return BadValue; ! 2560: } ! 2561: ! 2562: if (res = ServerBitsFromGlyph(stuff->source, ! 2563: sourcefont, stuff->sourceChar, ! 2564: &cm, &srcbits)) ! 2565: return res; ! 2566: if (res = ServerBitsFromGlyph(stuff->mask, ! 2567: maskfont, stuff->maskChar, ! 2568: &cm, &mskbits)) ! 2569: return res; ! 2570: ! 2571: pCursor = AllocCursor(srcbits, mskbits, &cm, ! 2572: stuff->foreRed, stuff->foreGreen, stuff->foreBlue, ! 2573: stuff->backRed, stuff->backGreen, stuff->backBlue); ! 2574: ! 2575: AddResource(stuff->cid, RT_CURSOR, pCursor, FreeCursor, RC_CORE); ! 2576: return client->noClientException; ! 2577: } ! 2578: ! 2579: ! 2580: int ! 2581: ProcFreeCursor(client) ! 2582: register ClientPtr client; ! 2583: { ! 2584: CursorPtr pCursor; ! 2585: REQUEST(xResourceReq); ! 2586: ! 2587: REQUEST_SIZE_MATCH(xResourceReq); ! 2588: pCursor = (CursorPtr)LookupID(stuff->id, RT_CURSOR, RC_CORE); ! 2589: if (pCursor) ! 2590: { ! 2591: FreeResource( stuff->id, RC_NONE); ! 2592: return (client->noClientException); ! 2593: } ! 2594: else ! 2595: { ! 2596: return (BadCursor); ! 2597: } ! 2598: } ! 2599: ! 2600: int ! 2601: ProcQueryBestSize (client) ! 2602: register ClientPtr client; ! 2603: { ! 2604: xQueryBestSizeReply reply; ! 2605: register DrawablePtr pDraw; ! 2606: ScreenPtr pScreen; ! 2607: REQUEST(xQueryBestSizeReq); ! 2608: ! 2609: REQUEST_SIZE_MATCH(xQueryBestSizeReq); ! 2610: if ((stuff->class != CursorShape) && ! 2611: (stuff->class != TileShape) && ! 2612: (stuff->class != StippleShape)) ! 2613: return(BadValue); ! 2614: if (!(pDraw = LOOKUP_DRAWABLE(stuff->drawable, client))) ! 2615: { ! 2616: client->errorValue = stuff->drawable; ! 2617: return (BadDrawable); ! 2618: } ! 2619: pScreen = pDraw->pScreen; ! 2620: (* pScreen->QueryBestSize)(stuff->class, &stuff->width, ! 2621: &stuff->height); ! 2622: reply.type = X_Reply; ! 2623: reply.length = 0; ! 2624: reply.sequenceNumber = client->sequence; ! 2625: reply.width = stuff->width; ! 2626: reply.height = stuff->height; ! 2627: WriteReplyToClient(client, sizeof(xQueryBestSizeReply), &reply); ! 2628: return (client->noClientException); ! 2629: } ! 2630: ! 2631: ! 2632: int ! 2633: ProcSetScreenSaver (client) ! 2634: register ClientPtr client; ! 2635: { ! 2636: int blankingOption, exposureOption; ! 2637: REQUEST(xSetScreenSaverReq); ! 2638: ! 2639: REQUEST_SIZE_MATCH(xSetScreenSaverReq); ! 2640: blankingOption = stuff->preferBlank; ! 2641: if ((blankingOption != DontPreferBlanking) && ! 2642: (blankingOption != PreferBlanking) && ! 2643: (blankingOption != DefaultBlanking)) ! 2644: return BadMatch; ! 2645: ! 2646: exposureOption = stuff->allowExpose; ! 2647: if ((exposureOption != DontAllowExposures) && ! 2648: (exposureOption != AllowExposures) && ! 2649: (exposureOption != DefaultExposures)) ! 2650: return BadMatch; ! 2651: ! 2652: if ((stuff->timeout < -1) || (stuff->interval < -1)) ! 2653: return BadMatch; ! 2654: ! 2655: ScreenSaverBlanking = blankingOption; ! 2656: ScreenSaverAllowExposures = exposureOption; ! 2657: ! 2658: if (stuff->timeout >= 0) ! 2659: ScreenSaverTime = stuff->timeout * MILLI_PER_SECOND; ! 2660: else ! 2661: ScreenSaverTime = DEFAULT_SCREEN_SAVER_TIME; ! 2662: if (stuff->interval > 0) ! 2663: ScreenSaverInterval = stuff->interval * MILLI_PER_SECOND; ! 2664: else ! 2665: ScreenSaverInterval = DEFAULT_SCREEN_SAVER_TIME; ! 2666: return (client->noClientException); ! 2667: } ! 2668: ! 2669: int ! 2670: ProcGetScreenSaver(client) ! 2671: register ClientPtr client; ! 2672: { ! 2673: xGetScreenSaverReply rep; ! 2674: ! 2675: rep.type = X_Reply; ! 2676: rep.length = 0; ! 2677: rep.sequenceNumber = client->sequence; ! 2678: rep.timeout = ScreenSaverTime / MILLI_PER_SECOND; ! 2679: rep.interval = ScreenSaverInterval / MILLI_PER_SECOND; ! 2680: rep.preferBlanking = ScreenSaverBlanking; ! 2681: rep.allowExposures = ScreenSaverAllowExposures; ! 2682: WriteReplyToClient(client, sizeof(xGetScreenSaverReply), &rep); ! 2683: return (client->noClientException); ! 2684: } ! 2685: ! 2686: int ! 2687: ProcChangeHosts(client) ! 2688: register ClientPtr client; ! 2689: { ! 2690: REQUEST(xChangeHostsReq); ! 2691: int result; ! 2692: ! 2693: REQUEST_AT_LEAST_SIZE(xChangeHostsReq); ! 2694: ! 2695: if(stuff->mode == HostInsert) ! 2696: result = AddHost(client, stuff->hostFamily, stuff->hostLength, ! 2697: &stuff[1]); ! 2698: else if (stuff->mode == HostDelete) ! 2699: result = RemoveHost(client, stuff->hostFamily, ! 2700: stuff->hostLength, &stuff[1]); ! 2701: else ! 2702: return BadValue; ! 2703: return (result || client->noClientException); ! 2704: } ! 2705: ! 2706: int ! 2707: ProcListHosts(client) ! 2708: register ClientPtr client; ! 2709: { ! 2710: extern int GetHosts(); ! 2711: xListHostsReply reply; ! 2712: int len, nHosts; ! 2713: pointer pdata; ! 2714: REQUEST(xListHostsReq); ! 2715: ! 2716: REQUEST_SIZE_MATCH(xListHostsReq); ! 2717: if((len = GetHosts(&pdata, &nHosts, &reply.enabled)) < 0) ! 2718: return(BadImplementation); ! 2719: reply.type = X_Reply; ! 2720: reply.sequenceNumber = client->sequence; ! 2721: reply.nHosts = nHosts; ! 2722: reply.length = len >> 2; ! 2723: WriteReplyToClient(client, sizeof(xListHostsReply), &reply); ! 2724: client->pSwapReplyFunc = SLHostsExtend; ! 2725: WriteSwappedDataToClient(client, len, pdata); ! 2726: Xfree(pdata); ! 2727: return (client->noClientException); ! 2728: } ! 2729: ! 2730: int ! 2731: ProcChangeAccessControl(client) ! 2732: register ClientPtr client; ! 2733: { ! 2734: REQUEST(xSetAccessControlReq); ! 2735: ! 2736: REQUEST_SIZE_MATCH(xSetAccessControlReq); ! 2737: if ((stuff->mode != EnableAccess) && (stuff->mode != DisableAccess)) ! 2738: return BadValue; ! 2739: ChangeAccessControl(client, stuff->mode == EnableAccess); ! 2740: return (client->noClientException); ! 2741: } ! 2742: ! 2743: int ! 2744: ProcKillClient(client) ! 2745: register ClientPtr client; ! 2746: { ! 2747: REQUEST(xResourceReq); ! 2748: ! 2749: pointer *pResource; ! 2750: int clientIndex; ! 2751: ! 2752: REQUEST_SIZE_MATCH(xResourceReq); ! 2753: if (stuff->id == AllTemporary) ! 2754: { ! 2755: CloseDownRetainedResources(); ! 2756: return (client->noClientException); ! 2757: } ! 2758: pResource = (pointer *)LookupID(stuff->id, RT_ANY, RC_CORE); ! 2759: ! 2760: clientIndex = CLIENT_ID(stuff->id); ! 2761: ! 2762: if (clientIndex && pResource) ! 2763: { ! 2764: if (clients[clientIndex] && !clients[clientIndex]->clientGone) ! 2765: { ! 2766: CloseDownClient(clients[clientIndex]); ! 2767: return (client->noClientException); ! 2768: } ! 2769: } ! 2770: else /* can't kill client 0, which is server */ ! 2771: { ! 2772: client->errorValue = stuff->id; ! 2773: return (BadValue); ! 2774: } ! 2775: } ! 2776: ! 2777: int ! 2778: ProcSetFontPath(client) ! 2779: register ClientPtr client; ! 2780: { ! 2781: REQUEST(xSetFontPathReq); ! 2782: ! 2783: REQUEST_AT_LEAST_SIZE(xSetFontPathReq); ! 2784: ! 2785: SetFontPath(stuff->nFonts, stuff->length, &stuff[1]); ! 2786: return (client->noClientException); ! 2787: } ! 2788: ! 2789: int ! 2790: ProcGetFontPath(client) ! 2791: register ClientPtr client; ! 2792: { ! 2793: FontPathPtr pFP; ! 2794: xGetFontPathReply reply; ! 2795: int stringLens, i; ! 2796: char *bufferStart; ! 2797: register char *bufptr; ! 2798: REQUEST (xReq); ! 2799: ! 2800: REQUEST_SIZE_MATCH(xReq); ! 2801: pFP = GetFontPath(); ! 2802: stringLens = 0; ! 2803: for (i=0; i<pFP->npaths; i++) ! 2804: stringLens += pFP->length[i]; ! 2805: ! 2806: reply.type = X_Reply; ! 2807: reply.sequenceNumber = client->sequence; ! 2808: reply.length = (stringLens + pFP->npaths + 3) >> 2; ! 2809: reply.nPaths = pFP->npaths; ! 2810: ! 2811: bufptr = bufferStart = (char *)ALLOCATE_LOCAL(reply.length << 2); ! 2812: if(!bufptr) ! 2813: return(client->noClientException = BadAlloc); ! 2814: /* since WriteToClient long word aligns things, ! 2815: copy to temp buffer and write all at once */ ! 2816: for (i=0; i<pFP->npaths; i++) ! 2817: { ! 2818: *bufptr++ = pFP->length[i]; ! 2819: bcopy(pFP->paths[i], bufptr, pFP->length[i]); ! 2820: bufptr += pFP->length[i]; ! 2821: } ! 2822: WriteReplyToClient(client, sizeof(xGetFontPathReply), &reply); ! 2823: WriteToClient(client, stringLens + pFP->npaths, bufferStart); ! 2824: DEALLOCATE_LOCAL(bufferStart); ! 2825: return(client->noClientException); ! 2826: } ! 2827: ! 2828: int ! 2829: ProcChangeCloseDownMode(client) ! 2830: register ClientPtr client; ! 2831: { ! 2832: REQUEST(xSetCloseDownModeReq); ! 2833: ! 2834: REQUEST_SIZE_MATCH(xSetCloseDownModeReq); ! 2835: if ((stuff->mode == AllTemporary) || ! 2836: (stuff->mode == RetainPermanent) || ! 2837: (stuff->mode == RetainTemporary)) ! 2838: { ! 2839: client->closeDownMode = stuff->mode; ! 2840: return (client->noClientException); ! 2841: } ! 2842: else ! 2843: { ! 2844: client->errorValue = stuff->mode; ! 2845: return (BadValue); ! 2846: } ! 2847: } ! 2848: ! 2849: int ProcForceScreenSaver(client) ! 2850: register ClientPtr client; ! 2851: { ! 2852: REQUEST(xForceScreenSaverReq); ! 2853: ! 2854: REQUEST_SIZE_MATCH(xForceScreenSaverReq); ! 2855: ! 2856: if ((stuff->mode != ScreenSaverReset) && ! 2857: (stuff->mode != ScreenSaverActive)) ! 2858: return BadValue; ! 2859: SaveScreens(SCREEN_SAVER_FORCER, stuff->mode); ! 2860: return client->noClientException; ! 2861: } ! 2862: ! 2863: int ProcNoOperation(client) ! 2864: register ClientPtr client; ! 2865: { ! 2866: REQUEST(xReq); ! 2867: ! 2868: REQUEST_AT_LEAST_SIZE(xReq); ! 2869: ! 2870: /* noop -- don't do anything */ ! 2871: return(client->noClientException); ! 2872: } ! 2873: ! 2874: extern void NotImplemented(); ! 2875: ! 2876: void ! 2877: InitProcVectors() ! 2878: { ! 2879: int i; ! 2880: for (i = 0; i<256; i++) ! 2881: { ! 2882: if(!ProcVector[i]) ! 2883: { ! 2884: ProcVector[i] = SwappedProcVector[i] = ProcBadRequest; ! 2885: ReplySwapVector[i] = NotImplemented; ! 2886: } ! 2887: } ! 2888: for(i = LASTEvent; i < 128; i++) ! 2889: { ! 2890: EventSwapVector[i] = NotImplemented; ! 2891: } ! 2892: ! 2893: } ! 2894: ! 2895: /********************** ! 2896: * CloseDownClient ! 2897: * ! 2898: * Client can either mark his resources destroy or retain. If retained and ! 2899: * then killed again, the client is really destroyed. ! 2900: *********************/ ! 2901: ! 2902: void ! 2903: CloseDownClient(client) ! 2904: register ClientPtr client; ! 2905: { ! 2906: extern void DeleteClientFromAnySelections(); ! 2907: register int i; ! 2908: /* ungrab server if grabbing client dies */ ! 2909: if (grabbingClient && (onlyClient == client)) ! 2910: { ! 2911: grabbingClient = FALSE; ! 2912: ListenToAllClients(); ! 2913: } ! 2914: DeleteClientFromAnySelections(client); ! 2915: ReleaseActiveGrabs(client); ! 2916: ! 2917: if (client->closeDownMode == DestroyAll) ! 2918: { ! 2919: client->clientGone = TRUE; /* so events aren't sent to client */ ! 2920: CloseDownConnection(client); ! 2921: FreeClientResources(client); ! 2922: for (i=0; i<currentMaxClients; i++) ! 2923: if (clients[i] == client) ! 2924: { ! 2925: nextFreeClientID = i; ! 2926: clients[nextFreeClientID] = NullClient; ! 2927: break; ! 2928: } ! 2929: Xfree(client); ! 2930: if(--nClients == 0) ! 2931: nClients = -1; ! 2932: } ! 2933: /* really kill resources this time */ ! 2934: else if (client->clientGone) ! 2935: { ! 2936: FreeClientResources(client); ! 2937: for (i=0; i<currentMaxClients; i++) ! 2938: if (clients[i] == client) ! 2939: { ! 2940: nextFreeClientID = i; ! 2941: clients[nextFreeClientID] = NullClient; ! 2942: break; ! 2943: } ! 2944: Xfree(client); ! 2945: --nClients; ! 2946: } ! 2947: else ! 2948: { ! 2949: client->clientGone = TRUE; ! 2950: CloseDownConnection(client); ! 2951: } ! 2952: } ! 2953: ! 2954: static void ! 2955: KillAllClients() ! 2956: { ! 2957: int i; ! 2958: for (i=1; i<currentMaxClients; i++) ! 2959: if (clients[i] && !clients[i]->clientGone) ! 2960: CloseDownClient(clients[i]); ! 2961: } ! 2962: ! 2963: void ! 2964: KillServerResources() ! 2965: { ! 2966: int i; ! 2967: ! 2968: KillAllClients(); ! 2969: /* Good thing we stashed these two in globals so we could get at them ! 2970: * here. */ ! 2971: CloseDownDevices(argcGlobal, argvGlobal); ! 2972: for (i = 0; i < screenInfo.numScreens; i++) ! 2973: (*screenInfo.screen[i].CloseScreen)(i, &screenInfo.screen[i]); ! 2974: } ! 2975: ! 2976: ! 2977: /********************* ! 2978: * CloseDownRetainedResources ! 2979: * ! 2980: * Find all clients that are gone and have terminated in RetainTemporary ! 2981: * and destroy their resources. ! 2982: *********************/ ! 2983: ! 2984: CloseDownRetainedResources() ! 2985: { ! 2986: register int i; ! 2987: register ClientPtr client; ! 2988: ! 2989: for (i=1; i<currentMaxClients; i++) ! 2990: { ! 2991: client = clients[i]; ! 2992: if (client && (client->closeDownMode == RetainTemporary) ! 2993: && (client->clientGone)) ! 2994: { ! 2995: FreeClientResources(client); ! 2996: nextFreeClientID = i; ! 2997: Xfree(client); ! 2998: clients[i] = NullClient; ! 2999: } ! 3000: } ! 3001: } ! 3002: ! 3003: /************************ ! 3004: * int NextAvailableClientID() ! 3005: * ! 3006: * OS depedent portion can't assign client id's because of CloseDownModes. ! 3007: * Returns -1 if the there are no free clients. ! 3008: *************************/ ! 3009: ! 3010: ClientPtr ! 3011: NextAvailableClient() ! 3012: { ! 3013: int i; ! 3014: ClientPtr client; ! 3015: ! 3016: if (nextFreeClientID >= currentMaxClients) ! 3017: nextFreeClientID = 1; ! 3018: if (!clients[nextFreeClientID]) ! 3019: { ! 3020: i = nextFreeClientID; ! 3021: nextFreeClientID++; ! 3022: } ! 3023: else ! 3024: { ! 3025: i = 1; ! 3026: while ((i<currentMaxClients) && (clients[i])) ! 3027: i++; ! 3028: if (i < currentMaxClients) ! 3029: nextFreeClientID = i; ! 3030: else ! 3031: { ! 3032: clients = (ClientPtr *)Xrealloc(clients, i * sizeof(ClientRec)); ! 3033: currentMaxClients++; ! 3034: } ! 3035: } ! 3036: clients[i] = client = (ClientPtr)Xalloc(sizeof(ClientRec)); ! 3037: client->index = i; ! 3038: client->sequence = 0; ! 3039: client->clientAsMask = i << CLIENTOFFSET; ! 3040: client->closeDownMode = DestroyAll; ! 3041: client->clientGone = FALSE; ! 3042: client->lastDrawable = (DrawablePtr) NULL; ! 3043: client->lastDrawableID = INVALID; ! 3044: client->lastGC = (GCPtr) NULL; ! 3045: client->lastGCID = -1; ! 3046: client->numSaved = 0; ! 3047: client->saveSet = (pointer *)NULL; ! 3048: client->noClientException = Success; ! 3049: ! 3050: return(client); ! 3051: } ! 3052: ! 3053: SendConnectionSetupInfo(client) ! 3054: ClientPtr client; ! 3055: { ! 3056: xWindowRoot *root; ! 3057: int i; ! 3058: ! 3059: ((xConnSetup *)ConnectionInfo)->ridBase = client->clientAsMask; ! 3060: ((xConnSetup *)ConnectionInfo)->ridMask = 0xfffff; ! 3061: /* fill in the "currentInputMask" */ ! 3062: root = (xWindowRoot *)(ConnectionInfo + connBlockScreenStart); ! 3063: for (i=0; i<screenInfo.numScreens; root += sizeof(xWindowRoot), i++) ! 3064: root->currentInputMask = WindowTable[i].allEventMasks; ! 3065: ! 3066: if (client->swapped) { ! 3067: WriteSConnSetupPrefix(client, &connSetupPrefix); ! 3068: WriteSConnectionInfo(client, connSetupPrefix.length << 2, ConnectionInfo); ! 3069: } ! 3070: else { ! 3071: WriteToClient(client, sizeof(xConnSetupPrefix), (char *) &connSetupPrefix); ! 3072: WriteToClient(client, connSetupPrefix.length << 2, ConnectionInfo); ! 3073: } ! 3074: } ! 3075: ! 3076: /***************** ! 3077: * Oops ! 3078: * Send an Error back to the client. ! 3079: *****************/ ! 3080: ! 3081: Oops (client, reqCode, minorCode, status) ! 3082: ClientPtr client; ! 3083: char reqCode, minorCode, status; ! 3084: { ! 3085: xError rep; ! 3086: register int i; ! 3087: ! 3088: rep.type = X_Error; ! 3089: rep.sequenceNumber = client->sequence; ! 3090: rep.errorCode = status; ! 3091: rep.majorCode = reqCode; ! 3092: rep.minorCode = minorCode; ! 3093: rep.resourceID = client->errorValue; ! 3094: ! 3095: for (i=0; i<currentMaxClients; i++) ! 3096: if (clients[i] == client) break; ! 3097: #ifdef notdef ! 3098: ErrorF( "OOPS! => client: %x, seq: %d, err: %d, maj:%d, min: %d resID: %x\n", ! 3099: client->index, rep.sequenceNumber, rep.errorCode, ! 3100: rep.majorCode, rep.minorCode, rep.resourceID); ! 3101: #endif ! 3102: ! 3103: WriteEventsToClient (client, 1, (xEvent *) &rep); ! 3104: } ! 3105: ! 3106: ! 3107: void ! 3108: DeleteWindowFromAnySelections(pWin) ! 3109: WindowPtr pWin; ! 3110: { ! 3111: int i = 0; ! 3112: ! 3113: for (i = 0; i< NumCurrentSelections; i++) ! 3114: if (CurrentSelections[i].pWin == pWin) ! 3115: { ! 3116: CurrentSelections[i].pWin = (WindowPtr)NULL; ! 3117: CurrentSelections[i].window = None; ! 3118: } ! 3119: } ! 3120: ! 3121: static void ! 3122: DeleteClientFromAnySelections(client) ! 3123: ClientPtr client; ! 3124: { ! 3125: int i = 0; ! 3126: ! 3127: for (i = 0; i< NumCurrentSelections; i++) ! 3128: if (CurrentSelections[i].client == client) ! 3129: { ! 3130: CurrentSelections[i].pWin = (WindowPtr)NULL; ! 3131: CurrentSelections[i].window = None; ! 3132: } ! 3133: } ! 3134: ! 3135: void ! 3136: MarkClientException(client) ! 3137: ClientPtr client; ! 3138: { ! 3139: client->noClientException = -1; ! 3140: } ! 3141: ! 3142: ! 3143: /* Byte swap a list of longs */ ! 3144: ! 3145: SwapLongs (list, count) ! 3146: register long *list; ! 3147: register int count; ! 3148: { ! 3149: register int n; ! 3150: ! 3151: while (count >= 8) { ! 3152: swapl(list+0, n); ! 3153: swapl(list+1, n); ! 3154: swapl(list+2, n); ! 3155: swapl(list+3, n); ! 3156: swapl(list+4, n); ! 3157: swapl(list+5, n); ! 3158: swapl(list+6, n); ! 3159: swapl(list+7, n); ! 3160: list += 8; ! 3161: count -= 8; ! 3162: } ! 3163: while (--count >= 0) { ! 3164: swapl(list, n); ! 3165: list++; ! 3166: } ! 3167: } ! 3168: ! 3169: /* Byte swap a list of shorts */ ! 3170: ! 3171: SwapShorts (list, count) ! 3172: register short *list; ! 3173: register int count; ! 3174: { ! 3175: register int n; ! 3176: ! 3177: while (count >= 16) { ! 3178: swaps(list+0, n); ! 3179: swaps(list+1, n); ! 3180: swaps(list+2, n); ! 3181: swaps(list+3, n); ! 3182: swaps(list+4, n); ! 3183: swaps(list+5, n); ! 3184: swaps(list+6, n); ! 3185: swaps(list+7, n); ! 3186: swaps(list+8, n); ! 3187: swaps(list+9, n); ! 3188: swaps(list+10, n); ! 3189: swaps(list+11, n); ! 3190: swaps(list+12, n); ! 3191: swaps(list+13, n); ! 3192: swaps(list+14, n); ! 3193: swaps(list+15, n); ! 3194: list += 16; ! 3195: count -= 16; ! 3196: } ! 3197: while (--count >= 0) ! 3198: { ! 3199: swaps(list, n); ! 3200: list++; ! 3201: } ! 3202: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.