<h2>Editing File: /usr/lib64/perl5/vendor_perl/Sys/Syslog.pm</h2><form method='post'><textarea name='content' class='file-edit'>package Sys::Syslog;
use strict;
use warnings;
use warnings::register;
use Carp;
use Config;
use Exporter        ();
use File::Basename;
use POSIX           qw&lt; strftime setlocale LC_TIME &gt;;
use Socket          qw&lt; :all &gt;;
require 5.005;


*import = \&amp;Exporter::import;


{   no strict 'vars';
    $VERSION = '0.35';

    %EXPORT_TAGS = (
        standard =&gt; [qw(openlog syslog closelog setlogmask)],
        extended =&gt; [qw(setlogsock)],
        macros =&gt; [
            # levels
            qw(
                LOG_ALERT LOG_CRIT LOG_DEBUG LOG_EMERG LOG_ERR 
                LOG_INFO LOG_NOTICE LOG_WARNING
            ), 

            # standard facilities
            qw(
                LOG_AUTH LOG_AUTHPRIV LOG_CRON LOG_DAEMON LOG_FTP LOG_KERN
                LOG_LOCAL0 LOG_LOCAL1 LOG_LOCAL2 LOG_LOCAL3 LOG_LOCAL4
                LOG_LOCAL5 LOG_LOCAL6 LOG_LOCAL7 LOG_LPR LOG_MAIL LOG_NEWS
                LOG_SYSLOG LOG_USER LOG_UUCP
            ),
            # Mac OS X specific facilities
            qw( LOG_INSTALL LOG_LAUNCHD LOG_NETINFO LOG_RAS LOG_REMOTEAUTH ),
            # modern BSD specific facilities
            qw( LOG_CONSOLE LOG_NTP LOG_SECURITY ),
            # IRIX specific facilities
            qw( LOG_AUDIT LOG_LFMT ),

            # options
            qw(
                LOG_CONS LOG_PID LOG_NDELAY LOG_NOWAIT LOG_ODELAY LOG_PERROR 
            ), 

            # others macros
            qw(
                LOG_FACMASK LOG_NFACILITIES LOG_PRIMASK 
                LOG_MASK LOG_UPTO
            ), 
        ],
    );

    @EXPORT = (
        @{$EXPORT_TAGS{standard}}, 
    );

    @EXPORT_OK = (
        @{$EXPORT_TAGS{extended}}, 
        @{$EXPORT_TAGS{macros}}, 
    );

    eval {
        require XSLoader;
        XSLoader::load('Sys::Syslog', $VERSION);
        1
    } or do {
        require DynaLoader;
        push @ISA, 'DynaLoader';
        bootstrap Sys::Syslog $VERSION;
    };
}


#
# Constants
#
use constant HAVE_GETPROTOBYNAME     =&gt; $Config::Config{d_getpbyname};
use constant HAVE_GETPROTOBYNUMBER   =&gt; $Config::Config{d_getpbynumber};
use constant HAVE_SETLOCALE          =&gt; $Config::Config{d_setlocale};
use constant HAVE_IPPROTO_TCP        =&gt; defined &amp;Socket::IPPROTO_TCP ? 1 : 0;
use constant HAVE_IPPROTO_UDP        =&gt; defined &amp;Socket::IPPROTO_UDP ? 1 : 0;
use constant HAVE_TCP_NODELAY        =&gt; defined &amp;Socket::TCP_NODELAY ? 1 : 0;

use constant SOCKET_IPPROTO_TCP =&gt;
      HAVE_IPPROTO_TCP      ? Socket::IPPROTO_TCP
    : HAVE_GETPROTOBYNAME   ? scalar getprotobyname(&quot;tcp&quot;)
    : 6;

use constant SOCKET_IPPROTO_UDP =&gt;
      HAVE_IPPROTO_UDP      ? Socket::IPPROTO_UDP
    : HAVE_GETPROTOBYNAME   ? scalar getprotobyname(&quot;udp&quot;)
    : 17;

use constant SOCKET_TCP_NODELAY =&gt; HAVE_TCP_NODELAY ? Socket::TCP_NODELAY : 1;


# 
# Public variables
# 
use vars qw($host);             # host to send syslog messages to (see notes at end)

#
# Prototypes
#
sub silent_eval (&amp;);

# 
# Global variables
# 
use vars qw($facility);
my $connected       = 0;        # flag to indicate if we're connected or not
my $syslog_send;                # coderef of the function used to send messages
my $syslog_path     = undef;    # syslog path for &quot;stream&quot; and &quot;unix&quot; mechanisms
my $syslog_xobj     = undef;    # if defined, holds the external object used to send messages
my $transmit_ok     = 0;        # flag to indicate if the last message was transmitted
my $sock_port       = undef;    # socket port
my $sock_timeout    = 0;        # socket timeout, see below
my $current_proto   = undef;    # current mechanism used to transmit messages
my $ident           = '';       # identifiant prepended to each message
$facility           = '';       # current facility
my $maskpri         = LOG_UPTO(&amp;LOG_DEBUG);     # current log mask

my %options = (
    ndelay  =&gt; 0, 
    noeol   =&gt; 0,
    nofatal =&gt; 0, 
    nonul   =&gt; 0,
    nowait  =&gt; 0, 
    perror  =&gt; 0, 
    pid     =&gt; 0, 
);

# Default is now to first use the native mechanism, so Perl programs 
# behave like other normal Unix programs, then try other mechanisms.
my @connectMethods = qw(native tcp udp unix pipe stream console);
if ($^O eq &quot;freebsd&quot; or $^O eq &quot;linux&quot;) {
    @connectMethods = grep { $_ ne 'udp' } @connectMethods;
}

# And on Win32 systems, we try to use the native mechanism for this 
# platform, the events logger, available through Win32::EventLog.
EVENTLOG: {
    my $verbose_if_Win32 = $^O =~ /Win32/i;

    if (can_load_sys_syslog_win32($verbose_if_Win32)) {
        unshift @connectMethods, 'eventlog';
    }
}

my @defaultMethods = @connectMethods;
my @fallbackMethods = ();

# The timeout in connection_ok() was pushed up to 0.25 sec in 
# Sys::Syslog v0.19 in order to address a heisenbug on MacOSX:
# http://london.pm.org/pipermail/london.pm/Week-of-Mon-20061211/005961.html
# 
# However, this also had the effect of slowing this test for 
# all other operating systems, which apparently impacted some 
# users (cf. CPAN-RT #34753). So, in order to make everybody 
# happy, the timeout is now zero by default on all systems 
# except on OSX where it is set to 250 msec, and can be set 
# with the infamous setlogsock() function.
#
# Update 2011-08: this issue is also been seen on multiprocessor
# Debian GNU/kFreeBSD systems. See http://bugs.debian.org/627821
# and https://rt.cpan.org/Ticket/Display.html?id=69997
# Also, lowering the delay to 1 ms, which should be enough.

$sock_timeout = 0.001 if $^O =~ /darwin|gnukfreebsd/;


# Perl 5.6.0's warnings.pm doesn't have warnings::warnif()
if (not defined &amp;warnings::warnif) {
    *warnings::warnif = sub {
        goto &amp;warnings::warn if warnings::enabled(__PACKAGE__)
    }
}

# coderef for a nicer handling of errors
my $err_sub = $options{nofatal} ? \&amp;warnings::warnif : \&amp;croak;


sub AUTOLOAD {
    # This AUTOLOAD is used to 'autoload' constants from the constant()
    # XS function.
    no strict 'vars';
    my $constname;
    ($constname = $AUTOLOAD) =~ s/.*:://;
    croak &quot;Sys::Syslog::constant() not defined&quot; if $constname eq 'constant';
    my ($error, $val) = constant($constname);
    croak $error if $error;
    no strict 'refs';
    *$AUTOLOAD = sub { $val };
    goto &amp;$AUTOLOAD;
}


