libxdas_records.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 <xdas.h>
#include <xdasd.h>
#include <xdas_buf.h>
#include <xdas_wire.h>

#include "libxdas_impl.h"

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

#ifdef _WIN32
# define snprintf _snprintf
#endif

static size_t xdas_calc_max_record_len(xdas_session * xs, xdas_record * xr)
{
   unsigned i;
   size_t fmtsz;

   fmtsz = 4   /* HDR: */
         + 5   /* <hex_4_character_zero_padded_length_in_bytes>: */
         + sizeof(XDAS_RECORD_VERSION)
               /* <XDAS record format version>: */
         + 9   /* <hex_time_offset>: */
         + 9   /* <hex_time_uncertainty_interval>: */
         + 9   /* <hex_time_uncertainty_indicator>: */
         + strlen(xs->time_source) + 1   
               /* <str_time_source>: */
         + strlen(xs->time_zone) + 1       
               /* <str_time_zone>: */
         + 9   /* <hex_event_number>: */
         + 9;  /* <hex_outcome>: */

   fmtsz += 4; /* ORG:
                * <org_location_name>:
                * <org_location_address>:
                * <org_service-type>:
                * <org_auth_authority>:
                * <org_principal_name>:
                * <org_principal_id>:
                */
   for (i = 0; i < xdas_elemcount(xs->org_info) && xs->org_info[i]; i++)
      fmtsz += strlen(xs->org_info[i]) + 1;
   for (; i< xdas_elemcount(xs->org_info); i++)
      fmtsz++;

   fmtsz += 4; /* INT:
                * <int_auth_authority>:
                * <int_domain_specific_name>:
                * <int_domain_specific_id>:
                */
   for (i = 0; i < xdas_elemcount(xr->int_info) && xr->int_info[i]; i++)
      fmtsz += strlen(xr->int_info[i]) + 1;
   for (; i< xdas_elemcount(xr->int_info); i++)
      fmtsz++;

   fmtsz += 4; /* TGT:
                * <tgt_location_name>:
                * <tgt_location_address>:
                * <tgt_service-type>:
                * <tgt_auth_authority>:
                * <tgt_principal_name>:
                * <tgt_principal_id>:
                */
   for (i = 0; i < xdas_elemcount(xr->tgt_info) && xr->tgt_info[i]; i++)
      fmtsz += strlen(xr->tgt_info[i]) + 1;
   for (; i< xdas_elemcount(xr->tgt_info); i++)
      fmtsz++;

   fmtsz += 4  /* SRC: */
         + (xr->src_ref? strlen(xr->src_ref): 0) + 1; 
               /* <pointer_to_source_domain>: */

   fmtsz +=4   /* EVT: */
         + (xr->evt_info? strlen(xr->evt_info): 0) + 1   
               /* <event_specific_information>: */
         + 4;  /* END\0 */

   /* XDAS records can never be larger than 64K */
   if (fmtsz > MAX_XDAS_REC_SIZE)
      fmtsz = MAX_XDAS_REC_SIZE;

   return fmtsz;
}

