msgLog.c

Go to the documentation of this file.

/* msgLog.c - MINOS DAQ syslog functionality */

/* 
 * Tim Nicholls, Real Time Systems Group
 * CLRC Rutherford Appleton Laboratory
 */

/*
 * Current CVS Tag: 
 * $Header: /cvs/minoscvs/rep1/minossoft/OnlineUtil/msgLogLib/msgLog.c,v 1.3 2005/12/15 23:07:22 rhatcher Exp $ 
 */

/*
 * Modification History : DO NOT EDIT - MAINTAINED BY CVS 
 * $Log: msgLog.c,v $
 * Revision 1.3  2005/12/15 23:07:22  rhatcher
 * synch to fix I suggested to Caius on 2005-10-15 (and then had to rediscover).
 * This FPE in the initial stage confuses gdb (version 6.1 and earilier)
 * to no end.  Of course, I forgot to make same commit at that time so
 * I had to rediscover (painfully hard) this fix.
 *
 * Revision 1.2  2005/09/06 19:06:49  rhatcher
 * Synch with online CVS repository as of 2005-08-25.  This includes fixes
 * for const correctness on char* format strings.  Alas, it now uses
 * clock_gettime() rather than gettimeofday() -- this exists on Linux,
 * but doesn't for MacOSX, but does require linkage to -lrt library.
 *
 * Revision 1.15  2005/08/25 17:37:24  howcroft
 * Added a function that allows a process to set its own max message repeat rate
 *
 * Revision 1.14  2005/08/25 17:20:43  howcroft
 * VxWorks and Linux now share code for time based message rate limiting. replaced the linux calls to gettimeofday with clock_getttime.
 *
 * Also, change char pointers to const pointers for format args.
 *
 * Revision 1.13  2005/08/15 20:22:26  howcroft
 * Wrap the repeated message timeouts in ifndef Vxworks statements, so it should still compile under vxworks
 *
 * Revision 1.12  2005/08/15 20:02:03  howcroft
 * use the macro MSG_USERPT to switch on and off the writing of the "last message sent N times".  If this macro is defined then this message is used, if not then the actual message is sent instead.
 *
 * Revision 1.11  2005/08/15 19:32:28  howcroft
 * Added new feature: timeouts on repeated message buffering.  A repeated messsage is now resent if:
 *
 * number of repeats>=MAX_RPTMSG_BUFFER (currently set to 1e6)
 *
 * OR
 *
 * time since last send > MAX_DTMSG_BUFFER (currently set to 0.5s)
 *
 * Revision 1.10  2005/05/03 10:12:38  tcn
 * Added function msgLogPidSet
 *
 * Revision 1.9  2003/11/06 11:17:09  howcroft
 * hacked so one can step back to syslog with USESYSLOG macro
 *
 * Revision 1.8  2003/10/24 13:34:53  howcroft
 * Bug fix, typo
 *
 * Revision 1.7  2003/10/24 13:30:22  howcroft
 *
 * MsgLogLib:
 * o Messages go via UDP to runControl directly rather than via syslog.
 * o Include a header with infomation about node Id, and message counter, we can now tell when messages are dropped.
 *
 * o msgLogger.c builds a little binary to act like the logger script.
 * o msgRead, a library to extract the messages from the UDP socket and fill a common struct defined in msgCommon.h
 *
 * Revision 1.6  2002/08/07 07:48:40  tcn
 * Added printf to Vxworks version of logMessage function, so messages also go to
 * console.
 *
 * Revision 1.5  2002/03/01 11:19:01  tcn
 * Implemented new debug message scheme with specifiable debug level and
 * and reporting threshold.
 *
 * Revision 1.4  2001/09/05 14:41:44  tcn
 * Forgot to include string.h
 *
 * Revision 1.3  2001/08/16 12:13:21  tcn
 * Added logNotice call, msgLogInit to (optionally) call openlog, message
 * priority code prepending for Linux and VxWorks
 *
 * Revision 1.2  2001/06/18 10:52:54  tcn
 * Implemented multi-level message logging. Now also works under VxWorks with the
 * -DVxWorks flag.
 *
 * Revision 1.1  2001/04/05 13:35:18  tcn
 * First commit of msgogLib
 *
 *
 */

 /*
DESCRIPTION
This module provides message logging functionality, routed either
via syslog or (for VxWorks) via logMsg.

The meaning of the levels for use in the MINOS DAQ is defined this:

   logCritical : Critical condition - system level problem (power, temp, etc.)
   logError    : Error condition - problem with DAQ, stopping readout
   logWarning  : Warning condition - problem with DAQ but can continue
   logNotice   : Normal condition, e.g. state transition by RC, LI sequence, 
                 executes complete
   logInfo     : Informational messages, e.g. component state changes
   logDebug    : Debug messages, e.g. TF xfer parameters

logDebug has an additional argument, which specifies a debug level. A settable
threshold, accessed by logDebugLevelSet, controls what debug levels are written
as messages.

INCLUDE FILES: msgLog.h, OsExtras.h
*/

