xdm_odbc.c

Go to the documentation of this file.

/*----------------------------------------------------------------------------
 * Copyright (c) 2006, Novell, Inc.
 * All rights reserved.
 * 
 * Redistribution and use in source and binary forms, with or without 
 * modification, are permitted provided that the following conditions are 
 * met:
 * 
 *     * Redistributions of source code must retain the above copyright 
 *       notice, this list of conditions and the following disclaimer.
 *     * Redistributions in binary form must reproduce the above copyright 
 *       notice, this list of conditions and the following disclaimer in the 
 *       documentation and/or other materials provided with the distribution.
 *     * Neither the name of the Novell nor the names of its contributors 
 *       may be used to endorse or promote products derived from this 
 *       software without specific prior written permission.
 * 
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 
 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR 
 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, 
 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, 
 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR 
 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF 
 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING 
 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS 
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *--------------------------------------------------------------------------*/

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

#ifdef _WIN32
# define WIN32_LEAN_AND_MEAN
# undef UNICODE
# pragma warning(disable: 4201) /* non-standard extension used : nameless structure/union */
# include <windows.h>
# define SQL_Window 0
# define XDMAPI __cdecl
# define XDMEXP __declspec(dllexport)
#else
# define SQL_Window 1
# define XDMAPI
# define XDMEXP
#endif

#include <sql.h>
#include <sqlext.h>

#define ARRAYSZ(x) (sizeof(x)/sizeof(*(x)))

#define XDM_DEF_CONNSTR "DSN=xdas;"

static void (*s_fplogmsg)(int level, const char * msg, ... ) = 0;

static char * (*s_fpgetcnfstr)(const char *, char *, size_t *) = 0;

static SQLHENV hsql = 0;
static SQLHDBC hdbc = 0;
static SQLHSTMT hstmt = 0;

static SQLCHAR * primary_stmt = (SQLCHAR *)
      "INSERT INTO xdas (xdasver, timestamp, tmuncert_int, tmuncert_ind, "
      "timesrc, tz, event, outcome, org_loc, org_addr, org_type, org_auth, "
      "org_pname, org_pid, int_auth, int_dsname, int_dsid, tgt_loc, tgt_addr, "
      "tgt_type, tgt_auth, tgt_pname, tgt_pid, esrc, edata) VALUES "
      "(?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)";

static struct xdr_tag
{
   char xdasver[16];
   char timesrc[256];
   char tz[10];
   unsigned long timestamp;
   unsigned long tm_uncert_int;
   unsigned long tm_uncert_ind;
   unsigned long event;
   unsigned long outcome;
   char org_loc[512];
   char org_addr[512];
   char org_type[512];
   char org_auth[512];
   char org_pname[512];
   char org_pid[512];
   char int_auth[512];
   char int_dsname[512];
   char int_dsid[512];
   char tgt_loc[512];
   char tgt_addr[512];
   char tgt_type[512];
   char tgt_auth[512];
   char tgt_pname[512];
   char tgt_pid[512];
   char esrc[1024];
   char edata[1024];
} xdr;

