+#if USE_POLL
+#include <poll.h>
+#endif
+#ifndef _WIN32
+#include <sys/select.h>
+#include <sys/socket.h>
+#endif
+
+#ifdef _WIN32
+#include "xcb_windefs.h"
+#endif /* _WIN32 */
+
+#define XCB_ERROR 0
+#define XCB_REPLY 1
+#define XCB_XGE_EVENT 35
+
+/* required for compiling for Win32 using MinGW */
+#ifndef MSG_WAITALL
+#define MSG_WAITALL 0
+#endif
+
+struct event_list {
+ uint64_t sequence;
+ xcb_generic_event_t *event;
+ struct event_list *next;
+};
+
+struct reply_list {
+ void *reply;
+ struct reply_list *next;
+};
+
+typedef struct pending_reply {
+ uint64_t first_request;
+ uint64_t last_request;
+ enum workarounds workaround;
+ int flags;
+ struct pending_reply *next;
+} pending_reply;
+
+typedef struct reader_list {
+ uint64_t request;
+ pthread_cond_t *data;
+ struct reader_list *next;
+} reader_list;
+
+static void remove_finished_readers(reader_list **prev_reader, uint64_t completed)
+{
+ while(*prev_reader && XCB_SEQUENCE_COMPARE((*prev_reader)->request, <=, completed))
+ {
+ /* If you don't have what you're looking for now, you never
+ * will. Wake up and leave me alone. */
+ pthread_cond_signal((*prev_reader)->data);
+ *prev_reader = (*prev_reader)->next;
+ }
+}
+
+static int read_packet(xcb_connection_t *c)
+{
+ xcb_generic_reply_t genrep;
+ int length = 32;
+ int eventlength = 0; /* length after first 32 bytes for GenericEvents */
+ void *buf;
+ pending_reply *pend = 0;
+ struct event_list *event;
+
+ /* Wait for there to be enough data for us to read a whole packet */
+ if(c->in.queue_len < length)
+ return 0;
+
+ /* Get the response type, length, and sequence number. */
+ memcpy(&genrep, c->in.queue, sizeof(genrep));
+
+ /* Compute 32-bit sequence number of this packet. */
+ if((genrep.response_type & 0x7f) != XCB_KEYMAP_NOTIFY)
+ {
+ uint64_t lastread = c->in.request_read;
+ c->in.request_read = (lastread & UINT64_C(0xffffffffffff0000)) | genrep.sequence;
+ if(XCB_SEQUENCE_COMPARE(c->in.request_read, <, lastread))
+ c->in.request_read += 0x10000;
+ if(XCB_SEQUENCE_COMPARE(c->in.request_read, >, c->in.request_expected))
+ c->in.request_expected = c->in.request_read;
+
+ if(c->in.request_read != lastread)
+ {
+ if(c->in.current_reply)
+ {
+ _xcb_map_put(c->in.replies, lastread, c->in.current_reply);
+ c->in.current_reply = 0;
+ c->in.current_reply_tail = &c->in.current_reply;
+ }
+ c->in.request_completed = c->in.event_responses_completed = c->in.request_read - 1;
+ }
+
+ while(c->in.pending_replies &&
+ c->in.pending_replies->workaround != WORKAROUND_EXTERNAL_SOCKET_OWNER &&
+ XCB_SEQUENCE_COMPARE (c->in.pending_replies->last_request, <=, c->in.request_completed))
+ {
+ pending_reply *oldpend = c->in.pending_replies;
+ c->in.pending_replies = oldpend->next;
+ if(!oldpend->next)
+ c->in.pending_replies_tail = &c->in.pending_replies;
+ free(oldpend);
+ }
+
+ if(genrep.response_type == XCB_ERROR)
+ c->in.request_completed = c->in.event_responses_completed = c->in.request_read;
+ else if(genrep.response_type == XCB_REPLY)
+ c->in.event_responses_completed = c->in.request_read;
+
+ remove_finished_readers(&c->in.readers, c->in.request_completed);
+ remove_finished_readers(&c->in.event_readers, c->in.event_responses_completed);
+ }
+
+ if(genrep.response_type == XCB_ERROR || genrep.response_type == XCB_REPLY)
+ {
+ pend = c->in.pending_replies;
+ if(pend &&
+ !(XCB_SEQUENCE_COMPARE(pend->first_request, <=, c->in.request_read) &&
+ (pend->workaround == WORKAROUND_EXTERNAL_SOCKET_OWNER ||
+ XCB_SEQUENCE_COMPARE(c->in.request_read, <=, pend->last_request))))
+ pend = 0;
+ }
+
+ /* For reply packets, check that the entire packet is available. */
+ if(genrep.response_type == XCB_REPLY)
+ {
+ if(pend && pend->workaround == WORKAROUND_GLX_GET_FB_CONFIGS_BUG)
+ {
+ uint32_t *p = (uint32_t *) c->in.queue;
+ genrep.length = p[2] * p[3] * 2;
+ }
+ length += genrep.length * 4;
+ }
+
+ /* XGE events may have sizes > 32 */
+ if ((genrep.response_type & 0x7f) == XCB_XGE_EVENT)
+ eventlength = genrep.length * 4;
+
+ buf = malloc(length + eventlength +
+ (genrep.response_type == XCB_REPLY ? 0 : sizeof(uint32_t)));
+ if(!buf)
+ {
+ _xcb_conn_shutdown(c);
+ return 0;
+ }
+
+ if(_xcb_in_read_block(c, buf, length) <= 0)
+ {
+ free(buf);
+ return 0;
+ }
+
+ /* pull in XGE event data if available, append after event struct */
+ if (eventlength)
+ {
+ if(_xcb_in_read_block(c, &((xcb_generic_event_t*)buf)[1], eventlength) <= 0)
+ {
+ free(buf);
+ return 0;
+ }
+ }