/* includes */
#include <stdio.h>
#include <stdarg.h>
#include <string.h>
#include <time.h>

#ifdef VxWorks
#include <bootLib.h>
#include <logLib.h>
#include <socket.h>
#include <sockLib.h>
#include <stdLib.h>
#include <sysLib.h>
#include <in.h>
#include <ioLib.h>
#include <msgQLib.h>
#else
#include <stdlib.h>
#include <syslog.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <sys/time.h>
#include <errno.h>
#include <unistd.h>
#include <netdb.h>
#endif

#include "minosDaq.h"
#include "msgLog.h"
#include "msgCommon.h"

#ifndef CLOCK_REALTIME
#include "fake_clock_gettime.h"
#endif

/* defines */
#ifdef VxWorks
#define BOOT_LINE_SIZE 255
#define TASK_SIZE_MSGLOGGER 2000
#define TASK_PRIORITY_MSGLOGGER 1
#define MSGQ_MAX_MSGS  100
#define ENDIAN_SWAP_LONG(w) ( ((w&0xff)<<24) | ((w&0xff00)<<8) | ((w&0xff0000)>>8) | ((w&0xff000000)>>24) )
#define ENDIAN_SWAP_SHORT(w) ( ((w&0xff)<<8) | ((w&0xff00)>>8) )
#define NATIVE_MSG(args...) printf(## args)
#else
#define NATIVE_MSG(args...) syslog(DAQ_LOG_FACILITY|LOG_ERR, ## args)
#endif

/* typedefs */


/* globals */


/* locals */
static unsigned int lDebugLevel = 0;
static long  lMaxRptDt = MAX_DTMSG_BUFFER;

#ifdef USESYSLOG
static mdMsgLogBuffer lBuffer;
#else
#ifdef VxWorks
static MSG_Q_ID lMsgLogQId = NULL;
static int lMsgLogTaskId   = NULL;
#endif
static int lSocket = 0;
static struct sockaddr_in lServerAddr;
static mdMsgLogBuffer lBuffer;
static int lMsgLocalEcho = 0;
#endif
static const char logTag[]= "EACEWNID";

static struct timespec lastMessageTime; //time the last message was sent

/* forward declarations */
void logMessage(int priority, const char *fmt, va_list args);
#ifdef USESYSLOG
#else
#ifdef VxWorks
STATUS tMsgLogger(void);
#endif
static void msgSend(int priority);
#endif



