Merge pull request #3487 from matt335672/fix_g_htoi

matt335672 · web-flow · commit 73bc82afc232 · 2025-03-31T16:09:36.000+01:00
Rationalise g_htoi() / xrdp_wm_htoi()
diff --git a/common/string_calls.c b/common/string_calls.c
@@ -502,82 +502,32 @@ size_t strlcpy(char *dst, const char *src, size_t dsize)
 #endif
 
 /*****************************************************************************/
-int
-g_htoi(char *str)
+unsigned int
+g_htoi(const char *str)
 {
-    int len;
-    int index;
-    int rv;
-    int val;
-    int shift;
-
-    rv = 0;
-    len = strlen(str);
-    index = len - 1;
-    shift = 0;
-
-    while (index >= 0)
+    unsigned int rv = 0;
+    while (*str != '\0')
     {
-        val = 0;
-
-        switch (str[index])
+        char c = *str;
+        unsigned int val;
+        if (c >= '0' && c <= '9')
         {
-            case '1':
-                val = 1;
-                break;
-            case '2':
-                val = 2;
-                break;
-            case '3':
-                val = 3;
-                break;
-            case '4':
-                val = 4;
-                break;
-            case '5':
-                val = 5;
-                break;
-            case '6':
-                val = 6;
-                break;
-            case '7':
-                val = 7;
-                break;
-            case '8':
-                val = 8;
-                break;
-            case '9':
-                val = 9;
-                break;
-            case 'a':
-            case 'A':
-                val = 10;
-                break;
-            case 'b':
-            case 'B':
-                val = 11;
-                break;
-            case 'c':
-            case 'C':
-                val = 12;
-                break;
-            case 'd':
-            case 'D':
-                val = 13;
-                break;
-            case 'e':
-            case 'E':
-                val = 14;
-                break;
-            case 'f':
-            case 'F':
-                val = 15;
-                break;
+            val = c - '0';
         }
-
-        rv = rv | (val << shift);
-        index--;
-        shift += 4;
+        else if (c >= 'A' && c <= 'F')
+        {
+            val = (c - 'A' + 10);
+        }
+        else if (c >= 'a' && c <= 'f')
+        {
+            val = (c - 'a' + 10);
+        }
+        else
+        {
+            break; // Unrecognised character
+        }
+        rv = (rv << 4) | val;
+        ++str;
     }
 
     return rv;
diff --git a/common/string_calls.h b/common/string_calls.h
@@ -310,7 +310,15 @@ size_t   strlcpy(char *dst, const char *src, size_t dsize);
  * @return int Integer expression of a string
  */
 int      g_atoix(const char *str);
-int      g_htoi(char *str);
+/**
+ * Converts a hex string to an integer
+ * @param str pointer to Hex string containing only hex digits
+ * @return value, converted from hex
+ *
+ * This function is intended to be used as an analogue to the standard
+ * function atoi(). It performs no error checking of its own
+ */
+unsigned int g_htoi(const char *str);
 int      g_bytes_to_hexstr(const void *bytes, int num_bytes, char *out_str,
                            int bytes_out_str);
 int      g_pos(const char *str, const char *to_find);
diff --git a/tests/common/test_string_calls.c b/tests/common/test_string_calls.c
@@ -1141,6 +1141,28 @@ END_TEST
 
 /******************************************************************************/
 
+START_TEST(test_htoi__all)
+{
+    // Invalid 1st character
+    ck_assert_int_eq(g_htoi(""), 0);
+    ck_assert_int_eq(g_htoi("z"), 0);
+    // Test border conditions (assumes ASCII) */
+    ck_assert_int_eq(g_htoi("99/"), 0x99); /* '/' = one-before '0' */
+    ck_assert_int_eq(g_htoi("99:"), 0x99); /* '/' = one-after '9' */
+    ck_assert_int_eq(g_htoi("99@"), 0x99); /* '#' = one-before 'A' */
+    ck_assert_int_eq(g_htoi("99G"), 0x99); /* 'G' = one-after 'F' */
+    ck_assert_int_eq(g_htoi("99`"), 0x99); /* '`' = one-before 'a' */
+    ck_assert_int_eq(g_htoi("99g"), 0x99); /* 'g' = one-after 'f' */
+
+    // Test all valid characters and shifting is OK */
+    ck_assert_int_eq(g_htoi("01234567"), 0x01234567);
+    ck_assert_int_eq(g_htoi("8ABCDEFa"), 0x8ABCDEFa);
+    ck_assert_int_eq(g_htoi("bcdef"), 0xbcdef);
+}
+END_TEST
+
+/******************************************************************************/
+
 Suite *
 make_suite_test_string(void)
 {
@@ -1152,6 +1174,7 @@ make_suite_test_string(void)
     TCase *tc_char2bm;
     TCase *tc_strtrim;
     TCase *tc_sigs;
+    TCase *tc_htoi;
 
     s = suite_create("String");
 
@@ -1230,5 +1253,9 @@ make_suite_test_string(void)
     tcase_add_test(tc_sigs, test_sigs__common);
     tcase_add_test(tc_sigs, test_sigs__bigint);
 
+    tc_htoi = tcase_create("g_htoi");
+    suite_add_tcase(s, tc_htoi);
+    tcase_add_test(tc_htoi, test_htoi__all);
+
     return s;
 }
diff --git a/xrdp/lang.c b/xrdp/lang.c
@@ -698,7 +698,7 @@ xrdp_init_xkb_layout(struct xrdp_client_info *client_info)
             int rdp_layout_id;
             item = (char *)list_get_item(items, index);
             value = (char *)list_get_item(values, index);
-            rdp_layout_id = g_htoi(value);
+            rdp_layout_id = g_atoix(value);
             if (rdp_layout_id == client_info->keylayout)
             {
                 g_strncpy(rdp_layout, item, 255);
@@ -714,12 +714,12 @@ xrdp_init_xkb_layout(struct xrdp_client_info *client_info)
             {
                 item = (char *)list_get_item(items, index);
                 value = (char *)list_get_item(values, index);
-                int rdp_layout_id = g_htoi(value);
+                int rdp_layout_id = g_atoix(value);
                 if (rdp_layout_id == alt_layout)
                 {
                     g_strncpy(rdp_layout, item, 255);
                     LOG(LOG_LEVEL_INFO,
-                        "Failed to match layout %08X, but matched %04X to %s",
+                        "Failed to match layout 0x%08X, but matched 0x%04X to %s",
                         client_info->keylayout, alt_layout, rdp_layout);
                     break;
                 }
diff --git a/xrdp/xrdp.h b/xrdp/xrdp.h
@@ -141,8 +141,6 @@ xrdp_wm_send_bitmap(struct xrdp_wm *self, struct xrdp_bitmap *bitmap,
                     int x, int y, int cx, int cy);
 int
 xrdp_wm_set_pointer(struct xrdp_wm *self, int cache_idx);
-unsigned int
-xrdp_wm_htoi (const char *ptr);
 int
 xrdp_wm_set_focused(struct xrdp_wm *self, struct xrdp_bitmap *wnd);
 int
diff --git a/xrdp/xrdp_login_wnd.c b/xrdp/xrdp_login_wnd.c
@@ -1074,8 +1074,8 @@ load_xrdp_config(struct xrdp_config *config, const char *xrdp_ini, int bpp)
     globals->ini_version = 1;
     globals->default_dpi = 96;
 
-    globals->ls_top_window_bg_color = HCOLOR(bpp, xrdp_wm_htoi("009cb5"));
-    globals->ls_bg_color = HCOLOR(bpp, xrdp_wm_htoi("dedede"));
+    globals->ls_top_window_bg_color = HCOLOR(bpp, g_htoi("009cb5"));
+    globals->ls_bg_color = HCOLOR(bpp, g_htoi("dedede"));
     globals->ls_unscaled.width = 350;
     globals->ls_unscaled.height = 350;
     globals->ls_background_transform = XBLT_NONE;
@@ -1214,47 +1214,47 @@ load_xrdp_config(struct xrdp_config *config, const char *xrdp_ini, int bpp)
 
         else if (g_strncmp(n, "grey", 64) == 0)
         {
-            globals->grey = xrdp_wm_htoi(v);
+            globals->grey = g_htoi(v);
         }
 
         else if (g_strncmp(n, "black", 64) == 0)
         {
-            globals->black = xrdp_wm_htoi(v);
+            globals->black = g_htoi(v);
         }
 
         else if (g_strncmp(n, "dark_grey", 64) == 0)
         {
-            globals->dark_grey = xrdp_wm_htoi(v);
+            globals->dark_grey = g_htoi(v);
         }
 
         else if (g_strncmp(n, "blue", 64) == 0)
         {
-            globals->blue = xrdp_wm_htoi(v);
+            globals->blue = g_htoi(v);
         }
 
         else if (g_strncmp(n, "dark_blue", 64) == 0)
         {
-            globals->dark_blue = xrdp_wm_htoi(v);
+            globals->dark_blue = g_htoi(v);
         }
 
         else if (g_strncmp(n, "white", 64) == 0)
         {
-            globals->white = xrdp_wm_htoi(v);
+            globals->white = g_htoi(v);
         }
 
         else if (g_strncmp(n, "red", 64) == 0)
         {
-            globals->red = xrdp_wm_htoi(v);
+            globals->red = g_htoi(v);
         }
 
         else if (g_strncmp(n, "green", 64) == 0)
         {
-            globals->green = xrdp_wm_htoi(v);
+            globals->green = g_htoi(v);
         }
 
         else if (g_strncmp(n, "background", 64) == 0)
         {
-            globals->background = xrdp_wm_htoi(v);
+            globals->background = g_htoi(v);
         }
 
         /* misc stuff */
@@ -1313,7 +1313,7 @@ load_xrdp_config(struct xrdp_config *config, const char *xrdp_ini, int bpp)
 
         else if (g_strncmp(n, "ls_top_window_bg_color", 64) == 0)
         {
-            globals->ls_top_window_bg_color = HCOLOR(bpp, xrdp_wm_htoi(v));
+            globals->ls_top_window_bg_color = HCOLOR(bpp, g_htoi(v));
         }
 
         else if (g_strncmp(n, "ls_width", 64) == 0)
@@ -1328,7 +1328,7 @@ load_xrdp_config(struct xrdp_config *config, const char *xrdp_ini, int bpp)
 
         else if (g_strncmp(n, "ls_bg_color", 64) == 0)
         {
-            globals->ls_bg_color = HCOLOR(bpp, xrdp_wm_htoi(v));
+            globals->ls_bg_color = HCOLOR(bpp, g_htoi(v));
         }
 
         else if (g_strncmp(n, "ls_title", 255) == 0)
diff --git a/xrdp/xrdp_wm.c b/xrdp/xrdp_wm.c
@@ -442,42 +442,6 @@ xrdp_wm_set_pointer(struct xrdp_wm *self, int cache_idx)
     return libxrdp_set_pointer(self->session, cache_idx);
 }
 
-/*****************************************************************************/
-/* convert hex string to int */
-unsigned int
-xrdp_wm_htoi (const char *ptr)
-{
-    unsigned int value = 0;
-    char ch = *ptr;
-
-    while (ch == ' ' || ch == '\t')
-    {
-        ch = *(++ptr);
-    }
-
-    for (;;)
-    {
-        if (ch >= '0' && ch <= '9')
-        {
-            value = (value << 4) + (ch - '0');
-        }
-        else if (ch >= 'A' && ch <= 'F')
-        {
-            value = (value << 4) + (ch - 'A' + 10);
-        }
-        else if (ch >= 'a' && ch <= 'f')
-        {
-            value = (value << 4) + (ch - 'a' + 10);
-        }
-        else
-        {
-            return value;
-        }
-
-        ch = *(++ptr);
-    }
-}
-
 /*****************************************************************************/
 int
 xrdp_wm_load_static_colors_plus(struct xrdp_wm *self, char *autorun_name)
@@ -529,47 +493,47 @@ xrdp_wm_load_static_colors_plus(struct xrdp_wm *self, char *autorun_name)
                     if (g_strcasecmp(val, "black") == 0)
                     {
                         val = (char *)list_get_item(values, index);
-                        self->black = HCOLOR(self->screen->bpp, xrdp_wm_htoi(val));
+                        self->black = HCOLOR(self->screen->bpp, g_htoi(val));
                     }
                     else if (g_strcasecmp(val, "grey") == 0)
                     {
                         val = (char *)list_get_item(values, index);
-                        self->grey = HCOLOR(self->screen->bpp, xrdp_wm_htoi(val));
+                        self->grey = HCOLOR(self->screen->bpp, g_htoi(val));
                     }
                     else if (g_strcasecmp(val, "dark_grey") == 0)
                     {
                         val = (char *)list_get_item(values, index);
-                        self->dark_grey = HCOLOR(self->screen->bpp, xrdp_wm_htoi(val));
+                        self->dark_grey = HCOLOR(self->screen->bpp, g_htoi(val));
                     }
                     else if (g_strcasecmp(val, "blue") == 0)
                     {
                         val = (char *)list_get_item(values, index);
-                        self->blue = HCOLOR(self->screen->bpp, xrdp_wm_htoi(val));
+                        self->blue = HCOLOR(self->screen->bpp, g_htoi(val));
                     }
                     else if (g_strcasecmp(val, "dark_blue") == 0)
                     {
                         val = (char *)list_get_item(values, index);
-                        self->dark_blue = HCOLOR(self->screen->bpp, xrdp_wm_htoi(val));
+                        self->dark_blue = HCOLOR(self->screen->bpp, g_htoi(val));
                     }
                     else if (g_strcasecmp(val, "white") == 0)
                     {
                         val = (char *)list_get_item(values, index);
-                        self->white = HCOLOR(self->screen->bpp, xrdp_wm_htoi(val));
+                        self->white = HCOLOR(self->screen->bpp, g_htoi(val));
                     }
                     else if (g_strcasecmp(val, "red") == 0)
                     {
                         val = (char *)list_get_item(values, index);
-                        self->red = HCOLOR(self->screen->bpp, xrdp_wm_htoi(val));
+                        self->red = HCOLOR(self->screen->bpp, g_htoi(val));
                     }
                     else if (g_strcasecmp(val, "green") == 0)
                     {
                         val = (char *)list_get_item(values, index);
-                        self->green = HCOLOR(self->screen->bpp, xrdp_wm_htoi(val));
+                        self->green = HCOLOR(self->screen->bpp, g_htoi(val));
                     }
                     else if (g_strcasecmp(val, "background") == 0)
                     {
                         val = (char *)list_get_item(values, index);
-                        self->background = HCOLOR(self->screen->bpp, xrdp_wm_htoi(val));
+                        self->background = HCOLOR(self->screen->bpp, g_htoi(val));
                     }
                     else if (g_strcasecmp(val, "autorun") == 0)
                     {

Original file line number	Diff line number	Diff line change
`@@ -698,7 +698,7 @@ xrdp_init_xkb_layout(struct xrdp_client_info *client_info)`
`698`	`698`	`int rdp_layout_id;`
`699`	`699`	`item = (char *)list_get_item(items, index);`
`700`	`700`	`value = (char *)list_get_item(values, index);`
`701`		`- rdp_layout_id = g_htoi(value);`
	`701`	`+ rdp_layout_id = g_atoix(value);`
`702`	`702`	`if (rdp_layout_id == client_info->keylayout)`
`703`	`703`	`{`
`704`	`704`	`g_strncpy(rdp_layout, item, 255);`
`@@ -714,12 +714,12 @@ xrdp_init_xkb_layout(struct xrdp_client_info *client_info)`
`714`	`714`	`{`
`715`	`715`	`item = (char *)list_get_item(items, index);`
`716`	`716`	`value = (char *)list_get_item(values, index);`
`717`		`- int rdp_layout_id = g_htoi(value);`
	`717`	`+ int rdp_layout_id = g_atoix(value);`
`718`	`718`	`if (rdp_layout_id == alt_layout)`
`719`	`719`	`{`
`720`	`720`	`g_strncpy(rdp_layout, item, 255);`
`721`	`721`	`LOG(LOG_LEVEL_INFO,`
`722`		`- "Failed to match layout %08X, but matched %04X to %s",`
	`722`	`+ "Failed to match layout 0x%08X, but matched 0x%04X to %s",`
`723`	`723`	`client_info->keylayout, alt_layout, rdp_layout);`
`724`	`724`	`break;`
`725`	`725`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1074,8 +1074,8 @@ load_xrdp_config(struct xrdp_config config, const char xrdp_ini, int bpp)`
`1074`	`1074`	`globals->ini_version = 1;`
`1075`	`1075`	`globals->default_dpi = 96;`
`1076`	`1076`
`1077`		`- globals->ls_top_window_bg_color = HCOLOR(bpp, xrdp_wm_htoi("009cb5"));`
`1078`		`- globals->ls_bg_color = HCOLOR(bpp, xrdp_wm_htoi("dedede"));`
	`1077`	`+ globals->ls_top_window_bg_color = HCOLOR(bpp, g_htoi("009cb5"));`
	`1078`	`+ globals->ls_bg_color = HCOLOR(bpp, g_htoi("dedede"));`
`1079`	`1079`	`globals->ls_unscaled.width = 350;`
`1080`	`1080`	`globals->ls_unscaled.height = 350;`
`1081`	`1081`	`globals->ls_background_transform = XBLT_NONE;`
`@@ -1214,47 +1214,47 @@ load_xrdp_config(struct xrdp_config config, const char xrdp_ini, int bpp)`
`1214`	`1214`
`1215`	`1215`	`else if (g_strncmp(n, "grey", 64) == 0)`
`1216`	`1216`	`{`
`1217`		`- globals->grey = xrdp_wm_htoi(v);`
	`1217`	`+ globals->grey = g_htoi(v);`
`1218`	`1218`	`}`
`1219`	`1219`
`1220`	`1220`	`else if (g_strncmp(n, "black", 64) == 0)`
`1221`	`1221`	`{`
`1222`		`- globals->black = xrdp_wm_htoi(v);`
	`1222`	`+ globals->black = g_htoi(v);`
`1223`	`1223`	`}`
`1224`	`1224`
`1225`	`1225`	`else if (g_strncmp(n, "dark_grey", 64) == 0)`
`1226`	`1226`	`{`
`1227`		`- globals->dark_grey = xrdp_wm_htoi(v);`
	`1227`	`+ globals->dark_grey = g_htoi(v);`
`1228`	`1228`	`}`
`1229`	`1229`
`1230`	`1230`	`else if (g_strncmp(n, "blue", 64) == 0)`
`1231`	`1231`	`{`
`1232`		`- globals->blue = xrdp_wm_htoi(v);`
	`1232`	`+ globals->blue = g_htoi(v);`
`1233`	`1233`	`}`
`1234`	`1234`
`1235`	`1235`	`else if (g_strncmp(n, "dark_blue", 64) == 0)`
`1236`	`1236`	`{`
`1237`		`- globals->dark_blue = xrdp_wm_htoi(v);`
	`1237`	`+ globals->dark_blue = g_htoi(v);`
`1238`	`1238`	`}`
`1239`	`1239`
`1240`	`1240`	`else if (g_strncmp(n, "white", 64) == 0)`
`1241`	`1241`	`{`
`1242`		`- globals->white = xrdp_wm_htoi(v);`
	`1242`	`+ globals->white = g_htoi(v);`
`1243`	`1243`	`}`
`1244`	`1244`
`1245`	`1245`	`else if (g_strncmp(n, "red", 64) == 0)`
`1246`	`1246`	`{`
`1247`		`- globals->red = xrdp_wm_htoi(v);`
	`1247`	`+ globals->red = g_htoi(v);`
`1248`	`1248`	`}`
`1249`	`1249`
`1250`	`1250`	`else if (g_strncmp(n, "green", 64) == 0)`
`1251`	`1251`	`{`
`1252`		`- globals->green = xrdp_wm_htoi(v);`
	`1252`	`+ globals->green = g_htoi(v);`
`1253`	`1253`	`}`
`1254`	`1254`
`1255`	`1255`	`else if (g_strncmp(n, "background", 64) == 0)`
`1256`	`1256`	`{`
`1257`		`- globals->background = xrdp_wm_htoi(v);`
	`1257`	`+ globals->background = g_htoi(v);`
`1258`	`1258`	`}`
`1259`	`1259`
`1260`	`1260`	`/* misc stuff */`
`@@ -1313,7 +1313,7 @@ load_xrdp_config(struct xrdp_config config, const char xrdp_ini, int bpp)`
`1313`	`1313`
`1314`	`1314`	`else if (g_strncmp(n, "ls_top_window_bg_color", 64) == 0)`
`1315`	`1315`	`{`
`1316`		`- globals->ls_top_window_bg_color = HCOLOR(bpp, xrdp_wm_htoi(v));`
	`1316`	`+ globals->ls_top_window_bg_color = HCOLOR(bpp, g_htoi(v));`
`1317`	`1317`	`}`
`1318`	`1318`
`1319`	`1319`	`else if (g_strncmp(n, "ls_width", 64) == 0)`
`@@ -1328,7 +1328,7 @@ load_xrdp_config(struct xrdp_config config, const char xrdp_ini, int bpp)`
`1328`	`1328`
`1329`	`1329`	`else if (g_strncmp(n, "ls_bg_color", 64) == 0)`
`1330`	`1330`	`{`
`1331`		`- globals->ls_bg_color = HCOLOR(bpp, xrdp_wm_htoi(v));`
	`1331`	`+ globals->ls_bg_color = HCOLOR(bpp, g_htoi(v));`
`1332`	`1332`	`}`
`1333`	`1333`
`1334`	`1334`	`else if (g_strncmp(n, "ls_title", 255) == 0)`
Original file line number	Diff line number	Diff line change
`@@ -442,42 +442,6 @@ xrdp_wm_set_pointer(struct xrdp_wm *self, int cache_idx)`
`442`	`442`	`return libxrdp_set_pointer(self->session, cache_idx);`
`443`	`443`	`}`
`444`	`444`
`445`		`-/*****************************************************************************/`
`446`		`-/* convert hex string to int */`
`447`		`-unsigned int`
`448`		`-xrdp_wm_htoi (const char *ptr)`
`449`		`-{`
`450`		`- unsigned int value = 0;`
`451`		`- char ch = *ptr;`
`452`		`-`
`453`		`- while (ch == ' ' \|\| ch == '\t')`
`454`		`- {`
`455`		`- ch = *(++ptr);`
`456`		`- }`
`457`		`-`
`458`		`- for (;;)`
`459`		`- {`
`460`		`- if (ch >= '0' && ch <= '9')`
`461`		`- {`
`462`		`- value = (value << 4) + (ch - '0');`
`463`		`- }`
`464`		`- else if (ch >= 'A' && ch <= 'F')`
`465`		`- {`
`466`		`- value = (value << 4) + (ch - 'A' + 10);`
`467`		`- }`
`468`		`- else if (ch >= 'a' && ch <= 'f')`
`469`		`- {`
`470`		`- value = (value << 4) + (ch - 'a' + 10);`
`471`		`- }`
`472`		`- else`
`473`		`- {`
`474`		`- return value;`
`475`		`- }`
`476`		`-`
`477`		`- ch = *(++ptr);`
`478`		`- }`
`479`		`-}`
`480`		`-`
`481`	`445`	`/*****************************************************************************/`
`482`	`446`	`int`
`483`	`447`	`xrdp_wm_load_static_colors_plus(struct xrdp_wm self, char autorun_name)`
`@@ -529,47 +493,47 @@ xrdp_wm_load_static_colors_plus(struct xrdp_wm self, char autorun_name)`
`529`	`493`	`if (g_strcasecmp(val, "black") == 0)`
`530`	`494`	`{`
`531`	`495`	`val = (char *)list_get_item(values, index);`
`532`		`- self->black = HCOLOR(self->screen->bpp, xrdp_wm_htoi(val));`
	`496`	`+ self->black = HCOLOR(self->screen->bpp, g_htoi(val));`
`533`	`497`	`}`
`534`	`498`	`else if (g_strcasecmp(val, "grey") == 0)`
`535`	`499`	`{`
`536`	`500`	`val = (char *)list_get_item(values, index);`
`537`		`- self->grey = HCOLOR(self->screen->bpp, xrdp_wm_htoi(val));`
	`501`	`+ self->grey = HCOLOR(self->screen->bpp, g_htoi(val));`
`538`	`502`	`}`
`539`	`503`	`else if (g_strcasecmp(val, "dark_grey") == 0)`
`540`	`504`	`{`
`541`	`505`	`val = (char *)list_get_item(values, index);`
`542`		`- self->dark_grey = HCOLOR(self->screen->bpp, xrdp_wm_htoi(val));`
	`506`	`+ self->dark_grey = HCOLOR(self->screen->bpp, g_htoi(val));`
`543`	`507`	`}`
`544`	`508`	`else if (g_strcasecmp(val, "blue") == 0)`
`545`	`509`	`{`
`546`	`510`	`val = (char *)list_get_item(values, index);`
`547`		`- self->blue = HCOLOR(self->screen->bpp, xrdp_wm_htoi(val));`
	`511`	`+ self->blue = HCOLOR(self->screen->bpp, g_htoi(val));`
`548`	`512`	`}`
`549`	`513`	`else if (g_strcasecmp(val, "dark_blue") == 0)`
`550`	`514`	`{`
`551`	`515`	`val = (char *)list_get_item(values, index);`
`552`		`- self->dark_blue = HCOLOR(self->screen->bpp, xrdp_wm_htoi(val));`
	`516`	`+ self->dark_blue = HCOLOR(self->screen->bpp, g_htoi(val));`
`553`	`517`	`}`
`554`	`518`	`else if (g_strcasecmp(val, "white") == 0)`
`555`	`519`	`{`
`556`	`520`	`val = (char *)list_get_item(values, index);`
`557`		`- self->white = HCOLOR(self->screen->bpp, xrdp_wm_htoi(val));`
	`521`	`+ self->white = HCOLOR(self->screen->bpp, g_htoi(val));`
`558`	`522`	`}`
`559`	`523`	`else if (g_strcasecmp(val, "red") == 0)`
`560`	`524`	`{`
`561`	`525`	`val = (char *)list_get_item(values, index);`
`562`		`- self->red = HCOLOR(self->screen->bpp, xrdp_wm_htoi(val));`
	`526`	`+ self->red = HCOLOR(self->screen->bpp, g_htoi(val));`
`563`	`527`	`}`
`564`	`528`	`else if (g_strcasecmp(val, "green") == 0)`
`565`	`529`	`{`
`566`	`530`	`val = (char *)list_get_item(values, index);`
`567`		`- self->green = HCOLOR(self->screen->bpp, xrdp_wm_htoi(val));`
	`531`	`+ self->green = HCOLOR(self->screen->bpp, g_htoi(val));`
`568`	`532`	`}`
`569`	`533`	`else if (g_strcasecmp(val, "background") == 0)`
`570`	`534`	`{`
`571`	`535`	`val = (char *)list_get_item(values, index);`
`572`		`- self->background = HCOLOR(self->screen->bpp, xrdp_wm_htoi(val));`
	`536`	`+ self->background = HCOLOR(self->screen->bpp, g_htoi(val));`
`573`	`537`	`}`
`574`	`538`	`else if (g_strcasecmp(val, "autorun") == 0)`
`575`	`539`	`{`