---

eventLog.cpp

Go to the documentation of this file.

#include "eventLog.h"
#include "rmClientTypes.h"
#include "rmClient.h"

eventLog::eventLog(eventQuery * aEventQuery) 
{
  mDefaultQuery = 0;
  mLogFilePath.erase();
  mEventQuery = aEventQuery;
  // mLastBuf = NULL;
}

eventLog::~eventLog()
{
  posix_log_close(mLog);
}

int
eventLog::init()
{
  int ret;

  const char * path = NULL;

  if(mLogFilePath.size())
    path = mLogFilePath.c_str();

  ret = posix_log_open(&mLog, path);
  if(ret) 
    return RMCLIENT_ERROR_LOG_OPEN;

  return RMCLIENT_SUCCESS;
}

const EventLog *
eventLog::getConstElement(unsigned long aID)
{
  int ret;

  if(mLastEntry.entry.log_recid == aID)
    return & mLastEntry;
  else {
    ret = findId(aID);
    if(ret)
      return NULL;
    else 
      return & mLastEntry;
  }
}

int
eventLog::findId(unsigned long aID)
{
  unsigned long next;
  return SearchAndReadLog(FIND_ID, aID, next);
}

int
eventLog::getNextId(unsigned long aID, unsigned long & aNextID)
{
  return SearchAndReadLog(FIND_NEXT_ID, aID, aNextID);
}

int
eventLog::getInteger32(RMAttribute aName, unsigned long aID, long & aValue)
{
  aValue = -1;

  const EventLog * log = getConstElement(aID);
  if(!log) {
    return RMCLIENT_ERROR_LOG;
  }
  

  switch(aName) {

    case EVENTLOG_FORMAT:
      aValue = log->entry.log_format;
      break;

    case EVENTLOG_TYPE:
      aValue = log->entry.log_event_type;
      break;

    case EVENTLOG_FACILITY:
      aValue = log->entry.log_facility;
      break;

    case EVENTLOG_SEVERITY:
      aValue = log->entry.log_severity;
      break;

    default:
      return RMCLIENT_ERROR_NOSUCHNAME;
  }

  return RMCLIENT_SUCCESS;
}

int
eventLog::getUnsigned(RMAttribute aName, unsigned long aID, unsigned long & aValue)
{
  aValue = 0;

  if(aName == EVENTLOG_DEFAULTQUERY) {
    aValue = mDefaultQuery;
    return RMCLIENT_SUCCESS;
  }

  const EventLog * log = getConstElement(aID);
  if(!log)
    return RMCLIENT_ERROR_LOG;

  switch(aName) {

    case EVENTLOG_SIZE:
      aValue = log->entry.log_size;
      break;

    case EVENTLOG_UID:
      aValue = log->entry.log_uid;
      break;

    case EVENTLOG_GID:
      aValue = log->entry.log_gid;
      break;

    case EVENTLOG_PID:
      aValue = log->entry.log_pid;
      break;

    case EVENTLOG_PGID:
      aValue = log->entry.log_pgrp;
      break;

    case EVENTLOG_FLAG:
      aValue = log->entry.log_flags;
      break;

    case EVENTLOG_THREAD:
      aValue = log->entry.log_thread;
      break;

    case EVENTLOG_PROCESSOR:
      aValue = log->entry.log_processor;
      break;

    default:
      return RMCLIENT_ERROR_NOSUCHNAME;
  }

  return RMCLIENT_SUCCESS;
}

int
eventLog::getString(RMAttribute aName, unsigned long aID, char * & aBuf)
{
  aBuf = NULL;
  size_t len;
  char * buf = NULL;
  char * time;

  const EventLog * log = getConstElement(aID);
  if(!log)
    return RMCLIENT_ERROR_LOG;

  switch(aName) {

    case EVENTLOG_DEFAULTFILE:
      len = mLogFilePath.size();
      if(len) {

        buf = (char *) malloc(sizeof(char)*len);
        if(!buf)
          return RMCLIENT_ERROR_MEMORY;

        mLogFilePath.copy(buf, len);
      }
      break;

    case EVENTLOG_TIMESTAMP:

      time = ctime(&(log->entry.log_time.tv_sec));
      if(time) {
        buf = (char *) malloc (sizeof(char) * (strlen(time) + 1));
        if(!buf)
          return RMCLIENT_ERROR_MEMORY;

        strncpy(buf, time, strlen(time) + 1);
      }
      break;

    case EVENTLOG_STRING:
      if(log->entry.log_format == POSIX_LOG_STRING) {
        len = log->entry.log_size;
        if(len) {
          buf = (char *)malloc(sizeof(char)*len);
          if(!buf)
            return RMCLIENT_ERROR_MEMORY;

          log->data.copy(buf, len);
        }
      }
      else 
        return RMCLIENT_ERROR_NOSUCHNAME;

      break;

    default:
      return RMCLIENT_ERROR_NOSUCHNAME;
  }

  aBuf = buf;
  return RMCLIENT_SUCCESS;

}

