Merge lp:~pedronis/ubuntu-push/api-handling-dry into lp:ubuntu-push

[Samuele Pedroni]

refactor api handling to avoid repetition and have just one ServeHTTP

refactor api handling to avoid repetition and have just one ServeHTTP

[lp:~pedronis/ubuntu-push/api-handling-dry]

199. By Samuele Pedroni on 2014-06-25

Merged better-ok-matching into api-handling-dry.

Unmerged revisions

=== modified file 'Makefile'
--- Makefile	2014-06-02 11:37:03 +0000
+++ Makefile	2014-06-24 18:15:10 +0000
@@ -36,8 +36,8 @@
 	$(GOPATH)/bin/godeps -u dependencies.tsv
 	go install $(GODEPS)
 
-dependencies.tsv: $(TOBUILD)
-	$(GOPATH)/bin/godeps -t $(foreach i,$^,$(dir $(PROJECT)/$(i))) 2>/dev/null | cat > $@
+dependencies.tsv:
+	$(GOPATH)/bin/godeps -t $(TOTEST) $(foreach i,$(TOBUILD),$(dir $(PROJECT)/$(i))) 2>/dev/null | cat > $@
 
 check:
 	go test $(TESTFLAGS) $(TOTEST)

=== modified file 'PACKAGE_DEPS'
--- PACKAGE_DEPS	2014-05-23 06:21:46 +0000
+++ PACKAGE_DEPS	2014-06-24 18:15:10 +0000
@@ -8,3 +8,5 @@
 libsqlite3-dev
 libubuntuoneauth-2.0-dev
 libwhoopsie-dev
+libmessaging-menu-dev
+libubuntu-app-launch2-dev

=== modified file 'bus/endpoint.go'
--- bus/endpoint.go	2014-05-15 11:28:06 +0000
+++ bus/endpoint.go	2014-06-24 18:15:10 +0000
@@ -29,7 +29,7 @@
  *    Endpoint (and its implementation)
  */
 
-type BusMethod func([]interface{}, []interface{}) ([]interface{}, error)
+type BusMethod func(string, []interface{}, []interface{}) ([]interface{}, error)
 type DispatchMap map[string]BusMethod
 
 // bus.Endpoint represents the DBus connection itself.
