use os_call in sesman

common/os_calls.c

@@ -34,11 +34,14 @@
 #include <sys/un.h>
 #include <sys/time.h>
 #include <sys/types.h>
+#include <sys/wait.h>
+#include <sys/stat.h>
 #include <dlfcn.h>
 #include <arpa/inet.h>
 #include <netdb.h>
 #include <signal.h>
 #include <fcntl.h>
+#include <pwd.h>
 #endif
 
 #include <stdlib.h>
@@ -46,12 +49,6 @@
 #include <stdarg.h>
 #include <stdio.h>
 
-/* forward declarations */
-void
-g_printf(char* format, ...);
-void
-g_pipe_sig(int sig_num);
-
 /*****************************************************************************/
 void*
 g_malloc(int size, int zero)
@@ -520,6 +517,66 @@ g_file_lock(int fd, int start, int len)
 #endif
 }
 
+/*****************************************************************************/
+int
+g_set_file_rights(char* filename, int read, int write)
+{
+#if defined(_WIN32)
+#else
+  int flags;
+
+  flags = read ? S_IRUSR : 0;
+  flags |= write ? S_IWUSR : 0;
+  chmod(filename, flags);
+#endif
+  return 0;
+}
+
+/*****************************************************************************/
+int
+g_mkdir(char* dirname)
+{
+#if defined(_WIN32)
+#else
+  mkdir(dirname, S_IRWXU);
+#endif
+  return 0;
+}
+
+/*****************************************************************************/
+char*
+g_get_current_dir(char* dirname, int maxlen)
+{
+#if defined(_WIN32)
+  return 0;
+#else
+  return getcwd(dirname, maxlen);
+#endif
+}
+
+/*****************************************************************************/
+int
+g_set_current_dir(char* dirname)
+{
+#if defined(_WIN32)
+  return 0;
+#else
+  return chdir(dirname);
+#endif
+}
+
+/*****************************************************************************/
+/* returns non zero if the file exists */
+int
+g_file_exist(char* filename)
+{
+#if defined(_WIN32)
+  return 0;
+#else
+  return access(filename, F_OK) == 0;
+#endif
+}
+
 /*****************************************************************************/
 int
 g_strlen(char* text)
@@ -609,6 +666,13 @@ g_strncmp(char* c1, char* c2, int len)
   return strncmp(c1, c2, len);
 }
 
+/*****************************************************************************/
+int
+g_atoi(char* str)
+{
+  return atoi(str);
+}
+
 /*****************************************************************************/
 long
 g_load_library(char* in)
@@ -662,6 +726,39 @@ g_system(char* aexec)
 #endif
 }
 
+/*****************************************************************************/
+void
+g_execvp(char* p1, char* args[])
+{
+#if defined(_WIN32)
+#else
+  execvp(p1, args);
+#endif
+}
+
+/*****************************************************************************/
+int
+g_execlp3(char* a1, char* a2, char* a3)
+{
+#if defined(_WIN32)
+  return 0;
+#else
+  return execlp(a1, a2, a3);
+#endif
+}
+
+/*****************************************************************************/
+int
+g_execlp11(char* a1, char* a2, char* a3, char* a4, char* a5, char* a6,
+           char* a7, char* a8, char* a9, char* a10, char* a11)
+{
+#if defined(_WIN32)
+  return 0;
+#else
+  return execlp(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11);
+#endif
+}
+
 /*****************************************************************************/
 void
 g_signal(int sig_num, void (*func)(int))
@@ -671,3 +768,151 @@ g_signal(int sig_num, void (*func)(int))
   signal(sig_num, func);
 #endif
 }
