Golang on Miek Gieben

Script to Upgrade to Latest Go version

Fri, 17 Jul 2020 05:39:00 +0000

This is my super simple script to upgrade to a newer Go version. You might find it handy as well.

#!/bin/zsh

GODIR=~/up

function latestGo {
    local LATEST=$(curl -s 'https://golang.org/dl/?mode=json' | jq -r '.[0].version')
    local INSTALLED=$(go version | awk '{ print $3 }')
    if [[ ${INSTALLED} == ${LATEST} ]]; then
        echo Go is up to date, running ${LATEST} >&2
        exit 0
    fi
    echo Upgrading Go from ${INSTALLED} to ${LATEST} >&2
    local GOLANG=https://dl.google.com/go/${LATEST}.linux-amd64.tar.gz
    local TAR=$(basename $GOLANG)

    ( cd ${GODIR}
      echo Downloading and extracting: $GOLANG >&2
      wget -q $GOLANG && rm -rf go && tar xvfz ${TAR}
    )
}

latestGo

Learning Go

Tue, 13 Aug 2019 07:39:00 +0000

Learning Go is a book that teaches you Go. It includes exercises (and solutions) to help put your new knowledge to the test.

Switching to Vodafone Uncovered a Bug

Fri, 17 Nov 2017 20:55:08 +0000

Recently I’ve switched to Vodafone for all my cellular needs, in a twisted turn of events this uncovered a goroutine leak in miekg/dns.

First some background on the setup I have at home (where this first showed up). I have your run-of-the-mill LAN + Wifi and a Raspberry Pi running CoreDNS for my DNS (proxy) needs. This CoreDNS instance forwards all DNS traffic to https://dns.google.com which uses a non-standard DNS protocol implemented as JSON over HTTPS. I use this so that my DNS traffic is encrypted. Note that CoreDNS makes heavy use of miekg/dns.

Go and Alpine Linux

Sat, 06 Jun 2015 11:13:00 +0000

Alpine Linux is the small Linux OS everybody is using for Docker images. It is super small and has a sh*tload of packages. It’s libc is musl libc, which is different than glibc most other Linux distros are using. When deploying Go on such a image you want a truly static binary.

Building a static binary can be done with the following command (this is for SkyDNS):