@@ -249,12 +249,12 @@
 				endp.log.Errorf("WatchMethod: unknown method %s", msg.Member)
 			} else {
 				args := msg.AllArgs()
-				rvals, err := meth(args, extra)
+				rvals, err := meth(string(msg.Path), args, extra)
 				if err != nil {
 					reply = dbus.NewErrorMessage(msg, err_iface, err.Error())
-					endp.log.Errorf("WatchMethod: %s(%#v, %#v) failure: %#v", msg.Member, args, extra, err)
+					endp.log.Errorf("WatchMethod: %s(%v, %#v, %#v) failure: %#v", msg.Member, msg.Path, args, extra, err)
 				} else {
-					endp.log.Debugf("WatchMethod: %s(%#v, %#v) success: %#v", msg.Member, args, extra, rvals)
+					endp.log.Debugf("WatchMethod: %s(%v, %#v, %#v) success: %#v", msg.Member, msg.Path, args, extra, rvals)
 					reply = dbus.NewMethodReturnMessage(msg)
 					err = reply.AppendArgs(rvals...)
 					if err != nil {

=== modified file 'bus/testing/testing_endpoint_test.go'
--- bus/testing/testing_endpoint_test.go	2014-06-02 10:04:34 +0000
+++ bus/testing/testing_endpoint_test.go	2014-06-24 18:15:10 +0000
@@ -229,7 +229,7 @@
 // Test that WatchMethod updates callArgs
 func (s *TestingEndpointSuite) TestWatchMethodUpdatesCallArgs(c *C) {
 	endp := NewTestingEndpoint(nil, condition.Work(true))
-	foo := func([]interface{}, []interface{}) ([]interface{}, error) { return nil, nil }
+	foo := func(string, []interface{}, []interface{}) ([]interface{}, error) { return nil, nil }
 	foomp := bus.DispatchMap{"foo": foo}
 	endp.WatchMethod(foomp)
 	c.Check(GetCallArgs(endp), DeepEquals, []callArgs{

=== modified file 'client/client.go'
--- client/client.go	2014-05-21 10:03:18 +0000
+++ client/client.go	2014-06-24 18:15:10 +0000
@@ -28,6 +28,7 @@
 	"fmt"
 	"io/ioutil"
 	"os"
+	"os/exec"
 	"strings"
 
 	"launchpad.net/go-dbus/v1"
@@ -63,32 +64,36 @@
 	// The PEM-encoded server certificate
 	CertPEMFile string `json:"cert_pem_file"`
 	// How to invoke the auth helper
-	AuthHelper []string `json:"auth_helper"`
+	AuthHelper      string `json:"auth_helper"`
+	SessionURL      string `json:"session_url"`
+	RegistrationURL string `json:"registration_url"`
 	// The logging level (one of "debug", "info", "error")
 	LogLevel logger.ConfigLogLevel `json:"log_level"`
 }
 
 // PushClient is the Ubuntu Push Notifications client-side daemon.
 type PushClient struct {
-	leveldbPath        string
-	configPath         string
-	config             ClientConfig
-	log                logger.Logger
-	pem                []byte
-	idder              identifier.Id
-	deviceId           string
-	notificationsEndp  bus.Endpoint
-	urlDispatcherEndp  bus.Endpoint
-	connectivityEndp   bus.Endpoint
-	systemImageEndp    bus.Endpoint
-	systemImageInfo    *systemimage.InfoResult
-	connCh             chan bool
-	hasConnectivity    bool
-	actionsCh          <-chan notifications.RawActionReply
-	session            *session.ClientSession
-	sessionConnectedCh chan uint32
-	serviceEndpoint    bus.Endpoint
-	service            *service.Service
+	leveldbPath           string
+	configPath            string
+	config                ClientConfig
+	log                   logger.Logger
+	pem                   []byte
+	idder                 identifier.Id
+	deviceId              string
+	notificationsEndp     bus.Endpoint
+	urlDispatcherEndp     bus.Endpoint
+	connectivityEndp      bus.Endpoint
+	systemImageEndp       bus.Endpoint
+	systemImageInfo       *systemimage.InfoResult
+	connCh                chan bool
+	hasConnectivity       bool
+	actionsCh             <-chan notifications.RawActionReply
+	session               *session.ClientSession
+	sessionConnectedCh    chan uint32
+	pushServiceEndpoint   bus.Endpoint
+	pushService           *service.PushService
+	postalServiceEndpoint bus.Endpoint
+	postalService         *service.PostalService
 }
 
 var (
@@ -160,7 +165,27 @@
 		ExpectAllRepairedTime:  client.config.ExpectAllRepairedTime.TimeDuration(),
 		PEM:        client.pem,
 		Info:       info,
-		AuthHelper: client.config.AuthHelper,
+		AuthGetter: client.getAuthorization,
+		AuthURL:    client.config.SessionURL,
+	}
+}
+
+// getAuthorization gets the authorization blob to send to the server
+func (client *PushClient) getAuthorization(url string) string {
+	client.log.Debugf("getting authorization for %s", url)
+	// using a helper, for now at least
+	if len(client.config.AuthHelper) == 0 {
+		// do nothing if helper is unset or empty
+		return ""
+	}
+
+	auth, err := exec.Command(client.config.AuthHelper, url).Output()
+	if err != nil {
+		// For now we just log the error, as we don't want to block unauthorized users
+		client.log.Errorf("unable to get the authorization token from the account: %v", err)
+		return ""
+	} else {
+		return strings.TrimSpace(string(auth))
 	}
 }
 
@@ -331,7 +356,7 @@
 // handleUnicastNotification deals with receiving a unicast notification
 func (client *PushClient) handleUnicastNotification(msg *protocol.Notification) error {
 	client.log.Debugf("sending notification %#v for %#v.", msg.MsgId, msg.AppId)
-	return client.service.Inject(msg.AppId, string(msg.Payload))
+	return client.postalService.Inject(msg.AppId, string(msg.Payload))
 }
 
 // handleClick deals with the user clicking a notification
@@ -422,21 +447,34 @@
 }
 
 func (client *PushClient) startService() error {
-	if client.serviceEndpoint == nil {
-		client.serviceEndpoint = bus.SessionBus.Endpoint(service.BusAddress, client.log)
+	if client.pushServiceEndpoint == nil {
+		client.pushServiceEndpoint = bus.SessionBus.Endpoint(service.PushServiceBusAddress, client.log)
+	}
+	if client.postalServiceEndpoint == nil {
+		client.postalServiceEndpoint = bus.SessionBus.Endpoint(service.PostalServiceBusAddress, client.log)
 	}
 
-	client.service = service.NewService(client.serviceEndpoint, client.log)
-	client.service.SetMessageHandler(client.messageHandler)
-	return client.service.Start()
+	client.pushService = service.NewPushService(client.pushServiceEndpoint, client.log)
+	client.pushService.SetRegistrationURL(client.config.RegistrationURL)
+	client.pushService.SetAuthGetter(client.getAuthorization)
+	client.pushService.SetDeviceId(client.deviceId)
+	client.postalService = service.NewPostalService(client.postalServiceEndpoint, client.log)
+	client.postalService.SetMessageHandler(client.messageHandler)
+	if err := client.pushService.Start(); err != nil {
+		return err
+	}
+	if err := client.postalService.Start(); err != nil {
+		return err
+	}
+	return nil
 }
 
 // Start calls doStart with the "real" starters
 func (client *PushClient) Start() error {
 	return client.doStart(
 		client.configure,
+		client.getDeviceId,
 		client.startService,
-		client.getDeviceId,
 		client.takeTheBus,
 		client.initSession,
 	)

=== modified file 'client/client_test.go'
--- client/client_test.go	2014-05-20 13:56:37 +0000
+++ client/client_test.go	2014-06-24 18:15:10 +0000
@@ -103,11 +103,13 @@
 		"stabilizing_timeout":    "0ms",
 		"connectivity_check_url": "",
 		"connectivity_check_md5": "",
-		"addr":            ":0",
-		"cert_pem_file":   pem_file,
-		"recheck_timeout": "3h",
-		"auth_helper":     []string{},
-		"log_level":       "debug",
+		"addr":             ":0",
+		"cert_pem_file":    pem_file,
+		"recheck_timeout":  "3h",
+		"auth_helper":      "",
+		"session_url":      "xyzzy://",
+		"registration_url": "reg://",
+		"log_level":        "debug",
 	}
 	for k, v := range overrides {
 		cfgMap[k] = v
@@ -257,7 +259,7 @@
 
 func (cs *clientSuite) TestDeriveSessionConfig(c *C) {
 	cs.writeTestConfig(map[string]interface{}{
-		"auth_helper": []string{"auth", "helper"},
+		"auth_helper": "auth helper",
 	})
 	info := map[string]interface{}{
 		"foo": 1,
@@ -272,7 +274,8 @@
 		ExpectAllRepairedTime:  30 * time.Minute,
 		PEM:        cli.pem,
 		Info:       info,
-		AuthHelper: []string{"auth", "helper"},
+		AuthGetter: func(string) string { return "" },
+		AuthURL:    "xyzzy://",
 	}
 	// sanity check that we are looking at all fields
 	vExpected := reflect.ValueOf(expected)
@@ -284,6 +287,11 @@
 	}
 	// finally compare
 	conf := cli.deriveSessionConfig(info)
+	// compare authGetter by string
+	c.Check(fmt.Sprintf("%v", conf.AuthGetter), Equals, fmt.Sprintf("%v", cli.getAuthorization))
+	// and set it to nil
+	conf.AuthGetter = nil
+	expected.AuthGetter = nil
 	c.Check(conf, DeepEquals, expected)
 }
 
@@ -292,15 +300,25 @@
 ******************************************************************/
 
 func (cs *clientSuite) TestStartServiceWorks(c *C) {
+	cs.writeTestConfig(map[string]interface{}{
+		"auth_helper": helpers.ScriptAbsPath("dummyauth.sh"),
+	})
 	cli := NewPushClient(cs.configPath, cs.leveldbPath)
+	cli.configure()
 	cli.log = cs.log
-	cli.serviceEndpoint = testibus.NewTestingEndpoint(condition.Work(true), nil)
-	c.Check(cli.service, IsNil)
+	cli.deviceId = "fake-id"
+	cli.pushServiceEndpoint = testibus.NewTestingEndpoint(condition.Work(true), nil)
+	cli.postalServiceEndpoint = testibus.NewTestingEndpoint(condition.Work(true), nil)
+	c.Check(cli.pushService, IsNil)
 	c.Check(cli.startService(), IsNil)
-	c.Assert(cli.service, NotNil)
-	c.Check(cli.service.IsRunning(), Equals, true)
-	c.Check(cli.service.GetMessageHandler(), NotNil)
-	cli.service.Stop()
+	c.Assert(cli.pushService, NotNil)
+	c.Check(cli.pushService.IsRunning(), Equals, true)
+	c.Check(cli.pushService.GetDeviceId(), Equals, "fake-id")
+	c.Check(cli.pushService.GetRegistrationAuthorization(), Equals, "hello reg://")
+	c.Check(cli.postalService.IsRunning(), Equals, true)
+	c.Check(cli.postalService.GetMessageHandler(), NotNil)
+	cli.pushService.Stop()
+	cli.postalService.Stop()
 }
 
 func (cs *clientSuite) TestStartServiceErrorsOnNilLog(c *C) {
@@ -309,10 +327,19 @@
 	c.Check(cli.startService(), NotNil)
 }
 
-func (cs *clientSuite) TestStartServiceErrorsOnBusDialFail(c *C) {
-	cli := NewPushClient(cs.configPath, cs.leveldbPath)
-	cli.log = cs.log
-	cli.serviceEndpoint = testibus.NewTestingEndpoint(condition.Work(false), nil)
+func (cs *clientSuite) TestStartServiceErrorsOnBusDialPushFail(c *C) {
+	cli := NewPushClient(cs.configPath, cs.leveldbPath)
+	cli.log = cs.log
+	cli.pushServiceEndpoint = testibus.NewTestingEndpoint(condition.Work(false), nil)
+	cli.postalServiceEndpoint = testibus.NewTestingEndpoint(condition.Work(false), nil)
+	c.Check(cli.startService(), NotNil)
+}
+
+func (cs *clientSuite) TestStartServiceErrorsOnBusDialPostalFail(c *C) {
+	cli := NewPushClient(cs.configPath, cs.leveldbPath)
+	cli.log = cs.log
+	cli.pushServiceEndpoint = testibus.NewTestingEndpoint(condition.Work(true), nil)
+	cli.postalServiceEndpoint = testibus.NewTestingEndpoint(condition.Work(false), nil)
 	c.Check(cli.startService(), NotNil)
 }
 
@@ -647,14 +674,16 @@
 func (cs *clientSuite) TestHandleUcastNotification(c *C) {
 	cli := NewPushClient(cs.configPath, cs.leveldbPath)
 	svcEndp := testibus.NewTestingEndpoint(condition.Work(true), condition.Work(true), uint32(1))
+	postEndp := testibus.NewTestingEndpoint(condition.Work(true), condition.Work(true), uint32(1))
 	cli.log = cs.log
-	cli.serviceEndpoint = svcEndp
+	cli.pushServiceEndpoint = svcEndp
+	cli.postalServiceEndpoint = postEndp
 	notsEndp := testibus.NewTestingEndpoint(nil, condition.Work(true), uint32(1))
 	cli.notificationsEndp = notsEndp
 	c.Assert(cli.startService(), IsNil)
 	c.Check(cli.handleUnicastNotification(notif), IsNil)
 	// check we sent the notification
-	args := testibus.GetCallArgs(svcEndp)
+	args := testibus.GetCallArgs(postEndp)
 	c.Assert(len(args), Not(Equals), 0)
 	c.Check(args[len(args)-1].Member, Equals, "::Signal")
 	c.Check(cs.log.Captured(), Matches, `(?m).*sending notification "42" for "hello".*`)
@@ -879,7 +908,7 @@
 	cli := NewPushClient(cs.configPath, cs.leveldbPath)
 	// before start, everything sucks:
 	// no service,
-	c.Check(cli.service, IsNil)
+	c.Check(cli.pushService, IsNil)
 	// no config,
 	c.Check(string(cli.config.Addr), Equals, "")
 	// no device id,
@@ -904,9 +933,10 @@
 	// and a bus,
 	c.Check(cli.notificationsEndp, NotNil)
 	// and a service,
-	c.Check(cli.service, NotNil)
+	c.Check(cli.pushService, NotNil)
 	// and everthying us just peachy!
-	cli.service.Stop() // cleanup
+	cli.pushService.Stop()   // cleanup
+	cli.postalService.Stop() // cleanup
 }
 
 func (cs *clientSuite) TestStartCanFail(c *C) {
@@ -951,3 +981,42 @@
 	c.Assert(err, NotNil)
 	c.Check(cs.log.Captured(), Matches, "(?msi).*showing notification: no way$")
 }
+
+func (cs *clientSuite) TestInitSessionErr(c *C) {
+	cli := NewPushClient(cs.configPath, cs.leveldbPath)
+	cli.log = cs.log
+	cli.systemImageInfo = siInfoRes
+	// change the cli.pem value so initSession fails
+	cli.pem = []byte("foo")
+	c.Assert(cli.initSession(), NotNil)
+}
+
+/*****************************************************************
+    getAuthorization() tests
+******************************************************************/
+
+func (cs *clientSuite) TestGetAuthorizationIgnoresErrors(c *C) {
+	cli := NewPushClient(cs.configPath, cs.leveldbPath)
+	cli.configure()
+	cli.config.AuthHelper = "/no/such/executable"
+
+	c.Check(cli.getAuthorization("xyzzy://"), Equals, "")
+}
+
+func (cs *clientSuite) TestGetAuthorizationGetsIt(c *C) {
+	cli := NewPushClient(cs.configPath, cs.leveldbPath)
+	cli.configure()
+	cli.config.AuthHelper = helpers.ScriptAbsPath("dummyauth.sh")
+
+	c.Check(cli.getAuthorization("xyzzy://"), Equals, "hello xyzzy://")
+}
+
+func (cs *clientSuite) TestGetAuthorizationWorksIfUnsetOrNil(c *C) {
+	cli := NewPushClient(cs.configPath, cs.leveldbPath)
+	cli.log = cs.log
+
+	c.Assert(cli.config, NotNil)
+	c.Check(cli.getAuthorization("xyzzy://"), Equals, "")
+	cli.configure()
+	c.Check(cli.getAuthorization("xyzzy://"), Equals, "")
+}

=== modified file 'client/gethosts/gethost_test.go'
--- client/gethosts/gethost_test.go	2014-05-02 10:42:16 +0000
+++ client/gethosts/gethost_test.go	2014-06-24 18:15:10 +0000
@@ -59,7 +59,7 @@
 	res, err := gh.Get()
 	c.Assert(err, IsNil)
 	c.Check(*res, DeepEquals,
-		Host{Domain: "example.com", Hosts: []string{"http://c1130408a700afe0"}})
+		Host{Domain: "example.com", Hosts: []string{"http://bdd2ae7116c85a45"}})
 }
 
 func (s *getHostsSuite) TestGetTimeout(c *C) {

=== added file 'client/service/common.go'
--- client/service/common.go	1970-01-01 00:00:00 +0000
+++ client/service/common.go	2014-06-24 18:15:10 +0000
@@ -0,0 +1,99 @@
+/*
+ Copyright 2014 Canonical Ltd.
+
+ This program is free software: you can redistribute it and/or modify it
+ under the terms of the GNU General Public License version 3, as published
+ by the Free Software Foundation.
+
+ This program is distributed in the hope that it will be useful, but
+ WITHOUT ANY WARRANTY; without even the implied warranties of
+ MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
+ PURPOSE.  See the GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License along
+ with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+// package service implements the dbus-level service with which client
+// applications are expected to interact.
+package service
+
+import (
+	"errors"
+	"sync"
+
+	"launchpad.net/ubuntu-push/bus"
+	"launchpad.net/ubuntu-push/logger"
+)
+
+type DBusService struct {
+	lock  sync.RWMutex
+	state ServiceState
+	Log   logger.Logger
+	Bus   bus.Endpoint
+}
+
+// the service can be in a numnber of states
+type ServiceState uint8
+
+const (
+	StateUnknown  ServiceState = iota
+	StateRunning               // Start() has been successfully called
+	StateFinished              // Stop() has been successfully called
+)
+
+var (
+	NotConfigured  = errors.New("not configured")
+	AlreadyStarted = errors.New("already started")
+	BadArgCount    = errors.New("Wrong number of arguments")
+	BadArgType     = errors.New("Bad argument type")
+)
+
+// IsRunning() returns whether the service's state is StateRunning
+func (svc *DBusService) IsRunning() bool {
+	svc.lock.RLock()
+	defer svc.lock.RUnlock()
+	return svc.state == StateRunning
+}
+
+// Start() dials the bus, grab the name, and listens for method calls.
+func (svc *DBusService) Start(dispatchMap bus.DispatchMap, busAddr bus.Address) error {
+	svc.lock.Lock()
+	defer svc.lock.Unlock()
+	if svc.state != StateUnknown {
+		return AlreadyStarted
+	}
+	if svc.Log == nil || svc.Bus == nil {
+		return NotConfigured
+	}
+	err := svc.Bus.Dial()
+	if err != nil {
+		return err
+	}
+	ch := svc.Bus.GrabName(true)
+	log := svc.Log
+	go func() {
+		for err := range ch {
+			if !svc.IsRunning() {
+				break
+			}
+			if err != nil {
+				log.Fatalf("name channel for %s got: %v",
+					busAddr.Name, err)
+			}
+		}
+	}()
+	svc.Bus.WatchMethod(dispatchMap, svc)
+	svc.state = StateRunning
+	return nil
+}
+
+// Stop() closes the bus and sets the state to StateFinished
+func (svc *DBusService) Stop() {
+	svc.lock.Lock()
+	defer svc.lock.Unlock()
+	if svc.Bus != nil {
+		svc.Bus.Close()
+	}
+	svc.state = StateFinished
+}

=== added file 'client/service/postal.go'
--- client/service/postal.go	1970-01-01 00:00:00 +0000
+++ client/service/postal.go	2014-06-24 18:15:10 +0000
@@ -0,0 +1,122 @@
+/*
+ Copyright 2013-2014 Canonical Ltd.
+
+ This program is free software: you can redistribute it and/or modify it
+ under the terms of the GNU General Public License version 3, as published
+ by the Free Software Foundation.
+
+ This program is distributed in the hope that it will be useful, but
+ WITHOUT ANY WARRANTY; without even the implied warranties of
+ MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
+ PURPOSE.  See the GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License along
+ with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+package service
+
+import (
+	"strings"
+
+	"launchpad.net/ubuntu-push/bus"
+	"launchpad.net/ubuntu-push/logger"
+	"launchpad.net/ubuntu-push/nih"
+)
+
+// PostalService is the dbus api
+type PostalService struct {
+	DBusService
+	mbox       map[string][]string
+	msgHandler func([]byte) error
+}
+
+var (
+	PostalServiceBusAddress = bus.Address{
+		Interface: "com.ubuntu.Postal",
+		Path:      "/com/ubuntu/Postal/*",
+		Name:      "com.ubuntu.Postal",
+	}
+)
+
+// NewPostalService() builds a new service and returns it.
+func NewPostalService(bus bus.Endpoint, log logger.Logger) *PostalService {
+	var svc = &PostalService{}
+	svc.Log = log
+	svc.Bus = bus
+	return svc
+}
+
+// SetMessageHandler() sets the message-handling callback
+func (svc *PostalService) SetMessageHandler(callback func([]byte) error) {
+	svc.lock.RLock()
+	defer svc.lock.RUnlock()
+	svc.msgHandler = callback
+}
+
+// GetMessageHandler() returns the (possibly nil) messaging handler callback
+func (svc *PostalService) GetMessageHandler() func([]byte) error {
+	svc.lock.RLock()
+	defer svc.lock.RUnlock()
+	return svc.msgHandler
+}
+
+// Start() dials the bus, grab the name, and listens for method calls.
+func (svc *PostalService) Start() error {
+	return svc.DBusService.Start(bus.DispatchMap{
+		"Notifications": svc.notifications,
+		"Inject":        svc.inject,
+	}, PostalServiceBusAddress)
+}
+
+func (svc *PostalService) notifications(path string, args, _ []interface{}) ([]interface{}, error) {
+	if len(args) != 0 {
+		return nil, BadArgCount
+	}
+	appname := string(nih.Unquote([]byte(path[strings.LastIndex(path, "/")+1:])))
+
+	svc.lock.Lock()
+	defer svc.lock.Unlock()
+
+	if svc.mbox == nil {
+		return []interface{}{[]string(nil)}, nil
+	}
+	msgs := svc.mbox[appname]
+	delete(svc.mbox, appname)
+
+	return []interface{}{msgs}, nil
+}
+
+func (svc *PostalService) inject(path string, args, _ []interface{}) ([]interface{}, error) {
+	if len(args) != 1 {
+		return nil, BadArgCount
+	}
+	notif, ok := args[0].(string)
+	if !ok {
+		return nil, BadArgType
+	}
+	appname := string(nih.Unquote([]byte(path[strings.LastIndex(path, "/")+1:])))
+
+	return nil, svc.Inject(appname, notif)
+}
+
+// Inject() signals to an application over dbus that a notification
+// has arrived.
+func (svc *PostalService) Inject(appname string, notif string) error {
+	svc.lock.Lock()
+	defer svc.lock.Unlock()
+	if svc.mbox == nil {
+		svc.mbox = make(map[string][]string)
+	}
+	svc.mbox[appname] = append(svc.mbox[appname], notif)
+	if svc.msgHandler != nil {
+		err := svc.msgHandler([]byte(notif))
+		if err != nil {
+			svc.DBusService.Log.Errorf("msgHandler returned %v", err)
+			return err
+		}
+		svc.DBusService.Log.Debugf("call to msgHandler successful")
+	}
+
+	return svc.Bus.Signal("Notification", []interface{}{appname})
+}

=== added file 'client/service/postal_test.go'
--- client/service/postal_test.go	1970-01-01 00:00:00 +0000
+++ client/service/postal_test.go	2014-06-24 18:15:10 +0000
@@ -0,0 +1,191 @@
+/*
+ Copyright 2014 Canonical Ltd.
+
+ This program is free software: you can redistribute it and/or modify it
+ under the terms of the GNU General Public License version 3, as published
+ by the Free Software Foundation.
+
+ This program is distributed in the hope that it will be useful, but
+ WITHOUT ANY WARRANTY; without even the implied warranties of
+ MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
+ PURPOSE.  See the GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License along
+ with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+package service
+
+import (
+	"errors"
+
+	. "launchpad.net/gocheck"
+
+	"launchpad.net/ubuntu-push/bus"
+	testibus "launchpad.net/ubuntu-push/bus/testing"
+	"launchpad.net/ubuntu-push/logger"
+	helpers "launchpad.net/ubuntu-push/testing"
+	"launchpad.net/ubuntu-push/testing/condition"
+)
+
+type postalSuite struct {
+	log logger.Logger
+	bus bus.Endpoint
+}
+
+var _ = Suite(&postalSuite{})
+
+func (ss *postalSuite) SetUpTest(c *C) {
+	ss.log = helpers.NewTestLogger(c, "debug")
+	ss.bus = testibus.NewTestingEndpoint(condition.Work(true), nil)
+}
+
+func (ss *postalSuite) TestStart(c *C) {
+	svc := NewPostalService(ss.bus, ss.log)
+	c.Check(svc.IsRunning(), Equals, false)
+	c.Check(svc.Start(), IsNil)
+	c.Check(svc.IsRunning(), Equals, true)
+	svc.Stop()
+}
+
+func (ss *postalSuite) TestStartTwice(c *C) {
+	svc := NewPostalService(ss.bus, ss.log)
+	c.Check(svc.Start(), IsNil)
+	c.Check(svc.Start(), Equals, AlreadyStarted)
+	svc.Stop()
+}
+
+func (ss *postalSuite) TestStartNoLog(c *C) {
+	svc := NewPostalService(ss.bus, nil)
+	c.Check(svc.Start(), Equals, NotConfigured)
+}
+
+func (ss *postalSuite) TestStartNoBus(c *C) {
+	svc := NewPostalService(nil, ss.log)
+	c.Check(svc.Start(), Equals, NotConfigured)
+}
+
+func (ss *postalSuite) TestStartFailsOnBusDialFailure(c *C) {
+	bus := testibus.NewTestingEndpoint(condition.Work(false), nil)
+	svc := NewPostalService(bus, ss.log)
+	c.Check(svc.Start(), ErrorMatches, `.*(?i)cond said no.*`)
+	svc.Stop()
+}
+
+func (ss *postalSuite) TestStartGrabsName(c *C) {
+	svc := NewPostalService(ss.bus, ss.log)
+	c.Assert(svc.Start(), IsNil)
+	callArgs := testibus.GetCallArgs(ss.bus)
+	defer svc.Stop()
+	c.Assert(callArgs, NotNil)
+	c.Check(callArgs[0].Member, Equals, "::GrabName")
+}
+
+func (ss *postalSuite) TestStopClosesBus(c *C) {
+	svc := NewPostalService(ss.bus, ss.log)
+	c.Assert(svc.Start(), IsNil)
+	svc.Stop()
+	callArgs := testibus.GetCallArgs(ss.bus)
+	c.Assert(callArgs, NotNil)
+	c.Check(callArgs[len(callArgs)-1].Member, Equals, "::Close")
+}
+
+//
+// Injection tests
+
+func (ss *postalSuite) TestInjectWorks(c *C) {
+	svc := NewPostalService(ss.bus, ss.log)
+	rvs, err := svc.inject("/hello", []interface{}{"world"}, nil)
+	c.Assert(err, IsNil)
+	c.Check(rvs, IsNil)
+	rvs, err = svc.inject("/hello", []interface{}{"there"}, nil)
+	c.Assert(err, IsNil)
+	c.Check(rvs, IsNil)
+	c.Assert(svc.mbox, HasLen, 1)
+	c.Assert(svc.mbox["hello"], HasLen, 2)
+	c.Check(svc.mbox["hello"][0], Equals, "world")
+	c.Check(svc.mbox["hello"][1], Equals, "there")
+
+	// and check it fired the right signal (twice)
+	callArgs := testibus.GetCallArgs(ss.bus)
+	c.Assert(callArgs, HasLen, 2)
+	c.Check(callArgs[0].Member, Equals, "::Signal")
+	c.Check(callArgs[0].Args, DeepEquals, []interface{}{"Notification", []interface{}{"hello"}})
+	c.Check(callArgs[1], DeepEquals, callArgs[0])
+}
+
+func (ss *postalSuite) TestInjectFailsIfInjectFails(c *C) {
+	bus := testibus.NewTestingEndpoint(condition.Work(true),
+		condition.Work(false))
+	svc := NewPostalService(bus, ss.log)
+	svc.SetMessageHandler(func([]byte) error { return errors.New("fail") })
+	_, err := svc.inject("/hello", []interface{}{"xyzzy"}, nil)
+	c.Check(err, NotNil)
+}
+
+func (ss *postalSuite) TestInjectFailsIfBadArgs(c *C) {
+	for i, s := range []struct {
+		args []interface{}
+		errt error
+	}{
+		{nil, BadArgCount},
+		{[]interface{}{}, BadArgCount},
+		{[]interface{}{1}, BadArgType},
+		{[]interface{}{1, 2}, BadArgCount},
+	} {
+		reg, err := new(PostalService).inject("", s.args, nil)
+		c.Check(reg, IsNil, Commentf("iteration #%d", i))
+		c.Check(err, Equals, s.errt, Commentf("iteration #%d", i))
+	}
+}
+
+//
+// Notifications tests
+func (ss *postalSuite) TestNotificationsWorks(c *C) {
+	svc := NewPostalService(ss.bus, ss.log)
+	nots, err := svc.notifications("/hello", nil, nil)
+	c.Assert(err, IsNil)
+	c.Assert(nots, NotNil)
+	c.Assert(nots, HasLen, 1)
+	c.Check(nots[0], HasLen, 0)
+	if svc.mbox == nil {
+		svc.mbox = make(map[string][]string)
+	}
+	svc.mbox["hello"] = append(svc.mbox["hello"], "this", "thing")
+	nots, err = svc.notifications("/hello", nil, nil)
+	c.Assert(err, IsNil)
+	c.Assert(nots, NotNil)
+	c.Assert(nots, HasLen, 1)
+	c.Check(nots[0], DeepEquals, []string{"this", "thing"})
+}
+
+func (ss *postalSuite) TestNotificationsFailsIfBadArgs(c *C) {
+	reg, err := new(PostalService).notifications("/foo", []interface{}{1}, nil)
+	c.Check(reg, IsNil)
+	c.Check(err, Equals, BadArgCount)
+}
+
+func (ss *postalSuite) TestMessageHandler(c *C) {
+	svc := new(PostalService)
+	c.Assert(svc.msgHandler, IsNil)
+	var ext = []byte{}
+	e := errors.New("Hello")
+	f := func(s []byte) error { ext = s; return e }
+	c.Check(svc.GetMessageHandler(), IsNil)
+	svc.SetMessageHandler(f)
+	c.Check(svc.GetMessageHandler(), NotNil)
+	c.Check(svc.msgHandler([]byte("37")), Equals, e)
+	c.Check(ext, DeepEquals, []byte("37"))
+}
+
+func (ss *postalSuite) TestInjectCallsMessageHandler(c *C) {
+	var ext = []byte{}
+	svc := NewPostalService(ss.bus, ss.log)
+	f := func(s []byte) error { ext = s; return nil }
+	svc.SetMessageHandler(f)
+	c.Check(svc.Inject("stuff", "{}"), IsNil)
+	c.Check(ext, DeepEquals, []byte("{}"))
+	err := errors.New("ouch")
+	svc.SetMessageHandler(func([]byte) error { return err })
+	c.Check(svc.Inject("stuff", "{}"), Equals, err)
+}

=== modified file 'client/service/service.go'
--- client/service/service.go	2014-05-21 10:03:18 +0000
+++ client/service/service.go	2014-06-24 18:15:10 +0000
@@ -14,196 +14,184 @@
  with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-// package service implements the dbus-level service with which client
-// applications are expected to interact.
 package service
 
 import (
+	"bytes"
+	"encoding/json"
 	"errors"
+	"fmt"
+	"io/ioutil"
+	"net/http"
 	"os"
-	"sync"
+	"strings"
 
 	"launchpad.net/ubuntu-push/bus"
+	http13 "launchpad.net/ubuntu-push/http13client"
 	"launchpad.net/ubuntu-push/logger"
+	"launchpad.net/ubuntu-push/nih"
 )
 
-// Service is the dbus api
-type Service struct {
-	lock       sync.RWMutex
-	state      ServiceState
-	mbox       map[string][]string
-	msgHandler func([]byte) error
-	Log        logger.Logger
-	Bus        bus.Endpoint
+// PushService is the dbus api
+type PushService struct {
+	DBusService
+	regURL     string
+	deviceId   string
+	authGetter func(string) string
+	httpCli    http13.Client
 }
 
-// the service can be in a numnber of states
-type ServiceState uint8
-
-const (
-	StateUnknown  ServiceState = iota
-	StateRunning               // Start() has been successfully called
-	StateFinished              // Stop() has been successfully called
-)
-
 var (
-	NotConfigured  = errors.New("not configured")
-	AlreadyStarted = errors.New("already started")
-	BusAddress     = bus.Address{
+	PushServiceBusAddress = bus.Address{
 		Interface: "com.ubuntu.PushNotifications",
-		Path:      "/com/ubuntu/PushNotifications",
+		Path:      "/com/ubuntu/PushNotifications/*",
 		Name:      "com.ubuntu.PushNotifications",
 	}
 )
 
-// NewService() builds a new service and returns it.
-func NewService(bus bus.Endpoint, log logger.Logger) *Service {
-	return &Service{Log: log, Bus: bus}
-}
-
-// SetMessageHandler() sets the message-handling callback
-func (svc *Service) SetMessageHandler(callback func([]byte) error) {
-	svc.lock.Lock()
-	defer svc.lock.Unlock()
-	svc.msgHandler = callback
-}
-
-// GetMessageHandler() returns the (possibly nil) messaging handler callback
-func (svc *Service) GetMessageHandler() func([]byte) error {
-	svc.lock.RLock()
-	defer svc.lock.RUnlock()
-	return svc.msgHandler
-}
-
-// IsRunning() returns whether the service's state is StateRunning
-func (svc *Service) IsRunning() bool {
-	svc.lock.RLock()
-	defer svc.lock.RUnlock()
-	return svc.state == StateRunning
-}
-
-// Start() dials the bus, grab the name, and listens for method calls.
-func (svc *Service) Start() error {
-	svc.lock.Lock()
-	defer svc.lock.Unlock()
-	if svc.state != StateUnknown {
-		return AlreadyStarted
-	}
-	if svc.Log == nil || svc.Bus == nil {
-		return NotConfigured
-	}
-	err := svc.Bus.Dial()
-	if err != nil {
-		return err
-	}
-	ch := svc.Bus.GrabName(true)
-	log := svc.Log
-	go func() {
-		for err := range ch {
-			if !svc.IsRunning() {
-				break
-			}
-			if err != nil {
-				log.Fatalf("name channel for %s got: %v",
-					BusAddress.Name, err)
-			}
-		}
-	}()
-	svc.Bus.WatchMethod(bus.DispatchMap{
-		"Register":      svc.register,
-		"Notifications": svc.notifications,
-		"Inject":        svc.inject,
-	}, svc)
-	svc.state = StateRunning
-	return nil
-}
-
-// Stop() closes the bus and sets the state to StateFinished
-func (svc *Service) Stop() {
-	svc.lock.Lock()
-	defer svc.lock.Unlock()
-	if svc.Bus != nil {
-		svc.Bus.Close()
-	}
-	svc.state = StateFinished
+// NewPushService() builds a new service and returns it.
+func NewPushService(bus bus.Endpoint, log logger.Logger) *PushService {
+	var svc = &PushService{}
+	svc.Log = log
+	svc.Bus = bus
+	return svc
+}
+
+// SetRegistrationURL() sets the registration url for the service
+func (svc *PushService) SetRegistrationURL(url string) {
+	svc.lock.Lock()
+	defer svc.lock.Unlock()
+	svc.regURL = url
+}
+
+// SetAuthGetter() sets the authorization getter for the service
+func (svc *PushService) SetAuthGetter(authGetter func(string) string) {
+	svc.lock.Lock()
+	defer svc.lock.Unlock()
+	svc.authGetter = authGetter
+}
+
+// getRegistrationAuthorization() returns the authorization header for
+// POSTing to the registration HTTP endpoint
+//
+// (this is for calling with the lock held)
+func (svc *PushService) getRegistrationAuthorization() string {
+	if svc.authGetter != nil && svc.regURL != "" {
+		return svc.authGetter(svc.regURL)
+	} else {
+		return ""
+	}
+}
+
+// GetRegistrationAuthorization() returns the authorization header for
+// POSTing to the registration HTTP endpoint
+func (svc *PushService) GetRegistrationAuthorization() string {
+	svc.lock.RLock()
+	defer svc.lock.RUnlock()
+	return svc.getRegistrationAuthorization()
+}
+
+// SetDeviceId() sets the device id
+func (svc *PushService) SetDeviceId(deviceId string) {
+	svc.lock.Lock()
+	defer svc.lock.Unlock()
+	svc.deviceId = deviceId
+}
+
+// GetDeviceId() returns the device id
+func (svc *PushService) GetDeviceId() string {
+	svc.lock.RLock()
+	defer svc.lock.RUnlock()
+	return svc.deviceId
+}
+
+func (svc *PushService) Start() error {
+	return svc.DBusService.Start(bus.DispatchMap{
+		"Register": svc.register,
+	}, PushServiceBusAddress)
 }
 
 var (
-	BadArgCount = errors.New("Wrong number of arguments")
-	BadArgType  = errors.New("Bad argument type")
+	BadServer  = errors.New("Bad server")
+	BadRequest = errors.New("Bad request")
+	BadToken   = errors.New("Bad token")
+	BadAuth    = errors.New("Bad auth")
 )
 
-func (svc *Service) register(args []interface{}, _ []interface{}) ([]interface{}, error) {
-	if len(args) != 1 {
-		return nil, BadArgCount
-	}
-	appname, ok := args[0].(string)
-	if !ok {
-		return nil, BadArgType
-	}
-
-	rv := os.Getenv("PUSH_REG_" + appname)
-	if rv == "" {
-		rv = "this-is-an-opaque-block-of-random-bits-i-promise"
-	}
-
-	return []interface{}{rv}, nil
-}
-
-func (svc *Service) notifications(args []interface{}, _ []interface{}) ([]interface{}, error) {
-	if len(args) != 1 {
-		return nil, BadArgCount
-	}
-	appname, ok := args[0].(string)
-	if !ok {
-		return nil, BadArgType
-	}
-
-	svc.lock.Lock()
-	defer svc.lock.Unlock()
-
-	if svc.mbox == nil {
-		return []interface{}{[]string(nil)}, nil
-	}
-	msgs := svc.mbox[appname]
-	delete(svc.mbox, appname)
-
-	return []interface{}{msgs}, nil
-}
-
-func (svc *Service) inject(args []interface{}, _ []interface{}) ([]interface{}, error) {
-	if len(args) != 2 {
-		return nil, BadArgCount
-	}
-	appname, ok := args[0].(string)
-	if !ok {
-		return nil, BadArgType
-	}
-	notif, ok := args[1].(string)
-	if !ok {
-		return nil, BadArgType
-	}
-
-	return nil, svc.Inject(appname, notif)
-}
-
-// Inject() signals to an application over dbus that a notification
-// has arrived.
-func (svc *Service) Inject(appname string, notif string) error {
-	svc.lock.Lock()
-	defer svc.lock.Unlock()
-	if svc.mbox == nil {
-		svc.mbox = make(map[string][]string)
-	}
-	svc.mbox[appname] = append(svc.mbox[appname], notif)
-	if svc.msgHandler != nil {
-		err := svc.msgHandler([]byte(notif))
-		if err != nil {
-			svc.Log.Errorf("msgHandler returned %v", err)
-			return err
+type registrationRequest struct {
+	DeviceId string `json:"deviceid"`
+	AppId    string `json:"appid"`
+}
+
+type registrationReply struct {
+	Token   string `json:"token"`   // the bit we're after
+	Ok      bool   `json:"ok"`      // only ever true or absent
+	Error   string `json:"error"`   // these two only used for debugging
+	Message string `json:"message"` //
+}
+
+func (svc *PushService) register(path string, args, _ []interface{}) ([]interface{}, error) {
+	svc.lock.RLock()
+	defer svc.lock.RUnlock()
+	if len(args) != 0 {
+		return nil, BadArgCount
+	}
+	raw_appname := path[strings.LastIndex(path, "/")+1:]
+	appname := string(nih.Unquote([]byte(raw_appname)))
+
+	rv := os.Getenv("PUSH_REG_" + raw_appname)
+	if rv != "" {
+		return []interface{}{rv}, nil
+	}
+
+	req_body, err := json.Marshal(registrationRequest{svc.deviceId, appname})
+	if err != nil {
+		return nil, fmt.Errorf("unable to marshal register request body: %v", err)
+	}
+	req, err := http13.NewRequest("POST", svc.regURL, bytes.NewReader(req_body))
+	if err != nil {
+		return nil, fmt.Errorf("unable to build register request: %v", err)
+	}
+	auth := svc.getRegistrationAuthorization()
+	if auth == "" {
+		return nil, BadAuth
+	}
+	req.Header.Add("Authorization", auth)
+	req.Header.Add("Content-Type", "application/json")
+
+	resp, err := svc.httpCli.Do(req)
+	if err != nil {
+		return nil, fmt.Errorf("unable to request registration: %v", err)
+	}
+	defer resp.Body.Close()
+	if resp.StatusCode != http.StatusOK {
+		svc.Log.Errorf("register endpoint replied %d", resp.StatusCode)
+		switch {
+		case resp.StatusCode >= http.StatusInternalServerError:
+			// XXX retry on 503
+			return nil, BadServer
+		default:
+			return nil, BadRequest
 		}
-		svc.Log.Debugf("call to msgHandler successful")
-	}
-
-	return svc.Bus.Signal("Notification", []interface{}{appname})
+	}
+	// errors below here Can't Happen (tm).
+	body, err := ioutil.ReadAll(resp.Body)
+	if err != nil {
+		svc.Log.Errorf("Reading response body: %v", err)
+		return nil, err
+	}
+
+	var reply registrationReply
+	err = json.Unmarshal(body, &reply)
+	if err != nil {
+		svc.Log.Errorf("Unmarshalling response body: %v", err)
+		return nil, fmt.Errorf("unable to unmarshal register response: %v", err)
+	}
+
+	if !reply.Ok || reply.Token == "" {
+		svc.Log.Errorf("Unexpected response: %#v", reply)
+		return nil, BadToken
+	}
+
+	return []interface{}{reply.Token}, nil
 }

=== modified file 'client/service/service_test.go'
--- client/service/service_test.go	2014-05-21 10:05:24 +0000
+++ client/service/service_test.go	2014-06-24 18:15:10 +0000
@@ -17,7 +17,10 @@
 package service
 
 import (
-	"errors"
+	"encoding/json"
+	"fmt"
+	"net/http"
+	"net/http/httptest"
 	"os"
 	"testing"
 
@@ -45,7 +48,7 @@
 }
 
 func (ss *serviceSuite) TestStart(c *C) {
-	svc := NewService(ss.bus, ss.log)
+	svc := NewPushService(ss.bus, ss.log)
 	c.Check(svc.IsRunning(), Equals, false)
 	c.Check(svc.Start(), IsNil)
 	c.Check(svc.IsRunning(), Equals, true)
@@ -53,31 +56,31 @@
 }
 
 func (ss *serviceSuite) TestStartTwice(c *C) {
-	svc := NewService(ss.bus, ss.log)
+	svc := NewPushService(ss.bus, ss.log)
 	c.Check(svc.Start(), IsNil)
 	c.Check(svc.Start(), Equals, AlreadyStarted)
 	svc.Stop()
 }
 
 func (ss *serviceSuite) TestStartNoLog(c *C) {
-	svc := NewService(ss.bus, nil)
+	svc := NewPushService(ss.bus, nil)
 	c.Check(svc.Start(), Equals, NotConfigured)
 }
 
 func (ss *serviceSuite) TestStartNoBus(c *C) {
-	svc := NewService(nil, ss.log)
+	svc := NewPushService(nil, ss.log)
 	c.Check(svc.Start(), Equals, NotConfigured)
 }
 
 func (ss *serviceSuite) TestStartFailsOnBusDialFailure(c *C) {
 	bus := testibus.NewTestingEndpoint(condition.Work(false), nil)
-	svc := NewService(bus, ss.log)
+	svc := NewPushService(bus, ss.log)
 	c.Check(svc.Start(), ErrorMatches, `.*(?i)cond said no.*`)
 	svc.Stop()
 }
 
 func (ss *serviceSuite) TestStartGrabsName(c *C) {
-	svc := NewService(ss.bus, ss.log)
+	svc := NewPushService(ss.bus, ss.log)
 	c.Assert(svc.Start(), IsNil)
 	callArgs := testibus.GetCallArgs(ss.bus)
 	defer svc.Stop()
@@ -86,7 +89,7 @@
 }
 
 func (ss *serviceSuite) TestStopClosesBus(c *C) {
-	svc := NewService(ss.bus, ss.log)
+	svc := NewPushService(ss.bus, ss.log)
 	c.Assert(svc.Start(), IsNil)
 	svc.Stop()
 	callArgs := testibus.GetCallArgs(ss.bus)
@@ -96,36 +99,75 @@
 
 // registration tests
 
+func (ss *serviceSuite) TestSetRegURLWorks(c *C) {
+	svc := NewPushService(ss.bus, ss.log)
+	c.Check(svc.regURL, Equals, "")
+	svc.SetRegistrationURL("xyzzy://")
+	c.Check(svc.regURL, Equals, "xyzzy://")
+}
+
+func (ss *serviceSuite) TestSetAuthGetterWorks(c *C) {
+	svc := NewPushService(ss.bus, ss.log)
+	c.Check(svc.authGetter, IsNil)
+	f := func(string) string { return "" }
+	svc.SetAuthGetter(f)
+	c.Check(fmt.Sprintf("%#v", svc.authGetter), Equals, fmt.Sprintf("%#v", f))
+}
+
+func (ss *serviceSuite) TestGetRegAuthWorks(c *C) {
+	svc := NewPushService(ss.bus, ss.log)
+	svc.SetRegistrationURL("xyzzy://")
+	ch := make(chan string, 1)
+	f := func(s string) string { ch <- s; return "Auth " + s }
+	svc.SetAuthGetter(f)
+	c.Check(svc.getRegistrationAuthorization(), Equals, "Auth xyzzy://")
+	c.Assert(len(ch), Equals, 1)
+	c.Check(<-ch, Equals, "xyzzy://")
+}
+
+func (ss *serviceSuite) TestGetRegAuthDoesNotPanic(c *C) {
+	svc := NewPushService(ss.bus, ss.log)
+	c.Check(svc.getRegistrationAuthorization(), Equals, "")
+}
+
 func (ss *serviceSuite) TestRegistrationFailsIfBadArgs(c *C) {
-	for i, s := range []struct {
-		args []interface{}
-		errt error
-	}{
-		{nil, BadArgCount},                 // no args
-		{[]interface{}{}, BadArgCount},     // still no args
-		{[]interface{}{42}, BadArgType},    // bad arg type
-		{[]interface{}{1, 2}, BadArgCount}, // too many args
-	} {
-		reg, err := new(Service).register(s.args, nil)
-		c.Check(reg, IsNil, Commentf("iteration #%d", i))
-		c.Check(err, Equals, s.errt, Commentf("iteration #%d", i))
-	}
+	reg, err := new(PushService).register("", []interface{}{1}, nil)
+	c.Check(reg, IsNil)
+	c.Check(err, Equals, BadArgCount)
 }
 
 func (ss *serviceSuite) TestRegistrationWorks(c *C) {
-	reg, err := new(Service).register([]interface{}{"this"}, nil)
+	ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		buf := make([]byte, 256)
+		n, e := r.Body.Read(buf)
+		c.Assert(e, IsNil)
+		req := registrationRequest{}
+		c.Assert(json.Unmarshal(buf[:n], &req), IsNil)
+		c.Check(req, DeepEquals, registrationRequest{"fake-device-id", "an-app-id"})
+
+		w.Header().Set("Content-Type", "application/json")
+		fmt.Fprintln(w, `{"ok":true,"token":"blob-of-bytes"}`)
+	}))
+	defer ts.Close()
+
+	svc := NewPushService(ss.bus, ss.log)
+	svc.SetAuthGetter(func(string) string { return "tok" })
+	svc.SetRegistrationURL(ts.URL)
+	svc.SetDeviceId("fake-device-id")
+	// this'll check (un)quoting, too
+	reg, err := svc.register("/an_2dapp_2did", nil, nil)
+	c.Assert(err, IsNil)
 	c.Assert(reg, HasLen, 1)
 	regs, ok := reg[0].(string)
 	c.Check(ok, Equals, true)
-	c.Check(regs, Not(Equals), "")
-	c.Check(err, IsNil)
+	c.Check(regs, Equals, "blob-of-bytes")
 }
 
 func (ss *serviceSuite) TestRegistrationOverrideWorks(c *C) {
 	os.Setenv("PUSH_REG_stuff", "42")
 	defer os.Setenv("PUSH_REG_stuff", "")
 
-	reg, err := new(Service).register([]interface{}{"stuff"}, nil)
+	reg, err := new(PushService).register("/stuff", nil, nil)
 	c.Assert(reg, HasLen, 1)
 	regs, ok := reg[0].(string)
 	c.Check(ok, Equals, true)
@@ -133,115 +175,103 @@
 	c.Check(err, IsNil)
 }
 
-//
-// Injection tests
-
-func (ss *serviceSuite) TestInjectWorks(c *C) {
-	svc := NewService(ss.bus, ss.log)
-	rvs, err := svc.inject([]interface{}{"hello", "world"}, nil)
-	c.Assert(err, IsNil)
-	c.Check(rvs, IsNil)
-	rvs, err = svc.inject([]interface{}{"hello", "there"}, nil)
-	c.Assert(err, IsNil)
-	c.Check(rvs, IsNil)
-	c.Assert(svc.mbox, HasLen, 1)
-	c.Assert(svc.mbox["hello"], HasLen, 2)
-	c.Check(svc.mbox["hello"][0], Equals, "world")
-	c.Check(svc.mbox["hello"][1], Equals, "there")
-
-	// and check it fired the right signal (twice)
-	callArgs := testibus.GetCallArgs(ss.bus)
-	c.Assert(callArgs, HasLen, 2)
-	c.Check(callArgs[0].Member, Equals, "::Signal")
-	c.Check(callArgs[0].Args, DeepEquals, []interface{}{"Notification", []interface{}{"hello"}})
-	c.Check(callArgs[1], DeepEquals, callArgs[0])
-}
-
-func (ss *serviceSuite) TestInjectFailsIfInjectFails(c *C) {
-	bus := testibus.NewTestingEndpoint(condition.Work(true),
-		condition.Work(false))
-	svc := NewService(bus, ss.log)
-	svc.SetMessageHandler(func([]byte) error { return errors.New("fail") })
-	_, err := svc.inject([]interface{}{"hello", "xyzzy"}, nil)
-	c.Check(err, NotNil)
-}
-
-func (ss *serviceSuite) TestInjectFailsIfBadArgs(c *C) {
-	for i, s := range []struct {
-		args []interface{}
-		errt error
-	}{
-		{nil, BadArgCount},
-		{[]interface{}{}, BadArgCount},
-		{[]interface{}{1}, BadArgCount},
-		{[]interface{}{1, 2}, BadArgType},
-		{[]interface{}{"1", 2}, BadArgType},
-		{[]interface{}{1, "2"}, BadArgType},
-		{[]interface{}{1, 2, 3}, BadArgCount},
-	} {
-		reg, err := new(Service).inject(s.args, nil)
-		c.Check(reg, IsNil, Commentf("iteration #%d", i))
-		c.Check(err, Equals, s.errt, Commentf("iteration #%d", i))
-	}
-}
-
-//
-// Notifications tests
-func (ss *serviceSuite) TestNotificationsWorks(c *C) {
-	svc := NewService(ss.bus, ss.log)
-	nots, err := svc.notifications([]interface{}{"hello"}, nil)
-	c.Assert(err, IsNil)
-	c.Assert(nots, NotNil)
-	c.Assert(nots, HasLen, 1)
-	c.Check(nots[0], HasLen, 0)
-	if svc.mbox == nil {
-		svc.mbox = make(map[string][]string)
-	}
-	svc.mbox["hello"] = append(svc.mbox["hello"], "this", "thing")
-	nots, err = svc.notifications([]interface{}{"hello"}, nil)
-	c.Assert(err, IsNil)
-	c.Assert(nots, NotNil)
-	c.Assert(nots, HasLen, 1)
-	c.Check(nots[0], DeepEquals, []string{"this", "thing"})
-}
-
-func (ss *serviceSuite) TestNotificationsFailsIfBadArgs(c *C) {
-	for i, s := range []struct {
-		args []interface{}
-		errt error
-	}{
-		{nil, BadArgCount},                 // no args
-		{[]interface{}{}, BadArgCount},     // still no args
-		{[]interface{}{42}, BadArgType},    // bad arg type
-		{[]interface{}{1, 2}, BadArgCount}, // too many args
-	} {
-		reg, err := new(Service).notifications(s.args, nil)
-		c.Check(reg, IsNil, Commentf("iteration #%d", i))
-		c.Check(err, Equals, s.errt, Commentf("iteration #%d", i))
-	}
-}
-
-func (ss *serviceSuite) TestMessageHandler(c *C) {
-	svc := new(Service)
-	c.Assert(svc.msgHandler, IsNil)
-	var ext = []byte{}
-	e := errors.New("Hello")
-	f := func(s []byte) error { ext = s; return e }
-	c.Check(svc.GetMessageHandler(), IsNil)
-	svc.SetMessageHandler(f)
-	c.Check(svc.GetMessageHandler(), NotNil)
-	c.Check(svc.msgHandler([]byte("37")), Equals, e)
-	c.Check(ext, DeepEquals, []byte("37"))
-}
-
-func (ss *serviceSuite) TestInjectCallsMessageHandler(c *C) {
-	var ext = []byte{}
-	svc := NewService(ss.bus, ss.log)
-	f := func(s []byte) error { ext = s; return nil }
-	svc.SetMessageHandler(f)
-	c.Check(svc.Inject("stuff", "{}"), IsNil)
-	c.Check(ext, DeepEquals, []byte("{}"))
-	err := errors.New("ouch")
-	svc.SetMessageHandler(func([]byte) error { return err })
-	c.Check(svc.Inject("stuff", "{}"), Equals, err)
+func (ss *serviceSuite) TestRegistrationFailsOnBadReqURL(c *C) {
+	svc := NewPushService(ss.bus, ss.log)
+	svc.SetRegistrationURL("%gh")
+	reg, err := svc.register("thing", nil, nil)
+	c.Check(reg, IsNil)
+	c.Check(err, ErrorMatches, "unable to build register request: .*")
+}
+
+func (ss *serviceSuite) TestRegistrationFailsOnBadAuth(c *C) {
+	svc := NewPushService(ss.bus, ss.log)
+	// ... no auth added
+	reg, err := svc.register("thing", nil, nil)
+	c.Check(reg, IsNil)
+	c.Check(err, Equals, BadAuth)
+}
+
+func (ss *serviceSuite) TestRegistrationFailsOnNoServer(c *C) {
+	svc := NewPushService(ss.bus, ss.log)
+	svc.SetRegistrationURL("xyzzy://")
+	svc.SetAuthGetter(func(string) string { return "tok" })
+	reg, err := svc.register("thing", nil, nil)
+	c.Check(reg, IsNil)
+	c.Check(err, ErrorMatches, "unable to request registration: .*")
+}
+
+func (ss *serviceSuite) TestRegistrationFailsOn40x(c *C) {
+	ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		http.Error(w, "I'm a teapot", 418)
+	}))
+	defer ts.Close()
+
+	svc := NewPushService(ss.bus, ss.log)
+	svc.SetAuthGetter(func(string) string { return "tok" })
+	svc.SetRegistrationURL(ts.URL)
+	reg, err := svc.register("/thing", nil, nil)
+	c.Check(err, Equals, BadRequest)
+	c.Check(reg, IsNil)
+}
+
+func (ss *serviceSuite) TestRegistrationFailsOn50x(c *C) {
+	ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		http.Error(w, "Not implemented", 501)
+	}))
+	defer ts.Close()
+
+	svc := NewPushService(ss.bus, ss.log)
+	svc.SetAuthGetter(func(string) string { return "tok" })
+	svc.SetRegistrationURL(ts.URL)
+	reg, err := svc.register("/thing", nil, nil)
+	c.Check(err, Equals, BadServer)
+	c.Check(reg, IsNil)
+}
+
+func (ss *serviceSuite) TestRegistrationFailsOnBadJSON(c *C) {
+	ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		buf := make([]byte, 256)
+		n, e := r.Body.Read(buf)
+		c.Assert(e, IsNil)
+		req := registrationRequest{}
+		c.Assert(json.Unmarshal(buf[:n], &req), IsNil)
+		c.Check(req, DeepEquals, registrationRequest{"fake-device-id", "an-app-id"})
+
+		w.Header().Set("Content-Type", "application/json")
+		fmt.Fprintln(w, `{`)
+	}))
+	defer ts.Close()
+
+	svc := NewPushService(ss.bus, ss.log)
+	svc.SetAuthGetter(func(string) string { return "tok" })
+	svc.SetRegistrationURL(ts.URL)
+	svc.SetDeviceId("fake-device-id")
+	// this'll check (un)quoting, too
+	reg, err := svc.register("/an_2dapp_2did", nil, nil)
+	c.Check(reg, IsNil)
+	c.Check(err, ErrorMatches, "unable to unmarshal register response: .*")
+}
+
+func (ss *serviceSuite) TestRegistrationFailsOnBadJSONDocument(c *C) {
+	ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		buf := make([]byte, 256)
+		n, e := r.Body.Read(buf)
+		c.Assert(e, IsNil)
+		req := registrationRequest{}
+		c.Assert(json.Unmarshal(buf[:n], &req), IsNil)
+		c.Check(req, DeepEquals, registrationRequest{"fake-device-id", "an-app-id"})
+
+		w.Header().Set("Content-Type", "application/json")
+		fmt.Fprintln(w, `{"bananas": "very yes"}`)
+	}))
+	defer ts.Close()
+
+	svc := NewPushService(ss.bus, ss.log)
+	svc.SetAuthGetter(func(string) string { return "tok" })
+	svc.SetRegistrationURL(ts.URL)
+	svc.SetDeviceId("fake-device-id")
+	// this'll check (un)quoting, too
+	reg, err := svc.register("/an_2dapp_2did", nil, nil)
+	c.Check(reg, IsNil)
+	c.Check(err, Equals, BadToken)
 }

=== modified file 'client/session/session.go'
--- client/session/session.go	2014-05-23 05:59:38 +0000
+++ client/session/session.go	2014-06-24 18:15:10 +0000
@@ -26,7 +26,6 @@
 	"fmt"
 	"math/rand"
 	"net"
-	"os/exec"
 	"strings"
 	"sync"
 	"sync/atomic"
@@ -87,7 +86,8 @@
 	ExpectAllRepairedTime  time.Duration
 	PEM                    []byte
 	Info                   map[string]interface{}
-	AuthHelper             []string
+	AuthGetter             func(string) string
+	AuthURL                string
 }
 
 // ClientSession holds a client<->server session and its configuration.
@@ -244,21 +244,10 @@
 // addAuthorization gets the authorization blob to send to the server
 // and adds it to the session.
 func (sess *ClientSession) addAuthorization() error {
-	sess.Log.Debugf("adding authorization")
-	// using a helper, for now at least
-	if len(sess.AuthHelper) == 0 {
-		// do nothing if helper is unset or empty
-		return nil
-	}
-
-	auth, err := exec.Command(sess.AuthHelper[0], sess.AuthHelper[1:]...).Output()
-	if err != nil {
-		// For now we just log the error, as we don't want to block unauthorized users
-		sess.Log.Errorf("unable to get the authorization token from the account: %v", err)
-	} else {
-		sess.auth = strings.TrimSpace(string(auth))
-	}
-
+	if sess.AuthGetter != nil {
+		sess.Log.Debugf("adding authorization")
+		sess.auth = sess.AuthGetter(sess.AuthURL)
+	}
 	return nil
 }
 

=== modified file 'client/session/session_test.go'
--- client/session/session_test.go	2014-05-23 05:59:38 +0000
+++ client/session/session_test.go	2014-06-24 18:15:10 +0000
@@ -353,34 +353,21 @@
 ****************************************************************/
 
 func (cs *clientSessionSuite) TestAddAuthorizationAddsAuthorization(c *C) {
-	sess := &ClientSession{Log: cs.log}
-	sess.AuthHelper = []string{"echo", "some auth"}
-	c.Assert(sess.auth, Equals, "")
-	err := sess.addAuthorization()
-	c.Assert(err, IsNil)
-	c.Check(sess.auth, Equals, "some auth")
-}
-
-func (cs *clientSessionSuite) TestAddAuthorizationIgnoresErrors(c *C) {
-	sess := &ClientSession{Log: cs.log}
-	sess.AuthHelper = []string{"sh", "-c", "echo hello; false"}
-
-	c.Assert(sess.auth, Equals, "")
-	err := sess.addAuthorization()
-	c.Assert(err, IsNil)
-	c.Check(sess.auth, Equals, "")
-}
-
-func (cs *clientSessionSuite) TestAddAuthorizationSkipsIfUnsetOrNil(c *C) {
-	sess := &ClientSession{Log: cs.log}
-	sess.AuthHelper = nil
-	c.Assert(sess.auth, Equals, "")
-	err := sess.addAuthorization()
-	c.Assert(err, IsNil)
-	c.Check(sess.auth, Equals, "")
-
-	sess.AuthHelper = []string{}
-	err = sess.addAuthorization()
+	url := "xyzzy://"
+	sess := &ClientSession{Log: cs.log}
+	sess.AuthGetter = func(url string) string { return url + " auth'ed" }
+	sess.AuthURL = url
+	c.Assert(sess.auth, Equals, "")
+	err := sess.addAuthorization()
+	c.Assert(err, IsNil)
+	c.Check(sess.auth, Equals, "xyzzy:// auth'ed")
+}
+
+func (cs *clientSessionSuite) TestAddAuthorizationSkipsIfUnset(c *C) {
+	sess := &ClientSession{Log: cs.log}
+	sess.AuthGetter = nil
+	c.Assert(sess.auth, Equals, "")
+	err := sess.addAuthorization()
 	c.Assert(err, IsNil)
 	c.Check(sess.auth, Equals, "")
 }

=== modified file 'debian/changelog'
--- debian/changelog	2014-06-05 09:42:22 +0000
+++ debian/changelog	2014-06-24 18:15:10 +0000
@@ -1,3 +1,35 @@
+ubuntu-push (0.41ubuntu1) UNRELEASED; urgency=medium
+
+  [ Samuele Pedroni ]
+  * Support registering tokens and sending notifications with a token
+  * Register script and scripts unicast support
+  * Update http13client from the actual go1.3 release
+  * Avoid late pings in the face of nop exchanges
+  * murmur3 upstream change of seed to 0
+
+  [ Roberto Alsina ]
+  * Make signing-helper generate a HTTP header instead of a querystring,
+    and take a URL to sign.
+  * Wrap libmessaging-menu to allow for persistent notifications.
+  * Wrap ubuntu-app-launch start_helper / stop_helper functions.
+
+  [ John R. Lenton ]
+  * Switch dbus api to retrieve app name from dbus path.
+  * Move signing bits up from session to client, for reuse by service.
+  * Change AuthHelper to be a string; auth helper should now expect a
+    parameter (the url to sign). Added SessionURL to config.
+  * Adapt our whoopsie wrapper to whoopsie's now more correct behavior wrt
+    failing to get a mac address.
+  * Add registration_url to config; hook up auth bits and reg url to
+    client & service.
+  * Do an HTTP POST to registration_url on register.
+  * Fix debian/rules so packaging-time tests pass (ugh)
+
+  [ Guillermo Gonzalez ]
+  * Split DBus service into PushService and PostalService
+
+ -- John R. Lenton <[e-mail]>  Fri, 06 Jun 2014 12:02:56 +0100
+
 ubuntu-push (0.3+14.10.20140605-0ubuntu1) utopic; urgency=medium
 
   [ John Lenton ]

=== modified file 'debian/config.json'
--- debian/config.json	2014-06-04 12:18:42 +0000
+++ debian/config.json	2014-06-24 18:15:10 +0000
@@ -1,5 +1,7 @@
 {
-    "auth_helper": [],
+    "auth_helper": "/usr/lib/ubuntu-push-client/signing-helper",
+    "session_url": "https://push.ubuntu.com/",
+    "registration_url": "https://push.ubuntu.com/register",
     "connect_timeout": "20s",
     "exchange_timeout": "30s",
     "hosts_cache_expiry": "12h",

=== modified file 'debian/control'
--- debian/control	2014-06-02 10:01:13 +0000
+++ debian/control	2014-06-24 18:15:10 +0000
@@ -14,7 +14,9 @@
                golang-uuid-dev,
                libgcrypt11-dev,
                libglib2.0-dev (>= 2.31.6),
+               libmessaging-menu-dev,
                libwhoopsie-dev,
+               libubuntu-app-launch2-dev,
                libubuntuoneauth-2.0-dev,
                libdbus-1-dev,
                libnih-dbus-dev,

=== modified file 'debian/rules'
--- debian/rules	2014-05-02 12:42:27 +0000
+++ debian/rules	2014-06-24 18:15:10 +0000
@@ -5,10 +5,15 @@
 export UBUNTU_PUSH_TEST_RESOURCES_ROOT := $(CURDIR)
 
 override_dh_auto_build:
-	cd $$( find ./ -type d -regex '\./[^/]*/src/launchpad.net' -printf "%h\n" | head -n1)
 	dh_auto_build --buildsystem=golang
 	(cd signing-helper && cmake . && make)
 
+# overriding dh_auto_test because the http13client tests don't all pass on go < 1.3
+# (should go away once we ship go 1.3)
+override_dh_auto_test:
+	cd $$( find ./ -type d -regex '\./[^/]*/src/launchpad.net' -printf "%h\n" | head -n1) && \
+	env GOPATH=$$(cd ..; pwd) go test $$(env GOPATH=$$(cd ..; pwd) go list $(DH_GOPKG)/... | grep -v acceptance | grep -v http13client )
+
 override_dh_install:
 	dh_install -Xusr/bin/cmd -Xusr/bin/dev --fail-missing
 

=== modified file 'external/README'
--- external/README	2014-03-24 15:37:36 +0000
+++ external/README	2014-06-24 18:15:10 +0000
@@ -1,3 +1,3 @@
 Directly included vendorized small packages.
 
-* murmor3 comes from import at lp:~ubuntu-push-hackers/ubuntu-push/murmur at revno 10
+* murmur3 comes from import at lp:~ubuntu-push-hackers/ubuntu-push/murmur at revno 12

=== modified file 'external/murmur3/murmur128.go'
--- external/murmur3/murmur128.go	2014-03-24 15:31:42 +0000
+++ external/murmur3/murmur128.go	2014-06-24 18:15:10 +0000
@@ -40,7 +40,7 @@
 
 func (d *digest128) Size() int { return 16 }
 
-func (d *digest128) reset() { d.h1, d.h2 = 1, 1 }
+func (d *digest128) reset() { d.h1, d.h2 = 0, 0 }
 
 func (d *digest128) Sum(b []byte) []byte {
 	h1, h2 := d.h1, d.h2
@@ -182,7 +182,7 @@
 //     hasher.Write(data)
 //     return hasher.Sum128()
 func Sum128(data []byte) (h1 uint64, h2 uint64) {
-	d := &digest128{h1: 1, h2: 1}
+	d := &digest128{h1: 0, h2: 0}
 	d.tail = d.bmix(data)
 	d.clen = len(data)
 	return d.Sum128()

=== modified file 'external/murmur3/murmur32.go'
--- external/murmur3/murmur32.go	2014-03-24 15:31:42 +0000
+++ external/murmur3/murmur32.go	2014-06-24 18:15:10 +0000
@@ -33,7 +33,7 @@
 
 func (d *digest32) Size() int { return 4 }
 
-func (d *digest32) reset() { d.h1 = 1 }
+func (d *digest32) reset() { d.h1 = 0 }
 
 func (d *digest32) Sum(b []byte) []byte {
 	h := d.h1
@@ -104,7 +104,7 @@
 //     return hasher.Sum32()
 func Sum32(data []byte) uint32 {
 
-	var h1 uint32 = 1
+	var h1 uint32 = 0
 
 	nblocks := len(data) / 4
 	var p uintptr

=== modified file 'external/murmur3/murmur64.go'
--- external/murmur3/murmur64.go	2014-03-24 15:31:42 +0000
+++ external/murmur3/murmur64.go	2014-06-24 18:15:10 +0000
@@ -37,7 +37,7 @@
 //     hasher.Write(data)
 //     return hasher.Sum64()
 func Sum64(data []byte) uint64 {
-	d := &digest128{h1: 1, h2: 1}
+	d := &digest128{h1: 0, h2: 0}
 	d.tail = d.bmix(data)
 	d.clen = len(data)
 	h1, _ := d.Sum128()

=== modified file 'external/murmur3/murmur_test.go'
--- external/murmur3/murmur_test.go	2014-03-24 15:31:42 +0000
+++ external/murmur3/murmur_test.go	2014-06-24 18:15:10 +0000
@@ -11,11 +11,11 @@
 	h64_2 uint64
 	s     string
 }{
-	{0x514e28b7, 0x4610abe56eff5cb5, 0x51622daa78f83583, ""},
-	{0xbb4abcad, 0xa78ddff5adae8d10, 0x128900ef20900135, "hello"},
-	{0x6f5cb2e9, 0x8b95f808840725c6, 0x1597ed5422bd493b, "hello, world"},
-	{0xf50e1f30, 0x2a929de9c8f97b2f, 0x56a41d99af43a2db, "19 Jan 2038 at 3:14:07 AM"},
-	{0x846f6a36, 0xfb3325171f9744da, 0xaaf8b92a5f722952, "The quick brown fox jumps over the lazy dog."},
+	{0x00000000, 0x0000000000000000, 0x0000000000000000, ""},
+	{0x248bfa47, 0xcbd8a7b341bd9b02, 0x5b1e906a48ae1d19, "hello"},
+	{0x149bbb7f, 0x342fac623a5ebc8e, 0x4cdcbc079642414d, "hello, world"},
+	{0xe31e8a70, 0xb89e5988b737affc, 0x664fc2950231b2cb, "19 Jan 2038 at 3:14:07 AM"},
+	{0xd5c48bfc, 0xcd99481f9ee902c9, 0x695da1a38987b6e7, "The quick brown fox jumps over the lazy dog."},
 }
 
 func TestRef(t *testing.T) {
@@ -37,6 +37,10 @@
 			t.Errorf("'%s': 0x%x (want 0x%x)", elem.s, v, elem.h64_1)
 		}
 
+		if v := Sum64([]byte(elem.s)); v != elem.h64_1 {
+			t.Errorf("'%s': 0x%x (want 0x%x)", elem.s, v, elem.h64_1)
+		}
+
 		var h128 Hash128 = New128()
 		h128.Write([]byte(elem.s))
 		if v1, v2 := h128.Sum128(); v1 != elem.h64_1 || v2 != elem.h64_2 {

=== modified file 'http13client/Makefile'
--- http13client/Makefile	2014-03-20 12:15:36 +0000
+++ http13client/Makefile	2014-06-24 18:15:10 +0000
@@ -20,7 +20,8 @@
 
 prune:
 	rm -rf example_test.go filetransport*.go fs*.go race.go range_test.go \
-	sniff*.go httptest httputil testdata triv.go jar.go status.go
+	sniff*.go httptest httputil testdata triv.go jar.go status.go \
+	cookie_test.go
 	sed -i -e 's+"launchpad.net/ubuntu-push/http13client/+"net/http/+' *.go
 
 fix:

=== modified file 'http13client/_patches/empty_server.patch'
--- http13client/_patches/empty_server.patch	2014-03-19 23:13:58 +0000
+++ http13client/_patches/empty_server.patch	2014-06-24 18:15:10 +0000
@@ -1,6 +1,6 @@
 === modified file 'http13client/serve_test.go'
---- http13client/serve_test.go	2014-03-19 21:38:56 +0000
-+++ http13client/serve_test.go	2014-03-19 22:27:37 +0000
+--- http13client/serve_test.go	2014-06-20 11:00:47 +0000
++++ http13client/serve_test.go	2014-06-20 12:00:22 +0000
 @@ -2,60 +2,15 @@
  // Use of this source code is governed by a BSD-style
  // license that can be found in the LICENSE file.
@@ -62,7 +62,7 @@
  
  func (a dummyAddr) Network() string {
  	return string(a)
-@@ -93,1289 +48,6 @@
+@@ -93,1325 +48,6 @@
  	return nil
  }
  
@@ -906,31 +906,50 @@
 -}
 -
 -type serverExpectTest struct {
--	contentLength    int    // of request body
+-	contentLength    int // of request body
+-	chunked          bool
 -	expectation      string // e.g. "100-continue"
 -	readBody         bool   // whether handler should read the body (if false, sends StatusUnauthorized)
 -	expectedResponse string // expected substring in first line of http response
 -}
 -
+-func expectTest(contentLength int, expectation string, readBody bool, expectedResponse string) serverExpectTest {
+-	return serverExpectTest{
+-		contentLength:    contentLength,
+-		expectation:      expectation,
+-		readBody:         readBody,
+-		expectedResponse: expectedResponse,
+-	}
+-}
+-
 -var serverExpectTests = []serverExpectTest{
 -	// Normal 100-continues, case-insensitive.
--	{100, "100-continue", true, "100 Continue"},
--	{100, "100-cOntInUE", true, "100 Continue"},
+-	expectTest(100, "100-continue", true, "100 Continue"),
+-	expectTest(100, "100-cOntInUE", true, "100 Continue"),
 -
 -	// No 100-continue.
--	{100, "", true, "200 OK"},
+-	expectTest(100, "", true, "200 OK"),
 -
 -	// 100-continue but requesting client to deny us,
 -	// so it never reads the body.
--	{100, "100-continue", false, "401 Unauthorized"},
+-	expectTest(100, "100-continue", false, "401 Unauthorized"),
 -	// Likewise without 100-continue:
--	{100, "", false, "401 Unauthorized"},
+-	expectTest(100, "", false, "401 Unauthorized"),
 -
 -	// Non-standard expectations are failures
--	{0, "a-pony", false, "417 Expectation Failed"},
+-	expectTest(0, "a-pony", false, "417 Expectation Failed"),
 -
--	// Expect-100 requested but no body
--	{0, "100-continue", true, "400 Bad Request"},
+-	// Expect-100 requested but no body (is apparently okay: Issue 7625)
+-	expectTest(0, "100-continue", true, "200 OK"),
+-	// Expect-100 requested but handler doesn't read the body
+-	expectTest(0, "100-continue", false, "401 Unauthorized"),
+-	// Expect-100 continue with no body, but a chunked body.
+-	{
+-		expectation:      "100-continue",
+-		readBody:         true,
+-		chunked:          true,
+-		expectedResponse: "100 Continue",
+-	},
 -}
 -
 -// Tests that the server responds to the "Expect" request header
@@ -959,21 +978,38 @@
 -
 -		// Only send the body immediately if we're acting like an HTTP client
 -		// that doesn't send 100-continue expectations.
--		writeBody := test.contentLength > 0 && strings.ToLower(test.expectation) != "100-continue"
+-		writeBody := test.contentLength != 0 && strings.ToLower(test.expectation) != "100-continue"
 -
 -		go func() {
+-			contentLen := fmt.Sprintf("Content-Length: %d", test.contentLength)
+-			if test.chunked {
+-				contentLen = "Transfer-Encoding: chunked"
+-			}
 -			_, err := fmt.Fprintf(conn, "POST /?readbody=%v HTTP/1.1\r\n"+
 -				"Connection: close\r\n"+
--				"Content-Length: %d\r\n"+
+-				"%s\r\n"+
 -				"Expect: %s\r\nHost: foo\r\n\r\n",
--				test.readBody, test.contentLength, test.expectation)
+-				test.readBody, contentLen, test.expectation)
 -			if err != nil {
 -				t.Errorf("On test %#v, error writing request headers: %v", test, err)
 -				return
 -			}
 -			if writeBody {
+-				var targ io.WriteCloser = struct {
+-					io.Writer
+-					io.Closer
+-				}{
+-					conn,
+-					ioutil.NopCloser(nil),
+-				}
+-				if test.chunked {
+-					targ = httputil.NewChunkedWriter(conn)
+-				}
 -				body := strings.Repeat("A", test.contentLength)
--				_, err = fmt.Fprint(conn, body)
+-				_, err = fmt.Fprint(targ, body)
+-				if err == nil {
+-					err = targ.Close()
+-				}
 -				if err != nil {
 -					if !test.readBody {
 -						// Server likely already hung up on us.
@@ -1352,7 +1388,7 @@
  type neverEnding byte
  
  func (b neverEnding) Read(p []byte) (n int, err error) {
-@@ -1384,1344 +56,3 @@
+@@ -1420,1392 +56,3 @@
  	}
  	return len(p), nil
  }
@@ -2080,7 +2116,7 @@
 -			got := ht.rawResponse(req)
 -			wantStatus := fmt.Sprintf("%d %s", code, StatusText(code))
 -			if !strings.Contains(got, wantStatus) {
--				t.Errorf("Code %d: Wanted %q Modified for %q: %s", code, req, got)
+-				t.Errorf("Code %d: Wanted %q Modified for %q: %s", code, wantStatus, req, got)
 -			} else if strings.Contains(got, "Content-Length") {
 -				t.Errorf("Code %d: Got a Content-Length from %q: %s", code, req, got)
 -			} else if strings.Contains(got, "stuff") {
@@ -2090,6 +2126,21 @@
 -	}
 -}
 -
+-func TestContentTypeOkayOn204(t *testing.T) {
+-	ht := newHandlerTest(HandlerFunc(func(w ResponseWriter, r *Request) {
+-		w.Header().Set("Content-Length", "123") // suppressed
+-		w.Header().Set("Content-Type", "foo/bar")
+-		w.WriteHeader(204)
+-	}))
+-	got := ht.rawResponse("GET / HTTP/1.1")
+-	if !strings.Contains(got, "Content-Type: foo/bar") {
+-		t.Errorf("Response = %q; want Content-Type: foo/bar", got)
+-	}
+-	if strings.Contains(got, "Content-Length: 123") {
+-		t.Errorf("Response = %q; don't want a Content-Length", got)
+-	}
+-}
+-
 -// Issue 6995
 -// A server Handler can receive a Request, and then turn around and
 -// give a copy of that Request.Body out to the Transport (e.g. any
@@ -2261,7 +2312,7 @@
 -	ts.Config.ErrorLog = log.New(ioutil.Discard, "", 0)
 -	ts.Config.ConnState = func(c net.Conn, state ConnState) {
 -		if c == nil {
--			t.Error("nil conn seen in state %s", state)
+-			t.Errorf("nil conn seen in state %s", state)
 -			return
 -		}
 -		mu.Lock()
@@ -2397,6 +2448,39 @@
 -	}
 -}
 -
+-// golang.org/issue/7856
+-func TestServerEmptyBodyRace(t *testing.T) {
+-	defer afterTest(t)
+-	var n int32
+-	ts := httptest.NewServer(HandlerFunc(func(rw ResponseWriter, req *Request) {
+-		atomic.AddInt32(&n, 1)
+-	}))
+-	defer ts.Close()
+-	var wg sync.WaitGroup
+-	const reqs = 20
+-	for i := 0; i < reqs; i++ {
+-		wg.Add(1)
+-		go func() {
+-			defer wg.Done()
+-			res, err := Get(ts.URL)
+-			if err != nil {
+-				t.Error(err)
+-				return
+-			}
+-			defer res.Body.Close()
+-			_, err = io.Copy(ioutil.Discard, res.Body)
+-			if err != nil {
+-				t.Error(err)
+-				return
+-			}
+-		}()
+-	}
+-	wg.Wait()
+-	if got := atomic.LoadInt32(&n); got != reqs {
+-		t.Errorf("handler ran %d times; want %d", got, reqs)
+-	}
+-}
+-
 -func TestServerConnStateNew(t *testing.T) {
 -	sawNew := false // if the test is buggy, we'll race on this variable.
 -	srv := &Server{
@@ -2699,9 +2783,9 @@
 -}
 
 === modified file 'http13client/server.go'
---- http13client/server.go	2014-03-19 20:20:19 +0000
-+++ http13client/server.go	2014-03-19 22:27:37 +0000
-@@ -2,1984 +2,17 @@
+--- http13client/server.go	2014-06-20 11:00:47 +0000
++++ http13client/server.go	2014-06-20 12:05:53 +0000
+@@ -2,1976 +2,16 @@
  // Use of this source code is governed by a BSD-style
  // license that can be found in the LICENSE file.
  
@@ -2723,7 +2807,7 @@
 -	"path"
 -	"runtime"
 -	"strconv"
- 	"strings"
+-	"strings"
  	"sync"
 -	"sync/atomic"
 -	"time"
@@ -3506,18 +3590,16 @@
 -	}
 -
 -	code := w.status
--	if !bodyAllowedForStatus(code) {
--		// Must not have body.
--		// RFC 2616 section 10.3.5: "the response MUST NOT include other entity-headers"
--		for _, k := range []string{"Content-Type", "Content-Length", "Transfer-Encoding"} {
--			delHeader(k)
--		}
--	} else {
+-	if bodyAllowedForStatus(code) {
 -		// If no content type, apply sniffing algorithm to body.
 -		_, haveType := header["Content-Type"]
 -		if !haveType {
 -			setHeader.contentType = DetectContentType(p)
 -		}
+-	} else {
+-		for _, k := range suppressedHeaders(code) {
+-			delHeader(k)
+-		}
 -	}
 -
 -	if _, ok := header["Date"]; !ok {
@@ -3865,16 +3947,10 @@
 -		// Expect 100 Continue support
 -		req := w.req
 -		if req.expectsContinue() {
--			if req.ProtoAtLeast(1, 1) {
+-			if req.ProtoAtLeast(1, 1) && req.ContentLength != 0 {
 -				// Wrap the Body reader with one that replies on the connection
 -				req.Body = &expectContinueReader{readCloser: req.Body, resp: w}
 -			}
--			if req.ContentLength == 0 {
--				w.Header().Set("Connection", "close")
--				w.WriteHeader(StatusBadRequest)
--				w.finishRequest()
--				break
--			}
 -			req.Header.Del("Expect")
 -		} else if req.Header.get("Expect") != "" {
 -			w.sendExpectationFailed()
@@ -4685,11 +4761,11 @@
 -}
 +)
  
- // eofReader is a non-nil io.ReadCloser that always returns EOF.
- // It embeds a *strings.Reader so it still has a WriteTo method
-@@ -1992,28 +25,6 @@
- 	ioutil.NopCloser(nil),
- }
+ type eofReaderWithWriteTo struct{}
+ 
+@@ -1991,28 +31,6 @@
+ // Verify that an io.Copy from an eofReader won't require a buffer.
+ var _ io.WriterTo = eofReader
  
 -// initNPNRequest is an HTTP handler that initializes certain
 -// uninitialized fields in its *Request. Such partially-initialized

=== modified file 'http13client/_patches/fix_code.patch'
--- http13client/_patches/fix_code.patch	2014-03-19 23:13:58 +0000
+++ http13client/_patches/fix_code.patch	2014-06-24 18:15:10 +0000
@@ -1,6 +1,6 @@
 === modified file 'http13client/client.go'
---- http13client/client.go	2014-03-19 20:20:19 +0000
-+++ http13client/client.go	2014-03-19 22:27:37 +0000
+--- http13client/client.go	2014-06-20 11:00:47 +0000
++++ http13client/client.go	2014-06-20 12:05:53 +0000
 @@ -17,6 +17,7 @@
  	"io/ioutil"
  	"log"
@@ -18,7 +18,7 @@
  
  	// Timeout specifies a time limit for requests made by this
  	// Client. The timeout includes connection time, any
-@@ -177,7 +178,7 @@
+@@ -184,7 +185,7 @@
  	// Headers, leaving it uninitialized.  We guarantee to the
  	// Transport that this has been initialized, though.
  	if req.Header == nil {
@@ -27,7 +27,7 @@
  	}
  
  	if u := req.URL.User; u != nil {
-@@ -308,7 +309,7 @@
+@@ -316,7 +317,7 @@
  			if ireq.Method == "POST" || ireq.Method == "PUT" {
  				nreq.Method = "GET"
  			}
@@ -38,8 +38,8 @@
  				break
 
 === modified file 'http13client/cookie.go'
---- http13client/cookie.go	2014-03-19 20:20:19 +0000
-+++ http13client/cookie.go	2014-03-19 22:27:37 +0000
+--- http13client/cookie.go	2014-06-20 11:00:47 +0000
++++ http13client/cookie.go	2014-06-20 12:05:53 +0000
 @@ -5,10 +5,9 @@
  package http
  
@@ -94,7 +94,7 @@
  			Name:  name,
  			Value: value,
  			Raw:   line,
-@@ -129,59 +108,12 @@
+@@ -125,59 +104,12 @@
  	return cookies
  }
  
@@ -156,7 +156,7 @@
  	lines, ok := h["Cookie"]
  	if !ok {
  		return cookies
-@@ -213,7 +145,7 @@
+@@ -209,7 +141,7 @@
  			if !success {
  				continue
  			}
@@ -167,8 +167,8 @@
  	}
 
 === modified file 'http13client/header.go'
---- http13client/header.go	2014-03-19 20:20:19 +0000
-+++ http13client/header.go	2014-03-19 22:27:37 +0000
+--- http13client/header.go	2014-06-20 11:00:47 +0000
++++ http13client/header.go	2014-06-20 12:00:22 +0000
 @@ -5,176 +5,9 @@
  package http
  
@@ -348,8 +348,8 @@
  // token must be all lowercase.
 
 === modified file 'http13client/request.go'
---- http13client/request.go	2014-03-19 20:20:19 +0000
-+++ http13client/request.go	2014-03-19 22:27:37 +0000
+--- http13client/request.go	2014-06-20 11:00:47 +0000
++++ http13client/request.go	2014-06-20 12:05:53 +0000
 @@ -16,6 +16,7 @@
  	"io/ioutil"
  	"mime"
@@ -358,25 +358,25 @@
  	"net/textproto"
  	"net/url"
  	"strconv"
-@@ -103,7 +104,7 @@
- 	// The request parser implements this by canonicalizing the
- 	// name, making the first character and any characters
- 	// following a hyphen uppercase and the rest lowercase.
+@@ -121,7 +122,7 @@
+ 	// added and may override values in Header.
+ 	//
+ 	// See the documentation for the Request.Write method.
 -	Header Header
 +	Header http.Header
  
  	// Body is the request's body.
  	//
-@@ -164,7 +165,7 @@
- 	// For server requests, Trailer is only populated after Body has been
- 	// closed or fully consumed.
- 	// Trailer support is only partially complete.
+@@ -199,7 +200,7 @@
+ 	// not mutate Trailer.
+ 	//
+ 	// Few HTTP clients, servers, or proxies support HTTP trailers.
 -	Trailer Header
 +	Trailer http.Header
  
  	// RemoteAddr allows HTTP servers and other software to record
  	// the network address that sent the request, usually for
-@@ -204,7 +205,7 @@
+@@ -239,7 +240,7 @@
  }
  
  // Cookies parses and returns the HTTP cookies sent with the request.
@@ -385,7 +385,7 @@
  	return readCookies(r.Header, "")
  }
  
-@@ -212,7 +213,7 @@
+@@ -247,7 +248,7 @@
  
  // Cookie returns the named cookie provided in the request or
  // ErrNoCookie if not found.
@@ -394,7 +394,7 @@
  	for _, c := range readCookies(r.Header, name) {
  		return c, nil
  	}
-@@ -223,7 +224,7 @@
+@@ -258,7 +259,7 @@
  // AddCookie does not attach more than one Cookie header field.  That
  // means all cookies, if any, are written into the same line,
  // separated by semicolon.
@@ -403,7 +403,7 @@
  	s := fmt.Sprintf("%s=%s", sanitizeCookieName(c.Name), sanitizeCookieValue(c.Value))
  	if c := r.Header.Get("Cookie"); c != "" {
  		r.Header.Set("Cookie", c+"; "+s)
-@@ -326,7 +327,7 @@
+@@ -361,7 +362,7 @@
  }
  
  // extraHeaders may be nil
@@ -412,7 +412,7 @@
  	host := req.Host
  	if host == "" {
  		if req.URL == nil {
-@@ -456,7 +457,7 @@
+@@ -490,7 +491,7 @@
  		Proto:      "HTTP/1.1",
  		ProtoMajor: 1,
  		ProtoMinor: 1,
@@ -421,7 +421,7 @@
  		Body:       rc,
  		Host:       u.Host,
  	}
-@@ -571,7 +572,7 @@
+@@ -605,7 +606,7 @@
  	if err != nil {
  		return nil, err
  	}
@@ -430,7 +430,7 @@
  
  	// RFC2616: Must treat
  	//	GET /index.html HTTP/1.1
-@@ -582,7 +583,7 @@
+@@ -616,7 +617,7 @@
  	// the same.  In the second case, any Host line is ignored.
  	req.Host = req.URL.Host
  	if req.Host == "" {
@@ -439,7 +439,7 @@
  	}
  	delete(req.Header, "Host")
  
-@@ -630,12 +631,12 @@
+@@ -638,12 +639,12 @@
  //
  // MaxBytesReader prevents clients from accidentally or maliciously
  // sending a large request and wasting server resources.
@@ -454,7 +454,7 @@
  	r       io.ReadCloser // underlying reader
  	n       int64         // max bytes remaining
  	stopped bool
-@@ -645,9 +646,6 @@
+@@ -653,9 +654,6 @@
  	if l.n <= 0 {
  		if !l.stopped {
  			l.stopped = true
@@ -464,7 +464,7 @@
  		}
  		return 0, errors.New("http: request body too large")
  	}
-@@ -852,16 +850,16 @@
+@@ -858,18 +856,18 @@
  }
  
  func (r *Request) expectsContinue() bool {
@@ -484,11 +484,13 @@
 -	return hasToken(r.Header.get("Connection"), "close")
 +	return hasToken(r.Header.Get("Connection"), "close")
  }
+ 
+ func (r *Request) closeBody() {
 
 === modified file 'http13client/response.go'
---- http13client/response.go	2014-03-19 20:20:19 +0000
-+++ http13client/response.go	2014-03-19 22:27:37 +0000
-@@ -11,6 +11,7 @@
+--- http13client/response.go	2014-06-20 11:00:47 +0000
++++ http13client/response.go	2014-06-20 12:05:53 +0000
+@@ -12,6 +12,7 @@
  	"crypto/tls"
  	"errors"
  	"io"
@@ -496,7 +498,7 @@
  	"net/textproto"
  	"net/url"
  	"strconv"
-@@ -40,7 +41,7 @@
+@@ -41,7 +42,7 @@
  	// omitted from Header.
  	//
  	// Keys in the map are canonicalized (see CanonicalHeaderKey).
@@ -505,7 +507,7 @@
  
  	// Body represents the response body.
  	//
-@@ -69,7 +70,7 @@
+@@ -71,7 +72,7 @@
  
  	// Trailer maps trailer keys to values, in the same
  	// format as the header.
@@ -514,7 +516,7 @@
  
  	// The Request that was sent to obtain this Response.
  	// Request's Body is nil (having already been consumed).
-@@ -84,7 +85,7 @@
+@@ -86,7 +87,7 @@
  }
  
  // Cookies parses and returns the cookies set in the Set-Cookie headers.
@@ -523,7 +525,7 @@
  	return readSetCookies(r.Header)
  }
  
-@@ -153,7 +154,7 @@
+@@ -155,7 +156,7 @@
  		}
  		return nil, err
  	}
@@ -532,7 +534,7 @@
  
  	fixPragmaCacheControl(resp.Header)
  
-@@ -169,7 +170,7 @@
+@@ -171,7 +172,7 @@
  //	Pragma: no-cache
  // like
  //	Cache-Control: no-cache
@@ -543,17 +545,17 @@
  			header["Cache-Control"] = []string{"no-cache"}
 
 === modified file 'http13client/transfer.go'
---- http13client/transfer.go	2014-03-19 20:20:19 +0000
-+++ http13client/transfer.go	2014-03-19 22:27:37 +0000
+--- http13client/transfer.go	2014-06-20 11:00:47 +0000
++++ http13client/transfer.go	2014-06-20 12:05:53 +0000
 @@ -11,6 +11,7 @@
  	"fmt"
  	"io"
  	"io/ioutil"
 +	"net/http"
  	"net/textproto"
+ 	"sort"
  	"strconv"
- 	"strings"
-@@ -36,7 +37,7 @@
+@@ -37,7 +38,7 @@
  	ContentLength    int64 // -1 means unknown, 0 means exactly none
  	Close            bool
  	TransferEncoding []string
@@ -562,16 +564,16 @@
  }
  
  func newTransferWriter(r interface{}) (t *transferWriter, err error) {
-@@ -174,7 +175,7 @@
- 		io.WriteString(w, "Trailer: ")
- 		needComma := false
+@@ -171,7 +172,7 @@
+ 	if t.Trailer != nil {
+ 		keys := make([]string, 0, len(t.Trailer))
  		for k := range t.Trailer {
 -			k = CanonicalHeaderKey(k)
 +			k = http.CanonicalHeaderKey(k)
  			switch k {
  			case "Transfer-Encoding", "Trailer", "Content-Length":
  				return &badStringError{"invalid Trailer key", k}
-@@ -237,7 +238,7 @@
+@@ -243,7 +244,7 @@
  
  type transferReader struct {
  	// Input
@@ -580,7 +582,7 @@
  	StatusCode    int
  	RequestMethod string
  	ProtoMajor    int
-@@ -247,7 +248,7 @@
+@@ -253,7 +254,7 @@
  	ContentLength    int64
  	TransferEncoding []string
  	Close            bool
@@ -589,7 +591,7 @@
  }
  
  // bodyAllowedForStatus reports whether a given response status code
-@@ -308,7 +309,7 @@
+@@ -330,7 +331,7 @@
  		return err
  	}
  	if isResponse && t.RequestMethod == "HEAD" {
@@ -598,7 +600,7 @@
  			return err
  		} else {
  			t.ContentLength = n
-@@ -386,7 +387,7 @@
+@@ -408,7 +409,7 @@
  func isIdentity(te []string) bool { return len(te) == 1 && te[0] == "identity" }
  
  // Sanitize transfer encoding
@@ -607,7 +609,7 @@
  	raw, present := header["Transfer-Encoding"]
  	if !present {
  		return nil, nil
-@@ -429,7 +430,7 @@
+@@ -451,7 +452,7 @@
  // Determine the expected body length, using RFC 2616 Section 4.4. This
  // function is not a method, because ultimately it should be shared by
  // ReadResponse and ReadRequest.
@@ -616,7 +618,7 @@
  
  	// Logic based on response type or status
  	if noBodyExpected(requestMethod) {
-@@ -449,7 +450,7 @@
+@@ -471,7 +472,7 @@
  	}
  
  	// Logic based on Content-Length
@@ -625,7 +627,7 @@
  	if cl != "" {
  		n, err := parseContentLength(cl)
  		if err != nil {
-@@ -475,18 +476,18 @@
+@@ -497,18 +498,18 @@
  // Determine whether to hang up after sending a request and body, or
  // receiving a response and body
  // 'header' is the request headers
@@ -647,7 +649,7 @@
  			header.Del("Connection")
  			return true
  		}
-@@ -495,17 +496,17 @@
+@@ -517,17 +518,17 @@
  }
  
  // Parse the trailer header
@@ -669,22 +671,28 @@
  		switch key {
  		case "Transfer-Encoding", "Trailer", "Content-Length":
  			return nil, &badStringError{"bad trailer key", key}
-@@ -642,9 +643,9 @@
+@@ -664,14 +665,14 @@
  	}
  	switch rr := b.hdr.(type) {
  	case *Request:
--		rr.Trailer = Header(hdr)
-+		rr.Trailer = http.Header(hdr)
+-		mergeSetHeader(&rr.Trailer, Header(hdr))
++		mergeSetHeader(&rr.Trailer, http.Header(hdr))
  	case *Response:
--		rr.Trailer = Header(hdr)
-+		rr.Trailer = http.Header(hdr)
+-		mergeSetHeader(&rr.Trailer, Header(hdr))
++		mergeSetHeader(&rr.Trailer, http.Header(hdr))
  	}
  	return nil
  }
+ 
+-func mergeSetHeader(dst *Header, src Header) {
++func mergeSetHeader(dst *http.Header, src http.Header) {
+ 	if *dst == nil {
+ 		*dst = src
+ 		return
 
 === modified file 'http13client/transport.go'
---- http13client/transport.go	2014-03-19 20:20:19 +0000
-+++ http13client/transport.go	2014-03-19 22:27:37 +0000
+--- http13client/transport.go	2014-06-20 11:00:47 +0000
++++ http13client/transport.go	2014-06-20 12:05:53 +0000
 @@ -18,6 +18,7 @@
  	"io"
  	"log"
@@ -693,7 +701,7 @@
  	"net/url"
  	"os"
  	"strings"
-@@ -144,12 +145,12 @@
+@@ -147,12 +148,12 @@
  // optional extra headers to write.
  type transportRequest struct {
  	*Request        // original request, not to be mutated
@@ -709,7 +717,7 @@
  	}
  	return tr.extra
  }
-@@ -512,7 +513,7 @@
+@@ -519,7 +520,7 @@
  	case cm.targetScheme == "http":
  		pconn.isProxy = true
  		if pa != "" {
@@ -718,7 +726,7 @@
  				h.Set("Proxy-Authorization", pa)
  			}
  		}
-@@ -521,7 +522,7 @@
+@@ -528,7 +529,7 @@
  			Method: "CONNECT",
  			URL:    &url.URL{Opaque: cm.targetAddr},
  			Host:   cm.targetAddr,
@@ -727,7 +735,7 @@
  		}
  		if pa != "" {
  			connectReq.Header.Set("Proxy-Authorization", pa)
-@@ -735,7 +736,7 @@
+@@ -748,7 +749,7 @@
  	// mutateHeaderFunc is an optional func to modify extra
  	// headers on each outbound request before it's written. (the
  	// original Request given to RoundTrip is not modified)
@@ -735,5 +743,5 @@
 +	mutateHeaderFunc func(http.Header)
  }
  
- func (pc *persistConn) isBroken() bool {
+ // isBroken reports whether this connection is in a known broken state.
 

=== modified file 'http13client/_patches/fix_status.patch'
--- http13client/_patches/fix_status.patch	2014-03-19 23:43:25 +0000
+++ http13client/_patches/fix_status.patch	2014-06-24 18:15:10 +0000
@@ -1,7 +1,7 @@
 === modified file 'http13client/client.go'
---- http13client/client.go	2014-03-19 23:13:58 +0000
-+++ http13client/client.go	2014-03-19 23:38:11 +0000
-@@ -210,7 +210,7 @@
+--- http13client/client.go	2014-06-20 12:46:25 +0000
++++ http13client/client.go	2014-06-20 12:46:45 +0000
+@@ -217,7 +217,7 @@
  // automatically redirect.
  func shouldRedirectGet(statusCode int) bool {
  	switch statusCode {
@@ -10,7 +10,7 @@
  		return true
  	}
  	return false
-@@ -220,7 +220,7 @@
+@@ -227,7 +227,7 @@
  // automatically redirect.
  func shouldRedirectPost(statusCode int) bool {
  	switch statusCode {
@@ -21,9 +21,9 @@
  	return false
 
 === modified file 'http13client/client_test.go'
---- http13client/client_test.go	2014-03-19 23:13:58 +0000
-+++ http13client/client_test.go	2014-03-19 23:39:48 +0000
-@@ -202,7 +202,7 @@
+--- http13client/client_test.go	2014-06-20 12:46:25 +0000
++++ http13client/client_test.go	2014-06-20 12:46:45 +0000
+@@ -204,7 +204,7 @@
  			}
  		}
  		if n < 15 {
@@ -32,7 +32,7 @@
  			return
  		}
  		fmt.Fprintf(w, "n=%d", n)
-@@ -324,7 +324,7 @@
+@@ -326,7 +326,7 @@
  	}
  	if r.URL.Path == "/" {
  		http.SetCookie(w, expectedCookies[1])
@@ -41,7 +41,7 @@
  	} else {
  		http.SetCookie(w, expectedCookies[2])
  		w.Write([]byte("hello"))
-@@ -783,7 +783,7 @@
+@@ -785,7 +785,7 @@
  	ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
  		if r.URL.Path == "/" {
  			sawRoot <- true
@@ -50,7 +50,7 @@
  			return
  		}
  		if r.URL.Path == "/slow" {
-@@ -844,7 +844,7 @@
+@@ -846,7 +846,7 @@
  	ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
  		saw <- r.RemoteAddr
  		if r.URL.Path == "/" {
@@ -61,9 +61,9 @@
  	defer ts.Close()
 
 === modified file 'http13client/request_test.go'
---- http13client/request_test.go	2014-03-19 23:13:58 +0000
-+++ http13client/request_test.go	2014-03-19 23:40:12 +0000
-@@ -164,11 +164,11 @@
+--- http13client/request_test.go	2014-06-20 12:46:25 +0000
++++ http13client/request_test.go	2014-06-20 12:46:45 +0000
+@@ -182,11 +182,11 @@
  		switch r.URL.Path {
  		case "/":
  			w.Header().Set("Location", "/foo/")
@@ -79,9 +79,9 @@
  	defer ts.Close()
 
 === modified file 'http13client/response.go'
---- http13client/response.go	2014-03-19 23:13:58 +0000
-+++ http13client/response.go	2014-03-19 23:38:56 +0000
-@@ -204,9 +204,8 @@
+--- http13client/response.go	2014-06-20 12:46:25 +0000
++++ http13client/response.go	2014-06-20 12:46:45 +0000
+@@ -205,9 +205,8 @@
  	// Status line
  	text := r.Status
  	if text == "" {
@@ -94,10 +94,23 @@
  		}
  	}
 
+=== modified file 'http13client/responsewrite_test.go'
+--- http13client/responsewrite_test.go	2014-06-20 12:46:25 +0000
++++ http13client/responsewrite_test.go	2014-06-20 12:47:05 +0000
+@@ -197,7 +197,7 @@
+ 		// there were two.
+ 		{
+ 			Response{
+-				StatusCode:       StatusOK,
++				StatusCode:       http.StatusOK,
+ 				ProtoMajor:       1,
+ 				ProtoMinor:       1,
+ 				Request:          &Request{Method: "POST"},
+
 === modified file 'http13client/transport_test.go'
---- http13client/transport_test.go	2014-03-19 23:13:58 +0000
-+++ http13client/transport_test.go	2014-03-19 23:40:39 +0000
-@@ -968,7 +968,7 @@
+--- http13client/transport_test.go	2014-06-20 12:46:25 +0000
++++ http13client/transport_test.go	2014-06-20 12:46:45 +0000
+@@ -1004,7 +1004,7 @@
  	defer afterTest(t)
  	const deniedMsg = "sorry, denied."
  	ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
@@ -106,7 +119,7 @@
  	}))
  	defer ts.Close()
  	tr := &Transport{}
-@@ -992,7 +992,7 @@
+@@ -1028,7 +1028,7 @@
  func TestChunkedNoContent(t *testing.T) {
  	defer afterTest(t)
  	ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {

=== modified file 'http13client/_patches/fix_tests.patch'
--- http13client/_patches/fix_tests.patch	2014-03-19 23:13:58 +0000
+++ http13client/_patches/fix_tests.patch	2014-06-24 18:15:10 +0000
@@ -1,6 +1,6 @@
 === modified file 'http13client/client_test.go'
---- http13client/client_test.go	2014-03-19 21:38:56 +0000
-+++ http13client/client_test.go	2014-03-19 22:27:37 +0000
+--- http13client/client_test.go	2014-06-20 11:00:47 +0000
++++ http13client/client_test.go	2014-06-20 12:05:53 +0000
 @@ -15,8 +15,8 @@
  	"fmt"
  	"io"
@@ -11,7 +11,7 @@
  	. "launchpad.net/ubuntu-push/http13client"
  	"net/http/httptest"
  	"net/url"
-@@ -27,7 +27,7 @@
+@@ -29,7 +29,7 @@
  	"time"
  )
  
@@ -20,7 +20,7 @@
  	w.Header().Set("Last-Modified", "sometime")
  	fmt.Fprintf(w, "User-agent: go\nDisallow: /something/")
  })
-@@ -193,7 +193,7 @@
+@@ -195,7 +195,7 @@
  func TestClientRedirects(t *testing.T) {
  	defer afterTest(t)
  	var ts *httptest.Server
@@ -29,7 +29,7 @@
  		n, _ := strconv.Atoi(r.FormValue("n"))
  		// Test Referer header. (7 is arbitrary position to test at)
  		if n == 7 {
-@@ -202,7 +202,7 @@
+@@ -204,7 +204,7 @@
  			}
  		}
  		if n < 15 {
@@ -38,7 +38,7 @@
  			return
  		}
  		fmt.Fprintf(w, "n=%d", n)
-@@ -271,7 +271,7 @@
+@@ -273,7 +273,7 @@
  		bytes.Buffer
  	}
  	var ts *httptest.Server
@@ -47,7 +47,7 @@
  		log.Lock()
  		fmt.Fprintf(&log.Buffer, "%s %s ", r.Method, r.RequestURI)
  		log.Unlock()
-@@ -312,21 +312,21 @@
+@@ -314,21 +314,21 @@
  	}
  }
  
@@ -75,7 +75,7 @@
  		w.Write([]byte("hello"))
  	}
  })
-@@ -334,7 +334,7 @@
+@@ -336,7 +336,7 @@
  func TestClientSendsCookieFromJar(t *testing.T) {
  	tr := &recordingTransport{}
  	client := &Client{Transport: tr}
@@ -84,7 +84,7 @@
  	us := "http://dummy.faketld/"
  	u, _ := url.Parse(us)
  	client.Jar.SetCookies(u, expectedCookies)
-@@ -364,19 +364,19 @@
+@@ -366,19 +366,19 @@
  // scope of all cookies.
  type TestJar struct {
  	m      sync.Mutex
@@ -108,7 +108,7 @@
  	j.m.Lock()
  	defer j.m.Unlock()
  	return j.perURL[u.Host]
-@@ -391,7 +391,7 @@
+@@ -393,7 +393,7 @@
  		Jar: new(TestJar),
  	}
  	u, _ := url.Parse(ts.URL)
@@ -117,7 +117,7 @@
  	resp, err := c.Get(ts.URL)
  	if err != nil {
  		t.Fatalf("Get: %v", err)
-@@ -400,7 +400,7 @@
+@@ -402,7 +402,7 @@
  	matchReturnedCookies(t, expectedCookies, resp.Cookies())
  }
  
@@ -126,7 +126,7 @@
  	if len(given) != len(expected) {
  		t.Logf("Received cookies: %v", given)
  		t.Errorf("Expected %d cookies, got %d", len(expected), len(given))
-@@ -421,14 +421,14 @@
+@@ -423,14 +423,14 @@
  
  func TestJarCalls(t *testing.T) {
  	defer afterTest(t)
@@ -144,7 +144,7 @@
  		}
  	}))
  	defer ts.Close()
-@@ -468,11 +468,11 @@
+@@ -470,11 +470,11 @@
  	log bytes.Buffer
  }
  
@@ -158,7 +158,7 @@
  	j.logf("Cookies(%q)\n", u)
  	return nil
  }
-@@ -486,11 +486,11 @@
+@@ -488,11 +488,11 @@
  func TestStreamingGet(t *testing.T) {
  	defer afterTest(t)
  	say := make(chan string)
@@ -173,7 +173,7 @@
  		}
  	}))
  	defer ts.Close()
