xorg driver, work on client connection

xorg/server/module/rdp.h

@@ -111,7 +111,9 @@ struct _rdpRec
     RRSetPanningProcPtr rrSetPanning;
 
     int listen_sck;
-    rdpClientCon *clientCon;
+    char uds_data[256];
+    rdpClientCon *clientConHead;
+    rdpClientCon *clientConTail;
 };
 typedef struct _rdpRec rdpRec;
 typedef struct _rdpRec * rdpPtr;

xorg/server/module/rdpClientCon.c

@@ -47,7 +47,24 @@ Client connection to xrdp
 static int
 rdpClientConGotConnection(ScreenPtr pScreen, rdpPtr dev)
 {
+    rdpClientCon *clientCon;
+
     LLOGLN(0, ("rdpClientConGotConnection:"));
+    clientCon = (rdpClientCon *) g_malloc(sizeof(rdpClientCon), 1);
+    make_stream(clientCon->in_s);
+    init_stream(clientCon->in_s, 8192);
+    make_stream(clientCon->out_s);
+    init_stream(clientCon->out_s, 8192 * 4 + 100);
+    if (dev->clientConTail == NULL)
+    {
+        dev->clientConHead = clientCon;
+        dev->clientConTail = clientCon;
+    }
+    else
+    {
+        dev->clientConTail->next = clientCon;
+        dev->clientConTail = clientCon;
+    }
     return 0;
 }
 
@@ -102,7 +119,7 @@ rdpClientConCheck(ScreenPtr pScreen)
         FD_SET(LTOUI32(dev->listen_sck), &rfds);
         max = RDPMAX(dev->listen_sck, max);
     }
-    clientCon = dev->clientCon;
+    clientCon = dev->clientConHead;
     while (clientCon != NULL)
     {
         if (clientCon->sck > 0)
@@ -145,7 +162,7 @@ rdpClientConCheck(ScreenPtr pScreen)
             rdpClientConGotConnection(pScreen, dev);
         }
     }
-    clientCon = dev->clientCon;
+    clientCon = dev->clientConHead;
     while (clientCon != NULL)
     {
         if (clientCon->sck > 0)
@@ -173,3 +190,45 @@ rdpClientConCheck(ScreenPtr pScreen)
     }
     return 0;
 }
+
+/******************************************************************************/
+int
+rdpClientConInit(rdpPtr dev)
+{
+    char text[256];
+    int i;
+
+    if (!g_directory_exist("/tmp/.xrdp"))
+    {
+        if (!g_create_dir("/tmp/.xrdp"))
+        {
+            if (!g_directory_exist("/tmp/.xrdp"))
+            {
+                LLOGLN(0, ("rdpup_init: g_create_dir failed"));
+                return 0;
+            }
+        }
+
+        g_chmod_hex("/tmp/.xrdp", 0x1777);
+    }
+
+    i = atoi(display);
+
+    if (i < 1)
+    {
+        return 0;
+    }
+    g_sprintf(dev->uds_data, "/tmp/.xrdp/xrdp_display_%s", display);
+    if (dev->listen_sck == 0)
+    {
+        dev->listen_sck = g_tcp_local_socket_stream();
+        if (g_tcp_local_bind(dev->listen_sck, dev->uds_data) != 0)
+        {
+            LLOGLN(0, ("rdpClientConInit: g_tcp_local_bind failed"));
+            return 1;
+        }
+        g_tcp_listen(dev->listen_sck);
+        AddEnabledDevice(dev->listen_sck);
+    }
+    return 0;
+}

xorg/server/module/rdpClientCon.h

@@ -29,10 +29,14 @@ struct _rdpClientCon
     int sck;
     int sckControlListener;
     int sckControl;
+    struct stream *out_s;
+    struct stream *in_s;
     struct _rdpClientCon *next;
 };
 
 int
 rdpClientConCheck(ScreenPtr pScreen);
+int
+rdpClientConInit(rdpPtr dev);
 
 #endif

xorg/server/module/rdpMisc.h

@@ -24,6 +24,8 @@ the rest
 #ifndef __RDPMISC_H
 #define __RDPMISC_H
 
+#include <X11/Xos.h>
+
 int
 rdpBitsPerPixel(int depth);
 int
@@ -75,4 +77,177 @@ g_chmod_hex(const char *filename, int flags);
 void
 g_hexdump(unsigned char *p, unsigned int len);
 