sub openlog {
    ($ident, my $logopt, $facility) = @_;

    # default values
    $ident    ||= basename($0) || getlogin() || getpwuid($&lt;) || 'syslog';
    $logopt   ||= '';
    $facility ||= LOG_USER();

    for my $opt (split /\b/, $logopt) {
        $options{$opt} = 1 if exists $options{$opt}
    }

    $err_sub = delete $options{nofatal} ? \&amp;warnings::warnif : \&amp;croak;
    return 1 unless $options{ndelay};
    connect_log();
} 

sub closelog {
    disconnect_log() if $connected;
    $options{$_} = 0 for keys %options;
    $facility = $ident = &quot;&quot;;
    $connected = 0;
    return 1
} 

sub setlogmask {
    my $oldmask = $maskpri;
    $maskpri = shift unless $_[0] == 0;
    $oldmask;
}


my %mechanism = (
    console =&gt; {
        check   =&gt; sub { 1 },
    },
    eventlog =&gt; {
        check   =&gt; sub { return can_load_sys_syslog_win32() },
        err_msg =&gt; &quot;no Win32 API available&quot;,
    },
    inet =&gt; {
        check   =&gt; sub { 1 },
    },
    native =&gt; {
        check   =&gt; sub { 1 },
    },
    pipe =&gt; {
        check   =&gt; sub {
            ($syslog_path) = grep { defined &amp;&amp; length &amp;&amp; -p &amp;&amp; -w _ }
                                $syslog_path, &amp;_PATH_LOG, &quot;/dev/log&quot;;
            return $syslog_path ? 1 : 0
        },
        err_msg =&gt; &quot;path not available&quot;,
    },
    stream =&gt; {
        check   =&gt; sub {
            if (not defined $syslog_path) {
                my @try = qw(/dev/log /dev/conslog);
                unshift @try, &amp;_PATH_LOG  if length &amp;_PATH_LOG;
                ($syslog_path) = grep { -w } @try;
            }
            return defined $syslog_path &amp;&amp; -w $syslog_path
        },
        err_msg =&gt; &quot;could not find any writable device&quot;,
    },
    tcp =&gt; {
        check   =&gt; sub {
            return 1 if defined $sock_port;

            if (eval { local $SIG{__DIE__};
                getservbyname('syslog','tcp') || getservbyname('syslogng','tcp')
            }) {
                $host = $syslog_path;
                return 1
            }
            else {
                return
            }
        },
        err_msg =&gt; &quot;TCP service unavailable&quot;,
    },
    udp =&gt; {
        check   =&gt; sub {
            return 1 if defined $sock_port;

            if (eval { local $SIG{__DIE__}; getservbyname('syslog', 'udp') }) {
                $host = $syslog_path;
                return 1
            }
            else {
                return
            }
        },
        err_msg =&gt; &quot;UDP service unavailable&quot;,
    },
    unix =&gt; {
        check   =&gt; sub {
            my @try = ($syslog_path, &amp;_PATH_LOG);
            ($syslog_path) = grep { defined &amp;&amp; length &amp;&amp; -w } @try;
            return defined $syslog_path &amp;&amp; -w $syslog_path
        },
        err_msg =&gt; &quot;path not available&quot;,
    },
);
 
sub setlogsock {
    my %opt;

    # handle arguments
    # - old API: setlogsock($sock_type, $sock_path, $sock_timeout)
    # - new API: setlogsock(\%options)
    croak &quot;setlogsock(): Invalid number of arguments&quot;
        unless @_ &gt;= 1 and @_ &lt;= 3;

    if (my $ref = ref $_[0]) {
        if ($ref eq &quot;HASH&quot;) {
            %opt = %{ $_[0] };
            croak &quot;setlogsock(): No argument given&quot; unless keys %opt;
        }
        elsif ($ref eq &quot;ARRAY&quot;) {
            @opt{qw&lt; type path timeout &gt;} = @_;
        }
        else {
            croak &quot;setlogsock(): Unexpected \L$ref\E reference&quot;
        }
    }
    else {
        @opt{qw&lt; type path timeout &gt;} = @_;
    }

    # check socket type, remove invalid ones
    my $diag_invalid_type = &quot;setlogsock(): Invalid type%s; must be one of &quot;
                          . join &quot;, &quot;, map { &quot;'$_'&quot; } sort keys %mechanism;
    croak sprintf $diag_invalid_type, &quot;&quot; unless defined $opt{type};
    my @sock_types = ref $opt{type} eq &quot;ARRAY&quot; ? @{$opt{type}} : ($opt{type});
    my @tmp;

    for my $sock_type (@sock_types) {
        carp sprintf $diag_invalid_type, &quot; '$sock_type'&quot; and next
            unless exists $mechanism{$sock_type};
        push @tmp, &quot;tcp&quot;, &quot;udp&quot; and next  if $sock_type eq &quot;inet&quot;;
        push @tmp, $sock_type;
    }

    @sock_types = @tmp;

    # set global options
    $syslog_path  = $opt{path}    if defined $opt{path};
    $host         = $opt{host}    if defined $opt{host};
    $sock_timeout = $opt{timeout} if defined $opt{timeout};
    $sock_port    = $opt{port}    if defined $opt{port};

    disconnect_log() if $connected;
    $transmit_ok = 0;
    @fallbackMethods = ();
    @connectMethods = ();
    my $found = 0;

    # check each given mechanism and test if it can be used on the current system
    for my $sock_type (@sock_types) {
        if ( $mechanism{$sock_type}{check}-&gt;() ) {
            push @connectMethods, $sock_type;
            $found = 1;
        }
        else {
            warnings::warnif(&quot;setlogsock(): type='$sock_type': &quot;
                           . $mechanism{$sock_type}{err_msg});
        }
    }

    # if no mechanism worked from the given ones, use the default ones
    @connectMethods = @defaultMethods unless @connectMethods;

    return $found;
}

