rt_errh.c

Go to the documentation of this file.

/*
 * ProviewR   Open Source Process Control.
 * Copyright (C) 2005-2026 SSAB EMEA AB.
 *
 * This file is part of ProviewR.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License as
 * published by the Free Software Foundation, either version 2 of
 * the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with ProviewR. If not, see <http://www.gnu.org/licenses/>
 *
 * Linking ProviewR statically or dynamically with other modules is
 * making a combined work based on ProviewR. Thus, the terms and
 * conditions of the GNU General Public License cover the whole
 * combination.
 *
 * In addition, as a special exception, the copyright holders of
 * ProviewR give you permission to, from the build function in the
 * ProviewR Configurator, combine ProviewR with modules generated by the
 * ProviewR PLC Editor to a PLC program, regardless of the license
 * terms of these modules. You may copy and distribute the resulting
 * combined work under the terms of your choice, provided that every
 * copy of the combined work is accompanied by a complete copy of
 * the source code of ProviewR (the version used to produce the
 * combined work), being distributed under the terms of the GNU
 * General Public License plus this exception.
 */
 
/* rt_errh.c -- Logg errors and more.
  The routines in this module are the error logging package.  */
 
#include <errno.h>
#include <fcntl.h>
#include <limits.h>
#include <pthread.h> /* for tid_t */
#include <stdlib.h>
#include <stdarg.h>
#include <stdio.h> /* for EOF */
#include <string.h>
#include <unistd.h>
 
#if defined OS_LINUX || defined OS_CYGWIN
#include <mqueue.h>
#elif defined OS_MACOS || defined OS_FREEBSD || defined OS_OPENBSD
#include <sys/msg.h>
#include <sys/ipc.h>
#endif
 
#include "pwr_msg.h"
#include "co_msg.h"
#include "co_time.h"
#include "co_string.h"
#include "rt_gdh.h"
#include "rt_errh_msg.h"
#include "rt_pwr_msg.h"
 
#define UNKNOWN_PROGRAM_NAME "Unknown name   "
 
//typedef void* aa_list[];
 
typedef enum { eArg_sts, eArg_int, eArg_string } eArg;
 
typedef struct {
  eArg class;
  union {
    pwr_tStatus sts;
    int intval;
    char* string;
  } u;
} sArg;
 
#if defined OS_LINUX || defined OS_CYGWIN
typedef pid_t sPid;
 
static mqd_t mqid = (mqd_t)-1;
static unsigned int prio = 0;
static int mq_send_errno = 0;
#elif defined OS_MACOS || defined OS_FREEBSD || defined OS_OPENBSD
typedef pid_t sPid;
 
static int mqid = -1;
// static unsigned int prio = 0;
static int mq_send_errno = 0;
#endif
 
static char programName[16];
static int interactive = 0;
static int initDone = 0;
static errh_eAnix errh_anix = errh_eNAnix;
 
static char* get_header(char, char*);
static char* get_message(const int, unsigned int, char*, int);
static char* get_name(char*, int);
static char get_severity(pwr_tStatus);
static void openLog();
static void set_name(const char*);
static void errh_send(char*, char, pwr_tStatus, errh_eMsgType);
static void log_message(errh_sLog*, char, const char*, va_list);
//static int msg_vsprintf(char*, const char*, aa_list, va_list);
 
static char anix_name[40][32] = {
  "rt_init",
  "rt_qmon",
  "rt_neth",
  "rt_neth_acp",
  "rt_io",
  "rt_tmon",
  "rt_emon",
  "rt_alimserver",
  "rt_bck",
  "rt_linksup",
  "rt_trend",
  "rt_fast",
  "rt_elog",
  "rt_webmon",
  "rt_webmonmh",
  "rt_sysmon",
  "plc",
  "rs_remotehandler",
  "opc_server",
  "rt_statussrv",
  "rt_post",
  "rt_report",
  "rt_sevhistmon",
  "rt_sim",
  "rt_powerlink",
  "rt_videomgm",
  "rt_redcom",
  "rt_websocketserver",
  "rt_maintsupserver",
  "rt_mqttserver",
};
 
void errh_AnixName(errh_eAnix anix, char *name)
{
  if (anix > 0 && anix <= 40)
    strcpy(name, anix_name[anix - 1]);
  else
    strcpy(name, "");
}
 
void errh_Interactive(void)
{
  interactive = 1;
}
 
pwr_tStatus errh_Init(const char* name, errh_eAnix anix)
{
  get_name(programName, sizeof(programName) - 1);
  if (name != NULL && name[0] != '\0')
    set_name(name);
  errh_anix = anix;
 
  if (!initDone) {
    initDone = 1;
    openLog();
  }
 
  return 1;
}
 
