path: root/xgob.go

package xgob

import (
		"bufio"
		"bytes"
		"io"
		"net"
		"os"
		"strconv"
		"strings"
		"sync"
	   )

const X_TCP_PORT = 6000

type ConnectionBlock struct {
	Major, Minor uint16
	todo []byte
}

type Event struct {
	EventType	uint8
	Sent		bool
	Remainder	[31]byte
}

type Error struct {
	Sequence	uint64
	BadValue	uint32
	Minor		uint16
	Major		uint8
	Error		uint8
}

type Reply struct {
	Sequence	uint64
	Length		uint32
	Remainder	[]byte
	Aux			byte
}

type Connection struct {
	Setup				ConnectionBlock
	Event				chan Event
	conn				io.ReadWriteCloser
	reply				map[uint64]chan interface {}
	replyMutex			sync.Mutex
	lastRequestWritten	uint64
	lastSequenceRead	uint64
}

const events_before_readblock = 10000

func parse_display (name string) (host string, protocol string, display int, screen int) {
    if len(name) == 0 {
		name = os.Getenv("DISPLAY")
	}
    if len(name) == 0 {
        return
	}

    if !strings.HasPrefix(name, "/tmp/launch") {
		slash := strings.LastIndex(name, "/")
		if slash >= 0 {
			protocol = name[:slash]
			name = name[slash+1:]
		}
	}

	var err os.Error
	
    dot := strings.LastIndex(name, ".");
	if dot >= 0 {
		screen,err = strconv.Atoi(name[dot+1:])
		if err == nil {
			name = name[:dot]
		}
	}
    colon := strings.LastIndex(name, ":");
    if colon < 0 {
		return
	}
	display, err = strconv.Atoi(name[colon+1:])
	if err != nil {
		return
	}
	host = name[:colon]
	return
}

func open(host string, protocol string, display int) io.ReadWriteCloser {
	unix_base := "/tmp/.X11-unix/X";
	base := unix_base

	if strings.HasPrefix(host, "/tmp/launch") {
		base = host
		host = ""
		protocol = ""
	}

	if(len(host) > 0 || len(protocol) > 0) {
		if len(protocol) > 0 || "unix" == host { /* follow the old unix: rule */
			/* display specifies TCP */
			port := X_TCP_PORT + display;
			return open_tcp(host, protocol, port);
		}
	}

	var file string
	/* display specifies Unix socket */
	if strings.HasPrefix(base, "/tmp/launch") {
		file = base + ":" + strconv.Itoa(display)
	} else {
		file = base + strconv.Itoa(display)
	}

    return open_unix(protocol, file)
}

func open_tcp(host string, protocol string, port int) io.ReadWriteCloser {
	if len(protocol) > 0 && "tcp" != protocol && "inet" != protocol && "inet6" != protocol {
		return nil;
	}
	proto := "tcp"
	if protocol == "inet6" {
		proto = "tcp6"
	}

	if len(host) == 0 {
		host = "localhost"
	}

	conn, err := net.Dial(proto, "", host + ":" + strconv.Itoa(port))
	// TODO - remove
	if err != nil {
		println("TCP error ", err.String())
	}
	return conn
}

func open_unix(protocol string, file string) io.ReadWriteCloser {
	if len(protocol) > 0 && "unix" != protocol {
		return nil
	}

	conn, err := net.Dial(protocol, "", file)
	// TODO - remove
	if err != nil {
		println("Unix socket error ", err.String())
	}
	return conn
}

func Pad (i int) int {
	return (-i) & 3
}

func (c *Connection) write_setup (name string, data string) {
	buf := make([]byte, 0, 100)

	buf = append(buf, 'B')		// Big endian.
	buf = append(buf, 'l')
	buf = append(buf, 0, 11)	// X11
	buf = append(buf, 0, 0)		// .0
	buf = append(buf, byte((len(name) & 0xFF00) >> 8), byte(len(name) & 0xFF))
	buf = append(buf, byte((len(data) & 0xFF00) >> 8), byte(len(data) & 0xFF))
	buf = append(buf, 0, 0)		// pad

	if len(name) > 0 && len(data) > 0 {
		n := bytes.NewBufferString(name)
		buf = append(buf, n.Bytes()...)
		for i := 0; i < Pad(len(name)); i++ {
			buf = append(buf, 0)
		}
		n = bytes.NewBufferString(data)
		buf = append(buf, n.Bytes()...)
		for i := 0; i < Pad(len(data)); i++ {
			buf = append(buf, 0)
		}
	}

	c.conn.Write(buf)
}

func getUint16(in *bufio.Reader) uint16 {
	var rv uint16
	i, _ := in.ReadByte()
	rv = uint16(i) << 8
	i, _ = in.ReadByte()
	rv |= uint16(i)
	return rv
}

