xdas_stub.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.
 *--------------------------------------------------------------------------*/

#define XDAS_STATIC
#include <xdas.h>

#ifdef _WIN32
# define WIN32_LEAN_AND_MEAN
# include <windows.h>
# define libhandle_t HANDLE
# define LOAD_LIBRARY(n)      LoadLibraryA(n)
# define FREE_LIBRARY(h)      FreeLibrary((h))
# define IMPORT_SYMBOL(h,n)   (fptr_t)GetProcAddress((h),(n))
# define LN_XDAS_CLIENT       "libxdas.dll"
#else
# include <config.h>
# ifndef HAVE_DLFCN_H
#  error Unable to build the stub library without dynamic linking.
# endif
# include <dlfcn.h>
# define libhandle_t void *
# define LOAD_LIBRARY(n)      dlopen((n), RTLD_NOW)
# define FREE_LIBRARY(h)      dlclose((h))
# define IMPORT_SYMBOL(h,n)   (fptr_t)dlsym((h),(n))
# define LN_XDAS_CLIENT       "libxdas.so"
#endif

/* this set of names works for windows and linux - perhaps others... */

#define FN_XDAS_INITIALIZE_SESSION     "xdas_initialize_session"
#define FN_XDAS_TERMINATE_SESSION      "xdas_terminate_session"
#define FN_XDAS_CLOSE_AUDIT_STREAM     "xdas_close_audit_stream"
#define FN_XDAS_GET_NEXT               "xdas_get_next"
#define FN_XDAS_OPEN_AUDIT_STREAM      "xdas_open_audit_stream"
#define FN_XDAS_PARSE_RECORD           "xdas_parse_record"
#define FN_XDAS_REWIND_AUDIT_STREAM    "xdas_rewind_audit_stream"
#define FN_XDAS_IMPORT_EVENT_RECORDS   "xdas_import_event_records"
#define FN_XDAS_COMMIT_RECORD          "xdas_commit_record"
#define FN_XDAS_DISCARD_RECORD         "xdas_discard_record"
#define FN_XDAS_PUT_EVENT_INFO         "xdas_put_event_info"
#define FN_XDAS_START_RECORD           "xdas_start_record"
#define FN_XDAS_TIMESTAMP_RECORD       "xdas_timestamp_record"
#define FN_XDAS_CREATE_FILTER          "xdas_create_filter"
#define FN_XDAS_DELETE_FILTER          "xdas_delete_filter"
#define FN_XDAS_DISABLE_FILTER         "xdas_disable_filter"
#define FN_XDAS_ENABLE_FILTER          "xdas_enable_filter"
#define FN_XDAS_GET_FILTER             "xdas_get_filter"
#define FN_XDAS_LIST_FILTERS           "xdas_list_filters"

typedef void (*fptr_t)(void);

typedef struct
{
   const char * fname;
   fptr_t * fpp;
} fptable_t;

