---

mysql.c

Go to the documentation of this file.

/*! \file mysql.c
          Simple interface to MySql.
 */ 

#include <stdio.h>
#include <stdlib.h>
#include <stdarg.h>
#include <unistd.h>
#include <string.h>
#include <mysql/errmsg.h>
#include "config.h"        /* EXT, from the common-c-lib */ 
#include "mysql_header.h"  /* INT                        */
#include "strings_utils.h"
#include "mysqld_error.h"



static void set_last_error (struct smysql *mysql_info);
static void clear_error_reporting (struct smysql *mysql_info);
static void copy_error (struct smysql *mysql_info, char *m);
static int standard_query (struct smysql *mysql_info, char* query);

/*! \brief Last MySql error message.
 */

char mysql_error_str[MYSQL_MAX_ERROR_SIZE];

/*! \brief Last MySql error code.
 */

int  mysql_error_errno;

/*! \brief This is a handler to a fake loggin service. It is used if no logging service is specified in the
           MySql configuration handler.
 */

static int my_fake_syslog (const char *file, const char * fmt,...) { return 0; }

/*! \brief Assign a logging service to a given MySql handler.
    \author Denis BEURIVE
    \param logger Pointer to a guven logging service.
    \param mysql_info Pointer  to a MySql handler.
    \remark To desactivate logging, just set the value of 'logger' to NULL.
    \warning Unless you call load_mysql_configuration_from_file(), you MUST call mysql_set_logger() first!
             Failing to initialize the logging service may lead to process segmentation fault.
 */ 

void mysql_set_logger (int (*logger) (const char *file, const char * fmt,...), struct smysql *mysql_info)
{ mysql_info->my_syslog = logger; } 

/*! \brief Clear all error reporting data.
    \author Denis BEURIVE
 */

static void clear_error_reporting (struct smysql *mysql_info)
{
  mysql_info->last_error_int = 0;
  memset ((void*)mysql_info->last_error_str, 0, MYSQL_MAX_ERROR_SIZE);
  mysql_error_errno = 0;
  memset ((void*)mysql_error_str, 0, MYSQL_MAX_ERROR_SIZE);
}

/*! \brief Safely copy error message from MySql.
    \author Denis BEURIVE
    \param mysql_info Pointer to a Mysql management structure.
 */

static void set_last_error (struct smysql *mysql_info)
{
  const char *err;
  int        merror;

  err    = NULL;
  merror = 0;

  clear_error_reporting (mysql_info);

  merror = mysql_errno(mysql_info->handler);
  err    = mysql_error(mysql_info->handler);
 
  mysql_info->last_error_int = merror;

  if (err != NULL) { strncpy (mysql_info->last_error_str, err, MYSQL_MAX_ERROR_SIZE); }
  else             { strncpy (mysql_info->last_error_str, "No error message available", MYSQL_MAX_ERROR_SIZE); }

  mysql_error_errno = mysql_info->last_error_int;
  strcpy (mysql_error_str, mysql_info->last_error_str);
 
  return;
}

/*! \brief Safely copy a specific error message to the error reporting system. This function is intended to
           set functional error message (that does not have MySql system error defined).
    \author Denis BEURIVE
    \param mysql_info mysql_info Pointer to a Mysql management structure.
    \param m Pointer to zero terminated string of characters that represents the error message to report.
 */

static void copy_error (struct smysql *mysql_info, char *m)
{
  clear_error_reporting (mysql_info);
  mysql_info->last_error_int = 0;
  mysql_error_errno          = 0;
  strncpy (mysql_info->last_error_str, m, MYSQL_MAX_ERROR_SIZE); 
  strcpy (mysql_error_str, mysql_info->last_error_str);
}


/*! \brief Initialise the Mysql management structure.
    \author Denis BEURIVE
    \param mysql_info Pointer to a Mysql management structure.
 */

void init_mysql_structure (struct smysql *mysql_info)
{
  mysql_info->handler                   = NULL;
  mysql_info->result                    = NULL;
  mysql_info->num_fields                = -1;
  mysql_info->num_rows                  = -1;
  mysql_info->last_connection_timestamp = 0;
  mysql_info->connected                 = 0;

  clear_error_reporting (mysql_info);
}

/*! \brief Connect to Mysql server.
    \author Denis BEURIVE
    \param mysql_info Pointer to a Mysql management structure that contains all the configuration for the
           connection.
    \return Upon successful completion, the function returns the value 0. 
            Otherwise it returns the value 1.
    \warning <UL>
               <LI>You must call the function init_mysql_structure() first.
               <LI>Then you may:
                   <UL>
                      <LI>Call load_mysql_configuration_from_file() if you want to load the configuration
                          from a file.
                      <LI>Initialize the MySql configuration data structure yourself and call
                          mysql_set_logger().
                   </UL>
               <LI>Don't forget to call disconnect_from_mysql() in order to free the allocated memory.
               <LI>We use the option CLIENT_FOUND_ROWS which modify the behavior of the function
                   mysql_affected_raws(). With this option, the function mysql_affected_raws() returns the
                   number of rows that matched the "WHERE" statement. In standard mode, the function
                   mysql_affected_raws() returns the number of rows that have been changed.
             </UL>
 */

