syslog.h

/* Copyright © 2019 Pascal JEAN, All rights reserved.
 * This file is part of the Piduino Library.
 *
 * The Piduino Library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * The Piduino Library 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
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * along with the Piduino Library; if not, see <http://www.gnu.org/licenses/>.
 */
#pragma once
 
#include <stdarg.h>
#include <syslog.h>
#include <sstream>
#include <string>
#include <piduino/flags.h>
#include <piduino/global.h>
 
namespace Piduino {
 
#ifndef __DOXYGEN__
  class SysLogBuffer :  public std::stringbuf {
    protected:
      SysLogBuffer (int priority) : m_priority (priority) {}
      int sync();
      void setPriority (const int priority);
      inline int priority() const {
        return m_priority;
      }
    private:
      int m_priority;
  };
#endif
 
  class SysLog : protected SysLogBuffer, public std::ostream  {
    public:
 
      enum  Priority {
        Emergency = LOG_EMERG, 
        Alert = LOG_ALERT, 
        Critical = LOG_CRIT, 
        Error = LOG_ERR, 
        Warning = LOG_WARNING, 
        Notice = LOG_NOTICE, 
        Info = LOG_INFO, 
        Debug = LOG_DEBUG, 
        NoPriority = -1
      };
 
      enum Facility {
        Auth = LOG_AUTH, 
        AuthPriv = LOG_AUTHPRIV, 
        Cron = LOG_CRON, 
        Daemon = LOG_DAEMON, 
        Ftp = LOG_FTP, 
        Kernel = LOG_KERN, 
        Local0 = LOG_LOCAL0, 
        Local1 = LOG_LOCAL1, 
        Local2 = LOG_LOCAL2, 
        Local3 = LOG_LOCAL3, 
        Local4 = LOG_LOCAL4, 
        Local5 = LOG_LOCAL5, 
        Local6 = LOG_LOCAL6, 
        Local7 = LOG_LOCAL7, 
        Lpr = LOG_LPR, 
        Mail = LOG_MAIL, 
        News = LOG_NEWS, 
        Syslogd = LOG_SYSLOG, 
        User = LOG_USER, 
        Uucp = LOG_UUCP, 
        NoFacility = -1
      };
 
      enum OptionFlag {
 
        Console = LOG_CONS, 
        NoDelay = LOG_NDELAY, 
        NoWait = LOG_NOWAIT, 
        Delay = LOG_ODELAY, 
        Perror = LOG_PERROR, 
        Pid = LOG_PID, 
        NoOption = 0
      };
 
      typedef Flags<OptionFlag> Option;
      
      SysLog (Priority  initialPrio = Info);
      
      ~SysLog();
 
      void open (const std::string & ident, const SysLog::Facility & facility = User, const SysLog::Option & option = Pid);
      void open (const SysLog::Facility & facility = User, const SysLog::Option & option = Pid);
 
      inline bool is_open() const {
        return m_isopen;
      }
      void close();
 
 
      void log (Priority  p, const char *format, ...);
 
      void log (const char *format, ...);
 
      inline void setMask (Priority  p) {
        (void) setlogmask (LOG_MASK (p));
      }
 
      inline void setMaskUpTo (Priority  p) {
        (void) setlogmask (LOG_UPTO (p));
      }
 
      inline int mask() const {
        return setlogmask (0);
      }
 
      inline void setPriority (Priority  p = Info) {
        SysLogBuffer::setPriority (static_cast<int> (p));
      }
 
      inline Priority priority() const {
        return static_cast<Priority> (SysLogBuffer::priority());
      }
 
      inline std::string priorityName() const {
        return priorityName (priority());
      }
 
      inline Facility facility() const {
        return m_facility;
      }
 
      inline std::string facilityName() const {
        return facilityName (facility());
      }
 
      inline Option option() const {
        return m_option;
      }
 
      static std::string priorityName (Priority  p);
 
      static std::string facilityName (const Facility & facility);
      
      static void cerrToSyslog ();
      
      static void coutToSyslog ();
 
    private:
      Option m_option;
      Facility m_facility;
      bool m_isopen;
    private:
      void open (const char * ident, const SysLog::Facility & facility, const SysLog::Option & option);
  };
 
#ifndef __DOXYGEN__
  struct _Setpriority {
    SysLog::Priority m_value;
  };
 
  inline _Setpriority
  setpriority (SysLog::Priority __priority) {
    return { __priority };
  }
 
  inline std::ostream &
  operator<< (std::ostream & __os, _Setpriority __p) {
    SysLog * log = dynamic_cast<SysLog *> (&__os);
 
    log->setPriority (__p.m_value);
    // __os << "setpriority(" << log->priorityName() << ") ";
    return __os;
  }
#endif
 
  // ---------------------------------------------------------------------------
  //
  //                      Piduino SysLog Global Object
  //
  // ---------------------------------------------------------------------------
  extern SysLog Syslog; 
}