typedef int XDASAPI xdas_initialize_session_t(int * minor_status, const char * org_info, xdas_audit_ref_t * das_ref);
typedef int XDASAPI xdas_terminate_session_t(int * minor_status, xdas_audit_ref_t * das_ref);
typedef int XDASAPI xdas_close_audit_stream_t(int * minor_status, xdas_audit_ref_t das_ref, xdas_audit_stream_t * audit_stream_ref);
typedef int XDASAPI xdas_get_next_t(int * minor_status, xdas_audit_ref_t das_ref, xdas_audit_stream_t audit_stream_ref, unsigned max_records, xdas_buffer_t audit_record_buffer, unsigned * no_of_records);
typedef int XDASAPI xdas_open_audit_stream_t(int * minor_status, xdas_audit_ref_t das_ref, xdas_audit_stream_t * audit_stream_ref); 
typedef int XDASAPI xdas_parse_record_t(int * minor_status, xdas_audit_ref_t das_ref, xdas_buffer_t audit_record_buffer, unsigned record_number, xdas_audit_record_t audit_record);
typedef int XDASAPI xdas_rewind_audit_stream_t(int * minor_status, xdas_audit_ref_t das_ref, xdas_audit_stream_t audit_stream_ref); 
typedef int XDASAPI xdas_import_event_records_t(int * minor_status, xdas_audit_ref_t das_ref, xdas_buffer_t audit_record_buffer, size_t * position_in_buffer);
typedef int XDASAPI xdas_commit_record_t(int * minor_status, xdas_audit_ref_t das_ref, xdas_audit_rec_desc_t * audit_record_descriptor); 
typedef int XDASAPI xdas_discard_record_t(int * minor_status, xdas_audit_ref_t das_ref, xdas_audit_rec_desc_t * audit_record_descriptor);
typedef int XDASAPI xdas_put_event_info_t(int * minor_status, xdas_audit_ref_t das_ref, xdas_audit_rec_desc_t * audit_record_descriptor, unsigned event_number, unsigned outcome, const char * initiator_information, const char * target_information, const char * event_information);
typedef int XDASAPI xdas_start_record_t(int * minor_status, xdas_audit_ref_t das_ref, xdas_audit_rec_desc_t * audit_record_descriptor, unsigned event_number, unsigned outcome, const char * initiator_information, const char * target_information, const char * event_information);
typedef int XDASAPI xdas_timestamp_record_t(int * minor_status, xdas_audit_ref_t das_ref, xdas_audit_rec_desc_t audit_record_descriptor); 
typedef int XDASAPI xdas_create_filter_t(int * minor_status, xdas_audit_ref_t das_ref, const char * name, unsigned filter_type, const char * filter_exp, const char * filter_act);
typedef int XDASAPI xdas_delete_filter_t(int * minor_status, xdas_audit_ref_t das_ref, const char * name);
typedef int XDASAPI xdas_disable_filter_t(int * minor_status, xdas_audit_ref_t das_ref, const char * name); 
typedef int XDASAPI xdas_enable_filter_t(int * minor_status, xdas_audit_ref_t das_ref, const char * name);
typedef int XDASAPI xdas_get_filter_t(int * minor_status, xdas_audit_ref_t das_ref, const char * name, unsigned * filter_type, xdas_buffer_t filter_exp, xdas_buffer_t filter_act, unsigned * filter_status);
typedef int XDASAPI xdas_list_filters_t(int * minor_status, xdas_audit_ref_t das_ref, char ** filter_name_list, size_t * buffer_size);

static xdas_initialize_session_t * fp_xdas_initialize_session;
static xdas_terminate_session_t * fp_xdas_terminate_session;
static xdas_close_audit_stream_t * fp_xdas_close_audit_stream;
static xdas_get_next_t * fp_xdas_get_next;
static xdas_open_audit_stream_t * fp_xdas_open_audit_stream;
static xdas_parse_record_t * fp_xdas_parse_record;
static xdas_rewind_audit_stream_t * fp_xdas_rewind_audit_stream;
static xdas_import_event_records_t * fp_xdas_import_event_records;
static xdas_commit_record_t * fp_xdas_commit_record;
static xdas_discard_record_t * fp_xdas_discard_record;
static xdas_put_event_info_t * fp_xdas_put_event_info;
static xdas_start_record_t * fp_xdas_start_record;
static xdas_timestamp_record_t * fp_xdas_timestamp_record;
static xdas_create_filter_t * fp_xdas_create_filter;
static xdas_delete_filter_t * fp_xdas_delete_filter;
static xdas_disable_filter_t * fp_xdas_disable_filter;
static xdas_enable_filter_t * fp_xdas_enable_filter;
static xdas_get_filter_t * fp_xdas_get_filter;
static xdas_list_filters_t * fp_xdas_list_filters;