int connect_to_mysql (struct smysql *mysql_info)
{
  MYSQL *connect_res;
  int   retry;
  int   (*my_syslog)(const char *file, const char * fmt,...);

  if ((mysql_info->my_syslog != NULL) && (mysql_info->log_file[0] != 0))
  { my_syslog = mysql_info->my_syslog; }
  else { my_syslog = my_fake_syslog; }


  retry = 0;
  clear_error_reporting(mysql_info);

  while (retry <= mysql_info->connect_retry)
  {
    /* ----------------------------------------------- */
    /* Free allocated memory, if necessary             */
    /* ----------------------------------------------- */

    if (mysql_info->handler != NULL) { mysql_close(mysql_info->handler); mysql_info->handler = NULL; }

    /* ----------------------------------------------- */
    /* Initialize the handler structure                */
    /* ----------------------------------------------- */

    mysql_info->handler = mysql_init(mysql_info->handler);
    if (mysql_info->handler == NULL)
    {
      set_last_error (mysql_info);
      mysql_info->connected = 0;
      return 1;
    } 

    /* ----------------------------------------------- */
    /* Set the connection timeout                      */
    /* ----------------------------------------------- */

    if (mysql_options(
                       mysql_info->handler,
                       MYSQL_OPT_CONNECT_TIMEOUT,
                       (char*)&(mysql_info->connect_timeout)) != 0)
    {
      set_last_error (mysql_info);
      mysql_info->connected = 0;
      return 1;
    }

    /* ----------------------------------------------- */
    /* Connect to mysql server                         */
    /* Note: the option CLIENT_FOUND_ROWS modify the   */
    /* behavior of function mysql_affected_rows().     */
    /* ----------------------------------------------- */

    connect_res = mysql_real_connect (  
                                       mysql_info->handler,
                                       mysql_info->host,
                                       mysql_info->user,
                                       mysql_info->passwd,
                                       mysql_info->db,
                                       mysql_info->port,
                                       mysql_info->socket,
                                       CLIENT_FOUND_ROWS
                                     );

    if (connect_res != NULL) { break; }

    /* ----------------------------------------------- */
    /* Could not connect to server, try again          */
    /* ----------------------------------------------- */

    my_syslog (mysql_info->log_file, "[WARNING] [%s:%d] Try to reconnect to MySql server (%d / %d)",
               __FILE__, __LINE__,
               retry,
               mysql_info->connect_retry);

    sleep (mysql_info->connect_sleep);

    retry++;
  }

  /* ------------------------------------------------- */
  /* We may not be connected ...                       */
  /* ------------------------------------------------- */

  if (retry > mysql_info->connect_retry)
  {
    set_last_error (mysql_info);
    mysql_info->connected = 0;
    return 1;
  } 

  my_syslog (mysql_info->log_file,
             "[INFO] [%s:%d] Connection successfully established with MySql server", __FILE__, __LINE__);

  mysql_info->connected = 1;
  return 0;
}

/*! \brief Close the connection with the Mysql server and free allocated memory.
    \author Denis BEURIVE
    \param mysql_info Pointer to a Mysql management structure.
 */

void disconnect_from_mysql(struct smysql *mysql_info)
{ if (mysql_info->handler != NULL) { mysql_close(mysql_info->handler); mysql_info->handler = NULL; } }

/*! \brief Execute SQL statements that does not return data (UPDATE, DELETE, INSERT, REPLACE and otjer).
    \author Denis BEURIVE
    \param mysql_info Pointer to a Mysql management structure.
    \param query SQL statement to execute.
    \return Upon successful completion, the function returns the number of rows matched by the "WHERE" statement.
            Otherwize, the function may return one of the following values:
            <UL>
               <LI>MYSQL_REQUEST_SKIPED
               <LI>MYSQL_CONNECTION_LOST
               <LI>MYSQL_RECONNECTION_FAILED
               <LI>MYSQL_SQL_PROBLEM
               <LI>MYSQL_UNEXPECTED_ERROR
            </UL>
    \warning <UL>
                <LI>Keep in mind that the function does __NOT__ return the number of rows that have been changed
                    by the request. The function returns the number of rows that matched the "WHERE" statement
                    (which may be different).
                <LI>If the connection to the MySql server is lost, then the client tries to reconnect. If it
                    can not reconnect, then the function returns on failure.
             </UL>
 */

