ogle/probe/net.go - debug - Git at Google

 // Copyright 2014 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.

 // TODO: Document the protocol once it settles.

 package probe

 import (
 	"errors"
 	"io" // Used only for the definitions of the various interfaces and errors.
 	"net"

 	"golang.org/x/debug/ogle/socket"
 )

 var (
 	tracing   = false
 	listening = make(chan struct{})
 )

 // init starts a listener and leaves it in the background waiting for connections.
 func init() {
 	go demon()
 }

 // demon answers consecutive connection requests and starts a server to manage each one.
 // The server runs in the same goroutine as the demon, so a new connection cannot be
 // established until the previous one is completed.
 func demon() {
 	listener, err := socket.Listen()
 	close(listening)
 	if err != nil {
 		trace("listen:", err)
 		return
 	}
 	trace("listening")
 	for {
 		conn, err := listener.Accept()
 		if err != nil {
 			trace("accept", err)
 			continue
 		}
 		trace("accepted a connection")
 		serve(conn)
 		conn.Close()
 	}
 }

 // stringer is the same as fmt.Stringer. We redefine it here to avoid pulling in fmt.
 type stringer interface {
 	String() string
 }

 func printHex(b byte) {
 	const hex = "0123456789ABCDEF"
 	b1, b0 := b>>4&0xF, b&0xF
 	print(hex[b1:b1+1], hex[b0:b0+1])
 }

 // trace is a simple version of println that is enabled by the tracing boolean.
 func trace(args ...interface{}) {
 	if !tracing {
 		return
 	}
 	print("ogle demon: ")
 	for i, arg := range args {
 		if i > 0 {
 			print(" ")
 		}
 		// A little help. Built-in print isn't very capable.
 		switch arg := arg.(type) {
 		case stringer:
 			print(arg.String())
 		case error:
 			print(arg.Error())
 		case []byte:
 			print("[")
 			for i := range arg {
 				if i > 0 {
 					print(" ")
 				}
 				printHex(arg[i])
 			}
 			print("]")
 		case int:
 			print(arg)
 		case string:
 			print(arg)
 		case uintptr:
 			print("0x")
 			for i := ptrSize - 1; i >= 0; i-- {
 				printHex(byte(arg >> uint(8*i)))
 			}
 		default:
 			print(arg)
 		}
 	}
 	print("\n")
 }

 func serve(conn net.Conn) {
 	const (
 		bufSize = 1 << 16
 	)
 	var buf [bufSize]byte
 	network := &pipe{
 		rw: conn,
 	}
 	for {
 		// One message per loop.
 		n, err := network.Read(buf[:1])
 		if n != 1 || err != nil {
 			return
 		}
 		switch buf[0] {
 		case 'r':
 			// Read: ['r', address, size] => [0, size, size bytes]
 			u, err := network.readUintptr()
 			if err != nil {
 				return
 			}
 			n, err := network.readInt()
 			if err != nil {
 				return
 			}
 			if !validRead(u, n) {
 				trace("read", err)
 				network.error("invalid read address")
 				continue
 			}
 			network.sendReadResponse(u, n)
 		default:
 			// TODO: shut down connection?
 			trace("unknown message type:", buf[0])
 		}
 	}
 }

 // pipe is a buffered network connection (actually just a reader/writer) that
 // implements Read and ReadByte as well as readFull.
 // It also has support routines to make it easier to read and write
 // network messages.
 type pipe struct {
 	rw      io.ReadWriter
 	pos     int
 	end     int
 	oneByte [1]byte
 	buf     [4096]byte
 }

 // readFull fills the argument slice with data from the wire. If it cannot fill the
 // slice, it returns an error.
 // TODO: unused for now; write will need it.
 func (p *pipe) readFull(buf []byte) error {
 	for len(buf) > 0 {
 		n, err := p.rw.Read(buf)
 		if n == len(buf) {
 			return nil
 		}
 		if err != nil {
 			if err == io.EOF {
 				err = io.ErrUnexpectedEOF
 			}
 			return err
 		}
 		if n == 0 {
 			return io.EOF
 		}
 		buf = buf[n:]
 	}
 	return nil
 }

 // Read satisfies io.Reader.
 func (p *pipe) Read(buf []byte) (int, error) {
 	n := len(buf)
 	if p.end == p.pos {
 		p.pos = 0
 		// Read from network
 		var err error
 		p.end, err = p.rw.Read(p.buf[:])
 		if err != nil {
 			trace("read:", err)
 			return p.end, err
 		}
 		if p.end == 0 {
 			trace("read: eof")
 			return p.end, io.EOF
 		}
 	}
 	if n > p.end-p.pos {
 		n = p.end - p.pos
 	}
 	copy(buf, p.buf[p.pos:p.pos+n])
 	p.pos += n
 	return n, nil
 }

 // ReadByte satisfies io.ByteReader.
 func (p *pipe) ReadByte() (byte, error) {
 	_, err := p.Read(p.oneByte[:])
 	return p.oneByte[0], err
 }

 // readUintptr reads a varint-encoded uinptr value from the connection.
 func (p *pipe) readUintptr() (uintptr, error) {
 	u, err := readUvarint(p)
 	if err != nil {
 		trace("read uintptr:", err)
 		return 0, err
 	}
 	if u > uint64(^uintptr(0)) {
 		trace("read uintptr: overflow")
 		return 0, err
 	}
 	return uintptr(u), nil
 }

 var intOverflow = errors.New("ogle probe: varint overflows int")

 // readInt reads an varint-encoded int value from the connection.
 // The transported value is always a uint64; this routine
 // verifies that it fits in an int.
 func (p *pipe) readInt() (int, error) {
 	u, err := readUvarint(p)
 	if err != nil {
 		trace("read int:", err)
 		return 0, err
 	}
 	// Does it fit in an int?
 	if u > maxInt {
 		trace("int overflow")
 		return 0, intOverflow
 	}
 	return int(u), nil
 }

 // error writes an error message to the connection.
 // The format is [size, size bytes].
 func (p *pipe) error(msg string) {
 	// A zero-length message is problematic. It should never arise, but be safe.
 	if len(msg) == 0 {
 		msg = "undefined error"
 	}
 	// Truncate if necessary. Extremely unlikely.
 	if len(msg) > len(p.buf)-maxVarintLen64 {
 		msg = msg[:len(p.buf)-maxVarintLen64]
 	}
 	n := putUvarint(p.buf[:], uint64(len(msg)))
 	n += copy(p.buf[n:], msg)
 	_, err := p.rw.Write(p.buf[:n])
 	if err != nil {
 		trace("write:", err)
 		// TODO: shut down connection?
 	}
 }

 // sendReadResponse sends a read response to the connection.
 // The format is [0, size, size bytes].
 func (p *pipe) sendReadResponse(addr uintptr, size int) {
 	trace("sendRead:", addr, size)
 	m := 0
 	m += putUvarint(p.buf[m:], 0)            // No error.
 	m += putUvarint(p.buf[m:], uint64(size)) // Number of bytes to follow.
 	for m > 0 || size > 0 {
 		n := len(p.buf) - m
 		if n > size {
 			n = size
 		}
 		if !read(addr, p.buf[m:m+n]) {
 			trace("copy error")
 			// TODO: shut down connection?
 			// TODO: for now, continue delivering data. We said we would.
 		}
 		_, err := p.rw.Write(p.buf[:m+n])
 		if err != nil {
 			trace("write:", err)
 			// TODO: shut down connection?
 		}
 		addr += uintptr(n)
 		size -= n
 		// Next time we can use the whole buffer.
 		m = 0
 	}
 }
	// Copyright 2014 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.

	// TODO: Document the protocol once it settles.

	package probe

	import (
	"errors"
	"io" // Used only for the definitions of the various interfaces and errors.
	"net"

	"golang.org/x/debug/ogle/socket"
	)

	var (
	tracing = false
	listening = make(chan struct{})
	)

	// init starts a listener and leaves it in the background waiting for connections.
	func init() {
	go demon()
	}

	// demon answers consecutive connection requests and starts a server to manage each one.
	// The server runs in the same goroutine as the demon, so a new connection cannot be
	// established until the previous one is completed.
	func demon() {
	listener, err := socket.Listen()
	close(listening)
	if err != nil {
	trace("listen:", err)
	return
	}
	trace("listening")
	for {
	conn, err := listener.Accept()
	if err != nil {
	trace("accept", err)
	continue
	}
	trace("accepted a connection")
	serve(conn)
	conn.Close()
	}
	}

	// stringer is the same as fmt.Stringer. We redefine it here to avoid pulling in fmt.
	type stringer interface {
	String() string
	}

	func printHex(b byte) {
	const hex = "0123456789ABCDEF"
	b1, b0 := b>>4&0xF, b&0xF
	print(hex[b1:b1+1], hex[b0:b0+1])
	}

	// trace is a simple version of println that is enabled by the tracing boolean.
	func trace(args ...interface{}) {
	if !tracing {
	return
	}
	print("ogle demon: ")
	for i, arg := range args {
	if i > 0 {
	print(" ")
	}
	// A little help. Built-in print isn't very capable.
	switch arg := arg.(type) {
	case stringer:
	print(arg.String())
	case error:
	print(arg.Error())
	case []byte:
	print("[")
	for i := range arg {
	if i > 0 {
	print(" ")
	}
	printHex(arg[i])
	}
	print("]")
	case int:
	print(arg)
	case string:
	print(arg)
	case uintptr:
	print("0x")
	for i := ptrSize - 1; i >= 0; i-- {
	printHex(byte(arg >> uint(8*i)))
	}
	default:
	print(arg)
	}
	}
	print("\n")
	}

	func serve(conn net.Conn) {
	const (
	bufSize = 1 << 16
	)
	var buf [bufSize]byte
	network := &pipe{
	rw: conn,
	}
	for {
	// One message per loop.
	n, err := network.Read(buf[:1])
	if n != 1 \|\| err != nil {
	return
	}
	switch buf[0] {
	case 'r':
	// Read: ['r', address, size] => [0, size, size bytes]
	u, err := network.readUintptr()
	if err != nil {
	return
	}
	n, err := network.readInt()
	if err != nil {
	return
	}
	if !validRead(u, n) {
	trace("read", err)
	network.error("invalid read address")
	continue
	}
	network.sendReadResponse(u, n)
	default:
	// TODO: shut down connection?
	trace("unknown message type:", buf[0])
	}
	}
	}

	// pipe is a buffered network connection (actually just a reader/writer) that
	// implements Read and ReadByte as well as readFull.
	// It also has support routines to make it easier to read and write
	// network messages.
	type pipe struct {
	rw io.ReadWriter
	pos int
	end int
	oneByte [1]byte
	buf [4096]byte
	}

	// readFull fills the argument slice with data from the wire. If it cannot fill the
	// slice, it returns an error.
	// TODO: unused for now; write will need it.
	func (p *pipe) readFull(buf []byte) error {
	for len(buf) > 0 {
	n, err := p.rw.Read(buf)
	if n == len(buf) {
	return nil
	}
	if err != nil {
	if err == io.EOF {
	err = io.ErrUnexpectedEOF
	}
	return err
	}
	if n == 0 {
	return io.EOF
	}
	buf = buf[n:]
	}
	return nil
	}

	// Read satisfies io.Reader.
	func (p *pipe) Read(buf []byte) (int, error) {
	n := len(buf)
	if p.end == p.pos {
	p.pos = 0
	// Read from network
	var err error
	p.end, err = p.rw.Read(p.buf[:])
	if err != nil {
	trace("read:", err)
	return p.end, err
	}
	if p.end == 0 {
	trace("read: eof")
	return p.end, io.EOF
	}
	}
	if n > p.end-p.pos {
	n = p.end - p.pos
	}
	copy(buf, p.buf[p.pos:p.pos+n])
	p.pos += n
	return n, nil
	}

	// ReadByte satisfies io.ByteReader.
	func (p *pipe) ReadByte() (byte, error) {
	_, err := p.Read(p.oneByte[:])
	return p.oneByte[0], err
	}

	// readUintptr reads a varint-encoded uinptr value from the connection.
	func (p *pipe) readUintptr() (uintptr, error) {
	u, err := readUvarint(p)
	if err != nil {
	trace("read uintptr:", err)
	return 0, err
	}
	if u > uint64(^uintptr(0)) {
	trace("read uintptr: overflow")
	return 0, err
	}
	return uintptr(u), nil
	}

	var intOverflow = errors.New("ogle probe: varint overflows int")

	// readInt reads an varint-encoded int value from the connection.
	// The transported value is always a uint64; this routine
	// verifies that it fits in an int.
	func (p *pipe) readInt() (int, error) {
	u, err := readUvarint(p)
	if err != nil {
	trace("read int:", err)
	return 0, err
	}
	// Does it fit in an int?
	if u > maxInt {
	trace("int overflow")
	return 0, intOverflow
	}
	return int(u), nil
	}

	// error writes an error message to the connection.
	// The format is [size, size bytes].
	func (p *pipe) error(msg string) {
	// A zero-length message is problematic. It should never arise, but be safe.
	if len(msg) == 0 {
	msg = "undefined error"
	}
	// Truncate if necessary. Extremely unlikely.
	if len(msg) > len(p.buf)-maxVarintLen64 {
	msg = msg[:len(p.buf)-maxVarintLen64]
	}
	n := putUvarint(p.buf[:], uint64(len(msg)))
	n += copy(p.buf[n:], msg)
	_, err := p.rw.Write(p.buf[:n])
	if err != nil {
	trace("write:", err)
	// TODO: shut down connection?
	}
	}

	// sendReadResponse sends a read response to the connection.
	// The format is [0, size, size bytes].
	func (p *pipe) sendReadResponse(addr uintptr, size int) {
	trace("sendRead:", addr, size)
	m := 0
	m += putUvarint(p.buf[m:], 0) // No error.
	m += putUvarint(p.buf[m:], uint64(size)) // Number of bytes to follow.
	for m > 0 \|\| size > 0 {
	n := len(p.buf) - m
	if n > size {
	n = size
	}
	if !read(addr, p.buf[m:m+n]) {
	trace("copy error")
	// TODO: shut down connection?
	// TODO: for now, continue delivering data. We said we would.
	}
	_, err := p.rw.Write(p.buf[:m+n])
	if err != nil {
	trace("write:", err)
	// TODO: shut down connection?
	}
	addr += uintptr(n)
	size -= n
	// Next time we can use the whole buffer.
	m = 0
	}
	}