Have to explicitly allow darwin/amd64 in the build tag.

+ Stat_t on Darwin amd64 now uses the same struct fields
  for file times as Lunix, not the BSD ones. I need to
  follow up on this.

.travis.yml

@@ -0,0 +1,17 @@
+sudo: false
+language: go
+go:
+  - tip
+  - 1.9
+script: 
+  - go get golang.org/x/lint/golint
+  - go get golang.org/x/tools/cmd/cover
+  - go get github.com/kisom/goutils/... 
+  - go test -cover github.com/kisom/goutils/... 
+  - golint github.com/kisom/goutils/... 
+notifications:
+  email:
+    recipients:
+      - coder@kyleisom.net
+    on_success: change
+    on_failure: change

CHANGELOG

@@ -1,3 +1,11 @@
+Release 1.2.1 - 2018-09-15
+
++ Add missing format argument to Errorf call in kgz.
+
+Release 1.2.0 - 2018-09-15
+
++ Adds the kgz command line utility.
+
 Release 1.1.0 - 2017-11-16
 
 + A number of new command line utilities were added

README.md

@@ -3,6 +3,12 @@ GOUTILS
 This is a collection of small utility code I've written in Go; the `cmd/`
 directory has a number of command-line utilities. Rather than keep all
 of these in superfluous repositories of their own, I'm putting them here.
+Note that for packaging purposes, the goutils-pkg repo should be used: it
+pins the library versions to working copies and vendors all depdencies. See
+https://github.com/kisom/goutils-pkg for more details.
+
+The goutils-pkg repo [1] has stable versions of the command line
+utilities here, along with a vendored snapshot of any dependencies.
 
 Contents:
 
@@ -25,6 +31,8 @@ Contents:
         csrpubdump/ Dump the public key from an X.509 certificate request.
         fragment/   Print a fragment of a file.
         jlp/        JSON linter/prettifier.
+        kgz/        Custom gzip compressor / decompressor that handles 99%
+                    of my use cases.
         pem2bin/    Dump the binary body of a PEM-encoded block.
         pembody/    Print the body of a PEM certificate.
         pemit/      Dump data to a PEM file.
@@ -57,3 +65,5 @@ Each program should have a small README in the directory with more
 information.
 
 All code here is licensed under the MIT license.
+
+[1] https://github.com/kisom/goutils-pkg/

ahash/ahash_test.go