+
+/*****************************************************************************/
+int
+g_fork(void)
+{
+#if defined(_WIN32)
+  return 0;
+#else
+  return fork();
+#endif
+}
+
+/*****************************************************************************/
+int
+g_setgid(int pid)
+{
+#if defined(_WIN32)
+  return 0;
+#else
+  return setgid(pid);
+#endif
+}
+
+/*****************************************************************************/
+int
+g_setuid(int pid)
+{
+#if defined(_WIN32)
+  return 0;
+#else
+  return setuid(pid);
+#endif
+}
+
+/*****************************************************************************/
+int
+g_waitchild(void)
+{
+#if defined(_WIN32)
+  return 0;
+#else
+  int wstat;
+
+  return waitpid(0, &wstat, WNOHANG);
+#endif
+}
+
+/*****************************************************************************/
+int
+g_waitpid(int pid)
+{
+#if defined(_WIN32)
+  return 0;
+#else
+  return waitpid(pid, 0, 0);
+#endif
+}
+
+/*****************************************************************************/
+void
+g_clearenv(void)
+{
+#if defined(_WIN32)
+#else
+  clearenv();
+#endif
+}
+
+/*****************************************************************************/
+int
+g_setenv(char* name, char* value, int rewrite)
+{
+#if defined(_WIN32)
+  return 0;
+#else
+  return setenv(name, value, rewrite);
+#endif
+}
+
+/*****************************************************************************/
+int
+g_exit(int exit_code)
+{
+#if defined(_WIN32)
+#else
+  _exit(exit_code);
+#endif
+  return 0;
+}
+
+/*****************************************************************************/
+int
+g_getpid(void)
+{
+#if defined(_WIN32)
+  return 0;
+#else
+  return getpid();
+#endif
+}
+
+/*****************************************************************************/
+int
+g_sigterm(int pid)
+{
+#if defined(_WIN32)
+  return 0;
+#else
+  return kill(pid, SIGTERM);
+#endif
+}
+
+/*****************************************************************************/
+int
+g_getuser_info(char* username, int* gid, int* uid, char* shell, char* dir,
+               char* gecos)
+{
+#if defined(_WIN32)
+#else
+  struct passwd* pwd_1;
+
+  pwd_1 = getpwnam(username);
+  if (pwd_1 != 0)
+  {
+    if (gid != 0)
+    {
+      *gid = pwd_1->pw_gid;
+    }
+    if (uid != 0)
+    {
+      *uid = pwd_1->pw_uid;
+    }
+    if (dir != 0)
+    {
+      g_strcpy(dir, pwd_1->pw_dir);
+    }
+    if (shell != 0)
+    {
+      g_strcpy(shell, pwd_1->pw_shell);
+    }
+    if (gecos != 0)
+    {
+      g_strcpy(gecos, pwd_1->pw_gecos);
+    }
+  }
+#endif
+  return 0;
+}

common/os_calls.h

@@ -23,18 +23,16 @@
 #if !defined(OS_CALLS_H)
 #define OS_CALLS_H
 
-int g_init_system(void);
+void*
-int g_exit_system(void);
+g_malloc(int size, int zero);
+void
+g_free(void* ptr);
 void
 g_printf(char *format, ...);
 void
 g_sprintf(char* dest, char* format, ...);
 void
 g_hexdump(char* p, int len);
-void*
-g_malloc(int size, int zero);
-void
-g_free(void* ptr);
 void
 g_memset(void* ptr, int val, int size);
 void
@@ -51,38 +49,113 @@ void
 g_tcp_close(int sck);
 int
 g_tcp_connect(int sck, char* address, char* port);