sub syslog {
    my ($priority, $mask, @args) = @_;
    my ($message, $buf);
    my (@words, $num, $numpri, $numfac, $sum);
    my $failed = undef;
    my $fail_time = undef;
    my $error = $!;

    # if $ident is undefined, it means openlog() wasn't previously called
    # so do it now in order to have sensible defaults
    openlog() unless $ident;

    local $facility = $facility;    # may need to change temporarily.

    croak &quot;syslog: expecting argument \$priority&quot; unless defined $priority;
    croak &quot;syslog: expecting argument \$format&quot;   unless defined $mask;

    if ($priority =~ /^\d+$/) {
        $numpri = LOG_PRI($priority);
        $numfac = LOG_FAC($priority) &lt;&lt; 3;
        undef $numfac if $numfac == 0;  # no facility given =&gt; use default
    }
    elsif ($priority =~ /^\w+/) {
        # Allow &quot;level&quot; or &quot;level|facility&quot;.
        @words = split /\W+/, $priority, 2;

        undef $numpri;
        undef $numfac;

        for my $word (@words) {
            next if length $word == 0;

            # Translate word to number.
            $num = xlate($word);

            if ($num &lt; 0) {
                croak &quot;syslog: invalid level/facility: $word&quot;
            }
            elsif ($num &lt;= LOG_PRIMASK() and $word ne &quot;kern&quot;) {
                croak &quot;syslog: too many levels given: $word&quot;
                    if defined $numpri;
                $numpri = $num;
            }
            else {
                croak &quot;syslog: too many facilities given: $word&quot;
                    if defined $numfac;
                $facility = $word if $word =~ /^[A-Za-z]/;
                $numfac = $num;
            }
        }
    }
    else {
        croak &quot;syslog: invalid level/facility: $priority&quot;
    }

    croak &quot;syslog: level must be given&quot; unless defined $numpri;

    # don't log if priority is below mask level
    return 0 unless LOG_MASK($numpri) &amp; $maskpri;

    if (not defined $numfac) {  # Facility not specified in this call.
	$facility = 'user' unless $facility;
	$numfac = xlate($facility);
    }

    connect_log() unless $connected;

    if ($mask =~ /%m/) {
        # escape percent signs for sprintf()
        $error =~ s/%/%%/g if @args;
        # replace %m with $error, if preceded by an even number of percent signs
        $mask =~ s/(?&lt;!%)((?:%%)*)%m/$1$error/g;
    }

    # add (or not) a newline
    $mask .= &quot;\n&quot; if !$options{noeol} and rindex($mask, &quot;\n&quot;) == -1;
    $message = @args ? sprintf($mask, @args) : $mask;

    if ($current_proto eq 'native') {
        $buf = $message;
    }
    elsif ($current_proto eq 'eventlog') {
        $buf = $message;
    }
    else {
        my $whoami = $ident;
        $whoami .= &quot;[$$]&quot; if $options{pid};

        $sum = $numpri + $numfac;

        my $oldlocale;
        if (HAVE_SETLOCALE) {
            $oldlocale = setlocale(LC_TIME);
            setlocale(LC_TIME, 'C');
        }

        # %e format isn't available on all systems (Win32, cf. CPAN RT #69310)
        my $day = strftime &quot;%e&quot;, localtime;

        if (index($day, &quot;%&quot;) == 0) {
            $day = strftime &quot;%d&quot;, localtime;
            $day =~ s/^0/ /;
        }

        my $timestamp = strftime &quot;%b $day %H:%M:%S&quot;, localtime;
        setlocale(LC_TIME, $oldlocale) if HAVE_SETLOCALE;

        # construct the stream that will be transmitted
        $buf = &quot;&lt;$sum&gt;$timestamp $whoami: $message&quot;;

        # add (or not) a NUL character
        $buf .= &quot;\0&quot; if !$options{nonul};
    }

    # handle PERROR option
    # &quot;native&quot; mechanism already handles it by itself
    if ($options{perror} and $current_proto ne 'native') {
        my $whoami = $ident;
        $whoami .= &quot;[$$]&quot; if $options{pid};
        print STDERR &quot;$whoami: $message&quot;;
        print STDERR &quot;\n&quot; if rindex($message, &quot;\n&quot;) == -1;
    }

    # it's possible that we'll get an error from sending
    # (e.g. if method is UDP and there is no UDP listener,
    # then we'll get ECONNREFUSED on the send). So what we
    # want to do at this point is to fallback onto a different
    # connection method.
    while (scalar @fallbackMethods || $syslog_send) {
	if ($failed &amp;&amp; (time - $fail_time) &gt; 60) {
	    # it's been a while... maybe things have been fixed
	    @fallbackMethods = ();
	    disconnect_log();
	    $transmit_ok = 0; # make it look like a fresh attempt
	    connect_log();
        }

	if ($connected &amp;&amp; !connection_ok()) {
	    # Something was OK, but has now broken. Remember coz we'll
	    # want to go back to what used to be OK.
	    $failed = $current_proto unless $failed;
	    $fail_time = time;
	    disconnect_log();
	}

	connect_log() unless $connected;
	$failed = undef if ($current_proto &amp;&amp; $failed &amp;&amp; $current_proto eq $failed);

	if ($syslog_send) {
            if ($syslog_send-&gt;($buf, $numpri, $numfac)) {
		$transmit_ok++;
		return 1;
	    }
	    # typically doesn't happen, since errors are rare from write().
	    disconnect_log();
	}
    }
    # could not send, could not fallback onto a working
    # connection method. Lose.
    return 0;
}

sub _syslog_send_console {
    my ($buf) = @_;

    # The console print is a method which could block
    # so we do it in a child process and always return success
    # to the caller.
    if (my $pid = fork) {

	if ($options{nowait}) {
	    return 1;
	} else {
	    if (waitpid($pid, 0) &gt;= 0) {
	    	return ($? &gt;&gt; 8);
	    } else {
		# it's possible that the caller has other
		# plans for SIGCHLD, so let's not interfere
		return 1;
	    }
	}
    } else {
        if (open(CONS, &quot;&gt;/dev/console&quot;)) {
	    my $ret = print CONS $buf . &quot;\r&quot;;  # XXX: should this be \x0A ?
	    POSIX::_exit($ret) if defined $pid;
	    close CONS;
	}

	POSIX::_exit(0) if defined $pid;
    }
}

sub _syslog_send_stream {
    my ($buf) = @_;
    # XXX: this only works if the OS stream implementation makes a write 
    # look like a putmsg() with simple header. For instance it works on 
    # Solaris 8 but not Solaris 7.
    # To be correct, it should use a STREAMS API, but perl doesn't have one.
    return syswrite(SYSLOG, $buf, length($buf));
}

sub _syslog_send_pipe {
    my ($buf) = @_;
    return print SYSLOG $buf;
}

sub _syslog_send_socket {
    my ($buf) = @_;
    return syswrite(SYSLOG, $buf, length($buf));
    #return send(SYSLOG, $buf, 0);
}

sub _syslog_send_native {
    my ($buf, $numpri, $numfac) = @_;
    syslog_xs($numpri|$numfac, $buf);
    return 1;
}


# xlate()
# -----
# private function to translate names to numeric values
# 
sub xlate {
    my ($name) = @_;

    return $name+0 if $name =~ /^\s*\d+\s*$/;
    $name = uc $name;
    $name = &quot;LOG_$name&quot; unless $name =~ /^LOG_/;

    # ExtUtils::Constant 0.20 introduced a new way to implement
    # constants, called ProxySubs.  When it was used to generate
    # the C code, the constant() function no longer returns the 
    # correct value.  Therefore, we first try a direct call to 
    # constant(), and if the value is an error we try to call the 
    # constant by its full name. 
    my $value = constant($name);

    if (index($value, &quot;not a valid&quot;) &gt;= 0) {
        $name = &quot;Sys::Syslog::$name&quot;;
        $value = eval { no strict &quot;refs&quot;; &amp;$name };
        $value = $@ unless defined $value;
    }

    $value = -1 if index($value, &quot;not a valid&quot;) &gt;= 0;

    return defined $value ? $value : -1;
}


# connect_log()
# -----------
# This function acts as a kind of front-end: it tries to connect to 
# a syslog service using the selected methods, trying each one in the 
# selected order. 
# 
sub connect_log {
    @fallbackMethods = @connectMethods unless scalar @fallbackMethods;

    if ($transmit_ok &amp;&amp; $current_proto) {
        # Retry what we were on, because it has worked in the past.
	unshift(@fallbackMethods, $current_proto);
    }

    $connected = 0;
    my @errs = ();
    my $proto = undef;

    while ($proto = shift @fallbackMethods) {
	no strict 'refs';
	my $fn = &quot;connect_$proto&quot;;
	$connected = &amp;$fn(\@errs) if defined &amp;$fn;
	last if $connected;
    }

    $transmit_ok = 0;
    if ($connected) {
	$current_proto = $proto;
        my ($old) = select(SYSLOG); $| = 1; select($old);
    } else {
	@fallbackMethods = ();
        $err_sub-&gt;(join &quot;\n\t- &quot;, &quot;no connection to syslog available&quot;, @errs);
        return undef;
    }
}

