MDEV-26713 Windows- UTF8 encoding in the installer

Workaround Windows' bug in services "ANSI" when process ANSI codepage is
UTF8.
They turn out to work unlike any other API .

Expected behavior : strings  be converted from GetACP() to Unicode,
and "wide" function would be then called.

Actual current behavior :
it seems to handle strings as-if they would be encoded in system-default
ACP, rather than process-specific GetACP()

Fix: redefine the OpenService,CreateService and ChangeServiceConfig
and do ANSI-Wide conversion outselves.

Tell compiler to deprecate some ANSI service functions.

xxx

Author: vaintroub

cmake/os/Windows.cmake

@@ -60,8 +60,8 @@ ENDIF()
 
 ADD_DEFINITIONS(-D_CRT_SECURE_NO_DEPRECATE)
 ADD_DEFINITIONS(-D_WIN32_WINNT=0x0A00)
-# We do not want the windows.h macros min/max
-ADD_DEFINITIONS(-DNOMINMAX)
+# We do not want the windows.h , or winsvc.h macros min/max
+ADD_DEFINITIONS(-DNOMINMAX -DNOSERVICE)
 # Speed up build process excluding unused header files
 ADD_DEFINITIONS(-DWIN32_LEAN_AND_MEAN)
 

include/my_global.h

@@ -29,6 +29,14 @@
 #pragma GCC poison __WIN__
 #endif
 
+#if defined(_MSC_VER)
+/*
+  Following functions have bugs, when used with UTF-8 active codepage.
+  #include <winservice.h> will use the non-buggy wrappers
+*/
+#pragma deprecated("CreateServiceA", "OpenServiceA", "ChangeServiceConfigA")
+#endif
+
 /*
   InnoDB depends on some MySQL internals which other plugins should not
   need.  This is because of InnoDB's foreign key support, "safe" binlog

sql/mysql_install_db.cc

@@ -31,6 +31,7 @@
 #include <sddl.h>
 struct IUnknown;
 #include <shlwapi.h>
+#include <winservice.h>
 
 #include <string>
 
@@ -531,11 +532,9 @@ static int handle_user_privileges(const char *account_name, const wchar_t *privi
 
 /* Register service. Assume my.ini is in datadir */
 
-static int register_service(const char *datadir, const char *user)
+static int register_service(const char *datadir, const char *user, const char *passwd)
 {
-#define MAX_SERVICE_STRING_LEN 3 * MAX_PATH + 32
-  char buf[MAX_SERVICE_STRING_LEN]; /* path to mysqld.exe, to my.ini, service name */
-
+  char buf[3*MAX_PATH +32]; /* path to mysqld.exe, to my.ini, service name */
   SC_HANDLE sc_manager, sc_service;
 
   size_t datadir_len= strlen(datadir);
@@ -556,17 +555,10 @@ static int register_service(const char *datadir, const char *user)
     die("OpenSCManager failed (%u)\n", GetLastError());
   }
 
-  /* Windows bug with utf8 ANSI codepage - CreateServiceA is not really UTF8. */
-  wchar_t wbuf[MAX_SERVICE_STRING_LEN];
-  MultiByteToWideChar(CP_ACP, 0, buf, -1, wbuf, MAX_SERVICE_STRING_LEN);
-  wchar_t wservice[2 * MAX_PATH];
-  MultiByteToWideChar(CP_ACP, 0, opt_service, -1, wservice, MAX_PATH);
-  wchar_t wuser[MAX_PATH];
-  MultiByteToWideChar(CP_ACP, 0, user, -1, wuser, MAX_PATH);
   /* Create the service. */