-int g_tcp_force_send(int sck, char* data, int len);
+int
-int g_tcp_force_recv(int sck, char* data, int len);
+g_tcp_force_send(int sck, char* data, int len);
-int g_tcp_set_non_blocking(int sck);
+int
-int g_tcp_bind(int sck, char* port);
+g_tcp_force_recv(int sck, char* data, int len);
-int g_tcp_local_bind(int sck, char* port);
+int
-int g_tcp_listen(int sck);
+g_tcp_set_non_blocking(int sck);
-int g_tcp_accept(int sck);
+int
-int g_tcp_recv(int sck, void* ptr, int len, int flags);
+g_tcp_bind(int sck, char* port);
-int g_tcp_send(int sck, void* ptr, int len, int flags);
+int
-int g_tcp_last_error_would_block(int sck);
+g_tcp_local_bind(int sck, char* port);
-int g_tcp_select(int sck1, int sck2);
+int
-void g_sleep(int msecs);
+g_tcp_listen(int sck);
-void g_random(char* data, int len);
+int
-int g_abs(int i);
+g_tcp_accept(int sck);
-int g_memcmp(void* s1, void* s2, int len);
+int
-int g_file_open(char* file_name);
+g_tcp_recv(int sck, void* ptr, int len, int flags);
-int g_file_close(int fd);
+int
-int g_file_read(int fd, char* ptr, int len);
+g_tcp_send(int sck, void* ptr, int len, int flags);
-int g_file_write(int fd, char* ptr, int len);
+int
-int g_file_seek(int fd, int offset);
+g_tcp_last_error_would_block(int sck);
-int g_file_lock(int fd, int start, int len);
+int
-int g_strlen(char* text);
+g_tcp_select(int sck1, int sck2);
-char* g_strcpy(char* dest, char* src);
+void
-char* g_strncpy(char* dest, char* src, int len);
+g_sleep(int msecs);
-char* g_strcat(char* dest, char* src);
+void
-char* g_strdup(char* in);
+g_random(char* data, int len);
-int g_strcmp(char* c1, char* c2);
+int
-int g_strncmp(char* c1, char* c2, int len);
+g_abs(int i);
-long g_load_library(char* in);
+int
-int g_free_library(long lib);
+g_memcmp(void* s1, void* s2, int len);
-void* g_get_proc_address(long lib, char* name);
+int
-int g_system(char* aexec);
+g_file_open(char* file_name);
-void g_signal(int sig_num, void (*func)(int));
+int
+g_file_close(int fd);
+int
+g_file_read(int fd, char* ptr, int len);
+int
+g_file_write(int fd, char* ptr, int len);
+int
+g_file_seek(int fd, int offset);
+int
+g_file_lock(int fd, int start, int len);
+int
+g_set_file_rights(char* filename, int read, int write);
+int
+g_mkdir(char* dirname);
+char*
+g_get_current_dir(char* dirname, int maxlen);
+int
+g_set_current_dir(char* dirname);
+int
+g_file_exist(char* filename);
+int
+g_strlen(char* text);
+char*
+g_strcpy(char* dest, char* src);
+char*
+g_strncpy(char* dest, char* src, int len);
+char*
+g_strcat(char* dest, char* src);
+char*
+g_strdup(char* in);
+int
+g_strcmp(char* c1, char* c2);
+int
+g_strncmp(char* c1, char* c2, int len);
+int
+g_atoi(char* str);
+long
+g_load_library(char* in);
+int
+g_free_library(long lib);
+void*
+g_get_proc_address(long lib, char* name);
+int
+g_system(char* aexec);
+void
+g_execvp(char* p1, char* args[]);
+int
+g_execlp3(char* a1, char* a2, char* a3);
+int
+g_execlp11(char* a1, char* a2, char* a3, char* a4, char* a5, char* a6,
+           char* a7, char* a8, char* a9, char* a10, char* a11);
+void
+g_signal(int sig_num, void (*func)(int));
+int
+g_fork(void);
+int
+g_setgid(int pid);
+int
+g_setuid(int pid);
+int
+g_waitchild(void);
+int
+g_waitpid(int pid);
+void
+g_clearenv(void);
+int
+g_setenv(char* name, char* value, int rewrite);
+int
+g_exit(int exit_code);
+int
+g_getpid(void);
+int
+g_sigterm(int pid);
+int
+g_getuser_info(char* username, int* gid, int* uid, char* shell, char* dir,
+               char* gecos);
 
 #endif

sesman/sesman.c

@@ -21,27 +21,14 @@
 
 */
 
-#include <sys/types.h>
-#include <sys/wait.h>
-#include <sys/socket.h>
-#include <sys/stat.h>
-#include <netinet/in.h>
-#include <netinet/tcp.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <unistd.h>
-#include <pwd.h>
-#include <signal.h>
-#include <grp.h>
-
 #include "d3des.h"
 
 #include "arch.h"
 #include "parse.h"
 #include "os_calls.h"
 
-int auth_userpass(char* user, char* pass);
+int DEFAULT_CC
+auth_userpass(char* user, char* pass);
 
 static int g_sck;
 static int g_pid;