/********************************************************************
* =v=>
* msgLogInit - initialise message logging
*
* This function can be called OPTIONALLY to initialise the message
* logging. On VxWorks it does nothing, on systems with a syslog
* implementation it calls openlog, which allows the program identity
* and various syslog options to be set. Calling this function has the 
* effect of printing syslog messages to STDERR in addition, and shows 
* the PID in each message. 
*
* RETURNS: void
* ===<
* =i=> */
void msgLogInit
(
    const char *ident  /* process identifier (name) */
)
{

#ifdef USESYSLOG
#ifdef VxWorks    
    /* Do nothing */
#else /* !VxWorks */
    openlog(ident, LOG_PERROR | LOG_PID, DAQ_LOG_FACILITY);
#endif /* VxWorks */

#else /* !USESYSLOG */

  const char* ip;
  const char* portenv;
  int port;
  int sockAddrSize;
  int pid;

  /*set last message time to 01/01/70
   * this way first message is always sent */
  lastMessageTime.tv_sec = 0; 
  lastMessageTime.tv_nsec = 0;

  sockAddrSize = sizeof(struct sockaddr_in);

  /* Clear socket address structure */
  bzero((char *)&lServerAddr, sockAddrSize);

  /* 
   * For VxWorks we pull the message server IP address directly from
   * the boot parameters. Otherwise, the server name/IP is resolved from
   * environment variables or falls back to the local host 
   */
#ifdef VxWorks
  {
      char bootString[BOOT_LINE_SIZE];
      BOOT_PARAMS bootParams;

      /* 
       * Get the msgLogger IP adddress from the "other" field of the boot
       * parameters
       */
      sysNvRamGet(bootString, BOOT_LINE_SIZE, 0);
      bootStringToStruct(bootString, &bootParams);
      ip = (char *)&(bootParams.other);
      port = MSGLOG_PORT;

      if ((lServerAddr.sin_addr.s_addr = inet_addr(ip)) == ERROR) {
          NATIVE_MSG("msgLogInit: bad server name from boot params: %s", ip);
          return;
      }
      pid = taskIdSelf();

      /* Clean up any existing msgLogger task and message queue */
      if (lMsgLogTaskId != NULL) {
          NATIVE_MSG("msgLogInit: deleting existing message logger task (tid=0x%x)\n", lMsgLogTaskId);
          taskDelete(lMsgLogTaskId);
          lMsgLogTaskId = NULL;
      }
      if (lMsgLogQId != NULL) {
          NATIVE_MSG("msgLogInit: deleting existing message logger queue (id=0x%x)\n", lMsgLogQId);
          msgQDelete(lMsgLogQId);
          lMsgLogQId = NULL;
      }

      /* Create the message queue for the logging task */
      lMsgLogQId = msgQCreate(MSGQ_MAX_MSGS, sizeof(mdMsgLogBuffer), MSG_Q_FIFO);
      if (lMsgLogQId == NULL) {
          NATIVE_MSG("msgLogInit: msgQCreate failed: %s", strerror(errno));
          return;
      }
      /* Spawn the message logging task */
      lMsgLogTaskId = taskSpawn("tMsgLogger", TASK_PRIORITY_MSGLOGGER, 0, 
                                TASK_SIZE_MSGLOGGER, (FUNCPTR)tMsgLogger,
                                0,0,0,0,0,0,0,0,0,0);
      if (lMsgLogTaskId == ERROR) {
          NATIVE_MSG("msgLogInit: task creation failed: %s", strerror(errno));
          return;
      }
  }
#else /* !Vxworks */
  {
      struct hostent     *host_ptr; /*the host add*/

      /* 
       * Pull the msg logger IP address and port from env vars, otherwise
       * take the default values
       */      
      ip = getenv(DAQ_MSG_IP);
      if (ip == NULL) {
          ip = MSGLOG_DEFAULT_IP;
      }
      portenv = getenv("DAQ_MSG_PORT");
      if ( portenv == NULL){
          port = MSGLOG_PORT;
      } else {
          sscanf(portenv, "%d", &port);
      }
  
      /* Resolve server hostname to address */
      host_ptr = gethostbyname(ip);
      if(!host_ptr ||host_ptr->h_addrtype != AF_INET ){
          NATIVE_MSG( "msgLogInit: bad server name/address: %s , %s",ip, strerror(errno));
          return;
      }
      memcpy(&lServerAddr.sin_addr.s_addr, host_ptr->h_addr, host_ptr->h_length);
      if(lServerAddr.sin_addr.s_addr == INADDR_NONE)
        {
          NATIVE_MSG( "msgLogInit: unresolved server address, unable to open msgLog socket\n");
          return;
        }

      /* Get current process ID */ 
      pid = getpid();
  
      /* Open syslog connection for fallback (native) messages */
      openlog(ident, LOG_PERROR | LOG_PID, DAQ_LOG_FACILITY);
  }
#endif /* VxWorks */

  /* Fill in port and type in socket address structure */
  /* lServerAddr.sin_len    = (unsigned char)sockAddrSize; */
  lServerAddr.sin_family = AF_INET;
  lServerAddr.sin_port   = htons(port);

  /* Close the old socket if it exists */
  if (lSocket != 0) {
    NATIVE_MSG("msgLogInit: closing existing message logger socket (id=0x%x)\n", lSocket);
    close(lSocket);
    lSocket = 0;
  }

  /* Create the UDP datagram socket */
  lSocket = socket(AF_INET, SOCK_DGRAM, 0);
  if(lSocket == -1) {
      NATIVE_MSG("msgLogInit: socket() failed: %s", strerror(errno));
      return;
  }
    
  /* Initialise message header */
  lBuffer.hdr.pid = pid;
  lBuffer.hdr.count = 0;
  lBuffer.hdr.nodeFrom = MINOS_UNIDENTIFIED_CLIENT;
  strncpy(lBuffer.hdr.prcName, ident, MSGLOG_MAXNAME);

  /* Set local message echoing off by default */
  lMsgLocalEcho = 0;

#endif /* USESYSLOG */
  
  /* Set default debug level to zero */
  lDebugLevel = 0;

  return;

} /* msgLogInit */