static int standard_query (struct smysql *mysql_info, char* query)
{
  int   cr, n, err;
  int   (*my_syslog)(const char *file, const char * fmt,...);

  if ((mysql_info->my_syslog != NULL) && (mysql_info->log_file[0] != 0))
  { my_syslog = mysql_info->my_syslog; }
  else { my_syslog = my_fake_syslog; }


  #ifdef TEST_MYSQL_STANDART_QUERY
    fprintf (stdout, "Testing mysql.c::standard_query()\n");
    fprintf (stdout, "  Next action: <1> Test the connection state (UP/DOWN).\n"); 
    fprintf (stdout, "  Next action: <2> If status is DOWN, test the delay since last disconnection.\n");
    fprintf (stdout, "  Next action: <3> If status is DOWN, skip request or try to reconnect.\n");
    fprintf (stdout, "\n");
    fprintf (stdout, "  Press any key to continue.");
    getchar();
    fprintf (stdout, "\n\n");
  #endif

  clear_error_reporting(mysql_info);

  /* ------------------------------------------------- */
  /* If connection is down, skip request OR try to     */
  /* reconnect.                                        */
  /* ------------------------------------------------- */

  if (! mysql_info->connected)
  {
    time_t delta = time(NULL) - mysql_info->last_connection_timestamp;
    if (mysql_info->reconnection_delay == 0) { delta = 0; } 

    my_syslog (mysql_info->log_file,
               "[INFO] [%s:%d] MySql connection is down since %u seconds",
               __FILE__, __LINE__, delta);

    if ((delta > mysql_info->reconnection_delay) || (mysql_info->reconnection_delay == 0))
    {
         my_syslog (mysql_info->log_file,
                    "[INFO] [%s:%d] %u > %u => Try to reconnect to MySql server",
                    __FILE__, __LINE__, 
                    delta, mysql_info->reconnection_delay);

         /* ------------------------------------------ */
         /* Try to reconnect                           */
         /* ------------------------------------------ */

         disconnect_from_mysql (mysql_info);
         if (connect_to_mysql(mysql_info) == 1)
         {
           my_syslog (mysql_info->log_file,
           "[WARNING] [%s:%d] Could not reconnect to MySql", __FILE__, __LINE__);

           /* ---------------------------------------- */
           /* Connection to the server is down         */
           /* ---------------------------------------- */

           mysql_info->last_connection_timestamp = time(NULL);
           mysql_info->connected = 0;

           copy_error (mysql_info, "Could not reconnect to MySql"); 
           return MYSQL_RECONNECTION_FAILED;
         }
         else
         {
           mysql_info->last_connection_timestamp = 0;
           mysql_info->connected = 1;
         }
    }
    else {
           my_syslog (mysql_info->log_file,
           "[INFO] [%s:%d] %u < %u => Do not try to reconnect. Skip SQL request",
           __FILE__, __LINE__, 
           delta, mysql_info->reconnection_delay);
           copy_error (mysql_info, "SQL request skiped (this is normal, see configuration)");
           return MYSQL_REQUEST_SKIPED;
         }
  }

  /* ------------------------------------------------- */
  /* At this point, the connection should be up        */
  /* ------------------------------------------------- */

  #ifdef TEST_MYSQL_STANDART_QUERY
    fprintf (stdout, "Testing mysql.c::standard_query()\n");
    fprintf (stdout, "  Next action: <1> Perform the SQL query\n");
    fprintf (stdout, "\n");
    fprintf (stdout, "  Press any key to continue.");
    getchar();
    fprintf (stdout, "\n\n");
  #endif



  while (1)
  {
     clear_error_reporting(mysql_info);
     
     /* ------------------------------------------------- */
     /* Make sure that we are connected                   */
     /* ------------------------------------------------- */
     
     if (mysql_info->handler == NULL)
     { set_last_error (mysql_info); return MYSQL_UNEXPECTED_ERROR; }
     
     /* ------------------------------------------------- */
     /* Send the request to mysql server                  */
     /* ------------------------------------------------- */
     
     cr = mysql_query(mysql_info->handler, query);
     if (cr != 0)
     {
       set_last_error (mysql_info);

       my_syslog (mysql_info->log_file,
       "[INFO] [%s:%d] Query [%s] failed: %s (%d -- CR_SERVER_GONE_ERROR=%d, CR_SERVER_LOST=%d, CR_CONNECTION_ERROR=%d, ER_SERVER_SHUTDOWN=%d)",
                  __FILE__, __LINE__,
                  query,
                  mysql_info->last_error_str,
                  mysql_info->last_error_int,
                  CR_SERVER_GONE_ERROR,
                  CR_SERVER_LOST,
                  CR_CONNECTION_ERROR,
                  ER_SERVER_SHUTDOWN);
   
       /* ----------------------------------------------- */
       /* The server may have gone away...                */
       /* ----------------------------------------------- */
   
       err = mysql_errno(mysql_info->handler);
   
       if ((err == CR_SERVER_GONE_ERROR) || (err == CR_SERVER_LOST) || (err == CR_CONNECTION_ERROR) ||
           (err == ER_SERVER_SHUTDOWN))
       {
         my_syslog (mysql_info->log_file,
                    "[WARNING] [%s:%d] Connection lost with MySql server", __FILE__, __LINE__);

         disconnect_from_mysql (mysql_info);
         if (connect_to_mysql(mysql_info) == 1)
         {
           my_syslog (mysql_info->log_file, 
           "[WARNING] [%s:%d] Could not reconnect to MySql", __FILE__, __LINE__);

           /* ------------------------------------------- */
           /* Connection to the server is down            */
           /* ------------------------------------------- */

           mysql_info->last_connection_timestamp = time(NULL);
           mysql_info->connected = 0;
           set_last_error (mysql_info);
           return MYSQL_CONNECTION_LOST;
         }

         my_syslog (mysql_info->log_file,
                    "[INFO] [%s:%d] Connection successfully established with MySql", __FILE__, __LINE__);

         mysql_info->last_connection_timestamp = 0;
         mysql_info->connected = 1;

         continue;
       }
       else {
               my_syslog (mysql_info->log_file,
               "[INFO] [%s:%d] Some SQL error occured", __FILE__, __LINE__);
               set_last_error (mysql_info);
               return MYSQL_SQL_PROBLEM;
            }
     }

     break;
  }

  /* ------------------------------------------------- */
  /* Get the number of affected rows                   */
  /* ------------------------------------------------- */

  n = mysql_affected_rows(mysql_info->handler);

  return n;
}

/*! \brief Execute an UPDATE SQL statement.
    \author Denis BEURIVE
    \param mysql_info Pointer to a Mysql management structure.
    \param query SQL statement to execute.
    \return Upon successful completion, the function returns the number of rows matched by the "WHERE"
            statement.
            Otherwize, the function may return one of the following values:
            <UL>
               <LI>MYSQL_REQUEST_SKIPED
               <LI>MYSQL_CONNECTION_LOST
               <LI>MYSQL_RECONNECTION_FAILED
               <LI>MYSQL_SQL_PROBLEM
               <LI>MYSQL_UNEXPECTED_ERROR
            </UL>
    \warning Keep in mind that the function does __NOT__ return the number of rows that have been changed by
             the request. The function returns the number of rows that matched the "WHERE" statement
             (which may be different). 
 */

int sql_update (struct smysql *mysql_info, char* query) { return standard_query (mysql_info, query); }

/*! \brief Execute an INSERT SQL statement.
    \author Denis BEURIVE
    \param mysql_info Pointer to a Mysql management structure.
    \param query SQL statement to execute.
    \return Upon successful completion, the function returns the number of rows matched by the "WHERE"
            statement.
            Otherwize, the function may return one of the following values:
            <UL>
               <LI>MYSQL_REQUEST_SKIPED
               <LI>MYSQL_CONNECTION_LOST
               <LI>MYSQL_RECONNECTION_FAILED
               <LI>MYSQL_SQL_PROBLEM
               <LI>MYSQL_UNEXPECTED_ERROR
            </UL>
    \warning Keep in mind that the function does __NOT__ return the number of rows that have been changed by
             the request. The function returns the number of rows that matched the "WHERE" statement
             (which may be different). 
 */