-@@ -536,7 +536,7 @@
+@@ -538,7 +538,7 @@
  // don't send a TCP packet per line of the http request + body.
  func TestClientWrites(t *testing.T) {
  	defer afterTest(t)
@@ -182,7 +182,7 @@
  	}))
  	defer ts.Close()
  
-@@ -568,46 +568,6 @@
+@@ -570,46 +570,6 @@
  	}
  }
  
@@ -229,7 +229,7 @@
  func TestClientErrorWithRequestURI(t *testing.T) {
  	defer afterTest(t)
  	req, _ := NewRequest("GET", "http://localhost:1234/", nil)
-@@ -639,7 +599,7 @@
+@@ -641,7 +601,7 @@
  
  func TestClientWithCorrectTLSServerName(t *testing.T) {
  	defer afterTest(t)
@@ -238,7 +238,7 @@
  		if r.TLS.ServerName != "127.0.0.1" {
  			t.Errorf("expected client to set ServerName 127.0.0.1, got: %q", r.TLS.ServerName)
  		}
-@@ -652,33 +612,6 @@
+@@ -654,33 +614,6 @@
  	}
  }
  
@@ -272,7 +272,7 @@
  // Test for golang.org/issue/5829; the Transport should respect TLSClientConfig.ServerName
  // when not empty.
  //