/********************************************************************
*
* msgLogCleanup - clean up the message logger
*
* This function cleans up the message logger, closing the socket and
* deleting the (VxWorks) logging task and message queue as necessary.
*
* RETURNS: none
*
*/
void msgLogCleanup(void)
{

#ifdef VxWorks
    /* Clean up any existing msgLogger task and message queue */
    if (lMsgLogTaskId != NULL) {
        taskDelete(lMsgLogTaskId);
        lMsgLogTaskId = NULL;
    }
    if (lMsgLogQId != NULL) {
        msgQDelete(lMsgLogQId);
        lMsgLogQId = NULL;
    }
#endif

#ifndef USESYSLOG
    /* Close the UDP socket if it is open */
    if (lSocket != 0) {
      close(lSocket);
      lSocket = 0;
    }
#endif

} /* msgLogCleanup */

/********************************************************************
* =v=>
* msgLogNodeIdSet - set node ID for message logging
* 
* Sets the node id use in the message header for UDP messaging to 
* rcServer. This ID should be the appropriate entry from the
* MinosEntity enumeration in minosDaq.h 
* Only has meaning when conpiled without USESYSLOG.
* 
* RETURNS: None
* ===<
* =i=> */
void msgLogNodeIdSet
(
    long nodeId  /* node ID to be set */
)
{
#ifdef USESYSLOG
  
#else   
  lBuffer.hdr.nodeFrom = nodeId;
#endif
  return;

} /* msgLoNodeIdSet */

/********************************************************************
* =v=>
* msgLogPidSet - set process ID for message logging
* 
* Sets the process ID to  use in the message header for UDP messaging to 
* rcServer. 
* 
* RETURNS: None
* ===<
* =i=> */
void msgLogPidSet
(
    long pid  /* node ID to be set */
)
{
#ifdef USESYSLOG
  
#else   
  lBuffer.hdr.pid = pid;
#endif
  return;

} /* msgLogPidSet */

/********************************************************************
* =v=>
* msgLogLocalEchoSet - set/clear local echoing of messages
* 
* This function will enable/disable the echoing of messages locally
* (e.g. to stderr). Only has meaning when conpiled without USESYSLOG.
* 
* RETURNS: None
* ===<
* =i=> */
void msgLogLocalEchoSet
(
    int enable /* enable 1 = on, 0 = off */
)
{
#ifdef USESYSLOG
  
#else   
  lMsgLocalEcho = enable;
#endif
  return;

} /* msgLogLocalEchoSet */

