/* Copyright (C) 2003-2006 Jamey Sharp, Josh Triplett

 * This file is licensed under the MIT license. See the file COPYING. */

#ifdef HAVE_CONFIG_H

#include <config.h>

#endif

#include "Xlibint.h"

#include "locking.h"

#include "Xprivate.h"

#include "Xxcbint.h"

#include <xcb/xcbext.h>

#include <assert.h>

#ifdef HAVE_INTTYPES_H

#include <inttypes.h>

#endif

#include <stdio.h>

#include <stdint.h>

#include <stdlib.h>

#include <string.h>

#include <limits.h>

#ifdef HAVE_SYS_SELECT_H

#include <sys/select.h>

#endif

#define xcb_fail_assert(_message, _var) { \

	unsigned int _var = 1; \

	fprintf(stderr, "[xcb] Aborting, sorry about that.\n"); \

	assert(!_var); \

}

#define throw_thread_fail_assert(_message, _var) { \

	fprintf(stderr, "[xcb] " _message "\n"); \

	fprintf(stderr, "[xcb] Most likely this is a multi-threaded client " \

	                "and XInitThreads has not been called\n"); \

	xcb_fail_assert(_message, _var); \

}

/* XXX: It would probably be most useful if we stored the last-processed

 *      request, so we could find the offender from the message. */

#define throw_extlib_fail_assert(_message, _var) { \

	fprintf(stderr, "[xcb] " _message "\n"); \

	fprintf(stderr, "[xcb] This is most likely caused by a broken X " \

	                "extension library\n"); \

	xcb_fail_assert(_message, _var); \

}

static void return_socket(void *closure)

{

	Display *dpy = closure;

	InternalLockDisplay(dpy, /* don't skip user locks */ 0);

	_XSend(dpy, NULL, 0);

	dpy->bufmax = dpy->buffer;

	UnlockDisplay(dpy);

}

static void require_socket(Display *dpy)

{

	if(dpy->bufmax == dpy->buffer)

	{

		uint64_t sent;

		int flags = 0;

		/* if we don't own the event queue, we have to ask XCB

		 * to set our errors aside for us. */

		if(dpy->xcb->event_owner != XlibOwnsEventQueue)

			flags = XCB_REQUEST_CHECKED;

		if(!xcb_take_socket(dpy->xcb->connection, return_socket, dpy,

		                    flags, &sent))

			_XIOError(dpy);

		dpy->xcb->last_flushed = sent;

		X_DPY_SET_REQUEST(dpy, sent);

		dpy->bufmax = dpy->xcb->real_bufmax;

	}

}

/* Call internal connection callbacks for any fds that are currently

 * ready to read. This function will not block unless one of the

 * callbacks blocks.

 *

 * This code borrowed from _XWaitForReadable. Inverse call tree:

 * _XRead

 *  _XWaitForWritable

 *   _XFlush

 *   _XSend

 *  _XEventsQueued

 *  _XReadEvents

 *  _XRead[0-9]+

 *   _XAllocIDs

 *  _XReply

 *  _XEatData

 * _XReadPad

 */

static void check_internal_connections(Display *dpy)