void errh_SetStatus(pwr_tStatus sts)
{
  /* Send close message */
  errh_send(0, 0, sts, errh_eMsgType_Status);
}
 
errh_eAnix errh_Anix(void)
{
  return errh_anix;
}
 
void errh_SetAnix(errh_eAnix anix)
{
  errh_anix = anix;
}
 
void errh_SetName(char* name)
{
  set_name(name);
}
 
/* Check if a given messagenumber exists,
   return string representation if valid.  */
 
char* errh_GetMsg(const int sts, char* buf, int bufSize)
{
  return get_message(sts, 0xf, buf, bufSize);
}
 
/* Checks if a given messagenumber exists,
  return string representation if valid.  */
 
char* errh_GetText(const int sts, char* buf, int bufSize)
{
  return get_message(sts, 1, buf, bufSize);
}
 
/* Log a message.  */
char* errh_Log(char* buff, char severity, const char* msg, ...)
{
  char* s;
  va_list ap;
 
  s = get_header(severity, buff);
  va_start(ap, msg);
  msg_vsprintf(s, msg, NULL, ap);
  va_end(ap);
 
  if (interactive)
    printf("%s\n", buff);
  else
    errh_send(buff, severity, 0, errh_eMsgType_Log);
 
  return buff;
}
 
void errh_Success(const char* msg, ...)
{
  va_list args;
 
  va_start(args, msg);
  log_message(NULL, 'S', msg, args);
  va_end(args);
}
 
void errh_Info(const char* msg, ...)
{
  va_list args;
 
  va_start(args, msg);
  log_message(NULL, 'I', msg, args);
  va_end(args);
}
 
void errh_Warning(const char* msg, ...)
{
  va_list args;
 
  va_start(args, msg);
  log_message(NULL, 'W', msg, args);
  va_end(args);
}
 
void errh_Error(const char* msg, ...)
{
  va_list args;
 
  va_start(args, msg);
  log_message(NULL, 'E', msg, args);
  va_end(args);
}
 
void errh_Fatal(const char* msg, ...)
{
  va_list args;
 
  va_start(args, msg);
  log_message(NULL, 'F', msg, args);
  va_end(args);
}
 
/* Log a fatal message.  */
void errh_LogFatal(errh_sLog* lp, const char* msg, ...)
{
  va_list args;
 
  va_start(args, msg);
  log_message(lp, 'F', msg, args);
  va_end(args);
}
 
/* Log a warning message.  */
void errh_LogWarning(errh_sLog* lp, const char* msg, ...)
{
  va_list args;
 
  va_start(args, msg);
  log_message(lp, 'W', msg, args);
  va_end(args);
}
 
/* Log a error message.  */
void errh_LogError(errh_sLog* lp, const char* msg, ...)
{
  va_list args;
 
  va_start(args, msg);
  log_message(lp, 'E', msg, args);
  va_end(args);
}
 
/* Log a info message.  */
void errh_LogInfo(errh_sLog* lp, const char* msg, ...)
{
  va_list args;
 
  va_start(args, msg);
  log_message(lp, 'I', msg, args);
  va_end(args);
}
 
/* Log a success message.  */
void errh_LogSuccess(errh_sLog* lp, const char* msg, ...)
{
  va_list args;
 
  va_start(args, msg);
  log_message(lp, 'S', msg, args);
  va_end(args);
}
 
/* Insert a status message in a message.  */
 
void* errh_ErrArgMsg(pwr_tStatus sts)
{
  sArg* eap;
 
  eap = (sArg*)malloc(sizeof(*eap));
  eap->class = eArg_sts;
  eap->u.sts = sts;
 
  return eap;
}
 
/* Insert a string argument in a message.  */
 
void* errh_ErrArgAF(char* str)
{
  sArg* eap;
 
  eap = (sArg*)malloc(sizeof(*eap));
 
  eap->class = eArg_string;
  eap->u.string = str;
 
  return eap;
}
 
/* Insert a integer value in a message.  */
 
void* errh_ErrArgL(int val)
{
  sArg* eap;
 
  eap = (sArg*)malloc(sizeof(*eap));
 
  eap->class = eArg_int;
  eap->u.intval = val;
 
  return eap;
}
 