/********************************************************************
* =v=>
* logMaxRepRateSet - set max message repeat rate
*
* Sets the max time (in nano-secs) that identical messages are buffered. Setting to zero switches off bufferiing. 
*
* RETURNS: None
* ===<
* =i=> */
void logMaxRepRateSet
(
 long max_dt_ns
)
{
  lMaxRptDt = max_dt_ns;
}

/********************************************************************
* =v=>
* logDebugLevelSet - set debug log level
*
* This function sets the debug log level, which is used as a 
* threshold for debugging. A value of zero turns off all debug level
* messages. It is up to the user to determine how many levels of
* debugging are available, but the number must always be positive.
*
* RETURNS: None
* ===<
* =i=> */
void logDebugLevelSet
(
   unsigned int level
)
{

   lDebugLevel = level;

} /* logDebugLevelSet */


/********************************************************************
* =v=>
*  msgLogResetMsgCount
*
* Resets the count of a message
*
* RETURNS: None
* ===<
* =i=> */
void  msgLogResetMsgCount(long count)
{
#ifndef USESYSLOG
#ifndef VxWorks
  lBuffer.hdr.count = count;
#endif
#endif
} /*  msgLogResetMsgCount */

long  msgLogGetMsgCount()
{
#ifndef USESYSLOG
#ifndef VxWorks
  return (lBuffer.hdr.count);
#endif
#else
  return -1;
#endif
} /*  msgLogResetMsgCount */




/********************************************************************
* =v=>
* logCritical - send an critical message to the message logger
*
* This function parses a variable argument list and sends an message
* with LOG_CRIT level to the message logger
*
* RETURNS: void
* ===<
* =i=> */

void logCritical(const char *fmt, ...) {

    va_list args;
    va_start(args, fmt);
    logMessage(LOG_CRIT, fmt, args);
    va_end(args);

} /* logCritical */

/********************************************************************
* =v=>
* logError - send an error message to the message logger
*
* This function parses a variable argument list and sends an message
* with LOG_ERR level to the message logger
*
* RETURNS: void
* ===<
* =i=> */
void logError(const char *fmt, ...) {
    
    va_list args;
    va_start(args, fmt);
    logMessage(LOG_ERR, fmt, args);    
    va_end(args);

} /* logError */

/********************************************************************
* =v=>
* logWarn - send an warning message to the message logger
*
* This function parses a variable argument list and sends an message
* with LOG_WARNING level to the message logger
*
* RETURNS: void
* ===<
* =i=> */
void logWarn(const char *fmt, ...) {

    va_list args;
    va_start(args, fmt);
    logMessage(LOG_WARNING, fmt, args);
    va_end(args);

} /* logWarn */

/********************************************************************
* =v=>
* logNotice - send a notice message to the message logger
*
* This function parses a variable argument list and sends an message
* with LOG_NOTICE level to the message logger
*
* RETURNS: void
* ===<
* =i=> */
void logNotice(const char *fmt, ...) {

    va_list args;
    va_start(args, fmt);
    logMessage(LOG_NOTICE, fmt, args);
    va_end(args);

} /* logNotice */

/********************************************************************
* =v=>
* logInfo - send an info message to the message logger
*
* This function parses a variable argument list and sends an message
* with LOG_INFO level to the message logger
*
* RETURNS: void
* ===<
* =i=> */
void logInfo(const char *fmt, ...) {

    va_list args;
    va_start(args, fmt);
    logMessage(LOG_INFO, fmt, args);
    va_end(args);

} /* logInfo */


/********************************************************************
* =v=>
* logDebug - send an debug message to the message logger
*
* This function parses a variable argument list and sends an message
* with LOG_DEBUG level to the message logger
*
* RETURNS: void
* ===<
* =i=> */
void logDebug(unsigned int level, const char *fmt, ...) {

    va_list args;

    /* 
     * Check requested level against threshold - values < 1 are
     * prohibited and reset to one to avoid situation where some
     * debug messages always get through.
     */
    if (level < 1) {
       level = 1;
    }
    if (level <= lDebugLevel) {
       va_start(args, fmt);
       logMessage(LOG_DEBUG, fmt, args);
       va_end(args);
    }

} /* logDebug */

