o moved from GNU General Public License to Apache License, Version 2.0

o applied new coding standards to all .c files
o moved some files around

1 files changed, 1878 insertions, 1670 deletions

diff --git a/xrdp/xrdp_mm.c b/xrdp/xrdp_mm.c
index 0b764cc6..e13854ae 100644
--- a/xrdp/xrdp_mm.c
+++ b/xrdp/xrdp_mm.c
@@ -1,42 +1,40 @@
-/*
-   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-2010
-
-   module manager
-
-*/
+/**
+ * xrdp: A Remote Desktop Protocol server.
+ *
+ * Copyright (C) Jay Sorg 2004-2012
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * module manager
+ */
 
 #include "xrdp.h"
 #include "log.h"
 #define ACCESS
 
 /*****************************************************************************/
-struct xrdp_mm* APP_CC
-xrdp_mm_create(struct xrdp_wm* owner)
+struct xrdp_mm *APP_CC
+xrdp_mm_create(struct xrdp_wm *owner)
 {
-  struct xrdp_mm* self;
+    struct xrdp_mm *self;
 
-  self = (struct xrdp_mm*)g_malloc(sizeof(struct xrdp_mm), 1);
-  self->wm = owner;
-  self->login_names = list_create();
-  self->login_names->auto_free = 1;
-  self->login_values = list_create();
-  self->login_values->auto_free = 1;
-  return self;
+    self = (struct xrdp_mm *)g_malloc(sizeof(struct xrdp_mm), 1);
+    self->wm = owner;
+    self->login_names = list_create();
+    self->login_names->auto_free = 1;
+    self->login_values = list_create();
+    self->login_values->auto_free = 1;
+    return self;
 }
 
 /*****************************************************************************/
@@ -44,7 +42,7 @@ xrdp_mm_create(struct xrdp_wm* owner)
 static long DEFAULT_CC
 xrdp_mm_sync_unload(long param1, long param2)
 {
-  return g_free_library(param1);
+    return g_free_library(param1);
 }
 
 /*****************************************************************************/
@@ -52,170 +50,178 @@ xrdp_mm_sync_unload(long param1, long param2)
 static long DEFAULT_CC
 xrdp_mm_sync_load(long param1, long param2)
 {
-  long rv;
-  char* libname;
+    long rv;
+    char *libname;
 
-  libname = (char*)param1;
-  rv = g_load_library(libname);
-  return rv;
+    libname = (char *)param1;
+    rv = g_load_library(libname);
+    return rv;
 }
 
 /*****************************************************************************/
 static void APP_CC
-xrdp_mm_module_cleanup(struct xrdp_mm* self)
+xrdp_mm_module_cleanup(struct xrdp_mm *self)
 {
-  g_writeln("xrdp_mm_module_cleanup");
-  if (self->mod != 0)
-  {
-    if (self->mod_exit != 0)
+    g_writeln("xrdp_mm_module_cleanup");
+
+    if (self->mod != 0)
+    {
+        if (self->mod_exit != 0)
+        {
+            /* let the module cleanup */
+            self->mod_exit(self->mod);
+        }
+    }
+
+    if (self->mod_handle != 0)
     {
-      /* let the module cleanup */
-      self->mod_exit(self->mod);
+        /* Let the main thread unload the module.*/
+        g_xrdp_sync(xrdp_mm_sync_unload, self->mod_handle, 0);
     }
-  }
-  if (self->mod_handle != 0)
-  {
-    /* Let the main thread unload the module.*/
-    g_xrdp_sync(xrdp_mm_sync_unload, self->mod_handle, 0);
-  }
-  trans_delete(self->chan_trans);
-  self->chan_trans = 0;
-  self->chan_trans_up = 0;
-  self->mod_init = 0;
-  self->mod_exit = 0;
-  self->mod = 0;
-  self->mod_handle = 0;
+
+    trans_delete(self->chan_trans);
+    self->chan_trans = 0;
+    self->chan_trans_up = 0;
+    self->mod_init = 0;
+    self->mod_exit = 0;
+    self->mod = 0;
+    self->mod_handle = 0;
 }
 
 /*****************************************************************************/
 void APP_CC
-xrdp_mm_delete(struct xrdp_mm* self)
+xrdp_mm_delete(struct xrdp_mm *self)
 {
-  if (self == 0)
-  {
-    return;
-  }
-  /* free any module stuff */
-  xrdp_mm_module_cleanup(self);
-  trans_delete(self->sesman_trans);
-  self->sesman_trans = 0;
-  self->sesman_trans_up = 0;
-  list_delete(self->login_names);
-  list_delete(self->login_values);
-  g_free(self);
+    if (self == 0)
+    {
+        return;
+    }
+
+    /* free any module stuff */
+    xrdp_mm_module_cleanup(self);
+    trans_delete(self->sesman_trans);
+    self->sesman_trans = 0;
+    self->sesman_trans_up = 0;
+    list_delete(self->login_names);
+    list_delete(self->login_values);
+    g_free(self);
 }
 
 /*****************************************************************************/
 /* Send login information to sesman */
 static int APP_CC
