int SProcXSendExtensionEvent(ClientPtr client) { CARD32 *p; int i; xEvent eventT; xEvent *eventP; EventSwapPtr proc; REQUEST(xSendExtensionEventReq); swaps(&stuff->length); REQUEST_AT_LEAST_SIZE(xSendExtensionEventReq); swapl(&stuff->destination); swaps(&stuff->count); if (stuff->length != bytes_to_int32(sizeof(xSendExtensionEventReq)) + stuff->count + bytes_to_int32(stuff->num_events * sizeof(xEvent))) return BadLength; eventP = (xEvent *) & stuff[1]; for (i = 0; i < stuff->num_events; i++, eventP++) { proc = EventSwapVector[eventP->u.u.type & 0177]; if (proc == NotImplemented) /* no swapping proc; invalid event type? */ return BadValue; (*proc) (eventP, &eventT); *eventP = eventT; } p = (CARD32 *)(((xEvent *) & stuff[1]) + stuff->num_events); SwapLongs(p, stuff->count); return (ProcXSendExtensionEvent(client)); }
static int SProcSecurityGenerateAuthorization( ClientPtr client) { REQUEST(xSecurityGenerateAuthorizationReq); char n; CARD32 *values; unsigned long nvalues; int values_offset; swaps(&stuff->length, n); REQUEST_AT_LEAST_SIZE(xSecurityGenerateAuthorizationReq); swaps(&stuff->nbytesAuthProto, n); swaps(&stuff->nbytesAuthData, n); swapl(&stuff->valueMask, n); values_offset = bytes_to_int32(stuff->nbytesAuthProto) + bytes_to_int32(stuff->nbytesAuthData); if (values_offset > stuff->length - bytes_to_int32(sz_xSecurityGenerateAuthorizationReq)) return BadLength; values = (CARD32 *)(&stuff[1]) + values_offset; nvalues = (((CARD32 *)stuff) + stuff->length) - values; SwapLongs(values, nvalues); return ProcSecurityGenerateAuthorization(client); } /* SProcSecurityGenerateAuthorization */
/** * Write button information into info. * @return Number of bytes written into info. */ int ListButtonInfo(DeviceIntPtr dev, xXIButtonInfo * info, Bool reportState) { unsigned char *bits; int mask_len; int i; if (!dev || !dev->button) return 0; mask_len = bytes_to_int32(bits_to_bytes(dev->button->numButtons)); info->type = ButtonClass; info->num_buttons = dev->button->numButtons; info->length = bytes_to_int32(sizeof(xXIButtonInfo)) + info->num_buttons + mask_len; info->sourceid = dev->button->sourceid; bits = (unsigned char *) &info[1]; memset(bits, 0, mask_len * 4); if (reportState) for (i = 0; i < dev->button->numButtons; i++) if (BitIsOn(dev->button->down, i)) SetBit(bits, i); bits += mask_len * 4; memcpy(bits, dev->button->labels, dev->button->numButtons * sizeof(Atom)); return info->length * 4; }
int ProcRRCreateMode (ClientPtr client) { REQUEST(xRRCreateModeReq); xRRCreateModeReply rep; WindowPtr pWin; ScreenPtr pScreen; rrScrPrivPtr pScrPriv; xRRModeInfo *modeInfo; long units_after; char *name; int error, rc; RRModePtr mode; REQUEST_AT_LEAST_SIZE (xRRCreateModeReq); rc = dixLookupWindow(&pWin, stuff->window, client, DixGetAttrAccess); if (rc != Success) return rc; pScreen = pWin->drawable.pScreen; pScrPriv = rrGetScrPriv(pScreen); modeInfo = &stuff->modeInfo; name = (char *) (stuff + 1); units_after = (stuff->length - bytes_to_int32(sizeof (xRRCreateModeReq))); /* check to make sure requested name fits within the data provided */ if (bytes_to_int32(modeInfo->nameLength) > units_after) return BadLength; mode = RRModeCreateUser (pScreen, modeInfo, name, &error); if (!mode) return error; rep.type = X_Reply; rep.pad0 = 0; rep.sequenceNumber = client->sequence; rep.length = 0; rep.mode = mode->mode.id; if (client->swapped) { int n; swaps(&rep.sequenceNumber, n); swapl(&rep.length, n); swapl(&rep.mode, n); } WriteToClient(client, sizeof(xRRCreateModeReply), (char *)&rep); /* Drop out reference to this mode */ RRModeDestroy (mode); return client->noClientException; }
int ProcXChangeDeviceKeyMapping(ClientPtr client) { int ret; unsigned len; DeviceIntPtr dev; unsigned int count; REQUEST(xChangeDeviceKeyMappingReq); REQUEST_AT_LEAST_SIZE(xChangeDeviceKeyMappingReq); count = stuff->keyCodes * stuff->keySymsPerKeyCode; REQUEST_FIXED_SIZE(xChangeDeviceKeyMappingReq, count * sizeof(CARD32)); ret = dixLookupDevice(&dev, stuff->deviceid, client, DixManageAccess); if (ret != Success) return ret; len = stuff->length - bytes_to_int32(sizeof(xChangeDeviceKeyMappingReq)); ret = ChangeKeyMapping(client, dev, len, DeviceMappingNotify, stuff->firstKeyCode, stuff->keyCodes, stuff->keySymsPerKeyCode, (KeySym *) & stuff[1]); return ret; }
/* 1 - 7 is the range we use for the global modifiers array * above */ assert(mods->modifiers > 0); assert(mods->modifiers <= 7); assert(mods->modifiers % 2 == 1); /* because we fail odd ones */ assert(mods->status != Success); assert(mods->pad0 == 0); assert(mods->pad1 == 0); } reply_handler = reply_XIPassiveGrabDevice; } static void request_XIPassiveGrabDevice(ClientPtr client, xXIPassiveGrabDeviceReq* req, int error, int errval) { int rc; int modifiers; rc = ProcXIPassiveGrabDevice(&client_request); assert(rc == error); if (rc != Success) assert(client_request.errorValue == errval); client_request.swapped = TRUE; swaps(&req->length); swapl(&req->time); swapl(&req->grab_window); swapl(&req->cursor); swapl(&req->detail); swaps(&req->deviceid); modifiers = req->num_modifiers; swaps(&req->num_modifiers); swaps(&req->mask_len); while(modifiers--) { CARD32 *mod = ((CARD32*)(req + 1)) + modifiers; swapl(mod); } rc = SProcXIPassiveGrabDevice(&client_request); assert(rc == error); if (rc != Success) assert(client_request.errorValue == errval); } static unsigned char *data[4096]; /* the request buffer */ static void test_XIPassiveGrabDevice(void) { int i; xXIPassiveGrabDeviceReq *request = (xXIPassiveGrabDeviceReq*)data; unsigned char *mask; request_init(request, XIPassiveGrabDevice); request->grab_window = CLIENT_WINDOW_ID; reply_handler = reply_XIPassiveGrabDevice; client_request = init_client(request->length, request); printf("Testing invalid device\n"); request->deviceid = 12; request_XIPassiveGrabDevice(&client_request, request, BadDevice, request->deviceid); request->deviceid = XIAllMasterDevices; printf("Testing invalid grab types\n"); for (i = XIGrabtypeFocusIn + 1; i < 0xFF; i++) { request->grab_type = i; request_XIPassiveGrabDevice(&client_request, request, BadValue, request->grab_type); } printf("Testing invalid grab type + detail combinations\n"); request->grab_type = XIGrabtypeEnter; request->detail = 1; request_XIPassiveGrabDevice(&client_request, request, BadValue, request->detail); request->grab_type = XIGrabtypeFocusIn; request_XIPassiveGrabDevice(&client_request, request, BadValue, request->detail); request->detail = 0; printf("Testing invalid masks\n"); mask = (unsigned char*)&request[1]; request->mask_len = bytes_to_int32(XI2LASTEVENT + 1); request->length += request->mask_len; SetBit(mask, XI2LASTEVENT + 1); request_XIPassiveGrabDevice(&client_request, request, BadValue, XI2LASTEVENT + 1); ClearBit(mask, XI2LASTEVENT + 1); /* tested all special cases now, test a few valid cases */ /* no modifiers */ request->deviceid = XIAllDevices; request->grab_type = XIGrabtypeButton; request->detail = XIAnyButton; request_XIPassiveGrabDevice(&client_request, request, Success, 0); /* some modifiers */ request->num_modifiers = N_MODS; request->length += N_MODS; memcpy((uint32_t*)(request + 1) + request->mask_len, modifiers, sizeof(modifiers)); request_XIPassiveGrabDevice(&client_request, request, Success, 0); }
static int eventToBarrierEvent(BarrierEvent *ev, xEvent **xi) { xXIBarrierEvent *barrier; int len = sizeof(xXIBarrierEvent); *xi = calloc(1, len); barrier = (xXIBarrierEvent*) *xi; barrier->type = GenericEvent; barrier->extension = IReqCode; barrier->evtype = GetXI2Type(ev->type); barrier->length = bytes_to_int32(len - sizeof(xEvent)); barrier->deviceid = ev->deviceid; barrier->sourceid = ev->sourceid; barrier->time = ev->time; barrier->event = ev->window; barrier->root = ev->root; barrier->dx = double_to_fp3232(ev->dx); barrier->dy = double_to_fp3232(ev->dy); barrier->dtime = ev->dt; barrier->flags = ev->flags; barrier->eventid = ev->event_id; barrier->barrier = ev->barrierid; barrier->root_x = double_to_fp1616(ev->root_x); barrier->root_y = double_to_fp1616(ev->root_y); return Success; }
/** * Send a GLX reply to the client. * * Technically speaking, there are several different ways to encode a GLX * reply. The primary difference is whether or not certain fields (e.g., * retval, size, and "pad3") are set. This function gets around that by * always setting all of the fields to "reasonable" values. This does no * harm to clients, but it does make the server-side code much more compact. * * \warning * This function assumes that values stored in \c data will be byte-swapped * by the caller if necessary. */ void __glXSendReplySwap( ClientPtr client, const void * data, size_t elements, size_t element_size, GLboolean always_array, CARD32 retval ) { size_t reply_ints = 0; if ( __glXErrorOccured() ) { elements = 0; } else if ( (elements > 1) || always_array ) { reply_ints = bytes_to_int32(elements * element_size); } __glXReply.length = bswap_32( reply_ints ); __glXReply.type = X_Reply; __glXReply.sequenceNumber = bswap_16( client->sequence ); __glXReply.size = bswap_32( elements ); __glXReply.retval = bswap_32( retval ); /* It is faster on almost always every architecture to just copy the 8 * bytes, even when not necessary, than check to see of the value of * elements requires it. Copying the data when not needed will do no * harm. */ (void) memcpy( & __glXReply.pad3, data, 8 ); WriteToClient( client, sz_xGLXSingleReply, (char *) & __glXReply ); if ( reply_ints != 0 ) { WriteToClient( client, reply_ints * 4, (char *) data ); } }
static int SELinuxSendContextReply(ClientPtr client, security_id_t sid) { SELinuxGetContextReply rep; security_context_t ctx = NULL; int len = 0; if (sid) { if (avc_sid_to_context_raw(sid, &ctx) < 0) return BadValue; len = strlen(ctx) + 1; } rep.type = X_Reply; rep.length = bytes_to_int32(len); rep.sequenceNumber = client->sequence; rep.context_len = len; if (client->swapped) { swapl(&rep.length); swaps(&rep.sequenceNumber); swapl(&rep.context_len); } WriteToClient(client, sizeof(SELinuxGetContextReply), (char *)&rep); WriteToClient(client, len, ctx); freecon(ctx); return Success; }
int ProcRRSetCrtcGamma (ClientPtr client) { REQUEST(xRRSetCrtcGammaReq); RRCrtcPtr crtc; unsigned long len; CARD16 *red, *green, *blue; REQUEST_AT_LEAST_SIZE(xRRSetCrtcGammaReq); VERIFY_RR_CRTC(stuff->crtc, crtc, DixReadAccess); len = client->req_len - bytes_to_int32(sizeof (xRRSetCrtcGammaReq)); if (len < (stuff->size * 3 + 1) >> 1) return BadLength; if (stuff->size != crtc->gammaSize) return BadMatch; red = (CARD16 *) (stuff + 1); green = red + crtc->gammaSize; blue = green + crtc->gammaSize; RRCrtcGammaSet (crtc, red, green, blue); return Success; }
static void transform_encode (ClientPtr client, xRenderTransform *wire, PictTransform *pict) { xRenderTransform_from_PictTransform (wire, pict); if (client->swapped) SwapLongs ((CARD32 *) wire, bytes_to_int32(sizeof(xRenderTransform))); }
static int ProcXvQueryEncodings(ClientPtr client) { xvEncodingInfo einfo; xvQueryEncodingsReply rep; int totalSize; int nameSize; XvPortPtr pPort; int ne; XvEncodingPtr pe; int status; REQUEST(xvQueryEncodingsReq); REQUEST_SIZE_MATCH(xvQueryEncodingsReq); VALIDATE_XV_PORT(stuff->port, pPort, DixReadAccess); if ((status = _AllocatePort(stuff->port, pPort)) != Success) { client->errorValue = stuff->port; return status; } rep.type = X_Reply; rep.sequenceNumber = client->sequence; rep.num_encodings = pPort->pAdaptor->nEncodings; /* FOR EACH ENCODING ADD UP THE BYTES FOR ENCODING NAMES */ ne = pPort->pAdaptor->nEncodings; pe = pPort->pAdaptor->pEncodings; totalSize = ne * sz_xvEncodingInfo; while (ne--) { totalSize += pad_to_int32(strlen(pe->name)); pe++; } rep.length = bytes_to_int32(totalSize); _WriteQueryEncodingsReply(client, &rep); ne = pPort->pAdaptor->nEncodings; pe = pPort->pAdaptor->pEncodings; while (ne--) { einfo.encoding = pe->id; einfo.name_size = nameSize = strlen(pe->name); einfo.width = pe->width; einfo.height = pe->height; einfo.rate.numerator = pe->rate.numerator; einfo.rate.denominator = pe->rate.denominator; _WriteEncodingInfo(client, &einfo); WriteToClient(client, nameSize, pe->name); pe++; } return Success; }
int ProcListExtensions(ClientPtr client) { xListExtensionsReply reply; char *bufptr, *buffer; int total_length = 0; REQUEST_SIZE_MATCH(xReq); memset(&reply, 0, sizeof(xListExtensionsReply)); reply.type = X_Reply; reply.nExtensions = 0; reply.length = 0; reply.sequenceNumber = client->sequence; buffer = NULL; if ( NumExtensions ) { int i, j; for (i=0; i<NumExtensions; i++) { /* call callbacks to find out whether to show extension */ if (XaceHook(XACE_EXT_ACCESS, client, extensions[i]) != Success) continue; total_length += strlen(extensions[i]->name) + 1; reply.nExtensions += 1 + extensions[i]->num_aliases; for (j = extensions[i]->num_aliases; --j >= 0;) total_length += strlen(extensions[i]->aliases[j]) + 1; } reply.length = bytes_to_int32(total_length); buffer = bufptr = malloc(total_length); if (!buffer) return BadAlloc; for (i=0; i<NumExtensions; i++) { int len; if (XaceHook(XACE_EXT_ACCESS, client, extensions[i]) != Success) continue; *bufptr++ = len = strlen(extensions[i]->name); memmove(bufptr, extensions[i]->name, len); bufptr += len; for (j = extensions[i]->num_aliases; --j >= 0;) { *bufptr++ = len = strlen(extensions[i]->aliases[j]); memmove(bufptr, extensions[i]->aliases[j], len); bufptr += len; } } } WriteReplyToClient(client, sizeof(xListExtensionsReply), &reply); if (reply.length) WriteToClient(client, total_length, buffer); free(buffer); return Success; }
static int eventToRawEvent(RawDeviceEvent *ev, xEvent **xi) { xXIRawEvent* raw; int vallen, nvals; int i, len = sizeof(xXIRawEvent); char *ptr; FP3232 *axisval, *axisval_raw; nvals = count_bits(ev->valuators.mask, sizeof(ev->valuators.mask)); len += nvals * sizeof(FP3232) * 2; /* 8 byte per valuator, once raw, once processed */ vallen = bytes_to_int32(bits_to_bytes(MAX_VALUATORS)); len += vallen * 4; /* valuators mask */ *xi = calloc(1, len); raw = (xXIRawEvent*)*xi; raw->type = GenericEvent; raw->extension = IReqCode; raw->evtype = GetXI2Type(ev->type); raw->time = ev->time; raw->length = bytes_to_int32(len - sizeof(xEvent)); raw->detail = ev->detail.button; raw->deviceid = ev->deviceid; raw->sourceid = ev->sourceid; raw->valuators_len = vallen; raw->flags = ev->flags; ptr = (char*)&raw[1]; axisval = (FP3232*)(ptr + raw->valuators_len * 4); axisval_raw = axisval + nvals; for (i = 0; i < sizeof(ev->valuators.mask) * 8; i++) { if (BitIsOn(ev->valuators.mask, i)) { SetBit(ptr, i); *axisval = double_to_fp3232(ev->valuators.data[i]); *axisval_raw = double_to_fp3232(ev->valuators.data_raw[i]); axisval++; axisval_raw++; } } return Success; }
static int SELinuxPopulateItem(SELinuxListItemRec *i, PrivateRec **privPtr, CARD32 id, int *size) { SELinuxObjectRec *obj = dixLookupPrivate(privPtr, objectKey); SELinuxObjectRec *data = dixLookupPrivate(privPtr, dataKey); if (avc_sid_to_context_raw(obj->sid, &i->octx) < 0) return BadValue; if (avc_sid_to_context_raw(data->sid, &i->dctx) < 0) return BadValue; i->id = id; i->octx_len = bytes_to_int32(strlen(i->octx) + 1); i->dctx_len = bytes_to_int32(strlen(i->dctx) + 1); *size += i->octx_len + i->dctx_len + 3; return Success; }
int ProcXSendExtensionEvent(ClientPtr client) { int ret; DeviceIntPtr dev; xEvent *first; XEventClass *list; struct tmask tmp[EMASKSIZE]; REQUEST(xSendExtensionEventReq); REQUEST_AT_LEAST_SIZE(xSendExtensionEventReq); if (stuff->length != bytes_to_int32(sizeof(xSendExtensionEventReq)) + stuff->count + (stuff->num_events * bytes_to_int32(sizeof(xEvent)))) return BadLength; ret = dixLookupDevice(&dev, stuff->deviceid, client, DixWriteAccess); if (ret != Success) return ret; /* The client's event type must be one defined by an extension. */ first = ((xEvent *) & stuff[1]); if (!((EXTENSION_EVENT_BASE <= first->u.u.type) && (first->u.u.type < lastEvent))) { client->errorValue = first->u.u.type; return BadValue; } list = (XEventClass *) (first + stuff->num_events); if ((ret = CreateMaskFromList(client, list, stuff->count, tmp, dev, X_SendExtensionEvent)) != Success) return ret; ret = (SendEvent(client, dev, stuff->destination, stuff->propagate, (xEvent *) & stuff[1], tmp[stuff->deviceid].mask, stuff->num_events)); return ret; }
static int ProcXResQueryClients (ClientPtr client) { /* REQUEST(xXResQueryClientsReq); */ xXResQueryClientsReply rep; int *current_clients; int i, num_clients; REQUEST_SIZE_MATCH(xXResQueryClientsReq); current_clients = xalloc(currentMaxClients * sizeof(int)); num_clients = 0; for(i = 0; i < currentMaxClients; i++) { if(clients[i]) { current_clients[num_clients] = i; num_clients++; } } rep.type = X_Reply; rep.sequenceNumber = client->sequence; rep.num_clients = num_clients; rep.length = bytes_to_int32(rep.num_clients * sz_xXResClient); if (client->swapped) { int n; swaps (&rep.sequenceNumber, n); swapl (&rep.length, n); swapl (&rep.num_clients, n); } WriteToClient (client, sizeof (xXResQueryClientsReply), (char *) &rep); if(num_clients) { xXResClient scratch; for(i = 0; i < num_clients; i++) { scratch.resource_base = clients[current_clients[i]]->clientAsMask; scratch.resource_mask = RESOURCE_ID_MASK; if(client->swapped) { int n; swapl (&scratch.resource_base, n); swapl (&scratch.resource_mask, n); } WriteToClient (client, sz_xXResClient, (char *) &scratch); } } xfree(current_clients); return (client->noClientException); }
static int ProcXvListImageFormats(ClientPtr client) { XvPortPtr pPort; XvImagePtr pImage; int i; xvListImageFormatsReply rep; xvImageFormatInfo info; REQUEST(xvListImageFormatsReq); REQUEST_SIZE_MATCH(xvListImageFormatsReq); VALIDATE_XV_PORT(stuff->port, pPort, DixReadAccess); rep.type = X_Reply; rep.sequenceNumber = client->sequence; rep.num_formats = pPort->pAdaptor->nImages; rep.length = bytes_to_int32(pPort->pAdaptor->nImages * sz_xvImageFormatInfo); _WriteListImageFormatsReply(client, &rep); pImage = pPort->pAdaptor->pImages; for(i = 0; i < pPort->pAdaptor->nImages; i++, pImage++) { info.id = pImage->id; info.type = pImage->type; info.byte_order = pImage->byte_order; memcpy(&info.guid, pImage->guid, 16); info.bpp = pImage->bits_per_pixel; info.num_planes = pImage->num_planes; info.depth = pImage->depth; info.red_mask = pImage->red_mask; info.green_mask = pImage->green_mask; info.blue_mask = pImage->blue_mask; info.format = pImage->format; info.y_sample_bits = pImage->y_sample_bits; info.u_sample_bits = pImage->u_sample_bits; info.v_sample_bits = pImage->v_sample_bits; info.horz_y_period = pImage->horz_y_period; info.horz_u_period = pImage->horz_u_period; info.horz_v_period = pImage->horz_v_period; info.vert_y_period = pImage->vert_y_period; info.vert_u_period = pImage->vert_u_period; info.vert_v_period = pImage->vert_v_period; memcpy(&info.comp_order, pImage->component_order, 32); info.scanline_order = pImage->scanline_order; _WriteImageFormatInfo(client, &info); } return Success; }
static int ProcXF86DRIGetDeviceInfo( register ClientPtr client ) { xXF86DRIGetDeviceInfoReply rep; drm_handle_t hFrameBuffer; void *pDevPrivate; REQUEST(xXF86DRIGetDeviceInfoReq); REQUEST_SIZE_MATCH(xXF86DRIGetDeviceInfoReq); if (stuff->screen >= screenInfo.numScreens) { client->errorValue = stuff->screen; return BadValue; } rep.type = X_Reply; rep.length = 0; rep.sequenceNumber = client->sequence; if (!DRIGetDeviceInfo( screenInfo.screens[stuff->screen], &hFrameBuffer, (int*)&rep.framebufferOrigin, (int*)&rep.framebufferSize, (int*)&rep.framebufferStride, (int*)&rep.devPrivateSize, &pDevPrivate)) { return BadValue; } rep.hFrameBufferLow = (CARD32)(hFrameBuffer & 0xffffffff); #if defined(LONG64) && !defined(__linux__) rep.hFrameBufferHigh = (CARD32)(hFrameBuffer >> 32); #else rep.hFrameBufferHigh = 0; #endif rep.length = 0; if (rep.devPrivateSize) { rep.length = bytes_to_int32(SIZEOF(xXF86DRIGetDeviceInfoReply) - SIZEOF(xGenericReply) + pad_to_int32(rep.devPrivateSize)); } WriteToClient(client, sizeof(xXF86DRIGetDeviceInfoReply), (char *)&rep); if (rep.length) { WriteToClient(client, rep.devPrivateSize, (char *)pDevPrivate); } return Success; }
static int appendButtonInfo(DeviceChangedEvent *dce, xXIButtonInfo *info) { unsigned char *bits; int mask_len; mask_len = bytes_to_int32(bits_to_bytes(dce->buttons.num_buttons)); info->type = XIButtonClass; info->num_buttons = dce->buttons.num_buttons; info->length = bytes_to_int32(sizeof(xXIButtonInfo)) + info->num_buttons + mask_len; info->sourceid = dce->sourceid; bits = (unsigned char*)&info[1]; memset(bits, 0, mask_len * 4); /* FIXME: is_down? */ bits += mask_len * 4; memcpy(bits, dce->buttons.names, dce->buttons.num_buttons * sizeof(Atom)); return info->length * 4; }
int ProcRRGetCrtcTransform (ClientPtr client) { REQUEST(xRRGetCrtcTransformReq); xRRGetCrtcTransformReply *reply; RRCrtcPtr crtc; int n, nextra; RRTransformPtr current, pending; char *extra; REQUEST_SIZE_MATCH (xRRGetCrtcTransformReq); VERIFY_RR_CRTC(stuff->crtc, crtc, DixReadAccess); pending = &crtc->client_pending_transform; current = &crtc->client_current_transform; nextra = (transform_filter_length (pending) + transform_filter_length (current)); reply = malloc(sizeof (xRRGetCrtcTransformReply) + nextra); if (!reply) return BadAlloc; extra = (char *) (reply + 1); reply->type = X_Reply; reply->sequenceNumber = client->sequence; reply->length = bytes_to_int32(CrtcTransformExtra + nextra); reply->hasTransforms = crtc->transforms; transform_encode (client, &reply->pendingTransform, &pending->transform); extra += transform_filter_encode (client, extra, &reply->pendingNbytesFilter, &reply->pendingNparamsFilter, pending); transform_encode (client, &reply->currentTransform, ¤t->transform); extra += transform_filter_encode (client, extra, &reply->currentNbytesFilter, &reply->currentNparamsFilter, current); if (client->swapped) { swaps (&reply->sequenceNumber, n); swapl (&reply->length, n); } WriteToClient (client, sizeof (xRRGetCrtcTransformReply) + nextra, (char *) reply); free(reply); return Success; }
static int ProcXvMCListSurfaceTypes(ClientPtr client) { XvPortPtr pPort; int i; XvMCScreenPtr pScreenPriv; xvmcListSurfaceTypesReply rep; xvmcSurfaceInfo info; XvMCAdaptorPtr adaptor = NULL; XvMCSurfaceInfoPtr surface; REQUEST(xvmcListSurfaceTypesReq); REQUEST_SIZE_MATCH(xvmcListSurfaceTypesReq); VALIDATE_XV_PORT(stuff->port, pPort, DixReadAccess); if(XvMCInUse) { /* any adaptors at all */ ScreenPtr pScreen = pPort->pAdaptor->pScreen; if((pScreenPriv = XVMC_GET_PRIVATE(pScreen))) { /* any this screen */ for(i = 0; i < pScreenPriv->num_adaptors; i++) { if(pPort->pAdaptor == pScreenPriv->adaptors[i].xv_adaptor) { adaptor = &(pScreenPriv->adaptors[i]); break; } } } } rep.type = X_Reply; rep.sequenceNumber = client->sequence; rep.num = (adaptor) ? adaptor->num_surfaces : 0; rep.length = bytes_to_int32(rep.num * sizeof(xvmcSurfaceInfo)); WriteToClient(client, sizeof(xvmcListSurfaceTypesReply), (char*)&rep); for(i = 0; i < rep.num; i++) { surface = adaptor->surfaces[i]; info.surface_type_id = surface->surface_type_id; info.chroma_format = surface->chroma_format; info.max_width = surface->max_width; info.max_height = surface->max_height; info.subpicture_max_width = surface->subpicture_max_width; info.subpicture_max_height = surface->subpicture_max_height; info.mc_type = surface->mc_type; info.flags = surface->flags; WriteToClient(client, sizeof(xvmcSurfaceInfo), (char*)&info); } return Success; }
int ProcXGetDeviceDontPropagateList(ClientPtr client) { CARD16 count = 0; int i, rc; XEventClass *buf = NULL, *tbuf; WindowPtr pWin; xGetDeviceDontPropagateListReply rep; OtherInputMasks *others; REQUEST(xGetDeviceDontPropagateListReq); REQUEST_SIZE_MATCH(xGetDeviceDontPropagateListReq); rep.repType = X_Reply; rep.RepType = X_GetDeviceDontPropagateList; rep.sequenceNumber = client->sequence; rep.length = 0; rep.count = 0; rc = dixLookupWindow(&pWin, stuff->window, client, DixGetAttrAccess); if (rc != Success) return rc; if ((others = wOtherInputMasks(pWin)) != 0) { for (i = 0; i < EMASKSIZE; i++) ClassFromMask(NULL, others->dontPropagateMask[i], i, &count, COUNT); if (count) { rep.count = count; buf = (XEventClass *) malloc(rep.count * sizeof(XEventClass)); rep.length = bytes_to_int32(rep.count * sizeof(XEventClass)); tbuf = buf; for (i = 0; i < EMASKSIZE; i++) tbuf = ClassFromMask(tbuf, others->dontPropagateMask[i], i, NULL, CREATE); } } WriteReplyToClient(client, sizeof(xGetDeviceDontPropagateListReply), &rep); if (count) { client->pSwapReplyFunc = (ReplySwapPtr) Swap32Write; WriteSwappedDataToClient(client, count * sizeof(XEventClass), buf); free(buf); } return Success; }
// was Xinerama static int ProcPseudoramiXQueryScreens(ClientPtr client) { /* REQUEST(xXineramaQueryScreensReq); */ xXineramaQueryScreensReply rep; DEBUG_LOG("noPseudoramiXExtension=%d, pseudoramiXNumScreens=%d\n", noPseudoramiXExtension, pseudoramiXNumScreens); REQUEST_SIZE_MATCH(xXineramaQueryScreensReq); rep.type = X_Reply; rep.sequenceNumber = client->sequence; rep.number = noPseudoramiXExtension ? 0 : pseudoramiXNumScreens; rep.length = bytes_to_int32(rep.number * sz_XineramaScreenInfo); if (client->swapped) { swaps(&rep.sequenceNumber); swapl(&rep.length); swapl(&rep.number); } WriteToClient(client, sizeof(xXineramaQueryScreensReply),&rep); if (!noPseudoramiXExtension) { xXineramaScreenInfo scratch; int i; for (i = 0; i < pseudoramiXNumScreens; i++) { scratch.x_org = pseudoramiXScreens[i].x; scratch.y_org = pseudoramiXScreens[i].y; scratch.width = pseudoramiXScreens[i].w; scratch.height = pseudoramiXScreens[i].h; if (client->swapped) { swaps(&scratch.x_org); swaps(&scratch.y_org); swaps(&scratch.width); swaps(&scratch.height); } WriteToClient(client, sz_XineramaScreenInfo,&scratch); } } return Success; }
int SProcXGrabDevice(ClientPtr client) { REQUEST(xGrabDeviceReq); swaps(&stuff->length); REQUEST_AT_LEAST_SIZE(xGrabDeviceReq); swapl(&stuff->grabWindow); swapl(&stuff->time); swaps(&stuff->event_count); if (stuff->length != bytes_to_int32(sizeof(xGrabDeviceReq)) + stuff->event_count) return BadLength; SwapLongs((CARD32 *) (&stuff[1]), stuff->event_count); return (ProcXGrabDevice(client)); }
int ProcRRGetCrtcGamma (ClientPtr client) { REQUEST(xRRGetCrtcGammaReq); xRRGetCrtcGammaReply reply; RRCrtcPtr crtc; int n; unsigned long len; char *extra = NULL; REQUEST_SIZE_MATCH(xRRGetCrtcGammaReq); VERIFY_RR_CRTC(stuff->crtc, crtc, DixReadAccess); /* Gamma retrieval failed, any better error? */ if (!RRCrtcGammaGet(crtc)) return RRErrorBase + BadRRCrtc; len = crtc->gammaSize * 3 * 2; if (crtc->gammaSize) { extra = malloc(len); if (!extra) return BadAlloc; } reply.type = X_Reply; reply.sequenceNumber = client->sequence; reply.length = bytes_to_int32(len); reply.size = crtc->gammaSize; if (client->swapped) { swaps (&reply.sequenceNumber, n); swapl (&reply.length, n); swaps (&reply.size, n); } WriteToClient (client, sizeof (xRRGetCrtcGammaReply), (char *) &reply); if (crtc->gammaSize) { memcpy(extra, crtc->gammaRed, len); client->pSwapReplyFunc = (ReplySwapPtr)CopySwap16Write; WriteSwappedDataToClient (client, len, extra); free(extra); } return Success; }
static int ProcXF86DRIOpenConnection( register ClientPtr client ) { xXF86DRIOpenConnectionReply rep; drm_handle_t hSAREA; char* busIdString; REQUEST(xXF86DRIOpenConnectionReq); REQUEST_SIZE_MATCH(xXF86DRIOpenConnectionReq); if (stuff->screen >= screenInfo.numScreens) { client->errorValue = stuff->screen; return BadValue; } if (!DRIOpenConnection( screenInfo.screens[stuff->screen], &hSAREA, &busIdString)) { return BadValue; } rep.type = X_Reply; rep.sequenceNumber = client->sequence; rep.busIdStringLength = 0; if (busIdString) rep.busIdStringLength = strlen(busIdString); rep.length = bytes_to_int32(SIZEOF(xXF86DRIOpenConnectionReply) - SIZEOF(xGenericReply) + pad_to_int32(rep.busIdStringLength)); rep.hSAREALow = (CARD32)(hSAREA & 0xffffffff); #if defined(LONG64) && !defined(__linux__) rep.hSAREAHigh = (CARD32)(hSAREA >> 32); #else rep.hSAREAHigh = 0; #endif WriteToClient(client, sizeof(xXF86DRIOpenConnectionReply), (char *)&rep); if (rep.busIdStringLength) WriteToClient(client, rep.busIdStringLength, busIdString); return Success; }
int ProcXSetDeviceValuators(ClientPtr client) { DeviceIntPtr dev; xSetDeviceValuatorsReply rep; int rc; REQUEST(xSetDeviceValuatorsReq); REQUEST_AT_LEAST_SIZE(xSetDeviceValuatorsReq); rep.repType = X_Reply; rep.RepType = X_SetDeviceValuators; rep.length = 0; rep.status = Success; rep.sequenceNumber = client->sequence; if (stuff->length != bytes_to_int32(sizeof(xSetDeviceValuatorsReq)) + stuff->num_valuators) return BadLength; rc = dixLookupDevice(&dev, stuff->deviceid, client, DixSetAttrAccess); if (rc != Success) return rc; if (dev->valuator == NULL) return BadMatch; if (stuff->first_valuator + stuff->num_valuators > dev->valuator->numAxes) return BadValue; if ((dev->deviceGrab.grab) && !SameClient(dev->deviceGrab.grab, client)) rep.status = AlreadyGrabbed; else rep.status = SetDeviceValuators(client, dev, (int *)&stuff[1], stuff->first_valuator, stuff->num_valuators); if (rep.status != Success && rep.status != AlreadyGrabbed) return rep.status; WriteReplyToClient(client, sizeof(xSetDeviceValuatorsReply), &rep); return Success; }
int ProcXSetDeviceModifierMapping(ClientPtr client) { int ret; xSetDeviceModifierMappingReply rep; DeviceIntPtr dev; REQUEST(xSetDeviceModifierMappingReq); REQUEST_AT_LEAST_SIZE(xSetDeviceModifierMappingReq); if (stuff->length != bytes_to_int32(sizeof(xSetDeviceModifierMappingReq)) + (stuff->numKeyPerModifier << 1)) return BadLength; rep.repType = X_Reply; rep.RepType = X_SetDeviceModifierMapping; rep.length = 0; rep.sequenceNumber = client->sequence; ret = dixLookupDevice(&dev, stuff->deviceid, client, DixManageAccess); if (ret != Success) return ret; ret = change_modmap(client, dev, (KeyCode *) &stuff[1], stuff->numKeyPerModifier); if (ret == Success) ret = MappingSuccess; if (ret == MappingSuccess || ret == MappingBusy || ret == MappingFailed) { rep.success = ret; WriteReplyToClient(client, sizeof(xSetDeviceModifierMappingReply), &rep); } else if (ret == -1) { return BadValue; } else { return ret; } return Success; }
static int eventToTouchOwnershipEvent(TouchOwnershipEvent *ev, xEvent **xi) { int len = sizeof(xXITouchOwnershipEvent); xXITouchOwnershipEvent *xtoe; *xi = calloc(1, len); xtoe = (xXITouchOwnershipEvent*)*xi; xtoe->type = GenericEvent; xtoe->extension = IReqCode; xtoe->length = bytes_to_int32(len - sizeof(xEvent)); xtoe->evtype = GetXI2Type(ev->type); xtoe->deviceid = ev->deviceid; xtoe->time = ev->time; xtoe->sourceid = ev->sourceid; xtoe->touchid = ev->touchid; xtoe->flags = 0; /* we don't have wire flags for ownership yet */ return Success; }