@@ -97,7 +97,7 @@ func TestHash32(t *testing.T) {
 	h.Write(data)
 	sum, ok = h.Sum32()
 	assert.BoolT(t, ok, algo+" should be able to return a Sum32")
-	assert.BoolT(t, expected != sum, fmt.Sprintf("%s returned %d but shouldn't have", algo, sum, expected))
+	assert.BoolT(t, expected != sum, fmt.Sprintf("%s returned %d but shouldn't have", algo, sum))
 }
 
 func TestHash64(t *testing.T) {
@@ -129,7 +129,7 @@ func TestHash64(t *testing.T) {
 	h.Write(data)
 	sum, ok = h.Sum64()
 	assert.BoolT(t, ok, algo+" should be able to return a Sum64")
-	assert.BoolT(t, expected != sum, fmt.Sprintf("%s returned %d but shouldn't have", algo, sum, expected))
+	assert.BoolT(t, expected != sum, fmt.Sprintf("%s returned %d but shouldn't have", algo, sum))
 }
 
 func TestListLengthSanity(t *testing.T) {

cmd/certdump/certdump.go

@@ -14,6 +14,7 @@ import (
 	"fmt"
 	"io/ioutil"
 	"os"
+	"sort"
 	"strings"
 
 	"github.com/cloudflare/cfssl/helpers"
@@ -83,6 +84,7 @@ func keyUsages(ku x509.KeyUsage) string {
 			uses = append(uses, s)
 		}
 	}
+	sort.Strings(uses)
 
 	return strings.Join(uses, ", ")
 }
@@ -92,6 +94,7 @@ func extUsage(ext []x509.ExtKeyUsage) string {
 	for i := range ext {
 		ns = append(ns, extKeyUsages[ext[i]])
 	}
+	sort.Strings(ns)
 
 	return strings.Join(ns, ", ")
 }

cmd/kgz/README

@@ -0,0 +1,23 @@
+kgz
+
+kgz is like gzip, but supports compressing and decompressing to a different
+directory than the source file is in.
+
+Usage: kgz [-l] source [target]
+
+If target is a directory, the basename of the sourcefile will be used
+as the target filename. Compression and decompression is selected
+based on whether the source filename ends in ".gz".
+
+Flags:
+	-l level	Compression level (0-9). Only meaninful when
+			compressing a file.
+
+
+
+
+
+
+
+
+

cmd/kgz/main.go

@@ -0,0 +1,182 @@
+package main
+
+import (
+	"compress/flate"
+	"compress/gzip"
+	"flag"
+	"fmt"
+	"io"
+	"os"
+	"path/filepath"
+	"strings"
+
+	"github.com/pkg/errors"
+)
+
+const gzipExt = ".gz"
+
+func compress(path, target string, level int) error {
+	sourceFile, err := os.Open(path)
+	if err != nil {
+		return errors.Wrap(err, "opening file for read")
+	}
+	defer sourceFile.Close()
+
+	destFile, err := os.Create(target)
+	if err != nil {
+		return errors.Wrap(err, "opening file for write")
+	}
+	defer destFile.Close()
+
+	gzipCompressor, err := gzip.NewWriterLevel(destFile, level)
+	if err != nil {
+		return errors.Wrap(err, "invalid compression level")
+	}
+	defer gzipCompressor.Close()
+
+	_, err = io.Copy(gzipCompressor, sourceFile)
+	if err != nil {
+		return errors.Wrap(err, "compressing file")
+	}
+
+	if err != nil {
+		return errors.Wrap(err, "stat(2)ing destination file")
+	}
+
+	return nil
+}
+
+func uncompress(path, target string) error {
+	sourceFile, err := os.Open(path)
+	if err != nil {
+		return errors.Wrap(err, "opening file for read")
+	}
+	defer sourceFile.Close()
+
+	gzipUncompressor, err := gzip.NewReader(sourceFile)
+	if err != nil {
+		return errors.Wrap(err, "reading gzip headers")
+	}
+	defer gzipUncompressor.Close()
+
+	destFile, err := os.Create(target)
+	if err != nil {
+		return errors.Wrap(err, "opening file for write")
+	}
+	defer destFile.Close()
+
+	_, err = io.Copy(destFile, gzipUncompressor)
+	if err != nil {
+		return errors.Wrap(err, "uncompressing file")
+	}
+
+	return nil
+}
+
+func usage(w io.Writer) {
+	fmt.Fprintf(w, `Usage: %s [-l] source [target]
+
+kgz is like gzip, but supports compressing and decompressing to a different
+directory than the source file is in.
+
+Flags:
+	-l level	Compression level (0-9). Only meaninful when
+			compressing a file.
+`, os.Args[0])
+}
+
+func init() {
+	flag.Usage = func() { usage(os.Stderr) }
+}
+
+func isDir(path string) bool {
+	file, err := os.Open(path)
+	if err == nil {
+		defer file.Close()
+		stat, err := file.Stat()
+		if err != nil {
+			return false
+		}
+
+		if stat.IsDir() {
+			return true
+		}
+	}
+
+	return false
+}
+
+func pathForUncompressing(source, dest string) (string, error) {
+	if !isDir(dest) {
+		return dest, nil
+	}
+
+	source = filepath.Base(source)
+	if !strings.HasSuffix(source, gzipExt) {
+		return "", errors.Errorf("%s is a not gzip-compressed file", source)
+	}
+	outFile := source[:len(source)-len(gzipExt)]
+	outFile = filepath.Join(dest, outFile)
+	return outFile, nil
+}
+
+func pathForCompressing(source, dest string) (string, error) {
+	if !isDir(dest) {
+		return dest, nil
+	}
+
+	source = filepath.Base(source)
+	if strings.HasSuffix(source, gzipExt) {
+		return "", errors.Errorf("%s is a gzip-compressed file", source)
+	}
+
+	dest = filepath.Join(dest, source+gzipExt)
+	return dest, nil
+}
+
+func main() {
+	var level int
+	var path string
+	var target = "."
+
+	flag.IntVar(&level, "l", flate.DefaultCompression, "compression level")
+	flag.Parse()
+
+	if flag.NArg() < 1 || flag.NArg() > 2 {
+		usage(os.Stderr)
+		os.Exit(1)
+	}
+
+	path = flag.Arg(0)
+	if flag.NArg() == 2 {
+		target = flag.Arg(1)
+	}
+
+	if strings.HasSuffix(path, gzipExt) {
+		target, err := pathForUncompressing(path, target)
+		if err != nil {
+			fmt.Fprintf(os.Stderr, "%s\n", err)
+			os.Exit(1)
+		}
+
+		err = uncompress(path, target)
+		if err != nil {
+			os.Remove(target)
+			fmt.Fprintf(os.Stderr, "%s\n", err)
+			os.Exit(1)
+		}
+	} else {
+		target, err := pathForCompressing(path, target)
+		if err != nil {
+			fmt.Fprintf(os.Stderr, "%s\n", err)
+			os.Exit(1)
+		}
+
+		err = compress(path, target, level)
+		if err != nil {
+			os.Remove(target)
+			fmt.Fprintf(os.Stderr, "%s\n", err)
+			os.Exit(1)
+		}
+	}
+}

cmd/parts/README

@@ -0,0 +1,9 @@
+parts: simple parts database for electronic components
+
+Usage:  parts [id] -- query the database for a part
+	parts [-c class] [id] [description] -- store a part in the database
+
+	Options:
+		-f path		Path to parts database (default is
+				/home/kyle/.parts.json).
+

cmd/parts/main.go

@@ -0,0 +1,142 @@
+package main
+
+import (
+	"encoding/json"
+	"flag"
+	"fmt"
+	"io"
+	"io/ioutil"
+	"os"
+	"path/filepath"
+	"sort"
+	"strings"
+
+	"github.com/kisom/goutils/die"
+)
+
+const dbVersion = "1"
+
+var dbFile = filepath.Join(os.Getenv("HOME"), ".parts.json")
+var partsDB = &database{Version: dbVersion}
+
+type part struct {
+	Name        string `json:"name"`
+	Description string `json:"description"`
+	Class       string `json:"class,omitempty"`
+}
+
+func (p part) String() string {
+	return fmt.Sprintf("%s: %s", p.Name, p.Description)
+}
+
+type database struct {
+	Version    string          `json:"version"`
+	LastUpdate int64           `json:"json"`
+	Parts      map[string]part `json:"parts"`
+}
+
+func help(w io.Writer) {
+	fmt.Fprintf(w, `Usage:  parts [id] -- query the database for a part
+	parts [-c class] [id] [description] -- store a part in the database
+
+	Options:
+		-f path		Path to parts database (default is
+				%s).
+          
+`, dbFile)
+}
+
+func loadDatabase() {
+	data, err := ioutil.ReadFile(dbFile)
+	if err != nil && os.IsNotExist(err) {
+		partsDB = &database{
+			Version: dbVersion,
+			Parts:   map[string]part{},
+		}
+		return
+	}
+	die.If(err)
+
+	err = json.Unmarshal(data, partsDB)
+	die.If(err)
+}
+
+func findPart(partName string) {
+	partName = strings.ToLower(partName)
+	for name, part := range partsDB.Parts {
+		if strings.Contains(strings.ToLower(name), partName) {
+			fmt.Println(part.String())
+		}
+	}
+}
+
+func writeDB() {
+	data, err := json.Marshal(partsDB)
+	die.If(err)
+
+	err = ioutil.WriteFile(dbFile, data, 0644)
+	die.If(err)
+}
+
+func storePart(name, class, description string) {
+	p, exists := partsDB.Parts[name]
+	if exists {
+		fmt.Printf("warning: replacing part %s\n", name)
+		fmt.Printf("\t%s\n", p.String())
+	}
+
+	partsDB.Parts[name] = part{
+		Name:        name,
+		Class:       class,
+		Description: description,
+	}
+
+	writeDB()
+}
+
+func listParts() {
+	parts := make([]string, 0, len(partsDB.Parts))
+	for partName := range partsDB.Parts {
+		parts = append(parts, partName)
+	}
+
+	sort.Strings(parts)
+	for _, partName := range parts {
+		fmt.Println(partsDB.Parts[partName].String())
+	}
+}
+
+func main() {
+	var class string
+	var helpFlag bool
+
+	flag.StringVar(&class, "c", "", "device class")
+	flag.StringVar(&dbFile, "f", dbFile, "`path` to database")
+	flag.BoolVar(&helpFlag, "h", false, "Print a help message.")
+	flag.Parse()
+
+	if helpFlag {
+		help(os.Stdout)
+		return
+	}
+
+	loadDatabase()
+
+	switch flag.NArg() {
+	case 0:
+		help(os.Stdout)
+		return
+	case 1:
+		partName := flag.Arg(0)
+		if partName == "list" {
+			listParts()
+		} else {
+			findPart(flag.Arg(0))
+		}
+		return
+	default:
+		description := strings.Join(flag.Args()[1:], " ")
+		storePart(flag.Arg(0), class, description)
+		return
+	}
+}

cmd/renfnv/renfnv.go

@@ -46,7 +46,6 @@ func newName(path string) (string, error) {
 func move(dst, src string, force bool) (err error) {
 	if fileutil.FileDoesExist(dst) && !force {
 		return fmt.Errorf("%s exists (pass the -f flag to overwrite)", dst)
-		return nil
 	}
 	dstFile, err := os.Create(dst)
 	if err != nil {

cmd/rhash/main.go

@@ -4,7 +4,6 @@ import (
 	"flag"
 	"fmt"
 	"io"
-	"io/ioutil"
 	"net/http"
 	"net/url"
 	"os"
@@ -15,20 +14,6 @@ import (
 	"github.com/kisom/goutils/lib"
 )
 
-func fetch(remote string) ([]byte, error) {
-	resp, err := http.Get(remote)
-	if err != nil {
-		return nil, err
-	}
-
-	defer resp.Body.Close()
-	body, err := ioutil.ReadAll(resp.Body)
-	if err != nil {
-		return nil, err
-	}
-	return body, nil
-}
-
 func usage(w io.Writer) {
 	fmt.Fprintf(w, `Usage: %s [-a algo] [-h] [-l set] urls...
 Compute the hash over each URL.
@@ -91,13 +76,19 @@ func main() {
 			continue
 		}
 
-		body, err := fetch(remote)
+		resp, err := http.Get(remote)
 		if err != nil {
 			lib.Warn(err, "fetching %s", remote)
 			continue
 		}
 
-		sum, err := ahash.Sum(algo, body)
+		if err != nil {
+			lib.Warn(err, "fetching %s", remote)
+			continue
+		}
+
+		sum, err := ahash.SumReader(algo, resp.Body)
+		resp.Body.Close()
 		if err != nil {
 			lib.Err(lib.ExitFailure, err, "while hashing data")
 		}

cmd/showimp/main.go

@@ -67,6 +67,10 @@ func init() {
 }
 
 func walkFile(path string, info os.FileInfo, err error) error {
+	if ignores[path] {
+		return filepath.SkipDir
+	}
+
 	if !sourceRegexp.MatchString(path) {
 		return nil
 	}
@@ -97,10 +101,24 @@ func walkFile(path string, info os.FileInfo, err error) error {
 	return nil
 }
 
+var ignores = map[string]bool{}
+
 func main() {
+	var ignoreLine string
+	var noVendor bool
+	flag.StringVar(&ignoreLine, "i", "", "comma-separated list of directories to ignore")
+	flag.BoolVar(&noVendor, "nv", false, "ignore the vendor directory")
 	flag.BoolVar(&debug, "v", false, "log debugging information")
 	flag.Parse()
 
+	if noVendor {
+		ignores["vendor"] = true
+	}
+
+	for _, word := range strings.Split(ignoreLine, ",") {
+		ignores[strings.TrimSpace(word)] = true
+	}
+
 	err := filepath.Walk(".", walkFile)
 	die.If(err)
 

cmd/sprox/main.go

@@ -0,0 +1,46 @@
+package main
+
+import (
+	"flag"
+	"io"
+	"log"
+	"net"
+
+	"github.com/kisom/goutils/die"
+)
+
+func proxy(conn net.Conn, inside string) error {
+	proxyConn, err := net.Dial("tcp", inside)
+	if err != nil {
+		return err
+	}
+
+	defer proxyConn.Close()
+	defer conn.Close()
+
+	go func() {
+		io.Copy(conn, proxyConn)
+	}()
+	_, err = io.Copy(proxyConn, conn)
+	return err
+}
+
+func main() {
+	var outside, inside string
+	flag.StringVar(&outside, "f", "8080", "outside port")
+	flag.StringVar(&inside, "p", "4000", "inside port")
+	flag.Parse()
+
+	l, err := net.Listen("tcp", "0.0.0.0:"+outside)
+	die.If(err)
+
+	for {
+		conn, err := l.Accept()
+		if err != nil {
+			log.Println(err)
+			continue
+		}
+
+		go proxy(conn, "127.0.0.1:"+inside)
+	}
+}

cmd/utc/main.go

@@ -72,7 +72,7 @@ Flags:
 
 func usageExamples() {
 	usage(os.Stdout)
-	fmt.Println(`
+	fmt.Printf(`
 Examples (note that the examples are done in the America/Los_Angeles /
 PST8PDT time zone):
 
@@ -134,6 +134,7 @@ PST8PDT time zone):
 	  (Converting from GMT (offset +0000) to UTC (offset +0000).)
 	  ==================================================================
 	  2016-06-14 23:46 = 2016-06-14 23:46
+
 `)
 }
 

dbg/dbg.go

@@ -0,0 +1,76 @@
+// Package dbg implements a debug printer.
+package dbg
+
+import (
+	"fmt"
+	"io"
+	"os"
+)
+
+// A DebugPrinter is a drop-in replacement for fmt.Print*, and also acts as
+// an io.WriteCloser when enabled.
+type DebugPrinter struct {
+	// If Enabled is false, the print statements won't do anything.
+	Enabled bool
+	out     io.WriteCloser
+}
+
+// Close satisfies the Closer interface.
+func (dbg *DebugPrinter) Close() error {
+	return dbg.out.Close()
+}
+
+// Write satisfies the Writer interface.
+func (dbg *DebugPrinter) Write(p []byte) (int, error) {
+	if dbg.Enabled {
+		return dbg.out.Write(p)
+	}
+	return 0, nil
+}
+
+// New returns a new DebugPrinter on os.Stdout.
+func New() *DebugPrinter {
+	return &DebugPrinter{
+		out: os.Stdout,
+	}
+}
+
+// ToFile sets up a new DebugPrinter to a file, truncating it if it exists.
+func ToFile(path string) (*DebugPrinter, error) {
+	file, err := os.Create(path)
+	if err != nil {
+		return nil, err
+	}
+
+	return &DebugPrinter{
+		out: file,
+	}, nil
+}
+
+// To sets up a new DebugPrint to an io.WriteCloser.
+func To(w io.WriteCloser) *DebugPrinter {
+	return &DebugPrinter{
+		out: w,
+	}
+}
+
+// Print calls fmt.Print if Enabled is true.
+func (dbg DebugPrinter) Print(v ...interface{}) {
+	if dbg.Enabled {
+		fmt.Fprint(dbg.out, v...)
+	}
+}
+
+// Println calls fmt.Println if Enabled is true.
+func (dbg DebugPrinter) Println(v ...interface{}) {
+	if dbg.Enabled {
+		fmt.Fprintln(dbg.out, v...)
+	}
+}
+
+// Printf calls fmt.Printf if Enabled is true.
+func (dbg DebugPrinter) Printf(format string, v ...interface{}) {
+	if dbg.Enabled {
+		fmt.Fprintf(dbg.out, format, v...)
+	}
+}

dbg/dbg_test.go

@@ -0,0 +1,120 @@
+package dbg
+
+import (
+	"io/ioutil"
+	"os"
+	"testing"
+
+	"github.com/kisom/goutils/testio"
+	"github.com/stretchr/testify/require"
+)
+
+func TestNew(t *testing.T) {
+	buf := testio.NewBufCloser(nil)
+	dbg := New()
+	dbg.out = buf
+
+	dbg.Print("hello")
+	dbg.Println("hello")
+	dbg.Printf("hello %s", "world")
+	require.Equal(t, 0, buf.Len())
+
+	dbg.Enabled = true
+	dbg.Print("hello")              // +5
+	dbg.Println("hello")            // +6
+	dbg.Printf("hello %s", "world") // +11
+	require.Equal(t, 22, buf.Len())
+
+	err := dbg.Close()
+	require.NoError(t, err)
+}
+
+func TestTo(t *testing.T) {
+	buf := testio.NewBufCloser(nil)
+	dbg := To(buf)
+
+	dbg.Print("hello")
+	dbg.Println("hello")
+	dbg.Printf("hello %s", "world")
+	require.Equal(t, 0, buf.Len())
+
+	dbg.Enabled = true
+	dbg.Print("hello")              // +5
+	dbg.Println("hello")            // +6
+	dbg.Printf("hello %s", "world") // +11
+
+	require.Equal(t, 22, buf.Len())
+
+	err := dbg.Close()
+	require.NoError(t, err)
+}
+
+func TestToFile(t *testing.T) {
+	testFile, err := ioutil.TempFile("", "dbg")
+	require.NoError(t, err)
+	err = testFile.Close()
+	require.NoError(t, err)
+
+	testFileName := testFile.Name()
+	defer os.Remove(testFileName)
+
+	dbg, err := ToFile(testFileName)
+	require.NoError(t, err)
+
+	dbg.Print("hello")
+	dbg.Println("hello")
+	dbg.Printf("hello %s", "world")
+
+	stat, err := os.Stat(testFileName)
+	require.NoError(t, err)
+
+	require.EqualValues(t, 0, stat.Size())
+
+	dbg.Enabled = true
+	dbg.Print("hello")              // +5
+	dbg.Println("hello")            // +6
+	dbg.Printf("hello %s", "world") // +11
+
+	stat, err = os.Stat(testFileName)
+	require.NoError(t, err)
+
+	require.EqualValues(t, 22, stat.Size())
+
+	err = dbg.Close()
+	require.NoError(t, err)
+}
+
+func TestWriting(t *testing.T) {
+	data := []byte("hello, world")
+	buf := testio.NewBufCloser(nil)
+	dbg := To(buf)
+
+	n, err := dbg.Write(data)
+	require.NoError(t, err)
+	require.EqualValues(t, 0, n)
+
+	dbg.Enabled = true
+	n, err = dbg.Write(data)
+	require.NoError(t, err)
+	require.EqualValues(t, 12, n)
+
+	err = dbg.Close()
+	require.NoError(t, err)
+}
+
+func TestToFileError(t *testing.T) {
+	testFile, err := ioutil.TempFile("", "dbg")
+	require.NoError(t, err)
+	err = testFile.Chmod(0400)
+	require.NoError(t, err)
+	err = testFile.Close()
+	require.NoError(t, err)
+
+	testFileName := testFile.Name()
+
+	_, err = ToFile(testFileName)
+	require.Error(t, err)
+
+	err = os.Remove(testFileName)
+	require.NoError(t, err)
+}

go.mod

@@ -0,0 +1,3 @@
+module github.com/kisom/goutils
+
+go 1.13

lib/ftime_bsd.go

@@ -1,4 +1,4 @@
-// +build freebsd darwin netbsd
+// +build freebsd darwin,386 netbsd
 
 package lib
 

lib/ftime_unix.go

@@ -1,4 +1,4 @@
-// +build unix linux openbsd
+// +build unix linux openbsd darwin,amd64
 
 package lib
 

logging/file.go

@@ -20,6 +20,8 @@ func (fl *File) Close() error {
 	if fl.fe != nil {
 		return fl.fe.Close()
 	}
+
+	return nil
 }
 
 // NewFile creates a new Logger that writes all logs to the file

logging/log.go

@@ -21,7 +21,7 @@ type Logger interface {
 	Status() error
 
 	// Close gives the Logger the opportunity to perform any cleanup.
-	Close()
+	Close() error
 
 	// Log messages consist of four components:
 	//
@@ -276,4 +276,4 @@ func (lw *LogWriter) SetLevel(l Level) {
 }
 
 // Close is a no-op that satisfies the Logger interface.
-func (lw *LogWriter) Close() {}
+func (lw *LogWriter) Close() error { return nil }

sbuf/sbuf_test.go

@@ -168,7 +168,7 @@ func TestRWByte(t *testing.T) {
 	}
 
 	if c != 42 {
-		t.Fatal("Expected 42, have %d", c)
+		t.Fatalf("Expected 42, have %d", c)
 	}
 
 	_, err = buf.ReadByte()

testio/testio.go

@@ -194,6 +194,11 @@ func (buf *BufCloser) Bytes() []byte {
 	return buf.buf.Bytes()
 }
 
+// Len returns the length of the buffer.
+func (buf *BufCloser) Len() int {
+	return buf.buf.Len()
+}
+
 // NewBufCloser creates and initializes a new BufCloser using buf as
 // its initial contents. It is intended to prepare a BufCloser to read
 // existing data. It can also be used to size the internal buffer for