int sql_insert (struct smysql *mysql_info, char* query) { return standard_query (mysql_info, query); }

/*! \brief Execute a REPLACE SQL statement.
    \author Denis BEURIVE
    \param mysql_info Pointer to a Mysql management structure.
    \param query SQL statement to execute.
    \return Upon successful completion, the function returns the number of rows matched by the "WHERE"
            statement.
            Otherwize, the function may return one of the following values:
            <UL>
               <LI>MYSQL_REQUEST_SKIPED
               <LI>MYSQL_CONNECTION_LOST
               <LI>MYSQL_RECONNECTION_FAILED
               <LI>MYSQL_SQL_PROBLEM
               <LI>MYSQL_UNEXPECTED_ERROR
            </UL>
    \warning Keep in mind that the function does __NOT__ return the number of rows that have been changed by
             the request. The function returns the number of rows that matched the "WHERE" statement
             (which may be different).
 */

int sql_replace (struct smysql *mysql_info, char* query) { return standard_query (mysql_info, query); }

/*! \brief Execute a DELETE SQL statement.
    \author Denis BEURIVE
    \param mysql_info Pointer to a Mysql management structure.
    \param query SQL statement to execute.
    \return Upon successful completion, the function returns the number of rows matched by the "WHERE"
            statement.
            Otherwize, the function may return one of the following values:
            <UL>
               <LI>MYSQL_REQUEST_SKIPED
               <LI>MYSQL_CONNECTION_LOST
               <LI>MYSQL_RECONNECTION_FAILED
               <LI>MYSQL_SQL_PROBLEM
               <LI>MYSQL_UNEXPECTED_ERROR
            </UL>
    \warning Keep in mind that the function does __NOT__ return the number of rows that have been changed by
             the request. The function returns the number of rows that matched the "WHERE" statement
             (which may be different). 
 */

int sql_delete (struct smysql *mysql_info, char* query) { return standard_query (mysql_info, query); }

/*! \brief Execute a SELECT SQL statement.
    \author Denis BEURIVE
    \param mysql_info Pointer to a Mysql management structure.
    \param query SQL statement to execute.
    \return Upon successful completion, the function returns the number of selected items.
            Otherwize, the function may return one of the following values:
            <UL>
               <LI>MYSQL_REQUEST_SKIPED
               <LI>MYSQL_CONNECTION_LOST
               <LI>MYSQL_RECONNECTION_FAILED
               <LI>MYSQL_SQL_PROBLEM
               <LI>MYSQL_UNEXPECTED_ERROR
            </UL>
    \warning Upon successful completion, the fonction stores results into the MySql data structure
             <I>mysql_info->result</I>. You must call the function mysql_free_result() in order to
             free all allocated memory. Note that if an error occured, you must <B>__NOT__</B> call 
             mysql_free_result().
 */