/********************************************************************
* =v=>
* logMessage - format and send a message to the message logger
*
* This function parses an variable input argument list to format a
* message. This is sent to the message logger with the specified
* priority: logMsg under vxWorks with the priority tagged by a <x>
* sequent, syslog otherwise
*
* RETURNS: void
* ===<
* =i=> */
void logMessage(int priority, const char *fmt, va_list args) {

    int len = 0;
    static char lastMessage[MSGLOG_MAXMESSAGE]="";
    static int lastMessageCount=0;    

    static struct timespec thisMessageTime;
    clock_gettime(CLOCK_REALTIME,&thisMessageTime);


    /* Build message from argument list */
#ifdef VxWorks
    vsprintf(lBuffer.message, fmt, args);
#else
    vsnprintf(lBuffer.message, MSGLOG_MAXMESSAGE, fmt, args);
#endif

    /* Discard any trailing new lines as we'll force one if necessary*/
    len = strlen(lBuffer.message);
    if (lBuffer.message[len-1] == '\n') lBuffer.message[len-1]=0;

#ifdef USESYSLOG
#ifdef VxWorks
    logMsg("<%c> %s\n", (int)logTag[priority], (int)lBuffer.message, 0, 0, 0, 0);
    printf("<%c> %s\n", logTag[priority], lBuffer.message);

#else /* !VxWorks */
    syslog(DAQ_LOG_FACILITY | priority, "<%c> %s\n", logTag[priority], lBuffer.message);

#endif /* VxWorks */
#else  /* !USESYSLOG */

    /* Check if this is the same message as last time */
    len = strncmp(lastMessage, lBuffer.message, MSGLOG_MAXMESSAGE);

    /* Decide whether this is a repeated message and if it needs to be sent or not */
    long long deltat = (thisMessageTime.tv_sec-lastMessageTime.tv_sec)*1e9 +  (thisMessageTime.tv_nsec-lastMessageTime.tv_nsec);

    if(lastMessageCount!=0 && len==0 && lastMessageCount<MAX_RPTMSG_BUFFER && deltat<lMaxRptDt) {
      
        /* Same message - less than max counts nothing needs to be sent*/
        lastMessageCount++;

    } else{ 
      /* Either new message, or we've exceeded max count so send "repeated" message */
      if((len!=0 && lastMessageCount>1) || 
         (len==0 && (lastMessageCount>=MAX_RPTMSG_BUFFER || deltat>MAX_DTMSG_BUFFER) )) {
#ifdef MSG_USERPT /*use the repeat message*/
          sprintf(lBuffer.message, "Last message repeated %d times", lastMessageCount);
          msgSend(LOG_INFO); 
#ifdef VxWorks
          vsprintf(lBuffer.message, fmt, args);
#else
          vsnprintf(lBuffer.message, MSGLOG_MAXMESSAGE, fmt, args);
#endif
          lBuffer.hdr.priority = priority;        
#else 
          strncpy(lastMessage, lBuffer.message, MSGLOG_MAXMESSAGE);
          msgSend(priority);
#endif /*MSG_USERPT*/
      }
      /* New message, send it */
      if( len!=0 ) {
          strncpy(lastMessage, lBuffer.message, MSGLOG_MAXMESSAGE);
          msgSend(priority);      
      }
      /* Reset last message count */
      lastMessageTime.tv_sec = thisMessageTime.tv_sec;
      lastMessageTime.tv_nsec = thisMessageTime.tv_nsec;
      lastMessageCount=1;
    }

#endif /* USESYSLOG */

    return;
}

