April 24, 2011

go-runas: call RPCs to yourself as a child dropping root

If you have a Go server running as root and want to run some of your code as adifferent user, it turns out that Go’s standard rpc package works wonderfully for this.

Here’s a fun hack of a library that makes this easy: go-runas

Usage, from example.go in that repo:

// ....

func main() {
    runas.Server.Register(&DemoService{})
    runas.MaybeRunChildServer()

    for _, user := range []string{"nobody", "daemon", "man", "syslog"} {
        var res WhoAmIResult
        client, err := runas.User(user)
        if err != nil {
            log.Printf("failed to get client for user %s: %v", user, err)
            continue
        }   
        client.Call("DemoService.WhoAmI", true, &res)
        log.Printf("user %s: %v", user, res)
    }
}

// This code runs as a different user, not root.
func (s *DemoService) WhoAmI(unused *bool, res *WhoAmIResult) os.Error {
    res.Uid = syscall.Getuid()
    res.Gid = syscall.Getgid()
    return nil
}

And the result:

$ 6g example.go && 6l -o example example.6 && sudo ./example
2011/04/22 12:14:57 user nobody: {65534 65534}
2011/04/22 12:14:57 user daemon: {1 1}
2011/04/22 12:14:57 user man: {6 12}
2011/04/22 12:14:57 user syslog: {101 103}

April 18, 2011

More informative printf-style debugging with closures

Brad sent me this neat piece of code that creates the function here that logs the current line to the console. Much easier and more informative than my usual println("a"), println("b"), etc. :–)

here := func() {
    _, file, line, _ := runtime.Caller(1)
    log.Printf("%s:%d", file, line)
}
here()
// some code
here()
// some more code
here()

April 5, 2011

Marshalling JSON data structures the quick-and-dirty way

It’s easy to marshal arbitrarly-structured JSON in Go. This example uses a locally-defined type m (within the function scope) to provide shorthand for map[string]interface{} so that you can quite naturally express complex JSON data structures.

type m map[string]interface{}
data := m{"data": m{"object": m{
    "type":    "note",
    "content": text,
    "attachments": []m{{
        "type":    "photo",
        "content": photoContent,
        "links": m{
            "enclosure": []m{{
                "href": photoURL,
                "type": "image/png",
            }},
        },
    }},
}}}
b, err := json.Marshal(data)

This works in a pinch, but more often than not you’ll want to create explicit Go data structures instead of using this trick.

March 23, 2011

Using defer to log return values from within the function

package main

import (
    "log"
    "os"
)

func foo(s string) (n int, err os.Error) {
    defer func() {          
        log.Printf("foo(%q) = %d, %v", s, n, err)
    }()                                     
    return 123, os.EOF                      
}

func main() {                                       
    foo("bar")                                      
}

Output:

2011/03/23 20:24:25 foo("bar") = 123, EOF

March 23, 2011

Making a []byte from a pointer

Another version of the previous post, but without creating the slice header manually. Very cute!

package main

import (
    "fmt"
    "unsafe"
)

func main() {
    p := &[...]byte{1, 2, 3, 4}
    b := (*[unsafe.Sizeof(*p)]byte)(unsafe.Pointer(p))[:]
    fmt.Printf("%x %T\n", b, b)
}

March 23, 2011

Making a []byte from a pointer

Manually building a slice header, filling in the pointer to a piece of data, and casting it to a []byte. Messy, but it works!

package main

import (
    "fmt"
    "reflect"
    "unsafe"
)

func main() {
    data := [...]byte{1, 2, 3, 4}
    h := &reflect.SliceHeader{
            uintptr(unsafe.Pointer(&data)),
            len(data),
            len(data),
    }
    b := *(*[]byte)(unsafe.Pointer(h))
    fmt.Printf("%x\n", b)
}

March 9, 2011

Hello, world

package main

import "fmt"

func main() {
    fmt.Println("Hello, world")
}

Because it has to be said.

go snippets

cute bits of go code

go-runas: call RPCs to yourself as a child dropping root

More informative printf-style debugging with closures

Marshalling JSON data structures the quick-and-dirty way

Using defer to log return values from within the function

Making a []byte from a pointer

Making a []byte from a pointer

Hello, world