func getUint32(in *bufio.Reader) uint32 {
	var rv uint32
	i, _ := in.ReadByte()
	rv = uint32(i) << 24
	i, _ = in.ReadByte()
	rv |= uint32(i) << 16
	i, _ = in.ReadByte()
	rv |= uint32(i) << 8
	i, _ = in.ReadByte()
	rv |= uint32(i)
	return rv
}

func skipBytes (in *bufio.Reader, skip uint) {
	for i := uint(0); i < skip; i++ {
		_, _ = in.ReadByte()
	}
}

func readAll(in *bufio.Reader, buf []byte) {
	var read int
	len := len(buf)
	for read < len {
		input, err := in.Read(buf[read:])
		if err != nil {
			return
		}
		read += input
	}
}

func (c *Connection) read_setup(in *bufio.Reader) bool {
	status, _ := in.ReadByte()
	reason_len, _ := in.ReadByte()
	c.Setup.Major = getUint16(in)
	c.Setup.Minor = getUint16(in)
	len := getUint16(in)

	c.Setup.todo = make([]byte, len * 4)
	readAll(in, c.Setup.todo)

	switch status {
	case 0:
		println("Server refused connection because")
		println(bytes.NewBuffer(c.Setup.todo[:reason_len]).String())
	case 1:
		/* Success */
		return true
	case 2:
		println("Server requires authentication")
		println(bytes.NewBuffer(c.Setup.todo).String())
	default:
		panic("Unexpected return value from server " + strconv.Uitoa(uint(status)))
	}
	return false
}

func (c *Connection) fullSeq(seq uint16) uint64 {
	var fs uint64
	fs = (c.lastSequenceRead &^ 0xFFFF) | uint64(seq)
	if fs < c.lastSequenceRead {
		fs += 0x10000
	}
	return fs
}

func (c *Connection) postReply (seq uint64, reply interface{}) {
	c.replyMutex.Lock()
	defer c.replyMutex.Unlock()

	if c.reply[seq] == nil {
		println("Error: Unexpected sequence", seq)
		return
	}

	for i := c.lastSequenceRead; i < seq; i++ {
		c.reply[i] <- nil
		c.reply[i] = nil, false
	}
	c.reply[seq] <- reply
	c.lastSequenceRead = seq
}

func (c *Connection) read (in *bufio.Reader) {
	for {
		t, err := in.ReadByte()
		if err != nil {
			c.conn = nil
			return
		}

		switch t {
		case 0:
			var e Error
			e.Error, _ = in.ReadByte()
			e.Sequence = c.fullSeq(getUint16(in))
			e.BadValue = getUint32(in)
			e.Minor = getUint16(in)
			e.Major, _ = in.ReadByte()
			skipBytes(in, 20)
			c.postReply(e.Sequence, e)
		case 1:
			var r Reply
			r.Aux, _ = in.ReadByte()
			r.Sequence = c.fullSeq(getUint16(in))
			r.Length = getUint32(in)
			r.Remainder = make([]byte, r.Length * 4 + 24)
			readAll(in, r.Remainder)
			c.postReply(r.Sequence, r)
		default:
			var e Event
			e.EventType = t
			if t & 0x80 != 0 {
				e.EventType = t & 0x7F
				e.Sent = true
			}
			readAll(in, e.Remainder[:])
			c.Event <- e
		// TODO GenericEvent
		}
	}
}

func (c *Connection)connect_auth(name string, data string) {
	c.write_setup(name, data)
	in := bufio.NewReader(c.conn)
	if !c.read_setup(in) {
		c.Disconnect()
		return
	}
	c.Event = make (chan Event, events_before_readblock)
	c.reply = make (map [uint64]chan interface{})
	c.lastSequenceRead = 1			// Not really, but this prevents writing to a nil channel
	go c.read(in)
}

func Connect (dpy string) (conn *Connection, screen int) {
	host, proto, display, screen := parse_display(dpy)

	var c Connection
	c.conn = open(host, proto, display);

    if c.conn == nil {
		return
	}

	// TODO: name, data := c.get_auth_info()
	name, data := "", ""
	c.connect_auth(name, data);
	conn = &c
	return
}

func (c *Connection) Disconnect () {
	c.conn.Close()
	c.conn = nil
}

func (c *Connection) WriteMultiRequest (req []byte, expected int) chan interface{} {
	rv := make(chan interface {}, expected)

	if c == nil || c.conn == nil {
		return rv
	}

	c.replyMutex.Lock()
	defer c.replyMutex.Unlock()

	c.lastRequestWritten++
	c.reply[c.lastRequestWritten] = rv

	c.conn.Write(req)
	return rv
}

func (c *Connection) WriteRequest (req []byte) chan interface{} {
	return c.WriteMultiRequest(req, 1)
}

func (c *Connection) Flush () {
	// TODO buffer WriteRequest
}

func (c *Connection) HasError () bool {
	if c == nil || c.conn == nil {
		return true
	}
	return false
}