int
eventLog::getBinary(RMAttribute aName, unsigned long aID, char * & aBuf, unsigned long & aLength)
{
  aLength = 0;
  aBuf = NULL;

  size_t len;
  char * buf;

  const EventLog * log = getConstElement(aID);
  if(!log)
    return RMCLIENT_ERROR_LOG;

  if(aName == EVENTLOG_BINARY && log->entry.log_format == POSIX_LOG_BINARY) {

    len = log->entry.log_size;
    if(len) {
      buf = (char *)malloc(sizeof(char)*len);
      if(!buf)
        return RMCLIENT_ERROR_MEMORY;

      log->data.copy(buf, len);
    }
  }
  else 
    return RMCLIENT_ERROR_NOSUCHNAME;

  aBuf = buf;
  aLength = len;
  return RMCLIENT_SUCCESS;
}

int
eventLog::setString(RMAttribute aName, unsigned long aID, char * aBuf)
{
  int ret;

  if(aName != EVENTLOG_DEFAULTFILE)
    return RMCLIENT_ERROR_NOSUCHNAME;

  ret = posix_log_close(mLog);
  if(ret)
    return RMCLIENT_ERROR_LOG_CLOSE;

  ret = posix_log_open(&mLog, aBuf);
  if(ret) {
    // reopen the default log file in case.
    posix_log_open(&mLog, 0);

    return RMCLIENT_ERROR_LOG_OPEN;
  }

  mLogFilePath = aBuf;

  return RMCLIENT_SUCCESS;
}

int
eventLog::setUnsigned(RMAttribute aName, unsigned long aID, unsigned long aValue)
{
  int ret;

  if(aName != EVENTLOG_DEFAULTQUERY)
    return RMCLIENT_ERROR_NOSUCHNAME;

  if (aValue > 0) {
    // verify the query exists if it is a real query
    ret = ::findId(EVENTQUERY, aValue);
    if(ret)
      return RMCLIENT_ERROR_NOSUCHVALUE;
  }

  mDefaultQuery = aValue;

  return RMCLIENT_SUCCESS;
}

int
eventLog::SearchAndReadLog(enum SearchOption aMethod, unsigned long aID, unsigned long & aNextID)
{
  int ret;

  posix_log_query_t query;

  size_t buf(36);

  char id[buf];

  snprintf(id, buf, "%lu", aID);

  string qs;

  aNextID = 0;

  if(mDefaultQuery) {

    const EventQuery * defaultQuery = mEventQuery->getConstElement(mDefaultQuery);
    if(!defaultQuery)
      return RMCLIENT_ERROR_QUERY;

    qs = defaultQuery->qstr;
    qs += " && ";
  }

  if(aMethod == FIND_ID) 
    qs += " recid = " ;
  else
    qs += " recid > " ;

  qs += id;

  ret = posix_log_query_create(qs.c_str(), POSIX_LOG_PRPS_SEEK, &query, 0, 0);
  if(ret)
    return RMCLIENT_ERROR_QUERY_CREATE;

  // reset the seek pointer. is this necessary? 
  ret = posix_log_seek(mLog, 0, POSIX_LOG_SEEK_START);
  if(ret)
    return RMCLIENT_ERROR_LOG_SEEK;

  // see if we can find it.
  ret = posix_log_seek(mLog, &query, POSIX_LOG_SEEK_FIRST);
  if(ret)
    return RMCLIENT_ERROR_LOG;

  // store the record to mLastEntry.
  ret = posix_log_read(mLog, &(mLastEntry.entry), 0, 0);
  if(ret)
    return RMCLIENT_ERROR_LOG_READ;

  // if we have data
  size_t bufSize = mLastEntry.entry.log_size;
  if(bufSize) {

    void * logBuf = malloc( sizeof(char) * bufSize);
    if(!logBuf)
      return RMCLIENT_ERROR_MEMORY;

    // move the seek pointer back a record.
    ret = posix_log_seek(mLog, &query, POSIX_LOG_SEEK_BACKWARD);
    if(ret)
      return RMCLIENT_ERROR_LOG_SEEK;

    // store the data to mLastBuf.
    ret = posix_log_read(mLog, &(mLastEntry.entry), logBuf, bufSize);
    if(ret)
      return RMCLIENT_ERROR_LOG_READ;

    mLastEntry.data.assign((const char *)logBuf, bufSize);

    // release the memory.
    free(logBuf);
  }

  aNextID = mLastEntry.entry.log_recid;

  return RMCLIENT_SUCCESS;
}

---