static fptable_t xdas_ftable[] = {
   {FN_XDAS_INITIALIZE_SESSION,     (fptr_t*)&fp_xdas_initialize_session},
   {FN_XDAS_TERMINATE_SESSION,      (fptr_t*)&fp_xdas_terminate_session},
   {FN_XDAS_CLOSE_AUDIT_STREAM,     (fptr_t*)&fp_xdas_close_audit_stream},
   {FN_XDAS_GET_NEXT,               (fptr_t*)&fp_xdas_get_next},
   {FN_XDAS_OPEN_AUDIT_STREAM,      (fptr_t*)&fp_xdas_open_audit_stream},
   {FN_XDAS_PARSE_RECORD,           (fptr_t*)&fp_xdas_parse_record},
   {FN_XDAS_REWIND_AUDIT_STREAM,    (fptr_t*)&fp_xdas_rewind_audit_stream},
   {FN_XDAS_IMPORT_EVENT_RECORDS,   (fptr_t*)&fp_xdas_import_event_records},
   {FN_XDAS_COMMIT_RECORD,          (fptr_t*)&fp_xdas_commit_record},
   {FN_XDAS_DISCARD_RECORD,         (fptr_t*)&fp_xdas_discard_record},
   {FN_XDAS_PUT_EVENT_INFO,         (fptr_t*)&fp_xdas_put_event_info},
   {FN_XDAS_START_RECORD,           (fptr_t*)&fp_xdas_start_record},
   {FN_XDAS_TIMESTAMP_RECORD,       (fptr_t*)&fp_xdas_timestamp_record},
   {FN_XDAS_CREATE_FILTER,          (fptr_t*)&fp_xdas_create_filter},
   {FN_XDAS_DELETE_FILTER,          (fptr_t*)&fp_xdas_delete_filter},
   {FN_XDAS_DISABLE_FILTER,         (fptr_t*)&fp_xdas_disable_filter},
   {FN_XDAS_ENABLE_FILTER,          (fptr_t*)&fp_xdas_enable_filter},
   {FN_XDAS_GET_FILTER,             (fptr_t*)&fp_xdas_get_filter},
   {FN_XDAS_LIST_FILTERS,           (fptr_t*)&fp_xdas_list_filters},
};

static libhandle_t xdas_lib_handle = 0;

static void unload_xdas_client(void)
{
   FREE_LIBRARY(xdas_lib_handle);
   xdas_lib_handle = 0;
}

static void load_xdas_client(void)
{
   if (xdas_lib_handle == 0 
         && (xdas_lib_handle = LOAD_LIBRARY(LN_XDAS_CLIENT)) != 0)
   {
      int i;
      for (i = 0; i < sizeof(xdas_ftable)/sizeof(*xdas_ftable); i++)
         if ((*xdas_ftable[i].fpp = IMPORT_SYMBOL(xdas_lib_handle, 
                  xdas_ftable[i].fname)) == 0)
         {
            unload_xdas_client();
            break;
         }
   }
}

/*---------------------------------------------------------------------------
 */
XDASXPC int XDASAPI xdas_initialize_session(
      int * minor_status,
      const char * org_info,
      xdas_audit_ref_t * das_ref)
{
   if (xdas_lib_handle == 0)
      load_xdas_client();
   return xdas_lib_handle == 0? XDAS_S_SERVICE_FAILURE
         : fp_xdas_initialize_session(minor_status, org_info, das_ref);
}

/*---------------------------------------------------------------------------
 */
XDASXPC int XDASAPI xdas_terminate_session(
      int * minor_status,
      xdas_audit_ref_t * das_ref)
{
   int rv = 0;
   if (xdas_lib_handle != 0)
   {
      rv = xdas_lib_handle == 0? XDAS_S_SERVICE_FAILURE
            : fp_xdas_terminate_session(minor_status, das_ref);
      unload_xdas_client();
   }
   return rv;
}

/*---------------------------------------------------------------------------
 */
