| package npipe |
| |
| //sys createNamedPipe(name *uint16, openMode uint32, pipeMode uint32, maxInstances uint32, outBufSize uint32, inBufSize uint32, defaultTimeout uint32, sa *syscall.SecurityAttributes) (handle syscall.Handle, err error) [failretval==syscall.InvalidHandle] = CreateNamedPipeW |
| //sys connectNamedPipe(handle syscall.Handle, overlapped *syscall.Overlapped) (err error) = ConnectNamedPipe |
| //sys disconnectNamedPipe(handle syscall.Handle) (err error) = DisconnectNamedPipe |
| //sys waitNamedPipe(name *uint16, timeout uint32) (err error) = WaitNamedPipeW |
| //sys createEvent(sa *syscall.SecurityAttributes, manualReset bool, initialState bool, name *uint16) (handle syscall.Handle, err error) [failretval==syscall.InvalidHandle] = CreateEventW |
| //sys getOverlappedResult(handle syscall.Handle, overlapped *syscall.Overlapped, transferred *uint32, wait bool) (err error) = GetOverlappedResult |
| //sys cancelIoEx(handle syscall.Handle, overlapped *syscall.Overlapped) (err error) = CancelIoEx |
| |
| import ( |
| "fmt" |
| "io" |
| "net" |
| "sync" |
| "syscall" |
| "time" |
| ) |
| |
| const ( |
| // openMode |
| pipe_access_duplex = 0x3 |
| pipe_access_inbound = 0x1 |
| pipe_access_outbound = 0x2 |
| |
| // openMode write flags |
| file_flag_first_pipe_instance = 0x00080000 |
| file_flag_write_through = 0x80000000 |
| file_flag_overlapped = 0x40000000 |
| |
| // openMode ACL flags |
| write_dac = 0x00040000 |
| write_owner = 0x00080000 |
| access_system_security = 0x01000000 |
| |
| // pipeMode |
| pipe_type_byte = 0x0 |
| pipe_type_message = 0x4 |
| |
| // pipeMode read mode flags |
| pipe_readmode_byte = 0x0 |
| pipe_readmode_message = 0x2 |
| |
| // pipeMode wait mode flags |
| pipe_wait = 0x0 |
| pipe_nowait = 0x1 |
| |
| // pipeMode remote-client mode flags |
| pipe_accept_remote_clients = 0x0 |
| pipe_reject_remote_clients = 0x8 |
| |
| pipe_unlimited_instances = 255 |
| |
| nmpwait_wait_forever = 0xFFFFFFFF |
| |
| // the two not-an-errors below occur if a client connects to the pipe between |
| // the server's CreateNamedPipe and ConnectNamedPipe calls. |
| error_no_data syscall.Errno = 0xE8 |
| error_pipe_connected syscall.Errno = 0x217 |
| error_pipe_busy syscall.Errno = 0xE7 |
| error_sem_timeout syscall.Errno = 0x79 |
| |
| error_bad_pathname syscall.Errno = 0xA1 |
| error_invalid_name syscall.Errno = 0x7B |
| |
| error_io_incomplete syscall.Errno = 0x3e4 |
| ) |
| |
| var _ net.Conn = (*PipeConn)(nil) |
| var _ net.Listener = (*PipeListener)(nil) |
| |
| // ErrClosed is the error returned by PipeListener.Accept when Close is called |
| // on the PipeListener. |
| var ErrClosed = PipeError{"Pipe has been closed.", false} |
| |
| // PipeError is an error related to a call to a pipe |
| type PipeError struct { |
| msg string |
| timeout bool |
| } |
| |
| // Error implements the error interface |
| func (e PipeError) Error() string { |
| return e.msg |
| } |
| |
| // Timeout implements net.AddrError.Timeout() |
| func (e PipeError) Timeout() bool { |
| return e.timeout |
| } |
| |
| // Temporary implements net.AddrError.Temporary() |
| func (e PipeError) Temporary() bool { |
| return false |
| } |
| |
| // Dial connects to a named pipe with the given address. If the specified pipe is not available, |
| // it will wait indefinitely for the pipe to become available. |
| // |
| // The address must be of the form \\.\\pipe\<name> for local pipes and \\<computer>\pipe\<name> |
| // for remote pipes. |
| // |
| // Dial will return a PipeError if you pass in a badly formatted pipe name. |
| // |
| // Examples: |
| // // local pipe |
| // conn, err := Dial(`\\.\pipe\mypipename`) |
| // |
| // // remote pipe |
| // conn, err := Dial(`\\othercomp\pipe\mypipename`) |
| func Dial(address string) (*PipeConn, error) { |
| for { |
| conn, err := dial(address, nmpwait_wait_forever) |
| if err == nil { |
| return conn, nil |
| } |
| if isPipeNotReady(err) { |
| <-time.After(100 * time.Millisecond) |
| continue |
| } |
| return nil, err |
| } |
| } |
| |
| // DialTimeout acts like Dial, but will time out after the duration of timeout |
| func DialTimeout(address string, timeout time.Duration) (*PipeConn, error) { |
| deadline := time.Now().Add(timeout) |
| |
| now := time.Now() |
| for now.Before(deadline) { |
| millis := uint32(deadline.Sub(now) / time.Millisecond) |
| conn, err := dial(address, millis) |
| if err == nil { |
| return conn, nil |
| } |
| if err == error_sem_timeout { |
| // This is WaitNamedPipe's timeout error, so we know we're done |
| return nil, PipeError{fmt.Sprintf( |
| "Timed out waiting for pipe '%s' to come available", address), true} |
| } |
| if isPipeNotReady(err) { |
| left := deadline.Sub(time.Now()) |
| retry := 100 * time.Millisecond |
| if left > retry { |
| <-time.After(retry) |
| } else { |
| <-time.After(left - time.Millisecond) |
| } |
| now = time.Now() |
| continue |
| } |
| return nil, err |
| } |
| return nil, PipeError{fmt.Sprintf( |
| "Timed out waiting for pipe '%s' to come available", address), true} |
| } |
| |
| // isPipeNotReady checks the error to see if it indicates the pipe is not ready |
| func isPipeNotReady(err error) bool { |
| // Pipe Busy means another client just grabbed the open pipe end, |
| // and the server hasn't made a new one yet. |
| // File Not Found means the server hasn't created the pipe yet. |
| // Neither is a fatal error. |
| |
| return err == syscall.ERROR_FILE_NOT_FOUND || err == error_pipe_busy |
| } |
| |
| // newOverlapped creates a structure used to track asynchronous |
| // I/O requests that have been issued. |
| func newOverlapped() (*syscall.Overlapped, error) { |
| event, err := createEvent(nil, true, true, nil) |
| if err != nil { |
| return nil, err |
| } |
| return &syscall.Overlapped{HEvent: event}, nil |
| } |
| |
| // waitForCompletion waits for an asynchronous I/O request referred to by overlapped to complete. |
| // This function returns the number of bytes transferred by the operation and an error code if |
| // applicable (nil otherwise). |
| func waitForCompletion(handle syscall.Handle, overlapped *syscall.Overlapped) (uint32, error) { |
| _, err := syscall.WaitForSingleObject(overlapped.HEvent, syscall.INFINITE) |
| if err != nil { |
| return 0, err |
| } |
| var transferred uint32 |
| err = getOverlappedResult(handle, overlapped, &transferred, true) |
| return transferred, err |
| } |
| |
| // dial is a helper to initiate a connection to a named pipe that has been started by a server. |
| // The timeout is only enforced if the pipe server has already created the pipe, otherwise |
| // this function will return immediately. |
| func dial(address string, timeout uint32) (*PipeConn, error) { |
| name, err := syscall.UTF16PtrFromString(string(address)) |
| if err != nil { |
| return nil, err |
| } |
| // If at least one instance of the pipe has been created, this function |
| // will wait timeout milliseconds for it to become available. |
| // It will return immediately regardless of timeout, if no instances |
| // of the named pipe have been created yet. |
| // If this returns with no error, there is a pipe available. |
| if err := waitNamedPipe(name, timeout); err != nil { |
| if err == error_bad_pathname { |
| // badly formatted pipe name |
| return nil, badAddr(address) |
| } |
| return nil, err |
| } |
| pathp, err := syscall.UTF16PtrFromString(address) |
| if err != nil { |
| return nil, err |
| } |
| handle, err := syscall.CreateFile(pathp, syscall.GENERIC_READ|syscall.GENERIC_WRITE, |
| uint32(syscall.FILE_SHARE_READ|syscall.FILE_SHARE_WRITE), nil, syscall.OPEN_EXISTING, |
| syscall.FILE_FLAG_OVERLAPPED, 0) |
| if err != nil { |
| return nil, err |
| } |
| return &PipeConn{handle: handle, addr: PipeAddr(address)}, nil |
| } |
| |
| // Listen returns a new PipeListener that will listen on a pipe with the given |
| // address. The address must be of the form \\.\pipe\<name> |
| // |
| // Listen will return a PipeError for an incorrectly formatted pipe name. |
| func Listen(address string) (*PipeListener, error) { |
| handle, err := createPipe(address, true) |
| if err == error_invalid_name { |
| return nil, badAddr(address) |
| } |
| if err != nil { |
| return nil, err |
| } |
| |
| return &PipeListener{ |
| addr: PipeAddr(address), |
| handle: handle, |
| }, nil |
| } |
| |
| // PipeListener is a named pipe listener. Clients should typically |
| // use variables of type net.Listener instead of assuming named pipe. |
| type PipeListener struct { |
| mu sync.Mutex |
| |
| addr PipeAddr |
| handle syscall.Handle |
| closed bool |
| |
| // acceptHandle contains the current handle waiting for |
| // an incoming connection or nil. |
| acceptHandle syscall.Handle |
| // acceptOverlapped is set before waiting on a connection. |
| // If not waiting, it is nil. |
| acceptOverlapped *syscall.Overlapped |
| } |
| |
| // Accept implements the Accept method in the net.Listener interface; it |
| // waits for the next call and returns a generic net.Conn. |
| func (l *PipeListener) Accept() (net.Conn, error) { |
| c, err := l.AcceptPipe() |
| for err == error_no_data { |
| // Ignore clients that connect and immediately disconnect. |
| c, err = l.AcceptPipe() |
| } |
| if err != nil { |
| return nil, err |
| } |
| return c, nil |
| } |
| |
| // AcceptPipe accepts the next incoming call and returns the new connection. |
| // It might return an error if a client connected and immediately cancelled |
| // the connection. |
| func (l *PipeListener) AcceptPipe() (*PipeConn, error) { |
| if l == nil { |
| return nil, syscall.EINVAL |
| } |
| |
| l.mu.Lock() |
| defer l.mu.Unlock() |
| |
| if l.addr == "" || l.closed { |
| return nil, syscall.EINVAL |
| } |
| |
| // the first time we call accept, the handle will have been created by the Listen |
| // call. This is to prevent race conditions where the client thinks the server |
| // isn't listening because it hasn't actually called create yet. After the first time, we'll |
| // have to create a new handle each time |
| handle := l.handle |
| if handle == 0 { |
| var err error |
| handle, err = createPipe(string(l.addr), false) |
| if err != nil { |
| return nil, err |
| } |
| } else { |
| l.handle = 0 |
| } |
| |
| overlapped, err := newOverlapped() |
| if err != nil { |
| return nil, err |
| } |
| defer syscall.CloseHandle(overlapped.HEvent) |
| err = connectNamedPipe(handle, overlapped) |
| if err == nil || err == error_pipe_connected { |
| return &PipeConn{handle: handle, addr: l.addr}, nil |
| } |
| |
| if err == error_io_incomplete || err == syscall.ERROR_IO_PENDING { |
| l.acceptOverlapped = overlapped |
| l.acceptHandle = handle |
| // unlock here so close can function correctly while we wait (we'll |
| // get relocked via the defer below, before the original defer |
| // unlock happens.) |
| l.mu.Unlock() |
| defer func() { |
| l.mu.Lock() |
| l.acceptOverlapped = nil |
| l.acceptHandle = 0 |
| // unlock is via defer above. |
| }() |
| _, err = waitForCompletion(handle, overlapped) |
| } |
| if err == syscall.ERROR_OPERATION_ABORTED { |
| // Return error compatible to net.Listener.Accept() in case the |
| // listener was closed. |
| return nil, ErrClosed |
| } |
| if err != nil { |
| return nil, err |
| } |
| return &PipeConn{handle: handle, addr: l.addr}, nil |
| } |
| |
| // Close stops listening on the address. |
| // Already Accepted connections are not closed. |
| func (l *PipeListener) Close() error { |
| l.mu.Lock() |
| defer l.mu.Unlock() |
| |
| if l.closed { |
| return nil |
| } |
| l.closed = true |
| if l.handle != 0 { |
| err := disconnectNamedPipe(l.handle) |
| if err != nil { |
| return err |
| } |
| err = syscall.CloseHandle(l.handle) |
| if err != nil { |
| return err |
| } |
| l.handle = 0 |
| } |
| if l.acceptOverlapped != nil && l.acceptHandle != 0 { |
| // Cancel the pending IO. This call does not block, so it is safe |
| // to hold onto the mutex above. |
| if err := cancelIoEx(l.acceptHandle, l.acceptOverlapped); err != nil { |
| return err |
| } |
| err := syscall.CloseHandle(l.acceptOverlapped.HEvent) |
| if err != nil { |
| return err |
| } |
| l.acceptOverlapped.HEvent = 0 |
| err = syscall.CloseHandle(l.acceptHandle) |
| if err != nil { |
| return err |
| } |
| l.acceptHandle = 0 |
| } |
| return nil |
| } |
| |
| // Addr returns the listener's network address, a PipeAddr. |
| func (l *PipeListener) Addr() net.Addr { return l.addr } |
| |
| // PipeConn is the implementation of the net.Conn interface for named pipe connections. |
| type PipeConn struct { |
| handle syscall.Handle |
| addr PipeAddr |
| |
| // these aren't actually used yet |
| readDeadline *time.Time |
| writeDeadline *time.Time |
| } |
| |
| type iodata struct { |
| n uint32 |
| err error |
| } |
| |
| // completeRequest looks at iodata to see if a request is pending. If so, it waits for it to either complete or to |
| // abort due to hitting the specified deadline. Deadline may be set to nil to wait forever. If no request is pending, |
| // the content of iodata is returned. |
| func (c *PipeConn) completeRequest(data iodata, deadline *time.Time, overlapped *syscall.Overlapped) (int, error) { |
| if data.err == error_io_incomplete || data.err == syscall.ERROR_IO_PENDING { |
| var timer <-chan time.Time |
| if deadline != nil { |
| if timeDiff := deadline.Sub(time.Now()); timeDiff > 0 { |
| timer = time.After(timeDiff) |
| } |
| } |
| done := make(chan iodata) |
| go func() { |
| n, err := waitForCompletion(c.handle, overlapped) |
| done <- iodata{n, err} |
| }() |
| select { |
| case data = <-done: |
| case <-timer: |
| syscall.CancelIoEx(c.handle, overlapped) |
| data = iodata{0, timeout(c.addr.String())} |
| } |
| } |
| // Windows will produce ERROR_BROKEN_PIPE upon closing |
| // a handle on the other end of a connection. Go RPC |
| // expects an io.EOF error in this case. |
| if data.err == syscall.ERROR_BROKEN_PIPE { |
| data.err = io.EOF |
| } |
| return int(data.n), data.err |
| } |
| |
| // Read implements the net.Conn Read method. |
| func (c *PipeConn) Read(b []byte) (int, error) { |
| // Use ReadFile() rather than Read() because the latter |
| // contains a workaround that eats ERROR_BROKEN_PIPE. |
| overlapped, err := newOverlapped() |
| if err != nil { |
| return 0, err |
| } |
| defer syscall.CloseHandle(overlapped.HEvent) |
| var n uint32 |
| err = syscall.ReadFile(c.handle, b, &n, overlapped) |
| return c.completeRequest(iodata{n, err}, c.readDeadline, overlapped) |
| } |
| |
| // Write implements the net.Conn Write method. |
| func (c *PipeConn) Write(b []byte) (int, error) { |
| overlapped, err := newOverlapped() |
| if err != nil { |
| return 0, err |
| } |
| defer syscall.CloseHandle(overlapped.HEvent) |
| var n uint32 |
| err = syscall.WriteFile(c.handle, b, &n, overlapped) |
| return c.completeRequest(iodata{n, err}, c.writeDeadline, overlapped) |
| } |
| |
| // Close closes the connection. |
| func (c *PipeConn) Close() error { |
| return syscall.CloseHandle(c.handle) |
| } |
| |
| // LocalAddr returns the local network address. |
| func (c *PipeConn) LocalAddr() net.Addr { |
| return c.addr |
| } |
| |
| // RemoteAddr returns the remote network address. |
| func (c *PipeConn) RemoteAddr() net.Addr { |
| // not sure what to do here, we don't have remote addr.... |
| return c.addr |
| } |
| |
| // SetDeadline implements the net.Conn SetDeadline method. |
| // Note that timeouts are only supported on Windows Vista/Server 2008 and above |
| func (c *PipeConn) SetDeadline(t time.Time) error { |
| c.SetReadDeadline(t) |
| c.SetWriteDeadline(t) |
| return nil |
| } |
| |
| // SetReadDeadline implements the net.Conn SetReadDeadline method. |
| // Note that timeouts are only supported on Windows Vista/Server 2008 and above |
| func (c *PipeConn) SetReadDeadline(t time.Time) error { |
| c.readDeadline = &t |
| return nil |
| } |
| |
| // SetWriteDeadline implements the net.Conn SetWriteDeadline method. |
| // Note that timeouts are only supported on Windows Vista/Server 2008 and above |
| func (c *PipeConn) SetWriteDeadline(t time.Time) error { |
| c.writeDeadline = &t |
| return nil |
| } |
| |
| // PipeAddr represents the address of a named pipe. |
| type PipeAddr string |
| |
| // Network returns the address's network name, "pipe". |
| func (a PipeAddr) Network() string { return "pipe" } |
| |
| // String returns the address of the pipe |
| func (a PipeAddr) String() string { |
| return string(a) |
| } |
| |
| // createPipe is a helper function to make sure we always create pipes |
| // with the same arguments, since subsequent calls to create pipe need |
| // to use the same arguments as the first one. If first is set, fail |
| // if the pipe already exists. |
| func createPipe(address string, first bool) (syscall.Handle, error) { |
| n, err := syscall.UTF16PtrFromString(address) |
| if err != nil { |
| return 0, err |
| } |
| mode := uint32(pipe_access_duplex | syscall.FILE_FLAG_OVERLAPPED) |
| if first { |
| mode |= file_flag_first_pipe_instance |
| } |
| return createNamedPipe(n, |
| mode, |
| pipe_type_byte, |
| pipe_unlimited_instances, |
| 512, 512, 0, nil) |
| } |
| |
| func badAddr(addr string) PipeError { |
| return PipeError{fmt.Sprintf("Invalid pipe address '%s'.", addr), false} |
| } |
| func timeout(addr string) PipeError { |
| return PipeError{fmt.Sprintf("Pipe IO timed out waiting for '%s'", addr), true} |
| } |