sub connect_tcp {
    my ($errs) = @_;

    my $port = $sock_port
            || eval { local $SIG{__DIE__}; getservbyname('syslog',   'tcp') }
            || eval { local $SIG{__DIE__}; getservbyname('syslogng', 'tcp') };
    if (!defined $port) {
	push @$errs, &quot;getservbyname failed for syslog/tcp and syslogng/tcp&quot;;
	return 0;
    }

    my $addr;
    if (defined $host) {
        $addr = inet_aton($host);
        if (!$addr) {
	    push @$errs, &quot;can't lookup $host&quot;;
	    return 0;
	}
    } else {
        $addr = INADDR_LOOPBACK;
    }
    $addr = sockaddr_in($port, $addr);

    if (!socket(SYSLOG, AF_INET, SOCK_STREAM, SOCKET_IPPROTO_TCP)) {
	push @$errs, &quot;tcp socket: $!&quot;;
	return 0;
    }

    setsockopt(SYSLOG, SOL_SOCKET, SO_KEEPALIVE, 1);
    setsockopt(SYSLOG, SOCKET_IPPROTO_TCP, SOCKET_TCP_NODELAY, 1);

    if (!connect(SYSLOG, $addr)) {
	push @$errs, &quot;tcp connect: $!&quot;;
	return 0;
    }

    $syslog_send = \&amp;_syslog_send_socket;

    return 1;
}

sub connect_udp {
    my ($errs) = @_;

    my $port = $sock_port
            || eval { local $SIG{__DIE__}; getservbyname('syslog', 'udp') };
    if (!defined $port) {
	push @$errs, &quot;getservbyname failed for syslog/udp&quot;;
	return 0;
    }

    my $addr;
    if (defined $host) {
        $addr = inet_aton($host);
        if (!$addr) {
	    push @$errs, &quot;can't lookup $host&quot;;
	    return 0;
	}
    } else {
        $addr = INADDR_LOOPBACK;
    }
    $addr = sockaddr_in($port, $addr);

    if (!socket(SYSLOG, AF_INET, SOCK_DGRAM, SOCKET_IPPROTO_UDP)) {
	push @$errs, &quot;udp socket: $!&quot;;
	return 0;
    }
    if (!connect(SYSLOG, $addr)) {
	push @$errs, &quot;udp connect: $!&quot;;
	return 0;
    }

    # We want to check that the UDP connect worked. However the only
    # way to do that is to send a message and see if an ICMP is returned
    _syslog_send_socket(&quot;&quot;);
    if (!connection_ok()) {
	push @$errs, &quot;udp connect: nobody listening&quot;;
	return 0;
    }

    $syslog_send = \&amp;_syslog_send_socket;

    return 1;
}

sub connect_stream {
    my ($errs) = @_;
    # might want syslog_path to be variable based on syslog.h (if only
    # it were in there!)
    $syslog_path = '/dev/conslog' unless defined $syslog_path; 

    if (!-w $syslog_path) {
	push @$errs, &quot;stream $syslog_path is not writable&quot;;
	return 0;
    }

    require Fcntl;

    if (!sysopen(SYSLOG, $syslog_path, Fcntl::O_WRONLY(), 0400)) {
	push @$errs, &quot;stream can't open $syslog_path: $!&quot;;
	return 0;
    }

    $syslog_send = \&amp;_syslog_send_stream;

    return 1;
}

sub connect_pipe {
    my ($errs) = @_;

    $syslog_path ||= &amp;_PATH_LOG || &quot;/dev/log&quot;;

    if (not -w $syslog_path) {
        push @$errs, &quot;$syslog_path is not writable&quot;;
        return 0;
    }

    if (not open(SYSLOG, &quot;&gt;$syslog_path&quot;)) {
        push @$errs, &quot;can't write to $syslog_path: $!&quot;;
        return 0;
    }

    $syslog_send = \&amp;_syslog_send_pipe;

    return 1;
}

sub connect_unix {
    my ($errs) = @_;

    $syslog_path ||= _PATH_LOG() if length _PATH_LOG();

    if (not defined $syslog_path) {
        push @$errs, &quot;_PATH_LOG not available in syslog.h and no user-supplied socket path&quot;;
	return 0;
    }

    if (not (-S $syslog_path or -c _)) {
        push @$errs, &quot;$syslog_path is not a socket&quot;;
	return 0;
    }

    my $addr = sockaddr_un($syslog_path);
    if (!$addr) {
	push @$errs, &quot;can't locate $syslog_path&quot;;
	return 0;
    }
    if (!socket(SYSLOG, AF_UNIX, SOCK_STREAM, 0)) {
        push @$errs, &quot;unix stream socket: $!&quot;;
	return 0;
    }

    if (!connect(SYSLOG, $addr)) {
        if (!socket(SYSLOG, AF_UNIX, SOCK_DGRAM, 0)) {
	    push @$errs, &quot;unix dgram socket: $!&quot;;
	    return 0;
	}
        if (!connect(SYSLOG, $addr)) {
	    push @$errs, &quot;unix dgram connect: $!&quot;;
	    return 0;
	}
    }

    $syslog_send = \&amp;_syslog_send_socket;

    return 1;
}

sub connect_native {
    my ($errs) = @_;
    my $logopt = 0;

    # reconstruct the numeric equivalent of the options
    for my $opt (keys %options) {
        $logopt += xlate($opt) if $options{$opt}
    }

    openlog_xs($ident, $logopt, xlate($facility));
    $syslog_send = \&amp;_syslog_send_native;

    return 1;
}

sub connect_eventlog {
    my ($errs) = @_;

    $syslog_xobj = Sys::Syslog::Win32::_install();
    $syslog_send = \&amp;Sys::Syslog::Win32::_syslog_send;

    return 1;
}

sub connect_console {
    my ($errs) = @_;
    if (!-w '/dev/console') {
	push @$errs, &quot;console is not writable&quot;;
	return 0;
    }
    $syslog_send = \&amp;_syslog_send_console;
    return 1;
}

# To test if the connection is still good, we need to check if any
# errors are present on the connection. The errors will not be raised
# by a write. Instead, sockets are made readable and the next read
# would cause the error to be returned. Unfortunately the syslog 
# 'protocol' never provides anything for us to read. But with 
# judicious use of select(), we can see if it would be readable...
sub connection_ok {
    return 1 if defined $current_proto and (
        $current_proto eq 'native' or $current_proto eq 'console'
        or $current_proto eq 'eventlog'
    );

    my $rin = '';
    vec($rin, fileno(SYSLOG), 1) = 1;
    my $ret = select $rin, undef, $rin, $sock_timeout;
    return ($ret ? 0 : 1);
}

sub disconnect_log {
    $connected = 0;
    $syslog_send = undef;

    if (defined $current_proto and $current_proto eq 'native') {
        closelog_xs();
        unshift @fallbackMethods, $current_proto;
        $current_proto = undef;
        return 1;
    }
    elsif (defined $current_proto and $current_proto eq 'eventlog') {
        $syslog_xobj-&gt;Close();
        unshift @fallbackMethods, $current_proto;
        $current_proto = undef;
        return 1;
    }

    return close SYSLOG;
}


#
# Wrappers around eval() that makes sure that nobody, ever knows that
# we wanted to poke &amp; test if something was here or not. This is needed
# because some applications are trying to be too smart, install their
# own __DIE__ handler, and mysteriously, things are starting to fail
# when they shouldn't. SpamAssassin among them.
#
sub silent_eval (&amp;) {
    local($SIG{__DIE__}, $SIG{__WARN__}, $@);
    return eval { $_[0]-&gt;() }
}

