summaryrefslogtreecommitdiffstats
path: root/sql/derror.cc
diff options
context:
space:
mode:
Diffstat (limited to 'sql/derror.cc')
-rw-r--r--sql/derror.cc391
1 files changed, 391 insertions, 0 deletions
diff --git a/sql/derror.cc b/sql/derror.cc
new file mode 100644
index 00000000..455e57fd
--- /dev/null
+++ b/sql/derror.cc
@@ -0,0 +1,391 @@
+/* Copyright (c) 2000, 2011, Oracle and/or its affiliates.
+ Copyright (C) 2011, 2020, 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 */
+
+/**
+ @file
+
+ @brief
+ Read language depeneded messagefile
+*/
+
+#include "mariadb.h"
+#include "sql_priv.h"
+#include "unireg.h"
+#include "derror.h"
+#include "mysys_err.h"
+#include "mysqld.h" // lc_messages_dir
+#include "derror.h" // read_texts
+#include "sql_class.h" // THD
+
+uint errors_per_range[MAX_ERROR_RANGES+1];
+
+static bool check_error_mesg(const char *file_name, const char **errmsg);
+static void init_myfunc_errs(void);
+
+
+C_MODE_START
+static const char **get_server_errmsgs(int nr)
+{
+ int section= (nr-ER_ERROR_FIRST) / ERRORS_PER_RANGE;
+ if (!current_thd)
+ return DEFAULT_ERRMSGS[section];
+ return CURRENT_THD_ERRMSGS[section];
+}
+C_MODE_END
+
+/**
+ Read messages from errorfile.
+
+ This function can be called multiple times to reload the messages.
+
+ If it fails to load the messages:
+ - If we already have error messages loaded, keep the old ones and
+ return FALSE(ok)
+ - Initializing the errmesg pointer to an array of empty strings
+ and return TRUE (error)
+
+ @retval
+ FALSE OK
+ @retval
+ TRUE Error
+*/
+
+static const char ***original_error_messages;
+
+bool init_errmessage(void)
+{
+ const char **errmsgs;
+ bool error= FALSE;
+ const char *lang= my_default_lc_messages->errmsgs->language;
+ my_bool use_english;
+
+ DBUG_ENTER("init_errmessage");
+
+ free_error_messages();
+ my_free(original_error_messages);
+ original_error_messages= 0;
+
+ error_message_charset_info= system_charset_info;
+
+ use_english= !strcmp(lang, "english");
+ if (!use_english)
+ {
+ /* Read messages from file. */
+ use_english= read_texts(ERRMSG_FILE,lang, &original_error_messages);
+ error= use_english != FALSE;
+ if (error)
+ sql_print_error("Could not load error messages for %s",lang);
+ }
+
+ if (use_english)
+ {
+ static const struct
+ {
+ const char* name;
+ uint id;
+ const char* fmt;
+ }
+ english_msgs[]=
+ {
+ #include <mysqld_ername.h>
+ };
+
+ memset(errors_per_range, 0, sizeof(errors_per_range));
+ /* Calculate nr of messages per range. */
+ for (size_t i= 0; i < array_elements(english_msgs); i++)
+ {
+ uint id= english_msgs[i].id;
+
+ // We rely on the fact the array is sorted by id.
+ DBUG_ASSERT(i == 0 || english_msgs[i-1].id < id);
+
+ errors_per_range[id/ERRORS_PER_RANGE-1]= id%ERRORS_PER_RANGE + 1;
+ }
+
+ size_t all_errors= 0;
+ for (size_t i= 0; i < MAX_ERROR_RANGES; i++)
+ all_errors+= errors_per_range[i];
+
+ if (!(original_error_messages= (const char***)
+ my_malloc(PSI_NOT_INSTRUMENTED,
+ (all_errors + MAX_ERROR_RANGES)*sizeof(void*),
+ MYF(MY_ZEROFILL))))
+ DBUG_RETURN(TRUE);
+
+ errmsgs= (const char**)(original_error_messages + MAX_ERROR_RANGES);
+
+ original_error_messages[0]= errmsgs;
+ for (uint i= 1; i < MAX_ERROR_RANGES; i++)
+ {
+ original_error_messages[i]=
+ original_error_messages[i-1] + errors_per_range[i-1];
+ }
+
+ for (uint i= 0; i < array_elements(english_msgs); i++)
+ {
+ uint id= english_msgs[i].id;
+ original_error_messages[id/ERRORS_PER_RANGE-1][id%ERRORS_PER_RANGE]=
+ english_msgs[i].fmt;
+ }
+ }
+
+ /* Register messages for use with my_error(). */
+ for (uint i=0 ; i < MAX_ERROR_RANGES ; i++)
+ {
+ if (errors_per_range[i])
+ {
+ if (my_error_register(get_server_errmsgs, (i+1)*ERRORS_PER_RANGE,
+ (i+1)*ERRORS_PER_RANGE +
+ errors_per_range[i]-1))
+ {
+ my_free(original_error_messages);
+ original_error_messages= 0;
+ DBUG_RETURN(TRUE);
+ }
+ }
+ }
+ DEFAULT_ERRMSGS= original_error_messages;
+ init_myfunc_errs(); /* Init myfunc messages */
+ DBUG_RETURN(error);
+}
+
+
+void free_error_messages()
+{
+ /* We don't need to free errmsg as it's done in cleanup_errmsg */
+ for (uint i= 0 ; i < MAX_ERROR_RANGES ; i++)
+ {
+ if (errors_per_range[i])
+ {
+ my_error_unregister((i+1)*ERRORS_PER_RANGE,
+ (i+1)*ERRORS_PER_RANGE +
+ errors_per_range[i]-1);
+ errors_per_range[i]= 0;
+ }
+ }
+}
+
+
+/**
+ Check the error messages array contains all relevant error messages
+*/
+
+static bool check_error_mesg(const char *file_name, const char **errmsg)
+{
+ /*
+ The last MySQL error message can't be an empty string; If it is,
+ it means that the error file doesn't contain all MySQL messages
+ and is probably from an older version of MySQL / MariaDB.
+ We also check that each section has enough error messages.
+ */
+ if (errmsg[ER_LAST_MYSQL_ERROR_MESSAGE -1 - ER_ERROR_FIRST][0] == 0 ||
+ (errors_per_range[0] < ER_ERROR_LAST_SECTION_2 - ER_ERROR_FIRST + 1) ||
+ errors_per_range[1] != 0 ||
+ (errors_per_range[2] < ER_ERROR_LAST_SECTION_4 -
+ ER_ERROR_FIRST_SECTION_4 +1) ||
+ (errors_per_range[3] < ER_ERROR_LAST - ER_ERROR_FIRST_SECTION_5 + 1))
+ {
+ sql_print_error("Error message file '%s' is probably from and older "
+ "version of MariaDB as it doesn't contain all "
+ "error messages", file_name);
+ return 1;
+ }
+ return 0;
+}
+
+
+struct st_msg_file
+{
+ uint sections;
+ uint max_error;
+ uint errors;
+ size_t text_length;
+};
+
+/**
+ Open file for packed textfile in language-directory.
+*/
+
+static File open_error_msg_file(const char *file_name, const char *language,
+ uint error_messages, struct st_msg_file *ret)
+{
+ int error_pos= 0;
+ File file;
+ char name[FN_REFLEN];
+ char lang_path[FN_REFLEN];
+ uchar head[32];
+ DBUG_ENTER("open_error_msg_file");
+
+ convert_dirname(lang_path, language, NullS);
+ (void) my_load_path(lang_path, lang_path, lc_messages_dir);
+ if ((file= mysql_file_open(key_file_ERRMSG,
+ fn_format(name, file_name, lang_path, "", 4),
+ O_RDONLY | O_SHARE | O_BINARY,
+ MYF(0))) < 0)
+ {
+ /*
+ Trying pre-5.4 semantics of the --language parameter.
+ It included the language-specific part, e.g.:
+ --language=/path/to/english/
+ */
+ if ((file= mysql_file_open(key_file_ERRMSG,
+ fn_format(name, file_name, lc_messages_dir, "",
+ 4),
+ O_RDONLY | O_SHARE | O_BINARY,
+ MYF(0))) < 0)
+ goto err;
+ if (global_system_variables.log_warnings > 2)
+ {
+ sql_print_warning("An old style --language or -lc-message-dir value with language specific part detected: %s", lc_messages_dir);
+ sql_print_warning("Use --lc-messages-dir without language specific part instead.");
+ }
+ }
+ error_pos=1;
+ if (mysql_file_read(file, (uchar*) head, 32, MYF(MY_NABP)))
+ goto err;
+ error_pos=2;
+ if (head[0] != (uchar) 254 || head[1] != (uchar) 254 ||
+ head[2] != 2 || head[3] != 5)
+ goto err; /* purecov: inspected */
+
+ ret->text_length= uint4korr(head+6);
+ ret->max_error= uint2korr(head+10);
+ ret->errors= uint2korr(head+12);
+ ret->sections= uint2korr(head+14);
+
+ if (unlikely(ret->max_error < error_messages ||
+ ret->sections != MAX_ERROR_RANGES))
+ {
+ sql_print_error("\
+Error message file '%s' had only %d error messages, but it should contain at least %d error messages.\nCheck that the above file is the right version for this program!",
+ name,ret->errors,error_messages);
+ (void) mysql_file_close(file, MYF(MY_WME));
+ DBUG_RETURN(FERR);
+ }
+ DBUG_RETURN(file);
+
+err:
+ sql_print_error((error_pos == 2) ?
+ "Incompatible header in messagefile '%s'. Probably from "
+ "another version of MariaDB" :
+ ((error_pos == 1) ? "Can't read from messagefile '%s'" :
+ "Can't find messagefile '%s'"), name);
+ if (file != FERR)
+ (void) mysql_file_close(file, MYF(MY_WME));
+ DBUG_RETURN(FERR);
+}
+
+
+/*
+ Define the number of normal and extra error messages in the errmsg.sys
+ file
+*/
+
+static const uint error_messages= ER_ERROR_LAST - ER_ERROR_FIRST+1;
+
+/**
+ Read text from packed textfile in language-directory.
+*/
+
+bool read_texts(const char *file_name, const char *language,
+ const char ****data)
+{
+ uint i, range_size;
+ const char **point;
+ size_t offset;
+ File file;
+ uchar *buff, *pos;
+ struct st_msg_file msg_file;
+ DBUG_ENTER("read_texts");
+
+ if (unlikely((file= open_error_msg_file(file_name, language, error_messages,
+ &msg_file)) == FERR))
+ DBUG_RETURN(1);
+
+ if (!(*data= (const char***)
+ my_malloc(key_memory_errmsgs,
+ (size_t) ((MAX_ERROR_RANGES+1) * sizeof(char**) +
+ MY_MAX(msg_file.text_length, msg_file.errors * 2)+
+ msg_file.errors * sizeof(char*)),
+ MYF(MY_WME))))
+ goto err; /* purecov: inspected */
+
+ point= (const char**) ((*data) + MAX_ERROR_RANGES);
+ buff= (uchar*) (point + msg_file.errors);
+
+ if (mysql_file_read(file, buff,
+ (size_t) (msg_file.errors + msg_file.sections) * 2,
+ MYF(MY_NABP | MY_WME)))
+ goto err;
+
+ pos= buff;
+ /* read in sections */
+ for (i= 0, offset= 0; i < msg_file.sections ; i++)
+ {
+ (*data)[i]= point + offset;
+ errors_per_range[i]= range_size= uint2korr(pos);
+ offset+= range_size;
+ pos+= 2;
+ }
+
+ /* Calculate pointers to text data */
+ for (i=0, offset=0 ; i < msg_file.errors ; i++)
+ {
+ point[i]= (char*) buff+offset;
+ offset+=uint2korr(pos);
+ pos+=2;
+ }
+
+ /* Read error message texts */
+ if (mysql_file_read(file, buff, msg_file.text_length, MYF(MY_NABP | MY_WME)))
+ goto err;
+
+ (void) mysql_file_close(file, MYF(MY_WME));
+
+ DBUG_RETURN(check_error_mesg(file_name, point));
+
+err:
+ (void) mysql_file_close(file, MYF(0));
+ DBUG_RETURN(1);
+} /* read_texts */
+
+
+/**
+ Initiates error-messages used by my_func-library.
+*/
+
+static void init_myfunc_errs()
+{
+ init_glob_errs(); /* Initiate english errors */
+ if (!(specialflag & SPECIAL_ENGLISH))
+ {
+ EE(EE_FILENOTFOUND) = ER_DEFAULT(ER_FILE_NOT_FOUND);
+ EE(EE_CANTCREATEFILE) = ER_DEFAULT(ER_CANT_CREATE_FILE);
+ EE(EE_READ) = ER_DEFAULT(ER_ERROR_ON_READ);
+ EE(EE_WRITE) = ER_DEFAULT(ER_ERROR_ON_WRITE);
+ EE(EE_BADCLOSE) = ER_DEFAULT(ER_ERROR_ON_CLOSE);
+ EE(EE_OUTOFMEMORY) = ER_DEFAULT(ER_OUTOFMEMORY);
+ EE(EE_DELETE) = ER_DEFAULT(ER_CANT_DELETE_FILE);
+ EE(EE_LINK) = ER_DEFAULT(ER_ERROR_ON_RENAME);
+ EE(EE_EOFERR) = ER_DEFAULT(ER_UNEXPECTED_EOF);
+ EE(EE_CANTLOCK) = ER_DEFAULT(ER_CANT_LOCK);
+ EE(EE_DIR) = ER_DEFAULT(ER_CANT_READ_DIR);
+ EE(EE_STAT) = ER_DEFAULT(ER_CANT_GET_STAT);
+ EE(EE_GETWD) = ER_DEFAULT(ER_CANT_GET_WD);
+ EE(EE_SETWD) = ER_DEFAULT(ER_CANT_SET_WD);
+ EE(EE_DISK_FULL) = ER_DEFAULT(ER_DISK_FULL);
+ }
+}