void errh_CErrLog(pwr_tStatus sts, ...)
{
  va_list ap;
  void* args[25];
  char msg[200];
  sArg* eap;
  int argno = 0;
  char* s;
  char string[1000];
 
  get_message(sts, 0xb, msg, sizeof(msg));
 
  va_start(ap, sts);
  while ((eap = va_arg(ap, sArg*)) != NULL) {
    switch (eap->class) {
    case eArg_sts:
      args[argno++] = (char*)((long int)eap->u.sts);
      strcat(msg, "\n%m");
      break;
    case eArg_int:
      args[argno++] = (char*)((long int)eap->u.intval);
      break;
    case eArg_string:
      args[argno++] = eap->u.string;
      break;
    }
    free(eap);
  }
  va_end(ap);
 
  args[argno] = NULL;
 
  va_list tmp;
  memset(&tmp, 0, sizeof(tmp));
  s = get_header(get_severity(sts), string);
  msg_vsprintf(s, msg, args, tmp);
  errh_send(string, get_severity(sts), sts, errh_eMsgType_Log);
}
 
/* Format a string.  */
 
char* errh_Message(char* string, char severity, char* msg, ...)
{
  char* s;
  va_list ap;
 
  s = get_header(severity, string);
  va_start(ap, msg);
  msg_vsprintf(s, msg, NULL, ap);
  va_end(ap);
 
  return string;
}
 
/* Get a message string, VMS style.
 
   %FACILITYNAME-S-MESSAGENAME, message string
 
   flags:
    0x1         message string
    0x2         MESSAGENAME
    0x4         S (severity)
    0x8         FACILITYNAME
    0xf         % + all
 
    any other   gives a combination of above excluding %  */
 
static char* get_message(
    const pwr_tStatus sts, unsigned int flags, char* buf, int bufSize)
{
  return msg_GetMessage(sts, flags, buf, bufSize);
}
 
static void set_name(const char* name)
{
  strncpy(programName, name, sizeof(programName) - 1);
  programName[sizeof(programName) - 1] = '\0';
}
 
static void openLog()
{
#if defined OS_LINUX || defined OS_CYGWIN
  if (mqid == (mqd_t)-1) {
    char name[64];
    char* busid = getenv(pwr_dEnvBusId);
 
    sprintf(name, "%s_%s", LOG_QUEUE_NAME, busid ? busid : "");
    mqid = mq_open(name, O_WRONLY | O_NONBLOCK, 0, 0);
    if (mqid == (mqd_t)-1) {
      char string[256];
      char* s;
 
      s = errh_Message(
          string, 'E', "Open messageQ, mq_open(%s)\n%s", name, strerror(errno));
      printf("%s\n", s);
      return;
    }
  }
#elif defined OS_MACOS || defined OS_FREEBSD || defined OS_OPENBSD
  if (mqid == (key_t)-1) {
    char name[64];
    char* busid = getenv(pwr_dEnvBusId);
    key_t key;
    int fd;
    int flags = O_RDWR | O_CREAT;
    mode_t mode = S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP;
 
    sprintf(name, "%s_%s", LOG_QUEUE_NAME, busid ? busid : "");
    fd = open(name, flags, mode);
    if (fd == -1) {
      printf("Message Queue, open failed on %s, errno: %d\n", name, errno);
    }
    key = ftok(name, 'm');
    close(fd);
 
    mqid = msgget(key, IPC_CREAT | 0660);
    if (mqid == -1) {
      char string[256];
      char* s;
 
      s = errh_Message(string, 'E', "Open message queue, msgget(%s)\n%s", name,
          strerror(errno));
      printf("%s\n", s);
      return;
    }
  }
#endif
}
 
static char* get_name(char* name, int size)
{
  int len = strlen(UNKNOWN_PROGRAM_NAME);
 
  strncpy(name, UNKNOWN_PROGRAM_NAME, MIN(size, len));
 
  name[MIN(size, len)] = '\0';
 
  return name;
}
static sPid* get_pid(sPid* pid)
{
  *pid = getpid();
 
  return pid;
}
 
static char* get_header(char severity, char* s)
{
  sPid pid;
  pwr_tTime time;
  struct tm tp, *t;
 
  if (!initDone)
    errh_Init(NULL, 0);
 
  if (interactive) {
    s += sprintf(s, "%c ", severity);
    return s;
  }
 
  time_GetTime(&time);
 
  get_pid(&pid);
 
  s += sprintf(s, "%c %-*.*s", severity, (int)sizeof(programName),
      (int)sizeof(programName), programName);
 
  time_t sec = time.tv_sec;
  localtime_r(&sec, &tp);
  t = &tp;
  s += sprintf(s, " %8d ", pid);
 
  s += sprintf(s, "%02d-%02d-%02d %02d:%02d:%02d.%02d ", t->tm_year % 100,
      t->tm_mon + 1, t->tm_mday, t->tm_hour, t->tm_min, t->tm_sec,
      (int)(time.tv_nsec / 10000000));
 
  return s;
}
 