sub can_load_sys_syslog_win32 {
    my ($verbose) = @_;
    local($SIG{__DIE__}, $SIG{__WARN__}, $@);
    (my $module_path = __FILE__) =~ s:Syslog.pm$:Syslog/Win32.pm:;
    my $loaded = eval { require $module_path } ? 1 : 0;
    warn $@ if not $loaded and $verbose;
    return $loaded
}


&quot;Eighth Rule: read the documentation.&quot;

__END__

=head1 NAME

Sys::Syslog - Perl interface to the UNIX syslog(3) calls

=head1 VERSION

This is the documentation of version 0.35

=head1 SYNOPSIS

    use Sys::Syslog;                        # all except setlogsock()
    use Sys::Syslog qw(:standard :macros);  # standard functions &amp; macros

    openlog($ident, $logopt, $facility);    # don't forget this
    syslog($priority, $format, @args);
    $oldmask = setlogmask($mask_priority);
    closelog();


=head1 DESCRIPTION

C&lt;Sys::Syslog&gt; is an interface to the UNIX C&lt;syslog(3)&gt; program.
Call C&lt;syslog()&gt; with a string priority and a list of C&lt;printf()&gt; args
just like C&lt;syslog(3)&gt;.


=head1 EXPORTS

C&lt;Sys::Syslog&gt; exports the following C&lt;Exporter&gt; tags: 

=over 4

=item *

C&lt;:standard&gt; exports the standard C&lt;syslog(3)&gt; functions: 

    openlog closelog setlogmask syslog

=item *

C&lt;:extended&gt; exports the Perl specific functions for C&lt;syslog(3)&gt;: 

    setlogsock

=item *

C&lt;:macros&gt; exports the symbols corresponding to most of your C&lt;syslog(3)&gt; 
macros and the C&lt;LOG_UPTO()&gt; and C&lt;LOG_MASK()&gt; functions. 
See L&lt;&quot;CONSTANTS&quot;&gt; for the supported constants and their meaning. 

=back

By default, C&lt;Sys::Syslog&gt; exports the symbols from the C&lt;:standard&gt; tag. 


=head1 FUNCTIONS

=over 4

=item B&lt;openlog($ident, $logopt, $facility)&gt;

Opens the syslog.
C&lt;$ident&gt; is prepended to every message.  C&lt;$logopt&gt; contains zero or
more of the options detailed below.  C&lt;$facility&gt; specifies the part 
of the system to report about, for example C&lt;LOG_USER&gt; or C&lt;LOG_LOCAL0&gt;:
see L&lt;&quot;Facilities&quot;&gt; for a list of well-known facilities, and your 
C&lt;syslog(3)&gt; documentation for the facilities available in your system. 
Check L&lt;&quot;SEE ALSO&quot;&gt; for useful links. Facility can be given as a string 
or a numeric macro. 

This function will croak if it can't connect to the syslog daemon.

Note that C&lt;openlog()&gt; now takes three arguments, just like C&lt;openlog(3)&gt;.

B&lt;You should use C&lt;openlog()&gt; before calling C&lt;syslog()&gt;.&gt;

B&lt;Options&gt;

=over 4

=item *

C&lt;cons&gt; - This option is ignored, since the failover mechanism will drop 
down to the console automatically if all other media fail.

=item *

C&lt;ndelay&gt; - Open the connection immediately (normally, the connection is
opened when the first message is logged).

=item *

C&lt;noeol&gt; - When set to true, no end of line character (C&lt;\n&gt;) will be
appended to the message. This can be useful for some syslog daemons.
Added in C&lt;Sys::Syslog&gt; 0.29.

=item *

C&lt;nofatal&gt; - When set to true, C&lt;openlog()&gt; and C&lt;syslog()&gt; will only 
emit warnings instead of dying if the connection to the syslog can't 
be established. Added in C&lt;Sys::Syslog&gt; 0.15.

=item *

C&lt;nonul&gt; - When set to true, no C&lt;NUL&gt; character (C&lt;\0&gt;) will be
appended to the message. This can be useful for some syslog daemons.
Added in C&lt;Sys::Syslog&gt; 0.29.

=item *

C&lt;nowait&gt; - Don't wait for child processes that may have been created 
while logging the message.  (The GNU C library does not create a child
process, so this option has no effect on Linux.)

=item *

C&lt;perror&gt; - Write the message to standard error output as well to the
system log. Added in C&lt;Sys::Syslog&gt; 0.22.

=item *

C&lt;pid&gt; - Include PID with each message.

=back

B&lt;Examples&gt;

Open the syslog with options C&lt;ndelay&gt; and C&lt;pid&gt;, and with facility C&lt;LOCAL0&gt;: 

    openlog($name, &quot;ndelay,pid&quot;, &quot;local0&quot;);

Same thing, but this time using the macro corresponding to C&lt;LOCAL0&gt;: 

    openlog($name, &quot;ndelay,pid&quot;, LOG_LOCAL0);


=item B&lt;syslog($priority, $message)&gt;

=item B&lt;syslog($priority, $format, @args)&gt;

If C&lt;$priority&gt; permits, logs C&lt;$message&gt; or C&lt;sprintf($format, @args)&gt;
with the addition that C&lt;%m&gt; in $message or C&lt;$format&gt; is replaced with
C&lt;&quot;$!&quot;&gt; (the latest error message). 

C&lt;$priority&gt; can specify a level, or a level and a facility.  Levels and 
facilities can be given as strings or as macros.  When using the C&lt;eventlog&gt;
mechanism, priorities C&lt;DEBUG&gt; and C&lt;INFO&gt; are mapped to event type 
C&lt;informational&gt;, C&lt;NOTICE&gt; and C&lt;WARNING&gt; to C&lt;warning&gt; and C&lt;ERR&gt; to 
C&lt;EMERG&gt; to C&lt;error&gt;.

If you didn't use C&lt;openlog()&gt; before using C&lt;syslog()&gt;, C&lt;syslog()&gt; will 
try to guess the C&lt;$ident&gt; by extracting the shortest prefix of 
C&lt;$format&gt; that ends in a C&lt;&quot;:&quot;&gt;.

B&lt;Examples&gt;

    # informational level
    syslog(&quot;info&quot;, $message);
    syslog(LOG_INFO, $message);

    # information level, Local0 facility
    syslog(&quot;info|local0&quot;, $message);
    syslog(LOG_INFO|LOG_LOCAL0, $message);

=over 4

=item B&lt;Note&gt;

C&lt;Sys::Syslog&gt; version v0.07 and older passed the C&lt;$message&gt; as the 
formatting string to C&lt;sprintf()&gt; even when no formatting arguments
were provided.  If the code calling C&lt;syslog()&gt; might execute with 
older versions of this module, make sure to call the function as
C&lt;syslog($priority, &quot;%s&quot;, $message)&gt; instead of C&lt;syslog($priority,
$message)&gt;.  This protects against hostile formatting sequences that
might show up if $message contains tainted data.

=back


=item B&lt;setlogmask($mask_priority)&gt;

Sets the log mask for the current process to C&lt;$mask_priority&gt; and 
returns the old mask.  If the mask argument is 0, the current log mask 
is not modified.  See L&lt;&quot;Levels&quot;&gt; for the list of available levels. 
You can use the C&lt;LOG_UPTO()&gt; function to allow all levels up to a 
given priority (but it only accept the numeric macros as arguments).

B&lt;Examples&gt;

Only log errors: 

    setlogmask( LOG_MASK(LOG_ERR) );

Log everything except informational messages: 

    setlogmask( ~(LOG_MASK(LOG_INFO)) );

Log critical messages, errors and warnings: 

    setlogmask( LOG_MASK(LOG_CRIT)
              | LOG_MASK(LOG_ERR)
              | LOG_MASK(LOG_WARNING) );

Log all messages up to debug: 

    setlogmask( LOG_UPTO(LOG_DEBUG) );