int sql_select (struct smysql *mysql_info, char* query)
{
  int cr, err;
  int (*my_syslog)(const char *file, const char * fmt,...);

  if ((mysql_info->my_syslog != NULL) && (mysql_info->log_file[0] != 0))
  { my_syslog = mysql_info->my_syslog; }
  else { my_syslog = my_fake_syslog; }
  
  clear_error_reporting (mysql_info);

  /* ------------------------------------------------- */
  /* If connection is down, skip request OR try to     */
  /* reconnect.                                        */
  /* ------------------------------------------------- */


  #ifdef TEST_MYSQL_STANDART_QUERY
    fprintf (stdout, "Testing mysql.c::sql_select()\n");
    fprintf (stdout, "  Next action: <1> Test the connection state (UP/DOWN).\n");
    fprintf (stdout, "  Next action: <2> If status is DOWN, test the delay since last disconnection.\n");
    fprintf (stdout, "  Next action: <3> If status is DOWN, skip request or try to reconnect.\n");
    fprintf (stdout, "\n");
    fprintf (stdout, "  Press any key to continue.");
    getchar();
    fprintf (stdout, "\n\n");
  #endif

  if (! mysql_info->connected)
  {
    time_t delta = time(NULL) - mysql_info->last_connection_timestamp;
    if (mysql_info->reconnection_delay == 0) { delta = 0; }

    my_syslog (mysql_info->log_file,
               "[INFO] [%s:%d] MySql connection down since %u seconds", __FILE__, __LINE__, delta);

    if ((delta > mysql_info->reconnection_delay) || (mysql_info->reconnection_delay == 0))
    {
         my_syslog (mysql_info->log_file,
                    "[INFO] [%s:%d] %u > %u => Try to reconnect",
                    __FILE__, __LINE__,
                    delta, mysql_info->reconnection_delay);
                 

         /* ------------------------------------------ */
         /* Try to reconnect                           */
         /* ------------------------------------------ */

         disconnect_from_mysql (mysql_info);
         if (connect_to_mysql(mysql_info) == 1)
         {
           my_syslog (mysql_info->log_file,
           "[WARNING] [%s:%d] Could not reconnect to MySql", __FILE__, __LINE__);

           /* ------------------------------------------- */
           /* Connection to the server is down            */
           /* ------------------------------------------- */

           mysql_info->last_connection_timestamp = time(NULL);
           mysql_info->connected = 0;

           copy_error (mysql_info, "Could not reconnect to database");
           return MYSQL_RECONNECTION_FAILED;
         }
         else
         {
           mysql_info->last_connection_timestamp = 0;
           mysql_info->connected = 1;
         }
    }
    else {
           my_syslog (mysql_info->log_file,
           "[INFO] [%s:%d] %u < %u => Do not try to reconnect. Skip SQL request",
           __FILE__, __LINE__,
           delta, mysql_info->reconnection_delay);

           copy_error (mysql_info, "SQL request skiped (this is normal - see configuration)");
           return MYSQL_REQUEST_SKIPED;
         }
  }

  /* ------------------------------------------------- */
  /* At this point, the connection should be up        */
  /* ------------------------------------------------- */

  #ifdef TEST_MYSQL_STANDART_QUERY
    fprintf (stdout, "Testing mysql.c::sql_select()\n");
    fprintf (stdout, "  Next action: <1> Perform the SQL query.\n");
    fprintf (stdout, "\n");
    fprintf (stdout, "  Press any key to continue.");
    getchar();
    fprintf (stdout, "\n\n");
  #endif

  while (1)
  {
    mysql_info->num_fields = -1;
    mysql_info->num_rows   = -1;

    clear_error_reporting(mysql_info);
  
    /* ------------------------------------------------- */
    /* Make sure that we are connected                   */
    /* ------------------------------------------------- */
  
    if (mysql_info->handler == NULL) { set_last_error (mysql_info); return MYSQL_UNEXPECTED_ERROR; }
  
    /* ------------------------------------------------- */
    /* Send the request to mysql server                  */
    /* ------------------------------------------------- */
  
    cr = mysql_query(mysql_info->handler, query);
    if (cr != 0)
    {
      set_last_error (mysql_info);

       my_syslog (mysql_info->log_file,
       "[INFO] [%s:%d] Query [%s] failed: %s (%d -- CR_SERVER_GONE_ERROR=%d, CR_SERVER_LOST=%d, CR_CONNECTION_ERROR=%d, ER_SERVER_SHUTDOWN=%d)",
                  __FILE__, __LINE__,
                  query,
                  mysql_info->last_error_str,
                  mysql_info->last_error_int,
                  CR_SERVER_GONE_ERROR,
                  CR_SERVER_LOST,
                  CR_CONNECTION_ERROR,
                  ER_SERVER_SHUTDOWN);

      /* ----------------------------------------------- */
      /* The server may have gone away                   */
      /* ----------------------------------------------- */

      err = mysql_errno(mysql_info->handler);

      if ((err == CR_SERVER_GONE_ERROR) || (err == CR_SERVER_LOST) || (err == CR_CONNECTION_ERROR) ||
          (err == ER_SERVER_SHUTDOWN))
      {
         my_syslog (mysql_info->log_file,
         "[WARNING] [%s:%d] Connection lost with MySql server", __FILE__, __LINE__);

         disconnect_from_mysql (mysql_info);
         if (connect_to_mysql(mysql_info) == 1)
         {
           my_syslog (mysql_info->log_file,
           "[WARNING] [%s:%d] Could not reconnect to MySql", __FILE__, __LINE__);

           /* ------------------------------------------- */
           /* Connection to the server is down            */
           /* ------------------------------------------- */

           mysql_info->last_connection_timestamp = time(NULL);
           mysql_info->connected = 0;

           copy_error (mysql_info, "Could not reconnect to the database");
           return MYSQL_RECONNECTION_FAILED;
         }

         my_syslog (mysql_info->log_file,
         "[INFO] [%s:%d] Connection successfully established with MySql", __FILE__, __LINE__);

         mysql_info->last_connection_timestamp = time(NULL);
         mysql_info->connected = 0;

         continue;
      }
      else {
              my_syslog (mysql_info->log_file,
              "[INFO] [%s:%d] Some SQL error occured", __FILE__, __LINE__);

              set_last_error (mysql_info);
              return MYSQL_SQL_PROBLEM;
           }
    }

    break;
  }

  /* ------------------------------------------------- */
  /* Get selected data                                 */
  /* ------------------------------------------------- */

  mysql_info->result = mysql_store_result(mysql_info->handler);
  if (mysql_info->result)
  {
    mysql_info->num_rows   = mysql_num_rows   (mysql_info->result);
    mysql_info->num_fields = mysql_num_fields (mysql_info->result);
  }
  else
  { set_last_error (mysql_info); return MYSQL_UNEXPECTED_ERROR; }

  return mysql_info->num_rows;
}

/*! \brief Load MySql configuration from a given configuration file.
    \author Denis BEURIVE
    \param path Path to the configuration file to parse.
    \param mysql_info Pointer to a MySql configuration data structure unsed to store the loaded configuration.
    \param tags Pointer to an array of zero terminated strinfs of characters. Each string represents one tag
           to load from the configuration file. Tags must be written in the following order:
           <UL>
              <LI>0  - Host name of the server that runs the database server.
              <LI>1  - User used to log to the database server.
              <LI>2  - Password used to log to the database server.
              <LI>3  - Name of the database.
              <LI>4  - TCP port number use to connect to the database server.
              <LI>5  - Path to the UNIX socket used for local connection to the database server.
              <LI>6  - Number of connection retry.
              <LI>7  - Connection timeout in seconds.
              <LI>8  - Delay of inactivity between 2 connection attempts.
              <LI>9  - Debug verbosity level.
              <LI>10 - Path to the log file used to log debug messages.
              <LI>11 - Number of seconds between 2 reconnection attempts.
           </UL><P>
           The size of the array is MYSQL_CONFIGURATION_TAG_NUMBER.
    \param logger Pointer to a logging function used to log message, if required. The function' signature 
           must be:<P>
           int (*logger) (const char *file, const char * fmt,...)<P>
           If NULL, then logging is not activated (no matter if a log file is defined).
    \return Upon successful completion, the function returns the value 0.
            Otherwize, the function returns the value 1.
    \warning If you do not want to specify a log file in the configuration file, then set the value of the
             tag "log-file" (index 10 in the array 'tags') to "desactivate logs".
 */

