diff options
Diffstat (limited to 'nx-X11/lib/Xtst/XRecord.c')
| -rw-r--r-- | nx-X11/lib/Xtst/XRecord.c | 1103 |
1 files changed, 1103 insertions, 0 deletions
diff --git a/nx-X11/lib/Xtst/XRecord.c b/nx-X11/lib/Xtst/XRecord.c new file mode 100644 index 000000000..16eaeffd7 --- /dev/null +++ b/nx-X11/lib/Xtst/XRecord.c @@ -0,0 +1,1103 @@ +/* +$Xorg: XRecord.c,v 1.4 2001/02/09 02:04:00 xorgcvs Exp $ + +XRecord.c - client-side library for RECORD extension + +Copyright 1995, 1998 The Open Group + +Permission to use, copy, modify, distribute, and sell this software and its +documentation for any purpose is hereby granted without fee, provided that +the above copyright notice appear in all copies and that both that +copyright notice and this permission notice appear in supporting +documentation. + +The above copyright notice and this permission notice shall be +included in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. +IN NO EVENT SHALL THE OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR +OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, +ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR +OTHER DEALINGS IN THE SOFTWARE. + +Except as contained in this notice, the name of The Open Group shall +not be used in advertising or otherwise to promote the sale, use or +other dealings in this Software without prior written authorization +from The Open Group. + +*/ +/*************************************************************************** + * Copyright 1995 Network Computing Devices + * + * Permission to use, copy, modify, distribute, and sell this software and + * its documentation for any purpose is hereby granted without fee, provided + * that the above copyright notice appear in all copies and that both that + * copyright notice and this permission notice appear in supporting + * documentation, and that the name of Network Computing Devices + * not be used in advertising or publicity pertaining to distribution + * of the software without specific, written prior permission. + * + * NETWORK COMPUTING DEVICES DISCLAIMs ALL WARRANTIES WITH REGARD TO + * THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS, IN NO EVENT SHALL NETWORK COMPUTING DEVICES BE LIABLE + * FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN + * AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING + * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + **************************************************************************/ +/* + * By Stephen Gildea, X Consortium, and Martha Zimet, NCD. + */ +/* $XFree86: xc/lib/Xtst/XRecord.c,v 1.6 2002/10/16 00:37:33 dawes Exp $ */ + +#include <stdio.h> +#include <assert.h> +#define NEED_EVENTS +#define NEED_REPLIES +#include <X11/Xlibint.h> +#include <X11/extensions/Xext.h> +#include <X11/extensions/extutil.h> +#include <X11/extensions/recordstr.h> + +static XExtensionInfo _xrecord_info_data; +static XExtensionInfo *xrecord_info = &_xrecord_info_data; +static /* const */ char *xrecord_extension_name = RECORD_NAME; + +#define XRecordCheckExtension(dpy,i,val) \ + XextCheckExtension(dpy, i, xrecord_extension_name, val) + +/************************************************************************** + * * + * private utility routines * + * * + **************************************************************************/ + +static XExtDisplayInfo *find_display(); + +/* + * A reply buffer holds a reply from RecordEnableContext. + * Pieces of that buffer are passed to the XRecordEnableContext callback. + * ref_count is incremented each time we do that. + * ref_count is decremented each time XRecordFreeData is called on + * the buffer. When ref_count is 0, we can free or reuse the buffer. + */ +struct reply_buffer +{ + struct reply_buffer *next; /* next in list or NULL */ + unsigned char *buf; /* pointer to malloc'd buffer */ + int nbytes; /* size of buf */ + int ref_count; /* callback uses pending */ +}; + + +/* + * There's some extra information the implementation finds useful + * to attach to an XRecordInterceptData packet to handle memory + * management. So we really allocate one of these. + */ +struct intercept_queue +{ + /* this struct gets passed to the user as an XRecordInterceptData, + so the data field must come first so we can cast the address + back and forth */ + XRecordInterceptData data; + struct intercept_queue *next; /* next in free list or NULL */ + struct mem_cache_str *cache; /* contains head of free list */ +}; + +/* + * per-display pointers to cache of malloc'd but unused memory + */ +struct mem_cache_str +{ + struct intercept_queue *inter_data; /* free structs only */ + struct reply_buffer *reply_buffers; /* all reply buffers */ + int inter_data_count; /* total allocated, free and in use */ + Bool display_closed; /* so we know when to free ourself */ +}; + +static int close_display(dpy, codes) + Display *dpy; + XExtCodes *codes; /* not used */ +{ + XExtDisplayInfo *info = find_display (dpy); + + LockDisplay(dpy); + if (info && info->data) { + struct mem_cache_str *cache = (struct mem_cache_str *)info->data; + struct intercept_queue *iq, *iq_next; + struct reply_buffer *rbp, **rbp_next_p; + + for (iq=cache->inter_data; iq; iq=iq_next) { + iq_next = iq->next; + XFree(iq); + cache->inter_data_count--; + } + + /* this is a little trickier, because some of these + might still be in use */ + for (rbp_next_p = &cache->reply_buffers; *rbp_next_p; ) { + rbp = *rbp_next_p; + if (rbp->ref_count == 0) { + *rbp_next_p = rbp->next; + XFree(rbp->buf); + XFree(rbp); + } else { + rbp_next_p = &rbp->next; + } + } + + if (cache->reply_buffers == NULL && cache->inter_data_count == 0) { + /* every thing has been freed, can free ourselves, too */ + XFree(cache); + } else { + cache->display_closed = True; + cache->inter_data = NULL; /* neatness only; won't be used */ + } + } + UnlockDisplay(dpy); + return XextRemoveDisplay(xrecord_info, dpy); +} + +static XPointer alloc_mem_cache() +{ + struct mem_cache_str *cache; + + /* note that an error will go unnoticed */ + cache = (struct mem_cache_str *) Xmalloc(sizeof(struct mem_cache_str)); + if (cache) { + cache->display_closed = False; + cache->inter_data = NULL; + cache->inter_data_count = 0; + cache->reply_buffers = NULL; + } + return (XPointer) cache; +} + +static char *xrecord_error_list[] = { + "XRecordBadContext (Not a defined RECORD context)", +}; + +static XEXT_GENERATE_ERROR_STRING (error_string, xrecord_extension_name, + RecordNumErrors, xrecord_error_list) + +static XExtensionHooks xrecord_extension_hooks = { + NULL, /* create_gc */ + NULL, /* copy_gc */ + NULL, /* flush_gc */ + NULL, /* free_gc */ + NULL, /* create_font */ + NULL, /* free_font */ + close_display, /* close_display */ + NULL, /* wire_to_event */ + NULL, /* event_to_wire */ + NULL, /* error */ + error_string /* error_string */ +}; + +static XEXT_GENERATE_FIND_DISPLAY (find_display, xrecord_info, + xrecord_extension_name, &xrecord_extension_hooks, RecordNumEvents, + alloc_mem_cache()) + +/************************************************************************** + * * + * private library routines * + * * + **************************************************************************/ + +static void +SendRange(dpy, range_item, nranges) + Display *dpy; + XRecordRange **range_item; + int nranges; +{ + int rlen = SIZEOF(xRecordRange); + while(nranges--) + { + xRecordRange xrange; + + xrange.coreRequestsFirst = (*range_item)->core_requests.first; + xrange.coreRequestsLast = (*range_item)->core_requests.last; + xrange.coreRepliesFirst = (*range_item)->core_replies.first; + xrange.coreRepliesLast = (*range_item)->core_replies.last; + xrange.extRequestsMajorFirst = (*range_item)->ext_requests.ext_major.first; + xrange.extRequestsMajorLast = (*range_item)->ext_requests.ext_major.last; + xrange.extRequestsMinorFirst = (*range_item)->ext_requests.ext_minor.first; + xrange.extRequestsMinorLast = (*range_item)->ext_requests.ext_minor.last; + xrange.extRepliesMajorFirst = (*range_item)->ext_replies.ext_major.first; + xrange.extRepliesMajorLast = (*range_item)->ext_replies.ext_major.last; + xrange.extRepliesMinorFirst = (*range_item)->ext_replies.ext_minor.first; + xrange.extRepliesMinorLast = (*range_item)->ext_replies.ext_minor.last; + xrange.deliveredEventsFirst = (*range_item)->delivered_events.first; + xrange.deliveredEventsLast = (*range_item)->delivered_events.last; + xrange.deviceEventsFirst = (*range_item)->device_events.first; + xrange.deviceEventsLast = (*range_item)->device_events.last; + xrange.errorsFirst = (*range_item)->errors.first; + xrange.errorsLast = (*range_item)->errors.last; + xrange.clientStarted = (*range_item)->client_started; + xrange.clientDied = (*range_item)->client_died; + + Data(dpy, (char *)&xrange, rlen); + range_item++; + } +} + +/************************************************************************** + * * + * public routines * + * * + **************************************************************************/ + +XID +XRecordIdBaseMask(dpy) + Display *dpy; +{ + return 0x1fffffff & ~dpy->resource_mask; +} + +Status +XRecordQueryVersion (dpy, cmajor_return, cminor_return) + Display *dpy; + int *cmajor_return, *cminor_return; +{ + XExtDisplayInfo *info = find_display (dpy); + register xRecordQueryVersionReq *req; + xRecordQueryVersionReply rep; + + XRecordCheckExtension (dpy, info, False); + + LockDisplay(dpy); + GetReq(RecordQueryVersion, req); + req->reqType = info->codes->major_opcode; + req->recordReqType = X_RecordQueryVersion; + req->majorVersion = RECORD_MAJOR_VERSION; + req->minorVersion = RECORD_MINOR_VERSION; + if (!_XReply(dpy,(xReply *)&rep, 0, True)) { + UnlockDisplay(dpy); + SyncHandle(); + return False; + } + UnlockDisplay(dpy); + SyncHandle(); + *cmajor_return = rep.majorVersion; + *cminor_return = rep.minorVersion; + return ((rep.majorVersion == RECORD_MAJOR_VERSION) && + (rep.minorVersion >= RECORD_LOWEST_MINOR_VERSION)); +} + +XRecordContext +XRecordCreateContext(dpy, datum_flags, clients, nclients, ranges, nranges) + Display *dpy; + int datum_flags; + XRecordClientSpec *clients; + int nclients; + XRecordRange **ranges; + int nranges; +{ + XExtDisplayInfo *info = find_display (dpy); + register xRecordCreateContextReq *req; + int clen = 4 * nclients; + + XRecordCheckExtension (dpy, info, 0); + LockDisplay(dpy); + GetReq(RecordCreateContext, req); + + req->reqType = info->codes->major_opcode; + req->recordReqType = X_RecordCreateContext; + req->context = XAllocID(dpy); + req->length += (nclients * 4 + + nranges * SIZEOF(xRecordRange)) >> 2; + req->elementHeader = datum_flags; + req->nClients = nclients; + req->nRanges = nranges; + + Data32(dpy, (long *)clients, clen); + SendRange(dpy, ranges, nranges); + + UnlockDisplay(dpy); + SyncHandle(); + return req->context; +} + +XRecordRange * +XRecordAllocRange() +{ + return (XRecordRange*)Xcalloc(1, sizeof(XRecordRange)); +} + +Status +XRecordRegisterClients(dpy, context, datum_flags, clients, nclients, ranges, nranges) + Display *dpy; + XRecordContext context; + int datum_flags; + XRecordClientSpec *clients; + int nclients; + XRecordRange **ranges; + int nranges; +{ + XExtDisplayInfo *info = find_display (dpy); + register xRecordRegisterClientsReq *req; + int clen = 4 * nclients; + + XRecordCheckExtension (dpy, info, 0); + LockDisplay(dpy); + GetReq(RecordRegisterClients, req); + + req->reqType = info->codes->major_opcode; + req->recordReqType = X_RecordRegisterClients; + req->context = context; + req->length += (nclients * 4 + + nranges * SIZEOF(xRecordRange)) >> 2; + req->elementHeader = datum_flags; + req->nClients = nclients; + req->nRanges = nranges; + + Data32(dpy, (long *)clients, clen); + SendRange(dpy, ranges, nranges); + + UnlockDisplay(dpy); + SyncHandle(); + return 1; +} + +Status +XRecordUnregisterClients(dpy, context, clients, nclients) + Display *dpy; + XRecordContext context; + XRecordClientSpec *clients; + int nclients; +{ + XExtDisplayInfo *info = find_display (dpy); + register xRecordUnregisterClientsReq *req; + int clen = 4 * nclients; + + XRecordCheckExtension (dpy, info, 0); + LockDisplay(dpy); + GetReq(RecordUnregisterClients, req); + + req->reqType = info->codes->major_opcode; + req->recordReqType = X_RecordUnregisterClients; + req->context = context; + req->length += nclients; + req->nClients = nclients; + + Data32(dpy, (long *)clients, clen); + + UnlockDisplay(dpy); + SyncHandle(); + return 1; +} + +static void +WireToLibRange(wire_range, lib_range) + xRecordRange *wire_range; + XRecordRange *lib_range; +{ + lib_range->core_requests.first = wire_range->coreRequestsFirst; + lib_range->core_requests.last = wire_range->coreRequestsLast; + lib_range->core_replies.first = wire_range->coreRepliesFirst; + lib_range->core_replies.last = wire_range->coreRepliesLast; + lib_range->ext_requests.ext_major.first = wire_range->extRequestsMajorFirst; + lib_range->ext_requests.ext_major.last = wire_range->extRequestsMajorLast; + lib_range->ext_requests.ext_minor.first = wire_range->extRequestsMinorFirst; + lib_range->ext_requests.ext_minor.last = wire_range->extRequestsMinorLast; + lib_range->ext_replies.ext_major.first = wire_range->extRepliesMajorFirst; + lib_range->ext_replies.ext_major.last = wire_range->extRepliesMajorLast; + lib_range->ext_replies.ext_minor.first = wire_range->extRepliesMinorFirst; + lib_range->ext_replies.ext_minor.last = wire_range->extRepliesMinorLast; + lib_range->delivered_events.first = wire_range->deliveredEventsFirst; + lib_range->delivered_events.last = wire_range->deliveredEventsLast; + lib_range->device_events.first = wire_range->deviceEventsFirst; + lib_range->device_events.last = wire_range->deviceEventsLast; + lib_range->errors.first = wire_range->errorsFirst; + lib_range->errors.last = wire_range->errorsLast; + lib_range->client_started = wire_range->clientStarted; + lib_range->client_died = wire_range->clientDied; +} + +Status +XRecordGetContext(dpy, context, state_return) + Display *dpy; + XRecordContext context; + XRecordState **state_return; +{ + XExtDisplayInfo *info = find_display (dpy); + register xRecordGetContextReq *req; + xRecordGetContextReply rep; + int count, i, rn; + xRecordRange xrange; + XRecordRange *ranges; + xRecordClientInfo xclient_inf; + XRecordClientInfo **client_inf, *client_inf_str; + XRecordState *ret; + + XRecordCheckExtension (dpy, info, 0); + LockDisplay(dpy); + GetReq(RecordGetContext, req); + req->reqType = info->codes->major_opcode; + req->recordReqType = X_RecordGetContext; + req->context = context; + if (!_XReply(dpy,(xReply *)&rep, 0, False)) { + UnlockDisplay(dpy); + SyncHandle(); + return 0; + } + count = rep.nClients; + + ret = (XRecordState*)Xmalloc(sizeof(XRecordState)); + if (!ret) { + /* XXX - eat data */ + UnlockDisplay(dpy); + SyncHandle(); + return 0; + } + + ret->enabled = rep.enabled; + ret->datum_flags = rep.elementHeader; + ret->nclients = count; + + if (count) + { + client_inf = (XRecordClientInfo **) Xcalloc(count, sizeof(XRecordClientInfo*)); + ret->client_info = client_inf; + client_inf_str = (XRecordClientInfo *) Xmalloc(count*sizeof(XRecordClientInfo)); + if (!client_inf || !client_inf_str) + { + for(i = 0; i < count; i++) + { + _XEatData (dpy, sizeof(xRecordClientInfo)); + _XEatData (dpy, SIZEOF(xRecordRange)); /* XXX - don't know how many */ + } + UnlockDisplay(dpy); + XRecordFreeState(ret); + SyncHandle(); + return 0; + } + for(i = 0; i < count; i++) + { + client_inf[i] = &(client_inf_str[i]); + _XRead(dpy, (char *)&xclient_inf, (long)sizeof(xRecordClientInfo)); + client_inf_str[i].client = xclient_inf.clientResource; + client_inf_str[i].nranges = xclient_inf.nRanges; + + if (xclient_inf.nRanges) + { + client_inf_str[i].ranges = (XRecordRange**) Xcalloc(xclient_inf.nRanges, sizeof(XRecordRange*)); + ranges = (XRecordRange*) Xmalloc(xclient_inf.nRanges * sizeof(XRecordRange)); + if (!client_inf_str[i].ranges || !ranges) { + /* XXX eat data */ + UnlockDisplay(dpy); + XRecordFreeState(ret); + SyncHandle(); + return 0; + } + for (rn=0; rn<xclient_inf.nRanges; rn++) { + client_inf_str[i].ranges[rn] = &(ranges[rn]); + _XRead(dpy, (char *)&xrange, (long)sizeof(xRecordRange)); + WireToLibRange(&xrange, &(ranges[rn])); + } + } else { + client_inf_str[i].ranges = NULL; + } + } + } else { + ret->client_info = NULL; + } + + *state_return = ret; + + UnlockDisplay(dpy); + SyncHandle(); + return 1; +} + +void +XRecordFreeState(state) + XRecordState *state; +{ + int i; + + for(i=0; i<state->nclients; i++) { + if (state->client_info[i]->ranges) { + if (state->client_info[i]->ranges[0]) + Xfree(state->client_info[i]->ranges[0]); + Xfree(state->client_info[i]->ranges); + } + } + if (state->client_info) { + if (state->client_info[0]) + Xfree(state->client_info[0]); + Xfree(state->client_info); + } + Xfree(state); +} + +static struct reply_buffer *alloc_reply_buffer(info, nbytes) + XExtDisplayInfo *info; + int nbytes; +{ + struct mem_cache_str *cache = (struct mem_cache_str *)info->data; + struct reply_buffer *rbp; + struct reply_buffer *saved_rb = NULL; + /* + * First look for an allocated buffer that is not in use. + * If we have a big enough buffer, use that, otherwise + * realloc an existing one. + */ + for (rbp = cache->reply_buffers; rbp; rbp = rbp->next) { + if (rbp->ref_count == 0) { + if (rbp->nbytes >= nbytes) + return rbp; + else + saved_rb = rbp; + } + } + if (saved_rb) { + saved_rb->buf = (unsigned char *)Xrealloc(saved_rb->buf, nbytes); + if (!saved_rb->buf) { + saved_rb->nbytes = 0; + return NULL; + } + saved_rb->nbytes = nbytes; + return saved_rb; + } + + /* + * nothing available; malloc a new struct + */ + rbp = (struct reply_buffer *)Xmalloc(sizeof(struct reply_buffer)); + if (!rbp) + return NULL; + rbp->buf = (unsigned char *)Xmalloc(nbytes); + if (!rbp->buf) { + Xfree(rbp); + return NULL; + } + rbp->nbytes = nbytes; + rbp->ref_count = 0; + rbp->next = cache->reply_buffers; + cache->reply_buffers = rbp; + return rbp; +} + +static XRecordInterceptData *alloc_inter_data(info) + XExtDisplayInfo *info; +{ + struct mem_cache_str *cache = (struct mem_cache_str *)info->data; + struct intercept_queue *iq; + + /* if there is one on the free list, pop it */ + if (cache->inter_data) { + iq = cache->inter_data; + cache->inter_data = iq->next; + return &iq->data; + } + /* allocate a new one */ + iq = (struct intercept_queue *)Xmalloc(sizeof(struct intercept_queue)); + if (!iq) + return NULL; + iq->cache = cache; + cache->inter_data_count++; + return &iq->data; +} + +void +XRecordFreeData(data) + XRecordInterceptData *data; +{ + /* we can do this cast because that is what we really allocated */ + struct intercept_queue *iq = (struct intercept_queue *)data; + struct reply_buffer *rbp = NULL; + struct mem_cache_str *cache = iq->cache; + + /* + * figure out what reply_buffer this points at + * and decrement its ref_count. + */ + if (data->data) { + + for (rbp = cache->reply_buffers; rbp; rbp = rbp->next) { + if (data->data >= rbp->buf + && data->data < rbp->buf + rbp->nbytes) + { + assert(rbp->ref_count > 0); + rbp->ref_count--; + break; + } + } + /* it's an error if we didn't find something to free */ + assert(rbp); + } + /* + * If the display is still open, put this back on the free queue. + * + * Otherwise the display is closed and we won't reuse this, so free it. + * See if we can free the reply buffer, too. + * If we can, see if this is the last reply buffer and if so + * free the list of reply buffers. + */ + if (cache->display_closed == False) { + iq->next = cache->inter_data; + cache->inter_data = iq; + } else { + if (rbp && rbp->ref_count == 0) { + struct reply_buffer *rbp2, **rbp_next_p; + + /* Have to search the list again to find the prev element. + This is not the common case, so don't slow down the code + above by doing it then. */ + for (rbp_next_p = &cache->reply_buffers; *rbp_next_p; ) { + rbp2 = *rbp_next_p; + if (rbp == rbp2) { + *rbp_next_p = rbp2->next; + break; + } else { + rbp_next_p = &rbp2->next; + } + } + XFree(rbp->buf); + XFree(rbp); + } + + XFree(iq); + cache->inter_data_count--; + + if (cache->reply_buffers == NULL && cache->inter_data_count == 0) { + XFree(cache); /* all finished */ + } + } +} + +/* the EXTRACT macros are adapted from ICElibint.h */ + +#ifndef WORD64 + +#define EXTRACT_CARD16(swap, src, dst) \ +{ \ + (dst) = *((CARD16 *) (src)); \ + if (swap) \ + (dst) = lswaps (dst); \ +} + +#define EXTRACT_CARD32(swap, src, dst) \ +{ \ + (dst) = *((CARD32 *) (src)); \ + if (swap) \ + (dst) = lswapl (dst); \ +} + +#else /* WORD64 */ + +#define EXTRACT_CARD16(swap, src, dst) \ +{ \ + (dst) = *((src) + 0); \ + (dst) <<= 8; \ + (dst) |= *((src) + 1); \ + if (swap) \ + (dst) = lswaps (dst); \ +} + +#define EXTRACT_CARD32(swap, src, dst) \ +{ \ + (dst) = *((src) + 0); \ + (dst) <<= 8; \ + (dst) |= *((src) + 1); \ + (dst) <<= 8; \ + (dst) |= *((src) + 2); \ + (dst) <<= 8; \ + (dst) |= *((src) + 3); \ + if (swap) \ + (dst) = lswapl (dst); \ +} + +#endif /* WORD64 */ + +/* byte swapping macros from xfs/include/misc.h */ + +/* byte swap a long literal */ +#define lswapl(x) ((((x) & 0xff) << 24) |\ + (((x) & 0xff00) << 8) |\ + (((x) & 0xff0000) >> 8) |\ + (((x) >> 24) & 0xff)) + +/* byte swap a short literal */ +#define lswaps(x) ((((x) & 0xff) << 8) | (((x) >> 8) & 0xff)) + +enum parser_return { Continue, End, Error }; + +static enum parser_return +parse_reply_call_callback(dpy, info, rep, reply, callback, closure) + Display *dpy; + XExtDisplayInfo *info; + xRecordEnableContextReply *rep; + struct reply_buffer *reply; + XRecordInterceptProc callback; + XPointer closure; +{ + int current_index; + int datum_bytes = 0; + XRecordInterceptData *data; + + /* call the callback for each protocol element in the reply */ + current_index = 0; + do { + data = alloc_inter_data(info); + if (!data) + return Error; + + data->id_base = rep->idBase; + data->category = rep->category; + data->client_swapped = rep->clientSwapped; + data->server_time = rep->serverTime; + data->client_seq = rep->recordedSequenceNumber; + /* + * compute the size of this protocol element. + */ + switch (rep->category) { + case XRecordFromServer: + if (rep->elementHeader&XRecordFromServerTime) { + EXTRACT_CARD32(rep->clientSwapped, + reply->buf+current_index, + data->server_time); + current_index += 4; + } + switch (reply->buf[current_index]) { + case X_Reply: /* reply */ + EXTRACT_CARD32(rep->clientSwapped, + reply->buf+current_index+4, datum_bytes); + datum_bytes = (datum_bytes+8) << 2; + break; + default: /* error or event */ + datum_bytes = 32; + } + break; + case XRecordFromClient: + if (rep->elementHeader&XRecordFromClientTime) { + EXTRACT_CARD32(rep->clientSwapped, + reply->buf+current_index, + data->server_time); + current_index += 4; + } + if (rep->elementHeader&XRecordFromClientSequence) { + EXTRACT_CARD32(rep->clientSwapped, + reply->buf+current_index, + data->client_seq); + current_index += 4; + } + if (reply->buf[current_index+2] == 0 + && reply->buf[current_index+3] == 0) /* needn't swap 0 */ + { /* BIG-REQUESTS */ + EXTRACT_CARD32(rep->clientSwapped, + reply->buf+current_index+4, datum_bytes); + } else { + EXTRACT_CARD16(rep->clientSwapped, + reply->buf+current_index+2, datum_bytes); + } + datum_bytes <<= 2; + break; + case XRecordClientStarted: + EXTRACT_CARD16(rep->clientSwapped, + reply->buf+current_index+6, datum_bytes); + datum_bytes = (datum_bytes+2) << 2; + break; + case XRecordClientDied: + if (rep->elementHeader&XRecordFromClientSequence) { + EXTRACT_CARD32(rep->clientSwapped, + reply->buf+current_index, + data->client_seq); + current_index += 4; + } + /* fall through */ + case XRecordStartOfData: + case XRecordEndOfData: + datum_bytes = 0; + } + + if (datum_bytes > 0) { + if (current_index + datum_bytes > rep->length << 2) + fprintf(stderr, + "XRecord: %lu-byte reply claims %d-byte element (seq %lu)\n", + (long)rep->length << 2, current_index + datum_bytes, + dpy->last_request_read); + /* + * This assignment (and indeed the whole buffer sharing + * scheme) assumes arbitrary 4-byte boundaries are + * addressable. + */ + data->data = reply->buf+current_index; + reply->ref_count++; + } else { + data->data = NULL; + } + data->data_len = datum_bytes >> 2; + + (*callback)(closure, data); + + current_index += datum_bytes; + } while (current_index<rep->length<<2); + + if (rep->category == XRecordEndOfData) + return End; + + return Continue; +} + +Status +XRecordEnableContext(dpy, context, callback, closure) + Display *dpy; + XRecordContext context; + XRecordInterceptProc callback; + XPointer closure; +{ + XExtDisplayInfo *info = find_display (dpy); + register xRecordEnableContextReq *req; + xRecordEnableContextReply rep; + struct reply_buffer *reply; + enum parser_return status; + + XRecordCheckExtension (dpy, info, 0); + LockDisplay(dpy); + GetReq(RecordEnableContext, req); + + req->reqType = info->codes->major_opcode; + req->recordReqType = X_RecordEnableContext; + req->context = context; + + while (1) + { + /* This code should match that in XRecordEnableContextAsync */ + if (!_XReply (dpy, (xReply *)&rep, 0, xFalse)) + { + UnlockDisplay(dpy); + SyncHandle(); + return 0; + } + + if (rep.length > 0) { + reply = alloc_reply_buffer(info, rep.length<<2); + if (!reply) { + UnlockDisplay(dpy); + SyncHandle(); + return 0; + } + _XRead (dpy, (char *)reply->buf, rep.length<<2); + } else { + reply = NULL; + } + + status = parse_reply_call_callback(dpy, info, &rep, reply, + callback, closure); + switch (status) { + case Continue: + break; + case End: + UnlockDisplay(dpy); + SyncHandle(); + return 1; + case Error: + UnlockDisplay(dpy); + SyncHandle(); + return 0; + } + } +} + + +typedef struct _record_async_state +{ + unsigned long enable_seq; + _XAsyncHandler *async; + _XAsyncErrorState *error_state; + XExtDisplayInfo *info; + XRecordInterceptProc callback; + XPointer closure; +} record_async_state; + +static Bool +record_async_handler(dpy, rep, buf, len, adata) + register Display *dpy; + register xReply *rep; + char *buf; + int len; + XPointer adata; +{ + register record_async_state *state = (record_async_state *)adata; + struct reply_buffer *reply; + enum parser_return status; + + if (dpy->last_request_read != state->enable_seq) + { + if (dpy->last_request_read > state->enable_seq) { + /* it is an error that we are still on the handler list */ + fprintf(stderr, "XRecord: handler for seq %lu never saw XRecordEndOfData. (seq now %lu)\n", + state->enable_seq, dpy->last_request_read); + DeqAsyncHandler(dpy, state->async); + Xfree(state->async); + } + return False; + } + if (rep->generic.type == X_Error) + { + DeqAsyncHandler(dpy, state->async); + Xfree(state->async); + return False; + } + + if (rep->generic.length > 0) { + reply = alloc_reply_buffer(state->info, rep->generic.length<<2); + + if (!reply) { + DeqAsyncHandler(dpy, state->async); + Xfree(state->async); + return False; + } + + _XGetAsyncData(dpy, (char *)reply->buf, buf, len, + SIZEOF(xRecordEnableContextReply), + rep->generic.length << 2, 0); + } else { + reply = NULL; + } + + status = parse_reply_call_callback(dpy, state->info, + (xRecordEnableContextReply*) rep, + reply, state->callback, state->closure); + + if (status != Continue) + { + DeqAsyncHandler(dpy, state->async); + Xfree(state->async); + if (status == Error) + return False; + } + + return True; +} + +/* + * reads the first reply, StartOfData, synchronously, + * then returns allowing the app to call XRecordProcessReplies + * to get the rest. + */ +Status +XRecordEnableContextAsync(dpy, context, callback, closure) + Display *dpy; + XRecordContext context; + XRecordInterceptProc callback; + XPointer closure; +{ + XExtDisplayInfo *info = find_display (dpy); + register xRecordEnableContextReq *req; + xRecordEnableContextReply rep; + struct reply_buffer *reply; + enum parser_return status; + _XAsyncHandler *async; + record_async_state *async_state; + + XRecordCheckExtension (dpy, info, 0); + async = (_XAsyncHandler *)Xmalloc(sizeof(_XAsyncHandler) + + sizeof(record_async_state)); + if (!async) + return 0; + async_state = (record_async_state *)(async + 1); + + LockDisplay(dpy); + GetReq(RecordEnableContext, req); + + req->reqType = info->codes->major_opcode; + req->recordReqType = X_RecordEnableContext; + req->context = context; + + /* Get the StartOfData reply. */ + /* This code should match that in XRecordEnableContext */ + if (!_XReply (dpy, (xReply *)&rep, 0, xFalse)) + { + UnlockDisplay(dpy); + SyncHandle(); + Xfree(async); + return 0; + } + + /* this had better be a StartOfData, which has no extra data. */ + if (rep.length != 0) { + fprintf(stderr, "XRecord: malformed StartOfData for sequence %lu\n", + dpy->last_request_read); + } + reply = NULL; + + status = parse_reply_call_callback(dpy, info, &rep, reply, + callback, closure); + if (status != Continue) + { + UnlockDisplay(dpy); + Xfree(async); + return 0; + } + + /* hook in the async handler for the rest of the replies */ + async_state->enable_seq = dpy->request; + async_state->async = async; + async_state->info = info; + async_state->callback = callback; + async_state->closure = closure; + + async->next = dpy->async_handlers; + async->handler = record_async_handler; + async->data = (XPointer)async_state; + dpy->async_handlers = async; + + UnlockDisplay(dpy); + /* Don't invoke SyncHandle here, since this is an async + function. Does this break XSetAfterFunction() ? */ + return 1; +} + +void +XRecordProcessReplies(dpy) + Display *dpy; +{ + (void) XPending(dpy); +} + +Status +XRecordDisableContext(dpy, context) + Display *dpy; + XRecordContext context; +{ + XExtDisplayInfo *info = find_display (dpy); + register xRecordDisableContextReq *req; + + XRecordCheckExtension (dpy, info, 0); + LockDisplay(dpy); + GetReq(RecordDisableContext, req); + req->reqType = info->codes->major_opcode; + req->recordReqType = X_RecordDisableContext; + req->context = context; + + UnlockDisplay(dpy); + SyncHandle(); + return 1; +} + +Status +XRecordFreeContext(dpy, context) + Display *dpy; + XRecordContext context; +{ + XExtDisplayInfo *info = find_display (dpy); + register xRecordFreeContextReq *req; + + XRecordCheckExtension (dpy, info, 0); + + LockDisplay(dpy); + GetReq(RecordFreeContext, req); + req->reqType = info->codes->major_opcode; + req->recordReqType = X_RecordFreeContext; + req->context = context; + + UnlockDisplay(dpy); + SyncHandle(); + return 1; +} |