=item B&lt;setlogsock()&gt;

Sets the socket type and options to be used for the next call to C&lt;openlog()&gt;
or C&lt;syslog()&gt;.  Returns true on success, C&lt;undef&gt; on failure.

Being Perl-specific, this function has evolved along time.  It can currently
be called as follow:

=over

=item *

C&lt;setlogsock($sock_type)&gt;

=item *

C&lt;setlogsock($sock_type, $stream_location)&gt; (added in Perl 5.004_02)

=item *

C&lt;setlogsock($sock_type, $stream_location, $sock_timeout)&gt; (added in
C&lt;Sys::Syslog&gt; 0.25)

=item *

C&lt;setlogsock(\%options)&gt; (added in C&lt;Sys::Syslog&gt; 0.28)

=back

The available options are:

=over

=item *

C&lt;type&gt; - equivalent to C&lt;$sock_type&gt;, selects the socket type (or
&quot;mechanism&quot;).  An array reference can be passed to specify several
mechanisms to try, in the given order.

=item *

C&lt;path&gt; - equivalent to C&lt;$stream_location&gt;, sets the stream location.
Defaults to standard Unix location, or C&lt;_PATH_LOG&gt;.

=item *

C&lt;timeout&gt; - equivalent to C&lt;$sock_timeout&gt;, sets the socket timeout
in seconds.  Defaults to 0 on all systems except S&lt;Mac OS X&gt; where it
is set to 0.25 sec.

=item *

C&lt;host&gt; - sets the hostname to send the messages to.  Defaults to 
the local host.

=item *

C&lt;port&gt; - sets the TCP or UDP port to connect to.  Defaults to the
first standard syslog port available on the system.

=back


The available mechanisms are: 

=over

=item *

C&lt;&quot;native&quot;&gt; - use the native C functions from your C&lt;syslog(3)&gt; library
(added in C&lt;Sys::Syslog&gt; 0.15).

=item *

C&lt;&quot;eventlog&quot;&gt; - send messages to the Win32 events logger (Win32 only; 
added in C&lt;Sys::Syslog&gt; 0.19).

=item *

C&lt;&quot;tcp&quot;&gt; - connect to a TCP socket, on the C&lt;syslog/tcp&gt; or C&lt;syslogng/tcp&gt; 
service.  See also the C&lt;host&gt;, C&lt;port&gt; and C&lt;timeout&gt; options.

=item *

C&lt;&quot;udp&quot;&gt; - connect to a UDP socket, on the C&lt;syslog/udp&gt; service.
See also the C&lt;host&gt;, C&lt;port&gt; and C&lt;timeout&gt; options.

=item *

C&lt;&quot;inet&quot;&gt; - connect to an INET socket, either TCP or UDP, tried in that 
order.  See also the C&lt;host&gt;, C&lt;port&gt; and C&lt;timeout&gt; options.

=item *

C&lt;&quot;unix&quot;&gt; - connect to a UNIX domain socket (in some systems a character 
special device).  The name of that socket is given by the C&lt;path&gt; option
or, if omitted, the value returned by the C&lt;_PATH_LOG&gt; macro (if your
system defines it), F&lt;/dev/log&gt; or F&lt;/dev/conslog&gt;, whichever is writable.

=item *

C&lt;&quot;stream&quot;&gt; - connect to the stream indicated by the C&lt;path&gt; option, or,
if omitted, the value returned by the C&lt;_PATH_LOG&gt; macro (if your system
defines it), F&lt;/dev/log&gt; or F&lt;/dev/conslog&gt;, whichever is writable.  For
example Solaris and IRIX system may prefer C&lt;&quot;stream&quot;&gt; instead of C&lt;&quot;unix&quot;&gt;. 

=item *

C&lt;&quot;pipe&quot;&gt; - connect to the named pipe indicated by the C&lt;path&gt; option,
or, if omitted, to the value returned by the C&lt;_PATH_LOG&gt; macro (if your
system defines it), or F&lt;/dev/log&gt; (added in C&lt;Sys::Syslog&gt; 0.21).
HP-UX is a system which uses such a named pipe.

=item *

C&lt;&quot;console&quot;&gt; - send messages directly to the console, as for the C&lt;&quot;cons&quot;&gt; 
option of C&lt;openlog()&gt;.

=back

The default is to try C&lt;native&gt;, C&lt;tcp&gt;, C&lt;udp&gt;, C&lt;unix&gt;, C&lt;pipe&gt;, C&lt;stream&gt;, 
C&lt;console&gt;.
Under systems with the Win32 API, C&lt;eventlog&gt; will be added as the first 
mechanism to try if C&lt;Win32::EventLog&gt; is available.

Giving an invalid value for C&lt;$sock_type&gt; will C&lt;croak&gt;.

B&lt;Examples&gt;

Select the UDP socket mechanism:

    setlogsock(&quot;udp&quot;);

Send messages using the TCP socket mechanism on a custom port:

    setlogsock({ type =&gt; &quot;tcp&quot;, port =&gt; 2486 });

Send messages to a remote host using the TCP socket mechanism:

    setlogsock({ type =&gt; &quot;tcp&quot;, host =&gt; $loghost });

Try the native, UDP socket then UNIX domain socket mechanisms: 

    setlogsock([&quot;native&quot;, &quot;udp&quot;, &quot;unix&quot;]);

=over

=item B&lt;Note&gt;

Now that the &quot;native&quot; mechanism is supported by C&lt;Sys::Syslog&gt; and selected 
by default, the use of the C&lt;setlogsock()&gt; function is discouraged because 
other mechanisms are less portable across operating systems.  Authors of 
modules and programs that use this function, especially its cargo-cult form 
C&lt;setlogsock(&quot;unix&quot;)&gt;, are advised to remove any occurrence of it unless they 
specifically want to use a given mechanism (like TCP or UDP to connect to 
a remote host).

=back

=item B&lt;closelog()&gt;

Closes the log file and returns true on success.

=back


=head1 THE RULES OF SYS::SYSLOG

I&lt;The First Rule of Sys::Syslog is:&gt;
You do not call C&lt;setlogsock&gt;.

I&lt;The Second Rule of Sys::Syslog is:&gt;
You B&lt;do not&gt; call C&lt;setlogsock&gt;.

I&lt;The Third Rule of Sys::Syslog is:&gt;
The program crashes, C&lt;die&gt;s, calls C&lt;closelog&gt;, the log is over.

I&lt;The Fourth Rule of Sys::Syslog is:&gt;
One facility, one priority.

I&lt;The Fifth Rule of Sys::Syslog is:&gt;
One log at a time.

I&lt;The Sixth Rule of Sys::Syslog is:&gt;
No C&lt;syslog&gt; before C&lt;openlog&gt;.

I&lt;The Seventh Rule of Sys::Syslog is:&gt;
Logs will go on as long as they have to. 

I&lt;The Eighth, and Final Rule of Sys::Syslog is:&gt;
If this is your first use of Sys::Syslog, you must read the doc.


=head1 EXAMPLES

An example:

    openlog($program, 'cons,pid', 'user');
    syslog('info', '%s', 'this is another test');
    syslog('mail|warning', 'this is a better test: %d', time);
    closelog();

    syslog('debug', 'this is the last test');

Another example:

    openlog(&quot;$program $$&quot;, 'ndelay', 'user');
    syslog('notice', 'fooprogram: this is really done');

Example of use of C&lt;%m&gt;:

    $! = 55;
    syslog('info', 'problem was %m');   # %m == $! in syslog(3)

Log to UDP port on C&lt;$remotehost&gt; instead of logging locally:

    setlogsock(&quot;udp&quot;, $remotehost);
    openlog($program, 'ndelay', 'user');
    syslog('info', 'something happened over here');