int load_mysql_configuration_from_file (
                                         char *path,
                                         struct smysql *mysql_info,
                                         char *tags[MYSQL_CONFIGURATION_TAG_NUMBER],
                                         int (*logger) (const char *file, const char * fmt,...)
                                       )
{
  int   res, e;
  char  *value;
  int   (*my_syslog)(const char *file, const char * fmt,...);

  /* ------------------------------------------------- */
  /* Manage logging service                            */
  /* ------------------------------------------------- */

  mysql_set_logger (logger, mysql_info);

  /* ------------------------------------------------- */
  /* Clear error reporting service                     */
  /* ------------------------------------------------- */

  clear_error_reporting(mysql_info);

  /* ------------------------------------------------- */
  /* Load the configuration file into memory           */
  /* ------------------------------------------------- */

  if (parse_configuration_file (path, &e) != PARSE_CONFIGURATION_OK)
  {
    snprintf (mysql_info->last_error_str, MYSQL_MAX_ERROR_SIZE,
              "Could not load the configuration file <%s> - %s",
              path,
              strerror(e));
    return 1;
  }

  /* ------------------------------------------------- */
  /* Set defaults                                      */
  /* ------------------------------------------------- */

  memset ((void*)mysql_info->host,      0, DB_HOST_MAX_SIZE);
  memset ((void*)mysql_info->user,      0, DB_USER_MAX_SIZE);
  memset ((void*)mysql_info->passwd,    0, DB_PASSWD_MAX_SIZE);
  memset ((void*)mysql_info->db,        0, DB_NAME_MAX_SIZE);
  memset ((void*)mysql_info->socket,    0, MYSQL_SOCKET_FILE_MAX_SIZE);
  memset ((void*)mysql_info->log_file,  0, MYSQL_DEBUG_FILE_MAX_SIZE);

  mysql_info->port               = 0;
  mysql_info->connect_retry      = 0;
  mysql_info->connect_timeout    = 0;
  mysql_info->connect_sleep      = 0;
  mysql_info->debug              = 0;
  mysql_info->reconnection_delay = 0;

  /* ------------------------------------------------- */
  /* Get the Host name                                 */
  /* ------------------------------------------------- */

  res = get_value (tags[0], &value);

  if (res == 0)
  {
    snprintf (mysql_info->last_error_str, MYSQL_MAX_ERROR_SIZE,
              "<%s>: tag '%s' is missing",
              path,
              tags[0]);
    return 1;
  }

  if (res == -1)
  {
    snprintf (mysql_info->last_error_str, MYSQL_MAX_ERROR_SIZE,
             "<%s>: Unexpected error while checking tag '%s'",
             path,
             tags[0]);
    return 1;
  }

  if (strlen(value) >= DB_HOST_MAX_SIZE)
  {
    snprintf (mysql_info->last_error_str, MYSQL_MAX_ERROR_SIZE,
             "<%s>: Tag '%s' is too long (buffer overflow avoided!)",
             path,
             tags[0]);
    return 1;
  }

  strcpy (mysql_info->host, value);

  /* ------------------------------------------------- */
  /* Get the user name                                 */
  /* ------------------------------------------------- */

  res = get_value (tags[1], &value);

  if (res == 0)
  {
    snprintf (mysql_info->last_error_str, MYSQL_MAX_ERROR_SIZE,
              "<%s>: tag '%s' is missing",
              path,
              tags[1]);
    return 1;
  }

  if (res == -1)
  {
    snprintf (mysql_info->last_error_str, MYSQL_MAX_ERROR_SIZE,
             "<%s>: Unexpected error while checking tag '%s'",
             path,
             tags[1]);
    return 1;
  }

  if (strlen(value) >= DB_USER_MAX_SIZE)
  {
    snprintf (mysql_info->last_error_str, MYSQL_MAX_ERROR_SIZE,
             "<%s>: Tag '%s' is too long (buffer overflow avoided!)",
             path,
             tags[1]);
    return 1;
  }

  strcpy (mysql_info->user, value);

  /* ------------------------------------------------- */
  /* Get the password                                  */
  /* ------------------------------------------------- */

  res = get_value (tags[2], &value);

  if (res == 0)
  {
    snprintf (mysql_info->last_error_str, MYSQL_MAX_ERROR_SIZE,
              "<%s>: tag '%s' is missing",
              path,
              tags[2]);
    return 1;
  }

  if (res == -1)
  {
    snprintf (mysql_info->last_error_str, MYSQL_MAX_ERROR_SIZE,
             "<%s>: Unexpected error while checking tag '%s'",
             path,
             tags[2]);
    return 1;
  }

  if (strlen(value) >= DB_PASSWD_MAX_SIZE)
  {
    snprintf (mysql_info->last_error_str, MYSQL_MAX_ERROR_SIZE,
             "<%s>: Tag '%s' is too long (buffer overflow avoided!)",
             path,
             tags[2]);
    return 1;
  }

  strcpy (mysql_info->passwd, value);

  /* ------------------------------------------------- */
  /* Get the database name                             */
  /* ------------------------------------------------- */

  res = get_value (tags[3], &value);

  if (res == 0)
  {
    snprintf (mysql_info->last_error_str, MYSQL_MAX_ERROR_SIZE,
              "<%s>: tag '%s' is missing",
              path,
              tags[3]);
    return 1;
  }

  if (res == -1)
  {
    snprintf (mysql_info->last_error_str, MYSQL_MAX_ERROR_SIZE,
             "<%s>: Unexpected error while checking tag '%s'",
             path,
             tags[3]);
    return 1;
  }

  if (strlen(value) >= DB_NAME_MAX_SIZE)
  {
    snprintf (mysql_info->last_error_str, MYSQL_MAX_ERROR_SIZE,
             "<%s>: Tag '%s' is too long (buffer overflow avoided!)",
             path,
             tags[3]);
    return 1;
  }

  strcpy (mysql_info->db, value);

  /* ------------------------------------------------- */
  /* Get the TCP port number                           */
  /* ------------------------------------------------- */

  res = get_value (tags[4], &value);

  if (res == 0)
  {
    snprintf (mysql_info->last_error_str, MYSQL_MAX_ERROR_SIZE,
              "<%s>: tag '%s' is missing",
              path,
              tags[4]);
    return 1;
  }

  if (res == -1)
  {
    snprintf (mysql_info->last_error_str, MYSQL_MAX_ERROR_SIZE,
             "<%s>: Unexpected error while checking tag '%s'",
             path,
             tags[4]);
    return 1;
  }

  mysql_info->port = atoi(value);

  /* ------------------------------------------------- */
  /* Get the UNIX socket path                          */
  /* ------------------------------------------------- */

  res = get_value (tags[5], &value);

  if (res == 0)
  {
    snprintf (mysql_info->last_error_str, MYSQL_MAX_ERROR_SIZE,
              "<%s>: tag '%s' is missing",
              path,
              tags[5]);
    return 1;
  }

  if (res == -1)
  {
    snprintf (mysql_info->last_error_str, MYSQL_MAX_ERROR_SIZE,
             "<%s>: Unexpected error while checking tag '%s'",
             path,
             tags[5]);
    return 1;
  }

  if (strlen(value) >= MYSQL_SOCKET_FILE_MAX_SIZE)
  {
    snprintf (mysql_info->last_error_str, MYSQL_MAX_ERROR_SIZE,
             "<%s>: Tag '%s' is too long (buffer overflow avoided!)",
             path,
             tags[5]);
    return 1;
  }

  strcpy (mysql_info->socket, value);

  /* ------------------------------------------------- */
  /* Get number of connect retries                     */
  /* ------------------------------------------------- */

  res = get_value (tags[6], &value);

  if (res == 0)
  {
    snprintf (mysql_info->last_error_str, MYSQL_MAX_ERROR_SIZE,
              "<%s>: tag '%s' is missing",
              path,
              tags[6]);
    return 1;
  }

  if (res == -1)
  {
    snprintf (mysql_info->last_error_str, MYSQL_MAX_ERROR_SIZE,
             "<%s>: Unexpected error while checking tag '%s'",
             path,
             tags[6]);
    return 1;
  }

  mysql_info->connect_retry = atoi(value);

  /* ------------------------------------------------- */
  /* Get the connect timout                            */
  /* ------------------------------------------------- */

  res = get_value (tags[7], &value);

  if (res == 0)
  {
    snprintf (mysql_info->last_error_str, MYSQL_MAX_ERROR_SIZE,
              "<%s>: tag '%s' is missing",
              path,
              tags[7]);
    return 1;
  }

  if (res == -1)
  {
    snprintf (mysql_info->last_error_str, MYSQL_MAX_ERROR_SIZE,
             "<%s>: Unexpected error while checking tag '%s'",
             path,
             tags[7]);
    return 1;
  }

  mysql_info->connect_timeout = atoi(value);

  /* ------------------------------------------------- */
  /* Get the inactivity period between 2 connections   */
  /* ------------------------------------------------- */

  res = get_value (tags[8], &value);

  if (res == 0)
  {
    snprintf (mysql_info->last_error_str, MYSQL_MAX_ERROR_SIZE,
              "<%s>: tag '%s' is missing",
              path,
              tags[8]);
    return 1;
  }

  if (res == -1)
  {
    snprintf (mysql_info->last_error_str, MYSQL_MAX_ERROR_SIZE,
             "<%s>: Unexpected error while checking tag '%s'",
             path,
             tags[8]);
    return 1;
  }

  mysql_info->connect_sleep = atoi(value);

  /* ------------------------------------------------- */
  /* Get the debug verbosity level                     */
  /* ------------------------------------------------- */

  res = get_value (tags[9], &value);

  if (res == 0)
  {
    snprintf (mysql_info->last_error_str, MYSQL_MAX_ERROR_SIZE,
              "<%s>: tag '%s' is missing",
              path,
              tags[9]);
    return 1;
  }

  if (res == -1)
  {
    snprintf (mysql_info->last_error_str, MYSQL_MAX_ERROR_SIZE,
             "<%s>: Unexpected error while checking tag '%s'",
             path,
             tags[9]);
    return 1;
  }

  mysql_info->debug = atoi(value);

  /* ------------------------------------------------- */
  /* Get the path to the log file                      */
  /* ------------------------------------------------- */

  res = get_value (tags[10], &value);

  if (res == 0)
  {
    snprintf (mysql_info->last_error_str, MYSQL_MAX_ERROR_SIZE,
              "<%s>: tag '%s' is missing",
              path,
              tags[10]);
    return 1;
  }

  if (res == -1)
  {
    snprintf (mysql_info->last_error_str, MYSQL_MAX_ERROR_SIZE,
             "<%s>: Unexpected error while checking tag '%s'",
             path,
             tags[10]);
    return 1;
  }

  if (strlen(value) >= MYSQL_DEBUG_FILE_MAX_SIZE)
  {
    snprintf (mysql_info->last_error_str, MYSQL_MAX_ERROR_SIZE,
             "<%s>: Tag '%s' is too long (buffer overflow avoided!)",
             path,
             tags[10]);
    return 1;
  }

  if ((strcmp(value, "desactivate logs") != 0) || (mysql_info->debug == 0))
     { strcpy (mysql_info->log_file, value); }

  /* ------------------------------------------------- */
  /* Get the reconnection delay                        */
  /* ------------------------------------------------- */

  res = get_value (tags[11], &value);

  if (res == 0)
  {
    snprintf (mysql_info->last_error_str, MYSQL_MAX_ERROR_SIZE,
              "<%s>: tag '%s' is missing",
              path,
              tags[11]);
    return 1;
  }

  if (res == -1)
  {
    snprintf (mysql_info->last_error_str, MYSQL_MAX_ERROR_SIZE,
             "<%s>: Unexpected error while checking tag '%s'",
             path,
             tags[11]);
    return 1;
  }

  mysql_info->reconnection_delay = atoi(value);

  /* ------------------------------------------------- */
  /* Log DEBUG data, if required                       */
  /* ------------------------------------------------- */

  if ((mysql_info->my_syslog != NULL) && (mysql_info->log_file[0] != 0))
  { my_syslog = mysql_info->my_syslog; }
  else { my_syslog = my_fake_syslog; }

  if (mysql_info->debug > 0)
  {
    char big_buffer[8000];

    snprintf (big_buffer, 8000,
              "host='%s', user='%s', passwd='%s', dbname='%s', port='%u', socket='%s', connect_retry='%d', connect_timeout='%d', connect_sleep='%d', debug='%d', log_file='%s', reconnection_delay='%lu'",
              mysql_info->host,
              mysql_info->user,
              mysql_info->passwd,
              mysql_info->db,
              mysql_info->port,
              mysql_info->socket,
              mysql_info->connect_retry,
              mysql_info->connect_timeout,
              mysql_info->connect_sleep,
              mysql_info->debug,
              mysql_info->log_file,
              mysql_info->reconnection_delay);

    my_syslog (mysql_info->log_file, "[DEBUG] [%s:%d] %s",
               __FILE__, __LINE__,
               big_buffer);
  }

  return 0;
}

