2006-11-26 11:13:41 -07:00
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
|
|
|
|
|
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.
|
|
|
|
|
|
|
|
|
|
Author: David P. Wiggins, The Open Group
|
|
|
|
|
|
|
|
|
|
This work benefited from earlier work done by Martha Zimet of NCD
|
|
|
|
|
and Jim Haggerty of Metheus.
|
|
|
|
|
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
#ifdef HAVE_DIX_CONFIG_H
|
|
|
|
|
#include <dix-config.h>
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
#include "dixstruct.h"
|
|
|
|
|
#include "extnsionst.h"
|
2010-07-27 13:02:24 -06:00
|
|
|
|
#include <X11/extensions/recordproto.h>
|
2006-11-26 11:13:41 -07:00
|
|
|
|
#include "set.h"
|
|
|
|
|
#include "swaprep.h"
|
2009-09-06 13:44:18 -06:00
|
|
|
|
#include "inputstr.h"
|
2010-07-27 13:02:24 -06:00
|
|
|
|
#include "eventconvert.h"
|
2010-12-05 08:36:02 -07:00
|
|
|
|
#include "scrnintstr.h"
|
2010-07-27 13:02:24 -06:00
|
|
|
|
|
2006-11-26 11:13:41 -07:00
|
|
|
|
|
|
|
|
|
#include <stdio.h>
|
|
|
|
|
#include <assert.h>
|
|
|
|
|
|
|
|
|
|
#ifdef PANORAMIX
|
|
|
|
|
#include "globals.h"
|
|
|
|
|
#include "panoramiX.h"
|
|
|
|
|
#include "panoramiXsrv.h"
|
|
|
|
|
#include "cursor.h"
|
|
|
|
|
#endif
|
|
|
|
|
|
2010-07-27 13:02:24 -06:00
|
|
|
|
#include "protocol-versions.h"
|
|
|
|
|
|
2006-11-26 11:13:41 -07:00
|
|
|
|
static RESTYPE RTContext; /* internal resource type for Record contexts */
|
|
|
|
|
|
|
|
|
|
/* How many bytes of protocol data to buffer in a context. Don't set to less
|
|
|
|
|
* than 32.
|
|
|
|
|
*/
|
|
|
|
|
#define REPLY_BUF_SIZE 1024
|
|
|
|
|
|
|
|
|
|
/* Record Context structure */
|
|
|
|
|
|
|
|
|
|
typedef struct {
|
|
|
|
|
XID id; /* resource id of context */
|
|
|
|
|
ClientPtr pRecordingClient; /* client that has context enabled */
|
|
|
|
|
struct _RecordClientsAndProtocolRec *pListOfRCAP; /* all registered info */
|
|
|
|
|
ClientPtr pBufClient; /* client whose protocol is in replyBuffer*/
|
|
|
|
|
unsigned int continuedReply:1; /* recording a reply that is split up? */
|
|
|
|
|
char elemHeaders; /* element header flags (time/seq no.) */
|
|
|
|
|
char bufCategory; /* category of protocol in replyBuffer */
|
|
|
|
|
int numBufBytes; /* number of bytes in replyBuffer */
|
|
|
|
|
char replyBuffer[REPLY_BUF_SIZE]; /* buffered recorded protocol */
|
2011-04-02 10:08:38 -06:00
|
|
|
|
int inFlush; /* are we inside RecordFlushReplyBuffer */
|
2006-11-26 11:13:41 -07:00
|
|
|
|
} RecordContextRec, *RecordContextPtr;
|
|
|
|
|
|
|
|
|
|
/* RecordMinorOpRec - to hold minor opcode selections for extension requests
|
|
|
|
|
* and replies
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
typedef union {
|
|
|
|
|
int count; /* first element of array: how many "major" structs to follow */
|
|
|
|
|
struct { /* rest of array elements are this */
|
|
|
|
|
short first; /* first major opcode */
|
|
|
|
|
short last; /* last major opcode */
|
|
|
|
|
RecordSetPtr pMinOpSet; /* minor opcode set for above major range */
|
|
|
|
|
} major;
|
|
|
|
|
} RecordMinorOpRec, *RecordMinorOpPtr;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* RecordClientsAndProtocolRec, nicknamed RCAP - holds all the client and
|
|
|
|
|
* protocol selections passed in a single CreateContext or RegisterClients.
|
|
|
|
|
* Generally, a context will have one of these from the create and an
|
|
|
|
|
* additional one for each RegisterClients. RCAPs are freed when all their
|
|
|
|
|
* clients are unregistered.
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
typedef struct _RecordClientsAndProtocolRec {
|
|
|
|
|
RecordContextPtr pContext; /* context that owns this RCAP */
|
|
|
|
|
struct _RecordClientsAndProtocolRec *pNextRCAP; /* next RCAP on context */
|
|
|
|
|
RecordSetPtr pRequestMajorOpSet; /* requests to record */
|
|
|
|
|
RecordMinorOpPtr pRequestMinOpInfo; /* extension requests to record */
|
|
|
|
|
RecordSetPtr pReplyMajorOpSet; /* replies to record */
|
|
|
|
|
RecordMinorOpPtr pReplyMinOpInfo; /* extension replies to record */
|
|
|
|
|
RecordSetPtr pDeviceEventSet; /* device events to record */
|
|
|
|
|
RecordSetPtr pDeliveredEventSet; /* delivered events to record */
|
|
|
|
|
RecordSetPtr pErrorSet; /* errors to record */
|
|
|
|
|
XID * pClientIDs; /* array of clients to record */
|
|
|
|
|
short numClients; /* number of clients in pClientIDs */
|
|
|
|
|
short sizeClients; /* size of pClientIDs array */
|
|
|
|
|
unsigned int clientStarted:1; /* record new client connections? */
|
|
|
|
|
unsigned int clientDied:1; /* record client disconnections? */
|
|
|
|
|
unsigned int clientIDsSeparatelyAllocated:1; /* pClientIDs malloced? */
|
|
|
|
|
} RecordClientsAndProtocolRec, *RecordClientsAndProtocolPtr;
|
|
|
|
|
|
|
|
|
|
/* how much bigger to make pRCAP->pClientIDs when reallocing */
|
|
|
|
|
#define CLIENT_ARRAY_GROWTH_INCREMENT 4
|
|
|
|
|
|
|
|
|
|
/* counts the total number of RCAPs belonging to enabled contexts. */
|
|
|
|
|
static int numEnabledRCAPs;
|
|
|
|
|
|
|
|
|
|
/* void VERIFY_CONTEXT(RecordContextPtr, XID, ClientPtr)
|
|
|
|
|
* In the spirit of the VERIFY_* macros in dix.h, this macro fills in
|
|
|
|
|
* the context pointer if the given ID is a valid Record Context, else it
|
|
|
|
|
* returns an error.
|
|
|
|
|
*/
|
|
|
|
|
#define VERIFY_CONTEXT(_pContext, _contextid, _client) { \
|
2010-07-27 13:02:24 -06:00
|
|
|
|
int rc = dixLookupResourceByType((pointer *)&(_pContext), _contextid, \
|
|
|
|
|
RTContext, _client, DixUseAccess); \
|
|
|
|
|
if (rc != Success) \
|
2010-12-05 08:36:02 -07:00
|
|
|
|
return rc; \
|
2006-11-26 11:13:41 -07:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int RecordDeleteContext(
|
|
|
|
|
pointer /*value*/,
|
|
|
|
|
XID /*id*/
|
|
|
|
|
);
|
|
|
|
|
|
2010-07-27 13:02:24 -06:00
|
|
|
|
void RecordExtensionInit(void);
|
|
|
|
|
|
2006-11-26 11:13:41 -07:00
|
|
|
|
/***************************************************************************/
|
|
|
|
|
|
|
|
|
|
/* client private stuff */
|
|
|
|
|
|
|
|
|
|
/* To make declarations less obfuscated, have a typedef for a pointer to a
|
|
|
|
|
* Proc function.
|
|
|
|
|
*/
|
|
|
|
|
typedef int (*ProcFunctionPtr)(
|
|
|
|
|
ClientPtr /*pClient*/
|
|
|
|
|
);
|
|
|
|
|
|
|
|
|
|
/* Record client private. Generally a client only has one of these if
|
|
|
|
|
* any of its requests are being recorded.
|
|
|
|
|
*/
|
|
|
|
|
typedef struct {
|
|
|
|
|
/* ptr to client's proc vector before Record stuck its nose in */
|
|
|
|
|
ProcFunctionPtr *originalVector;
|
|
|
|
|
|
|
|
|
|
/* proc vector with pointers for recorded requests redirected to the
|
|
|
|
|
* function RecordARequest
|
|
|
|
|
*/
|
|
|
|
|
ProcFunctionPtr recordVector[256];
|
|
|
|
|
} RecordClientPrivateRec, *RecordClientPrivatePtr;
|
|
|
|
|
|
2010-12-05 08:36:02 -07:00
|
|
|
|
static DevPrivateKeyRec RecordClientPrivateKeyRec;
|
|
|
|
|
#define RecordClientPrivateKey (&RecordClientPrivateKeyRec)
|
2006-11-26 11:13:41 -07:00
|
|
|
|
|
|
|
|
|
/* RecordClientPrivatePtr RecordClientPrivate(ClientPtr)
|
|
|
|
|
* gets the client private of the given client. Syntactic sugar.
|
|
|
|
|
*/
|
|
|
|
|
#define RecordClientPrivate(_pClient) (RecordClientPrivatePtr) \
|
2008-11-02 08:26:08 -07:00
|
|
|
|
dixLookupPrivate(&(_pClient)->devPrivates, RecordClientPrivateKey)
|
2006-11-26 11:13:41 -07:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/***************************************************************************/
|
|
|
|
|
|
|
|
|
|
/* global list of all contexts */
|
|
|
|
|
|
|
|
|
|
static RecordContextPtr *ppAllContexts;
|
|
|
|
|
|
|
|
|
|
static int numContexts;/* number of contexts in ppAllContexts */
|
|
|
|
|
|
|
|
|
|
/* number of currently enabled contexts. All enabled contexts are bunched
|
|
|
|
|
* up at the front of the ppAllContexts array, from ppAllContexts[0] to
|
|
|
|
|
* ppAllContexts[numEnabledContexts-1], to eliminate time spent skipping
|
|
|
|
|
* past disabled contexts.
|
|
|
|
|
*/
|
|
|
|
|
static int numEnabledContexts;
|
|
|
|
|
|
|
|
|
|
/* RecordFindContextOnAllContexts
|
|
|
|
|
*
|
|
|
|
|
* Arguments:
|
|
|
|
|
* pContext is the context to search for.
|
|
|
|
|
*
|
|
|
|
|
* Returns:
|
|
|
|
|
* The index into the array ppAllContexts at which pContext is stored.
|
|
|
|
|
* If pContext is not found in ppAllContexts, returns -1.
|
|
|
|
|
*
|
|
|
|
|
* Side Effects: none.
|
|
|
|
|
*/
|
|
|
|
|
static int
|
|
|
|
|
RecordFindContextOnAllContexts(RecordContextPtr pContext)
|
|
|
|
|
{
|
|
|
|
|
int i;
|
|
|
|
|
|
|
|
|
|
assert(numContexts >= numEnabledContexts);
|
|
|
|
|
for (i = 0; i < numContexts; i++)
|
|
|
|
|
{
|
|
|
|
|
if (ppAllContexts[i] == pContext)
|
|
|
|
|
return i;
|
|
|
|
|
}
|
|
|
|
|
return -1;
|
|
|
|
|
} /* RecordFindContextOnAllContexts */
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/***************************************************************************/
|
|
|
|
|
|
|
|
|
|
/* RecordFlushReplyBuffer
|
|
|
|
|
*
|
|
|
|
|
* Arguments:
|
|
|
|
|
* pContext is the context to flush.
|
|
|
|
|
* data1 is a pointer to additional data, and len1 is its length in bytes.
|
|
|
|
|
* data2 is a pointer to additional data, and len2 is its length in bytes.
|
|
|
|
|
*
|
|
|
|
|
* Returns: nothing.
|
|
|
|
|
*
|
|
|
|
|
* Side Effects:
|
|
|
|
|
* If the context is enabled, any buffered (recorded) protocol is written
|
|
|
|
|
* to the recording client, and the number of buffered bytes is set to
|
|
|
|
|
* zero. If len1 is not zero, data1/len1 are then written to the
|
|
|
|
|
* recording client, and similarly for data2/len2 (written after
|
|
|
|
|
* data1/len1).
|
|
|
|
|
*/
|
|
|
|
|
static void
|
|
|
|
|
RecordFlushReplyBuffer(
|
|
|
|
|
RecordContextPtr pContext,
|
|
|
|
|
pointer data1,
|
|
|
|
|
int len1,
|
|
|
|
|
pointer data2,
|
|
|
|
|
int len2
|
|
|
|
|
)
|
|
|
|
|
{
|
2011-04-02 10:08:38 -06:00
|
|
|
|
if (!pContext->pRecordingClient || pContext->pRecordingClient->clientGone || pContext->inFlush)
|
2006-11-26 11:13:41 -07:00
|
|
|
|
return;
|
2011-04-02 10:08:38 -06:00
|
|
|
|
++pContext->inFlush;
|
2006-11-26 11:13:41 -07:00
|
|
|
|
if (pContext->numBufBytes)
|
|
|
|
|
WriteToClient(pContext->pRecordingClient, pContext->numBufBytes,
|
|
|
|
|
(char *)pContext->replyBuffer);
|
|
|
|
|
pContext->numBufBytes = 0;
|
|
|
|
|
if (len1)
|
|
|
|
|
WriteToClient(pContext->pRecordingClient, len1, (char *)data1);
|
|
|
|
|
if (len2)
|
|
|
|
|
WriteToClient(pContext->pRecordingClient, len2, (char *)data2);
|
2011-04-02 10:08:38 -06:00
|
|
|
|
--pContext->inFlush;
|
2006-11-26 11:13:41 -07:00
|
|
|
|
} /* RecordFlushReplyBuffer */
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* RecordAProtocolElement
|
|
|
|
|
*
|
|
|
|
|
* Arguments:
|
|
|
|
|
* pContext is the context that is recording a protocol element.
|
|
|
|
|
* pClient is the client whose protocol is being recorded. For
|
|
|
|
|
* device events and EndOfData, pClient is NULL.
|
|
|
|
|
* category is the category of the protocol element, as defined
|
|
|
|
|
* by the RECORD spec.
|
|
|
|
|
* data is a pointer to the protocol data, and datalen is its length
|
|
|
|
|
* in bytes.
|
|
|
|
|
* futurelen is the number of bytes that will be sent in subsequent
|
|
|
|
|
* calls to this function to complete this protocol element.
|
|
|
|
|
* In those subsequent calls, futurelen will be -1 to indicate
|
|
|
|
|
* that the current data is a continuation of the same protocol
|
|
|
|
|
* element.
|
|
|
|
|
*
|
|
|
|
|
* Returns: nothing.
|
|
|
|
|
*
|
|
|
|
|
* Side Effects:
|
|
|
|
|
* The context may be flushed. The new protocol element will be
|
|
|
|
|
* added to the context's protocol buffer with appropriate element
|
|
|
|
|
* headers prepended (sequence number and timestamp). If the data
|
|
|
|
|
* is continuation data (futurelen == -1), element headers won't
|
|
|
|
|
* be added. If the protocol element and headers won't fit in
|
|
|
|
|
* the context's buffer, it is sent directly to the recording
|
|
|
|
|
* client (after any buffered data).
|
|
|
|
|
*/
|
|
|
|
|
static void
|
|
|
|
|
RecordAProtocolElement(RecordContextPtr pContext, ClientPtr pClient,
|
|
|
|
|
int category, pointer data, int datalen, int futurelen)
|
|
|
|
|
{
|
|
|
|
|
CARD32 elemHeaderData[2];
|
|
|
|
|
int numElemHeaders = 0;
|
|
|
|
|
Bool recordingClientSwapped = pContext->pRecordingClient->swapped;
|
|
|
|
|
int n;
|
|
|
|
|
CARD32 serverTime = 0;
|
|
|
|
|
Bool gotServerTime = FALSE;
|
|
|
|
|
int replylen;
|
|
|
|
|
|
|
|
|
|
if (futurelen >= 0)
|
|
|
|
|
{ /* start of new protocol element */
|
|
|
|
|
xRecordEnableContextReply *pRep = (xRecordEnableContextReply *)
|
|
|
|
|
pContext->replyBuffer;
|
|
|
|
|
if (pContext->pBufClient != pClient ||
|
|
|
|
|
pContext->bufCategory != category)
|
|
|
|
|
{
|
|
|
|
|
RecordFlushReplyBuffer(pContext, NULL, 0, NULL, 0);
|
|
|
|
|
pContext->pBufClient = pClient;
|
|
|
|
|
pContext->bufCategory = category;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (!pContext->numBufBytes)
|
|
|
|
|
{
|
|
|
|
|
serverTime = GetTimeInMillis();
|
|
|
|
|
gotServerTime = TRUE;
|
|
|
|
|
pRep->type = X_Reply;
|
|
|
|
|
pRep->category = category;
|
|
|
|
|
pRep->sequenceNumber = pContext->pRecordingClient->sequence;
|
|
|
|
|
pRep->length = 0;
|
|
|
|
|
pRep->elementHeader = pContext->elemHeaders;
|
|
|
|
|
pRep->serverTime = serverTime;
|
|
|
|
|
if (pClient)
|
|
|
|
|
{
|
|
|
|
|
pRep->clientSwapped =
|
|
|
|
|
(pClient->swapped != recordingClientSwapped);
|
|
|
|
|
pRep->idBase = pClient->clientAsMask;
|
|
|
|
|
pRep->recordedSequenceNumber = pClient->sequence;
|
|
|
|
|
}
|
|
|
|
|
else /* it's a device event, StartOfData, or EndOfData */
|
|
|
|
|
{
|
|
|
|
|
pRep->clientSwapped = (category != XRecordFromServer) &&
|
|
|
|
|
recordingClientSwapped;
|
|
|
|
|
pRep->idBase = 0;
|
|
|
|
|
pRep->recordedSequenceNumber = 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (recordingClientSwapped)
|
|
|
|
|
{
|
|
|
|
|
swaps(&pRep->sequenceNumber, n);
|
|
|
|
|
swapl(&pRep->length, n);
|
|
|
|
|
swapl(&pRep->idBase, n);
|
|
|
|
|
swapl(&pRep->serverTime, n);
|
|
|
|
|
swapl(&pRep->recordedSequenceNumber, n);
|
|
|
|
|
}
|
|
|
|
|
pContext->numBufBytes = SIZEOF(xRecordEnableContextReply);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* generate element headers if needed */
|
|
|
|
|
|
|
|
|
|
if ( ( (pContext->elemHeaders & XRecordFromClientTime)
|
|
|
|
|
&& category == XRecordFromClient)
|
|
|
|
|
||
|
|
|
|
|
( (pContext->elemHeaders & XRecordFromServerTime)
|
|
|
|
|
&& category == XRecordFromServer))
|
|
|
|
|
{
|
|
|
|
|
if (gotServerTime)
|
|
|
|
|
elemHeaderData[numElemHeaders] = serverTime;
|
|
|
|
|
else
|
|
|
|
|
elemHeaderData[numElemHeaders] = GetTimeInMillis();
|
|
|
|
|
if (recordingClientSwapped)
|
|
|
|
|
swapl(&elemHeaderData[numElemHeaders], n);
|
|
|
|
|
numElemHeaders++;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if ( (pContext->elemHeaders & XRecordFromClientSequence)
|
|
|
|
|
&&
|
|
|
|
|
(category == XRecordFromClient || category == XRecordClientDied))
|
|
|
|
|
{
|
|
|
|
|
elemHeaderData[numElemHeaders] = pClient->sequence;
|
|
|
|
|
if (recordingClientSwapped)
|
|
|
|
|
swapl(&elemHeaderData[numElemHeaders], n);
|
|
|
|
|
numElemHeaders++;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* adjust reply length */
|
|
|
|
|
|
|
|
|
|
replylen = pRep->length;
|
|
|
|
|
if (recordingClientSwapped) swapl(&replylen, n);
|
2010-07-27 13:02:24 -06:00
|
|
|
|
replylen += numElemHeaders + bytes_to_int32(datalen) +
|
|
|
|
|
bytes_to_int32(futurelen);
|
2006-11-26 11:13:41 -07:00
|
|
|
|
if (recordingClientSwapped) swapl(&replylen, n);
|
|
|
|
|
pRep->length = replylen;
|
|
|
|
|
} /* end if not continued reply */
|
|
|
|
|
|
|
|
|
|
numElemHeaders *= 4;
|
|
|
|
|
|
|
|
|
|
/* if space available >= space needed, buffer the data */
|
|
|
|
|
|
|
|
|
|
if (REPLY_BUF_SIZE - pContext->numBufBytes >= datalen + numElemHeaders)
|
|
|
|
|
{
|
|
|
|
|
if (numElemHeaders)
|
|
|
|
|
{
|
|
|
|
|
memcpy(pContext->replyBuffer + pContext->numBufBytes,
|
|
|
|
|
elemHeaderData, numElemHeaders);
|
|
|
|
|
pContext->numBufBytes += numElemHeaders;
|
|
|
|
|
}
|
|
|
|
|
if (datalen)
|
|
|
|
|
{
|
|
|
|
|
memcpy(pContext->replyBuffer + pContext->numBufBytes,
|
|
|
|
|
data, datalen);
|
|
|
|
|
pContext->numBufBytes += datalen;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
RecordFlushReplyBuffer(pContext, (pointer)elemHeaderData,
|
|
|
|
|
numElemHeaders, (pointer)data, datalen);
|
|
|
|
|
|
|
|
|
|
} /* RecordAProtocolElement */
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* RecordFindClientOnContext
|
|
|
|
|
*
|
|
|
|
|
* Arguments:
|
|
|
|
|
* pContext is the context to search.
|
|
|
|
|
* clientspec is the resource ID mask identifying the client to search
|
|
|
|
|
* for, or XRecordFutureClients.
|
|
|
|
|
* pposition is a pointer to an int, or NULL. See Returns.
|
|
|
|
|
*
|
|
|
|
|
* Returns:
|
|
|
|
|
* The RCAP on which clientspec was found, or NULL if not found on
|
|
|
|
|
* any RCAP on the given context.
|
|
|
|
|
* If pposition was not NULL and the returned RCAP is not NULL,
|
|
|
|
|
* *pposition will be set to the index into the returned the RCAP's
|
|
|
|
|
* pClientIDs array that holds clientspec.
|
|
|
|
|
*
|
|
|
|
|
* Side Effects: none.
|
|
|
|
|
*/
|
|
|
|
|
static RecordClientsAndProtocolPtr
|
|
|
|
|
RecordFindClientOnContext(
|
|
|
|
|
RecordContextPtr pContext,
|
|
|
|
|
XID clientspec,
|
|
|
|
|
int *pposition
|
|
|
|
|
)
|
|
|
|
|
{
|
|
|
|
|
RecordClientsAndProtocolPtr pRCAP;
|
|
|
|
|
|
|
|
|
|
for (pRCAP = pContext->pListOfRCAP; pRCAP; pRCAP = pRCAP->pNextRCAP)
|
|
|
|
|
{
|
|
|
|
|
int i;
|
|
|
|
|
for (i = 0; i < pRCAP->numClients; i++)
|
|
|
|
|
{
|
|
|
|
|
if (pRCAP->pClientIDs[i] == clientspec)
|
|
|
|
|
{
|
|
|
|
|
if (pposition)
|
|
|
|
|
*pposition = i;
|
|
|
|
|
return pRCAP;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
return NULL;
|
|
|
|
|
} /* RecordFindClientOnContext */
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* RecordABigRequest
|
|
|
|
|
*
|
|
|
|
|
* Arguments:
|
|
|
|
|
* pContext is the recording context.
|
|
|
|
|
* client is the client being recorded.
|
|
|
|
|
* stuff is a pointer to the big request of client (see the Big Requests
|
|
|
|
|
* extension for details.)
|
|
|
|
|
*
|
|
|
|
|
* Returns: nothing.
|
|
|
|
|
*
|
|
|
|
|
* Side Effects:
|
|
|
|
|
* The big request is recorded with the correct length field re-inserted.
|
|
|
|
|
*
|
|
|
|
|
* Note: this function exists mainly to make RecordARequest smaller.
|
|
|
|
|
*/
|
|
|
|
|
static void
|
|
|
|
|
RecordABigRequest(RecordContextPtr pContext, ClientPtr client, xReq *stuff)
|
|
|
|
|
{
|
|
|
|
|
CARD32 bigLength;
|
|
|
|
|
char n;
|
|
|
|
|
int bytesLeft;
|
|
|
|
|
|
|
|
|
|
/* note: client->req_len has been frobbed by ReadRequestFromClient
|
|
|
|
|
* (os/io.c) to discount the extra 4 bytes taken by the extended length
|
|
|
|
|
* field in a big request. The actual request length to record is
|
|
|
|
|
* client->req_len + 1 (measured in CARD32s).
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
/* record the request header */
|
|
|
|
|
bytesLeft = client->req_len << 2;
|
|
|
|
|
RecordAProtocolElement(pContext, client, XRecordFromClient,
|
|
|
|
|
(pointer)stuff, SIZEOF(xReq), bytesLeft);
|
|
|
|
|
|
|
|
|
|
/* reinsert the extended length field that was squished out */
|
2010-07-27 13:02:24 -06:00
|
|
|
|
bigLength = client->req_len + bytes_to_int32(sizeof(bigLength));
|
2006-11-26 11:13:41 -07:00
|
|
|
|
if (client->swapped)
|
|
|
|
|
swapl(&bigLength, n);
|
|
|
|
|
RecordAProtocolElement(pContext, client, XRecordFromClient,
|
|
|
|
|
(pointer)&bigLength, sizeof(bigLength), /* continuation */ -1);
|
|
|
|
|
bytesLeft -= sizeof(bigLength);
|
|
|
|
|
|
|
|
|
|
/* record the rest of the request after the length */
|
|
|
|
|
RecordAProtocolElement(pContext, client, XRecordFromClient,
|
|
|
|
|
(pointer)(stuff + 1), bytesLeft, /* continuation */ -1);
|
|
|
|
|
} /* RecordABigRequest */
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* RecordARequest
|
|
|
|
|
*
|
|
|
|
|
* Arguments:
|
|
|
|
|
* client is a client that the server has dispatched a request to by
|
|
|
|
|
* calling client->requestVector[request opcode] .
|
|
|
|
|
* The request is in client->requestBuffer.
|
|
|
|
|
*
|
|
|
|
|
* Returns:
|
|
|
|
|
* Whatever is returned by the "real" Proc function for this request.
|
|
|
|
|
* The "real" Proc function is the function that was in
|
|
|
|
|
* client->requestVector[request opcode] before it was replaced by
|
|
|
|
|
* RecordARequest. (See the function RecordInstallHooks.)
|
|
|
|
|
*
|
|
|
|
|
* Side Effects:
|
|
|
|
|
* The request is recorded by all contexts that have registered this
|
|
|
|
|
* request for this client. The real Proc function is called.
|
|
|
|
|
*/
|
|
|
|
|
static int
|
|
|
|
|
RecordARequest(ClientPtr client)
|
|
|
|
|
{
|
|
|
|
|
RecordContextPtr pContext;
|
|
|
|
|
RecordClientsAndProtocolPtr pRCAP;
|
|
|
|
|
int i;
|
|
|
|
|
RecordClientPrivatePtr pClientPriv;
|
|
|
|
|
REQUEST(xReq);
|
|
|
|
|
int majorop;
|
|
|
|
|
|
|
|
|
|
majorop = stuff->reqType;
|
|
|
|
|
for (i = 0; i < numEnabledContexts; i++)
|
|
|
|
|
{
|
|
|
|
|
pContext = ppAllContexts[i];
|
|
|
|
|
pRCAP = RecordFindClientOnContext(pContext, client->clientAsMask,
|
|
|
|
|
NULL);
|
|
|
|
|
if (pRCAP && pRCAP->pRequestMajorOpSet &&
|
|
|
|
|
RecordIsMemberOfSet(pRCAP->pRequestMajorOpSet, majorop))
|
|
|
|
|
{
|
|
|
|
|
if (majorop <= 127)
|
|
|
|
|
{ /* core request */
|
|
|
|
|
|
|
|
|
|
if (stuff->length == 0)
|
|
|
|
|
RecordABigRequest(pContext, client, stuff);
|
|
|
|
|
else
|
|
|
|
|
RecordAProtocolElement(pContext, client, XRecordFromClient,
|
|
|
|
|
(pointer)stuff, client->req_len << 2, 0);
|
|
|
|
|
}
|
|
|
|
|
else /* extension, check minor opcode */
|
|
|
|
|
{
|
|
|
|
|
int minorop = MinorOpcodeOfRequest(client);
|
|
|
|
|
int numMinOpInfo;
|
|
|
|
|
RecordMinorOpPtr pMinorOpInfo = pRCAP->pRequestMinOpInfo;
|
|
|
|
|
|
|
|
|
|
assert (pMinorOpInfo);
|
|
|
|
|
numMinOpInfo = pMinorOpInfo->count;
|
|
|
|
|
pMinorOpInfo++;
|
|
|
|
|
assert (numMinOpInfo);
|
|
|
|
|
for ( ; numMinOpInfo; numMinOpInfo--, pMinorOpInfo++)
|
|
|
|
|
{
|
|
|
|
|
if (majorop >= pMinorOpInfo->major.first &&
|
|
|
|
|
majorop <= pMinorOpInfo->major.last &&
|
|
|
|
|
RecordIsMemberOfSet(pMinorOpInfo->major.pMinOpSet,
|
|
|
|
|
minorop))
|
|
|
|
|
{
|
|
|
|
|
if (stuff->length == 0)
|
|
|
|
|
RecordABigRequest(pContext, client, stuff);
|
|
|
|
|
else
|
|
|
|
|
RecordAProtocolElement(pContext, client,
|
|
|
|
|
XRecordFromClient, (pointer)stuff,
|
|
|
|
|
client->req_len << 2, 0);
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
} /* end for each minor op info */
|
|
|
|
|
} /* end extension request */
|
|
|
|
|
} /* end this RCAP wants this major opcode */
|
|
|
|
|
} /* end for each context */
|
|
|
|
|
pClientPriv = RecordClientPrivate(client);
|
|
|
|
|
assert(pClientPriv);
|
|
|
|
|
return (* pClientPriv->originalVector[majorop])(client);
|
|
|
|
|
} /* RecordARequest */
|
|
|
|
|
|
|
|
|
|
/* RecordAReply
|
|
|
|
|
*
|
|
|
|
|
* Arguments:
|
|
|
|
|
* pcbl is &ReplyCallback.
|
|
|
|
|
* nulldata is NULL.
|
|
|
|
|
* calldata is a pointer to a ReplyInfoRec (include/os.h)
|
|
|
|
|
* which provides information about replies that are being sent
|
|
|
|
|
* to clients.
|
|
|
|
|
*
|
|
|
|
|
* Returns: nothing.
|
|
|
|
|
*
|
|
|
|
|
* Side Effects:
|
|
|
|
|
* The reply is recorded by all contexts that have registered this
|
|
|
|
|
* reply type for this client. If more data belonging to the same
|
|
|
|
|
* reply is expected, and if the reply is being recorded by any
|
|
|
|
|
* context, pContext->continuedReply is set to 1.
|
|
|
|
|
* If pContext->continuedReply was already 1 and this is the last
|
|
|
|
|
* chunk of data belonging to this reply, it is set to 0.
|
|
|
|
|
*/
|
|
|
|
|
static void
|
|
|
|
|
RecordAReply(CallbackListPtr *pcbl, pointer nulldata, pointer calldata)
|
|
|
|
|
{
|
|
|
|
|
RecordContextPtr pContext;
|
|
|
|
|
RecordClientsAndProtocolPtr pRCAP;
|
|
|
|
|
int eci;
|
|
|
|
|
int majorop;
|
|
|
|
|
ReplyInfoRec *pri = (ReplyInfoRec *)calldata;
|
|
|
|
|
ClientPtr client = pri->client;
|
|
|
|
|
REQUEST(xReq);
|
|
|
|
|
|
|
|
|
|
majorop = stuff->reqType;
|
|
|
|
|
for (eci = 0; eci < numEnabledContexts; eci++)
|
|
|
|
|
{
|
|
|
|
|
pContext = ppAllContexts[eci];
|
|
|
|
|
pRCAP = RecordFindClientOnContext(pContext, client->clientAsMask,
|
|
|
|
|
NULL);
|
|
|
|
|
if (pRCAP)
|
|
|
|
|
{
|
|
|
|
|
if (pContext->continuedReply)
|
|
|
|
|
{
|
|
|
|
|
RecordAProtocolElement(pContext, client, XRecordFromServer,
|
2010-07-27 13:02:24 -06:00
|
|
|
|
(pointer)pri->replyData, pri->dataLenBytes, /* continuation */ -1);
|
2006-11-26 11:13:41 -07:00
|
|
|
|
if (!pri->bytesRemaining)
|
|
|
|
|
pContext->continuedReply = 0;
|
|
|
|
|
}
|
|
|
|
|
else if (pri->startOfReply && pRCAP->pReplyMajorOpSet &&
|
|
|
|
|
RecordIsMemberOfSet(pRCAP->pReplyMajorOpSet, majorop))
|
|
|
|
|
{
|
|
|
|
|
if (majorop <= 127)
|
|
|
|
|
{ /* core reply */
|
|
|
|
|
RecordAProtocolElement(pContext, client, XRecordFromServer,
|
2010-07-27 13:02:24 -06:00
|
|
|
|
(pointer)pri->replyData, pri->dataLenBytes, pri->bytesRemaining);
|
2006-11-26 11:13:41 -07:00
|
|
|
|
if (pri->bytesRemaining)
|
|
|
|
|
pContext->continuedReply = 1;
|
|
|
|
|
}
|
|
|
|
|
else /* extension, check minor opcode */
|
|
|
|
|
{
|
|
|
|
|
int minorop = MinorOpcodeOfRequest(client);
|
|
|
|
|
int numMinOpInfo;
|
|
|
|
|
RecordMinorOpPtr pMinorOpInfo = pRCAP->pReplyMinOpInfo;
|
|
|
|
|
assert (pMinorOpInfo);
|
|
|
|
|
numMinOpInfo = pMinorOpInfo->count;
|
|
|
|
|
pMinorOpInfo++;
|
|
|
|
|
assert (numMinOpInfo);
|
|
|
|
|
for ( ; numMinOpInfo; numMinOpInfo--, pMinorOpInfo++)
|
|
|
|
|
{
|
|
|
|
|
if (majorop >= pMinorOpInfo->major.first &&
|
|
|
|
|
majorop <= pMinorOpInfo->major.last &&
|
|
|
|
|
RecordIsMemberOfSet(pMinorOpInfo->major.pMinOpSet,
|
|
|
|
|
minorop))
|
|
|
|
|
{
|
|
|
|
|
RecordAProtocolElement(pContext, client,
|
2010-07-27 13:02:24 -06:00
|
|
|
|
XRecordFromServer, (pointer)pri->replyData,
|
2006-11-26 11:13:41 -07:00
|
|
|
|
pri->dataLenBytes, pri->bytesRemaining);
|
|
|
|
|
if (pri->bytesRemaining)
|
|
|
|
|
pContext->continuedReply = 1;
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
} /* end for each minor op info */
|
|
|
|
|
} /* end extension reply */
|
|
|
|
|
} /* end continued reply vs. start of reply */
|
|
|
|
|
} /* end client is registered on this context */
|
|
|
|
|
} /* end for each context */
|
|
|
|
|
} /* RecordAReply */
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* RecordADeliveredEventOrError
|
|
|
|
|
*
|
|
|
|
|
* Arguments:
|
|
|
|
|
* pcbl is &EventCallback.
|
|
|
|
|
* nulldata is NULL.
|
|
|
|
|
* calldata is a pointer to a EventInfoRec (include/dix.h)
|
|
|
|
|
* which provides information about events that are being sent
|
|
|
|
|
* to clients.
|
|
|
|
|
*
|
|
|
|
|
* Returns: nothing.
|
|
|
|
|
*
|
|
|
|
|
* Side Effects:
|
|
|
|
|
* The event or error is recorded by all contexts that have registered
|
|
|
|
|
* it for this client.
|
|
|
|
|
*/
|
|
|
|
|
static void
|
|
|
|
|
RecordADeliveredEventOrError(CallbackListPtr *pcbl, pointer nulldata, pointer calldata)
|
|
|
|
|
{
|
|
|
|
|
EventInfoRec *pei = (EventInfoRec *)calldata;
|
|
|
|
|
RecordContextPtr pContext;
|
|
|
|
|
RecordClientsAndProtocolPtr pRCAP;
|
|
|
|
|
int eci; /* enabled context index */
|
|
|
|
|
ClientPtr pClient = pei->client;
|
|
|
|
|
|
|
|
|
|
for (eci = 0; eci < numEnabledContexts; eci++)
|
|
|
|
|
{
|
|
|
|
|
pContext = ppAllContexts[eci];
|
|
|
|
|
pRCAP = RecordFindClientOnContext(pContext, pClient->clientAsMask,
|
|
|
|
|
NULL);
|
|
|
|
|
if (pRCAP && (pRCAP->pDeliveredEventSet || pRCAP->pErrorSet))
|
|
|
|
|
{
|
|
|
|
|
int ev; /* event index */
|
|
|
|
|
xEvent *pev = pei->events;
|
|
|
|
|
for (ev = 0; ev < pei->count; ev++, pev++)
|
|
|
|
|
{
|
|
|
|
|
int recordit = 0;
|
|
|
|
|
if (pRCAP->pErrorSet)
|
|
|
|
|
{
|
|
|
|
|
recordit = RecordIsMemberOfSet(pRCAP->pErrorSet,
|
|
|
|
|
((xError *)(pev))->errorCode);
|
|
|
|
|
}
|
|
|
|
|
else if (pRCAP->pDeliveredEventSet)
|
|
|
|
|
{
|
|
|
|
|
recordit = RecordIsMemberOfSet(pRCAP->pDeliveredEventSet,
|
|
|
|
|
pev->u.u.type & 0177);
|
|
|
|
|
}
|
|
|
|
|
if (recordit)
|
|
|
|
|
{
|
|
|
|
|
xEvent swappedEvent;
|
|
|
|
|
xEvent *pEvToRecord = pev;
|
|
|
|
|
|
|
|
|
|
if (pClient->swapped)
|
|
|
|
|
{
|
|
|
|
|
(*EventSwapVector[pev->u.u.type & 0177])
|
|
|
|
|
(pev, &swappedEvent);
|
|
|
|
|
pEvToRecord = &swappedEvent;
|
|
|
|
|
|
|
|
|
|
}
|
|
|
|
|
RecordAProtocolElement(pContext, pClient,
|
|
|
|
|
XRecordFromServer, pEvToRecord, SIZEOF(xEvent), 0);
|
|
|
|
|
}
|
|
|
|
|
} /* end for each event */
|
|
|
|
|
} /* end this client is on this context */
|
|
|
|
|
} /* end for each enabled context */
|
|
|
|
|
} /* RecordADeliveredEventOrError */
|
|
|
|
|
|
|
|
|
|
|
2010-07-27 13:02:24 -06:00
|
|
|
|
static void
|
|
|
|
|
RecordSendProtocolEvents(RecordClientsAndProtocolPtr pRCAP,
|
|
|
|
|
RecordContextPtr pContext,
|
|
|
|
|
xEvent* pev, int count)
|
|
|
|
|
{
|
|
|
|
|
int ev; /* event index */
|
|
|
|
|
|
|
|
|
|
for (ev = 0; ev < count; ev++, pev++)
|
|
|
|
|
{
|
|
|
|
|
if (RecordIsMemberOfSet(pRCAP->pDeviceEventSet,
|
|
|
|
|
pev->u.u.type & 0177))
|
|
|
|
|
{
|
|
|
|
|
xEvent swappedEvent;
|
|
|
|
|
xEvent *pEvToRecord = pev;
|
|
|
|
|
#ifdef PANORAMIX
|
|
|
|
|
xEvent shiftedEvent;
|
|
|
|
|
|
|
|
|
|
if (!noPanoramiXExtension &&
|
|
|
|
|
(pev->u.u.type == MotionNotify ||
|
|
|
|
|
pev->u.u.type == ButtonPress ||
|
|
|
|
|
pev->u.u.type == ButtonRelease ||
|
|
|
|
|
pev->u.u.type == KeyPress ||
|
|
|
|
|
pev->u.u.type == KeyRelease)) {
|
|
|
|
|
int scr = XineramaGetCursorScreen(inputInfo.pointer);
|
|
|
|
|
memcpy(&shiftedEvent, pev, sizeof(xEvent));
|
|
|
|
|
shiftedEvent.u.keyButtonPointer.rootX +=
|
2010-12-05 08:36:02 -07:00
|
|
|
|
screenInfo.screens[scr]->x -
|
|
|
|
|
screenInfo.screens[0]->x;
|
2010-07-27 13:02:24 -06:00
|
|
|
|
shiftedEvent.u.keyButtonPointer.rootY +=
|
2010-12-05 08:36:02 -07:00
|
|
|
|
screenInfo.screens[scr]->y -
|
|
|
|
|
screenInfo.screens[0]->y;
|
2010-07-27 13:02:24 -06:00
|
|
|
|
pEvToRecord = &shiftedEvent;
|
|
|
|
|
}
|
|
|
|
|
#endif /* PANORAMIX */
|
|
|
|
|
|
|
|
|
|
if (pContext->pRecordingClient->swapped)
|
|
|
|
|
{
|
|
|
|
|
(*EventSwapVector[pEvToRecord->u.u.type & 0177])
|
|
|
|
|
(pEvToRecord, &swappedEvent);
|
|
|
|
|
pEvToRecord = &swappedEvent;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
RecordAProtocolElement(pContext, NULL,
|
|
|
|
|
XRecordFromServer, pEvToRecord, SIZEOF(xEvent), 0);
|
|
|
|
|
/* make sure device events get flushed in the absence
|
|
|
|
|
* of other client activity
|
|
|
|
|
*/
|
|
|
|
|
SetCriticalOutputPending();
|
|
|
|
|
}
|
|
|
|
|
} /* end for each event */
|
|
|
|
|
|
|
|
|
|
} /* RecordADeviceEvent */
|
|
|
|
|
|
2006-11-26 11:13:41 -07:00
|
|
|
|
/* RecordADeviceEvent
|
|
|
|
|
*
|
|
|
|
|
* Arguments:
|
|
|
|
|
* pcbl is &DeviceEventCallback.
|
|
|
|
|
* nulldata is NULL.
|
|
|
|
|
* calldata is a pointer to a DeviceEventInfoRec (include/dix.h)
|
|
|
|
|
* which provides information about device events that occur.
|
|
|
|
|
*
|
|
|
|
|
* Returns: nothing.
|
|
|
|
|
*
|
|
|
|
|
* Side Effects:
|
|
|
|
|
* The device event is recorded by all contexts that have registered
|
|
|
|
|
* it for this client.
|
|
|
|
|
*/
|
|
|
|
|
static void
|
|
|
|
|
RecordADeviceEvent(CallbackListPtr *pcbl, pointer nulldata, pointer calldata)
|
|
|
|
|
{
|
|
|
|
|
DeviceEventInfoRec *pei = (DeviceEventInfoRec *)calldata;
|
|
|
|
|
RecordContextPtr pContext;
|
|
|
|
|
RecordClientsAndProtocolPtr pRCAP;
|
|
|
|
|
int eci; /* enabled context index */
|
|
|
|
|
|
|
|
|
|
for (eci = 0; eci < numEnabledContexts; eci++)
|
|
|
|
|
{
|
|
|
|
|
pContext = ppAllContexts[eci];
|
|
|
|
|
for (pRCAP = pContext->pListOfRCAP; pRCAP; pRCAP = pRCAP->pNextRCAP)
|
|
|
|
|
{
|
|
|
|
|
if (pRCAP->pDeviceEventSet)
|
|
|
|
|
{
|
2010-07-27 13:02:24 -06:00
|
|
|
|
int count;
|
|
|
|
|
xEvent *xi_events = NULL;
|
2006-11-26 11:13:41 -07:00
|
|
|
|
|
2010-07-27 13:02:24 -06:00
|
|
|
|
/* TODO check return values */
|
|
|
|
|
if (IsMaster(pei->device))
|
|
|
|
|
{
|
2011-11-05 07:32:40 -06:00
|
|
|
|
xEvent *core_events;
|
|
|
|
|
EventToCore(pei->event, &core_events, &count);
|
|
|
|
|
RecordSendProtocolEvents(pRCAP, pContext, core_events,
|
|
|
|
|
count);
|
|
|
|
|
free(core_events);
|
2010-07-27 13:02:24 -06:00
|
|
|
|
}
|
2006-11-26 11:13:41 -07:00
|
|
|
|
|
2010-07-27 13:02:24 -06:00
|
|
|
|
EventToXI(pei->event, &xi_events, &count);
|
|
|
|
|
RecordSendProtocolEvents(pRCAP, pContext, xi_events, count);
|
2010-12-05 08:36:02 -07:00
|
|
|
|
free(xi_events);
|
2006-11-26 11:13:41 -07:00
|
|
|
|
} /* end this RCAP selects device events */
|
|
|
|
|
} /* end for each RCAP on this context */
|
|
|
|
|
} /* end for each enabled context */
|
2010-07-27 13:02:24 -06:00
|
|
|
|
}
|
2006-11-26 11:13:41 -07:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* RecordFlushAllContexts
|
|
|
|
|
*
|
|
|
|
|
* Arguments:
|
|
|
|
|
* pcbl is &FlushCallback.
|
|
|
|
|
* nulldata and calldata are NULL.
|
|
|
|
|
*
|
|
|
|
|
* Returns: nothing.
|
|
|
|
|
*
|
|
|
|
|
* Side Effects:
|
|
|
|
|
* All buffered reply data of all enabled contexts is written to
|
|
|
|
|
* the recording clients.
|
|
|
|
|
*/
|
|
|
|
|
static void
|
|
|
|
|
RecordFlushAllContexts(
|
|
|
|
|
CallbackListPtr *pcbl,
|
|
|
|
|
pointer nulldata,
|
|
|
|
|
pointer calldata
|
|
|
|
|
)
|
|
|
|
|
{
|
|
|
|
|
int eci; /* enabled context index */
|
|
|
|
|
RecordContextPtr pContext;
|
|
|
|
|
|
|
|
|
|
for (eci = 0; eci < numEnabledContexts; eci++)
|
|
|
|
|
{
|
|
|
|
|
pContext = ppAllContexts[eci];
|
|
|
|
|
|
|
|
|
|
/* In most cases we leave it to RecordFlushReplyBuffer to make
|
|
|
|
|
* this check, but this function could be called very often, so we
|
|
|
|
|
* check before calling hoping to save the function call cost
|
|
|
|
|
* most of the time.
|
|
|
|
|
*/
|
|
|
|
|
if (pContext->numBufBytes)
|
|
|
|
|
RecordFlushReplyBuffer(ppAllContexts[eci], NULL, 0, NULL, 0);
|
|
|
|
|
}
|
|
|
|
|
} /* RecordFlushAllContexts */
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* RecordInstallHooks
|
|
|
|
|
*
|
|
|
|
|
* Arguments:
|
|
|
|
|
* pRCAP is an RCAP on an enabled or being-enabled context.
|
|
|
|
|
* oneclient can be zero or the resource ID mask identifying a client.
|
|
|
|
|
*
|
|
|
|
|
* Returns: BadAlloc if a memory allocation error occurred, else Success.
|
|
|
|
|
*
|
|
|
|
|
* Side Effects:
|
|
|
|
|
* Recording hooks needed by RCAP are installed.
|
|
|
|
|
* If oneclient is zero, recording hooks needed for all clients and
|
|
|
|
|
* protocol on the RCAP are installed. If oneclient is non-zero,
|
|
|
|
|
* only those hooks needed for the specified client are installed.
|
|
|
|
|
*
|
|
|
|
|
* Client requestVectors may be altered. numEnabledRCAPs will be
|
|
|
|
|
* incremented if oneclient == 0. Callbacks may be added to
|
|
|
|
|
* various callback lists.
|
|
|
|
|
*/
|
|
|
|
|
static int
|
|
|
|
|
RecordInstallHooks(RecordClientsAndProtocolPtr pRCAP, XID oneclient)
|
|
|
|
|
{
|
|
|
|
|
int i = 0;
|
|
|
|
|
XID client;
|
|
|
|
|
|
|
|
|
|
if (oneclient)
|
|
|
|
|
client = oneclient;
|
|
|
|
|
else
|
|
|
|
|
client = pRCAP->numClients ? pRCAP->pClientIDs[i++] : 0;
|
|
|
|
|
|
|
|
|
|
while (client)
|
|
|
|
|
{
|
|
|
|
|
if (client != XRecordFutureClients)
|
|
|
|
|
{
|
|
|
|
|
if (pRCAP->pRequestMajorOpSet)
|
|
|
|
|
{
|
|
|
|
|
RecordSetIteratePtr pIter = NULL;
|
|
|
|
|
RecordSetInterval interval;
|
|
|
|
|
ClientPtr pClient = clients[CLIENT_ID(client)];
|
|
|
|
|
|
|
|
|
|
if (pClient && !RecordClientPrivate(pClient))
|
|
|
|
|
{
|
|
|
|
|
RecordClientPrivatePtr pClientPriv;
|
|
|
|
|
/* no Record proc vector; allocate one */
|
|
|
|
|
pClientPriv = (RecordClientPrivatePtr)
|
2010-12-05 08:36:02 -07:00
|
|
|
|
malloc(sizeof(RecordClientPrivateRec));
|
2006-11-26 11:13:41 -07:00
|
|
|
|
if (!pClientPriv)
|
|
|
|
|
return BadAlloc;
|
|
|
|
|
/* copy old proc vector to new */
|
|
|
|
|
memcpy(pClientPriv->recordVector, pClient->requestVector,
|
|
|
|
|
sizeof (pClientPriv->recordVector));
|
|
|
|
|
pClientPriv->originalVector = pClient->requestVector;
|
2008-11-02 08:26:08 -07:00
|
|
|
|
dixSetPrivate(&pClient->devPrivates,
|
|
|
|
|
RecordClientPrivateKey, pClientPriv);
|
2006-11-26 11:13:41 -07:00
|
|
|
|
pClient->requestVector = pClientPriv->recordVector;
|
|
|
|
|
}
|
|
|
|
|
while ((pIter = RecordIterateSet(pRCAP->pRequestMajorOpSet,
|
|
|
|
|
pIter, &interval)))
|
|
|
|
|
{
|
|
|
|
|
unsigned int j;
|
|
|
|
|
for (j = interval.first; j <= interval.last; j++)
|
|
|
|
|
pClient->requestVector[j] = RecordARequest;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
if (oneclient)
|
|
|
|
|
client = 0;
|
|
|
|
|
else
|
|
|
|
|
client = (i < pRCAP->numClients) ? pRCAP->pClientIDs[i++] : 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
assert(numEnabledRCAPs >= 0);
|
|
|
|
|
if (!oneclient && ++numEnabledRCAPs == 1)
|
|
|
|
|
{ /* we're enabling the first context */
|
|
|
|
|
if (!AddCallback(&EventCallback, RecordADeliveredEventOrError, NULL))
|
|
|
|
|
return BadAlloc;
|
|
|
|
|
if (!AddCallback(&DeviceEventCallback, RecordADeviceEvent, NULL))
|
|
|
|
|
return BadAlloc;
|
|
|
|
|
if (!AddCallback(&ReplyCallback, RecordAReply, NULL))
|
|
|
|
|
return BadAlloc;
|
|
|
|
|
if (!AddCallback(&FlushCallback, RecordFlushAllContexts, NULL))
|
|
|
|
|
return BadAlloc;
|
|
|
|
|
/* Alternate context flushing scheme: delete the line above
|
|
|
|
|
* and call RegisterBlockAndWakeupHandlers here passing
|
|
|
|
|
* RecordFlushAllContexts. Is this any better?
|
|
|
|
|
*/
|
|
|
|
|
}
|
|
|
|
|
return Success;
|
|
|
|
|
} /* RecordInstallHooks */
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* RecordUninstallHooks
|
|
|
|
|
*
|
|
|
|
|
* Arguments:
|
|
|
|
|
* pRCAP is an RCAP on an enabled or being-disabled context.
|
|
|
|
|
* oneclient can be zero or the resource ID mask identifying a client.
|
|
|
|
|
*
|
|
|
|
|
* Returns: nothing.
|
|
|
|
|
*
|
|
|
|
|
* Side Effects:
|
|
|
|
|
* Recording hooks needed by RCAP may be uninstalled.
|
|
|
|
|
* If oneclient is zero, recording hooks needed for all clients and
|
|
|
|
|
* protocol on the RCAP may be uninstalled. If oneclient is non-zero,
|
|
|
|
|
* only those hooks needed for the specified client may be uninstalled.
|
|
|
|
|
*
|
|
|
|
|
* Client requestVectors may be altered. numEnabledRCAPs will be
|
|
|
|
|
* decremented if oneclient == 0. Callbacks may be deleted from
|
|
|
|
|
* various callback lists.
|
|
|
|
|
*/
|
|
|
|
|
static void
|
|
|
|
|
RecordUninstallHooks(RecordClientsAndProtocolPtr pRCAP, XID oneclient)
|
|
|
|
|
{
|
|
|
|
|
int i = 0;
|
|
|
|
|
XID client;
|
|
|
|
|
|
|
|
|
|
if (oneclient)
|
|
|
|
|
client = oneclient;
|
|
|
|
|
else
|
|
|
|
|
client = pRCAP->numClients ? pRCAP->pClientIDs[i++] : 0;
|
|
|
|
|
|
|
|
|
|
while (client)
|
|
|
|
|
{
|
|
|
|
|
if (client != XRecordFutureClients)
|
|
|
|
|
{
|
|
|
|
|
if (pRCAP->pRequestMajorOpSet)
|
|
|
|
|
{
|
|
|
|
|
ClientPtr pClient = clients[CLIENT_ID(client)];
|
|
|
|
|
int c;
|
|
|
|
|
Bool otherRCAPwantsProcVector = FALSE;
|
2010-12-05 08:36:02 -07:00
|
|
|
|
RecordClientPrivatePtr pClientPriv = NULL;
|
2006-11-26 11:13:41 -07:00
|
|
|
|
|
2010-12-05 08:36:02 -07:00
|
|
|
|
assert (pClient);
|
|
|
|
|
pClientPriv = RecordClientPrivate(pClient);
|
|
|
|
|
assert (pClientPriv);
|
2006-11-26 11:13:41 -07:00
|
|
|
|
memcpy(pClientPriv->recordVector, pClientPriv->originalVector,
|
|
|
|
|
sizeof (pClientPriv->recordVector));
|
|
|
|
|
|
|
|
|
|
for (c = 0; c < numEnabledContexts; c++)
|
|
|
|
|
{
|
|
|
|
|
RecordClientsAndProtocolPtr pOtherRCAP;
|
|
|
|
|
RecordContextPtr pContext = ppAllContexts[c];
|
|
|
|
|
|
|
|
|
|
if (pContext == pRCAP->pContext) continue;
|
|
|
|
|
pOtherRCAP = RecordFindClientOnContext(pContext, client,
|
|
|
|
|
NULL);
|
|
|
|
|
if (pOtherRCAP && pOtherRCAP->pRequestMajorOpSet)
|
|
|
|
|
{
|
|
|
|
|
RecordSetIteratePtr pIter = NULL;
|
|
|
|
|
RecordSetInterval interval;
|
|
|
|
|
|
|
|
|
|
otherRCAPwantsProcVector = TRUE;
|
|
|
|
|
while ((pIter = RecordIterateSet(
|
|
|
|
|
pOtherRCAP->pRequestMajorOpSet,
|
|
|
|
|
pIter, &interval)))
|
|
|
|
|
{
|
|
|
|
|
unsigned int j;
|
|
|
|
|
for (j = interval.first; j <= interval.last; j++)
|
|
|
|
|
pClient->requestVector[j] = RecordARequest;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
if (!otherRCAPwantsProcVector)
|
|
|
|
|
{ /* nobody needs it, so free it */
|
|
|
|
|
pClient->requestVector = pClientPriv->originalVector;
|
2008-11-02 08:26:08 -07:00
|
|
|
|
dixSetPrivate(&pClient->devPrivates,
|
|
|
|
|
RecordClientPrivateKey, NULL);
|
2010-12-05 08:36:02 -07:00
|
|
|
|
free(pClientPriv);
|
2006-11-26 11:13:41 -07:00
|
|
|
|
}
|
|
|
|
|
} /* end if this RCAP specifies any requests */
|
|
|
|
|
} /* end if not future clients */
|
|
|
|
|
if (oneclient)
|
|
|
|
|
client = 0;
|
|
|
|
|
else
|
|
|
|
|
client = (i < pRCAP->numClients) ? pRCAP->pClientIDs[i++] : 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
assert(numEnabledRCAPs >= 1);
|
|
|
|
|
if (!oneclient && --numEnabledRCAPs == 0)
|
|
|
|
|
{ /* we're disabling the last context */
|
|
|
|
|
DeleteCallback(&EventCallback, RecordADeliveredEventOrError, NULL);
|
|
|
|
|
DeleteCallback(&DeviceEventCallback, RecordADeviceEvent, NULL);
|
|
|
|
|
DeleteCallback(&ReplyCallback, RecordAReply, NULL);
|
|
|
|
|
DeleteCallback(&FlushCallback, RecordFlushAllContexts, NULL);
|
|
|
|
|
/* Alternate context flushing scheme: delete the line above
|
|
|
|
|
* and call RemoveBlockAndWakeupHandlers here passing
|
|
|
|
|
* RecordFlushAllContexts. Is this any better?
|
|
|
|
|
*/
|
|
|
|
|
/* Having deleted the callback, call it one last time. -gildea */
|
|
|
|
|
RecordFlushAllContexts(&FlushCallback, NULL, NULL);
|
|
|
|
|
}
|
|
|
|
|
} /* RecordUninstallHooks */
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* RecordDeleteClientFromRCAP
|
|
|
|
|
*
|
|
|
|
|
* Arguments:
|
|
|
|
|
* pRCAP is an RCAP to delete the client from.
|
|
|
|
|
* position is the index into the array pRCAP->pClientIDs of the
|
|
|
|
|
* client to delete.
|
|
|
|
|
*
|
|
|
|
|
* Returns: nothing.
|
|
|
|
|
*
|
|
|
|
|
* Side Effects:
|
|
|
|
|
* Recording hooks needed by client will be uninstalled if the context
|
|
|
|
|
* is enabled. The designated client will be removed from the
|
|
|
|
|
* pRCAP->pClientIDs array. If it was the only client on the RCAP,
|
|
|
|
|
* the RCAP is removed from the context and freed. (Invariant: RCAPs
|
|
|
|
|
* have at least one client.)
|
|
|
|
|
*/
|
|
|
|
|
static void
|
|
|
|
|
RecordDeleteClientFromRCAP(RecordClientsAndProtocolPtr pRCAP, int position)
|
|
|
|
|
{
|
|
|
|
|
if (pRCAP->pContext->pRecordingClient)
|
|
|
|
|
RecordUninstallHooks(pRCAP, pRCAP->pClientIDs[position]);
|
|
|
|
|
if (position != pRCAP->numClients - 1)
|
|
|
|
|
pRCAP->pClientIDs[position] = pRCAP->pClientIDs[pRCAP->numClients - 1];
|
|
|
|
|
if (--pRCAP->numClients == 0)
|
|
|
|
|
{ /* no more clients; remove RCAP from context's list */
|
|
|
|
|
RecordContextPtr pContext = pRCAP->pContext;
|
|
|
|
|
if (pContext->pRecordingClient)
|
|
|
|
|
RecordUninstallHooks(pRCAP, 0);
|
|
|
|
|
if (pContext->pListOfRCAP == pRCAP)
|
|
|
|
|
pContext->pListOfRCAP = pRCAP->pNextRCAP;
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
RecordClientsAndProtocolPtr prevRCAP;
|
|
|
|
|
for (prevRCAP = pContext->pListOfRCAP;
|
|
|
|
|
prevRCAP->pNextRCAP != pRCAP;
|
|
|
|
|
prevRCAP = prevRCAP->pNextRCAP)
|
|
|
|
|
;
|
|
|
|
|
prevRCAP->pNextRCAP = pRCAP->pNextRCAP;
|
|
|
|
|
}
|
|
|
|
|
/* free the RCAP */
|
|
|
|
|
if (pRCAP->clientIDsSeparatelyAllocated)
|
2010-12-05 08:36:02 -07:00
|
|
|
|
free(pRCAP->pClientIDs);
|
|
|
|
|
free(pRCAP);
|
2006-11-26 11:13:41 -07:00
|
|
|
|
}
|
|
|
|
|
} /* RecordDeleteClientFromRCAP */
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* RecordAddClientToRCAP
|
|
|
|
|
*
|
|
|
|
|
* Arguments:
|
|
|
|
|
* pRCAP is an RCAP to add the client to.
|
|
|
|
|
* clientspec is the resource ID mask identifying a client, or
|
|
|
|
|
* XRecordFutureClients.
|
|
|
|
|
*
|
|
|
|
|
* Returns: nothing.
|
|
|
|
|
*
|
|
|
|
|
* Side Effects:
|
|
|
|
|
* Recording hooks needed by client will be installed if the context
|
|
|
|
|
* is enabled. The designated client will be added to the
|
|
|
|
|
* pRCAP->pClientIDs array, which may be realloced.
|
|
|
|
|
* pRCAP->clientIDsSeparatelyAllocated may be set to 1 if there
|
|
|
|
|
* is no more room to hold clients internal to the RCAP.
|
|
|
|
|
*/
|
|
|
|
|
static void
|
|
|
|
|
RecordAddClientToRCAP(RecordClientsAndProtocolPtr pRCAP, XID clientspec)
|
|
|
|
|
{
|
|
|
|
|
if (pRCAP->numClients == pRCAP->sizeClients)
|
|
|
|
|
{
|
|
|
|
|
if (pRCAP->clientIDsSeparatelyAllocated)
|
|
|
|
|
{
|
2010-12-05 08:36:02 -07:00
|
|
|
|
XID *pNewIDs = (XID *)realloc(pRCAP->pClientIDs,
|
2006-11-26 11:13:41 -07:00
|
|
|
|
(pRCAP->sizeClients + CLIENT_ARRAY_GROWTH_INCREMENT) *
|
|
|
|
|
sizeof(XID));
|
|
|
|
|
if (!pNewIDs)
|
|
|
|
|
return;
|
|
|
|
|
pRCAP->pClientIDs = pNewIDs;
|
|
|
|
|
pRCAP->sizeClients += CLIENT_ARRAY_GROWTH_INCREMENT;
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
2010-12-05 08:36:02 -07:00
|
|
|
|
XID *pNewIDs = (XID *)malloc((pRCAP->sizeClients +
|
2006-11-26 11:13:41 -07:00
|
|
|
|
CLIENT_ARRAY_GROWTH_INCREMENT) * sizeof(XID));
|
|
|
|
|
if (!pNewIDs)
|
|
|
|
|
return;
|
|
|
|
|
memcpy(pNewIDs, pRCAP->pClientIDs, pRCAP->numClients *sizeof(XID));
|
|
|
|
|
pRCAP->pClientIDs = pNewIDs;
|
|
|
|
|
pRCAP->sizeClients += CLIENT_ARRAY_GROWTH_INCREMENT;
|
|
|
|
|
pRCAP->clientIDsSeparatelyAllocated = 1;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
pRCAP->pClientIDs[pRCAP->numClients++] = clientspec;
|
|
|
|
|
if (pRCAP->pContext->pRecordingClient)
|
|
|
|
|
RecordInstallHooks(pRCAP, clientspec);
|
|
|
|
|
} /* RecordDeleteClientFromRCAP */
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* RecordDeleteClientFromContext
|
|
|
|
|
*
|
|
|
|
|
* Arguments:
|
|
|
|
|
* pContext is the context to delete from.
|
|
|
|
|
* clientspec is the resource ID mask identifying a client, or
|
|
|
|
|
* XRecordFutureClients.
|
|
|
|
|
*
|
|
|
|
|
* Returns: nothing.
|
|
|
|
|
*
|
|
|
|
|
* Side Effects:
|
|
|
|
|
* If clientspec is on any RCAP of the context, it is deleted from that
|
|
|
|
|
* RCAP. (A given clientspec can only be on one RCAP of a context.)
|
|
|
|
|
*/
|
|
|
|
|
static void
|
|
|
|
|
RecordDeleteClientFromContext(RecordContextPtr pContext, XID clientspec)
|
|
|
|
|
{
|
|
|
|
|
RecordClientsAndProtocolPtr pRCAP;
|
|
|
|
|
int position;
|
|
|
|
|
|
|
|
|
|
if ((pRCAP = RecordFindClientOnContext(pContext, clientspec, &position)))
|
|
|
|
|
RecordDeleteClientFromRCAP(pRCAP, position);
|
|
|
|
|
} /* RecordDeleteClientFromContext */
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* RecordSanityCheckClientSpecifiers
|
|
|
|
|
*
|
|
|
|
|
* Arguments:
|
|
|
|
|
* clientspecs is an array of alleged CLIENTSPECs passed by the client.
|
|
|
|
|
* nspecs is the number of elements in clientspecs.
|
|
|
|
|
* errorspec, if non-zero, is the resource id base of a client that
|
|
|
|
|
* must not appear in clienspecs.
|
|
|
|
|
*
|
|
|
|
|
* Returns: BadMatch if any of the clientspecs are invalid, else Success.
|
|
|
|
|
*
|
|
|
|
|
* Side Effects: none.
|
|
|
|
|
*/
|
|
|
|
|
static int
|
2010-07-27 13:02:24 -06:00
|
|
|
|
RecordSanityCheckClientSpecifiers(ClientPtr client, XID *clientspecs, int nspecs, XID errorspec)
|
2006-11-26 11:13:41 -07:00
|
|
|
|
{
|
|
|
|
|
int i;
|
|
|
|
|
int clientIndex;
|
2010-07-27 13:02:24 -06:00
|
|
|
|
int rc;
|
|
|
|
|
pointer value;
|
2006-11-26 11:13:41 -07:00
|
|
|
|
|
|
|
|
|
for (i = 0; i < nspecs; i++)
|
|
|
|
|
{
|
|
|
|
|
if (clientspecs[i] == XRecordCurrentClients ||
|
|
|
|
|
clientspecs[i] == XRecordFutureClients ||
|
|
|
|
|
clientspecs[i] == XRecordAllClients)
|
|
|
|
|
continue;
|
|
|
|
|
if (errorspec && (CLIENT_BITS(clientspecs[i]) == errorspec) )
|
|
|
|
|
return BadMatch;
|
|
|
|
|
clientIndex = CLIENT_ID(clientspecs[i]);
|
|
|
|
|
if (clientIndex && clients[clientIndex] &&
|
|
|
|
|
clients[clientIndex]->clientState == ClientStateRunning)
|
|
|
|
|
{
|
|
|
|
|
if (clientspecs[i] == clients[clientIndex]->clientAsMask)
|
|
|
|
|
continue;
|
2010-07-27 13:02:24 -06:00
|
|
|
|
rc = dixLookupResourceByClass(&value, clientspecs[i], RC_ANY,
|
|
|
|
|
client, DixGetAttrAccess);
|
|
|
|
|
if (rc != Success)
|
|
|
|
|
return rc;
|
2006-11-26 11:13:41 -07:00
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
return BadMatch;
|
|
|
|
|
}
|
|
|
|
|
return Success;
|
|
|
|
|
} /* RecordSanityCheckClientSpecifiers */
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* RecordCanonicalizeClientSpecifiers
|
|
|
|
|
*
|
|
|
|
|
* Arguments:
|
|
|
|
|
* pClientspecs is an array of CLIENTSPECs that have been sanity
|
|
|
|
|
* checked.
|
|
|
|
|
* pNumClientspecs is a pointer to the number of elements in pClientspecs.
|
|
|
|
|
* excludespec, if non-zero, is the resource id base of a client that
|
|
|
|
|
* should not be included in the expansion of XRecordAllClients or
|
|
|
|
|
* XRecordCurrentClients.
|
|
|
|
|
*
|
|
|
|
|
* Returns:
|
|
|
|
|
* A pointer to an array of CLIENTSPECs that is the same as the
|
|
|
|
|
* passed array with the following modifications:
|
|
|
|
|
* - all but the client id bits of resource IDs are stripped off.
|
|
|
|
|
* - duplicates removed.
|
|
|
|
|
* - XRecordAllClients expanded to a list of all currently connected
|
|
|
|
|
* clients + XRecordFutureClients - excludespec (if non-zero)
|
|
|
|
|
* - XRecordCurrentClients expanded to a list of all currently
|
|
|
|
|
* connected clients - excludespec (if non-zero)
|
|
|
|
|
* The returned array may be the passed array modified in place, or
|
2010-12-05 08:36:02 -07:00
|
|
|
|
* it may be an malloc'ed array. The caller should keep a pointer to the
|
2006-11-26 11:13:41 -07:00
|
|
|
|
* original array and free the returned array if it is different.
|
|
|
|
|
*
|
|
|
|
|
* *pNumClientspecs is set to the number of elements in the returned
|
|
|
|
|
* array.
|
|
|
|
|
*
|
|
|
|
|
* Side Effects:
|
|
|
|
|
* pClientspecs may be modified in place.
|
|
|
|
|
*/
|
|
|
|
|
static XID *
|
|
|
|
|
RecordCanonicalizeClientSpecifiers(XID *pClientspecs, int *pNumClientspecs, XID excludespec)
|
|
|
|
|
{
|
|
|
|
|
int i;
|
|
|
|
|
int numClients = *pNumClientspecs;
|
|
|
|
|
|
|
|
|
|
/* first pass strips off the resource index bits, leaving just the
|
|
|
|
|
* client id bits. This makes searching for a particular client simpler
|
|
|
|
|
* (and faster.)
|
|
|
|
|
*/
|
|
|
|
|
for (i = 0; i < numClients; i++)
|
|
|
|
|
{
|
|
|
|
|
XID cs = pClientspecs[i];
|
|
|
|
|
if (cs > XRecordAllClients)
|
|
|
|
|
pClientspecs[i] = CLIENT_BITS(cs);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
for (i = 0; i < numClients; i++)
|
|
|
|
|
{
|
|
|
|
|
if (pClientspecs[i] == XRecordAllClients ||
|
|
|
|
|
pClientspecs[i] == XRecordCurrentClients)
|
|
|
|
|
{ /* expand All/Current */
|
|
|
|
|
int j, nc;
|
2010-12-05 08:36:02 -07:00
|
|
|
|
XID *pCanon = (XID *)malloc(sizeof(XID) * (currentMaxClients + 1));
|
2006-11-26 11:13:41 -07:00
|
|
|
|
if (!pCanon) return NULL;
|
|
|
|
|
for (nc = 0, j = 1; j < currentMaxClients; j++)
|
|
|
|
|
{
|
|
|
|
|
ClientPtr client = clients[j];
|
|
|
|
|
if (client != NullClient &&
|
|
|
|
|
client->clientState == ClientStateRunning &&
|
|
|
|
|
client->clientAsMask != excludespec)
|
|
|
|
|
{
|
|
|
|
|
pCanon[nc++] = client->clientAsMask;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
if (pClientspecs[i] == XRecordAllClients)
|
|
|
|
|
pCanon[nc++] = XRecordFutureClients;
|
|
|
|
|
*pNumClientspecs = nc;
|
|
|
|
|
return pCanon;
|
|
|
|
|
}
|
|
|
|
|
else /* not All or Current */
|
|
|
|
|
{
|
|
|
|
|
int j;
|
|
|
|
|
for (j = i + 1; j < numClients; )
|
|
|
|
|
{
|
|
|
|
|
if (pClientspecs[i] == pClientspecs[j])
|
|
|
|
|
{
|
|
|
|
|
pClientspecs[j] = pClientspecs[--numClients];
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
j++;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
} /* end for each clientspec */
|
|
|
|
|
*pNumClientspecs = numClients;
|
|
|
|
|
return pClientspecs;
|
|
|
|
|
} /* RecordCanonicalizeClientSpecifiers */
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/****************************************************************************/
|
|
|
|
|
|
|
|
|
|
/* stuff for RegisterClients */
|
|
|
|
|
|
|
|
|
|
/* RecordPadAlign
|
|
|
|
|
*
|
|
|
|
|
* Arguments:
|
|
|
|
|
* size is the number of bytes taken by an object.
|
|
|
|
|
* align is a byte boundary (e.g. 4, 8)
|
|
|
|
|
*
|
|
|
|
|
* Returns:
|
|
|
|
|
* the number of pad bytes to add at the end of an object of the
|
|
|
|
|
* given size so that an object placed immediately behind it will
|
|
|
|
|
* begin on an <align>-byte boundary.
|
|
|
|
|
*
|
|
|
|
|
* Side Effects: none.
|
|
|
|
|
*/
|
|
|
|
|
static int
|
|
|
|
|
RecordPadAlign(int size, int align)
|
|
|
|
|
{
|
|
|
|
|
return (align - (size & (align - 1))) & (align - 1);
|
|
|
|
|
} /* RecordPadAlign */
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* RecordSanityCheckRegisterClients
|
|
|
|
|
*
|
|
|
|
|
* Arguments:
|
|
|
|
|
* pContext is the context being registered on.
|
|
|
|
|
* client is the client that issued a RecordCreateContext or
|
|
|
|
|
* RecordRegisterClients request.
|
|
|
|
|
* stuff is a pointer to the request.
|
|
|
|
|
*
|
|
|
|
|
* Returns:
|
|
|
|
|
* Any one of several possible error values if any of the request
|
|
|
|
|
* arguments are invalid. Success if everything is OK.
|
|
|
|
|
*
|
|
|
|
|
* Side Effects: none.
|
|
|
|
|
*/
|
|
|
|
|
static int
|
|
|
|
|
RecordSanityCheckRegisterClients(RecordContextPtr pContext, ClientPtr client, xRecordRegisterClientsReq *stuff)
|
|
|
|
|
{
|
|
|
|
|
int err;
|
|
|
|
|
xRecordRange *pRange;
|
|
|
|
|
int i;
|
|
|
|
|
XID recordingClient;
|
|
|
|
|
|
|
|
|
|
if (((client->req_len << 2) - SIZEOF(xRecordRegisterClientsReq)) !=
|
|
|
|
|
4 * stuff->nClients + SIZEOF(xRecordRange) * stuff->nRanges)
|
|
|
|
|
return BadLength;
|
|
|
|
|
|
|
|
|
|
if (stuff->elementHeader &
|
|
|
|
|
~(XRecordFromClientSequence|XRecordFromClientTime|XRecordFromServerTime))
|
|
|
|
|
{
|
|
|
|
|
client->errorValue = stuff->elementHeader;
|
|
|
|
|
return BadValue;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
recordingClient = pContext->pRecordingClient ?
|
|
|
|
|
pContext->pRecordingClient->clientAsMask : 0;
|
2010-07-27 13:02:24 -06:00
|
|
|
|
err = RecordSanityCheckClientSpecifiers(client, (XID *)&stuff[1],
|
|
|
|
|
stuff->nClients, recordingClient);
|
2006-11-26 11:13:41 -07:00
|
|
|
|
if (err != Success) return err;
|
|
|
|
|
|
|
|
|
|
pRange = (xRecordRange *)(((XID *)&stuff[1]) + stuff->nClients);
|
|
|
|
|
for (i = 0; i < stuff->nRanges; i++, pRange++)
|
|
|
|
|
{
|
|
|
|
|
if (pRange->coreRequestsFirst > pRange->coreRequestsLast)
|
|
|
|
|
{
|
|
|
|
|
client->errorValue = pRange->coreRequestsFirst;
|
|
|
|
|
return BadValue;
|
|
|
|
|
}
|
|
|
|
|
if (pRange->coreRepliesFirst > pRange->coreRepliesLast)
|
|
|
|
|
{
|
|
|
|
|
client->errorValue = pRange->coreRepliesFirst;
|
|
|
|
|
return BadValue;
|
|
|
|
|
}
|
|
|
|
|
if ((pRange->extRequestsMajorFirst || pRange->extRequestsMajorLast) &&
|
|
|
|
|
(pRange->extRequestsMajorFirst < 128 ||
|
|
|
|
|
pRange->extRequestsMajorLast < 128 ||
|
|
|
|
|
pRange->extRequestsMajorFirst > pRange->extRequestsMajorLast))
|
|
|
|
|
{
|
|
|
|
|
client->errorValue = pRange->extRequestsMajorFirst;
|
|
|
|
|
return BadValue;
|
|
|
|
|
}
|
|
|
|
|
if (pRange->extRequestsMinorFirst > pRange->extRequestsMinorLast)
|
|
|
|
|
{
|
|
|
|
|
client->errorValue = pRange->extRequestsMinorFirst;
|
|
|
|
|
return BadValue;
|
|
|
|
|
}
|
|
|
|
|
if ((pRange->extRepliesMajorFirst || pRange->extRepliesMajorLast) &&
|
|
|
|
|
(pRange->extRepliesMajorFirst < 128 ||
|
|
|
|
|
pRange->extRepliesMajorLast < 128 ||
|
|
|
|
|
pRange->extRepliesMajorFirst > pRange->extRepliesMajorLast))
|
|
|
|
|
{
|
|
|
|
|
client->errorValue = pRange->extRepliesMajorFirst;
|
|
|
|
|
return BadValue;
|
|
|
|
|
}
|
|
|
|
|
if (pRange->extRepliesMinorFirst > pRange->extRepliesMinorLast)
|
|
|
|
|
{
|
|
|
|
|
client->errorValue = pRange->extRepliesMinorFirst;
|
|
|
|
|
return BadValue;
|
|
|
|
|
}
|
|
|
|
|
if ((pRange->deliveredEventsFirst || pRange->deliveredEventsLast) &&
|
|
|
|
|
(pRange->deliveredEventsFirst < 2 ||
|
|
|
|
|
pRange->deliveredEventsLast < 2 ||
|
|
|
|
|
pRange->deliveredEventsFirst > pRange->deliveredEventsLast))
|
|
|
|
|
{
|
|
|
|
|
client->errorValue = pRange->deliveredEventsFirst;
|
|
|
|
|
return BadValue;
|
|
|
|
|
}
|
|
|
|
|
if ((pRange->deviceEventsFirst || pRange->deviceEventsLast) &&
|
|
|
|
|
(pRange->deviceEventsFirst < 2 ||
|
|
|
|
|
pRange->deviceEventsLast < 2 ||
|
|
|
|
|
pRange->deviceEventsFirst > pRange->deviceEventsLast))
|
|
|
|
|
{
|
|
|
|
|
client->errorValue = pRange->deviceEventsFirst;
|
|
|
|
|
return BadValue;
|
|
|
|
|
}
|
|
|
|
|
if (pRange->errorsFirst > pRange->errorsLast)
|
|
|
|
|
{
|
|
|
|
|
client->errorValue = pRange->errorsFirst;
|
|
|
|
|
return BadValue;
|
|
|
|
|
}
|
|
|
|
|
if (pRange->clientStarted != xFalse && pRange->clientStarted != xTrue)
|
|
|
|
|
{
|
|
|
|
|
client->errorValue = pRange->clientStarted;
|
|
|
|
|
return BadValue;
|
|
|
|
|
}
|
|
|
|
|
if (pRange->clientDied != xFalse && pRange->clientDied != xTrue)
|
|
|
|
|
{
|
|
|
|
|
client->errorValue = pRange->clientDied;
|
|
|
|
|
return BadValue;
|
|
|
|
|
}
|
|
|
|
|
} /* end for each range */
|
|
|
|
|
return Success;
|
|
|
|
|
} /* end RecordSanityCheckRegisterClients */
|
|
|
|
|
|
|
|
|
|
/* This is a tactical structure used to gather information about all the sets
|
|
|
|
|
* (RecordSetPtr) that need to be created for an RCAP in the process of
|
|
|
|
|
* digesting a list of RECORDRANGEs (converting it to the internal
|
|
|
|
|
* representation).
|
|
|
|
|
*/
|
|
|
|
|
typedef struct
|
|
|
|
|
{
|
|
|
|
|
int nintervals; /* number of intervals in following array */
|
|
|
|
|
RecordSetInterval *intervals; /* array of intervals for this set */
|
|
|
|
|
int size; /* size of intevals array; >= nintervals */
|
|
|
|
|
int align; /* alignment restriction for set */
|
|
|
|
|
int offset; /* where to store set pointer rel. to start of RCAP */
|
|
|
|
|
short first, last; /* if for extension, major opcode interval */
|
|
|
|
|
} SetInfoRec, *SetInfoPtr;
|
|
|
|
|
|
|
|
|
|
/* These constant are used to index into an array of SetInfoRec. */
|
|
|
|
|
enum {REQ, /* set info for requests */
|
|
|
|
|
REP, /* set info for replies */
|
|
|
|
|
ERR, /* set info for errors */
|
|
|
|
|
DEV, /* set info for device events */
|
|
|
|
|
DLEV, /* set info for delivered events */
|
|
|
|
|
PREDEFSETS}; /* number of predefined array entries */
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* RecordAllocIntervals
|
|
|
|
|
*
|
|
|
|
|
* Arguments:
|
|
|
|
|
* psi is a pointer to a SetInfoRec whose intervals pointer is NULL.
|
|
|
|
|
* nIntervals is the desired size of the intervals array.
|
|
|
|
|
*
|
|
|
|
|
* Returns: BadAlloc if a memory allocation error occurred, else Success.
|
|
|
|
|
*
|
|
|
|
|
* Side Effects:
|
|
|
|
|
* If Success is returned, psi->intervals is a pointer to size
|
|
|
|
|
* RecordSetIntervals, all zeroed, and psi->size is set to size.
|
|
|
|
|
*/
|
|
|
|
|
static int
|
|
|
|
|
RecordAllocIntervals(SetInfoPtr psi, int nIntervals)
|
|
|
|
|
{
|
|
|
|
|
assert(!psi->intervals);
|
|
|
|
|
psi->intervals = (RecordSetInterval *)
|
2010-12-05 08:36:02 -07:00
|
|
|
|
malloc(nIntervals * sizeof(RecordSetInterval));
|
2006-11-26 11:13:41 -07:00
|
|
|
|
if (!psi->intervals)
|
|
|
|
|
return BadAlloc;
|
2010-12-05 08:36:02 -07:00
|
|
|
|
memset(psi->intervals, 0, nIntervals * sizeof(RecordSetInterval));
|
2006-11-26 11:13:41 -07:00
|
|
|
|
psi->size = nIntervals;
|
|
|
|
|
return Success;
|
|
|
|
|
} /* end RecordAllocIntervals */
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* RecordConvertRangesToIntervals
|
|
|
|
|
*
|
|
|
|
|
* Arguments:
|
|
|
|
|
* psi is a pointer to the SetInfoRec we are building.
|
|
|
|
|
* pRanges is an array of xRecordRanges.
|
|
|
|
|
* nRanges is the number of elements in pRanges.
|
|
|
|
|
* byteoffset is the offset from the start of an xRecordRange of the
|
|
|
|
|
* two bytes (1 for first, 1 for last) we are interested in.
|
|
|
|
|
* pExtSetInfo, if non-NULL, indicates that the two bytes mentioned
|
|
|
|
|
* above are followed by four bytes (2 for first, 2 for last)
|
|
|
|
|
* representing a minor opcode range, and this information should be
|
|
|
|
|
* stored in one of the SetInfoRecs starting at pExtSetInfo.
|
|
|
|
|
* pnExtSetInfo is the number of elements in the pExtSetInfo array.
|
|
|
|
|
*
|
|
|
|
|
* Returns: BadAlloc if a memory allocation error occurred, else Success.
|
|
|
|
|
*
|
|
|
|
|
* Side Effects:
|
|
|
|
|
* The slice of pRanges indicated by byteoffset is stored in psi.
|
|
|
|
|
* If pExtSetInfo is non-NULL, minor opcode intervals are stored
|
|
|
|
|
* in an existing SetInfoRec if the major opcode interval matches, else
|
|
|
|
|
* they are stored in a new SetInfoRec, and *pnExtSetInfo is
|
|
|
|
|
* increased accordingly.
|
|
|
|
|
*/
|
|
|
|
|
static int
|
|
|
|
|
RecordConvertRangesToIntervals(
|
|
|
|
|
SetInfoPtr psi,
|
|
|
|
|
xRecordRange *pRanges,
|
|
|
|
|
int nRanges,
|
|
|
|
|
int byteoffset,
|
|
|
|
|
SetInfoPtr pExtSetInfo,
|
|
|
|
|
int *pnExtSetInfo
|
|
|
|
|
)
|
|
|
|
|
{
|
|
|
|
|
int i;
|
|
|
|
|
CARD8 *pCARD8;
|
|
|
|
|
int first, last;
|
|
|
|
|
int err;
|
|
|
|
|
|
|
|
|
|
for (i = 0; i < nRanges; i++, pRanges++)
|
|
|
|
|
{
|
|
|
|
|
pCARD8 = ((CARD8 *)pRanges) + byteoffset;
|
|
|
|
|
first = pCARD8[0];
|
|
|
|
|
last = pCARD8[1];
|
|
|
|
|
if (first || last)
|
|
|
|
|
{
|
|
|
|
|
if (!psi->intervals)
|
|
|
|
|
{
|
|
|
|
|
err = RecordAllocIntervals(psi, 2 * (nRanges - i));
|
|
|
|
|
if (err != Success)
|
|
|
|
|
return err;
|
|
|
|
|
}
|
|
|
|
|
psi->intervals[psi->nintervals].first = first;
|
|
|
|
|
psi->intervals[psi->nintervals].last = last;
|
|
|
|
|
psi->nintervals++;
|
|
|
|
|
assert(psi->nintervals <= psi->size);
|
|
|
|
|
if (pExtSetInfo)
|
|
|
|
|
{
|
|
|
|
|
SetInfoPtr pesi = pExtSetInfo;
|
|
|
|
|
CARD16 *pCARD16 = (CARD16 *)(pCARD8 + 2);
|
|
|
|
|
int j;
|
|
|
|
|
|
|
|
|
|
for (j = 0; j < *pnExtSetInfo; j++, pesi++)
|
|
|
|
|
{
|
|
|
|
|
if ( (first == pesi->first) && (last == pesi->last) )
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
if (j == *pnExtSetInfo)
|
|
|
|
|
{
|
|
|
|
|
err = RecordAllocIntervals(pesi, 2 * (nRanges - i));
|
|
|
|
|
if (err != Success)
|
|
|
|
|
return err;
|
|
|
|
|
pesi->first = first;
|
|
|
|
|
pesi->last = last;
|
|
|
|
|
(*pnExtSetInfo)++;
|
|
|
|
|
}
|
|
|
|
|
pesi->intervals[pesi->nintervals].first = pCARD16[0];
|
|
|
|
|
pesi->intervals[pesi->nintervals].last = pCARD16[1];
|
|
|
|
|
pesi->nintervals++;
|
|
|
|
|
assert(pesi->nintervals <= pesi->size);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
return Success;
|
|
|
|
|
} /* end RecordConvertRangesToIntervals */
|
|
|
|
|
|
|
|
|
|
#define offset_of(_structure, _field) \
|
|
|
|
|
((char *)(& (_structure . _field)) - (char *)(&_structure))
|
|
|
|
|
|
|
|
|
|
/* RecordRegisterClients
|
|
|
|
|
*
|
|
|
|
|
* Arguments:
|
|
|
|
|
* pContext is the context on which to register the clients.
|
|
|
|
|
* client is the client that issued the RecordCreateContext or
|
|
|
|
|
* RecordRegisterClients request.
|
|
|
|
|
* stuff is a pointer to the request.
|
|
|
|
|
*
|
|
|
|
|
* Returns:
|
|
|
|
|
* Any one of several possible error values defined by the protocol.
|
|
|
|
|
* Success if everything is OK.
|
|
|
|
|
*
|
|
|
|
|
* Side Effects:
|
|
|
|
|
* If different element headers are specified, the context is flushed.
|
|
|
|
|
* If any of the specified clients are already registered on the
|
|
|
|
|
* context, they are first unregistered. A new RCAP is created to
|
|
|
|
|
* hold the specified protocol and clients, and it is linked onto the
|
|
|
|
|
* context. If the context is enabled, appropriate hooks are installed
|
|
|
|
|
* to record the new clients and protocol.
|
|
|
|
|
*/
|
|
|
|
|
static int
|
|
|
|
|
RecordRegisterClients(RecordContextPtr pContext, ClientPtr client, xRecordRegisterClientsReq *stuff)
|
|
|
|
|
{
|
|
|
|
|
int err;
|
|
|
|
|
int i;
|
|
|
|
|
SetInfoPtr si;
|
|
|
|
|
int maxSets;
|
|
|
|
|
int nExtReqSets = 0;
|
|
|
|
|
int nExtRepSets = 0;
|
|
|
|
|
int extReqSetsOffset = 0;
|
|
|
|
|
int extRepSetsOffset = 0;
|
|
|
|
|
SetInfoPtr pExtReqSets, pExtRepSets;
|
|
|
|
|
int clientListOffset;
|
|
|
|
|
XID *pCanonClients;
|
|
|
|
|
int clientStarted = 0, clientDied = 0;
|
|
|
|
|
xRecordRange *pRanges, rr;
|
|
|
|
|
int nClients;
|
|
|
|
|
int sizeClients;
|
|
|
|
|
int totRCAPsize;
|
|
|
|
|
RecordClientsAndProtocolPtr pRCAP;
|
|
|
|
|
int pad;
|
|
|
|
|
XID recordingClient;
|
|
|
|
|
|
|
|
|
|
/* do all sanity checking up front */
|
|
|
|
|
|
|
|
|
|
err = RecordSanityCheckRegisterClients(pContext, client, stuff);
|
|
|
|
|
if (err != Success)
|
|
|
|
|
return err;
|
|
|
|
|
|
|
|
|
|
/* if element headers changed, flush buffer */
|
|
|
|
|
|
|
|
|
|
if (pContext->elemHeaders != stuff->elementHeader)
|
|
|
|
|
{
|
|
|
|
|
RecordFlushReplyBuffer(pContext, NULL, 0, NULL, 0);
|
|
|
|
|
pContext->elemHeaders = stuff->elementHeader;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
nClients = stuff->nClients;
|
|
|
|
|
if (!nClients)
|
|
|
|
|
/* if empty clients list, we're done. */
|
|
|
|
|
return Success;
|
|
|
|
|
|
|
|
|
|
recordingClient = pContext->pRecordingClient ?
|
|
|
|
|
pContext->pRecordingClient->clientAsMask : 0;
|
|
|
|
|
pCanonClients = RecordCanonicalizeClientSpecifiers((XID *)&stuff[1],
|
|
|
|
|
&nClients, recordingClient);
|
|
|
|
|
if (!pCanonClients)
|
|
|
|
|
return BadAlloc;
|
|
|
|
|
|
|
|
|
|
/* We may have to create as many as one set for each "predefined"
|
|
|
|
|
* protocol types, plus one per range for extension reuests, plus one per
|
|
|
|
|
* range for extension replies.
|
|
|
|
|
*/
|
|
|
|
|
maxSets = PREDEFSETS + 2 * stuff->nRanges;
|
2010-12-05 08:36:02 -07:00
|
|
|
|
si = (SetInfoPtr)malloc(sizeof(SetInfoRec) * maxSets);
|
2006-11-26 11:13:41 -07:00
|
|
|
|
if (!si)
|
|
|
|
|
{
|
|
|
|
|
err = BadAlloc;
|
|
|
|
|
goto bailout;
|
|
|
|
|
}
|
2010-12-05 08:36:02 -07:00
|
|
|
|
memset(si, 0, sizeof(SetInfoRec) * maxSets);
|
2006-11-26 11:13:41 -07:00
|
|
|
|
|
|
|
|
|
/* theoretically you must do this because NULL may not be all-bits-zero */
|
|
|
|
|
for (i = 0; i < maxSets; i++)
|
|
|
|
|
si[i].intervals = NULL;
|
|
|
|
|
|
|
|
|
|
pExtReqSets = si + PREDEFSETS;
|
|
|
|
|
pExtRepSets = pExtReqSets + stuff->nRanges;
|
|
|
|
|
|
|
|
|
|
pRanges = (xRecordRange *)(((XID *)&stuff[1]) + stuff->nClients);
|
|
|
|
|
|
|
|
|
|
err = RecordConvertRangesToIntervals(&si[REQ], pRanges, stuff->nRanges,
|
|
|
|
|
offset_of(rr, coreRequestsFirst), NULL, NULL);
|
|
|
|
|
if (err != Success) goto bailout;
|
|
|
|
|
|
|
|
|
|
err = RecordConvertRangesToIntervals(&si[REQ], pRanges, stuff->nRanges,
|
|
|
|
|
offset_of(rr, extRequestsMajorFirst), pExtReqSets, &nExtReqSets);
|
|
|
|
|
if (err != Success) goto bailout;
|
|
|
|
|
|
|
|
|
|
err = RecordConvertRangesToIntervals(&si[REP], pRanges, stuff->nRanges,
|
|
|
|
|
offset_of(rr, coreRepliesFirst), NULL, NULL);
|
|
|
|
|
if (err != Success) goto bailout;
|
|
|
|
|
|
|
|
|
|
err = RecordConvertRangesToIntervals(&si[REP], pRanges, stuff->nRanges,
|
|
|
|
|
offset_of(rr, extRepliesMajorFirst), pExtRepSets, &nExtRepSets);
|
|
|
|
|
if (err != Success) goto bailout;
|
|
|
|
|
|
|
|
|
|
err = RecordConvertRangesToIntervals(&si[ERR], pRanges, stuff->nRanges,
|
|
|
|
|
offset_of(rr, errorsFirst), NULL, NULL);
|
|
|
|
|
if (err != Success) goto bailout;
|
|
|
|
|
|
|
|
|
|
err = RecordConvertRangesToIntervals(&si[DLEV], pRanges, stuff->nRanges,
|
|
|
|
|
offset_of(rr, deliveredEventsFirst), NULL, NULL);
|
|
|
|
|
if (err != Success) goto bailout;
|
|
|
|
|
|
|
|
|
|
err = RecordConvertRangesToIntervals(&si[DEV], pRanges, stuff->nRanges,
|
|
|
|
|
offset_of(rr, deviceEventsFirst), NULL, NULL);
|
|
|
|
|
if (err != Success) goto bailout;
|
|
|
|
|
|
|
|
|
|
/* collect client-started and client-died */
|
|
|
|
|
|
|
|
|
|
for (i = 0; i < stuff->nRanges; i++)
|
|
|
|
|
{
|
|
|
|
|
if (pRanges[i].clientStarted) clientStarted = TRUE;
|
|
|
|
|
if (pRanges[i].clientDied) clientDied = TRUE;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* We now have all the information collected to create all the sets,
|
|
|
|
|
* and we can compute the total memory required for the RCAP.
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
totRCAPsize = sizeof(RecordClientsAndProtocolRec);
|
|
|
|
|
|
|
|
|
|
/* leave a little room to grow before forcing a separate allocation */
|
|
|
|
|
sizeClients = nClients + CLIENT_ARRAY_GROWTH_INCREMENT;
|
|
|
|
|
pad = RecordPadAlign(totRCAPsize, sizeof(XID));
|
|
|
|
|
clientListOffset = totRCAPsize + pad;
|
|
|
|
|
totRCAPsize += pad + sizeClients * sizeof(XID);
|
|
|
|
|
|
|
|
|
|
if (nExtReqSets)
|
|
|
|
|
{
|
|
|
|
|
pad = RecordPadAlign(totRCAPsize, sizeof(RecordSetPtr));
|
|
|
|
|
extReqSetsOffset = totRCAPsize + pad;
|
|
|
|
|
totRCAPsize += pad + (nExtReqSets + 1) * sizeof(RecordMinorOpRec);
|
|
|
|
|
}
|
|
|
|
|
if (nExtRepSets)
|
|
|
|
|
{
|
|
|
|
|
pad = RecordPadAlign(totRCAPsize, sizeof(RecordSetPtr));
|
|
|
|
|
extRepSetsOffset = totRCAPsize + pad;
|
|
|
|
|
totRCAPsize += pad + (nExtRepSets + 1) * sizeof(RecordMinorOpRec);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
for (i = 0; i < maxSets; i++)
|
|
|
|
|
{
|
|
|
|
|
if (si[i].nintervals)
|
|
|
|
|
{
|
|
|
|
|
si[i].size = RecordSetMemoryRequirements(
|
|
|
|
|
si[i].intervals, si[i].nintervals, &si[i].align);
|
|
|
|
|
pad = RecordPadAlign(totRCAPsize, si[i].align);
|
|
|
|
|
si[i].offset = pad + totRCAPsize;
|
|
|
|
|
totRCAPsize += pad + si[i].size;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* allocate memory for the whole RCAP */
|
|
|
|
|
|
2010-12-05 08:36:02 -07:00
|
|
|
|
pRCAP = (RecordClientsAndProtocolPtr)malloc(totRCAPsize);
|
2006-11-26 11:13:41 -07:00
|
|
|
|
if (!pRCAP)
|
|
|
|
|
{
|
|
|
|
|
err = BadAlloc;
|
|
|
|
|
goto bailout;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* fill in the RCAP */
|
|
|
|
|
|
|
|
|
|
pRCAP->pContext = pContext;
|
|
|
|
|
pRCAP->pClientIDs = (XID *)((char *)pRCAP + clientListOffset);
|
|
|
|
|
pRCAP->numClients = nClients;
|
|
|
|
|
pRCAP->sizeClients = sizeClients;
|
|
|
|
|
pRCAP->clientIDsSeparatelyAllocated = 0;
|
|
|
|
|
for (i = 0; i < nClients; i++)
|
|
|
|
|
{
|
|
|
|
|
RecordDeleteClientFromContext(pContext, pCanonClients[i]);
|
|
|
|
|
pRCAP->pClientIDs[i] = pCanonClients[i];
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* create all the sets */
|
|
|
|
|
|
|
|
|
|
if (si[REQ].intervals)
|
|
|
|
|
{
|
|
|
|
|
pRCAP->pRequestMajorOpSet =
|
|
|
|
|
RecordCreateSet(si[REQ].intervals, si[REQ].nintervals,
|
|
|
|
|
(RecordSetPtr)((char *)pRCAP + si[REQ].offset), si[REQ].size);
|
|
|
|
|
}
|
|
|
|
|
else pRCAP->pRequestMajorOpSet = NULL;
|
|
|
|
|
|
|
|
|
|
if (si[REP].intervals)
|
|
|
|
|
{
|
|
|
|
|
pRCAP->pReplyMajorOpSet =
|
|
|
|
|
RecordCreateSet(si[REP].intervals, si[REP].nintervals,
|
|
|
|
|
(RecordSetPtr)((char *)pRCAP + si[REP].offset), si[REP].size);
|
|
|
|
|
}
|
|
|
|
|
else pRCAP->pReplyMajorOpSet = NULL;
|
|
|
|
|
|
|
|
|
|
if (si[ERR].intervals)
|
|
|
|
|
{
|
|
|
|
|
pRCAP->pErrorSet =
|
|
|
|
|
RecordCreateSet(si[ERR].intervals, si[ERR].nintervals,
|
|
|
|
|
(RecordSetPtr)((char *)pRCAP + si[ERR].offset), si[ERR].size);
|
|
|
|
|
}
|
|
|
|
|
else pRCAP->pErrorSet = NULL;
|
|
|
|
|
|
|
|
|
|
if (si[DEV].intervals)
|
|
|
|
|
{
|
|
|
|
|
pRCAP->pDeviceEventSet =
|
|
|
|
|
RecordCreateSet(si[DEV].intervals, si[DEV].nintervals,
|
|
|
|
|
(RecordSetPtr)((char *)pRCAP + si[DEV].offset), si[DEV].size);
|
|
|
|
|
}
|
|
|
|
|
else pRCAP->pDeviceEventSet = NULL;
|
|
|
|
|
|
|
|
|
|
if (si[DLEV].intervals)
|
|
|
|
|
{
|
|
|
|
|
pRCAP->pDeliveredEventSet =
|
|
|
|
|
RecordCreateSet(si[DLEV].intervals, si[DLEV].nintervals,
|
|
|
|
|
(RecordSetPtr)((char *)pRCAP + si[DLEV].offset), si[DLEV].size);
|
|
|
|
|
}
|
|
|
|
|
else pRCAP->pDeliveredEventSet = NULL;
|
|
|
|
|
|
|
|
|
|
if (nExtReqSets)
|
|
|
|
|
{
|
|
|
|
|
pRCAP->pRequestMinOpInfo = (RecordMinorOpPtr)
|
|
|
|
|
((char *)pRCAP + extReqSetsOffset);
|
|
|
|
|
pRCAP->pRequestMinOpInfo[0].count = nExtReqSets;
|
|
|
|
|
for (i = 0; i < nExtReqSets; i++, pExtReqSets++)
|
|
|
|
|
{
|
|
|
|
|
pRCAP->pRequestMinOpInfo[i+1].major.first = pExtReqSets->first;
|
|
|
|
|
pRCAP->pRequestMinOpInfo[i+1].major.last = pExtReqSets->last;
|
|
|
|
|
pRCAP->pRequestMinOpInfo[i+1].major.pMinOpSet =
|
|
|
|
|
RecordCreateSet(pExtReqSets->intervals,
|
|
|
|
|
pExtReqSets->nintervals,
|
|
|
|
|
(RecordSetPtr)((char *)pRCAP + pExtReqSets->offset),
|
|
|
|
|
pExtReqSets->size);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
else pRCAP->pRequestMinOpInfo = NULL;
|
|
|
|
|
|
|
|
|
|
if (nExtRepSets)
|
|
|
|
|
{
|
|
|
|
|
pRCAP->pReplyMinOpInfo = (RecordMinorOpPtr)
|
|
|
|
|
((char *)pRCAP + extRepSetsOffset);
|
|
|
|
|
pRCAP->pReplyMinOpInfo[0].count = nExtRepSets;
|
|
|
|
|
for (i = 0; i < nExtRepSets; i++, pExtRepSets++)
|
|
|
|
|
{
|
|
|
|
|
pRCAP->pReplyMinOpInfo[i+1].major.first = pExtRepSets->first;
|
|
|
|
|
pRCAP->pReplyMinOpInfo[i+1].major.last = pExtRepSets->last;
|
|
|
|
|
pRCAP->pReplyMinOpInfo[i+1].major.pMinOpSet =
|
|
|
|
|
RecordCreateSet(pExtRepSets->intervals,
|
|
|
|
|
pExtRepSets->nintervals,
|
|
|
|
|
(RecordSetPtr)((char *)pRCAP + pExtRepSets->offset),
|
|
|
|
|
pExtRepSets->size);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
else pRCAP->pReplyMinOpInfo = NULL;
|
|
|
|
|
|
|
|
|
|
pRCAP->clientStarted = clientStarted;
|
|
|
|
|
pRCAP->clientDied = clientDied;
|
|
|
|
|
|
|
|
|
|
/* link the RCAP onto the context */
|
|
|
|
|
|
|
|
|
|
pRCAP->pNextRCAP = pContext->pListOfRCAP;
|
|
|
|
|
pContext->pListOfRCAP = pRCAP;
|
|
|
|
|
|
|
|
|
|
if (pContext->pRecordingClient) /* context enabled */
|
|
|
|
|
RecordInstallHooks(pRCAP, 0);
|
|
|
|
|
|
|
|
|
|
bailout:
|
|
|
|
|
if (si)
|
|
|
|
|
{
|
|
|
|
|
for (i = 0; i < maxSets; i++)
|
2010-12-05 08:36:02 -07:00
|
|
|
|
free(si[i].intervals);
|
|
|
|
|
free(si);
|
2006-11-26 11:13:41 -07:00
|
|
|
|
}
|
|
|
|
|
if (pCanonClients && pCanonClients != (XID *)&stuff[1])
|
2010-12-05 08:36:02 -07:00
|
|
|
|
free(pCanonClients);
|
2006-11-26 11:13:41 -07:00
|
|
|
|
return err;
|
|
|
|
|
} /* RecordRegisterClients */
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* Proc functions all take a client argument, execute the request in
|
|
|
|
|
* client->requestBuffer, and return a protocol error status.
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
static int
|
|
|
|
|
ProcRecordQueryVersion(ClientPtr client)
|
|
|
|
|
{
|
|
|
|
|
/* REQUEST(xRecordQueryVersionReq); */
|
|
|
|
|
xRecordQueryVersionReply rep;
|
|
|
|
|
int n;
|
|
|
|
|
|
|
|
|
|
REQUEST_SIZE_MATCH(xRecordQueryVersionReq);
|
|
|
|
|
rep.type = X_Reply;
|
|
|
|
|
rep.sequenceNumber = client->sequence;
|
|
|
|
|
rep.length = 0;
|
2010-07-27 13:02:24 -06:00
|
|
|
|
rep.majorVersion = SERVER_RECORD_MAJOR_VERSION;
|
|
|
|
|
rep.minorVersion = SERVER_RECORD_MINOR_VERSION;
|
2006-11-26 11:13:41 -07:00
|
|
|
|
if(client->swapped)
|
|
|
|
|
{
|
|
|
|
|
swaps(&rep.sequenceNumber, n);
|
|
|
|
|
swaps(&rep.majorVersion, n);
|
|
|
|
|
swaps(&rep.minorVersion, n);
|
|
|
|
|
}
|
|
|
|
|
(void)WriteToClient(client, sizeof(xRecordQueryVersionReply),
|
|
|
|
|
(char *)&rep);
|
2010-12-05 08:36:02 -07:00
|
|
|
|
return Success;
|
2006-11-26 11:13:41 -07:00
|
|
|
|
} /* ProcRecordQueryVersion */
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
static int
|
|
|
|
|
ProcRecordCreateContext(ClientPtr client)
|
|
|
|
|
{
|
|
|
|
|
REQUEST(xRecordCreateContextReq);
|
|
|
|
|
RecordContextPtr pContext;
|
|
|
|
|
RecordContextPtr *ppNewAllContexts = NULL;
|
|
|
|
|
int err = BadAlloc;
|
|
|
|
|
|
|
|
|
|
REQUEST_AT_LEAST_SIZE(xRecordCreateContextReq);
|
|
|
|
|
LEGAL_NEW_RESOURCE(stuff->context, client);
|
|
|
|
|
|
2010-12-05 08:36:02 -07:00
|
|
|
|
pContext = (RecordContextPtr)malloc(sizeof(RecordContextRec));
|
2006-11-26 11:13:41 -07:00
|
|
|
|
if (!pContext)
|
|
|
|
|
goto bailout;
|
|
|
|
|
|
|
|
|
|
/* make sure there is room in ppAllContexts to store the new context */
|
|
|
|
|
|
|
|
|
|
ppNewAllContexts = (RecordContextPtr *)
|
2010-12-05 08:36:02 -07:00
|
|
|
|
realloc(ppAllContexts, sizeof(RecordContextPtr) * (numContexts + 1));
|
2006-11-26 11:13:41 -07:00
|
|
|
|
if (!ppNewAllContexts)
|
|
|
|
|
goto bailout;
|
|
|
|
|
ppAllContexts = ppNewAllContexts;
|
|
|
|
|
|
|
|
|
|
pContext->id = stuff->context;
|
|
|
|
|
pContext->pRecordingClient = NULL;
|
|
|
|
|
pContext->pListOfRCAP = NULL;
|
|
|
|
|
pContext->elemHeaders = 0;
|
|
|
|
|
pContext->bufCategory = 0;
|
|
|
|
|
pContext->numBufBytes = 0;
|
|
|
|
|
pContext->pBufClient = NULL;
|
|
|
|
|
pContext->continuedReply = 0;
|
2011-04-02 10:08:38 -06:00
|
|
|
|
pContext->inFlush = 0;
|
2006-11-26 11:13:41 -07:00
|
|
|
|
|
|
|
|
|
err = RecordRegisterClients(pContext, client,
|
|
|
|
|
(xRecordRegisterClientsReq *)stuff);
|
|
|
|
|
if (err != Success)
|
|
|
|
|
goto bailout;
|
|
|
|
|
|
|
|
|
|
if (AddResource(pContext->id, RTContext, pContext))
|
|
|
|
|
{
|
|
|
|
|
ppAllContexts[numContexts++] = pContext;
|
|
|
|
|
return Success;
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
RecordDeleteContext((pointer)pContext, pContext->id);
|
2011-11-05 07:32:40 -06:00
|
|
|
|
return BadAlloc;
|
2006-11-26 11:13:41 -07:00
|
|
|
|
}
|
|
|
|
|
bailout:
|
2010-12-05 08:36:02 -07:00
|
|
|
|
free(pContext);
|
2006-11-26 11:13:41 -07:00
|
|
|
|
return err;
|
|
|
|
|
} /* ProcRecordCreateContext */
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
static int
|
|
|
|
|
ProcRecordRegisterClients(ClientPtr client)
|
|
|
|
|
{
|
|
|
|
|
RecordContextPtr pContext;
|
|
|
|
|
REQUEST(xRecordRegisterClientsReq);
|
|
|
|
|
|
|
|
|
|
REQUEST_AT_LEAST_SIZE(xRecordRegisterClientsReq);
|
|
|
|
|
VERIFY_CONTEXT(pContext, stuff->context, client);
|
|
|
|
|
|
|
|
|
|
return RecordRegisterClients(pContext, client, stuff);
|
|
|
|
|
} /* ProcRecordRegisterClients */
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
static int
|
|
|
|
|
ProcRecordUnregisterClients(ClientPtr client)
|
|
|
|
|
{
|
|
|
|
|
RecordContextPtr pContext;
|
|
|
|
|
int err;
|
|
|
|
|
REQUEST(xRecordUnregisterClientsReq);
|
|
|
|
|
XID *pCanonClients;
|
|
|
|
|
int nClients;
|
|
|
|
|
int i;
|
|
|
|
|
|
|
|
|
|
REQUEST_AT_LEAST_SIZE(xRecordUnregisterClientsReq);
|
|
|
|
|
if ((client->req_len << 2) - SIZEOF(xRecordUnregisterClientsReq) !=
|
|
|
|
|
4 * stuff->nClients)
|
|
|
|
|
return BadLength;
|
|
|
|
|
VERIFY_CONTEXT(pContext, stuff->context, client);
|
2010-07-27 13:02:24 -06:00
|
|
|
|
err = RecordSanityCheckClientSpecifiers(client, (XID *)&stuff[1],
|
2006-11-26 11:13:41 -07:00
|
|
|
|
stuff->nClients, 0);
|
|
|
|
|
if (err != Success)
|
|
|
|
|
return err;
|
|
|
|
|
|
|
|
|
|
nClients = stuff->nClients;
|
|
|
|
|
pCanonClients = RecordCanonicalizeClientSpecifiers((XID *)&stuff[1],
|
|
|
|
|
&nClients, 0);
|
|
|
|
|
if (!pCanonClients)
|
|
|
|
|
return BadAlloc;
|
|
|
|
|
|
|
|
|
|
for (i = 0; i < nClients; i++)
|
|
|
|
|
{
|
|
|
|
|
RecordDeleteClientFromContext(pContext, pCanonClients[i]);
|
|
|
|
|
}
|
|
|
|
|
if (pCanonClients != (XID *)&stuff[1])
|
2010-12-05 08:36:02 -07:00
|
|
|
|
free(pCanonClients);
|
2006-11-26 11:13:41 -07:00
|
|
|
|
return Success;
|
|
|
|
|
} /* ProcRecordUnregisterClients */
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/****************************************************************************/
|
|
|
|
|
|
|
|
|
|
/* stuff for GetContext */
|
|
|
|
|
|
|
|
|
|
/* This is a tactical structure used to hold the xRecordRanges as they are
|
|
|
|
|
* being reconstituted from the sets in the RCAPs.
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
typedef struct {
|
|
|
|
|
xRecordRange *pRanges; /* array of xRecordRanges for one RCAP */
|
|
|
|
|
int size; /* number of elements in pRanges, >= nRanges */
|
|
|
|
|
int nRanges; /* number of occupied element of pRanges */
|
|
|
|
|
} GetContextRangeInfoRec, *GetContextRangeInfoPtr;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* RecordAllocRanges
|
|
|
|
|
*
|
|
|
|
|
* Arguments:
|
|
|
|
|
* pri is a pointer to a GetContextRangeInfoRec to allocate for.
|
|
|
|
|
* nRanges is the number of xRecordRanges desired for pri.
|
|
|
|
|
*
|
|
|
|
|
* Returns: BadAlloc if a memory allocation error occurred, else Success.
|
|
|
|
|
*
|
|
|
|
|
* Side Effects:
|
|
|
|
|
* If Success is returned, pri->pRanges points to at least nRanges
|
|
|
|
|
* ranges. pri->nRanges is set to nRanges. pri->size is the actual
|
|
|
|
|
* number of ranges. Newly allocated ranges are zeroed.
|
|
|
|
|
*/
|
|
|
|
|
static int
|
|
|
|
|
RecordAllocRanges(GetContextRangeInfoPtr pri, int nRanges)
|
|
|
|
|
{
|
|
|
|
|
int newsize;
|
|
|
|
|
xRecordRange *pNewRange;
|
|
|
|
|
#define SZINCR 8
|
|
|
|
|
|
|
|
|
|
newsize = max(pri->size + SZINCR, nRanges);
|
2010-12-05 08:36:02 -07:00
|
|
|
|
pNewRange = (xRecordRange *)realloc(pri->pRanges,
|
2006-11-26 11:13:41 -07:00
|
|
|
|
newsize * sizeof(xRecordRange));
|
|
|
|
|
if (!pNewRange)
|
|
|
|
|
return BadAlloc;
|
|
|
|
|
|
|
|
|
|
pri->pRanges = pNewRange;
|
|
|
|
|
pri->size = newsize;
|
2010-12-05 08:36:02 -07:00
|
|
|
|
memset(&pri->pRanges[pri->size - SZINCR], 0, SZINCR * sizeof(xRecordRange));
|
2006-11-26 11:13:41 -07:00
|
|
|
|
if (pri->nRanges < nRanges)
|
|
|
|
|
pri->nRanges = nRanges;
|
|
|
|
|
return Success;
|
|
|
|
|
} /* RecordAllocRanges */
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* RecordConvertSetToRanges
|
|
|
|
|
*
|
|
|
|
|
* Arguments:
|
|
|
|
|
* pSet is the set to be converted.
|
|
|
|
|
* pri is where the result should be stored.
|
|
|
|
|
* byteoffset is the offset from the start of an xRecordRange of the
|
|
|
|
|
* two vales (first, last) we are interested in.
|
|
|
|
|
* card8 is TRUE if the vales are one byte each and FALSE if two bytes
|
|
|
|
|
* each.
|
|
|
|
|
* imax is the largest set value to store in pri->pRanges.
|
|
|
|
|
* pStartIndex, if non-NULL, is the index of the first range in
|
|
|
|
|
* pri->pRanges that should be stored to. If NULL,
|
|
|
|
|
* start at index 0.
|
|
|
|
|
*
|
|
|
|
|
* Returns: BadAlloc if a memory allocation error occurred, else Success.
|
|
|
|
|
*
|
|
|
|
|
* Side Effects:
|
|
|
|
|
* If Success is returned, the slice of pri->pRanges indicated by
|
|
|
|
|
* byteoffset and card8 is filled in with the intervals from pSet.
|
|
|
|
|
* if pStartIndex was non-NULL, *pStartIndex is filled in with one
|
|
|
|
|
* more than the index of the last xRecordRange that was touched.
|
|
|
|
|
*/
|
|
|
|
|
static int
|
|
|
|
|
RecordConvertSetToRanges(
|
|
|
|
|
RecordSetPtr pSet,
|
|
|
|
|
GetContextRangeInfoPtr pri,
|
|
|
|
|
int byteoffset,
|
|
|
|
|
Bool card8,
|
|
|
|
|
unsigned int imax,
|
|
|
|
|
int *pStartIndex
|
|
|
|
|
)
|
|
|
|
|
{
|
|
|
|
|
int nRanges;
|
|
|
|
|
RecordSetIteratePtr pIter = NULL;
|
|
|
|
|
RecordSetInterval interval;
|
|
|
|
|
CARD8 *pCARD8;
|
|
|
|
|
CARD16 *pCARD16;
|
|
|
|
|
int err;
|
|
|
|
|
|
|
|
|
|
if (!pSet)
|
|
|
|
|
return Success;
|
|
|
|
|
|
|
|
|
|
nRanges = pStartIndex ? *pStartIndex : 0;
|
|
|
|
|
while ((pIter = RecordIterateSet(pSet, pIter, &interval)))
|
|
|
|
|
{
|
|
|
|
|
if (interval.first > imax) break;
|
|
|
|
|
if (interval.last > imax) interval.last = imax;
|
|
|
|
|
nRanges++;
|
|
|
|
|
if (nRanges > pri->size)
|
|
|
|
|
{
|
|
|
|
|
err = RecordAllocRanges(pri, nRanges);
|
|
|
|
|
if (err != Success)
|
|
|
|
|
return err;
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
pri->nRanges = max(pri->nRanges, nRanges);
|
|
|
|
|
if (card8)
|
|
|
|
|
{
|
|
|
|
|
pCARD8 = ((CARD8 *)&pri->pRanges[nRanges-1]) + byteoffset;
|
|
|
|
|
*pCARD8++ = interval.first;
|
|
|
|
|
*pCARD8 = interval.last;
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
pCARD16 = (CARD16 *)
|
|
|
|
|
(((char *)&pri->pRanges[nRanges-1]) + byteoffset);
|
|
|
|
|
*pCARD16++ = interval.first;
|
|
|
|
|
*pCARD16 = interval.last;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
if (pStartIndex)
|
|
|
|
|
*pStartIndex = nRanges;
|
|
|
|
|
return Success;
|
|
|
|
|
} /* RecordConvertSetToRanges */
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* RecordConvertMinorOpInfoToRanges
|
|
|
|
|
*
|
|
|
|
|
* Arguments:
|
|
|
|
|
* pMinOpInfo is the minor opcode info to convert to xRecordRanges.
|
|
|
|
|
* pri is where the result should be stored.
|
|
|
|
|
* byteoffset is the offset from the start of an xRecordRange of the
|
|
|
|
|
* four vales (CARD8 major_first, CARD8 major_last,
|
|
|
|
|
* CARD16 minor_first, CARD16 minor_last) we are going to store.
|
|
|
|
|
*
|
|
|
|
|
* Returns: BadAlloc if a memory allocation error occurred, else Success.
|
|
|
|
|
*
|
|
|
|
|
* Side Effects:
|
|
|
|
|
* If Success is returned, the slice of pri->pRanges indicated by
|
|
|
|
|
* byteoffset is filled in with the information from pMinOpInfo.
|
|
|
|
|
*/
|
|
|
|
|
static int
|
|
|
|
|
RecordConvertMinorOpInfoToRanges(
|
|
|
|
|
RecordMinorOpPtr pMinOpInfo,
|
|
|
|
|
GetContextRangeInfoPtr pri,
|
|
|
|
|
int byteoffset
|
|
|
|
|
)
|
|
|
|
|
{
|
|
|
|
|
int nsets;
|
|
|
|
|
int start;
|
|
|
|
|
int i;
|
|
|
|
|
int err;
|
|
|
|
|
|
|
|
|
|
if (!pMinOpInfo)
|
|
|
|
|
return Success;
|
|
|
|
|
|
|
|
|
|
nsets = pMinOpInfo->count;
|
|
|
|
|
pMinOpInfo++;
|
|
|
|
|
start = 0;
|
|
|
|
|
for (i = 0; i < nsets; i++)
|
|
|
|
|
{
|
|
|
|
|
int j, s;
|
|
|
|
|
s = start;
|
|
|
|
|
err = RecordConvertSetToRanges(pMinOpInfo[i].major.pMinOpSet, pri,
|
|
|
|
|
byteoffset + 2, FALSE, 65535, &start);
|
|
|
|
|
if (err != Success) return err;
|
|
|
|
|
for (j = s; j < start; j++)
|
|
|
|
|
{
|
|
|
|
|
CARD8 *pCARD8 = ((CARD8 *)&pri->pRanges[j]) + byteoffset;
|
|
|
|
|
*pCARD8++ = pMinOpInfo[i].major.first;
|
|
|
|
|
*pCARD8 = pMinOpInfo[i].major.last;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
return Success;
|
|
|
|
|
} /* RecordConvertMinorOpInfoToRanges */
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* RecordSwapRanges
|
|
|
|
|
*
|
|
|
|
|
* Arguments:
|
|
|
|
|
* pRanges is an array of xRecordRanges.
|
|
|
|
|
* nRanges is the number of elements in pRanges.
|
|
|
|
|
*
|
|
|
|
|
* Returns: nothing.
|
|
|
|
|
*
|
|
|
|
|
* Side Effects:
|
|
|
|
|
* The 16 bit fields of each xRecordRange are byte swapped.
|
|
|
|
|
*/
|
|
|
|
|
static void
|
|
|
|
|
RecordSwapRanges(xRecordRange *pRanges, int nRanges)
|
|
|
|
|
{
|
|
|
|
|
int i;
|
|
|
|
|
register char n;
|
|
|
|
|
for (i = 0; i < nRanges; i++, pRanges++)
|
|
|
|
|
{
|
|
|
|
|
swaps(&pRanges->extRequestsMinorFirst, n);
|
|
|
|
|
swaps(&pRanges->extRequestsMinorLast, n);
|
|
|
|
|
swaps(&pRanges->extRepliesMinorFirst, n);
|
|
|
|
|
swaps(&pRanges->extRepliesMinorLast, n);
|
|
|
|
|
}
|
|
|
|
|
} /* RecordSwapRanges */
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
static int
|
|
|
|
|
ProcRecordGetContext(ClientPtr client)
|
|
|
|
|
{
|
|
|
|
|
RecordContextPtr pContext;
|
|
|
|
|
REQUEST(xRecordGetContextReq);
|
|
|
|
|
xRecordGetContextReply rep;
|
|
|
|
|
int n;
|
|
|
|
|
RecordClientsAndProtocolPtr pRCAP;
|
|
|
|
|
int nRCAPs = 0;
|
|
|
|
|
GetContextRangeInfoPtr pRangeInfo;
|
|
|
|
|
GetContextRangeInfoPtr pri;
|
|
|
|
|
int i;
|
|
|
|
|
int err;
|
|
|
|
|
|
|
|
|
|
REQUEST_SIZE_MATCH(xRecordGetContextReq);
|
|
|
|
|
VERIFY_CONTEXT(pContext, stuff->context, client);
|
|
|
|
|
|
|
|
|
|
/* how many RCAPs are there on this context? */
|
|
|
|
|
|
|
|
|
|
for (pRCAP = pContext->pListOfRCAP; pRCAP; pRCAP = pRCAP->pNextRCAP)
|
|
|
|
|
nRCAPs++;
|
|
|
|
|
|
|
|
|
|
/* allocate and initialize space for record range info */
|
|
|
|
|
|
2010-12-05 08:36:02 -07:00
|
|
|
|
pRangeInfo = (GetContextRangeInfoPtr)malloc(
|
2006-11-26 11:13:41 -07:00
|
|
|
|
nRCAPs * sizeof(GetContextRangeInfoRec));
|
|
|
|
|
if (!pRangeInfo && nRCAPs > 0)
|
|
|
|
|
return BadAlloc;
|
|
|
|
|
for (i = 0; i < nRCAPs; i++)
|
|
|
|
|
{
|
|
|
|
|
pRangeInfo[i].pRanges = NULL;
|
|
|
|
|
pRangeInfo[i].size = 0;
|
|
|
|
|
pRangeInfo[i].nRanges = 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* convert the RCAP (internal) representation of the recorded protocol
|
|
|
|
|
* to the wire protocol (external) representation, storing the information
|
|
|
|
|
* for the ith RCAP in pri[i]
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
for (pRCAP = pContext->pListOfRCAP, pri = pRangeInfo;
|
|
|
|
|
pRCAP;
|
|
|
|
|
pRCAP = pRCAP->pNextRCAP, pri++)
|
|
|
|
|
{
|
|
|
|
|
xRecordRange rr;
|
|
|
|
|
|
|
|
|
|
err = RecordConvertSetToRanges(pRCAP->pRequestMajorOpSet, pri,
|
|
|
|
|
offset_of(rr, coreRequestsFirst), TRUE, 127, NULL);
|
|
|
|
|
if (err != Success) goto bailout;
|
|
|
|
|
|
|
|
|
|
err = RecordConvertSetToRanges(pRCAP->pReplyMajorOpSet, pri,
|
|
|
|
|
offset_of(rr, coreRepliesFirst), TRUE, 127, NULL);
|
|
|
|
|
if (err != Success) goto bailout;
|
|
|
|
|
|
|
|
|
|
err = RecordConvertSetToRanges(pRCAP->pDeliveredEventSet, pri,
|
|
|
|
|
offset_of(rr, deliveredEventsFirst), TRUE, 255, NULL);
|
|
|
|
|
if (err != Success) goto bailout;
|
|
|
|
|
|
|
|
|
|
err = RecordConvertSetToRanges(pRCAP->pDeviceEventSet, pri,
|
|
|
|
|
offset_of(rr, deviceEventsFirst), TRUE, 255, NULL);
|
|
|
|
|
if (err != Success) goto bailout;
|
|
|
|
|
|
|
|
|
|
err = RecordConvertSetToRanges(pRCAP->pErrorSet, pri,
|
|
|
|
|
offset_of(rr, errorsFirst), TRUE, 255, NULL);
|
|
|
|
|
if (err != Success) goto bailout;
|
|
|
|
|
|
|
|
|
|
err = RecordConvertMinorOpInfoToRanges(pRCAP->pRequestMinOpInfo,
|
|
|
|
|
pri, offset_of(rr, extRequestsMajorFirst));
|
|
|
|
|
if (err != Success) goto bailout;
|
|
|
|
|
|
|
|
|
|
err = RecordConvertMinorOpInfoToRanges(pRCAP->pReplyMinOpInfo,
|
|
|
|
|
pri, offset_of(rr, extRepliesMajorFirst));
|
|
|
|
|
if (err != Success) goto bailout;
|
|
|
|
|
|
|
|
|
|
if (pRCAP->clientStarted || pRCAP->clientDied)
|
|
|
|
|
{
|
|
|
|
|
if (pri->nRanges == 0)
|
|
|
|
|
RecordAllocRanges(pri, 1);
|
|
|
|
|
pri->pRanges[0].clientStarted = pRCAP->clientStarted;
|
|
|
|
|
pri->pRanges[0].clientDied = pRCAP->clientDied;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* calculate number of clients and reply length */
|
|
|
|
|
|
|
|
|
|
rep.nClients = 0;
|
|
|
|
|
rep.length = 0;
|
|
|
|
|
for (pRCAP = pContext->pListOfRCAP, pri = pRangeInfo;
|
|
|
|
|
pRCAP;
|
|
|
|
|
pRCAP = pRCAP->pNextRCAP, pri++)
|
|
|
|
|
{
|
|
|
|
|
rep.nClients += pRCAP->numClients;
|
|
|
|
|
rep.length += pRCAP->numClients *
|
2010-07-27 13:02:24 -06:00
|
|
|
|
( bytes_to_int32(sizeof(xRecordClientInfo)) +
|
|
|
|
|
pri->nRanges * bytes_to_int32(sizeof(xRecordRange)));
|
2006-11-26 11:13:41 -07:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* write the reply header */
|
|
|
|
|
|
|
|
|
|
rep.type = X_Reply;
|
|
|
|
|
rep.sequenceNumber = client->sequence;
|
|
|
|
|
rep.enabled = pContext->pRecordingClient != NULL;
|
|
|
|
|
rep.elementHeader = pContext->elemHeaders;
|
|
|
|
|
if(client->swapped)
|
|
|
|
|
{
|
|
|
|
|
swaps(&rep.sequenceNumber, n);
|
|
|
|
|
swapl(&rep.length, n);
|
|
|
|
|
swapl(&rep.nClients, n);
|
|
|
|
|
}
|
|
|
|
|
(void)WriteToClient(client, sizeof(xRecordGetContextReply),
|
|
|
|
|
(char *)&rep);
|
|
|
|
|
|
|
|
|
|
/* write all the CLIENT_INFOs */
|
|
|
|
|
|
|
|
|
|
for (pRCAP = pContext->pListOfRCAP, pri = pRangeInfo;
|
|
|
|
|
pRCAP;
|
|
|
|
|
pRCAP = pRCAP->pNextRCAP, pri++)
|
|
|
|
|
{
|
|
|
|
|
xRecordClientInfo rci;
|
|
|
|
|
rci.nRanges = pri->nRanges;
|
|
|
|
|
if (client->swapped)
|
|
|
|
|
{
|
|
|
|
|
swapl(&rci.nRanges, n);
|
|
|
|
|
RecordSwapRanges(pri->pRanges, pri->nRanges);
|
|
|
|
|
}
|
|
|
|
|
for (i = 0; i < pRCAP->numClients; i++)
|
|
|
|
|
{
|
|
|
|
|
rci.clientResource = pRCAP->pClientIDs[i];
|
|
|
|
|
if (client->swapped) swapl(&rci.clientResource, n);
|
|
|
|
|
WriteToClient(client, sizeof(xRecordClientInfo), (char *)&rci);
|
|
|
|
|
WriteToClient(client, sizeof(xRecordRange) * pri->nRanges,
|
|
|
|
|
(char *)pri->pRanges);
|
|
|
|
|
}
|
|
|
|
|
}
|
2010-12-05 08:36:02 -07:00
|
|
|
|
err = Success;
|
2006-11-26 11:13:41 -07:00
|
|
|
|
|
|
|
|
|
bailout:
|
|
|
|
|
for (i = 0; i < nRCAPs; i++)
|
|
|
|
|
{
|
2010-12-05 08:36:02 -07:00
|
|
|
|
free(pRangeInfo[i].pRanges);
|
2006-11-26 11:13:41 -07:00
|
|
|
|
}
|
2010-12-05 08:36:02 -07:00
|
|
|
|
free(pRangeInfo);
|
2006-11-26 11:13:41 -07:00
|
|
|
|
return err;
|
|
|
|
|
} /* ProcRecordGetContext */
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
static int
|
|
|
|
|
ProcRecordEnableContext(ClientPtr client)
|
|
|
|
|
{
|
|
|
|
|
RecordContextPtr pContext;
|
|
|
|
|
REQUEST(xRecordEnableContextReq);
|
|
|
|
|
int i;
|
|
|
|
|
RecordClientsAndProtocolPtr pRCAP;
|
|
|
|
|
|
|
|
|
|
REQUEST_SIZE_MATCH(xRecordGetContextReq);
|
|
|
|
|
VERIFY_CONTEXT(pContext, stuff->context, client);
|
|
|
|
|
if (pContext->pRecordingClient)
|
|
|
|
|
return BadMatch; /* already enabled */
|
|
|
|
|
|
|
|
|
|
/* install record hooks for each RCAP */
|
|
|
|
|
|
|
|
|
|
for (pRCAP = pContext->pListOfRCAP; pRCAP; pRCAP = pRCAP->pNextRCAP)
|
|
|
|
|
{
|
|
|
|
|
int err = RecordInstallHooks(pRCAP, 0);
|
|
|
|
|
if (err != Success)
|
|
|
|
|
{ /* undo the previous installs */
|
|
|
|
|
RecordClientsAndProtocolPtr pUninstallRCAP;
|
|
|
|
|
for (pUninstallRCAP = pContext->pListOfRCAP;
|
|
|
|
|
pUninstallRCAP != pRCAP;
|
|
|
|
|
pUninstallRCAP = pUninstallRCAP->pNextRCAP)
|
|
|
|
|
{
|
|
|
|
|
RecordUninstallHooks(pUninstallRCAP, 0);
|
|
|
|
|
}
|
|
|
|
|
return err;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Disallow further request processing on this connection until
|
|
|
|
|
* the context is disabled.
|
|
|
|
|
*/
|
|
|
|
|
IgnoreClient(client);
|
|
|
|
|
pContext->pRecordingClient = client;
|
|
|
|
|
|
|
|
|
|
/* Don't allow the data connection to record itself; unregister it. */
|
|
|
|
|
RecordDeleteClientFromContext(pContext,
|
|
|
|
|
pContext->pRecordingClient->clientAsMask);
|
|
|
|
|
|
|
|
|
|
/* move the newly enabled context to the front part of ppAllContexts,
|
|
|
|
|
* where all the enabled contexts are
|
|
|
|
|
*/
|
|
|
|
|
i = RecordFindContextOnAllContexts(pContext);
|
|
|
|
|
assert(i >= numEnabledContexts);
|
|
|
|
|
if (i != numEnabledContexts)
|
|
|
|
|
{
|
|
|
|
|
ppAllContexts[i] = ppAllContexts[numEnabledContexts];
|
|
|
|
|
ppAllContexts[numEnabledContexts] = pContext;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
++numEnabledContexts;
|
|
|
|
|
assert(numEnabledContexts > 0);
|
|
|
|
|
|
|
|
|
|
/* send StartOfData */
|
|
|
|
|
RecordAProtocolElement(pContext, NULL, XRecordStartOfData, NULL, 0, 0);
|
|
|
|
|
RecordFlushReplyBuffer(pContext, NULL, 0, NULL, 0);
|
|
|
|
|
return Success;
|
|
|
|
|
} /* ProcRecordEnableContext */
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* RecordDisableContext
|
|
|
|
|
*
|
|
|
|
|
* Arguments:
|
|
|
|
|
* pContext is the context to disable.
|
|
|
|
|
* nRanges is the number of elements in pRanges.
|
|
|
|
|
*
|
|
|
|
|
* Returns: nothing.
|
|
|
|
|
*
|
|
|
|
|
* Side Effects:
|
|
|
|
|
* If the context was enabled, it is disabled. An EndOfData
|
|
|
|
|
* message is sent to the recording client. Recording hooks for
|
|
|
|
|
* this context are uninstalled. The context is moved to the
|
|
|
|
|
* rear part of the ppAllContexts array. numEnabledContexts is
|
|
|
|
|
* decremented. Request processing for the formerly recording client
|
|
|
|
|
* is resumed.
|
|
|
|
|
*/
|
|
|
|
|
static void
|
|
|
|
|
RecordDisableContext(RecordContextPtr pContext)
|
|
|
|
|
{
|
|
|
|
|
RecordClientsAndProtocolPtr pRCAP;
|
|
|
|
|
int i;
|
|
|
|
|
|
|
|
|
|
if (!pContext->pRecordingClient) return;
|
|
|
|
|
if (!pContext->pRecordingClient->clientGone)
|
|
|
|
|
{
|
|
|
|
|
RecordAProtocolElement(pContext, NULL, XRecordEndOfData, NULL, 0, 0);
|
|
|
|
|
RecordFlushReplyBuffer(pContext, NULL, 0, NULL, 0);
|
|
|
|
|
/* Re-enable request processing on this connection. */
|
|
|
|
|
AttendClient(pContext->pRecordingClient);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
for (pRCAP = pContext->pListOfRCAP; pRCAP; pRCAP = pRCAP->pNextRCAP)
|
|
|
|
|
{
|
|
|
|
|
RecordUninstallHooks(pRCAP, 0);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
pContext->pRecordingClient = NULL;
|
|
|
|
|
|
|
|
|
|
/* move the newly disabled context to the rear part of ppAllContexts,
|
|
|
|
|
* where all the disabled contexts are
|
|
|
|
|
*/
|
|
|
|
|
i = RecordFindContextOnAllContexts(pContext);
|
|
|
|
|
assert( (i != -1) && (i < numEnabledContexts) );
|
|
|
|
|
if (i != (numEnabledContexts - 1) )
|
|
|
|
|
{
|
|
|
|
|
ppAllContexts[i] = ppAllContexts[numEnabledContexts-1];
|
|
|
|
|
ppAllContexts[numEnabledContexts-1] = pContext;
|
|
|
|
|
}
|
|
|
|
|
--numEnabledContexts;
|
|
|
|
|
assert(numEnabledContexts >= 0);
|
|
|
|
|
} /* RecordDisableContext */
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
static int
|
|
|
|
|
ProcRecordDisableContext(ClientPtr client)
|
|
|
|
|
{
|
|
|
|
|
RecordContextPtr pContext;
|
|
|
|
|
REQUEST(xRecordDisableContextReq);
|
|
|
|
|
|
|
|
|
|
REQUEST_SIZE_MATCH(xRecordDisableContextReq);
|
|
|
|
|
VERIFY_CONTEXT(pContext, stuff->context, client);
|
|
|
|
|
RecordDisableContext(pContext);
|
|
|
|
|
return Success;
|
|
|
|
|
} /* ProcRecordDisableContext */
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* RecordDeleteContext
|
|
|
|
|
*
|
|
|
|
|
* Arguments:
|
|
|
|
|
* value is the context to delete.
|
|
|
|
|
* id is its resource ID.
|
|
|
|
|
*
|
|
|
|
|
* Returns: Success.
|
|
|
|
|
*
|
|
|
|
|
* Side Effects:
|
|
|
|
|
* Disables the context, frees all associated memory, and removes
|
|
|
|
|
* it from the ppAllContexts array.
|
|
|
|
|
*/
|
|
|
|
|
static int
|
|
|
|
|
RecordDeleteContext(pointer value, XID id)
|
|
|
|
|
{
|
|
|
|
|
int i;
|
|
|
|
|
RecordContextPtr pContext = (RecordContextPtr)value;
|
|
|
|
|
RecordClientsAndProtocolPtr pRCAP;
|
|
|
|
|
|
|
|
|
|
RecordDisableContext(pContext);
|
|
|
|
|
|
|
|
|
|
/* Remove all the clients from all the RCAPs.
|
|
|
|
|
* As a result, the RCAPs will be freed.
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
while ((pRCAP = pContext->pListOfRCAP))
|
|
|
|
|
{
|
|
|
|
|
int numClients = pRCAP->numClients;
|
|
|
|
|
/* when the last client is deleted, the RCAP will go away. */
|
|
|
|
|
while(numClients--)
|
|
|
|
|
{
|
|
|
|
|
RecordDeleteClientFromRCAP(pRCAP, numClients);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* remove context from AllContexts list */
|
|
|
|
|
|
|
|
|
|
if (-1 != (i = RecordFindContextOnAllContexts(pContext)))
|
|
|
|
|
{
|
|
|
|
|
ppAllContexts[i] = ppAllContexts[numContexts - 1];
|
|
|
|
|
if (--numContexts == 0)
|
|
|
|
|
{
|
2010-12-05 08:36:02 -07:00
|
|
|
|
free(ppAllContexts);
|
2006-11-26 11:13:41 -07:00
|
|
|
|
ppAllContexts = NULL;
|
|
|
|
|
}
|
|
|
|
|
}
|
2010-12-05 08:36:02 -07:00
|
|
|
|
free(pContext);
|
|
|
|
|
|
2006-11-26 11:13:41 -07:00
|
|
|
|
return Success;
|
|
|
|
|
} /* RecordDeleteContext */
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
static int
|
|
|
|
|
ProcRecordFreeContext(ClientPtr client)
|
|
|
|
|
{
|
|
|
|
|
RecordContextPtr pContext;
|
|
|
|
|
REQUEST(xRecordFreeContextReq);
|
|
|
|
|
|
|
|
|
|
REQUEST_SIZE_MATCH(xRecordFreeContextReq);
|
|
|
|
|
VERIFY_CONTEXT(pContext, stuff->context, client);
|
|
|
|
|
FreeResource(stuff->context, RT_NONE);
|
|
|
|
|
return Success;
|
|
|
|
|
} /* ProcRecordFreeContext */
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
static int
|
|
|
|
|
ProcRecordDispatch(ClientPtr client)
|
|
|
|
|
{
|
|
|
|
|
REQUEST(xReq);
|
|
|
|
|
|
|
|
|
|
switch (stuff->data)
|
|
|
|
|
{
|
|
|
|
|
case X_RecordQueryVersion:
|
|
|
|
|
return ProcRecordQueryVersion(client);
|
|
|
|
|
case X_RecordCreateContext:
|
|
|
|
|
return ProcRecordCreateContext(client);
|
|
|
|
|
case X_RecordRegisterClients:
|
|
|
|
|
return ProcRecordRegisterClients(client);
|
|
|
|
|
case X_RecordUnregisterClients:
|
|
|
|
|
return ProcRecordUnregisterClients(client);
|
|
|
|
|
case X_RecordGetContext:
|
|
|
|
|
return ProcRecordGetContext(client);
|
|
|
|
|
case X_RecordEnableContext:
|
|
|
|
|
return ProcRecordEnableContext(client);
|
|
|
|
|
case X_RecordDisableContext:
|
|
|
|
|
return ProcRecordDisableContext(client);
|
|
|
|
|
case X_RecordFreeContext:
|
|
|
|
|
return ProcRecordFreeContext(client);
|
|
|
|
|
default:
|
|
|
|
|
return BadRequest;
|
|
|
|
|
}
|
|
|
|
|
} /* ProcRecordDispatch */
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
static int
|
|
|
|
|
SProcRecordQueryVersion(ClientPtr client)
|
|
|
|
|
{
|
|
|
|
|
REQUEST(xRecordQueryVersionReq);
|
|
|
|
|
register char n;
|
|
|
|
|
|
|
|
|
|
swaps(&stuff->length, n);
|
|
|
|
|
REQUEST_SIZE_MATCH(xRecordQueryVersionReq);
|
|
|
|
|
swaps(&stuff->majorVersion, n);
|
|
|
|
|
swaps(&stuff->minorVersion,n);
|
|
|
|
|
return ProcRecordQueryVersion(client);
|
|
|
|
|
} /* SProcRecordQueryVersion */
|
|
|
|
|
|
|
|
|
|
|
2008-06-11 09:39:26 -06:00
|
|
|
|
static int
|
2006-11-26 11:13:41 -07:00
|
|
|
|
SwapCreateRegister(xRecordRegisterClientsReq *stuff)
|
|
|
|
|
{
|
|
|
|
|
register char n;
|
|
|
|
|
int i;
|
|
|
|
|
XID *pClientID;
|
|
|
|
|
|
|
|
|
|
swapl(&stuff->context, n);
|
|
|
|
|
swapl(&stuff->nClients, n);
|
|
|
|
|
swapl(&stuff->nRanges, n);
|
|
|
|
|
pClientID = (XID *)&stuff[1];
|
2010-07-27 13:02:24 -06:00
|
|
|
|
if (stuff->nClients > stuff->length - bytes_to_int32(sz_xRecordRegisterClientsReq))
|
2008-06-11 09:39:26 -06:00
|
|
|
|
return BadLength;
|
2006-11-26 11:13:41 -07:00
|
|
|
|
for (i = 0; i < stuff->nClients; i++, pClientID++)
|
|
|
|
|
{
|
|
|
|
|
swapl(pClientID, n);
|
|
|
|
|
}
|
2010-07-27 13:02:24 -06:00
|
|
|
|
if (stuff->nRanges > stuff->length - bytes_to_int32(sz_xRecordRegisterClientsReq)
|
2008-06-11 09:39:26 -06:00
|
|
|
|
- stuff->nClients)
|
|
|
|
|
return BadLength;
|
2006-11-26 11:13:41 -07:00
|
|
|
|
RecordSwapRanges((xRecordRange *)pClientID, stuff->nRanges);
|
2008-06-11 09:39:26 -06:00
|
|
|
|
return Success;
|
2006-11-26 11:13:41 -07:00
|
|
|
|
} /* SwapCreateRegister */
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
static int
|
|
|
|
|
SProcRecordCreateContext(ClientPtr client)
|
|
|
|
|
{
|
|
|
|
|
REQUEST(xRecordCreateContextReq);
|
2008-06-11 09:39:26 -06:00
|
|
|
|
int status;
|
2006-11-26 11:13:41 -07:00
|
|
|
|
register char n;
|
|
|
|
|
|
|
|
|
|
swaps(&stuff->length, n);
|
|
|
|
|
REQUEST_AT_LEAST_SIZE(xRecordCreateContextReq);
|
2008-06-11 09:39:26 -06:00
|
|
|
|
if ((status = SwapCreateRegister((pointer)stuff)) != Success)
|
|
|
|
|
return status;
|
2006-11-26 11:13:41 -07:00
|
|
|
|
return ProcRecordCreateContext(client);
|
|
|
|
|
} /* SProcRecordCreateContext */
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
static int
|
|
|
|
|
SProcRecordRegisterClients(ClientPtr client)
|
|
|
|
|
{
|
|
|
|
|
REQUEST(xRecordRegisterClientsReq);
|
2008-06-11 09:39:26 -06:00
|
|
|
|
int status;
|
2006-11-26 11:13:41 -07:00
|
|
|
|
register char n;
|
|
|
|
|
|
|
|
|
|
swaps(&stuff->length, n);
|
|
|
|
|
REQUEST_AT_LEAST_SIZE(xRecordRegisterClientsReq);
|
2008-06-11 09:39:26 -06:00
|
|
|
|
if ((status = SwapCreateRegister((pointer)stuff)) != Success)
|
|
|
|
|
return status;
|
2006-11-26 11:13:41 -07:00
|
|
|
|
return ProcRecordRegisterClients(client);
|
|
|
|
|
} /* SProcRecordRegisterClients */
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
static int
|
|
|
|
|
SProcRecordUnregisterClients(ClientPtr client)
|
|
|
|
|
{
|
|
|
|
|
REQUEST(xRecordUnregisterClientsReq);
|
|
|
|
|
register char n;
|
|
|
|
|
|
|
|
|
|
swaps(&stuff->length, n);
|
|
|
|
|
REQUEST_AT_LEAST_SIZE(xRecordUnregisterClientsReq);
|
|
|
|
|
swapl(&stuff->context, n);
|
|
|
|
|
swapl(&stuff->nClients, n);
|
|
|
|
|
SwapRestL(stuff);
|
|
|
|
|
return ProcRecordUnregisterClients(client);
|
|
|
|
|
} /* SProcRecordUnregisterClients */
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
static int
|
|
|
|
|
SProcRecordGetContext(ClientPtr client)
|
|
|
|
|
{
|
|
|
|
|
REQUEST(xRecordGetContextReq);
|
|
|
|
|
register char n;
|
|
|
|
|
|
|
|
|
|
swaps(&stuff->length, n);
|
|
|
|
|
REQUEST_SIZE_MATCH(xRecordGetContextReq);
|
|
|
|
|
swapl(&stuff->context, n);
|
|
|
|
|
return ProcRecordGetContext(client);
|
|
|
|
|
} /* SProcRecordGetContext */
|
|
|
|
|
|
|
|
|
|
static int
|
|
|
|
|
SProcRecordEnableContext(ClientPtr client)
|
|
|
|
|
{
|
|
|
|
|
REQUEST(xRecordEnableContextReq);
|
|
|
|
|
register char n;
|
|
|
|
|
|
|
|
|
|
swaps(&stuff->length, n);
|
|
|
|
|
REQUEST_SIZE_MATCH(xRecordEnableContextReq);
|
|
|
|
|
swapl(&stuff->context, n);
|
|
|
|
|
return ProcRecordEnableContext(client);
|
|
|
|
|
} /* SProcRecordEnableContext */
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
static int
|
|
|
|
|
SProcRecordDisableContext(ClientPtr client)
|
|
|
|
|
{
|
|
|
|
|
REQUEST(xRecordDisableContextReq);
|
|
|
|
|
register char n;
|
|
|
|
|
|
|
|
|
|
swaps(&stuff->length, n);
|
|
|
|
|
REQUEST_SIZE_MATCH(xRecordDisableContextReq);
|
|
|
|
|
swapl(&stuff->context, n);
|
|
|
|
|
return ProcRecordDisableContext(client);
|
|
|
|
|
} /* SProcRecordDisableContext */
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
static int
|
|
|
|
|
SProcRecordFreeContext(ClientPtr client)
|
|
|
|
|
{
|
|
|
|
|
REQUEST(xRecordFreeContextReq);
|
|
|
|
|
register char n;
|
|
|
|
|
|
|
|
|
|
swaps(&stuff->length, n);
|
|
|
|
|
REQUEST_SIZE_MATCH(xRecordFreeContextReq);
|
|
|
|
|
swapl(&stuff->context, n);
|
|
|
|
|
return ProcRecordFreeContext(client);
|
|
|
|
|
} /* SProcRecordFreeContext */
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
static int
|
|
|
|
|
SProcRecordDispatch(ClientPtr client)
|
|
|
|
|
{
|
|
|
|
|
REQUEST(xReq);
|
|
|
|
|
|
|
|
|
|
switch (stuff->data)
|
|
|
|
|
{
|
|
|
|
|
case X_RecordQueryVersion:
|
|
|
|
|
return SProcRecordQueryVersion(client);
|
|
|
|
|
case X_RecordCreateContext:
|
|
|
|
|
return SProcRecordCreateContext(client);
|
|
|
|
|
case X_RecordRegisterClients:
|
|
|
|
|
return SProcRecordRegisterClients(client);
|
|
|
|
|
case X_RecordUnregisterClients:
|
|
|
|
|
return SProcRecordUnregisterClients(client);
|
|
|
|
|
case X_RecordGetContext:
|
|
|
|
|
return SProcRecordGetContext(client);
|
|
|
|
|
case X_RecordEnableContext:
|
|
|
|
|
return SProcRecordEnableContext(client);
|
|
|
|
|
case X_RecordDisableContext:
|
|
|
|
|
return SProcRecordDisableContext(client);
|
|
|
|
|
case X_RecordFreeContext:
|
|
|
|
|
return SProcRecordFreeContext(client);
|
|
|
|
|
default:
|
|
|
|
|
return BadRequest;
|
|
|
|
|
}
|
|
|
|
|
} /* SProcRecordDispatch */
|
|
|
|
|
|
|
|
|
|
/* RecordConnectionSetupInfo
|
|
|
|
|
*
|
|
|
|
|
* Arguments:
|
|
|
|
|
* pContext is an enabled context that specifies recording of
|
|
|
|
|
* connection setup info.
|
|
|
|
|
* pci holds the connection setup info.
|
|
|
|
|
*
|
|
|
|
|
* Returns: nothing.
|
|
|
|
|
*
|
|
|
|
|
* Side Effects:
|
|
|
|
|
* The connection setup info is sent to the recording client.
|
|
|
|
|
*/
|
|
|
|
|
static void
|
|
|
|
|
RecordConnectionSetupInfo(RecordContextPtr pContext, NewClientInfoRec *pci)
|
|
|
|
|
{
|
|
|
|
|
int prefixsize = SIZEOF(xConnSetupPrefix);
|
|
|
|
|
int restsize = pci->prefix->length * 4;
|
|
|
|
|
|
|
|
|
|
if (pci->client->swapped)
|
|
|
|
|
{
|
2010-12-05 08:36:02 -07:00
|
|
|
|
char *pConnSetup = (char *)malloc(prefixsize + restsize);
|
2006-11-26 11:13:41 -07:00
|
|
|
|
if (!pConnSetup)
|
|
|
|
|
return;
|
2010-07-27 13:02:24 -06:00
|
|
|
|
SwapConnSetupPrefix(pci->prefix, (xConnSetupPrefix*)pConnSetup);
|
|
|
|
|
SwapConnSetupInfo((char*)pci->setup, (char*)(pConnSetup + prefixsize));
|
2006-11-26 11:13:41 -07:00
|
|
|
|
RecordAProtocolElement(pContext, pci->client, XRecordClientStarted,
|
|
|
|
|
(pointer)pConnSetup, prefixsize + restsize, 0);
|
2010-12-05 08:36:02 -07:00
|
|
|
|
free(pConnSetup);
|
2006-11-26 11:13:41 -07:00
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
/* don't alloc and copy as in the swapped case; just send the
|
|
|
|
|
* data in two pieces
|
|
|
|
|
*/
|
|
|
|
|
RecordAProtocolElement(pContext, pci->client, XRecordClientStarted,
|
|
|
|
|
(pointer)pci->prefix, prefixsize, restsize);
|
|
|
|
|
RecordAProtocolElement(pContext, pci->client, XRecordClientStarted,
|
|
|
|
|
(pointer)pci->setup, restsize, /* continuation */ -1);
|
|
|
|
|
}
|
|
|
|
|
} /* RecordConnectionSetupInfo */
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* RecordDeleteContext
|
|
|
|
|
*
|
|
|
|
|
* Arguments:
|
|
|
|
|
* pcbl is &ClientStateCallback.
|
|
|
|
|
* nullata is NULL.
|
|
|
|
|
* calldata is a pointer to a NewClientInfoRec (include/dixstruct.h)
|
|
|
|
|
* which contains information about client state changes.
|
|
|
|
|
*
|
|
|
|
|
* Returns: nothing.
|
|
|
|
|
*
|
|
|
|
|
* Side Effects:
|
|
|
|
|
* If a new client has connected and any contexts have specified
|
|
|
|
|
* XRecordFutureClients, the new client is registered on those contexts.
|
|
|
|
|
* If any of those contexts specify recording of the connection setup
|
|
|
|
|
* info, it is recorded.
|
|
|
|
|
*
|
|
|
|
|
* If an existing client has disconnected, it is deleted from any
|
|
|
|
|
* contexts that it was registered on. If any of those contexts
|
|
|
|
|
* specified XRecordClientDied, they record a ClientDied protocol element.
|
|
|
|
|
* If the disconnectiong client happened to be the data connection of an
|
|
|
|
|
* enabled context, the context is disabled.
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
RecordAClientStateChange(CallbackListPtr *pcbl, pointer nulldata, pointer calldata)
|
|
|
|
|
{
|
|
|
|
|
NewClientInfoRec *pci = (NewClientInfoRec *)calldata;
|
|
|
|
|
int i;
|
|
|
|
|
ClientPtr pClient = pci->client;
|
2010-12-05 08:36:02 -07:00
|
|
|
|
RecordContextPtr *ppAllContextsCopy = NULL;
|
|
|
|
|
int numContextsCopy = 0;
|
2006-11-26 11:13:41 -07:00
|
|
|
|
|
|
|
|
|
switch (pClient->clientState)
|
|
|
|
|
{
|
|
|
|
|
case ClientStateRunning: /* new client */
|
|
|
|
|
for (i = 0; i < numContexts; i++)
|
|
|
|
|
{
|
|
|
|
|
RecordClientsAndProtocolPtr pRCAP;
|
|
|
|
|
RecordContextPtr pContext = ppAllContexts[i];
|
|
|
|
|
|
|
|
|
|
if ((pRCAP = RecordFindClientOnContext(pContext,
|
|
|
|
|
XRecordFutureClients, NULL)))
|
|
|
|
|
{
|
|
|
|
|
RecordAddClientToRCAP(pRCAP, pClient->clientAsMask);
|
|
|
|
|
if (pContext->pRecordingClient && pRCAP->clientStarted)
|
|
|
|
|
RecordConnectionSetupInfo(pContext, pci);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case ClientStateGone:
|
|
|
|
|
case ClientStateRetained: /* client disconnected */
|
2010-12-05 08:36:02 -07:00
|
|
|
|
|
|
|
|
|
/* RecordDisableContext modifies contents of ppAllContexts. */
|
|
|
|
|
numContextsCopy = numContexts;
|
|
|
|
|
ppAllContextsCopy = malloc(numContextsCopy * sizeof(RecordContextPtr));
|
|
|
|
|
assert(ppAllContextsCopy);
|
|
|
|
|
memcpy(ppAllContextsCopy, ppAllContexts, numContextsCopy * sizeof(RecordContextPtr));
|
|
|
|
|
|
|
|
|
|
for (i = 0; i < numContextsCopy; i++)
|
2006-11-26 11:13:41 -07:00
|
|
|
|
{
|
|
|
|
|
RecordClientsAndProtocolPtr pRCAP;
|
2010-12-05 08:36:02 -07:00
|
|
|
|
RecordContextPtr pContext = ppAllContextsCopy[i];
|
2006-11-26 11:13:41 -07:00
|
|
|
|
int pos;
|
|
|
|
|
|
|
|
|
|
if (pContext->pRecordingClient == pClient)
|
|
|
|
|
RecordDisableContext(pContext);
|
|
|
|
|
if ((pRCAP = RecordFindClientOnContext(pContext,
|
|
|
|
|
pClient->clientAsMask, &pos)))
|
|
|
|
|
{
|
|
|
|
|
if (pContext->pRecordingClient && pRCAP->clientDied)
|
|
|
|
|
RecordAProtocolElement(pContext, pClient,
|
|
|
|
|
XRecordClientDied, NULL, 0, 0);
|
|
|
|
|
RecordDeleteClientFromRCAP(pRCAP, pos);
|
|
|
|
|
}
|
|
|
|
|
}
|
2010-12-05 08:36:02 -07:00
|
|
|
|
|
|
|
|
|
free(ppAllContextsCopy);
|
2006-11-26 11:13:41 -07:00
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
default:
|
|
|
|
|
break;
|
|
|
|
|
} /* end switch on client state */
|
|
|
|
|
} /* RecordAClientStateChange */
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* RecordCloseDown
|
|
|
|
|
*
|
|
|
|
|
* Arguments:
|
|
|
|
|
* extEntry is the extension information for RECORD.
|
|
|
|
|
*
|
|
|
|
|
* Returns: nothing.
|
|
|
|
|
*
|
|
|
|
|
* Side Effects:
|
|
|
|
|
* Performs any cleanup needed by RECORD at server shutdown time.
|
|
|
|
|
*
|
|
|
|
|
*/
|
|
|
|
|
static void
|
|
|
|
|
RecordCloseDown(ExtensionEntry *extEntry)
|
|
|
|
|
{
|
|
|
|
|
DeleteCallback(&ClientStateCallback, RecordAClientStateChange, NULL);
|
|
|
|
|
} /* RecordCloseDown */
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* RecordExtensionInit
|
|
|
|
|
*
|
|
|
|
|
* Arguments: none.
|
|
|
|
|
*
|
|
|
|
|
* Returns: nothing.
|
|
|
|
|
*
|
|
|
|
|
* Side Effects:
|
|
|
|
|
* Enables the RECORD extension if possible.
|
|
|
|
|
*/
|
|
|
|
|
void
|
|
|
|
|
RecordExtensionInit(void)
|
|
|
|
|
{
|
|
|
|
|
ExtensionEntry *extentry;
|
|
|
|
|
|
2010-07-27 13:02:24 -06:00
|
|
|
|
RTContext = CreateNewResourceType(RecordDeleteContext, "RecordContext");
|
2006-11-26 11:13:41 -07:00
|
|
|
|
if (!RTContext)
|
|
|
|
|
return;
|
|
|
|
|
|
2010-12-05 08:36:02 -07:00
|
|
|
|
if (!dixRegisterPrivateKey(RecordClientPrivateKey, PRIVATE_CLIENT, 0))
|
|
|
|
|
return;
|
|
|
|
|
|
2006-11-26 11:13:41 -07:00
|
|
|
|
ppAllContexts = NULL;
|
|
|
|
|
numContexts = numEnabledContexts = numEnabledRCAPs = 0;
|
|
|
|
|
|
|
|
|
|
if (!AddCallback(&ClientStateCallback, RecordAClientStateChange, NULL))
|
|
|
|
|
return;
|
|
|
|
|
|
|
|
|
|
extentry = AddExtension(RECORD_NAME, RecordNumEvents, RecordNumErrors,
|
|
|
|
|
ProcRecordDispatch, SProcRecordDispatch,
|
|
|
|
|
RecordCloseDown, StandardMinorOpcode);
|
|
|
|
|
if (!extentry)
|
|
|
|
|
{
|
|
|
|
|
DeleteCallback(&ClientStateCallback, RecordAClientStateChange, NULL);
|
|
|
|
|
return;
|
|
|
|
|
}
|
2010-12-05 08:36:02 -07:00
|
|
|
|
SetResourceTypeErrorValue(RTContext, extentry->errorBase + XRecordBadContext);
|
2006-11-26 11:13:41 -07:00
|
|
|
|
|
|
|
|
|
} /* RecordExtensionInit */
|
|
|
|
|
|