+ _xcb_out_send(c, vector, count);
+}
+
+static void send_sync(xcb_connection_t *c)
+{
+ static const union {
+ struct {
+ uint8_t major;
+ uint8_t pad;
+ uint16_t len;
+ } fields;
+ uint32_t packet;
+ } sync_req = { { /* GetInputFocus */ 43, 0, 1 } };
+ struct iovec vector[2];
+ vector[1].iov_base = (char *) &sync_req;
+ vector[1].iov_len = sizeof(sync_req);
+ send_request(c, 0, WORKAROUND_NONE, XCB_REQUEST_DISCARD_REPLY, vector + 1, 1);
+}
+
+static void get_socket_back(xcb_connection_t *c)
+{
+ while(c->out.return_socket && c->out.socket_moving)
+ pthread_cond_wait(&c->out.socket_cond, &c->iolock);
+ if(!c->out.return_socket)
+ return;
+
+ c->out.socket_moving = 1;
+ pthread_mutex_unlock(&c->iolock);
+ c->out.return_socket(c->out.socket_closure);
+ pthread_mutex_lock(&c->iolock);
+ c->out.socket_moving = 0;
+
+ pthread_cond_broadcast(&c->out.socket_cond);
+ c->out.return_socket = 0;
+ c->out.socket_closure = 0;
+ _xcb_in_replies_done(c);
+}
+
+static void prepare_socket_request(xcb_connection_t *c)
+{
+ /* We're about to append data to out.queue, so we need to
+ * atomically test for an external socket owner *and* some other
+ * thread currently writing.
+ *
+ * If we have an external socket owner, we have to get the socket back
+ * before we can use it again.
+ *
+ * If some other thread is writing to the socket, we assume it's
+ * writing from out.queue, and so we can't stick data there.
+ *
+ * We satisfy this condition by first calling get_socket_back
+ * (which may drop the lock, but will return when XCB owns the
+ * socket again) and then checking for another writing thread and
+ * escaping the loop if we're ready to go.
+ */
+ for (;;) {
+ if(c->has_error)
+ return;
+ get_socket_back(c);
+ if (!c->out.writing)
+ break;
+ pthread_cond_wait(&c->out.cond, &c->iolock);
+ }