static struct pa_tag
{ 
   SQLSMALLINT c_type, s_type; 
   SQLUINTEGER csize; 
   SQLPOINTER pvp;
   SQLINTEGER blen; 
} pa[] = 
{
/*  C data type       SQL data type     Column Size                Buffer Addr         Buf Len
    ----------------- ----------------- -------------------------- ------------------- -------- */
   {SQL_UNKNOWN_TYPE, SQL_UNKNOWN_TYPE, 0,                         0,                  0},       /* 0  HDR:     */
   {SQL_UNKNOWN_TYPE, SQL_UNKNOWN_TYPE, 0,                         0,                  0},       /* 1  hex4len: */
   {SQL_C_CHAR,       SQL_VARCHAR,      sizeof(xdr.xdasver),       xdr.xdasver,        SQL_NTS}, /* 2  xdasver: */
   {SQL_C_ULONG,      SQL_INTEGER,      sizeof(xdr.timestamp),     &xdr.timestamp,     0},       /* 3  tstamp:  */
   {SQL_C_ULONG,      SQL_INTEGER,      sizeof(xdr.tm_uncert_int), &xdr.tm_uncert_int, 0},       /* 4  tuinter: */
   {SQL_C_ULONG,      SQL_INTEGER,      sizeof(xdr.tm_uncert_ind), &xdr.tm_uncert_ind, 0},       /* 5  tuindic: */
   {SQL_C_CHAR,       SQL_VARCHAR,      sizeof(xdr.timesrc),       xdr.timesrc,        SQL_NTS}, /* 6  tsrc:    */
   {SQL_C_CHAR,       SQL_VARCHAR,      sizeof(xdr.tz),            xdr.tz,             SQL_NTS}, /* 7  tzone:   */
   {SQL_C_ULONG,      SQL_INTEGER,      sizeof(xdr.event),         &xdr.event,         0},       /* 8  event:   */
   {SQL_C_ULONG,      SQL_INTEGER,      sizeof(xdr.outcome),       &xdr.outcome,       0},       /* 9  outcome: */
   {SQL_UNKNOWN_TYPE, SQL_UNKNOWN_TYPE, 0,                         0,                  0},       /* 10 ORG:     */
   {SQL_C_CHAR,       SQL_VARCHAR,      sizeof(xdr.org_loc),       xdr.org_loc,        SQL_NTS}, /* 11 orgloc:  */
   {SQL_C_CHAR,       SQL_VARCHAR,      sizeof(xdr.org_addr),      xdr.org_addr,       SQL_NTS}, /* 12 orgaddr: */
   {SQL_C_CHAR,       SQL_VARCHAR,      sizeof(xdr.org_type),      xdr.org_type,       SQL_NTS}, /* 13 orgtype: */
   {SQL_C_CHAR,       SQL_VARCHAR,      sizeof(xdr.org_auth),      xdr.org_auth,       SQL_NTS}, /* 14 orgauth: */
   {SQL_C_CHAR,       SQL_VARCHAR,      sizeof(xdr.org_pname),     xdr.org_pname,      SQL_NTS}, /* 15 orgpname:*/
   {SQL_C_CHAR,       SQL_VARCHAR,      sizeof(xdr.org_pid),       xdr.org_pid,        SQL_NTS}, /* 16 orgpid:  */
   {SQL_UNKNOWN_TYPE, SQL_UNKNOWN_TYPE, 0,                         0,                  0},       /* 17 INT:     */
   {SQL_C_CHAR,       SQL_VARCHAR,      sizeof(xdr.int_auth),      xdr.int_auth,       SQL_NTS}, /* 18 intauth: */
   {SQL_C_CHAR,       SQL_VARCHAR,      sizeof(xdr.int_dsname),    xdr.int_dsname,     SQL_NTS}, /* 19 intdsnam:*/
   {SQL_C_CHAR,       SQL_VARCHAR,      sizeof(xdr.int_dsid),      xdr.int_dsid,       SQL_NTS}, /* 20 intdsid: */
   {SQL_UNKNOWN_TYPE, SQL_UNKNOWN_TYPE, 0,                         0,                  0},       /* 21 TGT:     */
   {SQL_C_CHAR,       SQL_VARCHAR,      sizeof(xdr.tgt_loc),       xdr.tgt_loc,        SQL_NTS}, /* 22 tgtloc:  */
   {SQL_C_CHAR,       SQL_VARCHAR,      sizeof(xdr.tgt_addr),      xdr.tgt_addr,       SQL_NTS}, /* 23 tgtaddr: */
   {SQL_C_CHAR,       SQL_VARCHAR,      sizeof(xdr.tgt_type),      xdr.tgt_type,       SQL_NTS}, /* 24 tgttype: */
   {SQL_C_CHAR,       SQL_VARCHAR,      sizeof(xdr.tgt_auth),      xdr.tgt_auth,       SQL_NTS}, /* 25 tgtauth: */
   {SQL_C_CHAR,       SQL_VARCHAR,      sizeof(xdr.tgt_pname),     xdr.tgt_pname,      SQL_NTS}, /* 26 tgtpname:*/
   {SQL_C_CHAR,       SQL_VARCHAR,      sizeof(xdr.tgt_pid),       xdr.tgt_pid,        SQL_NTS}, /* 27 tgtpid:  */
   {SQL_UNKNOWN_TYPE, SQL_UNKNOWN_TYPE, 0,                         0,                  0},       /* 28 SRC:     */
   {SQL_C_CHAR,       SQL_VARCHAR,      sizeof(xdr.esrc),          xdr.esrc,           SQL_NTS}, /* 29 src:     */
   {SQL_UNKNOWN_TYPE, SQL_UNKNOWN_TYPE, 0,                         0,                  0},       /* 30 EVT:     */
   {SQL_C_CHAR,       SQL_VARCHAR,      sizeof(xdr.edata),         xdr.edata,          SQL_NTS}, /* 31 edata:   */
   {SQL_UNKNOWN_TYPE, SQL_UNKNOWN_TYPE, 0,                         0,                  0},       /* 32 END      */
};

