diff --git a/common/arch.h b/common/arch.h
index c63db197..b8d61381 100644
--- a/common/arch.h
+++ b/common/arch.h
@@ -18,6 +18,9 @@
 
 */
 
+#if !defined(ARCH_H)
+#define ARCH_H
+
 /* check endianess */
 #if __BYTE_ORDER == __LITTLE_ENDIAN
 #define L_ENDIAN
@@ -39,3 +42,19 @@
 #define THREAD_RV void*
 #define THREAD_CC
 #endif
+
+#if defined(__BORLANDC__)
+#define APP_CC __cdecl
+#define DEFAULT_CC __cdecl
+#else
+#define APP_CC
+#define DEFAULT_CC
+#endif
+
+#if defined(_WIN32)
+#define EXPORT_CC __declspec(dllexport)
+#else
+#define EXPORT_CC
+#endif
+
+#endif
diff --git a/common/defines.h b/common/defines.h
new file mode 100644
index 00000000..77c7d75c
--- /dev/null
+++ b/common/defines.h
@@ -0,0 +1,66 @@
+/*
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+
+   xrdp: A Remote Desktop Protocol server.
+   Copyright (C) Jay Sorg 2004-2005
+
+   main define/macro file
+
+*/
+
+#if !defined(DEFINES_H)
+#define DEFINES_H
+
+/* check for debug */
+#ifdef XRDP_DEBUG
+#define DEBUG(args) g_printf args;
+#else
+#define DEBUG(args)
+#endif
+/* other macros */
+#define MIN(x1, x2) ((x1) < (x2) ? (x1) : (x2))
+#define MAX(x1, x2) ((x1) > (x2) ? (x1) : (x2))
+#define HIWORD(in) (((in) & 0xffff0000) >> 16)
+#define LOWORD(in) ((in) & 0x0000ffff)
+#define MAKELONG(hi, lo) ((((hi) & 0xffff) << 16) | ((lo) & 0xffff))
+#define MAKERECT(r, x, y, cx, cy) \
+{ (r).left = x; (r).top = y; (r).right = (x) + (cx); (r).bottom = (y) + (cy); }
+#define ISRECTEMPTY(r) (((r).right <= (r).left) || ((r).bottom <= (r).top))
+#define RECTOFFSET(r, dx, dy) \
+{ (r).left += dx; (r).top += dy; (r).right += dx; (r).bottom += dy; }
+#define GETPIXEL8(d, x, y, w) (*(((unsigned char*)d) + ((y) * (w) + (x))))
+#define GETPIXEL16(d, x, y, w) (*(((unsigned short*)d) + ((y) * (w) + (x))))
+#define GETPIXEL32(d, x, y, w) (*(((unsigned int*)d) + ((y) * (w) + (x))))
+#define SETPIXEL8(d, x, y, w, v) \
+(*(((unsigned char*)d) + ((y) * (w) + (x))) = (v))
+#define SETPIXEL16(d, x, y, w, v) \
+(*(((unsigned short*)d) + ((y) * (w) + (x))) = (v))
+#define SETPIXEL32(d, x, y, w, v) \
+(*(((unsigned long*)d) + ((y) * (w) + (x))) = (v))
+#define COLOR8(r, g, b) \
+( \
+  (((r) >> 5) << 0) | \
+  (((g) >> 5) << 3) | \
+  (((b) >> 6) << 6) \
+)
+#define COLOR15(r, g, b) ((((r) >> 3) << 10) | (((g) >> 3) << 5) | ((b) >> 3))
+#define COLOR16(r, g, b) ((((r) >> 3) << 11) | (((g) >> 2) << 5) | ((b) >> 3))
+#define COLOR24(r, g, b) ((r) | ((g) << 8) | ((b) << 16))
+/* font macros */
+#define FONT_DATASIZE(f) ((((f)->height * (((f)->width + 7) / 8)) + 3) & ~3);
+/* use crc for bitmap cache lookups */
+#define USE_CRC
+
+#endif
diff --git a/common/file.c b/common/file.c
new file mode 100644
index 00000000..8bd37cb8
--- /dev/null
+++ b/common/file.c
@@ -0,0 +1,221 @@
+/*
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+
+   xrdp: A Remote Desktop Protocol server.
+   Copyright (C) Jay Sorg 2004-2005
+
+   read a config file
+
+*/
+
+#include "arch.h"
+#include "os_calls.h"
+#include "list.h"
+#include "file.h"
+#include "parse.h"
+
+/*****************************************************************************/
+int
+file_read_sections(int fd, struct list* names)
+{
+  struct stream* s;
+  char text[256];
+  char c;
+  int in_it;
+  int in_it_index;
+  int len;
+  int index;
+
+  g_file_seek(fd, 0);
+  in_it_index = 0;
+  in_it = 0;
+  g_memset(text, 0, 256);
+  list_clear(names);
+  make_stream(s);
+  init_stream(s, 8192);
+  len = g_file_read(fd, s->data, 8192);
+  if (len > 0)
+  {
+    s->end = s->p + len;
+    for (index = 0; index < len; index++)
+    {
+      in_uint8(s, c);
+      if (c == '[')
+      {
+        in_it = 1;
+      }
+      else if (c == ']')
+      {
+        list_add_item(names, (long)g_strdup(text));
+        in_it = 0;
+        in_it_index = 0;
+        g_memset(text, 0, 256);
+      }
+      else if (in_it)
+      {
+        text[in_it_index] = c;
+        in_it_index++;
+      }
+    }
+  }
+  free_stream(s);
+  return 0;
+}
+
+/*****************************************************************************/
+int
+file_read_line(struct stream* s, char* text)
+{
+  int i;
+  char c;
+  char* hold;
+
+  if (!s_check(s))
+  {
+    return 1;
+  }
+  hold = s->p;
+  i = 0;
+  in_uint8(s, c);
+  while (c != 10 && c != 13 && s_check(s))
+  {
+    text[i] = c;
+    i++;
+    in_uint8(s, c);
+  }
+  if (c == 10 || c == 13)
+  {
+    while ((c == 10 || c == 13) && s_check(s))
+    {
+      in_uint8(s, c);
+    }
+    s->p--;
+  }
+  text[i] = 0;
+  if (text[0] == '[')
+  {
+    s->p = hold;
+    return 1;
+  }
+  if (g_strlen(text) > 0)
+  {
+    return 0;
+  }
+  else
+  {
+    return 1;
+  }
+}
+
+/*****************************************************************************/
+int
+file_split_name_value(char* text, char* name, char* value)
+{
+  int len;
+  int i;
+  int value_index;
+  int name_index;
+  int on_to;
+
+  value_index = 0;
+  name_index = 0;
+  on_to = 0;
+  name[0] = 0;
+  value[0] = 0;
+  len = g_strlen(text);
+  for (i = 0; i < len; i++)
+  {
+    if (text[i] == '=')
+    {
+      on_to = 1;
+    }
+    else if (on_to)
+    {
+      value[value_index] = text[i];
+      value_index++;
+      value[value_index] = 0;
+    }
+    else
+    {
+      name[name_index] = text[i];
+      name_index++;
+      name[name_index] = 0;
+    }
+  }
+  return 0;
+}
+
+/*****************************************************************************/
+int
+file_read_section(int fd, char* section, struct list* names,
+                  struct list* values)
+{
+  struct stream* s;
+  char text[256];
+  char name[256];
+  char value[256];
+  char c;
+  int in_it;
+  int in_it_index;
+  int len;
+  int index;
+
+  g_file_seek(fd, 0);
+  in_it_index = 0;
+  in_it = 0;
+  g_memset(text, 0, 256);
+  list_clear(names);
+  list_clear(values);
+  make_stream(s);
+  init_stream(s, 8192);
+  len = g_file_read(fd, s->data, 8192);
+  if (len > 0)
+  {
+    s->end = s->p + len;
+    for (index = 0; index < len; index++)
+    {
+      in_uint8(s, c);
+      if (c == '[')
+      {
+        in_it = 1;
+      }
+      else if (c == ']')
+      {
+        if (g_strcmp(section, text) == 0)
+        {
+          file_read_line(s, text);
+          while (file_read_line(s, text) == 0)
+          {
+            file_split_name_value(text, name, value);
+            list_add_item(names, (long)g_strdup(name));
+            list_add_item(values, (long)g_strdup(value));
+          }
+          free_stream(s);
+          return 0;
+        }
+        in_it = 0;
+        in_it_index = 0;
+        g_memset(text, 0, 256);
+      }
+      else if (in_it)
+      {
+        text[in_it_index] = c;
+        in_it_index++;
+      }
+    }
+  }
+  free_stream(s);
+  return 0;
+}
diff --git a/common/file.h b/common/file.h
new file mode 100644
index 00000000..86ca684f
--- /dev/null
+++ b/common/file.h
@@ -0,0 +1,28 @@
+/*
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+
+   xrdp: A Remote Desktop Protocol server.
+   Copyright (C) Jay Sorg 2004-2005
+
+*/
+
+#if !defined(FILE_H)
+#define FILE_H
+
+int file_read_sections(int fd, struct list* names);
+int file_read_section(int fd, char* section, struct list* names,
+                      struct list* values);
+
+#endif
diff --git a/common/list.c b/common/list.c
new file mode 100644
index 00000000..b1201d0a
--- /dev/null
+++ b/common/list.c
@@ -0,0 +1,181 @@
+/*
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+
+   xrdp: A Remote Desktop Protocol server.
+   Copyright (C) Jay Sorg 2004-2005
+
+   simple list
+
+*/
+
+#include "arch.h"
+#include "os_calls.h"
+#include "list.h"
+
+/*****************************************************************************/
+struct list*
+list_create(void)
+{
+  struct list* self;
+
+  self = (struct list*)g_malloc(sizeof(struct list), 1);
+  self->grow_by = 10;
+  self->alloc_size = 10;
+  self->items = (long*)g_malloc(sizeof(long) * 10, 1);
+  return self;
+}
+
+/*****************************************************************************/
+void
+list_delete(struct list* self)
+{
+  int i;
+
+  if (self == 0)
+  {
+    return;
+  }
+  if (self->auto_free)
+  {
+    for (i = 0; i < self->count; i++)
+    {
+      g_free((void*)self->items[i]);
+      self->items[i] = 0;
+    }
+  }
+  g_free(self->items);
+  g_free(self);
+}
+
+/*****************************************************************************/
+void
+list_add_item(struct list* self, long item)
+{
+  long* p;
+  int i;
+
+  if (self->count >= self->alloc_size)
+  {
+    i = self->alloc_size;
+    self->alloc_size += self->grow_by;
+    p = (long*)g_malloc(sizeof(long) * self->alloc_size, 1);
+    g_memcpy(p, self->items, sizeof(long) * i);
+    g_free(self->items);
+    self->items = p;
+  }
+  self->items[self->count] = item;
+  self->count++;
+}
+
+/*****************************************************************************/
+long
+list_get_item(struct list* self, int index)
+{
+  if (index < 0 || index >= self->count)
+  {
+    return 0;
+  }
+  return self->items[index];
+}
+
+/*****************************************************************************/
+void
+list_clear(struct list* self)
+{
+  int i;
+
+  if (self->auto_free)
+  {
+    for (i = 0; i < self->count; i++)
+    {
+      g_free((void*)self->items[i]);
+      self->items[i] = 0;
+    }
+  }
+  g_free(self->items);
+  self->count = 0;
+  self->grow_by = 10;
+  self->alloc_size = 10;
+  self->items = (long*)g_malloc(sizeof(long) * 10, 1);
+}
+
+/*****************************************************************************/
+int
+list_index_of(struct list* self, long item)
+{
+  int i;
+
+  for (i = 0; i < self->count; i++)
+  {
+    if (self->items[i] == item)
+    {
+      return i;
+    }
+  }
+  return -1;
+}
+
+/*****************************************************************************/
+void
+list_remove_item(struct list* self, int index)
+{
+  int i;
+
+  if (index >= 0 && index < self->count)
+  {
+    if (self->auto_free)
+    {
+      g_free((void*)self->items[index]);
+      self->items[index] = 0;
+    }
+    for (i = index; i < (self->count - 1); i++)
+    {
+      self->items[i] = self->items[i + 1];
+    }
+    self->count--;
+  }
+}
+
+/*****************************************************************************/
+void
+list_insert_item(struct list* self, int index, long item)
+{
+  long* p;
+  int i;
+
+  if (index == self->count)
+  {
+    list_add_item(self, item);
+    return;
+  }
+  if (index >= 0 && index < self->count)
+  {
+    self->count++;
+    if (self->count > self->alloc_size)
+    {
+      i = self->alloc_size;
+      self->alloc_size += self->grow_by;
+      p = (long*)g_malloc(sizeof(long) * self->alloc_size, 1);
+      g_memcpy(p, self->items, sizeof(long) * i);
+      g_free(self->items);
+      self->items = p;
+    }
+    for (i = (self->count - 2); i >= index; i--)
+    {
+      self->items[i + 1] = self->items[i];
+    }
+    self->items[index] = item;
+  }
+}
diff --git a/common/list.h b/common/list.h
new file mode 100644
index 00000000..c0c7b060
--- /dev/null
+++ b/common/list.h
@@ -0,0 +1,43 @@
+/*
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+
+   xrdp: A Remote Desktop Protocol server.
+   Copyright (C) Jay Sorg 2004-2005
+
+*/
+
+#if !defined(LIST_H)
+#define LIST_H
+
+/* list */
+struct list
+{
+  long* items;
+  int count;
+  int alloc_size;
+  int grow_by;
+  int auto_free;
+};
+
+struct list* list_create(void);
+void list_delete(struct list* self);
+void list_add_item(struct list* self, long item);
+long list_get_item(struct list* self, int index);
+void list_clear(struct list* self);
+int list_index_of(struct list* self, long item);
+void list_remove_item(struct list* self, int index);
+void list_insert_item(struct list* self, int index, long item);
+
+#endif
diff --git a/common/os_calls.c b/common/os_calls.c
index c276b4c0..0d6a4773 100644
--- a/common/os_calls.c
+++ b/common/os_calls.c
@@ -20,9 +20,6 @@
 
    put all the os / arch define in here you want
 
