[BOX32][WRAPPER] Some work on 32bits xcb_connection

6 files changed, 346 insertions, 137 deletions

diff --git a/src/libtools/my_xcb_defs.h b/src/libtools/my_xcb_defs.h
new file mode 100644
index 00000000..997f02c5
--- /dev/null
+++ b/src/libtools/my_xcb_defs.h
@@ -0,0 +1,114 @@
+#include <stdint.h>
+#include <pthread.h>
+
+#define MUTEX_SIZE_X64 40
+typedef struct my_xcb_ext_s {
+    pthread_mutex_t lock;
+    struct lazyreply *extensions;
+    int extensions_size;
+} my_xcb_ext_t;
+  
+typedef struct x64_xcb_ext_s {
+    uint8_t lock[MUTEX_SIZE_X64];
+    struct lazyreply *extensions;
+    int extensions_size;
+} x64_xcb_ext_t;
+
+typedef struct my_xcb_xid_s {
+    pthread_mutex_t lock;
+    uint32_t last;
+    uint32_t base;
+    uint32_t max;
+    uint32_t inc;
+} my_xcb_xid_t;
+
+typedef struct x64_xcb_xid_s {
+    uint8_t lock[MUTEX_SIZE_X64];
+    uint32_t last;
+    uint32_t base;
+    uint32_t max;
+    uint32_t inc;
+} x64_xcb_xid_t;
+
+typedef struct my_xcb_fd_s {
+    int fd[16];
+    int nfd;
+    int ifd;
+} my_xcb_fd_t;
+
+typedef struct my_xcb_in_s {
+    pthread_cond_t event_cond;
+    int reading;
+    char queue[4096];
+    int queue_len;
+    uint64_t request_expected;
+    uint64_t request_read;
+    uint64_t request_completed;
+    struct reply_list *current_reply;
+    struct reply_list **current_reply_tail;
+    void*  replies;
+    struct event_list *events;
+    struct event_list **events_tail;
+    struct reader_list *readers;
+    struct special_list *special_waiters;
+    struct pending_reply *pending_replies;
+    struct pending_reply **pending_replies_tail;
+    my_xcb_fd_t in_fd;
+    struct xcb_special_event *special_events;
+} my_xcb_in_t;
+
+typedef struct x64_xcb_out_s {
+    pthread_cond_t cond;
+    int writing;
+    pthread_cond_t socket_cond;
+    void (*return_socket)(void *closure);
+    void *socket_closure;
+    int socket_moving;
+    char queue[16384];
+    int queue_len;
+    uint64_t request;
+    uint64_t request_written;
+    uint8_t reqlenlock[MUTEX_SIZE_X64];
+    int maximum_request_length_tag;
+    uint32_t maximum_request_length;
+    my_xcb_fd_t out_fd;
+} x64_xcb_out_t;
+
+typedef struct my_xcb_out_s {
+    pthread_cond_t cond;
+    int writing;
+    pthread_cond_t socket_cond;
+    void (*return_socket)(void *closure);
+    void *socket_closure;
+    int socket_moving;
+    char queue[16384];
+    int queue_len;
+    uint64_t request;
+    uint64_t request_written;
+    pthread_mutex_t reqlenlock;
+    int maximum_request_length_tag;
+    uint32_t maximum_request_length;
+    my_xcb_fd_t out_fd;
+} my_xcb_out_t;
+
+typedef struct my_xcb_connection_s {
+    int has_error;
+    void *setup;
+    int fd;
+    pthread_mutex_t iolock;
+    my_xcb_in_t in;
+    my_xcb_out_t out;
+    my_xcb_ext_t ext;
+    my_xcb_xid_t xid;
+} my_xcb_connection_t;
+
+typedef struct x64_xcb_connection_s {
+    int has_error;
+    void *setup;
+    int fd;
+    uint8_t iolock[MUTEX_SIZE_X64];
+    my_xcb_in_t in;
+    x64_xcb_out_t out;
+    x64_xcb_ext_t ext;
+    x64_xcb_xid_t xid;
+} x64_xcb_connection_t;
diff --git a/src/libtools/myalign.c b/src/libtools/myalign.c
index 599ce904..3bd71237 100644
--- a/src/libtools/myalign.c
+++ b/src/libtools/myalign.c
@@ -1241,121 +1241,11 @@ void myStackAlignGVariantNew(x64emu_t* emu, const char* fmt, uint64_t* scratch,
 
 #endif
 
-#define MUTEX_SIZE_X64 40
-typedef struct my_xcb_ext_s {
-    pthread_mutex_t lock;
-    struct lazyreply *extensions;
-    int extensions_size;
-} my_xcb_ext_t;
-  
-typedef struct x64_xcb_ext_s {
-    uint8_t lock[MUTEX_SIZE_X64];
-    struct lazyreply *extensions;
-    int extensions_size;
-} x64_xcb_ext_t;
-
-typedef struct my_xcb_xid_s {
-    pthread_mutex_t lock;
-    uint32_t last;
-    uint32_t base;
-    uint32_t max;
-    uint32_t inc;
-} my_xcb_xid_t;
-
-typedef struct x64_xcb_xid_s {
-    uint8_t lock[MUTEX_SIZE_X64];
-    uint32_t last;
-    uint32_t base;
-    uint32_t max;
-    uint32_t inc;
-} x64_xcb_xid_t;
-
-typedef struct my_xcb_fd_s {
-    int fd[16];
-    int nfd;
-    int ifd;
-} my_xcb_fd_t;
-
-typedef struct my_xcb_in_s {
-    pthread_cond_t event_cond;
-    int reading;
-    char queue[4096];
-    int queue_len;
-    uint64_t request_expected;
-    uint64_t request_read;
-    uint64_t request_completed;
-    struct reply_list *current_reply;
-    struct reply_list **current_reply_tail;
-    void*  replies;
-    struct event_list *events;
-    struct event_list **events_tail;
-    struct reader_list *readers;
-    struct special_list *special_waiters;
-    struct pending_reply *pending_replies;
-    struct pending_reply **pending_replies_tail;
-    my_xcb_fd_t in_fd;
-    struct xcb_special_event *special_events;
-} my_xcb_in_t;
-
-typedef struct x64_xcb_out_s {
-    pthread_cond_t cond;
-    int writing;
-    pthread_cond_t socket_cond;
-    void (*return_socket)(void *closure);
-    void *socket_closure;
-    int socket_moving;
-    char queue[16384];
-    int queue_len;
-    uint64_t request;
-    uint64_t request_written;
-    uint8_t reqlenlock[40];
-    int maximum_request_length_tag;
-    uint32_t maximum_request_length;
-    my_xcb_fd_t out_fd;
-} x64_xcb_out_t;
-
-typedef struct my_xcb_out_s {
-    pthread_cond_t cond;
-    int writing;
-    pthread_cond_t socket_cond;
-    void (*return_socket)(void *closure);
-    void *socket_closure;
-    int socket_moving;
-    char queue[16384];
-    int queue_len;
-    uint64_t request;
-    uint64_t request_written;
-    pthread_mutex_t reqlenlock;
-    int maximum_request_length_tag;
-    uint32_t maximum_request_length;
-    my_xcb_fd_t out_fd;
-} my_xcb_out_t;
-
-typedef struct my_xcb_connection_s {
-    int has_error;
-    void *setup;
-    int fd;
-    pthread_mutex_t iolock;
-    my_xcb_in_t in;
-    my_xcb_out_t out;
-    my_xcb_ext_t ext;
-    my_xcb_xid_t xid;
-} my_xcb_connection_t;
-
-typedef struct x64_xcb_connection_s {
-    int has_error;
-    void *setup;
-    int fd;
-    uint8_t iolock[MUTEX_SIZE_X64];
-    my_xcb_in_t in;
-    x64_xcb_out_t out;
-    x64_xcb_ext_t ext;
-    x64_xcb_xid_t xid;
-} x64_xcb_connection_t;
+#include "my_xcb_defs.h"
 
 #define NXCB 8
-my_xcb_connection_t* my_xcb_connects[NXCB] = {0};
-x64_xcb_connection_t x64_xcb_connects[NXCB] = {0};
+static my_xcb_connection_t* my_xcb_connects[NXCB] = {0};
+static x64_xcb_connection_t x64_xcb_connects[NXCB] = {0};
 
 void* align_xcb_connection(void* src)
 {
diff --git a/src/libtools/myalign32.c b/src/libtools/myalign32.c
index 258fcc9e..9121aa39 100755
--- a/src/libtools/myalign32.c
+++ b/src/libtools/myalign32.c
@@ -1572,15 +1572,3 @@ void convert_regext_to_64(void* d, void* s)
     dst->re_nsub = from_ulong(src->re_nsub);
     dst->flags = src->flags;
 }
-
-void* add_xcb_connection(void* src);
-void del_xcb_connection(void* src);
-
-void* add_xcb_connection32(void* src)
-{
-    return add_xcb_connection(src);
-}
-void del_xcb_connection32(void* src)
-{
-    del_xcb_connection(src);
-}
diff --git a/src/libtools/myalignxcb32.c b/src/libtools/myalignxcb32.c
new file mode 100644
index 00000000..e1b0e868
--- /dev/null
+++ b/src/libtools/myalignxcb32.c
@@ -0,0 +1,209 @@
+#include <stdint.h>
+#include <pthread.h>
+#include <string.h>
+
+#include "debug.h"
+#include "myalign32.h"
+#include "threads32.h"
+#include "my_xcb_defs.h"
+  
+typedef struct my_xcb_ext_32_s {
+    fake_phtread_mutex_t lock;
+    ptr_t extensions;   //struct lazyreply *
+    int extensions_size;
+} my_xcb_ext_32_t;
+
+typedef struct my_xcb_xid_32_s {
+    fake_phtread_mutex_t lock;
+    uint32_t last;
+    uint32_t base;
+    uint32_t max;
+    uint32_t inc;
+} my_xcb_xid_32_t;
+
+typedef struct my_xcb_out_32_s {
+    pthread_cond_t cond;
+    int writing;
+    pthread_cond_t socket_cond;
+    ptr_t return_socket;//void (*return_socket)(void *closure);
+    ptr_t socket_closure;//void *
+    int socket_moving;
+    char queue[16384];
+    int queue_len;
+    uint64_t request;
+    uint64_t request_written;
+    fake_phtread_mutex_t reqlenlock;
+    int maximum_request_length_tag;
+    uint32_t maximum_request_length;
+    my_xcb_fd_t out_fd;
+} my_xcb_out_32_t;
+
+typedef struct my_xcb_in_32_s {
+    pthread_cond_t  event_cond;
+    int             reading;
+    char            queue[4096];
+    int             queue_len;
+    uint64_t        request_expected;
+    uint64_t        request_read;
+    uint64_t        request_completed;
+    ptr_t           current_reply;//struct reply_list *
+    ptr_t           current_reply_tail;//struct reply_list **
+    ptr_t           replies;//void*
+    ptr_t           events;//struct event_list *
+    ptr_t           events_tail;//struct event_list **
+    ptr_t           readers;//struct reader_list *
+    ptr_t           special_waiters;//struct special_list *
+    ptr_t           pending_replies;//struct pending_reply *
+    ptr_t           pending_replies_tail;//struct pending_reply **
+    my_xcb_fd_t     in_fd;
+    ptr_t           special_events;//struct xcb_special_event *
+} my_xcb_in_32_t;
+
+typedef struct my_xcb_connection_32_s {
+    int has_error;
+    ptr_t setup;    //void *
+    int fd;
+    fake_phtread_mutex_t iolock;
+    my_xcb_in_32_t in;
+    my_xcb_out_32_t out;
+    my_xcb_ext_32_t ext;
+    my_xcb_xid_32_t xid;
+} my_xcb_connection_32_t;
+
+#define NXCB 8
+static my_xcb_connection_t* my_xcb_connects[NXCB] = {0};
+static my_xcb_connection_32_t x64_xcb_connects[NXCB] = {0};
+
+void* align_xcb_connection32(void* src)
+{
+    if(!src)
+        return src;
+    // find it
+    my_xcb_connection_t * dest = NULL;
+    for(int i=0; i<NXCB && !dest; ++i)
+        if(src==&x64_xcb_connects[i])
+            dest = my_xcb_connects[i];
+    #if 1
+    if(!dest)
+        dest = add_xcb_connection32(src);
+    #else
+    if(!dest) {
+        printf_log(LOG_NONE, "BOX64: Error, xcb_connect %p not found\n", src);
+        abort();
+    }
+    #endif
+    #if 1
+    // do not update most values
+    my_xcb_connection_32_t* source = src;
+    dest->has_error = source->has_error;
+    dest->setup = from_ptrv(source->setup);
+    dest->fd = source->fd;
+    //memcpy(&dest->iolock, source->iolock, MUTEX_SIZE_X64);
+    //dest->in = source->in;
+    //dest->out = source->out;
+    //memcpy(&dest->ext.lock, source->ext.lock, MUTEX_SIZE_X64);
+    dest->ext.extensions = from_ptrv(source->ext.extensions);
+    dest->ext.extensions_size = source->ext.extensions_size;
+    //memcpy(&dest->xid.lock, source->xid.lock, MUTEX_SIZE_X64);
+    dest->xid.base = source->xid.base;
+    dest->xid.inc = source->xid.inc;
+    dest->xid.last = source->xid.last;
+    dest->xid.max = source->xid.last;
+    #endif
+    return dest;
+}
+
+static void setup_mutex(fake_phtread_mutex_t* mutex, pthread_mutex_t* src)
+{
+    memset(mutex, 0, sizeof(*mutex));
+    mutex->__kind = KIND_SIGN;
+    mutex->real_mutex = to_ptrv(src);
+}
+
+void unalign_xcb_connection32(void* src, void* dst)
+{
+    if(!src || !dst || src==dst)
+        return;
+    // update values
+    my_xcb_connection_t* source = src;
+    my_xcb_connection_32_t* dest = dst;
+    dest->has_error = source->has_error;
+    dest->setup = to_ptrv(source->setup);
+    dest->fd = source->fd;
+    setup_mutex(&dest->iolock, &source->iolock);
+    dest->in.event_cond = source->in.event_cond;
+    dest->in.reading = source->in.reading;
+    memcpy(dest->in.queue, source->in.queue, sizeof(dest->in.queue));
+    dest->in.queue_len = source->in.queue_len;
+    dest->in.request_expected = source->in.request_expected;
+    dest->in.request_read = source->in.request_read;
+    dest->in.request_completed = source->in.request_completed;
+    dest->in.current_reply = to_ptrv(source->in.current_reply);
+    dest->in.current_reply_tail = to_ptrv(source->in.current_reply_tail);
+    dest->in.replies = to_ptrv(source->in.replies);
+    dest->in.events = to_ptrv(source->in.events);
+    dest->in.events_tail = to_ptrv(source->in.events_tail);
+    dest->in.readers = to_ptrv(source->in.readers);
+    dest->in.special_waiters = to_ptrv(source->in.special_waiters);
+    dest->in.pending_replies = to_ptrv(source->in.pending_replies);
+    dest->in.pending_replies_tail = to_ptrv(source->in.pending_replies_tail);
+    dest->in.in_fd = source->in.in_fd;
+    dest->in.special_events = to_ptrv(source->in.special_events);
+    setup_mutex(&dest->out.reqlenlock, &source->out.reqlenlock);
+    dest->out.cond = source->out.cond;
+    dest->out.maximum_request_length = source->out.maximum_request_length;
+    dest->out.maximum_request_length_tag = source->out.maximum_request_length_tag;
+    dest->out.out_fd = source->out.out_fd;
+    memcpy(dest->out.queue, source->out.queue, sizeof(dest->out.queue));
+    dest->out.queue_len = source->out.queue_len;
+    dest->out.request = source->out.request;
+    dest->out.request_written = source->out.request_written;
+    dest->out.return_socket = to_ptrv(source->out.return_socket);
+    dest->out.socket_closure = to_ptrv(source->out.socket_closure);
+    dest->out.socket_cond = source->out.socket_cond;
+    dest->out.socket_moving = source->out.socket_moving;
+    dest->out.writing = source->out.writing;
+    setup_mutex(&dest->ext.lock, &source->ext.lock);
+    dest->ext.extensions = to_ptrv(source->ext.extensions);
+    dest->ext.extensions_size = source->ext.extensions_size;
+    setup_mutex(&dest->xid.lock, &source->xid.lock);
+    dest->xid.base = source->xid.base;
+    dest->xid.inc = source->xid.inc;
+    dest->xid.last = source->xid.last;
+    dest->xid.max = source->xid.last;
+}
+
+void* add_xcb_connection32(void* src)
+{
+    if(!src)
+        return src;
+    // check if already exist
+    for(int i=0; i<NXCB; ++i)
+        if(my_xcb_connects[i] == src) {
+            unalign_xcb_connection32(src, &x64_xcb_connects[i]);
+            return &x64_xcb_connects[i];
+        }
+    // find a free slot
+    for(int i=0; i<NXCB; ++i)
+        if(!my_xcb_connects[i]) {
+            my_xcb_connects[i] = src;
+            unalign_xcb_connection32(src, &x64_xcb_connects[i]);
+            return &x64_xcb_connects[i];
+        }
+    printf_log(LOG_NONE, "BOX64: Error, no more free xcb_connect 32bits slot for %p\n", src);
+    return src;
+}
+
+void del_xcb_connection32(void* src)
+{
+    if(!src)
+        return;
+    // find it
+    for(int i=0; i<NXCB; ++i)
+        if(src==&x64_xcb_connects[i]) {
+            my_xcb_connects[i] = NULL;
+            memset(&x64_xcb_connects[i], 0, sizeof(my_xcb_connection_32_t));
+            return;
+        }
+    printf_log(LOG_NONE, "BOX64: Error, 32bits xcb_connect %p not found for deletion\n", src);
+}
diff --git a/src/libtools/threads32.c b/src/libtools/threads32.c
index d0759ac0..829c76f2 100755
--- a/src/libtools/threads32.c
+++ b/src/libtools/threads32.c
@@ -824,15 +824,8 @@ EXPORT int my32_pthread_kill_old(x64emu_t* emu, void* thread, int sig)
 // TODO: find a better way for mutex. It should be possible to use the actual mutex most of the time, especially for simple ones
 // Having the mutex table behind a mutex is far from ideal!
 
-typedef struct fake_pthread_mutext_s {
-	int __lock;
-	unsigned int __count;
-  	int __owner;
-	int i386__kind;
-	int __kind;
-	ptr_t real_mutex;
-} fakse_phtread_mutex_t;
-#define KIND_SIGN	0xbad001
+#include "threads32.h"
+
 pthread_mutex_t* createNewMutex()
 {
 	pthread_mutex_t* ret = (pthread_mutex_t*)box_calloc(1, sizeof(pthread_mutex_t));
@@ -842,7 +835,7 @@ pthread_mutex_t* createNewMutex()
 // init = 1: get the mutex and init it with optione attr (attr will disallow native mutex)
 pthread_mutex_t* getAlignedMutex(pthread_mutex_t* m)
 {
-	fakse_phtread_mutex_t* fake = (fakse_phtread_mutex_t*)m;
+	fake_phtread_mutex_t* fake = (fake_phtread_mutex_t*)m;
 	if(!fake->__lock && !fake->__count && !fake->__owner && !fake->__kind && !fake->i386__kind && !fake->real_mutex) {
 		printf_log(LOG_DEBUG, " (init t0) ", m);
 		fake->real_mutex = KIND_SIGN;
@@ -876,7 +869,7 @@ pthread_mutex_t* getAlignedMutex(pthread_mutex_t* m)
 }
 EXPORT int my32_pthread_mutex_destroy(pthread_mutex_t *m)
 {
-	fakse_phtread_mutex_t* fake = (fakse_phtread_mutex_t*)m;
+	fake_phtread_mutex_t* fake = (fake_phtread_mutex_t*)m;
 	if(fake->real_mutex==KIND_SIGN) {
 		//TODO: check if that save/restore is actually needed
 		uint8_t saved[sizeof(pthread_mutex_t)];
@@ -910,7 +903,7 @@ EXPORT int my32___pthread_mutex_destroy(pthread_mutex_t *m) __attribute__((alias
 
 EXPORT int my32_pthread_mutex_init(pthread_mutex_t *m, pthread_mutexattr_t *att)
 {
-	fakse_phtread_mutex_t* fake = (fakse_phtread_mutex_t*)m;
+	fake_phtread_mutex_t* fake = (fake_phtread_mutex_t*)m;
 	if(!att) {
 		fake->__lock = 0;
 		fake->__count = 0;
diff --git a/src/libtools/threads32.h b/src/libtools/threads32.h
new file mode 100644
index 00000000..00a527d3
--- /dev/null
+++ b/src/libtools/threads32.h
@@ -0,0 +1,15 @@
+#ifndef __THREADS_32_H_
+#define __THREADS_32_H_
+#include "box32.h"
+
+typedef struct fake_pthread_mutext_s {
+	int __lock;
+	unsigned int __count;
+  	int __owner;
+	int i386__kind;
+	int __kind;
+	ptr_t real_mutex;
+} fake_phtread_mutex_t;
+#define KIND_SIGN	0xbad001
+
+#endif //__THREADS_32_H_
\ No newline at end of file