作者:gitter-badge
项目:tcel
func (t *tScreen) termioInit() error {
var e error
var rv C.int
var newtios C.struct_termios
var fd C.int
if t.in, e = os.OpenFile("/dev/tty", os.O_RDONLY, 0); e != nil {
goto failed
}
if t.out, e = os.OpenFile("/dev/tty", os.O_WRONLY, 0); e != nil {
goto failed
}
t.tiosp = &termiosPrivate{}
fd = C.int(t.out.Fd())
if rv, e = C.tcgetattr(fd, &t.tiosp.tios); rv != 0 {
goto failed
}
t.baud = int(C.getbaud(&t.tiosp.tios))
newtios = t.tiosp.tios
newtios.c_iflag &^= C.IGNBRK | C.BRKINT | C.PARMRK |
C.ISTRIP | C.INLCR | C.IGNCR |
C.ICRNL | C.IXON
newtios.c_oflag &^= C.OPOST
newtios.c_lflag &^= C.ECHO | C.ECHONL | C.ICANON |
C.ISIG | C.IEXTEN
newtios.c_cflag &^= C.CSIZE | C.PARENB
newtios.c_cflag |= C.CS8
// We wake up at the earliest of 100 msec or when data is received.
// We need to wake up frequently to permit us to exit cleanly and
// close file descriptors on systems like Darwin, where close does
// cause a wakeup. (Probably we could reasonably increase this to
// something like 1 sec or 500 msec.)
newtios.c_cc[C.VMIN] = 0
newtios.c_cc[C.VTIME] = 1
if rv, e = C.tcsetattr(fd, C.TCSANOW|C.TCSAFLUSH, &newtios); rv != 0 {
goto failed
}
signal.Notify(t.sigwinch, syscall.SIGWINCH)
if w, h, e := t.getWinSize(); e == nil && w != 0 && h != 0 {
t.w = w
t.h = h
}
return nil
failed:
if t.in != nil {
t.in.Close()
}
if t.out != nil {
t.out.Close()
}
return e
}
作者:ridal
项目:sirservalo
/**
* Open the serial port setting the baud etc.
*/
func openSerial() (io.ReadWriteCloser, error) {
file, err :=
os.OpenFile(
"/dev/ttyUSB0",
syscall.O_RDWR|syscall.O_NOCTTY,
0600)
if err != nil {
return nil, err
}
fd := C.int(file.Fd())
if C.isatty(fd) == 0 {
err := errors.New("File is not a serial port")
return nil, err
}
var termios C.struct_termios
_, err = C.tcgetattr(fd, &termios)
if err != nil {
return nil, err
}
var baud C.speed_t
baud = C.B115200
_, err = C.cfsetispeed(&termios, baud)
if err != nil {
return nil, err
}
_, err = C.cfsetospeed(&termios, baud)
if err != nil {
return nil, err
}
return file, nil
}
作者:vegasj
项目:go-seria
func (c *Connection) setBaudRate(baud Baud) error {
fd, err := c.getFileDescriptor()
if err != nil {
return err
}
var st C.struct_termios
_, err = C.tcgetattr(fd, &st)
if err != nil {
return err
}
speed, err := convertBaud(c.Baud)
if err != nil {
return err
}
_, err = C.cfsetispeed(&st, speed)
if err != nil {
return err
}
_, err = C.cfsetospeed(&st, speed)
if err != nil {
return err
}
return nil
}
作者:CadeLaRe
项目:docker-
func tcget(fd uintptr, p *Termios) syscall.Errno {
ret, err := C.tcgetattr(C.int(fd), (*C.struct_termios)(unsafe.Pointer(p)))
if ret != 0 {
return err.(syscall.Errno)
}
return 0
}
作者:jacobs
项目:comebac
// Thin wrapper around tcgetattr.
func getTermSettings() (settings C.struct_termios) {
res, err := C.tcgetattr(C.int(os.Stderr.Fd()), &settings)
if res != 0 {
panic(fmt.Sprintf("tcgetattr returned %d: %v", res, err))
}
return
}
作者:blamarch
项目:Go-Ter
// Gets terminal state.
//
// int tcgetattr(int fd, struct termios *termios_p);
func (tc *termios) tcgetattr() error {
exitCode, errno := C.tcgetattr(C.int(tc.fd), tc.wrap)
if exitCode == 0 {
return nil
}
return errno
}
作者:krocko
项目:goter
// Gets a terminal's attributes. Akin to tcgetattr().
func (t *Terminal) GetAttributes() (*Attributes, os.Error) {
var cattr C.struct_termios
result := int(C.tcgetattr(C.int(t.Fd()), &cattr))
if result < 0 {
return nil, os.NewError("Unable to get terminal attributes.")
}
return makeGoAttributes(&cattr), nil
}
作者:k0kubu
项目:go-termio
// Wrapper of tcgetattr(3).
// The GetAttr() function copies the parameters associated with the terminal.
func (t *Termios) GetAttr(fd int) error {
var cTerm C.struct_termios
if C.tcgetattr(C.int(fd), &cTerm) == -1 {
return errors.New("tcgetattr failure")
}
*t = *goTermios(&cTerm)
return nil
}
作者:distribute
项目:ser
func (bp *baseport) getattr() (*C.struct_termios, error) {
var tio C.struct_termios
res, err := C.tcgetattr(C.int(bp.f.Fd()), (*C.struct_termios)(unsafe.Pointer(&tio)))
if res != 0 || err != nil {
return nil, err
}
return &tio, nil
}
作者:vegasj
项目:go-seria
func (c *Connection) open() (err error) {
c.file, err = os.OpenFile(c.Name, syscall.O_RDWR|syscall.O_NOCTTY|syscall.O_NONBLOCK, 0666)
if err != nil {
return err
}
fd, err := c.getFileDescriptor()
if err != nil {
c.file.Close()
return err
}
var st C.struct_termios
_, err = C.tcgetattr(fd, &st)
if err != nil {
c.file.Close()
return err
}
// set the baud rate of the connection
err = c.setBaudRate(c.Baud)
if err != nil {
c.file.Close()
return err
}
// No timeout set directly on termios
st.c_cc[C.VMIN] = 0
st.c_cc[C.VTIME] = 0
// 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 {
c.file.Close()
return err
}
r1, _, e := syscall.Syscall(syscall.SYS_FCNTL,
uintptr(c.file.Fd()),
uintptr(syscall.F_SETFL),
uintptr(0))
if e != 0 || r1 != 0 {
s := fmt.Sprint("Clearing NONBLOCK syscall error:", e, r1)
c.file.Close()
return errors.New(s)
}
return nil
}
作者:wdreevei
项目:termiosli
// Getattr copies the parameters associated with the terminal
// referenced by fd in the Termios structure referenced by dst.
func Getattr(fd uintptr, dst *Termios) error {
_, rv := C.tcgetattr(C.int(fd), &dst.i)
if rv == nil {
dst.C_iflag = dst.i.c_iflag
dst.C_oflag = dst.i.c_oflag
dst.C_cflag = dst.i.c_cflag
dst.C_lflag = dst.i.c_lflag
dst.C_cc = dst.i.c_cc
}
return rv
}
作者:jameine
项目:lx
func GetState(fd int) (*State, error) {
termios := syscall.Termios{}
ret, err := C.tcgetattr(C.int(fd), (*C.struct_termios)(unsafe.Pointer(&termios)))
if ret != 0 {
return nil, err.(syscall.Errno)
}
state := State{}
state.Termios = termios
return &state, nil
}
作者:npat-efaul
项目:seria
// GetFd reads the attributes of the terminal corresponding to the
// file-descriptor fd and stores them in the Termios structure t. See
// tcgetattr(3) for more.
func (t *Termios) GetFd(fd int) error {
for {
r, err := C.tcgetattr(C.int(fd), &t.t)
if r < 0 {
// This is most-likely not possible, but
// better be safe.
if err == syscall.EINTR {
continue
}
return err
}
return nil
}
}
作者:sf
项目:crypti
func ReadPassphrase() string {
stdin := C.int(os.Stdin.Fd())
C.tcgetattr(stdin, &C.AttrOld)
C.Attr = C.AttrOld
C.Attr.c_lflag = C.Attr.c_lflag&^C.ECHO | C.ECHONL
C.tcsetattr(stdin, C.TCSANOW, &C.Attr)
defer C.tcsetattr(stdin, C.TCSANOW, &C.AttrOld)
reader := bufio.NewReader(os.Stdin)
line, err := reader.ReadString('\n')
if err != nil {
return ""
}
return strings.TrimSpace(line)
}
作者:wxdubli
项目:go-rs23
// SetInputAttr sets VMIN and VTIME for control serial reads.
//
// In non-canonical input processing mode, input is not assembled into
// lines and input processing (erase, kill, delete, etc.) does not
// occur. Two parameters control the behavior of this mode:
// c_cc[VTIME] sets the character timer, and c_cc[VMIN] sets the
// minimum number of characters to receive before satisfying the read.
//
// If MIN > 0 and TIME = 0, MIN sets the number of characters to
//receive before the read is satisfied. As TIME is zero, the timer is
//not used.
//
// If MIN = 0 and TIME > 0, TIME serves as a timeout value. The read
//will be satisfied if a single character is read, or TIME is exceeded
//(t = TIME *0.1 s). If TIME is exceeded, no character will be
//returned.
//
// If MIN > 0 and TIME > 0, TIME serves as an inter-character
//timer. The read will be satisfied if MIN characters are received, or
//the time between two characters exceeds TIME. The timer is restarted
//every time a character is received and only becomes active after the
//first character has been received.
//
// If MIN = 0 and TIME = 0, read will be satisfied immediately. The
//number of characters currently available, or the number of
//characters requested will be returned. According to Antonino (see
//contributions), you could issue a fcntl(fd, F_SETFL, FNDELAY);
//before reading to get the same result.
//
// By modifying newtio.c_cc[VTIME] and newtio.c_cc[VMIN] all modes
//described above can be tested.
//
// -- copied from http://tldp.org/HOWTO/Serial-Programming-HOWTO/x115.html
func (port *SerialPort) SetInputAttr(minBytes int, timeout time.Duration) error {
fd := port.port.Fd()
var options C.struct_termios
if C.tcgetattr(C.int(fd), &options) < 0 {
return fmt.Errorf("tcgetattr failed")
}
options.c_cc[C.VMIN] = _Ctype_cc_t(minBytes)
options.c_cc[C.VTIME] = _Ctype_cc_t(timeout / (time.Second / 10))
if C.tcsetattr(C.int(fd), C.TCSANOW, &options) < 0 {
return fmt.Errorf("tcsetattr failed")
}
return nil
}
作者:MagikBS
项目:htdigest-g
func stdin_read_password() string {
stdin := C.int(os.Stdin.Fd())
C.tcgetattr(stdin, &C.T)
C.T_orig = C.T
C.T.c_lflag &^= C.ECHO
C.T.c_lflag |= C.ECHONL
C.tcsetattr(stdin, C.TCSANOW, &C.T)
var passwd string
fmt.Scanf("%s", &passwd)
C.tcsetattr(stdin, C.TCSANOW, &C.T_orig)
return passwd
}
作者:prof-brain
项目:PropForth5.
func SerialChannels(name string, baud int, debug bool) (chan byte, chan byte, chan bool, chan bool, error) {
var err error
var serFile *os.File
var chFromSerial, chToSerial chan byte
var chDTRSerial, chQuitSerial chan bool
serFile, err = os.OpenFile(name, os.O_RDWR|syscall.O_NOCTTY|syscall.O_NONBLOCK, 0666)
if err == nil {
fd := C.int(serFile.Fd())
var st C.struct_termios
_, err = C.tcgetattr(fd, &st)
if err == nil {
if C.isatty(fd) != 1 {
err = errors.New("Not a tty")
}
}
var speed C.speed_t
if err == nil {
switch baud {
case 230400:
speed = C.B230400
case 115200:
speed = C.B115200
case 57600:
speed = C.B57600
case 19200:
speed = C.B19200
case 9600:
speed = C.B9600
default:
err = errors.New("Invalid baud rate")
}
}
if err == nil {
_, err = C.cfsetispeed(&st, speed)
if err == nil {
_, err = C.cfsetospeed(&st, speed)
}
}
if err == nil {
C.cfmakeraw(&st)
_, err = C.tcsetattr(fd, C.TCSANOW, &st)
}
if err == nil {
chFromSerial = make(chan byte, 8192)
chQuitFrom := make(chan bool)
go func() {
datain := make([]byte, 1)
for q := false; q == false; {
count, _ := serFile.Read(datain)
for i := 0; i < count; i++ {
if debug {
if datain[i] == byte(0x0D) {
fmt.Print("(\n)")
} else {
fmt.Printf("(%02X)", datain[i])
}
}
chFromSerial <- datain[i]
}
select {
case q = <-chQuitFrom:
default:
}
time.Sleep(10)
}
}()
chToSerial = make(chan byte, 8192)
chQuitTo := make(chan bool)
go func() {
dataout := make([]byte, 1)
for q := false; q == false; {
dataout[0] = <-chToSerial
if debug {
if dataout[0] == byte(0x0D) {
fmt.Print("[\n]")
} else {
fmt.Printf("[%c]", dataout[0])
}
}
scount, serr := serFile.Write(dataout)
if scount != 1 || serr != nil {
fmt.Printf("SERIAL ERROR: write error [%d][%s]\n", scount, serr)
}
}
}()
chDTRSerial = make(chan bool)
chQuitDTR := make(chan bool)
//.........这里部分代码省略.........
作者:axlros
项目:golang_sample
func openPort(name string, c *Config) (rwc io.ReadWriteCloser, err error) {
f, err := os.OpenFile(name, syscall.O_RDWR|syscall.O_NOCTTY|syscall.O_NONBLOCK, 0666)
if err != nil {
return
}
defer func() {
if err != nil {
f.Close()
}
}()
fd := C.int(f.Fd())
if C.isatty(fd) != 1 {
return nil, errors.New("File is not a tty")
}
var st C.struct_termios
_, err = C.tcgetattr(fd, &st)
if err != nil {
return nil, err
}
var speed C.speed_t
switch c.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
default:
return nil, fmt.Errorf("Unknown baud rate %v", c.Baud)
}
_, err = C.cfsetispeed(&st, speed)
if err != nil {
return nil, err
}
_, err = C.cfsetospeed(&st, speed)
if err != nil {
return nil, err
}
// Select local mode
st.c_cflag |= C.CLOCAL | C.CREAD
// Select stop bits
switch c.StopBits {
case StopBits1:
st.c_cflag &^= C.CSTOPB
case StopBits2:
st.c_cflag |= C.CSTOPB
default:
panic(c.StopBits)
}
// Select character size
st.c_cflag &^= C.CSIZE
switch c.Size {
case Byte5:
st.c_cflag |= C.CS5
case Byte6:
st.c_cflag |= C.CS6
case Byte7:
st.c_cflag |= C.CS7
case Byte8:
st.c_cflag |= C.CS8
default:
panic(c.Size)
}
// Select parity mode
switch c.Parity {
case ParityNone:
st.c_cflag &^= C.PARENB
case ParityEven:
st.c_cflag |= C.PARENB
st.c_cflag &^= C.PARODD
case ParityOdd:
st.c_cflag |= C.PARENB
st.c_cflag |= C.PARODD
default:
panic(c.Parity)
}
// Select CRLF translation
if c.CRLFTranslate {
st.c_iflag |= C.ICRNL
} else {
st.c_iflag &^= C.ICRNL
}
// Select raw mode
st.c_lflag &^= C.ICANON | C.ECHO | C.ECHOE | C.ISIG
st.c_oflag &^= C.OPOST
//.........这里部分代码省略.........
作者:shotanta
项目:5DPrin
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, fmt.Errorf("[ERROR] not a tty/cu device")
}
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
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
}
r1, _, e := syscall.Syscall(syscall.SYS_FCNTL,
uintptr(f.Fd()),
uintptr(syscall.F_SETFL),
uintptr(0))
if e != 0 || r1 != 0 {
s := fmt.Sprint("[WARN] clearing NONBLOCK syscall error:", e, r1)
f.Close()
return nil, fmt.Errorf("%s", s)
}
return f, nil
}
作者:wxdubli
项目:go-rs23
// Opens and returns a non-blocking serial port.
// The device, baud rate, and SerConf is specified.
//
// Example: rs232.OpenPort("/dev/ttyS0", 115200, rs232.S_8N1)
func OpenPort(port string, baudRate int, serconf SerConf) (*SerialPort, error) {
rv := &SerialPort{}
f, err := os.OpenFile(port,
syscall.O_RDWR|syscall.O_NOCTTY, 0666)
if err != nil {
return nil, err
}
rv.port = f
fd := rv.port.Fd()
var options C.struct_termios
if C.tcgetattr(C.int(fd), &options) < 0 {
defer f.Close()
return nil, fmt.Errorf("tcgetattr failed")
}
if C.cfsetispeed(&options, baudConversion(baudRate)) < 0 {
defer f.Close()
return nil, fmt.Errorf("cfsetispeed failed")
}
if C.cfsetospeed(&options, baudConversion(baudRate)) < 0 {
defer f.Close()
return nil, fmt.Errorf("cfsetospeed failed")
}
switch serconf {
case S_8N1:
{
options.c_cflag &^= C.PARENB
options.c_cflag &^= C.CSTOPB
options.c_cflag &^= C.CSIZE
options.c_cflag |= C.CS8
}
case S_7E1:
{
options.c_cflag |= C.PARENB
options.c_cflag &^= C.PARODD
options.c_cflag &^= C.CSTOPB
options.c_cflag &^= C.CSIZE
options.c_cflag |= C.CS7
}
case S_7O1:
{
options.c_cflag |= C.PARENB
options.c_cflag |= C.PARODD
options.c_cflag &^= C.CSTOPB
options.c_cflag &^= C.CSIZE
options.c_cflag |= C.CS7
}
}
// Local
options.c_cflag |= (C.CLOCAL | C.CREAD)
// no hardware flow control
options.c_cflag &^= C.CRTSCTS
// Don't EOF on a zero read, just block
options.c_cc[C.VMIN] = 1
if C.tcsetattr(C.int(fd), C.TCSANOW, &options) < 0 {
defer f.Close()
return nil, fmt.Errorf("tcsetattr failed")
}
return rv, nil
}