zorldo

conn.go (4607B)

---

 package xgb
 
 /*
 conn.go contains a couple of functions that do some real dirty work related
 to the initial connection handshake with X.
 
 This code is largely unmodified from the original XGB package that I forked.
 */
 
 import (
 	"errors"
 	"fmt"
 	"io"
 	"net"
 	"os"
 	"strconv"
 	"strings"
 )
 
 // connect connects to the X server given in the 'display' string,
 // and does all the necessary setup handshaking.
 // If 'display' is empty it will be taken from os.Getenv("DISPLAY").
 // Note that you should read and understand the "Connection Setup" of the
 // X Protocol Reference Manual before changing this function:
 // http://goo.gl/4zGQg
 func (c *Conn) connect(display string) error {
 	err := c.dial(display)
 	if err != nil {
 		return err
 	}
 
 	return c.postConnect()
 }
 
 // connect init from to the net.Conn,
 func (c *Conn) connectNet(netConn net.Conn) error {
 	c.conn = netConn
 	return c.postConnect()
 }
 
 // do the postConnect action after Conn get it's underly net.Conn
 func (c *Conn) postConnect() error {
 	// Get authentication data
 	authName, authData, err := readAuthority(c.host, c.display)
 	noauth := false
 	if err != nil {
 		Logger.Printf("Could not get authority info: %v", err)
 		Logger.Println("Trying connection without authority info...")
 		authName = ""
 		authData = []byte{}
 		noauth = true
 	}
 
 	// Assume that the authentication protocol is "MIT-MAGIC-COOKIE-1".
 	if !noauth && (authName != "MIT-MAGIC-COOKIE-1" || len(authData) != 16) {
 		return errors.New("unsupported auth protocol " + authName)
 	}
 
 	buf := make([]byte, 12+Pad(len(authName))+Pad(len(authData)))
 	buf[0] = 0x6c
 	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:], []byte(authName))
 	copy(buf[12+Pad(len(authName)):], authData)
 	if _, err = c.conn.Write(buf); err != nil {
 		return err
 	}
 
 	head := make([]byte, 8)
 	if _, err = io.ReadFull(c.conn, head[0:8]); err != nil {
 		return 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 fmt.Errorf("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 err
 	}
 
 	if code == 0 {
 		reason := buf[8 : 8+reasonLen]
 		return fmt.Errorf("x protocol authentication refused: %s",
 			string(reason))
 	}
 
 	// Unfortunately, it isn't really feasible to read the setup bytes here,
 	// since the code to do so is in a different package.
 	// Users must call 'xproto.Setup(X)' to get the setup info.
 	c.SetupBytes = buf
 
 	// But also read stuff that we *need* to get started.
 	c.setupResourceIdBase = Get32(buf[12:])
 	c.setupResourceIdMask = Get32(buf[16:])
 
 	return nil
 }
 
 // dial initializes the actual net connection with X.
 func (c *Conn) dial(display string) error {
 	if len(display) == 0 {
 		display = os.Getenv("DISPLAY")
 	}
 
 	display0 := display
 	if len(display) == 0 {
 		return errors.New("empty display string")
 	}
 
 	colonIdx := strings.LastIndex(display, ":")
 	if colonIdx < 0 {
 		return errors.New("bad display string: " + display0)
 	}
 
 	var protocol, socket string
 
 	if display[0] == '/' {
 		socket = display[0:colonIdx]
 	} else {
 		slashIdx := strings.LastIndex(display, "/")
 		if slashIdx >= 0 {
 			protocol = display[0:slashIdx]
 			c.host = display[slashIdx+1 : colonIdx]
 		} else {
 			c.host = display[0:colonIdx]
 		}
 	}
 
 	display = display[colonIdx+1 : len(display)]
 	if len(display) == 0 {
 		return errors.New("bad display string: " + display0)
 	}
 
 	var scr string
 	dotIdx := strings.LastIndex(display, ".")
 	if dotIdx < 0 {
 		c.display = display[0:]
 	} else {
 		c.display = display[0:dotIdx]
 		scr = display[dotIdx+1:]
 	}
 
 	var err error
 	c.DisplayNumber, err = strconv.Atoi(c.display)
 	if err != nil || c.DisplayNumber < 0 {
 		return errors.New("bad display string: " + display0)
 	}
 
 	if len(scr) != 0 {
 		c.DefaultScreen, err = strconv.Atoi(scr)
 		if err != nil {
 			return errors.New("bad display string: " + display0)
 		}
 	}
 
 	// Connect to server
 	if len(socket) != 0 {
 		c.conn, err = net.Dial("unix", socket+":"+c.display)
 	} else if len(c.host) != 0 && c.host != "unix" {
 		if protocol == "" {
 			protocol = "tcp"
 		}
 		c.conn, err = net.Dial(protocol,
 			c.host+":"+strconv.Itoa(6000+c.DisplayNumber))
 	} else {
 		c.host = ""
 		c.conn, err = net.Dial("unix", "/tmp/.X11-unix/X"+c.display)
 	}
 
 	if err != nil {
 		return errors.New("cannot connect to " + display0 + ": " + err.Error())
 	}
 	return nil
 }