-xrdp_mm_send_login(struct xrdp_mm* self)
-{
-  struct stream* s;
-  int rv;
-  int index;
-  int count;
-  int xserverbpp;
-  char* username;
-  char* password;
-  char* name;
-  char* value;
-
-  xrdp_wm_log_msg(self->wm, "sending login info to session manager, "
-                            "please wait...");
-  username = 0;
-  password = 0;
-  self->code = 0;
-  xserverbpp = 0;
-  count = self->login_names->count;
-  for (index = 0; index < count; index++)
-  {
-    name = (char*)list_get_item(self->login_names, index);
-    value = (char*)list_get_item(self->login_values, index);
-    if (g_strcasecmp(name, "username") == 0)
-    {
-      username = value;
-    }
-    else if (g_strcasecmp(name, "password") == 0)
-    {
-      password = value;
-    }
-    else if (g_strcasecmp(name, "lib") == 0)
-    {
-      if ((g_strcasecmp(value, "libxup.so") == 0) ||
-          (g_strcasecmp(value, "xup.dll") == 0))
-      {
-        self->code = 10;
-      }
-    }
-    else if (g_strcasecmp(name, "xserverbpp") == 0)
-    {
-      xserverbpp = g_atoi(value);
-    }
-  }
-  if ((username == 0) || (password == 0))
-  {
-    xrdp_wm_log_msg(self->wm, "Error finding username and password");
-    return 1;
-  }
-
-  s = trans_get_out_s(self->sesman_trans, 8192);
-  s_push_layer(s, channel_hdr, 8);
-  /* this code is either 0 for Xvnc or 10 for X11rdp */
-  out_uint16_be(s, self->code);
-  index = g_strlen(username);
-  out_uint16_be(s, index);
-  out_uint8a(s, username, index);
-  index = g_strlen(password);
-
-  out_uint16_be(s, index);
-  out_uint8a(s, password, index);
-  out_uint16_be(s, self->wm->screen->width);
-  out_uint16_be(s, self->wm->screen->height);
-
-  if (xserverbpp > 0)
-  {
-    out_uint16_be(s, xserverbpp);
-  }
-  else
-  {
-    out_uint16_be(s, self->wm->screen->bpp);
-  }
-
-  /* send domain */
-  index = g_strlen(self->wm->client_info->domain);
-  out_uint16_be(s, index);
-  out_uint8a(s, self->wm->client_info->domain, index);
-
-  /* send program / shell */
-  index = g_strlen(self->wm->client_info->program);
-  out_uint16_be(s, index);
-  out_uint8a(s, self->wm->client_info->program, index);
-
-  /* send directory */
-  index = g_strlen(self->wm->client_info->directory);
-  out_uint16_be(s, index);
-  out_uint8a(s, self->wm->client_info->directory, index);
-
-  /* send client ip */
-  index = g_strlen(self->wm->client_info->client_ip);
-  out_uint16_be(s, index);
-  out_uint8a(s, self->wm->client_info->client_ip, index);
-
-  s_mark_end(s);
-
-  s_pop_layer(s, channel_hdr);
-  /* Version 0 of the protocol to sesman is currently used by XRDP */
-  out_uint32_be(s, 0); /* version */
-  index = (int)(s->end - s->data);
-  out_uint32_be(s, index); /* size */
-
-  rv = trans_force_write(self->sesman_trans);
-
-  if (rv != 0) {
-    xrdp_wm_log_msg(self->wm, "xrdp_mm_send_login: xrdp_mm_send_login failed");
-  }
-
-  return rv;
+xrdp_mm_send_login(struct xrdp_mm *self)
+{
+    struct stream *s;
+    int rv;
+    int index;
+    int count;
+    int xserverbpp;
+    char *username;
+    char *password;
+    char *name;
+    char *value;
+
+    xrdp_wm_log_msg(self->wm, "sending login info to session manager, "
+                    "please wait...");
+    username = 0;
+    password = 0;
+    self->code = 0;
+    xserverbpp = 0;
+    count = self->login_names->count;
+
+    for (index = 0; index < count; index++)
+    {
+        name = (char *)list_get_item(self->login_names, index);
+        value = (char *)list_get_item(self->login_values, index);
+
+        if (g_strcasecmp(name, "username") == 0)
+        {
+            username = value;
+        }
+        else if (g_strcasecmp(name, "password") == 0)
+        {
+            password = value;
+        }
+        else if (g_strcasecmp(name, "lib") == 0)
+        {
+            if ((g_strcasecmp(value, "libxup.so") == 0) ||
+                    (g_strcasecmp(value, "xup.dll") == 0))
+            {
+                self->code = 10;
+            }
+        }
+        else if (g_strcasecmp(name, "xserverbpp") == 0)
+        {
+            xserverbpp = g_atoi(value);
+        }
+    }
+
+    if ((username == 0) || (password == 0))
+    {
+        xrdp_wm_log_msg(self->wm, "Error finding username and password");
+        return 1;
+    }
+
+    s = trans_get_out_s(self->sesman_trans, 8192);
+    s_push_layer(s, channel_hdr, 8);
+    /* this code is either 0 for Xvnc or 10 for X11rdp */
+    out_uint16_be(s, self->code);
+    index = g_strlen(username);
+    out_uint16_be(s, index);
+    out_uint8a(s, username, index);
+    index = g_strlen(password);
+
+    out_uint16_be(s, index);
+    out_uint8a(s, password, index);
+    out_uint16_be(s, self->wm->screen->width);
+    out_uint16_be(s, self->wm->screen->height);
+
+    if (xserverbpp > 0)
+    {
+        out_uint16_be(s, xserverbpp);
+    }
+    else
+    {
+        out_uint16_be(s, self->wm->screen->bpp);
+    }
+
+    /* send domain */
+    index = g_strlen(self->wm->client_info->domain);
+    out_uint16_be(s, index);
+    out_uint8a(s, self->wm->client_info->domain, index);
+
+    /* send program / shell */
+    index = g_strlen(self->wm->client_info->program);
+    out_uint16_be(s, index);
+    out_uint8a(s, self->wm->client_info->program, index);
+
+    /* send directory */
+    index = g_strlen(self->wm->client_info->directory);
+    out_uint16_be(s, index);
+    out_uint8a(s, self->wm->client_info->directory, index);
+
+    /* send client ip */
+    index = g_strlen(self->wm->client_info->client_ip);
+    out_uint16_be(s, index);
+    out_uint8a(s, self->wm->client_info->client_ip, index);
+
+    s_mark_end(s);
+
+    s_pop_layer(s, channel_hdr);
+    /* Version 0 of the protocol to sesman is currently used by XRDP */
+    out_uint32_be(s, 0); /* version */
+    index = (int)(s->end - s->data);
+    out_uint32_be(s, index); /* size */
+
+    rv = trans_force_write(self->sesman_trans);
+
+    if (rv != 0)
+    {
+        xrdp_wm_log_msg(self->wm, "xrdp_mm_send_login: xrdp_mm_send_login failed");
+    }
+
+    return rv;
 }
 
 /*****************************************************************************/
@@ -224,744 +230,828 @@ xrdp_mm_send_login(struct xrdp_mm* self)
    then it copies the corisponding login_values item into 'dest'
    'dest' must be at least 'dest_len' + 1 bytes in size */
 static int APP_CC
-xrdp_mm_get_value(struct xrdp_mm* self, char* aname, char* dest, int dest_len)
+xrdp_mm_get_value(struct xrdp_mm *self, char *aname, char *dest, int dest_len)
 {
-  char* name;
-  char* value;
-  int index;
-  int count;
-  int rv;
+    char *name;
+    char *value;
+    int index;
+    int count;
+    int rv;
 
-  rv = 1;
-  /* find the library name */
-  dest[0] = 0;
-  count = self->login_names->count;
-  for (index = 0; index < count; index++)
-  {
-    name = (char*)list_get_item(self->login_names, index);
-    value = (char*)list_get_item(self->login_values, index);
-    if ((name == 0) || (value == 0))
-    {
-      break;
-    }
-    if (g_strcasecmp(name, aname) == 0)
+    rv = 1;
+    /* find the library name */
+    dest[0] = 0;
+    count = self->login_names->count;
+
+    for (index = 0; index < count; index++)
     {
-      g_strncpy(dest, value, dest_len);
-      rv = 0;
+        name = (char *)list_get_item(self->login_names, index);
+        value = (char *)list_get_item(self->login_values, index);
+
+        if ((name == 0) || (value == 0))
+        {
+            break;
+        }
+
+        if (g_strcasecmp(name, aname) == 0)
+        {
+            g_strncpy(dest, value, dest_len);
+            rv = 0;
+        }
     }
-  }
 
-  return rv;
+    return rv;
 }
 
 /*****************************************************************************/
 static int APP_CC
-xrdp_mm_setup_mod1(struct xrdp_mm* self)
-{
-  void* func;
-  char lib[256];
-  char text[256];
-
-  if (self == 0)
-  {
-    return 1;
-  }
-  lib[0] = 0;
-  if (xrdp_mm_get_value(self, "lib", lib, 255) != 0)
-  {
-    g_snprintf(text, 255, "no library name specified in xrdp.ini, please add "
-                          "lib=libxrdp-vnc.so or similar");
-    xrdp_wm_log_msg(self->wm, text);
-
-    return 1;
-  }
-  if (lib[0] == 0)
-  {
-    g_snprintf(text, 255, "empty library name specified in xrdp.ini, please "
-                          "add lib=libxrdp-vnc.so or similar");
-    xrdp_wm_log_msg(self->wm, text);
-
-    return 1;
-  }
-  if (self->mod_handle == 0)
-  {
-    /* Let the main thread load the lib,*/
-    self->mod_handle = g_xrdp_sync(xrdp_mm_sync_load, (long)lib, 0);
-    if (self->mod_handle != 0)
+xrdp_mm_setup_mod1(struct xrdp_mm *self)
+{
+    void *func;
+    char lib[256];
+    char text[256];
+
+    if (self == 0)
     {
-      func = g_get_proc_address(self->mod_handle, "mod_init");
-      if (func == 0)
-      {
-        func = g_get_proc_address(self->mod_handle, "_mod_init");
-      }
-      if (func == 0)
-      {
-        g_snprintf(text, 255, "error finding proc mod_init in %s, not a valid "
-                              "xrdp backend", lib);
-        xrdp_wm_log_msg(self->wm, text);
-      }
-      self->mod_init = (struct xrdp_mod* (*)(void))func;
-      func = g_get_proc_address(self->mod_handle, "mod_exit");
-      if (func == 0)
-      {
-        func = g_get_proc_address(self->mod_handle, "_mod_exit");
-      }
-      if (func == 0)
-      {
-        g_snprintf(text, 255, "error finding proc mod_exit in %s, not a valid "
-                              "xrdp backend", lib);
+        return 1;
+    }
+
+    lib[0] = 0;
+
+    if (xrdp_mm_get_value(self, "lib", lib, 255) != 0)
+    {
+        g_snprintf(text, 255, "no library name specified in xrdp.ini, please add "
+                   "lib=libxrdp-vnc.so or similar");
         xrdp_wm_log_msg(self->wm, text);
-      }
-      self->mod_exit = (int (*)(struct xrdp_mod*))func;
-      if ((self->mod_init != 0) && (self->mod_exit != 0))
-      {
-        self->mod = self->mod_init();
-        if (self->mod != 0)
-        {
-          g_writeln("loaded module '%s' ok, interface size %d, version %d", lib,
-                    self->mod->size, self->mod->version);
-        }
-      }else{
-        g_writeln("no mod_init or mod_exit address found");
-      }
+
+        return 1;
     }
-    else
+
+    if (lib[0] == 0)
     {
-      g_snprintf(text, 255, "error loading %s specified in xrdp.ini, please "
-                            "add a valid entry like lib=libxrdp-vnc.so or similar", lib);
-      xrdp_wm_log_msg(self->wm, text);
-      return 1;
+        g_snprintf(text, 255, "empty library name specified in xrdp.ini, please "
+                   "add lib=libxrdp-vnc.so or similar");
+        xrdp_wm_log_msg(self->wm, text);
+
+        return 1;
     }
-    if (self->mod != 0)
+
+    if (self->mod_handle == 0)
     {
-      self->mod->wm = (long)(self->wm);
-      self->mod->server_begin_update = server_begin_update;
-      self->mod->server_end_update = server_end_update;
-      self->mod->server_bell_trigger = server_bell_trigger;
-      self->mod->server_fill_rect = server_fill_rect;
-      self->mod->server_screen_blt = server_screen_blt;
-      self->mod->server_paint_rect = server_paint_rect;
-      self->mod->server_set_pointer = server_set_pointer;
-      self->mod->server_palette = server_palette;
-      self->mod->server_msg = server_msg;
-      self->mod->server_is_term = server_is_term;
-      self->mod->server_set_clip = server_set_clip;
-      self->mod->server_reset_clip = server_reset_clip;
-      self->mod->server_set_fgcolor = server_set_fgcolor;
-      self->mod->server_set_bgcolor = server_set_bgcolor;
-      self->mod->server_set_opcode = server_set_opcode;
-      self->mod->server_set_mixmode = server_set_mixmode;
-      self->mod->server_set_brush = server_set_brush;
-      self->mod->server_set_pen = server_set_pen;
-      self->mod->server_draw_line = server_draw_line;
-      self->mod->server_add_char = server_add_char;
-      self->mod->server_draw_text = server_draw_text;
-      self->mod->server_reset = server_reset;
-      self->mod->server_query_channel = server_query_channel;
-      self->mod->server_get_channel_id = server_get_channel_id;
-      self->mod->server_send_to_channel = server_send_to_channel;
-      self->mod->server_create_os_surface = server_create_os_surface;
-      self->mod->server_switch_os_surface = server_switch_os_surface;
-      self->mod->server_delete_os_surface = server_delete_os_surface;
-      self->mod->server_paint_rect_os = server_paint_rect_os;
-      self->mod->server_set_hints = server_set_hints;
-      self->mod->server_window_new_update = server_window_new_update;
-      self->mod->server_window_delete = server_window_delete;
-      self->mod->server_window_icon = server_window_icon;
-      self->mod->server_window_cached_icon = server_window_cached_icon;
-      self->mod->server_notify_new_update = server_notify_new_update;
-      self->mod->server_notify_delete = server_notify_delete;
-      self->mod->server_monitored_desktop = server_monitored_desktop;
-    }
-  }
-  /* id self->mod is null, there must be a problem */
-  if (self->mod == 0)
-  {
-    DEBUG(("problem loading lib in xrdp_mm_setup_mod1"));
-    return 1;
-  }
-  return 0;
-}
+        /* Let the main thread load the lib,*/
+        self->mod_handle = g_xrdp_sync(xrdp_mm_sync_load, (long)lib, 0);
 
-/*****************************************************************************/
-static int APP_CC
-xrdp_mm_setup_mod2(struct xrdp_mm* self)
-{
-  char text[256];
-  char* name;
-  char* value;
-  int i;
-  int rv;
-  int key_flags;
-  int device_flags;
-  int use_uds;
-
-  rv = 1; /* failure */
-  g_memset(text, 0, sizeof(text));
-  if (!g_is_wait_obj_set(self->wm->pro_layer->self_term_event))
-  {
-    if (self->mod->mod_start(self->mod, self->wm->screen->width,
-                             self->wm->screen->height,
-                             self->wm->screen->bpp) != 0)
-    {
-      g_set_wait_obj(self->wm->pro_layer->self_term_event); /* kill session */
-    }
-  }
-  if (!g_is_wait_obj_set(self->wm->pro_layer->self_term_event))
-  {
-    if (self->display > 0)
-    {
-      if (self->code == 0) /* Xvnc */
-      {
-        g_snprintf(text, 255, "%d", 5900 + self->display);
-      }
-      else if (self->code == 10) /* X11rdp */
-      {
-        use_uds = 1;
-        if (xrdp_mm_get_value(self, "ip", text, 255) == 0)
-        {
-          if (g_strcmp(text, "127.0.0.1") != 0)
-          {
-            use_uds = 0;
-          }
-        }
-        if (use_uds)
-        {
-          g_snprintf(text, 255, "/tmp/.xrdp/xrdp_display_%d", self->display);
+        if (self->mod_handle != 0)
+        {
+            func = g_get_proc_address(self->mod_handle, "mod_init");
+
+            if (func == 0)
+            {
+                func = g_get_proc_address(self->mod_handle, "_mod_init");
+            }
+
+            if (func == 0)
+            {
+                g_snprintf(text, 255, "error finding proc mod_init in %s, not a valid "
+                           "xrdp backend", lib);
+                xrdp_wm_log_msg(self->wm, text);
+            }
+
+            self->mod_init = (struct xrdp_mod * ( *)(void))func;
+            func = g_get_proc_address(self->mod_handle, "mod_exit");
+
+            if (func == 0)
+            {
+                func = g_get_proc_address(self->mod_handle, "_mod_exit");
+            }
+
+            if (func == 0)
+            {
+                g_snprintf(text, 255, "error finding proc mod_exit in %s, not a valid "
+                           "xrdp backend", lib);
+                xrdp_wm_log_msg(self->wm, text);
+            }
+
+            self->mod_exit = (int ( *)(struct xrdp_mod *))func;
+
+            if ((self->mod_init != 0) && (self->mod_exit != 0))
+            {
+                self->mod = self->mod_init();
+
+                if (self->mod != 0)
+                {
+                    g_writeln("loaded module '%s' ok, interface size %d, version %d", lib,
+                              self->mod->size, self->mod->version);
+                }
+            }
+            else
+            {
+                g_writeln("no mod_init or mod_exit address found");
+            }
         }
         else
         {
-          g_snprintf(text, 255, "%d", 6200 + self->display);
+            g_snprintf(text, 255, "error loading %s specified in xrdp.ini, please "
+                       "add a valid entry like lib=libxrdp-vnc.so or similar", lib);
+            xrdp_wm_log_msg(self->wm, text);
+            return 1;
+        }
+
+        if (self->mod != 0)
+        {
+            self->mod->wm = (long)(self->wm);
+            self->mod->server_begin_update = server_begin_update;
+            self->mod->server_end_update = server_end_update;
+            self->mod->server_bell_trigger = server_bell_trigger;
+            self->mod->server_fill_rect = server_fill_rect;
+            self->mod->server_screen_blt = server_screen_blt;
+            self->mod->server_paint_rect = server_paint_rect;
+            self->mod->server_set_pointer = server_set_pointer;
+            self->mod->server_palette = server_palette;
+            self->mod->server_msg = server_msg;
+            self->mod->server_is_term = server_is_term;
+            self->mod->server_set_clip = server_set_clip;
+            self->mod->server_reset_clip = server_reset_clip;
+            self->mod->server_set_fgcolor = server_set_fgcolor;
+            self->mod->server_set_bgcolor = server_set_bgcolor;
+            self->mod->server_set_opcode = server_set_opcode;
+            self->mod->server_set_mixmode = server_set_mixmode;
+            self->mod->server_set_brush = server_set_brush;
+            self->mod->server_set_pen = server_set_pen;
+            self->mod->server_draw_line = server_draw_line;
+            self->mod->server_add_char = server_add_char;
+            self->mod->server_draw_text = server_draw_text;
+            self->mod->server_reset = server_reset;
+            self->mod->server_query_channel = server_query_channel;
+            self->mod->server_get_channel_id = server_get_channel_id;
+            self->mod->server_send_to_channel = server_send_to_channel;
+            self->mod->server_create_os_surface = server_create_os_surface;
+            self->mod->server_switch_os_surface = server_switch_os_surface;
+            self->mod->server_delete_os_surface = server_delete_os_surface;
+            self->mod->server_paint_rect_os = server_paint_rect_os;
+            self->mod->server_set_hints = server_set_hints;
+            self->mod->server_window_new_update = server_window_new_update;
+            self->mod->server_window_delete = server_window_delete;
+            self->mod->server_window_icon = server_window_icon;
+            self->mod->server_window_cached_icon = server_window_cached_icon;
+            self->mod->server_notify_new_update = server_notify_new_update;
+            self->mod->server_notify_delete = server_notify_delete;
+            self->mod->server_monitored_desktop = server_monitored_desktop;
         }
-      }
-      else
-      {
-        g_set_wait_obj(self->wm->pro_layer->self_term_event); /* kill session */
-      }
     }
-  }
-  if (!g_is_wait_obj_set(self->wm->pro_layer->self_term_event))
-  {
-    /* this adds the port to the end of the list, it will already be in
-       the list as -1
-       the module should use the last one */
-    if (g_strlen(text) > 0)
+
+    /* id self->mod is null, there must be a problem */
+    if (self->mod == 0)
     {
-      list_add_item(self->login_names, (long)g_strdup("port"));
-      list_add_item(self->login_values, (long)g_strdup(text));
+        DEBUG(("problem loading lib in xrdp_mm_setup_mod1"));
+        return 1;
     }
-    /* always set these */
 
-    self->mod->mod_set_param(self->mod, "client_info",
-                             (char*)(self->wm->session->client_info));
+    return 0;
+}
 
-    name = self->wm->session->client_info->hostname;
-    self->mod->mod_set_param(self->mod, "hostname", name);
-    g_snprintf(text, 255, "%d", self->wm->session->client_info->keylayout);
-    self->mod->mod_set_param(self->mod, "keylayout", text);
-    for (i = 0; i < self->login_names->count; i++)
-    {
-      name = (char*)list_get_item(self->login_names, i);
-      value = (char*)list_get_item(self->login_values, i);
-      self->mod->mod_set_param(self->mod, name, value);
-    }
-    /* connect */
-    if (self->mod->mod_connect(self->mod) == 0)
-    {
-      rv = 0; /* connect success */
-    }
-  }
-  if (rv == 0)
-  {
-    /* sync modifiers */
-    key_flags = 0;
-    device_flags = 0;
-    if (self->wm->scroll_lock)
+/*****************************************************************************/
+static int APP_CC
+xrdp_mm_setup_mod2(struct xrdp_mm *self)
+{
+    char text[256];
+    char *name;
+    char *value;
+    int i;
+    int rv;
+    int key_flags;
+    int device_flags;
+    int use_uds;
+
+    rv = 1; /* failure */
+    g_memset(text, 0, sizeof(text));
+
+    if (!g_is_wait_obj_set(self->wm->pro_layer->self_term_event))
     {
-      key_flags |= 1;
+        if (self->mod->mod_start(self->mod, self->wm->screen->width,
+                                 self->wm->screen->height,
+                                 self->wm->screen->bpp) != 0)
+        {
+            g_set_wait_obj(self->wm->pro_layer->self_term_event); /* kill session */
+        }
     }
-    if (self->wm->num_lock)
+
+    if (!g_is_wait_obj_set(self->wm->pro_layer->self_term_event))
     {
-      key_flags |= 2;
+        if (self->display > 0)
+        {
+            if (self->code == 0) /* Xvnc */
+            {
+                g_snprintf(text, 255, "%d", 5900 + self->display);
+            }
+            else if (self->code == 10) /* X11rdp */
+            {
+                use_uds = 1;
+
+                if (xrdp_mm_get_value(self, "ip", text, 255) == 0)
+                {
+                    if (g_strcmp(text, "127.0.0.1") != 0)
+                    {
+                        use_uds = 0;
+                    }
+                }
+
+                if (use_uds)
+                {
+                    g_snprintf(text, 255, "/tmp/.xrdp/xrdp_display_%d", self->display);
+                }
+                else
+                {
+                    g_snprintf(text, 255, "%d", 6200 + self->display);
+                }
+            }
+            else
+            {
+                g_set_wait_obj(self->wm->pro_layer->self_term_event); /* kill session */
+            }
+        }
     }
-    if (self->wm->caps_lock)
+
+    if (!g_is_wait_obj_set(self->wm->pro_layer->self_term_event))
     {
-      key_flags |= 4;
+        /* this adds the port to the end of the list, it will already be in
+           the list as -1
+           the module should use the last one */
+        if (g_strlen(text) > 0)
+        {
+            list_add_item(self->login_names, (long)g_strdup("port"));
+            list_add_item(self->login_values, (long)g_strdup(text));
+        }
+
+        /* always set these */
+
+        self->mod->mod_set_param(self->mod, "client_info",
+                                 (char *)(self->wm->session->client_info));
+
+        name = self->wm->session->client_info->hostname;
+        self->mod->mod_set_param(self->mod, "hostname", name);
+        g_snprintf(text, 255, "%d", self->wm->session->client_info->keylayout);
+        self->mod->mod_set_param(self->mod, "keylayout", text);
+
+        for (i = 0; i < self->login_names->count; i++)
+        {
+            name = (char *)list_get_item(self->login_names, i);
+            value = (char *)list_get_item(self->login_values, i);
+            self->mod->mod_set_param(self->mod, name, value);
+        }
+
+        /* connect */
+        if (self->mod->mod_connect(self->mod) == 0)
+        {
+            rv = 0; /* connect success */
+        }
     }
-    if (self->mod != 0)
+
+    if (rv == 0)
     {
-      if (self->mod->mod_event != 0)
-      {
-        self->mod->mod_event(self->mod, 17, key_flags, device_flags,
-                             key_flags, device_flags);
-      }
+        /* sync modifiers */
+        key_flags = 0;
+        device_flags = 0;
+
+        if (self->wm->scroll_lock)
+        {
+            key_flags |= 1;
+        }
+
+        if (self->wm->num_lock)
+        {
+            key_flags |= 2;
+        }
+
+        if (self->wm->caps_lock)
+        {
+            key_flags |= 4;
+        }
+
+        if (self->mod != 0)
+        {
+            if (self->mod->mod_event != 0)
+            {
+                self->mod->mod_event(self->mod, 17, key_flags, device_flags,
+                                     key_flags, device_flags);
+            }
+        }
     }
-  }
-  return rv;
+
+    return rv;
 }
 
 /*****************************************************************************/
 /* returns error
    send a list of channels to the channel handler */
 static int APP_CC
-xrdp_mm_trans_send_channel_setup(struct xrdp_mm* self, struct trans* trans)
-{
-  int index;
-  int chan_id;
-  int chan_flags;
-  int size;
-  struct stream* s;
-  char chan_name[256];
-
-  g_memset(chan_name,0,sizeof(char) * 256);
-
-  s = trans_get_out_s(trans, 8192);
-  if (s == 0)
-  {
-    return 1;
-  }
-  s_push_layer(s, iso_hdr, 8);
-  s_push_layer(s, mcs_hdr, 8);
-  s_push_layer(s, sec_hdr, 2);
-  index = 0;
-  while (libxrdp_query_channel(self->wm->session, index, chan_name,
-                               &chan_flags) == 0)
-  {
-    chan_id = libxrdp_get_channel_id(self->wm->session, chan_name);
-    out_uint8a(s, chan_name, 8);
-    out_uint16_le(s, chan_id);
-    out_uint16_le(s, chan_flags);
-    index++;
-  }
-  s_mark_end(s);
-  s_pop_layer(s, sec_hdr);
-  out_uint16_le(s, index);
-  s_pop_layer(s, mcs_hdr);
-  size = (int)(s->end - s->p);
-  out_uint32_le(s, 3); /* msg id */
-  out_uint32_le(s, size); /* msg size */
-  s_pop_layer(s, iso_hdr);
-  size = (int)(s->end - s->p);
-  out_uint32_le(s, 0); /* version */
-  out_uint32_le(s, size); /* block size */
-  return trans_force_write(trans);
+xrdp_mm_trans_send_channel_setup(struct xrdp_mm *self, struct trans *trans)
+{
+    int index;
+    int chan_id;
+    int chan_flags;
+    int size;
+    struct stream *s;
+    char chan_name[256];
+
+    g_memset(chan_name, 0, sizeof(char) * 256);
+
+    s = trans_get_out_s(trans, 8192);
+
+    if (s == 0)
+    {
+        return 1;
+    }
+
+    s_push_layer(s, iso_hdr, 8);
+    s_push_layer(s, mcs_hdr, 8);
+    s_push_layer(s, sec_hdr, 2);
+    index = 0;
+
+    while (libxrdp_query_channel(self->wm->session, index, chan_name,
+                                 &chan_flags) == 0)
+    {
+        chan_id = libxrdp_get_channel_id(self->wm->session, chan_name);
+        out_uint8a(s, chan_name, 8);
+        out_uint16_le(s, chan_id);
+        out_uint16_le(s, chan_flags);
+        index++;
+    }
+
+    s_mark_end(s);
+    s_pop_layer(s, sec_hdr);
+    out_uint16_le(s, index);
+    s_pop_layer(s, mcs_hdr);
+    size = (int)(s->end - s->p);
+    out_uint32_le(s, 3); /* msg id */
+    out_uint32_le(s, size); /* msg size */
+    s_pop_layer(s, iso_hdr);
+    size = (int)(s->end - s->p);
+    out_uint32_le(s, 0); /* version */
+    out_uint32_le(s, size); /* block size */
+    return trans_force_write(trans);
 }
 
 /*****************************************************************************/
 /* returns error */
 static int APP_CC
-xrdp_mm_trans_send_channel_data_response(struct xrdp_mm* self,
-                                         struct trans* trans)
+xrdp_mm_trans_send_channel_data_response(struct xrdp_mm *self,
+        struct trans *trans)
 {
-  struct stream* s;
+    struct stream *s;
+
+    s = trans_get_out_s(trans, 8192);
+
+    if (s == 0)
+    {
+        return 1;
+    }
 
-  s = trans_get_out_s(trans, 8192);
-  if (s == 0)
-  {
-    return 1;
-  }
-  out_uint32_le(s, 0); /* version */
-  out_uint32_le(s, 8 + 8); /* size */
-  out_uint32_le(s, 7); /* msg id */
-  out_uint32_le(s, 8); /* size */
-  s_mark_end(s);
-  return trans_force_write(trans);
+    out_uint32_le(s, 0); /* version */
+    out_uint32_le(s, 8 + 8); /* size */
+    out_uint32_le(s, 7); /* msg id */
+    out_uint32_le(s, 8); /* size */
+    s_mark_end(s);
+    return trans_force_write(trans);
 }
 
 /*****************************************************************************/
 /* returns error
    init is done, sent channel setup */
 static int APP_CC
-xrdp_mm_trans_process_init_response(struct xrdp_mm* self, struct trans* trans)
+xrdp_mm_trans_process_init_response(struct xrdp_mm *self, struct trans *trans)
 {
-  return xrdp_mm_trans_send_channel_setup(self, trans);
+    return xrdp_mm_trans_send_channel_setup(self, trans);
 }
 
 /*****************************************************************************/
 /* returns error
    data coming in from the channel handler, send it to the client */
 static int APP_CC
-xrdp_mm_trans_process_channel_data(struct xrdp_mm* self, struct trans* trans)
-{
-  struct stream* s;
-  int size;
-  int total_size;
-  int chan_id;
-  int chan_flags;
-  int rv;
-
-  s = trans_get_in_s(trans);
-  if (s == 0)
-  {
-    return 1;
-  }
-  in_uint16_le(s, chan_id);
-  in_uint16_le(s, chan_flags);
-  in_uint16_le(s, size);
-  in_uint32_le(s, total_size);
-  rv = xrdp_mm_trans_send_channel_data_response(self, trans);
-  if (rv == 0)
-  {
-    rv = libxrdp_send_to_channel(self->wm->session, chan_id, s->p, size, total_size,
-                                 chan_flags);
-  }
-  return rv;
+xrdp_mm_trans_process_channel_data(struct xrdp_mm *self, struct trans *trans)
+{
+    struct stream *s;
+    int size;
+    int total_size;
+    int chan_id;
+    int chan_flags;
+    int rv;
+
+    s = trans_get_in_s(trans);
+
+    if (s == 0)
+    {
+        return 1;
+    }
+
+    in_uint16_le(s, chan_id);
+    in_uint16_le(s, chan_flags);
+    in_uint16_le(s, size);
+    in_uint32_le(s, total_size);
+    rv = xrdp_mm_trans_send_channel_data_response(self, trans);
+
+    if (rv == 0)
+    {
+        rv = libxrdp_send_to_channel(self->wm->session, chan_id, s->p, size, total_size,
+                                     chan_flags);
+    }
+
+    return rv;
 }
 
 /*****************************************************************************/
 /* returns error
    process a message for the channel handler */
 static int APP_CC
-xrdp_mm_chan_process_msg(struct xrdp_mm* self, struct trans* trans,
-                         struct stream* s)
-{
-  int rv;
-  int id;
-  int size;
-  char* next_msg;
-
-  rv = 0;
-  while (s_check_rem(s, 8))
-  {
-    next_msg = s->p;
-    in_uint32_le(s, id);
-    in_uint32_le(s, size);
-    next_msg += size;
-    switch (id)
-    {
-      case 2: /* channel init response */
-        rv = xrdp_mm_trans_process_init_response(self, trans);
-        break;
-      case 4: /* channel setup response */
-        break;
-      case 6: /* channel data response */
-        break;
-      case 8: /* channel data */
-        rv = xrdp_mm_trans_process_channel_data(self, trans);
-        break;
-      default:
-        g_writeln("xrdp_mm_chan_process_msg: unknown id %d", id);
-        break;
-    }
-    if (rv != 0)
+xrdp_mm_chan_process_msg(struct xrdp_mm *self, struct trans *trans,
+                         struct stream *s)
+{
+    int rv;
+    int id;
+    int size;
+    char *next_msg;
+
+    rv = 0;
+
+    while (s_check_rem(s, 8))
     {
-      break;
+        next_msg = s->p;
+        in_uint32_le(s, id);
+        in_uint32_le(s, size);
+        next_msg += size;
+
+        switch (id)
+        {
+            case 2: /* channel init response */
+                rv = xrdp_mm_trans_process_init_response(self, trans);
+                break;
+            case 4: /* channel setup response */
+                break;
+            case 6: /* channel data response */
+                break;
+            case 8: /* channel data */
+                rv = xrdp_mm_trans_process_channel_data(self, trans);
+                break;
+            default:
+                g_writeln("xrdp_mm_chan_process_msg: unknown id %d", id);
+                break;
+        }
+
+        if (rv != 0)
+        {
+            break;
+        }
+
+        s->p = next_msg;
     }
-    s->p = next_msg;
-  }
-  return rv;
+
+    return rv;
 }
 
 /*****************************************************************************/
 /* this is callback from trans obj
    returns error */
 static int APP_CC
-xrdp_mm_chan_data_in(struct trans* trans)
-{
-  struct xrdp_mm* self;
-  struct stream* s;
-  int id;
-  int size;
-  int error;
-
-  if (trans == 0)
-  {
-    return 1;
-  }
-  self = (struct xrdp_mm*)(trans->callback_data);
-  s = trans_get_in_s(trans);
-  if (s == 0)
-  {
-    return 1;
-  }
-  in_uint32_le(s, id);
-  in_uint32_le(s, size);
-  error = trans_force_read(trans, size - 8);
-  if (error == 0)
-  {
-    /* here, the entire message block is read in, process it */
-    error = xrdp_mm_chan_process_msg(self, trans, s);
-  }
-  return error;
+xrdp_mm_chan_data_in(struct trans *trans)
+{
+    struct xrdp_mm *self;
+    struct stream *s;
+    int id;
+    int size;
+    int error;
+
+    if (trans == 0)
+    {
+        return 1;
+    }
+
+    self = (struct xrdp_mm *)(trans->callback_data);
+    s = trans_get_in_s(trans);
+
+    if (s == 0)
+    {
+        return 1;
+    }
+
+    in_uint32_le(s, id);
+    in_uint32_le(s, size);
+    error = trans_force_read(trans, size - 8);
+
+    if (error == 0)
+    {
+        /* here, the entire message block is read in, process it */
+        error = xrdp_mm_chan_process_msg(self, trans, s);
+    }
+
+    return error;
 }
 
 /*****************************************************************************/
 static int APP_CC
-xrdp_mm_chan_send_init(struct xrdp_mm* self)
+xrdp_mm_chan_send_init(struct xrdp_mm *self)
 {
-  struct stream* s;
+    struct stream *s;
+
+    s = trans_get_out_s(self->chan_trans, 8192);
 
-  s = trans_get_out_s(self->chan_trans, 8192);
-  if (s == 0)
-  {
-    return 1;
-  }
-  out_uint32_le(s, 0); /* version */
-  out_uint32_le(s, 8 + 8); /* size */
-  out_uint32_le(s, 1); /* msg id */
-  out_uint32_le(s, 8); /* size */
-  s_mark_end(s);
-  return trans_force_write(self->chan_trans);
+    if (s == 0)
+    {
+        return 1;
+    }
+
+    out_uint32_le(s, 0); /* version */
+    out_uint32_le(s, 8 + 8); /* size */
+    out_uint32_le(s, 1); /* msg id */
+    out_uint32_le(s, 8); /* size */
+    s_mark_end(s);
+    return trans_force_write(self->chan_trans);
 }
 
 /*****************************************************************************/
 /* connect to chansrv */
 static int APP_CC
-xrdp_mm_connect_chansrv(struct xrdp_mm* self, char* ip, char* port)
-{
-  int index;
-
-  self->usechansrv = 1;
-
-  /* connect channel redir */
-  if ((ip == 0) || (g_strcmp(ip, "127.0.0.1") == 0) || (ip[0] == 0))
-  {
-    /* unix socket */
-    self->chan_trans = trans_create(TRANS_MODE_UNIX, 8192, 8192);
-  }
-  else
-  {
-    /* tcp */
-    self->chan_trans = trans_create(TRANS_MODE_TCP, 8192, 8192);
-  }
-  self->chan_trans->trans_data_in = xrdp_mm_chan_data_in;
-  self->chan_trans->header_size = 8;
-  self->chan_trans->callback_data = self;
-  /* try to connect up to 4 times */
-  for (index = 0; index < 4; index++)
-  {
-    if (trans_connect(self->chan_trans, ip, port, 3000) == 0)
-    {
-      self->chan_trans_up = 1;
-      break;
-    }
-    g_sleep(1000);
-    g_writeln("xrdp_mm_connect_chansrv: connect failed "
-              "trying again...");
-  }
-  if (!(self->chan_trans_up))
-  {
-    g_writeln("xrdp_mm_connect_chansrv: error in trans_connect "
-              "chan");
-  }
-  if (self->chan_trans_up)
-  {
-    if (xrdp_mm_chan_send_init(self) != 0)
-    {
-      g_writeln("xrdp_mm_connect_chansrv: error in "
-                "xrdp_mm_chan_send_init");
+xrdp_mm_connect_chansrv(struct xrdp_mm *self, char *ip, char *port)
+{
+    int index;
+
+    self->usechansrv = 1;
+
+    /* connect channel redir */
+    if ((ip == 0) || (g_strcmp(ip, "127.0.0.1") == 0) || (ip[0] == 0))
+    {
+        /* unix socket */
+        self->chan_trans = trans_create(TRANS_MODE_UNIX, 8192, 8192);
     }
     else
     {
-      g_writeln("xrdp_mm_connect_chansrv: chansrv connect successful");
+        /* tcp */
+        self->chan_trans = trans_create(TRANS_MODE_TCP, 8192, 8192);
     }
-  }
-  return 0;
+
+    self->chan_trans->trans_data_in = xrdp_mm_chan_data_in;
+    self->chan_trans->header_size = 8;
+    self->chan_trans->callback_data = self;
+
+    /* try to connect up to 4 times */
+    for (index = 0; index < 4; index++)
+    {
+        if (trans_connect(self->chan_trans, ip, port, 3000) == 0)
+        {
+            self->chan_trans_up = 1;
+            break;
+        }
+
+        g_sleep(1000);
+        g_writeln("xrdp_mm_connect_chansrv: connect failed "
+                  "trying again...");
+    }
+
+    if (!(self->chan_trans_up))
+    {
+        g_writeln("xrdp_mm_connect_chansrv: error in trans_connect "
+                  "chan");
+    }
+
+    if (self->chan_trans_up)
+    {
+        if (xrdp_mm_chan_send_init(self) != 0)
+        {
+            g_writeln("xrdp_mm_connect_chansrv: error in "
+                      "xrdp_mm_chan_send_init");
+        }
+        else
+        {
+            g_writeln("xrdp_mm_connect_chansrv: chansrv connect successful");
+        }
+    }
+
+    return 0;
 }
 
-static void cleanup_sesman_connection(struct xrdp_mm* self)
+static void cleanup_sesman_connection(struct xrdp_mm *self)
 {
-  self->delete_sesman_trans = 1;
-  self->connected_state = 0;
-  if (self->wm->login_mode != 10)
-  {
-    xrdp_wm_set_login_mode(self->wm, 11);
-    xrdp_mm_module_cleanup(self);
-  }
+    self->delete_sesman_trans = 1;
+    self->connected_state = 0;
+
+    if (self->wm->login_mode != 10)
+    {
+        xrdp_wm_set_login_mode(self->wm, 11);
+        xrdp_mm_module_cleanup(self);
+    }
 }
 
 /*****************************************************************************/
 static int APP_CC
-xrdp_mm_process_login_response(struct xrdp_mm* self, struct stream* s)
-{
-  int ok;
-  int display;
-  int rv;
-  char text[256];
-  char ip[256];
-  char port[256];
-
-  rv = 0;
-  in_uint16_be(s, ok);
-  in_uint16_be(s, display);
-  if (ok)
-  {
-    self->display = display;
-    g_snprintf(text, 255, "xrdp_mm_process_login_response: login successful "
-                          "for display %d", display);
-    xrdp_wm_log_msg(self->wm, text);
-    if (xrdp_mm_setup_mod1(self) == 0)
-    {
-      if (xrdp_mm_setup_mod2(self) == 0)
-      {
-        xrdp_mm_get_value(self, "ip", ip, 255);
-        xrdp_wm_set_login_mode(self->wm, 10);
-        self->wm->dragging = 0;
-        /* connect channel redir */
-        if ((ip == 0) || (g_strcmp(ip, "127.0.0.1") == 0) || (ip[0] == 0))
-        {
-          g_snprintf(port, 255, "/tmp/.xrdp/xrdp_chansrv_socket_%d", 7200 + display);
-        }
-        else
+xrdp_mm_process_login_response(struct xrdp_mm *self, struct stream *s)
+{
+    int ok;
+    int display;
+    int rv;
+    char text[256];
+    char ip[256];
+    char port[256];
+
+    rv = 0;
+    in_uint16_be(s, ok);
+    in_uint16_be(s, display);
+
+    if (ok)
+    {
+        self->display = display;
+        g_snprintf(text, 255, "xrdp_mm_process_login_response: login successful "
+                   "for display %d", display);
+        xrdp_wm_log_msg(self->wm, text);
+
+        if (xrdp_mm_setup_mod1(self) == 0)
         {
-          g_snprintf(port, 255, "%d", 7200 + display);
+            if (xrdp_mm_setup_mod2(self) == 0)
+            {
+                xrdp_mm_get_value(self, "ip", ip, 255);
+                xrdp_wm_set_login_mode(self->wm, 10);
+                self->wm->dragging = 0;
+
+                /* connect channel redir */
+                if ((ip == 0) || (g_strcmp(ip, "127.0.0.1") == 0) || (ip[0] == 0))
+                {
+                    g_snprintf(port, 255, "/tmp/.xrdp/xrdp_chansrv_socket_%d", 7200 + display);
+                }
+                else
+                {
+                    g_snprintf(port, 255, "%d", 7200 + display);
+                }
+
+                xrdp_mm_connect_chansrv(self, ip, port);
+            }
         }
-        xrdp_mm_connect_chansrv(self, ip, port);
-      }
     }
-  }
-  else
-  {
-    xrdp_wm_log_msg(self->wm, "xrdp_mm_process_login_response: "
-                              "login failed");
-  }
-  cleanup_sesman_connection(self);
-  return rv;
+    else
+    {
+        xrdp_wm_log_msg(self->wm, "xrdp_mm_process_login_response: "
+                        "login failed");
+    }
+
+    cleanup_sesman_connection(self);
+    return rv;
 }
 
 /*****************************************************************************/
 static int
-xrdp_mm_get_sesman_port(char* port, int port_bytes)
-{
-  int fd;
-  int error;
-  int index;
-  char* val;
-  char cfg_file[256];
-  struct list* names;
-  struct list* values;
-
-  g_memset(cfg_file,0,sizeof(char) * 256);
-  /* default to port 3350 */
-  g_strncpy(port, "3350", port_bytes - 1);
-  /* see if port is in xrdp.ini file */
-  g_snprintf(cfg_file, 255, "%s/sesman.ini", XRDP_CFG_PATH);
-  fd = g_file_open(cfg_file);
-  if (fd > 0)
-  {
-    names = list_create();
-    names->auto_free = 1;
-    values = list_create();
-    values->auto_free = 1;
-    if (file_read_section(fd, "Globals", names, values) == 0)
-    {
-      for (index = 0; index < names->count; index++)
-      {
-        val = (char*)list_get_item(names, index);
-        if (val != 0)
-        {
-          if (g_strcasecmp(val, "ListenPort") == 0)
-          {
-            val = (char*)list_get_item(values, index);
-            error = g_atoi(val);
-            if ((error > 0) && (error < 65000))
+xrdp_mm_get_sesman_port(char *port, int port_bytes)
+{
+    int fd;
+    int error;
+    int index;
+    char *val;
+    char cfg_file[256];
+    struct list *names;
+    struct list *values;
+
+    g_memset(cfg_file, 0, sizeof(char) * 256);
+    /* default to port 3350 */
+    g_strncpy(port, "3350", port_bytes - 1);
+    /* see if port is in xrdp.ini file */
+    g_snprintf(cfg_file, 255, "%s/sesman.ini", XRDP_CFG_PATH);
+    fd = g_file_open(cfg_file);
+
+    if (fd > 0)
+    {
+        names = list_create();
+        names->auto_free = 1;
+        values = list_create();
+        values->auto_free = 1;
+
+        if (file_read_section(fd, "Globals", names, values) == 0)
+        {
+            for (index = 0; index < names->count; index++)
             {
-              g_strncpy(port, val, port_bytes - 1);
+                val = (char *)list_get_item(names, index);
+
+                if (val != 0)
+                {
+                    if (g_strcasecmp(val, "ListenPort") == 0)
+                    {
+                        val = (char *)list_get_item(values, index);
+                        error = g_atoi(val);
+
+                        if ((error > 0) && (error < 65000))
+                        {
+                            g_strncpy(port, val, port_bytes - 1);
+                        }
+
+                        break;
+                    }
+                }
             }
-            break;
-          }
         }
-      }
+
+        list_delete(names);
+        list_delete(values);
+        g_file_close(fd);
     }
-    list_delete(names);
-    list_delete(values);
-    g_file_close(fd);
-  }
 
-  return 0;
+    return 0;
 }
 
 /*****************************************************************************/
 /* returns error
    data coming from client that need to go to channel handler */
 int APP_CC
-xrdp_mm_process_channel_data(struct xrdp_mm* self, tbus param1, tbus param2,
+xrdp_mm_process_channel_data(struct xrdp_mm *self, tbus param1, tbus param2,
                              tbus param3, tbus param4)
 {
-  struct stream* s;
-  int rv;
-  int length;
-  int total_length;
-  int flags;
-  int id;
-  char* data;
-
-  rv = 0;
-  if ((self->chan_trans != 0) && self->chan_trans_up)
-  {
-    s = trans_get_out_s(self->chan_trans, 8192);
-    if (s != 0)
-    {
-      id = LOWORD(param1);
-      flags = HIWORD(param1);
-      length = param2;
-      data = (char*)param3;
-      total_length = param4;
-      if (total_length < length)
-      {
-        g_writeln("WARNING in xrdp_mm_process_channel_data(): total_len < length");
-        total_length = length;
-      }
-      out_uint32_le(s, 0); /* version */
-      out_uint32_le(s, 8 + 8 + 2 + 2 + 2 + 4 + length);
-      out_uint32_le(s, 5); /* msg id */
-      out_uint32_le(s, 8 + 2 + 2 + 2 + 4 + length);
-      out_uint16_le(s, id);
-      out_uint16_le(s, flags);
-      out_uint16_le(s, length);
-      out_uint32_le(s, total_length);
-      out_uint8a(s, data, length);
-      s_mark_end(s);
-      rv = trans_force_write(self->chan_trans);
-    }
-  }
-
-  return rv;
+    struct stream *s;
+    int rv;
+    int length;
+    int total_length;
+    int flags;
+    int id;
+    char *data;
+
+    rv = 0;
+
+    if ((self->chan_trans != 0) && self->chan_trans_up)
+    {
+        s = trans_get_out_s(self->chan_trans, 8192);
+
+        if (s != 0)
+        {
+            id = LOWORD(param1);
+            flags = HIWORD(param1);
+            length = param2;
+            data = (char *)param3;
+            total_length = param4;
+
+            if (total_length < length)
+            {
+                g_writeln("WARNING in xrdp_mm_process_channel_data(): total_len < length");
+                total_length = length;
+            }
+
+            out_uint32_le(s, 0); /* version */
+            out_uint32_le(s, 8 + 8 + 2 + 2 + 2 + 4 + length);
+            out_uint32_le(s, 5); /* msg id */
+            out_uint32_le(s, 8 + 2 + 2 + 2 + 4 + length);
+            out_uint16_le(s, id);
+            out_uint16_le(s, flags);
+            out_uint16_le(s, length);
+            out_uint32_le(s, total_length);
+            out_uint8a(s, data, length);
+            s_mark_end(s);
+            rv = trans_force_write(self->chan_trans);
+        }
+    }
+
+    return rv;
 }
 
 /*****************************************************************************/
 /* This is the callback registered for sesman communication replies. */
 static int APP_CC
-xrdp_mm_sesman_data_in(struct trans* trans)
-{
-  struct xrdp_mm* self;
-  struct stream* s;
-  int version;
-  int size;
-  int error;
-  int code;
-
-  if (trans == 0)
-  {
-    return 1;
-  }
-  self = (struct xrdp_mm*)(trans->callback_data);
-  s = trans_get_in_s(trans);
-  if (s == 0)
-  {
-    return 1;
-  }
-  in_uint32_be(s, version);
-  in_uint32_be(s, size);
-  error = trans_force_read(trans, size - 8);
-  if (error == 0)
-  {
-    in_uint16_be(s, code);
-    switch (code)
-    {
-      /* even when the request is denied the reply will hold 3 as the command. */
-      case 3:
-        error = xrdp_mm_process_login_response(self, s);
-        break;
-      default:
-        xrdp_wm_log_msg(self->wm, "An undefined reply code was received from sesman");
-        g_writeln("Fatal xrdp_mm_sesman_data_in: unknown cmd code %d", code);
-        cleanup_sesman_connection(self);
-        break;
-    }
-  }
-
-  return error;
+xrdp_mm_sesman_data_in(struct trans *trans)
+{
+    struct xrdp_mm *self;
+    struct stream *s;
+    int version;
+    int size;
+    int error;
+    int code;
+
+    if (trans == 0)
+    {
+        return 1;
+    }
+
+    self = (struct xrdp_mm *)(trans->callback_data);
+    s = trans_get_in_s(trans);
+
+    if (s == 0)
+    {
+        return 1;
+    }
+
+    in_uint32_be(s, version);
+    in_uint32_be(s, size);
+    error = trans_force_read(trans, size - 8);
+
+    if (error == 0)
+    {
+        in_uint16_be(s, code);
+
+        switch (code)
+        {
+                /* even when the request is denied the reply will hold 3 as the command. */
+            case 3:
+                error = xrdp_mm_process_login_response(self, s);
+                break;
+            default:
+                xrdp_wm_log_msg(self->wm, "An undefined reply code was received from sesman");
+                g_writeln("Fatal xrdp_mm_sesman_data_in: unknown cmd code %d", code);
+                cleanup_sesman_connection(self);
+                break;
+        }
+    }
+
+    return error;
 }
 
 #ifdef ACCESS
@@ -969,104 +1059,112 @@ xrdp_mm_sesman_data_in(struct trans* trans)
 /* return 0 on success */
 int access_control(char *username, char *password, char *srv)
 {
-  int reply;
-  int rec = 1; // failure
-  struct stream* in_s;
-  struct stream* out_s;
-  unsigned long version;
-  unsigned short int dummy;
-  unsigned short int ok;
-  unsigned short int code;
-  unsigned long size;
-  int index;
-  int socket = g_tcp_socket();
-  if (socket > 0)
-  {
-    /* we use a blocking socket here */
-    reply = g_tcp_connect(socket, srv, "3350");
-    if (reply == 0)
-    {
-      make_stream(in_s);
-      init_stream(in_s, 500);
-      make_stream(out_s);
-      init_stream(out_s, 500);
-      s_push_layer(out_s, channel_hdr, 8);
-      out_uint16_be(out_s, 4); /*0x04 means SCP_GW_AUTHENTICATION*/
-      index = g_strlen(username);
-      out_uint16_be(out_s, index);
-      out_uint8a(out_s, username, index);
-
-      index = g_strlen(password);
-      out_uint16_be(out_s, index);
-      out_uint8a(out_s, password, index);
-      s_mark_end(out_s);
-      s_pop_layer(out_s, channel_hdr);
-      out_uint32_be(out_s, 0); /* version */
-      index = (int)(out_s->end - out_s->data);
-      out_uint32_be(out_s, index); /* size */
-      /* g_writeln("Number of data to send : %d",index); */
-      reply = g_tcp_send(socket, out_s->data, index, 0);
-      free_stream(out_s);
-      if (reply > 0)
-      {
-        /* We wait in 5 sec for a reply from sesman*/
-        if (g_tcp_can_recv(socket, 5000))
-        {
-          reply = g_tcp_recv(socket, in_s->end, 500, 0);
-          if (reply > 0)
-          {
-            in_s->end =  in_s->end + reply;
-            in_uint32_be(in_s, version);
-            /*g_writeln("Version number in reply from sesman: %d",version) ; */
-            in_uint32_be(in_s, size);
-            if ((size == 14) && (version == 0))
+    int reply;
+    int rec = 1; // failure
+    struct stream *in_s;
+    struct stream *out_s;
+    unsigned long version;
+    unsigned short int dummy;
+    unsigned short int ok;
+    unsigned short int code;
+    unsigned long size;
+    int index;
+    int socket = g_tcp_socket();
+
+    if (socket > 0)
+    {
+        /* we use a blocking socket here */
+        reply = g_tcp_connect(socket, srv, "3350");
+
+        if (reply == 0)
+        {
+            make_stream(in_s);
+            init_stream(in_s, 500);
+            make_stream(out_s);
+            init_stream(out_s, 500);
+            s_push_layer(out_s, channel_hdr, 8);
+            out_uint16_be(out_s, 4); /*0x04 means SCP_GW_AUTHENTICATION*/
+            index = g_strlen(username);
+            out_uint16_be(out_s, index);
+            out_uint8a(out_s, username, index);
+
+            index = g_strlen(password);
+            out_uint16_be(out_s, index);
+            out_uint8a(out_s, password, index);
+            s_mark_end(out_s);
+            s_pop_layer(out_s, channel_hdr);
+            out_uint32_be(out_s, 0); /* version */
+            index = (int)(out_s->end - out_s->data);
+            out_uint32_be(out_s, index); /* size */
+            /* g_writeln("Number of data to send : %d",index); */
+            reply = g_tcp_send(socket, out_s->data, index, 0);
+            free_stream(out_s);
+
+            if (reply > 0)
             {
-              in_uint16_be(in_s, code);
-              in_uint16_be(in_s, ok);
-              in_uint16_be(in_s, dummy);
-              if (code != 4)
-              {
-                log_message(LOG_LEVEL_ERROR, "Returned cmd code from "
-                  "sesman is corrupt");
-              }
-              else
-              {
-                rec = ok; /* here we read the reply from the access control */
-              }
+                /* We wait in 5 sec for a reply from sesman*/
+                if (g_tcp_can_recv(socket, 5000))
+                {
+                    reply = g_tcp_recv(socket, in_s->end, 500, 0);
+
+                    if (reply > 0)
+                    {
+                        in_s->end =  in_s->end + reply;
+                        in_uint32_be(in_s, version);
+                        /*g_writeln("Version number in reply from sesman: %d",version) ; */
+                        in_uint32_be(in_s, size);
+
+                        if ((size == 14) && (version == 0))
+                        {
+                            in_uint16_be(in_s, code);
+                            in_uint16_be(in_s, ok);
+                            in_uint16_be(in_s, dummy);
+
+                            if (code != 4)
+                            {
+                                log_message(LOG_LEVEL_ERROR, "Returned cmd code from "
+                                            "sesman is corrupt");
+                            }
+                            else
+                            {
+                                rec = ok; /* here we read the reply from the access control */
+                            }
+                        }
+                        else
+                        {
+                            log_message(LOG_LEVEL_ERROR, "Corrupt reply size or "
+                                        "version from sesman: %d", size);
+                        }
+                    }
+                    else
+                    {
+                        log_message(LOG_LEVEL_ERROR, "No data received from sesman");
+                    }
+                }
+                else
+                {
+                    log_message(LOG_LEVEL_ERROR, "Timeout when waiting for sesman");
+                }
             }
             else
             {
-              log_message(LOG_LEVEL_ERROR, "Corrupt reply size or "
-                "version from sesman: %d", size);
+                log_message(LOG_LEVEL_ERROR, "No success sending to sesman");
             }
-          }
-          else
-          {
-            log_message(LOG_LEVEL_ERROR, "No data received from sesman");
-          }
+
+            free_stream(in_s);
+            g_tcp_close(socket);
         }
         else
         {
-          log_message(LOG_LEVEL_ERROR, "Timeout when waiting for sesman");
+            log_message(LOG_LEVEL_ERROR, "Failure connecting to socket sesman");
         }
-      }
-      else
-      {
-        log_message(LOG_LEVEL_ERROR, "No success sending to sesman");
-      }
-      free_stream(in_s);
-      g_tcp_close(socket);
     }
     else
     {
-      log_message(LOG_LEVEL_ERROR, "Failure connecting to socket sesman");
+        log_message(LOG_LEVEL_ERROR, "Failure creating socket - for access control");
     }
-  }
-  else
-  {
-    log_message(LOG_LEVEL_ERROR, "Failure creating socket - for access control");
-  }
-  return rec;
+
+    return rec;
 }
 #endif
 
@@ -1074,1134 +1172,1244 @@ int access_control(char *username, char *password, char *srv)
 /* This routine clears all states to make sure that our next login will be
  * as expected. If the user does not press ok on the log window and try to
  * connect again we must make sure that no previous information is stored.*/
-void cleanup_states(struct xrdp_mm* self)
-{
-  if (self != NULL)
-  {
-    self-> connected_state = 0; /* true if connected to sesman else false */
-    self-> sesman_trans = NULL; /* connection to sesman */
-    self-> sesman_trans_up = 0; /* true once connected to sesman */
-    self-> delete_sesman_trans = 0; /* boolean set when done with sesman connection */
-    self-> display = 0; /* 10 for :10.0, 11 for :11.0, etc */
-    self-> code = 0; /* 0 Xvnc session 10 X11rdp session */
-    self-> sesman_controlled = 0; /* true if this is a sesman session */
-    self-> chan_trans = NULL; /* connection to chansrv */
-    self-> chan_trans_up = 0; /* true once connected to chansrv */
-    self-> delete_chan_trans = 0; /* boolean set when done with channel connection */
-    self-> usechansrv = 0; /* true if chansrvport is set in xrdp.ini or using sesman */
-  }
+void cleanup_states(struct xrdp_mm *self)
+{
+    if (self != NULL)
+    {
+        self-> connected_state = 0; /* true if connected to sesman else false */
+        self-> sesman_trans = NULL; /* connection to sesman */
+        self-> sesman_trans_up = 0; /* true once connected to sesman */
+        self-> delete_sesman_trans = 0; /* boolean set when done with sesman connection */
+        self-> display = 0; /* 10 for :10.0, 11 for :11.0, etc */
+        self-> code = 0; /* 0 Xvnc session 10 X11rdp session */
+        self-> sesman_controlled = 0; /* true if this is a sesman session */
+        self-> chan_trans = NULL; /* connection to chansrv */
+        self-> chan_trans_up = 0; /* true once connected to chansrv */
+        self-> delete_chan_trans = 0; /* boolean set when done with channel connection */
+        self-> usechansrv = 0; /* true if chansrvport is set in xrdp.ini or using sesman */
+    }
 }
 /*****************************************************************************/
 int APP_CC
-xrdp_mm_connect(struct xrdp_mm* self)
-{
-  struct list* names;
-  struct list* values;
-  int index;
-  int count;
-  int ok;
-  int rv;
-  char* name;
-  char* value;
-  char ip[256];
-  char errstr[256];
-  char text[256];
-  char port[8];
-  char chansrvport[256];
+xrdp_mm_connect(struct xrdp_mm *self)
+{
+    struct list *names;
+    struct list *values;
+    int index;
+    int count;
+    int ok;
+    int rv;
+    char *name;
+    char *value;
+    char ip[256];
+    char errstr[256];
+    char text[256];
+    char port[8];
+    char chansrvport[256];
 #ifdef ACCESS
-  int use_pam_auth = 0;
-  char pam_auth_sessionIP[256];
-  char pam_auth_password[256];
-  char pam_auth_username[256];
-  char username[256];
-  char password[256];
-  username[0] = 0;
-  password[0] = 0;
+    int use_pam_auth = 0;
+    char pam_auth_sessionIP[256];
+    char pam_auth_password[256];
+    char pam_auth_username[256];
+    char username[256];
+    char password[256];
+    username[0] = 0;
+    password[0] = 0;
 #endif
-  /* make sure we start in correct state */
-  cleanup_states(self);
-  g_memset(ip, 0, sizeof(ip));
-  g_memset(errstr, 0, sizeof(errstr));
-  g_memset(text, 0, sizeof(text));
-  g_memset(port, 0, sizeof(port));
-  g_memset(chansrvport, 0, sizeof(chansrvport));
-  rv = 0; /* success */
-  names = self->login_names;
-  values = self->login_values;
-  count = names->count;
-  for (index = 0; index < count; index++)
-  {
-    name = (char*)list_get_item(names, index);
-    value = (char*)list_get_item(values, index);
-    if (g_strcasecmp(name, "ip") == 0)
-    {
-      g_strncpy(ip, value, 255);
-    }
-    else if (g_strcasecmp(name, "port") == 0)
-    {
-      if (g_strcasecmp(value, "-1") == 0)
-      {
-        self->sesman_controlled = 1;
-      }
-    }
+    /* make sure we start in correct state */
+    cleanup_states(self);
+    g_memset(ip, 0, sizeof(ip));
+    g_memset(errstr, 0, sizeof(errstr));
+    g_memset(text, 0, sizeof(text));
+    g_memset(port, 0, sizeof(port));
+    g_memset(chansrvport, 0, sizeof(chansrvport));
+    rv = 0; /* success */
+    names = self->login_names;
+    values = self->login_values;
+    count = names->count;
+
+    for (index = 0; index < count; index++)
+    {
+        name = (char *)list_get_item(names, index);
+        value = (char *)list_get_item(values, index);
+
+        if (g_strcasecmp(name, "ip") == 0)
+        {
+            g_strncpy(ip, value, 255);
+        }
+        else if (g_strcasecmp(name, "port") == 0)
+        {
+            if (g_strcasecmp(value, "-1") == 0)
+            {
+                self->sesman_controlled = 1;
+            }
+        }
+
 #ifdef ACCESS
-    else if (g_strcasecmp(name, "pamusername") == 0)
-    {
-      use_pam_auth = 1;
-      g_strncpy(pam_auth_username, value, 255);
-    }
-    else if (g_strcasecmp(name, "pamsessionmng") == 0)
-    {
-      g_strncpy(pam_auth_sessionIP, value, 255);
-    }
-    else if (g_strcasecmp(name, "pampassword") == 0)
-    {
-      g_strncpy(pam_auth_password, value, 255);
-    }
-    else if (g_strcasecmp(name, "password") == 0)
-    {
-      g_strncpy(password, value, 255);
-    }
-    else if (g_strcasecmp(name, "username") == 0)
-    {
-      g_strncpy(username, value, 255);
-    }
+        else if (g_strcasecmp(name, "pamusername") == 0)
+        {
+            use_pam_auth = 1;
+            g_strncpy(pam_auth_username, value, 255);
+        }
+        else if (g_strcasecmp(name, "pamsessionmng") == 0)
+        {
+            g_strncpy(pam_auth_sessionIP, value, 255);
+        }
+        else if (g_strcasecmp(name, "pampassword") == 0)
+        {
+            g_strncpy(pam_auth_password, value, 255);
+        }
+        else if (g_strcasecmp(name, "password") == 0)
+        {
+            g_strncpy(password, value, 255);
+        }
+        else if (g_strcasecmp(name, "username") == 0)
+        {
+            g_strncpy(username, value, 255);
+        }
+
 #endif
-    else if (g_strcasecmp(name, "chansrvport") == 0)
-    {
-      g_strncpy(chansrvport, value, 255);
-      self->usechansrv = 1;
+        else if (g_strcasecmp(name, "chansrvport") == 0)
+        {
+            g_strncpy(chansrvport, value, 255);
+            self->usechansrv = 1;
+        }
     }
-  }
+
 #ifdef ACCESS
-  if (use_pam_auth)
-  {
-    int reply;
-    char replytxt[80];
-    char replymessage[4][80] = {"Ok","Sesman connect failure","User or password error","Privilege group error"};
-    xrdp_wm_log_msg(self->wm, "Please wait, we now perform access control...");
-    /* g_writeln("we use pam modules to check if we can approve this user"); */
-    if (!g_strncmp(pam_auth_username, "same", 255))
-    {
-      log_message(LOG_LEVEL_DEBUG, "pamusername copied from username - same: %s", username);
-      g_strncpy(pam_auth_username,username, 255);
-    }
-    if (!g_strncmp(pam_auth_password, "same", 255))
-    {
-      log_message(LOG_LEVEL_DEBUG,"pam_auth_password copied from username - same: %s", password);
-      g_strncpy(pam_auth_password, password, 255);
-    }
-    /* access_control return 0 on success */
-    reply = access_control(pam_auth_username, pam_auth_password, pam_auth_sessionIP);
-    if (reply >= 0 && reply < 4)
+
+    if (use_pam_auth)
     {
-      g_sprintf(replytxt,"Reply from access control: %s", replymessage[reply]);
+        int reply;
+        char replytxt[80];
+        char replymessage[4][80] = {"Ok", "Sesman connect failure", "User or password error", "Privilege group error"};
+        xrdp_wm_log_msg(self->wm, "Please wait, we now perform access control...");
+
+        /* g_writeln("we use pam modules to check if we can approve this user"); */
+        if (!g_strncmp(pam_auth_username, "same", 255))
+        {
+            log_message(LOG_LEVEL_DEBUG, "pamusername copied from username - same: %s", username);
+            g_strncpy(pam_auth_username, username, 255);
+        }
+
+        if (!g_strncmp(pam_auth_password, "same", 255))
+        {
+            log_message(LOG_LEVEL_DEBUG, "pam_auth_password copied from username - same: %s", password);
+            g_strncpy(pam_auth_password, password, 255);
+        }
+
+        /* access_control return 0 on success */
+        reply = access_control(pam_auth_username, pam_auth_password, pam_auth_sessionIP);
+
+        if (reply >= 0 && reply < 4)
+        {
+            g_sprintf(replytxt, "Reply from access control: %s", replymessage[reply]);
+        }
+        else
+        {
+            g_sprintf(replytxt, "Reply from access control undefined");
+        }
+
+        xrdp_wm_log_msg(self->wm, replytxt);
+        log_message(LOG_LEVEL_INFO, replytxt);
+
+        if (reply != 0)
+        {
+            rv = 1;
+            return rv;
+        }
     }
-    else
+
+#endif
+
+    if (self->sesman_controlled)
     {
-      g_sprintf(replytxt,"Reply from access control undefined");
+        ok = 0;
+        trans_delete(self->sesman_trans);
+        self->sesman_trans = trans_create(TRANS_MODE_TCP, 8192, 8192);
+        xrdp_mm_get_sesman_port(port, sizeof(port));
+        g_snprintf(text, 255, "connecting to sesman ip %s port %s", ip, port);
+        xrdp_wm_log_msg(self->wm, text);
+        /* xrdp_mm_sesman_data_in is the callback that is called when data arrives */
+        self->sesman_trans->trans_data_in = xrdp_mm_sesman_data_in;
+        self->sesman_trans->header_size = 8;
+        self->sesman_trans->callback_data = self;
+
+        /* try to connect up to 4 times */
+        for (index = 0; index < 4; index++)
+        {
+            if (trans_connect(self->sesman_trans, ip, port, 3000) == 0)
+            {
+                self->sesman_trans_up = 1;
+                ok = 1;
+                break;
+            }
+
+            g_sleep(1000);
+            g_writeln("xrdp_mm_connect: connect failed "
+                      "trying again...");
+        }
+
+        if (ok)
+        {
+            /* fully connect */
+            xrdp_wm_log_msg(self->wm, "sesman connect ok");
+            self->connected_state = 1;
+            rv = xrdp_mm_send_login(self);
+        }
+        else
+        {
+            g_snprintf(errstr, 255, "Failure to connect to sesman: %s port: %s",
+                       ip, port);
+            xrdp_wm_log_msg(self->wm, errstr);
+            trans_delete(self->sesman_trans);
+            self->sesman_trans = 0;
+            self->sesman_trans_up = 0;
+            rv = 1;
+        }
     }
-    xrdp_wm_log_msg(self->wm,replytxt);
-    log_message(LOG_LEVEL_INFO,replytxt);
-    if (reply != 0)
+    else /* no sesman */
     {
-      rv = 1;
-      return rv;
+        if (xrdp_mm_setup_mod1(self) == 0)
+        {
+            if (xrdp_mm_setup_mod2(self) == 0)
+            {
+                xrdp_wm_set_login_mode(self->wm, 10);
+                rv = 0; /*sucess*/
+            }
+            else
+            {
+                /* connect error */
+                g_snprintf(errstr, 255, "Failure to connect to: %s", ip);
+                xrdp_wm_log_msg(self->wm, errstr);
+                rv = 1; /* failure */
+            }
+        }
+        else
+        {
+            g_writeln("Failure setting up module");
+        }
+
+        if (self->wm->login_mode != 10)
+        {
+            xrdp_wm_set_login_mode(self->wm, 11);
+            xrdp_mm_module_cleanup(self);
+            rv = 1; /* failure */
+        }
     }
-  }
-#endif
-  if (self->sesman_controlled)
-  {
-    ok = 0;
-    trans_delete(self->sesman_trans);
-    self->sesman_trans = trans_create(TRANS_MODE_TCP, 8192, 8192);
-    xrdp_mm_get_sesman_port(port, sizeof(port));
-    g_snprintf(text, 255, "connecting to sesman ip %s port %s", ip, port);
-    xrdp_wm_log_msg(self->wm, text);
-    /* xrdp_mm_sesman_data_in is the callback that is called when data arrives */
-    self->sesman_trans->trans_data_in = xrdp_mm_sesman_data_in;
-    self->sesman_trans->header_size = 8;
-    self->sesman_trans->callback_data = self;
-    /* try to connect up to 4 times */
-    for (index = 0; index < 4; index++)
+
+    if ((self->wm->login_mode == 10) && (self->sesman_controlled == 0) &&
+            (self->usechansrv != 0))
     {
-      if (trans_connect(self->sesman_trans, ip, port, 3000) == 0)
-      {
-        self->sesman_trans_up = 1;
-        ok = 1;
-        break;
-      }
-      g_sleep(1000);
-      g_writeln("xrdp_mm_connect: connect failed "
-                "trying again...");
+        /* if sesman controlled, this will connect later */
+        xrdp_mm_connect_chansrv(self, "", chansrvport);
     }
-    if (ok)
+
+    g_writeln("returnvalue from xrdp_mm_connect %d", rv);
+
+    return rv;
+}
+
+/*****************************************************************************/
+int APP_CC
+xrdp_mm_get_wait_objs(struct xrdp_mm *self,
+                      tbus *read_objs, int *rcount,
+                      tbus *write_objs, int *wcount, int *timeout)
+{
+    int rv = 0;
+
+    if (self == 0)
     {
-      /* fully connect */
-      xrdp_wm_log_msg(self->wm, "sesman connect ok");
-      self->connected_state = 1;
-      rv = xrdp_mm_send_login(self);
+        return 0;
     }
-    else
+
+    rv = 0;
+
+    if ((self->sesman_trans != 0) && self->sesman_trans_up)
     {
-      g_snprintf(errstr, 255, "Failure to connect to sesman: %s port: %s",
-                   ip, port);
-      xrdp_wm_log_msg(self->wm, errstr);
-      trans_delete(self->sesman_trans);
-      self->sesman_trans = 0;
-      self->sesman_trans_up = 0;
-      rv = 1;
-    }
-  }
-  else /* no sesman */
-  {
-    if (xrdp_mm_setup_mod1(self) == 0)
-    {
-      if (xrdp_mm_setup_mod2(self) == 0)
-      {
-        xrdp_wm_set_login_mode(self->wm, 10);
-        rv = 0; /*sucess*/
-      }
-      else
-      {
-        /* connect error */
-        g_snprintf(errstr, 255, "Failure to connect to: %s", ip);
-        xrdp_wm_log_msg(self->wm, errstr);
-        rv = 1; /* failure */
-      }
+        trans_get_wait_objs(self->sesman_trans, read_objs, rcount);
     }
-    else
+
+    if ((self->chan_trans != 0) && self->chan_trans_up)
     {
-      g_writeln("Failure setting up module");
+        trans_get_wait_objs(self->chan_trans, read_objs, rcount);
     }
-    if (self->wm->login_mode != 10)
+
+    if (self->mod != 0)
     {
-      xrdp_wm_set_login_mode(self->wm, 11);
-      xrdp_mm_module_cleanup(self);
-      rv = 1; /* failure */
+        if (self->mod->mod_get_wait_objs != 0)
+        {
+            rv = self->mod->mod_get_wait_objs(self->mod, read_objs, rcount,
+                                              write_objs, wcount, timeout);
+        }
     }
-  }
 
-  if ((self->wm->login_mode == 10) && (self->sesman_controlled == 0) &&
-      (self->usechansrv != 0))
-  {
-    /* if sesman controlled, this will connect later */
-    xrdp_mm_connect_chansrv(self, "", chansrvport);
-  }
-  g_writeln("returnvalue from xrdp_mm_connect %d", rv);
-
-  return rv;
+    return rv;
 }
 
 /*****************************************************************************/
 int APP_CC
-xrdp_mm_get_wait_objs(struct xrdp_mm* self,
-                      tbus* read_objs, int* rcount,
-                      tbus* write_objs, int* wcount, int* timeout)
+xrdp_mm_check_wait_objs(struct xrdp_mm *self)
 {
-  int rv = 0;
+    int rv;
 
-  if (self == 0)
-  {
-    return 0;
-  }
-  rv = 0;
-  if ((self->sesman_trans != 0) && self->sesman_trans_up)
-  {
-    trans_get_wait_objs(self->sesman_trans, read_objs, rcount);
-  }
-  if ((self->chan_trans != 0) && self->chan_trans_up)
-  {
-    trans_get_wait_objs(self->chan_trans, read_objs, rcount);
-  }
-  if (self->mod != 0)
-  {
-    if (self->mod->mod_get_wait_objs != 0)
+    if (self == 0)
     {
-      rv = self->mod->mod_get_wait_objs(self->mod, read_objs, rcount,
-                                        write_objs, wcount, timeout);
+        return 0;
     }
-  }
 
-  return rv;
-}
+    rv = 0;
 
-/*****************************************************************************/
-int APP_CC
-xrdp_mm_check_wait_objs(struct xrdp_mm* self)
-{
-  int rv;
+    if ((self->sesman_trans != 0) && self->sesman_trans_up)
+    {
+        if (trans_check_wait_objs(self->sesman_trans) != 0)
+        {
+            self->delete_sesman_trans = 1;
+        }
+    }
 
-  if (self == 0)
-  {
-    return 0;
-  }
-  rv = 0;
-  if ((self->sesman_trans != 0) && self->sesman_trans_up)
-  {
-    if (trans_check_wait_objs(self->sesman_trans) != 0)
+    if ((self->chan_trans != 0) && self->chan_trans_up)
+    {
+        if (trans_check_wait_objs(self->chan_trans) != 0)
+        {
+            self->delete_chan_trans = 1;
+        }
+    }
+
+    if (self->mod != 0)
     {
-      self->delete_sesman_trans = 1;
+        if (self->mod->mod_check_wait_objs != 0)
+        {
+            rv = self->mod->mod_check_wait_objs(self->mod);
+        }
     }
-  }
-  if ((self->chan_trans != 0) && self->chan_trans_up)
-  {
-    if (trans_check_wait_objs(self->chan_trans) != 0)
+
+    if (self->delete_sesman_trans)
     {
-      self->delete_chan_trans = 1;
+        trans_delete(self->sesman_trans);
+        self->sesman_trans = 0;
+        self->sesman_trans_up = 0;
+        self->delete_sesman_trans = 0;
     }
-  }
-  if (self->mod != 0)
-  {
-    if (self->mod->mod_check_wait_objs != 0)
+
+    if (self->delete_chan_trans)
     {
-      rv = self->mod->mod_check_wait_objs(self->mod);
+        trans_delete(self->chan_trans);
+        self->chan_trans = 0;
+        self->chan_trans_up = 0;
+        self->delete_chan_trans = 0;
     }
-  }
-  if (self->delete_sesman_trans)
-  {
-    trans_delete(self->sesman_trans);
-    self->sesman_trans = 0;
-    self->sesman_trans_up = 0;
-    self->delete_sesman_trans = 0;
-  }
-  if (self->delete_chan_trans)
-  {
-    trans_delete(self->chan_trans);
-    self->chan_trans = 0;
-    self->chan_trans_up = 0;
-    self->delete_chan_trans = 0;
-  }
 
-  return rv;
+    return rv;
 }
 
 #if 0
 /*****************************************************************************/
-struct xrdp_painter* APP_CC
-get_painter(struct xrdp_mod* mod)
+struct xrdp_painter *APP_CC
+get_painter(struct xrdp_mod *mod)
 {
-  struct xrdp_wm* wm;
-  struct xrdp_painter* p;
+    struct xrdp_wm *wm;
+    struct xrdp_painter *p;
 
-  p = (struct xrdp_painter*)(mod->painter);
-  if (p == 0)
-  {
-    wm = (struct xrdp_wm*)(mod->wm);
-    p = xrdp_painter_create(wm, wm->session);
-    mod->painter = (tintptr)p;
-  }
-  return p;
+    p = (struct xrdp_painter *)(mod->painter);
+
+    if (p == 0)
+    {
+        wm = (struct xrdp_wm *)(mod->wm);
+        p = xrdp_painter_create(wm, wm->session);
+        mod->painter = (tintptr)p;
+    }
+
+    return p;
 }
 #endif
 
 /*****************************************************************************/
 int DEFAULT_CC
-server_begin_update(struct xrdp_mod* mod)
+server_begin_update(struct xrdp_mod *mod)
 {
-  struct xrdp_wm* wm;
-  struct xrdp_painter* p;
+    struct xrdp_wm *wm;
+    struct xrdp_painter *p;
 
-  wm = (struct xrdp_wm*)(mod->wm);
-  p = xrdp_painter_create(wm, wm->session);
-  xrdp_painter_begin_update(p);
-  mod->painter = (long)p;
-  return 0;
+    wm = (struct xrdp_wm *)(mod->wm);
+    p = xrdp_painter_create(wm, wm->session);
+    xrdp_painter_begin_update(p);
+    mod->painter = (long)p;
+    return 0;
 }
 
 /*****************************************************************************/
 int DEFAULT_CC
-server_end_update(struct xrdp_mod* mod)
+server_end_update(struct xrdp_mod *mod)
 {
-  struct xrdp_painter* p;
+    struct xrdp_painter *p;
+
+    p = (struct xrdp_painter *)(mod->painter);
+
+    if (p == 0)
+    {
+        return 0;
+    }
 
-  p = (struct xrdp_painter*)(mod->painter);
-  if (p == 0)
-  {
+    xrdp_painter_end_update(p);
+    xrdp_painter_delete(p);
+    mod->painter = 0;
     return 0;
-  }
-  xrdp_painter_end_update(p);
-  xrdp_painter_delete(p);
-  mod->painter = 0;
-  return 0;
 }
 
 /*****************************************************************************/
 /* got bell signal... try to send to client */
 int DEFAULT_CC
-server_bell_trigger(struct xrdp_mod* mod)
+server_bell_trigger(struct xrdp_mod *mod)
 {
-  struct xrdp_wm* wm;
+    struct xrdp_wm *wm;
 
-  wm = (struct xrdp_wm*)(mod->wm);
-  xrdp_wm_send_bell(wm);
-  return 0;
+    wm = (struct xrdp_wm *)(mod->wm);
+    xrdp_wm_send_bell(wm);
+    return 0;
 }
 
 
 /*****************************************************************************/
 int DEFAULT_CC
-server_fill_rect(struct xrdp_mod* mod, int x, int y, int cx, int cy)
+server_fill_rect(struct xrdp_mod *mod, int x, int y, int cx, int cy)
 {
-  struct xrdp_wm* wm;
-  struct xrdp_painter* p;
+    struct xrdp_wm *wm;
+    struct xrdp_painter *p;
 
-  p = (struct xrdp_painter*)(mod->painter);
-  if (p == 0)
-  {
+    p = (struct xrdp_painter *)(mod->painter);
+
+    if (p == 0)
+    {
+        return 0;
+    }
+
+    wm = (struct xrdp_wm *)(mod->wm);
+    xrdp_painter_fill_rect(p, wm->target_surface, x, y, cx, cy);
     return 0;
-  }
-  wm = (struct xrdp_wm*)(mod->wm);
-  xrdp_painter_fill_rect(p, wm->target_surface, x, y, cx, cy);
-  return 0;
 }
 
 /*****************************************************************************/
 int DEFAULT_CC
-server_screen_blt(struct xrdp_mod* mod, int x, int y, int cx, int cy,
+server_screen_blt(struct xrdp_mod *mod, int x, int y, int cx, int cy,
                   int srcx, int srcy)
 {
-  struct xrdp_wm* wm;
-  struct xrdp_painter* p;
+    struct xrdp_wm *wm;
+    struct xrdp_painter *p;
+
+    p = (struct xrdp_painter *)(mod->painter);
 
-  p = (struct xrdp_painter*)(mod->painter);
-  if (p == 0)
-  {
+    if (p == 0)
+    {
+        return 0;
+    }
+
+    wm = (struct xrdp_wm *)(mod->wm);
+    p->rop = 0xcc;
+    xrdp_painter_copy(p, wm->screen, wm->target_surface, x, y, cx, cy, srcx, srcy);
     return 0;
-  }
-  wm = (struct xrdp_wm*)(mod->wm);
-  p->rop = 0xcc;
-  xrdp_painter_copy(p, wm->screen, wm->target_surface, x, y, cx, cy, srcx, srcy);
-  return 0;
 }
 
 /*****************************************************************************/
 int DEFAULT_CC
-server_paint_rect(struct xrdp_mod* mod, int x, int y, int cx, int cy,
-                  char* data, int width, int height, int srcx, int srcy)
+server_paint_rect(struct xrdp_mod *mod, int x, int y, int cx, int cy,
+                  char *data, int width, int height, int srcx, int srcy)
 {
-  struct xrdp_wm* wm;
-  struct xrdp_bitmap* b;
-  struct xrdp_painter* p;
+    struct xrdp_wm *wm;
+    struct xrdp_bitmap *b;
+    struct xrdp_painter *p;
+
+    p = (struct xrdp_painter *)(mod->painter);
+
+    if (p == 0)
+    {
+        return 0;
+    }
 
-  p = (struct xrdp_painter*)(mod->painter);
-  if (p == 0)
-  {
+    wm = (struct xrdp_wm *)(mod->wm);
+    b = xrdp_bitmap_create_with_data(width, height, wm->screen->bpp, data, wm);
+    xrdp_painter_copy(p, b, wm->target_surface, x, y, cx, cy, srcx, srcy);
+    xrdp_bitmap_delete(b);
     return 0;
-  }
-  wm = (struct xrdp_wm*)(mod->wm);
-  b = xrdp_bitmap_create_with_data(width, height, wm->screen->bpp, data, wm);
-  xrdp_painter_copy(p, b, wm->target_surface, x, y, cx, cy, srcx, srcy);
-  xrdp_bitmap_delete(b);
-  return 0;
 }
 
 /*****************************************************************************/
 int DEFAULT_CC
-server_set_pointer(struct xrdp_mod* mod, int x, int y,
-                   char* data, char* mask)
+server_set_pointer(struct xrdp_mod *mod, int x, int y,
+                   char *data, char *mask)
 {
-  struct xrdp_wm* wm;
+    struct xrdp_wm *wm;
 
-  wm = (struct xrdp_wm*)(mod->wm);
-  xrdp_wm_pointer(wm, data, mask, x, y);
-  return 0;
+    wm = (struct xrdp_wm *)(mod->wm);
+    xrdp_wm_pointer(wm, data, mask, x, y);
+    return 0;
 }
 
 /*****************************************************************************/
 int DEFAULT_CC
-server_palette(struct xrdp_mod* mod, int* palette)
+server_palette(struct xrdp_mod *mod, int *palette)
 {
-  struct xrdp_wm* wm;
+    struct xrdp_wm *wm;
+
+    wm = (struct xrdp_wm *)(mod->wm);
 
-  wm = (struct xrdp_wm*)(mod->wm);
-  if (g_memcmp(wm->palette, palette, 255 * sizeof(int)) != 0)
-  {
-    g_memcpy(wm->palette, palette, 256 * sizeof(int));
-    xrdp_wm_send_palette(wm);
-  }
-  return 0;
+    if (g_memcmp(wm->palette, palette, 255 * sizeof(int)) != 0)
+    {
+        g_memcpy(wm->palette, palette, 256 * sizeof(int));
+        xrdp_wm_send_palette(wm);
+    }
+
+    return 0;
 }
 
 /*****************************************************************************/
 int DEFAULT_CC
-server_msg(struct xrdp_mod* mod, char* msg, int code)
+server_msg(struct xrdp_mod *mod, char *msg, int code)
 {
-  struct xrdp_wm* wm;
+    struct xrdp_wm *wm;
 
-  if (code == 1)
-  {
-    g_writeln(msg);
-    return 0;
-  }
-  wm = (struct xrdp_wm*)(mod->wm);
-  return xrdp_wm_log_msg(wm, msg);
+    if (code == 1)
+    {
+        g_writeln(msg);
+        return 0;
+    }
+
+    wm = (struct xrdp_wm *)(mod->wm);
+    return xrdp_wm_log_msg(wm, msg);
 }
 
 /*****************************************************************************/
 int DEFAULT_CC
-server_is_term(struct xrdp_mod* mod)
+server_is_term(struct xrdp_mod *mod)
 {
-  return g_is_term();
+    return g_is_term();
 }
 
 /*****************************************************************************/
 int DEFAULT_CC
-server_set_clip(struct xrdp_mod* mod, int x, int y, int cx, int cy)
+server_set_clip(struct xrdp_mod *mod, int x, int y, int cx, int cy)
 {
-  struct xrdp_painter* p;
+    struct xrdp_painter *p;
 
-  p = (struct xrdp_painter*)(mod->painter);
-  if (p == 0)
-  {
-    return 0;
-  }
-  return xrdp_painter_set_clip(p, x, y, cx, cy);
+    p = (struct xrdp_painter *)(mod->painter);
+
+    if (p == 0)
+    {
+        return 0;
+    }
+
+    return xrdp_painter_set_clip(p, x, y, cx, cy);
 }
 
 /*****************************************************************************/
 int DEFAULT_CC
-server_reset_clip(struct xrdp_mod* mod)
+server_reset_clip(struct xrdp_mod *mod)
 {
-  struct xrdp_painter* p;
+    struct xrdp_painter *p;
 
-  p = (struct xrdp_painter*)(mod->painter);
-  if (p == 0)
-  {
-    return 0;
-  }
-  return xrdp_painter_clr_clip(p);
+    p = (struct xrdp_painter *)(mod->painter);
+
+    if (p == 0)
+    {
+        return 0;
+    }
+
+    return xrdp_painter_clr_clip(p);
 }
 
 /*****************************************************************************/
 int DEFAULT_CC
-server_set_fgcolor(struct xrdp_mod* mod, int fgcolor)
+server_set_fgcolor(struct xrdp_mod *mod, int fgcolor)
 {
-  struct xrdp_painter* p;
+    struct xrdp_painter *p;
+
+    p = (struct xrdp_painter *)(mod->painter);
+
+    if (p == 0)
+    {
+        return 0;
+    }
 
-  p = (struct xrdp_painter*)(mod->painter);
-  if (p == 0)
-  {
+    p->fg_color = fgcolor;
+    p->pen.color = p->fg_color;
     return 0;
-  }
-  p->fg_color = fgcolor;
-  p->pen.color = p->fg_color;
-  return 0;
 }
 
 /*****************************************************************************/
 int DEFAULT_CC
-server_set_bgcolor(struct xrdp_mod* mod, int bgcolor)
+server_set_bgcolor(struct xrdp_mod *mod, int bgcolor)
 {
-  struct xrdp_painter* p;
+    struct xrdp_painter *p;
+
+    p = (struct xrdp_painter *)(mod->painter);
+
+    if (p == 0)
+    {
+        return 0;
+    }
 
-  p = (struct xrdp_painter*)(mod->painter);
-  if (p == 0)
-  {
+    p->bg_color = bgcolor;
     return 0;
-  }
-  p->bg_color = bgcolor;
-  return 0;
 }
 
 /*****************************************************************************/
 int DEFAULT_CC
-server_set_opcode(struct xrdp_mod* mod, int opcode)
+server_set_opcode(struct xrdp_mod *mod, int opcode)
 {
-  struct xrdp_painter* p;
+    struct xrdp_painter *p;
+
+    p = (struct xrdp_painter *)(mod->painter);
 
-  p = (struct xrdp_painter*)(mod->painter);
-  if (p == 0)
-  {
+    if (p == 0)
+    {
+        return 0;
+    }
+
+    p->rop = opcode;
     return 0;
-  }
-  p->rop = opcode;
-  return 0;
 }
 
 /*****************************************************************************/
 int DEFAULT_CC
-server_set_mixmode(struct xrdp_mod* mod, int mixmode)
+server_set_mixmode(struct xrdp_mod *mod, int mixmode)
 {
-  struct xrdp_painter* p;
+    struct xrdp_painter *p;
+
+    p = (struct xrdp_painter *)(mod->painter);
+
+    if (p == 0)
+    {
+        return 0;
+    }
 
-  p = (struct xrdp_painter*)(mod->painter);
-  if (p == 0)
-  {
+    p->mix_mode = mixmode;
     return 0;
-  }
-  p->mix_mode = mixmode;
-  return 0;
 }
 
 /*****************************************************************************/
 int DEFAULT_CC
-server_set_brush(struct xrdp_mod* mod, int x_orgin, int y_orgin,
-                 int style, char* pattern)
+server_set_brush(struct xrdp_mod *mod, int x_orgin, int y_orgin,
+                 int style, char *pattern)
 {
-  struct xrdp_painter* p;
+    struct xrdp_painter *p;
+
+    p = (struct xrdp_painter *)(mod->painter);
+
+    if (p == 0)
+    {
+        return 0;
+    }
 
-  p = (struct xrdp_painter*)(mod->painter);
-  if (p == 0)
-  {
+    p->brush.x_orgin = x_orgin;
+    p->brush.y_orgin = y_orgin;
+    p->brush.style = style;
+    g_memcpy(p->brush.pattern, pattern, 8);
     return 0;
-  }
-  p->brush.x_orgin = x_orgin;
-  p->brush.y_orgin = y_orgin;
-  p->brush.style = style;
-  g_memcpy(p->brush.pattern, pattern, 8);
-  return 0;
 }
 
 /*****************************************************************************/
 int DEFAULT_CC
-server_set_pen(struct xrdp_mod* mod, int style, int width)
+server_set_pen(struct xrdp_mod *mod, int style, int width)
 {
-  struct xrdp_painter* p;
+    struct xrdp_painter *p;
 
-  p = (struct xrdp_painter*)(mod->painter);
-  if (p == 0)
-  {
+    p = (struct xrdp_painter *)(mod->painter);
+
+    if (p == 0)
+    {
+        return 0;
+    }
+
+    p->pen.style = style;
+    p->pen.width = width;
     return 0;
-  }
-  p->pen.style = style;
-  p->pen.width = width;
-  return 0;
 }
 
 /*****************************************************************************/
 int DEFAULT_CC
-server_draw_line(struct xrdp_mod* mod, int x1, int y1, int x2, int y2)
+server_draw_line(struct xrdp_mod *mod, int x1, int y1, int x2, int y2)
 {
-  struct xrdp_wm* wm;
-  struct xrdp_painter* p;
+    struct xrdp_wm *wm;
+    struct xrdp_painter *p;
 
-  p = (struct xrdp_painter*)(mod->painter);
-  if (p == 0)
-  {
-    return 0;
-  }
-  wm = (struct xrdp_wm*)(mod->wm);
-  return xrdp_painter_line(p, wm->target_surface, x1, y1, x2, y2);
+    p = (struct xrdp_painter *)(mod->painter);
+
+    if (p == 0)
+    {
+        return 0;
+    }
+
+    wm = (struct xrdp_wm *)(mod->wm);
+    return xrdp_painter_line(p, wm->target_surface, x1, y1, x2, y2);
 }
 
 /*****************************************************************************/
 int DEFAULT_CC
-server_add_char(struct xrdp_mod* mod, int font, int charactor,
+server_add_char(struct xrdp_mod *mod, int font, int charactor,
                 int offset, int baseline,
-                int width, int height, char* data)
+                int width, int height, char *data)
 {
-  struct xrdp_font_char fi;
+    struct xrdp_font_char fi;
 
-  fi.offset = offset;
-  fi.baseline = baseline;
-  fi.width = width;
-  fi.height = height;
-  fi.incby = 0;
-  fi.data = data;
-  return libxrdp_orders_send_font(((struct xrdp_wm*)mod->wm)->session,
-                                  &fi, font, charactor);
+    fi.offset = offset;
+    fi.baseline = baseline;
+    fi.width = width;
+    fi.height = height;
+    fi.incby = 0;
+    fi.data = data;
+    return libxrdp_orders_send_font(((struct xrdp_wm *)mod->wm)->session,
+                                    &fi, font, charactor);
 }
 
 /*****************************************************************************/
 int DEFAULT_CC
-server_draw_text(struct xrdp_mod* mod, int font,
+server_draw_text(struct xrdp_mod *mod, int font,
                  int flags, int mixmode, int clip_left, int clip_top,
                  int clip_right, int clip_bottom,
                  int box_left, int box_top,
                  int box_right, int box_bottom,
-                 int x, int y, char* data, int data_len)
+                 int x, int y, char *data, int data_len)
 {
-  struct xrdp_wm* wm;
-  struct xrdp_painter* p;
+    struct xrdp_wm *wm;
+    struct xrdp_painter *p;
 
-  p = (struct xrdp_painter*)(mod->painter);
-  if (p == 0)
-  {
-    return 0;
-  }
-  wm = (struct xrdp_wm*)(mod->wm);
-  return xrdp_painter_draw_text2(p, wm->target_surface, font, flags,
-                                 mixmode, clip_left, clip_top,
-                                 clip_right, clip_bottom,
-                                 box_left, box_top,
-                                 box_right, box_bottom,
-                                 x, y, data, data_len);
+    p = (struct xrdp_painter *)(mod->painter);
+
+    if (p == 0)
+    {
+        return 0;
+    }
+
+    wm = (struct xrdp_wm *)(mod->wm);
+    return xrdp_painter_draw_text2(p, wm->target_surface, font, flags,
+                                   mixmode, clip_left, clip_top,
+                                   clip_right, clip_bottom,
+                                   box_left, box_top,
+                                   box_right, box_bottom,
+                                   x, y, data, data_len);
 }
 
 /*****************************************************************************/
 int DEFAULT_CC
-server_reset(struct xrdp_mod* mod, int width, int height, int bpp)
-{
-  struct xrdp_wm* wm;
-
-  wm = (struct xrdp_wm*)(mod->wm);
-  if (wm->client_info == 0)
-  {
-    return 1;
-  }
-  /* older client can't resize */
-  if (wm->client_info->build <= 419)
-  {
-    return 0;
-  }
-  /* if same, don't need to do anything */
-  if (wm->client_info->width == width &&
-      wm->client_info->height == height &&
-      wm->client_info->bpp == bpp)
-  {
+server_reset(struct xrdp_mod *mod, int width, int height, int bpp)
+{
+    struct xrdp_wm *wm;
+
+    wm = (struct xrdp_wm *)(mod->wm);
+
+    if (wm->client_info == 0)
+    {
+        return 1;
+    }
+
+    /* older client can't resize */
+    if (wm->client_info->build <= 419)
+    {
+        return 0;
+    }
+
+    /* if same, don't need to do anything */
+    if (wm->client_info->width == width &&
+            wm->client_info->height == height &&
+            wm->client_info->bpp == bpp)
+    {
+        return 0;
+    }
+
+    /* reset lib, client_info gets updated in libxrdp_reset */
+    if (libxrdp_reset(wm->session, width, height, bpp) != 0)
+    {
+        return 1;
+    }
+
+    /* reset cache */
+    xrdp_cache_reset(wm->cache, wm->client_info);
+    /* resize the main window */
+    xrdp_bitmap_resize(wm->screen, wm->client_info->width,
+                       wm->client_info->height);
+    /* load some stuff */
+    xrdp_wm_load_static_colors_plus(wm, 0);
+    xrdp_wm_load_static_pointers(wm);
     return 0;
-  }
-  /* reset lib, client_info gets updated in libxrdp_reset */
-  if (libxrdp_reset(wm->session, width, height, bpp) != 0)
-  {
-    return 1;
-  }
-  /* reset cache */
-  xrdp_cache_reset(wm->cache, wm->client_info);
-  /* resize the main window */
-  xrdp_bitmap_resize(wm->screen, wm->client_info->width,
-                     wm->client_info->height);
-  /* load some stuff */
-  xrdp_wm_load_static_colors_plus(wm, 0);
-  xrdp_wm_load_static_pointers(wm);
-  return 0;
 }
 /* read the channel section of the ini file into lists
  * return 1 on success 0 on failure */
-int read_allowed_channel_names(struct list* names, struct list* values)
-{
-  int fd;
-  int ret = 0;
-  char cfg_file[256];
-  int pos;
-  g_snprintf(cfg_file, 255, "%s/xrdp.ini", XRDP_CFG_PATH);
-  fd = g_file_open(cfg_file);
-  if (fd > 0)
-  {
-    names->auto_free = 1;
-    values->auto_free = 1;
-    pos = 0;
-    /* all values in this section can be valid channel names */
-    if (file_read_section(fd, "channels", names, values) == 0)
-    {
-      ret = 1;
-    }
-    else
+int read_allowed_channel_names(struct list *names, struct list *values)
+{
+    int fd;
+    int ret = 0;
+    char cfg_file[256];
+    int pos;
+    g_snprintf(cfg_file, 255, "%s/xrdp.ini", XRDP_CFG_PATH);
+    fd = g_file_open(cfg_file);
+
+    if (fd > 0)
     {
-      g_writeln("Failure reading channel section of configuration");
+        names->auto_free = 1;
+        values->auto_free = 1;
+        pos = 0;
+
+        /* all values in this section can be valid channel names */
+        if (file_read_section(fd, "channels", names, values) == 0)
+        {
+            ret = 1;
+        }
+        else
+        {
+            g_writeln("Failure reading channel section of configuration");
+        }
+
+        g_file_close(fd);
+        return ret;
     }
-    g_file_close(fd);
-    return ret;
-  }
 }
 /* internal function return 1 if name is in list of channels
  * and if the value is allowed */
 int DEFAULT_CC
-is_name_in_lists(char* inName, struct list* names, struct list* values)
-{
-  int reply = 0; /*means not in the list*/
-  int index;
-  char* val;
-  char* name;
-  for (index = 0; index < names->count; index++)
-  {
-    name = (char*)list_get_item(names, index);
-    if (name != 0)
-    {
-      /* ex rdpdr ;rdpsnd ; drdynvc ; cliprdr */
-      if (!g_strncmp(name, inName, MAX_CHANNEL_NAME))
-      {
-        val = (char*)list_get_item(values, index);
-        if ((g_strcasecmp(val, "yes") == 0) ||
-            (g_strcasecmp(val, "on") == 0) ||
-            (g_strcasecmp(val, "true") == 0) ||
-            (g_atoi(val) != 0))
-        {
-          reply = 1;
-        }
-        else
+is_name_in_lists(char *inName, struct list *names, struct list *values)
+{
+    int reply = 0; /*means not in the list*/
+    int index;
+    char *val;
+    char *name;
+
+    for (index = 0; index < names->count; index++)
+    {
+        name = (char *)list_get_item(names, index);
+
+        if (name != 0)
         {
-          g_writeln("This channel is disabled: %s", name);
+            /* ex rdpdr ;rdpsnd ; drdynvc ; cliprdr */
+            if (!g_strncmp(name, inName, MAX_CHANNEL_NAME))
+            {
+                val = (char *)list_get_item(values, index);
+
+                if ((g_strcasecmp(val, "yes") == 0) ||
+                        (g_strcasecmp(val, "on") == 0) ||
+                        (g_strcasecmp(val, "true") == 0) ||
+                        (g_atoi(val) != 0))
+                {
+                    reply = 1;
+                }
+                else
+                {
+                    g_writeln("This channel is disabled: %s", name);
+                }
+
+                break; /* stop loop - item found*/
+            }
         }
-        break; /* stop loop - item found*/
-      }
     }
-  }
-  return reply;
+
+    return reply;
 }
 /* internal function only used once per session
  * creates the list of allowed channels and store the information
  * in wm struct */
-void init_channel_allowed(struct xrdp_wm* wm)
-{
-  int error;
-  int i;
-  char channelname[MAX_CHANNEL_NAME];
-  int index = 0;
-  int allowindex = 0;
-  struct list* names;
-  struct list* values;
-  /* first reset allowedchannels */
-  for (i = 0; i < MAX_NR_CHANNELS; i++)
-  {
-    /* 0 is a valid channel so we use -1 to mark the index as unused */
-    wm->allowedchannels[i] = -1;
-  }
-  names = list_create();
-  values = list_create();
-  if (read_allowed_channel_names(names, values))
-  {
-    do
-    {
-      /* libxrdp_query_channel return 1 on error*/
-      error = libxrdp_query_channel(wm->session, index, channelname,NULL);
-      if (error == 0)
-      {
-        /* examples of channel names: rdpdr ; rdpsnd ; drdynvc ; cliprdr */
-        if (is_name_in_lists(channelname, names, values))
-        {
-          g_writeln("The following channel is allowed: %s", channelname);
-          wm->allowedchannels[allowindex] = index;
-          allowindex++;
-          if (allowindex >= MAX_NR_CHANNELS)
-          {
-            g_writeln("Programming error in is_channel_allowed");
-            error = 1; /* end loop */
-          }
-        }
-        else
+void init_channel_allowed(struct xrdp_wm *wm)
+{
+    int error;
+    int i;
+    char channelname[MAX_CHANNEL_NAME];
+    int index = 0;
+    int allowindex = 0;
+    struct list *names;
+    struct list *values;
+
+    /* first reset allowedchannels */
+    for (i = 0; i < MAX_NR_CHANNELS; i++)
+    {
+        /* 0 is a valid channel so we use -1 to mark the index as unused */
+        wm->allowedchannels[i] = -1;
+    }
+
+    names = list_create();
+    values = list_create();
+
+    if (read_allowed_channel_names(names, values))
+    {
+        do
         {
-          g_writeln("The following channel is not allowed: %s",channelname);
+            /* libxrdp_query_channel return 1 on error*/
+            error = libxrdp_query_channel(wm->session, index, channelname, NULL);
+
+            if (error == 0)
+            {
+                /* examples of channel names: rdpdr ; rdpsnd ; drdynvc ; cliprdr */
+                if (is_name_in_lists(channelname, names, values))
+                {
+                    g_writeln("The following channel is allowed: %s", channelname);
+                    wm->allowedchannels[allowindex] = index;
+                    allowindex++;
+
+                    if (allowindex >= MAX_NR_CHANNELS)
+                    {
+                        g_writeln("Programming error in is_channel_allowed");
+                        error = 1; /* end loop */
+                    }
+                }
+                else
+                {
+                    g_writeln("The following channel is not allowed: %s", channelname);
+                }
+
+                index++;
+            }
         }
-        index++;
-      }
-    } while ((error == 0) && (index < MAX_NR_CHANNELS));
-  }
-  else
-  {
-    g_writeln("Error reading channel section in inifile");
-  }
-  list_delete(names);
-  list_delete(values);
+        while ((error == 0) && (index < MAX_NR_CHANNELS));
+    }
+    else
+    {
+        g_writeln("Error reading channel section in inifile");
+    }
+
+    list_delete(names);
+    list_delete(values);
 }
 
 /*****************************************************************************/
 /* This function returns 1 if the channelID is allowed by rule set
  * returns 0 if not allowed */
-int DEFAULT_CC is_channel_allowed(struct xrdp_wm* wm, int channel_id)
+int DEFAULT_CC is_channel_allowed(struct xrdp_wm *wm, int channel_id)
 {
-  int i;
-  int reply = 0; /* not allowed */
-  /* The first time each client is using this function we have to
-   * define the list of allowed channels */
-  if (wm->allowedinitialized == 0)
-  {
-   init_channel_allowed(wm);
-   g_writeln("allow channel list initialized");
-   wm->allowedinitialized = 1;
-  }
-  for(i = 0; i < MAX_NR_CHANNELS; i++)
-  {
-    if (channel_id == wm->allowedchannels[i])
+    int i;
+    int reply = 0; /* not allowed */
+
+    /* The first time each client is using this function we have to
+     * define the list of allowed channels */
+    if (wm->allowedinitialized == 0)
     {
-      /*g_writeln("Channel allowed: %d",channel_id);*/
-      reply = 1; /*channel allowed*/
-      break;
+        init_channel_allowed(wm);
+        g_writeln("allow channel list initialized");
+        wm->allowedinitialized = 1;
     }
-    else if (wm->allowedchannels[i] == -1)
+
+    for (i = 0; i < MAX_NR_CHANNELS; i++)
     {
-      /* We are in the unused space of the allowedchannels list
-       * We can end the loop */
-      break;
+        if (channel_id == wm->allowedchannels[i])
+        {
+            /*g_writeln("Channel allowed: %d",channel_id);*/
+            reply = 1; /*channel allowed*/
+            break;
+        }
+        else if (wm->allowedchannels[i] == -1)
+        {
+            /* We are in the unused space of the allowedchannels list
+             * We can end the loop */
+            break;
+        }
     }
-  }
-  /*if (reply == 0)
-  {
-    g_writeln("This channel is NOT allowed: %d",channel_id) ;
-  }*/
-  return reply;
+
+    /*if (reply == 0)
+    {
+      g_writeln("This channel is NOT allowed: %d",channel_id) ;
+    }*/
+    return reply;
 }
 
 /*****************************************************************************/
 /*return 0 if the index is not found*/
 int DEFAULT_CC
-server_query_channel(struct xrdp_mod* mod, int index, char* channel_name,
-                     int* channel_flags)
+server_query_channel(struct xrdp_mod *mod, int index, char *channel_name,
+                     int *channel_flags)
 {
-  struct xrdp_wm* wm;
+    struct xrdp_wm *wm;
+
+    wm = (struct xrdp_wm *)(mod->wm);
+
+    if (wm->mm->usechansrv)
+    {
+        return 1;
+    }
 
-  wm = (struct xrdp_wm*)(mod->wm);
-  if (wm->mm->usechansrv)
-  {
-    return 1;
-  }
-  return libxrdp_query_channel(wm->session, index, channel_name,
-                               channel_flags);
+    return libxrdp_query_channel(wm->session, index, channel_name,
+                                 channel_flags);
 }
 
 /*****************************************************************************/
 /* returns -1 on error */
 int DEFAULT_CC
-server_get_channel_id(struct xrdp_mod* mod, char* name)
+server_get_channel_id(struct xrdp_mod *mod, char *name)
 {
-  struct xrdp_wm* wm;
+    struct xrdp_wm *wm;
+
+    wm = (struct xrdp_wm *)(mod->wm);
+
+    if (wm->mm->usechansrv)
+    {
+        return -1;
+    }
 
-  wm = (struct xrdp_wm*)(mod->wm);
-  if (wm->mm->usechansrv)
-  {
-    return -1;
-  }
-  return libxrdp_get_channel_id(wm->session, name);
+    return libxrdp_get_channel_id(wm->session, name);
 }
 
 /*****************************************************************************/
 int DEFAULT_CC
-server_send_to_channel(struct xrdp_mod* mod, int channel_id,
-                       char* data, int data_len,
+server_send_to_channel(struct xrdp_mod *mod, int channel_id,
+                       char *data, int data_len,
                        int total_data_len, int flags)
 {
-  struct xrdp_wm* wm;
+    struct xrdp_wm *wm;
 
-  wm = (struct xrdp_wm*)(mod->wm);
-  if (is_channel_allowed(wm, channel_id))
-  {
-    if (wm->mm->usechansrv)
+    wm = (struct xrdp_wm *)(mod->wm);
+
+    if (is_channel_allowed(wm, channel_id))
+    {
+        if (wm->mm->usechansrv)
+        {
+            return 1;
+        }
+
+        return libxrdp_send_to_channel(wm->session, channel_id, data, data_len,
+                                       total_data_len, flags);
+    }
+    else
     {
-      return 1;
+        return 1;
     }
-    return libxrdp_send_to_channel(wm->session, channel_id, data, data_len,
-                                   total_data_len, flags);
-  }
-  else
-  {
-    return 1;
-  }
 }
 
 /*****************************************************************************/
 int DEFAULT_CC
-server_create_os_surface(struct xrdp_mod* mod, int rdpindex,
+server_create_os_surface(struct xrdp_mod *mod, int rdpindex,
                          int width, int height)
 {
-  struct xrdp_wm* wm;
-  struct xrdp_bitmap* bitmap;
-  int error;
+    struct xrdp_wm *wm;
+    struct xrdp_bitmap *bitmap;
+    int error;
 
-  wm = (struct xrdp_wm*)(mod->wm);
-  bitmap = xrdp_bitmap_create(width, height, wm->screen->bpp,
-                              WND_TYPE_OFFSCREEN, wm);
-  error = xrdp_cache_add_os_bitmap(wm->cache, bitmap, rdpindex);
-  if (error != 0)
-  {
-    g_writeln("server_create_os_surface: xrdp_cache_add_os_bitmap failed");
-    return 1;
-  }
-  bitmap->item_index = rdpindex;
-  bitmap->id = rdpindex;
-  return 0;
+    wm = (struct xrdp_wm *)(mod->wm);
+    bitmap = xrdp_bitmap_create(width, height, wm->screen->bpp,
+                                WND_TYPE_OFFSCREEN, wm);
+    error = xrdp_cache_add_os_bitmap(wm->cache, bitmap, rdpindex);
+
+    if (error != 0)
+    {
+        g_writeln("server_create_os_surface: xrdp_cache_add_os_bitmap failed");
+        return 1;
+    }
+
+    bitmap->item_index = rdpindex;
+    bitmap->id = rdpindex;
+    return 0;
 }
 
 /*****************************************************************************/
 int DEFAULT_CC
-server_switch_os_surface(struct xrdp_mod* mod, int rdpindex)
+server_switch_os_surface(struct xrdp_mod *mod, int rdpindex)
 {
-  struct xrdp_wm* wm;
-  struct xrdp_os_bitmap_item* bi;
-  struct xrdp_painter* p;
+    struct xrdp_wm *wm;
+    struct xrdp_os_bitmap_item *bi;
+    struct xrdp_painter *p;
+
+    //g_writeln("server_switch_os_surface: id 0x%x", id);
+    wm = (struct xrdp_wm *)(mod->wm);
+
+    if (rdpindex == -1)
+    {
+        //g_writeln("server_switch_os_surface: setting target_surface to screen");
+        wm->target_surface = wm->screen;
+        p = (struct xrdp_painter *)(mod->painter);
+
+        if (p != 0)
+        {
+            //g_writeln("setting target");
+            wm_painter_set_target(p);
+        }
+
+        return 0;
+    }
 
-  //g_writeln("server_switch_os_surface: id 0x%x", id);
-  wm = (struct xrdp_wm*)(mod->wm);
-  if (rdpindex == -1)
-  {
-    //g_writeln("server_switch_os_surface: setting target_surface to screen");
-    wm->target_surface = wm->screen;
-    p = (struct xrdp_painter*)(mod->painter);
-    if (p != 0)
+    bi = xrdp_cache_get_os_bitmap(wm->cache, rdpindex);
+
+    if (bi != 0)
     {
-      //g_writeln("setting target");
-      wm_painter_set_target(p);
+        //g_writeln("server_switch_os_surface: setting target_surface to rdpid %d", id);
+        wm->target_surface = bi->bitmap;
+        p = (struct xrdp_painter *)(mod->painter);
+
+        if (p != 0)
+        {
+            //g_writeln("setting target");
+            wm_painter_set_target(p);
+        }
     }
-    return 0;
-  }
-  bi = xrdp_cache_get_os_bitmap(wm->cache, rdpindex);
-  if (bi != 0)
-  {
-    //g_writeln("server_switch_os_surface: setting target_surface to rdpid %d", id);
-    wm->target_surface = bi->bitmap;
-    p = (struct xrdp_painter*)(mod->painter);
-    if (p != 0)
+    else
     {
-      //g_writeln("setting target");
-      wm_painter_set_target(p);
+        g_writeln("server_switch_os_surface: error finding id %d", rdpindex);
     }
-  }
-  else
-  {
-    g_writeln("server_switch_os_surface: error finding id %d", rdpindex);
-  }
-  return 0;
+
+    return 0;
 }
 
 /*****************************************************************************/
 int DEFAULT_CC
-server_delete_os_surface(struct xrdp_mod* mod, int rdpindex)
+server_delete_os_surface(struct xrdp_mod *mod, int rdpindex)
 {
-  struct xrdp_wm* wm;
-  struct xrdp_painter* p;
+    struct xrdp_wm *wm;
+    struct xrdp_painter *p;
 
-  //g_writeln("server_delete_os_surface: id 0x%x", id);
-  wm = (struct xrdp_wm*)(mod->wm);
-  if (wm->target_surface->type == WND_TYPE_OFFSCREEN)
-  {
-    if (wm->target_surface->id == rdpindex)
+    //g_writeln("server_delete_os_surface: id 0x%x", id);
+    wm = (struct xrdp_wm *)(mod->wm);
+
+    if (wm->target_surface->type == WND_TYPE_OFFSCREEN)
     {
-      g_writeln("server_delete_os_surface: setting target_surface to screen");
-      wm->target_surface = wm->screen;
-      p = (struct xrdp_painter*)(mod->painter);
-      if (p != 0)
-      {
-        //g_writeln("setting target");
-        wm_painter_set_target(p);
-      }
+        if (wm->target_surface->id == rdpindex)
+        {
+            g_writeln("server_delete_os_surface: setting target_surface to screen");
+            wm->target_surface = wm->screen;
+            p = (struct xrdp_painter *)(mod->painter);
+
+            if (p != 0)
+            {
+                //g_writeln("setting target");
+                wm_painter_set_target(p);
+            }
+        }
     }
-  }
-  xrdp_cache_remove_os_bitmap(wm->cache, rdpindex);
-  return 0;
+
+    xrdp_cache_remove_os_bitmap(wm->cache, rdpindex);
+    return 0;
 }
 
 /*****************************************************************************/
 int DEFAULT_CC
-server_paint_rect_os(struct xrdp_mod* mod, int x, int y, int cx, int cy,
+server_paint_rect_os(struct xrdp_mod *mod, int x, int y, int cx, int cy,
                      int rdpindex, int srcx, int srcy)
 {
-  struct xrdp_wm* wm;
-  struct xrdp_bitmap* b;
-  struct xrdp_painter* p;
-  struct xrdp_os_bitmap_item* bi;
+    struct xrdp_wm *wm;
+    struct xrdp_bitmap *b;
+    struct xrdp_painter *p;
+    struct xrdp_os_bitmap_item *bi;
+
+    p = (struct xrdp_painter *)(mod->painter);
+
+    if (p == 0)
+    {
+        return 0;
+    }
+
+    wm = (struct xrdp_wm *)(mod->wm);
+    bi = xrdp_cache_get_os_bitmap(wm->cache, rdpindex);
+
+    if (bi != 0)
+    {
+        b = bi->bitmap;
+        xrdp_painter_copy(p, b, wm->target_surface, x, y, cx, cy, srcx, srcy);
+    }
+    else
+    {
+        g_writeln("server_paint_rect_os: error finding id %d", rdpindex);
+    }
 
-  p = (struct xrdp_painter*)(mod->painter);
-  if (p == 0)
-  {
     return 0;
-  }
-  wm = (struct xrdp_wm*)(mod->wm);
-  bi = xrdp_cache_get_os_bitmap(wm->cache, rdpindex);
-  if (bi != 0)
-  {
-    b = bi->bitmap;
-    xrdp_painter_copy(p, b, wm->target_surface, x, y, cx, cy, srcx, srcy);
-  }
-  else
-  {
-    g_writeln("server_paint_rect_os: error finding id %d", rdpindex);
-  }
-  return 0;
 }
 
 /*****************************************************************************/
 int DEFAULT_CC
-server_set_hints(struct xrdp_mod* mod, int hints, int mask)
+server_set_hints(struct xrdp_mod *mod, int hints, int mask)
 {
-  struct xrdp_wm* wm;
+    struct xrdp_wm *wm;
 
-  wm = (struct xrdp_wm*)(mod->wm);
-  if (mask & 1)
-  {
-    if (hints & 1)
-    {
-      wm->hints |= 1;
-    }
-    else
+    wm = (struct xrdp_wm *)(mod->wm);
+
+    if (mask & 1)
     {
-      wm->hints &= ~1;
+        if (hints & 1)
+        {
+            wm->hints |= 1;
+        }
+        else
+        {
+            wm->hints &= ~1;
+        }
     }
-  }
-  return 0;
+
+    return 0;
 }
 
 /*****************************************************************************/
 int DEFAULT_CC
-server_window_new_update(struct xrdp_mod* mod, int window_id,
-                         struct rail_window_state_order* window_state,
+server_window_new_update(struct xrdp_mod *mod, int window_id,
+                         struct rail_window_state_order *window_state,
                          int flags)
 {
-  struct xrdp_wm* wm;
+    struct xrdp_wm *wm;
 
-  wm = (struct xrdp_wm*)(mod->wm);
-  return libxrdp_window_new_update(wm->session, window_id,
-                                   window_state, flags);
+    wm = (struct xrdp_wm *)(mod->wm);
+    return libxrdp_window_new_update(wm->session, window_id,
+                                     window_state, flags);
 }
 
 /*****************************************************************************/
 int DEFAULT_CC
-server_window_delete(struct xrdp_mod* mod, int window_id)
+server_window_delete(struct xrdp_mod *mod, int window_id)
 {
-  struct xrdp_wm* wm;
+    struct xrdp_wm *wm;
 
-  wm = (struct xrdp_wm*)(mod->wm);
-  return libxrdp_window_delete(wm->session, window_id);
+    wm = (struct xrdp_wm *)(mod->wm);
+    return libxrdp_window_delete(wm->session, window_id);
 }
 
 /*****************************************************************************/
 int DEFAULT_CC
-server_window_icon(struct xrdp_mod* mod, int window_id, int cache_entry,
-                   int cache_id, struct rail_icon_info* icon_info,
+server_window_icon(struct xrdp_mod *mod, int window_id, int cache_entry,
+                   int cache_id, struct rail_icon_info *icon_info,
                    int flags)
 {
-  struct xrdp_wm* wm;
+    struct xrdp_wm *wm;
 
-  wm = (struct xrdp_wm*)(mod->wm);
-  return libxrdp_window_icon(wm->session, window_id, cache_entry, cache_id,
-                             icon_info, flags);
+    wm = (struct xrdp_wm *)(mod->wm);
+    return libxrdp_window_icon(wm->session, window_id, cache_entry, cache_id,
+                               icon_info, flags);
 }
 
 /*****************************************************************************/
 int DEFAULT_CC
-server_window_cached_icon(struct xrdp_mod* mod,
+server_window_cached_icon(struct xrdp_mod *mod,
                           int window_id, int cache_entry,
                           int cache_id, int flags)
 {
-  struct xrdp_wm* wm;
+    struct xrdp_wm *wm;
 
-  wm = (struct xrdp_wm*)(mod->wm);
-  return libxrdp_window_cached_icon(wm->session, window_id, cache_entry,
-                                    cache_id, flags);
+    wm = (struct xrdp_wm *)(mod->wm);
+    return libxrdp_window_cached_icon(wm->session, window_id, cache_entry,
+                                      cache_id, flags);
 }
 
 /*****************************************************************************/
 int DEFAULT_CC
-server_notify_new_update(struct xrdp_mod* mod,
+server_notify_new_update(struct xrdp_mod *mod,
                          int window_id, int notify_id,
-                         struct rail_notify_state_order* notify_state,
+                         struct rail_notify_state_order *notify_state,
                          int flags)
 {
-  struct xrdp_wm* wm;
+    struct xrdp_wm *wm;
 
-  wm = (struct xrdp_wm*)(mod->wm);
-  return libxrdp_notify_new_update(wm->session, window_id, notify_id,
-                                   notify_state, flags);
+    wm = (struct xrdp_wm *)(mod->wm);
+    return libxrdp_notify_new_update(wm->session, window_id, notify_id,
+                                     notify_state, flags);
 }
 
 /*****************************************************************************/
 int DEFAULT_CC
-server_notify_delete(struct xrdp_mod* mod, int window_id,
+server_notify_delete(struct xrdp_mod *mod, int window_id,
                      int notify_id)
 {
-  struct xrdp_wm* wm;
+    struct xrdp_wm *wm;
 
-  wm = (struct xrdp_wm*)(mod->wm);
-  return libxrdp_notify_delete(wm->session, window_id, notify_id);
+    wm = (struct xrdp_wm *)(mod->wm);
+    return libxrdp_notify_delete(wm->session, window_id, notify_id);
 }
 
 /*****************************************************************************/
 int DEFAULT_CC
-server_monitored_desktop(struct xrdp_mod* mod,
-                         struct rail_monitored_desktop_order* mdo,
+server_monitored_desktop(struct xrdp_mod *mod,
+                         struct rail_monitored_desktop_order *mdo,
                          int flags)
 {
-  struct xrdp_wm* wm;
+    struct xrdp_wm *wm;
 
-  wm = (struct xrdp_wm*)(mod->wm);
-  return libxrdp_monitored_desktop(wm->session, mdo, flags);
+    wm = (struct xrdp_wm *)(mod->wm);
+    return libxrdp_monitored_desktop(wm->session, mdo, flags);
 }