static SQLINTEGER ind[ARRAYSZ(pa)];

static void logsqlerr(const char * fn, SQLHANDLE handle, 
      SQLSMALLINT type, SQLRETURN rc)
{
   SQLINTEGER i = 0;
   SQLINTEGER native;
   SQLCHAR state[32];
   SQLCHAR text[512];
   SQLSMALLINT len;

   (*s_fplogmsg)(0, "xdm_odbc: ODBC reported %d during %s:\n", rc, fn);

   do
   {
      if (SQL_SUCCEEDED(rc = SQLGetDiagRec(type, handle, 
            (SQLSMALLINT)++i, state, &native, text, sizeof(text), &len)))
         (*s_fplogmsg)(0, "xdm_odbc: (cont) %s:%ld:%ld:%s\n", state, i, native, text);
   }
   while (SQL_SUCCEEDED(rc));
}

static int getmsgparam(const char * cp, const char * ep, 
      SQLSMALLINT type, SQLPOINTER buf, SQLUINTEGER bufsz)
{
   switch(type)
   {
      case SQL_C_ULONG:
      {
         char tmp[64];
         size_t cnt = ep - cp > sizeof(tmp) - 1? sizeof(tmp) - 1: ep - cp;
         memcpy(tmp, cp, cnt);
         tmp[cnt] = 0;
         *(unsigned long *)buf = strtoul(tmp, 0, 16);
         break;
      }
      case SQL_C_CHAR:
      {
         unsigned i;
         char * op = (char *)buf;
         for (i = 0; cp < ep && i < bufsz - 1; i++, cp++)
         {
            if (*cp == '%') cp++;   /* skip escape characters */
            op[i] = *cp;
         }
         op[i] = 0;
         break;
      }
   }
   return 0;
}

static int parsemsg(const char ** msgflds)
{
   int i;

   for (i = 0; i < ARRAYSZ(pa); i++)
   {
      /* extract only fields we care about */
      if (pa[i].pvp && getmsgparam(msgflds[i], msgflds[i+1], 
            pa[i].c_type, pa[i].pvp, pa[i].csize) != 0)
         return -1;
   }
   return 0;
}

static void sql_disconnect(void)
{
   if (hstmt != 0)
      SQLFreeHandle(SQL_HANDLE_STMT, hstmt);
   if (hdbc != 0)
   {
      SQLDisconnect(hdbc);
      SQLFreeHandle(SQL_HANDLE_DBC, hdbc);
   }
   hstmt = hdbc = 0;
}