XDASXPC int XDASAPI xdas_close_audit_stream(
      int * minor_status,
      xdas_audit_ref_t das_ref,
      xdas_audit_stream_t * audit_stream_ref)
{
   return xdas_lib_handle == 0? XDAS_S_SERVICE_FAILURE
         : fp_xdas_close_audit_stream(minor_status, das_ref, 
               audit_stream_ref);
}

/*---------------------------------------------------------------------------
 */
XDASXPC int XDASAPI xdas_get_next(
      int * minor_status,
      xdas_audit_ref_t das_ref,
      xdas_audit_stream_t audit_stream_ref,
      unsigned max_records,
      xdas_buffer_t audit_record_buffer,
      unsigned * no_of_records)
{
   return xdas_lib_handle == 0? XDAS_S_SERVICE_FAILURE
         : fp_xdas_get_next(minor_status, das_ref, audit_stream_ref, 
               max_records, audit_record_buffer, no_of_records);
}

/*---------------------------------------------------------------------------
 */
XDASXPC int XDASAPI xdas_open_audit_stream(
      int * minor_status,
      xdas_audit_ref_t das_ref,
      xdas_audit_stream_t * audit_stream_ref)
{
   return xdas_lib_handle == 0? XDAS_S_SERVICE_FAILURE
         : fp_xdas_open_audit_stream(minor_status, das_ref, 
               audit_stream_ref);
}

/*---------------------------------------------------------------------------
 */
XDASXPC int XDASAPI xdas_parse_record(
      int * minor_status,
      xdas_audit_ref_t das_ref,
      xdas_buffer_t audit_record_buffer,
      unsigned record_number,
      xdas_audit_record_t audit_record)
{
   return xdas_lib_handle == 0? XDAS_S_SERVICE_FAILURE
         : fp_xdas_parse_record(minor_status, das_ref, 
               audit_record_buffer, record_number, audit_record);
}

/*---------------------------------------------------------------------------
 */
XDASXPC int XDASAPI xdas_rewind_audit_stream(
      int * minor_status,
      xdas_audit_ref_t das_ref,
      xdas_audit_stream_t audit_stream_ref)
{
   return xdas_lib_handle == 0? XDAS_S_SERVICE_FAILURE
         : fp_xdas_rewind_audit_stream(minor_status, das_ref, 
               audit_stream_ref);
}

/*---------------------------------------------------------------------------
 */
XDASXPC int XDASAPI xdas_import_event_records(
      int * minor_status,
      xdas_audit_ref_t das_ref,
      xdas_buffer_t audit_record_buffer,
      size_t * position_in_buffer)
{
   return xdas_lib_handle == 0? XDAS_S_SERVICE_FAILURE
         : fp_xdas_import_event_records(minor_status, das_ref, 
               audit_record_buffer, position_in_buffer);
}

/*---------------------------------------------------------------------------
 */
XDASXPC int XDASAPI xdas_commit_record(
      int * minor_status,
      xdas_audit_ref_t das_ref,
      xdas_audit_rec_desc_t * audit_record_descriptor)
{
   return xdas_lib_handle == 0? XDAS_S_SERVICE_FAILURE
         : fp_xdas_commit_record(minor_status, das_ref, 
               audit_record_descriptor);
}

/*---------------------------------------------------------------------------
 */
XDASXPC int XDASAPI xdas_discard_record(
      int * minor_status,
      xdas_audit_ref_t das_ref,
      xdas_audit_rec_desc_t * audit_record_descriptor)
{
   return xdas_lib_handle == 0? XDAS_S_SERVICE_FAILURE
         : fp_xdas_discard_record(minor_status, das_ref, 
               audit_record_descriptor);
}

/*---------------------------------------------------------------------------
 */
