#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 {
xcb_generic_event_t *event;
struct event_list *next;
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;
if(genrep.response_type == XCB_ERROR)
c->in.request_completed = c->in.request_read;
+
+ remove_finished_readers(&c->in.readers, c->in.request_completed);
}
if(genrep.response_type == XCB_ERROR || genrep.response_type == XCB_REPLY)
}
/* XGE events may have sizes > 32 */
- if (genrep.response_type == XCB_XGE_EVENT)
+ 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);
+ _xcb_conn_shutdown(c, XCB_CONN_CLOSED_MEM_INSUFFICIENT);
return 0;
}
if( genrep.response_type == XCB_REPLY ||
(genrep.response_type == XCB_ERROR && pend && (pend->flags & XCB_REQUEST_CHECKED)))
{
- reader_list *reader;
struct reply_list *cur = malloc(sizeof(struct reply_list));
if(!cur)
{
- _xcb_conn_shutdown(c);
+ _xcb_conn_shutdown(c, XCB_CONN_CLOSED_MEM_INSUFFICIENT);
free(buf);
return 0;
}
cur->next = 0;
*c->in.current_reply_tail = cur;
c->in.current_reply_tail = &cur->next;
- for(reader = c->in.readers;
- reader &&
- XCB_SEQUENCE_COMPARE(reader->request, <=, c->in.request_read);
- reader = reader->next)
- {
- pthread_cond_signal(reader->data);
- if(reader->request == c->in.request_read)
- {
- break;
- }
- }
+ if(c->in.readers && c->in.readers->request == c->in.request_read)
+ pthread_cond_signal(c->in.readers->data);
return 1;
}
event = malloc(sizeof(struct event_list));
if(!event)
{
- _xcb_conn_shutdown(c);
+ _xcb_conn_shutdown(c, XCB_CONN_CLOSED_MEM_INSUFFICIENT);
free(buf);
return 0;
}
int done = 0;
while(done < len)
{
- int ret = recv(fd, ((char *) buf) + done, len - done,MSG_WAITALL);
+ int ret = recv(fd, ((char *) buf) + done, len - done, 0);
if(ret > 0)
done += ret;
#ifndef _WIN32
return 1;
}
+static void insert_reader(reader_list **prev_reader, reader_list *reader, uint64_t request, pthread_cond_t *cond)
+{
+ while(*prev_reader && XCB_SEQUENCE_COMPARE((*prev_reader)->request, <=, request))
+ prev_reader = &(*prev_reader)->next;
+ reader->request = request;
+ reader->data = cond;
+ reader->next = *prev_reader;
+ *prev_reader = reader;
+}
+
+static void remove_reader(reader_list **prev_reader, reader_list *reader)
+{
+ while(*prev_reader && XCB_SEQUENCE_COMPARE((*prev_reader)->request, <=, reader->request))
+ if(*prev_reader == reader)
+ {
+ *prev_reader = (*prev_reader)->next;
+ break;
+ }
+}
+
static void *wait_for_reply(xcb_connection_t *c, uint64_t request, xcb_generic_error_t **e)
{
void *ret = 0;
{
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
reader_list reader;
- reader_list **prev_reader;
-
- for(prev_reader = &c->in.readers;
- *prev_reader &&
- XCB_SEQUENCE_COMPARE((*prev_reader)->request, <=, request);
- prev_reader = &(*prev_reader)->next)
- {
- /* empty */;
- }
- reader.request = request;
- reader.data = &cond;
- reader.next = *prev_reader;
- *prev_reader = &reader;
+
+ insert_reader(&c->in.readers, &reader, request, &cond);
while(!poll_for_reply(c, request, &ret, e))
if(!_xcb_conn_wait(c, &cond, 0, 0))
break;
- for(prev_reader = &c->in.readers;
- *prev_reader &&
- XCB_SEQUENCE_COMPARE((*prev_reader)->request, <=, request);
- prev_reader = &(*prev_reader)->next)
- {
- if(*prev_reader == &reader)
- {
- *prev_reader = (*prev_reader)->next;
- break;
- }
- }
+ remove_reader(&c->in.readers, &reader);
pthread_cond_destroy(&cond);
}
pend = malloc(sizeof(*pend));
if(!pend)
{
- _xcb_conn_shutdown(c);
+ _xcb_conn_shutdown(c, XCB_CONN_CLOSED_MEM_INSUFFICIENT);
return;
}
return ret;
}
-xcb_generic_event_t *xcb_poll_for_event(xcb_connection_t *c)
+static xcb_generic_event_t *poll_for_next_event(xcb_connection_t *c, int queued)
{
xcb_generic_event_t *ret = 0;
if(!c->has_error)
pthread_mutex_lock(&c->iolock);
/* FIXME: follow X meets Z architecture changes. */
ret = get_event(c);
- if(!ret && _xcb_in_read(c)) /* _xcb_in_read shuts down the connection on error */
+ if(!ret && !queued && c->in.reading == 0 && _xcb_in_read(c)) /* _xcb_in_read shuts down the connection on error */
ret = get_event(c);
pthread_mutex_unlock(&c->iolock);
}
return ret;
}
+xcb_generic_event_t *xcb_poll_for_event(xcb_connection_t *c)
+{
+ return poll_for_next_event(c, 0);
+}
+
+xcb_generic_event_t *xcb_poll_for_queued_event(xcb_connection_t *c)
+{
+ return poll_for_next_event(c, 1);
+}
+
xcb_generic_error_t *xcb_request_check(xcb_connection_t *c, xcb_void_cookie_t cookie)
{
uint64_t request;
assert(workaround != WORKAROUND_NONE || flags != 0);
if(!pend)
{
- _xcb_conn_shutdown(c);
+ _xcb_conn_shutdown(c, XCB_CONN_CLOSED_MEM_INSUFFICIENT);
return 0;
}
pend->first_request = pend->last_request = request;
int _xcb_in_read(xcb_connection_t *c)
{
- int n = recv(c->fd, c->in.queue + c->in.queue_len, sizeof(c->in.queue) - c->in.queue_len,MSG_WAITALL);
+ int n = recv(c->fd, c->in.queue + c->in.queue_len, sizeof(c->in.queue) - c->in.queue_len, 0);
if(n > 0)
c->in.queue_len += n;
while(read_packet(c))
if((n > 0) || (n < 0 && WSAGetLastError() == WSAEWOULDBLOCK))
#endif /* !_WIN32 */
return 1;
- _xcb_conn_shutdown(c);
+ _xcb_conn_shutdown(c, XCB_CONN_ERROR);
return 0;
}
int ret = read_block(c->fd, (char *) buf + done, len - done);
if(ret <= 0)
{
- _xcb_conn_shutdown(c);
+ _xcb_conn_shutdown(c, XCB_CONN_ERROR);
return ret;
}
}