func (server *Server) Listen(addr string) error {
	laddr, err := net.ResolveUDPAddr("udp", addr)
	if err != nil {
		return err
	}

	conn, err := net.ListenUDP("udp", laddr)
	if err != nil {
		return err
	}

	newPacket := make(chan packet)

	go func() {
		buffer := make([]byte, 4096)

		for {
			n, raddr, err := conn.ReadFromUDP(buffer)

			if err != nil {
				log.Println(err)
				continue
			}

			newPacket <- packet{addr: raddr, data: buffer[:n]}
		}
	}()

	services := make(map[string]*Service)
	tunnelsByAddr := make(map[string]*tunnel)
	tunnelsByTID := make(map[uint64]*tunnel)

	for {
		select {
		case importRequest := <-server.importRequest:
			service := services[importRequest.serviceName]

			if service == nil {
				importRequest.fail <- errors.New("No service by that name")
			} else {
				pendingImports := service.pendingImports

				go func() { pendingImports <- importRequest }()
			}
		case outgoing := <-server.outgoing:
			tunnel := tunnelsByTID[outgoing.tid]
			if tunnel == nil {
				log.Println("No tunnel", outgoing.tid)
				continue
			}

			c := tunnel.conns[outgoing.cid]
			if c == nil {
				log.Println("No conn", outgoing.cid)
				continue
			}

			nonce := tunnel.lastNonce.Next()
			tunnel.lastNonce = nonce

			messageWithCID := make([]byte, 8, 8+len(outgoing.data))
			binary.LittleEndian.PutUint64(messageWithCID[0:8], uint64(outgoing.cid))
			messageWithCID = append(messageWithCID, outgoing.data...)
			packet := buildPacket(tunnel.boxer, outgoing.tid, nonce, nil, nil, messageWithCID)

			if _, err := conn.WriteTo(packet, tunnel.addr); err != nil {
				outgoing.done <- err
			} else {
				outgoing.done <- nil
			}
		case packet := <-newPacket:
			// Puzzle is unused at the moment.
			tid, nonce, remotePk, _, boxedMessage := parsePacket(packet.data)

			tunnel := tunnelsByTID[tid]

			if tunnel == nil && remotePk != nil {
				// Attempt to establish a tunnel with us.

				boxer := cryptonacl.NewBoxer(remotePk, server.SecretKey)
				nonce := nonce.Next()
				tunnel = createTunnel(tid, packet.addr, 0, nonce, boxer, server)

				tunnel.conns[0] = createConn(tunnel, 0)
				tunnelsByTID[tid] = tunnel
			} else if tunnel != nil && remotePk != nil {
				// The tunnel already exists, yet this packet seems to be trying to
				// make a connection again.  It's most likely that this is a reincident
				// packet, so ignore it.
				log.Println("Dropping because tunnel already exists, but public key given")
				continue
			}

			messageWithCID, err := tunnel.boxer.Unbox(boxedMessage, nonce)
			if err != nil {
				// Drop the packet.
				log.Println("Could not unbox")
				continue
			}

			cid := binary.LittleEndian.Uint64(messageWithCID[0:8])
			message := messageWithCID[8:]

			if cid == 0 {
				rpc := []json.RawMessage{}

				if err := json.Unmarshal(message, &rpc); err != nil {
					log.Println("err", err)
					continue
				}

				var command string

				if err := json.Unmarshal(rpc[0], &command); err != nil {
					log.Println("err", err)
					continue
				}

				args := rpc[1:]

				if command == "create" {
					var createCID uint64
					var serviceName string

					if err := json.Unmarshal(args[0], &createCID); err != nil {
						log.Println("json.Unmarshal", err)
						continue
					}

					if err := json.Unmarshal(args[1], &serviceName); err != nil {
						log.Println("json.Unmarshal", err)
						continue
					}

					service := services[serviceName]
					if service == nil {
						log.Println("No service", serviceName)
						continue
					}

					conn := createConn(tunnel, createCID)

					buf, err := json.Marshal([]interface{}{"created", createCID})
					if err != nil {
						log.Println("json.Marshal", err)
						continue
					}

					importRequest := <-service.pendingImports
					tunnel.conns[createCID] = conn
					importRequest.done <- conn

					go func() {
						if _, err := tunnel.conns[0].Write(buf); err != nil {
							return
						}
					}()
				} else if command == "created" {
					var createdCID uint64

					if err := json.Unmarshal(args[0], &createdCID); err != nil {
						log.Println("json.Unmarshal", err)
						continue
					}

					req := tunnel.pendingConnections[createdCID]
					delete(tunnel.pendingConnections, createdCID)
					c := createConn(tunnel, createdCID)
					tunnel.conns[createdCID] = c

					req.done <- c
				} else {
					log.Println("Invalid command", command)
					continue
				}
			} else {
				conn := tunnel.conns[cid]

				if conn != nil {
					conn.inbox <- message
				}
			}
		case req := <-server.advertiseRequest:
			_, serviceExists := services[req.serviceName]

			if serviceExists {
				req.fail <- errors.New("Service already exists")
			} else {
				service := &Service{
					ServiceName:    req.serviceName,
					server:         server,
					pendingImports: make(chan importRequest),
				}

				services[req.serviceName] = service

				req.done <- service
			}
		case req := <-server.ipcRequest:
			tunnel := tunnelsByAddr[req.addr.String()]

			if tunnel == nil {
				remotePk, err := server.Directory(req.addr)
				if err != nil {
					req.fail <- err
					continue
				}

				tid := createTID()
				localPk, localSk := cryptonacl.BoxKeypair()
				nonce := cryptonacl.CreateNonce(localPk, remotePk)
				boxer := cryptonacl.NewBoxer(remotePk, localSk)

				message, err := json.Marshal([]interface{}{"create", 1, req.serviceName})
				if err != nil {
					req.fail <- err
					continue
				}

				messageWithCID := make([]byte, 8, 8+len(message))
				binary.LittleEndian.PutUint64(messageWithCID[0:8], 0)
				messageWithCID = append(messageWithCID, message...)

				packet := buildPacket(boxer, tid, nonce, localPk, nil, messageWithCID)
				tunnel := createTunnel(tid, req.addr, 1, nonce, boxer, server)

				tunnel.conns[0] = createConn(tunnel, 0)

				if _, err := conn.WriteTo(packet, req.addr); err != nil {
					req.fail <- err
					continue
				}

				tunnel.pendingConnections[1] = &req

				// We can't even be sure yet if the tunnel is established; might need
				// a 'pending' mechanism like for connections.
				tunnelsByAddr[req.addr.String()] = tunnel
				tunnelsByTID[tid] = tunnel
			} else {
				cid := tunnel.lastCID + 1
				nonce := tunnel.lastNonce.Next()

				tunnel.lastNonce = nonce
				tunnel.lastCID = cid

				message, err := json.Marshal([]interface{}{"create", cid, req.serviceName})
				if err != nil {
					req.fail <- err
					continue
				}

				messageWithCID := make([]byte, 8+len(message))
				binary.LittleEndian.PutUint64(messageWithCID[0:8], uint64(cid))
				messageWithCID = append(messageWithCID, message...)

				packet := buildPacket(tunnel.boxer, tunnel.tid, nonce, nil, nil, messageWithCID)
				if _, err := conn.WriteTo(packet, tunnel.addr); err != nil {
					req.fail <- err
					continue
				}

				tunnel.pendingConnections[cid] = &req
			}
		case <-server.stop:
			return nil
		}
	}
}
func TestConnection(t *testing.T) {
	alice := CreateServer()
	bob := CreateServer()

	aliceDone := make(chan error)
	bobDone := make(chan error)
	advertiseDone := make(chan error)
	ipcDone := make(chan error)

	alice.PublicKey, alice.SecretKey = cryptonacl.BoxKeypair()

	aliceAddr := "127.0.0.1:9123"
	bobAddr := "127.0.0.1:9124"

	bob.Directory = func(addr *net.UDPAddr) (cryptonacl.PublicKey, error) {
		if addr.String() == aliceAddr {
			return alice.PublicKey, nil
		} else {
			return nil, errors.New("Could not lookup host " + addr.String())
		}
	}

	go func() { aliceDone <- alice.Listen(aliceAddr) }()
	go func() { bobDone <- bob.Listen(bobAddr) }()

	go func() {
		ping, err := alice.Advertise("ping")

		if err != nil {
			advertiseDone <- err
			return
		}

		conn, err := ping.Import()
		if err != nil {
			advertiseDone <- err
			return
		}

		buffer := make([]byte, len("ping"))

		if n, err := conn.Read(buffer); err != nil {
			advertiseDone <- err
			return
		} else if !bytes.Equal(buffer[:n], []byte("ping")) {
			advertiseDone <- errors.New(fmt.Sprintf("Expected ping, got %s", buffer[:n]))
			return
		}

		response := []byte("pong")
		if _, err := conn.Write(response); err != nil {
			advertiseDone <- err
			return
		}

		advertiseDone <- nil
	}()

	go func() {
		conn, err := bob.IPC("ping", aliceAddr)
		if err != nil {
			ipcDone <- err
			return
		}

		message := []byte("ping")
		if _, err := conn.Write(message); err != nil {
			ipcDone <- err
			return
		}

		response := make([]byte, len("pong"))

		if n, err := conn.Read(response); err != nil {
			ipcDone <- err
			return
		} else if !bytes.Equal(response[:n], []byte("pong")) {
			ipcDone <- errors.New(fmt.Sprintf("Expected pong, got %s", response[:n]))
			return
		}

		ipcDone <- nil
	}()

	// Wait for the client and server to finish (or fail or timeout).
	errs := make(chan error)

	go func() { errs <- <-advertiseDone }()
	go func() { errs <- <-ipcDone }()

	timeout := time.After(80 * time.Millisecond)
	for i := 0; i < 2; i++ {
		select {
		case err := <-errs:
			if err != nil {
				t.Error(err)
			}
		case <-timeout:
			t.Error("Timeout waiting on advertise and IPC;", i, "processes finished.")
			goto timeout
		}
	}

timeout:

	// Wait for the MinimaLT services themselves to stop (or fail or timeout).
	alice.Stop()
	bob.Stop()

	serverErrs := make(chan error)

	go func() { serverErrs <- <-aliceDone }()
	go func() { serverErrs <- <-bobDone }()

	timeout2 := time.After(80 * time.Millisecond)
	for i := 0; i < 2; i++ {
		select {
		case err := <-serverErrs:
			if err != nil {
				t.Error(err)
			}
		case <-timeout2:
			t.Error("Timeout waiting on Alice and Bob;", i, "processes finished.")
			goto timeout2
		}
	}

timeout2:
}