% go build -ldflags "-linkmode external -extldflags -static"
# github.com/miekg/skydns
/var/tmp/go-link-FI6Ox0/000000.o: In function `_cgo_632c88804cec_C2func_getaddrinfo':
/home/miek/upstream/go/src/net/cgo_unix.go:55: warning: Using 'getaddrinfo' in
statically linked applications requires at runtime the shared libraries from the
glibc version used for linking

That ugly warning is because glibc uses nss(5) “Nameserver Service Switch” which uses dlopen(3) to dynamically load the correct resolver library. The end result is that the Go binary can’t resolve any DNS records!

Learning Go in Markdown

Sat, 09 May 2015 07:39:00 +0000

The original Learning Go is written in LaTeX. With LaTeX you get beautiful (PDF) output, but there are a few problems. Most notably I consider LaTeX an output format: it is hard to convert it into something else. Markdown offers much more flexibility in that regard. The downside of markdown is that is not powerful enough to typeset a book. To fix this I forked BlackFriday extended it and renamed it Mmark (These are all written in Golang).

Go DNS package

Sat, 16 Aug 2014 09:33:00 +0000

Go DNS is a package that implements a DNS interface in Go. This library ~~takes a new, innovative and enterprise ready approach~~ sends and receives queries to and from the DNS. It is licensed under the same license as the official Go code, as this is a fork of that code.

The aim is to be powerful, simple and fast.

Supported:

All RR types;
Synchronous and asynchronous queries and replies;
DNSSEC: validation, signing, key generation, reading .private key files
(Fast) sending/receiving/printing packets, RRs;
Full control over what is being send;
Zone transfers, EDNS0, TSIG, NSID;
Server side programming (a full blown nameserver).
(Fast) reading zones/RRs from files/strings.

Code

The git repository is hosted on github.

SkyDNS running live

Sat, 28 Jun 2014 09:02:00 +0000

SkyDNS is able to do DNSSEC. It generates signatures and NSEC3 records on the fly. For authenticated denial of existence SkyDNS uses NSEC3 white lies, of course implementing (and testing!) this isn’t completely trivial.

To aid in debugging I’ve setup a live version of SkyDNS on voordeur.atoom.net, under the name the zone http://dnssex.nl:

% dig +mul +noall +answer @voordeur.atoom.net soa skydns.dnssex.nl
skydns.dnssex.nl.    3600 IN SOA ns1.dns.skydns.dnssex.nl. hostmaster.skydns.local. (
                            1403942400 ; serial
                            28800      ; refresh (8 hours)
                            7200       ; retry (2 hours)
                            604800     ; expire (1 week)
                            60         ; minimum (1 minute)
                            )

To help getting DNSSEC support 100% working this zone has been delegated and has an DS record in the parent zone. With unbound-host you can see the validation status of this zone:

SkyDNS version 2

Sun, 08 Jun 2014 12:46:00 +0000

SkyDNS version 1 was announced some time ago, since then it has seen some developments, which resulted in SkyDNS version 2. This new version uses Etcd as its backend. This blog post will walk you through the installation and shows how to use it.

What?!

SkyDNS(2) is a service discovery tool that utilizes the DNS to find hosts in a distributed environment. But using DNS means “legacy” clients can be used. Want to know if you MariaDB cluster is still up? ping mariadb.skydns.local can be used for that. By default SkyDNS will use skydns.local. as the domain to anchor all names.

Learning Go

Sun, 01 Jun 2014 08:33:00 +0000

“Learning Go” is a book that gives an introduction into the Go language of Google. It is licensed under a copy-left license. The book currently consists out +/- 120 (A4 sized) pages and the following chapters:

Introduction
Show how to install Go and details the lineage of the language Go.
Basics
Types, variables and control structures.
Functions
How to make and use functions.
Packages
Functions and data is grouped together in packages. Here you will see how to make your own package. How to unit test your package is also described.
Beyond the basics
Learn how to create your own data types and define function on them (called methods in Go).
Interfaces
Go does not support Object Orientation in the traditional sense. In Go the central concept is interfaces.
Concurrency
With the go keyword function can be started in separate routines (called goroutines). Communication with those goroutines is done via channels.
Communication
How to create/read/write from and to files. And how to do networking.

Each chapter concludes with a number of exercises (and answers) to may help you to get some hands on experience. Currently it has more than 30 exercises.

DNS Router

Sat, 17 May 2014 10:35:00 +0000

Say you have a zone that does not fit in the memory of one machine. Who hasn’t these zones nowadays? How would you solve such a problem? With a DNS router of course!

Dns router is a small Go program I whipped together that acts as a DNS router. Clients register an <ip:port, regexp> combination and will then only receive queries that match that regular expression. The registration happens in Etcd. Of course “Dns router” (I need a better name), has some features, it will:

Personal Go install

Mon, 02 Dec 2013 20:28:00 +0000

With golang 1.2, both godoc and go vet are removed from the main repository. Here is a super short list of commands (that I personally use) to install Go and both tools.

export GOBIN=~/bin
export GOPATH=~/g
mkdir -p ~/upstream
mkdir -p ~/g
cd ~/upstream
hg clone https://code.google.com/p/go/
hg update release
cd src
./all.bash
go get code.google.com/p/go.tools/cmd/godoc
go get code.google.com/p/go.tools/cmd/vet
go get code.google.com/p/go.tools/cmd/cover

PKCS11 wrapper for Go

Sat, 17 Aug 2013 03:32:00 +0000

In my quest to write a DNS server in Go I found myself lacking an interface to PKCS#11, so I wrote one. PKCS#11 is the interface to HSMs (including SoftHSM), and even though the interface sucks, I think a DNS server should store its keys in an HSM, by default.

So… here it is. I’m still putting in the finishing touches and some general polish, but it is already usable.

Go DNS API change WITH rewrite rules!

Sun, 09 Dec 2012 20:06:00 +0000

In the standard library the DNS types have been renamed from RR_MX to MX which I think is a good change. So I made the same change in Go DNS, but this time I’m providing gofmt -r rewrite rules. They all have the form:

gofmt -r 'RR_A -> A' -w *.go

And then for all the types, so it’s quite a list.

Download the rewrite rules here and use it like $SHELL rewrite.

Adding new RR types to GO DNS

Fri, 30 Nov 2012 20:01:00 +0000

Inspired by NLnet Labs and PowerDNS, I figured I couldn’t stay behind, so here is how to add new RRs to Go DNS.

A small note before I delve into the details, I haven’t optimized Go DNS for adding new types, as this is a relative infrequent event. There are a few items that need to be added before Go DNS understands the new RR type.

Adding the type itself (as a structure) and the four methods needed to implement the RR interface;
Adding the type number and the text string belonging it;
Parsing from text, i.e. when parsing zonefiles.

Lets take the new DANE (RFC6698) as an example. The record is called TLSA, and looks like:

User management in fksd

Tue, 07 Aug 2012 21:58:00 +0000

If you do DNS for too long everything looks like 53.

In this “trace” I’m showing the logging of fksd when I add a zone, try to list it as a non-existent user miekg (which fails), add the user miekg and list it again. User are identified by the key in the TSIG record, their password is the shared secret.

The “config files” from nsupdate can be found in the github repo of fksd. The nsupdate commands are preceded with a %, extra comments are preceded with #:

Dynamic nameserver provisioning with dns pkts

Mon, 06 Aug 2012 23:18:00 +0000

I’m writing a nameserver called fksd (Funkensturm daemon), which is currently in a prototype stage (but the code is available at github).

In this server I’m pursuing some interesting directions in nameserver development, such as the dynamic configuration as provided by BIND10.

BIND10 uses http(s), but I think using DNS packets is more in line with a nameserver, so I opted for that route.

With fksd you can use packets (which will be TSIG signed in the ~~future~~ tomorrow) to configure the server. The only configuration possible at the moment is adding a zone. Such a packet needs to have a TXT record like the following in its AUTHORITY SECTION:

Libunbound wrapper in Go

Sun, 01 Jul 2012 21:37:00 +0000

I’ve created a small wrapper for libunbound for use in Go.

The code can be found at github. It depends on my Go DNS library which can be found here.

Official announcement on the Unbound-users@ list.

To give you a little taste of how it looks, I’ve (re)created tutorials 2 to 6 in Go. Tutorial 2 looks like this, for instance:

package main

// https://www.unbound.net/documentation/libunbound-tutorial-2.html

import (
        "dns"
        "fmt"
        "os"
        "unbound"
)

func main() {
        u := unbound.New()
        defer u.Destroy()

        if err := u.ResolvConf("/etc/resolv.conf"); err != nil {
                fmt.Printf("error %s\n", err.Error())
                os.Exit(1)
        }

        if err := u.Hosts("/etc/hosts"); err != nil {
                fmt.Printf("error %s\n", err.Error())
                os.Exit(1)
        }

        r, err := u.Resolve("www.nlnetlabs.nl.", dns.TypeA, dns.ClassINET)
        if err != nil {
                fmt.Printf("error %s\n", err.Error())
                os.Exit(1)
        }
        fmt.Printf("%+v\n", r)
}

Printing MX records with Go DNS

Thu, 21 Jun 2012 10:30:00 +0000

Now that the API seems to stabilize it is time to update these items.

We want to create a little program that prints out the MX records of domains, like so:

% mx miek.nl
miek.nl.        86400   IN      MX      10 elektron.atoom.net.

% mx microsoft.com 
microsoft.com.  3600    IN      MX      10 mail.messaging.microsoft.com.

We are using my Go DNS package. First the normal header of a Go program, with a bunch of imports. We need the dns package:

Super-short guide to getting q (Part II)

Sun, 04 Mar 2012 10:54:00 +0000

The development of the language Go is going at a fast pace, hence an updated version of Super-short guide to gettinq q.

Get the latest version (called weekly) of Go:

Get Go: hg clone -u release https://go.googlecode.com/hg/ go Note the directory you have downloaded it to and set add its bin directory to your PATH: PATH=$PWD/go/bin.
Update Go to the latest weekly: cd go; hg pull; hg update weekly
Compile Go: cd src, you should now sit in go/src. And compile: ./all.bash

godns is now dns

Sat, 11 Feb 2012 23:09:00 +0000

Due to the new go tool (long story), I’ve renamed godns to dns. This means the github repo is also somewhere else.

godns installed itself as dns so code using it does not need to be changed.

DNS Fingerprinting

Sat, 28 Jan 2012 16:03:00 +0000

Announcing FP

The tool for DNS fingerprinting is fpdns, which is Perl based. In recent times development seems to have picked up, but a little competition never hurt anyone, so I wrote fp in Go. Fp is also a fingerprint program for DNS servers. Its aim is to be more readable then fpdns is (was?). And make it more easy to add new server types.

Help needed!

Do you have some old(er) nameserver laying around that can be queried? Does your (sick) mind know of a few extra evil queries that can be sent to nameservers? If so, please contact me: query@evilquery.nl. I want to get to a point where fp sends about 10 queries that can be used to identify a server.

Super-short guide to getting q

Mon, 23 Jan 2012 18:07:00 +0000

Get the latest version (called weekly) of Go:

Get Go: hg clone -u release https://go.googlecode.com/hg/ go Note the directory you have downloaded it to and set $GOROOT to it: export GOROOT=$PWD/go. Add the GOROOT bin directory to your path: PATH=$PATH:$GOROOT/bin
Update Go to the latest weekly: cd $GOROOT; hg pull; hg update weekly
Compile Go: cd $GOROOT/src ; ./all.bash

Install missing commands (gcc, sed, bison, etc.) if needed.

The latest Go is now installed.

Learning Go for E-readers

Sun, 28 Aug 2011 20:45:00 +0000

Thanks to a patch from Thomas Kappler I can now offer two types of PDFs, one for A4 pages and one for E-readers, like the kindle.

The E-reader variant is suffixed with -kindle:

VIM setup

Fri, 12 Aug 2011 09:04:00 +0000

After several years I decided to use a different color scheme for VIM. Also I’m going for force myself to use VIM’s folding abilities and use make from within VIM.

For good measure I also want to use Omni-completion when writing Go code:

Btw, this screenshots also shows the solarized (dark) colorscheme.

Coloring

Google for solarized. In my .vimrc:

let g:solarized_termcolors=256
colorscheme solarized

Make from VIM

Use :make inside the editor and jump through the errors with:

Chaining proxies

Mon, 01 Aug 2011 20:38:00 +0000

Online signing is cool, but slow. Caching queries in a reverse proxy is nice, but useless for something like NSD. But what if you want to do online signing in a fast way?

Enter: proxy chaining.

I already showed FunkenSign (example code is quite old though) and yesterday FunkenShield.

What if you combine the two? That gives the best of both worlds:

Online signing;
Caching;
And it adheres to the true Unix philosophy: do one thing, and do one thing well.

So lets get some figures again.

Reverse DNS proxy

Sun, 31 Jul 2011 16:09:00 +0000

Have a slow nameserver and want to spice things up? How about a reverse DNS proxy? For lack of a cool name I chose the name FunkenShield. It’s (of course) in the early stages, but it works quite nicely already.

This is done with the framework of FunkenSturm. Which is part of GoDNS.

How it works:

You place FunkenShield in front of your nameserver and it will cache the binary packets coming from your server in a local cache.

On programming languages and programmers

Mon, 18 Jul 2011 13:02:00 +0000

Very well written email message from Geoff Teale on the golang mailing list on programmers and progamming languages (thread).

To summarise a long presentation I gave to non-programmers:

There are 12 million programmers in the world

The majority of those programmers are scarcely qualified

Most technology decisions are made by a combination of following the crowd and a false understanding of risk.

The high cost and failure rate in software development is no coincidence.

Remember the Stevie Wonder rule - “When you believe in something you don’t understand then you suffer”. In this case that means “Perhaps making programming language decisions based on what 12 million powerless idiots are doing isn’t the golden road to glory and great hacks.”

Go DNS (update)

Wed, 06 Jul 2011 08:41:00 +0000

I’m finally back to coding Go DNS and making it work with the latest Go releases. Also the API has changed quite significantly since the last time I blogged about it.

So this I will detail key2ds which is small utility that queries a zone and print any DNSKEY records as DS records on the fly, to show the new API and some sample usage.

% ./key2ds sidn.nl
sidn.nl.    0   IN  DS  42033 8 1 343F74674D36C9B5BE2CEB2C401AC4EDEB2A05B2
sidn.nl.    0   IN  DS  42033 8 2 BF985EC0738FACC89EE0B12FBD9261827C59191D9EA6A9BDFF55F9BDF3DBBFF3
sidn.nl.    0   IN  DS  39274 8 1 E79E031DFDE8E68EF1E2C6CA0943C2CC0DED1889
sidn.nl.    0   IN  DS  39274 8 2 8E8A8CFB40FD0C30BFA82E53752E1C257DAFB7B6206D12B9EDA43AF3EAB2157D

This util uses synchronous queries. I will explain the main-function:

DNS reflector server in GO

Mon, 04 Apr 2011 21:08:00 +0000

I’m (again) rewriting the API of godns. I’ve now taking a cue from the http package in Go, the result seems very nice. A reflector (returns your query in the answer) in Go becomes:

package main

import (
        "dns"
        "log"
)

func ReflectServer(w dns.ResponseWriter, req *dns.Msg) {
        m := new(dns.Msg)
        m.SetReply(req)

        m.Extra = make([]dns.RR, 1)
        m.Extra[0] = &dns.RR_TXT{Hdr: dns.RR_Header{Name: m.Question[0].Name, Rrtype: dns.TypeTXT, 
                Class: dns.ClassINET, Ttl: 0}, Txt: "Hello world"}
        buf, _ := m.Pack()
        w.Write(buf)
}

func main() {
        dns.HandleFunc(".", ReflectServer)
        err := dns.ListenAndServe(":8053", "udp", nil)
        if err != nil {
                log.Fatal("ListenAndServe: ", err.String())
        }
}

Learning Go - version 0.3

Mon, 28 Feb 2011 20:54:00 +0000

I’ve tagged a new version of “Learning Go”, version 0.3. It’s more of a snapshot of the current development, than an actual “release” release.

There are lots of fixes, code updates and tweaks. Numerous people send in fixes. Thank you all for the contributions!

Get it:

PDF download;
Latest daily build.

Feedback is welcome.

To see the development version you can use:

Major stuff coming in 0.4:

Funkensign

Mon, 24 Jan 2011 12:52:00 +0000

How about on-the-fly signing? In this example we add a signature to any packet dealing with www.example.org. Again it is a matter of defining the matching, action and setup functions.

Matching

We don’t have to match anything coming in, we only need to sign pkts on their way out. So the function becomes:

func match(m *dns.Msg, d int) (*dns.Msg, bool) {
        // Matching criteria
        switch d { 
        case IN: 
                // nothing
        case OUT:
                // nothing
        }   
        // Packet Mangling
        switch d { 
        case IN: 
                // nothing
        case OUT:
                if m.Question[0].Name == "www.example.org." {
                        // On the way out sign the packet
                        m = sign(m) // keys are global
                }   
        }   
        return m, true
}

As you can see, it calls the sign() function where the actual signing takes place. We just sign the first RR in the answer section — if there is one.

Funkensturm

Sun, 23 Jan 2011 20:59:00 +0000

You need to install Go and Go DNS, but then you can play with Funkensturm:

Funkensturm: delaying proxy example

Sun, 23 Jan 2011 20:50:00 +0000

Another application for Funkensturm is: delaying packets. Here we only delay packets with the recursion desired bit (RD) set, but it can be easily be changed to check for other properties of a packet, see godoc dns for all elements of DNS packets.

The configuration is similar as described here.

Matching pkts with RD bit set

The matching function becomes:

// the only matching we do is on the RD bit
// for incoming packets.
func match(m *dns.Msg, d int) (*dns.Msg, bool) {
        // Matching criteria
        var ok bool
        switch d {
        case IN:
                // only delay pkts with RD bit 
                ok = m.MsgHdr.RecursionDesired == true
        case OUT:
                // nothing
        }

        // Packet Mangling
        switch d {
        case IN:
                // nothing
        case OUT:
                // nothing
        }
        return m, ok
}

Action function

First a delay helper function. As shown here it returns true if the delay time isn’t reached, and false if a something should be delayed.

Funkensturm: transparent proxy example

Sun, 23 Jan 2011 19:00:00 +0000

A transparent proxy is a proxy that does nothing, but it serves as a nice introduction into Funkensturm.

See this post for an architectural overview of Funkensturm.

Currently a configuration is compiled into the Funkensturm binary. As such it must look like a normal Go program.

Matching function

The matching function checks a packet for features and can optionally modify it.

This is the prototype of a matching function:

func match(m *dns.Msg, d int) (*dns.Msg, bool)

It receives a *dns.Msg which is a packet in Go DNS and a direction d which can be IN (first incoming packet) or OUT when the packet is on its way back to the client. It returns a DNS packet and a boolean value signaling a match.

Funkensturm: a versatile DNS proxy

Sun, 23 Jan 2011 16:52:00 +0000

What’s a DNS proxy?

A proxy is something this sits between a client and a server and does something with the data flowing through it. So a DNS proxy does this for DNS packets.

How does Funkensturm work?

Funkensturm consists out of 3 configuration parts:

A setup function for the initial setup.
Match/Modify function(s) — This function checks the packet for configured properties. If there is match true is returned.
Action function(s) — Taking the truth value from 2. (and the packet) as input, it does something with it.

With this setup you can change incoming packets before they are send through to the server. And you can change packet coming from the server that are send back to the client.

DNSSEC validation in Go for fun and profit

Sun, 02 Jan 2011 18:46:00 +0000

Doing cryptography is hard, luckily there are enough libraries out there that help you with it. OpenSSL is probably one of the best (known). Go has its own crypto library, which is written in pure Go.

Now with these aids crypto becomes doable for mere mortals, but all these libraries work with buffers which hold the data, the signature and sometimes the key also. Off-by-one errors in composing these buffers leads to a “Bogus signature” error (in DNSSEC). The problem here is that you don’t get any other clue on what went wrong. For me as a programmer an error such as “Shift buffer A one byte to the left and you’re OK”, would be much better. But due to the nature of crypto these kind of errors are not possible, nor desirable.

Go DNS and AXFR

Sat, 01 Jan 2011 19:15:00 +0000

I’ve implemented axfr in my Go DNS library in nice and Go-like way (at least that’s what I like to think). Starting an axfr results in a channel which can then be used with the range keyword to loop over it, until the entire axfr is received.

Using it

First the normal begin of a Go program:

package main
import (
    "fmt"
    "dns"           // DNS package
)

Then we start the main function in which we define a new resolver and a channel for receiving the axfr messages. The channels will send dns.xfr messages which is defined as:

(Re)announcing GoDNS

Sun, 19 Dec 2010 12:13:00 +0000

[ post updated to reflect changes in the library ]

This library ~~takes a new, innovative and enterprise ready approach~~ sends and receives queries to and from the DNS.

The library was forked from the official DNS code in Go (in the net package). Since that time Go team has thrown out this code and started to use the system’s C library via a wrapper. I was however struck by the elegance of the code (esp. the pack and unpack functions), so I forked it and added new record types (AAAA, DS, RRSIG, etc.) and turned into a more general DNS API.

Learning Go - version 0.2

Wed, 27 Oct 2010 21:09:00 +0000

This morning I’ve tagged version 0.2 of “Learning Go”. Among the larger changes is that “Interfaces” is now a separate chapter.

I have also removed/added/updated the text. Fixed mistakes in the text and code (and probably added new ones).

To get it:

Feedback is welcome.

Of course a lot of work still needs to be done:

(Finally) fix all the exercises;
Test/Retest if all the Go code works with the latest compiler;
Finish the last chapters (chapter 6,7 and 8);
…

Go book update

Mon, 18 Oct 2010 09:10:00 +0000

I’m preparing a 0.2 version of the Go book I’m writing. There are lots of small tweaks in the text and in the layout. I still need to extend the number exercises (and enhance the answers a bit), but it is slowly coming together.

There is a new chapter on how to write programs that communicate with the outside world (via files, sockets, etc.).

Some infrastructure work includes an automatic code checker — sadly written in Perl.

Go number cruncher

Tue, 17 Aug 2010 21:27:00 +0000

Write a number cruncher that works as follows:

Pick six (6) random numbers from this list:
```
1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 25, 50, 75, 100
```
Numbers may be picked multiple times.
Pick one (1) random number (i) in the range:
```
1 . . . 1000
```
Tell how, by combining the first 6 numbers or or subset with the operators +,-,* and /, you can make i;

Learning Go - version 0.1

Mon, 16 Aug 2010 20:46:00 +0000

I’ve tagged an 0.1 version of the book I’m writing: “Learning Go”. It currently has 7 chapters. The first five are finished. Chapter 6 and 7 still need work. The exercises can also use some (more) love. The current chapter list of “Learning Go” is:

Introduction
Basics
Functions
Packages
Beyond the basics
Concurrency
Communication

To get it:

PDF download
Gitweb repository

If you have comments, text or exercises feel free to drop an email.