+#if defined(X_BYTE_ORDER)
+#  if X_BYTE_ORDER == X_LITTLE_ENDIAN
+#    define L_ENDIAN
+#  else
+#    define B_ENDIAN
+#  endif
+#else
+#  error Unknown endianness in rdp.h
+#endif
+/* check if we need to align data */
+/* check if we need to align data */
+#if defined(__sparc__) || defined(__alpha__) || defined(__hppa__) || \
+    defined(__AIX__) || defined(__PPC__) || defined(__mips__) || \
+    defined(__ia64__) || defined(__ppc__) || defined(__arm__)
+#define NEED_ALIGN
+#endif
+
+/* parser state */
+struct stream
+{
+  char* p;
+  char* end;
+  char* data;
+  int size;
+  /* offsets of various headers */
+  char* iso_hdr;
+  char* mcs_hdr;
+  char* sec_hdr;
+  char* rdp_hdr;
+  char* channel_hdr;
+  char* next_packet;
+};
+
+/******************************************************************************/
+#define s_push_layer(s, h, n) \
+{ \
+  (s)->h = (s)->p; \
+  (s)->p += (n); \
+}
+
+/******************************************************************************/
+#define s_pop_layer(s, h) \
+{ \
+  (s)->p = (s)->h; \
+}
+
+/******************************************************************************/
+#if defined(B_ENDIAN) || defined(NEED_ALIGN)
+#define out_uint16_le(s, v) \
+{ \
+  *((s)->p) = (unsigned char)((v) >> 0); \
+  (s)->p++; \
+  *((s)->p) = (unsigned char)((v) >> 8); \
+  (s)->p++; \
+}
+#else
+#define out_uint16_le(s, v) \
+{ \
+  *((unsigned short*)((s)->p)) = (unsigned short)(v); \
+  (s)->p += 2; \
+}
+#endif
+
+/******************************************************************************/
+#define init_stream(s, v) \
+{ \
+  if ((v) > (s)->size) \
+  { \
+    g_free((s)->data); \
+    (s)->data = (char*)g_malloc((v), 0); \
+    (s)->size = (v); \
+  } \
+  (s)->p = (s)->data; \
+  (s)->end = (s)->data; \
+  (s)->next_packet = 0; \
+}
+
+/******************************************************************************/
+#define out_uint8p(s, v, n) \
+{ \
+  g_memcpy((s)->p, (v), (n)); \
+  (s)->p += (n); \
+}
+
+/******************************************************************************/
+#define out_uint8a(s, v, n) \
+{ \
+  out_uint8p((s), (v), (n)); \
+}
+
+/******************************************************************************/
+#if defined(B_ENDIAN) || defined(NEED_ALIGN)
+#define out_uint32_le(s, v) \
+{ \
+  *((s)->p) = (unsigned char)((v) >> 0); \
+  (s)->p++; \
+  *((s)->p) = (unsigned char)((v) >> 8); \
+  (s)->p++; \
+  *((s)->p) = (unsigned char)((v) >> 16); \
+  (s)->p++; \
+  *((s)->p) = (unsigned char)((v) >> 24); \
+  (s)->p++; \
+}
+#else
+#define out_uint32_le(s, v) \
+{ \
+  *((unsigned int*)((s)->p)) = (v); \
+  (s)->p += 4; \
+}
+#endif
+
+/******************************************************************************/
+#if defined(B_ENDIAN) || defined(NEED_ALIGN)
+#define in_uint32_le(s, v) \
+{ \
+  (v) = (unsigned int) \
+    ( \
+      (*((unsigned char*)((s)->p + 0)) << 0) | \
+      (*((unsigned char*)((s)->p + 1)) << 8) | \
+      (*((unsigned char*)((s)->p + 2)) << 16) | \
+      (*((unsigned char*)((s)->p + 3)) << 24) \
+    ); \
+  (s)->p += 4; \
+}
+#else
+#define in_uint32_le(s, v) \
+{ \
+  (v) = *((unsigned int*)((s)->p)); \
+  (s)->p += 4; \
+}
+#endif
+
+/******************************************************************************/
+#if defined(B_ENDIAN) || defined(NEED_ALIGN)
+#define in_uint16_le(s, v) \
+{ \
+  (v) = (unsigned short) \
+    ( \
+      (*((unsigned char*)((s)->p + 0)) << 0) | \
+      (*((unsigned char*)((s)->p + 1)) << 8) \
+    ); \
+  (s)->p += 2; \
+}
+#else
+#define in_uint16_le(s, v) \
+{ \
+  (v) = *((unsigned short*)((s)->p)); \
+  (s)->p += 2; \
+}
+#endif
+
+/******************************************************************************/
+#define s_mark_end(s) \
+{ \
+  (s)->end = (s)->p; \
+}
+
+/******************************************************************************/
+#define make_stream(s) \
+{ \
+  (s) = (struct stream*)g_malloc(sizeof(struct stream), 1); \
+}
+
+/******************************************************************************/
+#define free_stream(s) do \
+{ \
+  if ((s) != 0) \
+  { \
+    g_free((s)->data); \
+  } \
+  g_free((s)); \
+} while (0)
+
 #endif

xorg/server/xrdpdev/xrdpdev.c

@@ -536,6 +536,11 @@ rdpScreenInit(int scrnIndex, ScreenPtr pScreen, int argc, char **argv)
 
     g_timer = TimerSet(g_timer, 0, 10, rdpDeferredRandR, pScreen);
 
+    if (rdpClientConInit(dev) != 0)
+    {
+        LLOGLN(0, ("rdpScreenInit: rdpClientConInit failed"));
+    }
+
     LLOGLN(0, ("rdpScreenInit: out"));
     return TRUE;
 }