diff --git a/fetch.go b/fetch.go
index 831d620..dd953a8 100644
--- a/fetch.go
+++ b/fetch.go
@@ -91,14 +91,7 @@
 		return fmt.Errorf("%s is already vendored", path)
 	}
 
-	var wc vendor.WorkingCopy
-
-	// if we are not recursing, then always fetch the HEAD of the master
-	if recurse {
-		wc, err = repo.Checkout(branch, tag, revision)
-	} else {
-		wc, err = repo.Checkout("", "", "")
-	}
+	wc, err := repo.Checkout(branch, tag, revision)
 
 	if err != nil {
 		return err
@@ -145,6 +138,12 @@
 		return nil
 	}
 
+	// if we are recursing, overwrite branch, tag and revision
+	// values so recursive fetching checks out from HEAD.
+	branch = ""
+	tag = ""
+	revision = ""
+
 	for done := false; !done; {
 
 		paths := []struct {
diff --git a/gbvendor/copy.go b/gbvendor/copy.go
index 1d2f599..52d4c98 100644
--- a/gbvendor/copy.go
+++ b/gbvendor/copy.go
@@ -61,6 +61,7 @@
 	if err != nil {
 		return fmt.Errorf("copyfile: create(%q): %v", dst, err)
 	}
+	defer w.Close()
 	if debugCopyfile {
 		fmt.Printf("copyfile(dst: %v, src: %v)\n", dst, src)
 	}
diff --git a/gbvendor/imports.go b/gbvendor/imports.go
index d3c34b2..80174af 100644
--- a/gbvendor/imports.go
+++ b/gbvendor/imports.go
@@ -5,7 +5,6 @@
 	"go/parser"
 	"go/token"
 	"io"
-	"log"
 	"net/http"
 	"os"
 	"path/filepath"
@@ -48,36 +47,36 @@
 }
 
 // FetchMetadata fetchs the remote metadata for path.
-func FetchMetadata(path string, insecure bool) (io.ReadCloser, error) {
-	schemes := []string{"https", "http"}
-	for _, s := range schemes {
-		if r, err := fetchMetadata(s, path, insecure); err == nil {
-			return r, nil
+func FetchMetadata(path string, insecure bool) (rc io.ReadCloser, err error) {
+	defer func() {
+		if err != nil {
+			err = fmt.Errorf("unable to determine remote metadata protocol: %s", err)
 		}
+	}()
+	// try https first
+	rc, err = fetchMetadata("https", path)
+	if err == nil {
+		return
 	}
-	return nil, fmt.Errorf("unable to determine remote metadata protocol")
+	// try http if supported
+	if insecure {
+		rc, err = fetchMetadata("http", path)
+	}
+	return
 }
 
-func fetchMetadata(scheme, path string, insecure bool) (io.ReadCloser, error) {
+func fetchMetadata(scheme, path string) (io.ReadCloser, error) {
 	url := fmt.Sprintf("%s://%s?go-get=1", scheme, path)
 	switch scheme {
-	case "https":
+	case "https", "http":
 		resp, err := http.Get(url)
-		if err == nil {
-			return resp.Body, nil
+		if err != nil {
+			return nil, fmt.Errorf("failed to access url %q", url)
 		}
-	case "http":
-		if !insecure {
-			log.Printf("skipping insecure protocol: %v", url)
-		} else {
-			resp, err := http.Get(url)
-			if err == nil {
-				return resp.Body, nil
-			}
-		}
+		return resp.Body, nil
+	default:
+		return nil, fmt.Errorf("unknown remote protocol scheme: %q", scheme)
 	}
-
-	return nil, fmt.Errorf("unknown remote protocol scheme: %q", scheme)
 }
 
 // ParseMetadata fetchs and decodes remote metadata for path.
diff --git a/gbvendor/imports_test.go b/gbvendor/imports_test.go
index 2794292..37d029d 100644
--- a/gbvendor/imports_test.go
+++ b/gbvendor/imports_test.go
@@ -2,7 +2,6 @@
 
 import (
 	"bytes"
-	"fmt"
 	"io"
 	"os"
 	"path/filepath"
@@ -28,11 +27,12 @@
 	if testing.Short() {
 		t.Skipf("skipping network tests in -short mode")
 	}
-	tests := []struct {
+	type testParams struct {
 		path     string
 		want     string
 		insecure bool
-	}{{
+	}
+	tests := []testParams{{
 		path: "golang.org/x/tools/cmd/godoc",
 		want: `<!DOCTYPE html>
 <html>
@@ -80,6 +80,32 @@
 			t.Errorf("FetchMetadata(%q): want %q, got %q", tt.path, tt.want, got)
 		}
 	}
+
+	// Test for error catch.
+	errTests := []testParams{{
+		path:     "any.inaccessible.server/the.project",
+		want:     `unable to determine remote metadata protocol: failed to access url "http://any.inaccessible.server/the.project?go-get=1"`,
+		insecure: true,
+	}, {
+		path:     "any.inaccessible.server/the.project",
+		want:     `unable to determine remote metadata protocol: failed to access url "https://any.inaccessible.server/the.project?go-get=1"`,
+		insecure: false,
+	}}
+
+	for _, ett := range errTests {
+		r, err := FetchMetadata(ett.path, ett.insecure)
+		if err == nil {
+			t.Errorf("Access to url %q without any error, but the error should be happen.", ett.path)
+			if r != nil {
+				r.Close()
+			}
+			continue
+		}
+		got := err.Error()
+		if got != ett.want {
+			t.Errorf("FetchMetadata(%q): want %q, got %q", ett.path, ett.want, got)
+		}
+	}
 }
 
 func TestParseMetadata(t *testing.T) {
@@ -108,9 +134,10 @@
 		importpath: "gopkg.in/mgo.v2",
 		vcs:        "git",
 		reporoot:   "https://gopkg.in/mgo.v2",
-	}, {
-		path: "speter.net/go/exp",
-		err:  fmt.Errorf("go-import metadata not found"),
+		//	disabled: certificate has expired
+		//	}, {
+		//		path: "speter.net/go/exp",
+		//		err:  fmt.Errorf("go-import metadata not found"),
 	}}
 
 	for _, tt := range tests {
diff --git a/gbvendor/remove.go b/gbvendor/path.go
similarity index 70%
rename from gbvendor/remove.go
rename to gbvendor/path.go
index fdc155b..bb8334d 100644
--- a/gbvendor/remove.go
+++ b/gbvendor/path.go
@@ -10,8 +10,17 @@
 // deletes read only files on Windows.
 func RemoveAll(path string) error {
 	if runtime.GOOS == "windows" {
+		// Simple case: if Remove works, we're done.
+		err := os.Remove(path)
+		if err == nil || os.IsNotExist(err) {
+			return nil
+		}
 		// make sure all files are writable so we can delete them
 		filepath.Walk(path, func(path string, info os.FileInfo, err error) error {
+			if err != nil {
+				// walk gave us some error, give it back.
+				return err
+			}
 			mode := info.Mode()
 			if mode|0200 == mode {
 				return nil
diff --git a/gbvendor/path_test.go b/gbvendor/path_test.go
new file mode 100644
index 0000000..2bba91b
--- /dev/null
+++ b/gbvendor/path_test.go
@@ -0,0 +1,106 @@
+// Copyright 2009 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+package vendor
+
+import (
+	"os"
+	"runtime"
+	"testing"
+)
+
+var isReadonlyError = func(error) bool { return false }
+
+func TestRemoveAll(t *testing.T) {
+	tmpDir := os.TempDir()
+	// Work directory.
+	path := tmpDir + "/_TestRemoveAll_"
+	fpath := path + "/file"
+	dpath := path + "/dir"
+
+	// Make directory with 1 file and remove.
+	if err := os.MkdirAll(path, 0777); err != nil {
+		t.Fatalf("MkdirAll %q: %s", path, err)
+	}
+	fd, err := os.Create(fpath)
+	if err != nil {
+		t.Fatalf("create %q: %s", fpath, err)
+	}
+	fd.Close()
+	if err = RemoveAll(path); err != nil {
+		t.Fatalf("RemoveAll %q (first): %s", path, err)
+	}
+	if _, err = os.Lstat(path); err == nil {
+		t.Fatalf("Lstat %q succeeded after RemoveAll (first)", path)
+	}
+
+	// Make directory with file and subdirectory and remove.
+	if err = os.MkdirAll(dpath, 0777); err != nil {
+		t.Fatalf("MkdirAll %q: %s", dpath, err)
+	}
+	fd, err = os.Create(fpath)
+	if err != nil {
+		t.Fatalf("create %q: %s", fpath, err)
+	}
+	fd.Close()
+	fd, err = os.Create(dpath + "/file")
+	if err != nil {
+		t.Fatalf("create %q: %s", fpath, err)
+	}
+	fd.Close()
+	if err = RemoveAll(path); err != nil {
+		t.Fatalf("RemoveAll %q (second): %s", path, err)
+	}
+	if _, err := os.Lstat(path); err == nil {
+		t.Fatalf("Lstat %q succeeded after RemoveAll (second)", path)
+	}
+
+	// Determine if we should run the following test.
+	testit := true
+	if runtime.GOOS == "windows" {
+		// Chmod is not supported under windows.
+		testit = false
+	} else {
+		// Test fails as root.
+		testit = os.Getuid() != 0
+	}
+	if testit {
+		// Make directory with file and subdirectory and trigger error.
+		if err = os.MkdirAll(dpath, 0777); err != nil {
+			t.Fatalf("MkdirAll %q: %s", dpath, err)
+		}
+
+		for _, s := range []string{fpath, dpath + "/file1", path + "/zzz"} {
+			fd, err = os.Create(s)
+			if err != nil {
+				t.Fatalf("create %q: %s", s, err)
+			}
+			fd.Close()
+		}
+		if err = os.Chmod(dpath, 0); err != nil {
+			t.Fatalf("Chmod %q 0: %s", dpath, err)
+		}
+
+		// No error checking here: either RemoveAll
+		// will or won't be able to remove dpath;
+		// either way we want to see if it removes fpath
+		// and path/zzz.  Reasons why RemoveAll might
+		// succeed in removing dpath as well include:
+		//	* running as root
+		//	* running on a file system without permissions (FAT)
+		RemoveAll(path)
+		os.Chmod(dpath, 0777)
+
+		for _, s := range []string{fpath, path + "/zzz"} {
+			if _, err = os.Lstat(s); err == nil {
+				t.Fatalf("Lstat %q succeeded after partial RemoveAll", s)
+			}
+		}
+	}
+	if err = RemoveAll(path); err != nil {
+		t.Fatalf("RemoveAll %q after partial RemoveAll: %s", path, err)
+	}
+	if _, err = os.Lstat(path); err == nil {
+		t.Fatalf("Lstat %q succeeded after RemoveAll (final)", path)
+	}
+}