static int xdas_format_record(xdas_session * xs, xdas_record * xr)
{
   char * fmt;
   int sret;
   unsigned fmtlen, i, ccnt;
   size_t fmtsz = xdas_calc_max_record_len(xs, xr);

   /* allocate buffer for record string */
   if ((fmt = (char *)malloc(fmtsz)) == 0)
      return -1;

   /* HDR:
    * <hex_4_character_zero_padded_length_in_bytes>:
    * <max_16_char_version_str>:
    * <hex_time_offset>:
    * <hex_time_uncertainty_interval>:
    * <hex_time_uncertainty_indicator>:
    * <str_time_source>:
    * <str_time_zone>:
    * <hex_event_number>:
    * <hex_outcome>:
    */
   sret = snprintf(fmt, fmtsz, 
         "HDR:0000:" XDAS_RECORD_VERSION ":%x:%x:%x:%s:%s:%x:%x:", 
         xr->time_offset, xs->time_uncert_int,
         xs->time_uncert_ind, xs->time_source, xs->time_zone,
         xr->event_number, xr->outcome);
   if (sret < 0 || sret > (int)fmtsz) return -1;
   ccnt = sret;

   /* ORG:
    * <org_location_name>:
    * <org_location_address>:
    * <org_service-type>:
    * <org_auth_authority>:
    * <org_principal_name>:
    * <org_principal_id>:
    */
   sret = snprintf(fmt + ccnt, fmtsz - ccnt, "ORG:");
   if (sret < 0 || sret > (int)(fmtsz - ccnt)) return -1;
   ccnt += sret;
   for (i = 0; i < xdas_elemcount(xs->org_info) && xs->org_info[i]; i++)
   {
      sret = snprintf(fmt + ccnt, fmtsz - ccnt, "%s:", xs->org_info[i]);
      if (sret < 0 || sret > (int)(fmtsz - ccnt)) return -1;
      ccnt += sret;
   }
   for (; i < xdas_elemcount(xs->org_info); i++)
      fmt[ccnt++] = ':';

   /* INT:
    * <int_auth_authority>:
    * <int_domain_specific_name>:
    * <int_domain_specific_id>:
    */
   sret = snprintf(fmt + ccnt, fmtsz - ccnt, "INT:");
   if (sret < 0 || sret > (int)(fmtsz - ccnt)) return -1;
   ccnt += sret;
   for (i = 0; i < xdas_elemcount(xr->int_info) && xr->int_info[i]; i++)
   {
      sret = snprintf(fmt + ccnt, fmtsz - ccnt, "%s:", xr->int_info[i]);
      if (sret < 0 || sret > (int)(fmtsz - ccnt)) return -1;
      ccnt += sret;
   }
   for (; i < xdas_elemcount(xr->int_info); i++)
      fmt[ccnt++] = ':';

   /* TGT:
    * <tgt_location_name>:
    * <tgt_location_address>:
    * <tgt_service-type>:
    * <tgt_auth_authority>:
    * <tgt_principal_name>:
    * <tgt_principal_id>:
    */
   sret = snprintf(fmt + ccnt, fmtsz - ccnt, "TGT:");
   if (sret < 0 || sret > (int)(fmtsz - ccnt)) return -1;
   ccnt += sret;
   for (i = 0; i < xdas_elemcount(xr->tgt_info) && xr->tgt_info[i]; i++)
   {
      sret = snprintf(fmt + ccnt, fmtsz - ccnt, "%s:", xr->tgt_info[i]);
      if (sret < 0 || sret > (int)(fmtsz - ccnt)) return -1;
      ccnt += sret;
   }
   for (; i < xdas_elemcount(xr->tgt_info); i++)
      fmt[ccnt++] = ':';

   /* SRC:
    * <pointer_to_source_domain>:
    * EVT:
    * <event_specific_information>:
    * "END\0"
    */
   sret = snprintf(fmt + ccnt, fmtsz - ccnt, "SRC:%s:EVT:%s:END", 
         xr->src_ref? xr->src_ref: "", xr->evt_info? xr->evt_info: "");
   if (sret < 0 || sret > (int)(fmtsz - ccnt)) return -1;
   ccnt += sret;

   /* put the record length, and replace the colon character */
   fmtlen = ccnt;
   sprintf(fmt + 4, "%04hx", (unsigned short)ccnt);
   fmt[4 + 4] = ':';

   /* is data different? */
   if (fmtlen == xr->fmtlen && strcmp(fmt, xr->fmt) == 0)
   {
      free(fmt);  /* no, free temp buffer, return "no change" */
      return 1;
   }

   /* yes, free existing, set new */
   free(xr->fmt);
   xr->fmt = fmt;
   xr->fmtlen = fmtlen;
   return 0;
}

xdas_record * xdas_validate_record(xdas_audit_rec_desc_t record_ref) 
{
   xdas_record * xr = (xdas_record *)record_ref;
   return (xr && xr->signature == XDAS_RECORD_SIG)? xr: 0;
}

unsigned xdas_get_next_record_number(void)
{
   static unsigned g_recnum = 0;
   return ++g_recnum;
}

void xdas_set_record_timestamp(xdas_record * xr)
{
   xr->time_offset = (unsigned)time(0);
}

int xdas_is_valid_outcome(unsigned outcome)
{
   switch(outcome & 0x000000FF)
   {
      case XDAS_OUT_SUCCESS:  return !(outcome & ~0x00003FFF);
      case XDAS_OUT_FAILURE:  return !(outcome & ~0x000FFFFF);
      case XDAS_OUT_DENIAL :  return !(outcome & ~0x000007FF);
   }
   return 0;   /* no outcome class matched */
}

void xdas_internal_discard_record(xdas_record * xr)
{
   free(xr->int_info[0]);
   free(xr->tgt_info[0]);
   free(xr->src_ref);
   free(xr->evt_info);
   free(xr->fmt);
   free(xr);
}

int xdas_send_record(int * minorp, xdas_session * xs, 
      xdas_record * xr, int eval, int import)
{
   int rv;

   /* format record to add in string and length */
   if ((rv = xdas_format_record(xs, xr)) < 0)
      return (*minorp = OXDAS_MS_OUT_OF_MEMORY), XDAS_S_FAILURE;

   /* if record modified or if we're submitting send request */
   if (rv == 0 || !eval)
   {
      xdas_buffer req;
      size_t reqsz = 5 * sizeof(uint32_t) + xr->fmtlen;
   
      /* resize request buffer */
      if ((req = xdas_buffer_realloc(xs->req, reqsz)) == 0)
         return (*minorp = OXDAS_MS_OUT_OF_MEMORY), XDAS_S_FAILURE;
      req->curpos = req->start;
      xs->req = req;

      /* put header and data request fields */
      xdas_buffer_put_uint32(req, reqsz);
      xdas_buffer_put_uint32(req, XDASD_REQ_EVENT);
      xdas_buffer_put_uint32(req, eval? XDASD_EVT_SRQ_CHECK: XDASD_EVT_SRQ_SUBMIT);
      xdas_buffer_put_uint32(req, import? 1: 0);
      xdas_buffer_put_uint32(req, xr->fmtlen);
      memcpy(req->curpos, xr->fmt, xr->fmtlen);
      req->curpos += xr->fmtlen;
   
      /* Send request, return status and response buffer. */
      xr->last_status = xdas_req_rsp(minorp, xs);
   }
   return xr->last_status;
}