-   if you want pthread calls define USE_PTHREAD in makefile
-   if you want openssl calls define USE_OPENSSL in makefile
-
 */
 
 #if defined(_WIN32)
@@ -49,218 +46,16 @@
 #include <stdarg.h>
 #include <stdio.h>
 
-#if defined(USE_OPENSSL)
-#include <openssl/rc4.h>
-#include <openssl/md5.h>
-#include <openssl/sha.h>
-#include <openssl/bn.h>
-#endif
-
-#if defined(USE_PTHREAD)
-#include <pthread.h>
-#endif
-
-/*#define MEMLEAK*/
-
-#if defined(_WIN32)
-static CRITICAL_SECTION g_term_mutex;
-static int g_term = 0;
-#elif defined(USE_PTHREAD)
-static pthread_mutex_t g_term_mutex = PTHREAD_MUTEX_INITIALIZER;
-static int g_term = 0;
-#endif
-
-#if defined(MEMLEAK)
-static int g_memsize = 0;
-static int g_memid = 0;
-static struct list* g_memlist = 0;
-
-/* for memory debugging */
-struct mem
-{
-  int size;
-  int id;
-};
-
-/* list */
-struct list
-{
-  long* items;
-  int count;
-  int alloc_size;
-  int grow_by;
-  int auto_free;
-};
-
-/*****************************************************************************/
-struct list* list_create(void)
-{
-  struct list* self;
-
-  self = (struct list*)malloc(sizeof(struct list));
-  memset(self, 0, sizeof(struct list));
-  self->grow_by = 10;
-  self->alloc_size = 10;
-  self->items = (long*)malloc(sizeof(long) * 10);
-  memset(self->items, 0, sizeof(long) * 10);
-  return self;
-}
-
-/*****************************************************************************/
-void list_delete(struct list* self)
-{
-  int i;
-
-  if (self == 0)
-  {
-    return;
-  }
-  if (self->auto_free)
-  {
-    for (i = 0; i < self->count; i++)
-    {
-      free((void*)self->items[i]);
-      self->items[i] = 0;
-    }
-  }
-  free(self->items);
-  free(self);
-}
-
-/*****************************************************************************/
-void list_add_item(struct list* self, long item)
-{
-  long* p;
-  int i;
-
-  if (self->count >= self->alloc_size)
-  {
-    i = self->alloc_size;
-    self->alloc_size += self->grow_by;
-    p = (long*)malloc(sizeof(long) * self->alloc_size);
-    memset(p, 0, sizeof(long) * self->alloc_size);
-    memcpy(p, self->items, sizeof(long) * i);
-    free(self->items);
-    self->items = p;
-  }
-  self->items[self->count] = item;
-  self->count++;
-}
-
-/*****************************************************************************/
-int list_index_of(struct list* self, long item)
-{
-  int i;
-
-  for (i = 0; i < self->count; i++)
-  {
-    if (self->items[i] == item)
-    {
-      return i;
-    }
-  }
-  return -1;
-}
-
-/*****************************************************************************/
-void list_remove_item(struct list* self, int index)
-{
-  int i;
-
-  if (index >= 0 && index < self->count)
-  {
-    if (self->auto_free)
-    {
-      free((void*)self->items[index]);
-      self->items[index] = 0;
-    }
-    for (i = index; i < (self->count - 1); i++)
-    {
-      self->items[i] = self->items[i + 1];
-    }
-    self->count--;
-  }
-}
-
-/*****************************************************************************/
-long list_get_item(struct list* self, int index)
-{
-  if (index < 0 || index >= self->count)
-  {
-    return 0;
-  }
-  return self->items[index];
-}
-
-#endif
-
 /* forward declarations */
