X go mod vendor

wcfs/vendor/github.com/DataDog/czlib/LICENSE

+Simplified BSD License
+
+Copyright (c) 2012, Google Inc.
+Copyright (c) 2016, Datadog <info@datadoghq.com>
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+    * Redistributions of source code must retain the above copyright notice,
+      this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright notice,
+      this list of conditions and the following disclaimer in the documentation
+      and/or other materials provided with the distribution.
+    * Neither the name of the copyright holder nor the names of its contributors
+      may be used to endorse or promote products derived from this software
+      without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

wcfs/vendor/github.com/DataDog/czlib/adler32.go

+// Pulled from https://github.com/youtube/vitess 229422035ca0c716ad0c1397ea1351fe62b0d35a
+// Copyright 2012, Google Inc. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package czlib
+
+// NOTE: the routines defined in this file are used for verification in
+// czlib_test.go, but you cannot use cgo in test files, so they are
+// defined here despite not being exposed.
+
+// #cgo pkg-config: zlib
+
+/*
+
+#include "zlib.h"
+*/
+import "C"
+
+import (
+	"hash"
+	"unsafe"
+)
+
+type adler32Hash struct {
+	adler C.uLong
+}
+
+// an empty buffer has an adler32 of '1' by default, so start with that
+// (the go hash/adler32 does the same)
+func newAdler32() hash.Hash32 {
+	a := &adler32Hash{}
+	a.Reset()
+	return a
+}
+
+// Write implements an io.Writer interface
+func (a *adler32Hash) Write(p []byte) (n int, err error) {
+	if len(p) > 0 {
+		a.adler = C.adler32(a.adler, (*C.Bytef)(unsafe.Pointer(&p[0])), (C.uInt)(len(p)))
+	}
+	return len(p), nil
+}
+
+// Sum implements a hash.Hash interface
+func (a *adler32Hash) Sum(b []byte) []byte {
+	s := a.Sum32()
+	b = append(b, byte(s>>24))
+	b = append(b, byte(s>>16))
+	b = append(b, byte(s>>8))
+	b = append(b, byte(s))
+	return b
+}
+
+// Reset resets the hash to default value
+func (a *adler32Hash) Reset() {
+	a.adler = C.adler32(0, (*C.Bytef)(unsafe.Pointer(nil)), 0)
+}
+
+// Size returns the (fixed) size of the hash
+func (a *adler32Hash) Size() int {
+	return 4
+}
+
+// BlockSize returns the (fixed) block size
+func (a *adler32Hash) BlockSize() int {
+	return 1
+}
+
+// Sum32 implements a hash.Hash32 interface
+func (a *adler32Hash) Sum32() uint32 {
+	return uint32(a.adler)
+}
+
+// helper method for partial checksums. From the zlib.h header:
+//
+//   Combine two Adler-32 checksums into one.  For two sequences of bytes, seq1
+// and seq2 with lengths len1 and len2, Adler-32 checksums were calculated for
+// each, adler1 and adler2.  adler32_combine() returns the Adler-32 checksum of
+// seq1 and seq2 concatenated, requiring only adler1, adler2, and len2.
+func adler32Combine(adler1, adler2 uint32, len2 int) uint32 {
+	return uint32(C.adler32_combine(C.uLong(adler1), C.uLong(adler2), C.z_off_t(len2)))
+}

wcfs/vendor/github.com/DataDog/czlib/crc32.go

+// Pulled from https://github.com/youtube/vitess 229422035ca0c716ad0c1397ea1351fe62b0d35a
+// Copyright 2012, Google Inc. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package czlib
+
+// NOTE: the routines defined in this file are used for verification in
+// czlib_test.go, but you cannot use cgo in test files, so they are
+// defined here despite not being exposed.
+
+/*
+#include "zlib.h"
+*/
+import "C"
+
+import (
+	"hash"
+	"unsafe"
+)
+
+type crc32Hash struct {
+	crc C.uLong
+}
+
+// an empty buffer has an crc32 of '1' by default, so start with that
+// (the go hash/crc32 does the same)
+func newCrc32() hash.Hash32 {
+	c := &crc32Hash{}
+	c.Reset()
+	return c
+}
+
+// Write implements an io.Writer interface
+func (a *crc32Hash) Write(p []byte) (n int, err error) {
+	if len(p) > 0 {
+		a.crc = C.crc32(a.crc, (*C.Bytef)(unsafe.Pointer(&p[0])), (C.uInt)(len(p)))
+	}
+	return len(p), nil
+}
+
+// Sum implements a hash.Hash interface
+func (a *crc32Hash) Sum(b []byte) []byte {
+	s := a.Sum32()
+	b = append(b, byte(s>>24))
+	b = append(b, byte(s>>16))
+	b = append(b, byte(s>>8))
+	b = append(b, byte(s))
+	return b
+}
+
+// Reset resets the hash to default value
+func (a *crc32Hash) Reset() {
+	a.crc = C.crc32(0, (*C.Bytef)(unsafe.Pointer(nil)), 0)
+}
+
+// Size returns the (fixed) size of the hash
+func (a *crc32Hash) Size() int {
+	return 4
+}
+
+// BlockSize returns the (fixed) block size of the hash
+func (a *crc32Hash) BlockSize() int {
+	return 1
+}
+
+// Sum32 implements a hash.Hash32 interface
+func (a *crc32Hash) Sum32() uint32 {
+	return uint32(a.crc)
+}
+
+// helper method for partial checksums. From the zlib.h header:
+//
+//   Combine two CRC-32 checksums into one.  For two sequences of bytes, seq1
+// and seq2 with lengths len1 and len2, CRC-32 checksums were calculated for
+// each, crc1 and crc2.  crc32_combine() returns the CRC-32 checksum of
+// seq1 and seq2 concatenated, requiring only crc1, crc2, and len2.
+func crc32Combine(crc1, crc2 uint32, len2 int) uint32 {
+	return uint32(C.crc32_combine(C.uLong(crc1), C.uLong(crc2), C.z_off_t(len2)))
+}

wcfs/vendor/github.com/DataDog/czlib/czlib.go

+// Copyright 2016, Datadog Inc.  All rights reserved.
+
+package czlib
+
+import (
+	"compress/flate"
+	"compress/zlib"
+)
+
+// Constants copied from the flate package, so that code that imports czlib
+// does not also have to import "compress/flate".
+const (
+	NoCompression      = flate.NoCompression
+	BestSpeed          = flate.BestSpeed
+	BestCompression    = flate.BestCompression
+	DefaultCompression = flate.DefaultCompression
+)
+
+var (
+	// ErrChecksum is returned when reading ZLIB data that has an invalid checksum.
+	ErrChecksum = zlib.ErrChecksum
+	// ErrDictionary is returned when reading ZLIB data that has an invalid dictionary.
+	ErrDictionary = zlib.ErrDictionary
+	// ErrHeader is returned when reading ZLIB data that has an invalid header.
+	ErrHeader = zlib.ErrHeader
+)

wcfs/vendor/github.com/DataDog/czlib/fastzlib.go

