X-Git-Url: http://git.demorecorder.com/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=src%2Fxcbint.h;h=f89deba4ab2ad269378d2c10ee8dcf307ea699fa;hb=a187ae85729ec56e46ed0a0453458db18ab731eb;hp=402b0420c14d92fda1921190fca5f90598afa718;hpb=55c1842686d2e668708cd106b5e08847df0184c3;p=free-sw%2Fxcb%2Flibxcb

diff --git a/src/xcbint.h b/src/xcbint.h
index 402b042..f89deba 100644
--- a/src/xcbint.h
+++ b/src/xcbint.h
@@ -28,88 +28,99 @@
 #ifndef __XCBINT_H
 #define __XCBINT_H
 
-/* Not simply (a <= b) because eventually the 32-bit sequence number
- * will wrap, causing earlier sequence numbers to be higher than later
- * ones for a brief but fatal period. (a and b must be unsigned.) */
-#define _xcb_assert_sequence_less(a,b) assert((b) - (a) < 65536)
+#include "bigreq.h"
 
-#define _xcb_assert_valid_sequence(c) do { \
-    _xcb_assert_sequence_less((c)->in.request_read, (c)->out.request_written); \
-    _xcb_assert_sequence_less((c)->out.request_written, (c)->out.request); \
-} while(0)
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#ifdef GCC_HAS_VISIBILITY
+#pragma GCC visibility push(hidden)
+#endif
 
 enum workarounds {
     WORKAROUND_NONE,
-    WORKAROUND_GLX_GET_FB_CONFIGS_BUG
+    WORKAROUND_GLX_GET_FB_CONFIGS_BUG,
+    WORKAROUND_EXTERNAL_SOCKET_OWNER
 };
 
-/* xcb_list.c */
+enum lazy_reply_tag
+{
+    LAZY_NONE = 0,
+    LAZY_COOKIE,
+    LAZY_FORCED
+};
 
-typedef struct _xcb_list _xcb_list;
-typedef void (*XCBListFreeFunc)(void *);
+#define XCB_PAD(i) (-(i) & 3)
 
-_xcb_list *_xcb_list_new(void);
-void _xcb_list_delete(_xcb_list *list, XCBListFreeFunc do_free);
-int _xcb_list_insert(_xcb_list *list, void *data);
-int _xcb_list_append(_xcb_list *list, void *data);
-void *_xcb_list_peek_head(_xcb_list *list);
-void *_xcb_list_remove_head(_xcb_list *list);
-void *_xcb_list_remove(_xcb_list *list, int (*cmp)(const void *, const void *), const void *data);
-void *_xcb_list_find(_xcb_list *list, int (*cmp)(const void *, const void *), const void *data);
+#define XCB_SEQUENCE_COMPARE(a,op,b)    ((int64_t) ((a) - (b)) op 0)
 
-typedef _xcb_list _xcb_queue;
+#ifndef offsetof
+#define offsetof(type,member) ((size_t) &((type *)0)->member)
+#endif
 
-_xcb_queue *_xcb_queue_new(void);
-void _xcb_queue_delete(_xcb_queue *q, XCBListFreeFunc do_free);
-int _xcb_queue_enqueue(_xcb_queue *q, void *data);
-void *_xcb_queue_dequeue(_xcb_queue *q);
-int _xcb_queue_is_empty(_xcb_queue *q);
+#ifndef MIN
+#define MIN(x,y) ((x) < (y) ? (x) : (y))
+#endif
 
-typedef _xcb_list _xcb_map;
+#define container_of(pointer,type,member) ((type *)(((char *)(pointer)) - offsetof(type, member)))
 
-_xcb_map *_xcb_map_new(void);
-void _xcb_map_delete(_xcb_map *q, XCBListFreeFunc do_free);
-int _xcb_map_put(_xcb_map *q, unsigned int key, void *data);
-void *_xcb_map_get(_xcb_map *q, unsigned int key);
-void *_xcb_map_remove(_xcb_map *q, unsigned int key);
+/* xcb_list.c */
 
+typedef void (*xcb_list_free_func_t)(void *);
 
-/* xcb_util.c */
+typedef struct _xcb_map _xcb_map;
 
-/* Index of nearest 4-byte boundary following E. */
-#define XCB_CEIL(E) (((E)+3)&~3)
+_xcb_map *_xcb_map_new(void);
+void _xcb_map_delete(_xcb_map *q, xcb_list_free_func_t do_free);
+int _xcb_map_put(_xcb_map *q, unsigned int key, void *data);
+void *_xcb_map_remove(_xcb_map *q, unsigned int key);
 
-#define XCB_PAD(i) ((4 - (i & 3)) & 3)
 
-int _xcb_set_fd_flags(const int fd);
-int _xcb_readn(const int fd, void *buf, const int buflen, int *count);
-int _xcb_read_block(const int fd, void *buf, const size_t len);
+/* xcb_out.c */
 
+#if HAVE_SENDMSG
+#define XCB_MAX_PASS_FD 16
 