@@ -49,7 +36,7 @@ static int g_pid;
 struct session_item
 {
   char name[256];
-  int pid; // pid of sesman waiting for wm to end
+  int pid; /* pid of sesman waiting for wm to end */
   int display;
   int width;
   int height;
@@ -61,7 +48,8 @@ static unsigned char s_fixedkey[8] = {23, 82, 107, 6, 35, 78, 88, 7};
 static struct session_item session_items[100];
 
 /*****************************************************************************/
-int tcp_force_recv(int sck, char* data, int len)
+static int DEFAULT_CC
+tcp_force_recv(int sck, char* data, int len)
 {
   int rcvd;
 
@@ -93,7 +81,8 @@ int tcp_force_recv(int sck, char* data, int len)
 }
 
 /*****************************************************************************/
-int tcp_force_send(int sck, char* data, int len)
+static int DEFAULT_CC
+tcp_force_send(int sck, char* data, int len)
 {
   int sent;
 
@@ -125,8 +114,8 @@ int tcp_force_send(int sck, char* data, int len)
 }
 
 /******************************************************************************/
-struct session_item* find_session_item(char* name, int width,
+static struct session_item* DEFAULT_CC
-                                       int height, int bpp)
+find_session_item(char* name, int width, int height, int bpp)
 {
   int i;
 
@@ -144,52 +133,24 @@ struct session_item* find_session_item(char* name, int width,
 }
 
 /******************************************************************************/
-struct session_item* find_session_item_by_name(char* name)
+/* returns non zero if there is an xserver running on this display */
-{
+static int DEFAULT_CC
-  int i;
+x_server_running(int display)
-
-  for (i = 0; i < 100; i++)
-  {
-    if (g_strcmp(name, session_items[i].name) == 0)
-    {
-      return session_items + i;
-    }
-  }
-  return 0;
-}
-
-/******************************************************************************/
-struct session_item* find_session_item_by_display(int display)
-{
-  int i;
-
-  for (i = 0; i < 100; i++)
-  {
-    if (session_items[i].display == display)
-    {
-      return session_items + i;
-    }
-  }
-  return 0;
-}
-
-/******************************************************************************/
-int x_server_running(int display)
 {
   char text[256];
 
   g_sprintf(text, "/tmp/.X11-unix/X%d", display);
-  return access(text, F_OK) == 0;
+  return g_file_exist(text);
 }
 
 /******************************************************************************/
-void cterm(int s)
+static void DEFAULT_CC
+cterm(int s)
 {
   int i;
   int pid;
-  int wstat;
 
-  pid = waitpid(0, &wstat, WNOHANG);
+  pid = g_waitchild();
   if (pid > 0)
   {
     for (i = 0; i < 100; i++)
@@ -203,23 +164,8 @@ void cterm(int s)
 }
 
 /******************************************************************************/
-/* ge the next available X display */
+static int DEFAULT_CC
-int get_next_display(void)
+check_password_file(char* filename, char* password)
-{
-  int i;
-
-  for (i = 10; i < 100; i++)
-  {
-    if (!x_server_running(i))
-    {
-      return i;
-    }
-  }
-  return -1;
-}
-
-/******************************************************************************/
-int check_password_file(char* filename, char* password)
 {
   char encryptedPasswd[16];
   int fd;
@@ -235,13 +181,13 @@ int check_password_file(char* filename, char* password)
   }
   g_file_write(fd, encryptedPasswd, 8);
   g_file_close(fd);
-  chmod(filename, S_IRUSR | S_IWUSR);
+  g_set_file_rights(filename, 1, 1); /* set read and write flags */
   return 0;
 }
 
 /******************************************************************************/
-int start_session(int width, int height, int bpp, char* username,
+static int DEFAULT_CC
-                  char* password)
+start_session(int width, int height, int bpp, char* username, char* password)
 {
   int display;
   int pid;
@@ -249,7 +195,11 @@ int start_session(int width, int height, int bpp, char* username,
   int wmpid;
   int xpid;
   int error;
-  struct passwd* pwd_1;
+  int pw_uid;
+  int pw_gid;
+  char pw_gecos[256];
+  char pw_dir[256];
+  char pw_shell[256];
   char text[256];
   char passwd_file[256];
   char geometry[32];
@@ -257,7 +207,7 @@ int start_session(int width, int height, int bpp, char* username,
   char screen[32];
   char cur_dir[256];
 
-  getcwd(cur_dir, 255);
+  g_get_current_dir(cur_dir, 255);
   display = 10;
   while (x_server_running(display) && display < 50)
   {
@@ -268,90 +218,85 @@ int start_session(int width, int height, int bpp, char* username,
     return 0;
   }
   wmpid = 0;
-  pid = fork();
+  pid = g_fork();
   if (pid == -1)
   {
   }
-  else if (pid == 0) // child
+  else if (pid == 0) /* child */
-  {
-    pwd_1 = getpwnam(username);
-    if (pwd_1 != 0)
   {
-      /* set uid and groups */
+    error = g_getuser_info(username, &pw_gid, &pw_uid, pw_shell, pw_dir,
-      error = initgroups(pwd_1->pw_name, pwd_1->pw_gid);
+                           pw_gecos);
     if (error == 0)
     {
-        error = setgid(pwd_1->pw_gid);
+      error = g_setgid(pw_gid);
-      }
       if (error == 0)
       {
-        uid = pwd_1->pw_uid;
+        uid = pw_uid;
-        error = setuid(uid);
+        error = g_setuid(uid);
       }
       if (error == 0)
       {
-        clearenv();
+        g_clearenv();
-        setenv("SHELL", pwd_1->pw_shell, 1);
+        g_setenv("SHELL", pw_shell, 1);
-        setenv("PATH", "/bin:/usr/bin:/usr/X11R6/bin:/usr/local/bin", 1);
+        g_setenv("PATH", "/bin:/usr/bin:/usr/X11R6/bin:/usr/local/bin", 1);
-        setenv("USER", username, 1);
+        g_setenv("USER", username, 1);
         g_sprintf(text, "%d", uid);
-        setenv("UID", text, 1);
+        g_setenv("UID", text, 1);
-        setenv("HOME", pwd_1->pw_dir, 1);
+        g_setenv("HOME", pw_dir, 1);
-        chdir(pwd_1->pw_dir);
+        g_set_current_dir(pw_dir);
         g_sprintf(text, ":%d.0", display);
-        setenv("DISPLAY", text, 1);
+        g_setenv("DISPLAY", text, 1);
         g_sprintf(geometry, "%dx%d", width, height);
         g_sprintf(depth, "%d", bpp);
         g_sprintf(screen, ":%d", display);
-        mkdir(".vnc", S_IRWXU);
+        g_mkdir(".vnc");
-        g_sprintf(passwd_file, "%s/.vnc/sesman_passwd", pwd_1->pw_dir);
+        g_sprintf(passwd_file, "%s/.vnc/sesman_passwd", pw_dir);
         check_password_file(passwd_file, password);
-        wmpid = fork();
+        wmpid = g_fork();
         if (wmpid == -1)
         {
         }
-        else if (wmpid == 0) // child
+        else if (wmpid == 0) /* child */
         {
-          // give X a bit to start
+          /* give X a bit to start */
           g_sleep(500);
           if (x_server_running(display))
           {
             g_sprintf(text, "%s/startwm.sh", cur_dir);
-            execlp(text, "startwm.sh", NULL);
+            g_execlp3(text, "startwm.sh", 0);
-            // should not get here
+            /* should not get here */
           }
           g_printf("error\n");
-          _exit(0);
+          g_exit(0);
         }
-        else // parent
+        else /* parent */
         {
-          xpid = fork();
+          xpid = g_fork();
           if (xpid == -1)
           {
           }
-          else if (xpid == 0) // child
+          else if (xpid == 0) /* child */
           {
-            execlp("Xvnc", "Xvnc", screen, "-geometry", geometry,
+            g_execlp11("Xvnc", "Xvnc", screen, "-geometry", geometry,
-                   "-depth", depth, "-bs", "-rfbauth", passwd_file,
+                       "-depth", depth, "-bs", "-rfbauth", passwd_file, 0);
-                   NULL);
+            /* should not get here */
-            // should not get here
             g_printf("error\n");
-            _exit(0);
+            g_exit(0);
           }
-          else // parent
+          else /* parent */
           {
-            waitpid(wmpid, 0, 0);
+            g_waitpid(wmpid);
-            kill(xpid, SIGTERM);
+            g_sigterm(xpid);
-            kill(wmpid, SIGTERM);
+            g_sigterm(wmpid);
-            _exit(0);
+            g_exit(0);
           }
         }
       }
     }
   }
-  else // parent
+  else /* parent */
   {
-    signal(SIGCHLD, cterm);
+    g_signal(17, cterm); /* SIGCHLD */
     session_items[display].pid = pid;
     g_strcpy(session_items[display].name, username);
     session_items[display].display = display;
@@ -364,20 +309,21 @@ int start_session(int width, int height, int bpp, char* username,
 }
 
 /******************************************************************************/
-void sesman_shutdown(int sig)
+static void DEFAULT_CC
+sesman_shutdown(int sig)
 {
-  if (getpid() != g_pid)
+  if (g_getpid() != g_pid)
   {
     return;
   }
   g_printf("shutting down\n\r");
-  g_printf("signal %d pid %d\n\r", sig, getpid());
+  g_printf("signal %d pid %d\n\r", sig, g_getpid());
   g_tcp_close(g_sck);
 }
 
-
 /******************************************************************************/
-int main(int argc, char** argv)
+int DEFAULT_CC
+main(int argc, char** argv)
 {
   int sck;
   int in_sck;
@@ -399,11 +345,11 @@ int main(int argc, char** argv)
   char pass[256];
   struct session_item* s_item;
 
-  signal(2, sesman_shutdown);
+  g_signal(2, sesman_shutdown); /* SIGINT */
-  signal(9, sesman_shutdown);
+  g_signal(9, sesman_shutdown); /* SIGKILL */
-  signal(15, sesman_shutdown);
+  g_signal(15, sesman_shutdown); /* SIGTERM */
   g_memset(&session_items, 0, sizeof(session_items));
-  g_pid = getpid();
+  g_pid = g_getpid();
   if (argc == 1)
   {
     g_printf("xrdp session manager v0.1\n");
@@ -446,20 +392,17 @@ start session\n");
               if (version == 0)
               {
                 in_uint16_be(in_s, code);
-                if (code == 0) // check username - password, start session
+                if (code == 0) /* check username - password, start session */
                 {
                   in_uint16_be(in_s, i);
                   in_uint8a(in_s, user, i);
                   user[i] = 0;
-                  //g_printf("%s\n", user);
                   in_uint16_be(in_s, i);
                   in_uint8a(in_s, pass, i);
                   pass[i] = 0;
-                  //g_printf("%s\n", pass);
                   in_uint16_be(in_s, width);
                   in_uint16_be(in_s, height);
                   in_uint16_be(in_s, bpp);
-                  //g_printf("%d %d %d\n", width, height, bpp);
                   ok = auth_userpass(user, pass);
                   display = 0;
                   if (ok)
@@ -479,11 +422,11 @@ start session\n");
                     }
                   }
                   init_stream(out_s, 8192);
-                  out_uint32_be(out_s, 0); // version
+                  out_uint32_be(out_s, 0); /* version */
-                  out_uint32_be(out_s, 14); // size
+                  out_uint32_be(out_s, 14); /* size */
-                  out_uint16_be(out_s, 3); // cmd
+                  out_uint16_be(out_s, 3); /* cmd */
-                  out_uint16_be(out_s, ok); // data
+                  out_uint16_be(out_s, ok); /* data */
-                  out_uint16_be(out_s, display); // data
+                  out_uint16_be(out_s, display); /* data */
                   s_mark_end(out_s);
                   tcp_force_send(in_sck, out_s->data,
                                  out_s->end - out_s->data);
@@ -517,9 +460,9 @@ start session\n");
   {
     username = argv[2];
     password = argv[3];
-    width = atoi(argv[4]);
+    width = g_atoi(argv[4]);
-    height = atoi(argv[5]);
+    height = g_atoi(argv[5]);
-    bpp = atoi(argv[6]);
+    bpp = g_atoi(argv[6]);
     make_stream(in_s);
     init_stream(in_s, 8192);
     make_stream(out_s);
@@ -528,21 +471,20 @@ start session\n");
     if (g_tcp_connect(sck, argv[1], "3350") == 0)
     {
       s_push_layer(out_s, channel_hdr, 8);
-      out_uint16_be(out_s, 0); // code
+      out_uint16_be(out_s, 0); /* code */
       i = g_strlen(username);
       out_uint16_be(out_s, i);
       out_uint8a(out_s, username, i);
       i = g_strlen(password);
       out_uint16_be(out_s, i);
       out_uint8a(out_s, password, i);
-      //g_printf("%d\n", width);
       out_uint16_be(out_s, width);
       out_uint16_be(out_s, height);
       out_uint16_be(out_s, bpp);
       s_mark_end(out_s);
       s_pop_layer(out_s, channel_hdr);
-      out_uint32_be(out_s, 0); // version
+      out_uint32_be(out_s, 0); /* version */
-      out_uint32_be(out_s, out_s->end - out_s->data); // size
+      out_uint32_be(out_s, out_s->end - out_s->data); /* size */
       tcp_force_send(sck, out_s->data, out_s->end - out_s->data);
       if (tcp_force_recv(sck, in_s->data, 8) == 0)
       {