From 554fd8c5195424bdbcabf5de30fdc183aba391bd Mon Sep 17 00:00:00 2001 From: upstream source tree Date: Sun, 15 Mar 2015 20:14:05 -0400 Subject: obtained gcc-4.6.4.tar.bz2 from upstream website; verified gcc-4.6.4.tar.bz2.sig; imported gcc-4.6.4 source tree from verified upstream tarball. downloading a git-generated archive based on the 'upstream' tag should provide you with a source tree that is binary identical to the one extracted from the above tarball. if you have obtained the source via the command 'git clone', however, do note that line-endings of files in your working directory might differ from line-endings of the respective files in the upstream repository. --- libgo/go/syslog/syslog.go | 150 ++++++++++++++++++++++++++++++++++++++ libgo/go/syslog/syslog_c.c | 19 +++++ libgo/go/syslog/syslog_solaris.go | 37 ++++++++++ libgo/go/syslog/syslog_test.go | 95 ++++++++++++++++++++++++ libgo/go/syslog/syslog_unix.go | 31 ++++++++ 5 files changed, 332 insertions(+) create mode 100644 libgo/go/syslog/syslog.go create mode 100644 libgo/go/syslog/syslog_c.c create mode 100644 libgo/go/syslog/syslog_solaris.go create mode 100644 libgo/go/syslog/syslog_test.go create mode 100644 libgo/go/syslog/syslog_unix.go (limited to 'libgo/go/syslog') diff --git a/libgo/go/syslog/syslog.go b/libgo/go/syslog/syslog.go new file mode 100644 index 000000000..711d5ddc7 --- /dev/null +++ b/libgo/go/syslog/syslog.go @@ -0,0 +1,150 @@ +// Copyright 2009 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +// The syslog package provides a simple interface to +// the system log service. It can send messages to the +// syslog daemon using UNIX domain sockets, UDP, or +// TCP connections. +package syslog + +import ( + "fmt" + "log" + "net" + "os" +) + +type Priority int + +const ( + // From /usr/include/sys/syslog.h. + // These are the same on Linux, BSD, and OS X. + LOG_EMERG Priority = iota + LOG_ALERT + LOG_CRIT + LOG_ERR + LOG_WARNING + LOG_NOTICE + LOG_INFO + LOG_DEBUG +) + +// A Writer is a connection to a syslog server. +type Writer struct { + priority Priority + prefix string + conn serverConn +} + +type serverConn interface { + writeBytes(p Priority, prefix string, b []byte) (int, os.Error) + writeString(p Priority, prefix string, s string) (int, os.Error) + close() os.Error +} + +type netConn struct { + conn net.Conn +} + +// New establishes a new connection to the system log daemon. +// Each write to the returned writer sends a log message with +// the given priority and prefix. +func New(priority Priority, prefix string) (w *Writer, err os.Error) { + return Dial("", "", priority, prefix) +} + +// Dial establishes a connection to a log daemon by connecting +// to address raddr on the network net. +// Each write to the returned writer sends a log message with +// the given priority and prefix. +func Dial(network, raddr string, priority Priority, prefix string) (w *Writer, err os.Error) { + if prefix == "" { + prefix = os.Args[0] + } + var conn serverConn + if network == "" { + conn, err = unixSyslog() + } else { + var c net.Conn + c, err = net.Dial(network, "", raddr) + conn = netConn{c} + } + return &Writer{priority, prefix, conn}, err +} + +// Write sends a log message to the syslog daemon. +func (w *Writer) Write(b []byte) (int, os.Error) { + if w.priority > LOG_DEBUG || w.priority < LOG_EMERG { + return 0, os.EINVAL + } + return w.conn.writeBytes(w.priority, w.prefix, b) +} + +func (w *Writer) writeString(p Priority, s string) (int, os.Error) { + return w.conn.writeString(p, w.prefix, s) +} + +func (w *Writer) Close() os.Error { return w.conn.close() } + +// Emerg logs a message using the LOG_EMERG priority. +func (w *Writer) Emerg(m string) (err os.Error) { + _, err = w.writeString(LOG_EMERG, m) + return err +} +// Crit logs a message using the LOG_CRIT priority. +func (w *Writer) Crit(m string) (err os.Error) { + _, err = w.writeString(LOG_CRIT, m) + return err +} +// ERR logs a message using the LOG_ERR priority. +func (w *Writer) Err(m string) (err os.Error) { + _, err = w.writeString(LOG_ERR, m) + return err +} + +// Warning logs a message using the LOG_WARNING priority. +func (w *Writer) Warning(m string) (err os.Error) { + _, err = w.writeString(LOG_WARNING, m) + return err +} + +// Notice logs a message using the LOG_NOTICE priority. +func (w *Writer) Notice(m string) (err os.Error) { + _, err = w.writeString(LOG_NOTICE, m) + return err +} +// Info logs a message using the LOG_INFO priority. +func (w *Writer) Info(m string) (err os.Error) { + _, err = w.writeString(LOG_INFO, m) + return err +} +// Debug logs a message using the LOG_DEBUG priority. +func (w *Writer) Debug(m string) (err os.Error) { + _, err = w.writeString(LOG_DEBUG, m) + return err +} + +func (n netConn) writeBytes(p Priority, prefix string, b []byte) (int, os.Error) { + return fmt.Fprintf(n.conn, "<%d>%s: %s\n", p, prefix, b) +} + +func (n netConn) writeString(p Priority, prefix string, s string) (int, os.Error) { + return fmt.Fprintf(n.conn, "<%d>%s: %s\n", p, prefix, s) +} + +func (n netConn) close() os.Error { + return n.conn.Close() +} + +// NewLogger provides an object that implements the full log.Logger interface, +// but sends messages to Syslog instead; flag is passed as is to Logger; +// priority will be used for all messages sent using this interface. +// All messages are logged with priority p. +func NewLogger(p Priority, flag int) *log.Logger { + s, err := New(p, "") + if err != nil { + return nil + } + return log.New(s, "", flag) +} diff --git a/libgo/go/syslog/syslog_c.c b/libgo/go/syslog/syslog_c.c new file mode 100644 index 000000000..f49b9ffcb --- /dev/null +++ b/libgo/go/syslog/syslog_c.c @@ -0,0 +1,19 @@ +/* syslog_c.c -- call syslog for Go. + + Copyright 2011 The Go Authors. All rights reserved. + Use of this source code is governed by a BSD-style + license that can be found in the LICENSE file. */ + +#include + +/* We need to use a C function to call the syslog function, because we + can't represent a C varargs function in Go. */ + +void syslog_c(int, const char*) + asm ("libgo_syslog.syslog.syslog_c"); + +void +syslog_c (int priority, const char *msg) +{ + syslog (priority, "%s", msg); +} diff --git a/libgo/go/syslog/syslog_solaris.go b/libgo/go/syslog/syslog_solaris.go new file mode 100644 index 000000000..044351dbf --- /dev/null +++ b/libgo/go/syslog/syslog_solaris.go @@ -0,0 +1,37 @@ +// Copyright 2011 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +// gccgo specific implementation of syslog for Solaris. Solaris uses +// STREAMS to communicate with syslogd. That is enough of a pain that +// we just call the libc function. + +package syslog + +import ( + "fmt" + "os" + "syscall" +) + +func unixSyslog() (conn serverConn, err os.Error) { + return libcConn(0), nil +} + +type libcConn int + +func syslog_c(int, *byte) + +func (libcConn) writeBytes(p Priority, prefix string, b []byte) (int, os.Error) { + syslog_c(int(p), syscall.StringBytePtr(fmt.Sprintf("%s: %s", prefix, b))) + return len(b), nil +} + +func (libcConn) writeString(p Priority, prefix string, s string) (int, os.Error) { + syslog_c(int(p), syscall.StringBytePtr(fmt.Sprintf("%s: %s", prefix, s))) + return len(s), nil +} + +func (libcConn) close() os.Error { + return nil +} diff --git a/libgo/go/syslog/syslog_test.go b/libgo/go/syslog/syslog_test.go new file mode 100644 index 000000000..063ab71b4 --- /dev/null +++ b/libgo/go/syslog/syslog_test.go @@ -0,0 +1,95 @@ +// Copyright 2009 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. +package syslog + +import ( + "io" + "log" + "net" + "testing" +) + +var serverAddr string + +func runSyslog(c net.PacketConn, done chan<- string) { + var buf [4096]byte + var rcvd string = "" + for { + n, _, err := c.ReadFrom(buf[0:]) + if err != nil || n == 0 { + break + } + rcvd += string(buf[0:n]) + } + done <- rcvd +} + +func startServer(done chan<- string) { + c, e := net.ListenPacket("udp", "127.0.0.1:0") + if e != nil { + log.Exitf("net.ListenPacket failed udp :0 %v", e) + } + serverAddr = c.LocalAddr().String() + c.SetReadTimeout(100e6) // 100ms + go runSyslog(c, done) +} + +func TestNew(t *testing.T) { + s, err := New(LOG_INFO, "") + if err != nil { + t.Fatalf("New() failed: %s", err) + } + // Don't send any messages. + s.Close() +} + +func TestNewLogger(t *testing.T) { + f := NewLogger(LOG_INFO, 0) + if f == nil { + t.Error("NewLogger() failed") + } +} + +func TestDial(t *testing.T) { + l, err := Dial("", "", LOG_ERR, "syslog_test") + if err != nil { + t.Fatalf("Dial() failed: %s", err) + } + l.Close() +} + +func TestUDPDial(t *testing.T) { + done := make(chan string) + startServer(done) + l, err := Dial("udp", serverAddr, LOG_INFO, "syslog_test") + if err != nil { + t.Fatalf("syslog.Dial() failed: %s", err) + } + msg := "udp test" + l.Info(msg) + expected := "<6>syslog_test: udp test\n" + rcvd := <-done + if rcvd != expected { + t.Fatalf("s.Info() = '%q', but wanted '%q'", rcvd, expected) + } +} + +func TestWrite(t *testing.T) { + done := make(chan string) + startServer(done) + l, err := Dial("udp", serverAddr, LOG_ERR, "syslog_test") + if err != nil { + t.Fatalf("syslog.Dial() failed: %s", err) + } + msg := "write test" + _, err = io.WriteString(l, msg) + if err != nil { + t.Fatalf("WriteString() failed: %s", err) + } + expected := "<3>syslog_test: write test\n" + rcvd := <-done + if rcvd != expected { + t.Fatalf("s.Info() = '%q', but wanted '%q'", rcvd, expected) + } +} diff --git a/libgo/go/syslog/syslog_unix.go b/libgo/go/syslog/syslog_unix.go new file mode 100644 index 000000000..b4daf88ee --- /dev/null +++ b/libgo/go/syslog/syslog_unix.go @@ -0,0 +1,31 @@ +// Copyright 2009 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +package syslog + +import ( + "net" + "os" +) + +// unixSyslog opens a connection to the syslog daemon running on the +// local machine using a Unix domain socket. + +func unixSyslog() (conn serverConn, err os.Error) { + logTypes := []string{"unixgram", "unix"} + logPaths := []string{"/dev/log", "/var/run/syslog"} + var raddr string + for _, network := range logTypes { + for _, path := range logPaths { + raddr = path + conn, err := net.Dial(network, "", raddr) + if err != nil { + continue + } else { + return netConn{conn}, nil + } + } + } + return nil, os.ErrorString("Unix syslog delivery error") +} -- cgit v1.2.3