From 3975f8b11ff7a4590cc8654626dc1a6779b704d2 Mon Sep 17 00:00:00 2001 From: brent s Date: Wed, 15 Dec 2021 04:49:03 -0500 Subject: [PATCH] do bitmask better, add (COMPLETELY 100% EXPERIMENTAL NOT DONE YET) eventlog support to logger --- bitmask/bitmasks.go | 46 ++++ bitmask/doc.go | 45 ++++ logging/TODO | 8 + logging/consts.go | 18 -- logging/consts_linux.go | 28 +++ logging/consts_windows.go | 48 ++++ logging/funcs.go | 117 --------- logging/funcs_linux.go | 123 +++++++++ logging/funcs_std.go | 7 +- .../{funcs_sysd.go => funcs_sysd_linux.go} | 8 +- ...{funcs_syslog.go => funcs_syslog_linux.go} | 7 +- logging/funcs_windows.go | 100 ++++++++ logging/funcs_winlogger_windows.go | 238 ++++++++++++++++++ logging/types.go | 19 -- logging/types_linux.go | 23 ++ logging/types_windows.go | 23 ++ types/bitmasks.go | 64 ----- 17 files changed, 698 insertions(+), 224 deletions(-) create mode 100644 bitmask/bitmasks.go create mode 100644 bitmask/doc.go create mode 100644 logging/consts_linux.go create mode 100644 logging/consts_windows.go create mode 100644 logging/funcs_linux.go rename logging/{funcs_sysd.go => funcs_sysd_linux.go} (96%) rename logging/{funcs_syslog.go => funcs_syslog_linux.go} (98%) create mode 100644 logging/funcs_windows.go create mode 100644 logging/funcs_winlogger_windows.go create mode 100644 logging/types_linux.go create mode 100644 logging/types_windows.go delete mode 100644 types/bitmasks.go diff --git a/bitmask/bitmasks.go b/bitmask/bitmasks.go new file mode 100644 index 0000000..2d3d868 --- /dev/null +++ b/bitmask/bitmasks.go @@ -0,0 +1,46 @@ +package bitmask + +// MaskBit is a flag container. +type MaskBit uint8 + +/* + NewMaskBit is a convenience function. + It will return a MaskBit with a (referenced) value of 0, so set your consts up accordingly. + It is highly recommended to set this default as a "None" flag (separate from your iotas!) + as shown in the example. +*/ +func NewMaskBit() (m *MaskBit) { + + m = new(MaskBit) + + return +} + +// HasFlag is true if m has MaskBit flag set/enabled. +func (m *MaskBit) HasFlag(flag MaskBit) (r bool) { + + var b MaskBit = *m + + if b&flag != 0 { + r = true + } + return +} + +// AddFlag adds MaskBit flag to m. +func (m *MaskBit) AddFlag(flag MaskBit) { + *m |= flag + return +} + +// ClearFlag removes MaskBit flag from m. +func (m *MaskBit) ClearFlag(flag MaskBit) { + *m &= flag + return +} + +// ToggleFlag switches MaskBit flag in m to its inverse; if true, it is now false and vice versa. +func (m *MaskBit) ToggleFlag(flag MaskBit) { + *m ^= flag + return +} diff --git a/bitmask/doc.go b/bitmask/doc.go new file mode 100644 index 0000000..bba44e0 --- /dev/null +++ b/bitmask/doc.go @@ -0,0 +1,45 @@ +/* +Package bitmask handles a flag-like opt/bitmask system. + +See https://yourbasic.org/golang/bitmask-flag-set-clear/ for more information. + +To use this, set constants like thus: + + package main + + import ( + "r00t2.io/goutils/bitmask" + ) + + const OPTNONE types.MaskBit = 0 + const ( + OPT1 types.MaskBit = 1 << iota + OPT2 + OPT3 + // ... + ) + + var MyMask *MaskBit + + func main() { + MyMask = types.NewMaskBit + + MyMask.AddFlag(OPT1) + MyMask.AddFlag(OPT3) + + _ = MyMask + } + +This would return true: + + MyMask.HasFlag(OPT1) + +As would this: + + MyMask.HasFlag(OPT3) + +But this would return false: + + MyMask.HasFlag(OPT2) +*/ +package bitmask diff --git a/logging/TODO b/logging/TODO index 319b432..7fca130 100644 --- a/logging/TODO +++ b/logging/TODO @@ -1,3 +1,11 @@ - Implement code line/func/etc. (only for debug?): https://stackoverflow.com/a/24809646 https://golang.org/pkg/runtime/#Caller + +- Support simultaneous writing to multiple Loggers. + +- Suport remote loggers? (eventlog, syslog, systemd) + +- DOCS. + +- Unit/Integration tests. diff --git a/logging/consts.go b/logging/consts.go index 6f5c8d8..5c45941 100644 --- a/logging/consts.go +++ b/logging/consts.go @@ -1,29 +1,11 @@ package logging import ( - `log/syslog` `os` - - `r00t2.io/goutils/types` ) const ( - devlog string = "/dev/log" logPerm os.FileMode = 0600 logPrefix string = "GOLANG PROGRAM" appendFlags int = os.O_APPEND|os.O_CREATE|os.O_WRONLY - syslogFacility syslog.Priority = syslog.LOG_USER -) - -// Flags for logger configuration -const ( - LogUndefined types.MaskBit = 1 << iota - LogJournald - LogSyslog - LogFile - LogStdout -) - -var ( - defLogPaths = []string{"/var/log/golang/program.log", "~/.local/log/golang/program.log"} ) diff --git a/logging/consts_linux.go b/logging/consts_linux.go new file mode 100644 index 0000000..223faf3 --- /dev/null +++ b/logging/consts_linux.go @@ -0,0 +1,28 @@ +package logging + +import ( + `log/syslog` + + `r00t2.io/goutils/bitmask` +) + +const ( + devlog string = "/dev/log" + syslogFacility syslog.Priority = syslog.LOG_USER +) + +// Flags for logger configuration +const ( + LogUndefined bitmask.MaskBit = 1 << iota + LogJournald + LogSyslog + LogFile + LogStdout +) + +var ( + defLogPaths = []string{ + "/var/log/golang/program.log", + "~/.local/log/golang/program.log", + } +) diff --git a/logging/consts_windows.go b/logging/consts_windows.go new file mode 100644 index 0000000..22804f7 --- /dev/null +++ b/logging/consts_windows.go @@ -0,0 +1,48 @@ +package logging + +import ( + `os` + `path/filepath` + `regexp` +) + +// Flags for logger configuration +const ( + LogUndefined types.MaskBit = 1 << iota + LogWinLogger + LogFile + LogStdout +) + +var ( + defLogPaths = []string{ + filepath.Join(os.Getenv("ALLUSERSPROFILE"), "golang", "program.log"), // C:\ProgramData\log\golang\program.log + filepath.Join(os.Getenv("LOCALAPPDATA"), "log", "golang", "program.log"), // C:\Users\\AppData\Local\log\golang\program.log + } +) + +var ptrnSourceExists *regexp.Regexp = regexp.MustCompile(`registry\skey\salready\sexists$`) + +// Default WinEventID +var DefaultEventID *WinEventID = &WinEventID{ + Alert: EventAlert, + Crit: EventCrit, + Debug: EventDebug, + Emerg: EventEmerg, + Err: EventErr, + Info: EventInfo, + Notice: EventNotice, + Warning: EventWarning, +} + +// Default Event IDs for WinEventID. +const ( + EventAlert uint32 = 1 << iota + EventCrit + EventDebug + EventEmerg + EventErr + EventInfo + EventNotice + EventWarning +) diff --git a/logging/funcs.go b/logging/funcs.go index 80ae0e0..c10edb9 100644 --- a/logging/funcs.go +++ b/logging/funcs.go @@ -1,126 +1,9 @@ package logging import ( - native "log" "os" - "path" - - "r00t2.io/goutils/types" - - sysd "github.com/coreos/go-systemd/journal" - "r00t2.io/sysutils/paths" ) -var ( - _ = sysd.Enabled() - _ = native.Logger{} - _ = os.Interrupt -) - -// GetLogger returns an instance of Logger that best suits your system's capabilities. -// If enableDebug is true, debug messages (which according to your program may or may not contain sensitive data) are rendered and written. -// If prefix is "\x00" (a null byte), then the default logging prefix will be used. If anything else, even an empty string, -// is specified then that will be used instead for the prefix. -// logpaths is an (optional) list of strings to use as paths to test for writing. If the file can be created/written to, -// it will be used (assuming you have no higher-level loggers available). Only the first logpaths entry that "works" will be used, later entries will be ignored. -func GetLogger(enableDebug bool, prefix string, logpaths ...string) (logger Logger, err error) { - - var logPath string - var logflags types.MaskBit - - // Configure system-supported logger(s). - if sysd.Enabled() { - // Use Journald. - logflags.AddFlag(LogJournald) - } else { - // If we can detect syslog, use that. If not, try to use a file logger (+ stdout). - // Last ditch, stdout. - var hasSyslog bool - var stat os.FileInfo - var devlogPath string = devlog - - if hasSyslog, stat, err = paths.RealPathExistsStat(&devlogPath); hasSyslog && err != nil { - return - } - - if hasSyslog && !stat.Mode().IsRegular() { - logflags.AddFlag(LogSyslog) - } else { - var exists bool - var success bool - var ckLogPaths []string - logflags.AddFlag(LogStdout) - ckLogPaths = defLogPaths - if logpaths != nil { - ckLogPaths = logpaths - } - for _, p := range ckLogPaths { - if exists, _ = paths.RealPathExists(&p); exists { - if success, err = testOpen(p); err != nil { - continue - } else if !success { - continue - } - logflags.AddFlag(LogFile) - logPath = p - break - } else { - dirPath := path.Dir(p) - if err = paths.MakeDirIfNotExist(&dirPath); err != nil { - continue - } - if success, err = testOpen(p); err != nil { - continue - } else if !success { - continue - } - logflags.AddFlag(LogFile) - logPath = p - break - } - } - } - } - - if logflags.HasFlag(LogJournald) { - logger = &SystemDLogger{ - Prefix: logPrefix, - EnableDebug: enableDebug, - } - } else { - if logflags.HasFlag(LogSyslog) { - logger = &SyslogLogger{ - Prefix: logPrefix, - EnableDebug: enableDebug, - } - } else { - if logflags.HasFlag(LogFile) { - logger = &FileLogger{ - StdLogger: StdLogger{ - Prefix: logPrefix, - EnableDebug: enableDebug, - }, - Path: logPath, - } - } else { - logger = &StdLogger{ - Prefix: logPrefix, - EnableDebug: enableDebug, - } - } - } - } - - logger.Setup() - if prefix != "\x00" { - logger.SetPrefix(prefix) - } - - logger.Info("logger initialized of type %T with prefix %v", logger, logger.GetPrefix()) - - return -} - func testOpen(path string) (success bool, err error) { var f *os.File diff --git a/logging/funcs_linux.go b/logging/funcs_linux.go new file mode 100644 index 0000000..bc6d13c --- /dev/null +++ b/logging/funcs_linux.go @@ -0,0 +1,123 @@ +package logging + +import ( + native `log` + `os` + `path` + + sysd `github.com/coreos/go-systemd/journal` + `r00t2.io/sysutils/paths` +) + +var ( + _ = sysd.Enabled() + _ = native.Logger{} + _ = os.Interrupt +) + +/* + GetLogger returns an instance of Logger that best suits your system's capabilities. + If enableDebug is true, debug messages (which according to your program may or may not contain sensitive data) are rendered and written. + If prefix is "\x00" (a null byte), then the default logging prefix will be used. If anything else, even an empty string, + is specified then that will be used instead for the prefix. + logPaths is an (optional) list of strings to use as paths to test for writing. If the file can be created/written to, + it will be used (assuming you have no higher-level loggers available). Only the first logPaths entry that "works" will be used, later entries will be ignored. +*/ +func GetLogger(enableDebug bool, prefix string, logPaths ...string) (logger Logger, err error) { + + var logPath string + var logFlags types.MaskBit + + // Configure system-supported logger(s). + if sysd.Enabled() { + // Use Journald. + logFlags.AddFlag(LogJournald) + } else { + // If we can detect syslog, use that. If not, try to use a file logger (+ stdout). + // Last ditch, stdout. + var hasSyslog bool + var stat os.FileInfo + var devlogPath string = devlog + + if hasSyslog, stat, err = paths.RealPathExistsStat(&devlogPath); hasSyslog && err != nil { + return + } + + if hasSyslog && !stat.Mode().IsRegular() { + logFlags.AddFlag(LogSyslog) + } else { + var exists bool + var success bool + var ckLogPaths []string + + logFlags.AddFlag(LogStdout) + ckLogPaths = defLogPaths + if logPaths != nil { + ckLogPaths = logPaths + } + for _, p := range ckLogPaths { + if exists, _ = paths.RealPathExists(&p); exists { + if success, err = testOpen(p); err != nil { + continue + } else if !success { + continue + } + logFlags.AddFlag(LogFile) + logPath = p + break + } else { + dirPath := path.Dir(p) + if err = paths.MakeDirIfNotExist(&dirPath); err != nil { + continue + } + if success, err = testOpen(p); err != nil { + continue + } else if !success { + continue + } + logFlags.AddFlag(LogFile) + logPath = p + break + } + } + } + } + + if logFlags.HasFlag(LogJournald) { + logger = &SystemDLogger{ + Prefix: logPrefix, + EnableDebug: enableDebug, + } + } else { + if logFlags.HasFlag(LogSyslog) { + logger = &SyslogLogger{ + Prefix: logPrefix, + EnableDebug: enableDebug, + } + } else { + if logFlags.HasFlag(LogFile) { + logger = &FileLogger{ + StdLogger: StdLogger{ + Prefix: logPrefix, + EnableDebug: enableDebug, + }, + Path: logPath, + } + } else { + logger = &StdLogger{ + Prefix: logPrefix, + EnableDebug: enableDebug, + } + } + } + } + + logger.Setup() + if prefix != "\x00" { + logger.SetPrefix(prefix) + } + + logger.Info("logger initialized of type %T with prefix %v", logger, logger.GetPrefix()) + + return +} diff --git a/logging/funcs_std.go b/logging/funcs_std.go index a5af2ad..f18f972 100644 --- a/logging/funcs_std.go +++ b/logging/funcs_std.go @@ -27,8 +27,11 @@ func (l *StdLogger) SetPrefix(prefix string) { l.Logger.SetPrefix(prefix) } -func (l *StdLogger) GetPrefix() string { - return l.Prefix +func (l *StdLogger) GetPrefix() (prefix string) { + + prefix = l.Prefix + + return } func (l *StdLogger) Alert(s string, v ...interface{}) (err error) { diff --git a/logging/funcs_sysd.go b/logging/funcs_sysd_linux.go similarity index 96% rename from logging/funcs_sysd.go rename to logging/funcs_sysd_linux.go index 493bee3..f39cf15 100644 --- a/logging/funcs_sysd.go +++ b/logging/funcs_sysd_linux.go @@ -29,8 +29,11 @@ func (l *SystemDLogger) SetPrefix(prefix string) { l.Prefix = prefix } -func (l *SystemDLogger) GetPrefix() string { - return l.Prefix +func (l *SystemDLogger) GetPrefix() (prefix string) { + + prefix = l.Prefix + + return } func (l *SystemDLogger) Alert(s string, v ...interface{}) (err error) { @@ -158,6 +161,7 @@ func (l *SystemDLogger) Warning(s string, v ...interface{}) (err error) { } func (l *SystemDLogger) renderWrite(msg string, prio journal.Priority) { + // TODO: implement code line, etc. // https://www.freedesktop.org/software/systemd/man/systemd.journal-fields.html // CODE_FILE=, CODE_LINE=, CODE_FUNC= diff --git a/logging/funcs_syslog.go b/logging/funcs_syslog_linux.go similarity index 98% rename from logging/funcs_syslog.go rename to logging/funcs_syslog_linux.go index ceaed18..fcc50b7 100644 --- a/logging/funcs_syslog.go +++ b/logging/funcs_syslog_linux.go @@ -58,8 +58,11 @@ func (l *SyslogLogger) SetPrefix(prefix string) { l.Setup() } -func (l *SyslogLogger) GetPrefix() string { - return l.Prefix +func (l *SyslogLogger) GetPrefix() (prefix string) { + + prefix = l.Prefix + + return } func (l *SyslogLogger) Alert(s string, v ...interface{}) (err error) { diff --git a/logging/funcs_windows.go b/logging/funcs_windows.go new file mode 100644 index 0000000..13b9ac2 --- /dev/null +++ b/logging/funcs_windows.go @@ -0,0 +1,100 @@ +package logging + +import ( + `errors` + `strings` +) + +/* + GetLogger returns an instance of Logger that best suits your system's capabilities. Note that this is a VERY generalized interface to the Windows Event Log. + If you require more robust logging capabilities (e.g. custom event IDs per uniquely identifiable event), + you will want to set up your own logger (golang.org/x/sys/windows/svc/eventlog). + If enableDebug is true, debug messages (which according to your program may or may not contain sensitive data) are rendered and written (otherwise they are ignored). + A blank source will return an error as it's used as the source name. Other functions, struct fields, etc. will refer to this as the "prefix". + A pointer to a WinEventID struct may be specified for eventIDs to map extended logging levels (as Windows only supports three levels natively). + If it is nil, a default one (DefaultEventID) will be used. + logPaths is an (optional) list of strings to use as paths to test for writing. If the file can be created/written to, + it will be used (assuming you have no higher-level loggers available). + Only the first logPaths entry that "works" will be used, later entries will be ignored. + Currently this will almost always return a WinLogger until multiple logging destination support is added. +*/ +func GetLogger(enableDebug bool, source string, eventIDs *WinEventID, logPaths ...string) (logger Logger, err error) { + + var logPath string + var logFlags types.MaskBit + var exists bool + var success bool + var ckLogPaths []string + + if strings.TrimSpace(source) == "" { + err = errors.New("invalid source for Windows logging") + return + } + + // Configure system-supported logger(s). The Windows Event Logger (should) ALWAYS be available. + logFlags.AddFlag(LogWinLogger) + if eventIDs == nil { + eventIDs = DefaultEventID + } + + if logPaths != nil { + ckLogPaths = logPaths + ckLogPaths = append(ckLogPaths, defLogPaths...) + + for _, p := range ckLogPaths { + if exists, _ = paths.RealPathExists(&p); exists { + if success, err = testOpen(p); err != nil { + continue + } else if !success { + continue + } + logFlags.AddFlag(LogFile) + logPath = p + break + } else { + dirPath := path.Dir(p) + if err = paths.MakeDirIfNotExist(&dirPath); err != nil { + continue + } + if success, err = testOpen(p); err != nil { + continue + } else if !success { + continue + } + logFlags.AddFlag(LogFile) + logPath = p + break + } + } + } + + if logFlags.HasFlag(LogWinLogger) { + logger = &WinLogger{ + Prefix: source, + EnableDebug: enableDebug, + eids: eventIDs, + } + } else { + if logFlags.HasFlag(LogFile) { + logger = &FileLogger{ + StdLogger: StdLogger{ + Prefix: source, + EnableDebug: enableDebug, + }, + Path: logPath, + } + } else { + logger = &StdLogger{ + Prefix: source, + EnableDebug: enableDebug, + } + } + } + + logger.Setup() + + logger.Info("logger initialized of type %T with source %v", logger, logger.GetPrefix()) + + return + +} diff --git a/logging/funcs_winlogger_windows.go b/logging/funcs_winlogger_windows.go new file mode 100644 index 0000000..c12b310 --- /dev/null +++ b/logging/funcs_winlogger_windows.go @@ -0,0 +1,238 @@ +package logging + +import ( + `errors` +) + +func (l *WinLogger) Setup() { + + var err error + + /* + First a sanity check on the EventIDs. + Since we use eventcreate, all Event IDs must be 1 <= eid <= 1000. + */ + for _, eid := range []uint32{ + l.eids.Alert, + l.eids.Crit, + l.eids.Debug, + l.eids.Emerg, + l.eids.Err, + l.eids.Info, + l.eids.Notice, + l.eids.Warning, + } { + if !(1 <= eid <= 1000) { + err = errors.New("event IDs must be between 1 and 1000 inclusive") + panic(err) + } + } + + if err = eventlog.InstallAsEventCreate(l.Prefix, eventlog.Error|eventlog.Warning|eventlog.Info); err != nil { + if idx := ptrnSourceExists.FindStringIndex(err.Error()); idx == nil { + // It's an error we want to panic on. + panic(err) + } else { + // It already exists, so ignore the error. + err = nil + } + } + + if l.elog, err = eventlog.Open(l.Prefix); err != nil { + panic(err) + } + +} + +func (l *WinLogger) Shutdown() { + + var err error + + if err = l.elog.Close(); err != nil { + panic(err) + } + + if err = eventlog.Remove(l.Prefix); err != nil { + panic(err) + } + +} + +func (l *WinLogger) DoDebug(d bool) { + + l.EnableDebug = d + +} + +func (l *WinLogger) SetPrefix(prefix string) { + + var err error + + l.Prefix = prefix + + // To properly change the prefix, we need to tear down the old event log and create a new one. + if err = l.elog.Close(); err != nil { + panic(err) + } + + if err = eventlog.Remove(l.Prefix); err != nil { + panic(err) + } + + if err = eventlog.InstallAsEventCreate(l.Prefix, eventlog.Error|eventlog.Warning|eventlog.Info); err != nil { + if idx := ptrnSourceExists.FindStringIndex(err.Error()); idx == nil { + // It's an error we want to panic on. + panic(err) + } else { + // It already exists, so ignore the error. + err = nil + } + } + + if l.elog, err = eventlog.Open(l.Prefix); err != nil { + panic(err) + } + +} + +func (l *WinLogger) GetPrefix() (prefix string) { + + prefix = l.Prefix + + return +} + +func (l *WinLogger) Alert(s string, v ...interface{}) (err error) { + + var msg string + + if v != nil { + msg = fmt.Sprintf(s, v...) + } else { + msg = s + } + + // Treat ALERT as Warning + err = l.elog.Warning(l.eids.Alert, msg) + + return +} + +func (l *WinLogger) Crit(s string, v ...interface{}) (err error) { + + var msg string + + if v != nil { + msg = fmt.Sprintf(s, v...) + } else { + msg = s + } + + // Treat CRIT as Error + err = l.elog.Error(l.eids.Crit, msg) + + return +} + +func (l *WinLogger) Debug(s string, v ...interface{}) (err error) { + + if !l.EnableDebug { + return + } + + var msg string + + if v != nil { + msg = fmt.Sprintf(s, v...) + } else { + msg = s + } + + // Treat DEBUG as Info + err = l.elog.Info(l.eids.Debug, msg) + + return + +} + +func (l *WinLogger) Emerg(s string, v ...interface{}) (err error) { + + var msg string + + if v != nil { + msg = fmt.Sprintf(s, v...) + } else { + msg = s + } + + // Treat EMERG as Error + err = l.elog.Error(l.eids.Emerg, msg) + + return + +} + +func (l *WinLogger) Err(s string, v ...interface{}) (err error) { + + var msg string + + if v != nil { + msg = fmt.Sprintf(s, v...) + } else { + msg = s + } + + err = l.elog.Error(l.eids.Error, msg) + + return + +} + +func (l *WinLogger) Info(s string, v ...interface{}) (err error) { + + var msg string + + if v != nil { + msg = fmt.Sprintf(s, v...) + } else { + msg = s + } + + err = l.elog.Info(l.eids.Info, msg) + + return + +} + +func (l *WinLogger) Notice(s string, v ...interface{}) (err error) { + + var msg string + + if v != nil { + msg = fmt.Sprintf(s, v...) + } else { + msg = s + } + + // Treat NOTICE as Info + err = l.elog.Info(l.eids.Notice, msg) + + return + +} + +func (l *WinLogger) Warning(s string, v ...interface{}) (err error) { + + var msg string + + if v != nil { + msg = fmt.Sprintf(s, v...) + } else { + msg = s + } + + err = l.elog.Warning(l.eids.Warning, msg) + + return + +} diff --git a/logging/types.go b/logging/types.go index bba044e..9a150e3 100644 --- a/logging/types.go +++ b/logging/types.go @@ -2,7 +2,6 @@ package logging import ( "log" - "log/syslog" "os" ) @@ -22,24 +21,6 @@ type Logger interface { Shutdown() } -type SystemDLogger struct { - EnableDebug bool - Prefix string -} - -type SyslogLogger struct { - EnableDebug bool - Prefix string - alert, - crit, - debug, - emerg, - err, - info, - notice, - warning *syslog.Writer -} - type StdLogger struct { *log.Logger EnableDebug bool diff --git a/logging/types_linux.go b/logging/types_linux.go new file mode 100644 index 0000000..a352ffa --- /dev/null +++ b/logging/types_linux.go @@ -0,0 +1,23 @@ +package logging + +import ( + `log/syslog` +) + +type SystemDLogger struct { + EnableDebug bool + Prefix string +} + +type SyslogLogger struct { + EnableDebug bool + Prefix string + alert, + crit, + debug, + emerg, + err, + info, + notice, + warning *syslog.Writer +} diff --git a/logging/types_windows.go b/logging/types_windows.go new file mode 100644 index 0000000..0941d06 --- /dev/null +++ b/logging/types_windows.go @@ -0,0 +1,23 @@ +package logging + +import ( + `golang.org/x/sys/windows/svc/eventlog` +) + +type WinLogger struct { + EnableDebug bool + Prefix string + elog *eventlog.Log + eids *WinEventID +} + +type WinEventID struct { + Alert, + Crit, + Debug, + Emerg, + Err, + Info, + Notice, + Warning uint32 +} diff --git a/types/bitmasks.go b/types/bitmasks.go deleted file mode 100644 index e70d4e3..0000000 --- a/types/bitmasks.go +++ /dev/null @@ -1,64 +0,0 @@ -package types - -/* - See https://yourbasic.org/golang/bitmask-flag-set-clear/ for more information. - To use this, set constants like thus: - - const ( - OPT1 types.MaskBit = 1 << iota - OPT2 - OPT3 - // ... - ) - - type Object struct { - Opts BitMask - } - - o := Object{ - BitMask: uint8(0) - } - - o.AddFlag(OPT1) - o.AddFlag(OPT3) - - - This would return true: - o.HasFlag(OPT1) - As would this: - o.HasFlag(OPT3) - But this would return false: - o.HasFlag(OPT2) - -*/ -type BitMask interface { - HasFlag(bit MaskBit) bool - AddFlag(bit MaskBit) - ClearFlag(bit MaskBit) - ToggleFlag(bit MaskBit) -} - -// BitMasks -type MaskBit uint8 - -func (f MaskBit) HasFlag(flag MaskBit) (r bool) { - if f&flag != 0 { - r = true - } - return -} - -func (f *MaskBit) AddFlag(flag MaskBit) { - *f |= flag - return -} - -func (f *MaskBit) ClearFlag(flag MaskBit) { - *f &= flag - return -} - -func (f *MaskBit) ToggleFlag(flag MaskBit) { - *f ^= flag - return -}