{

	struct _XConnectionInfo *ilist;

	fd_set r_mask;

	struct timeval tv;

	int result;

	int highest_fd = -1;

	if(dpy->flags & XlibDisplayProcConni || !dpy->im_fd_info)

		return;

	FD_ZERO(&r_mask);

	for(ilist = dpy->im_fd_info; ilist; ilist = ilist->next)

	{

		assert(ilist->fd >= 0);

		FD_SET(ilist->fd, &r_mask);

		if(ilist->fd > highest_fd)

			highest_fd = ilist->fd;

	}

	assert(highest_fd >= 0);

	tv.tv_sec = 0;

	tv.tv_usec = 0;

	result = select(highest_fd + 1, &r_mask, NULL, NULL, &tv;;

	if(result == -1)

	{

		if(errno == EINTR)

			return;

		_XIOError(dpy);

	}

	for(ilist = dpy->im_fd_info; result && ilist; ilist = ilist->next)

		if(FD_ISSET(ilist->fd, &r_mask))

		{

			_XProcessInternalConnection(dpy, ilist);

			--result;

		}

}

static PendingRequest *append_pending_request(Display *dpy, uint64_t sequence)

{

	PendingRequest *node = malloc(sizeof(PendingRequest));

	assert(node);

	node->next = NULL;

	node->sequence = sequence;

	node->reply_waiter = 0;

	if(dpy->xcb->pending_requests_tail)

	{

		if (XLIB_SEQUENCE_COMPARE(dpy->xcb->pending_requests_tail->sequence,

		                          >=, node->sequence))

			throw_thread_fail_assert("Unknown sequence number "

			                         "while appending request",

			                         xcb_xlib_unknown_seq_number);

		if (dpy->xcb->pending_requests_tail->next != NULL)

			throw_thread_fail_assert("Unknown request in queue "

			                         "while appending request",

			                         xcb_xlib_unknown_req_pending);

		dpy->xcb->pending_requests_tail->next = node;

	}

	else

		dpy->xcb->pending_requests = node;

	dpy->xcb->pending_requests_tail = node;

	return node;

}

static void dequeue_pending_request(Display *dpy, PendingRequest *req)

{

	if (req != dpy->xcb->pending_requests)

		throw_thread_fail_assert("Unknown request in queue while "

		                         "dequeuing",

		                         xcb_xlib_unknown_req_in_deq);

	dpy->xcb->pending_requests = req->next;

	if(!dpy->xcb->pending_requests)

	{

		if (req != dpy->xcb->pending_requests_tail)

			throw_thread_fail_assert("Unknown request in queue "

			                         "while dequeuing",

			                         xcb_xlib_unknown_req_in_deq);

		dpy->xcb->pending_requests_tail = NULL;

	}

	else if (XLIB_SEQUENCE_COMPARE(req->sequence, >=,

	                               dpy->xcb->pending_requests->sequence))

		throw_thread_fail_assert("Unknown sequence number while "

		                         "dequeuing request",

		                         xcb_xlib_threads_sequence_lost);

	free(req);

}

static int handle_error(Display *dpy, xError *err, Bool in_XReply)

{

	_XExtension *ext;

	int ret_code;

	/* Oddly, Xlib only allows extensions to suppress errors when

	 * those errors were seen by _XReply. */

	if(in_XReply)

		/*

		 * we better see if there is an extension who may

		 * want to suppress the error.

		 */

		for(ext = dpy->ext_procs; ext; ext = ext->next)

			if(ext->error && (*ext->error)(dpy, err, &ext->codes, &ret_code))

				return ret_code;

	_XError(dpy, err);

	return 0;

}

/* Widen a 32-bit sequence number into a 64bit (uint64_t) sequence number.

 */

static void widen(uint64_t *wide, unsigned int narrow)

{

	*wide += (int32_t) (narrow - *wide);

}

/* Thread-safety rules:

 *

 * At most one thread can be reading from XCB's event queue at a time.

 * If you are not the current event-reading thread and you need to find

 * out if an event is available, you must wait.

 *

 * The same rule applies for reading replies.

 *

 * A single thread cannot be both the the event-reading and the

 * reply-reading thread at the same time.

 *

 * We always look at both the current event and the first pending reply

 * to decide which to process next.

 *

 * We always process all responses in sequence-number order, which may

 * mean waiting for another thread (either the event_waiter or the

 * reply_waiter) to handle an earlier response before we can process or

 * return a later one. If so, we wait on the corresponding condition

 * variable for that thread to process the response and wake us up.

 */

static xcb_generic_reply_t *poll_for_event(Display *dpy, Bool queued_only)

{

	/* Make sure the Display's sequence numbers are valid */

	require_socket(dpy);

	/* Precondition: This thread can safely get events from XCB. */

	assert(dpy->xcb->event_owner == XlibOwnsEventQueue && !dpy->xcb->event_waiter);

	if(!dpy->xcb->next_event) {

		if(queued_only)

			dpy->xcb->next_event = xcb_poll_for_queued_event(dpy->xcb->connection);

		else

			dpy->xcb->next_event = xcb_poll_for_event(dpy->xcb->connection);

	}

	if(dpy->xcb->next_event)

	{

		PendingRequest *req = dpy->xcb->pending_requests;

		xcb_generic_event_t *event = dpy->xcb->next_event;

		uint64_t event_sequence = X_DPY_GET_LAST_REQUEST_READ(dpy);

		widen(&event_sequence, event->full_sequence);

		if(!req || XLIB_SEQUENCE_COMPARE(event_sequence, <, req->sequence)

		        || (event->response_type != X_Error && event_sequence == req->sequence))

		{

			uint64_t request = X_DPY_GET_REQUEST(dpy);

			if (XLIB_SEQUENCE_COMPARE(event_sequence, >, request))

			{

				throw_thread_fail_assert("Unknown sequence "

				                         "number while "

							 "processing queue",

				                xcb_xlib_threads_sequence_lost);

			}

			X_DPY_SET_LAST_REQUEST_READ(dpy, event_sequence);

			dpy->xcb->next_event = NULL;

			return (xcb_generic_reply_t *) event;

		}

	}

	return NULL;

}

static xcb_generic_reply_t *poll_for_response(Display *dpy)

{

	void *response;

	xcb_generic_error_t *error;

	PendingRequest *req;

	while(!(response = poll_for_event(dpy, False)) &&

	      (req = dpy->xcb->pending_requests) &&

	      !req->reply_waiter)

	{

		uint64_t request;

		if(!xcb_poll_for_reply64(dpy->xcb->connection, req->sequence,

					 &response, &error)) {

			/* xcb_poll_for_reply64 may have read events even if

			 * there is no reply. */

			response = poll_for_event(dpy, True);

			break;

		}

		request = X_DPY_GET_REQUEST(dpy);

		if(XLIB_SEQUENCE_COMPARE(req->sequence, >, request))

		{

			throw_thread_fail_assert("Unknown sequence number "

			                         "while awaiting reply",

			                        xcb_xlib_threads_sequence_lost);

		}

		X_DPY_SET_LAST_REQUEST_READ(dpy, req->sequence);

		if(response)

			break;

		dequeue_pending_request(dpy, req);

		if(error)

			return (xcb_generic_reply_t *) error;

	}

	return response;

}

static void handle_response(Display *dpy, xcb_generic_reply_t *response, Bool in_XReply)

{

	_XAsyncHandler *async, *next;

	switch(response->response_type)

	{

	case X_Reply:

		for(async = dpy->async_handlers; async; async = next)

		{

			next = async->next;

			if(async->handler(dpy, (xReply *) response, (char *) response, sizeof(xReply) + (response->length << 2), async->data))

				break;

		}

		break;

	case X_Error:

		handle_error(dpy, (xError *) response, in_XReply);

		break;

	default: /* event */

		/* GenericEvents may be > 32 bytes. In this case, the

		 * event struct is trailed by the additional bytes. the

		 * xcb_generic_event_t struct uses 4 bytes for internal

		 * numbering, so we need to shift the trailing data to

		 * be after the first 32 bytes. */

		if(response->response_type == GenericEvent && ((xcb_ge_event_t *) response)->length)

		{

			xcb_ge_event_t *event = (xcb_ge_event_t *) response;

			memmove(&event->full_sequence, &event[1], event->length * 4);

		}

		_XEnq(dpy, (xEvent *) response);

		break;

	}

	free(response);

}

int _XEventsQueued(Display *dpy, int mode)

{

	xcb_generic_reply_t *response;

	if(dpy->flags & XlibDisplayIOError)

		return 0;

	if(dpy->xcb->event_owner != XlibOwnsEventQueue)

		return 0;

	if(mode == QueuedAfterFlush)

		_XSend(dpy, NULL, 0);

	else

		check_internal_connections(dpy);

	/* If another thread is blocked waiting for events, then we must

	 * let that thread pick up the next event. Since it blocked, we

	 * can reasonably claim there are no new events right now. */

	if(!dpy->xcb->event_waiter)

	{

		while((response = poll_for_response(dpy)))

			handle_response(dpy, response, False);

		if(xcb_connection_has_error(dpy->xcb->connection))

			_XIOError(dpy);

	}

	return dpy->qlen;

}

/* _XReadEvents - Flush the output queue,

 * then read as many events as possible (but at least 1) and enqueue them

 */

void _XReadEvents(Display *dpy)

{

	xcb_generic_reply_t *response;

	unsigned long serial;

	if(dpy->flags & XlibDisplayIOError)

		return;

	_XSend(dpy, NULL, 0);

	if(dpy->xcb->event_owner != XlibOwnsEventQueue)

		return;

	check_internal_connections(dpy);

	serial = dpy->next_event_serial_num;

	while(serial == dpy->next_event_serial_num || dpy->qlen == 0)

	{

		if(dpy->xcb->event_waiter)

		{

			ConditionWait(dpy, dpy->xcb->event_notify);

			/* Maybe the other thread got us an event. */

			continue;

		}

		if(!dpy->xcb->next_event)

		{

			xcb_generic_event_t *event;

			dpy->xcb->event_waiter = 1;

			UnlockDisplay(dpy);

			event = xcb_wait_for_event(dpy->xcb->connection);

			/* It appears that classic Xlib respected user

			 * locks when waking up after waiting for

			 * events. However, if this thread did not have

			 * any user locks, and another thread takes a

			 * user lock and tries to read events, then we'd

			 * deadlock. So we'll choose to let the thread

			 * that got in first consume events, despite the

			 * later thread's user locks. */

			InternalLockDisplay(dpy, /* ignore user locks */ 1);

			dpy->xcb->event_waiter = 0;

			ConditionBroadcast(dpy, dpy->xcb->event_notify);

			if(!event)

				_XIOError(dpy);

			dpy->xcb->next_event = event;

		}

		/* We've established most of the conditions for

		 * poll_for_response to return non-NULL. The exceptions

		 * are connection shutdown, and finding that another

		 * thread is waiting for the next reply we'd like to

		 * process. */

		response = poll_for_response(dpy);

		if(response)

			handle_response(dpy, response, False);

		else if(dpy->xcb->pending_requests->reply_waiter)

		{ /* need braces around ConditionWait */

			ConditionWait(dpy, dpy->xcb->reply_notify);

		}

		else

			_XIOError(dpy);

	}

	/* The preceding loop established that there is no

	 * event_waiter--unless we just called ConditionWait because of

	 * a reply_waiter, in which case another thread may have become

	 * the event_waiter while we slept unlocked. */

	if(!dpy->xcb->event_waiter)

		while((response = poll_for_response(dpy)))

			handle_response(dpy, response, False);

	if(xcb_connection_has_error(dpy->xcb->connection))

		_XIOError(dpy);

}

/*

 * _XSend - Flush the buffer and send the client data. 32 bit word aligned

 * transmission is used, if size is not 0 mod 4, extra bytes are transmitted.

 *

 * Note that the connection must not be read from once the data currently

 * in the buffer has been written.

 */

void _XSend(Display *dpy, const char *data, long size)

{

	static const xReq dummy_request;

	static char const pad[3];

	struct iovec vec[3];

	uint64_t requests;

	uint64_t dpy_request;

	_XExtension *ext;

	xcb_connection_t *c = dpy->xcb->connection;

	if(dpy->flags & XlibDisplayIOError)

		return;

	if(dpy->bufptr == dpy->buffer && !size)

		return;

	/* append_pending_request does not alter the dpy request number

	 * therefore we can get it outside of the loop and the if

	 */

	dpy_request = X_DPY_GET_REQUEST(dpy);

	/* iff we asked XCB to set aside errors, we must pick those up

	 * eventually. iff there are async handlers, we may have just

	 * issued requests that will generate replies. in either case,

	 * we need to remember to check later. */

	if(dpy->xcb->event_owner != XlibOwnsEventQueue || dpy->async_handlers)

	{

		uint64_t sequence;

		for(sequence = dpy->xcb->last_flushed + 1; sequence <= dpy_request; ++sequence)

			append_pending_request(dpy, sequence);

	}

	requests = dpy_request - dpy->xcb->last_flushed;

	dpy->xcb->last_flushed = dpy_request;

	vec[0].iov_base = dpy->buffer;

	vec[0].iov_len = dpy->bufptr - dpy->buffer;

	vec[1].iov_base = (char *)data;

	vec[1].iov_len = size;

	vec[2].iov_base = (char *)pad;

	vec[2].iov_len = -size & 3;

	for(ext = dpy->flushes; ext; ext = ext->next_flush)

	{

		int i;

		for(i = 0; i < 3; ++i)

			if(vec[i].iov_len)

				ext->before_flush(dpy, &ext->codes, vec[i].iov_base, vec[i].iov_len);

	}

	if(xcb_writev(c, vec, 3, requests) < 0)

		_XIOError(dpy);

	dpy->bufptr = dpy->buffer;

	dpy->last_req = (char *) &dummy_request;

	check_internal_connections(dpy);

	_XSetSeqSyncFunction(dpy);

}

/*

 * _XFlush - Flush the X request buffer.  If the buffer is empty, no

 * action is taken.

 */

void _XFlush(Display *dpy)

{

	require_socket(dpy);

	_XSend(dpy, NULL, 0);

	_XEventsQueued(dpy, QueuedAfterReading);

}

static const XID inval_id = ~0UL;

void _XIDHandler(Display *dpy)

{

	if (dpy->xcb->next_xid == inval_id)

		_XAllocIDs(dpy, &dpy->xcb->next_xid, 1);

}

/* _XAllocID - resource ID allocation routine. */

XID _XAllocID(Display *dpy)

{

	XID ret = dpy->xcb->next_xid;

	assert (ret != inval_id);

	dpy->xcb->next_xid = inval_id;

	_XSetPrivSyncFunction(dpy);

	return ret;

}

/* _XAllocIDs - multiple resource ID allocation routine. */

void _XAllocIDs(Display *dpy, XID *ids, int count)

{

	int i;

#ifdef XTHREADS

	if (dpy->lock)

		(*dpy->lock->user_lock_display)(dpy);

	UnlockDisplay(dpy);

#endif

	for (i = 0; i < count; i++)

		ids[i] = xcb_generate_id(dpy->xcb->connection);

#ifdef XTHREADS

	InternalLockDisplay(dpy, /* don't skip user locks */ 0);

	if (dpy->lock)

		(*dpy->lock->user_unlock_display)(dpy);

#endif

}

static void _XFreeReplyData(Display *dpy, Bool force)

{

	if(!force && dpy->xcb->reply_consumed < dpy->xcb->reply_length)

		return;

	free(dpy->xcb->reply_data);

	dpy->xcb->reply_data = NULL;

}

/*

 * _XReply - Wait for a reply packet and copy its contents into the

 * specified rep.

 * extra: number of 32-bit words expected after the reply

 * discard: should I discard data following "extra" words?

 */

Status _XReply(Display *dpy, xReply *rep, int extra, Bool discard)

{

	xcb_generic_error_t *error;

	xcb_connection_t *c = dpy->xcb->connection;

	char *reply;

	PendingRequest *current;

	uint64_t dpy_request;

	if (dpy->xcb->reply_data)

		throw_extlib_fail_assert("Extra reply data still left in queue",

		                         xcb_xlib_extra_reply_data_left);

	if(dpy->flags & XlibDisplayIOError)

		return 0;

	_XSend(dpy, NULL, 0);

	dpy_request = X_DPY_GET_REQUEST(dpy);

	if(dpy->xcb->pending_requests_tail

	   && dpy->xcb->pending_requests_tail->sequence == dpy_request)

		current = dpy->xcb->pending_requests_tail;

	else

		current = append_pending_request(dpy, dpy_request);

	/* Don't let any other thread get this reply. */

	current->reply_waiter = 1;

	while(1)

	{

		PendingRequest *req = dpy->xcb->pending_requests;

		xcb_generic_reply_t *response;

		if(req != current && req->reply_waiter)

		{

			ConditionWait(dpy, dpy->xcb->reply_notify);

			/* Another thread got this reply. */

			continue;

		}

		req->reply_waiter = 1;

		UnlockDisplay(dpy);

		response = xcb_wait_for_reply64(c, req->sequence, &error);

		/* Any user locks on another thread must have been taken

		 * while we slept in xcb_wait_for_reply64. Classic Xlib

		 * ignored those user locks in this case, so we do too. */

		InternalLockDisplay(dpy, /* ignore user locks */ 1);

		/* We have the response we're looking for. Now, before

		 * letting anyone else process this sequence number, we

		 * need to process any events that should have come

		 * earlier. */

		if(dpy->xcb->event_owner == XlibOwnsEventQueue)

		{

			xcb_generic_reply_t *event;

			/* If some thread is already waiting for events,

			 * it will get the first one. That thread must

			 * process that event before we can continue. */

			/* FIXME: That event might be after this reply,

			 * and might never even come--or there might be

			 * multiple threads trying to get events. */

			while(dpy->xcb->event_waiter)

			{ /* need braces around ConditionWait */

				ConditionWait(dpy, dpy->xcb->event_notify);

			}

			while((event = poll_for_event(dpy, True)))

				handle_response(dpy, event, True);

		}

		req->reply_waiter = 0;

		ConditionBroadcast(dpy, dpy->xcb->reply_notify);

		dpy_request = X_DPY_GET_REQUEST(dpy);

		if(XLIB_SEQUENCE_COMPARE(req->sequence, >, dpy_request)) {

			throw_thread_fail_assert("Unknown sequence number "

			                         "while processing reply",

			                        xcb_xlib_threads_sequence_lost);

		}

		X_DPY_SET_LAST_REQUEST_READ(dpy, req->sequence);

		if(!response)

			dequeue_pending_request(dpy, req);

		if(req == current)

		{

			reply = (char *) response;

			break;

		}

		if(error)

			handle_response(dpy, (xcb_generic_reply_t *) error, True);

		else if(response)

			handle_response(dpy, response, True);

	}

	check_internal_connections(dpy);

	if(dpy->xcb->next_event && dpy->xcb->next_event->response_type == X_Error)

	{

		xcb_generic_event_t *event = dpy->xcb->next_event;

		uint64_t last_request_read = X_DPY_GET_LAST_REQUEST_READ(dpy);

		uint64_t event_sequence = last_request_read;

		widen(&event_sequence, event->full_sequence);

		if(event_sequence == last_request_read)

		{

			error = (xcb_generic_error_t *) event;

			dpy->xcb->next_event = NULL;

		}

	}

	if(error)

	{

		int ret_code;

		/* Xlib is evil and assumes that even errors will be

		 * copied into rep. */

		memcpy(rep, error, 32);

		/* do not die on "no such font", "can't allocate",

		   "can't grab" failures */

		switch(error->error_code)

		{

			case BadName:

				switch(error->major_code)

				{

					case X_LookupColor:

					case X_AllocNamedColor:

						free(error);

						return 0;

				}

				break;

			case BadFont:

				if(error->major_code == X_QueryFont) {

					free(error);

					return 0;

				}

				break;

			case BadAlloc:

			case BadAccess:

				free(error);

				return 0;

		}

		ret_code = handle_error(dpy, (xError *) error, True);

		free(error);

		return ret_code;

	}

	/* it's not an error, but we don't have a reply, so it's an I/O

	 * error. */

	if(!reply)

		_XIOError(dpy);

	/* there's no error and we have a reply. */

	dpy->xcb->reply_data = reply;

	dpy->xcb->reply_consumed = sizeof(xReply) + (extra * 4);

	dpy->xcb->reply_length = sizeof(xReply);

	if(dpy->xcb->reply_data[0] == 1)

		dpy->xcb->reply_length += (((xcb_generic_reply_t *) dpy->xcb->reply_data)->length * 4);

	/* error: Xlib asks too much. give them what we can anyway. */

	if(dpy->xcb->reply_length < dpy->xcb->reply_consumed)

		dpy->xcb->reply_consumed = dpy->xcb->reply_length;

	memcpy(rep, dpy->xcb->reply_data, dpy->xcb->reply_consumed);

	_XFreeReplyData(dpy, discard);

	return 1;

}

int _XRead(Display *dpy, char *data, long size)

{

	assert(size >= 0);

	if(size == 0)

		return 0;

	if(dpy->xcb->reply_data == NULL ||

	   dpy->xcb->reply_consumed + size > dpy->xcb->reply_length)

		throw_extlib_fail_assert("Too much data requested from _XRead",

		                         xcb_xlib_too_much_data_requested);

	memcpy(data, dpy->xcb->reply_data + dpy->xcb->reply_consumed, size);

	dpy->xcb->reply_consumed += size;

	_XFreeReplyData(dpy, False);

	return 0;

}

/*

 * _XReadPad - Read bytes from the socket taking into account incomplete

 * reads.  If the number of bytes is not 0 mod 4, read additional pad

 * bytes.

 */

void _XReadPad(Display *dpy, char *data, long size)

{

	_XRead(dpy, data, size);

	dpy->xcb->reply_consumed += -size & 3;

	_XFreeReplyData(dpy, False);

}

/* Read and discard "n" 8-bit bytes of data */

void _XEatData(Display *dpy, unsigned long n)

{

	dpy->xcb->reply_consumed += n;

	_XFreeReplyData(dpy, False);

}

/*

 * Read and discard "n" 32-bit words of data

 * Matches the units of the length field in X protocol replies, and provides

 * a single implementation of overflow checking to avoid having to replicate

 * those checks in every caller.

 */

void _XEatDataWords(Display *dpy, unsigned long n)

{

	if (n < ((INT_MAX - dpy->xcb->reply_consumed) >> 2))

		dpy->xcb->reply_consumed += (n << 2);

	else

		/* Overflow would happen, so just eat the rest of the reply */

		dpy->xcb->reply_consumed = dpy->xcb->reply_length;

	_XFreeReplyData(dpy, False);

}

unsigned long

_XNextRequest(Display *dpy)

{

    /* This will update dpy->request. The assumption is that the next thing

     * that the application will do is make a request so there's little

     * overhead.

     */

    require_socket(dpy);

    return NextRequest(dpy);

}