common.cpp

Go to the documentation of this file.

/*****************************************************************************\
*                                                                             *
*  Name   : common support for db apps.                                       *
*  Author : Chris Koeritz                                                     *
*  Author : freetds team for some support definitions                         *
*                                                                             *
*******************************************************************************
* Copyright (c) 2008-$now By Author.  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; either version 2 of   *
* the License or (at your option) any later version.  This is online at:      *
*     http://www.fsf.org/copyleft/gpl.html                                    *
* Please send any updates to: fred@gruntose.com                               *
\*****************************************************************************/

#include "common.h"

#include <basis/istring.h>
#include <basis/log_base.h>
#include <basis/program_wide_logger.h>

#if HAVE_UNISTD_H
  #include <unistd.h>
#endif

#if HAVE_LIBGEN_H
  #include <libgen.h>
#endif /* HAVE_LIBGEN_H */

#if HAVE_SYS_PARAM_H
  #include <sys/param.h>
#endif /* HAVE_SYS_PARAM_H */

#include <stdlib.h>
#include <string.h>

bool common_database_support::_error_was_seen = false;
  // starts out healthy anyway.

int common_database_support::syb_msg_handler(DBPROCESS * dbproc, DBINT msgno,
    int msgstate, int severity, char *msgtext, char *srvname, char *procname,
    int line)
{
  char var_value[31];
  int i;
  char *c;
  int *pexpected_msgno;
  
  /*
   * Check for "database changed", or "language changed" messages from
   * the client.  If we get one of these, then we need to pull the
   * name of the database or charset from the message and set the
   * appropriate variable.
   */
  if (msgno == 5701 ||  /* database context change */
      msgno == 5703 ||  /* language changed */
      msgno == 5704) {  /* charset changed */

    /* program_wide_logger().log(isprintf("msgno = %d: %s", msgno, msgtext)) ; */

    if (msgtext != NULL && (c = strchr(msgtext, '\'')) != NULL) {
      i = 0;
      for (++c; i <= 30 && *c != '\0' && *c != '\''; ++c)
        var_value[i++] = *c;
      var_value[i] = '\0';
    }
    // this condition is not considered an error, apparently.
    return 0;
  }

  /*
   * If the user data indicates this is an expected error message (because we're testing the 
   * error propogation, say) then indicate this message was anticipated.
   */
  if (dbproc != NULL) {
    pexpected_msgno = (int *) dbgetuserdata(dbproc);
    if (pexpected_msgno && *pexpected_msgno == msgno) {
      program_wide_logger().log(isprintf("OK: anticipated message arrived: %d %s", msgno, msgtext));
      *pexpected_msgno = 0;
      return 0;
    }
  }
  /*
   * If the severity is something other than 0 or the msg number is
   * 0 (user informational messages).
   */
  if (severity >= 0 || msgno == 0) {
    /*
     * If the message was something other than informational, and
     * the severity was greater than 0, then print information to
     * stderr with a little pre-amble information.
     */
    if (msgno > 0 && severity > 0) {
      istring err_msg;
      err_msg += isprintf("ERROR: Msg %d, Level %d, State %d\n", (int) msgno, (int) severity, (int) msgstate);
      err_msg += isprintf("Server '%s'", srvname);
      if (procname != NULL && *procname != '\0')
        err_msg += isprintf(", Procedure '%s'", procname);
      if (line > 0)
        err_msg += isprintf(", Line %d", line);
      err_msg += isprintf("\n");
      err_msg += isprintf("%s", msgtext);
      program_wide_logger().log(err_msg);
      // this is actually considered an error; first and only case here.
      _error_was_seen = true;
    } else {
      /*
       * Otherwise, it is just an informational (e.g. print) message
       * from the server, so send it to stdout.
       */
      program_wide_logger().log(msgtext);
    }
  }
  return 0;
}

int common_database_support::syb_err_handler(DBPROCESS * dbproc, int severity,
    int dberr, int oserr, char *dberrstr, char *oserrstr)
{
  int *pexpected_dberr;

  /*
   * For server messages, cancel the query and rely on the
   * message handler to spew the appropriate error messages out.
   */
  if (dberr == SYBESMSG) {
    // we think this is a real error case.
    _error_was_seen = true;
    return INT_CANCEL;
  }

  /*
   * If the user data indicates this is an expected error message (because we're testing the 
   * error propogation, say) then indicate this message was anticipated.
   */
  if (dbproc != NULL) {
    pexpected_dberr = (int *) dbgetuserdata(dbproc);
    if (pexpected_dberr && *pexpected_dberr == dberr) {
      program_wide_logger().log(isprintf("OK: anticipated error %d (%s) arrived", dberr, dberrstr));
      *pexpected_dberr = 0;
      return INT_CANCEL;
    }
  }

  program_wide_logger().log(isprintf("ERROR: in db-library (severity %d, dberr %d, oserr %d, dberrstr %s, oserrstr %s):",
    severity, dberr, oserr, dberrstr ? dberrstr : "(null)", oserrstr ? oserrstr : "(null)"));
  // we also think that anything after here is a real error.
  _error_was_seen = true;

  /*
   * If the dbprocess is dead or the dbproc is a NULL pointer and
   * we are not in the middle of logging in, then we need to exit.
   * We can't do anything from here on out anyway.
   * It's OK to end up here in response to a dbconvert() that
   * resulted in overflow, so don't exit in that case.
   */
  if ((dbproc == NULL) || DBDEAD(dbproc)) {
    if (dberr != SYBECOFL) {
      // we cannot allow this to exit, even with a bad database pointer.
      // instead, pass through to return bad value.
    }
  }
  return INT_CANCEL;
}

void common_database_support::nerf_special_characters(istring &to_nerf,
    char escape_char)
{
  for (int i = 0; i < to_nerf.length(); i++) {
    const char current = to_nerf[i];
    switch (current) {
      // the first bank of cases are all handled identically.
//      case '%':  // sql wildcard character (matches any number of chars).
//      case '_':  // sql wildcard for one character match.
//      case '*':  // sql wildcard for any column (may not be needed, but safer).
//      case '&':  // sql special character for variable substitutions.
//      case '[':  // sql special character starts literal phrases.
//      {
//        // put an escape before this character.
//        to_nerf.insert(i, istring(escape_char, 1));
//        i++;  // skip the next position, since we have offset the string.
//        break;
//      }
      case '\'': {
        // handle a single quote the sql way--add another single quote.
        to_nerf.insert(i, istring('\'', 1));  // put a new single quote in.
        i++;  // skip the next position, since we have offset the string.
        break;
      }
      default:
        // don't bother doing anything here.
        break;
    }
  }  
}

---