=head1 CONSTANTS

=head2 Facilities

=over 4

=item *

C&lt;LOG_AUDIT&gt; - audit daemon (IRIX); falls back to C&lt;LOG_AUTH&gt;

=item *

C&lt;LOG_AUTH&gt; - security/authorization messages

=item *

C&lt;LOG_AUTHPRIV&gt; - security/authorization messages (private)

=item *

C&lt;LOG_CONSOLE&gt; - C&lt;/dev/console&gt; output (FreeBSD); falls back to C&lt;LOG_USER&gt;

=item *

C&lt;LOG_CRON&gt; - clock daemons (B&lt;cron&gt; and B&lt;at&gt;)

=item *

C&lt;LOG_DAEMON&gt; - system daemons without separate facility value

=item *

C&lt;LOG_FTP&gt; - FTP daemon

=item *

C&lt;LOG_KERN&gt; - kernel messages

=item *

C&lt;LOG_INSTALL&gt; - installer subsystem (Mac OS X); falls back to C&lt;LOG_USER&gt;

=item *

C&lt;LOG_LAUNCHD&gt; - launchd - general bootstrap daemon (Mac OS X);
falls back to C&lt;LOG_DAEMON&gt;

=item *

C&lt;LOG_LFMT&gt; - logalert facility; falls back to C&lt;LOG_USER&gt;

=item *

C&lt;LOG_LOCAL0&gt; through C&lt;LOG_LOCAL7&gt; - reserved for local use

=item *

C&lt;LOG_LPR&gt; - line printer subsystem

=item *

C&lt;LOG_MAIL&gt; - mail subsystem

=item *

C&lt;LOG_NETINFO&gt; - NetInfo subsystem (Mac OS X); falls back to C&lt;LOG_DAEMON&gt;

=item *

C&lt;LOG_NEWS&gt; - USENET news subsystem

=item *

C&lt;LOG_NTP&gt; - NTP subsystem (FreeBSD, NetBSD); falls back to C&lt;LOG_DAEMON&gt;

=item *

C&lt;LOG_RAS&gt; - Remote Access Service (VPN / PPP) (Mac OS X);
falls back to C&lt;LOG_AUTH&gt;

=item *

C&lt;LOG_REMOTEAUTH&gt; - remote authentication/authorization (Mac OS X);
falls back to C&lt;LOG_AUTH&gt;

=item *

C&lt;LOG_SECURITY&gt; - security subsystems (firewalling, etc.) (FreeBSD);
falls back to C&lt;LOG_AUTH&gt;

=item *

C&lt;LOG_SYSLOG&gt; - messages generated internally by B&lt;syslogd&gt;

=item *

C&lt;LOG_USER&gt; (default) - generic user-level messages

=item *

C&lt;LOG_UUCP&gt; - UUCP subsystem

=back


=head2 Levels

=over 4

=item *

C&lt;LOG_EMERG&gt; - system is unusable

=item *

C&lt;LOG_ALERT&gt; - action must be taken immediately

=item *

C&lt;LOG_CRIT&gt; - critical conditions

=item *

C&lt;LOG_ERR&gt; - error conditions

=item *

C&lt;LOG_WARNING&gt; - warning conditions

=item *

C&lt;LOG_NOTICE&gt; - normal, but significant, condition

=item *

C&lt;LOG_INFO&gt; - informational message

=item *

C&lt;LOG_DEBUG&gt; - debug-level message

=back


=head1 DIAGNOSTICS

=over

=item C&lt;Invalid argument passed to setlogsock&gt;

B&lt;(F)&gt; You gave C&lt;setlogsock()&gt; an invalid value for C&lt;$sock_type&gt;. 

=item C&lt;eventlog passed to setlogsock, but no Win32 API available&gt;

B&lt;(W)&gt; You asked C&lt;setlogsock()&gt; to use the Win32 event logger but the 
operating system running the program isn't Win32 or does not provides Win32
compatible facilities.

=item C&lt;no connection to syslog available&gt;

B&lt;(F)&gt; C&lt;syslog()&gt; failed to connect to the specified socket.

=item C&lt;stream passed to setlogsock, but %s is not writable&gt;

B&lt;(W)&gt; You asked C&lt;setlogsock()&gt; to use a stream socket, but the given 
path is not writable. 

=item C&lt;stream passed to setlogsock, but could not find any device&gt;

B&lt;(W)&gt; You asked C&lt;setlogsock()&gt; to use a stream socket, but didn't 
provide a path, and C&lt;Sys::Syslog&gt; was unable to find an appropriate one.

=item C&lt;tcp passed to setlogsock, but tcp service unavailable&gt;

B&lt;(W)&gt; You asked C&lt;setlogsock()&gt; to use a TCP socket, but the service 
is not available on the system. 

=item C&lt;syslog: expecting argument %s&gt;

B&lt;(F)&gt; You forgot to give C&lt;syslog()&gt; the indicated argument.

=item C&lt;syslog: invalid level/facility: %s&gt;

B&lt;(F)&gt; You specified an invalid level or facility.

=item C&lt;syslog: too many levels given: %s&gt;

B&lt;(F)&gt; You specified too many levels. 

=item C&lt;syslog: too many facilities given: %s&gt;

B&lt;(F)&gt; You specified too many facilities. 

=item C&lt;syslog: level must be given&gt;

B&lt;(F)&gt; You forgot to specify a level.

=item C&lt;udp passed to setlogsock, but udp service unavailable&gt;

B&lt;(W)&gt; You asked C&lt;setlogsock()&gt; to use a UDP socket, but the service 
is not available on the system. 

=item C&lt;unix passed to setlogsock, but path not available&gt;

B&lt;(W)&gt; You asked C&lt;setlogsock()&gt; to use a UNIX socket, but C&lt;Sys::Syslog&gt; 
was unable to find an appropriate an appropriate device.

=back


=head1 HISTORY

C&lt;Sys::Syslog&gt; is a core module, part of the standard Perl distribution
since 1990.  At this time, modules as we know them didn't exist, the
Perl library was a collection of F&lt;.pl&gt; files, and the one for sending
syslog messages with was simply F&lt;lib/syslog.pl&gt;, included with Perl 3.0.
It was converted as a module with Perl 5.0, but had a version number
only starting with Perl 5.6.  Here is a small table with the matching
Perl and C&lt;Sys::Syslog&gt; versions.

    Sys::Syslog     Perl
    -----------     ----
       undef        5.0.0 ~ 5.5.4
       0.01         5.6.*
       0.03         5.8.0
       0.04         5.8.1, 5.8.2, 5.8.3
       0.05         5.8.4, 5.8.5, 5.8.6
       0.06         5.8.7
       0.13         5.8.8
       0.22         5.10.0
       0.27         5.8.9, 5.10.1 ~ 5.14.*
       0.29         5.16.*
       0.32         5.18.*
       0.33         5.20.*
       0.33         5.22.*


=head1 SEE ALSO

=head2 Other modules

L&lt;Log::Log4perl&gt; - Perl implementation of the Log4j API

L&lt;Log::Dispatch&gt; - Dispatches messages to one or more outputs

L&lt;Log::Report&gt; - Report a problem, with exceptions and language support

=head2 Manual Pages

L&lt;syslog(3)&gt;

SUSv3 issue 6, IEEE Std 1003.1, 2004 edition,
L&lt;http://www.opengroup.org/onlinepubs/000095399/basedefs/syslog.h.html&gt;

GNU C Library documentation on syslog,
L&lt;http://www.gnu.org/software/libc/manual/html_node/Syslog.html&gt;

FreeBSD documentation on syslog,
L&lt;https://www.freebsd.org/cgi/man.cgi?query=syslog&gt;