static int sql_connect(void)
{
   int i;
   SQLRETURN rc;
   SQLUSMALLINT j;
   char connstr[512];
   size_t connstrsz = sizeof(connstr);

   if (!SQL_SUCCEEDED(rc = SQLAllocHandle(SQL_HANDLE_DBC, hsql, &hdbc)))
   {
      (*s_fplogmsg)(0, "xdm_odbc: SQLAllocHandle(SQL_HANDLE_DBC) failed, %d.\n", rc);
      sql_disconnect();
      return -1;
   }
   
   /* Read connection string from the configuration file. */
   (*s_fpgetcnfstr)("xdasd.loggers.odbc.connstr", connstr, &connstrsz);
   if (connstrsz == 0)
      strcpy(connstr, XDM_DEF_CONNSTR);

   if (!SQL_SUCCEEDED(rc = SQLDriverConnect(hdbc, (SQLHWND)SQL_Window, 
         (SQLCHAR*)connstr, SQL_NTS, 0, 0, 0, SQL_DRIVER_COMPLETE)))
   {
      logsqlerr("SQLDriverConnect", hdbc, SQL_HANDLE_DBC, rc);
      sql_disconnect();
      return -1;
   }

   (*s_fplogmsg)(0, "xdm_odbc: Connection established using [%s].\n", connstr);

   if (!SQL_SUCCEEDED(rc = SQLAllocHandle(SQL_HANDLE_STMT, hdbc, &hstmt)))
   {
      (*s_fplogmsg)(0, "xdm_odbc: SQLAllocHandle(SQL_HANDLE_STMT) failed, %d.\n", rc);
      sql_disconnect();
      return -1;
   }
   if (!SQL_SUCCEEDED(rc = SQLPrepare(hstmt, primary_stmt, SQL_NTS)))
   {
      (*s_fplogmsg)(0, "xdm_odbc: SQLPrepare failed, %d.\n", rc);
      sql_disconnect();
      return -1;
   }
   for (i = 0, j = 1; i < ARRAYSZ(pa); i++)
   {
      if (pa[i].pvp)
      {
         ind[i] = pa[i].blen;
         if (!SQL_SUCCEEDED(rc = SQLBindParameter(hstmt, j++, SQL_PARAM_INPUT, 
               pa[i].c_type, pa[i].s_type, pa[i].csize, 0, pa[i].pvp, 0, &ind[i])))
         {
            logsqlerr("SQLBindParameter", hstmt, SQL_HANDLE_STMT, rc);
            sql_disconnect();
            return -1;
         }
      }
   }
   return 0;
}

XDMEXP int XDMAPI xdm_append(const char ** msgflds)
{
   int err;
   SQLRETURN rc;

   if ((err = parsemsg(msgflds)) != 0)
   {
      (*s_fplogmsg)(0, "xdm_odbc: Parse failed, error %d, for message:\n[ %s ]\n", 
            msgflds[0]);
      return -1;
   }

   /* first time? - establish initial connection and prepare statement */
   if (hdbc == 0 && (err = sql_connect()) != 0)
      return -1;     /* sql_connect logs its own errors */

   /* attempt one: execute the statement */
   if (!SQL_SUCCEEDED(rc = SQLExecute(hstmt)))
   {
      /* statement execution failed - disconnect and attempt to reconnect */
      sql_disconnect();
      if ((err = sql_connect()) != 0)
      {
         (*s_fplogmsg)(0, "xdm_odbc: ODBC Reconnect attempt failed.\n");
         return -1;
      }
      else
      {
         /* now try statement execution again */
         if (!SQL_SUCCEEDED(rc = SQLExecute(hstmt)))
         {
            logsqlerr("SQLExecute(SQL_HANDLE_STMT)", hstmt, SQL_HANDLE_STMT, rc);
            return -1;
         }
      }
   }
   return 0;
}

XDMEXP void XDMAPI xdm_exit(void)
{
   sql_disconnect();
   SQLFreeHandle(SQL_HANDLE_ENV, hsql);
   hsql = 0;
}

XDMEXP int XDMAPI xdm_init(void (*logmsg)(int level, const char * msg, ... ),
      char * (*getcnfstr)(const char *, char *, size_t *))
{
   SQLRETURN rc;

   s_fplogmsg = logmsg;       /* save logmsg function pointer */
   s_fpgetcnfstr = getcnfstr; /* save get conf str function pointer */

   /* establish environment handle and set ODBC version */
   if (!SQL_SUCCEEDED(rc = SQLAllocHandle(SQL_HANDLE_ENV, SQL_NULL_HANDLE, &hsql)))
   {
      (*s_fplogmsg)(0, "xdm_odbc: SQLAllocHandle(SQL_HANDLE_ENV) failed, %d.\n", rc);
      return -1;
   }
   if (!SQL_SUCCEEDED(rc = SQLSetEnvAttr(hsql, SQL_ATTR_ODBC_VERSION, (void *)SQL_OV_ODBC3, 0)))
   {
      (*s_fplogmsg)(0, "xdm_odbc: SQLSetEnvAttr(SQL_ATTR_ODBC_VERSION) failed, %d.\n", rc);
      SQLFreeHandle(SQL_HANDLE_ENV, hsql);
      return -1;
   }
   return 0;
}