#ifndef USESYSLOG
/********************************************************************
* =v=>
* msgSend - send log message
*
* This function formats and sends the message to the appropriate 
* location. Under VxWorks the message is passed (via a message queue)
* to the message logging task. Otherwise it is sent directly via
* the UDP socket which was opened by msgLogInit.
*
* RETURNS: none
* ===<
* =i=> */
static void msgSend
(
    int priority /* message priority */
)
{

  int len=0;

  /* Assemble the message header */
  lBuffer.hdr.priority = priority;
  lBuffer.hdr.length = strlen(lBuffer.message);
  lBuffer.hdr.count++;
  lBuffer.hdr.stime = 0;

  /* Complete the header OS-dependent fields then send the message */
#ifdef VxWorks
  {
      struct timespec msgTime;
      STATUS rc;
      if (clock_gettime(CLOCK_REALTIME, &msgTime) == 0) {
          lBuffer.hdr.stime = msgTime.tv_sec;
      }
      /* VxWorks PID and name depend on current task context */
      lBuffer.hdr.pid   = taskIdSelf();
      strncpy(lBuffer.hdr.prcName, (char *)taskName(lBuffer.hdr.pid), MSGLOG_MAXNAME);
  
      /* Push message into message queue for logging task to handle */
      rc = msgQSend(lMsgLogQId, (char *)&lBuffer, sizeof(mdMsgLogBuffer), 
              NO_WAIT, MSG_PRI_NORMAL);
      if (rc == ERROR) {
          NATIVE_MSG("msgSend: msgQSend failed: %s", strerror(errno));
      }

  }
#else /* !VxWorks */
  {
      struct timeval msgTime;
      if(gettimeofday(&msgTime, 0)==0) {
          lBuffer.hdr.stime = msgTime.tv_sec;
      }
      /* Send the message */  
      len = sendto(lSocket, (char *)&lBuffer, sizeof(mdMsgLogBuffer), MSG_DONTWAIT, 
                   (struct sockaddr *)&lServerAddr, sizeof(struct sockaddr_in)); 
      if(len < 0) {
          NATIVE_MSG( "msgSend: sendto() failed: %s", strerror(errno));
      }

  }
#endif /* VxWorks */
  
  if (lMsgLocalEcho) {
      printf("%-.10s[%ld]: <%c> %-.100s\n", lBuffer.hdr.prcName, 
             lBuffer.hdr.pid, logTag[lBuffer.hdr.priority], lBuffer.message);  
  }

  return;
}

#ifdef VxWorks
/********************************************************************
*
* tMsgLogger - message logging task
*
* This function implements the message logging task under VxWorks. It
* simply receives messages on a message queue, byte swaps the 
* numerical fields in the header and sends it to the UDP socket.
*
* RETURNS: OK, or ERROR if there was a problem
*
*/
STATUS tMsgLogger(void)
{

    mdMsgLogBuffer message;
    int msgLen, sendLen;

    /* Loop forever ! */
    while (1) {
        msgLen = msgQReceive(lMsgLogQId, (char *)&message, sizeof(mdMsgLogBuffer), WAIT_FOREVER);
        if (msgLen == ERROR) {
            NATIVE_MSG("tMsgLogger: msgQReceive failed: %s", strerror(errno));
            return ERROR;
        } else if (msgLen != sizeof(mdMsgLogBuffer)) {
            NATIVE_MSG("tMsgLogger: bad message length: %d", msgLen);        
        } else {
            /* Need to byte swap the appropriate fields in the header */
            message.hdr.nodeFrom = ENDIAN_SWAP_LONG(message.hdr.nodeFrom);
            message.hdr.priority = ENDIAN_SWAP_SHORT(message.hdr.priority);
            message.hdr.pid      = ENDIAN_SWAP_LONG(message.hdr.pid);
            message.hdr.stime    = ENDIAN_SWAP_LONG(message.hdr.stime);
            message.hdr.count    = ENDIAN_SWAP_LONG(message.hdr.count);
            message.hdr.length   = ENDIAN_SWAP_LONG(message.hdr.length);

            /* Send the message to the socket (non-blocking) */
            sendLen = sendto(lSocket, (char *)&message, sizeof(mdMsgLogBuffer), MSG_DONTWAIT,
                             (struct sockaddr *)&lServerAddr, sizeof(struct sockaddr_in));
            if (sendLen < 0) {
                NATIVE_MSG("tMsgLogger: sendto() failed: %s", strerror(errno));
            }
        }
    }

   return OK;

} /* tMsgLogger */
#endif /* Vxworks */
#endif /* !USESYSLOG */

---