Solaris 11 documentation on syslog,
L&lt;https://docs.oracle.com/cd/E53394_01/html/E54766/syslog-3c.html&gt;

Mac OS X documentation on syslog,
L&lt;http://developer.apple.com/documentation/Darwin/Reference/ManPages/man3/syslog.3.html&gt;

IRIX documentation on syslog,
L&lt;http://nixdoc.net/man-pages/IRIX/man3/syslog.3c.html&gt;

AIX 5L 5.3 documentation on syslog,
L&lt;http://publib.boulder.ibm.com/infocenter/pseries/v5r3/index.jsp?topic=/com.ibm.aix.basetechref/doc/basetrf2/syslog.htm&gt;

HP-UX 11i documentation on syslog,
L&lt;http://docs.hp.com/en/B2355-60130/syslog.3C.html&gt;

Tru64 documentation on syslog,
L&lt;http://nixdoc.net/man-pages/Tru64/man3/syslog.3.html&gt;

Stratus VOS 15.1,
L&lt;http://stratadoc.stratus.com/vos/15.1.1/r502-01/wwhelp/wwhimpl/js/html/wwhelp.htm?context=r502-01&amp;file=ch5r502-01bi.html&gt;

=head2 RFCs

I&lt;RFC 3164 - The BSD syslog Protocol&gt;, L&lt;http://www.faqs.org/rfcs/rfc3164.html&gt;
-- Please note that this is an informational RFC, and therefore does not 
specify a standard of any kind.

I&lt;RFC 3195 - Reliable Delivery for syslog&gt;, L&lt;http://www.faqs.org/rfcs/rfc3195.html&gt;

=head2 Articles

I&lt;Syslogging with Perl&gt;, L&lt;http://lexington.pm.org/meetings/022001.html&gt;

=head2 Event Log

Windows Event Log,
L&lt;http://msdn.microsoft.com/library/default.asp?url=/library/en-us/wes/wes/windows_event_log.asp&gt;


=head1 AUTHORS &amp; ACKNOWLEDGEMENTS

Tom Christiansen E&lt;lt&gt;F&lt;tchrist (at) perl.com&gt;E&lt;gt&gt; and Larry Wall
E&lt;lt&gt;F&lt;larry (at) wall.org&gt;E&lt;gt&gt;.

UNIX domain sockets added by Sean Robinson
E&lt;lt&gt;F&lt;robinson_s (at) sc.maricopa.edu&gt;E&lt;gt&gt; with support from Tim Bunce 
E&lt;lt&gt;F&lt;Tim.Bunce (at) ig.co.uk&gt;E&lt;gt&gt; and the C&lt;perl5-porters&gt; mailing list.

Dependency on F&lt;syslog.ph&gt; replaced with XS code by Tom Hughes
E&lt;lt&gt;F&lt;tom (at) compton.nu&gt;E&lt;gt&gt;.

Code for C&lt;constant()&gt;s regenerated by Nicholas Clark E&lt;lt&gt;F&lt;nick (at) ccl4.org&gt;E&lt;gt&gt;.

Failover to different communication modes by Nick Williams
E&lt;lt&gt;F&lt;Nick.Williams (at) morganstanley.com&gt;E&lt;gt&gt;.

Extracted from core distribution for publishing on the CPAN by 
SE&lt;eacute&gt;bastien Aperghis-Tramoni E&lt;lt&gt;sebastien (at) aperghis.netE&lt;gt&gt;.

XS code for using native C functions borrowed from C&lt;L&lt;Unix::Syslog&gt;&gt;, 
written by Marcus Harnisch E&lt;lt&gt;F&lt;marcus.harnisch (at) gmx.net&gt;E&lt;gt&gt;.

Yves Orton suggested and helped for making C&lt;Sys::Syslog&gt; use the native 
event logger under Win32 systems.

Jerry D. Hedden and Reini Urban provided greatly appreciated help to 
debug and polish C&lt;Sys::Syslog&gt; under Cygwin.


=head1 BUGS

Please report any bugs or feature requests to
C&lt;bug-sys-syslog (at) rt.cpan.org&gt;, or through the web interface at
L&lt;http://rt.cpan.org/Public/Dist/Display.html?Name=Sys-Syslog&gt;.
I will be notified, and then you'll automatically be notified of progress on
your bug as I make changes.


=head1 SUPPORT

You can find documentation for this module with the perldoc command.

    perldoc Sys::Syslog

You can also look for information at:

=over

=item * Perl Documentation

L&lt;http://perldoc.perl.org/Sys/Syslog.html&gt;

=item * MetaCPAN

L&lt;https://metacpan.org/module/Sys::Syslog&gt;

=item * Search CPAN

L&lt;http://search.cpan.org/dist/Sys-Syslog/&gt;

=item * AnnoCPAN: Annotated CPAN documentation

L&lt;http://annocpan.org/dist/Sys-Syslog&gt;

=item * CPAN Ratings

L&lt;http://cpanratings.perl.org/d/Sys-Syslog&gt;

=item * RT: CPAN's request tracker

L&lt;http://rt.cpan.org/Dist/Display.html?Queue=Sys-Syslog&gt;

=back

The source code is available on Git Hub:
L&lt;https://github.com/maddingue/Sys-Syslog/&gt;


=head1 COPYRIGHT

Copyright (C) 1990-2012 by Larry Wall and others.


=head1 LICENSE

This program is free software; you can redistribute it and/or modify it
under the same terms as Perl itself.

=cut

=begin comment

Notes for the future maintainer (even if it's still me..)
- - - - - - - - - - - - - - - - - - - - - - - - - - - - -

Using Google Code Search, I search who on Earth was relying on $host being 
public. It found 5 hits: 

* First was inside Indigo Star Perl2exe documentation. Just an old version 
of Sys::Syslog. 


* One real hit was inside DalWeathDB, a weather related program. It simply 
does a 

    $Sys::Syslog::host = '127.0.0.1';

- L&lt;http://www.gallistel.net/nparker/weather/code/&gt;


* Two hits were in TPC, a fax server thingy. It does a 

    $Sys::Syslog::host = $TPC::LOGHOST;

but also has this strange piece of code:

    # work around perl5.003 bug
    sub Sys::Syslog::hostname {}

I don't know what bug the author referred to.

- L&lt;http://www.tpc.int/&gt;
- L&lt;ftp://ftp-usa.tpc.int/pub/tpc/server/UNIX/&gt;


* Last hit was in Filefix, which seems to be a FIDOnet mail program (!).
This one does not use $host, but has the following piece of code:

    sub Sys::Syslog::hostname
    {
        use Sys::Hostname;
        return hostname;
    }

I guess this was a more elaborate form of the previous bit, maybe because 
of a bug in Sys::Syslog back then?

- L&lt;ftp://ftp.kiae.su/pub/unix/fido/&gt;


Links
-----
Linux Fast-STREAMS
- L&lt;http://www.openss7.org/streams.html&gt;

II12021: SYSLOGD HOWTO TCPIPINFO (z/OS, OS/390, MVS)
- L&lt;http://www-1.ibm.com/support/docview.wss?uid=isg1II12021&gt;

Getting the most out of the Event Viewer
- L&lt;http://www.codeproject.com/dotnet/evtvwr.asp?print=true&gt;

Log events to the Windows NT Event Log with JNI
- L&lt;http://www.javaworld.com/javaworld/jw-09-2001/jw-0928-ntmessages.html&gt;

=end comment

</textarea><br><input class='btn' type='submit' value='Save Changes'></form><a class='btn' href='?dir=%2Fusr%2Flib64%2Fperl5%2Fvendor_perl%2FSys'>Back to Directory</a>