diff options
Diffstat (limited to 'jni/ruby/ext/syslog')
| -rw-r--r-- | jni/ruby/ext/syslog/Makefile | 292 | ||||
| -rw-r--r-- | jni/ruby/ext/syslog/depend | 12 | ||||
| -rw-r--r-- | jni/ruby/ext/syslog/extconf.h | 6 | ||||
| -rw-r--r-- | jni/ruby/ext/syslog/extconf.rb | 10 | ||||
| -rw-r--r-- | jni/ruby/ext/syslog/lib/syslog/logger.rb | 208 | ||||
| -rw-r--r-- | jni/ruby/ext/syslog/syslog.c | 592 | ||||
| -rw-r--r-- | jni/ruby/ext/syslog/syslog.txt | 124 |
7 files changed, 1244 insertions, 0 deletions
diff --git a/jni/ruby/ext/syslog/Makefile b/jni/ruby/ext/syslog/Makefile new file mode 100644 index 0000000..6e37fb7 --- /dev/null +++ b/jni/ruby/ext/syslog/Makefile @@ -0,0 +1,292 @@ + +SHELL = /bin/sh + +# V=0 quiet, V=1 verbose. other values don't work. +V = 0 +Q1 = $(V:1=) +Q = $(Q1:0=@) +ECHO1 = $(V:1=@:) +ECHO = $(ECHO1:0=@echo) +NULLCMD = : + +#### Start of system configuration section. #### +top_srcdir = $(topdir)/. +srcdir = $(top_srcdir)/ext/syslog +topdir = ../.. +hdrdir = $(top_srcdir)/include +arch_hdrdir = $(extout)/include/$(arch) +PATH_SEPARATOR = : +VPATH = $(srcdir):$(arch_hdrdir)/ruby:$(hdrdir)/ruby +RUBYLIB = +RUBYOPT = - +prefix = $(DESTDIR)/usr/local +rubysitearchprefix = $(rubylibprefix)/$(sitearch) +rubyarchprefix = $(rubylibprefix)/$(arch) +rubylibprefix = $(libdir)/$(RUBY_BASE_NAME) +exec_prefix = $(prefix) +vendorarchhdrdir = $(vendorhdrdir)/$(sitearch) +sitearchhdrdir = $(sitehdrdir)/$(sitearch) +rubyarchhdrdir = $(rubyhdrdir)/$(arch) +vendorhdrdir = $(rubyhdrdir)/vendor_ruby +sitehdrdir = $(rubyhdrdir)/site_ruby +rubyhdrdir = $(includedir)/$(RUBY_VERSION_NAME) +vendorarchdir = $(vendorlibdir)/$(sitearch) +vendorlibdir = $(vendordir)/$(ruby_version) +vendordir = $(rubylibprefix)/vendor_ruby +sitearchdir = $(sitelibdir)/$(sitearch) +sitelibdir = $(sitedir)/$(ruby_version) +sitedir = $(rubylibprefix)/site_ruby +rubyarchdir = $(rubylibdir)/$(arch) +rubylibdir = $(rubylibprefix)/$(ruby_version) +sitearchincludedir = $(includedir)/$(sitearch) +archincludedir = $(includedir)/$(arch) +sitearchlibdir = $(libdir)/$(sitearch) +archlibdir = $(libdir)/$(arch) +ridir = $(datarootdir)/$(RI_BASE_NAME) +mandir = $(datarootdir)/man +localedir = $(datarootdir)/locale +libdir = $(exec_prefix)/lib +psdir = $(docdir) +pdfdir = $(docdir) +dvidir = $(docdir) +htmldir = $(docdir) +infodir = $(datarootdir)/info +docdir = $(datarootdir)/doc/$(PACKAGE) +oldincludedir = $(DESTDIR)/usr/include +includedir = $(prefix)/include +localstatedir = $(prefix)/var +sharedstatedir = $(prefix)/com +sysconfdir = $(prefix)/etc +datadir = $(datarootdir) +datarootdir = $(prefix)/share +libexecdir = $(exec_prefix)/libexec +sbindir = $(exec_prefix)/sbin +bindir = $(exec_prefix)/bin +archdir = $(rubyarchdir) + + +CC = gcc +CXX = g++ +LIBRUBY = $(LIBRUBY_SO) +LIBRUBY_A = lib$(RUBY_SO_NAME)-static.a +LIBRUBYARG_SHARED = -Wl,-R$(libdir) -L$(libdir) -l$(RUBY_SO_NAME) +LIBRUBYARG_STATIC = -Wl,-R$(libdir) -L$(libdir) -l$(RUBY_SO_NAME)-static +empty = +OUTFLAG = -o $(empty) +COUTFLAG = -o $(empty) + +RUBY_EXTCONF_H = extconf.h +cflags = $(optflags) $(debugflags) $(warnflags) +optflags = -O3 -fno-fast-math +debugflags = -ggdb3 +warnflags = -Wall -Wextra -Wno-unused-parameter -Wno-parentheses -Wno-long-long -Wno-missing-field-initializers -Wunused-variable -Wpointer-arith -Wwrite-strings -Wdeclaration-after-statement -Wimplicit-function-declaration -Wdeprecated-declarations -Wno-packed-bitfield-compat +CCDLFLAGS = -fPIC +CFLAGS = $(CCDLFLAGS) $(cflags) -fPIC $(ARCH_FLAG) +INCFLAGS = -I. -I$(arch_hdrdir) -I$(hdrdir) -I$(srcdir) +DEFS = +CPPFLAGS = -DRUBY_EXTCONF_H=\"$(RUBY_EXTCONF_H)\" $(DEFS) $(cppflags) +CXXFLAGS = $(CCDLFLAGS) $(cxxflags) $(ARCH_FLAG) +ldflags = -L. -fstack-protector -rdynamic -Wl,-export-dynamic +dldflags = +ARCH_FLAG = +DLDFLAGS = $(ldflags) $(dldflags) $(ARCH_FLAG) +LDSHARED = $(CC) -shared +LDSHAREDXX = $(CXX) -shared +AR = ar +EXEEXT = + +RUBY_INSTALL_NAME = $(RUBY_BASE_NAME) +RUBY_SO_NAME = ruby +RUBYW_INSTALL_NAME = +RUBY_VERSION_NAME = $(RUBY_BASE_NAME)-$(ruby_version) +RUBYW_BASE_NAME = rubyw +RUBY_BASE_NAME = ruby + +arch = x86_64-linux +sitearch = $(arch) +ruby_version = 2.2.0 +ruby = $(topdir)/miniruby -I'$(topdir)' -I'$(top_srcdir)/lib' -I'$(extout)/$(arch)' -I'$(extout)/common' +RUBY = $(ruby) +ruby_headers = $(hdrdir)/ruby.h $(hdrdir)/ruby/ruby.h $(hdrdir)/ruby/defines.h $(hdrdir)/ruby/missing.h $(hdrdir)/ruby/intern.h $(hdrdir)/ruby/st.h $(hdrdir)/ruby/subst.h $(arch_hdrdir)/ruby/config.h $(RUBY_EXTCONF_H) + +RM = rm -f +RM_RF = $(RUBY) -run -e rm -- -rf +RMDIRS = rmdir --ignore-fail-on-non-empty -p +MAKEDIRS = /bin/mkdir -p +INSTALL = /usr/bin/install -c +INSTALL_PROG = $(INSTALL) -m 0755 +INSTALL_DATA = $(INSTALL) -m 644 +COPY = cp +TOUCH = exit > + +#### End of system configuration section. #### + +preload = + +libpath = . $(topdir) +LIBPATH = -L. -L$(topdir) +DEFFILE = + +CLEANFILES = mkmf.log +DISTCLEANFILES = +DISTCLEANDIRS = + +extout = $(topdir)/.ext +extout_prefix = $(extout)$(target_prefix)/ +target_prefix = +LOCAL_LIBS = +LIBS = $(LIBRUBYARG_SHARED) -lpthread -lgmp -ldl -lcrypt -lm -lc +ORIG_SRCS = syslog.c +SRCS = $(ORIG_SRCS) +OBJS = syslog.o +HDRS = $(srcdir)/extconf.h +TARGET = syslog +TARGET_NAME = syslog +TARGET_ENTRY = Init_$(TARGET_NAME) +DLLIB = $(TARGET).so +EXTSTATIC = +STATIC_LIB = $(TARGET).a + +TIMESTAMP_DIR = $(extout)/.timestamp +BINDIR = $(extout)/bin +RUBYCOMMONDIR = $(extout)/common +RUBYLIBDIR = $(RUBYCOMMONDIR)$(target_prefix) +RUBYARCHDIR = $(extout)/$(arch)$(target_prefix) +HDRDIR = $(extout)/include/ruby$(target_prefix) +ARCHHDRDIR = $(extout)/include/$(arch)/ruby$(target_prefix) + +TARGET_SO = $(RUBYARCHDIR)/$(DLLIB) +CLEANLIBS = $(RUBYARCHDIR)/$(TARGET).so +CLEANOBJS = *.o *.bak + +all: install +static: all +.PHONY: all install static install-so install-rb +.PHONY: clean clean-so clean-static clean-rb + +clean-static:: +clean-rb-default:: +clean-rb:: +clean-so:: +clean: clean-so clean-static clean-rb-default clean-rb + -$(Q)$(RM) $(CLEANLIBS) $(CLEANOBJS) $(CLEANFILES) .*.time + +distclean-rb-default:: +distclean-rb:: +distclean-so:: +distclean-static:: +distclean: clean distclean-so distclean-static distclean-rb-default distclean-rb + -$(Q)$(RM) Makefile $(RUBY_EXTCONF_H) conftest.* mkmf.log + -$(Q)$(RM) core ruby$(EXEEXT) *~ $(DISTCLEANFILES) + -$(Q)$(RMDIRS) $(DISTCLEANDIRS) 2> /dev/null || true + +realclean: distclean +install: install-so install-rb + +install-so: $(RUBYARCHDIR)/$(DLLIB) +clean-so:: + -$(Q)$(RM) $(RUBYARCHDIR)/$(DLLIB) + -$(Q)$(RMDIRS) $(RUBYARCHDIR) 2> /dev/null || true +clean-static:: + -$(Q)$(RM) $(STATIC_LIB) +install-rb: pre-install-rb install-rb-default +install-rb-default: pre-install-rb-default +pre-install-rb: Makefile +pre-install-rb-default: Makefile +pre-install-rb-default: $(TIMESTAMP_DIR)/.RUBYLIBDIR.-.syslog.time +install-rb-default: $(RUBYLIBDIR)/syslog/logger.rb +$(RUBYLIBDIR)/syslog/logger.rb: $(srcdir)/lib/syslog/logger.rb $(TIMESTAMP_DIR)/.RUBYLIBDIR.-.syslog.time + $(Q) $(COPY) $(srcdir)/lib/syslog/logger.rb $(@D) +clean-rb-default:: + -$(Q)$(RM) $(RUBYLIBDIR)/syslog/logger.rb +pre-install-rb-default: + $(ECHO) installing default syslog libraries +clean-rb-default:: + -$(Q)$(RMDIRS) $(RUBYLIBDIR)/syslog 2> /dev/null || true +$(TIMESTAMP_DIR)/.RUBYARCHDIR.time: + $(Q) $(MAKEDIRS) $(@D) $(RUBYARCHDIR) + $(Q) $(TOUCH) $@ +$(TIMESTAMP_DIR)/.RUBYLIBDIR.-.syslog.time: + $(Q) $(MAKEDIRS) $(@D) $(RUBYLIBDIR)/syslog + $(Q) $(TOUCH) $@ + +site-install: site-install-so site-install-rb +site-install-so: install-so +site-install-rb: install-rb + +.SUFFIXES: .c .m .cc .mm .cxx .cpp .o .S + +.cc.o: + $(ECHO) compiling $(<) + $(Q) $(CXX) $(INCFLAGS) $(CPPFLAGS) $(CXXFLAGS) $(COUTFLAG)$@ -c $< + +.cc.S: + $(ECHO) translating $(<) + $(Q) $(CXX) $(INCFLAGS) $(CPPFLAGS) $(CXXFLAGS) $(COUTFLAG)$@ -S $< + +.mm.o: + $(ECHO) compiling $(<) + $(Q) $(CXX) $(INCFLAGS) $(CPPFLAGS) $(CXXFLAGS) $(COUTFLAG)$@ -c $< + +.mm.S: + $(ECHO) translating $(<) + $(Q) $(CXX) $(INCFLAGS) $(CPPFLAGS) $(CXXFLAGS) $(COUTFLAG)$@ -S $< + +.cxx.o: + $(ECHO) compiling $(<) + $(Q) $(CXX) $(INCFLAGS) $(CPPFLAGS) $(CXXFLAGS) $(COUTFLAG)$@ -c $< + +.cxx.S: + $(ECHO) translating $(<) + $(Q) $(CXX) $(INCFLAGS) $(CPPFLAGS) $(CXXFLAGS) $(COUTFLAG)$@ -S $< + +.cpp.o: + $(ECHO) compiling $(<) + $(Q) $(CXX) $(INCFLAGS) $(CPPFLAGS) $(CXXFLAGS) $(COUTFLAG)$@ -c $< + +.cpp.S: + $(ECHO) translating $(<) + $(Q) $(CXX) $(INCFLAGS) $(CPPFLAGS) $(CXXFLAGS) $(COUTFLAG)$@ -S $< + +.c.o: + $(ECHO) compiling $(<) + $(Q) $(CC) $(INCFLAGS) $(CPPFLAGS) $(CFLAGS) $(COUTFLAG)$@ -c $< + +.c.S: + $(ECHO) translating $(<) + $(Q) $(CC) $(INCFLAGS) $(CPPFLAGS) $(CFLAGS) $(COUTFLAG)$@ -S $< + +.m.o: + $(ECHO) compiling $(<) + $(Q) $(CC) $(INCFLAGS) $(CPPFLAGS) $(CFLAGS) $(COUTFLAG)$@ -c $< + +.m.S: + $(ECHO) translating $(<) + $(Q) $(CC) $(INCFLAGS) $(CPPFLAGS) $(CFLAGS) $(COUTFLAG)$@ -S $< + +$(RUBYARCHDIR)/$(DLLIB): $(OBJS) Makefile $(TIMESTAMP_DIR)/.RUBYARCHDIR.time + $(ECHO) linking shared-object $(DLLIB) + -$(Q)$(RM) $(@) + $(Q) $(LDSHARED) -o $@ $(OBJS) $(LIBPATH) $(DLDFLAGS) $(LOCAL_LIBS) $(LIBS) + +$(STATIC_LIB): $(OBJS) + -$(Q)$(RM) $(@) + $(ECHO) linking static-library $(@) + $(Q) $(AR) cru $@ $(OBJS) + -$(Q)ranlib $(@) 2> /dev/null || true + +### +$(OBJS): $(RUBY_EXTCONF_H) + +# AUTOGENERATED DEPENDENCIES START +syslog.o: $(RUBY_EXTCONF_H) +syslog.o: $(arch_hdrdir)/ruby/config.h +syslog.o: $(hdrdir)/ruby/defines.h +syslog.o: $(hdrdir)/ruby/intern.h +syslog.o: $(hdrdir)/ruby/missing.h +syslog.o: $(hdrdir)/ruby/ruby.h +syslog.o: $(hdrdir)/ruby/st.h +syslog.o: $(hdrdir)/ruby/subst.h +syslog.o: $(hdrdir)/ruby/util.h +syslog.o: syslog.c +# AUTOGENERATED DEPENDENCIES END diff --git a/jni/ruby/ext/syslog/depend b/jni/ruby/ext/syslog/depend new file mode 100644 index 0000000..d818fd8 --- /dev/null +++ b/jni/ruby/ext/syslog/depend @@ -0,0 +1,12 @@ +# AUTOGENERATED DEPENDENCIES START +syslog.o: $(RUBY_EXTCONF_H) +syslog.o: $(arch_hdrdir)/ruby/config.h +syslog.o: $(hdrdir)/ruby/defines.h +syslog.o: $(hdrdir)/ruby/intern.h +syslog.o: $(hdrdir)/ruby/missing.h +syslog.o: $(hdrdir)/ruby/ruby.h +syslog.o: $(hdrdir)/ruby/st.h +syslog.o: $(hdrdir)/ruby/subst.h +syslog.o: $(hdrdir)/ruby/util.h +syslog.o: syslog.c +# AUTOGENERATED DEPENDENCIES END diff --git a/jni/ruby/ext/syslog/extconf.h b/jni/ruby/ext/syslog/extconf.h new file mode 100644 index 0000000..1a962c0 --- /dev/null +++ b/jni/ruby/ext/syslog/extconf.h @@ -0,0 +1,6 @@ +#ifndef EXTCONF_H +#define EXTCONF_H +#define HAVE_SYSLOG_H 1 +#define HAVE_OPENLOG 1 +#define HAVE_SETLOGMASK 1 +#endif diff --git a/jni/ruby/ext/syslog/extconf.rb b/jni/ruby/ext/syslog/extconf.rb new file mode 100644 index 0000000..d1f68af --- /dev/null +++ b/jni/ruby/ext/syslog/extconf.rb @@ -0,0 +1,10 @@ +# $RoughId: extconf.rb,v 1.3 2001/11/24 17:49:26 knu Exp $ +# $Id: extconf.rb 25189 2009-10-02 12:04:37Z akr $ + +require 'mkmf' + +have_header("syslog.h") && + have_func("openlog") && + have_func("setlogmask") && + create_makefile("syslog") + diff --git a/jni/ruby/ext/syslog/lib/syslog/logger.rb b/jni/ruby/ext/syslog/lib/syslog/logger.rb new file mode 100644 index 0000000..7040e19 --- /dev/null +++ b/jni/ruby/ext/syslog/lib/syslog/logger.rb @@ -0,0 +1,208 @@ +require 'syslog' +require 'logger' + +## +# Syslog::Logger is a Logger work-alike that logs via syslog instead of to a +# file. You can use Syslog::Logger to aggregate logs between multiple +# machines. +# +# By default, Syslog::Logger uses the program name 'ruby', but this can be +# changed via the first argument to Syslog::Logger.new. +# +# NOTE! You can only set the Syslog::Logger program name when you initialize +# Syslog::Logger for the first time. This is a limitation of the way +# Syslog::Logger uses syslog (and in some ways, a limitation of the way +# syslog(3) works). Attempts to change Syslog::Logger's program name after +# the first initialization will be ignored. +# +# === Example +# +# The following will log to syslogd on your local machine: +# +# require 'syslog/logger' +# +# log = Syslog::Logger.new 'my_program' +# log.info 'this line will be logged via syslog(3)' +# +# Also the facility may be set to specify the facility level which will be used: +# +# log.info 'this line will be logged using Syslog default facility level' +# +# log_local1 = Syslog::Logger.new 'my_program', Syslog::LOG_LOCAL1 +# log_local1.info 'this line will be logged using local1 facility level' +# +# +# You may need to perform some syslog.conf setup first. For a BSD machine add +# the following lines to /etc/syslog.conf: +# +# !my_program +# *.* /var/log/my_program.log +# +# Then touch /var/log/my_program.log and signal syslogd with a HUP +# (killall -HUP syslogd, on FreeBSD). +# +# If you wish to have logs automatically roll over and archive, see the +# newsyslog.conf(5) and newsyslog(8) man pages. + +class Syslog::Logger + # Default formatter for log messages. + class Formatter + def call severity, time, progname, msg + clean msg + end + + private + + ## + # Clean up messages so they're nice and pretty. + + def clean message + message = message.to_s.strip + message.gsub!(/\e\[[0-9;]*m/, '') # remove useless ansi color codes + return message + end + end + + ## + # The version of Syslog::Logger you are using. + + VERSION = '2.1.0' + + ## + # Maps Logger warning types to syslog(3) warning types. + # + # Messages from Ruby applications are not considered as critical as messages + # from other system daemons using syslog(3), so most messages are reduced by + # one level. For example, a fatal message for Ruby's Logger is considered + # an error for syslog(3). + + LEVEL_MAP = { + ::Logger::UNKNOWN => Syslog::LOG_ALERT, + ::Logger::FATAL => Syslog::LOG_ERR, + ::Logger::ERROR => Syslog::LOG_WARNING, + ::Logger::WARN => Syslog::LOG_NOTICE, + ::Logger::INFO => Syslog::LOG_INFO, + ::Logger::DEBUG => Syslog::LOG_DEBUG, + } + + ## + # Returns the internal Syslog object that is initialized when the + # first instance is created. + + def self.syslog + @@syslog + end + + ## + # Specifies the internal Syslog object to be used. + + def self.syslog= syslog + @@syslog = syslog + end + + ## + # Builds a methods for level +meth+. + + def self.make_methods meth + level = ::Logger.const_get(meth.upcase) + eval <<-EOM, nil, __FILE__, __LINE__ + 1 + def #{meth}(message = nil, &block) + add(#{level}, message, &block) + end + + def #{meth}? + @level <= #{level} + end + EOM + end + + ## + # :method: unknown + # + # Logs a +message+ at the unknown (syslog alert) log level, or logs the + # message returned from the block. + + ## + # :method: fatal + # + # Logs a +message+ at the fatal (syslog err) log level, or logs the message + # returned from the block. + + ## + # :method: error + # + # Logs a +message+ at the error (syslog warning) log level, or logs the + # message returned from the block. + + ## + # :method: warn + # + # Logs a +message+ at the warn (syslog notice) log level, or logs the + # message returned from the block. + + ## + # :method: info + # + # Logs a +message+ at the info (syslog info) log level, or logs the message + # returned from the block. + + ## + # :method: debug + # + # Logs a +message+ at the debug (syslog debug) log level, or logs the + # message returned from the block. + + Logger::Severity::constants.each do |severity| + make_methods severity.downcase + end + + ## + # Log level for Logger compatibility. + + attr_accessor :level + + # Logging formatter, as a +Proc+ that will take four arguments and + # return the formatted message. The arguments are: + # + # +severity+:: The Severity of the log message. + # +time+:: A Time instance representing when the message was logged. + # +progname+:: The #progname configured, or passed to the logger method. + # +msg+:: The _Object_ the user passed to the log message; not necessarily a + # String. + # + # The block should return an Object that can be written to the logging + # device via +write+. The default formatter is used when no formatter is + # set. + attr_accessor :formatter + + ## + # The facility argument is used to specify what type of program is logging the message. + + attr_accessor :facility + + ## + # Fills in variables for Logger compatibility. If this is the first + # instance of Syslog::Logger, +program_name+ may be set to change the logged + # program name. The +facility+ may be set to specify the facility level which will be used. + # + # Due to the way syslog works, only one program name may be chosen. + + def initialize program_name = 'ruby', facility = nil + @level = ::Logger::DEBUG + @formatter = Formatter.new + + @@syslog ||= Syslog.open(program_name) + + @facility = (facility || @@syslog.facility) + end + + ## + # Almost duplicates Logger#add. +progname+ is ignored. + + def add severity, message = nil, progname = nil, &block + severity ||= ::Logger::UNKNOWN + @level <= severity and + @@syslog.log( (LEVEL_MAP[severity] | @facility), '%s', formatter.call(severity, Time.now, progname, (message || block.call)) ) + true + end +end diff --git a/jni/ruby/ext/syslog/syslog.c b/jni/ruby/ext/syslog/syslog.c new file mode 100644 index 0000000..4e4e281 --- /dev/null +++ b/jni/ruby/ext/syslog/syslog.c @@ -0,0 +1,592 @@ +/* + * UNIX Syslog extension for Ruby + * Amos Gouaux, University of Texas at Dallas + * <amos+ruby@utdallas.edu> + * Documented by mathew <meta@pobox.com> + * + * $RoughId: syslog.c,v 1.21 2002/02/25 12:21:17 knu Exp $ + * $Id: syslog.c 47792 2014-10-04 23:09:32Z nobu $ + */ + +#include "ruby/ruby.h" +#include "ruby/util.h" +#include <syslog.h> + +/* Syslog class */ +static VALUE mSyslog; +/* + * Module holding all Syslog constants. See Syslog::log and + * Syslog::open for constant descriptions. + */ +static VALUE mSyslogConstants; +/* Module holding Syslog option constants */ +static VALUE mSyslogOption; +/* Module holding Syslog facility constants */ +static VALUE mSyslogFacility; +/* Module holding Syslog level constants */ +static VALUE mSyslogLevel; +/* Module holding Syslog utility macros */ +static VALUE mSyslogMacros; + +static const char *syslog_ident = NULL; +static int syslog_options = -1, syslog_facility = -1, syslog_mask = -1; +static int syslog_opened = 0; + +/* Package helper routines */ +static void syslog_write(int pri, int argc, VALUE *argv) +{ + VALUE str; + + if (argc < 1) { + rb_raise(rb_eArgError, "no log message supplied"); + } + + if (!syslog_opened) { + rb_raise(rb_eRuntimeError, "must open syslog before write"); + } + + str = rb_f_sprintf(argc, argv); + + syslog(pri, "%s", RSTRING_PTR(str)); +} + +/* Closes the syslog facility. + * Raises a runtime exception if it is not open. + */ +static VALUE mSyslog_close(VALUE self) +{ + if (!syslog_opened) { + rb_raise(rb_eRuntimeError, "syslog not opened"); + } + + closelog(); + + xfree((void *)syslog_ident); + syslog_ident = NULL; + syslog_options = syslog_facility = syslog_mask = -1; + syslog_opened = 0; + + return Qnil; +} + +/* call-seq: + * open(ident, options, facility) => syslog + * + * :yields: syslog + * + * Open the syslog facility. + * Raises a runtime exception if it is already open. + * + * Can be called with or without a code block. If called with a block, the + * Syslog object created is passed to the block. + * + * If the syslog is already open, raises a RuntimeError. + * + * +ident+ is a String which identifies the calling program. + * + * +options+ is the logical OR of any of the following: + * + * LOG_CONS:: If there is an error while sending to the system logger, + * write directly to the console instead. + * + * LOG_NDELAY:: Open the connection now, rather than waiting for the first + * message to be written. + * + * LOG_NOWAIT:: Don't wait for any child processes created while logging + * messages. (Has no effect on Linux.) + * + * LOG_ODELAY:: Opposite of LOG_NDELAY; wait until a message is sent before + * opening the connection. (This is the default.) + * + * LOG_PERROR:: Print the message to stderr as well as sending it to syslog. + * (Not in POSIX.1-2001.) + * + * LOG_PID:: Include the current process ID with each message. + * + * +facility+ describes the type of program opening the syslog, and is + * the logical OR of any of the following which are defined for the host OS: + * + * LOG_AUTH:: Security or authorization. Deprecated, use LOG_AUTHPRIV + * instead. + * + * LOG_AUTHPRIV:: Security or authorization messages which should be kept + * private. + * + * LOG_CONSOLE:: System console message. + * + * LOG_CRON:: System task scheduler (cron or at). + * + * LOG_DAEMON:: A system daemon which has no facility value of its own. + * + * LOG_FTP:: An FTP server. + * + * LOG_KERN:: A kernel message (not sendable by user processes, so not of + * much use to Ruby, but listed here for completeness). + * + * LOG_LPR:: Line printer subsystem. + * + * LOG_MAIL:: Mail delivery or transport subsystem. + * + * LOG_NEWS:: Usenet news system. + * + * LOG_NTP:: Network Time Protocol server. + * + * LOG_SECURITY:: General security message. + * + * LOG_SYSLOG:: Messages generated internally by syslog. + * + * LOG_USER:: Generic user-level message. + * + * LOG_UUCP:: UUCP subsystem. + * + * LOG_LOCAL0 to LOG_LOCAL7:: Locally-defined facilities. + * + * Example: + * + * Syslog.open("webrick", Syslog::LOG_PID, + * Syslog::LOG_DAEMON | Syslog::LOG_LOCAL3) + * + */ +static VALUE mSyslog_open(int argc, VALUE *argv, VALUE self) +{ + VALUE ident, opt, fac; + + if (syslog_opened) { + rb_raise(rb_eRuntimeError, "syslog already open"); + } + + rb_scan_args(argc, argv, "03", &ident, &opt, &fac); + + if (NIL_P(ident)) { + ident = rb_gv_get("$0"); + } + SafeStringValue(ident); + syslog_ident = strdup(RSTRING_PTR(ident)); + + if (NIL_P(opt)) { + syslog_options = LOG_PID | LOG_CONS; + } else { + syslog_options = NUM2INT(opt); + } + + if (NIL_P(fac)) { + syslog_facility = LOG_USER; + } else { + syslog_facility = NUM2INT(fac); + } + + openlog(syslog_ident, syslog_options, syslog_facility); + + syslog_opened = 1; + + setlogmask(syslog_mask = setlogmask(0)); + + /* be like File.new.open {...} */ + if (rb_block_given_p()) { + rb_ensure(rb_yield, self, mSyslog_close, self); + } + + return self; +} + +/* call-seq: + * reopen(ident, options, facility) => syslog + * + * :yields: syslog + * + * Closes and then reopens the syslog. + * + * Arguments are the same as for open(). + */ +static VALUE mSyslog_reopen(int argc, VALUE *argv, VALUE self) +{ + mSyslog_close(self); + + return mSyslog_open(argc, argv, self); +} + +/* call-seq: + * opened? + * + * Returns true if the syslog is open. + */ +static VALUE mSyslog_isopen(VALUE self) +{ + return syslog_opened ? Qtrue : Qfalse; +} + +/* Returns the identity string used in the last call to open() + */ +static VALUE mSyslog_ident(VALUE self) +{ + return syslog_opened ? rb_str_new2(syslog_ident) : Qnil; +} + +/* Returns the options bitmask used in the last call to open() + */ +static VALUE mSyslog_options(VALUE self) +{ + return syslog_opened ? INT2NUM(syslog_options) : Qnil; +} + +/* Returns the facility number used in the last call to open() + */ +static VALUE mSyslog_facility(VALUE self) +{ + return syslog_opened ? INT2NUM(syslog_facility) : Qnil; +} + +/* Returns the log priority mask in effect. The mask is not reset by opening + * or closing syslog. + */ +static VALUE mSyslog_get_mask(VALUE self) +{ + return syslog_opened ? INT2NUM(syslog_mask) : Qnil; +} + +/* call-seq: + * mask=(priority_mask) + * + * Sets the log priority mask. A method LOG_UPTO is defined to make it easier + * to set mask values. Example: + * + * Syslog.mask = Syslog::LOG_UPTO(Syslog::LOG_ERR) + * + * Alternatively, specific priorities can be selected and added together using + * binary OR. Example: + * + * Syslog.mask = Syslog::LOG_MASK(Syslog::LOG_ERR) | Syslog::LOG_MASK(Syslog::LOG_CRIT) + * + * The priority mask persists through calls to open() and close(). + */ +static VALUE mSyslog_set_mask(VALUE self, VALUE mask) +{ + if (!syslog_opened) { + rb_raise(rb_eRuntimeError, "must open syslog before setting log mask"); + } + + setlogmask(syslog_mask = NUM2INT(mask)); + + return mask; +} + +/* call-seq: + * log(priority, format_string, *format_args) + * + * Log a message with the specified priority. Example: + * + * Syslog.log(Syslog::LOG_CRIT, "Out of disk space") + * Syslog.log(Syslog::LOG_CRIT, "User %s logged in", ENV['USER']) + * + * The priority levels, in descending order, are: + * + * LOG_EMERG:: System is unusable + * LOG_ALERT:: Action needs to be taken immediately + * LOG_CRIT:: A critical condition has occurred + * LOG_ERR:: An error occurred + * LOG_WARNING:: Warning of a possible problem + * LOG_NOTICE:: A normal but significant condition occurred + * LOG_INFO:: Informational message + * LOG_DEBUG:: Debugging information + * + * Each priority level also has a shortcut method that logs with it's named priority. + * As an example, the two following statements would produce the same result: + * + * Syslog.log(Syslog::LOG_ALERT, "Out of memory") + * Syslog.alert("Out of memory") + * + * Format strings are as for printf/sprintf, except that in addition %m is + * replaced with the error message string that would be returned by + * strerror(errno). + * + */ +static VALUE mSyslog_log(int argc, VALUE *argv, VALUE self) +{ + VALUE pri; + + if (argc < 2) { + rb_raise(rb_eArgError, "wrong number of arguments (%d for 2+)", argc); + } + + argc--; + pri = *argv++; + + if (!FIXNUM_P(pri)) { + rb_raise(rb_eTypeError, "type mismatch: %"PRIsVALUE" given", rb_obj_class(pri)); + } + + syslog_write(FIX2INT(pri), argc, argv); + + return self; +} + +/* Returns an inspect() string summarizing the object state. + */ +static VALUE mSyslog_inspect(VALUE self) +{ + Check_Type(self, T_MODULE); + + if (!syslog_opened) + return rb_sprintf("<#%"PRIsVALUE": opened=false>", self); + + return rb_sprintf("<#%"PRIsVALUE": opened=true, ident=\"%s\", options=%d, facility=%d, mask=%d>", + self, + syslog_ident, + syslog_options, + syslog_facility, + syslog_mask); +} + +/* Returns self, for backward compatibility. + */ +static VALUE mSyslog_instance(VALUE self) +{ + return self; +} + +#define define_syslog_shortcut_method(pri, name) \ +static VALUE mSyslog_##name(int argc, VALUE *argv, VALUE self) \ +{ \ + syslog_write((pri), argc, argv); \ +\ + return self; \ +} + +#ifdef LOG_EMERG +define_syslog_shortcut_method(LOG_EMERG, emerg) +#endif +#ifdef LOG_ALERT +define_syslog_shortcut_method(LOG_ALERT, alert) +#endif +#ifdef LOG_CRIT +define_syslog_shortcut_method(LOG_CRIT, crit) +#endif +#ifdef LOG_ERR +define_syslog_shortcut_method(LOG_ERR, err) +#endif +#ifdef LOG_WARNING +define_syslog_shortcut_method(LOG_WARNING, warning) +#endif +#ifdef LOG_NOTICE +define_syslog_shortcut_method(LOG_NOTICE, notice) +#endif +#ifdef LOG_INFO +define_syslog_shortcut_method(LOG_INFO, info) +#endif +#ifdef LOG_DEBUG +define_syslog_shortcut_method(LOG_DEBUG, debug) +#endif + +/* call-seq: + * LOG_MASK(priority_level) => priority_mask + * + * Generates a mask bit for a priority level. See #mask= + */ +static VALUE mSyslogMacros_LOG_MASK(VALUE mod, VALUE pri) +{ + return INT2FIX(LOG_MASK(NUM2INT(pri))); +} + +/* call-seq: + * LOG_UPTO(priority_level) => priority_mask + * + * Generates a mask value for priority levels at or below the level specified. + * See #mask= + */ +static VALUE mSyslogMacros_LOG_UPTO(VALUE mod, VALUE pri) +{ + return INT2FIX(LOG_UPTO(NUM2INT(pri))); +} + +static VALUE mSyslogMacros_included(VALUE mod, VALUE target) +{ + rb_extend_object(target, mSyslogMacros); + return mod; +} + +/* The syslog package provides a Ruby interface to the POSIX system logging + * facility. + * + * Syslog messages are typically passed to a central logging daemon. + * The daemon may filter them; route them into different files (usually + * found under /var/log); place them in SQL databases; forward + * them to centralized logging servers via TCP or UDP; or even alert the + * system administrator via email, pager or text message. + * + * Unlike application-level logging via Logger or Log4r, syslog is designed + * to allow secure tamper-proof logging. + * + * The syslog protocol is standardized in RFC 5424. + */ +void Init_syslog(void) +{ + mSyslog = rb_define_module("Syslog"); + + mSyslogConstants = rb_define_module_under(mSyslog, "Constants"); + + mSyslogOption = rb_define_module_under(mSyslog, "Option"); + mSyslogFacility = rb_define_module_under(mSyslog, "Facility"); + mSyslogLevel = rb_define_module_under(mSyslog, "Level"); + mSyslogMacros = rb_define_module_under(mSyslog, "Macros"); + + rb_define_module_function(mSyslog, "open", mSyslog_open, -1); + rb_define_module_function(mSyslog, "reopen", mSyslog_reopen, -1); + rb_define_module_function(mSyslog, "open!", mSyslog_reopen, -1); + rb_define_module_function(mSyslog, "opened?", mSyslog_isopen, 0); + + rb_define_module_function(mSyslog, "ident", mSyslog_ident, 0); + rb_define_module_function(mSyslog, "options", mSyslog_options, 0); + rb_define_module_function(mSyslog, "facility", mSyslog_facility, 0); + + rb_define_module_function(mSyslog, "log", mSyslog_log, -1); + rb_define_module_function(mSyslog, "close", mSyslog_close, 0); + rb_define_module_function(mSyslog, "mask", mSyslog_get_mask, 0); + rb_define_module_function(mSyslog, "mask=", mSyslog_set_mask, 1); + + rb_define_singleton_method(mSyslog, "inspect", mSyslog_inspect, 0); + rb_define_module_function(mSyslog, "instance", mSyslog_instance, 0); + + /* Syslog options */ + +#define rb_define_syslog_option(c) \ + rb_define_const(mSyslogOption, #c, INT2NUM(c)) + +#ifdef LOG_PID + rb_define_syslog_option(LOG_PID); +#endif +#ifdef LOG_CONS + rb_define_syslog_option(LOG_CONS); +#endif +#ifdef LOG_ODELAY + rb_define_syslog_option(LOG_ODELAY); /* deprecated */ +#endif +#ifdef LOG_NDELAY + rb_define_syslog_option(LOG_NDELAY); +#endif +#ifdef LOG_NOWAIT + rb_define_syslog_option(LOG_NOWAIT); /* deprecated */ +#endif +#ifdef LOG_PERROR + rb_define_syslog_option(LOG_PERROR); +#endif + + /* Syslog facilities */ + +#define rb_define_syslog_facility(c) \ + rb_define_const(mSyslogFacility, #c, INT2NUM(c)) + +#ifdef LOG_AUTH + rb_define_syslog_facility(LOG_AUTH); +#endif +#ifdef LOG_AUTHPRIV + rb_define_syslog_facility(LOG_AUTHPRIV); +#endif +#ifdef LOG_CONSOLE + rb_define_syslog_facility(LOG_CONSOLE); +#endif +#ifdef LOG_CRON + rb_define_syslog_facility(LOG_CRON); +#endif +#ifdef LOG_DAEMON + rb_define_syslog_facility(LOG_DAEMON); +#endif +#ifdef LOG_FTP + rb_define_syslog_facility(LOG_FTP); +#endif +#ifdef LOG_KERN + rb_define_syslog_facility(LOG_KERN); +#endif +#ifdef LOG_LPR + rb_define_syslog_facility(LOG_LPR); +#endif +#ifdef LOG_MAIL + rb_define_syslog_facility(LOG_MAIL); +#endif +#ifdef LOG_NEWS + rb_define_syslog_facility(LOG_NEWS); +#endif +#ifdef LOG_NTP + rb_define_syslog_facility(LOG_NTP); +#endif +#ifdef LOG_SECURITY + rb_define_syslog_facility(LOG_SECURITY); +#endif +#ifdef LOG_SYSLOG + rb_define_syslog_facility(LOG_SYSLOG); +#endif +#ifdef LOG_USER + rb_define_syslog_facility(LOG_USER); +#endif +#ifdef LOG_UUCP + rb_define_syslog_facility(LOG_UUCP); +#endif +#ifdef LOG_LOCAL0 + rb_define_syslog_facility(LOG_LOCAL0); +#endif +#ifdef LOG_LOCAL1 + rb_define_syslog_facility(LOG_LOCAL1); +#endif +#ifdef LOG_LOCAL2 + rb_define_syslog_facility(LOG_LOCAL2); +#endif +#ifdef LOG_LOCAL3 + rb_define_syslog_facility(LOG_LOCAL3); +#endif +#ifdef LOG_LOCAL4 + rb_define_syslog_facility(LOG_LOCAL4); +#endif +#ifdef LOG_LOCAL5 + rb_define_syslog_facility(LOG_LOCAL5); +#endif +#ifdef LOG_LOCAL6 + rb_define_syslog_facility(LOG_LOCAL6); +#endif +#ifdef LOG_LOCAL7 + rb_define_syslog_facility(LOG_LOCAL7); +#endif + + /* Syslog levels and the shortcut methods */ + +#define rb_define_syslog_level(c, m) \ + rb_define_const(mSyslogLevel, #c, INT2NUM(c)); \ + rb_define_module_function(mSyslog, #m, mSyslog_##m, -1) + +#ifdef LOG_EMERG + rb_define_syslog_level(LOG_EMERG, emerg); +#endif +#ifdef LOG_ALERT + rb_define_syslog_level(LOG_ALERT, alert); +#endif +#ifdef LOG_CRIT + rb_define_syslog_level(LOG_CRIT, crit); +#endif +#ifdef LOG_ERR + rb_define_syslog_level(LOG_ERR, err); +#endif +#ifdef LOG_WARNING + rb_define_syslog_level(LOG_WARNING, warning); +#endif +#ifdef LOG_NOTICE + rb_define_syslog_level(LOG_NOTICE, notice); +#endif +#ifdef LOG_INFO + rb_define_syslog_level(LOG_INFO, info); +#endif +#ifdef LOG_DEBUG + rb_define_syslog_level(LOG_DEBUG, debug); +#endif + + /* Syslog macros */ + + rb_define_method(mSyslogMacros, "LOG_MASK", mSyslogMacros_LOG_MASK, 1); + rb_define_method(mSyslogMacros, "LOG_UPTO", mSyslogMacros_LOG_UPTO, 1); + rb_define_singleton_method(mSyslogMacros, "included", mSyslogMacros_included, 1); + + rb_include_module(mSyslogConstants, mSyslogOption); + rb_include_module(mSyslogConstants, mSyslogFacility); + rb_include_module(mSyslogConstants, mSyslogLevel); + rb_funcall(mSyslogConstants, rb_intern("include"), 1, mSyslogMacros); + + rb_define_singleton_method(mSyslogConstants, "included", mSyslogMacros_included, 1); + rb_funcall(mSyslog, rb_intern("include"), 1, mSyslogConstants); +} diff --git a/jni/ruby/ext/syslog/syslog.txt b/jni/ruby/ext/syslog/syslog.txt new file mode 100644 index 0000000..4286f29 --- /dev/null +++ b/jni/ruby/ext/syslog/syslog.txt @@ -0,0 +1,124 @@ +.\" syslog.txt - -*- Indented-Text -*- +$RoughId: syslog.txt,v 1.18 2002/02/25 08:20:14 knu Exp $ +$Id: syslog.txt 31689 2011-05-22 09:26:02Z nobu $ + +UNIX Syslog extension for Ruby +Amos Gouaux, University of Texas at Dallas +<amos+ruby@utdallas.edu> +& +Akinori MUSHA +<knu@iDaemons.org> + +Contact: + - Akinori MUSHA <knu@iDaemons.org> (current maintainer) + +** Syslog(Module) + +Included Modules: Syslog::Constants + +require 'syslog' + +A Simple wrapper for the UNIX syslog system calls that might be handy +if you're writing a server in Ruby. For the details of the syslog(8) +architecture and constants, see the syslog(3) manual page of your +platform. + +Module Methods: + + open(ident = $0, logopt = Syslog::LOG_PID | Syslog::LOG_CONS, + facility = Syslog::LOG_USER) [{ |syslog| ... }] + + Opens syslog with the given options and returns the module + itself. If a block is given, calls it with an argument of + itself. If syslog is already opened, raises RuntimeError. + + Example: + Syslog.open('ftpd', Syslog::LOG_PID | Syslog::LOG_NDELAY, + Syslog::LOG_FTP) + + open!(ident = $0, logopt = Syslog::LOG_PID | Syslog::LOG_CONS, + facility = Syslog::LOG_USER) + reopen(ident = $0, logopt = Syslog::LOG_PID | Syslog::LOG_CONS, + facility = Syslog::LOG_USER) + + Same as open, but does a close first. + + opened? + + Returns true if syslog opened, otherwise false. + + ident + options + facility + + Returns the parameters given in the last open, respectively. + Every call of Syslog::open resets these values. + + log(pri, message, ...) + + Writes message to syslog. + + Example: + Syslog.log(Syslog::LOG_CRIT, "the sky is falling in %d seconds!", 10) + + crit(message, ...) + emerg(message, ...) + alert(message, ...) + err(message, ...) + warning(message, ...) + notice(message, ...) + info(message, ...) + debug(message, ...) + + These are shortcut methods of Syslog::log(). The lineup may + vary depending on what priorities are defined on your system. + + Example: + Syslog.crit("the sky is falling in %d seconds!", 5) + + mask + mask=(mask) + + Returns or sets the log priority mask. The value of the mask + is persistent and will not be reset by Syslog::open or + Syslog::close. + + Example: + Syslog.mask = Syslog::LOG_UPTO(Syslog::LOG_ERR) + + close + + Closes syslog. + + inspect + + Returns the "inspect" string of the Syslog module. + + instance + + Returns the module itself. (Just for backward compatibility) + + LOG_MASK(pri) + + Creates a mask for one priority. + + LOG_UPTO(pri) + + Creates a mask for all priorities up to pri. + +** Syslog::Constants(Module) + +require 'syslog' +include Syslog::Constants + +This module includes the LOG_* constants available on the system. + +Module Methods: + + LOG_MASK(pri) + + Creates a mask for one priority. + + LOG_UPTO(pri) + + Creates a mask for all priorities up to pri. |