+// Copyright 2013, Datadog Inc.  All rights reserved.
+
+package czlib
+
+import (
+	"errors"
+	"unsafe"
+)
+
+/*
+#cgo LDFLAGS: -lz
+#include "fastzlib.h"
+#include <stdlib.h>
+*/
+import "C"
+
+// An UnsafeByte is a []byte whose backing array has been allocated in C and
+// thus is not subject to the Go garbage collector.  The Unsafe versions of
+// Compress and Decompress return this in order to prevent copying the unsafe
+// memory into collected memory.
+type UnsafeByte []byte
+
+// NewUnsafeByte creates a []byte from the unsafe pointer without a copy,
+// using the method outlined in this mailing list post:
+//   https://groups.google.com/forum/#!topic/golang-nuts/KyXR0fDp0HA
+// but amended to use the three-index slices from go1.2 to set the capacity
+// of b correctly:
+//   https://tip.golang.org/doc/go1.2#three_index
+// This means this code only works in go1.2+.
+//
+// This shouldn't copy the underlying array;  it's just casting it
+// Afterwards, we use reflect to fix the Cap & len of the slice.
+func NewUnsafeByte(p *C.char, length int) UnsafeByte {
+	var b UnsafeByte
+	b = UnsafeByte((*[1<<31 - 1]byte)(unsafe.Pointer(p))[:length:length])
+	return b
+}
+
+// Free the underlying byte array;  doing this twice would be bad.
+func (b UnsafeByte) Free() {
+	C.free(unsafe.Pointer(&b[0]))
+}
+
+// Compress returns the input compressed using zlib, or an error if encountered.
+func Compress(input []byte) ([]byte, error) {
+	var cInput *C.char
+	if len(input) != 0 {
+		cInput = (*C.char)(unsafe.Pointer(&input[0]))
+	}
+	ret := C.c_compress2(cInput, C.uint(len(input)))
+
+	// if there was an error compressing, return it and free the original message
+	if ret.err != nil {
+		msg := C.GoString((*C.char)(ret.err))
+		C.free(unsafe.Pointer(ret.err))
+		return []byte{}, errors.New(msg)
+	}
+
+	// NOTE: this creates a copy of the return *char as a Go []byte.
+	// FIXME: uint -> int conversion here is dangerous
+	b := C.GoBytes(unsafe.Pointer(ret.str), C.int(ret.len))
+	C.free(unsafe.Pointer(ret.str))
+	return b, nil
+}
+
+// Decompress returns the input decompressed using zlib, or an error if encountered.
+func Decompress(input []byte) ([]byte, error) {
+	var cInput *C.char
+	if len(input) != 0 {
+		cInput = (*C.char)(unsafe.Pointer(&input[0]))
+	}
+	// send the input byte without copying iy
+	ret := C.c_decompress(cInput, C.uint(len(input)))
+
+	// if there was an error decompressing, return it and free the original message
+	if ret.err != nil {
+		msg := C.GoString((*C.char)(ret.err))
+		C.free(unsafe.Pointer(ret.err))
+		return []byte{}, errors.New(msg)
+	}
+
+	// NOTE: this creates a copy of the return *char as a Go []byte.
+	// FIXME: uint -> int conversion here is dangerous
+	b := C.GoBytes(unsafe.Pointer(ret.str), C.int(ret.len))
+	C.free(unsafe.Pointer(ret.str))
+	return b, nil
+}
+
+// UnsafeDecompress unzips input into an UnsafeByte without copying the result
+// malloced in C.  The UnsafeByte returned can be used as a normal []byte but
+// must be manually free'd w/ UnsafeByte.Free()
+func UnsafeDecompress(input []byte) (UnsafeByte, error) {
+	cInput := (*C.char)(unsafe.Pointer(&input[0]))
+	ret := C.c_decompress(cInput, C.uint(len(input)))
+
+	// if there was an error decompressing, return it and free the original message
+	if ret.err != nil {
+		msg := C.GoString((*C.char)(ret.err))
+		C.free(unsafe.Pointer(ret.err))
+		return UnsafeByte{}, errors.New(msg)
+	}
+
+	b := NewUnsafeByte((*C.char)(ret.str), int(ret.len))
+	return b, nil
+}
+
+// UnsafeCompress zips input into an UnsafeByte without copying the result
+// malloced in C.  The UnsafeByte returned can be used as a normal []byte but must
+// be manually free'd w/ UnsafeByte.Free()
+func UnsafeCompress(input []byte) (UnsafeByte, error) {
+	cInput := (*C.char)(unsafe.Pointer(&input[0]))
+	ret := C.c_compress(cInput, C.uint(len(input)))
+
+	// if there was an error decompressing, return it and free the original message
+	if ret.err != nil {
+		msg := C.GoString((*C.char)(ret.err))
+		C.free(unsafe.Pointer(ret.err))
+		return UnsafeByte{}, errors.New(msg)
+	}
+
+	b := NewUnsafeByte((*C.char)(ret.str), int(ret.len))
+	return b, nil
+}

wcfs/vendor/github.com/DataDog/czlib/fastzlib.h

+
+typedef unsigned int uint;
+
+/* simulate the Go return type ([]byte, error) so that the Go function
+ * can allocate the right amt of memory to copy the str if required or
+ * report errors directly from the C lib.
+ */
+typedef struct {
+    char *str;
+    uint len;
+    char *err;
+} ByteArray;
+
+ByteArray c_decompress(char *input, uint length);
+ByteArray c_compress(char *input, uint length);
+ByteArray c_compress2(char *input, uint length);
+

wcfs/vendor/github.com/DataDog/czlib/reader.go

+// Pulled from https://github.com/youtube/vitess 229422035ca0c716ad0c1397ea1351fe62b0d35a
+// Copyright 2012, Google Inc. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package czlib
+
+import "io"
+
+// err starts out as nil
+// we will call inflateEnd when we set err to a value:
+// - whatever error is returned by the underlying reader
+// - io.EOF if Close was called
+type reader struct {
+	r      io.Reader
+	in     []byte
+	strm   zstream
+	err    error
+	skipIn bool
+}
+
+// NewReader creates a new io.ReadCloser. Reads from the returned io.ReadCloser
+//read and decompress data from r. The implementation buffers input and may read
+// more data than necessary from r.
+// It is the caller's responsibility to call Close on the ReadCloser when done.
+func NewReader(r io.Reader) (io.ReadCloser, error) {
+	return NewReaderBuffer(r, DEFAULT_COMPRESSED_BUFFER_SIZE)
+}
+
+// NewReaderBuffer has the same behavior as NewReader but the user can provides
+// a custom buffer size.
+func NewReaderBuffer(r io.Reader, bufferSize int) (io.ReadCloser, error) {
+	z := &reader{r: r, in: make([]byte, bufferSize)}
+	if err := z.strm.inflateInit(); err != nil {
+		return nil, err
+	}
+	return z, nil
+}
+
+func (z *reader) Read(p []byte) (int, error) {
+	if z.err != nil {
+		return 0, z.err
+	}
+
+	if len(p) == 0 {
+		return 0, nil
+	}
+
+	// read and deflate until the output buffer is full
+	z.strm.setOutBuf(p, len(p))
+
+	for {
+		// if we have no data to inflate, read more
+		if !z.skipIn && z.strm.availIn() == 0 {
+			var n int
+			n, z.err = z.r.Read(z.in)
+			// If we got data and EOF, pretend we didn't get the
+			// EOF.  That way we will return the right values
+			// upstream.  Note this will trigger another read
+			// later on, that should return (0, EOF).
+			if n > 0 && z.err == io.EOF {
+				z.err = nil
+			}
+
+			// FIXME(alainjobart) this code is not compliant with
+			// the Reader interface. We should process all the
+			// data we got from the reader, and then return the
+			// error, whatever it is.
+			if (z.err != nil && z.err != io.EOF) || (n == 0 && z.err == io.EOF) {
+				z.strm.inflateEnd()
+				return 0, z.err
+			}
+
+			z.strm.setInBuf(z.in, n)
+		} else {
+			z.skipIn = false
+		}
+
+		// inflate some
+		ret, err := z.strm.inflate(zNoFlush)
+		if err != nil {
+			z.err = err
+			z.strm.inflateEnd()
+			return 0, z.err
+		}
+
+		// if we read something, we're good
+		have := len(p) - z.strm.availOut()
+		if have > 0 {
+			z.skipIn = ret == Z_OK && z.strm.availOut() == 0
+			return have, z.err
+		}
+	}
+}
+
+// Close closes the Reader. It does not close the underlying io.Reader.
+func (z *reader) Close() error {
+	if z.err != nil {
+		if z.err != io.EOF {
+			return z.err
+		}
+		return nil
+	}
+	z.strm.inflateEnd()
+	z.err = io.EOF
+	return nil
+}

wcfs/vendor/github.com/DataDog/czlib/writer.go

+// Pulled from https://github.com/youtube/vitess 229422035ca0c716ad0c1397ea1351fe62b0d35a
+// Copyright 2012, Google Inc. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package czlib
+
+import (
+	"fmt"
+	"io"
+)
+
+// Allowed flush values
+const (
+	Z_NO_FLUSH      = 0
+	Z_PARTIAL_FLUSH = 1
+	Z_SYNC_FLUSH    = 2
+	Z_FULL_FLUSH    = 3
+	Z_FINISH        = 4
+	Z_BLOCK         = 5
+	Z_TREES         = 6
+)
+
+// Return codes
+const (
+	Z_OK            = 0
+	Z_STREAM_END    = 1
+	Z_NEED_DICT     = 2
+	Z_ERRNO         = -1
+	Z_STREAM_ERROR  = -2
+	Z_DATA_ERROR    = -3
+	Z_MEM_ERROR     = -4
+	Z_BUF_ERROR     = -5
+	Z_VERSION_ERROR = -6
+)
+
+// our default buffer size
+// most go io functions use 32KB as buffer size, so 32KB
+// works well here for compressed data buffer
+const (
+	DEFAULT_COMPRESSED_BUFFER_SIZE = 32 * 1024
+)
+
+// Writer implements a io.WriteCloser
+// we will call deflateEnd when we set err to a value:
+// - whatever error is returned by the underlying writer
+// - io.EOF if Close was called
+type Writer struct {
+	w    io.Writer
+	out  []byte
+	strm zstream
+	err  error
+}
+
+// NewWriter returns a new zlib writer that writes to the underlying writer
+func NewWriter(w io.Writer) *Writer {
+	z, _ := NewWriterLevelBuffer(w, DefaultCompression, DEFAULT_COMPRESSED_BUFFER_SIZE)
+	return z
+}
+
+// NewWriterLevel let the user provide a compression level value
+func NewWriterLevel(w io.Writer, level int) (*Writer, error) {
+	return NewWriterLevelBuffer(w, level, DEFAULT_COMPRESSED_BUFFER_SIZE)
+}
+
+// NewWriterLevelBuffer let the user provide compression level and buffer size values
+func NewWriterLevelBuffer(w io.Writer, level, bufferSize int) (*Writer, error) {
+	z := &Writer{w: w, out: make([]byte, bufferSize)}
+	if err := z.strm.deflateInit(level); err != nil {
+		return nil, err
+	}
+	return z, nil
+}
+
+// this is the main function: it advances the write with either
+// new data or something else to do, like a flush
+func (z *Writer) write(p []byte, flush int) int {
+	if len(p) == 0 {
+		z.strm.setInBuf(nil, 0)
+	} else {
+		z.strm.setInBuf(p, len(p))
+	}
+	// we loop until we don't get a full output buffer
+	// each loop completely writes the output buffer to the underlying
+	// writer
+	for {
+		// deflate one buffer
+		z.strm.setOutBuf(z.out, len(z.out))
+		z.strm.deflate(flush)
+
+		// write everything
+		from := 0
+		have := len(z.out) - int(z.strm.availOut())
+		for have > 0 {
+			var n int
+			n, z.err = z.w.Write(z.out[from:have])
+			if z.err != nil {
+				z.strm.deflateEnd()
+				return 0
+			}
+			from += n
+			have -= n
+		}
+
+		// we stop trying if we get a partial response
+		if z.strm.availOut() != 0 {
+			break
+		}
+	}
+	// the library guarantees this
+	if z.strm.availIn() != 0 {
+		panic(fmt.Errorf("cgzip: Unexpected error (2)"))
+	}
+	return len(p)
+}
+
+// Write implements the io.Writer interface
+func (z *Writer) Write(p []byte) (n int, err error) {
+	if z.err != nil {
+		return 0, z.err
+	}
+	n = z.write(p, Z_NO_FLUSH)
+	return n, z.err
+}
+
+// Flush let the user flush the zlib buffer to the underlying writer buffer
+func (z *Writer) Flush() error {
+	if z.err != nil {
+		return z.err
+	}
+	z.write(nil, Z_SYNC_FLUSH)
+	return z.err
+}
+
+// Close closes the zlib buffer but does not close the wrapped io.Writer originally
+// passed to NewWriterX.
+func (z *Writer) Close() error {
+	if z.err != nil {
+		return z.err
+	}
+	z.write(nil, Z_FINISH)
+	if z.err != nil {
+		return z.err
+	}
+	z.strm.deflateEnd()
+	z.err = io.EOF
+	return nil
+}