/* Format a string and write it to log devices.  */
 
static void log_message(
    errh_sLog* lp, char severity, const char* msg, va_list ap)
{
  char* s;
  char string[1000];
 
  s = get_header(severity, string);
  msg_vsprintf(s, msg, NULL, ap);
  if (interactive)
    printf("%s\n", string);
  else
    errh_send(string, severity, 0, errh_eMsgType_Log);
 
  if (lp != NULL && lp->send) {
    lp->put.data = string;
    lp->put.size = strlen(string) + 1;
    lp->put.allocate = 1;
    qcom_Put(NULL, &lp->logQ, &lp->put);
  }
}
 
/* Print a message on error log.  */
 
static char get_severity(pwr_tStatus sts)
{
  switch (sts & 7) {
  case 0:
    return 'W';
  case 1:
    return 'S';
  case 2:
    return 'E';
  case 3:
    return 'I';
  case 4:
    return 'F';
  default:
    return '?';
  }
}
 
/****** internals ************************************************************/
 
/* Handle numerics.  */
 
static void errh_send(
    char* s, char severity, pwr_tStatus sts, errh_eMsgType message_type)
{
#if defined OS_LINUX || defined OS_CYGWIN
 
  int len;
  if (mqid != (mqd_t)-1) {
    errh_sMsg msg;
 
    switch (message_type) {
    case errh_eMsgType_Log:
      strncpy(msg.str, s, LOG_MAX_MSG_SIZE);
      str_Cut(msg.str, LOG_MAX_MSG_SIZE);
      msg.message_type = message_type;
      msg.severity = severity;
      msg.sts = sts;
      msg.anix = errh_anix;
      len = sizeof(msg) - sizeof(msg.message_type) - sizeof(msg.str)
          + strlen(msg.str) + 1;
      break;
    case errh_eMsgType_Status:
      msg.message_type = message_type;
      msg.sts = sts;
      msg.anix = errh_anix;
      len = sizeof(msg) - sizeof(msg.message_type) - sizeof(msg.str);
      break;
    }
    if (prio == 0)
      prio = sysconf(_SC_MQ_PRIO_MAX) - 1;
    if (mq_send(mqid, (char*)&msg, MIN(len, LOG_MAX_MSG_SIZE - 1), prio)
        == -1) {
      if (mq_send_errno != errno) {
        mq_send_errno = errno;
        perror("mq_send");
      }
    }
  } else if (s) {
    puts(s);
    return;
  }
 
#elif defined OS_MACOS || defined OS_FREEBSD || defined OS_OPENBSD
 
  int len;
  if (mqid != -1) {
    errh_sMsg msg;
 
    switch (message_type) {
    case errh_eMsgType_Log:
      strncpy(msg.str, s, LOG_MAX_MSG_SIZE);
      str_Cut(msg.str, LOG_MAX_MSG_SIZE);
      msg.message_type = message_type;
      msg.severity = severity;
      msg.sts = sts;
      msg.anix = errh_anix;
      len = sizeof(msg) - sizeof(msg.message_type) - sizeof(msg.str)
          + strlen(msg.str) + 1;
      break;
    case errh_eMsgType_Status:
      msg.message_type = message_type;
      msg.sts = sts;
      msg.anix = errh_anix;
      len = sizeof(msg) - sizeof(msg.message_type) - sizeof(msg.str);
      break;
    }
    // if ( prio == 0)
    //  prio = sysconf(_SC_MQ_PRIO_MAX) - 1;
    if (msgsnd(mqid, (char*)&msg, MIN(len, LOG_MAX_MSG_SIZE - 1), 0) == -1) {
      if (mq_send_errno != errno) {
        mq_send_errno = errno;
        perror("msgsnd");
      }
    }
  } else if (s) {
    puts(s);
    return;
  }
 
#else
 
  if (message_type != errh_eMsgType_Log)
    return;
 
  printf("%s\n", s);
 
#endif
}
 
errh_eSeverity errh_Severity(pwr_tStatus sts)
{
  if (sts == 0)
    return errh_eSeverity_Null;
 
  switch (sts & 7) {
  case 1:
    return errh_eSeverity_Success;
  case 3:
    return errh_eSeverity_Info;
  case 0:
    return errh_eSeverity_Warning;
  case 2:
    return errh_eSeverity_Error;
  case 4:
    return errh_eSeverity_Fatal;
  default:
    return errh_eSeverity_Null;
  }
}