xdasd_parse.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 "xdasd_parse.h"
#include "xdasd_list.h"
#include "xdasd_log.h"

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

static int prs_check_key_fields(Parsed * parsed)
{
   static const struct keys { char key[5]; int field; } keys[] = 
   {
      {"HDR:",  0}, {"ORG:", 10}, {"INT:", 17}, {"TGT:", 21},
      {"SRC:", 28}, {"EVT:", 30}, {"END\0",32},
   };
   unsigned i;

   for (i = 0; i < sizeof(keys)/sizeof(*keys); i++)
   {
      int fldnum = keys[i].field;
      size_t fldsz = parsed->parsed[fldnum + 1] - parsed->parsed[fldnum];
      if (fldsz != sizeof(keys[i].key) - 1
            || memcmp(keys[i].key, parsed->parsed[fldnum], fldsz) != 0)
      {
         xdasd_log(1, "prs_check_key_fields: %s field missing in event.\n", 
               keys[i].key);
         return 0;
      }
   }
   return 1;   /* True: all key fields present and accounted for. */
}

static void log_parsed_message(int level, Parsed * pp)
{
   /* don't waste the effort if the level isn't high enough... */
   if (level <= xdasd_log_level())
   {
      char * buf;
      unsigned psz = strlen(pp->msg);

      /* 32 fields * 6 extra chars per field + 1 null terminator */
      if ((buf = (char *)malloc(psz + 32 * 6 + 1)) == 0)
         xdasd_log(0, "Out of memory in log_parsed_message, %s(%d)\n",
               __FILE__, __LINE__);
      else
      {
         int i;
         char * bp = buf;
         for (i = 0; i < 32; i++)
            bp += sprintf(bp, "%3d:\"%.*s\"", i, 
                  (pp->parsed[i + 1] - pp->parsed[i]), pp->parsed[i]);
         xdasd_log(level, "xdasd_parse_message: structsz = %u, "
               "flags = %08X, severity = %d, parsed fields: [%s]\n", 
               pp->structsz, pp->flags, pp->severity, buf);
      }
   }
}

int xdasd_parse_message(unsigned flags, size_t msgsz, const char * msg, 
      Parsed ** parsedp)
{
   unsigned i;
   Parsed * pp;
   char * cp, * limit;
   size_t allocsz = offsetof(Parsed, msg) + msgsz + 1;

   if ((pp = (Parsed *)malloc(allocsz)) == 0)
       return -1;
   memset(pp, 0, offsetof(Parsed, parsed));  /* clear all fields to parsed */

   /* copy message into end of parsed buffer */
   pp->structsz = allocsz;
   pp->flags = flags;
   memcpy(pp->msg, msg, msgsz);
   pp->msg[msgsz] = 0;     /* null-terminate message */

   /* parse the message into field pointers */
   cp = pp->msg;
   limit = cp + msgsz;
   for (i = 0; i < XDAS_FIELD_COUNT && cp < limit; i++)
   {
      pp->parsed[i] = cp;
      while (cp < limit && (*cp != ':' || cp > pp->msg && cp[-1] == '%'))
         cp++;
      cp++;                /* move past the colon delimiter */
   }
   pp->parsed[i] = cp;

   /* see if all fields are accounted for */
   if (i < XDAS_FIELD_COUNT || !prs_check_key_fields(pp))
   {
      free(pp);
      if (i < XDAS_FIELD_COUNT)
         xdasd_log(1, "xdasd_parse_message: insufficient fields in event.");
      return -2;
   }

   log_parsed_message(15, pp);

   /* return the allocated Parsed structure, and success */
   *parsedp = pp;
   return 0;
}

void xdasd_parse_set_log_state(Parsed * parsed, int state)
{
   if (state != 0) 
      parsed->flags |= PMF_LOG; 
   else
      parsed->flags &= ~PMF_LOG;
}

void xdasd_parse_set_alarm_severity(Parsed * parsed, int severity)
{
   if (severity > 0)
      parsed->flags |= PMF_ALARM;
   else
      parsed->flags &= ~PMF_ALARM;
   parsed->severity = severity; 
}

