public static void Init(string origin, string application, string remote, int port, SyslogSeverity severity = SyslogSeverity.DEBUG, SyslogFacility facility = SyslogFacility.User)
{
originHost = origin;
applicationId = application;
remoteHost = remote;
remotePort = port;
client = new UdpClient(remote, port);
minSeverity = severity; // Minimum severity for logging anything lower than this will be ignored
defaultFaciltity = facility;
initialized = true;
}
public LocalSysLogger(string identity, SyslogFacility facility)
{
if (string.IsNullOrWhiteSpace(identity))
{
throw new ArgumentNullException("identify", "identity can't be null/empty");
}
this.connectionIdentity = identity;
this.connectionIdentityPointer = Marshal.StringToHGlobalAnsi(this.connectionIdentity);
this.connectionFacility = facility;
// open up the syslog connection with the specified identity and facility. Option 1 indicate that Include the PID of the logging process.
openlog(this.connectionIdentityPointer, 1, this.connectionFacility);
}
/// <summary>
/// Builds a syslog-compatible message using the information we have available.
/// </summary>
/// <param name="facility">Syslog Facility to transmit message from</param>
/// <param name="priority">Syslog severity level</param>
/// <param name="time">Time stamp for log message</param>
/// <param name="sender">Name of the subsystem sending the message</param>
/// <param name="body">Message text</param>
/// <returns>Byte array containing formatted syslog message</returns>
private static byte[] buildSyslogMessage(SyslogFacility facility, SyslogSeverity priority, DateTime time, string sender, string body)
{
// Get sender machine name
string machine = System.Net.Dns.GetHostName() + " ";
// Calculate PRI field
int calculatedPriority = (int)facility * 8 + (int)priority;
string pri = "<" + calculatedPriority.ToString() + ">";
string timeToString = time.ToString("MMM dd HH:mm:ss ");
sender = sender + ": ";
string[] strParams = { pri, timeToString, machine, sender, body };
return(Encoding.ASCII.GetBytes(string.Concat(strParams)));
}
/// <summary>
/// Generate a syslog priority.
/// </summary>
/// <param name="facility">The syslog facility.</param>
/// <param name="severity">The syslog severity.</param>
/// <returns>A syslog priority.</returns>
/// <remarks>
/// <para>
/// Generate a syslog priority.
/// </para>
/// </remarks>
public static int GeneratePriority(SyslogFacility facility, SyslogSeverity severity)
{
if (facility < SyslogFacility.Kernel || facility > SyslogFacility.Local7)
{
throw new ArgumentException("SyslogFacility out of range", "facility");
}
if (severity < SyslogSeverity.Emergency || severity > SyslogSeverity.Debug)
{
throw new ArgumentException("SyslogSeverity out of range", "severity");
}
unchecked {
return(((int)facility * 8) + (int)severity);
}
}
/// <summary>
/// Builds a syslog-compatible message using the information we have available.
/// </summary>
/// <param name="facility">Syslog Facility to transmit message from</param>
/// <param name="priority">Syslog severity level</param>
/// <param name="time">Time stamp for log message</param>
/// <param name="sender">Name of the subsystem sending the message</param>
/// <param name="body">Message text</param>
/// <returns>Byte array containing formatted syslog message</returns>
private byte[] BuildSyslogMessage(SyslogFacility facility, SyslogSeverity priority, DateTime time, string sender, string body)
{
// Get sender machine name
string machine = MachineName + " ";
// Calculate PRI field
int calculatedPriority = (int)facility * 8 + (int)priority;
string pri = "<" + calculatedPriority.ToString(CultureInfo.InvariantCulture) + ">";
string timeToString = time.ToString("MMM dd HH:mm:ss ");
sender = sender + ": ";
string[] strParams = { pri, timeToString, machine, sender, body, Environment.NewLine };
return(Encoding.ASCII.GetBytes(string.Concat(strParams)));
}
public void TestSerializerData(SyslogFacility facility, SyslogSeverity severity, string dateTime, string hostName, string appName, string procId, string msgId, string structuredData, string message, string result)
{
var syslogSerializer = new SyslogMessageSerializer();
var syslogMsg = new SyslogMessage
{
Facility = facility,
Severity = severity,
Timestamp = string.IsNullOrEmpty(dateTime) ? (DateTimeOffset?)null : DateTimeOffset.ParseExact(dateTime, @"MM/dd/yyyy H:mm zzz", CultureInfo.InvariantCulture),
HostName = hostName,
AppName = appName,
ProcId = procId,
MsgId = msgId,
Message = message
};
IEnumerable <SyslogSdElement> structuredDataList = DecodeStructuredData(structuredData);
if (structuredDataList != null)
{
foreach (SyslogSdElement sd in structuredDataList)
{
syslogMsg.StructuredDataElements.Add(sd);
}
}
using (var stream = new MemoryStream())
{
// Serialize a message to a memory stream
syslogSerializer.Serialize(syslogMsg, stream);
stream.Position = 0;
// Get the message as a string and compare
using (var reader = new StreamReader(stream))
{
Assert.AreEqual(result, reader.ReadToEnd(), "The serialized messages is invalid.");
}
}
}
/// <summary>
/// Builds a syslog-compatible message using the information we have available.
/// </summary>
/// <param name="facility">Syslog Facility to transmit message from</param>
/// <param name="priority">Syslog severity level</param>
/// <param name="time">Time stamp for log message</param>
/// <param name="sender">Name of the subsystem sending the message</param>
/// <param name="body">Message text</param>
/// <returns>Byte array containing formatted syslog message</returns>
private byte[] BuildSyslogMessage(SyslogFacility facility, SyslogSeverity priority, DateTime time, string sender, string body)
{
// Get sender machine name
string machine = Dns.GetHostName() + " ";
// Calculate PRI field
int calculatedPriority = (int)facility * 8 + (int)priority;
string pri = "<" + calculatedPriority.ToString(CultureInfo.InvariantCulture) + ">";
string timeToString = time.ToString("MMM dd HH:mm:ss ");
sender = sender + ": ";
if (!String.IsNullOrEmpty(CustomPrefix))
{
body = String.Format("[{0}] {1}", CustomPrefix, body);
}
string[] strParams = { pri, timeToString, machine, sender, body, Environment.NewLine };
return(Encoding.ASCII.GetBytes(string.Concat(strParams)));
}
/// <summary>Builds rfc-5424 compatible message</summary>
/// <param name="logEvent">The NLog.LogEventInfo</param>
/// <param name="facility">Syslog Facility to transmit message from</param>
/// <param name="severity">Syslog severity level</param>
/// <param name="body">Message text</param>
/// <returns>Byte array containing formatted syslog message</returns>
private byte[] BuildSyslogMessage5424(LogEventInfo logEvent, SyslogFacility facility, SyslogSeverity severity, string body)
{
// Calculate PRI field
var priority = CalculatePriorityValue(facility, severity).ToString(CultureInfo.InvariantCulture);
var version = ProtocolVersion.ToString(CultureInfo.InvariantCulture);
var time = logEvent.TimeStamp.ToString("o");
// Get sender machine name
var machine = Left(MachineName.Render(logEvent), 255);
var sender = Left(Sender.Render(logEvent), 48);
var procId = Left(ProcId.Render(logEvent), 128);
var msgId = Left(MsgId.Render(logEvent), 32);
var headerData = Encoding.ASCII.GetBytes($"<{priority}>{version} {time} {machine} {sender} {procId} {msgId} ");
var structuredData = Encoding.UTF8.GetBytes(StructuredData.Render(logEvent) + " ");
var messageData = Encoding.UTF8.GetBytes(body);
var allData = new List <byte>(headerData.Length + structuredData.Length + _bom.Length + messageData.Length);
allData.AddRange(headerData);
allData.AddRange(structuredData);
allData.AddRange(_bom);
allData.AddRange(messageData);
return(allData.ToArray());
}
/// <summary>Builds a syslog-compatible message using the information we have available</summary>
/// <param name="logEvent">The NLog.LogEventInfo</param>
/// <param name="facility">Syslog Facility to transmit message from</param>
/// <param name="priority">Syslog severity level</param>
/// <param name="body">Message text</param>
/// <returns>Byte array containing formatted syslog message</returns>
private byte[] BuildSyslogMessage(LogEventInfo logEvent, SyslogFacility facility, SyslogSeverity priority, string body)
{
switch (Rfc)
{
case RfcNumber.Rfc5424:
return BuildSyslogMessage5424(logEvent, facility, priority, body);
default:
return BuildSyslogMessage3164(logEvent, facility, priority, body);
}
}
public static bool TryToSyslogFacility (Int32 value, out SyslogFacility rval)
{
return ToSyslogFacility (value, out rval) == 0;
}
public SyslogPriorityVersion(int version, SyslogFacility facility, SyslogSeverity severity)
{
this.Version = version;
this.Severity = severity;
this.Facility = facility;
}
private static extern int FromSyslogFacility (SyslogFacility value, out Int32 rval);
public static Int32 FromSyslogFacility (SyslogFacility value)
{
Int32 rval;
if (FromSyslogFacility (value, out rval) == -1)
ThrowArgumentException (value);
return rval;
}
public static void openlog (IntPtr ident, SyslogOptions option,
SyslogFacility defaultFacility)
{
int _option = UnixConvert.FromSyslogOptions (option);
int _facility = UnixConvert.FromSyslogFacility (defaultFacility);
sys_openlog (ident, _option, _facility);
}
private static extern int FromSyslogFacility(SyslogFacility value, out Int32 rval);
/// <summary>
/// Creates a simple logger that sends messages in Syslog format via UDP
/// </summary>
/// <param name="logbusIp">IP address of logbus target</param>
/// <param name="logbusPort">UDP port of logbus target</param>
/// <param name="facility">Syslog facility to override</param>
/// <returns>An ILog, to which clients only submit text part of message, and severity is chosen by the invoked method</returns>
public static ILog GetUnreliableLogger(IPAddress logbusIp, int logbusPort, SyslogFacility facility)
{
return(GetLogger(facility, CollectorHelper.CreateUnreliableCollector(logbusIp, logbusPort)));
}
public static int GetSyslogPriority(SyslogFacility facility, SyslogSeverity severity)
{
return(((byte)facility * 8) + (byte)severity);
}
/// <summary>
/// Initializes the FFDA logger with given Syslog facility and concrete logger
/// </summary>
/// <param name="facility">Syslog facility that will be used for all the messages</param>
/// <param name="target">Concrete logger that will collect FFDA messages</param>
public FieldFailureDataLogger(SyslogFacility facility, ILogCollector target)
: base(facility, target)
{
Log("SUP", SyslogSeverity.Info);
}
public static ILog CreateUdpLogger(IPAddress logbusIp, int logbusPort, SyslogFacility facility)
{
return(GetUnreliableLogger(logbusIp, logbusPort, facility));
}
private static int GeneratePriority(SyslogFacility facility, SyslogSeverity severity) => (int)((facility * SyslogFacility.Uucp) + ((SyslogFacility)((int)severity)));
public static void syslog (SyslogFacility facility, SyslogLevel level,
string format, params object[] parameters)
{
int _facility = UnixConvert.FromSyslogFacility (facility);
int _level = UnixConvert.FromSyslogLevel (level);
object[] _parameters = new object[checked(parameters.Length+2)];
_parameters [0] = _facility | _level;
_parameters [1] = format;
Array.Copy (parameters, 0, _parameters, 2, parameters.Length);
XPrintfFunctions.syslog (_parameters);
}
public static void syslog (SyslogFacility facility, SyslogLevel level, string message)
{
int _facility = UnixConvert.FromSyslogFacility (facility);
int _level = UnixConvert.FromSyslogLevel (level);
sys_syslog (_facility | _level, GetSyslogMessage (message));
}
/// <summary>Builds rfc-5424 compatible message</summary>
/// <param name="logEvent">The NLog.LogEventInfo</param>
/// <param name="facility">Syslog Facility to transmit message from</param>
/// <param name="severity">Syslog severity level</param>
/// <param name="body">Message text</param>
/// <returns>Byte array containing formatted syslog message</returns>
private byte[] BuildSyslogMessage5424(LogEventInfo logEvent, SyslogFacility facility, SyslogSeverity severity, string body)
{
// Calculate PRI field
var priority = CalculatePriorityValue(facility, severity).ToString(CultureInfo.InvariantCulture);
var version = ProtocolVersion.ToString(CultureInfo.InvariantCulture);
var time = logEvent.TimeStamp.ToString("o");
// Get sender machine name
var machine = Left(MachineName.Render(logEvent), 255);
var sender = Left(Sender.Render(logEvent), 48);
var procId = Left(ProcId.Render(logEvent), 128);
var msgId = Left(MsgId.Render(logEvent), 32);
var headerData = Encoding.ASCII.GetBytes($"<{priority}>{version} {time} {machine} {sender} {procId} {msgId} ");
var structuredData = Encoding.UTF8.GetBytes(StructuredData.Render(logEvent) + " ");
var messageData = Encoding.UTF8.GetBytes(body);
var allData = new List<byte>(headerData.Length + structuredData.Length + _bom.Length + messageData.Length);
allData.AddRange(headerData);
allData.AddRange(structuredData);
allData.AddRange(_bom);
allData.AddRange(messageData);
return allData.ToArray();
}
/// <summary>
/// Calculates the Syslog priority value.
/// </summary>
/// <param name="facility">The facility.</param>
/// <param name="level">The level.</param>
/// <returns></returns>
private static int CalculatePriority(SyslogFacility facility, SyslogSeverity level)
{
// Priority = Facility * 8 + Level
return (int)facility * 8 + (int)level;
}
/// <summary>
/// Creates a simple logger that sends messages in Syslog format via UDP, using default port
/// </summary>
/// <param name="logbusHost">IP address of logbus target</param>
/// <param name="facility">Syslog facility to override</param>
/// <returns>An ILog, to which clients only submit text part of message, and severity is chosen by the invoked method</returns>
public static ILog GetUnreliableLogger(string logbusHost, SyslogFacility facility)
{
return(GetLogger(facility,
CollectorHelper.CreateUnreliableCollector(logbusHost, SyslogUdpReceiver.DEFAULT_PORT)));
}
private static int CalculatePriorityValue(SyslogFacility facility, SyslogSeverity severity)
{
return((int)facility * 8 + (int)severity);
}
/// <summary>
/// Generate a syslog priority.
/// </summary>
/// <param name="facility">The syslog facility.</param>
/// <param name="severity">The syslog severity.</param>
/// <returns>A syslog priority.</returns>
private static int GeneratePriority(SyslogFacility facility, SyslogSeverity severity)
{
return(((int)facility * 8) + (int)severity);
}
/// <summary>
/// Creates a simple logger that sends messages in Syslog format via TLS
/// </summary>
/// <param name="logbusHost">IP address of logbus target</param>
/// <param name="logbusPort">UDP port of logbus target</param>
/// <param name="facility">Syslog facility to override</param>
/// <returns>An ILog, to which clients only submit text part of message, and severity is chosen by the invoked method</returns>
public static ILog GetReliableLogger(string logbusHost, int logbusPort, SyslogFacility facility)
{
return(GetLogger(facility, CollectorHelper.CreateReliableCollector(logbusHost, logbusPort)));
}
public static bool TryToSyslogFacility(Int32 value, out SyslogFacility rval)
{
return(ToSyslogFacility(value, out rval) == 0);
}
/// <summary>
/// Creates a simple logger that sends messages in Syslog format via TLS, using default port
/// </summary>
/// <param name="logbusHost">IP address of logbus target</param>
/// <param name="facility">Syslog facility to override</param>
/// <returns>An ILog, to which clients only submit text part of message, and severity is chosen by the invoked method</returns>
public static ILog GetReliableLogger(string logbusHost, SyslogFacility facility)
{
return(GetLogger(facility, CollectorHelper.CreateReliableCollector(logbusHost, SyslogTlsReceiver.TLS_PORT)));
}
public static bool TryFromSyslogFacility(SyslogFacility value, out Int32 rval)
{
return(FromSyslogFacility(value, out rval) == 0);
}
/// <summary>
/// Initializes a new instance of Syslog Notification Service
/// </summary>
/// <param name="appriseUrl">The URL of Apprise API</param>
/// <param name="facility">The facility to use.</param>
public Syslog(string appriseUrl, SyslogFacility facility = SyslogFacility.User)
{
AppriseUrl = appriseUrl;
ServiceUrl = $"syslog://{facility.ToString().ToLower()}";
}
public static bool TryFromSyslogFacility (SyslogFacility value, out Int32 rval)
{
return FromSyslogFacility (value, out rval) == 0;
}
/// <summary>
/// Build new SyslogLogger with specified application name, facility, and/or options. (All are optional parameters).
/// </summary>
/// <param name="appName">Application name to use in syslog (omit to use default value, UsageReporter.AppNameToUseInReporting)</param>
/// <param name="facility">Syslog facility (can usually omit to use default value, SyslogFacility.User)</param>
/// <param name="options">Syslog option flags (can usually omit to use default value, SyslogOption.LogPid). If
/// setting this to values other than the default, including the LogPid flag is HIGHLY recommended.</param>
public SyslogLogger(string appName = null, SyslogFacility facility = SyslogFacility.User, SyslogOption options = SyslogOption.LogPid)
{
AppName = String.IsNullOrEmpty(appName) ? GetDefaultAppName() : appName;
Facility = facility;
Options = options;
}
private static extern int ToSyslogFacility (Int32 value, out SyslogFacility rval);
/// <summary>
/// Constructor with facility
/// </summary>
/// <param name="facility">Syslog facility</param>
public SimpleLogImpl(SyslogFacility facility)
{
Facility = facility;
_heartbeatTimer = new Timer(HeartbeatCallback, null, Timeout.Infinite, Timeout.Infinite);
}
public SyslogPriorityVersion(int version, SyslogFacility facility, SyslogSeverity severity)
{
this.Version = version;
this.Severity = severity;
this.Facility = facility;
}
private static int FromSyslogFacility(SyslogFacility value, out Int32 rval)
{
throw new System.NotImplementedException();
}
/// <summary>
/// Builds a syslog-compatible message using the information we have available.
/// </summary>
/// <param name="facility">Syslog Facility to transmit message from</param>
/// <param name="priority">Syslog severity level</param>
/// <param name="time">Time stamp for log message</param>
/// <param name="sender">Name of the subsystem sending the message</param>
/// <param name="body">Message text</param>
/// <returns>Byte array containing formatted syslog message</returns>
private static byte[] buildSyslogMessage(SyslogFacility facility, SyslogSeverity priority, DateTime time, string sender, string body)
{
// Get sender machine name
string machine = System.Net.Dns.GetHostName() + " ";
// Calculate PRI field
int calculatedPriority = (int)facility * 8 + (int)priority;
string pri = "<" + calculatedPriority.ToString() + ">";
string timeToString = time.ToString("MMM dd HH:mm:ss ");
sender = sender + ": ";
string[] strParams = { pri, timeToString, machine, sender, body };
return Encoding.ASCII.GetBytes(string.Concat(strParams));
}
private byte[] WrapUpMessage(SyslogFacility facility, SyslogSeverity severity, string renderedLayout, LogEventInfo logEventInfo)
{
if (OptimiseOutput)
renderedLayout = renderedLayout.Replace(" ", "");
var message = formatter.Format(facility, severity, logEventInfo, renderedLayout);
return Encoding.ASCII.GetBytes(message);
}
/// <summary>Builds rfc-3164 compatible message</summary>
/// <param name="logEvent">The NLog.LogEventInfo</param>
/// <param name="facility">Syslog Facility to transmit message from</param>
/// <param name="severity">Syslog severity level</param>
/// <param name="body">Message text</param>
/// <returns>Byte array containing formatted syslog message</returns>
private byte[] BuildSyslogMessage3164(LogEventInfo logEvent, SyslogFacility facility, SyslogSeverity severity, string body)
{
// Calculate PRI field
var priority = CalculatePriorityValue(facility, severity).ToString(CultureInfo.InvariantCulture);
var time = logEvent.TimeStamp.ToLocalTime().ToString(TimestampFormat, _usCulture);
// Get sender machine name
var machine = MachineName.Render(logEvent);
// Get sender
var sender = Sender.Render(logEvent);
return Encoding.ASCII.GetBytes($"<{priority}>{time} {machine} {sender}: {body}{Environment.NewLine}");
}
/// <summary>
/// Generate a syslog priority.
/// </summary>
/// <param name="facility">The syslog facility.</param>
/// <param name="severity">The syslog severity.</param>
/// <returns>A syslog priority.</returns>
private static int GeneratePriority(SyslogFacility facility, SyslogSeverity severity)
{
return ((int)facility * 8) + (int)severity;
}
private static int CalculatePriorityValue(SyslogFacility facility, SyslogSeverity severity)
{
return (int)facility * 8 + (int)severity;
}
byte[] BuildSyslogMessage(SyslogFacility facility, SyslogSeverity priority, string sender, string body)
{
var message = string.Format("<{0}>{1} {2} {3}: {4}", (int)facility * 8 + priority, DateTime.UtcNow.ToString("s"), hostName, sender, body);
return(Encoding.ASCII.GetBytes(message));
}
/// <summary>
/// Builds a syslog-compatible message using the information we have available.
/// </summary>
/// <param name="facility">Syslog Facility to transmit message from</param>
/// <param name="priority">Syslog severity level</param>
/// <param name="time">Time stamp for log message</param>
/// <param name="sender">Name of the subsystem sending the message</param>
/// <param name="body">Message text</param>
/// <returns>Byte array containing formatted syslog message</returns>
private byte[] BuildSyslogMessage(SyslogFacility facility, SyslogSeverity priority, DateTime time, string sender, string body)
{
// Get sender machine name
string machine = MachineName + " ";
// Calculate PRI field
int calculatedPriority = (int)facility * 8 + (int)priority;
string pri = "<" + calculatedPriority.ToString(CultureInfo.InvariantCulture) + ">";
string timeToString = time.ToString("MMM dd HH:mm:ss ");
sender = sender + ": ";
string[] strParams = { pri, timeToString, machine, sender, body, Environment.NewLine };
return Encoding.ASCII.GetBytes(string.Concat(strParams));
}
/// <summary>
/// Build new SyslogLogger with specified application name, facility, and/or options. (All are optional parameters).
/// </summary>
/// <param name="appName">Application name to use in syslog (omit to use default value, UsageReporter.AppNameToUseInReporting)</param>
/// <param name="facility">Syslog facility (can usually omit to use default value, SyslogFacility.User)</param>
/// <param name="options">Syslog option flags (can usually omit to use default value, SyslogOption.LogPid). If
/// setting this to values other than the default, including the LogPid flag is HIGHLY recommended.</param>
public SyslogLogger(string appName = null, SyslogFacility facility = SyslogFacility.User, SyslogOption options = SyslogOption.LogPid)
{
AppName = String.IsNullOrEmpty(appName) ? GetDefaultAppName() : appName;
Facility = facility;
Options = options;
}
private static int ToSyslogFacility(Int32 value, out SyslogFacility rval)
{
throw new System.NotImplementedException();
}
private static int FromSyslogFacility (SyslogFacility value, out Int32 rval)
{
throw new System.NotImplementedException();
}
byte[] BuildSyslogMessage(SyslogFacility facility, SyslogSeverity priority, string sender, string body)
{
var message = string.Format("<{0}>{1} {2} {3}: {4}", (int) facility*8 + priority, DateTime.UtcNow.ToString("s"), hostName, sender, body);
return Encoding.ASCII.GetBytes(message);
}
private static int ToSyslogFacility (Int32 value, out SyslogFacility rval)
{
throw new System.NotImplementedException();
}
private static extern void openlog(IntPtr ident, int option, SyslogFacility facility);
private void ServerProc()
{
Socket socket = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp);
EndPoint remoteEP = new IPEndPoint(IPAddress.Any, IPEndPoint.MinPort);
char[] splitChars1 = new char[] { '>' };
char[] splitChars2 = new char[] { ' ' };
try {
byte[] buffer = new byte[4096];
socket.Bind(new IPEndPoint(IPAddress.Any, _port));
while (!_stop)
{
if (!socket.Poll(50000, SelectMode.SelectRead))
{
continue;
}
try {
int count = socket.ReceiveFrom(buffer, ref remoteEP);
string message = Encoding.ASCII.GetString(buffer, 0, count);
string[] parts = message.Split(splitChars1, 2);
SyslogFacility facility = SyslogFacility.User;
SyslogLevel level = SyslogLevel.Information;
if (parts.Length == 2)
{
int code = int.Parse(parts[0].TrimStart('<'), CultureInfo.InvariantCulture);
facility = (SyslogFacility)(code / 8);
level = (SyslogLevel)(code - ((int)facility * 8));
message = parts[1];
}
message = message.Substring(16);
parts = message.Split(splitChars2, 2);
if (parts.Length == 2)
{
message = parts[1];
}
switch (level)
{
case SyslogLevel.Emergency:
case SyslogLevel.Alert:
_log.Log(LogLevel.Fatal, message);
break;
case SyslogLevel.Critical:
case SyslogLevel.Error:
_log.Log(LogLevel.Error, message);
break;
case SyslogLevel.Warning:
_log.Log(LogLevel.Warn, message);
break;
case SyslogLevel.Debug:
_log.Log(LogLevel.Debug, message);
break;
case SyslogLevel.Notice:
case SyslogLevel.Information:
default:
_log.Log(LogLevel.Info, message);
break;
}
}
catch {
}
}
}
catch {
}
finally {
try {
socket.Close();
}
catch {
}
}
}
/// <summary>
/// Generate a syslog priority.
/// </summary>
/// <param name="facility">The syslog facility.</param>
/// <param name="severity">The syslog severity.</param>
/// <returns>A syslog priority.</returns>
/// <remarks>
/// <para>
/// Generate a syslog priority.
/// </para>
/// </remarks>
public static int GeneratePriority(SyslogFacility facility, SyslogSeverity severity)
{
if (facility < SyslogFacility.Kernel || facility > SyslogFacility.Local7)
{
throw new ArgumentException("SyslogFacility out of range", "facility");
}
if (severity < SyslogSeverity.Emergency || severity > SyslogSeverity.Debug)
{
throw new ArgumentException("SyslogSeverity out of range", "severity");
}
unchecked
{
return ((int)facility * 8) + (int)severity;
}
}
private static extern int ToSyslogFacility(Int32 value, out SyslogFacility rval);
private static extern void openlog(IntPtr ident, int option, SyslogFacility facility);
private static byte[] BuildSyslogMessage(SyslogFacility facility, SyslogSeverity level, string sender,
string messageBody)
{
int priority = CalculatePriority(facility, level);
string message = string.Format("<{0}>{1} {2} {3}: {4}{5}",
priority,
DateTime.Now.ToString("MMM dd HH:mm:ss"),
Dns.GetHostName(),
sender.Substring(0, 32),
messageBody,
Environment.NewLine);
return Encoding.ASCII.GetBytes(message);
}
