src/pkg/xgb/xgb.go - go - Git at Google

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

 // The XGB package implements the X11 core protocol.
 // It is based on XCB: http://xcb.freedesktop.org/
 package xgb

 import (
 	"fmt";
 	"io";
 	"net";
 	"os";
 	"strconv";
 	"strings";
 )

 // A Conn represents a connection to an X server.
 // Only one goroutine should use a Conn's methods at a time.
 type Conn struct {
 	conn		net.Conn;
 	nextId		Id;
 	nextCookie	Cookie;
 	replies		map[Cookie][]byte;
 	events		queue;
 	err		os.Error;
 	defaultScreen	int;
 	scratch		[32]byte;
 	Setup		SetupInfo;
 }

 // Id is used for all X identifiers, such as windows, pixmaps, and GCs.
 type Id uint32

 // Cookies are the sequence numbers used to pair replies up with their requests
 type Cookie uint16

 type Keysym uint32
 type Timestamp uint32

 // Event is an interface that can contain any of the events returned by the server.
 // Use a type assertion switch to extract the Event structs.
 type Event interface{}

 // Error contains protocol errors returned to us by the X server.
 type Error struct {
 	Detail	uint8;
 	Major	uint8;
 	Minor	uint16;
 	Cookie	Cookie;
 	Id	Id;
 }

 func (e *Error) String() string {
 	return fmt.Sprintf("Bad%s (major=%d minor=%d cookie=%d id=0x%x)",
 		errorNames[e.Detail], e.Major, e.Minor, e.Cookie, e.Id)
 }

 // NewID generates a new unused ID for use with requests like CreateWindow.
 func (c *Conn) NewId() Id {
 	id := c.nextId;
 	// TODO: handle ID overflow
 	c.nextId++;
 	return id;
 }

 // Pad a length to align on 4 bytes.
 func pad(n int) int	{ return (n + 3) & ^3 }

 func put16(buf []byte, v uint16) {
 	buf[0] = byte(v);
 	buf[1] = byte(v >> 8);
 }

 func put32(buf []byte, v uint32) {
 	buf[0] = byte(v);
 	buf[1] = byte(v >> 8);
 	buf[2] = byte(v >> 16);
 	buf[3] = byte(v >> 24);
 }

 func get16(buf []byte) uint16 {
 	v := uint16(buf[0]);
 	v |= uint16(buf[1]) << 8;
 	return v;
 }

 func get32(buf []byte) uint32 {
 	v := uint32(buf[0]);
 	v |= uint32(buf[1]) << 8;
 	v |= uint32(buf[2]) << 16;
 	v |= uint32(buf[3]) << 32;
 	return v;
 }

 // Voodoo to count the number of bits set in a value list mask.
 func popCount(mask0 int) int {
 	mask := uint32(mask0);
 	n := 0;
 	for i := uint32(0); i < 32; i++ {
 		if mask&(1<<i) != 0 {
 			n++
 		}
 	}
 	return n;
 }

 // A simple queue used to stow away events.
 type queue struct {
 	data	[][]byte;
 	a, b	int;
 }

 func (q *queue) queue(item []byte) {
 	if q.b == len(q.data) {
 		if q.a > 0 {
 			copy(q.data, q.data[q.a:q.b]);
 			q.a, q.b = 0, q.b-q.a;
 		} else {
 			newData := make([][]byte, (len(q.data)*3)/2);
 			copy(newData, q.data);
 			q.data = newData;
 		}
 	}
 	q.data[q.b] = item;
 	q.b++;
 }

 func (q *queue) dequeue() []byte {
 	if q.a < q.b {
 		item := q.data[q.a];
 		q.a++;
 		return item;
 	}
 	return nil;
 }

 // sendRequest sends a request to the server and return its associated sequence number, or cookie.
 // It is only used to send the fixed length portion of the request, sendBytes and friends are used
 // to send any additional variable length data.
 func (c *Conn) sendRequest(buf []byte) Cookie {
 	if _, err := c.conn.Write(buf); err != nil {
 		fmt.Fprintf(os.Stderr, "x protocol write error: %s\n", err);
 		c.err = err;
 	}
 	cookie := c.nextCookie;
 	c.nextCookie++;
 	return cookie;
 }

 // sendPadding sends enough bytes to align to a 4-byte border.
 // It is used to pad the variable length data that is used with some requests.
 func (c *Conn) sendPadding(n int) {
 	x := pad(n) - n;
 	if x > 0 {
 		_, err := c.conn.Write(c.scratch[0:x]);
 		if err != nil {
 			fmt.Fprintf(os.Stderr, "x protocol write error: %s\n", err);
 			c.err = err;
 		}
 	}
 }

 // sendBytes sends a byte slice as variable length data after the fixed portion of a request,
 // along with any necessary padding.
 func (c *Conn) sendBytes(buf []byte) {
 	if _, err := c.conn.Write(buf); err != nil {
 		fmt.Fprintf(os.Stderr, "x protocol write error: %s\n", err);
 		c.err = err;
 	}
 	c.sendPadding(len(buf));
 }

 func (c *Conn) sendString(str string)	{ c.sendBytes(strings.Bytes(str)) }

 // sendUInt32s sends a list of 32-bit integers as variable length data.
 func (c *Conn) sendUInt32List(list []uint32) {
 	buf := make([]byte, len(list)*4);
 	for i := 0; i < len(list); i++ {
 		put32(buf[i*4:], list[i])
 	}
 	c.sendBytes(buf);
 }

 func (c *Conn) sendIdList(list []Id, length int) {
 	buf := make([]byte, length*4);
 	for i := 0; i < length; i++ {
 		put32(buf[i*4:], uint32(list[i]))
 	}
 	c.sendBytes(buf);
 }

 func (c *Conn) sendKeysymList(list []Keysym, length int) {
 	buf := make([]byte, length*4);
 	for i := 0; i < length; i++ {
 		put32(buf[i*4:], uint32(list[i]))
 	}
 	c.sendBytes(buf);
 }

 // readNextReply reads and processes the next server reply.
 // If it is a protocol error then it is returned as an Error.
 // Events are pushed onto the event queue and replies to requests
 // are stashed away in a map indexed by the sequence number.
 func (c *Conn) readNextReply() os.Error {
 	buf := make([]byte, 32);
 	if _, err := io.ReadFull(c.conn, buf); err != nil {
 		fmt.Fprintf(os.Stderr, "x protocol read error: %s\n", err);
 		return err;
 	}

 	switch buf[0] {
 	case 0:
 		err := &Error{
 			Detail: buf[1],
 			Cookie: Cookie(get16(buf[2:])),
 			Id: Id(get32(buf[4:])),
 			Minor: get16(buf[8:]),
 			Major: buf[10],
 		};
 		fmt.Fprintf(os.Stderr, "x protocol error: %s\n", err);
 		return err;

 	case 1:
 		seq := Cookie(get16(buf[2:]));
 		size := get32(buf[4:]);
 		if size > 0 {
 			bigbuf := make([]byte, 32+size*4, 32+size*4);
 			copy(bigbuf[0:32], buf);
 			if _, err := io.ReadFull(c.conn, bigbuf[32:]); err != nil {
 				fmt.Fprintf(os.Stderr, "x protocol read error: %s\n", err);
 				return err;
 			}
 			c.replies[seq] = bigbuf;
 		} else {
 			c.replies[seq] = buf
 		}

 	default:
 		c.events.queue(buf)
 	}

 	return nil;
 }

 // waitForReply looks for a reply in the map indexed by sequence number.
 // If the reply is not in the map it will block while reading replies from the server
 // until the reply is found or an error occurs.
 func (c *Conn) waitForReply(cookie Cookie) ([]byte, os.Error) {
 	for {
 		if reply, ok := c.replies[cookie]; ok {
 			c.replies[cookie] = reply, false;
 			return reply, nil;
 		}
 		if err := c.readNextReply(); err != nil {
 			return nil, err
 		}
 	}
 	panic("unreachable");
 }

 // WaitForEvent returns the next event from the server.
 // It will block until an event is available.
 func (c *Conn) WaitForEvent() (Event, os.Error) {
 	for {
 		if reply := c.events.dequeue(); reply != nil {
 			return parseEvent(reply)
 		}
 		if err := c.readNextReply(); err != nil {
 			return nil, err
 		}
 	}
 	panic("unreachable");
 }

 // PollForEvent returns the next event from the server if one is available in the internal queue.
 // It will not read from the connection, so you must call WaitForEvent to receive new events.
 // Only use this function to empty the queue without blocking.
 func (c *Conn) PollForEvent() (Event, os.Error) {
 	if reply := c.events.dequeue(); reply != nil {
 		return parseEvent(reply)
 	}
 	return nil, nil;
 }

 // Dial connects to the X server given in the 'display' string.
 // The display string is typically taken from os.Getenv("DISPLAY").
 func Dial(display string) (*Conn, os.Error) {
 	var err os.Error;

 	c := new(Conn);

 	if display[0] == '/' {
 		c.conn, err = net.Dial("unix", "", display);
 		if err != nil {
 			fmt.Printf("cannot connect: %v\n", err);
 			return nil, err;
 		}
 	} else {
 		parts := strings.Split(display, ":", 2);
 		host := parts[0];
 		port := 0;
 		if len(parts) > 1 {
 			parts = strings.Split(parts[1], ".", 2);
 			port, _ = strconv.Atoi(parts[0]);
 			if len(parts) > 1 {
 				c.defaultScreen, _ = strconv.Atoi(parts[1])
 			}
 		}
 		display = fmt.Sprintf("%s:%d", host, port+6000);
 		c.conn, err = net.Dial("tcp", "", display);
 		if err != nil {
 			fmt.Printf("cannot connect: %v\n", err);
 			return nil, err;
 		}
 	}

 	// TODO: get these from .Xauthority
 	var authName, authData []byte;

 	buf := make([]byte, 12+pad(len(authName))+pad(len(authData)));
 	buf[0] = 'l';
 	buf[1] = 0;
 	put16(buf[2:], 11);
 	put16(buf[4:], 0);
 	put16(buf[6:], uint16(len(authName)));
 	put16(buf[8:], uint16(len(authData)));
 	put16(buf[10:], 0);
 	copy(buf[12:], authName);
 	copy(buf[12+pad(len(authName)):], authData);
 	if _, err = c.conn.Write(buf); err != nil {
 		return nil, err
 	}

 	head := make([]byte, 8);
 	if _, err = io.ReadFull(c.conn, head[0:8]); err != nil {
 		return nil, err
 	}
 	code := head[0];
 	reasonLen := head[1];
 	major := get16(head[2:]);
 	minor := get16(head[4:]);
 	dataLen := get16(head[6:]);

 	if major != 11 || minor != 0 {
 		return nil, os.NewError(fmt.Sprintf("x protocol version mismatch: %d.%d", major, minor))
 	}

 	buf = make([]byte, int(dataLen)*4+8, int(dataLen)*4+8);
 	copy(buf, head);
 	if _, err = io.ReadFull(c.conn, buf[8:]); err != nil {
 		return nil, err
 	}

 	if code == 0 {
 		reason := buf[8 : 8+reasonLen];
 		return nil, os.NewError(fmt.Sprintf("x protocol authentication refused: %s", string(reason)));
 	}

 	getSetupInfo(buf, &c.Setup);

 	if c.defaultScreen >= len(c.Setup.Roots) {
 		c.defaultScreen = 0
 	}

 	c.nextId = Id(c.Setup.ResourceIdBase);
 	c.nextCookie = 1;
 	c.replies = make(map[Cookie][]byte);
 	c.events = queue{make([][]byte, 100), 0, 0};
 	return c, nil;
 }

 // Close closes the connection to the X server.
 func (c *Conn) Close()	{ c.conn.Close() }

 // DefaultScreen returns the Screen info for the default screen, which is
 // 0 or the one given in the display argument to Dial.
 func (c *Conn) DefaultScreen() *ScreenInfo	{ return &c.Setup.Roots[c.defaultScreen] }


 // ClientMessageData holds the data from a client message,
 // duplicated in three forms because Go doesn't have unions.
 type ClientMessageData struct {
 	Data8	[20]byte;
 	Data16	[10]uint16;
 	Data32	[5]uint32;
 }

 func getClientMessageData(b []byte, v *ClientMessageData) int {
 	copy(&v.Data8, b);
 	for i := 0; i < 10; i++ {
 		v.Data16[i] = get16(b[i*2:])
 	}
 	for i := 0; i < 5; i++ {
 		v.Data32[i] = get32(b[i*4:])
 	}
 	return 20;
 }
	// Copyright 2009 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.

	// The XGB package implements the X11 core protocol.
	// It is based on XCB: http://xcb.freedesktop.org/
	package xgb

	import (
	"fmt";
	"io";
	"net";
	"os";
	"strconv";
	"strings";
	)

	// A Conn represents a connection to an X server.
	// Only one goroutine should use a Conn's methods at a time.
	type Conn struct {
	conn net.Conn;
	nextId Id;
	nextCookie Cookie;
	replies map[Cookie][]byte;
	events queue;
	err os.Error;
	defaultScreen int;
	scratch [32]byte;
	Setup SetupInfo;
	}

	// Id is used for all X identifiers, such as windows, pixmaps, and GCs.
	type Id uint32

	// Cookies are the sequence numbers used to pair replies up with their requests
	type Cookie uint16

	type Keysym uint32
	type Timestamp uint32

	// Event is an interface that can contain any of the events returned by the server.
	// Use a type assertion switch to extract the Event structs.
	type Event interface{}

	// Error contains protocol errors returned to us by the X server.
	type Error struct {
	Detail uint8;
	Major uint8;
	Minor uint16;
	Cookie Cookie;
	Id Id;
	}

	func (e *Error) String() string {
	return fmt.Sprintf("Bad%s (major=%d minor=%d cookie=%d id=0x%x)",
	errorNames[e.Detail], e.Major, e.Minor, e.Cookie, e.Id)
	}

	// NewID generates a new unused ID for use with requests like CreateWindow.
	func (c *Conn) NewId() Id {
	id := c.nextId;
	// TODO: handle ID overflow
	c.nextId++;
	return id;
	}

	// Pad a length to align on 4 bytes.
	func pad(n int) int { return (n + 3) & ^3 }

	func put16(buf []byte, v uint16) {
	buf[0] = byte(v);
	buf[1] = byte(v >> 8);
	}

	func put32(buf []byte, v uint32) {
	buf[0] = byte(v);
	buf[1] = byte(v >> 8);
	buf[2] = byte(v >> 16);
	buf[3] = byte(v >> 24);
	}

	func get16(buf []byte) uint16 {
	v := uint16(buf[0]);
	v \|= uint16(buf[1]) << 8;
	return v;
	}

	func get32(buf []byte) uint32 {
	v := uint32(buf[0]);
	v \|= uint32(buf[1]) << 8;
	v \|= uint32(buf[2]) << 16;
	v \|= uint32(buf[3]) << 32;
	return v;
	}

	// Voodoo to count the number of bits set in a value list mask.
	func popCount(mask0 int) int {
	mask := uint32(mask0);
	n := 0;
	for i := uint32(0); i < 32; i++ {
	if mask&(1<<i) != 0 {
	n++
	}
	}
	return n;
	}

	// A simple queue used to stow away events.
	type queue struct {
	data [][]byte;
	a, b int;
	}

	func (q *queue) queue(item []byte) {
	if q.b == len(q.data) {
	if q.a > 0 {
	copy(q.data, q.data[q.a:q.b]);
	q.a, q.b = 0, q.b-q.a;
	} else {
	newData := make([][]byte, (len(q.data)*3)/2);
	copy(newData, q.data);
	q.data = newData;
	}
	}
	q.data[q.b] = item;
	q.b++;
	}

	func (q *queue) dequeue() []byte {
	if q.a < q.b {
	item := q.data[q.a];
	q.a++;
	return item;
	}
	return nil;
	}

	// sendRequest sends a request to the server and return its associated sequence number, or cookie.
	// It is only used to send the fixed length portion of the request, sendBytes and friends are used
	// to send any additional variable length data.
	func (c *Conn) sendRequest(buf []byte) Cookie {
	if _, err := c.conn.Write(buf); err != nil {
	fmt.Fprintf(os.Stderr, "x protocol write error: %s\n", err);
	c.err = err;
	}
	cookie := c.nextCookie;
	c.nextCookie++;
	return cookie;
	}

	// sendPadding sends enough bytes to align to a 4-byte border.
	// It is used to pad the variable length data that is used with some requests.
	func (c *Conn) sendPadding(n int) {
	x := pad(n) - n;
	if x > 0 {
	_, err := c.conn.Write(c.scratch[0:x]);
	if err != nil {
	fmt.Fprintf(os.Stderr, "x protocol write error: %s\n", err);
	c.err = err;
	}
	}
	}

	// sendBytes sends a byte slice as variable length data after the fixed portion of a request,
	// along with any necessary padding.
	func (c *Conn) sendBytes(buf []byte) {
	if _, err := c.conn.Write(buf); err != nil {
	fmt.Fprintf(os.Stderr, "x protocol write error: %s\n", err);
	c.err = err;
	}
	c.sendPadding(len(buf));
	}

	func (c *Conn) sendString(str string) { c.sendBytes(strings.Bytes(str)) }

	// sendUInt32s sends a list of 32-bit integers as variable length data.
	func (c *Conn) sendUInt32List(list []uint32) {
	buf := make([]byte, len(list)*4);
	for i := 0; i < len(list); i++ {
	put32(buf[i*4:], list[i])
	}
	c.sendBytes(buf);
	}

	func (c *Conn) sendIdList(list []Id, length int) {
	buf := make([]byte, length*4);
	for i := 0; i < length; i++ {
	put32(buf[i*4:], uint32(list[i]))
	}
	c.sendBytes(buf);
	}

	func (c *Conn) sendKeysymList(list []Keysym, length int) {
	buf := make([]byte, length*4);
	for i := 0; i < length; i++ {
	put32(buf[i*4:], uint32(list[i]))
	}
	c.sendBytes(buf);
	}

	// readNextReply reads and processes the next server reply.
	// If it is a protocol error then it is returned as an Error.
	// Events are pushed onto the event queue and replies to requests
	// are stashed away in a map indexed by the sequence number.
	func (c *Conn) readNextReply() os.Error {
	buf := make([]byte, 32);
	if _, err := io.ReadFull(c.conn, buf); err != nil {
	fmt.Fprintf(os.Stderr, "x protocol read error: %s\n", err);
	return err;
	}

	switch buf[0] {
	case 0:
	err := &Error{
	Detail: buf[1],
	Cookie: Cookie(get16(buf[2:])),
	Id: Id(get32(buf[4:])),
	Minor: get16(buf[8:]),
	Major: buf[10],
	};
	fmt.Fprintf(os.Stderr, "x protocol error: %s\n", err);
	return err;

	case 1:
	seq := Cookie(get16(buf[2:]));
	size := get32(buf[4:]);
	if size > 0 {
	bigbuf := make([]byte, 32+size4, 32+size4);
	copy(bigbuf[0:32], buf);
	if _, err := io.ReadFull(c.conn, bigbuf[32:]); err != nil {
	fmt.Fprintf(os.Stderr, "x protocol read error: %s\n", err);
	return err;
	}
	c.replies[seq] = bigbuf;
	} else {
	c.replies[seq] = buf
	}

	default:
	c.events.queue(buf)
	}

	return nil;
	}

	// waitForReply looks for a reply in the map indexed by sequence number.
	// If the reply is not in the map it will block while reading replies from the server
	// until the reply is found or an error occurs.
	func (c *Conn) waitForReply(cookie Cookie) ([]byte, os.Error) {
	for {
	if reply, ok := c.replies[cookie]; ok {
	c.replies[cookie] = reply, false;
	return reply, nil;
	}
	if err := c.readNextReply(); err != nil {
	return nil, err
	}
	}
	panic("unreachable");
	}

	// WaitForEvent returns the next event from the server.
	// It will block until an event is available.
	func (c *Conn) WaitForEvent() (Event, os.Error) {
	for {
	if reply := c.events.dequeue(); reply != nil {
	return parseEvent(reply)
	}
	if err := c.readNextReply(); err != nil {
	return nil, err
	}
	}
	panic("unreachable");
	}

	// PollForEvent returns the next event from the server if one is available in the internal queue.
	// It will not read from the connection, so you must call WaitForEvent to receive new events.
	// Only use this function to empty the queue without blocking.
	func (c *Conn) PollForEvent() (Event, os.Error) {
	if reply := c.events.dequeue(); reply != nil {
	return parseEvent(reply)
	}
	return nil, nil;
	}

	// Dial connects to the X server given in the 'display' string.
	// The display string is typically taken from os.Getenv("DISPLAY").
	func Dial(display string) (*Conn, os.Error) {
	var err os.Error;

	c := new(Conn);

	if display[0] == '/' {
	c.conn, err = net.Dial("unix", "", display);
	if err != nil {
	fmt.Printf("cannot connect: %v\n", err);
	return nil, err;
	}
	} else {
	parts := strings.Split(display, ":", 2);
	host := parts[0];
	port := 0;
	if len(parts) > 1 {
	parts = strings.Split(parts[1], ".", 2);
	port, _ = strconv.Atoi(parts[0]);
	if len(parts) > 1 {
	c.defaultScreen, _ = strconv.Atoi(parts[1])
	}
	}
	display = fmt.Sprintf("%s:%d", host, port+6000);
	c.conn, err = net.Dial("tcp", "", display);
	if err != nil {
	fmt.Printf("cannot connect: %v\n", err);
	return nil, err;
	}
	}

	// TODO: get these from .Xauthority
	var authName, authData []byte;

	buf := make([]byte, 12+pad(len(authName))+pad(len(authData)));
	buf[0] = 'l';
	buf[1] = 0;
	put16(buf[2:], 11);
	put16(buf[4:], 0);
	put16(buf[6:], uint16(len(authName)));
	put16(buf[8:], uint16(len(authData)));
	put16(buf[10:], 0);
	copy(buf[12:], authName);
	copy(buf[12+pad(len(authName)):], authData);
	if _, err = c.conn.Write(buf); err != nil {
	return nil, err
	}

	head := make([]byte, 8);
	if _, err = io.ReadFull(c.conn, head[0:8]); err != nil {
	return nil, err
	}
	code := head[0];
	reasonLen := head[1];
	major := get16(head[2:]);
	minor := get16(head[4:]);
	dataLen := get16(head[6:]);

	if major != 11 \|\| minor != 0 {
	return nil, os.NewError(fmt.Sprintf("x protocol version mismatch: %d.%d", major, minor))
	}

	buf = make([]byte, int(dataLen)4+8, int(dataLen)4+8);
	copy(buf, head);
	if _, err = io.ReadFull(c.conn, buf[8:]); err != nil {
	return nil, err
	}

	if code == 0 {
	reason := buf[8 : 8+reasonLen];
	return nil, os.NewError(fmt.Sprintf("x protocol authentication refused: %s", string(reason)));
	}

	getSetupInfo(buf, &c.Setup);

	if c.defaultScreen >= len(c.Setup.Roots) {
	c.defaultScreen = 0
	}

	c.nextId = Id(c.Setup.ResourceIdBase);
	c.nextCookie = 1;
	c.replies = make(map[Cookie][]byte);
	c.events = queue{make([][]byte, 100), 0, 0};
	return c, nil;
	}

	// Close closes the connection to the X server.
	func (c *Conn) Close() { c.conn.Close() }

	// DefaultScreen returns the Screen info for the default screen, which is
	// 0 or the one given in the display argument to Dial.
	func (c Conn) DefaultScreen() ScreenInfo { return &c.Setup.Roots[c.defaultScreen] }


	// ClientMessageData holds the data from a client message,
	// duplicated in three forms because Go doesn't have unions.
	type ClientMessageData struct {
	Data8 [20]byte;
	Data16 [10]uint16;
	Data32 [5]uint32;
	}

	func getClientMessageData(b []byte, v *ClientMessageData) int {
	copy(&v.Data8, b);
	for i := 0; i < 10; i++ {
	v.Data16[i] = get16(b[i*2:])
	}
	for i := 0; i < 5; i++ {
	v.Data32[i] = get32(b[i*4:])
	}
	return 20;
	}