int xdasd_parse_set_trigger(Parsed * parsed, const char * script)
{
   parsed->flags |= PMF_TRIGGER;
   if (script)
   {
      Trigger * t;
      size_t scriptsz = strlen(script) + 1;
   
      /* allocate an action structure long enough to hold the script */
      if ((t = (Trigger *)malloc(offsetof(Trigger, script) + scriptsz)) == 0)
         return -1;
   
      /* copy data into action structure */
      memcpy(t->script, script, scriptsz);
   
      /* link new action node into parsed message. */
      xdasd_list_link_tail(&parsed->triggers, (XDLItem *)t);
   }
   return 0;
}

void xdasd_parse_clear_actions(Parsed * parsed)
{
   XDLItem * ip = parsed->triggers.head;
   while (ip)
   {
      XDLItem * del = ip;
      ip = ip->next;
      free(del);
   }
   memset(&parsed->triggers, 0, sizeof(parsed->triggers));
   parsed->severity = 0;
   parsed->flags &= ~(PMF_LOG | PMF_ALARM | PMF_TRIGGER);
}

void xdasd_parse_free(Parsed * parsed)
{
   xdasd_parse_clear_actions(parsed);
   free(parsed);
}

/*==========================================================================*/

#ifdef XDASD_PARSE_TEST

void xdasd_log(int level, const char * fmt, ... ) 
{
#ifdef LOG_TO_STDOUT
   va_list args;
   va_start(args, fmt);
   vprintf(fmt, args);
   va_end(args);
#else
   (void)fmt;
#endif
}

int xdasd_log_level(void) { return 0; }

int main(int argc, char ** argv)
{
   static char msg[] = 
   /*  0 */ "HDR:"
   /*  1 */ "00A8:"
   /*  2 */ "OX1:"
   /*  3 */ "1F883AD5:"
   /*  4 */ ":"
   /*  5 */ ":"
   /*  6 */ "time.nist.gov:"
   /*  7 */ "MST7MDT:"
   /*  8 */ "0x10000001:"
   /*  9 */ "0:"
   /* 10 */ "ORG:"
   /* 11 */ "org_location_name:"
   /* 12 */ "http%:\\org.location.address:"
   /* 13 */ "org_service_type:"
   /* 14 */ "org_auth_authority:"
   /* 15 */ "org_principal_name:"
   /* 16 */ "org_principal_id:"
   /* 17 */ "INT:"
   /* 18 */ "int_auth_authority:"
   /* 19 */ "int_domain_specific_name:"
   /* 20 */ "int_domain_specific_id:"
   /* 21 */ "TGT:"
   /* 22 */ "tgt_location_name:"
   /* 23 */ "http%:\\tgt.location.address:"
   /* 24 */ "tgt_service_type:"
   /* 25 */ "tgt_auth_authority:"
   /* 26 */ "tgt_principal_name:"
   /* 27 */ "tgt_principal_id:"
   /* 28 */ "SRC:"
   /* 29 */ "pointer_to_source_domain:"
   /* 30 */ "EVT:"
   /* 31 */ "event_specific_information:"
   /* 32 */ "END";

   Parsed * parsed;
   int i, err, rv = 0;
   unsigned flags = 0;

   (void)argc;
   (void)argv;

   if ((err = xdasd_parse_message(flags, sizeof(msg) - 1, msg, &parsed)) != 0)
      return err;

   rv = 0;
   if (parsed->structsz != offsetof(Parsed, msg) + sizeof(msg))
      rv++;

   if (parsed->flags != flags)
      rv++;

   if (memcmp(parsed->msg, msg, sizeof(msg)) != 0)
      rv++;

   for (i = 0; i < XDAS_FIELD_COUNT + 1; i++)
      if (parsed->parsed[i] < parsed->msg 
            || parsed->parsed[i] > parsed->msg + sizeof(msg) + 1)
         rv++;

   xdasd_parse_free(parsed);
   return rv;
}

#endif