-@@ -690,7 +623,7 @@
+@@ -692,7 +625,7 @@
  // The httptest.Server has a cert with "example.com" as its name.
  func TestTransportUsesTLSConfigServerName(t *testing.T) {
  	defer afterTest(t)
@@ -281,7 +281,7 @@
  		w.Write([]byte("Hello"))
  	}))
  	defer ts.Close()
-@@ -711,7 +644,7 @@
+@@ -713,7 +646,7 @@
  
  func TestResponseSetsTLSConnectionState(t *testing.T) {
  	defer afterTest(t)
@@ -290,7 +290,7 @@
  		w.Write([]byte("Hello"))
  	}))
  	defer ts.Close()
-@@ -739,7 +672,7 @@
+@@ -741,7 +674,7 @@
  // Verify Response.ContentLength is populated. http://golang.org/issue/4126
  func TestClientHeadContentLength(t *testing.T) {
  	defer afterTest(t)
@@ -299,7 +299,7 @@
  		if v := r.FormValue("cl"); v != "" {
  			w.Header().Set("Content-Length", v)
  		}
-@@ -775,7 +708,7 @@
+@@ -777,7 +710,7 @@
  func TestEmptyPasswordAuth(t *testing.T) {
  	defer afterTest(t)
  	gopher := "gopher"
@@ -308,7 +308,7 @@
  		auth := r.Header.Get("Authorization")
  		if strings.HasPrefix(auth, "Basic ") {
  			encoded := auth[6:]
-@@ -847,15 +780,15 @@
+@@ -849,15 +782,15 @@
  	defer afterTest(t)
  	sawRoot := make(chan bool, 1)
  	sawSlow := make(chan bool, 1)
@@ -327,7 +327,7 @@
  			sawSlow <- true
  			time.Sleep(2 * time.Second)
  			return
-@@ -908,10 +841,10 @@
+@@ -910,10 +843,10 @@
  func TestClientRedirectEatsBody(t *testing.T) {
  	defer afterTest(t)
  	saw := make(chan string, 2)
@@ -340,233 +340,50 @@
  		}
  	}))
  	defer ts.Close()