/*! \brief Return the UNIX timestamp of the MySql server.
    \author Denis BEURIVE
    \param mysql_info Pointer to a 'struct smysql' that contains the Mysql configuration.
    \param error Pointer to an integer used to store an error code.
           Upon successful completion, the value pointed by 'error' is set to 0. 
           Otherwise, the value pointed by 'error' could be:
           <UL>
              <LI>MYSQL_REQUEST_SKIPED
              <LI>MYSQL_CONNECTION_LOST
              <LI>MYSQL_RECONNECTION_FAILED
              <LI>MYSQL_SQL_PROBLEM
              <LI>MYSQL_UNEXPECTED_ERROR
              <LI>MYSQL_NO_TIMESTAMP
           </UL>
    \return Upon successful completion (the value pointed by 'error' is set to 0), then the function
            returns the current UNIX timestamp of the MySql server. Otherwize, the function returns the
            value 0.
 */

time_t get_unix_timestamp (struct smysql *mysql_info, int *error)
{
  char               sql[] = "select UNIX_TIMESTAMP(now())";
  char               integer1[32];
  int                n, e;
  MYSQL_ROW          row;
  unsigned long int  *length;
  time_t             ttstp;
  int                (*my_syslog)(const char *file, const char * fmt,...);

  if ((mysql_info->my_syslog != NULL) && (mysql_info->log_file[0] != 0))
  { my_syslog = mysql_info->my_syslog; }
  else { my_syslog = my_fake_syslog; }



  if (mysql_info->debug > 1)
  { my_syslog (mysql_info->log_file, "[DEBUG] [%s,%d] SQL '%s'", __FILE__, __LINE__, sql); }

  *error = 0;

  /* ----------------------------------------------------- */
  /* Send request to MySql server                          */
  /* ----------------------------------------------------- */

  n = sql_select (mysql_info, sql);

  switch (n)
  {
    case MYSQL_REQUEST_SKIPED:
         my_syslog (mysql_info->log_file, "[WARNING] [%s,%d] Request skiped", __FILE__, __LINE__);
         *error = MYSQL_REQUEST_SKIPED;
         return 0;
    case MYSQL_CONNECTION_LOST:
         my_syslog (mysql_info->log_file, "[WARNING] [%s,%d] Coonection lost", __FILE__, __LINE__);
         *error = MYSQL_CONNECTION_LOST;
         return 0;
    case MYSQL_RECONNECTION_FAILED:
         my_syslog (mysql_info->log_file, "[WARNING] [%s,%d] Could not reconnect", __FILE__, __LINE__);
         *error = MYSQL_RECONNECTION_FAILED;
         return 0;
    case MYSQL_SQL_PROBLEM:
         my_syslog (mysql_info->log_file, "[ERROR] [%s,%d] Some SQL error", __FILE__, __LINE__);
         *error = MYSQL_SQL_PROBLEM; 
         return 0;
    case MYSQL_UNEXPECTED_ERROR:
         my_syslog (mysql_info->log_file, "[ERROR] [%s,%d] Unexpected error", __FILE__, __LINE__);
         *error = MYSQL_UNEXPECTED_ERROR;
         return 0;
    case 0:
         my_syslog (mysql_info->log_file, "[ERROR] [%s,%d] Could not get UNIX timestamp", __FILE__, __LINE__);
         *error = MYSQL_NO_TIMESTAMP;
         mysql_free_result(mysql_info->result);
         return 0;
  }

  if (mysql_info->debug > 1)
  { my_syslog (mysql_info->log_file, "[DEBUG] [%s,%d] Got %d result(s)", __FILE__, __LINE__, n); }

  /* ----------------------------------------------------- */
  /* Copy the result                                       */
  /* ----------------------------------------------------- */

  row    = mysql_fetch_row (mysql_info->result);
  length = mysql_fetch_lengths (mysql_info->result);

  if (mysql_info->debug > 1)
  {
    my_syslog (mysql_info->log_file,
    "[DEBUG] [%s,%d] Lengthes are: timestamp[%d]",
    __FILE__, __LINE__,
    length[0]);
  }

  memset ((void*)integer1, 0, 32);
  memcpy ((void*)integer1, (void*)row[0],
          (length[0] < 32) ? length[0] : 31);

  ttstp = (time_t)(string2unsigned_int (integer1, &e));

  mysql_free_result(mysql_info->result);
  return ttstp;
}

---