-void g_printf(char* format, ...);
-void g_pipe_sig(int sig_num);
-
-/*****************************************************************************/
-int g_init_system(void)
-{
-#if defined(_WIN32)
-  WSADATA w;
-
-  WSAStartup(2, &w);
-  InitializeCriticalSection(&g_term_mutex);
-#else
-  signal(SIGPIPE, g_pipe_sig);
-#endif
-#if defined(MEMLEAK)
-  g_memlist = list_create();
-#endif
-  return 0;
-}
+void
+g_printf(char* format, ...);
+void
+g_pipe_sig(int sig_num);
 
 /*****************************************************************************/
-int g_exit_system(void)
+void*
+g_malloc(int size, int zero)
 {
-#if defined(_WIN32)
-  WSACleanup();
-  DeleteCriticalSection(&g_term_mutex);
-#endif
-#if defined(MEMLEAK)
-  int i;
-  struct mem* p;
-
-  for (i = 0; i < g_memlist->count; i++)
-  {
-    p = (struct mem*)list_get_item(g_memlist, i);
-    g_printf("leak size %d id %d\n\r", p->size, p->id);
-  }
-  g_printf("mem %d\n\r", g_memsize);
-  list_delete(g_memlist);
-  g_memlist = 0;
-#endif
-  return 0;
-}
-
-/*****************************************************************************/
-void* g_malloc(int size, int zero)
-{
-#if defined(MEMLEAK)
-  char* rv;
-  struct mem* p;
-
-  rv = (char*)malloc(size + sizeof(struct mem));
-  if (zero)
-  {
-    memset(rv, 0, size + sizeof(struct mem));
-  }
-  g_memsize += size;
-  p = (struct mem*)rv;
-  p->size = size;
-  p->id = g_memid;
-  if (g_memlist != 0)
-  {
-    list_add_item(g_memlist, (long)p);
-  }
-  g_memid++;
-  return rv + sizeof(struct mem);
-#else
   char* rv;
 
   rv = (char*)malloc(size);
@@ -269,37 +64,21 @@ void* g_malloc(int size, int zero)
     memset(rv, 0, size);
   }
   return rv;
-#endif
 }
 
 /*****************************************************************************/
-void g_free(void* ptr)
+void
+g_free(void* ptr)
 {
-#if defined(MEMLEAK)
-  struct mem* p;
-  int i;
-
-  if (ptr != 0)
-  {
-    p = (struct mem*)(((char*)ptr) - sizeof(struct mem));
-    g_memsize -= p->size;
-    i = list_index_of(g_memlist, (long)p);
-    if (i >= 0)
-    {
-      list_remove_item(g_memlist, i);
-    }
-    free(p);
-  }
-#else
   if (ptr != 0)
   {
     free(ptr);
   }
-#endif
 }
 
 /*****************************************************************************/
-void g_printf(char* format, ...)
+void
+g_printf(char* format, ...)
 {
   va_list ap;
 
@@ -309,7 +88,8 @@ void g_printf(char* format, ...)
 }
 
 /*****************************************************************************/