-
-=== modified file 'http13client/cookie_test.go'
---- http13client/cookie_test.go	2014-03-19 20:20:19 +0000
-+++ http13client/cookie_test.go	2014-03-19 22:27:37 +0000
-@@ -9,6 +9,7 @@
- 	"encoding/json"
- 	"fmt"
- 	"log"
-+	"net/http"
- 	"os"
- 	"reflect"
- 	"strings"
-@@ -17,39 +18,39 @@
- )
- 
- var writeSetCookiesTests = []struct {
--	Cookie *Cookie
-+	Cookie *http.Cookie
- 	Raw    string
- }{
- 	{
--		&Cookie{Name: "cookie-1", Value: "v$1"},
-+		&http.Cookie{Name: "cookie-1", Value: "v$1"},
- 		"cookie-1=v$1",
- 	},
- 	{
--		&Cookie{Name: "cookie-2", Value: "two", MaxAge: 3600},
-+		&http.Cookie{Name: "cookie-2", Value: "two", MaxAge: 3600},
- 		"cookie-2=two; Max-Age=3600",
- 	},
- 	{
--		&Cookie{Name: "cookie-3", Value: "three", Domain: ".example.com"},
-+		&http.Cookie{Name: "cookie-3", Value: "three", Domain: ".example.com"},
- 		"cookie-3=three; Domain=example.com",
- 	},
- 	{
--		&Cookie{Name: "cookie-4", Value: "four", Path: "/restricted/"},
-+		&http.Cookie{Name: "cookie-4", Value: "four", Path: "/restricted/"},
- 		"cookie-4=four; Path=/restricted/",
- 	},
- 	{
--		&Cookie{Name: "cookie-5", Value: "five", Domain: "wrong;bad.abc"},
-+		&http.Cookie{Name: "cookie-5", Value: "five", Domain: "wrong;bad.abc"},
- 		"cookie-5=five",
- 	},
- 	{
--		&Cookie{Name: "cookie-6", Value: "six", Domain: "bad-.abc"},
-+		&http.Cookie{Name: "cookie-6", Value: "six", Domain: "bad-.abc"},
- 		"cookie-6=six",
- 	},
- 	{
--		&Cookie{Name: "cookie-7", Value: "seven", Domain: "127.0.0.1"},
-+		&http.Cookie{Name: "cookie-7", Value: "seven", Domain: "127.0.0.1"},
- 		"cookie-7=seven; Domain=127.0.0.1",
- 	},
- 	{
--		&Cookie{Name: "cookie-8", Value: "eight", Domain: "::1"},
-+		&http.Cookie{Name: "cookie-8", Value: "eight", Domain: "::1"},
- 		"cookie-8=eight",
- 	},
- }
-@@ -71,10 +72,10 @@
- 	}
- }
- 
--type headerOnlyResponseWriter Header
-+type headerOnlyResponseWriter http.Header
- 
--func (ho headerOnlyResponseWriter) Header() Header {
--	return Header(ho)
-+func (ho headerOnlyResponseWriter) Header() http.Header {
-+	return http.Header(ho)
- }
- 
- func (ho headerOnlyResponseWriter) Write([]byte) (int, error) {
-@@ -86,9 +87,9 @@
- }
- 
- func TestSetCookie(t *testing.T) {
--	m := make(Header)
--	SetCookie(headerOnlyResponseWriter(m), &Cookie{Name: "cookie-1", Value: "one", Path: "/restricted/"})
--	SetCookie(headerOnlyResponseWriter(m), &Cookie{Name: "cookie-2", Value: "two", MaxAge: 3600})
-+	m := make(http.Header)
-+	http.SetCookie(headerOnlyResponseWriter(m), &http.Cookie{Name: "cookie-1", Value: "one", Path: "/restricted/"})
-+	http.SetCookie(headerOnlyResponseWriter(m), &http.Cookie{Name: "cookie-2", Value: "two", MaxAge: 3600})
- 	if l := len(m["Set-Cookie"]); l != 2 {
- 		t.Fatalf("expected %d cookies, got %d", 2, l)
- 	}
-@@ -101,19 +102,19 @@
- }
- 
- var addCookieTests = []struct {
--	Cookies []*Cookie
-+	Cookies []*http.Cookie
- 	Raw     string
- }{
- 	{
--		[]*Cookie{},
-+		[]*http.Cookie{},
- 		"",
- 	},
- 	{
--		[]*Cookie{{Name: "cookie-1", Value: "v$1"}},
-+		[]*http.Cookie{{Name: "cookie-1", Value: "v$1"}},
- 		"cookie-1=v$1",
- 	},
- 	{
--		[]*Cookie{
-+		[]*http.Cookie{
- 			{Name: "cookie-1", Value: "v$1"},
- 			{Name: "cookie-2", Value: "v$2"},
- 			{Name: "cookie-3", Value: "v$3"},
-@@ -136,16 +137,16 @@
- }
- 
- var readSetCookiesTests = []struct {
--	Header  Header
--	Cookies []*Cookie
-+	Header  http.Header
-+	Cookies []*http.Cookie
- }{
- 	{
--		Header{"Set-Cookie": {"Cookie-1=v$1"}},
--		[]*Cookie{{Name: "Cookie-1", Value: "v$1", Raw: "Cookie-1=v$1"}},
-+		http.Header{"Set-Cookie": {"Cookie-1=v$1"}},
-+		[]*http.Cookie{{Name: "Cookie-1", Value: "v$1", Raw: "Cookie-1=v$1"}},
- 	},
- 	{
--		Header{"Set-Cookie": {"NID=99=YsDT5i3E-CXax-; expires=Wed, 23-Nov-2011 01:05:03 GMT; path=/; domain=.google.ch; HttpOnly"}},
--		[]*Cookie{{
-+		http.Header{"Set-Cookie": {"NID=99=YsDT5i3E-CXax-; expires=Wed, 23-Nov-2011 01:05:03 GMT; path=/; domain=.google.ch; HttpOnly"}},
-+		[]*http.Cookie{{
- 			Name:       "NID",
- 			Value:      "99=YsDT5i3E-CXax-",
- 			Path:       "/",
-@@ -157,8 +158,8 @@
- 		}},
- 	},
- 	{
--		Header{"Set-Cookie": {".ASPXAUTH=7E3AA; expires=Wed, 07-Mar-2012 14:25:06 GMT; path=/; HttpOnly"}},
--		[]*Cookie{{
-+		http.Header{"Set-Cookie": {".ASPXAUTH=7E3AA; expires=Wed, 07-Mar-2012 14:25:06 GMT; path=/; HttpOnly"}},
-+		[]*http.Cookie{{
- 			Name:       ".ASPXAUTH",
- 			Value:      "7E3AA",
- 			Path:       "/",
-@@ -169,8 +170,8 @@
- 		}},
- 	},
- 	{
--		Header{"Set-Cookie": {"ASP.NET_SessionId=foo; path=/; HttpOnly"}},
--		[]*Cookie{{
-+		http.Header{"Set-Cookie": {"ASP.NET_SessionId=foo; path=/; HttpOnly"}},
-+		[]*http.Cookie{{
- 			Name:     "ASP.NET_SessionId",
- 			Value:    "foo",
- 			Path:     "/",
-@@ -207,37 +208,37 @@
- }
- 
- var readCookiesTests = []struct {
--	Header  Header
-+	Header  http.Header
- 	Filter  string
--	Cookies []*Cookie
-+	Cookies []*http.Cookie
- }{
- 	{
--		Header{"Cookie": {"Cookie-1=v$1", "c2=v2"}},
--		"",
--		[]*Cookie{
--			{Name: "Cookie-1", Value: "v$1"},
--			{Name: "c2", Value: "v2"},
--		},
--	},
--	{
--		Header{"Cookie": {"Cookie-1=v$1", "c2=v2"}},
--		"c2",
--		[]*Cookie{
--			{Name: "c2", Value: "v2"},
--		},
--	},
--	{
--		Header{"Cookie": {"Cookie-1=v$1; c2=v2"}},
--		"",
--		[]*Cookie{
--			{Name: "Cookie-1", Value: "v$1"},
--			{Name: "c2", Value: "v2"},
--		},
--	},
--	{
--		Header{"Cookie": {"Cookie-1=v$1; c2=v2"}},
--		"c2",
--		[]*Cookie{
-+		http.Header{"Cookie": {"Cookie-1=v$1", "c2=v2"}},
-+		"",
-+		[]*http.Cookie{
-+			{Name: "Cookie-1", Value: "v$1"},
-+			{Name: "c2", Value: "v2"},
-+		},
-+	},
-+	{
-+		http.Header{"Cookie": {"Cookie-1=v$1", "c2=v2"}},
-+		"c2",
-+		[]*http.Cookie{
-+			{Name: "c2", Value: "v2"},
-+		},
-+	},
-+	{
-+		http.Header{"Cookie": {"Cookie-1=v$1; c2=v2"}},
-+		"",
-+		[]*http.Cookie{
-+			{Name: "Cookie-1", Value: "v$1"},
-+			{Name: "c2", Value: "v2"},
-+		},
-+	},
-+	{
-+		http.Header{"Cookie": {"Cookie-1=v$1; c2=v2"}},
-+		"c2",
-+		[]*http.Cookie{
- 			{Name: "c2", Value: "v2"},
- 		},
- 	},
+@@ -957,7 +890,7 @@
+ 
+ func TestClientTrailers(t *testing.T) {
+ 	defer afterTest(t)
+-	ts := httptest.NewServer(HandlerFunc(func(w ResponseWriter, r *Request) {
++	ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+ 		w.Header().Set("Connection", "close")
+ 		w.Header().Set("Trailer", "Server-Trailer-A, Server-Trailer-B")
+ 		w.Header().Add("Trailer", "Server-Trailer-C")
+@@ -992,9 +925,9 @@
+ 		// trailers to be sent, if and only if they were
+ 		// previously declared with w.Header().Set("Trailer",
+ 		// ..keys..)
+-		w.(Flusher).Flush()
+-		conn, buf, _ := w.(Hijacker).Hijack()
+-		t := Header{}
++		w.(http.Flusher).Flush()
++		conn, buf, _ := w.(http.Hijacker).Hijack()
++		t := http.Header{}
+ 		t.Set("Server-Trailer-A", "valuea")
+ 		t.Set("Server-Trailer-C", "valuec") // skipping B
+ 		buf.WriteString("0\r\n")            // eof
+@@ -1015,7 +948,7 @@
+ 			req.Trailer["Client-Trailer-B"] = []string{"valueb"}
+ 		}),
+ 	))
+-	req.Trailer = Header{
++	req.Trailer = http.Header{
+ 		"Client-Trailer-A": nil, //  to be set later
+ 		"Client-Trailer-B": nil, //  to be set later
+ 	}
+@@ -1027,7 +960,7 @@
+ 	if err := wantBody(res, err, "decl: [Client-Trailer-A Client-Trailer-B], vals: valuea, valueb"); err != nil {
+ 		t.Error(err)
+ 	}
+-	want := Header{
++	want := http.Header{
+ 		"Server-Trailer-A": []string{"valuea"},
+ 		"Server-Trailer-B": nil,
+ 		"Server-Trailer-C": []string{"valuec"},
 
 === modified file 'http13client/export_test.go'
---- http13client/export_test.go	2014-03-19 20:20:19 +0000
-+++ http13client/export_test.go	2014-03-19 22:27:37 +0000
+--- http13client/export_test.go	2014-06-20 11:00:47 +0000
++++ http13client/export_test.go	2014-06-20 12:00:22 +0000
 @@ -9,15 +9,12 @@
  
  import (
@@ -599,8 +416,8 @@
  	noProxyEnv.reset()
 
 === modified file 'http13client/header_test.go'
---- http13client/header_test.go	2014-03-19 20:20:19 +0000
-+++ http13client/header_test.go	2014-03-19 22:27:37 +0000
+--- http13client/header_test.go	2014-06-20 11:00:47 +0000
++++ http13client/header_test.go	2014-06-20 12:00:22 +0000
 @@ -6,19 +6,20 @@
  
  import (
@@ -731,8 +548,8 @@
  	}
 
 === modified file 'http13client/npn_test.go'
---- http13client/npn_test.go	2014-03-19 21:38:56 +0000
-+++ http13client/npn_test.go	2014-03-19 22:27:37 +0000
+--- http13client/npn_test.go	2014-06-20 11:00:47 +0000
++++ http13client/npn_test.go	2014-06-20 12:05:53 +0000
 @@ -11,13 +11,14 @@
  	"io"
  	"io/ioutil"
@@ -792,8 +609,8 @@
  func (w http09Writer) WriteHeader(int) {} // no headers
 
 === modified file 'http13client/readrequest_test.go'
---- http13client/readrequest_test.go	2014-03-19 20:20:19 +0000
-+++ http13client/readrequest_test.go	2014-03-19 22:27:37 +0000
+--- http13client/readrequest_test.go	2014-06-20 11:00:47 +0000
++++ http13client/readrequest_test.go	2014-06-20 12:00:22 +0000
 @@ -9,6 +9,7 @@
  	"bytes"
  	"fmt"
@@ -909,8 +726,8 @@
  			Close:         false,
 
 === modified file 'http13client/request_test.go'
---- http13client/request_test.go	2014-03-19 21:38:56 +0000
-+++ http13client/request_test.go	2014-03-19 22:27:37 +0000
+--- http13client/request_test.go	2014-06-20 11:00:47 +0000
++++ http13client/request_test.go	2014-06-20 12:05:53 +0000
 @@ -12,6 +12,7 @@
  	"io/ioutil"
  	"mime/multipart"
@@ -945,8 +762,26 @@
 +	req.Header = http.Header{"Content-Type": {"text/plain"}}
  	multipart, err = req.MultipartReader()
  	if multipart != nil {
- 		t.Errorf("unexpected multipart for text/plain")
-@@ -159,7 +160,7 @@
+ 		t.Error("unexpected multipart for text/plain")
+@@ -161,7 +162,7 @@
+ func TestParseMultipartForm(t *testing.T) {
+ 	req := &Request{
+ 		Method: "POST",
+-		Header: Header{"Content-Type": {`multipart/form-data; boundary="foo123"`}},
++		Header: http.Header{"Content-Type": {`multipart/form-data; boundary="foo123"`}},
+ 		Body:   ioutil.NopCloser(new(bytes.Buffer)),
+ 	}
+ 	err := req.ParseMultipartForm(25)
+@@ -169,7 +170,7 @@
+ 		t.Error("expected multipart EOF, got nil")
+ 	}
+ 
+-	req.Header = Header{"Content-Type": {"text/plain"}}
++	req.Header = http.Header{"Content-Type": {"text/plain"}}
+ 	err = req.ParseMultipartForm(25)
+ 	if err != ErrNotMultipart {
+ 		t.Error("expected ErrNotMultipart for text/plain")
+@@ -177,7 +178,7 @@
  }
  
  func TestRedirect(t *testing.T) {
@@ -957,8 +792,8 @@
  			w.Header().Set("Location", "/foo/")
 
 === modified file 'http13client/requestwrite_test.go'
---- http13client/requestwrite_test.go	2014-03-19 20:20:19 +0000
-+++ http13client/requestwrite_test.go	2014-03-19 22:27:37 +0000
+--- http13client/requestwrite_test.go	2014-06-20 11:00:47 +0000
++++ http13client/requestwrite_test.go	2014-06-20 12:00:22 +0000
 @@ -10,6 +10,7 @@
  	"fmt"
  	"io"
@@ -1068,8 +903,8 @@
  		var braw bytes.Buffer
 
 === modified file 'http13client/response_test.go'
---- http13client/response_test.go	2014-03-19 20:20:19 +0000
-+++ http13client/response_test.go	2014-03-19 22:27:37 +0000
+--- http13client/response_test.go	2014-06-20 11:00:47 +0000
++++ http13client/response_test.go	2014-06-20 12:05:53 +0000
 @@ -12,6 +12,7 @@
  	"fmt"
  	"io"
@@ -1078,7 +913,7 @@
  	"net/url"
  	"reflect"
  	"regexp"
-@@ -44,7 +45,7 @@
+@@ -48,7 +49,7 @@
  			ProtoMajor: 1,
  			ProtoMinor: 0,
  			Request:    dummyReq("GET"),
@@ -1087,7 +922,7 @@
  				"Connection": {"close"}, // TODO(rsc): Delete?
  			},
  			Close:         true,
-@@ -67,7 +68,7 @@
+@@ -71,7 +72,7 @@
  			Proto:         "HTTP/1.1",
  			ProtoMajor:    1,
  			ProtoMinor:    1,
@@ -1096,7 +931,7 @@
  			Request:       dummyReq("GET"),
  			Close:         true,
  			ContentLength: -1,
-@@ -88,7 +89,7 @@
+@@ -92,7 +93,7 @@
  			Proto:         "HTTP/1.1",
  			ProtoMajor:    1,
  			ProtoMinor:    1,
@@ -1105,7 +940,7 @@
  			Request:       dummyReq("GET"),
  			Close:         false,
  			ContentLength: 0,
-@@ -112,7 +113,7 @@
+@@ -116,7 +117,7 @@
  			ProtoMajor: 1,
  			ProtoMinor: 0,
  			Request:    dummyReq("GET"),
@@ -1114,61 +949,61 @@
  				"Connection":     {"close"},
  				"Content-Length": {"10"},
  			},
-@@ -142,7 +143,7 @@
- 			ProtoMajor:       1,
- 			ProtoMinor:       1,
- 			Request:          dummyReq("GET"),
--			Header:           Header{},
-+			Header:           http.Header{},
- 			Close:            false,
- 			ContentLength:    -1,
- 			TransferEncoding: []string{"chunked"},
-@@ -169,7 +170,7 @@
- 			ProtoMajor:       1,
- 			ProtoMinor:       1,
- 			Request:          dummyReq("GET"),
--			Header:           Header{},
-+			Header:           http.Header{},
- 			Close:            false,
- 			ContentLength:    -1,
- 			TransferEncoding: []string{"chunked"},
-@@ -191,7 +192,7 @@
- 			ProtoMajor:       1,
- 			ProtoMinor:       1,
- 			Request:          dummyReq("HEAD"),
--			Header:           Header{},
-+			Header:           http.Header{},
- 			TransferEncoding: []string{"chunked"},
- 			Close:            false,
- 			ContentLength:    -1,
-@@ -213,7 +214,7 @@
- 			ProtoMajor:       1,
- 			ProtoMinor:       0,
- 			Request:          dummyReq("HEAD"),
--			Header:           Header{"Content-Length": {"256"}},
-+			Header:           http.Header{"Content-Length": {"256"}},
- 			TransferEncoding: nil,
- 			Close:            true,
- 			ContentLength:    256,
-@@ -235,7 +236,7 @@
- 			ProtoMajor:       1,
- 			ProtoMinor:       1,
- 			Request:          dummyReq("HEAD"),
--			Header:           Header{"Content-Length": {"256"}},
-+			Header:           http.Header{"Content-Length": {"256"}},
- 			TransferEncoding: nil,
- 			Close:            false,
- 			ContentLength:    256,
-@@ -256,7 +257,7 @@
- 			ProtoMajor:       1,
- 			ProtoMinor:       0,
- 			Request:          dummyReq("HEAD"),
--			Header:           Header{},
-+			Header:           http.Header{},
- 			TransferEncoding: nil,
- 			Close:            true,
- 			ContentLength:    -1,
-@@ -278,7 +279,7 @@
+@@ -146,7 +147,7 @@
+ 			ProtoMajor:       1,
+ 			ProtoMinor:       1,
+ 			Request:          dummyReq("GET"),
+-			Header:           Header{},
++			Header:           http.Header{},
+ 			Close:            false,
+ 			ContentLength:    -1,
+ 			TransferEncoding: []string{"chunked"},
+@@ -173,7 +174,7 @@
+ 			ProtoMajor:       1,
+ 			ProtoMinor:       1,
+ 			Request:          dummyReq("GET"),
+-			Header:           Header{},
++			Header:           http.Header{},
+ 			Close:            false,
+ 			ContentLength:    -1,
+ 			TransferEncoding: []string{"chunked"},
+@@ -195,7 +196,7 @@
+ 			ProtoMajor:       1,
+ 			ProtoMinor:       1,
+ 			Request:          dummyReq("HEAD"),
+-			Header:           Header{},
++			Header:           http.Header{},
+ 			TransferEncoding: []string{"chunked"},
+ 			Close:            false,
+ 			ContentLength:    -1,
+@@ -217,7 +218,7 @@
+ 			ProtoMajor:       1,
+ 			ProtoMinor:       0,
+ 			Request:          dummyReq("HEAD"),
+-			Header:           Header{"Content-Length": {"256"}},
++			Header:           http.Header{"Content-Length": {"256"}},
+ 			TransferEncoding: nil,
+ 			Close:            true,
+ 			ContentLength:    256,
+@@ -239,7 +240,7 @@
+ 			ProtoMajor:       1,
+ 			ProtoMinor:       1,
+ 			Request:          dummyReq("HEAD"),
+-			Header:           Header{"Content-Length": {"256"}},
++			Header:           http.Header{"Content-Length": {"256"}},
+ 			TransferEncoding: nil,
+ 			Close:            false,
+ 			ContentLength:    256,
+@@ -260,7 +261,7 @@
+ 			ProtoMajor:       1,
+ 			ProtoMinor:       0,
+ 			Request:          dummyReq("HEAD"),
+-			Header:           Header{},
++			Header:           http.Header{},
+ 			TransferEncoding: nil,
+ 			Close:            true,
+ 			ContentLength:    -1,
+@@ -282,7 +283,7 @@
  			ProtoMajor: 1,
  			ProtoMinor: 1,
  			Request:    dummyReq("GET"),
@@ -1177,25 +1012,25 @@
  				"Content-Length": {"0"},
  			},
  			Close:         false,
-@@ -299,7 +300,7 @@
- 			ProtoMajor:    1,
- 			ProtoMinor:    0,
- 			Request:       dummyReq("GET"),
--			Header:        Header{},
-+			Header:        http.Header{},
- 			Close:         true,
- 			ContentLength: -1,
- 		},
-@@ -318,7 +319,7 @@
- 			ProtoMajor:    1,
- 			ProtoMinor:    0,
- 			Request:       dummyReq("GET"),
--			Header:        Header{},
-+			Header:        http.Header{},
- 			Close:         true,
- 			ContentLength: -1,
- 		},
-@@ -340,7 +341,7 @@
+@@ -303,7 +304,7 @@
+ 			ProtoMajor:    1,
+ 			ProtoMinor:    0,
+ 			Request:       dummyReq("GET"),
+-			Header:        Header{},
++			Header:        http.Header{},
+ 			Close:         true,
+ 			ContentLength: -1,
+ 		},
+@@ -322,7 +323,7 @@
+ 			ProtoMajor:    1,
+ 			ProtoMinor:    0,
+ 			Request:       dummyReq("GET"),
+-			Header:        Header{},
++			Header:        http.Header{},
+ 			Close:         true,
+ 			ContentLength: -1,
+ 		},
+@@ -344,7 +345,7 @@
  			ProtoMajor: 1,
  			ProtoMinor: 1,
  			Request:    dummyReq("GET"),
@@ -1204,7 +1039,7 @@
  				"Content-Type": []string{"multipart/byteranges; boundary=18a75608c8f47cef"},
  			},
  			Close:         true,
-@@ -363,7 +364,7 @@
+@@ -367,7 +368,7 @@
  			Proto:      "HTTP/1.0",
  			ProtoMajor: 1,
  			ProtoMinor: 0,
@@ -1213,7 +1048,7 @@
  				"Connection": {"close"}, // TODO(rsc): Delete?
  			},
  			Close:         true,
-@@ -545,7 +546,7 @@
+@@ -549,7 +550,7 @@
  func TestLocationResponse(t *testing.T) {
  	for i, tt := range responseLocationTests {
  		res := new(Response)
@@ -1222,7 +1057,7 @@
  		res.Header.Set("Location", tt.location)
  		if tt.requrl != "" {
  			res.Request = &Request{}
-@@ -626,16 +627,3 @@
+@@ -630,16 +631,3 @@
  		t.Errorf("ReadResponse = %v; want io.ErrUnexpectedEOF", err)
  	}
  }
@@ -1241,8 +1076,8 @@
 -}
 
 === modified file 'http13client/responsewrite_test.go'
---- http13client/responsewrite_test.go	2014-03-19 20:20:19 +0000
-+++ http13client/responsewrite_test.go	2014-03-19 22:27:37 +0000
+--- http13client/responsewrite_test.go	2014-06-20 11:00:47 +0000
++++ http13client/responsewrite_test.go	2014-06-20 12:05:53 +0000
 @@ -7,6 +7,7 @@
  import (
  	"bytes"
@@ -1257,7 +1092,7 @@
  				Request:       dummyReq("GET"),
 -				Header:        Header{},
 +				Header:        http.Header{},
- 				Body:          ioutil.NopCloser(bytes.NewBufferString("abcdef")),
+ 				Body:          ioutil.NopCloser(strings.NewReader("abcdef")),
  				ContentLength: 6,
  			},
 @@ -41,7 +42,7 @@
@@ -1270,6 +1105,60 @@
  				ContentLength: -1,
  			},
 @@ -56,7 +57,7 @@
+ 				ProtoMajor:    1,
+ 				ProtoMinor:    1,
+ 				Request:       dummyReq("GET"),
+-				Header:        Header{},
++				Header:        http.Header{},
+ 				Body:          ioutil.NopCloser(strings.NewReader("abcdef")),
+ 				ContentLength: -1,
+ 				Close:         true,
+@@ -73,7 +74,7 @@
+ 				ProtoMajor:    1,
+ 				ProtoMinor:    1,
+ 				Request:       dummyReq11("GET"),
+-				Header:        Header{},
++				Header:        http.Header{},
+ 				Body:          ioutil.NopCloser(strings.NewReader("abcdef")),
+ 				ContentLength: -1,
+ 				Close:         false,
+@@ -91,7 +92,7 @@
+ 				ProtoMajor:       1,
+ 				ProtoMinor:       1,
+ 				Request:          dummyReq11("GET"),
+-				Header:           Header{},
++				Header:           http.Header{},
+ 				Body:             ioutil.NopCloser(strings.NewReader("abcdef")),
+ 				ContentLength:    -1,
+ 				TransferEncoding: []string{"chunked"},
+@@ -108,7 +109,7 @@
+ 				ProtoMajor:    1,
+ 				ProtoMinor:    1,
+ 				Request:       dummyReq11("GET"),
+-				Header:        Header{},
++				Header:        http.Header{},
+ 				Body:          nil,
+ 				ContentLength: 0,
+ 				Close:         false,
+@@ -124,7 +125,7 @@
+ 				ProtoMajor:    1,
+ 				ProtoMinor:    1,
+ 				Request:       dummyReq11("GET"),
+-				Header:        Header{},
++				Header:        http.Header{},
+ 				Body:          ioutil.NopCloser(strings.NewReader("")),
+ 				ContentLength: 0,
+ 				Close:         false,
+@@ -140,7 +141,7 @@
+ 				ProtoMajor:    1,
+ 				ProtoMinor:    1,
+ 				Request:       dummyReq11("GET"),
+-				Header:        Header{},
++				Header:        http.Header{},
+ 				Body:          ioutil.NopCloser(strings.NewReader("foo")),
+ 				ContentLength: 0,
+ 				Close:         false,
+@@ -156,7 +157,7 @@
  				ProtoMajor:       1,
  				ProtoMinor:       1,
  				Request:          dummyReq("GET"),
@@ -1278,7 +1167,7 @@
  				Body:             ioutil.NopCloser(strings.NewReader("abcdef")),
  				ContentLength:    6,
  				TransferEncoding: []string{"chunked"},
-@@ -77,7 +78,7 @@
+@@ -177,7 +178,7 @@
  				ProtoMajor: 1,
  				ProtoMinor: 1,
  				Request:    dummyReq("GET"),
@@ -1287,11 +1176,20 @@
  					"Foo": []string{" Bar\nBaz "},
  				},
  				Body:             nil,
+@@ -200,7 +201,7 @@
+ 				ProtoMajor:       1,
+ 				ProtoMinor:       1,
+ 				Request:          &Request{Method: "POST"},
+-				Header:           Header{},
++				Header:           http.Header{},
+ 				ContentLength:    0,
+ 				TransferEncoding: nil,
+ 				Body:             nil,
 
 === modified file 'http13client/transport_test.go'
---- http13client/transport_test.go	2014-03-19 21:38:56 +0000
-+++ http13client/transport_test.go	2014-03-19 22:27:37 +0000
-@@ -17,8 +17,8 @@
+--- http13client/transport_test.go	2014-06-20 11:00:47 +0000
++++ http13client/transport_test.go	2014-06-20 12:05:53 +0000
+@@ -18,8 +18,8 @@
  	"io/ioutil"
  	"log"
  	"net"
@@ -1301,7 +1199,7 @@
  	"net/http/httptest"
  	"net/url"
  	"os"
-@@ -34,7 +34,7 @@
+@@ -35,7 +35,7 @@
  //       and then verify that the final 2 responses get errors back.
  
  // hostPortHandler writes back the client's "host:port".
@@ -1310,7 +1208,7 @@
  	if r.FormValue("close") == "true" {
  		w.Header().Set("Connection", "close")
  	}
-@@ -280,7 +280,7 @@
+@@ -289,7 +289,7 @@
  	const msg = "foobar"
  
  	var addrSeen map[string]int
@@ -1319,7 +1217,7 @@
  		addrSeen[r.RemoteAddr]++
  		if r.URL.Path == "/chunked/" {
  			w.WriteHeader(200)
-@@ -299,7 +299,7 @@
+@@ -308,7 +308,7 @@
  		wantLen := []int{len(msg), -1}[pi]
  		addrSeen = make(map[string]int)
  		for i := 0; i < 3; i++ {
@@ -1328,7 +1226,7 @@
  			if err != nil {
  				t.Errorf("Get %s: %v", path, err)
  				continue
-@@ -329,7 +329,7 @@
+@@ -338,7 +338,7 @@
  	defer afterTest(t)
  	resch := make(chan string)
  	gotReq := make(chan bool)
@@ -1337,7 +1235,7 @@
  		gotReq <- true
  		msg := <-resch
  		_, err := w.Write([]byte(msg))
-@@ -457,12 +457,12 @@
+@@ -466,12 +466,12 @@
  	if testing.Short() {
  		t.Skip("skipping test in short mode")
  	}
@@ -1353,7 +1251,7 @@
  		buf.Flush()
  		conn.Close()
  	}))
-@@ -510,7 +510,7 @@
+@@ -519,7 +519,7 @@
  // with no bodies properly
  func TestTransportHeadResponses(t *testing.T) {
  	defer afterTest(t)
@@ -1362,7 +1260,7 @@
  		if r.Method != "HEAD" {
  			panic("expected HEAD; got " + r.Method)
  		}
-@@ -545,7 +545,7 @@
+@@ -554,7 +554,7 @@
  // on responses to HEAD requests.
  func TestTransportHeadChunkedResponse(t *testing.T) {
  	defer afterTest(t)
@@ -1371,7 +1269,7 @@
  		if r.Method != "HEAD" {
  			panic("expected HEAD; got " + r.Method)
  		}
-@@ -588,7 +588,7 @@
+@@ -597,7 +597,7 @@
  func TestRoundTripGzip(t *testing.T) {
  	defer afterTest(t)
  	const responseBody = "test response body"
@@ -1380,7 +1278,7 @@
  		accept := req.Header.Get("Accept-Encoding")
  		if expect := req.FormValue("expect_accept"); accept != expect {
  			t.Errorf("in handler, test %v: Accept-Encoding = %q, want %q",
-@@ -647,7 +647,7 @@
+@@ -656,7 +656,7 @@
  	defer afterTest(t)
  	const testString = "The test string aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
  	const nRandBytes = 1024 * 1024
@@ -1389,7 +1287,7 @@
  		if req.Method == "HEAD" {
  			if g := req.Header.Get("Accept-Encoding"); g != "" {
  				t.Errorf("HEAD request sent with Accept-Encoding of %q; want none", g)
-@@ -742,11 +742,11 @@
+@@ -751,11 +751,11 @@
  func TestTransportProxy(t *testing.T) {
  	defer afterTest(t)
  	ch := make(chan string, 1)
@@ -1403,7 +1301,7 @@
  		ch <- "proxy for " + r.URL.String()
  	}))
  	defer proxy.Close()
-@@ -770,7 +770,7 @@
+@@ -779,7 +779,7 @@
  // Content-Encoding is removed.
  func TestTransportGzipRecursive(t *testing.T) {
  	defer afterTest(t)
@@ -1412,7 +1310,16 @@
  		w.Header().Set("Content-Encoding", "gzip")
  		w.Write(rgz)
  	}))
-@@ -802,7 +802,7 @@
+@@ -807,7 +807,7 @@
+ // a short gzip body
+ func TestTransportGzipShort(t *testing.T) {
+ 	defer afterTest(t)
+-	ts := httptest.NewServer(HandlerFunc(func(w ResponseWriter, r *Request) {
++	ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+ 		w.Header().Set("Content-Encoding", "gzip")
+ 		w.Write([]byte{0x1f, 0x8b})
+ 	}))
+@@ -838,7 +838,7 @@
  	defer afterTest(t)
  	gotReqCh := make(chan bool)
  	unblockCh := make(chan bool)
@@ -1421,7 +1328,7 @@
  		gotReqCh <- true
  		<-unblockCh
  		w.Header().Set("Content-Length", "0")
-@@ -869,7 +869,7 @@
+@@ -905,7 +905,7 @@
  		t.Skip("skipping test; see http://golang.org/issue/7237")
  	}
  	defer afterTest(t)
@@ -1430,7 +1337,7 @@
  	}))
  	defer ts.Close()
  
-@@ -912,7 +912,7 @@
+@@ -948,7 +948,7 @@
  	c := &Client{Transport: tr}
  
  	unblockCh := make(chan bool, 1)
@@ -1439,7 +1346,7 @@
  		<-unblockCh
  		tr.CloseIdleConnections()
  	}))
-@@ -939,7 +939,7 @@
+@@ -975,7 +975,7 @@
  func TestIssue3644(t *testing.T) {
  	defer afterTest(t)
  	const numFoos = 5000
@@ -1448,7 +1355,7 @@
  		w.Header().Set("Connection", "close")
  		for i := 0; i < numFoos; i++ {
  			w.Write([]byte("foo "))
-@@ -967,8 +967,8 @@
+@@ -1003,8 +1003,8 @@
  func TestIssue3595(t *testing.T) {
  	defer afterTest(t)
  	const deniedMsg = "sorry, denied."
@@ -1459,7 +1366,7 @@
  	}))
  	defer ts.Close()
  	tr := &Transport{}
-@@ -991,7 +991,7 @@
+@@ -1027,7 +1027,7 @@
  // "client fails to handle requests with no body and chunked encoding"
  func TestChunkedNoContent(t *testing.T) {
  	defer afterTest(t)
@@ -1468,7 +1375,7 @@
  		w.WriteHeader(StatusNoContent)
  	}))
  	defer ts.Close()
-@@ -1019,7 +1019,7 @@
+@@ -1055,7 +1055,7 @@
  		maxProcs, numReqs = 4, 50
  	}
  	defer runtime.GOMAXPROCS(runtime.GOMAXPROCS(maxProcs))
@@ -1477,7 +1384,7 @@
  		fmt.Fprintf(w, "%v", r.FormValue("echo"))
  	}))
  	defer ts.Close()
-@@ -1080,8 +1080,8 @@
+@@ -1116,8 +1116,8 @@
  	}
  	defer afterTest(t)
  	const debug = false
