/* Connection management: the core of XCB. */
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
#include <assert.h>
#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <errno.h>
+#include <limits.h>
#include "xcb.h"
#include "xcbint.h"
#ifdef _WIN32
#include "xcb_windefs.h"
#else
+#include <sys/socket.h>
#include <netinet/in.h>
#endif /* _WIN32 */
uint16_t length;
} xcb_setup_generic_t;
-const int error_connection = 1;
+static const int xcb_con_error = XCB_CONN_ERROR;
+static const int xcb_con_closed_mem_er = XCB_CONN_CLOSED_MEM_INSUFFICIENT;
+static const int xcb_con_closed_parse_er = XCB_CONN_CLOSED_PARSE_ERR;
+static const int xcb_con_closed_screen_er = XCB_CONN_CLOSED_INVALID_SCREEN;
static int set_fd_flags(const int fd)
{
i++;
}
#else
- n = writev(c->fd, *vector, *count);
+ n = *count;
+ if (n > IOV_MAX)
+ n = IOV_MAX;
+
+ n = writev(c->fd, *vector, n);
if(n < 0 && errno == EAGAIN)
return 1;
#endif /* _WIN32 */
if(n <= 0)
{
- _xcb_conn_shutdown(c);
+ _xcb_conn_shutdown(c, XCB_CONN_ERROR);
return 0;
}
if(fd >= FD_SETSIZE) /* would overflow in FD_SET */
{
close(fd);
- return (xcb_connection_t *) &error_connection;
+ return _xcb_conn_ret_error(XCB_CONN_ERROR);
}
#endif
#endif /* !_WIN32*/
c = calloc(1, sizeof(xcb_connection_t));
if(!c) {
close(fd);
- return (xcb_connection_t *) &error_connection;
+ return _xcb_conn_ret_error(XCB_CONN_CLOSED_MEM_INSUFFICIENT) ;
}
c->fd = fd;
))
{
xcb_disconnect(c);
- return (xcb_connection_t *) &error_connection;
+ return _xcb_conn_ret_error(XCB_CONN_ERROR);
}
return c;
void xcb_disconnect(xcb_connection_t *c)
{
- if(c == (xcb_connection_t *) &error_connection)
+ if(c->has_error)
return;
free(c->setup);
_xcb_xid_destroy(c);
free(c);
+
+#ifdef _WIN32
+ WSACleanup();
+#endif
}
/* Private interface */
-void _xcb_conn_shutdown(xcb_connection_t *c)
+void _xcb_conn_shutdown(xcb_connection_t *c, int err)
+{
+ c->has_error = err;
+}
+
+/* Return connection error state.
+ * To make thread-safe, I need a seperate static
+ * variable for every possible error.
+ */
+xcb_connection_t *_xcb_conn_ret_error(int err)
{
- c->has_error = 1;
+
+ switch(err)
+ {
+ case XCB_CONN_CLOSED_MEM_INSUFFICIENT:
+ {
+ return (xcb_connection_t *) &xcb_con_closed_mem_er;
+ }
+ case XCB_CONN_CLOSED_PARSE_ERR:
+ {
+ return (xcb_connection_t *) &xcb_con_closed_parse_er;
+ }
+ case XCB_CONN_CLOSED_INVALID_SCREEN:
+ {
+ return (xcb_connection_t *) &xcb_con_closed_screen_er;
+ }
+ case XCB_CONN_ERROR:
+ default:
+ {
+ return (xcb_connection_t *) &xcb_con_error;
+ }
+ }
}
int _xcb_conn_wait(xcb_connection_t *c, pthread_cond_t *cond, struct iovec **vector, int *count)
} while (ret == -1 && errno == EINTR);
if(ret < 0)
{
- _xcb_conn_shutdown(c);
+ _xcb_conn_shutdown(c, XCB_CONN_ERROR);
ret = 0;
}
pthread_mutex_lock(&c->iolock);
if(ret)
{
+ /* The code allows two threads to call select()/poll() at the same time.
+ * First thread just wants to read, a second thread wants to write, too.
+ * We have to make sure that we don't steal the reading thread's reply
+ * and let it get stuck in select()/poll().
+ * So a thread may read if either:
+ * - There is no other thread that wants to read (the above situation
+ * did not occur).
+ * - It is the reading thread (above situation occurred).
+ */
+ int may_read = c->in.reading == 1 || !count;
#if USE_POLL
- if((fd.revents & POLLIN) == POLLIN)
+ if(may_read && (fd.revents & POLLIN) == POLLIN)
#else
- if(FD_ISSET(c->fd, &rfds))
+ if(may_read && FD_ISSET(c->fd, &rfds))
#endif
ret = ret && _xcb_in_read(c);