-void g_sprintf(char* dest, char* format, ...)
+void
+g_sprintf(char* dest, char* format, ...)
 {
   va_list ap;
 
@@ -320,7 +100,8 @@ void g_sprintf(char* dest, char* format, ...)
 
 /*****************************************************************************/
 /* produce a hex dump */
-void g_hexdump(char* p, int len)
+void
+g_hexdump(char* p, int len)
 {
   unsigned char* line;
   int i;
@@ -356,25 +137,29 @@ void g_hexdump(char* p, int len)
 }
 
 /*****************************************************************************/
-void g_memset(void* ptr, int val, int size)
+void
+g_memset(void* ptr, int val, int size)
 {
   memset(ptr, val, size);
 }
 
 /*****************************************************************************/
-void g_memcpy(void* d_ptr, const void* s_ptr, int size)
+void
+g_memcpy(void* d_ptr, const void* s_ptr, int size)
 {
   memcpy(d_ptr, s_ptr, size);
 }
 
 /*****************************************************************************/
-int g_getchar(void)
+int
+g_getchar(void)
 {
   return getchar();
 }
 
 /*****************************************************************************/
-int g_tcp_set_no_delay(int sck)
+int
+g_tcp_set_no_delay(int sck)
 {
   int i;
 
@@ -384,7 +169,8 @@ int g_tcp_set_no_delay(int sck)
 }
 
 /*****************************************************************************/
-int g_tcp_socket(void)
+int
+g_tcp_socket(void)
 {
   int rv;
   int i;
@@ -396,7 +182,8 @@ int g_tcp_socket(void)
 }
 
 /*****************************************************************************/
-int g_tcp_local_socket(void)
+int
+g_tcp_local_socket(void)
 {
 #if defined(_WIN32)
   return 0;
@@ -406,7 +193,8 @@ int g_tcp_local_socket(void)
 }
 
 /*****************************************************************************/
-void g_tcp_close(int sck)
+void
+g_tcp_close(int sck)
 {
   if (sck == 0)
   {
@@ -421,7 +209,8 @@ void g_tcp_close(int sck)
 }
 
 /*****************************************************************************/
-int g_tcp_connect(int sck, char* address, char* port)
+int
+g_tcp_connect(int sck, char* address, char* port)
 {
   struct sockaddr_in s;
   struct hostent* h;
@@ -451,7 +240,8 @@ int g_tcp_connect(int sck, char* address, char* port)
 }
 
 /*****************************************************************************/
-int g_tcp_set_non_blocking(int sck)
+int
+g_tcp_set_non_blocking(int sck)
 {
   unsigned long i;
 
@@ -467,7 +257,8 @@ int g_tcp_set_non_blocking(int sck)
 }
 
 /*****************************************************************************/
-int g_tcp_bind(int sck, char* port)
+int
+g_tcp_bind(int sck, char* port)
 {
   struct sockaddr_in s;
 
@@ -479,7 +270,8 @@ int g_tcp_bind(int sck, char* port)
 }
 
 /*****************************************************************************/
-int g_tcp_local_bind(int sck, char* port)
+int
+g_tcp_local_bind(int sck, char* port)
 {
 #if defined(_WIN32)
   return -1;
@@ -494,13 +286,15 @@ int g_tcp_local_bind(int sck, char* port)
 }
 
 /*****************************************************************************/
-int g_tcp_listen(int sck)
+int
+g_tcp_listen(int sck)
 {
   return listen(sck, 2);
 }
 
 /*****************************************************************************/
-int g_tcp_accept(int sck)
+int
+g_tcp_accept(int sck)
 {
   struct sockaddr_in s;
 #if defined(_WIN32)
@@ -515,7 +309,8 @@ int g_tcp_accept(int sck)
 }
 
 /*****************************************************************************/
-void g_sleep(int msecs)
+void
+g_sleep(int msecs)
 {
 #if defined(_WIN32)
   Sleep(msecs);
@@ -525,7 +320,8 @@ void g_sleep(int msecs)
 }
 
 /*****************************************************************************/
-int g_tcp_last_error_would_block(int sck)
+int
+g_tcp_last_error_would_block(int sck)
 {
 #if defined(_WIN32)
   return WSAGetLastError() == WSAEWOULDBLOCK;
@@ -535,19 +331,22 @@ int g_tcp_last_error_would_block(int sck)
 }
 
 /*****************************************************************************/
-int g_tcp_recv(int sck, void* ptr, int len, int flags)
+int
+g_tcp_recv(int sck, void* ptr, int len, int flags)
 {
   return recv(sck, ptr, len, flags);
 }
 
 /*****************************************************************************/
-int g_tcp_send(int sck, void* ptr, int len, int flags)
+int
+g_tcp_send(int sck, void* ptr, int len, int flags)
 {
   return send(sck, ptr, len, flags);
 }
 
 /*****************************************************************************/
-int g_tcp_select(int sck1, int sck2)
+int
+g_tcp_select(int sck1, int sck2)
 {
   fd_set rfds;
   struct timeval time;
@@ -587,194 +386,8 @@ int g_tcp_select(int sck1, int sck2)
 }
 
 /*****************************************************************************/
-int g_is_term(void)
-{
-  int rv;
-
-#if defined(_WIN32)
-  EnterCriticalSection(&g_term_mutex);
-  rv = g_term;
-  LeaveCriticalSection(&g_term_mutex);
-#elif defined (USE_PTHREAD)
-  pthread_mutex_lock(&g_term_mutex);
-  rv = g_term;
-  pthread_mutex_unlock(&g_term_mutex);
-#else
-  rv = 1;
-#endif
-  return rv;
-}
-
-/*****************************************************************************/
-void g_set_term(int in_val)
-{
-#if defined(_WIN32)
-  EnterCriticalSection(&g_term_mutex);
-  g_term = in_val;
-  LeaveCriticalSection(&g_term_mutex);
-#elif defined(USE_PTHREAD)
-  pthread_mutex_lock(&g_term_mutex);
-  g_term = in_val;
-  pthread_mutex_unlock(&g_term_mutex);
-#endif
-}
-
-/*****************************************************************************/
-#if defined(_WIN32)
-int g_thread_create(unsigned long (__stdcall * start_routine)(void*), void* arg)
-{
-  DWORD thread;
-
-  return !CreateThread(0, 0, start_routine, arg, 0, &thread);
-}
-#elif defined(USE_PTHREAD)
-int g_thread_create(void* (* start_routine)(void*), void* arg)
-{
-  pthread_t thread;
-  int rv;
-
-  rv = pthread_create(&thread, 0, start_routine, arg);
-  pthread_detach(thread);
-  return rv;
-}
-#endif
-
-/*****************************************************************************/
-int g_get_threadid(void)
-{
-#if defined(_WIN32)
-  return 0;
-#elif defined(USE_PTHREAD)
-  return pthread_self();
-#else
-  return 0;
-#endif
-}
-
-#if defined(USE_OPENSSL)
-
-/* rc4 stuff */
-
-/*****************************************************************************/
-void* g_rc4_info_create(void)
-{
-  return g_malloc(sizeof(RC4_KEY), 1);;
-}
-
-/*****************************************************************************/
-void g_rc4_info_delete(void* rc4_info)
-{
-  g_free(rc4_info);
-}
-
-/*****************************************************************************/
-void g_rc4_set_key(void* rc4_info, char* key, int len)
-{
-  RC4_set_key((RC4_KEY*)rc4_info, len, (unsigned char*)key);
-}
-
-/*****************************************************************************/
-void g_rc4_crypt(void* rc4_info, char* data, int len)
-{
-  RC4((RC4_KEY*)rc4_info, len, (unsigned char*)data, (unsigned char*)data);
-}
-
-/* sha1 stuff */
-
-/*****************************************************************************/
-void* g_sha1_info_create(void)
-{
-  return g_malloc(sizeof(SHA_CTX), 1);
-}
-
-/*****************************************************************************/
-void g_sha1_info_delete(void* sha1_info)
-{
-  g_free(sha1_info);
-}
-
-/*****************************************************************************/
-void g_sha1_clear(void* sha1_info)
-{
-  SHA1_Init((SHA_CTX*)sha1_info);
-}
-
-/*****************************************************************************/
-void g_sha1_transform(void* sha1_info, char* data, int len)
-{
-  SHA1_Update((SHA_CTX*)sha1_info, data, len);
-}
-
-/*****************************************************************************/
-void g_sha1_complete(void* sha1_info, char* data)
-{
-  SHA1_Final((unsigned char*)data, (SHA_CTX*)sha1_info);
-}
-
-/* md5 stuff */
-
-/*****************************************************************************/
-void* g_md5_info_create(void)
-{
-  return g_malloc(sizeof(MD5_CTX), 1);
-}
-
-/*****************************************************************************/
-void g_md5_info_delete(void* md5_info)
-{
-  g_free(md5_info);
-}
-
-/*****************************************************************************/
-void g_md5_clear(void* md5_info)
-{
-  MD5_Init((MD5_CTX*)md5_info);
-}
-
-/*****************************************************************************/
-void g_md5_transform(void* md5_info, char* data, int len)
-{
-  MD5_Update((MD5_CTX*)md5_info, data, len);
-}
-
-/*****************************************************************************/
-void g_md5_complete(void* md5_info, char* data)
-{
-  MD5_Final((unsigned char*)data, (MD5_CTX*)md5_info);
-}
-
-/*****************************************************************************/
-int g_mod_exp(char* out, char* in, char* mod, char* exp)
-{
-  BN_CTX* ctx;
-  BIGNUM lmod;
-  BIGNUM lexp;
-  BIGNUM lin;
-  BIGNUM lout;
-  int rv;
-
-  ctx = BN_CTX_new();
-  BN_init(&lmod);
-  BN_init(&lexp);
-  BN_init(&lin);
-  BN_init(&lout);
-  BN_bin2bn((unsigned char*)mod, 64, &lmod);
-  BN_bin2bn((unsigned char*)exp, 64, &lexp);
-  BN_bin2bn((unsigned char*)in, 64, &lin);
-  BN_mod_exp(&lout, &lin, &lexp, &lmod, ctx);
-  rv = BN_bn2bin(&lout, (unsigned char*)out);
-  BN_free(&lin);
-  BN_free(&lout);
-  BN_free(&lexp);
-  BN_free(&lmod);
-  BN_CTX_free(ctx);
-  return rv;
-}
-
-#endif
-
-/*****************************************************************************/
-void g_random(char* data, int len)
+void
+g_random(char* data, int len)
 {
 #if defined(_WIN32)
   memset(data, 0x44, len);
@@ -796,19 +409,22 @@ void g_random(char* data, int len)
 }
 
 /*****************************************************************************/
-int g_abs(int i)
+int
+g_abs(int i)
 {
   return abs(i);
 }
 
 /*****************************************************************************/
-int g_memcmp(void* s1, void* s2, int len)
+int
+g_memcmp(void* s1, void* s2, int len)
 {
   return memcmp(s1, s2, len);
 }
 
 /*****************************************************************************/
-int g_file_open(char* file_name)
+int
+g_file_open(char* file_name)
 {
 #if defined(_WIN32)
   return (int)CreateFile(file_name, GENERIC_READ | GENERIC_WRITE,
@@ -820,7 +436,8 @@ int g_file_open(char* file_name)
 }
 
 /*****************************************************************************/
-int g_file_close(int fd)
+int
+g_file_close(int fd)
 {
 #if defined(_WIN32)
   CloseHandle((HANDLE)fd);
@@ -832,7 +449,8 @@ int g_file_close(int fd)
 
 /*****************************************************************************/
 /* read from file*/
-int g_file_read(int fd, char* ptr, int len)
+int
+g_file_read(int fd, char* ptr, int len)
 {
 #if defined(_WIN32)
   if (ReadFile((HANDLE)fd, (LPVOID)ptr, (DWORD)len, (LPDWORD)&len, 0))
@@ -850,7 +468,8 @@ int g_file_read(int fd, char* ptr, int len)
 
 /*****************************************************************************/
 /* write to file */
-int g_file_write(int fd, char* ptr, int len)
+int
+g_file_write(int fd, char* ptr, int len)
 {
 #if defined(_WIN32)
   if (WriteFile((HANDLE)fd, (LPVOID)ptr, (DWORD)len, (LPDWORD)&len, 0))
@@ -868,7 +487,8 @@ int g_file_write(int fd, char* ptr, int len)
 
 /*****************************************************************************/
 /* move file pointer */
-int g_file_seek(int fd, int offset)
+int
+g_file_seek(int fd, int offset)
 {
 #if defined(_WIN32)
   return SetFilePointer((HANDLE)fd, offset, 0, FILE_BEGIN);
@@ -880,7 +500,8 @@ int g_file_seek(int fd, int offset)
 /*****************************************************************************/
 /* do a write lock on a file */
 /* return boolean */
-int g_file_lock(int fd, int start, int len)
+int
+g_file_lock(int fd, int start, int len)
 {
 #if defined(_WIN32)
   return LockFile((HANDLE)fd, start, 0, len, 0);
@@ -900,7 +521,8 @@ int g_file_lock(int fd, int start, int len)
 }
 
 /*****************************************************************************/
-int g_strlen(char* text)
+int
+g_strlen(char* text)
 {
   if (text == 0)
   {
@@ -910,7 +532,8 @@ int g_strlen(char* text)
 }
 
 /*****************************************************************************/
-char* g_strcpy(char* dest, char* src)
+char*
+g_strcpy(char* dest, char* src)
 {
   if (src == 0 && dest != 0)
   {
@@ -925,7 +548,8 @@ char* g_strcpy(char* dest, char* src)
 }
 
 /*****************************************************************************/
-char* g_strncpy(char* dest, char* src, int len)
+char*
+g_strncpy(char* dest, char* src, int len)
 {
   char* rv;
 
@@ -944,7 +568,8 @@ char* g_strncpy(char* dest, char* src, int len)
 }
 
 /*****************************************************************************/
-char* g_strcat(char* dest, char* src)
+char*
+g_strcat(char* dest, char* src)
 {
   if (dest == 0 || src == 0)
   {
@@ -954,7 +579,8 @@ char* g_strcat(char* dest, char* src)
 }
 
 /*****************************************************************************/
-char* g_strdup(char* in)
+char*
+g_strdup(char* in)
 {
   int len;
   char* p;
@@ -970,19 +596,22 @@ char* g_strdup(char* in)
 }
 
 /*****************************************************************************/
-int g_strcmp(char* c1, char* c2)
+int
+g_strcmp(char* c1, char* c2)
 {
   return strcmp(c1, c2);
 }
 
 /*****************************************************************************/
-int g_strncmp(char* c1, char* c2, int len)
+int
+g_strncmp(char* c1, char* c2, int len)
 {
   return strncmp(c1, c2, len);
 }
 
 /*****************************************************************************/
-long g_load_library(char* in)
+long
+g_load_library(char* in)
 {
 #if defined(_WIN32)
   return 0;
@@ -992,7 +621,8 @@ long g_load_library(char* in)
 }
 
 /*****************************************************************************/
-int g_free_library(long lib)
+int
+g_free_library(long lib)
 {
   if (lib == 0)
   {
@@ -1007,7 +637,8 @@ int g_free_library(long lib)
 
 /*****************************************************************************/
 /* returns NULL if not found */
-void* g_get_proc_address(long lib, char* name)
+void*
+g_get_proc_address(long lib, char* name)
 {
   if (lib == 0)
   {
@@ -1021,7 +652,8 @@ void* g_get_proc_address(long lib, char* name)
 }
 
 /*****************************************************************************/
-int g_system(char* aexec)
+int
+g_system(char* aexec)
 {
 #if defined(_WIN32)
   return 0;
@@ -1031,17 +663,11 @@ int g_system(char* aexec)
 }
 
 /*****************************************************************************/
-void g_signal(int sig_num, void (*func)(int))
+void
+g_signal(int sig_num, void (*func)(int))
 {
 #if defined(_WIN32)
 #else
   signal(sig_num, func);
 #endif
 }
-
-/*****************************************************************************/
-void g_pipe_sig(int sig_num)
-{
-  /* do nothing */
-  g_printf("got SIGPIPE(%d)\n\r", sig_num);
-}
diff --git a/common/os_calls.h b/common/os_calls.h
index 7bc6bd89..81f90b66 100644
--- a/common/os_calls.h
+++ b/common/os_calls.h
@@ -20,23 +20,37 @@
 
 */
 
+#if !defined(OS_CALLS_H)
+#define OS_CALLS_H
+
 int g_init_system(void);
 int g_exit_system(void);
-void g_printf(char *format, ...);
-void g_sprintf(char* dest, char* format, ...);
-void g_hexdump(char* p, int len);
-void* g_malloc(int size, int zero);
-void* g_malloc1(int size, int zero);
-void g_free(void* ptr);
-void g_free1(void* ptr);
-void g_memset(void* ptr, int val, int size);
-void g_memcpy(void* d_ptr, const void* s_ptr, int size);
-int g_getchar(void);
-int g_tcp_set_no_delay(int sck);
-int g_tcp_socket(void);
-int g_tcp_local_socket(void);
-void g_tcp_close(int sck);
-int g_tcp_connect(int sck, char* address, char* port);
+void
+g_printf(char *format, ...);
+void
+g_sprintf(char* dest, char* format, ...);
+void
+g_hexdump(char* p, int len);
+void*
+g_malloc(int size, int zero);
+void
+g_free(void* ptr);
+void
+g_memset(void* ptr, int val, int size);
+void
+g_memcpy(void* d_ptr, const void* s_ptr, int size);
+int
+g_getchar(void);
+int
+g_tcp_set_no_delay(int sck);
+int
+g_tcp_socket(void);
+int
+g_tcp_local_socket(void);
+void
+g_tcp_close(int sck);
+int
+g_tcp_connect(int sck, char* address, char* port);
 int g_tcp_force_send(int sck, char* data, int len);
 int g_tcp_force_recv(int sck, char* data, int len);
 int g_tcp_set_non_blocking(int sck);
@@ -48,26 +62,7 @@ int g_tcp_recv(int sck, void* ptr, int len, int flags);
 int g_tcp_send(int sck, void* ptr, int len, int flags);
 int g_tcp_last_error_would_block(int sck);
 int g_tcp_select(int sck1, int sck2);
-int g_is_term(void);
-void g_set_term(int in_val);
 void g_sleep(int msecs);
-int g_thread_create(THREAD_RV (THREAD_CC * start_routine)(void*), void* arg);
-int g_get_threadid(void);
-void* g_rc4_info_create(void);
-void g_rc4_info_delete(void* rc4_info);
-void g_rc4_set_key(void* rc4_info, char* key, int len);
-void g_rc4_crypt(void* rc4_info, char* data, int len);
-void* g_sha1_info_create(void);
-void g_sha1_info_delete(void* sha1_info);
-void g_sha1_clear(void* sha1_info);
-void g_sha1_transform(void* sha1_info, char* data, int len);
-void g_sha1_complete(void* sha1_info, char* data);
-void* g_md5_info_create(void);
-void g_md5_info_delete(void* md5_info);
-void g_md5_clear(void* md5_info);
-void g_md5_transform(void* md5_info, char* data, int len);
-void g_md5_complete(void* md5_info, char* data);
-int g_mod_exp(char* out, char* in, char* mod, char* exp);
 void g_random(char* data, int len);
 int g_abs(int i);
 int g_memcmp(void* s1, void* s2, int len);
@@ -89,3 +84,5 @@ int g_free_library(long lib);
 void* g_get_proc_address(long lib, char* name);
 int g_system(char* aexec);
 void g_signal(int sig_num, void (*func)(int));
+
+#endif
diff --git a/common/parse.h b/common/parse.h
index e65f4c99..3c8b3fe6 100644
--- a/common/parse.h
+++ b/common/parse.h
@@ -21,6 +21,9 @@
 /* modified for xrdp */
 /* this is a super fast stream method, you bet */
 
+#if !defined(PARSE_H)
+#define PARSE_H
+
 #if defined(L_ENDIAN)
 #elif defined(B_ENDIAN)
 #else
@@ -299,3 +302,5 @@ struct stream
   g_memset((s)->p, 0, (n)); \
   (s)->p += (n); \
 }
+
+#endif
diff --git a/common/ssl_calls.c b/common/ssl_calls.c
new file mode 100644
index 00000000..7840eeb2
--- /dev/null
+++ b/common/ssl_calls.c
@@ -0,0 +1,161 @@
+/*
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+
+   xrdp: A Remote Desktop Protocol server.
+   Copyright (C) Jay Sorg 2004-2005
+
+   ssl calls
+
+*/
+
+#include "os_calls.h"
+
+#include <openssl/rc4.h>
+#include <openssl/md5.h>
+#include <openssl/sha.h>
+#include <openssl/bn.h>
+
+/* rc4 stuff */
+
+/*****************************************************************************/
+void*
+g_rc4_info_create(void)
+{
+  return g_malloc(sizeof(RC4_KEY), 1);;
+}
+
+/*****************************************************************************/
+void
+g_rc4_info_delete(void* rc4_info)
+{
+  g_free(rc4_info);
+}
+
+/*****************************************************************************/
+void
+g_rc4_set_key(void* rc4_info, char* key, int len)
+{
+  RC4_set_key((RC4_KEY*)rc4_info, len, (unsigned char*)key);
+}
+
+/*****************************************************************************/
+void
+g_rc4_crypt(void* rc4_info, char* data, int len)
+{
+  RC4((RC4_KEY*)rc4_info, len, (unsigned char*)data, (unsigned char*)data);
+}
+
+/* sha1 stuff */
+
+/*****************************************************************************/
+void*
+g_sha1_info_create(void)
+{
+  return g_malloc(sizeof(SHA_CTX), 1);
+}
+
+/*****************************************************************************/
+void
+g_sha1_info_delete(void* sha1_info)
+{
+  g_free(sha1_info);
+}
+
+/*****************************************************************************/
+void
+g_sha1_clear(void* sha1_info)
+{
+  SHA1_Init((SHA_CTX*)sha1_info);
+}
+
+/*****************************************************************************/
+void
+g_sha1_transform(void* sha1_info, char* data, int len)
+{
+  SHA1_Update((SHA_CTX*)sha1_info, data, len);
+}
+
+/*****************************************************************************/
+void
+g_sha1_complete(void* sha1_info, char* data)
+{
+  SHA1_Final((unsigned char*)data, (SHA_CTX*)sha1_info);
+}
+
+/* md5 stuff */
+
+/*****************************************************************************/
+void*
+g_md5_info_create(void)
+{
+  return g_malloc(sizeof(MD5_CTX), 1);
+}
+
+/*****************************************************************************/
+void
+g_md5_info_delete(void* md5_info)
+{
+  g_free(md5_info);
+}
+
+/*****************************************************************************/
+void
+g_md5_clear(void* md5_info)
+{
+  MD5_Init((MD5_CTX*)md5_info);
+}
+
+/*****************************************************************************/
+void
+g_md5_transform(void* md5_info, char* data, int len)
+{
+  MD5_Update((MD5_CTX*)md5_info, data, len);
+}
+
+/*****************************************************************************/
+void
+g_md5_complete(void* md5_info, char* data)
+{
+  MD5_Final((unsigned char*)data, (MD5_CTX*)md5_info);
+}
+
+/*****************************************************************************/
+int
+g_mod_exp(char* out, char* in, char* mod, char* exp)
+{
+  BN_CTX* ctx;
+  BIGNUM lmod;
+  BIGNUM lexp;
+  BIGNUM lin;
+  BIGNUM lout;
+  int rv;
+
+  ctx = BN_CTX_new();
+  BN_init(&lmod);
+  BN_init(&lexp);
+  BN_init(&lin);
+  BN_init(&lout);
+  BN_bin2bn((unsigned char*)mod, 64, &lmod);
+  BN_bin2bn((unsigned char*)exp, 64, &lexp);
+  BN_bin2bn((unsigned char*)in, 64, &lin);
+  BN_mod_exp(&lout, &lin, &lexp, &lmod, ctx);
+  rv = BN_bn2bin(&lout, (unsigned char*)out);
+  BN_free(&lin);
+  BN_free(&lout);
+  BN_free(&lexp);
+  BN_free(&lmod);
+  BN_CTX_free(ctx);
+  return rv;
+}
diff --git a/common/ssl_calls.h b/common/ssl_calls.h
new file mode 100644
index 00000000..1d736fae
--- /dev/null
+++ b/common/ssl_calls.h
@@ -0,0 +1,55 @@
+/*
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+
+   xrdp: A Remote Desktop Protocol server.
+   Copyright (C) Jay Sorg 2004-2005
+
+*/
+
+#if !defined(SSL_CALLS_H)
+#define SSL_CALLS_H
+
+void*
+g_rc4_info_create(void);
+void
+g_rc4_info_delete(void* rc4_info);
+void
+g_rc4_set_key(void* rc4_info, char* key, int len);
+void
+g_rc4_crypt(void* rc4_info, char* data, int len);
+void*
+g_sha1_info_create(void);
+void
+g_sha1_info_delete(void* sha1_info);
+void
+g_sha1_clear(void* sha1_info);
+void
+g_sha1_transform(void* sha1_info, char* data, int len);
+void
+g_sha1_complete(void* sha1_info, char* data);
+void*
+g_md5_info_create(void);
+void
+g_md5_info_delete(void* md5_info);
+void
+g_md5_clear(void* md5_info);
+void
+g_md5_transform(void* md5_info, char* data, int len);
+void
+g_md5_complete(void* md5_info, char* data);
+int
+g_mod_exp(char* out, char* in, char* mod, char* exp);
+
+#endif
diff --git a/common/thread_calls.c b/common/thread_calls.c
new file mode 100644
index 00000000..ad2334d4
--- /dev/null
+++ b/common/thread_calls.c
@@ -0,0 +1,60 @@
+/*
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+
+   xrdp: A Remote Desktop Protocol server.
+   Copyright (C) Jay Sorg 2004-2005
+
+   thread calls
+
+*/
+
+#if defined(_WIN32)
+#include <windows.h>
+#else
+#include <pthread.h>
+#endif
+
+/*****************************************************************************/
+#if defined(_WIN32)
+int
+g_thread_create(unsigned long (__stdcall * start_routine)(void*), void* arg)
+{
+  DWORD thread;
+
+  return !CreateThread(0, 0, start_routine, arg, 0, &thread);
+}
+#else
+int
+g_thread_create(void* (* start_routine)(void*), void* arg)
+{
+  pthread_t thread;
+  int rv;
+
+  rv = pthread_create(&thread, 0, start_routine, arg);
+  pthread_detach(thread);
+  return rv;
+}
+#endif
+
+/*****************************************************************************/
+int
+g_get_threadid(void)
+{
+#if defined(_WIN32)
+  return 0;
+#else
+  return pthread_self();
+#endif
+}
diff --git a/common/thread_calls.h b/common/thread_calls.h
new file mode 100644
index 00000000..700a8133
--- /dev/null
+++ b/common/thread_calls.h
@@ -0,0 +1,29 @@
+/*
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+
+   xrdp: A Remote Desktop Protocol server.
+   Copyright (C) Jay Sorg 2004-2005
+
+*/
+
+#if !defined(THREAD_CALLS_H)
+#define THREAD_CALLS_H
+
+int
+g_thread_create(THREAD_RV (THREAD_CC * start_routine)(void*), void* arg);
+int
+g_get_threadid(void);
+
+#endif
diff --git a/common/xrdp_constants.h b/common/xrdp_constants.h
new file mode 100644
index 00000000..0f40cd5c
--- /dev/null
+++ b/common/xrdp_constants.h
@@ -0,0 +1,438 @@
+/*
+   rdesktop: A Remote Desktop Protocol client.
+   Miscellaneous protocol constants
+   Copyright (C) Matthew Chapman 1999-2002
+
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+*/
+
+/* modified for xrdp */
+
+#if !defined(XRDP_CONSTANTS_H)
+#define XRDP_CONSTANTS_H
+
+/* TCP port for Remote Desktop Protocol */
+#define TCP_PORT_RDP                   3389
+
+#define ISO_PDU_CR                     0xE0 /* Connection Request */
+#define ISO_PDU_CC                     0xD0 /* Connection Confirm */
+#define ISO_PDU_DR                     0x80 /* Disconnect Request */
+#define ISO_PDU_DT                     0xF0 /* Data */
+#define ISO_PDU_ER                     0x70 /* Error */
+
+/* MCS PDU codes */
+#define MCS_EDRQ                       1  /* Erect Domain Request */
+#define MCS_DPUM                       8  /* Disconnect Provider Ultimatum */
+#define MCS_AURQ                       10 /* Attach User Request */
+#define MCS_AUCF                       11 /* Attach User Confirm */
+#define MCS_CJRQ                       14 /* Channel Join Request */
+#define MCS_CJCF                       15 /* Channel Join Confirm */
+#define MCS_SDRQ                       25 /* Send Data Request */
+#define MCS_SDIN                       26 /* Send Data Indication */
+
+#define MCS_CONNECT_INITIAL            0x7f65
+#define MCS_CONNECT_RESPONSE           0x7f66
+
+#define BER_TAG_BOOLEAN                1
+#define BER_TAG_INTEGER                2
+#define BER_TAG_OCTET_STRING           4
+#define BER_TAG_RESULT                 10
+#define MCS_TAG_DOMAIN_PARAMS          0x30
+
+#define MCS_GLOBAL_CHANNEL             1003
+#define MCS_USERCHANNEL_BASE           1001
+
+/* RDP secure transport constants */
+#define SEC_RANDOM_SIZE                32
+#define SEC_MODULUS_SIZE               64
+#define SEC_PADDING_SIZE               8
+#define SEC_EXPONENT_SIZE              4
+
+#define SEC_CLIENT_RANDOM              0x0001
+#define SEC_ENCRYPT                    0x0008
+#define SEC_LOGON_INFO                 0x0040
+#define SEC_LICENCE_NEG                0x0080
+
+#define SEC_TAG_SRV_INFO               0x0c01
+#define SEC_TAG_SRV_CRYPT              0x0c02
+#define SEC_TAG_SRV_CHANNELS           0x0c03
+
+#define SEC_TAG_CLI_INFO               0xc001
+#define SEC_TAG_CLI_CRYPT              0xc002
+#define SEC_TAG_CLI_CHANNELS           0xc003
+#define SEC_TAG_CLI_4                  0xc004
+
+#define SEC_TAG_PUBKEY                 0x0006
+#define SEC_TAG_KEYSIG                 0x0008
+
+#define SEC_RSA_MAGIC                  0x31415352 /* RSA1 */
+
+/* RDP licensing constants */
+#define LICENCE_TOKEN_SIZE	            10
+#define LICENCE_HWID_SIZE	            20
+#define LICENCE_SIGNATURE_SIZE	      16
+
+#define LICENCE_TAG_DEMAND             0x01
+#define LICENCE_TAG_AUTHREQ            0x02
+#define LICENCE_TAG_ISSUE              0x03
+#define LICENCE_TAG_REISSUE            0x04
+#define LICENCE_TAG_PRESENT            0x12
+#define LICENCE_TAG_REQUEST            0x13
+#define LICENCE_TAG_AUTHRESP           0x15
+#define LICENCE_TAG_RESULT             0xff
+
+#define LICENCE_TAG_USER               0x000f
+#define LICENCE_TAG_HOST               0x0010
+
+/* RDP PDU codes */
+#define RDP_PDU_DEMAND_ACTIVE          1
+#define RDP_PDU_CONFIRM_ACTIVE         3
+#define RDP_PDU_DEACTIVATE             6
+#define RDP_PDU_DATA                   7
+
+#define RDP_DATA_PDU_UPDATE            2
+#define RDP_DATA_PDU_CONTROL           20
+#define RDP_DATA_PDU_POINTER           27
+#define RDP_DATA_PDU_INPUT             28
+#define RDP_DATA_PDU_SYNCHRONISE       31
+#define RDP_DATA_PDU_BELL              34
+#define RDP_DATA_PDU_LOGON             38
+#define RDP_DATA_PDU_FONT2             39
+#define RDP_DATA_PDU_DISCONNECT        47
+
+#define RDP_CTL_REQUEST_CONTROL        1
+#define RDP_CTL_GRANT_CONTROL          2
+#define RDP_CTL_DETACH                 3
+#define RDP_CTL_COOPERATE              4
+
+#define RDP_UPDATE_ORDERS              0
+#define RDP_UPDATE_BITMAP              1
+#define RDP_UPDATE_PALETTE             2
+#define RDP_UPDATE_SYNCHRONIZE         3
+
+#define RDP_POINTER_SYSTEM             1
+#define RDP_POINTER_MOVE               3
+#define RDP_POINTER_COLOR              6
+#define RDP_POINTER_CACHED             7
+
+#define RDP_NULL_POINTER               0
+#define RDP_DEFAULT_POINTER            0x7F00
+
+#define RDP_INPUT_SYNCHRONIZE          0
+#define RDP_INPUT_CODEPOINT            1
+#define RDP_INPUT_VIRTKEY              2
+#define RDP_INPUT_SCANCODE             4
+#define RDP_INPUT_MOUSE                0x8001
+
+/* Device flags */
+#define KBD_FLAG_RIGHT                 0x0001
+#define KBD_FLAG_EXT                   0x0100
+#define KBD_FLAG_QUIET                 0x1000
+#define KBD_FLAG_DOWN                  0x4000
+#define KBD_FLAG_UP                    0x8000
+
+/* These are for synchronization; not for keystrokes */
+#define KBD_FLAG_SCROLL                0x0001
+#define KBD_FLAG_NUMLOCK               0x0002
+#define KBD_FLAG_CAPITAL               0x0004
+
+/* See T.128 */
+#define RDP_KEYPRESS                   0
+#define RDP_KEYRELEASE                 (KBD_FLAG_DOWN | KBD_FLAG_UP)
+
+#define MOUSE_FLAG_MOVE                0x0800
+#define MOUSE_FLAG_BUTTON1             0x1000
+#define MOUSE_FLAG_BUTTON2             0x2000
+#define MOUSE_FLAG_BUTTON3             0x4000
+#define MOUSE_FLAG_BUTTON4             0x0280
+#define MOUSE_FLAG_BUTTON5             0x0380
+#define MOUSE_FLAG_DOWN                0x8000
+
+/* Raster operation masks */
+#define ROP2_S(rop3)                   (rop3 & 0xf)
+#define ROP2_P(rop3)                   ((rop3 & 0x3) | ((rop3 & 0x30) >> 2))
+
+#define ROP2_COPY                      0xc
+#define ROP2_XOR                       0x6
+#define ROP2_AND                       0x8
+#define ROP2_NXOR                      0x9
+#define ROP2_OR                        0xe
+
+#define MIX_TRANSPARENT                0
+#define MIX_OPAQUE                     1
+
+#define TEXT2_VERTICAL                 0x04
+#define TEXT2_IMPLICIT_X               0x20
+
+/* RDP bitmap cache (version 2) constants */
+#define BMPCACHE2_C0_CELLS             0x78
+#define BMPCACHE2_C1_CELLS             0x78
+#define BMPCACHE2_C2_CELLS             0x150
+#define BMPCACHE2_NUM_PSTCELLS         0x9f6
+
+#define PDU_FLAG_FIRST                 0x01
+#define PDU_FLAG_LAST                  0x02
+
+/* Maps to generalCapabilitySet in T.128 page 138 */
+
+/* RDP capabilities */
+#define RDP_CAPSET_GENERAL             1
+#define RDP_CAPLEN_GENERAL             0x18
+#define OS_MAJOR_TYPE_UNIX             4
+#define OS_MINOR_TYPE_XSERVER          7
+
+#define RDP_CAPSET_BITMAP              2
+#define RDP_CAPLEN_BITMAP              0x1C
+
+#define RDP_CAPSET_ORDER               3
+#define RDP_CAPLEN_ORDER               0x58
+#define ORDER_CAP_NEGOTIATE            2
+#define ORDER_CAP_NOSUPPORT            4
+
+#define RDP_CAPSET_BMPCACHE            4
+#define RDP_CAPLEN_BMPCACHE            0x28
+
+#define RDP_CAPSET_CONTROL             5
+#define RDP_CAPLEN_CONTROL             0x0C
+
+#define RDP_CAPSET_ACTIVATE            7
+#define RDP_CAPLEN_ACTIVATE            0x0C
+
+#define RDP_CAPSET_POINTER             8
+#define RDP_CAPLEN_POINTER             0x08
+
+#define RDP_CAPSET_SHARE               9
+#define RDP_CAPLEN_SHARE               0x08
+
+#define RDP_CAPSET_COLCACHE            10
+#define RDP_CAPLEN_COLCACHE            0x08
+
+#define RDP_CAPSET_BMPCACHE2           19
+#define RDP_CAPLEN_BMPCACHE2           0x28
+#define BMPCACHE2_FLAG_PERSIST         ((long)1<<31)
+
+#define RDP_SOURCE                     "MSTSC"
+
+/* Logon flags */
+#define RDP_LOGON_AUTO                 0x0008
+#define RDP_LOGON_NORMAL               0x0033
+#define RDP_COMPRESSION                0x0080
+#define RDP_LOGON_BLOB                 0x0100
+#define RDP_LOGON_LEAVE_AUDIO          0x2000
+
+#define RDP5_DISABLE_NOTHING           0x00
+#define RDP5_NO_WALLPAPER              0x01
+#define RDP5_NO_FULLWINDOWDRAG         0x02
+#define RDP5_NO_MENUANIMATIONS         0x04
+#define RDP5_NO_THEMING                0x08
+#define RDP5_NO_CURSOR_SHADOW          0x20
+#define RDP5_NO_CURSORSETTINGS         0x40 /* disables cursor blinking */
+
+/* compression types */
+#define RDP_MPPC_COMPRESSED            0x20
+#define RDP_MPPC_RESET                 0x40
+#define RDP_MPPC_FLUSH                 0x80
+#define RDP_MPPC_DICT_SIZE             8192
+
+/* Keymap flags */
+#define MapRightShiftMask              (1 << 0)
+#define MapLeftShiftMask               (1 << 1)
+#define MapShiftMask                   (MapRightShiftMask | MapLeftShiftMask)
+
+#define MapRightAltMask                (1 << 2)
+#define MapLeftAltMask                 (1 << 3)
+#define MapAltGrMask                   MapRightAltMask
+
+#define MapRightCtrlMask               (1 << 4)
+#define MapLeftCtrlMask                (1 << 5)
+#define MapCtrlMask                    (MapRightCtrlMask | MapLeftCtrlMask)
+
+#define MapRightWinMask                (1 << 6)
+#define MapLeftWinMask                 (1 << 7)
+#define MapWinMask                     (MapRightWinMask | MapLeftWinMask)
+
+#define MapNumLockMask                 (1 << 8)
+#define MapCapsLockMask                (1 << 9)
+
+#define MapLocalStateMask              (1 << 10)
+
+#define MapInhibitMask                 (1 << 11)
+
+#define MASK_ADD_BITS(var, mask)       (var |= mask)
+#define MASK_REMOVE_BITS(var, mask)    (var &= ~mask)
+#define MASK_HAS_BITS(var, mask)       ((var & mask)>0)
+#define MASK_CHANGE_BIT(var, mask, active) \
+                  (var = ((var & ~mask) | (active ? mask : 0)))
+
+/* Clipboard constants, "borrowed" from GCC system headers in
+   the w32 cross compiler */
+
+#define CF_TEXT                        1
+#define CF_BITMAP                      2
+#define CF_METAFILEPICT                3
+#define CF_SYLK                        4
+#define CF_DIF                         5
+#define CF_TIFF                        6
+#define CF_OEMTEXT                     7
+#define CF_DIB                         8
+#define CF_PALETTE                     9
+#define CF_PENDATA                     10
+#define CF_RIFF                        11
+#define CF_WAVE                        12
+#define CF_UNICODETEXT                 13
+#define CF_ENHMETAFILE                 14
+#define CF_HDROP                       15
+#define CF_LOCALE                      16
+#define CF_MAX                         17
+#define CF_OWNERDISPLAY                128
+#define CF_DSPTEXT                     129
+#define CF_DSPBITMAP                   130
+#define CF_DSPMETAFILEPICT             131
+#define CF_DSPENHMETAFILE              142
+#define CF_PRIVATEFIRST                512
+#define CF_PRIVATELAST                 767
+#define CF_GDIOBJFIRST                 768
+#define CF_GDIOBJLAST                  1023
+
+/* Sound format constants */
+#define WAVE_FORMAT_PCM	               1
+#define WAVE_FORMAT_ADPCM              2
+#define WAVE_FORMAT_ALAW               6
+#define WAVE_FORMAT_MULAW              7
+
+/* Virtual channel options */
+#define CHANNEL_OPTION_INITIALIZED     0x80000000
+#define CHANNEL_OPTION_ENCRYPT_RDP     0x40000000
+#define CHANNEL_OPTION_COMPRESS_RDP    0x00800000
+#define CHANNEL_OPTION_SHOW_PROTOCOL   0x00200000
+
+/* NT status codes for RDPDR */
+#define STATUS_SUCCESS                 0x00000000
+#define STATUS_PENDING                 0x00000103
+
+#define STATUS_NO_MORE_FILES           0x80000006
+#define STATUS_DEVICE_PAPER_EMPTY      0x8000000e
+#define STATUS_DEVICE_POWERED_OFF      0x8000000f
+#define STATUS_DEVICE_OFF_LINE         0x80000010
+#define STATUS_DEVICE_BUSY             0x80000011
+
+#define STATUS_INVALID_HANDLE          0xc0000008
+#define STATUS_INVALID_PARAMETER       0xc000000d
+#define STATUS_NO_SUCH_FILE            0xc000000f
+#define STATUS_INVALID_DEVICE_REQUEST  0xc0000010
+#define STATUS_ACCESS_DENIED           0xc0000022
+#define STATUS_OBJECT_NAME_COLLISION   0xc0000035
+#define STATUS_DISK_FULL               0xc000007f
+#define STATUS_FILE_IS_A_DIRECTORY     0xc00000ba
+#define STATUS_NOT_SUPPORTED           0xc00000bb
+#define STATUS_TIMEOUT                 0xc0000102
+#define STATUS_CANCELLED               0xc0000120
+
+/* RDPDR constants */
+#define RDPDR_MAX_DEVICES              0x10
+#define DEVICE_TYPE_SERIAL             0x01
+#define DEVICE_TYPE_PARALLEL           0x02
+#define DEVICE_TYPE_PRINTER            0x04
+#define DEVICE_TYPE_DISK               0x08
+#define DEVICE_TYPE_SCARD              0x20
+
+#define FILE_DIRECTORY_FILE            0x00000001
+#define FILE_NON_DIRECTORY_FILE        0x00000040
+#define FILE_OPEN_FOR_FREE_SPACE_QUERY 0x00800000
+
+/* RDP5 disconnect PDU */
+#define exDiscReasonNoInfo                            0x0000
+#define exDiscReasonAPIInitiatedDisconnect            0x0001
+#define exDiscReasonAPIInitiatedLogoff                0x0002
+#define exDiscReasonServerIdleTimeout                 0x0003
+#define exDiscReasonServerLogonTimeout                0x0004
+#define exDiscReasonReplacedByOtherConnection         0x0005
+#define exDiscReasonOutOfMemory                       0x0006
+#define exDiscReasonServerDeniedConnection            0x0007
+#define exDiscReasonServerDeniedConnectionFips        0x0008
+#define exDiscReasonLicenseInternal                   0x0100
+#define exDiscReasonLicenseNoLicenseServer            0x0101
+#define exDiscReasonLicenseNoLicense                  0x0102
+#define exDiscReasonLicenseErrClientMsg               0x0103
+#define exDiscReasonLicenseHwidDoesntMatchLicense     0x0104
+#define exDiscReasonLicenseErrClientLicense           0x0105
+#define exDiscReasonLicenseCantFinishProtocol         0x0106
+#define exDiscReasonLicenseClientEndedProtocol        0x0107
+#define exDiscReasonLicenseErrClientEncryption        0x0108
+#define exDiscReasonLicenseCantUpgradeLicense         0x0109
+#define exDiscReasonLicenseNoRemoteConnections        0x010a
+
+#define RDP_ORDER_STANDARD   0x01
+#define RDP_ORDER_SECONDARY  0x02
+#define RDP_ORDER_BOUNDS     0x04
+#define RDP_ORDER_CHANGE     0x08
+#define RDP_ORDER_DELTA      0x10
+#define RDP_ORDER_LASTBOUNDS 0x20
+#define RDP_ORDER_SMALL      0x40
+#define RDP_ORDER_TINY       0x80
+
+#define RDP_ORDER_DESTBLT   0
+#define RDP_ORDER_PATBLT    1
+#define RDP_ORDER_SCREENBLT 2
+#define RDP_ORDER_LINE      9
+#define RDP_ORDER_RECT      10
+#define RDP_ORDER_DESKSAVE  11
+#define RDP_ORDER_MEMBLT    13
+#define RDP_ORDER_TRIBLT    14
+#define RDP_ORDER_POLYLINE  22
+#define RDP_ORDER_TEXT2     27
+
+#define RDP_ORDER_RAW_BMPCACHE  0
+#define RDP_ORDER_COLCACHE      1
+#define RDP_ORDER_BMPCACHE      2
+#define RDP_ORDER_FONTCACHE     3
+#define RDP_ORDER_RAW_BMPCACHE2 4
+#define RDP_ORDER_BMPCACHE2     5
+
+/* drawable types */
+#define WND_TYPE_BITMAP  0
+#define WND_TYPE_WND     1
+#define WND_TYPE_SCREEN  2
+#define WND_TYPE_BUTTON  3
+#define WND_TYPE_IMAGE   4
+#define WND_TYPE_EDIT    5
+#define WND_TYPE_LABEL   6
+#define WND_TYPE_COMBO   7
+#define WND_TYPE_SPECIAL 8
+
+/* button states */
+#define BUTTON_STATE_UP   0
+#define BUTTON_STATE_DOWN 1
+
+/* messages */
+#define WM_PAINT       3
+#define WM_KEYDOWN     15
+#define WM_KEYUP       16
+#define WM_MOUSEMOVE   100
+#define WM_LBUTTONUP   101
+#define WM_LBUTTONDOWN 102
+#define WM_RBUTTONUP   103
+#define WM_RBUTTONDOWN 104
+#define WM_BUTTON3UP   105
+#define WM_BUTTON3DOWN 106
+#define WM_BUTTON4UP   107
+#define WM_BUTTON4DOWN 108
+#define WM_BUTTON5UP   109
+#define WM_BUTTON5DOWN 110
+#define WM_INVALIDATE  200
+
+#define CB_ITEMCHANGE  300
+
+#endif