diff --git a/src/pkg/exp/draw/x11/Makefile b/src/pkg/exp/draw/x11/Makefile new file mode 100644 index 0000000000..808d5f0b25 --- /dev/null +++ b/src/pkg/exp/draw/x11/Makefile @@ -0,0 +1,12 @@ +# 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. + +include $(GOROOT)/src/Make.$(GOARCH) + +TARG=exp/draw/x11 +GOFILES=\ + auth.go\ + conn.go\ + +include $(GOROOT)/src/Make.pkg diff --git a/src/pkg/exp/draw/x11/auth.go b/src/pkg/exp/draw/x11/auth.go new file mode 100644 index 0000000000..8a90bf3642 --- /dev/null +++ b/src/pkg/exp/draw/x11/auth.go @@ -0,0 +1,102 @@ +// 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. + +package x11 + +import ( + "bufio"; + "io"; + "os"; +) + +// Reads the DISPLAY environment variable, and returns the "12" in ":12.0". +func getDisplay() string { + d := os.Getenv("DISPLAY"); + if len(d) < 1 || d[0] != ':' { + return "" + } + i := 1; + for ; i < len(d); i++ { + if d[i] < '0' || d[i] > '9' { + break + } + } + return d[1:i]; +} + +// Reads a big-endian uint16 from r, using b as a scratch buffer. +func readU16BE(r io.Reader, b []byte) (uint16, os.Error) { + _, err := io.ReadFull(r, b[0:2]); + if err != nil { + return 0, err + } + return uint16(b[0])<<8 + uint16(b[1]), nil; +} + +// Reads a length-prefixed string from r, using b as a scratch buffer. +func readStr(r io.Reader, b []byte) (s string, err os.Error) { + n, err := readU16BE(r, b); + if err != nil { + return + } + if int(n) > len(b) { + return s, os.NewError("Xauthority entry too long for buffer") + } + _, err = io.ReadFull(r, b[0:n]); + if err != nil { + return + } + return string(b[0:n]), nil; +} + +// Reads the ~/.Xauthority file and returns the name/data pair for the DISPLAY. +// b is a scratch buffer to use, and should be at least 256 bytes long (i.e. it should be able to hold a hostname). +func readAuth(b []byte) (name, data string, err os.Error) { + // As per /usr/include/X11/Xauth.h. + const familyLocal = 256; + + home := os.Getenv("HOME"); + if len(home) == 0 { + err = os.NewError("unknown HOME"); + return; + } + r, err := os.Open(home+"/.Xauthority", os.O_RDONLY, 0444); + if err != nil { + return + } + defer r.Close(); + br := bufio.NewReader(r); + + hostname, err := os.Hostname(); + if err != nil { + return + } + display := getDisplay(); + for { + family, err := readU16BE(br, b[0:2]); + if err != nil { + return + } + addr, err := readStr(br, b[0:]); + if err != nil { + return + } + disp, err := readStr(br, b[0:]); + if err != nil { + return + } + name0, err := readStr(br, b[0:]); + if err != nil { + return + } + data0, err := readStr(br, b[0:]); + if err != nil { + return + } + if family == familyLocal && addr == hostname && disp == display { + return name0, data0, nil + } + } + panic("unreachable"); +} diff --git a/src/pkg/exp/draw/x11/conn.go b/src/pkg/exp/draw/x11/conn.go new file mode 100644 index 0000000000..cb764d11c1 --- /dev/null +++ b/src/pkg/exp/draw/x11/conn.go @@ -0,0 +1,515 @@ +// 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. + +// This package implements an X11 backend for the exp/draw package. +// +// The X protocol specification is at ftp://ftp.x.org/pub/X11R7.0/doc/PDF/proto.pdf. +// A summary of the wire format can be found in XCB's xproto.xml. +package x11 + +// BUG(nigeltao): This is a toy library and not ready for production use. + +import ( + "bufio"; + "exp/draw"; + "image"; + "io"; + "net"; + "os"; +) + +type resID uint32 // X resource IDs. + +// TODO(nigeltao): Handle window resizes. +const ( + windowHeight = 600; + windowWidth = 800; +) + +type conn struct { + // TODO(nigeltao): Figure out which goroutine should be responsible for closing c, + // or if there is a race condition if one goroutine calls c.Close whilst another one + // is reading from r, or writing to w. + c io.Closer; + r *bufio.Reader; + w *bufio.Writer; + + gc, window, root, visual resID; + + img *image.RGBA; + kbd chan int; + mouse chan draw.Mouse; + resize chan bool; + quit chan bool; + mouseState draw.Mouse; + + buf [256]byte; // General purpose scratch buffer. + + flush chan bool; + flushBuf0 [24]byte; + flushBuf1 [4 * 1024]byte; +} + +// flusher runs in its own goroutine, serving both FlushImage calls directly from the exp/draw client +// and indirectly from X expose events. It paints c.img to the X server via PutImage requests. +func (c *conn) flusher() { + for { + _ = <-c.flush; + if closed(c.flush) { + return + } + + // Each X request has a 16-bit length (in terms of 4-byte units). To avoid going over + // this limit, we send PutImage for each row of the image, rather than trying to paint + // the entire image in one X request. This approach could easily be optimized (or the + // X protocol may have an escape sequence to delimit very large requests). + // TODO(nigeltao): See what XCB's xcb_put_image does in this situation. + w, h := c.img.Width(), c.img.Height(); + units := 6 + w; + if units > 0xffff || h > 0xffff { + // This window is too large for X. + close(c.flush); + return; + } + + c.flushBuf0[0] = 0x48; // PutImage opcode. + c.flushBuf0[1] = 0x02; // XCB_IMAGE_FORMAT_Z_PIXMAP. + c.flushBuf0[2] = uint8(units); + c.flushBuf0[3] = uint8(units >> 8); + setU32LE(c.flushBuf0[4:8], uint32(c.window)); + setU32LE(c.flushBuf0[8:12], uint32(c.gc)); + setU32LE(c.flushBuf0[12:16], 1<<16|uint32(w)); + c.flushBuf0[21] = 0x18; // depth = 24 bits. + + for y := 0; y < h; y++ { + setU32LE(c.flushBuf0[16:20], uint32(y<<16)); + _, err := c.w.Write(c.flushBuf0[0:24]); + if err != nil { + close(c.flush); + return; + } + for x := 0; x < w; { + nx := w - x; + if nx > len(c.flushBuf1)/4 { + nx = len(c.flushBuf1) / 4 + } + for i := 0; i < nx; i++ { + r, g, b, _ := c.img.At(x, y).RGBA(); + c.flushBuf1[4*i+0] = uint8(b >> 24); + c.flushBuf1[4*i+1] = uint8(g >> 24); + c.flushBuf1[4*i+2] = uint8(r >> 24); + x++; + } + _, err := c.w.Write(c.flushBuf1[0 : 4*nx]); + if err != nil { + close(c.flush); + return; + } + } + } + if c.w.Flush() != nil { + close(c.flush); + return; + } + } +} + +func (c *conn) Screen() draw.Image { return c.img } + +func (c *conn) FlushImage() { + // We do the send (the <- operator) in an expression context, rather than in + // a statement context, so that it does not block, and fails if the buffered + // channel is full (in which case there already is a flush request pending). + _ = c.flush <- false +} + +func (c *conn) KeyboardChan() <-chan int { return c.kbd } + +func (c *conn) MouseChan() <-chan draw.Mouse { return c.mouse } + +func (c *conn) ResizeChan() <-chan bool { return c.resize } + +func (c *conn) QuitChan() <-chan bool { return c.quit } + +// pumper runs in its own goroutine, reading X events and demuxing them over the kbd / mouse / resize / quit chans. +func (c *conn) pumper() { + for { + // X events are always 32 bytes long. + _, err := io.ReadFull(c.r, c.buf[0:32]); + if err != nil { + // TODO(nigeltao): should draw.Context expose err? + // TODO(nigeltao): should we do c.quit<-true? Should c.quit be a buffered channel? + // Or is c.quit only for non-exceptional closing (e.g. when the window manager destroys + // our window), and not for e.g. an I/O error? + break + } + switch c.buf[0] { + case 0x02, 0x03: // Key press, key release. + // BUG(nigeltao): Keycode to keysym mapping is not implemented. + + // The keycode is in c.buf[1], but as keymaps aren't implemented yet, we'll use the + // space character as a placeholder. + keysym := int(' '); + // TODO(nigeltao): Should we send KeyboardChan ints for Shift/Ctrl/Alt? Should Shift-A send + // the same int down the channel as the sent on just the A key? + // TODO(nigeltao): How should IME events (e.g. key presses that should generate CJK text) work? Or + // is that outside the scope of the draw.Context interface? + if c.buf[0] == 0x03 { + keysym = -keysym + } + c.kbd <- keysym; + case 0x04, 0x05: // Button press, button release. + mask := 1 << (c.buf[1] - 1); + if c.buf[0] == 0x04 { + c.mouseState.Buttons |= mask + } else { + c.mouseState.Buttons &^= mask + } + // TODO(nigeltao): update mouseState's timestamp. + c.mouse <- c.mouseState; + case 0x06: // Motion notify. + c.mouseState.Point.X = int(c.buf[25])<<8 | int(c.buf[24]); + c.mouseState.Point.Y = int(c.buf[27])<<8 | int(c.buf[26]); + // TODO(nigeltao): update mouseState's timestamp. + c.mouse <- c.mouseState; + case 0x0c: // Expose. + // A single user action could trigger multiple expose events (e.g. if moving another + // window with XShape'd rounded corners over our window). In that case, the X server + // will send a count (in bytes 16-17) of the number of additional expose events coming. + // We could parse each event for the (x, y, width, height) and maintain a minimal dirty + // rectangle, but for now, the simplest approach is to paint the entire window, when + // receiving the final event in the series. + count := int(c.buf[17])<<8 | int(c.buf[16]); + if count == 0 { + // TODO(nigeltao): Should we ignore the very first expose event? A freshly mapped window + // will trigger expose, but until the first c.FlushImage call, there's probably nothing to + // paint but black. For an 800x600 window, at 4 bytes per pixel, each repaint writes about + // 2MB over the socket. + c.FlushImage() + } + // TODO(nigeltao): Should we listen to DestroyNotify (0x11) and ResizeRequest (0x19) events? + // What about EnterNotify (0x07) and LeaveNotify (0x08)? + } + } + close(c.flush); + // TODO(nigeltao): Is this the right place for c.c.Close()? + // TODO(nigeltao): Should we explicitly close our kbd/mouse/resize/quit chans? +} + +// Authenticate ourselves with the X server. +func (c *conn) authenticate() os.Error { + key, value, err := readAuth(c.buf[0:]); + if err != nil { + return err + } + // Assume that the authentication protocol is "MIT-MAGIC-COOKIE-1". + if len(key) != 18 || len(value) != 16 { + return os.NewError("unsupported Xauth") + } + // 0x006c means little-endian. 0x000b, 0x0000 means X major version 11, minor version 0. + // 0x0012 and 0x0010 means the auth key and value have lenths 18 and 16. + // The final 0x0000 is padding, so that the string length is a multiple of 4. + _, err = io.WriteString(c.w, "\x6c\x00\x0b\x00\x00\x00\x12\x00\x10\x00\x00\x00"); + if err != nil { + return err + } + _, err = io.WriteString(c.w, key); + if err != nil { + return err + } + // Again, the 0x0000 is padding. + _, err = io.WriteString(c.w, "\x00\x00"); + if err != nil { + return err + } + _, err = io.WriteString(c.w, value); + if err != nil { + return err + } + err = c.w.Flush(); + if err != nil { + return err + } + return nil; +} + +// Reads a uint8 from r, using b as a scratch buffer. +func readU8(r io.Reader, b []byte) (uint8, os.Error) { + _, err := io.ReadFull(r, b[0:1]); + if err != nil { + return 0, err + } + return uint8(b[0]), nil; +} + +// Reads a little-endian uint16 from r, using b as a scratch buffer. +func readU16LE(r io.Reader, b []byte) (uint16, os.Error) { + _, err := io.ReadFull(r, b[0:2]); + if err != nil { + return 0, err + } + return uint16(b[0]) | uint16(b[1])<<8, nil; +} + +// Reads a little-endian uint32 from r, using b as a scratch buffer. +func readU32LE(r io.Reader, b []byte) (uint32, os.Error) { + _, err := io.ReadFull(r, b[0:4]); + if err != nil { + return 0, err + } + return uint32(b[0]) | uint32(b[1])<<8 | uint32(b[2])<<16 | uint32(b[3])<<24, nil; +} + +// Sets b[0:4] to be the big-endian representation of u. +func setU32LE(b []byte, u uint32) { + b[0] = byte((u >> 0) & 0xff); + b[1] = byte((u >> 8) & 0xff); + b[2] = byte((u >> 16) & 0xff); + b[3] = byte((u >> 24) & 0xff); +} + +// Check that we have an agreeable X pixmap Format. +func checkPixmapFormats(r io.Reader, b []byte, n int) (agree bool, err os.Error) { + for i := 0; i < n; i++ { + _, err = io.ReadFull(r, b[0:8]); + if err != nil { + return + } + // Byte 0 is depth, byte 1 is bits-per-pixel, byte 2 is scanline-pad, the rest (5) is padding. + if b[0] == 24 && b[1] == 32 { + agree = true + } + } + return; +} + +// Check that we have an agreeable X Depth (i.e. one that has an agreeable X VisualType). +func checkDepths(r io.Reader, b []byte, n int, visual uint32) (agree bool, err os.Error) { + for i := 0; i < n; i++ { + depth, err := readU16LE(r, b); + if err != nil { + return + } + depth &= 0xff; + visualsLen, err := readU16LE(r, b); + if err != nil { + return + } + // Ignore 4 bytes of padding. + _, err = io.ReadFull(r, b[0:4]); + if err != nil { + return + } + for j := 0; j < int(visualsLen); j++ { + // Read 24 bytes: visual(4), class(1), bits per rgb value(1), colormap entries(2), + // red mask(4), green mask(4), blue mask(4), padding(4). + v, err := readU32LE(r, b); + _, err = readU32LE(r, b); + rm, err := readU32LE(r, b); + gm, err := readU32LE(r, b); + bm, err := readU32LE(r, b); + _, err = readU32LE(r, b); + if err != nil { + return + } + if v == visual && rm == 0xff0000 && gm == 0xff00 && bm == 0xff && depth == 24 { + agree = true + } + } + } + return; +} + +// Check that we have an agreeable X Screen. +func checkScreens(r io.Reader, b []byte, n int) (root, visual uint32, err os.Error) { + for i := 0; i < n; i++ { + root0, err := readU32LE(r, b); + if err != nil { + return + } + // Ignore the next 7x4 bytes, which is: colormap, whitepixel, blackpixel, current input masks, + // width and height (pixels), width and height (mm), min and max installed maps. + _, err = io.ReadFull(r, b[0:28]); + if err != nil { + return + } + visual0, err := readU32LE(r, b); + if err != nil { + return + } + // Next 4 bytes: backing stores, save unders, root depth, allowed depths length. + x, err := readU32LE(r, b); + if err != nil { + return + } + nDepths := int(x >> 24); + agree, err := checkDepths(r, b, nDepths, visual0); + if err != nil { + return + } + if agree && root == 0 { + root = root0; + visual = visual0; + } + } + return; +} + +// Perform the protocol handshake with the X server, and ensure that the server provides a compatible Screen, Depth, etcetera. +func (c *conn) handshake() os.Error { + _, err := io.ReadFull(c.r, c.buf[0:8]); + if err != nil { + return err + } + // Byte 0:1 should be 1 (success), bytes 2:6 should be 0xb0000000 (major/minor version 11.0). + if c.buf[0] != 1 || c.buf[2] != 11 || c.buf[3] != 0 || c.buf[4] != 0 || c.buf[5] != 0 { + return os.NewError("unsupported X version") + } + // Ignore the release number. + _, err = io.ReadFull(c.r, c.buf[0:4]); + if err != nil { + return err + } + // Read the resource ID base. + resourceIdBase, err := readU32LE(c.r, c.buf[0:4]); + if err != nil { + return err + } + // Read the resource ID mask. + resourceIdMask, err := readU32LE(c.r, c.buf[0:4]); + if err != nil { + return err + } + if resourceIdMask < 256 { + return os.NewError("X resource ID mask is too small") + } + // Ignore the motion buffer size. + _, err = io.ReadFull(c.r, c.buf[0:4]); + if err != nil { + return err + } + // Read the vendor length. + vendorLen, err := readU16LE(c.r, c.buf[0:2]); + if err != nil { + return err + } + if vendorLen != 20 { + // For now, assume the vendor is "The X.Org Foundation". Supporting different + // vendors would require figuring out how much padding we need to read. + return os.NewError("unsupported X vendor") + } + // Read the maximum request length. + maxReqLen, err := readU16LE(c.r, c.buf[0:2]); + if err != nil { + return err + } + if maxReqLen != 0xffff { + return os.NewError("unsupported X maximum request length") + } + // Read the roots length. + rootsLen, err := readU8(c.r, c.buf[0:1]); + if err != nil { + return err + } + // Read the pixmap formats length. + pixmapFormatsLen, err := readU8(c.r, c.buf[0:1]); + if err != nil { + return err + } + // Ignore some things that we don't care about (totalling 30 bytes): + // imageByteOrder(1), bitmapFormatBitOrder(1), bitmapFormatScanlineUnit(1) bitmapFormatScanlinePad(1), + // minKeycode(1), maxKeycode(1), padding(4), vendor(20, hard-coded above). + _, err = io.ReadFull(c.r, c.buf[0:30]); + if err != nil { + return err + } + // Check that we have an agreeable pixmap format. + agree, err := checkPixmapFormats(c.r, c.buf[0:8], int(pixmapFormatsLen)); + if err != nil { + return err + } + if !agree { + return os.NewError("unsupported X pixmap formats") + } + // Check that we have an agreeable screen. + root, visual, err := checkScreens(c.r, c.buf[0:24], int(rootsLen)); + if err != nil { + return err + } + if root == 0 || visual == 0 { + return os.NewError("unsupported X screen") + } + c.gc = resID(resourceIdBase); + c.window = resID(resourceIdBase + 1); + c.root = resID(root); + c.visual = resID(visual); + return nil; +} + +// Returns a new draw.Context, backed by a newly created and mapped X11 window. +func NewWindow() (draw.Context, os.Error) { + display := getDisplay(); + if len(display) == 0 { + return nil, os.NewError("unsupported DISPLAY") + } + s, err := net.Dial("unix", "", "/tmp/.X11-unix/X"+display); + if err != nil { + return nil, err + } + c := new(conn); + c.c = s; + c.r = bufio.NewReader(s); + c.w = bufio.NewWriter(s); + err = c.authenticate(); + if err != nil { + return nil, err + } + err = c.handshake(); + if err != nil { + return nil, err + } + + // Now that we're connected, show a window, via three X protocol messages. + // First, create a graphics context (GC). + setU32LE(c.buf[0:4], 0x00060037); // 0x37 is the CreateGC opcode, and the message is 6 x 4 bytes long. + setU32LE(c.buf[4:8], uint32(c.gc)); + setU32LE(c.buf[8:12], uint32(c.root)); + setU32LE(c.buf[12:16], 0x00010004); // Bit 2 is XCB_GC_FOREGROUND, bit 16 is XCB_GC_GRAPHICS_EXPOSURES. + setU32LE(c.buf[16:20], 0x00000000); // The Foreground is black. + setU32LE(c.buf[20:24], 0x00000000); // GraphicsExposures' value is unused. + // Second, create the window. + setU32LE(c.buf[24:28], 0x000a0001); // 0x01 is the CreateWindow opcode, and the message is 10 x 4 bytes long. + setU32LE(c.buf[28:32], uint32(c.window)); + setU32LE(c.buf[32:36], uint32(c.root)); + setU32LE(c.buf[36:40], 0x00000000); // Initial (x, y) is (0, 0). + setU32LE(c.buf[40:44], windowHeight<<16|windowWidth); + setU32LE(c.buf[44:48], 0x00010000); // Border width is 0, XCB_WINDOW_CLASS_INPUT_OUTPUT is 1. + setU32LE(c.buf[48:52], uint32(c.visual)); + setU32LE(c.buf[52:56], 0x00000802); // Bit 1 is XCB_CW_BACK_PIXEL, bit 11 is XCB_CW_EVENT_MASK. + setU32LE(c.buf[56:60], 0x00000000); // The Back-Pixel is black. + setU32LE(c.buf[60:64], 0x0000804f); // Key/button press and release, pointer motion, and expose event masks. + // Third, map the window. + setU32LE(c.buf[64:68], 0x00020008); // 0x08 is the MapWindow opcode, and the message is 2 x 4 bytes long. + setU32LE(c.buf[68:72], uint32(c.window)); + // Write the bytes. + _, err = c.w.Write(c.buf[0:72]); + if err != nil { + return nil, err + } + err = c.w.Flush(); + if err != nil { + return nil, err + } + + c.img = image.NewRGBA(windowWidth, windowHeight); + // TODO(nigeltao): Should these channels be buffered? + c.kbd = make(chan int); + c.mouse = make(chan draw.Mouse); + c.resize = make(chan bool); + c.quit = make(chan bool); + c.flush = make(chan bool, 1); + go c.flusher(); + go c.pumper(); + return c, nil; +}