-/* xcb_out.c */
+typedef struct _xcb_fd {
+    int fd[XCB_MAX_PASS_FD];
+    int nfd;
+    int ifd;
+} _xcb_fd;
+#endif
 
 typedef struct _xcb_out {
     pthread_cond_t cond;
     int writing;
 
-    char queue[4096];
+    pthread_cond_t socket_cond;
+    void (*return_socket)(void *closure);
+    void *socket_closure;
+    int socket_moving;
+
+    char queue[XCB_QUEUE_BUFFER_SIZE];
     int queue_len;
-    struct iovec *vec;
-    int vec_len;
 
-    unsigned int request;
-    unsigned int request_written;
+    uint64_t request;
+    uint64_t request_written;
 
     pthread_mutex_t reqlenlock;
-    CARD32 maximum_request_length;
+    enum lazy_reply_tag maximum_request_length_tag;
+    union {
+        xcb_big_requests_enable_cookie_t cookie;
+        uint32_t value;
+    } maximum_request_length;
+#if HAVE_SENDMSG
+    _xcb_fd out_fd;
+#endif
 } _xcb_out;
 
 int _xcb_out_init(_xcb_out *out);
 void _xcb_out_destroy(_xcb_out *out);
 
-int _xcb_out_write(XCBConnection *c);
-int _xcb_out_write_block(XCBConnection *c, struct iovec *vector, size_t count);
-int _xcb_out_flush(XCBConnection *c);
+int _xcb_out_send(xcb_connection_t *c, struct iovec *vector, int count);
+void _xcb_out_send_sync(xcb_connection_t *c);
+int _xcb_out_flush_to(xcb_connection_t *c, uint64_t request);
 
 
 /* xcb_in.c */
@@ -121,55 +132,71 @@ typedef struct _xcb_in {
     char queue[4096];
     int queue_len;
 
-    unsigned int request_read;
-    _xcb_queue *current_reply;
+    uint64_t request_expected;
+    uint64_t request_read;
+    uint64_t request_completed;
+    struct reply_list *current_reply;
+    struct reply_list **current_reply_tail;
 
     _xcb_map *replies;
-    _xcb_queue *events;
-    _xcb_list *readers;
-
-    _xcb_queue *pending_replies;
+    struct event_list *events;
+    struct event_list **events_tail;
+    struct reader_list *readers;
+
+    struct pending_reply *pending_replies;
+    struct pending_reply **pending_replies_tail;
+#if HAVE_SENDMSG
+    _xcb_fd in_fd;
+#endif
+    struct xcb_special_event *special_events;
 } _xcb_in;
 
 int _xcb_in_init(_xcb_in *in);
 void _xcb_in_destroy(_xcb_in *in);
 
-int _xcb_in_expect_reply(XCBConnection *c, unsigned int request, enum workarounds workaround);
+void _xcb_in_wake_up_next_reader(xcb_connection_t *c);
 
-int _xcb_in_read(XCBConnection *c);
-int _xcb_in_read_block(XCBConnection *c, void *buf, int nread);
+int _xcb_in_expect_reply(xcb_connection_t *c, uint64_t request, enum workarounds workaround, int flags);
+void _xcb_in_replies_done(xcb_connection_t *c);
+
+int _xcb_in_read(xcb_connection_t *c);
+int _xcb_in_read_block(xcb_connection_t *c, void *buf, int nread);
 
 
 /* xcb_xid.c */
 
 typedef struct _xcb_xid {
     pthread_mutex_t lock;
-    CARD32 last;
-    CARD32 base;
-    CARD32 max;
-    CARD32 inc;
+    uint32_t last;
+    uint32_t base;
+    uint32_t max;
+    uint32_t inc;
 } _xcb_xid;
 
-int _xcb_xid_init(XCBConnection *c);
-void _xcb_xid_destroy(XCBConnection *c);
+int _xcb_xid_init(xcb_connection_t *c);
+void _xcb_xid_destroy(xcb_connection_t *c);
 
 
 /* xcb_ext.c */
 
 typedef struct _xcb_ext {
     pthread_mutex_t lock;
-    _xcb_map *extensions;
+    struct lazyreply *extensions;
+    int extensions_size;
 } _xcb_ext;
 
-int _xcb_ext_init(XCBConnection *c);
-void _xcb_ext_destroy(XCBConnection *c);
+int _xcb_ext_init(xcb_connection_t *c);
+void _xcb_ext_destroy(xcb_connection_t *c);
 
 
 /* xcb_conn.c */
 
-struct XCBConnection {
+struct xcb_connection_t {
+    /* This must be the first field; see _xcb_conn_ret_error(). */
+    int has_error;
+
     /* constant data */
-    XCBConnSetupSuccessRep *setup;
+    xcb_setup_t *setup;
     int fd;
 
     /* I/O data */
@@ -182,5 +209,19 @@ struct XCBConnection {
     _xcb_xid xid;
 };
 
-int _xcb_conn_wait(XCBConnection *c, const int should_write, pthread_cond_t *cond);
+void _xcb_conn_shutdown(xcb_connection_t *c, int err);
+
+xcb_connection_t *_xcb_conn_ret_error(int err);
+
+int _xcb_conn_wait(xcb_connection_t *c, pthread_cond_t *cond, struct iovec **vector, int *count);
+
+
+/* xcb_auth.c */
+
+int _xcb_get_auth_info(int fd, xcb_auth_info_t *info, int display);
+
+#ifdef GCC_HAS_VISIBILITY
+#pragma GCC visibility pop
+#endif
+
 #endif