@@ -1488,7 +1395,7 @@
  		io.Copy(w, neverEnding('a'))
  	})
  	ts := httptest.NewServer(mux)
-@@ -1144,11 +1144,11 @@
+@@ -1180,11 +1180,11 @@
  	}
  	defer afterTest(t)
  	const debug = false
@@ -1503,20 +1410,22 @@
  		defer r.Body.Close()
  		io.Copy(ioutil.Discard, r.Body)
  	})
-@@ -1214,9 +1214,9 @@
- 	if testing.Short() {
+@@ -1251,11 +1251,11 @@
  		t.Skip("skipping timeout test in -short mode")
  	}
+ 	inHandler := make(chan bool, 1)
 -	mux := NewServeMux()
--	mux.HandleFunc("/fast", func(w ResponseWriter, r *Request) {})
+-	mux.HandleFunc("/fast", func(w ResponseWriter, r *Request) {
++	mux := http.NewServeMux()
++	mux.HandleFunc("/fast", func(w http.ResponseWriter, r *http.Request) {
+ 		inHandler <- true
+ 	})
 -	mux.HandleFunc("/slow", func(w ResponseWriter, r *Request) {
-+	mux := http.NewServeMux()
-+	mux.HandleFunc("/fast", func(w http.ResponseWriter, r *http.Request) {})
 +	mux.HandleFunc("/slow", func(w http.ResponseWriter, r *http.Request) {
+ 		inHandler <- true
  		time.Sleep(2 * time.Second)
  	})
- 	ts := httptest.NewServer(mux)
-@@ -1276,9 +1276,9 @@
+@@ -1322,9 +1322,9 @@
  		t.Skip("skipping test in -short mode")
  	}
  	unblockc := make(chan bool)
@@ -1528,7 +1437,7 @@
  		<-unblockc
  	}))
  	defer ts.Close()
