func (c conn) Write(b []byte) (n int, err error) { n, err = unix.Write(c.fd, b) if err != nil { err = Err{err} } return }
func (tfd testFd) put(t *testing.T) { buf := make([]byte, 10) _, errno := unix.Write(tfd[1], buf) if errno != nil { t.Fatalf("Failed to write to pipe: %v", errno) } }
func TestDup(t *testing.T) { file, err := ioutil.TempFile("", "TestDup") if err != nil { t.Fatalf("Tempfile failed: %v", err) } defer os.Remove(file.Name()) defer file.Close() f := int(file.Fd()) newFd, err := unix.Dup(f) if err != nil { t.Fatalf("Dup: %v", err) } err = unix.Dup2(newFd, newFd+1) if err != nil { t.Fatalf("Dup2: %v", err) } b1 := []byte("Test123") b2 := make([]byte, 7) _, err = unix.Write(newFd+1, b1) if err != nil { t.Fatalf("Write to dup2 fd failed: %v", err) } _, err = unix.Seek(f, 0, 0) _, err = unix.Read(f, b2) if err != nil { t.Fatalf("Read back failed: %v", err) } if string(b1) != string(b2) { t.Errorf("Dup: stdout write not in file, expected %v, got %v", string(b1), string(b2)) } }
// Close the write end of the poller. func (poller *fdPoller) wake() error { buf := make([]byte, 1) n, errno := unix.Write(poller.pipe[1], buf) if n == -1 { if errno == unix.EAGAIN { // Buffer is full, poller will wake. return nil } return errno } return nil }
func (d *Device) recvResponse() { var n int buf := make([]byte, 4) for resp := range d.respChan { err := d.completeCommand(resp) if err != nil { log.Errorf("error completing command: %s", err) return } /* Tell the fd there's something new */ n, err = unix.Write(d.uioFd, buf) if n == -1 && err != nil { log.Errorln("poll write") return } } }
func stop() { if cxt != nil { // notify HandleRequest() that we're done if _, err := unix.Write(pipeFds[1], []byte{0}); err != nil { log.Errorln("Fail to notify poll for finishing: ", err) } close(done) C.tcmulib_close(cxt) if err := unix.Close(pipeFds[0]); err != nil { log.Errorln("Fail to close pipeFds[0]: ", err) } if err := unix.Close(pipeFds[1]); err != nil { log.Errorln("Fail to close pipeFds[1]: ", err) } cxt = nil } }
func main() { fmt.Println("Listening on port :", port) counter := new(connCounter) // create socket fd, err := unix.Socket(unix.AF_INET, unix.SOCK_STREAM, 0) if err != nil { log.Fatal("socket-error: ", err) } // sa struct sa := new(unix.SockaddrInet4) sa.Port = 9090 // bind err = unix.Bind(fd, sa) if err != nil { log.Fatal("bind: ", err) } // listen err = unix.Listen(fd, 3) if err != nil { log.Fatal("listen: ", err) } for { connInfo := new(connection) // accept connection, discard SA struct newFd, _, err := unix.Accept(fd) connInfo.fd = newFd if err != nil { log.Fatal("accept: ", err) } // client reads until closes, adding // a gorutine allows dealing with more // requests. counter.mu.Lock() counter.num += 1 counter.mu.Unlock() fmt.Println("Number of connections: ", counter.num) go func(c *connection, counter *connCounter) { fmt.Printf("Conn.fd=%d\n", c.fd) for { // read c.buf = make([]byte, 50) n, err := unix.Read(c.fd, c.buf) if err != nil { log.Fatal("read: ", err) } fmt.Printf("Read: %d Value: %s\n", n, string(c.buf[0:n])) // close if string(c.buf[0:5]) == "close" { _, err = unix.Write(c.fd, []byte(`Bye bye buddy`)) if err != nil { log.Fatal("close: ", err) } err = unix.Close(c.fd) if err != nil { log.Fatal("close: ", err) } counter.mu.Lock() counter.num = counter.num - 1 counter.mu.Unlock() return } } }(connInfo, counter) } }
func (s *Socket) Write(p []byte) (int, error) { s.wmu.Lock() defer s.wmu.Unlock() n, err := unix.Write(s.fd, p) return n, errors.Wrap(err, "can't write hci socket") }
// ReadPassword reads characters from the input until press Enter or until // fill in the given slice. // // Only reads characters that include letters, marks, numbers, punctuation, // and symbols from Unicode categories L, M, N, P, S, besides of the // ASCII space character. // Ctrl-C interrumpts, and backspace removes the last character read. // // Returns the number of bytes read. func ReadPassword(password []byte) (n int, err error) { ter, err := New() if err != nil { return 0, err } defer func() { err2 := ter.Restore() if err2 != nil && err == nil { err = err2 } }() if err = ter.RawMode(); err != nil { return 0, err } key := make([]byte, 4) // In-memory representation of a rune. lenPassword := 0 // Number of characters read. if PasswordShadowed { rand.Seed(int64(time.Now().Nanosecond())) } L: for { n, err = unix.Read(InputFD, key) if err != nil { return 0, err } if n == 1 { switch key[0] { case sys.K_RETURN: break L case sys.K_BACK: if lenPassword != 0 { lenPassword-- password[lenPassword] = 0 } continue case sys.K_CTRL_C: unix.Write(unix.Stdout, _CTRL_C) // Clean data stored, if any. for i, v := range password { if v == 0 { break } password[i] = 0 } return 0, nil } } char, _ := utf8.DecodeRune(key) if unicode.IsPrint(char) { password[lenPassword] = key[0] // Only want a character by key lenPassword++ if PasswordShadowed { unix.Write(unix.Stdout, bytes.Repeat(_SHADOW_CHAR, rand.Intn(3)+1)) } if lenPassword == len(password) { break } } } unix.Write(unix.Stdout, _RETURN) n = lenPassword return }