wcfs/vendor/github.com/DataDog/czlib/zstream.go

+// Pulled from https://github.com/youtube/vitess 229422035ca0c716ad0c1397ea1351fe62b0d35a
+// Copyright 2015, Google Inc. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package czlib
+
+// See http://www.zlib.net/zlib_how.html for more information on this
+
+/*
+#cgo CFLAGS: -Werror=implicit
+#cgo pkg-config: zlib
+
+#include "zlib.h"
+
+// inflateInit is a macro, so using a wrapper function
+int zstream_inflate_init(char *strm) {
+  ((z_stream*)strm)->zalloc = Z_NULL;
+  ((z_stream*)strm)->zfree = Z_NULL;
+  ((z_stream*)strm)->opaque = Z_NULL;
+  ((z_stream*)strm)->avail_in = 0;
+  ((z_stream*)strm)->next_in = Z_NULL;
+  return inflateInit((z_stream*)strm);
+}
+
+// deflateInit is a macro, so using a wrapper function
+int zstream_deflate_init(char *strm, int level) {
+  ((z_stream*)strm)->zalloc = Z_NULL;
+  ((z_stream*)strm)->zfree = Z_NULL;
+  ((z_stream*)strm)->opaque = Z_NULL;
+  return deflateInit((z_stream*)strm, level);
+}
+
+unsigned int zstream_avail_in(char *strm) {
+  return ((z_stream*)strm)->avail_in;
+}
+
+unsigned int zstream_avail_out(char *strm) {
+  return ((z_stream*)strm)->avail_out;
+}
+
+char* zstream_msg(char *strm) {
+  return ((z_stream*)strm)->msg;
+}
+
+void zstream_set_in_buf(char *strm, void *buf, unsigned int len) {
+  ((z_stream*)strm)->next_in = (Bytef*)buf;
+  ((z_stream*)strm)->avail_in = len;
+}
+
+void zstream_set_out_buf(char *strm, void *buf, unsigned int len) {
+  ((z_stream*)strm)->next_out = (Bytef*)buf;
+  ((z_stream*)strm)->avail_out = len;
+}
+
+int zstream_inflate(char *strm, int flag) {
+  return inflate((z_stream*)strm, flag);
+}
+
+int zstream_deflate(char *strm, int flag) {
+  return deflate((z_stream*)strm, flag);
+}
+
+void zstream_inflate_end(char *strm) {
+  inflateEnd((z_stream*)strm);
+}
+
+void zstream_deflate_end(char *strm) {
+  deflateEnd((z_stream*)strm);
+}
+*/
+import "C"
+
+import (
+	"fmt"
+	"unsafe"
+)
+
+const (
+	zNoFlush = C.Z_NO_FLUSH
+)
+
+// z_stream is a buffer that's big enough to fit a C.z_stream.
+// This lets us allocate a C.z_stream within Go, while keeping the contents
+// opaque to the Go GC. Otherwise, the GC would look inside and complain that
+// the pointers are invalid, since they point to objects allocated by C code.
+type zstream [unsafe.Sizeof(C.z_stream{})]C.char
+
+func (strm *zstream) inflateInit() error {
+	result := C.zstream_inflate_init(&strm[0])
+	if result != Z_OK {
+		return fmt.Errorf("cgzip: failed to initialize inflate (%v): %v", result, strm.msg())
+	}
+	return nil
+}
+
+func (strm *zstream) deflateInit(level int) error {
+	result := C.zstream_deflate_init(&strm[0], C.int(level))
+	if result != Z_OK {
+		return fmt.Errorf("cgzip: failed to initialize deflate (%v): %v", result, strm.msg())
+	}
+	return nil
+}
+
+func (strm *zstream) inflateEnd() {
+	C.zstream_inflate_end(&strm[0])
+}
+
+func (strm *zstream) deflateEnd() {
+	C.zstream_deflate_end(&strm[0])
+}
+
+func (strm *zstream) availIn() int {
+	return int(C.zstream_avail_in(&strm[0]))
+}
+
+func (strm *zstream) availOut() int {
+	return int(C.zstream_avail_out(&strm[0]))
+}
+
+func (strm *zstream) msg() string {
+	return C.GoString(C.zstream_msg(&strm[0]))
+}
+
+func (strm *zstream) setInBuf(buf []byte, size int) {
+	if buf == nil {
+		C.zstream_set_in_buf(&strm[0], nil, C.uint(size))
+	} else {
+		C.zstream_set_in_buf(&strm[0], unsafe.Pointer(&buf[0]), C.uint(size))
+	}
+}
+
+func (strm *zstream) setOutBuf(buf []byte, size int) {
+	if buf == nil {
+		C.zstream_set_out_buf(&strm[0], nil, C.uint(size))
+	} else {
+		C.zstream_set_out_buf(&strm[0], unsafe.Pointer(&buf[0]), C.uint(size))
+	}
+}
+
+func (strm *zstream) inflate(flag int) (int, error) {
+	ret := C.zstream_inflate(&strm[0], C.int(flag))
+	switch ret {
+	case Z_NEED_DICT:
+		ret = Z_DATA_ERROR
+		fallthrough
+	case Z_DATA_ERROR, Z_MEM_ERROR:
+		return int(ret), fmt.Errorf("cgzip: failed to inflate (%v): %v", ret, strm.msg())
+	}
+	return int(ret), nil
+}
+
+func (strm *zstream) deflate(flag int) {
+	ret := C.zstream_deflate(&strm[0], C.int(flag))
+	if ret == Z_STREAM_ERROR {
+		// all the other error cases are normal,
+		// and this should never happen
+		panic(fmt.Errorf("cgzip: Unexpected error (1)"))
+	}
+}

wcfs/vendor/github.com/cznic/strutil/AUTHORS

+# This file lists authors for copyright purposes.  This file is distinct from
+# the CONTRIBUTORS files.  See the latter for an explanation.
+#
+# Names should be added to this file as:
+#     Name or Organization <email address>
+#
+# The email address is not required for organizations.
+#
+# Please keep the list sorted.
+
+CZ.NIC z.s.p.o. <kontakt@nic.cz>
+Jan Mercl <0xjnml@gmail.com>

wcfs/vendor/github.com/cznic/strutil/CONTRIBUTORS

+# This file lists people who contributed code to this repository.  The AUTHORS
+# file lists the copyright holders; this file lists people.
+#
+# Names should be added to this file like so:
+#     Name <email address>
+#
+# Please keep the list sorted.
+
+Jan Mercl <0xjnml@gmail.com>

wcfs/vendor/github.com/cznic/strutil/LICENSE

+Copyright (c) 2014 The strutil Authors. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+
+   * Redistributions of source code must retain the above copyright
+notice, this list of conditions and the following disclaimer.
+   * Redistributions in binary form must reproduce the above
+copyright notice, this list of conditions and the following disclaimer
+in the documentation and/or other materials provided with the
+distribution.
+   * Neither the names of the authors nor the names of the
+contributors may be used to endorse or promote products derived from
+this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

wcfs/vendor/github.com/cznic/strutil/Makefile