-@@ -1386,14 +1386,14 @@
+@@ -1431,14 +1431,14 @@
  	defer afterTest(t)
  	writeErr := make(chan error, 1)
  	msg := []byte("young\n")
@@ -1545,7 +1454,7 @@
  		}
  	}))
  	defer ts.Close()
-@@ -1449,7 +1449,7 @@
+@@ -1494,7 +1494,7 @@
  	res := &Response{
  		Status:     "200 OK",
  		StatusCode: 200,
@@ -1554,7 +1463,7 @@
  		Body:       ioutil.NopCloser(strings.NewReader("You wanted " + req.URL.String())),
  	}
  	return res, nil
-@@ -1478,7 +1478,7 @@
+@@ -1523,7 +1523,7 @@
  	defer afterTest(t)
  	tr := &Transport{}
  	_, err := tr.RoundTrip(&Request{
@@ -1563,7 +1472,7 @@
  		URL: &url.URL{
  			Scheme: "http",
  		},
-@@ -1492,14 +1492,14 @@
+@@ -1537,14 +1537,14 @@
  func TestTransportSocketLateBinding(t *testing.T) {
  	defer afterTest(t)
  
@@ -1582,7 +1491,7 @@
  		w.Header().Set("bar-ipport", r.RemoteAddr)
  	})
  	ts := httptest.NewServer(mux)
-@@ -1720,7 +1720,7 @@
+@@ -1767,7 +1767,7 @@
  	var mu sync.Mutex
  	var n int
  
@@ -1591,7 +1500,7 @@
  		mu.Lock()
  		n++
  		mu.Unlock()
-@@ -1756,7 +1756,7 @@
+@@ -1803,7 +1803,7 @@
  // then closes it.
  func TestTransportClosesRequestBody(t *testing.T) {
  	defer afterTest(t)
@@ -1600,4 +1509,49 @@
  		io.Copy(ioutil.Discard, r.Body)
  	}))
  	defer ts.Close()
