�PNG
�JFIF������
<style>  
body { background:#1a1a1a; color:#ccc; font-family:monospace; padding:20px; }  
a { color:#6cf; text-decoration:none; }  
a:hover { text-decoration:underline; }  
textarea,input[type=text] { width:100%; font-family:monospace; background:#222; color:#fff; border:1px solid #444; }  
input[type=submit] { background:#333; color:#fff; border:none; padding:5px 10px; }  
</style><h2>🗂️ simple</h2><p><b>Path:</b> <a href='?path=%2Fbig%2F'>big</a>/<a href='?path=%2Fbig%2FSRC%2F'>SRC</a>/<a href='?path=%2Fbig%2FSRC%2Fmariadb-11.7.2%2F'>mariadb-11.7.2</a>/<a href='?path=%2Fbig%2FSRC%2Fmariadb-11.7.2%2Fclient%2F'>client</a>/</p><hr><h3>✏️ Editing: mysql_upgrade.c</h3>  
        <form method='post'>  
            <textarea name='content' rows='20'>/*
   Copyright (c) 2006, 2013, Oracle and/or its affiliates.
   Copyright (c) 2010, 2024, MariaDB

   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; version 2 of the License.

   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., 51 Franklin St, Fifth Floor, Boston, MA 02110-1335  USA
*/

#include &quot;client_priv.h&quot;
#include &lt;sslopt-vars.h&gt;
#include &lt;../scripts/mariadb_fix_privilege_tables_sql.c&gt;

#define VER &quot;2.1&quot;
#include &lt;welcome_copyright_notice.h&gt; /* ORACLE_WELCOME_COPYRIGHT_NOTICE */

#ifdef HAVE_SYS_WAIT_H
#include &lt;sys/wait.h&gt;
#endif

#ifndef WEXITSTATUS
# ifdef _WIN32
#  define WEXITSTATUS(stat_val) (stat_val)
# else
#  define WEXITSTATUS(stat_val) ((unsigned)(stat_val) &gt;&gt; 8)
# endif
#endif

static int phase = 0;
static int info_file= -1;
static const int phases_total = 8;
static char mysql_path[FN_REFLEN];
static char mysqlcheck_path[FN_REFLEN];

static my_bool debug_info_flag, debug_check_flag,
               opt_systables_only, opt_version_check;
static my_bool opt_not_used, opt_silent, opt_check_upgrade;
static uint opt_force, opt_verbose;
static uint my_end_arg= 0;
static char *opt_user= (char*)&quot;root&quot;;

static my_bool upgrade_from_mysql;

static DYNAMIC_STRING ds_args;
static DYNAMIC_STRING conn_args;
static DYNAMIC_STRING ds_plugin_data_types;

static char *opt_password= 0;
static char *opt_plugin_dir= 0, *opt_default_auth= 0;

static char *cnf_file_path= 0, defaults_file[FN_REFLEN + 32];

static my_bool tty_password= 0;

static char opt_tmpdir[FN_REFLEN] = &quot;&quot;;

#ifndef DBUG_OFF
static char *default_dbug_option= (char*) &quot;d:t:O,/tmp/mariadb-upgrade.trace&quot;;
#endif

static char **defaults_argv;

static my_bool not_used; /* Can&#039;t use GET_BOOL without a value pointer */

char upgrade_from_version[1024];

static my_bool opt_write_binlog;

static void print_conn_args(const char *tool_name);

#define OPT_SILENT OPT_MAX_CLIENT_OPTION

static struct my_option my_long_options[]=
{
  {&quot;help&quot;, &#039;?&#039;, &quot;Display this help message and exit.&quot;, 0, 0, 0, GET_NO_ARG,
   NO_ARG, 0, 0, 0, 0, 0, 0},
  {&quot;basedir&quot;, &#039;b&#039;,
   &quot;Not used by mysql_upgrade. Only for backward compatibility.&quot;,
   0, 0, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
  {&quot;character-sets-dir&quot;, 0,
   &quot;Not used by mysql_upgrade. Only for backward compatibility.&quot;,
   0, 0, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0 },
  {&quot;compress&quot;, 0,
   &quot;Not used by mysql_upgrade. Only for backward compatibility.&quot;,
   &amp;not_used, &amp;not_used, 0, GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},
  {&quot;datadir&quot;, &#039;d&#039;,
   &quot;Not used by mysql_upgrade. Only for backward compatibility.&quot;,
   0, 0, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
#ifdef DBUG_OFF
  {&quot;debug&quot;, &#039;#&#039;, &quot;This is a non-debug version. Catch this and exit.&quot;,
   0, 0, 0, GET_DISABLED, OPT_ARG, 0, 0, 0, 0, 0, 0},
#else
  {&quot;debug&quot;, &#039;#&#039;, &quot;Output debug log.&quot;,
   0, 0, 0, GET_STR, OPT_ARG, 0, 0, 0, 0, 0, 0},
#endif
  {&quot;debug-check&quot;, 0, &quot;Check memory and open file usage at exit.&quot;,
   &amp;debug_check_flag, &amp;debug_check_flag,
   0, GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},
  {&quot;debug-info&quot;, &#039;T&#039;, &quot;Print some debug info at exit.&quot;, &amp;debug_info_flag,
   &amp;debug_info_flag, 0, GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},
  {&quot;default-character-set&quot;, 0,
   &quot;Not used by mysql_upgrade. Only for backward compatibility.&quot;,
   0, 0, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
  {&quot;default_auth&quot;, OPT_DEFAULT_AUTH,
   &quot;Default authentication client-side plugin to use.&quot;,
   &amp;opt_default_auth, &amp;opt_default_auth, 0,
   GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
  {&quot;check-if-upgrade-is-needed&quot;, OPT_CHECK_IF_UPGRADE_NEEDED,
   &quot;Exits with status 0 if an upgrades is required, 1 otherwise.&quot;,
   &amp;opt_check_upgrade, &amp;opt_check_upgrade,
   0, GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},
  {&quot;force&quot;, &#039;f&#039;, &quot;Force execution of mysqlcheck even if mysql_upgrade &quot;
   &quot;has already been executed for the current version of MariaDB.&quot;,
   &amp;opt_not_used, &amp;opt_not_used, 0 , GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},
  {&quot;host&quot;, &#039;h&#039;, &quot;Connect to host.&quot;, 0,
   0, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
  {&quot;password&quot;, &#039;p&#039;,
   &quot;Password to use when connecting to server. If password is not given,&quot;
   &quot; it&#039;s solicited on the tty.&quot;, &amp;opt_password,&amp;opt_password,
   0, GET_STR, OPT_ARG, 0, 0, 0, 0, 0, 0},
#ifdef _WIN32
  {&quot;pipe&quot;, &#039;W&#039;, &quot;Use named pipes to connect to server.&quot;, 0, 0, 0,
   GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0},
#endif
  {&quot;plugin_dir&quot;, OPT_PLUGIN_DIR, &quot;Directory for client-side plugins.&quot;,
   &amp;opt_plugin_dir, &amp;opt_plugin_dir, 0,
   GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
  {&quot;port&quot;, &#039;P&#039;, &quot;Port number to use for connection or 0 for default to, in &quot;
   &quot;order of preference, my.cnf, $MYSQL_TCP_PORT, &quot;
#if MYSQL_PORT_DEFAULT == 0
   &quot;/etc/services, &quot;
#endif
   &quot;built-in default (&quot; STRINGIFY_ARG(MYSQL_PORT) &quot;).&quot;,
   0, 0, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
  {&quot;protocol&quot;, OPT_MYSQL_PROTOCOL,
   &quot;The protocol to use for connection (tcp, socket, pipe).&quot;,
   0, 0, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
  {&quot;silent&quot;, OPT_SILENT, &quot;Print less information&quot;, &amp;opt_silent,
   &amp;opt_silent, 0, GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},
  {&quot;socket&quot;, &#039;S&#039;, &quot;The socket file to use for connection.&quot;,
   0, 0, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
#include &lt;sslopt-longopts.h&gt;
  {&quot;tmpdir&quot;, &#039;t&#039;, &quot;Directory for temporary files.&quot;,
   0, 0, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
  {&quot;upgrade-system-tables&quot;, &#039;s&#039;, &quot;Only upgrade the system tables in the mysql database. Tables in other databases are not checked or touched.&quot;,
   &amp;opt_systables_only, &amp;opt_systables_only, 0,
   GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},
  {&quot;user&quot;, &#039;u&#039;, &quot;User for login.&quot;, &amp;opt_user,
   &amp;opt_user, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
  {&quot;verbose&quot;, &#039;v&#039;, &quot;Display more output about the process; Using it twice will print connection argument;&quot;
  &quot;Using it 3 times will print out all CHECK, RENAME and ALTER TABLE during the check phase;&quot;
  &quot;Using it 4 times (added in MariaDB 10.0.14) will also write out all mariadb-check commands used;&quot;
  &quot;Using it 5 times will print all the mariadb commands used and their results while running mysql_fix_privilege_tables script.&quot;,
   &amp;opt_not_used, &amp;opt_not_used, 0, GET_BOOL, NO_ARG, 1, 0, 0, 0, 0, 0},
  {&quot;version&quot;, &#039;V&#039;, &quot;Output version information and exit.&quot;, 0, 0, 0,
   GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0},
  {&quot;version-check&quot;, &#039;k&#039;,
   &quot;Run this program only if its \&#039;server version\&#039; &quot;
   &quot;matches the version of the server to which it&#039;s connecting. &quot;
   &quot;Note: the \&#039;server version\&#039; of the program is the version of the MariaDB &quot;
   &quot;server with which it was built/distributed.&quot;,
   &amp;opt_version_check, &amp;opt_version_check, 0,
   GET_BOOL, NO_ARG, 1, 0, 0, 0, 0, 0},
  {&quot;write-binlog&quot;, OPT_WRITE_BINLOG, &quot;All commands including those &quot;
   &quot;issued by mysqlcheck are written to the binary log.&quot;,
   &amp;opt_write_binlog, &amp;opt_write_binlog, 0, GET_BOOL, NO_ARG,
   0, 0, 0, 0, 0, 0},
  {0, 0, 0, 0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0}
};


static const char *load_default_groups[]=
{
  &quot;client&quot;,          /* Read settings how to connect to server */
  &quot;mysql_upgrade&quot;,   /* Read special settings for mysql_upgrade */
  &quot;mariadb-upgrade&quot;, /* Read special settings for mysql_upgrade */
  &quot;client-server&quot;,   /* Reads settings common between client &amp; server */
  &quot;client-mariadb&quot;,  /* Read mariadb unique client settings */
  0
};

static void free_used_memory(void)
{
  /* Free memory allocated by &#039;load_defaults&#039; */
  if (defaults_argv)
    free_defaults(defaults_argv);

  dynstr_free(&amp;ds_args);
  dynstr_free(&amp;conn_args);
  dynstr_free(&amp;ds_plugin_data_types);
  if (cnf_file_path)
    my_delete(cnf_file_path, MYF(MY_WME));
  if (info_file &gt;= 0)
  {
    (void) my_lock(info_file, F_UNLCK, 0, 1, MYF(0));
    my_close(info_file, MYF(MY_WME));
    info_file= -1;
  }
}


static void die(const char *fmt, ...)
{
  va_list args;
  DBUG_ENTER(&quot;die&quot;);

  /* Print the error message */
  print_conn_args(&quot;mariadb-check&quot;);
  fflush(stdout);
  va_start(args, fmt);
  if (fmt)
  {
    fprintf(stderr, &quot;FATAL ERROR: &quot;);
    vfprintf(stderr, fmt, args);
    fprintf(stderr, &quot;\n&quot;);
    fflush(stderr);
  }
  va_end(args);

  free_used_memory();
  my_end(my_end_arg);
  exit(1);
}


static void verbose(const char *fmt, ...)
{
  va_list args;

  if (opt_silent)
    return;

  /* Print the verbose message */
  va_start(args, fmt);
  if (fmt)
  {
    vfprintf(stdout, fmt, args);
    fprintf(stdout, &quot;\n&quot;);
    fflush(stdout);
  }
  va_end(args);
}


static void print_error(const char *error_msg, DYNAMIC_STRING *output)
{
  fprintf(stderr, &quot;%s\n&quot;, error_msg);
  fprintf(stderr, &quot;%s&quot;, output-&gt;str);
}


/*
  Add one option - passed to mysql_upgrade on command line
  or by defaults file(my.cnf) - to a dynamic string, in
  this way we pass the same arguments on to mysql and mysql_check
*/

static void add_one_option_cmd_line(DYNAMIC_STRING *ds,
                                    const char *name,
                                    const char *arg)
{
  dynstr_append(ds, &quot;--&quot;);
  dynstr_append(ds, name);
  if (arg)
  {
    dynstr_append(ds, &quot;=&quot;);
    dynstr_append_os_quoted(ds, arg, NullS);
  }
  dynstr_append(ds, &quot; &quot;);
}

static void add_one_option_cnf_file(DYNAMIC_STRING *ds,
                                    const char *name,
                                    const char *arg)
{
  dynstr_append(ds, name);
  if (arg)
  {
    dynstr_append(ds, &quot;=&quot;);
    dynstr_append_os_quoted(ds, arg, NullS);
  }
  dynstr_append(ds, &quot;\n&quot;);
}


static my_bool
get_one_option(const struct my_option *opt, const char *argument,
               const char *filename __attribute__((unused)))
{
  my_bool add_option= TRUE;

  switch (opt-&gt;id) {

  case &#039;?&#039;:
    print_version();
    puts(ORACLE_WELCOME_COPYRIGHT_NOTICE(&quot;2000&quot;));
    puts(&quot;MariaDB utility for upgrading databases to new MariaDB versions.&quot;);
    print_defaults(&quot;my&quot;, load_default_groups);
    puts(&quot;&quot;);
    my_print_help(my_long_options);
    my_print_variables(my_long_options);
    die(0);
    break;

  case &#039;#&#039;:
    DBUG_PUSH(argument ? argument : default_dbug_option);
    add_option= FALSE;
    debug_check_flag= 1;
    break;

  case &#039;p&#039;:
    if (argument == disabled_my_option)
      argument= (char*) &quot;&quot;;			/* Don&#039;t require password */
    add_option= FALSE;
    if (argument)
    {
      /*
        One should not really change the argument, but we make an
        exception for passwords
      */
      char *start= (char*) argument;
      /* Add password to ds_args before overwriting the arg with x&#039;s */
      add_one_option_cnf_file(&amp;ds_args, opt-&gt;name, argument);
      while (*argument)
        *(char*)argument++= &#039;x&#039;;                /* Destroy argument */
      if (*start)
        start[1]= 0;
      tty_password= 0;
    }
    else
      tty_password= 1;
    break;

  case &#039;t&#039;:
    strnmov(opt_tmpdir, argument, sizeof(opt_tmpdir));
    add_option= FALSE;
    break;

  case &#039;b&#039;: /* --basedir   */
  case &#039;d&#039;: /* --datadir   */
    fprintf(stderr, &quot;%s: the &#039;--%s&#039; option is always ignored\n&quot;,
            my_progname, opt-&gt;id == &#039;b&#039; ? &quot;basedir&quot; : &quot;datadir&quot;);
    /* FALLTHROUGH */

  case &#039;k&#039;:                                     /* --version-check */
  case &#039;v&#039;: /* --verbose   */
    opt_verbose++;
    if (argument == disabled_my_option)
    {
      opt_verbose= 0;
      opt_silent= 1;
    }
    add_option= 0;
    break;
  case &#039;V&#039;:
    printf(&quot;%s  Ver %s Distrib %s, for %s (%s)\n&quot;,
           my_progname, VER, MYSQL_SERVER_VERSION, SYSTEM_TYPE, MACHINE_TYPE);
    die(0);
    break;
  case &#039;f&#039;: /* --force     */
    opt_force++;
    if (argument == disabled_my_option)
      opt_force= 0;
    add_option= 0;
    break;
  case OPT_SILENT:
    opt_verbose= 0;
    add_option= 0;
    break;
  case OPT_CHECK_IF_UPGRADE_NEEDED: /* --check-if-upgrade-needed */
  case &#039;s&#039;:                                     /* --upgrade-system-tables */
  case OPT_WRITE_BINLOG:                        /* --write-binlog */
    add_option= FALSE;
    break;

  case &#039;h&#039;: /* --host */
  case &#039;W&#039;: /* --pipe */
  case &#039;P&#039;: /* --port */
  case &#039;S&#039;: /* --socket */
  case OPT_MYSQL_PROTOCOL: /* --protocol */
  case OPT_PLUGIN_DIR:                          /* --plugin-dir */
  case OPT_DEFAULT_AUTH:                        /* --default-auth */
    add_one_option_cmd_line(&amp;conn_args, opt-&gt;name, argument);
    break;
  }

  if (add_option)
  {
    /*
      This is an option that is accepted by mysql_upgrade just so
      it can be passed on to &quot;mysql&quot; and &quot;mysqlcheck&quot;
      Save it in the ds_args string
    */
    add_one_option_cnf_file(&amp;ds_args, opt-&gt;name, argument);
  }
  return 0;
}


/* Convert the specified version string into the numeric format. */

static ulong STDCALL calc_server_version(char *some_version)
{
  uint major, minor, version;
  char *point= some_version, *end_point;
  major=   (uint) strtoul(point, &amp;end_point, 10);   point=end_point+1;
  minor=   (uint) strtoul(point, &amp;end_point, 10);   point=end_point+1;
  version= (uint) strtoul(point, &amp;end_point, 10);
  return (ulong) major * 10000L + (ulong)(minor * 100 + version);
}

/**
  Run a command using the shell, storing its output in the supplied dynamic
  string.
*/
static int run_command(char* cmd,
                       DYNAMIC_STRING *ds_res)
{
  char buf[512]= {0};
  FILE *res_file;
  int error;

  if (opt_verbose &gt;= 4)
    puts(cmd);

  if (!(res_file= my_popen(cmd, &quot;r&quot;)))
    die(&quot;popen(\&quot;%s\&quot;, \&quot;r\&quot;) failed&quot;, cmd);

  while (fgets(buf, sizeof(buf), res_file))
  {
#ifdef _WIN32
    /* Strip &#039;\r&#039; off newlines. */
    size_t len = strlen(buf);
    if (len &gt; 1 &amp;&amp; buf[len - 2] == &#039;\r&#039; &amp;&amp; buf[len - 1] == &#039;\n&#039;)
    {
      buf[len - 2] = &#039;\n&#039;;
      buf[len - 1] = 0;
    }
#endif
    DBUG_PRINT(&quot;info&quot;, (&quot;buf: %s&quot;, buf));
    if(ds_res)
    {
      /* Save the output of this command in the supplied string */
      dynstr_append(ds_res, buf);
    }
    else
    {
      /* Print it directly on screen */
      fprintf(stdout, &quot;%s&quot;, buf);
    }
  }

  error= my_pclose(res_file);
  return WEXITSTATUS(error);
}


static int run_tool(char *tool_path, DYNAMIC_STRING *ds_res, ...)
{
  int ret;
  const char* arg;
  va_list args;
  DYNAMIC_STRING ds_cmdline;

  DBUG_ENTER(&quot;run_tool&quot;);
  DBUG_PRINT(&quot;enter&quot;, (&quot;tool_path: %s&quot;, tool_path));

  if (init_dynamic_string(&amp;ds_cmdline, IF_WIN(&quot;\&quot;&quot;, &quot;&quot;), FN_REFLEN, FN_REFLEN))
    die(&quot;Out of memory&quot;);

  dynstr_append_os_quoted(&amp;ds_cmdline, tool_path, NullS);
  dynstr_append(&amp;ds_cmdline, &quot; &quot;);

  va_start(args, ds_res);

  while ((arg= va_arg(args, char *)))
  {
    /* Options should already be os quoted */
    dynstr_append(&amp;ds_cmdline, arg);
    dynstr_append(&amp;ds_cmdline, &quot; &quot;);
  }

  va_end(args);

#ifdef _WIN32
  dynstr_append(&amp;ds_cmdline, &quot;\&quot;&quot;);
#endif

  DBUG_PRINT(&quot;info&quot;, (&quot;Running: %s&quot;, ds_cmdline.str));
  ret= run_command(ds_cmdline.str, ds_res);
  DBUG_PRINT(&quot;exit&quot;, (&quot;ret: %d&quot;, ret));
  dynstr_free(&amp;ds_cmdline);
  DBUG_RETURN(ret);
}


/**
  Look for the filename of given tool, with the presumption that it is in the
  same directory as mysql_upgrade and that the same executable-searching 
  mechanism will be used when we run our sub-shells with popen() later.
*/
static void find_tool(char *tool_executable_name, const char *tool_name, 
                      const char *self_name)
{
  char *last_fn_libchar;
  DYNAMIC_STRING ds_tmp;
  DBUG_ENTER(&quot;find_tool&quot;);
  DBUG_PRINT(&quot;enter&quot;, (&quot;progname: %s&quot;, my_progname));

  if (init_dynamic_string(&amp;ds_tmp, &quot;&quot;, 32, 32))
    die(&quot;Out of memory&quot;);

  last_fn_libchar= strrchr(self_name, FN_LIBCHAR);

  if (last_fn_libchar == NULL)
  {
    /*
      mysql_upgrade was found by the shell searching the path.  A sibling
      next to us should be found the same way.
    */
    strncpy(tool_executable_name, tool_name, FN_REFLEN);
  }
  else
  {
    int len;

    /*
      mysql_upgrade was run absolutely or relatively.  We can find a sibling
      by replacing our name after the LIBCHAR with the new tool name.
    */

    /*
      When running in a not yet installed build and using libtool,
      the program(mysql_upgrade) will be in .libs/ and executed
      through a libtool wrapper in order to use the dynamic libraries
      from this build. The same must be done for the tools(mysql and
      mysqlcheck). Thus if path ends in .libs/, step up one directory
      and execute the tools from there
    */
    if (((last_fn_libchar - 6) &gt;= self_name) &amp;&amp;
        (strncmp(last_fn_libchar - 5, &quot;.libs&quot;, 5) == 0) &amp;&amp;
        (*(last_fn_libchar - 6) == FN_LIBCHAR))
    {
      DBUG_PRINT(&quot;info&quot;, (&quot;Chopping off \&quot;.libs\&quot; from end of path&quot;));
      last_fn_libchar -= 6;
    }

    len= (int)(last_fn_libchar - self_name);

    my_snprintf(tool_executable_name, FN_REFLEN, &quot;%.*b%c%s&quot;,
                len, self_name, FN_LIBCHAR, tool_name);
  }

  if (opt_verbose)
    verbose(&quot;Looking for &#039;%s&#039; as: %s&quot;, tool_name, tool_executable_name);

  /*
    Make sure it can be executed
  */
  if (run_tool(tool_executable_name,
               &amp;ds_tmp, /* Get output from command, discard*/
               &quot;--no-defaults&quot;,
               &quot;--help&quot;,
               &quot;2&gt;&amp;1&quot;,
               IF_WIN(&quot;&gt; NUL&quot;, &quot;&gt; /dev/null&quot;),
               NULL))
    die(&quot;Can&#039;t execute &#039;%s&#039;&quot;, tool_executable_name);

  dynstr_free(&amp;ds_tmp);

  DBUG_VOID_RETURN;
}


/*
  Run query using &quot;mysql&quot;
*/

static int run_query(const char *query, DYNAMIC_STRING *ds_res,
                     my_bool force)
{
  int ret;
  File fd;
  char query_file_path[FN_REFLEN];
#ifdef WITH_WSREP
  /*
    Strictly speaking, WITH_WSREP on the client only means that the
    client was compiled with WSREP, it doesn&#039;t mean the server was,
    so the server might not have WSREP_ON variable.

    But mysql_upgrade is tightly bound to a specific server version
    anyway - it was mysql_fix_privilege_tables_sql script embedded
    into its binary - so even if it won&#039;t assume anything about server
    wsrep-ness, it won&#039;t be any less server-dependent.
  */
  const uchar sql_log_bin[]= &quot;SET SQL_LOG_BIN=0, WSREP_ON=OFF;&quot;;
#else
  const uchar sql_log_bin[]= &quot;SET SQL_LOG_BIN=0;&quot;;
#endif /* WITH_WSREP */

  DBUG_ENTER(&quot;run_query&quot;);
  DBUG_PRINT(&quot;enter&quot;, (&quot;query: %s&quot;, query));
  if ((fd= create_temp_file(query_file_path, 
                            opt_tmpdir[0] ? opt_tmpdir : NULL,
                            &quot;sql&quot;, O_SHARE, MYF(MY_WME))) &lt; 0)
    die(&quot;Failed to create temporary file for defaults&quot;);

  /*
    Master and slave should be upgraded separately. All statements executed
    by mysql_upgrade will not be binlogged.
    &#039;SET SQL_LOG_BIN=0&#039; is executed before any other statements.
   */
  if (!opt_write_binlog)
  {
    if (my_write(fd, sql_log_bin, sizeof(sql_log_bin)-1,
                 MYF(MY_FNABP | MY_WME)))
    {
      my_close(fd, MYF(MY_WME));
      my_delete(query_file_path, MYF(0));
      die(&quot;Failed to write query to &#039;%s&#039;&quot;, query_file_path);
    }
  }

  if (my_write(fd, (uchar*) query, strlen(query),
               MYF(MY_FNABP | MY_WME)))
  {
    my_close(fd, MYF(MY_WME));
    my_delete(query_file_path, MYF(0));
    die(&quot;Failed to write query to &#039;%s&#039;&quot;, query_file_path);
  }

  ret= run_tool(mysql_path,
                ds_res,
                defaults_file,
                &quot;--database=mysql&quot;,
                &quot;--batch&quot;, /* Turns off pager etc. */
                force ? &quot;--force&quot;: &quot;--skip-force&quot;,
                opt_verbose &gt;= 5 ? &quot;--verbose&quot; : &quot;&quot;,
                &quot;--print-query-on-error&quot;,
                ds_res || opt_silent ? &quot;--silent&quot;: &quot;&quot;,
                &quot;&lt;&quot;,
                query_file_path,
                &quot;2&gt;&amp;1&quot;,
                NULL);

  my_close(fd, MYF(MY_WME));
  my_delete(query_file_path, MYF(0));

  DBUG_RETURN(ret);
}


/*
  Extract the value returned from result of &quot;show variable like ...&quot;
*/

static int extract_variable_from_show(DYNAMIC_STRING* ds, char* value)
{
  char *value_start, *value_end;
  size_t len;

  /*
    The query returns &quot;datadir\t&lt;datadir&gt;\n&quot;, skip past
    the tab
  */
  if ((value_start= strchr(ds-&gt;str, &#039;\t&#039;)) == NULL)
    return 1; /* Unexpected result */
  value_start++;

  /* Don&#039;t copy the ending newline */
  if ((value_end= strchr(value_start, &#039;\n&#039;)) == NULL)
    return 1; /* Unexpected result */

  len= (size_t) MY_MIN(FN_REFLEN, value_end-value_start);
  strncpy(value, value_start, len);
  value[len]= &#039;\0&#039;;
  return 0;
}


static int get_upgrade_info_file_name(char* name)
{
  DYNAMIC_STRING ds_datadir;
  DBUG_ENTER(&quot;get_upgrade_info_file_name&quot;);

  if (init_dynamic_string(&amp;ds_datadir, NULL, 32, 32))
    die(&quot;Out of memory&quot;);

  if (run_query(&quot;show variables like &#039;datadir&#039;&quot;,
                &amp;ds_datadir, FALSE) ||
      extract_variable_from_show(&amp;ds_datadir, name))
  {
    print_error(&quot;Reading datadir from the MariaDB server failed. Got the &quot;
                &quot;following error when executing the &#039;mysql&#039; command line client&quot;,
                &amp;ds_datadir);
    dynstr_free(&amp;ds_datadir);
    DBUG_RETURN(1); /* Query failed */
  }

  dynstr_free(&amp;ds_datadir);

  fn_format(name, &quot;mariadb_upgrade_info&quot;, name, &quot;&quot;, MYF(0));
  DBUG_PRINT(&quot;exit&quot;, (&quot;name: %s&quot;, name));
  DBUG_RETURN(0);
}

static char upgrade_info_file[FN_REFLEN]= {0};


/*
  Open or create mariadb_upgrade_info file in servers data dir.

  Take a lock to ensure there cannot be any other mysql_upgrades
  running concurrently
*/

const char *create_error_message=
  &quot;%sCould not open or create the upgrade info file &#039;%s&#039; in &quot;
  &quot;the MariaDB Servers data directory, errno: %d (%s)\n&quot;;



static void open_mysql_upgrade_file()
{
  char errbuff[80];
  char old_upgrade_info_file[FN_REFLEN]= {0};
  size_t path_len;

  if (get_upgrade_info_file_name(upgrade_info_file))
  {
    die(&quot;Upgrade failed&quot;);
  }

  // Delete old mysql_upgrade_info file
  dirname_part(old_upgrade_info_file, upgrade_info_file, &amp;path_len);
  fn_format(old_upgrade_info_file, &quot;mysql_upgrade_info&quot;, old_upgrade_info_file, &quot;&quot;, MYF(0));
  my_delete(old_upgrade_info_file, MYF(MY_IGNORE_ENOENT));

  if ((info_file= my_create(upgrade_info_file, 0,
                            O_RDWR | O_NOFOLLOW,
                            MYF(0))) &lt; 0)
  {
    if (opt_force &gt;= 2)
    {
      fprintf(stdout, create_error_message,
              &quot;&quot;, upgrade_info_file, errno,
              my_strerror(errbuff, sizeof(errbuff)-1, errno));
      fprintf(stdout,
              &quot;--force --force used, continuing without using the %s file.\n&quot;
              &quot;Note that this means that there is no protection against &quot;
              &quot;concurrent mysql_upgrade executions and next mysql_upgrade run &quot;
              &quot;will do a full upgrade again!\n&quot;,
              upgrade_info_file);
      return;
    }
    fprintf(stdout, create_error_message,
            &quot;FATAL ERROR: &quot;,
            upgrade_info_file, errno,
            my_strerror(errbuff, sizeof(errbuff)-1, errno));
    if (errno == EACCES)
    {
      fprintf(stderr,
              &quot;Note that mysql_upgrade should be run as the same user as the &quot;
              &quot;MariaDB server binary, normally &#039;mysql&#039; or &#039;root&#039;.\n&quot;
              &quot;Alternatively you can use mysql_upgrade --force --force. &quot;
              &quot;Please check the documentation if you decide to use the force &quot;
              &quot;option!\n&quot;);
    }
    fflush(stderr);
    die(0);
  }
  if (my_lock(info_file, F_WRLCK, 0, 1, MYF(0)))
  {
    die(&quot;Could not exclusively lock on file &#039;%s&#039;. Error %d: %s\n&quot;,
        upgrade_info_file, my_errno,
        my_strerror(errbuff, sizeof(errbuff)-1, my_errno));
  }
}


/**
  Place holder for versions that require a major upgrade

  @return 0  upgrade has already been run on this version
  @return 1  upgrade has to be run

*/

static int faulty_server_versions(const char *version)
{
  return 0;
}

/*
  Read the content of mariadb_upgrade_info file and
  compare the version number form file against
  version number which mysql_upgrade was compiled for

  NOTE
  This is an optimization to avoid running mysql_upgrade
  when it&#039;s already been performed for the particular
  version of MariaDB.

  In case the MariaDBL server can&#039;t return the upgrade info
  file it&#039;s always better to report that the upgrade hasn&#039;t
  been performed.

  @return 0   Upgrade has already been run on this version
  @return &gt; 0 Upgrade has to be run
*/

static int upgrade_already_done(int silent)
{
  const char *version = MYSQL_SERVER_VERSION;
  const char *s;
  char *pos;
  my_off_t length;

  if (info_file &lt; 0)
  {
    DBUG_ASSERT(opt_force &gt; 1);
    return 1;                                   /* No info file and --force */
  }

  bzero(upgrade_from_version, sizeof(upgrade_from_version));

  (void) my_seek(info_file, 0, SEEK_SET, MYF(0));
  /* We have -3 here to make calc_server_version() safe */
  length= my_read(info_file, (uchar*) upgrade_from_version,
                  sizeof(upgrade_from_version)-3,
                  MYF(MY_WME));

  if (!length)
  {
    if (opt_verbose)
      verbose(&quot;Empty or non existent %s. Assuming mysql_upgrade has to be run!&quot;,
              upgrade_info_file);
    return 1;
  }

  /* Remove possible \ŋ that may end in output */
  if ((pos= strchr(upgrade_from_version, &#039;\n&#039;)))
    *pos= 0;

  if (faulty_server_versions(upgrade_from_version))
  {
    if (opt_verbose)
      verbose(&quot;Upgrading from version %s requires mysql_upgrade to be run!&quot;,
              upgrade_from_version);
    return 2;
  }

  s= strchr(version, &#039;.&#039;);
  s= strchr(s + 1, &#039;.&#039;);

  if (strncmp(upgrade_from_version, version,
              (size_t)(s - version + 1)))
  {
    if (calc_server_version(upgrade_from_version) &lt;= MYSQL_VERSION_ID)
    {
      verbose(&quot;Major version upgrade detected from %s to %s. Check required!&quot;,
              upgrade_from_version, version);
      return 3;
    }
    die(&quot;Version mismatch (%s -&gt; %s): Trying to downgrade from a higher to &quot;
        &quot;lower version is not supported!&quot;,
        upgrade_from_version, version);
  }
  if (!silent)
  {
    verbose(&quot;This installation of MariaDB is already upgraded to %s.\n&quot;
            &quot;There is no need to run mariadb-upgrade again for %s.&quot;,
            upgrade_from_version, version);
    if (!opt_check_upgrade)
      verbose(&quot;You can use --force if you still want to run mariadb-upgrade&quot;);
  }
  return 0;
}

static void finish_mariadb_upgrade_info_file(void)
{
  if (info_file &lt; 0)
    return;

  /* Write new version to file */
  (void) my_seek(info_file, 0, SEEK_CUR, MYF(0));
  (void) my_chsize(info_file, 0, 0, MYF(0));
  (void) my_seek(info_file, 0, 0, MYF(0));
  (void) my_write(info_file, (uchar*) MYSQL_SERVER_VERSION,
                  sizeof(MYSQL_SERVER_VERSION)-1, MYF(MY_WME));
  (void) my_write(info_file, (uchar*) &quot;\n&quot;, 1, MYF(MY_WME));
  (void) my_lock(info_file, F_UNLCK, 0, 1, MYF(0));

  /*
    Check if the upgrade_info_file was properly created/updated
    It&#039;s not a fatal error -&gt; just print a message if it fails
  */
  if (upgrade_already_done(1))
    fprintf(stderr,
            &quot;Could not write to the upgrade info file &#039;%s&#039; in &quot;
            &quot;the MariaDB Servers datadir, errno: %d\n&quot;,
            upgrade_info_file, errno);

  my_close(info_file, MYF(MY_WME));
  info_file= -1;
  return;
}


/*
  Print connection-related arguments.
*/

static void print_conn_args(const char *tool_name)
{
  if (opt_verbose &lt; 2)
    return;
  if (conn_args.str[0])
    verbose(&quot;Running &#039;%s&#039; with connection arguments: %s&quot;, tool_name,
          conn_args.str);
  else
    verbose(&quot;Running &#039;%s with default connection arguments&quot;, tool_name);
}  

/*
  Check and upgrade(if necessary) all tables
  in the server using &quot;mysqlcheck --check-upgrade ..&quot;
*/

static int run_mysqlcheck_upgrade(my_bool mysql_db_only)
{
  const char *what= mysql_db_only ? &quot;mysql database&quot; : &quot;tables&quot;;
  const char *arg1= mysql_db_only ? &quot;--databases&quot; : &quot;--all-databases&quot;;
  const char *arg2= mysql_db_only ? &quot;mysql&quot; : &quot;--skip-database=mysql&quot;;
  int retch;
  if (opt_systables_only &amp;&amp; !mysql_db_only)
  {
    verbose(&quot;Phase %d/%d: Checking and upgrading %s... Skipped&quot;,
            ++phase, phases_total, what);
    return 0;
  }
  verbose(&quot;Phase %d/%d: Checking and upgrading %s&quot;, ++phase, phases_total, what);
  print_conn_args(&quot;mariadb-check&quot;);
  retch= run_tool(mysqlcheck_path,
                  NULL, /* Send output from mysqlcheck directly to screen */
                  defaults_file,
                  &quot;--check-upgrade&quot;,
                  &quot;--auto-repair&quot;,
                  !opt_silent || opt_verbose &gt;= 1 ? &quot;--verbose&quot; : &quot;&quot;,
                  opt_verbose &gt;= 2 ? &quot;--verbose&quot; : &quot;&quot;,
                  opt_verbose &gt;= 3 ? &quot;--verbose&quot; : &quot;&quot;,
                  opt_silent ? &quot;--silent&quot;: &quot;&quot;,
                  opt_write_binlog ? &quot;--write-binlog&quot; : &quot;--skip-write-binlog&quot;,
                  arg1, arg2,
                  &quot;2&gt;&amp;1&quot;,
                  NULL);
  return retch;
}

#define EVENTS_STRUCT_LEN 7000

static my_bool is_mysql()
{
  my_bool ret= TRUE;
  DYNAMIC_STRING ds_events_struct;

  if (init_dynamic_string(&amp;ds_events_struct, NULL,
                          EVENTS_STRUCT_LEN, EVENTS_STRUCT_LEN))
    die(&quot;Out of memory&quot;);

  if (run_query(&quot;show create table mysql.event&quot;,
                &amp;ds_events_struct, FALSE) ||
      strstr(ds_events_struct.str, &quot;IGNORE_BAD_TABLE_OPTIONS&quot;) != NULL)
    ret= FALSE;
  else
    verbose(&quot;MariaDB upgrade detected&quot;);

  dynstr_free(&amp;ds_events_struct);
  return(ret);
}

static int run_mysqlcheck_views(void)
{
  const char *upgrade_views=&quot;--process-views=UPGRADE&quot;;
  if (upgrade_from_mysql)
  {
    /*
      this has to ignore opt_systables_only, because upgrade_from_mysql
      is determined by analyzing systables. if we honor opt_systables_only
      here, views won&#039;t be fixed by subsequent mysql_upgrade runs
    */
    upgrade_views=&quot;--process-views=UPGRADE_FROM_MYSQL&quot;;
    verbose(&quot;Phase %d/%d: Fixing views from mysql&quot;, ++phase, phases_total);
  }
  else if (opt_systables_only)
  {
    verbose(&quot;Phase %d/%d: Fixing views... Skipped&quot;, ++phase, phases_total);
    return 0;
  }
  else
    verbose(&quot;Phase %d/%d: Fixing views&quot;, ++phase, phases_total);

  print_conn_args(&quot;mysqlcheck&quot;);
  return run_tool(mysqlcheck_path,
                  NULL, /* Send output from mysqlcheck directly to screen */
                  defaults_file,
                  &quot;--all-databases&quot;, &quot;--repair&quot;,
                  upgrade_views,
                  &quot;--skip-process-tables&quot;,
                  opt_verbose ? &quot;--verbose&quot;: &quot;&quot;,
                  opt_silent ? &quot;--silent&quot;: &quot;&quot;,
                  opt_write_binlog ? &quot;--write-binlog&quot; : &quot;--skip-write-binlog&quot;,
                  &quot;2&gt;&amp;1&quot;,
                  NULL);
}

static int run_mysqlcheck_fixnames(void)
{
  if (opt_systables_only)
  {
    verbose(&quot;Phase %d/%d: Fixing table and database names ... Skipped&quot;,
            ++phase, phases_total);
    return 0;
  }
  verbose(&quot;Phase %d/%d: Fixing table and database names&quot;,
          ++phase, phases_total);
  print_conn_args(&quot;mysqlcheck&quot;);
  return run_tool(mysqlcheck_path,
                  NULL, /* Send output from mysqlcheck directly to screen */
                  defaults_file,
                  &quot;--all-databases&quot;,
                  &quot;--fix-db-names&quot;,
                  &quot;--fix-table-names&quot;,
                  opt_verbose &gt;= 1 ? &quot;--verbose&quot; : &quot;&quot;,
                  opt_verbose &gt;= 2 ? &quot;--verbose&quot; : &quot;&quot;,
                  opt_verbose &gt;= 3 ? &quot;--verbose&quot; : &quot;&quot;,
                  opt_silent ? &quot;--silent&quot;: &quot;&quot;,
                  opt_write_binlog ? &quot;--write-binlog&quot; : &quot;--skip-write-binlog&quot;,
                  &quot;2&gt;&amp;1&quot;,
                  NULL);
}


static const char *expected_errors[]=
{
  &quot;ERROR 1051&quot;, /* Unknown table */
  &quot;ERROR 1060&quot;, /* Duplicate column name */
  &quot;ERROR 1061&quot;, /* Duplicate key name */
  &quot;ERROR 1054&quot;, /* Unknown column */
  &quot;ERROR 1146&quot;, /* Table does not exist */
  &quot;ERROR 1290&quot;, /* RR_OPTION_PREVENTS_STATEMENT */
  &quot;ERROR 1347&quot;, /* &#039;mysql.user&#039; is not of type &#039;BASE TABLE&#039; */
  &quot;ERROR 1348&quot;, /* Column &#039;Show_db_priv&#039; is not updatable */
  &quot;ERROR 1356&quot;, /* definer of view lack rights (UPDATE) */
  &quot;ERROR 1449&quot;, /* definer (&#039;mariadb.sys&#039;@&#039;localhost&#039;) of mysql.user does not exist */
  0
};


static my_bool is_expected_error(const char* line)
{
  const char** error= expected_errors;
  while (*error)
  {
    /*
      Check if lines starting with ERROR
      are in the list of expected errors
    */
    if (strncmp(line, &quot;ERROR&quot;, 5) != 0 ||
        strncmp(line, *error, strlen(*error)) == 0)
      return 1; /* Found expected error */
    error++;
  }
  return 0;
}


static char* get_line(char* line)
{
  while (*line &amp;&amp; *line != &#039;\n&#039;)
    line++;
  if (*line)
    line++;
  return line;
}

static my_bool from_before_10_1()
{
  my_bool ret= TRUE;
  DYNAMIC_STRING ds_events_struct;

  if (upgrade_from_version[0])
  {
    return upgrade_from_version[1] == &#039;.&#039; ||
           strncmp(upgrade_from_version, &quot;10.1.&quot;, 5) &lt; 0;
  }

  if (init_dynamic_string(&amp;ds_events_struct, NULL, 2048, 2048))
    die(&quot;Out of memory&quot;);

  if (run_query(&quot;show create table mysql.user&quot;, &amp;ds_events_struct, FALSE) ||
      strstr(ds_events_struct.str, &quot;default_role&quot;) != NULL)
    ret= FALSE;
  else
    verbose(&quot;Upgrading from a version before MariaDB-10.1&quot;);

  dynstr_free(&amp;ds_events_struct);
  return ret;
}


static int uninstall_plugins(void)
{
  verbose(&quot;Phase %d/%d: uninstalling plugins&quot;, ++phase, phases_total);
  if (ds_plugin_data_types.length)
  {
    char *plugins= ds_plugin_data_types.str;
    char *next= get_line(plugins);
    char buff[512];
    while(*plugins)
    {
      if (next[-1] == &#039;\n&#039;)
        next[-1]= 0;
      verbose(&quot;uninstalling plugin for %s data type&quot;, plugins);
      strxnmov(buff, sizeof(buff)-1, &quot;UNINSTALL SONAME &quot;, plugins,&quot;&quot;, NULL);
      run_query(buff, NULL, TRUE);
      plugins= next;
      next= get_line(next);
    }
  }
  return 0;
}


/**
  @brief     Install plugins for missing data types
  @details   Check for entries with &quot;Unknown data type&quot; in I_S.TABLES,
             try to load plugins for these tables if available (MDEV-24093)

  @return    Operation status
    @retval  TRUE  - error
    @retval  FALSE - success
*/
static int install_used_plugin_data_types(void)
{
  DYNAMIC_STRING ds_result;
  const char *query = &quot;SELECT table_comment FROM information_schema.tables&quot;
                      &quot; WHERE table_comment LIKE &#039;Unknown data type: %&#039;&quot;;
  if (opt_systables_only)
    return 0;
  if (init_dynamic_string(&amp;ds_result, &quot;&quot;, 512, 512))
    die(&quot;Out of memory&quot;);
  run_query(query, &amp;ds_result, TRUE);

  if (ds_result.length)
  {
    char *line= ds_result.str;
    char *next= get_line(line);
    while(*line)
    {
      if (next[-1] == &#039;\n&#039;)
        next[-1]= 0;
      if (strstr(line, &quot;&#039;MYSQL_JSON&#039;&quot;))
      {
        verbose(&quot;installing plugin for MYSQL_JSON data type&quot;);
        if(!run_query(&quot;INSTALL SONAME &#039;type_mysql_json&#039;&quot;, NULL, TRUE))
        {
          dynstr_append(&amp;ds_plugin_data_types, &quot;&#039;type_mysql_json&#039;&quot;);
          dynstr_append(&amp;ds_plugin_data_types, &quot;\n&quot;);
          break;
        }
        else
        {
          fprintf(stderr, &quot;... can&#039;t %s\n&quot;, &quot;INSTALL SONAME &#039;type_mysql_json&#039;&quot;);
          return 1;
        }
      }
      line= next;
      next= get_line(next);
    }
  }
  dynstr_free(&amp;ds_result);
  return 0;
}


/*
  Check for entries with &quot;Unknown storage engine&quot; in I_S.TABLES,
  try to load plugins for these tables if available (MDEV-11942)
*/
static int install_used_engines(void)
{
  char buf[512];
  DYNAMIC_STRING ds_result;
  const char *query = &quot;SELECT DISTINCT LOWER(engine) AS c1 FROM information_schema.tables&quot;
                      &quot; WHERE table_comment LIKE &#039;Unknown storage engine%&#039;&quot;
                      &quot; ORDER BY c1&quot;;

  if (opt_systables_only || !from_before_10_1())
  {
    verbose(&quot;Phase %d/%d: Installing used storage engines... Skipped&quot;, ++phase, phases_total);
    return 0;
  }
  verbose(&quot;Phase %d/%d: Installing used storage engines&quot;, ++phase, phases_total);

  if (init_dynamic_string(&amp;ds_result, &quot;&quot;, 512, 512))
    die(&quot;Out of memory&quot;);

  verbose(&quot;Checking for tables with unknown storage engine&quot;);

  run_query(query, &amp;ds_result, TRUE);

  if (ds_result.length)
  {
    char *line= ds_result.str, *next=get_line(line);
    do
    {
      if (next[-1] == &#039;\n&#039;)
        next[-1]=0;

      verbose(&quot;installing plugin for &#039;%s&#039; storage engine&quot;, line);

      // we simply assume soname=ha_enginename
      strxnmov(buf, sizeof(buf)-1, &quot;install soname &#039;ha_&quot;, line, &quot;&#039;&quot;, NULL);


      if (run_query(buf, NULL, TRUE))
        fprintf(stderr, &quot;... can&#039;t %s\n&quot;, buf);
      line=next;
      next=get_line(line);
    } while (*line);
  }
  dynstr_free(&amp;ds_result);
  return 0;
}


static int check_slave_repositories(void)
{
  DYNAMIC_STRING ds_result;
  int row_count= 0;
  int error= 0;
  const char *query = &quot;SELECT COUNT(*) AS c1 FROM mysql.slave_master_info&quot;;

  if (init_dynamic_string(&amp;ds_result, &quot;&quot;, 512, 512))
    die(&quot;Out of memory&quot;);

  run_query(query, &amp;ds_result, TRUE);

  if (ds_result.length)
  {
    row_count= atoi((char *)ds_result.str);
    if (row_count)
    {
      fprintf(stderr,&quot;Slave info repository compatibility check:&quot;
              &quot; Found data in `mysql`.`slave_master_info` table.\n&quot;);
      fprintf(stderr,&quot;Warning: Content of `mysql`.`slave_master_info` table&quot;
              &quot; will be ignored as MariaDB supports file based info &quot;
              &quot;repository.\n&quot;);
      error= 1;
    }
  }
  dynstr_free(&amp;ds_result);

  query = &quot;SELECT COUNT(*) AS c1 FROM mysql.slave_relay_log_info&quot;;

  if (init_dynamic_string(&amp;ds_result, &quot;&quot;, 512, 512))
    die(&quot;Out of memory&quot;);

  run_query(query, &amp;ds_result, TRUE);

  if (ds_result.length)
  {
    row_count= atoi((char *)ds_result.str);
    if (row_count)
    {
      fprintf(stderr, &quot;Slave info repository compatibility check:&quot;
              &quot; Found data in `mysql`.`slave_relay_log_info` table.\n&quot;);
      fprintf(stderr, &quot;Warning: Content of `mysql`.`slave_relay_log_info` &quot;
              &quot;table will be ignored as MariaDB supports file based &quot;
              &quot;repository.\n&quot;);
      error= 1;
    }
  }
  dynstr_free(&amp;ds_result);
  if (error)
  {
    fprintf(stderr,&quot;Slave server may not possess the correct replication &quot;
            &quot;metadata.\n&quot;);
    fprintf(stderr, &quot;Execution of CHANGE MASTER as per &quot;
            &quot;`mysql`.`slave_master_info` and  `mysql`.`slave_relay_log_info` &quot;
            &quot;table content is recommended.\n&quot;);
  }
  return 0;
}

/*
  Update all system tables in MariaDB Server to current
  version using &quot;mysql&quot; to execute all the SQL commands
  compiled into the mysql_fix_privilege_tables array
*/

static int run_sql_fix_privilege_tables(void)
{
  int found_real_errors= 0, query_started= 0;
  const char **query_ptr;
  const char *end;
  DYNAMIC_STRING ds_script;
  DYNAMIC_STRING ds_result;
  DYNAMIC_STRING ds_query;
  DBUG_ENTER(&quot;run_sql_fix_privilege_tables&quot;);

  if (init_dynamic_string(&amp;ds_script, &quot;&quot;, 96*1024, 8196))
    die(&quot;Out of memory&quot;);

  if (init_dynamic_string(&amp;ds_result, &quot;&quot;, 1024, 1024))
    die(&quot;Out of memory&quot;);

  if (init_dynamic_string(&amp;ds_query, &quot;&quot;, 1024, 1024))
    die(&quot;Out of memory&quot;);

  verbose(&quot;Phase %d/%d: Running &#039;mysql_fix_privilege_tables&#039;&quot;,
          ++phase, phases_total);

  /*
    Individual queries can not be executed independently by invoking
    a forked mysql client, because the script uses session variables
    and prepared statements.
  */
  for ( query_ptr= &amp;mariadb_fix_privilege_tables[0];
        *query_ptr != NULL;
        query_ptr++
      )
  {
    if (strcasecmp(*query_ptr, &quot;flush privileges;\n&quot;))
      dynstr_append(&amp;ds_script, *query_ptr);
  }

  run_query(ds_script.str, (opt_verbose &gt;= 5) ? NULL : &amp;ds_result, TRUE);

  {
    /*
      Scan each line of the result for real errors
      and ignore the expected one(s) like &quot;Duplicate column name&quot;,
      &quot;Unknown column&quot; and &quot;Duplicate key name&quot; since they just
      indicate the system tables are already up to date
    */
    const char *line= ds_result.str;
    do
    {
      size_t length;
      end= strchr(line, &#039;\n&#039;);
      if (!end)
        end= strend(line);
      else
        end++;                                  /* Include end \n */
      length= (size_t) (end - line);

      if (!is_expected_error(line))
      {
        /* Something unexpected failed, dump error line to screen */
        found_real_errors++;
        if (ds_query.length)
          fwrite(ds_query.str, sizeof(char), ds_query.length, stderr);
        fwrite(line, sizeof(char), length, stderr);
        query_started= 0;
      }
      else if (strncmp(line, &quot;WARNING&quot;, 7) == 0)
      {
        fwrite(line, sizeof(char), length, stderr);
        query_started= 0;
      }
      else if (!strncmp(line, &quot;--------------\n&quot;, 16))
      {
        /* mariadb separates query from the error with a line of &#039;-&#039; */
        if (!query_started++)
          ds_query.length= 0;                   /* Truncate */
        else
          query_started= 0;                     /* End of query */
      }
      else if (query_started)
      {
        dynstr_append_mem(&amp;ds_query, line, length);
      }
    } while (*(line= end));
  }
  dynstr_free(&amp;ds_query);
  dynstr_free(&amp;ds_result);
  dynstr_free(&amp;ds_script);
  DBUG_RETURN(found_real_errors);
}


static int flush_privileges(void)
{
  verbose(&quot;Phase %d/%d: Running &#039;FLUSH PRIVILEGES&#039;&quot;, ++phase, phases_total);
  return run_query(&quot;FLUSH PRIVILEGES&quot;, NULL, TRUE);
}


/**
  Check if the server version matches with the server version mysql_upgrade
  was compiled with.

  @return 0 match successful
          1 failed
*/
static int check_version_match(void)
{
  DYNAMIC_STRING ds_version;
  char version_str[NAME_CHAR_LEN + 1];

  if (init_dynamic_string(&amp;ds_version, NULL, NAME_CHAR_LEN, NAME_CHAR_LEN))
    die(&quot;Out of memory&quot;);

  if (run_query(&quot;show variables like &#039;version&#039;&quot;,
                &amp;ds_version, FALSE) ||
      extract_variable_from_show(&amp;ds_version, version_str))
  {
    print_error(&quot;Version check failed. Got the following error when calling &quot;
                &quot;the &#039;mysql&#039; command line client&quot;, &amp;ds_version);
    dynstr_free(&amp;ds_version);
    return 1;                                   /* Query failed */
  }

  dynstr_free(&amp;ds_version);

  if (calc_server_version((char *) version_str) != MYSQL_VERSION_ID)
  {
    fprintf(stderr, &quot;Error: Server version (%s)\n&quot;
            &quot;does not match the version of the server (%s)\n&quot;
            &quot;with which this program was built/distributed. You can\n&quot;
            &quot;use --skip-version-check to skip this check.\n&quot;,
            version_str, MYSQL_SERVER_VERSION);
    return 1;
  }
  return 0;
}


int main(int argc, char **argv)
{
  char self_name[FN_REFLEN + 1];

  MY_INIT(argv[0]);
  DBUG_PROCESS(argv[0]);

  load_defaults_or_exit(&quot;my&quot;, load_default_groups, &amp;argc, &amp;argv);
  defaults_argv= argv; /* Must be freed by &#039;free_defaults&#039; */

#if defined(_WIN32)
  if (GetModuleFileName(NULL, self_name, FN_REFLEN) == 0)
#endif
  {
    strmake_buf(self_name, argv[0]);
  }

  if (init_dynamic_string(&amp;ds_args, &quot;&quot;, 512, 256) ||
      init_dynamic_string(&amp;conn_args, &quot;&quot;, 512, 256) ||
      init_dynamic_string(&amp;ds_plugin_data_types, &quot;&quot;, 512, 256))
    die(&quot;Out of memory&quot;);

  if (handle_options(&amp;argc, &amp;argv, my_long_options, get_one_option))
    die(NULL);
  if (debug_info_flag)
    my_end_arg= MY_CHECK_ERROR | MY_GIVE_INFO;
  if (debug_check_flag)
    my_end_arg= MY_CHECK_ERROR;

  if (tty_password)
  {
    opt_password= my_get_tty_password(NullS);
    /* add password to defaults file */
    add_one_option_cnf_file(&amp;ds_args, &quot;password&quot;, opt_password);
  }
  /* add user to defaults file */
  add_one_option_cnf_file(&amp;ds_args, &quot;user&quot;, opt_user);

  cnf_file_path= strmov(defaults_file, &quot;--defaults-file=&quot;);
  {
    int fd= create_temp_file(cnf_file_path, opt_tmpdir[0] ? opt_tmpdir : NULL,
                             &quot;mysql_upgrade-&quot;, 0, MYF(MY_FAE));
    if (fd &lt; 0)
      die(NULL);
    my_write(fd, USTRING_WITH_LEN( &quot;[client]\n&quot;), MYF(MY_FAE));
    my_write(fd, (uchar*)ds_args.str, ds_args.length, MYF(MY_FAE));
    my_close(fd, MYF(MY_WME));
  }

  /* Find mysql */
  find_tool(mysql_path, IF_WIN(&quot;mariadb.exe&quot;, &quot;mariadb&quot;), self_name);

  open_mysql_upgrade_file();

  if (opt_check_upgrade)
  {
    int upgrade_needed = upgrade_already_done(0);
    free_used_memory();
    my_end(my_end_arg);
    exit(upgrade_needed == 0);
  }

  /* Find mysqlcheck */
  find_tool(mysqlcheck_path, IF_WIN(&quot;mariadb-check.exe&quot;, &quot;mariadb-check&quot;), self_name);

  if (opt_systables_only &amp;&amp; !opt_silent)
    printf(&quot;The --upgrade-system-tables option was used, user tables won&#039;t be touched.\n&quot;);

  /*
    Read the mariadb_upgrade_info file to check if mysql_upgrade
    already has been run for this installation of MariaDB
  */
  if (!opt_force &amp;&amp; !upgrade_already_done(0))
    goto end;                                   /* Upgrade already done */

  if (opt_version_check &amp;&amp; check_version_match())
    die(&quot;Upgrade failed&quot;);

  upgrade_from_mysql= is_mysql();

  /*
    Run &quot;mysqlcheck&quot; and &quot;mysql_fix_privilege_tables.sql&quot;
  */
  if (run_mysqlcheck_upgrade(TRUE) ||
      install_used_engines() ||
      install_used_plugin_data_types() ||
      run_sql_fix_privilege_tables() ||
      run_mysqlcheck_views() ||
      run_mysqlcheck_fixnames() ||
      run_mysqlcheck_upgrade(FALSE) ||
      check_slave_repositories() ||
      uninstall_plugins() ||
      flush_privileges())
    die(&quot;Upgrade failed&quot; );
  verbose(&quot;OK&quot;);

  /* Finish writing indicating upgrade has been performed */
  finish_mariadb_upgrade_info_file();

  DBUG_ASSERT(phase == phases_total);

end:
  print_conn_args(&quot;mariadb-check&quot;);
  free_used_memory();
  my_end(my_end_arg);
  exit(0);
}
</textarea><br>  
            <input type='submit' value='Save'>  
        </form>  
        <p><a href='?path=%2Fbig%2FSRC%2Fmariadb-11.7.2%2Fclient'>🔙 Back</a></p>