+# Copyright (c) 2014 The sortutil Authors. All rights reserved.
+# Use of this source code is governed by a BSD-style
+# license that can be found in the LICENSE file.
+
+.PHONY:	all clean cover cpu editor internalError later mem nuke todo edit
+
+grep=--include=*.go --include=*.l --include=*.y --include=*.yy
+ngrep='TODOOK\|parser\.go\|scanner\.go\|.*_string\.go'
+
+all: editor
+	go vet 2>&1 | grep -v $(ngrep) || true
+	golint 2>&1 | grep -v $(ngrep) || true
+	make todo
+	unused . || true
+	misspell *.go
+	gosimple || true
+	maligned || true
+	unconvert -apply
+
+clean:
+	go clean
+	rm -f *~ *.test *.out
+
+cover:
+	t=$(shell tempfile) ; go test -coverprofile $$t && go tool cover -html $$t && unlink $$t
+
+cpu: clean
+	go test -run @ -bench . -cpuprofile cpu.out
+	go tool pprof -lines *.test cpu.out
+
+edit:
+	@ 1>/dev/null 2>/dev/null gvim -p Makefile *.go
+
+editor:
+	unconvert -apply || true
+	gofmt -l -s -w *.go
+	go test -i
+	go test 2>&1 | tee log
+	go install
+
+internalError:
+	egrep -ho '"internal error.*"' *.go | sort | cat -n
+
+later:
+	@grep -n $(grep) LATER * || true
+	@grep -n $(grep) MAYBE * || true
+
+mem: clean
+	go test -run @ -bench . -memprofile mem.out -memprofilerate 1 -timeout 24h
+	go tool pprof -lines -web -alloc_space *.test mem.out
+
+nuke: clean
+	go clean -i
+
+todo:
+	@grep -nr $(grep) ^[[:space:]]*_[[:space:]]*=[[:space:]][[:alpha:]][[:alnum:]]* * | grep -v $(ngrep) || true
+	@grep -nr $(grep) TODO * | grep -v $(ngrep) || true
+	@grep -nr $(grep) BUG * | grep -v $(ngrep) || true
+	@grep -nr $(grep) [^[:alpha:]]println * | grep -v $(ngrep) || true

wcfs/vendor/github.com/cznic/strutil/README

+This is a goinstall-able mirror of modified code already published at:
+http://git.nic.cz/redmine/projects/gostrutil/repository
+
+Online godoc documentation for this package (should be) available at:
+http://gopkgdoc.appspot.com/pkg/github.com/cznic/strutil
+
+Installation:
+$ go get github.com/cznic/strutil

wcfs/vendor/github.com/cznic/strutil/README.md