+@@ -1890,9 +1890,9 @@
+ 		t.Skip("skipping flaky test on Windows; golang.org/issue/7634")
+ 	}
+ 	closedc := make(chan bool, 1)
+-	ts := httptest.NewTLSServer(HandlerFunc(func(w ResponseWriter, r *Request) {
++	ts := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+ 		if strings.Contains(r.URL.Path, "/keep-alive-then-die") {
+-			conn, _, _ := w.(Hijacker).Hijack()
++			conn, _, _ := w.(http.Hijacker).Hijack()
+ 			conn.Write([]byte("HTTP/1.1 200 OK\r\nContent-Length: 3\r\n\r\nfoo"))
+ 			conn.Close()
+ 			closedc <- true
+@@ -1994,12 +1994,12 @@
+ 	}
+ 	defer closeConn()
+ 
+-	ts := httptest.NewServer(HandlerFunc(func(w ResponseWriter, r *Request) {
++	ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+ 		if r.Method == "GET" {
+ 			io.WriteString(w, "bar")
+ 			return
+ 		}
+-		conn, _, _ := w.(Hijacker).Hijack()
++		conn, _, _ := w.(http.Hijacker).Hijack()
+ 		sconn.Lock()
+ 		sconn.c = conn
+ 		sconn.Unlock()
+@@ -2056,7 +2056,7 @@
+ 	}
+ 	defer afterTest(t)
+ 	readBody := make(chan error, 1)
+-	ts := httptest.NewServer(HandlerFunc(func(w ResponseWriter, r *Request) {
++	ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+ 		_, err := ioutil.ReadAll(r.Body)
+ 		readBody <- err
+ 	}))
+@@ -2098,7 +2098,7 @@
+ 	}
+ }
+ 
+-func wantBody(res *http.Response, err error, want string) error {
++func wantBody(res *Response, err error, want string) error {
+ 	if err != nil {
+ 		return err
+ 	}
 

=== modified file 'http13client/_using.txt'
--- http13client/_using.txt	2014-03-20 12:20:01 +0000
+++ http13client/_using.txt	2014-06-24 18:15:10 +0000
@@ -1,5 +1,5 @@
-parent: 19512:32c32aef2a41 tip
- test: enable bug385_32 test on amd64p32.
-branch: default
+parent: 20169:9895f9e36435 go1.3 release
+ go1.3
+branch: release-branch.go1.3
 commit: (clean)
 update: (current)

=== modified file 'http13client/client.go'
--- http13client/client.go	2014-03-20 09:26:28 +0000
+++ http13client/client.go	2014-06-24 18:15:10 +0000
@@ -92,8 +92,9 @@
 	// authentication, or cookies.
 	//
 	// RoundTrip should not modify the request, except for
-	// consuming and closing the Body. The request's URL and
-	// Header fields are guaranteed to be initialized.
+	// consuming and closing the Body, including on errors. The
+	// request's URL and Header fields are guaranteed to be
+	// initialized.
 	RoundTrip(*Request) (*Response, error)
 }
 
@@ -141,6 +142,9 @@
 // (typically Transport) may not be able to re-use a persistent TCP
 // connection to the server for a subsequent "keep-alive" request.
 //
+// The request Body, if non-nil, will be closed by the underlying
+// Transport, even on errors.
+//
 // Generally Get, Post, or PostForm will be used instead of Do.
 func (c *Client) Do(req *Request) (resp *Response, err error) {
 	if req.Method == "GET" || req.Method == "HEAD" {
@@ -163,14 +167,17 @@
 // Caller should close resp.Body when done reading from it.
 func send(req *Request, t RoundTripper) (resp *Response, err error) {
 	if t == nil {
+		req.closeBody()
 		return nil, errors.New("http: no Client.Transport or DefaultTransport")
 	}
 
 	if req.URL == nil {
+		req.closeBody()
 		return nil, errors.New("http: nil Request.URL")
 	}
 
 	if req.RequestURI != "" {
+		req.closeBody()
 		return nil, errors.New("http: Request.RequestURI can't be set in client requests.")
 	}
 
@@ -278,6 +285,7 @@
 	var via []*Request
 
 	if ireq.URL == nil {
+		ireq.closeBody()
 		return nil, errors.New("http: nil Request.URL")
 	}
 
@@ -400,7 +408,7 @@
 // Caller should close resp.Body when done reading from it.
 //
 // If the provided body is also an io.Closer, it is closed after the
-// body is successfully written to the server.
+// request.
 func (c *Client) Post(url string, bodyType string, body io.Reader) (resp *Response, err error) {
 	req, err := NewRequest("POST", url, body)
 	if err != nil {

=== modified file 'http13client/client_test.go'
--- http13client/client_test.go	2014-03-20 09:26:28 +0000
+++ http13client/client_test.go	2014-06-24 18:15:10 +0000
@@ -20,6 +20,8 @@
 	"net/http"
 	"net/http/httptest"
 	"net/url"
+	"reflect"
+	"sort"
 	"strconv"
 	"strings"
 	"sync"
@@ -877,3 +879,93 @@
 		t.Fatal("server saw different client ports before & after the redirect")
 	}
 }
+
+// eofReaderFunc is an io.Reader that runs itself, and then returns io.EOF.
+type eofReaderFunc func()
+
+func (f eofReaderFunc) Read(p []byte) (n int, err error) {
+	f()
+	return 0, io.EOF
+}
+
+func TestClientTrailers(t *testing.T) {
+	defer afterTest(t)
+	ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		w.Header().Set("Connection", "close")
+		w.Header().Set("Trailer", "Server-Trailer-A, Server-Trailer-B")
+		w.Header().Add("Trailer", "Server-Trailer-C")
+
+		var decl []string
+		for k := range r.Trailer {
+			decl = append(decl, k)
+		}
+		sort.Strings(decl)
+
+		slurp, err := ioutil.ReadAll(r.Body)
+		if err != nil {
+			t.Errorf("Server reading request body: %v", err)
+		}
+		if string(slurp) != "foo" {
+			t.Errorf("Server read request body %q; want foo", slurp)
+		}
+		if r.Trailer == nil {
+			io.WriteString(w, "nil Trailer")
+		} else {
+			fmt.Fprintf(w, "decl: %v, vals: %s, %s",
+				decl,
+				r.Trailer.Get("Client-Trailer-A"),
+				r.Trailer.Get("Client-Trailer-B"))
+		}
+
+		// TODO: golang.org/issue/7759: there's no way yet for
+		// the server to set trailers without hijacking, so do
+		// that for now, just to test the client.  Later, in
+		// Go 1.4, it should be implicit that any mutations
+		// to w.Header() after the initial write are the
+		// trailers to be sent, if and only if they were
+		// previously declared with w.Header().Set("Trailer",
+		// ..keys..)
+		w.(http.Flusher).Flush()
+		conn, buf, _ := w.(http.Hijacker).Hijack()
+		t := http.Header{}
+		t.Set("Server-Trailer-A", "valuea")
+		t.Set("Server-Trailer-C", "valuec") // skipping B
+		buf.WriteString("0\r\n")            // eof
+		t.Write(buf)
+		buf.WriteString("\r\n") // end of trailers
+		buf.Flush()
+		conn.Close()
+	}))
+	defer ts.Close()
+
+	var req *Request
+	req, _ = NewRequest("POST", ts.URL, io.MultiReader(
+		eofReaderFunc(func() {
+			req.Trailer["Client-Trailer-A"] = []string{"valuea"}
+		}),
+		strings.NewReader("foo"),
+		eofReaderFunc(func() {
+			req.Trailer["Client-Trailer-B"] = []string{"valueb"}
+		}),
+	))
+	req.Trailer = http.Header{
+		"Client-Trailer-A": nil, //  to be set later
+		"Client-Trailer-B": nil, //  to be set later
+	}
+	req.ContentLength = -1
+	res, err := DefaultClient.Do(req)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if err := wantBody(res, err, "decl: [Client-Trailer-A Client-Trailer-B], vals: valuea, valueb"); err != nil {
+		t.Error(err)
+	}
+	want := http.Header{
+		"Server-Trailer-A": []string{"valuea"},
+		"Server-Trailer-B": nil,
+		"Server-Trailer-C": []string{"valuec"},
+	}
+	if !reflect.DeepEqual(res.Trailer, want) {
+		t.Errorf("Response trailers = %#v; want %#v", res.Trailer, want)
+	}
+}

=== modified file 'http13client/cookie.go'
--- http13client/cookie.go	2014-03-19 23:13:58 +0000
+++ http13client/cookie.go	2014-06-24 18:15:10 +0000
@@ -55,11 +55,7 @@
 				attr, val = attr[:j], attr[j+1:]
 			}
 			lowerAttr := strings.ToLower(attr)
-			parseCookieValueFn := parseCookieValue
-			if lowerAttr == "expires" {
-				parseCookieValueFn = parseCookieExpiresValue
-			}
-			val, success = parseCookieValueFn(val)
+			val, success = parseCookieValue(val)
 			if !success {
 				c.Unparsed = append(c.Unparsed, parts[i])
 				continue
@@ -230,12 +226,23 @@
 //           ; US-ASCII characters excluding CTLs,
 //           ; whitespace DQUOTE, comma, semicolon,
 //           ; and backslash
+// We loosen this as spaces and commas are common in cookie values
+// but we produce a quoted cookie-value in when value starts or ends
+// with a comma or space.
+// See http://golang.org/issue/7243 for the discussion.
 func sanitizeCookieValue(v string) string {
-	return sanitizeOrWarn("Cookie.Value", validCookieValueByte, v)
+	v = sanitizeOrWarn("Cookie.Value", validCookieValueByte, v)
+	if len(v) == 0 {
+		return v
+	}
+	if v[0] == ' ' || v[0] == ',' || v[len(v)-1] == ' ' || v[len(v)-1] == ',' {
+		return `"` + v + `"`
+	}
+	return v
 }
 
 func validCookieValueByte(b byte) bool {
-	return 0x20 < b && b < 0x7f && b != '"' && b != ',' && b != ';' && b != '\\'
+	return 0x20 <= b && b < 0x7f && b != '"' && b != ';' && b != '\\'
 }
 
 // path-av           = "Path=" path-value
@@ -270,38 +277,13 @@
 	return string(buf)
 }
 
-func unquoteCookieValue(v string) string {
-	if len(v) > 1 && v[0] == '"' && v[len(v)-1] == '"' {
-		return v[1 : len(v)-1]
-	}
-	return v
-}
-
-func isCookieByte(c byte) bool {
-	switch {
-	case c == 0x21, 0x23 <= c && c <= 0x2b, 0x2d <= c && c <= 0x3a,
-		0x3c <= c && c <= 0x5b, 0x5d <= c && c <= 0x7e:
-		return true
-	}
-	return false
-}
-
-func isCookieExpiresByte(c byte) (ok bool) {
-	return isCookieByte(c) || c == ',' || c == ' '
-}
-
 func parseCookieValue(raw string) (string, bool) {
-	return parseCookieValueUsing(raw, isCookieByte)
-}
-
-func parseCookieExpiresValue(raw string) (string, bool) {
-	return parseCookieValueUsing(raw, isCookieExpiresByte)
-}
-
-func parseCookieValueUsing(raw string, validByte func(byte) bool) (string, bool) {
-	raw = unquoteCookieValue(raw)
+	// Strip the quotes, if present.
+	if len(raw) > 1 && raw[0] == '"' && raw[len(raw)-1] == '"' {
+		raw = raw[1 : len(raw)-1]
+	}
 	for i := 0; i < len(raw); i++ {
-		if !validByte(raw[i]) {
+		if !validCookieValueByte(raw[i]) {
 			return "", false
 		}
 	}

=== removed file 'http13client/cookie_test.go'
--- http13client/cookie_test.go	2014-03-19 23:13:58 +0000
+++ http13client/cookie_test.go	1970-01-01 00:00:00 +0000
@@ -1,304 +0,0 @@
-// Copyright 2010 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 http
-
-import (
-	"bytes"
-	"encoding/json"
-	"fmt"
-	"log"
-	"net/http"
-	"os"
-	"reflect"
-	"strings"
-	"testing"
-	"time"
-)
-
-var writeSetCookiesTests = []struct {
-	Cookie *http.Cookie
-	Raw    string
-}{
-	{
-		&http.Cookie{Name: "cookie-1", Value: "v$1"},
-		"cookie-1=v$1",
-	},
-	{
-		&http.Cookie{Name: "cookie-2", Value: "two", MaxAge: 3600},
-		"cookie-2=two; Max-Age=3600",
-	},
-	{
-		&http.Cookie{Name: "cookie-3", Value: "three", Domain: ".example.com"},
-		"cookie-3=three; Domain=example.com",
-	},
-	{
-		&http.Cookie{Name: "cookie-4", Value: "four", Path: "/restricted/"},
-		"cookie-4=four; Path=/restricted/",
-	},
-	{
-		&http.Cookie{Name: "cookie-5", Value: "five", Domain: "wrong;bad.abc"},
-		"cookie-5=five",
-	},
-	{
-		&http.Cookie{Name: "cookie-6", Value: "six", Domain: "bad-.abc"},
-		"cookie-6=six",
-	},
-	{
-		&http.Cookie{Name: "cookie-7", Value: "seven", Domain: "127.0.0.1"},
-		"cookie-7=seven; Domain=127.0.0.1",
-	},
-	{
-		&http.Cookie{Name: "cookie-8", Value: "eight", Domain: "::1"},
-		"cookie-8=eight",
-	},
-}
-
-func TestWriteSetCookies(t *testing.T) {
-	defer log.SetOutput(os.Stderr)
-	var logbuf bytes.Buffer
-	log.SetOutput(&logbuf)
-
-	for i, tt := range writeSetCookiesTests {
-		if g, e := tt.Cookie.String(), tt.Raw; g != e {
-			t.Errorf("Test %d, expecting:\n%s\nGot:\n%s\n", i, e, g)
-			continue
-		}
-	}
-
-	if got, sub := logbuf.String(), "dropping domain attribute"; !strings.Contains(got, sub) {
-		t.Errorf("Expected substring %q in log output. Got:\n%s", sub, got)
-	}
-}
-
-type headerOnlyResponseWriter http.Header
-
-func (ho headerOnlyResponseWriter) Header() http.Header {
-	return http.Header(ho)
-}
-
-func (ho headerOnlyResponseWriter) Write([]byte) (int, error) {
-	panic("NOIMPL")
-}
-
-func (ho headerOnlyResponseWriter) WriteHeader(int) {
-	panic("NOIMPL")
-}
-
-func TestSetCookie(t *testing.T) {
-	m := make(http.Header)
-	http.SetCookie(headerOnlyResponseWriter(m), &http.Cookie{Name: "cookie-1", Value: "one", Path: "/restricted/"})
-	http.SetCookie(headerOnlyResponseWriter(m), &http.Cookie{Name: "cookie-2", Value: "two", MaxAge: 3600})
-	if l := len(m["Set-Cookie"]); l != 2 {
-		t.Fatalf("expected %d cookies, got %d", 2, l)
-	}
-	if g, e := m["Set-Cookie"][0], "cookie-1=one; Path=/restricted/"; g != e {
-		t.Errorf("cookie #1: want %q, got %q", e, g)
-	}
-	if g, e := m["Set-Cookie"][1], "cookie-2=two; Max-Age=3600"; g != e {
-		t.Errorf("cookie #2: want %q, got %q", e, g)
-	}
-}
-
-var addCookieTests = []struct {
-	Cookies []*http.Cookie
-	Raw     string
-}{
-	{
-		[]*http.Cookie{},
-		"",
-	},
-	{
-		[]*http.Cookie{{Name: "cookie-1", Value: "v$1"}},
-		"cookie-1=v$1",
-	},
-	{
-		[]*http.Cookie{
-			{Name: "cookie-1", Value: "v$1"},
-			{Name: "cookie-2", Value: "v$2"},
-			{Name: "cookie-3", Value: "v$3"},
-		},
-		"cookie-1=v$1; cookie-2=v$2; cookie-3=v$3",
-	},
-}
-
-func TestAddCookie(t *testing.T) {
-	for i, tt := range addCookieTests {
-		req, _ := NewRequest("GET", "http://example.com/", nil)
-		for _, c := range tt.Cookies {
-			req.AddCookie(c)
-		}
-		if g := req.Header.Get("Cookie"); g != tt.Raw {
-			t.Errorf("Test %d:\nwant: %s\n got: %s\n", i, tt.Raw, g)
-			continue
-		}
-	}
-}
-
-var readSetCookiesTests = []struct {
-	Header  http.Header
-	Cookies []*http.Cookie
-}{
-	{
-		http.Header{"Set-Cookie": {"Cookie-1=v$1"}},
-		[]*http.Cookie{{Name: "Cookie-1", Value: "v$1", Raw: "Cookie-1=v$1"}},
-	},
-	{
-		http.Header{"Set-Cookie": {"NID=99=YsDT5i3E-CXax-; expires=Wed, 23-Nov-2011 01:05:03 GMT; path=/; domain=.google.ch; HttpOnly"}},
-		[]*http.Cookie{{
-			Name:       "NID",
-			Value:      "99=YsDT5i3E-CXax-",
-			Path:       "/",
-			Domain:     ".google.ch",
-			HttpOnly:   true,
-			Expires:    time.Date(2011, 11, 23, 1, 5, 3, 0, time.UTC),
-			RawExpires: "Wed, 23-Nov-2011 01:05:03 GMT",
-			Raw:        "NID=99=YsDT5i3E-CXax-; expires=Wed, 23-Nov-2011 01:05:03 GMT; path=/; domain=.google.ch; HttpOnly",
-		}},
-	},
-	{
-		http.Header{"Set-Cookie": {".ASPXAUTH=7E3AA; expires=Wed, 07-Mar-2012 14:25:06 GMT; path=/; HttpOnly"}},
-		[]*http.Cookie{{
-			Name:       ".ASPXAUTH",
-			Value:      "7E3AA",
-			Path:       "/",
-			Expires:    time.Date(2012, 3, 7, 14, 25, 6, 0, time.UTC),
-			RawExpires: "Wed, 07-Mar-2012 14:25:06 GMT",
-			HttpOnly:   true,
-			Raw:        ".ASPXAUTH=7E3AA; expires=Wed, 07-Mar-2012 14:25:06 GMT; path=/; HttpOnly",
-		}},
-	},
-	{
-		http.Header{"Set-Cookie": {"ASP.NET_SessionId=foo; path=/; HttpOnly"}},
-		[]*http.Cookie{{
-			Name:     "ASP.NET_SessionId",
-			Value:    "foo",
-			Path:     "/",
-			HttpOnly: true,
-			Raw:      "ASP.NET_SessionId=foo; path=/; HttpOnly",
-		}},
-	},
-
-	// TODO(bradfitz): users have reported seeing this in the
-	// wild, but do browsers handle it? RFC 6265 just says "don't
-	// do that" (section 3) and then never mentions header folding
-	// again.
-	// Header{"Set-Cookie": {"ASP.NET_SessionId=foo; path=/; HttpOnly, .ASPXAUTH=7E3AA; expires=Wed, 07-Mar-2012 14:25:06 GMT; path=/; HttpOnly"}},
-}
-
-func toJSON(v interface{}) string {
-	b, err := json.Marshal(v)
-	if err != nil {
-		return fmt.Sprintf("%#v", v)
-	}
-	return string(b)
-}
-
-func TestReadSetCookies(t *testing.T) {
-	for i, tt := range readSetCookiesTests {
-		for n := 0; n < 2; n++ { // to verify readSetCookies doesn't mutate its input
-			c := readSetCookies(tt.Header)
-			if !reflect.DeepEqual(c, tt.Cookies) {
-				t.Errorf("#%d readSetCookies: have\n%s\nwant\n%s\n", i, toJSON(c), toJSON(tt.Cookies))
-				continue
-			}
-		}
-	}
-}
-
-var readCookiesTests = []struct {
-	Header  http.Header
-	Filter  string
-	Cookies []*http.Cookie
-}{
-	{
-		http.Header{"Cookie": {"Cookie-1=v$1", "c2=v2"}},
-		"",
-		[]*http.Cookie{
-			{Name: "Cookie-1", Value: "v$1"},
-			{Name: "c2", Value: "v2"},
-		},
-	},
-	{
-		http.Header{"Cookie": {"Cookie-1=v$1", "c2=v2"}},
-		"c2",
-		[]*http.Cookie{
-			{Name: "c2", Value: "v2"},
-		},
-	},
-	{
-		http.Header{"Cookie": {"Cookie-1=v$1; c2=v2"}},
-		"",
-		[]*http.Cookie{
-			{Name: "Cookie-1", Value: "v$1"},
-			{Name: "c2", Value: "v2"},
-		},
-	},
-	{
-		http.Header{"Cookie": {"Cookie-1=v$1; c2=v2"}},
-		"c2",
-		[]*http.Cookie{
-			{Name: "c2", Value: "v2"},
-		},
-	},
-}
-
-func TestReadCookies(t *testing.T) {
-	for i, tt := range readCookiesTests {
-		for n := 0; n < 2; n++ { // to verify readCookies doesn't mutate its input
-			c := readCookies(tt.Header, tt.Filter)
-			if !reflect.DeepEqual(c, tt.Cookies) {
-				t.Errorf("#%d readCookies:\nhave: %s\nwant: %s\n", i, toJSON(c), toJSON(tt.Cookies))
-				continue
-			}
-		}
-	}
-}
-
-func TestCookieSanitizeValue(t *testing.T) {
-	defer log.SetOutput(os.Stderr)
-	var logbuf bytes.Buffer
-	log.SetOutput(&logbuf)
-
-	tests := []struct {
-		in, want string
-	}{
-		{"foo", "foo"},
-		{"foo bar", "foobar"},
-		{"\x00\x7e\x7f\x80", "\x7e"},
-		{`"withquotes"`, "withquotes"},
-	}
-	for _, tt := range tests {
-		if got := sanitizeCookieValue(tt.in); got != tt.want {
-			t.Errorf("sanitizeCookieValue(%q) = %q; want %q", tt.in, got, tt.want)
-		}
-	}
-
-	if got, sub := logbuf.String(), "dropping invalid bytes"; !strings.Contains(got, sub) {
-		t.Errorf("Expected substring %q in log output. Got:\n%s", sub, got)
-	}
-}
-
-func TestCookieSanitizePath(t *testing.T) {
-	defer log.SetOutput(os.Stderr)
-	var logbuf bytes.Buffer
-	log.SetOutput(&logbuf)
-
-	tests := []struct {
-		in, want string
-	}{
-		{"/path", "/path"},
-		{"/path with space/", "/path with space/"},
-		{"/just;no;semicolon\x00orstuff/", "/justnosemicolonorstuff/"},
-	}
-	for _, tt := range tests {
-		if got := sanitizeCookiePath(tt.in); got != tt.want {
-			t.Errorf("sanitizeCookiePath(%q) = %q; want %q", tt.in, got, tt.want)
-		}
-	}
-
-	if got, sub := logbuf.String(), "dropping invalid bytes"; !strings.Contains(got, sub) {
-		t.Errorf("Expected substring %q in log output. Got:\n%s", sub, got)
-	}
-}

=== modified file 'http13client/request.go'
--- http13client/request.go	2014-03-19 23:13:58 +0000
+++ http13client/request.go	2014-06-24 18:15:10 +0000
@@ -69,18 +69,31 @@
 
 // A Request represents an HTTP request received by a server
 // or to be sent by a client.
+//
+// The field semantics differ slightly between client and server
+// usage. In addition to the notes on the fields below, see the
+// documentation for Request.Write and RoundTripper.
 type Request struct {
-	Method string // GET, POST, PUT, etc.
+	// Method specifies the HTTP method (GET, POST, PUT, etc.).
+	// For client requests an empty string means GET.
+	Method string
 
-	// URL is created from the URI supplied on the Request-Line
-	// as stored in RequestURI.
-	//
-	// For most requests, fields other than Path and RawQuery
-	// will be empty. (See RFC 2616, Section 5.1.2)
+	// URL specifies either the URI being requested (for server
+	// requests) or the URL to access (for client requests).
+	//
+	// For server requests the URL is parsed from the URI
+	// supplied on the Request-Line as stored in RequestURI.  For
+	// most requests, fields other than Path and RawQuery will be
+	// empty. (See RFC 2616, Section 5.1.2)
+	//
+	// For client requests, the URL's Host specifies the server to
+	// connect to, while the Request's Host field optionally
+	// specifies the Host header value to send in the HTTP
+	// request.
 	URL *url.URL
 
 	// The protocol version for incoming requests.
-	// Outgoing requests always use HTTP/1.1.
+	// Client requests always use HTTP/1.1.
 	Proto      string // "HTTP/1.0"
 	ProtoMajor int    // 1
 	ProtoMinor int    // 0
@@ -104,15 +117,20 @@
 	// The request parser implements this by canonicalizing the
 	// name, making the first character and any characters
 	// following a hyphen uppercase and the rest lowercase.
+	//
+	// For client requests certain headers are automatically
+	// added and may override values in Header.
+	//
+	// See the documentation for the Request.Write method.
 	Header http.Header
 
 	// Body is the request's body.
 	//
-	// For client requests, a nil body means the request has no
+	// For client requests a nil body means the request has no
 	// body, such as a GET request. The HTTP Client's Transport
 	// is responsible for calling the Close method.
 	//
-	// For server requests, the Request Body is always non-nil
+	// For server requests the Request Body is always non-nil
 	// but will return EOF immediately when no body is present.
 	// The Server will close the request body. The ServeHTTP
 	// Handler does not need to.
@@ -122,7 +140,7 @@
 	// The value -1 indicates that the length is unknown.
 	// Values >= 0 indicate that the given number of bytes may
 	// be read from Body.
-	// For outgoing requests, a value of 0 means unknown if Body is not nil.
+	// For client requests, a value of 0 means unknown if Body is not nil.
 	ContentLength int64
 
 	// TransferEncoding lists the transfer encodings from outermost to
@@ -133,13 +151,18 @@
 	TransferEncoding []string
 
 	// Close indicates whether to close the connection after
-	// replying to this request.
+	// replying to this request (for servers) or after sending
+	// the request (for clients).
 	Close bool
 
-	// The host on which the URL is sought.
-	// Per RFC 2616, this is either the value of the Host: header
-	// or the host name given in the URL itself.
+	// For server requests Host specifies the host on which the
+	// URL is sought. Per RFC 2616, this is either the value of
+	// the "Host" header or the host name given in the URL itself.
 	// It may be of the form "host:port".
+	//
+	// For client requests Host optionally overrides the Host
+	// header to send. If empty, the Request.Write method uses
+	// the value of URL.Host.
 	Host string
 
 	// Form contains the parsed form data, including both the URL
@@ -159,12 +182,24 @@
 	// The HTTP client ignores MultipartForm and uses Body instead.
 	MultipartForm *multipart.Form
 
-	// Trailer maps trailer keys to values.  Like for Header, if the
-	// response has multiple trailer lines with the same key, they will be
-	// concatenated, delimited by commas.
-	// For server requests, Trailer is only populated after Body has been
-	// closed or fully consumed.
-	// Trailer support is only partially complete.
+	// Trailer specifies additional headers that are sent after the request
+	// body.
+	//
+	// For server requests the Trailer map initially contains only the
+	// trailer keys, with nil values. (The client declares which trailers it
+	// will later send.)  While the handler is reading from Body, it must
+	// not reference Trailer. After reading from Body returns EOF, Trailer
+	// can be read again and will contain non-nil values, if they were sent
+	// by the client.
+	//
+	// For client requests Trailer must be initialized to a map containing
+	// the trailer keys to later send. The values may be nil or their final
+	// values. The ContentLength must be 0 or -1, to send a chunked request.
+	// After the HTTP request is sent the map values can be updated while
+	// the request body is read. Once the body returns EOF, the caller must
+	// not mutate Trailer.
+	//
+	// Few HTTP clients, servers, or proxies support HTTP trailers.
 	Trailer http.Header
 
 	// RemoteAddr allows HTTP servers and other software to record
@@ -382,7 +417,6 @@
 		return err
 	}
 
-	// TODO: split long values?  (If so, should share code with Conn.Write)
 	err = req.Header.WriteSubset(w, reqWriteExcludeHeader)
 	if err != nil {
 		return err
@@ -589,32 +623,6 @@
 
 	fixPragmaCacheControl(req.Header)
 
-	// TODO: Parse specific header values:
-	//	Accept
-	//	Accept-Encoding
-	//	Accept-Language
-	//	Authorization
-	//	Cache-Control
-	//	Connection
-	//	Date
-	//	Expect
-	//	From
-	//	If-Match
-	//	If-Modified-Since
-	//	If-None-Match
-	//	If-Range
-	//	If-Unmodified-Since
-	//	Max-Forwards
-	//	Proxy-Authorization
-	//	Referer [sic]
-	//	TE (transfer-codings)
-	//	Trailer
-	//	Transfer-Encoding
-	//	Upgrade
-	//	User-Agent
-	//	Via
-	//	Warning
-
 	err = readTransfer(req, b)
 	if err != nil {
 		return nil, err
@@ -783,9 +791,7 @@
 	}
 
 	mr, err := r.multipartReader()
-	if err == ErrNotMultipart {
-		return nil
-	} else if err != nil {
+	if err != nil {
 		return err
 	}
 
@@ -863,3 +869,9 @@
 func (r *Request) wantsClose() bool {
 	return hasToken(r.Header.Get("Connection"), "close")
 }
+
+func (r *Request) closeBody() {
+	if r.Body != nil {
+		r.Body.Close()
+	}
+}

=== modified file 'http13client/request_test.go'
--- http13client/request_test.go	2014-03-20 09:26:28 +0000
+++ http13client/request_test.go	2014-06-24 18:15:10 +0000
@@ -155,7 +155,25 @@
 	req.Header = http.Header{"Content-Type": {"text/plain"}}
 	multipart, err = req.MultipartReader()
 	if multipart != nil {
-		t.Errorf("unexpected multipart for text/plain")
+		t.Error("unexpected multipart for text/plain")
+	}
+}
+
+func TestParseMultipartForm(t *testing.T) {
+	req := &Request{
+		Method: "POST",
+		Header: http.Header{"Content-Type": {`multipart/form-data; boundary="foo123"`}},
+		Body:   ioutil.NopCloser(new(bytes.Buffer)),
+	}
+	err := req.ParseMultipartForm(25)
+	if err == nil {
+		t.Error("expected multipart EOF, got nil")
+	}
+
+	req.Header = http.Header{"Content-Type": {"text/plain"}}
+	err = req.ParseMultipartForm(25)
+	if err != ErrNotMultipart {
+		t.Error("expected ErrNotMultipart for text/plain")
 	}
 }
 
@@ -221,16 +239,38 @@
 	validateTestMultipartContents(t, req, true)
 }
 
-func TestEmptyMultipartRequest(t *testing.T) {
-	// Test that FormValue and FormFile automatically invoke
-	// ParseMultipartForm and return the right values.
-	req, err := NewRequest("GET", "/", nil)
-	if err != nil {
-		t.Errorf("NewRequest err = %q", err)
-	}
+func TestMissingFileMultipartRequest(t *testing.T) {
+	// Test that FormFile returns an error if
+	// the named file is missing.
+	req := newTestMultipartRequest(t)
 	testMissingFile(t, req)
 }
 
+// Test that FormValue invokes ParseMultipartForm.
+func TestFormValueCallsParseMultipartForm(t *testing.T) {
+	req, _ := NewRequest("POST", "http://www.google.com/", strings.NewReader("z=post"))
+	req.Header.Set("Content-Type", "application/x-www-form-urlencoded; param=value")
+	if req.Form != nil {
+		t.Fatal("Unexpected request Form, want nil")
+	}
+	req.FormValue("z")
+	if req.Form == nil {
+		t.Fatal("ParseMultipartForm not called by FormValue")
+	}
+}
+
+// Test that FormFile invokes ParseMultipartForm.
+func TestFormFileCallsParseMultipartForm(t *testing.T) {
+	req := newTestMultipartRequest(t)
+	if req.Form != nil {
+		t.Fatal("Unexpected request Form, want nil")
+	}
+	req.FormFile("")
+	if req.Form == nil {
+		t.Fatal("ParseMultipartForm not called by FormFile")
+	}
+}
+
 // Test that ParseMultipartForm errors if called
 // after MultipartReader on the same request.
 func TestParseMultipartFormOrder(t *testing.T) {

=== modified file 'http13client/response.go'
--- http13client/response.go	2014-03-19 23:43:25 +0000
+++ http13client/response.go	2014-06-24 18:15:10 +0000
@@ -8,6 +8,7 @@
 
 import (
 	"bufio"
+	"bytes"
 	"crypto/tls"
 	"errors"
 	"io"
@@ -47,7 +48,8 @@
 	//
 	// The http Client and Transport guarantee that Body is always
 	// non-nil, even on responses without a body or responses with
-	// a zero-lengthed body.
+	// a zero-length body. It is the caller's responsibility to
+	// close Body.
 	//
 	// The Body is automatically dechunked if the server replied
 	// with a "chunked" Transfer-Encoding.
@@ -200,7 +202,6 @@
 //
 // Body is closed after it is sent.
 func (r *Response) Write(w io.Writer) error {
-
 	// Status line
 	text := r.Status
 	if text == "" {
@@ -212,10 +213,45 @@
 	protoMajor, protoMinor := strconv.Itoa(r.ProtoMajor), strconv.Itoa(r.ProtoMinor)
 	statusCode := strconv.Itoa(r.StatusCode) + " "
 	text = strings.TrimPrefix(text, statusCode)
-	io.WriteString(w, "HTTP/"+protoMajor+"."+protoMinor+" "+statusCode+text+"\r\n")
+	if _, err := io.WriteString(w, "HTTP/"+protoMajor+"."+protoMinor+" "+statusCode+text+"\r\n"); err != nil {
+		return err
+	}
+
+	// Clone it, so we can modify r1 as needed.
+	r1 := new(Response)
+	*r1 = *r
+	if r1.ContentLength == 0 && r1.Body != nil {
+		// Is it actually 0 length? Or just unknown?
+		var buf [1]byte
+		n, err := r1.Body.Read(buf[:])
+		if err != nil && err != io.EOF {
+			return err
+		}
+		if n == 0 {
+			// Reset it to a known zero reader, in case underlying one
+			// is unhappy being read repeatedly.
+			r1.Body = eofReader
+		} else {
+			r1.ContentLength = -1
+			r1.Body = struct {
+				io.Reader
+				io.Closer
+			}{
+				io.MultiReader(bytes.NewReader(buf[:1]), r.Body),
+				r.Body,
+			}
+		}
+	}
+	// If we're sending a non-chunked HTTP/1.1 response without a
+	// content-length, the only way to do that is the old HTTP/1.0
+	// way, by noting the EOF with a connection close, so we need
+	// to set Close.
+	if r1.ContentLength == -1 && !r1.Close && r1.ProtoAtLeast(1, 1) && !chunked(r1.TransferEncoding) {
+		r1.Close = true
+	}
 
 	// Process Body,ContentLength,Close,Trailer
-	tw, err := newTransferWriter(r)
+	tw, err := newTransferWriter(r1)
 	if err != nil {
 		return err
 	}
@@ -230,8 +266,19 @@
 		return err
 	}
 
+	// contentLengthAlreadySent may have been already sent for
+	// POST/PUT requests, even if zero length. See Issue 8180.
+	contentLengthAlreadySent := tw.shouldSendContentLength()
+	if r1.ContentLength == 0 && !chunked(r1.TransferEncoding) && !contentLengthAlreadySent {
+		if _, err := io.WriteString(w, "Content-Length: 0\r\n"); err != nil {
+			return err
+		}
+	}
+
 	// End-of-header
-	io.WriteString(w, "\r\n")
+	if _, err := io.WriteString(w, "\r\n"); err != nil {
+		return err
+	}
 
 	// Write body and trailer
 	err = tw.WriteBody(w)

=== modified file 'http13client/response_test.go'
--- http13client/response_test.go	2014-03-19 23:13:58 +0000
+++ http13client/response_test.go	2014-06-24 18:15:10 +0000
@@ -30,6 +30,10 @@
 	return &Request{Method: method}
 }
 
+func dummyReq11(method string) *Request {
+	return &Request{Method: method, Proto: "HTTP/1.1", ProtoMajor: 1, ProtoMinor: 1}
+}
+
 var respTests = []respTest{
 	// Unchunked response without Content-Length.
 	{

=== modified file 'http13client/responsewrite_test.go'
--- http13client/responsewrite_test.go	2014-03-19 23:13:58 +0000
+++ http13client/responsewrite_test.go	2014-06-24 18:15:10 +0000
@@ -27,7 +27,7 @@
 				ProtoMinor:    0,
 				Request:       dummyReq("GET"),
 				Header:        http.Header{},
-				Body:          ioutil.NopCloser(bytes.NewBufferString("abcdef")),
+				Body:          ioutil.NopCloser(strings.NewReader("abcdef")),
 				ContentLength: 6,
 			},
 
@@ -50,6 +50,106 @@
 				"\r\n" +
 				"abcdef",
 		},
+		// HTTP/1.1 response with unknown length and Connection: close
+		{
+			Response{
+				StatusCode:    200,
+				ProtoMajor:    1,
+				ProtoMinor:    1,
+				Request:       dummyReq("GET"),
+				Header:        http.Header{},
+				Body:          ioutil.NopCloser(strings.NewReader("abcdef")),
+				ContentLength: -1,
+				Close:         true,
+			},
+			"HTTP/1.1 200 OK\r\n" +
+				"Connection: close\r\n" +
+				"\r\n" +
+				"abcdef",
+		},
+		// HTTP/1.1 response with unknown length and not setting connection: close
+		{
+			Response{
+				StatusCode:    200,
+				ProtoMajor:    1,
+				ProtoMinor:    1,
+				Request:       dummyReq11("GET"),
+				Header:        http.Header{},
+				Body:          ioutil.NopCloser(strings.NewReader("abcdef")),
+				ContentLength: -1,
+				Close:         false,