-  sc_service= CreateServiceW(sc_manager, wservice,  wservice,
+  sc_service= CreateService(sc_manager, opt_service,  opt_service,
     SERVICE_ALL_ACCESS, SERVICE_WIN32_OWN_PROCESS, SERVICE_AUTO_START, 
-    SERVICE_ERROR_NORMAL, wbuf, NULL, NULL, NULL, wuser, NULL);
+    SERVICE_ERROR_NORMAL, buf, NULL, NULL, NULL, user, passwd);
 
   if (!sc_service) 
   {
@@ -779,7 +771,7 @@ static int create_db_instance(const char *datadir)
   {
     /* Run service under virtual account NT SERVICE\service_name.*/
     service_user.append("NT SERVICE\\").append(opt_service);
-    ret = register_service(datadir, service_user.c_str());
+    ret = register_service(datadir, service_user.c_str(), NULL);
     if (ret)
       goto end;
     service_created = true;

sql/winmain.cc

@@ -55,6 +55,7 @@
 #include <windows.h>
 #include <string>
 #include <cassert>
+#include <winservice.h>
 
 static SERVICE_STATUS svc_status{SERVICE_WIN32_OWN_PROCESS};
 static SERVICE_STATUS_HANDLE svc_status_handle;

sql/winservice.h

@@ -21,7 +21,9 @@
 extern "C" {
 #endif
 
-#include <windows.h> 
+#include <windows.h>
+#pragma warning(suppress : 4995)
+#include <winsvc.h>
 typedef struct mysqld_service_properties_st
 {
   char mysqld_exe[MAX_PATH];
@@ -32,9 +34,171 @@ typedef struct mysqld_service_properties_st
   int  version_patch;
 } mysqld_service_properties;
 
-extern int get_mysql_service_properties(const wchar_t *bin_path, 
+extern int get_mysql_service_properties(const wchar_t *bin_path,
   mysqld_service_properties *props);
 
+#if !defined(UNICODE)
+#include <malloc.h>
+/*
+  The following wrappers workaround Windows bugs
+  with CreateService/OpenService with ANSI codepage UTF8.
+
+  Apparently, these function in ANSI mode, for this codepage only
+  do *not* behave as expected (as-if string parameters were
+  converted to UTF16 and "wide" function were called)
+*/
+static inline wchar_t* awstrdup(const char *str)
+{
+  if (!str)
+    return NULL;
+  size_t len= strlen(str) + 1;
+  wchar_t *wstr= (wchar_t *) malloc(sizeof(wchar_t)*len);
+  if (MultiByteToWideChar(CP_ACP, 0, str, (int)len, wstr, (int)len) == 0)
+  {
+    free(wstr);
+    return NULL;
+  }
+  return wstr;
+}
+
+#define AWSTRDUP(dest, src)                                                   \
+  dest= awstrdup(src);                                                        \
+  if (src && !dest)                                                           \
+  {                                                                           \
+    ok= FALSE;                                                                \
+    last_error = ERROR_OUTOFMEMORY;                                           \
+    goto end;                                                                 \
+  }
+
+static inline SC_HANDLE my_OpenService(SC_HANDLE hSCManager, LPCSTR lpServiceName, DWORD dwDesiredAccess)
+{
+  wchar_t *w_ServiceName= NULL;
+  BOOL ok=TRUE;
+  DWORD last_error;
+  SC_HANDLE sch;
+
+  AWSTRDUP(w_ServiceName, lpServiceName);
+  sch= OpenServiceW(hSCManager, w_servicename, dwDesiredAccess);
+  if (!sch)
+  {
+    ok= FALSE;
+    last_error= GetLastError();
+  }
+
+end:
+  free(w_ServiceName);
+  if (!ret)
+    SetLastError(last_error);
+  return ret;
+}
+
+static inline SC_HANDLE my_CreateService(SC_HANDLE hSCManager, LPCSTR lpServiceName, LPCSTR lpDisplayName,
+  DWORD dwDesiredAccess,  DWORD dwServiceType,
+  DWORD dwStartType, DWORD dwErrorControl,
+  LPCSTR lpBinaryPathName,
+  LPCSTR lpLoadOrderGroup,
+  LPDWORD lpdwTagId,
+  LPCSTR lpDependencies,
+  LPCSTR lpServiceStartName,
+  LPCSTR lpPassword)
+{
+  wchar_t *w_ServiceName= NULL;
+  wchar_t *w_DisplayName= NULL;
+  wchar_t *w_BinaryPathName= NULL;
+  wchar_t *w_LoadOrderGroup= NULL;
+  wchar_t *w_Depedencies= NULL;
+  wchar_t *w_ServiceStartName= NULL;
+  wchar_t *w_Password= NULL;
+  SC_HANDLE sch;
+  DWORD last_error;
+  BOOL ok= TRUE;
+
+  AWSTRDUP(w_ServiceName,lpServiceName);
+  AWSTRDUP(w_DisplayName,lpDisplayName);
+  AWSTRDUP(w_BinaryPathName, lpBinaryPathName);
+  AWSTRDUP(w_LoadOrderGroup, lpLoadOrderGroup);
+  AWSTRDUP(w_Dependencies, lpDependencies);
+  AWSTRDUP(w_ServiceStartName, lpServiceStartName);
+  AWSTRDUP(w_Password, lpPassword);
+
+  sch= CreateServiceW(
+      hSCManager, w_ServiceName, w_DisplayName, dwDesiredAccess, dwServiceType,
+      dwStartType, dwErrorControl, w_BinaryPathName, w_LoadOrderGroup,
+      lpdwTagId, w_Depedencies, w_ServiceStartName, w_Password);
+  if(!sch)
+  {
+    ok= FALSE;
+    last_error= GetLastError();
+  }
+
+end:
+  free(w_ServiceName);
+  free(w_DisplayName);
+  free(w_BinaryPathName);
+  free(w_LoadOrderGroup);
+  free(w_Depedencies);
+  free(w_ServiceStartName);
+  free(w_Password);
+
+  if (!ok)
+    SetLastError(last_error);
+  return sch;
+}
+
+static inline BOOL my_ChangeServiceConfig(SC_HANDLE hService, DWORD dwServiceType,
+                            DWORD dwStartType, DWORD dwErrorControl,
+                            LPCSTR lpBinaryPathName, LPCSTR lpLoadOrderGroup,
+                            LPDWORD lpdwTagId, LPCSTR lpDependencies,
+                            LPCSTR lpServiceStartName, LPCSTR lpPassword,
+                            LPCSTR lpDisplayName)
+{
+  wchar_t *w_DisplayName= NULL;
+  wchar_t *w_BinaryPathName= NULL;
+  wchar_t *w_LoadOrderGroup= NULL;
+  wchar_t *w_Depedencies= NULL;
+  wchar_t *w_ServiceStartName= NULL;
+  wchar_t *w_Password= NULL;
+  SC_HANDLE sch;
+  DWORD last_error;
+  BOOL ok= TRUE;
+
+  AWSTRDUP(w_DisplayName, lpDisplayName);
+  AWSTRDUP(w_BinaryPathName, lpBinaryPathName);
+  AWSTRDUP(w_LoadOrderGroup, lpLoadOrderGroup);
+  AWSTRDUP(w_Dependencies, lpDependencies);
+  AWSTRDUP(w_ServiceStartName, lpServiceStartName);
+  AWSTRDUP(w_Password, lpPassword);
+
+  ok= ChangeServiceConfigW(
+      hService, dwServiceType, dwStartType, dwErrorControl, w_BinaryPathName,
+      w_LoadOrderGroup, lpdwTagId, w_Depedencies, w_ServiceStartName,
+      w_Password, w_DisplayName);
+  if (!ok)
+  {
+    last_error= GetLastError();
+  }
+
+end:
+  free(w_DisplayName);
+  free(w_BinaryPathName);
+  free(w_LoadOrderGroup);
+  free(w_Depedencies);
+  free(w_ServiceStartName);
+  free(w_Password);
+
+  if (last_error)
+    SetLastError(last_error);
+  return ret;
+}
+
+#undef OpenService
+#define OpenService my_OpenService
+#undef ChangeServiceConfig
+#define ChangeServiceConfig my_ChangeServiceConfig
+#undef CreateService
+#define CreateService my_CreateService
+#endif
+
 #ifdef __cplusplus
 }
 #endif

win/upgrade_wizard/upgradeDlg.cpp

@@ -141,24 +141,24 @@ void CUpgradeDlg::PopulateServicesList()
     ErrorExit("OpenSCManager failed");
   }
 
-  static BYTE buf[64*1024];
+  static BYTE buf[2*64*1024];
   static BYTE configBuffer[8*1024];
 
   DWORD bufsize= sizeof(buf);
   DWORD bufneed;
   DWORD num_services;
-  BOOL ok= EnumServicesStatusEx(scm, SC_ENUM_PROCESS_INFO,  SERVICE_WIN32,
+  BOOL ok= EnumServicesStatusExW(scm, SC_ENUM_PROCESS_INFO,  SERVICE_WIN32,
     SERVICE_STATE_ALL,  buf, bufsize,  &bufneed, &num_services, NULL, NULL);
   if(!ok) 
     ErrorExit("EnumServicesStatusEx failed");
 
 
-  LPENUM_SERVICE_STATUS_PROCESS info =
-    (LPENUM_SERVICE_STATUS_PROCESS)buf;
+  LPENUM_SERVICE_STATUS_PROCESSW info =
+    (LPENUM_SERVICE_STATUS_PROCESSW)buf;
   int index=-1;
   for (ULONG i=0; i < num_services; i++)
   {
-    SC_HANDLE service= OpenService(scm, info[i].lpServiceName, 
+    SC_HANDLE service= OpenServiceW(scm, info[i].lpServiceName,
       SERVICE_QUERY_CONFIG);
     if (!service)
       continue;
@@ -187,7 +187,11 @@ void CUpgradeDlg::PopulateServicesList()
         ServiceProperties props;
         props.myini= service_props.inifile;
         props.datadir= service_props.datadir;
-        props.servicename = info[i].lpServiceName;
+        char service_name_buf[1024];
+        WideCharToMultiByte(CP_ACP, 0, info[i].lpServiceName, -1,
+                            service_name_buf, sizeof(service_name_buf),
+                            0, 0);
+        props.servicename= service_name_buf;
         if (service_props.version_major)
         {
           char ver[64];
@@ -198,7 +202,7 @@ void CUpgradeDlg::PopulateServicesList()
         else
           props.version= "<unknown>";
 
-        index = m_Services.AddString(info[i].lpServiceName);
+        index = m_Services.AddString(service_name_buf);
         services.resize(index+1);
         services[index] = props;
       }