+`github.com/cznic/strutil` has moved to [`modernc.org/strutil`](https://godoc.org/modernc.org/strutil) ([vcs](https://gitlab.com/cznic/strutil)).
+
+Please update your import paths to `modernc.org/strutil`.
+
+This repo is now archived.

wcfs/vendor/github.com/davecgh/go-spew/LICENSE

+ISC License
+
+Copyright (c) 2012-2016 Dave Collins <dave@davec.name>
+
+Permission to use, copy, modify, and distribute this software for any
+purpose with or without fee is hereby granted, provided that the above
+copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

wcfs/vendor/github.com/davecgh/go-spew/spew/bypass.go

+// Copyright (c) 2015-2016 Dave Collins <dave@davec.name>
+//
+// Permission to use, copy, modify, and distribute this software for any
+// purpose with or without fee is hereby granted, provided that the above
+// copyright notice and this permission notice appear in all copies.
+//
+// THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+// WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+// MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+// ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+// WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+// ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+// OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+// NOTE: Due to the following build constraints, this file will only be compiled
+// when the code is not running on Google App Engine, compiled by GopherJS, and
+// "-tags safe" is not added to the go build command line.  The "disableunsafe"
+// tag is deprecated and thus should not be used.
+// +build !js,!appengine,!safe,!disableunsafe
+
+package spew
+
+import (
+	"reflect"
+	"unsafe"
+)
+
+const (
+	// UnsafeDisabled is a build-time constant which specifies whether or
+	// not access to the unsafe package is available.
+	UnsafeDisabled = false
+
+	// ptrSize is the size of a pointer on the current arch.
+	ptrSize = unsafe.Sizeof((*byte)(nil))
+)
+
+var (
+	// offsetPtr, offsetScalar, and offsetFlag are the offsets for the
+	// internal reflect.Value fields.  These values are valid before golang
+	// commit ecccf07e7f9d which changed the format.  The are also valid
+	// after commit 82f48826c6c7 which changed the format again to mirror
+	// the original format.  Code in the init function updates these offsets
+	// as necessary.
+	offsetPtr    = uintptr(ptrSize)
+	offsetScalar = uintptr(0)
+	offsetFlag   = uintptr(ptrSize * 2)
+
+	// flagKindWidth and flagKindShift indicate various bits that the
+	// reflect package uses internally to track kind information.
+	//
+	// flagRO indicates whether or not the value field of a reflect.Value is
+	// read-only.
+	//
+	// flagIndir indicates whether the value field of a reflect.Value is
+	// the actual data or a pointer to the data.
+	//
+	// These values are valid before golang commit 90a7c3c86944 which
+	// changed their positions.  Code in the init function updates these
+	// flags as necessary.
+	flagKindWidth = uintptr(5)
+	flagKindShift = uintptr(flagKindWidth - 1)
+	flagRO        = uintptr(1 << 0)
+	flagIndir     = uintptr(1 << 1)
+)
+
+func init() {
+	// Older versions of reflect.Value stored small integers directly in the
+	// ptr field (which is named val in the older versions).  Versions
+	// between commits ecccf07e7f9d and 82f48826c6c7 added a new field named
+	// scalar for this purpose which unfortunately came before the flag
+	// field, so the offset of the flag field is different for those
+	// versions.
+	//
+	// This code constructs a new reflect.Value from a known small integer
+	// and checks if the size of the reflect.Value struct indicates it has
+	// the scalar field. When it does, the offsets are updated accordingly.
+	vv := reflect.ValueOf(0xf00)
+	if unsafe.Sizeof(vv) == (ptrSize * 4) {
+		offsetScalar = ptrSize * 2
+		offsetFlag = ptrSize * 3
+	}
+
+	// Commit 90a7c3c86944 changed the flag positions such that the low
+	// order bits are the kind.  This code extracts the kind from the flags
+	// field and ensures it's the correct type.  When it's not, the flag
+	// order has been changed to the newer format, so the flags are updated
+	// accordingly.
+	upf := unsafe.Pointer(uintptr(unsafe.Pointer(&vv)) + offsetFlag)
+	upfv := *(*uintptr)(upf)
+	flagKindMask := uintptr((1<<flagKindWidth - 1) << flagKindShift)
+	if (upfv&flagKindMask)>>flagKindShift != uintptr(reflect.Int) {
+		flagKindShift = 0
+		flagRO = 1 << 5
+		flagIndir = 1 << 6
+
+		// Commit adf9b30e5594 modified the flags to separate the
+		// flagRO flag into two bits which specifies whether or not the
+		// field is embedded.  This causes flagIndir to move over a bit
+		// and means that flagRO is the combination of either of the
+		// original flagRO bit and the new bit.
+		//
+		// This code detects the change by extracting what used to be
+		// the indirect bit to ensure it's set.  When it's not, the flag
+		// order has been changed to the newer format, so the flags are
+		// updated accordingly.
+		if upfv&flagIndir == 0 {
+			flagRO = 3 << 5
+			flagIndir = 1 << 7
+		}
+	}
+}
+
+// unsafeReflectValue converts the passed reflect.Value into a one that bypasses
+// the typical safety restrictions preventing access to unaddressable and
+// unexported data.  It works by digging the raw pointer to the underlying
+// value out of the protected value and generating a new unprotected (unsafe)
+// reflect.Value to it.
+//
+// This allows us to check for implementations of the Stringer and error
+// interfaces to be used for pretty printing ordinarily unaddressable and
+// inaccessible values such as unexported struct fields.
+func unsafeReflectValue(v reflect.Value) (rv reflect.Value) {
+	indirects := 1
+	vt := v.Type()
+	upv := unsafe.Pointer(uintptr(unsafe.Pointer(&v)) + offsetPtr)
+	rvf := *(*uintptr)(unsafe.Pointer(uintptr(unsafe.Pointer(&v)) + offsetFlag))
+	if rvf&flagIndir != 0 {
+		vt = reflect.PtrTo(v.Type())
+		indirects++
+	} else if offsetScalar != 0 {
+		// The value is in the scalar field when it's not one of the
+		// reference types.
+		switch vt.Kind() {
+		case reflect.Uintptr:
+		case reflect.Chan:
+		case reflect.Func:
+		case reflect.Map:
+		case reflect.Ptr:
+		case reflect.UnsafePointer:
+		default:
+			upv = unsafe.Pointer(uintptr(unsafe.Pointer(&v)) +
+				offsetScalar)
+		}
+	}
+
+	pv := reflect.NewAt(vt, upv)
+	rv = pv
+	for i := 0; i < indirects; i++ {
+		rv = rv.Elem()
+	}
+	return rv
+}

wcfs/vendor/github.com/davecgh/go-spew/spew/bypasssafe.go

+// Copyright (c) 2015-2016 Dave Collins <dave@davec.name>
+//
+// Permission to use, copy, modify, and distribute this software for any
+// purpose with or without fee is hereby granted, provided that the above
+// copyright notice and this permission notice appear in all copies.
+//
+// THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+// WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+// MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+// ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+// WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+// ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+// OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+// NOTE: Due to the following build constraints, this file will only be compiled
+// when the code is running on Google App Engine, compiled by GopherJS, or
+// "-tags safe" is added to the go build command line.  The "disableunsafe"
+// tag is deprecated and thus should not be used.
+// +build js appengine safe disableunsafe
+
+package spew
+
+import "reflect"
+
+const (
+	// UnsafeDisabled is a build-time constant which specifies whether or
+	// not access to the unsafe package is available.
+	UnsafeDisabled = true
+)
+
+// unsafeReflectValue typically converts the passed reflect.Value into a one
+// that bypasses the typical safety restrictions preventing access to
+// unaddressable and unexported data.  However, doing this relies on access to
+// the unsafe package.  This is a stub version which simply returns the passed
+// reflect.Value when the unsafe package is not available.
+func unsafeReflectValue(v reflect.Value) reflect.Value {
+	return v
+}

wcfs/vendor/github.com/davecgh/go-spew/spew/doc.go

+/*
+ * Copyright (c) 2013-2016 Dave Collins <dave@davec.name>
+ *
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+/*
+Package spew implements a deep pretty printer for Go data structures to aid in
+debugging.
+
+A quick overview of the additional features spew provides over the built-in
+printing facilities for Go data types are as follows:
+
+	* Pointers are dereferenced and followed
+	* Circular data structures are detected and handled properly
+	* Custom Stringer/error interfaces are optionally invoked, including
+	  on unexported types
+	* Custom types which only implement the Stringer/error interfaces via
+	  a pointer receiver are optionally invoked when passing non-pointer
+	  variables
+	* Byte arrays and slices are dumped like the hexdump -C command which
+	  includes offsets, byte values in hex, and ASCII output (only when using
+	  Dump style)
+
+There are two different approaches spew allows for dumping Go data structures:
+
+	* Dump style which prints with newlines, customizable indentation,
+	  and additional debug information such as types and all pointer addresses
+	  used to indirect to the final value
+	* A custom Formatter interface that integrates cleanly with the standard fmt
+	  package and replaces %v, %+v, %#v, and %#+v to provide inline printing
+	  similar to the default %v while providing the additional functionality
+	  outlined above and passing unsupported format verbs such as %x and %q
+	  along to fmt
+
+Quick Start
+
+This section demonstrates how to quickly get started with spew.  See the
+sections below for further details on formatting and configuration options.
+
+To dump a variable with full newlines, indentation, type, and pointer
+information use Dump, Fdump, or Sdump:
+	spew.Dump(myVar1, myVar2, ...)
+	spew.Fdump(someWriter, myVar1, myVar2, ...)
+	str := spew.Sdump(myVar1, myVar2, ...)
+
+Alternatively, if you would prefer to use format strings with a compacted inline
+printing style, use the convenience wrappers Printf, Fprintf, etc with
+%v (most compact), %+v (adds pointer addresses), %#v (adds types), or
+%#+v (adds types and pointer addresses):
+	spew.Printf("myVar1: %v -- myVar2: %+v", myVar1, myVar2)
+	spew.Printf("myVar3: %#v -- myVar4: %#+v", myVar3, myVar4)
+	spew.Fprintf(someWriter, "myVar1: %v -- myVar2: %+v", myVar1, myVar2)
+	spew.Fprintf(someWriter, "myVar3: %#v -- myVar4: %#+v", myVar3, myVar4)
+
+Configuration Options
+
+Configuration of spew is handled by fields in the ConfigState type.  For
+convenience, all of the top-level functions use a global state available
+via the spew.Config global.
+
+It is also possible to create a ConfigState instance that provides methods
+equivalent to the top-level functions.  This allows concurrent configuration
+options.  See the ConfigState documentation for more details.
+
+The following configuration options are available:
+	* Indent
+		String to use for each indentation level for Dump functions.
+		It is a single space by default.  A popular alternative is "\t".
+
+	* MaxDepth
+		Maximum number of levels to descend into nested data structures.
+		There is no limit by default.
+
+	* DisableMethods
+		Disables invocation of error and Stringer interface methods.
+		Method invocation is enabled by default.
+
+	* DisablePointerMethods
+		Disables invocation of error and Stringer interface methods on types
+		which only accept pointer receivers from non-pointer variables.
+		Pointer method invocation is enabled by default.
+
+	* DisablePointerAddresses
+		DisablePointerAddresses specifies whether to disable the printing of
+		pointer addresses. This is useful when diffing data structures in tests.
+
+	* DisableCapacities
+		DisableCapacities specifies whether to disable the printing of
+		capacities for arrays, slices, maps and channels. This is useful when
+		diffing data structures in tests.
+
+	* ContinueOnMethod
+		Enables recursion into types after invoking error and Stringer interface
+		methods. Recursion after method invocation is disabled by default.
+
+	* SortKeys
+		Specifies map keys should be sorted before being printed. Use
+		this to have a more deterministic, diffable output.  Note that
+		only native types (bool, int, uint, floats, uintptr and string)
+		and types which implement error or Stringer interfaces are
+		supported with other types sorted according to the
+		reflect.Value.String() output which guarantees display
+		stability.  Natural map order is used by default.
+
+	* SpewKeys
+		Specifies that, as a last resort attempt, map keys should be
+		spewed to strings and sorted by those strings.  This is only
+		considered if SortKeys is true.
+
+Dump Usage
+
+Simply call spew.Dump with a list of variables you want to dump:
+
+	spew.Dump(myVar1, myVar2, ...)
+
+You may also call spew.Fdump if you would prefer to output to an arbitrary
+io.Writer.  For example, to dump to standard error:
+
+	spew.Fdump(os.Stderr, myVar1, myVar2, ...)
+
+A third option is to call spew.Sdump to get the formatted output as a string:
+
+	str := spew.Sdump(myVar1, myVar2, ...)
+
+Sample Dump Output
+
+See the Dump example for details on the setup of the types and variables being
+shown here.
+
+	(main.Foo) {
+	 unexportedField: (*main.Bar)(0xf84002e210)({
+	  flag: (main.Flag) flagTwo,
+	  data: (uintptr) <nil>
+	 }),
+	 ExportedField: (map[interface {}]interface {}) (len=1) {
+	  (string) (len=3) "one": (bool) true
+	 }
+	}
+
+Byte (and uint8) arrays and slices are displayed uniquely like the hexdump -C
+command as shown.
+	([]uint8) (len=32 cap=32) {
+	 00000000  11 12 13 14 15 16 17 18  19 1a 1b 1c 1d 1e 1f 20  |............... |
+	 00000010  21 22 23 24 25 26 27 28  29 2a 2b 2c 2d 2e 2f 30  |!"#$%&'()*+,-./0|
+	 00000020  31 32                                             |12|
+	}
+
+Custom Formatter
+
+Spew provides a custom formatter that implements the fmt.Formatter interface
+so that it integrates cleanly with standard fmt package printing functions. The
+formatter is useful for inline printing of smaller data types similar to the
+standard %v format specifier.
+
+The custom formatter only responds to the %v (most compact), %+v (adds pointer
+addresses), %#v (adds types), or %#+v (adds types and pointer addresses) verb
+combinations.  Any other verbs such as %x and %q will be sent to the the
+standard fmt package for formatting.  In addition, the custom formatter ignores
+the width and precision arguments (however they will still work on the format
+specifiers not handled by the custom formatter).
+
+Custom Formatter Usage
+
+The simplest way to make use of the spew custom formatter is to call one of the
+convenience functions such as spew.Printf, spew.Println, or spew.Printf.  The
+functions have syntax you are most likely already familiar with:
+
+	spew.Printf("myVar1: %v -- myVar2: %+v", myVar1, myVar2)
+	spew.Printf("myVar3: %#v -- myVar4: %#+v", myVar3, myVar4)
+	spew.Println(myVar, myVar2)
+	spew.Fprintf(os.Stderr, "myVar1: %v -- myVar2: %+v", myVar1, myVar2)
+	spew.Fprintf(os.Stderr, "myVar3: %#v -- myVar4: %#+v", myVar3, myVar4)
+
+See the Index for the full list convenience functions.
+
+Sample Formatter Output
+
+Double pointer to a uint8:
+	  %v: <**>5
+	 %+v: <**>(0xf8400420d0->0xf8400420c8)5
+	 %#v: (**uint8)5
+	%#+v: (**uint8)(0xf8400420d0->0xf8400420c8)5
+
+Pointer to circular struct with a uint8 field and a pointer to itself:
+	  %v: <*>{1 <*><shown>}
+	 %+v: <*>(0xf84003e260){ui8:1 c:<*>(0xf84003e260)<shown>}
+	 %#v: (*main.circular){ui8:(uint8)1 c:(*main.circular)<shown>}
+	%#+v: (*main.circular)(0xf84003e260){ui8:(uint8)1 c:(*main.circular)(0xf84003e260)<shown>}
+
+See the Printf example for details on the setup of variables being shown
+here.
+
+Errors
+
+Since it is possible for custom Stringer/error interfaces to panic, spew
+detects them and handles them internally by printing the panic information
+inline with the output.  Since spew is intended to provide deep pretty printing
+capabilities on structures, it intentionally does not return any errors.
+*/
+package spew

wcfs/vendor/github.com/davecgh/go-spew/spew/spew.go

+/*
+ * Copyright (c) 2013-2016 Dave Collins <dave@davec.name>
+ *
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+package spew
+
+import (
+	"fmt"
+	"io"
+)
+
+// Errorf is a wrapper for fmt.Errorf that treats each argument as if it were
+// passed with a default Formatter interface returned by NewFormatter.  It
+// returns the formatted string as a value that satisfies error.  See
+// NewFormatter for formatting details.
+//
+// This function is shorthand for the following syntax:
+//
+//	fmt.Errorf(format, spew.NewFormatter(a), spew.NewFormatter(b))
+func Errorf(format string, a ...interface{}) (err error) {
+	return fmt.Errorf(format, convertArgs(a)...)
+}
+
+// Fprint is a wrapper for fmt.Fprint that treats each argument as if it were
+// passed with a default Formatter interface returned by NewFormatter.  It
+// returns the number of bytes written and any write error encountered.  See
+// NewFormatter for formatting details.
+//
+// This function is shorthand for the following syntax:
+//
+//	fmt.Fprint(w, spew.NewFormatter(a), spew.NewFormatter(b))
+func Fprint(w io.Writer, a ...interface{}) (n int, err error) {
+	return fmt.Fprint(w, convertArgs(a)...)
+}
+
+// Fprintf is a wrapper for fmt.Fprintf that treats each argument as if it were
+// passed with a default Formatter interface returned by NewFormatter.  It
+// returns the number of bytes written and any write error encountered.  See
+// NewFormatter for formatting details.
+//
+// This function is shorthand for the following syntax:
+//
+//	fmt.Fprintf(w, format, spew.NewFormatter(a), spew.NewFormatter(b))
+func Fprintf(w io.Writer, format string, a ...interface{}) (n int, err error) {
+	return fmt.Fprintf(w, format, convertArgs(a)...)
+}
+
+// Fprintln is a wrapper for fmt.Fprintln that treats each argument as if it
+// passed with a default Formatter interface returned by NewFormatter.  See
+// NewFormatter for formatting details.
+//
+// This function is shorthand for the following syntax:
+//
+//	fmt.Fprintln(w, spew.NewFormatter(a), spew.NewFormatter(b))
+func Fprintln(w io.Writer, a ...interface{}) (n int, err error) {
+	return fmt.Fprintln(w, convertArgs(a)...)
+}
+
+// Print is a wrapper for fmt.Print that treats each argument as if it were
+// passed with a default Formatter interface returned by NewFormatter.  It
+// returns the number of bytes written and any write error encountered.  See
+// NewFormatter for formatting details.
+//
+// This function is shorthand for the following syntax:
+//
+//	fmt.Print(spew.NewFormatter(a), spew.NewFormatter(b))
+func Print(a ...interface{}) (n int, err error) {
+	return fmt.Print(convertArgs(a)...)
+}
+
+// Printf is a wrapper for fmt.Printf that treats each argument as if it were
+// passed with a default Formatter interface returned by NewFormatter.  It
+// returns the number of bytes written and any write error encountered.  See
+// NewFormatter for formatting details.
+//
+// This function is shorthand for the following syntax:
+//
+//	fmt.Printf(format, spew.NewFormatter(a), spew.NewFormatter(b))
+func Printf(format string, a ...interface{}) (n int, err error) {
+	return fmt.Printf(format, convertArgs(a)...)
+}
+
+// Println is a wrapper for fmt.Println that treats each argument as if it were
+// passed with a default Formatter interface returned by NewFormatter.  It
+// returns the number of bytes written and any write error encountered.  See
+// NewFormatter for formatting details.
+//
+// This function is shorthand for the following syntax:
+//
+//	fmt.Println(spew.NewFormatter(a), spew.NewFormatter(b))
+func Println(a ...interface{}) (n int, err error) {
+	return fmt.Println(convertArgs(a)...)
+}
+
+// Sprint is a wrapper for fmt.Sprint that treats each argument as if it were
+// passed with a default Formatter interface returned by NewFormatter.  It
+// returns the resulting string.  See NewFormatter for formatting details.
+//
+// This function is shorthand for the following syntax:
+//
+//	fmt.Sprint(spew.NewFormatter(a), spew.NewFormatter(b))
+func Sprint(a ...interface{}) string {
+	return fmt.Sprint(convertArgs(a)...)
+}
+
+// Sprintf is a wrapper for fmt.Sprintf that treats each argument as if it were
+// passed with a default Formatter interface returned by NewFormatter.  It
+// returns the resulting string.  See NewFormatter for formatting details.
+//
+// This function is shorthand for the following syntax:
+//
+//	fmt.Sprintf(format, spew.NewFormatter(a), spew.NewFormatter(b))
+func Sprintf(format string, a ...interface{}) string {
+	return fmt.Sprintf(format, convertArgs(a)...)
+}
+
+// Sprintln is a wrapper for fmt.Sprintln that treats each argument as if it
+// were passed with a default Formatter interface returned by NewFormatter.  It
+// returns the resulting string.  See NewFormatter for formatting details.
+//
+// This function is shorthand for the following syntax:
+//
+//	fmt.Sprintln(spew.NewFormatter(a), spew.NewFormatter(b))
+func Sprintln(a ...interface{}) string {
+	return fmt.Sprintln(convertArgs(a)...)
+}
+
+// convertArgs accepts a slice of arguments and returns a slice of the same
+// length with each argument converted to a default spew Formatter interface.
+func convertArgs(args []interface{}) (formatters []interface{}) {
+	formatters = make([]interface{}, len(args))
+	for index, arg := range args {
+		formatters[index] = NewFormatter(arg)
+	}
+	return formatters
+}

wcfs/vendor/github.com/fsnotify/fsnotify/.editorconfig

+root = true
+
+[*.go]
+indent_style = tab
+indent_size = 4
+insert_final_newline = true
+
+[*.{yml,yaml}]
+indent_style = space
+indent_size = 2
+insert_final_newline = true
+trim_trailing_whitespace = true

wcfs/vendor/github.com/fsnotify/fsnotify/.gitattributes

+go.sum linguist-generated

wcfs/vendor/github.com/fsnotify/fsnotify/.gitignore

+# Setup a Global .gitignore for OS and editor generated files:
+# https://help.github.com/articles/ignoring-files
+# git config --global core.excludesfile ~/.gitignore_global
+
+.vagrant
+*.sublime-project

wcfs/vendor/github.com/fsnotify/fsnotify/.travis.yml

+sudo: false
+language: go
+
+go:
+  - "stable"
+  - "1.11.x"
+  - "1.10.x"
+  - "1.9.x"
+
+matrix:
+  include:
+    - go: "stable"
+      env: GOLINT=true
+  allow_failures:
+    - go: tip
+  fast_finish: true
+
+
+before_install:
+  - if [ ! -z "${GOLINT}" ]; then go get -u golang.org/x/lint/golint; fi
+
+script:
+  - go test --race ./...
+
+after_script:
+  - test -z "$(gofmt -s -l -w . | tee /dev/stderr)"
+  - if [ ! -z  "${GOLINT}" ]; then echo running golint; golint --set_exit_status  ./...; else echo skipping golint; fi
+  - go vet ./...
+
+os:
+  - linux
+  - osx
+  - windows
+
+notifications:
+  email: false

wcfs/vendor/github.com/fsnotify/fsnotify/AUTHORS

+# Names should be added to this file as
+#	Name or Organization <email address>
+# The email address is not required for organizations.
+
+# You can update this list using the following command:
+#
+#   $ git shortlog -se | awk '{print $2 " " $3 " " $4}'
+
+# Please keep the list sorted.
+
+Aaron L <aaron@bettercoder.net>
+Adrien Bustany <adrien@bustany.org>
+Amit Krishnan <amit.krishnan@oracle.com>
+Anmol Sethi <me@anmol.io>
+Bjørn Erik Pedersen <bjorn.erik.pedersen@gmail.com>
+Bruno Bigras <bigras.bruno@gmail.com>
+Caleb Spare <cespare@gmail.com>
+Case Nelson <case@teammating.com>
+Chris Howey <chris@howey.me> <howeyc@gmail.com>
+Christoffer Buchholz <christoffer.buchholz@gmail.com>
+Daniel Wagner-Hall <dawagner@gmail.com>
+Dave Cheney <dave@cheney.net>
+Evan Phoenix <evan@fallingsnow.net>
+Francisco Souza <f@souza.cc>
+Hari haran <hariharan.uno@gmail.com>
+John C Barstow
+Kelvin Fo <vmirage@gmail.com>
+Ken-ichirou MATSUZAWA <chamas@h4.dion.ne.jp>
+Matt Layher <mdlayher@gmail.com>
+Nathan Youngman <git@nathany.com>
+Nickolai Zeldovich <nickolai@csail.mit.edu>
+Patrick <patrick@dropbox.com>
+Paul Hammond <paul@paulhammond.org>
+Pawel Knap <pawelknap88@gmail.com>
+Pieter Droogendijk <pieter@binky.org.uk>
+Pursuit92 <JoshChase@techpursuit.net>
+Riku Voipio <riku.voipio@linaro.org>
+Rob Figueiredo <robfig@gmail.com>
+Rodrigo Chiossi <rodrigochiossi@gmail.com>
+Slawek Ligus <root@ooz.ie>
+Soge Zhang <zhssoge@gmail.com>
+Tiffany Jernigan <tiffany.jernigan@intel.com>
+Tilak Sharma <tilaks@google.com>
+Tom Payne <twpayne@gmail.com>
+Travis Cline <travis.cline@gmail.com>
+Tudor Golubenco <tudor.g@gmail.com>
+Vahe Khachikyan <vahe@live.ca>
+Yukang <moorekang@gmail.com>
+bronze1man <bronze1man@gmail.com>
+debrando <denis.brandolini@gmail.com>
+henrikedwards <henrik.edwards@gmail.com>
+铁哥 <guotie.9@gmail.com>

wcfs/vendor/github.com/fsnotify/fsnotify/CONTRIBUTING.md

+# Contributing
+
+## Issues
+
+* Request features and report bugs using the [GitHub Issue Tracker](https://github.com/fsnotify/fsnotify/issues).
+* Please indicate the platform you are using fsnotify on.
+* A code example to reproduce the problem is appreciated.
+
+## Pull Requests
+
+### Contributor License Agreement
+
+fsnotify is derived from code in the [golang.org/x/exp](https://godoc.org/golang.org/x/exp) package and it may be included [in the standard library](https://github.com/fsnotify/fsnotify/issues/1) in the future. Therefore fsnotify carries the same [LICENSE](https://github.com/fsnotify/fsnotify/blob/master/LICENSE) as Go. Contributors retain their copyright, so you need to fill out a short form before we can accept your contribution: [Google Individual Contributor License Agreement](https://developers.google.com/open-source/cla/individual).
+
+Please indicate that you have signed the CLA in your pull request.
+
+### How fsnotify is Developed
+
+* Development is done on feature branches.
+* Tests are run on BSD, Linux, macOS and Windows.
+* Pull requests are reviewed and [applied to master][am] using [hub][].
+  * Maintainers may modify or squash commits rather than asking contributors to.
+* To issue a new release, the maintainers will:
+  * Update the CHANGELOG
+  * Tag a version, which will become available through gopkg.in.
+ 
+### How to Fork
+
+For smooth sailing, always use the original import path. Installing with `go get` makes this easy. 
+
+1. Install from GitHub (`go get -u github.com/fsnotify/fsnotify`)
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Ensure everything works and the tests pass (see below)
+4. Commit your changes (`git commit -am 'Add some feature'`)
+
+Contribute upstream:
+
+1. Fork fsnotify on GitHub
+2. Add your remote (`git remote add fork git@github.com:mycompany/repo.git`)
+3. Push to the branch (`git push fork my-new-feature`)
+4. Create a new Pull Request on GitHub
+
+This workflow is [thoroughly explained by Katrina Owen](https://splice.com/blog/contributing-open-source-git-repositories-go/).
+
+### Testing
+
+fsnotify uses build tags to compile different code on Linux, BSD, macOS, and Windows.
+
+Before doing a pull request, please do your best to test your changes on multiple platforms, and list which platforms you were able/unable to test on.
+
+To aid in cross-platform testing there is a Vagrantfile for Linux and BSD.
+
+* Install [Vagrant](http://www.vagrantup.com/) and [VirtualBox](https://www.virtualbox.org/)
+* Setup [Vagrant Gopher](https://github.com/nathany/vagrant-gopher) in your `src` folder.
+* Run `vagrant up` from the project folder. You can also setup just one box with `vagrant up linux` or `vagrant up bsd` (note: the BSD box doesn't support Windows hosts at this time, and NFS may prompt for your host OS password)
+* Once setup, you can run the test suite on a given OS with a single command `vagrant ssh linux -c 'cd fsnotify/fsnotify; go test'`.
+* When you're done, you will want to halt or destroy the Vagrant boxes.
+
+Notice: fsnotify file system events won't trigger in shared folders. The tests get around this limitation by using the /tmp directory.
+
+Right now there is no equivalent solution for Windows and macOS, but there are Windows VMs [freely available from Microsoft](http://www.modern.ie/en-us/virtualization-tools#downloads).
+
+### Maintainers
+
+Help maintaining fsnotify is welcome. To be a maintainer:
+
+* Submit a pull request and sign the CLA as above.
+* You must be able to run the test suite on Mac, Windows, Linux and BSD.
+
+To keep master clean, the fsnotify project uses the "apply mail" workflow outlined in Nathaniel Talbott's post ["Merge pull request" Considered Harmful][am]. This requires installing [hub][].
+
+All code changes should be internal pull requests.
+
+Releases are tagged using [Semantic Versioning](http://semver.org/).
+
+[hub]: https://github.com/github/hub
+[am]: http://blog.spreedly.com/2014/06/24/merge-pull-request-considered-harmful/#.VGa5yZPF_Zs

wcfs/vendor/github.com/fsnotify/fsnotify/LICENSE

+Copyright (c) 2012 The Go Authors. All rights reserved.
+Copyright (c) 2012-2019 fsnotify Authors. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+
+   * Redistributions of source code must retain the above copyright
+notice, this list of conditions and the following disclaimer.
+   * Redistributions in binary form must reproduce the above
+copyright notice, this list of conditions and the following disclaimer
+in the documentation and/or other materials provided with the
+distribution.
+   * Neither the name of Google Inc. nor the names of its
+contributors may be used to endorse or promote products derived from
+this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

wcfs/vendor/github.com/fsnotify/fsnotify/README.md

+# File system notifications for Go
+
+[![GoDoc](https://godoc.org/github.com/fsnotify/fsnotify?status.svg)](https://godoc.org/github.com/fsnotify/fsnotify) [![Go Report Card](https://goreportcard.com/badge/github.com/fsnotify/fsnotify)](https://goreportcard.com/report/github.com/fsnotify/fsnotify)
+
+fsnotify utilizes [golang.org/x/sys](https://godoc.org/golang.org/x/sys) rather than `syscall` from the standard library. Ensure you have the latest version installed by running:
+
+```console
+go get -u golang.org/x/sys/...
+```
+
+Cross platform: Windows, Linux, BSD and macOS.
+
+| Adapter               | OS                               | Status                                                                                                                          |
+| --------------------- | -------------------------------- | ------------------------------------------------------------------------------------------------------------------------------- |
+| inotify               | Linux 2.6.27 or later, Android\* | Supported [![Build Status](https://travis-ci.org/fsnotify/fsnotify.svg?branch=master)](https://travis-ci.org/fsnotify/fsnotify) |
+| kqueue                | BSD, macOS, iOS\*                | Supported [![Build Status](https://travis-ci.org/fsnotify/fsnotify.svg?branch=master)](https://travis-ci.org/fsnotify/fsnotify) |
+| ReadDirectoryChangesW | Windows                          | Supported [![Build Status](https://travis-ci.org/fsnotify/fsnotify.svg?branch=master)](https://travis-ci.org/fsnotify/fsnotify) |
+| FSEvents              | macOS                            | [Planned](https://github.com/fsnotify/fsnotify/issues/11)                                                                       |
+| FEN                   | Solaris 11                       | [In Progress](https://github.com/fsnotify/fsnotify/issues/12)                                                                   |
+| fanotify              | Linux 2.6.37+                    | [Planned](https://github.com/fsnotify/fsnotify/issues/114)                                                                      |
+| USN Journals          | Windows                          | [Maybe](https://github.com/fsnotify/fsnotify/issues/53)                                                                         |
+| Polling               | *All*                            | [Maybe](https://github.com/fsnotify/fsnotify/issues/9)                                                                          |
+
+\* Android and iOS are untested.
+
+Please see [the documentation](https://godoc.org/github.com/fsnotify/fsnotify) and consult the [FAQ](#faq) for usage information.
+
+## API stability
+
+fsnotify is a fork of [howeyc/fsnotify](https://godoc.org/github.com/howeyc/fsnotify) with a new API as of v1.0. The API is based on [this design document](http://goo.gl/MrYxyA). 
+
+All [releases](https://github.com/fsnotify/fsnotify/releases) are tagged based on [Semantic Versioning](http://semver.org/). Further API changes are [planned](https://github.com/fsnotify/fsnotify/milestones), and will be tagged with a new major revision number.
+
+Go 1.6 supports dependencies located in the `vendor/` folder. Unless you are creating a library, it is recommended that you copy fsnotify into `vendor/github.com/fsnotify/fsnotify` within your project, and likewise for `golang.org/x/sys`.
+
+## Usage
+
+```go
+package main
+
+import (
+	"log"
+
+	"github.com/fsnotify/fsnotify"
+)
+
+func main() {
+	watcher, err := fsnotify.NewWatcher()
+	if err != nil {
+		log.Fatal(err)
+	}
+	defer watcher.Close()
+
+	done := make(chan bool)
+	go func() {
+		for {
+			select {
+			case event, ok := <-watcher.Events:
+				if !ok {
+					return
+				}
+				log.Println("event:", event)
+				if event.Op&fsnotify.Write == fsnotify.Write {
+					log.Println("modified file:", event.Name)
+				}
+			case err, ok := <-watcher.Errors:
+				if !ok {
+					return
+				}
+				log.Println("error:", err)
+			}
+		}
+	}()
+
+	err = watcher.Add("/tmp/foo")
+	if err != nil {
+		log.Fatal(err)
+	}
+	<-done
+}
+```
+
+## Contributing
+
+Please refer to [CONTRIBUTING][] before opening an issue or pull request.
+
+## Example
+
+See [example_test.go](https://github.com/fsnotify/fsnotify/blob/master/example_test.go).
+
+## FAQ
+
+**When a file is moved to another directory is it still being watched?**
+
+No (it shouldn't be, unless you are watching where it was moved to).
+
+**When I watch a directory, are all subdirectories watched as well?**
+
+No, you must add watches for any directory you want to watch (a recursive watcher is on the roadmap [#18][]).
+
+**Do I have to watch the Error and Event channels in a separate goroutine?**
+
+As of now, yes. Looking into making this single-thread friendly (see [howeyc #7][#7])
+
+**Why am I receiving multiple events for the same file on OS X?**
+
+Spotlight indexing on OS X can result in multiple events (see [howeyc #62][#62]). A temporary workaround is to add your folder(s) to the *Spotlight Privacy settings* until we have a native FSEvents implementation (see [#11][]).
+
+**How many files can be watched at once?**
+
+There are OS-specific limits as to how many watches can be created:
+* Linux: /proc/sys/fs/inotify/max_user_watches contains the limit, reaching this limit results in a "no space left on device" error.
+* BSD / OSX: sysctl variables "kern.maxfiles" and "kern.maxfilesperproc", reaching these limits results in a "too many open files" error.
+
+**Why don't notifications work with NFS filesystems or filesystem in userspace (FUSE)?**
+
+fsnotify requires support from underlying OS to work. The current NFS protocol does not provide network level support for file notifications.
+
+[#62]: https://github.com/howeyc/fsnotify/issues/62
+[#18]: https://github.com/fsnotify/fsnotify/issues/18
+[#11]: https://github.com/fsnotify/fsnotify/issues/11
+[#7]: https://github.com/howeyc/fsnotify/issues/7
+
+[contributing]: https://github.com/fsnotify/fsnotify/blob/master/CONTRIBUTING.md
+
+## Related Projects
+
+* [notify](https://github.com/rjeczalik/notify)
+* [fsevents](https://github.com/fsnotify/fsevents)
+

wcfs/vendor/github.com/fsnotify/fsnotify/fen.go

+// 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.
+
+// +build solaris
+
+package fsnotify
+
+import (
+	"errors"
+)
+
+// Watcher watches a set of files, delivering events to a channel.
+type Watcher struct {
+	Events chan Event
+	Errors chan error
+}
+
+// NewWatcher establishes a new watcher with the underlying OS and begins waiting for events.
+func NewWatcher() (*Watcher, error) {
+	return nil, errors.New("FEN based watcher not yet supported for fsnotify\n")
+}
+
+// Close removes all watches and closes the events channel.
+func (w *Watcher) Close() error {
+	return nil
+}
+
+// Add starts watching the named file or directory (non-recursively).
+func (w *Watcher) Add(name string) error {
+	return nil
+}
+
+// Remove stops watching the the named file or directory (non-recursively).
+func (w *Watcher) Remove(name string) error {
+	return nil
+}

wcfs/vendor/github.com/fsnotify/fsnotify/fsnotify.go

+// Copyright 2012 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.
+
+// +build !plan9
+
+// Package fsnotify provides a platform-independent interface for file system notifications.
+package fsnotify
+
+import (
+	"bytes"
+	"errors"
+	"fmt"
+)
+
+// Event represents a single file system notification.
+type Event struct {
+	Name string // Relative path to the file or directory.
+	Op   Op     // File operation that triggered the event.
+}
+
+// Op describes a set of file operations.
+type Op uint32
+
+// These are the generalized file operations that can trigger a notification.
+const (
+	Create Op = 1 << iota
+	Write
+	Remove
+	Rename
+	Chmod
+)
+
+func (op Op) String() string {
+	// Use a buffer for efficient string concatenation
+	var buffer bytes.Buffer
+
+	if op&Create == Create {
+		buffer.WriteString("|CREATE")
+	}
+	if op&Remove == Remove {
+		buffer.WriteString("|REMOVE")
+	}
+	if op&Write == Write {
+		buffer.WriteString("|WRITE")
+	}
+	if op&Rename == Rename {
+		buffer.WriteString("|RENAME")
+	}
+	if op&Chmod == Chmod {
+		buffer.WriteString("|CHMOD")
+	}
+	if buffer.Len() == 0 {
+		return ""
+	}
+	return buffer.String()[1:] // Strip leading pipe
+}
+
+// String returns a string representation of the event in the form
+// "file: REMOVE|WRITE|..."
+func (e Event) String() string {
+	return fmt.Sprintf("%q: %s", e.Name, e.Op.String())
+}
+
+// Common errors that can be reported by a watcher
+var (
+	ErrEventOverflow = errors.New("fsnotify queue overflow")
+)

wcfs/vendor/github.com/fsnotify/fsnotify/go.mod

+module github.com/fsnotify/fsnotify
+
+go 1.13
+
+require golang.org/x/sys v0.0.0-20191005200804-aed5e4c7ecf9

wcfs/vendor/github.com/fsnotify/fsnotify/go.sum

+golang.org/x/sys v0.0.0-20191005200804-aed5e4c7ecf9 h1:L2auWcuQIvxz9xSEqzESnV/QN/gNRXNApHi3fYwl2w0=
+golang.org/x/sys v0.0.0-20191005200804-aed5e4c7ecf9/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=

wcfs/vendor/github.com/fsnotify/fsnotify/open_mode_bsd.go

+// Copyright 2013 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.
+
+// +build freebsd openbsd netbsd dragonfly
+
+package fsnotify
+
+import "golang.org/x/sys/unix"
+
+const openMode = unix.O_NONBLOCK | unix.O_RDONLY | unix.O_CLOEXEC

wcfs/vendor/github.com/fsnotify/fsnotify/open_mode_darwin.go

+// Copyright 2013 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.
+
+// +build darwin
+
+package fsnotify
+
+import "golang.org/x/sys/unix"
+
+// note: this constant is not defined on BSD
+const openMode = unix.O_EVTONLY | unix.O_CLOEXEC

wcfs/vendor/github.com/golang/glog/README

+glog
+====
+
+Leveled execution logs for Go.
+
+This is an efficient pure Go implementation of leveled logs in the
+manner of the open source C++ package
+	https://github.com/google/glog
+
+By binding methods to booleans it is possible to use the log package
+without paying the expense of evaluating the arguments to the log.
+Through the -vmodule flag, the package also provides fine-grained
+control over logging at the file level.
+
+The comment from glog.go introduces the ideas:
+
+	Package glog implements logging analogous to the Google-internal
+	C++ INFO/ERROR/V setup.  It provides functions Info, Warning,
+	Error, Fatal, plus formatting variants such as Infof. It
+	also provides V-style logging controlled by the -v and
+	-vmodule=file=2 flags.
+	
+	Basic examples:
+	
+		glog.Info("Prepare to repel boarders")
+	
+		glog.Fatalf("Initialization failed: %s", err)
+	
+	See the documentation for the V function for an explanation
+	of these examples:
+	
+		if glog.V(2) {
+			glog.Info("Starting transaction...")
+		}
+	
+		glog.V(2).Infoln("Processed", nItems, "elements")
+
+
+The repository contains an open source version of the log package
+used inside Google. The master copy of the source lives inside
+Google, not here. The code in this repo is for export only and is not itself
+under development. Feature requests will be ignored.
+
+Send bug reports to golang-nuts@googlegroups.com.

wcfs/vendor/github.com/hanwen/go-fuse/v2/AUTHORS

+Adam H. Leventhal <adam.leventhal@gmail.com>
+Daniel Martí <mvdan@mvdan.cc>
+Fazlul Shahriar <fshahriar@gmail.com>
+Frederick Akalin <akalin@gmail.com>
+Google Inc.
+Haitao Li <lihaitao@gmail.com>
+Jakob Unterwurzacher <jakobunt@gmail.com>
+James D. Nurmi <james@abneptis.com>
+Jeff <leterip@me.com>
+Kaoet Ibe <kaoet.ibe@outlook.com>
+Kirill Smelkov <kirr@nexedi.com>
+Logan Hanks <logan@bitcasa.com>
+Maria Shaldibina <mshaldibina@pivotal.io>
+Nick Cooper <gh@smoogle.org>
+Patrick Crosby <pcrosby@gmail.com>
+Paul Jolly <paul@myitcv.org.uk>
+Paul Warren <paul.warren@emc.com>
+Shayan Pooya <shayan@arista.com>
+Valient Gough <vgough@pobox.com>
+Yongwoo Park <nnnlife@gmail.com>

wcfs/vendor/github.com/hanwen/go-fuse/v2/LICENSE

+// New BSD License
+//
+// Copyright (c) 2010 the Go-FUSE Authors. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Ivan Krasin nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//

wcfs/vendor/github.com/hanwen/go-fuse/v2/fuse/.gitignore

+version.gen.go

wcfs/vendor/github.com/hanwen/go-fuse/v2/fuse/attr_darwin.go

+// Copyright 2016 the Go-FUSE 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 fuse
+
+import (
+	"syscall"
+)
+
+func (a *Attr) FromStat(s *syscall.Stat_t) {
+	a.Ino = uint64(s.Ino)
+	a.Size = uint64(s.Size)
+	a.Blocks = uint64(s.Blocks)
+	a.Atime = uint64(s.Atimespec.Sec)
+	a.Atimensec = uint32(s.Atimespec.Nsec)
+	a.Mtime = uint64(s.Mtimespec.Sec)
+	a.Mtimensec = uint32(s.Mtimespec.Nsec)
+	a.Ctime = uint64(s.Ctimespec.Sec)
+	a.Ctimensec = uint32(s.Ctimespec.Nsec)
+	a.Mode = uint32(s.Mode)
+	a.Nlink = uint32(s.Nlink)
+	a.Uid = uint32(s.Uid)
+	a.Gid = uint32(s.Gid)
+	a.Rdev = uint32(s.Rdev)
+}

wcfs/vendor/github.com/hanwen/go-fuse/v2/fuse/constants_freebsd.go

+// Copyright 2016 the Go-FUSE 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 fuse
+
+// arbitrary values
+const syscall_O_LARGEFILE = 1 << 29
+const syscall_O_NOATIME = 1 << 30

wcfs/vendor/github.com/hanwen/go-fuse/v2/fuse/constants_linux.go

+// Copyright 2016 the Go-FUSE 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 fuse
+
+import (
+	"syscall"
+)
+
+const syscall_O_LARGEFILE = syscall.O_LARGEFILE
+const syscall_O_NOATIME = syscall.O_NOATIME