XDASXPC int XDASAPI xdas_put_event_info(
      int * minor_status,
      xdas_audit_ref_t das_ref,
      xdas_audit_rec_desc_t * audit_record_descriptor,
      unsigned event_number,
      unsigned outcome,
      const char * initiator_information,
      const char * target_information,
      const char * event_information)
{
   return xdas_lib_handle == 0? XDAS_S_SERVICE_FAILURE
         : fp_xdas_put_event_info(minor_status, das_ref, 
               audit_record_descriptor, event_number, outcome, 
               initiator_information, target_information,
               event_information);
}

/*---------------------------------------------------------------------------
 */
XDASXPC int XDASAPI xdas_start_record(
      int * minor_status,
      xdas_audit_ref_t das_ref,
      xdas_audit_rec_desc_t * audit_record_descriptor,
      unsigned event_number,
      unsigned outcome,
      const char * initiator_information,
      const char * target_information,
      const char * event_information)
{
   return xdas_lib_handle == 0? XDAS_S_SERVICE_FAILURE
         : fp_xdas_start_record(minor_status, das_ref, 
               audit_record_descriptor, event_number, outcome, 
               initiator_information, target_information, 
               event_information);
}

/*---------------------------------------------------------------------------
 */
XDASXPC int XDASAPI xdas_timestamp_record(
      int * minor_status,
      xdas_audit_ref_t das_ref,
      xdas_audit_rec_desc_t audit_record_descriptor)
{
   return xdas_lib_handle == 0? XDAS_S_SERVICE_FAILURE
         : fp_xdas_timestamp_record(minor_status, das_ref, 
               audit_record_descriptor);
}

/*---------------------------------------------------------------------------
 */
XDASXPC int XDASAPI xdas_create_filter(
      int * minor_status,
      xdas_audit_ref_t das_ref,
      const char * name,
      unsigned filter_type,
      const char * filter_exp,
      const char * filter_act)
{
   return xdas_lib_handle == 0? XDAS_S_SERVICE_FAILURE
         : fp_xdas_create_filter(minor_status, das_ref, 
               name, filter_type, filter_exp, filter_act);
}

/*---------------------------------------------------------------------------
 */
XDASXPC int XDASAPI xdas_delete_filter(
      int * minor_status,
      xdas_audit_ref_t das_ref,
      const char * name)
{
   return xdas_lib_handle == 0? XDAS_S_SERVICE_FAILURE
         : fp_xdas_delete_filter(minor_status, das_ref, name);
}

/*---------------------------------------------------------------------------
 */
XDASXPC int XDASAPI xdas_disable_filter(
      int * minor_status,
      xdas_audit_ref_t das_ref,
      const char * name)
{
   return xdas_lib_handle == 0? XDAS_S_SERVICE_FAILURE
         : fp_xdas_disable_filter(minor_status, das_ref, name);
}

/*---------------------------------------------------------------------------
 */
XDASXPC int XDASAPI xdas_enable_filter(
      int * minor_status,
      xdas_audit_ref_t das_ref,
      const char * name)
{
   return xdas_lib_handle == 0? XDAS_S_SERVICE_FAILURE
         : fp_xdas_enable_filter(minor_status, das_ref, name);
}

/*---------------------------------------------------------------------------
 */
XDASXPC int XDASAPI xdas_get_filter(
      int * minor_status,
      xdas_audit_ref_t das_ref,
      const char * name,
      unsigned * filter_type,
      xdas_buffer_t filter_exp,
      xdas_buffer_t filter_act,
      unsigned * filter_status)
{
   return xdas_lib_handle == 0? XDAS_S_SERVICE_FAILURE
         : fp_xdas_get_filter(minor_status, das_ref, name, 
               filter_type, filter_exp, filter_act, filter_status);
}

/*---------------------------------------------------------------------------
 */
XDASXPC int XDASAPI xdas_list_filters(
      int * minor_status,
      xdas_audit_ref_t das_ref,
      char ** filter_name_list,
      size_t * buffer_size)
{
   return xdas_lib_handle == 0? XDAS_S_SERVICE_FAILURE
         : fp_xdas_list_filters(minor_status, das_ref, 
               filter_name_list, buffer_size);
}