diff --git a/third_party/github.com/cloudsigma/cepgo/cepgo.go b/third_party/github.com/cloudsigma/cepgo/cepgo.go index 5250bcc..6aeff27 100644 --- a/third_party/github.com/cloudsigma/cepgo/cepgo.go +++ b/third_party/github.com/cloudsigma/cepgo/cepgo.go @@ -48,7 +48,7 @@ import ( "fmt" "runtime" - "github.com/tarm/goserial" + "github.com/coreos/coreos-cloudinit/third_party/github.com/tarm/goserial" ) const ( diff --git a/third_party/github.com/tarm/goserial/LICENSE b/third_party/github.com/tarm/goserial/LICENSE new file mode 100644 index 0000000..6a66aea --- /dev/null +++ b/third_party/github.com/tarm/goserial/LICENSE @@ -0,0 +1,27 @@ +Copyright (c) 2009 The Go Authors. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are +met: + + * Redistributions of source code must retain the above copyright +notice, this list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above +copyright notice, this list of conditions and the following disclaimer +in the documentation and/or other materials provided with the +distribution. + * Neither the name of Google Inc. nor the names of its +contributors may be used to endorse or promote products derived from +this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. diff --git a/third_party/github.com/tarm/goserial/README.md b/third_party/github.com/tarm/goserial/README.md new file mode 100644 index 0000000..becec66 --- /dev/null +++ b/third_party/github.com/tarm/goserial/README.md @@ -0,0 +1,63 @@ +GoSerial +======== +A simple go package to allow you to read and write from the +serial port as a stream of bytes. + +Details +------- +It aims to have the same API on all platforms, including windows. As +an added bonus, the windows package does not use cgo, so you can cross +compile for windows from another platform. Unfortunately goinstall +does not currently let you cross compile so you will have to do it +manually: + + GOOS=windows make clean install + +Currently there is very little in the way of configurability. You can +set the baud rate. Then you can Read(), Write(), or Close() the +connection. Read() will block until at least one byte is returned. +Write is the same. There is currently no exposed way to set the +timeouts, though patches are welcome. + +Currently all ports are opened with 8 data bits, 1 stop bit, no +parity, no hardware flow control, and no software flow control. This +works fine for many real devices and many faux serial devices +including usb-to-serial converters and bluetooth serial ports. + +You may Read() and Write() simulantiously on the same connection (from +different goroutines). + +Usage +----- +```go +package main + +import ( + "github.com/tarm/goserial" + "log" +) + +func main() { + c := &serial.Config{Name: "COM45", Baud: 115200} + s, err := serial.OpenPort(c) + if err != nil { + log.Fatal(err) + } + + n, err := s.Write([]byte("test")) + if err != nil { + log.Fatal(err) + } + + buf := make([]byte, 128) + n, err = s.Read(buf) + if err != nil { + log.Fatal(err) + } + log.Print("%q", buf[:n]) +} +``` + +Possible Future Work +-------------------- +- better tests (loopback etc) diff --git a/third_party/github.com/tarm/goserial/basic_test.go b/third_party/github.com/tarm/goserial/basic_test.go new file mode 100644 index 0000000..f6532ba --- /dev/null +++ b/third_party/github.com/tarm/goserial/basic_test.go @@ -0,0 +1,39 @@ +package serial + +import ( + "testing" +) + +func TestConnection(t *testing.T) { + if testing.Short() { + return + } + c0 := &Config{Name: "COM5", Baud: 115200} + + /* + c1 := new(Config) + c1.Name = "COM5" + c1.Baud = 115200 + */ + + s, err := OpenPort(c0) + if err != nil { + t.Fatal(err) + } + + _, err = s.Write([]byte("test")) + if err != nil { + t.Fatal(err) + } + + buf := make([]byte, 128) + _, err = s.Read(buf) + if err != nil { + t.Fatal(err) + } +} + +// BUG(tarmigan): Add loopback test +func TestLoopback(t *testing.T) { + +} diff --git a/third_party/github.com/tarm/goserial/serial.go b/third_party/github.com/tarm/goserial/serial.go new file mode 100644 index 0000000..7a404be --- /dev/null +++ b/third_party/github.com/tarm/goserial/serial.go @@ -0,0 +1,99 @@ +/* +Goserial is a simple go package to allow you to read and write from +the serial port as a stream of bytes. + +It aims to have the same API on all platforms, including windows. As +an added bonus, the windows package does not use cgo, so you can cross +compile for windows from another platform. Unfortunately goinstall +does not currently let you cross compile so you will have to do it +manually: + + GOOS=windows make clean install + +Currently there is very little in the way of configurability. You can +set the baud rate. Then you can Read(), Write(), or Close() the +connection. Read() will block until at least one byte is returned. +Write is the same. There is currently no exposed way to set the +timeouts, though patches are welcome. + +Currently all ports are opened with 8 data bits, 1 stop bit, no +parity, no hardware flow control, and no software flow control. This +works fine for many real devices and many faux serial devices +including usb-to-serial converters and bluetooth serial ports. + +You may Read() and Write() simulantiously on the same connection (from +different goroutines). + +Example usage: + + package main + + import ( + "github.com/tarm/goserial" + "log" + ) + + func main() { + c := &serial.Config{Name: "COM5", Baud: 115200} + s, err := serial.OpenPort(c) + if err != nil { + log.Fatal(err) + } + + n, err := s.Write([]byte("test")) + if err != nil { + log.Fatal(err) + } + + buf := make([]byte, 128) + n, err = s.Read(buf) + if err != nil { + log.Fatal(err) + } + log.Print("%q", buf[:n]) + } +*/ +package serial + +import "io" + +// Config contains the information needed to open a serial port. +// +// Currently few options are implemented, but more may be added in the +// future (patches welcome), so it is recommended that you create a +// new config addressing the fields by name rather than by order. +// +// For example: +// +// c0 := &serial.Config{Name: "COM45", Baud: 115200} +// or +// c1 := new(serial.Config) +// c1.Name = "/dev/tty.usbserial" +// c1.Baud = 115200 +// +type Config struct { + Name string + Baud int + + // Size int // 0 get translated to 8 + // Parity SomeNewTypeToGetCorrectDefaultOf_None + // StopBits SomeNewTypeToGetCorrectDefaultOf_1 + + // RTSFlowControl bool + // DTRFlowControl bool + // XONFlowControl bool + + // CRLFTranslate bool + // TimeoutStuff int +} + +// OpenPort opens a serial port with the specified configuration +func OpenPort(c *Config) (io.ReadWriteCloser, error) { + return openPort(c.Name, c.Baud) +} + +// func Flush() + +// func SendBreak() + +// func RegisterBreakHandler(func()) diff --git a/third_party/github.com/tarm/goserial/serial_linux.go b/third_party/github.com/tarm/goserial/serial_linux.go new file mode 100644 index 0000000..2366f2c --- /dev/null +++ b/third_party/github.com/tarm/goserial/serial_linux.go @@ -0,0 +1,90 @@ +// +build linux,!cgo + +package serial + +import ( + "io" + "os" + "syscall" + "unsafe" +) + +func openPort(name string, baud int) (rwc io.ReadWriteCloser, err error) { + + var bauds = map[int]uint32{ + 50: syscall.B50, + 75: syscall.B75, + 110: syscall.B110, + 134: syscall.B134, + 150: syscall.B150, + 200: syscall.B200, + 300: syscall.B300, + 600: syscall.B600, + 1200: syscall.B1200, + 1800: syscall.B1800, + 2400: syscall.B2400, + 4800: syscall.B4800, + 9600: syscall.B9600, + 19200: syscall.B19200, + 38400: syscall.B38400, + 57600: syscall.B57600, + 115200: syscall.B115200, + 230400: syscall.B230400, + 460800: syscall.B460800, + 500000: syscall.B500000, + 576000: syscall.B576000, + 921600: syscall.B921600, + 1000000: syscall.B1000000, + 1152000: syscall.B1152000, + 1500000: syscall.B1500000, + 2000000: syscall.B2000000, + 2500000: syscall.B2500000, + 3000000: syscall.B3000000, + 3500000: syscall.B3500000, + 4000000: syscall.B4000000, + } + + rate := bauds[baud] + + if rate == 0 { + return + } + + f, err := os.OpenFile(name, syscall.O_RDWR|syscall.O_NOCTTY|syscall.O_NONBLOCK, 0666) + if err != nil { + return nil, err + } + + defer func() { + if err != nil && f != nil { + f.Close() + } + }() + + fd := f.Fd() + t := syscall.Termios{ + Iflag: syscall.IGNPAR, + Cflag: syscall.CS8 | syscall.CREAD | syscall.CLOCAL | rate, + Cc: [32]uint8{syscall.VMIN: 1}, + Ispeed: rate, + Ospeed: rate, + } + + if _, _, errno := syscall.Syscall6( + syscall.SYS_IOCTL, + uintptr(fd), + uintptr(syscall.TCSETS), + uintptr(unsafe.Pointer(&t)), + 0, + 0, + 0, + ); errno != 0 { + return nil, errno + } + + if err = syscall.SetNonblock(int(fd), false); err != nil { + return + } + + return f, nil +} diff --git a/third_party/github.com/tarm/goserial/serial_posix.go b/third_party/github.com/tarm/goserial/serial_posix.go new file mode 100644 index 0000000..2eeb608 --- /dev/null +++ b/third_party/github.com/tarm/goserial/serial_posix.go @@ -0,0 +1,107 @@ +// +build !windows,cgo + +package serial + +// #include +// #include +import "C" + +// TODO: Maybe change to using syscall package + ioctl instead of cgo + +import ( + "errors" + "fmt" + "io" + "os" + "syscall" + //"unsafe" +) + +func openPort(name string, baud int) (rwc io.ReadWriteCloser, err error) { + f, err := os.OpenFile(name, syscall.O_RDWR|syscall.O_NOCTTY|syscall.O_NONBLOCK, 0666) + if err != nil { + return + } + + fd := C.int(f.Fd()) + if C.isatty(fd) != 1 { + f.Close() + return nil, errors.New("File is not a tty") + } + + var st C.struct_termios + _, err = C.tcgetattr(fd, &st) + if err != nil { + f.Close() + return nil, err + } + var speed C.speed_t + switch baud { + case 115200: + speed = C.B115200 + case 57600: + speed = C.B57600 + case 38400: + speed = C.B38400 + case 19200: + speed = C.B19200 + case 9600: + speed = C.B9600 + case 4800: + speed = C.B4800 + case 2400: + speed = C.B2400 + default: + f.Close() + return nil, fmt.Errorf("Unknown baud rate %v", baud) + } + + _, err = C.cfsetispeed(&st, speed) + if err != nil { + f.Close() + return nil, err + } + _, err = C.cfsetospeed(&st, speed) + if err != nil { + f.Close() + return nil, err + } + + // Select local mode + st.c_cflag |= (C.CLOCAL | C.CREAD) + + // Select raw mode + st.c_lflag &= ^C.tcflag_t(C.ICANON | C.ECHO | C.ECHOE | C.ISIG) + st.c_oflag &= ^C.tcflag_t(C.OPOST) + + _, err = C.tcsetattr(fd, C.TCSANOW, &st) + if err != nil { + f.Close() + return nil, err + } + + //fmt.Println("Tweaking", name) + r1, _, e := syscall.Syscall(syscall.SYS_FCNTL, + uintptr(f.Fd()), + uintptr(syscall.F_SETFL), + uintptr(0)) + if e != 0 || r1 != 0 { + s := fmt.Sprint("Clearing NONBLOCK syscall error:", e, r1) + f.Close() + return nil, errors.New(s) + } + + /* + r1, _, e = syscall.Syscall(syscall.SYS_IOCTL, + uintptr(f.Fd()), + uintptr(0x80045402), // IOSSIOSPEED + uintptr(unsafe.Pointer(&baud))); + if e != 0 || r1 != 0 { + s := fmt.Sprint("Baudrate syscall error:", e, r1) + f.Close() + return nil, os.NewError(s) + } + */ + + return f, nil +} diff --git a/third_party/github.com/tarm/goserial/serial_windows.go b/third_party/github.com/tarm/goserial/serial_windows.go new file mode 100644 index 0000000..76e0a30 --- /dev/null +++ b/third_party/github.com/tarm/goserial/serial_windows.go @@ -0,0 +1,263 @@ +// +build windows + +package serial + +import ( + "fmt" + "io" + "os" + "sync" + "syscall" + "unsafe" +) + +type serialPort struct { + f *os.File + fd syscall.Handle + rl sync.Mutex + wl sync.Mutex + ro *syscall.Overlapped + wo *syscall.Overlapped +} + +type structDCB struct { + DCBlength, BaudRate uint32 + flags [4]byte + wReserved, XonLim, XoffLim uint16 + ByteSize, Parity, StopBits byte + XonChar, XoffChar, ErrorChar, EofChar, EvtChar byte + wReserved1 uint16 +} + +type structTimeouts struct { + ReadIntervalTimeout uint32 + ReadTotalTimeoutMultiplier uint32 + ReadTotalTimeoutConstant uint32 + WriteTotalTimeoutMultiplier uint32 + WriteTotalTimeoutConstant uint32 +} + +func openPort(name string, baud int) (rwc io.ReadWriteCloser, err error) { + if len(name) > 0 && name[0] != '\\' { + name = "\\\\.\\" + name + } + + h, err := syscall.CreateFile(syscall.StringToUTF16Ptr(name), + syscall.GENERIC_READ|syscall.GENERIC_WRITE, + 0, + nil, + syscall.OPEN_EXISTING, + syscall.FILE_ATTRIBUTE_NORMAL|syscall.FILE_FLAG_OVERLAPPED, + 0) + if err != nil { + return nil, err + } + f := os.NewFile(uintptr(h), name) + defer func() { + if err != nil { + f.Close() + } + }() + + if err = setCommState(h, baud); err != nil { + return + } + if err = setupComm(h, 64, 64); err != nil { + return + } + if err = setCommTimeouts(h); err != nil { + return + } + if err = setCommMask(h); err != nil { + return + } + + ro, err := newOverlapped() + if err != nil { + return + } + wo, err := newOverlapped() + if err != nil { + return + } + port := new(serialPort) + port.f = f + port.fd = h + port.ro = ro + port.wo = wo + + return port, nil +} + +func (p *serialPort) Close() error { + return p.f.Close() +} + +func (p *serialPort) Write(buf []byte) (int, error) { + p.wl.Lock() + defer p.wl.Unlock() + + if err := resetEvent(p.wo.HEvent); err != nil { + return 0, err + } + var n uint32 + err := syscall.WriteFile(p.fd, buf, &n, p.wo) + if err != nil && err != syscall.ERROR_IO_PENDING { + return int(n), err + } + return getOverlappedResult(p.fd, p.wo) +} + +func (p *serialPort) Read(buf []byte) (int, error) { + if p == nil || p.f == nil { + return 0, fmt.Errorf("Invalid port on read %v %v", p, p.f) + } + + p.rl.Lock() + defer p.rl.Unlock() + + if err := resetEvent(p.ro.HEvent); err != nil { + return 0, err + } + var done uint32 + err := syscall.ReadFile(p.fd, buf, &done, p.ro) + if err != nil && err != syscall.ERROR_IO_PENDING { + return int(done), err + } + return getOverlappedResult(p.fd, p.ro) +} + +var ( + nSetCommState, + nSetCommTimeouts, + nSetCommMask, + nSetupComm, + nGetOverlappedResult, + nCreateEvent, + nResetEvent uintptr +) + +func init() { + k32, err := syscall.LoadLibrary("kernel32.dll") + if err != nil { + panic("LoadLibrary " + err.Error()) + } + defer syscall.FreeLibrary(k32) + + nSetCommState = getProcAddr(k32, "SetCommState") + nSetCommTimeouts = getProcAddr(k32, "SetCommTimeouts") + nSetCommMask = getProcAddr(k32, "SetCommMask") + nSetupComm = getProcAddr(k32, "SetupComm") + nGetOverlappedResult = getProcAddr(k32, "GetOverlappedResult") + nCreateEvent = getProcAddr(k32, "CreateEventW") + nResetEvent = getProcAddr(k32, "ResetEvent") +} + +func getProcAddr(lib syscall.Handle, name string) uintptr { + addr, err := syscall.GetProcAddress(lib, name) + if err != nil { + panic(name + " " + err.Error()) + } + return addr +} + +func setCommState(h syscall.Handle, baud int) error { + var params structDCB + params.DCBlength = uint32(unsafe.Sizeof(params)) + + params.flags[0] = 0x01 // fBinary + params.flags[0] |= 0x10 // Assert DSR + + params.BaudRate = uint32(baud) + params.ByteSize = 8 + + r, _, err := syscall.Syscall(nSetCommState, 2, uintptr(h), uintptr(unsafe.Pointer(¶ms)), 0) + if r == 0 { + return err + } + return nil +} + +func setCommTimeouts(h syscall.Handle) error { + var timeouts structTimeouts + const MAXDWORD = 1<<32 - 1 + timeouts.ReadIntervalTimeout = MAXDWORD + timeouts.ReadTotalTimeoutMultiplier = MAXDWORD + timeouts.ReadTotalTimeoutConstant = MAXDWORD - 1 + + /* From http://msdn.microsoft.com/en-us/library/aa363190(v=VS.85).aspx + + For blocking I/O see below: + + Remarks: + + If an application sets ReadIntervalTimeout and + ReadTotalTimeoutMultiplier to MAXDWORD and sets + ReadTotalTimeoutConstant to a value greater than zero and + less than MAXDWORD, one of the following occurs when the + ReadFile function is called: + + If there are any bytes in the input buffer, ReadFile returns + immediately with the bytes in the buffer. + + If there are no bytes in the input buffer, ReadFile waits + until a byte arrives and then returns immediately. + + If no bytes arrive within the time specified by + ReadTotalTimeoutConstant, ReadFile times out. + */ + + r, _, err := syscall.Syscall(nSetCommTimeouts, 2, uintptr(h), uintptr(unsafe.Pointer(&timeouts)), 0) + if r == 0 { + return err + } + return nil +} + +func setupComm(h syscall.Handle, in, out int) error { + r, _, err := syscall.Syscall(nSetupComm, 3, uintptr(h), uintptr(in), uintptr(out)) + if r == 0 { + return err + } + return nil +} + +func setCommMask(h syscall.Handle) error { + const EV_RXCHAR = 0x0001 + r, _, err := syscall.Syscall(nSetCommMask, 2, uintptr(h), EV_RXCHAR, 0) + if r == 0 { + return err + } + return nil +} + +func resetEvent(h syscall.Handle) error { + r, _, err := syscall.Syscall(nResetEvent, 1, uintptr(h), 0, 0) + if r == 0 { + return err + } + return nil +} + +func newOverlapped() (*syscall.Overlapped, error) { + var overlapped syscall.Overlapped + r, _, err := syscall.Syscall6(nCreateEvent, 4, 0, 1, 0, 0, 0, 0) + if r == 0 { + return nil, err + } + overlapped.HEvent = syscall.Handle(r) + return &overlapped, nil +} + +func getOverlappedResult(h syscall.Handle, overlapped *syscall.Overlapped) (int, error) { + var n int + r, _, err := syscall.Syscall6(nGetOverlappedResult, 4, + uintptr(h), + uintptr(unsafe.Pointer(overlapped)), + uintptr(unsafe.Pointer(&n)), 1, 0, 0) + if r == 0 { + return n, err + } + + return n, nil +}