update vendor

vendor/github.com/docker/libcontainer/NOTICE

+libcontainer
+Copyright 2012-2015 Docker, Inc.
+
+This product includes software developed at Docker, Inc. (http://www.docker.com).
+
+The following is courtesy of our legal counsel:
+
+
+Use and transfer of Docker may be subject to certain restrictions by the
+United States and other governments.  
+It is your responsibility to ensure that your use and/or transfer does not
+violate applicable laws. 
+
+For more information, please see http://www.bis.doc.gov
+
+See also http://www.apache.org/dev/crypto.html and/or seek legal counsel.

vendor/github.com/docker/libcontainer/netlink/MAINTAINERS

+Michael Crosby <michael@crosbymichael.com> (@crosbymichael)
+Guillaume J. Charmes <guillaume@docker.com> (@creack)

vendor/github.com/docker/libcontainer/netlink/netlink.go

+// Packet netlink provide access to low level Netlink sockets and messages.
+//
+// Actual implementations are in:
+// netlink_linux.go
+// netlink_darwin.go
+package netlink
+
+import (
+	"errors"
+	"net"
+)
+
+var (
+	ErrWrongSockType   = errors.New("Wrong socket type")
+	ErrShortResponse   = errors.New("Got short response from netlink")
+	ErrInterfaceExists = errors.New("Network interface already exists")
+)
+
+// A Route is a subnet associated with the interface to reach it.
+type Route struct {
+	*net.IPNet
+	Iface   *net.Interface
+	Default bool
+}
+
+// An IfAddr defines IP network settings for a given network interface
+type IfAddr struct {
+	Iface *net.Interface
+	IP    net.IP
+	IPNet *net.IPNet
+}

vendor/github.com/docker/libcontainer/netlink/netlink_linux_armppc64.go

+// +build arm ppc64 ppc64le
+
+package netlink
+
+func ifrDataByte(b byte) uint8 {
+	return uint8(b)
+}

vendor/github.com/docker/libcontainer/netlink/netlink_linux_notarm.go

+// +build !arm,!ppc64,!ppc64le
+
+package netlink
+
+func ifrDataByte(b byte) int8 {
+	return int8(b)
+}

vendor/github.com/docker/libcontainer/netlink/netlink_unsupported.go

+// +build !linux
+
+package netlink
+
+import (
+	"errors"
+	"net"
+)
+
+var (
+	ErrNotImplemented = errors.New("not implemented")
+)
+
+func NetworkGetRoutes() ([]Route, error) {
+	return nil, ErrNotImplemented
+}
+
+func NetworkLinkAdd(name string, linkType string) error {
+	return ErrNotImplemented
+}
+
+func NetworkLinkDel(name string) error {
+	return ErrNotImplemented
+}
+
+func NetworkLinkUp(iface *net.Interface) error {
+	return ErrNotImplemented
+}
+
+func NetworkLinkAddIp(iface *net.Interface, ip net.IP, ipNet *net.IPNet) error {
+	return ErrNotImplemented
+}
+
+func NetworkLinkDelIp(iface *net.Interface, ip net.IP, ipNet *net.IPNet) error {
+	return ErrNotImplemented
+}
+
+func AddRoute(destination, source, gateway, device string) error {
+	return ErrNotImplemented
+}
+
+func AddDefaultGw(ip, device string) error {
+	return ErrNotImplemented
+}
+
+func NetworkSetMTU(iface *net.Interface, mtu int) error {
+	return ErrNotImplemented
+}
+
+func NetworkSetTxQueueLen(iface *net.Interface, txQueueLen int) error {
+	return ErrNotImplemented
+}
+
+func NetworkCreateVethPair(name1, name2 string, txQueueLen int) error {
+	return ErrNotImplemented
+}
+
+func NetworkChangeName(iface *net.Interface, newName string) error {
+	return ErrNotImplemented
+}
+
+func NetworkSetNsFd(iface *net.Interface, fd int) error {
+	return ErrNotImplemented
+}
+
+func NetworkSetNsPid(iface *net.Interface, nspid int) error {
+	return ErrNotImplemented
+}
+
+func NetworkSetMaster(iface, master *net.Interface) error {
+	return ErrNotImplemented
+}
+
+func NetworkLinkDown(iface *net.Interface) error {
+	return ErrNotImplemented
+}
+
+func CreateBridge(name string, setMacAddr bool) error {
+	return ErrNotImplemented
+}
+
+func DeleteBridge(name string) error {
+	return ErrNotImplemented
+}
+
+func AddToBridge(iface, master *net.Interface) error {
+	return ErrNotImplemented
+}

vendor/github.com/docker/libcontainer/system/linux.go

+// +build linux
+
+package system
+
+import (
+	"os/exec"
+	"syscall"
+	"unsafe"
+)
+
+type ParentDeathSignal int
+
+func (p ParentDeathSignal) Restore() error {
+	if p == 0 {
+		return nil
+	}
+	current, err := GetParentDeathSignal()
+	if err != nil {
+		return err
+	}
+	if p == current {
+		return nil
+	}
+	return p.Set()
+}
+
+func (p ParentDeathSignal) Set() error {
+	return SetParentDeathSignal(uintptr(p))
+}
+
+func Execv(cmd string, args []string, env []string) error {
+	name, err := exec.LookPath(cmd)
+	if err != nil {
+		return err
+	}
+
+	return syscall.Exec(name, args, env)
+}
+
+func SetParentDeathSignal(sig uintptr) error {
+	if _, _, err := syscall.RawSyscall(syscall.SYS_PRCTL, syscall.PR_SET_PDEATHSIG, sig, 0); err != 0 {
+		return err
+	}
+	return nil
+}
+
+func GetParentDeathSignal() (ParentDeathSignal, error) {
+	var sig int
+	_, _, err := syscall.RawSyscall(syscall.SYS_PRCTL, syscall.PR_GET_PDEATHSIG, uintptr(unsafe.Pointer(&sig)), 0)
+	if err != 0 {
+		return -1, err
+	}
+	return ParentDeathSignal(sig), nil
+}
+
+func SetKeepCaps() error {
+	if _, _, err := syscall.RawSyscall(syscall.SYS_PRCTL, syscall.PR_SET_KEEPCAPS, 1, 0); err != 0 {
+		return err
+	}
+
+	return nil
+}
+
+func ClearKeepCaps() error {
+	if _, _, err := syscall.RawSyscall(syscall.SYS_PRCTL, syscall.PR_SET_KEEPCAPS, 0, 0); err != 0 {
+		return err
+	}
+
+	return nil
+}
+
+func Setctty() error {
+	if _, _, err := syscall.RawSyscall(syscall.SYS_IOCTL, 0, uintptr(syscall.TIOCSCTTY), 0); err != 0 {
+		return err
+	}
+	return nil
+}

vendor/github.com/docker/libcontainer/system/proc.go

+package system
+
+import (
+	"io/ioutil"
+	"path/filepath"
+	"strconv"
+	"strings"
+)
+
+// look in /proc to find the process start time so that we can verify
+// that this pid has started after ourself
+func GetProcessStartTime(pid int) (string, error) {
+	data, err := ioutil.ReadFile(filepath.Join("/proc", strconv.Itoa(pid), "stat"))
+	if err != nil {
+		return "", err
+	}
+
+	parts := strings.Split(string(data), " ")
+	// the starttime is located at pos 22
+	// from the man page
+	//
+	// starttime %llu (was %lu before Linux 2.6)
+	// (22)  The  time the process started after system boot.  In kernels before Linux 2.6, this
+	// value was expressed in jiffies.  Since Linux 2.6, the value is expressed in  clock  ticks
+	// (divide by sysconf(_SC_CLK_TCK)).
+	return parts[22-1], nil // starts at 1
+}

vendor/github.com/docker/libcontainer/system/setns_linux.go

+package system
+
+import (
+	"fmt"
+	"runtime"
+	"syscall"
+)
+
+// Via http://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git/commit/?id=7b21fddd087678a70ad64afc0f632e0f1071b092
+//
+// We need different setns values for the different platforms and arch
+// We are declaring the macro here because the SETNS syscall does not exist in th stdlib
+var setNsMap = map[string]uintptr{
+	"linux/386":     346,
+	"linux/arm64":   268,
+	"linux/amd64":   308,
+	"linux/arm":     375,
+	"linux/ppc":     350,
+	"linux/ppc64":   350,
+	"linux/ppc64le": 350,
+	"linux/s390x":   339,
+}
+
+var sysSetns = setNsMap[fmt.Sprintf("%s/%s", runtime.GOOS, runtime.GOARCH)]
+
+func SysSetns() uint32 {
+	return uint32(sysSetns)
+}
+
+func Setns(fd uintptr, flags uintptr) error {
+	ns, exists := setNsMap[fmt.Sprintf("%s/%s", runtime.GOOS, runtime.GOARCH)]
+	if !exists {
+		return fmt.Errorf("unsupported platform %s/%s", runtime.GOOS, runtime.GOARCH)
+	}
+	_, _, err := syscall.RawSyscall(ns, fd, flags, 0)
+	if err != 0 {
+		return err
+	}
+	return nil
+}

vendor/github.com/docker/libcontainer/system/syscall_linux_386.go

+// +build linux,386
+package system
+
+import (
+	"syscall"
+)
+
+// Setuid sets the uid of the calling thread to the specified uid.
+func Setuid(uid int) (err error) {
+	_, _, e1 := syscall.RawSyscall(syscall.SYS_SETUID, uintptr(uid), 0, 0)
+	if e1 != 0 {
+		err = e1
+	}
+	return
+}
+
+// Setgid sets the gid of the calling thread to the specified gid.
+func Setgid(gid int) (err error) {
+	_, _, e1 := syscall.RawSyscall(syscall.SYS_SETGID32, uintptr(gid), 0, 0)
+	if e1 != 0 {
+		err = e1
+	}
+	return
+}

vendor/github.com/docker/libcontainer/system/syscall_linux_64.go

+// +build linux,arm64 linux,amd64 linux,ppc linux,ppc64 linux,ppc64le linux,s390x
+
+package system
+
+import (
+	"syscall"
+)
+
+// Setuid sets the uid of the calling thread to the specified uid.
+func Setuid(uid int) (err error) {
+	_, _, e1 := syscall.RawSyscall(syscall.SYS_SETUID, uintptr(uid), 0, 0)
+	if e1 != 0 {
+		err = e1
+	}
+	return
+}
+
+// Setgid sets the gid of the calling thread to the specified gid.
+func Setgid(gid int) (err error) {
+	_, _, e1 := syscall.RawSyscall(syscall.SYS_SETGID, uintptr(gid), 0, 0)
+	if e1 != 0 {
+		err = e1
+	}
+	return
+}

vendor/github.com/docker/libcontainer/system/syscall_linux_arm.go

+// +build linux,arm
+package system
+
+import (
+	"syscall"
+)
+
+// Setuid sets the uid of the calling thread to the specified uid.
+func Setuid(uid int) (err error) {
+	_, _, e1 := syscall.RawSyscall(syscall.SYS_SETUID32, uintptr(uid), 0, 0)
+	if e1 != 0 {
+		err = e1
+	}
+	return
+}
+
+// Setgid sets the gid of the calling thread to the specified gid.
+func Setgid(gid int) (err error) {
+	_, _, e1 := syscall.RawSyscall(syscall.SYS_SETGID32, uintptr(gid), 0, 0)
+	if e1 != 0 {
+		err = e1
+	}
+	return
+}

vendor/github.com/docker/libcontainer/system/sysconfig.go

+// +build cgo,linux cgo,freebsd
+
+package system
+
+/*
+#include <unistd.h>
+*/
+import "C"
+
+func GetClockTicks() int {
+	return int(C.sysconf(C._SC_CLK_TCK))
+}

vendor/github.com/docker/libcontainer/system/sysconfig_notcgo.go

+// +build !cgo windows
+
+package system
+
+func GetClockTicks() int {
+	// TODO figure out a better alternative for platforms where we're missing cgo
+	//
+	// TODO Windows. This could be implemented using Win32 QueryPerformanceFrequency().
+	// https://msdn.microsoft.com/en-us/library/windows/desktop/ms644905(v=vs.85).aspx
+	//
+	// An example of its usage can be found here.
+	// https://msdn.microsoft.com/en-us/library/windows/desktop/dn553408(v=vs.85).aspx
+
+	return 100
+}

vendor/github.com/docker/libcontainer/system/xattrs_linux.go

+package system
+
+import (
+	"syscall"
+	"unsafe"
+)
+
+var _zero uintptr
+
+// Returns the size of xattrs and nil error
+// Requires path, takes allocated []byte or nil as last argument
+func Llistxattr(path string, dest []byte) (size int, err error) {
+	pathBytes, err := syscall.BytePtrFromString(path)
+	if err != nil {
+		return -1, err
+	}
+	var newpathBytes unsafe.Pointer
+	if len(dest) > 0 {
+		newpathBytes = unsafe.Pointer(&dest[0])
+	} else {
+		newpathBytes = unsafe.Pointer(&_zero)
+	}
+
+	_size, _, errno := syscall.Syscall6(syscall.SYS_LLISTXATTR, uintptr(unsafe.Pointer(pathBytes)), uintptr(newpathBytes), uintptr(len(dest)), 0, 0, 0)
+	size = int(_size)
+	if errno != 0 {
+		return -1, errno
+	}
+
+	return size, nil
+}
+
+// Returns a []byte slice if the xattr is set and nil otherwise
+// Requires path and its attribute as arguments
+func Lgetxattr(path string, attr string) ([]byte, error) {
+	var sz int
+	pathBytes, err := syscall.BytePtrFromString(path)
+	if err != nil {
+		return nil, err
+	}
+	attrBytes, err := syscall.BytePtrFromString(attr)
+	if err != nil {
+		return nil, err
+	}
+
+	// Start with a 128 length byte array
+	sz = 128
+	dest := make([]byte, sz)
+	destBytes := unsafe.Pointer(&dest[0])
+	_sz, _, errno := syscall.Syscall6(syscall.SYS_LGETXATTR, uintptr(unsafe.Pointer(pathBytes)), uintptr(unsafe.Pointer(attrBytes)), uintptr(destBytes), uintptr(len(dest)), 0, 0)
+
+	switch {
+	case errno == syscall.ENODATA:
+		return nil, errno
+	case errno == syscall.ENOTSUP:
+		return nil, errno
+	case errno == syscall.ERANGE:
+		// 128 byte array might just not be good enough,
+		// A dummy buffer is used ``uintptr(0)`` to get real size
+		// of the xattrs on disk
+		_sz, _, errno = syscall.Syscall6(syscall.SYS_LGETXATTR, uintptr(unsafe.Pointer(pathBytes)), uintptr(unsafe.Pointer(attrBytes)), uintptr(unsafe.Pointer(nil)), uintptr(0), 0, 0)
+		sz = int(_sz)
+		if sz < 0 {
+			return nil, errno
+		}
+		dest = make([]byte, sz)
+		destBytes := unsafe.Pointer(&dest[0])
+		_sz, _, errno = syscall.Syscall6(syscall.SYS_LGETXATTR, uintptr(unsafe.Pointer(pathBytes)), uintptr(unsafe.Pointer(attrBytes)), uintptr(destBytes), uintptr(len(dest)), 0, 0)
+		if errno != 0 {
+			return nil, errno
+		}
+	case errno != 0:
+		return nil, errno
+	}
+	sz = int(_sz)
+	return dest[:sz], nil
+}
+
+func Lsetxattr(path string, attr string, data []byte, flags int) error {
+	pathBytes, err := syscall.BytePtrFromString(path)
+	if err != nil {
+		return err
+	}
+	attrBytes, err := syscall.BytePtrFromString(attr)
+	if err != nil {
+		return err
+	}
+	var dataBytes unsafe.Pointer
+	if len(data) > 0 {
+		dataBytes = unsafe.Pointer(&data[0])
+	} else {
+		dataBytes = unsafe.Pointer(&_zero)
+	}
+	_, _, errno := syscall.Syscall6(syscall.SYS_LSETXATTR, uintptr(unsafe.Pointer(pathBytes)), uintptr(unsafe.Pointer(attrBytes)), uintptr(dataBytes), uintptr(len(data)), uintptr(flags), 0)
+	if errno != 0 {
+		return errno
+	}
+	return nil
+}

vendor/github.com/klauspost/reedsolomon/gentables.go

-//+build ignore
-
-package main
-
-import (
-	"fmt"
-)
-
-var logTable = [fieldSize]int16{
-	-1, 0, 1, 25, 2, 50, 26, 198,
-	3, 223, 51, 238, 27, 104, 199, 75,
-	4, 100, 224, 14, 52, 141, 239, 129,
-	28, 193, 105, 248, 200, 8, 76, 113,
-	5, 138, 101, 47, 225, 36, 15, 33,
-	53, 147, 142, 218, 240, 18, 130, 69,
-	29, 181, 194, 125, 106, 39, 249, 185,
-	201, 154, 9, 120, 77, 228, 114, 166,
-	6, 191, 139, 98, 102, 221, 48, 253,
-	226, 152, 37, 179, 16, 145, 34, 136,
-	54, 208, 148, 206, 143, 150, 219, 189,
-	241, 210, 19, 92, 131, 56, 70, 64,
-	30, 66, 182, 163, 195, 72, 126, 110,
-	107, 58, 40, 84, 250, 133, 186, 61,
-	202, 94, 155, 159, 10, 21, 121, 43,
-	78, 212, 229, 172, 115, 243, 167, 87,
-	7, 112, 192, 247, 140, 128, 99, 13,
-	103, 74, 222, 237, 49, 197, 254, 24,
-	227, 165, 153, 119, 38, 184, 180, 124,
-	17, 68, 146, 217, 35, 32, 137, 46,
-	55, 63, 209, 91, 149, 188, 207, 205,
-	144, 135, 151, 178, 220, 252, 190, 97,
-	242, 86, 211, 171, 20, 42, 93, 158,
-	132, 60, 57, 83, 71, 109, 65, 162,
-	31, 45, 67, 216, 183, 123, 164, 118,
-	196, 23, 73, 236, 127, 12, 111, 246,
-	108, 161, 59, 82, 41, 157, 85, 170,
-	251, 96, 134, 177, 187, 204, 62, 90,
-	203, 89, 95, 176, 156, 169, 160, 81,
-	11, 245, 22, 235, 122, 117, 44, 215,
-	79, 174, 213, 233, 230, 231, 173, 232,
-	116, 214, 244, 234, 168, 80, 88, 175,
-}
-
-const (
-	// The number of elements in the field.
-	fieldSize = 256
-
-	// The polynomial used to generate the logarithm table.
-	//
-	// There are a number of polynomials that work to generate
-	// a Galois field of 256 elements.  The choice is arbitrary,
-	// and we just use the first one.
-	//
-	// The possibilities are: 29, 43, 45, 77, 95, 99, 101, 105,
-	//* 113, 135, 141, 169, 195, 207, 231, and 245.
-	generatingPolynomial = 29
-)
-
-func main() {
-	t := generateExpTable()
-	fmt.Printf("var expTable = %#v\n", t)
-	//t2 := generateMulTableSplit(t)
-	//fmt.Printf("var mulTable = %#v\n", t2)
-	low, high := generateMulTableHalf(t)
-	fmt.Printf("var mulTableLow = %#v\n", low)
-	fmt.Printf("var mulTableHigh = %#v\n", high)
-}
-
-/**
- * Generates the inverse log table.
- */
-func generateExpTable() []byte {
-	result := make([]byte, fieldSize*2-2)
-	for i := 1; i < fieldSize; i++ {
-		log := logTable[i]
-		result[log] = byte(i)
-		result[log+fieldSize-1] = byte(i)
-	}
-	return result
-}
-
-func generateMulTable(expTable []byte) []byte {
-	result := make([]byte, 256*256)
-	for v := range result {
-		a := byte(v & 0xff)
-		b := byte(v >> 8)
-		if a == 0 || b == 0 {
-			result[v] = 0
-			continue
-		}
-		logA := int(logTable[a])
-		logB := int(logTable[b])
-		result[v] = expTable[logA+logB]
-	}
-	return result
-}
-
-func generateMulTableSplit(expTable []byte) [256][256]byte {
-	var result [256][256]byte
-	for a := range result {
-		for b := range result[a] {
-			if a == 0 || b == 0 {
-				result[a][b] = 0
-				continue
-			}
-			logA := int(logTable[a])
-			logB := int(logTable[b])
-			result[a][b] = expTable[logA+logB]
-		}
-	}
-	return result
-}
-
-func generateMulTableHalf(expTable []byte) (low [256][16]byte, high [256][16]byte) {
-	for a := range low {
-		for b := range low {
-			result := 0
-			if !(a == 0 || b == 0) {
-				logA := int(logTable[a])
-				logB := int(logTable[b])
-				result = int(expTable[logA+logB])
-			}
-			if (b & 0xf) == b {
-				low[a][b] = byte(result)
-			}
-			if (b & 0xf0) == b {
-				high[a][b>>4] = byte(result)
-			}
-		}
-	}
-	return
-}

vendor/github.com/lucas-clemente/quic-go/internal/crypto/chacha20poly1305_aead.go

-// +build ignore
-
-package crypto
-
-import (
-	"crypto/cipher"
-	"encoding/binary"
-	"errors"
-
-	"github.com/aead/chacha20"
-
-	"github.com/lucas-clemente/quic-go/internal/protocol"
-)
-
-type aeadChacha20Poly1305 struct {
-	otherIV   []byte
-	myIV      []byte
-	encrypter cipher.AEAD
-	decrypter cipher.AEAD
-}
-
-// NewAEADChacha20Poly1305 creates a AEAD using chacha20poly1305
-func NewAEADChacha20Poly1305(otherKey []byte, myKey []byte, otherIV []byte, myIV []byte) (AEAD, error) {
-	if len(myKey) != 32 || len(otherKey) != 32 || len(myIV) != 4 || len(otherIV) != 4 {
-		return nil, errors.New("chacha20poly1305: expected 32-byte keys and 4-byte IVs")
-	}
-	// copy because ChaCha20Poly1305 expects array pointers
-	var MyKey, OtherKey [32]byte
-	copy(MyKey[:], myKey)
-	copy(OtherKey[:], otherKey)
-
-	encrypter, err := chacha20.NewChaCha20Poly1305WithTagSize(&MyKey, 12)
-	if err != nil {
-		return nil, err
-	}
-	decrypter, err := chacha20.NewChaCha20Poly1305WithTagSize(&OtherKey, 12)
-	if err != nil {
-		return nil, err
-	}
-	return &aeadChacha20Poly1305{
-		otherIV:   otherIV,
-		myIV:      myIV,
-		encrypter: encrypter,
-		decrypter: decrypter,
-	}, nil
-}
-
-func (aead *aeadChacha20Poly1305) Open(dst, src []byte, packetNumber protocol.PacketNumber, associatedData []byte) ([]byte, error) {
-	return aead.decrypter.Open(dst, aead.makeNonce(aead.otherIV, packetNumber), src, associatedData)
-}
-
-func (aead *aeadChacha20Poly1305) Seal(dst, src []byte, packetNumber protocol.PacketNumber, associatedData []byte) []byte {
-	return aead.encrypter.Seal(dst, aead.makeNonce(aead.myIV, packetNumber), src, associatedData)
-}
-
-func (aead *aeadChacha20Poly1305) makeNonce(iv []byte, packetNumber protocol.PacketNumber) []byte {
-	res := make([]byte, 12)
-	copy(res[0:4], iv)
-	binary.LittleEndian.PutUint64(res[4:12], uint64(packetNumber))
-	return res
-}

vendor/github.com/miekg/dns/duplicate_generate.go

-//+build ignore
-
-// types_generate.go is meant to run with go generate. It will use
-// go/{importer,types} to track down all the RR struct types. Then for each type
-// it will generate conversion tables (TypeToRR and TypeToString) and banal
-// methods (len, Header, copy) based on the struct tags. The generated source is
-// written to ztypes.go, and is meant to be checked into git.
-package main
-
-import (
-	"bytes"
-	"fmt"
-	"go/format"
-	"go/importer"
-	"go/types"
-	"log"
-	"os"
-)
-
-var packageHdr = `
-// Code generated by "go run duplicate_generate.go"; DO NOT EDIT.
-
-package dns
-
-`
-
-func getTypeStruct(t types.Type, scope *types.Scope) (*types.Struct, bool) {
-	st, ok := t.Underlying().(*types.Struct)
-	if !ok {
-		return nil, false
-	}
-	if st.Field(0).Type() == scope.Lookup("RR_Header").Type() {
-		return st, false
-	}
-	if st.Field(0).Anonymous() {
-		st, _ := getTypeStruct(st.Field(0).Type(), scope)
-		return st, true
-	}
-	return nil, false
-}
-
-func main() {
-	// Import and type-check the package
-	pkg, err := importer.Default().Import("github.com/miekg/dns")
-	fatalIfErr(err)
-	scope := pkg.Scope()
-
-	// Collect actual types (*X)
-	var namedTypes []string
-	for _, name := range scope.Names() {
-		o := scope.Lookup(name)
-		if o == nil || !o.Exported() {
-			continue
-		}
-
-		if st, _ := getTypeStruct(o.Type(), scope); st == nil {
-			continue
-		}
-
-		if name == "PrivateRR" || name == "OPT" {
-			continue
-		}
-
-		namedTypes = append(namedTypes, o.Name())
-	}
-
-	b := &bytes.Buffer{}
-	b.WriteString(packageHdr)
-
-	// Generate the duplicate check for each type.
-	fmt.Fprint(b, "// isDuplicate() functions\n\n")
-	for _, name := range namedTypes {
-
-		o := scope.Lookup(name)
-		st, isEmbedded := getTypeStruct(o.Type(), scope)
-		if isEmbedded {
-			continue
-		}
-		fmt.Fprintf(b, "func (r1 *%s) isDuplicate(_r2 RR) bool {\n", name)
-		fmt.Fprintf(b, "r2, ok := _r2.(*%s)\n", name)
-		fmt.Fprint(b, "if !ok { return false }\n")
-		fmt.Fprint(b, "_ = r2\n")
-		for i := 1; i < st.NumFields(); i++ {
-			field := st.Field(i).Name()
-			o2 := func(s string) { fmt.Fprintf(b, s+"\n", field, field) }
-			o3 := func(s string) { fmt.Fprintf(b, s+"\n", field, field, field) }
-
-			// For some reason, a and aaaa don't pop up as *types.Slice here (mostly like because the are
-			// *indirectly* defined as a slice in the net package).
-			if _, ok := st.Field(i).Type().(*types.Slice); ok {
-				o2("if len(r1.%s) != len(r2.%s) {\nreturn false\n}")
-
-				if st.Tag(i) == `dns:"cdomain-name"` || st.Tag(i) == `dns:"domain-name"` {
-					o3(`for i := 0; i < len(r1.%s); i++ {
-						if !isDulicateName(r1.%s[i], r2.%s[i]) {
-							return false
-						}
-					}`)
-
-					continue
-				}
-
-				o3(`for i := 0; i < len(r1.%s); i++ {
-					if r1.%s[i] != r2.%s[i] {
-						return false
-					}
-				}`)
-
-				continue
-			}
-
-			switch st.Tag(i) {
-			case `dns:"-"`:
-				// ignored
-			case `dns:"a"`, `dns:"aaaa"`:
-				o2("if !r1.%s.Equal(r2.%s) {\nreturn false\n}")
-			case `dns:"cdomain-name"`, `dns:"domain-name"`:
-				o2("if !isDulicateName(r1.%s, r2.%s) {\nreturn false\n}")
-			default:
-				o2("if r1.%s != r2.%s {\nreturn false\n}")
-			}
-		}
-		fmt.Fprintf(b, "return true\n}\n\n")
-	}
-
-	// gofmt
-	res, err := format.Source(b.Bytes())
-	if err != nil {
-		b.WriteTo(os.Stderr)
-		log.Fatal(err)
-	}
-
-	// write result
-	f, err := os.Create("zduplicate.go")
-	fatalIfErr(err)
-	defer f.Close()
-	f.Write(res)
-}
-
-func fatalIfErr(err error) {
-	if err != nil {
-		log.Fatal(err)
-	}
-}

vendor/github.com/miekg/dns/msg_generate.go

-//+build ignore
-
-// msg_generate.go is meant to run with go generate. It will use
-// go/{importer,types} to track down all the RR struct types. Then for each type
-// it will generate pack/unpack methods based on the struct tags. The generated source is
-// written to zmsg.go, and is meant to be checked into git.
-package main
-
-import (
-	"bytes"
-	"fmt"
-	"go/format"
-	"go/importer"
-	"go/types"
-	"log"
-	"os"
-	"strings"
-)
-
-var packageHdr = `
-// Code generated by "go run msg_generate.go"; DO NOT EDIT.
-
-package dns
-
-`
-
-// getTypeStruct will take a type and the package scope, and return the
-// (innermost) struct if the type is considered a RR type (currently defined as
-// those structs beginning with a RR_Header, could be redefined as implementing
-// the RR interface). The bool return value indicates if embedded structs were
-// resolved.
-func getTypeStruct(t types.Type, scope *types.Scope) (*types.Struct, bool) {
-	st, ok := t.Underlying().(*types.Struct)
-	if !ok {
-		return nil, false
-	}
-	if st.Field(0).Type() == scope.Lookup("RR_Header").Type() {
-		return st, false
-	}
-	if st.Field(0).Anonymous() {
-		st, _ := getTypeStruct(st.Field(0).Type(), scope)
-		return st, true
-	}
-	return nil, false
-}
-
-func main() {
-	// Import and type-check the package
-	pkg, err := importer.Default().Import("github.com/miekg/dns")
-	fatalIfErr(err)
-	scope := pkg.Scope()
-
-	// Collect actual types (*X)
-	var namedTypes []string
-	for _, name := range scope.Names() {
-		o := scope.Lookup(name)
-		if o == nil || !o.Exported() {
-			continue
-		}
-		if st, _ := getTypeStruct(o.Type(), scope); st == nil {
-			continue
-		}
-		if name == "PrivateRR" {
-			continue
-		}
-
-		// Check if corresponding TypeX exists
-		if scope.Lookup("Type"+o.Name()) == nil && o.Name() != "RFC3597" {
-			log.Fatalf("Constant Type%s does not exist.", o.Name())
-		}
-
-		namedTypes = append(namedTypes, o.Name())
-	}
-
-	b := &bytes.Buffer{}
-	b.WriteString(packageHdr)
-
-	fmt.Fprint(b, "// pack*() functions\n\n")
-	for _, name := range namedTypes {
-		o := scope.Lookup(name)
-		st, _ := getTypeStruct(o.Type(), scope)
-
-		fmt.Fprintf(b, "func (rr *%s) pack(msg []byte, off int, compression compressionMap, compress bool) (off1 int, err error) {\n", name)
-		for i := 1; i < st.NumFields(); i++ {
-			o := func(s string) {
-				fmt.Fprintf(b, s, st.Field(i).Name())
-				fmt.Fprint(b, `if err != nil {
-return off, err
-}
-`)
-			}
-
-			if _, ok := st.Field(i).Type().(*types.Slice); ok {
-				switch st.Tag(i) {
-				case `dns:"-"`: // ignored
-				case `dns:"txt"`:
-					o("off, err = packStringTxt(rr.%s, msg, off)\n")
-				case `dns:"opt"`:
-					o("off, err = packDataOpt(rr.%s, msg, off)\n")
-				case `dns:"nsec"`:
-					o("off, err = packDataNsec(rr.%s, msg, off)\n")
-				case `dns:"domain-name"`:
-					o("off, err = packDataDomainNames(rr.%s, msg, off, compression, false)\n")
-				default:
-					log.Fatalln(name, st.Field(i).Name(), st.Tag(i))
-				}
-				continue
-			}
-
-			switch {
-			case st.Tag(i) == `dns:"-"`: // ignored
-			case st.Tag(i) == `dns:"cdomain-name"`:
-				o("off, err = packDomainName(rr.%s, msg, off, compression, compress)\n")
-			case st.Tag(i) == `dns:"domain-name"`:
-				o("off, err = packDomainName(rr.%s, msg, off, compression, false)\n")
-			case st.Tag(i) == `dns:"a"`:
-				o("off, err = packDataA(rr.%s, msg, off)\n")
-			case st.Tag(i) == `dns:"aaaa"`:
-				o("off, err = packDataAAAA(rr.%s, msg, off)\n")
-			case st.Tag(i) == `dns:"uint48"`:
-				o("off, err = packUint48(rr.%s, msg, off)\n")
-			case st.Tag(i) == `dns:"txt"`:
-				o("off, err = packString(rr.%s, msg, off)\n")
-
-			case strings.HasPrefix(st.Tag(i), `dns:"size-base32`): // size-base32 can be packed just like base32
-				fallthrough
-			case st.Tag(i) == `dns:"base32"`:
-				o("off, err = packStringBase32(rr.%s, msg, off)\n")
-
-			case strings.HasPrefix(st.Tag(i), `dns:"size-base64`): // size-base64 can be packed just like base64
-				fallthrough
-			case st.Tag(i) == `dns:"base64"`:
-				o("off, err = packStringBase64(rr.%s, msg, off)\n")
-
-			case strings.HasPrefix(st.Tag(i), `dns:"size-hex:SaltLength`):
-				// directly write instead of using o() so we get the error check in the correct place
-				field := st.Field(i).Name()
-				fmt.Fprintf(b, `// Only pack salt if value is not "-", i.e. empty
-if rr.%s != "-" {
-  off, err = packStringHex(rr.%s, msg, off)
-  if err != nil {
-    return off, err
-  }
-}
-`, field, field)
-				continue
-			case strings.HasPrefix(st.Tag(i), `dns:"size-hex`): // size-hex can be packed just like hex
-				fallthrough
-			case st.Tag(i) == `dns:"hex"`:
-				o("off, err = packStringHex(rr.%s, msg, off)\n")
-			case st.Tag(i) == `dns:"any"`:
-				o("off, err = packStringAny(rr.%s, msg, off)\n")
-			case st.Tag(i) == `dns:"octet"`:
-				o("off, err = packStringOctet(rr.%s, msg, off)\n")
-			case st.Tag(i) == "":
-				switch st.Field(i).Type().(*types.Basic).Kind() {
-				case types.Uint8:
-					o("off, err = packUint8(rr.%s, msg, off)\n")
-				case types.Uint16:
-					o("off, err = packUint16(rr.%s, msg, off)\n")
-				case types.Uint32:
-					o("off, err = packUint32(rr.%s, msg, off)\n")
-				case types.Uint64:
-					o("off, err = packUint64(rr.%s, msg, off)\n")
-				case types.String:
-					o("off, err = packString(rr.%s, msg, off)\n")
-				default:
-					log.Fatalln(name, st.Field(i).Name())
-				}
-			default:
-				log.Fatalln(name, st.Field(i).Name(), st.Tag(i))
-			}
-		}
-		fmt.Fprintln(b, "return off, nil }\n")
-	}
-
-	fmt.Fprint(b, "// unpack*() functions\n\n")
-	for _, name := range namedTypes {
-		o := scope.Lookup(name)
-		st, _ := getTypeStruct(o.Type(), scope)
-
-		fmt.Fprintf(b, "func (rr *%s) unpack(msg []byte, off int) (off1 int, err error) {\n", name)
-		fmt.Fprint(b, `rdStart := off
-_ = rdStart
-
-`)
-		for i := 1; i < st.NumFields(); i++ {
-			o := func(s string) {
-				fmt.Fprintf(b, s, st.Field(i).Name())
-				fmt.Fprint(b, `if err != nil {
-return off, err
-}
-`)
-			}
-
-			// size-* are special, because they reference a struct member we should use for the length.
-			if strings.HasPrefix(st.Tag(i), `dns:"size-`) {
-				structMember := structMember(st.Tag(i))
-				structTag := structTag(st.Tag(i))
-				switch structTag {
-				case "hex":
-					fmt.Fprintf(b, "rr.%s, off, err = unpackStringHex(msg, off, off + int(rr.%s))\n", st.Field(i).Name(), structMember)
-				case "base32":
-					fmt.Fprintf(b, "rr.%s, off, err = unpackStringBase32(msg, off, off + int(rr.%s))\n", st.Field(i).Name(), structMember)
-				case "base64":
-					fmt.Fprintf(b, "rr.%s, off, err = unpackStringBase64(msg, off, off + int(rr.%s))\n", st.Field(i).Name(), structMember)
-				default:
-					log.Fatalln(name, st.Field(i).Name(), st.Tag(i))
-				}
-				fmt.Fprint(b, `if err != nil {
-return off, err
-}
-`)
-				continue
-			}
-
-			if _, ok := st.Field(i).Type().(*types.Slice); ok {
-				switch st.Tag(i) {
-				case `dns:"-"`: // ignored
-				case `dns:"txt"`:
-					o("rr.%s, off, err = unpackStringTxt(msg, off)\n")
-				case `dns:"opt"`:
-					o("rr.%s, off, err = unpackDataOpt(msg, off)\n")
-				case `dns:"nsec"`:
-					o("rr.%s, off, err = unpackDataNsec(msg, off)\n")
-				case `dns:"domain-name"`:
-					o("rr.%s, off, err = unpackDataDomainNames(msg, off, rdStart + int(rr.Hdr.Rdlength))\n")
-				default:
-					log.Fatalln(name, st.Field(i).Name(), st.Tag(i))
-				}
-				continue
-			}
-
-			switch st.Tag(i) {
-			case `dns:"-"`: // ignored
-			case `dns:"cdomain-name"`:
-				fallthrough
-			case `dns:"domain-name"`:
-				o("rr.%s, off, err = UnpackDomainName(msg, off)\n")
-			case `dns:"a"`:
-				o("rr.%s, off, err = unpackDataA(msg, off)\n")
-			case `dns:"aaaa"`:
-				o("rr.%s, off, err = unpackDataAAAA(msg, off)\n")
-			case `dns:"uint48"`:
-				o("rr.%s, off, err = unpackUint48(msg, off)\n")
-			case `dns:"txt"`:
-				o("rr.%s, off, err = unpackString(msg, off)\n")
-			case `dns:"base32"`:
-				o("rr.%s, off, err = unpackStringBase32(msg, off, rdStart + int(rr.Hdr.Rdlength))\n")
-			case `dns:"base64"`:
-				o("rr.%s, off, err = unpackStringBase64(msg, off, rdStart + int(rr.Hdr.Rdlength))\n")
-			case `dns:"hex"`:
-				o("rr.%s, off, err = unpackStringHex(msg, off, rdStart + int(rr.Hdr.Rdlength))\n")
-			case `dns:"any"`:
-				o("rr.%s, off, err = unpackStringAny(msg, off, rdStart + int(rr.Hdr.Rdlength))\n")
-			case `dns:"octet"`:
-				o("rr.%s, off, err = unpackStringOctet(msg, off)\n")
-			case "":
-				switch st.Field(i).Type().(*types.Basic).Kind() {
-				case types.Uint8:
-					o("rr.%s, off, err = unpackUint8(msg, off)\n")
-				case types.Uint16:
-					o("rr.%s, off, err = unpackUint16(msg, off)\n")
-				case types.Uint32:
-					o("rr.%s, off, err = unpackUint32(msg, off)\n")
-				case types.Uint64:
-					o("rr.%s, off, err = unpackUint64(msg, off)\n")
-				case types.String:
-					o("rr.%s, off, err = unpackString(msg, off)\n")
-				default:
-					log.Fatalln(name, st.Field(i).Name())
-				}
-			default:
-				log.Fatalln(name, st.Field(i).Name(), st.Tag(i))
-			}
-			// If we've hit len(msg) we return without error.
-			if i < st.NumFields()-1 {
-				fmt.Fprintf(b, `if off == len(msg) {
-return off, nil
-	}
-`)
-			}
-		}
-		fmt.Fprintf(b, "return off, nil }\n\n")
-	}
-
-	// gofmt
-	res, err := format.Source(b.Bytes())
-	if err != nil {
-		b.WriteTo(os.Stderr)
-		log.Fatal(err)
-	}
-
-	// write result
-	f, err := os.Create("zmsg.go")
-	fatalIfErr(err)
-	defer f.Close()
-	f.Write(res)
-}
-
-// structMember will take a tag like dns:"size-base32:SaltLength" and return the last part of this string.
-func structMember(s string) string {
-	fields := strings.Split(s, ":")
-	if len(fields) == 0 {
-		return ""
-	}
-	f := fields[len(fields)-1]
-	// f should have a closing "
-	if len(f) > 1 {
-		return f[:len(f)-1]
-	}
-	return f
-}
-
-// structTag will take a tag like dns:"size-base32:SaltLength" and return base32.
-func structTag(s string) string {
-	fields := strings.Split(s, ":")
-	if len(fields) < 2 {
-		return ""
-	}
-	return fields[1][len("\"size-"):]
-}
-
-func fatalIfErr(err error) {
-	if err != nil {
-		log.Fatal(err)
-	}
-}

vendor/github.com/miekg/dns/types_generate.go

-//+build ignore
-
-// types_generate.go is meant to run with go generate. It will use
-// go/{importer,types} to track down all the RR struct types. Then for each type
-// it will generate conversion tables (TypeToRR and TypeToString) and banal
-// methods (len, Header, copy) based on the struct tags. The generated source is
-// written to ztypes.go, and is meant to be checked into git.
-package main
-
-import (
-	"bytes"
-	"fmt"
-	"go/format"
-	"go/importer"
-	"go/types"
-	"log"
-	"os"
-	"strings"
-	"text/template"
-)
-
-var skipLen = map[string]struct{}{
-	"NSEC":  {},
-	"NSEC3": {},
-	"OPT":   {},
-	"CSYNC": {},
-}
-
-var packageHdr = `
-// Code generated by "go run types_generate.go"; DO NOT EDIT.
-
-package dns
-
-import (
-	"encoding/base64"
-	"net"
-)
-
-`
-
-var TypeToRR = template.Must(template.New("TypeToRR").Parse(`
-// TypeToRR is a map of constructors for each RR type.
-var TypeToRR = map[uint16]func() RR{
-{{range .}}{{if ne . "RFC3597"}}  Type{{.}}:  func() RR { return new({{.}}) },
-{{end}}{{end}}                    }
-
-`))
-
-var typeToString = template.Must(template.New("typeToString").Parse(`
-// TypeToString is a map of strings for each RR type.
-var TypeToString = map[uint16]string{
-{{range .}}{{if ne . "NSAPPTR"}}  Type{{.}}: "{{.}}",
-{{end}}{{end}}                    TypeNSAPPTR:    "NSAP-PTR",
-}
-
-`))
-
-var headerFunc = template.Must(template.New("headerFunc").Parse(`
-{{range .}}  func (rr *{{.}}) Header() *RR_Header { return &rr.Hdr }
-{{end}}
-
-`))
-
-// getTypeStruct will take a type and the package scope, and return the
-// (innermost) struct if the type is considered a RR type (currently defined as
-// those structs beginning with a RR_Header, could be redefined as implementing
-// the RR interface). The bool return value indicates if embedded structs were
-// resolved.
-func getTypeStruct(t types.Type, scope *types.Scope) (*types.Struct, bool) {
-	st, ok := t.Underlying().(*types.Struct)
-	if !ok {
-		return nil, false
-	}
-	if st.Field(0).Type() == scope.Lookup("RR_Header").Type() {
-		return st, false
-	}
-	if st.Field(0).Anonymous() {
-		st, _ := getTypeStruct(st.Field(0).Type(), scope)
-		return st, true
-	}
-	return nil, false
-}
-
-func main() {
-	// Import and type-check the package
-	pkg, err := importer.Default().Import("github.com/miekg/dns")
-	fatalIfErr(err)
-	scope := pkg.Scope()
-
-	// Collect constants like TypeX
-	var numberedTypes []string
-	for _, name := range scope.Names() {
-		o := scope.Lookup(name)
-		if o == nil || !o.Exported() {
-			continue
-		}
-		b, ok := o.Type().(*types.Basic)
-		if !ok || b.Kind() != types.Uint16 {
-			continue
-		}
-		if !strings.HasPrefix(o.Name(), "Type") {
-			continue
-		}
-		name := strings.TrimPrefix(o.Name(), "Type")
-		if name == "PrivateRR" {
-			continue
-		}
-		numberedTypes = append(numberedTypes, name)
-	}
-
-	// Collect actual types (*X)
-	var namedTypes []string
-	for _, name := range scope.Names() {
-		o := scope.Lookup(name)
-		if o == nil || !o.Exported() {
-			continue
-		}
-		if st, _ := getTypeStruct(o.Type(), scope); st == nil {
-			continue
-		}
-		if name == "PrivateRR" {
-			continue
-		}
-
-		// Check if corresponding TypeX exists
-		if scope.Lookup("Type"+o.Name()) == nil && o.Name() != "RFC3597" {
-			log.Fatalf("Constant Type%s does not exist.", o.Name())
-		}
-
-		namedTypes = append(namedTypes, o.Name())
-	}
-
-	b := &bytes.Buffer{}
-	b.WriteString(packageHdr)
-
-	// Generate TypeToRR
-	fatalIfErr(TypeToRR.Execute(b, namedTypes))
-
-	// Generate typeToString
-	fatalIfErr(typeToString.Execute(b, numberedTypes))
-
-	// Generate headerFunc
-	fatalIfErr(headerFunc.Execute(b, namedTypes))
-
-	// Generate len()
-	fmt.Fprint(b, "// len() functions\n")
-	for _, name := range namedTypes {
-		if _, ok := skipLen[name]; ok {
-			continue
-		}
-		o := scope.Lookup(name)
-		st, isEmbedded := getTypeStruct(o.Type(), scope)
-		if isEmbedded {
-			continue
-		}
-		fmt.Fprintf(b, "func (rr *%s) len(off int, compression map[string]struct{}) int {\n", name)
-		fmt.Fprintf(b, "l := rr.Hdr.len(off, compression)\n")
-		for i := 1; i < st.NumFields(); i++ {
-			o := func(s string) { fmt.Fprintf(b, s, st.Field(i).Name()) }
-
-			if _, ok := st.Field(i).Type().(*types.Slice); ok {
-				switch st.Tag(i) {
-				case `dns:"-"`:
-					// ignored
-				case `dns:"cdomain-name"`:
-					o("for _, x := range rr.%s { l += domainNameLen(x, off+l, compression, true) }\n")
-				case `dns:"domain-name"`:
-					o("for _, x := range rr.%s { l += domainNameLen(x, off+l, compression, false) }\n")
-				case `dns:"txt"`:
-					o("for _, x := range rr.%s { l += len(x) + 1 }\n")
-				default:
-					log.Fatalln(name, st.Field(i).Name(), st.Tag(i))
-				}
-				continue
-			}
-
-			switch {
-			case st.Tag(i) == `dns:"-"`:
-				// ignored
-			case st.Tag(i) == `dns:"cdomain-name"`:
-				o("l += domainNameLen(rr.%s, off+l, compression, true)\n")
-			case st.Tag(i) == `dns:"domain-name"`:
-				o("l += domainNameLen(rr.%s, off+l, compression, false)\n")
-			case st.Tag(i) == `dns:"octet"`:
-				o("l += len(rr.%s)\n")
-			case strings.HasPrefix(st.Tag(i), `dns:"size-base64`):
-				fallthrough
-			case st.Tag(i) == `dns:"base64"`:
-				o("l += base64.StdEncoding.DecodedLen(len(rr.%s))\n")
-			case strings.HasPrefix(st.Tag(i), `dns:"size-hex:`): // this has an extra field where the length is stored
-				o("l += len(rr.%s)/2\n")
-			case strings.HasPrefix(st.Tag(i), `dns:"size-hex`):
-				fallthrough
-			case st.Tag(i) == `dns:"hex"`:
-				o("l += len(rr.%s)/2 + 1\n")
-			case st.Tag(i) == `dns:"any"`:
-				o("l += len(rr.%s)\n")
-			case st.Tag(i) == `dns:"a"`:
-				o("l += net.IPv4len // %s\n")
-			case st.Tag(i) == `dns:"aaaa"`:
-				o("l += net.IPv6len // %s\n")
-			case st.Tag(i) == `dns:"txt"`:
-				o("for _, t := range rr.%s { l += len(t) + 1 }\n")
-			case st.Tag(i) == `dns:"uint48"`:
-				o("l += 6 // %s\n")
-			case st.Tag(i) == "":
-				switch st.Field(i).Type().(*types.Basic).Kind() {
-				case types.Uint8:
-					o("l++ // %s\n")
-				case types.Uint16:
-					o("l += 2 // %s\n")
-				case types.Uint32:
-					o("l += 4 // %s\n")
-				case types.Uint64:
-					o("l += 8 // %s\n")
-				case types.String:
-					o("l += len(rr.%s) + 1\n")
-				default:
-					log.Fatalln(name, st.Field(i).Name())
-				}
-			default:
-				log.Fatalln(name, st.Field(i).Name(), st.Tag(i))
-			}
-		}
-		fmt.Fprintf(b, "return l }\n")
-	}
-
-	// Generate copy()
-	fmt.Fprint(b, "// copy() functions\n")
-	for _, name := range namedTypes {
-		o := scope.Lookup(name)
-		st, isEmbedded := getTypeStruct(o.Type(), scope)
-		if isEmbedded {
-			continue
-		}
-		fmt.Fprintf(b, "func (rr *%s) copy() RR {\n", name)
-		fields := []string{"rr.Hdr"}
-		for i := 1; i < st.NumFields(); i++ {
-			f := st.Field(i).Name()
-			if sl, ok := st.Field(i).Type().(*types.Slice); ok {
-				t := sl.Underlying().String()
-				t = strings.TrimPrefix(t, "[]")
-				if strings.Contains(t, ".") {
-					splits := strings.Split(t, ".")
-					t = splits[len(splits)-1]
-				}
-				fmt.Fprintf(b, "%s := make([]%s, len(rr.%s)); copy(%s, rr.%s)\n",
-					f, t, f, f, f)
-				fields = append(fields, f)
-				continue
-			}
-			if st.Field(i).Type().String() == "net.IP" {
-				fields = append(fields, "copyIP(rr."+f+")")
-				continue
-			}
-			fields = append(fields, "rr."+f)
-		}
-		fmt.Fprintf(b, "return &%s{%s}\n", name, strings.Join(fields, ","))
-		fmt.Fprintf(b, "}\n")
-	}
-
-	// gofmt
-	res, err := format.Source(b.Bytes())
-	if err != nil {
-		b.WriteTo(os.Stderr)
-		log.Fatal(err)
-	}
-
-	// write result
-	f, err := os.Create("ztypes.go")
-	fatalIfErr(err)
-	defer f.Close()
-	f.Write(res)
-}
-
-func fatalIfErr(err error) {
-	if err != nil {
-		log.Fatal(err)
-	}
-}

vendor/github.com/milosgajdos83/tenus/.gitignore

+.vagrant

vendor/github.com/milosgajdos83/tenus/README.md

+# Linux networking in Golang
+
+[![GoDoc](https://godoc.org/github.com/milosgajdos83/tenus?status.svg)](https://godoc.org/github.com/milosgajdos83/tenus)
+[![License](https://img.shields.io/:license-apache-blue.svg)](https://opensource.org/licenses/Apache-2.0)
+
+**tenus** is a [Golang](http://golang.org/) package which allows you to configure and manage Linux network devices programmatically. It communicates with Linux Kernel via [netlink](http://man7.org/linux/man-pages/man7/netlink.7.html) to facilitate creation and configuration of network devices on the Linux host. The package also allows for more advanced network setups with Linux containers including [Docker](https://github.com/dotcloud/docker/).
+
+**tenus** uses [runc](https://github.com/opencontainers/runc)'s implementation of **netlink** protocol. The package only works with newer Linux Kernels (3.10+) which are shipping reasonably new `netlink` protocol implementation, so **if you are running older kernel this package won't be of much use to you** I'm afraid. I have developed this package on Ubuntu [Trusty Tahr](http://releases.ubuntu.com/14.04/) which ships with 3.13+ and verified its functionality on [Precise Pangolin](http://releases.ubuntu.com/12.04/) with upgraded kernel to version 3.10. I could worked around the `netlink` issues by using `ioctl` syscalls, but I decided to prefer "pure netlink" implementation, so suck it old Kernels.
+
+At the moment only functional tests are available, but the interface design should hopefully allow for easy (ish) unit testing in the future. I do appreciate that the package's **test coverage is not great at the moment**, but the core functionality should be covered. I would massively welcome PRs.
+
+## Get started
+
+There is a ```Vagrantfile``` available in the repo so using [vagrant](https://github.com/mitchellh/vagrant) is the easiest way to get started:
+
+```bash
+milosgajdos@bimbonet ~ $ git clone https://github.com/milosgajdos83/tenus.git
+milosgajdos@bimbonet ~ $ vagrant up
+
+```
+
+**Note** using the provided ```Vagrantfile``` will take quite a long time to spin the VM as vagrant will setup Ubuntu Trusty VM with all the prerequisities:
+
+* it will install golang and docker onto the VM
+* it will export ```GOPATH``` and ```go get``` the **tenus** package onto the VM
+* it will also "**pull**" Docker ubuntu image so that you can run the tests once the VM is set up
+
+At the moment running the tests require Docker to be installed, but in the future I'd love to separate tests per interface so that you can run only chosen test sets.
+
+Once the VM is running, ```cd``` into particular repo directory and you can run the tests:
+
+```bash
+milosgajdos@bimbonet ~ $ cd $GOPATH/src/github.com/milosgajdos83/tenus
+milosgajdos@bimbonet ~ $ sudo go test
+```
+
+If you don't want to use the provided ```Vagrantfile```, you can simply run your own Linux VM (with 3.10+ kernel) and follow the regular golang development flow:
+
+```bash
+milosgajdos@bimbonet ~ $ go get github.com/milosgajdos83/tenus
+milosgajdos@bimbonet ~ $ cd $GOPATH/src/github.com/milosgajdos83/tenus
+milosgajdos@bimbonet ~ $ sudo go test
+```
+
+Once you've got the package and ran the tests (you don't need to run the tests!), you can start hacking. Below you can find simple code samples to get started with the package.
+
+## Examples
+
+Below you can find a few code snippets which can help you get started writing your own programs.
+
+### New network bridge, add dummy link into it
+
+The example below shows a simple program example which creates a new network bridge, a new dummy network link and adds it into the bridge.
+
+```go
+package main
+
+import (
+	"fmt"
+	"log"
+
+	"github.com/milosgajdos83/tenus"
+)
+
+func main() {
+	// Create a new network bridge
+	br, err := tenus.NewBridgeWithName("mybridge")
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	// Bring the bridge up
+	if err = br.SetLinkUp(); err != nil {
+		fmt.Println(err)
+	}
+
+	// Create a dummy link
+	dl, err := tenus.NewLink("mydummylink")
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	// Add the dummy link into bridge
+	if err = br.AddSlaveIfc(dl.NetInterface()); err != nil {
+		log.Fatal(err)
+	}
+
+	// Bring the dummy link up
+	if err = dl.SetLinkUp(); err != nil {
+		fmt.Println(err)
+	}
+}
+```
+
+### New network bridge, veth pair, one peer in Docker
+
+The example below shows how you can create a new network bride, configure its IP address, add a new veth pair and send one of the veth peers into Docker with a given name.
+
+**!! You must make sure that particular Docker is runnig if you want the code sample below to work properly !!** So before you compile and run the program below you should create a particular docker with the below used name:
+
+```bash
+milosgajdos@bimbonet ~ $ docker run -i -t --rm --privileged -h vethdckr --name vethdckr ubuntu:14.04 /bin/bash
+```
+
+```go
+package main
+
+import (
+	"fmt"
+	"log"
+	"net"
+
+	"github.com/milosgajdos83/tenus"
+)
+
+func main() {
+	// CREATE BRIDGE AND BRING IT UP
+	br, err := tenus.NewBridgeWithName("vethbridge")
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	brIp, brIpNet, err := net.ParseCIDR("10.0.41.1/16")
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	if err := br.SetLinkIp(brIp, brIpNet); err != nil {
+		fmt.Println(err)
+	}
+
+	if err = br.SetLinkUp(); err != nil {
+		fmt.Println(err)
+	}
+
+	// CREATE VETH PAIR
+	veth, err := tenus.NewVethPairWithOptions("myveth01", tenus.VethOptions{PeerName: "myveth02"})
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	// ASSIGN IP ADDRESS TO THE HOST VETH INTERFACE
+	vethHostIp, vethHostIpNet, err := net.ParseCIDR("10.0.41.2/16")
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	if err := veth.SetLinkIp(vethHostIp, vethHostIpNet); err != nil {
+		fmt.Println(err)
+	}
+
+	// ADD MYVETH01 INTERFACE TO THE MYBRIDGE BRIDGE
+	myveth01, err := net.InterfaceByName("myveth01")
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	if err = br.AddSlaveIfc(myveth01); err != nil {
+		fmt.Println(err)
+	}
+
+	if err = veth.SetLinkUp(); err != nil {
+		fmt.Println(err)
+	}
+
+	// PASS VETH PEER INTERFACE TO A RUNNING DOCKER BY PID
+	pid, err := tenus.DockerPidByName("vethdckr", "/var/run/docker.sock")
+	if err != nil {
+		fmt.Println(err)
+	}
+
+	if err := veth.SetPeerLinkNsPid(pid); err != nil {
+		log.Fatal(err)
+	}
+
+	// ALLOCATE AND SET IP FOR THE NEW DOCKER INTERFACE
+	vethGuestIp, vethGuestIpNet, err := net.ParseCIDR("10.0.41.5/16")
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	if err := veth.SetPeerLinkNetInNs(pid, vethGuestIp, vethGuestIpNet, nil); err != nil {
+		log.Fatal(err)
+	}
+}
+```
+
+### Working with existing bridges and interfaces
+
+The following examples show how to retrieve exisiting interfaces as a tenus link and bridge
+
+```go
+package main
+
+import (
+	"fmt"
+	"log"
+	"net"
+
+	"github.com/milosgajdos83/tenus"
+)
+
+func main() {
+	// RETRIEVE EXISTING BRIDGE
+	br, err := tenus.BridgeFromName("bridge0")
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	// REMOVING AN IP FROM A BRIDGE INTERFACE (BEFORE RECONFIGURATION)
+	brIp, brIpNet, err := net.ParseCIDR("10.0.41.1/16")
+	if err != nil {
+		log.Fatal(err)
+	}
+	if err := br.UnsetLinkIp(brIp, brIpNet); err != nil {
+		log.Fatal(err)
+	}
+
+	// RETRIEVE EXISTING INTERFACE
+	dl, err := tenus.NewLinkFrom("eth0")
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	// RENAMING AN INTERFACE BY NAME
+	if err := tenus.RenameInterfaceByName("vethPSQSEl", "vethNEWNAME"); err != nil {
+		log.Fatal(err)
+	}
+
+}
+```
+
+### VLAN and MAC VLAN interfaces
+
+You can check out [VLAN](https://gist.github.com/milosgajdos83/9f68b1818dca886e9ae8) and [Mac VLAN](https://gist.github.com/milosgajdos83/296fb90d076f259a5b0a) examples, too.
+
+### More examples
+
+Repo contains few more code sample in ```examples``` folder so make sure to check them out if you're interested.
+
+## TODO
+
+This is just a rough beginning of the project which I put together over couple of weeks in my free time. I'd like to integrate this into my own Docker fork and test the advanced netowrking functionality with the core of Docker as oppose to configuring network interfaces from a separate golang program, because advanced networking in Docker was the main motivation for writing this package.
+
+## Documentation
+
+More in depth package documentation is available via [godoc](http://godoc.org/github.com/milosgajdos83/tenus)

vendor/github.com/milosgajdos83/tenus/Vagrantfile

+# -*- mode: ruby -*-
+# vi: set ft=ruby :
+
+$provision = <<SCRIPT
+apt-get update -qq && apt-get install -y vim curl python-software-properties golang 
+add-apt-repository -y "deb https://get.docker.io/ubuntu docker main"
+curl -s https://get.docker.io/gpg | sudo apt-key add -
+apt-get update -qq; apt-get install -y lxc-docker
+docker pull ubuntu
+cat > /etc/profile.d/envvar.sh <<'EOF'
+export GOPATH=/opt/golang
+export PATH=$PATH:$GOPATH/bin
+EOF
+. /etc/profile.d/envvar.sh
+go get "github.com/milosgajdos83/tenus"
+SCRIPT
+
+VAGRANTFILE_API_VERSION = "2"
+
+Vagrant.configure(VAGRANTFILE_API_VERSION) do |config|
+  config.vm.box = "ubuntu/trusty64"
+  config.vm.hostname = "tenus"
+  config.vm.network :private_network, ip: "10.0.2.88"
+  config.vm.network :private_network, ip: "10.0.2.89"
+
+  config.vm.provider "virtualbox" do |v|
+    v.customize ['modifyvm', :id, '--nicpromisc1', 'allow-all']
+  end
+
+  config.vm.provision "shell", inline: $provision
+end

vendor/github.com/milosgajdos83/tenus/bridge_linux.go

+package tenus
+
+import (
+	"bytes"
+	"fmt"
+	"net"
+
+	"github.com/docker/libcontainer/netlink"
+)
+
+// Bridger embeds Linker interface and adds one extra function.
+type Bridger interface {
+	// Linker interface
+	Linker
+	// AddSlaveIfc adds network interface to the network bridge
+	AddSlaveIfc(*net.Interface) error
+	//RemoveSlaveIfc removes network interface from the network bridge
+	RemoveSlaveIfc(*net.Interface) error
+}
+
+// Bridge is Link which has zero or more slave network interfaces.
+// Bridge implements Bridger interface.
+type Bridge struct {
+	Link
+	slaveIfcs []net.Interface
+}
+
+// NewBridge creates new network bridge on Linux host.
+//
+// It is equivalent of running: ip link add name br${RANDOM STRING} type bridge
+// NewBridge returns Bridger which is initialized to a pointer of type Bridge if the
+// bridge was created successfully on the Linux host. Newly created bridge is assigned
+// a random name starting with "br".
+// It returns error if the bridge could not be created.
+func NewBridge() (Bridger, error) {
+	brDev := makeNetInterfaceName("br")
+
+	if ok, err := NetInterfaceNameValid(brDev); !ok {
+		return nil, err
+	}
+
+	if _, err := net.InterfaceByName(brDev); err == nil {
+		return nil, fmt.Errorf("Interface name %s already assigned on the host", brDev)
+	}
+
+	if err := netlink.NetworkLinkAdd(brDev, "bridge"); err != nil {
+		return nil, err
+	}
+
+	newIfc, err := net.InterfaceByName(brDev)
+	if err != nil {
+		return nil, fmt.Errorf("Could not find the new interface: %s", err)
+	}
+
+	return &Bridge{
+		Link: Link{
+			ifc: newIfc,
+		},
+	}, nil
+}
+
+// NewBridge creates new network bridge on Linux host with the name passed as a parameter.
+// It is equivalent of running: ip link add name ${ifcName} type bridge
+// It returns error if the bridge can not be created.
+func NewBridgeWithName(ifcName string) (Bridger, error) {
+	if ok, err := NetInterfaceNameValid(ifcName); !ok {
+		return nil, err
+	}
+
+	if _, err := net.InterfaceByName(ifcName); err == nil {
+		return nil, fmt.Errorf("Interface name %s already assigned on the host", ifcName)
+	}
+
+	if err := netlink.NetworkLinkAdd(ifcName, "bridge"); err != nil {
+		return nil, err
+	}
+
+	newIfc, err := net.InterfaceByName(ifcName)
+	if err != nil {
+		return nil, fmt.Errorf("Could not find the new interface: %s", err)
+	}
+
+	return &Bridge{
+		Link: Link{
+			ifc: newIfc,
+		},
+	}, nil
+}
+
+// BridgeFromName returns a tenus network bridge from an existing bridge of given name on the Linux host.
+// It returns error if the bridge of the given name cannot be found.
+func BridgeFromName(ifcName string) (Bridger, error) {
+	if ok, err := NetInterfaceNameValid(ifcName); !ok {
+		return nil, err
+	}
+
+	newIfc, err := net.InterfaceByName(ifcName)
+	if err != nil {
+		return nil, fmt.Errorf("Could not find the new interface: %s", err)
+	}
+
+	return &Bridge{
+		Link: Link{
+			ifc: newIfc,
+		},
+	}, nil
+}
+
+// AddToBridge adds network interfaces to network bridge.
+// It is equivalent of running: ip link set ${netIfc name} master ${netBridge name}
+// It returns error when it fails to add the network interface to bridge.
+func AddToBridge(netIfc, netBridge *net.Interface) error {
+	return netlink.NetworkSetMaster(netIfc, netBridge)
+}
+
+// AddToBridge adds network interfaces to network bridge.
+// It is equivalent of running: ip link set dev ${netIfc name} nomaster
+// It returns error when it fails to remove the network interface from the bridge.
+func RemoveFromBridge(netIfc *net.Interface) error {
+	return netlink.NetworkSetNoMaster(netIfc)
+}
+
+// AddSlaveIfc adds network interface to network bridge.
+// It is equivalent of running: ip link set ${ifc name} master ${bridge name}
+// It returns error if the network interface could not be added to the bridge.
+func (br *Bridge) AddSlaveIfc(ifc *net.Interface) error {
+	if err := netlink.NetworkSetMaster(ifc, br.ifc); err != nil {
+		return err
+	}
+
+	br.slaveIfcs = append(br.slaveIfcs, *ifc)
+
+	return nil
+}
+
+// RemoveSlaveIfc removes network interface from the network bridge.
+// It is equivalent of running: ip link set dev ${netIfc name} nomaster
+// It returns error if the network interface is not in the bridge or
+// it could not be removed from the bridge.
+func (br *Bridge) RemoveSlaveIfc(ifc *net.Interface) error {
+	if err := netlink.NetworkSetNoMaster(ifc); err != nil {
+		return err
+	}
+
+	for index, i := range br.slaveIfcs {
+		// I could reflect.DeepEqual(), but there is not point to import reflect for one operation
+		if i.Name == ifc.Name && bytes.Equal(i.HardwareAddr, ifc.HardwareAddr) {
+			br.slaveIfcs = append(br.slaveIfcs[:index], br.slaveIfcs[index+1:]...)
+		}
+	}
+
+	return nil
+}

vendor/github.com/milosgajdos83/tenus/doc.go

+// Package tenus allows to configure and manage Linux network devices programmatically.
+//
+// You can create, configure and manage various advanced Linux network setups directly from your Go code.
+// tenus also allows you to configure advanced network setups with Linux containers including Docker.
+// It leverages Linux Kernenl's netlink facility and exposes easier to work with programming API than
+// the one provided by netlink.
+//
+// Actual implementations are in:
+// link_linux.go, bridge_linux.go, veth_linux.go, vlan_linux.go and macvlan_linux.go
+package tenus

vendor/github.com/milosgajdos83/tenus/helpers_linux.go

+package tenus
+
+import (
+	"bytes"
+	"crypto/rand"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"net"
+	"net/http"
+	"os"
+	"path"
+	"path/filepath"
+	"strconv"
+	"syscall"
+	"time"
+	"unicode"
+
+	"github.com/docker/libcontainer/netlink"
+	"github.com/docker/libcontainer/system"
+)
+
+// generates random string for makeNetInterfaceName()
+func randomString(size int) string {
+	alphanum := "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"
+	bytes := make([]byte, size)
+	rand.Read(bytes)
+
+	for i, b := range bytes {
+		bytes[i] = alphanum[b%byte(len(alphanum))]
+	}
+
+	return string(bytes)
+}
+
+func MakeNetInterfaceName(base string) string {
+	return makeNetInterfaceName(base)
+}
+
+// generates new unused network interfaces name with given prefix
+func makeNetInterfaceName(base string) string {
+	for {
+		name := base + randomString(6)
+		if _, err := net.InterfaceByName(name); err == nil {
+			continue
+		}
+
+		return name
+	}
+}
+
+// validates MTU LinkOption
+func validMtu(mtu int) error {
+	if mtu < 0 {
+		return errors.New("MTU must be a positive integer!")
+	}
+
+	return nil
+}
+
+// validates MacAddress LinkOption
+func validMacAddress(macaddr string) error {
+	if _, err := net.ParseMAC(macaddr); err != nil {
+		return fmt.Errorf("Can not parse MAC address: %s", err)
+	}
+
+	if _, err := FindInterfaceByMacAddress(macaddr); err == nil {
+		return fmt.Errorf("MAC Address already assigned on the host: %s", macaddr)
+	}
+
+	return nil
+}
+
+// validates MacAddress LinkOption
+func validNs(ns int) error {
+	if ns < 0 {
+		return fmt.Errorf("Incorrect Network Namespace PID specified: %d", ns)
+	}
+
+	return nil
+}
+
+// validates Flags LinkOption
+func validFlags(flags net.Flags) error {
+	if (flags & syscall.IFF_UP) != syscall.IFF_UP {
+		return fmt.Errorf("Unsupported network flags specified: %v", flags)
+	}
+
+	return nil
+}
+
+// NetInterfaceNameValid checks if the network interface name is valid.
+// It accepts interface name as a string. It returns error if invalid interface name is supplied.
+func NetInterfaceNameValid(name string) (bool, error) {
+	if name == "" {
+		return false, errors.New("Interface name can not be empty")
+	}
+
+	if len(name) == 1 {
+		return false, fmt.Errorf("Interface name too short: %s", name)
+	}
+
+	if len(name) > netlink.IFNAMSIZ {
+		return false, fmt.Errorf("Interface name too long: %s", name)
+	}
+
+	for _, char := range name {
+		if unicode.IsSpace(char) || char > 0x7F {
+			return false, fmt.Errorf("Invalid characters in interface name: %s", name)
+		}
+	}
+
+	return true, nil
+}
+
+// FindInterfaceByMacAddress returns *net.Interface which has a given MAC address assigned.
+// It returns nil and error if invalid MAC address is supplied or if there is no network interface
+// with the given MAC address assigned on Linux host.
+func FindInterfaceByMacAddress(macaddr string) (*net.Interface, error) {
+	if macaddr == "" {
+		return nil, errors.New("Empty MAC address specified!")
+	}
+
+	ifcs, err := net.Interfaces()
+	if err != nil {
+		return nil, err
+	}
+
+	hwaddr, err := net.ParseMAC(macaddr)
+	if err != nil {
+		return nil, err
+	}
+
+	for _, ifc := range ifcs {
+		if bytes.Equal(hwaddr, ifc.HardwareAddr) {
+			return &ifc, nil
+		}
+	}
+
+	return nil, fmt.Errorf("Could not find interface with MAC address on the host: %s", macaddr)
+}
+
+// DockerPidByName returns PID of the running docker container.
+// It accepts Docker container name and Docker host as parameters and queries Docker API via HTTP.
+// Docker host passed as an argument can be either full path to Docker UNIX socket or HOST:PORT address string.
+// It returns error if Docker container can not be found or if an error occurs when querying Docker API.
+func DockerPidByName(name string, dockerHost string) (int, error) {
+	var network string
+
+	if name == "" {
+		return 0, errors.New("Docker name can not be empty!")
+	}
+
+	if dockerHost == "" {
+		return 0, errors.New("Docker host can not be empty!")
+	}
+
+	if filepath.IsAbs(dockerHost) {
+		network = "unix"
+	} else {
+		network = "tcp"
+	}
+
+	req, err := http.NewRequest("GET", "http://docker.socket/containers/"+name+"/json", nil)
+	if err != nil {
+		return 0, fmt.Errorf("Fail to create http request: %s", err)
+	}
+
+	timeout := time.Duration(2 * time.Second)
+	httpTransport := &http.Transport{
+		Dial: func(proto string, addr string) (net.Conn, error) {
+			return net.DialTimeout(network, dockerHost, timeout)
+		},
+	}
+
+	dockerClient := http.Client{Transport: httpTransport}
+
+	resp, err := dockerClient.Do(req)
+	if err != nil {
+		return 0, fmt.Errorf("Failed to create http client: %s", err)
+	}
+
+	switch resp.StatusCode {
+	case http.StatusNotFound:
+		return 0, fmt.Errorf("Docker container \"%s\" does not seem to exist!", name)
+	case http.StatusInternalServerError:
+		return 0, fmt.Errorf("Could not retrieve Docker %s pid due to Docker server error", name)
+	}
+
+	data := struct {
+		State struct {
+			Pid float64
+		}
+	}{}
+
+	err = json.NewDecoder(resp.Body).Decode(&data)
+	if err != nil {
+		return 0, fmt.Errorf("Unable to decode json response: %s", err)
+	}
+
+	return int(data.State.Pid), nil
+}
+
+// NetNsHandle returns a file descriptor handle for network namespace specified by PID.
+// It returns error if network namespace could not be found or if network namespace path could not be opened.
+func NetNsHandle(nspid int) (uintptr, error) {
+	if nspid <= 0 || nspid == 1 {
+		return 0, fmt.Errorf("Incorred PID specified: %d", nspid)
+	}
+
+	nsPath := path.Join("/", "proc", strconv.Itoa(nspid), "ns/net")
+	if nsPath == "" {
+		return 0, fmt.Errorf("Could not find Network namespace for pid: %d", nspid)
+	}
+
+	file, err := os.Open(nsPath)
+	if err != nil {
+		return 0, fmt.Errorf("Could not open Network Namespace: %s", err)
+	}
+
+	return file.Fd(), nil
+}
+
+// SetNetNsToPid sets network namespace to the one specied by PID.
+// It returns error if the network namespace could not be set.
+func SetNetNsToPid(nspid int) error {
+	if nspid <= 0 || nspid == 1 {
+		return fmt.Errorf("Incorred PID specified: %d", nspid)
+	}
+
+	nsFd, err := NetNsHandle(nspid)
+	defer syscall.Close(int(nsFd))
+	if err != nil {
+		return fmt.Errorf("Could not get network namespace handle: %s", err)
+	}
+
+	if err := system.Setns(nsFd, syscall.CLONE_NEWNET); err != nil {
+		return fmt.Errorf("Unable to set the network namespace: %v", err)
+	}
+
+	return nil
+}

vendor/github.com/milosgajdos83/tenus/macvlan_linux.go

+package tenus
+
+import (
+	"fmt"
+	"net"
+
+	"github.com/docker/libcontainer/netlink"
+)
+
+// Default MacVlan mode
+const (
+	default_mode = "bridge"
+)
+
+// Supported macvlan modes by tenus package
+var MacVlanModes = map[string]bool{
+	"private": true,
+	"vepa":    true,
+	"bridge":  true,
+}
+
+// MacVlanOptions allows you to specify some options for macvlan link.
+type MacVlanOptions struct {
+	// macvlan device name
+	Dev string
+	// macvlan mode
+	Mode string
+	// MAC address
+	MacAddr string
+}
+
+// MacVlaner embeds Linker interface and adds few more functions.
+type MacVlaner interface {
+	// Linker interface
+	Linker
+	// MasterNetInterface returns macvlan master network device
+	MasterNetInterface() *net.Interface
+	// Mode returns macvlan link's network mode
+	Mode() string
+}
+
+// MacVlanLink is Link which has a master network device and operates in
+// a given network mode. It implements MacVlaner interface.
+type MacVlanLink struct {
+	Link
+	// Master device logical network interface
+	masterIfc *net.Interface
+	// macvlan operatio nmode
+	mode string
+}
+
+// NewMacVlanLink creates macvlan network link
+//
+// It is equivalent of running:
+//		ip link add name mc${RANDOM STRING} link ${master interface} type macvlan
+// NewMacVlanLink returns MacVlaner which is initialized to a pointer of type MacVlanLink if the
+// macvlan link was created successfully on the Linux host. Newly created link is assigned
+// a random name starting with "mc". It sets the macvlan mode to "bridge" mode which is a default.
+// It returns error if the link could not be created.
+func NewMacVlanLink(masterDev string) (MacVlaner, error) {
+	macVlanDev := makeNetInterfaceName("mc")
+
+	if ok, err := NetInterfaceNameValid(masterDev); !ok {
+		return nil, err
+	}
+
+	if _, err := net.InterfaceByName(masterDev); err != nil {
+		return nil, fmt.Errorf("Master MAC VLAN device %s does not exist on the host", masterDev)
+	}
+
+	if err := netlink.NetworkLinkAddMacVlan(masterDev, macVlanDev, default_mode); err != nil {
+		return nil, err
+	}
+
+	macVlanIfc, err := net.InterfaceByName(macVlanDev)
+	if err != nil {
+		return nil, fmt.Errorf("Could not find the new interface: %s", err)
+	}
+
+	masterIfc, err := net.InterfaceByName(masterDev)
+	if err != nil {
+		return nil, fmt.Errorf("Could not find the new interface: %s", err)
+	}
+
+	return &MacVlanLink{
+		Link: Link{
+			ifc: macVlanIfc,
+		},
+		masterIfc: masterIfc,
+		mode:      default_mode,
+	}, nil
+}
+
+// NewMacVlanLinkWithOptions creates macvlan network link and sets som of its network parameters
+// passed in as MacVlanOptions.
+//
+// It is equivalent of running:
+// 		ip link add name ${macvlan name} link ${master interface} address ${macaddress} type macvlan mode ${mode}
+// NewMacVlanLinkWithOptions returns MacVlaner which is initialized to a pointer of type MacVlanLink if the
+// macvlan link was created successfully on the Linux host. If particular option is empty, it sets default value if possible.
+// It returns error if the macvlan link could not be created or if incorrect options have been passed.
+func NewMacVlanLinkWithOptions(masterDev string, opts MacVlanOptions) (MacVlaner, error) {
+	if ok, err := NetInterfaceNameValid(masterDev); !ok {
+		return nil, err
+	}
+
+	if _, err := net.InterfaceByName(masterDev); err != nil {
+		return nil, fmt.Errorf("Master MAC VLAN device %s does not exist on the host", masterDev)
+	}
+
+	if err := validateMacVlanOptions(&opts); err != nil {
+		return nil, err
+	}
+
+	if err := netlink.NetworkLinkAddMacVlan(masterDev, opts.Dev, opts.Mode); err != nil {
+		return nil, err
+	}
+
+	macVlanIfc, err := net.InterfaceByName(opts.Dev)
+	if err != nil {
+		return nil, fmt.Errorf("Could not find the new interface: %s", err)
+	}
+
+	if opts.MacAddr != "" {
+		if err := netlink.NetworkSetMacAddress(macVlanIfc, opts.MacAddr); err != nil {
+			if errDel := DeleteLink(macVlanIfc.Name); errDel != nil {
+				return nil, fmt.Errorf("Incorrect options specified. Attempt to delete the link failed: %s", errDel)
+			}
+		}
+	}
+
+	masterIfc, err := net.InterfaceByName(masterDev)
+	if err != nil {
+		return nil, fmt.Errorf("Could not find the new interface: %s", err)
+	}
+
+	return &MacVlanLink{
+		Link: Link{
+			ifc: macVlanIfc,
+		},
+		masterIfc: masterIfc,
+		mode:      opts.Mode,
+	}, nil
+}
+
+// NetInterface returns macvlan link's network interface
+func (macvln *MacVlanLink) NetInterface() *net.Interface {
+	return macvln.ifc
+}
+
+// MasterNetInterface returns macvlan link's master network interface
+func (macvln *MacVlanLink) MasterNetInterface() *net.Interface {
+	return macvln.masterIfc
+}
+
+// Mode returns macvlan link's network operation mode
+func (macvln *MacVlanLink) Mode() string {
+	return macvln.mode
+}
+
+func validateMacVlanOptions(opts *MacVlanOptions) error {
+	if opts.Dev != "" {
+		if ok, err := NetInterfaceNameValid(opts.Dev); !ok {
+			return err
+		}
+
+		if _, err := net.InterfaceByName(opts.Dev); err == nil {
+			return fmt.Errorf("MAC VLAN device %s already assigned on the host", opts.Dev)
+		}
+	} else {
+		opts.Dev = makeNetInterfaceName("mc")
+	}
+
+	if opts.Mode != "" {
+		if _, ok := MacVlanModes[opts.Mode]; !ok {
+			return fmt.Errorf("Unsupported MacVlan mode specified: %s", opts.Mode)
+		}
+	} else {
+		opts.Mode = default_mode
+	}
+
+	if opts.MacAddr != "" {
+		if _, err := net.ParseMAC(opts.MacAddr); err != nil {
+			return fmt.Errorf("Incorrect MAC ADDRESS specified: %s", opts.MacAddr)
+		}
+	}
+
+	return nil
+}

vendor/github.com/milosgajdos83/tenus/macvtap_linux.go

+package tenus
+
+import (
+	"fmt"
+	"net"
+
+	"github.com/docker/libcontainer/netlink"
+)
+
+// MacVtaper embeds MacVlaner interface
+type MacVtaper interface {
+	MacVlaner
+}
+
+// MacVtapLink is MacVlanLink. It implements MacVtaper interface
+type MacVtapLink struct {
+	*MacVlanLink
+}
+
+// NewMacVtapLink creates macvtap network link
+//
+// It is equivalent of running:
+//		ip link add name mvt${RANDOM STRING} link ${master interface} type macvtap
+// NewMacVtapLink returns MacVtaper which is initialized to a pointer of type MacVtapLink if the
+// macvtap link was created successfully on the Linux host. Newly created link is assigned
+// a random name starting with "mvt". It sets the macvlan mode to "bridge" which is a default.
+// It returns error if the link could not be created.
+func NewMacVtapLink(masterDev string) (MacVtaper, error) {
+	macVtapDev := makeNetInterfaceName("mvt")
+
+	if ok, err := NetInterfaceNameValid(masterDev); !ok {
+		return nil, err
+	}
+
+	if _, err := net.InterfaceByName(masterDev); err != nil {
+		return nil, fmt.Errorf("Master MAC VTAP device %s does not exist on the host", masterDev)
+	}
+
+	if err := netlink.NetworkLinkAddMacVtap(masterDev, macVtapDev, default_mode); err != nil {
+		return nil, err
+	}
+
+	macVtapIfc, err := net.InterfaceByName(macVtapDev)
+	if err != nil {
+		return nil, fmt.Errorf("Could not find the new interface: %s", err)
+	}
+
+	masterIfc, err := net.InterfaceByName(masterDev)
+	if err != nil {
+		return nil, fmt.Errorf("Could not find the new interface: %s", err)
+	}
+
+	return &MacVtapLink{
+		MacVlanLink: &MacVlanLink{
+			Link: Link{
+				ifc: macVtapIfc,
+			},
+			masterIfc: masterIfc,
+			mode:      default_mode,
+		},
+	}, nil
+}
+
+// NewMacVtapLinkWithOptions creates macvtap network link and can set some of its network parameters
+// passed in as MacVlanOptions.
+//
+// It is equivalent of running:
+// 		ip link add name ${macvlan name} link ${master interface} address ${macaddress} type macvtap mode ${mode}
+// NewMacVtapLinkWithOptions returns MacVtaper which is initialized to a pointer of type MacVtapLink if the
+// macvtap link was created successfully on the Linux host. It returns error if the macvtap link could not be created.
+func NewMacVtapLinkWithOptions(masterDev string, opts MacVlanOptions) (MacVtaper, error) {
+	if ok, err := NetInterfaceNameValid(masterDev); !ok {
+		return nil, err
+	}
+
+	if _, err := net.InterfaceByName(masterDev); err != nil {
+		return nil, fmt.Errorf("Master MAC VLAN device %s does not exist on the host", masterDev)
+	}
+
+	if err := validateMacVlanOptions(&opts); err != nil {
+		return nil, err
+	}
+
+	if err := netlink.NetworkLinkAddMacVtap(masterDev, opts.Dev, opts.Mode); err != nil {
+		return nil, err
+	}
+
+	macVtapIfc, err := net.InterfaceByName(opts.Dev)
+	if err != nil {
+		return nil, fmt.Errorf("Could not find the new interface: %s", err)
+	}
+
+	if opts.MacAddr != "" {
+		if err := netlink.NetworkSetMacAddress(macVtapIfc, opts.MacAddr); err != nil {
+			if errDel := DeleteLink(macVtapIfc.Name); errDel != nil {
+				return nil, fmt.Errorf("Incorrect options specified. Attempt to delete the link failed: %s",
+					errDel)
+			}
+		}
+	}
+
+	masterIfc, err := net.InterfaceByName(masterDev)
+	if err != nil {
+		return nil, fmt.Errorf("Could not find the new interface: %s", err)
+	}
+
+	return &MacVtapLink{
+		MacVlanLink: &MacVlanLink{
+			Link: Link{
+				ifc: macVtapIfc,
+			},
+			masterIfc: masterIfc,
+			mode:      opts.Mode,
+		},
+	}, nil
+}

vendor/github.com/milosgajdos83/tenus/network.go

+package tenus
+
+import (
+	"github.com/docker/libcontainer/netlink"
+)
+
+type NetworkOptions struct {
+	IpAddr string
+	Gw     string
+	Routes []netlink.Route
+}

vendor/github.com/songgao/water/.gitignore

+water.test
+water.test.exe

vendor/github.com/songgao/water/.travis.yml

+language: go
+go:
+  - "1.12.1"
+  - "1.10.8"
+go_import_path: github.com/songgao/water
+install: go get -u golang.org/x/lint/golint
+script: make ci
+
+matrix:
+  include:
+    - os: linux
+      dist: xenial
+    - os: osx

vendor/github.com/songgao/water/CONTRIBUTORS

+Song Gao <song@gao.io>
+Harshal Sheth <hsheth2@gmail.com>
+KOJIMA Takanori <tkojima@accense.com>
+Sean Purser-Haskell <sean.purserhaskell@gmail.com>
+daregod <daregod@yandex.ru>
+Lucus Lee <lixin9311@gmail.com>
+Arroyo Networks, LLC <open.source@arroyonetworks.com>
+Tony Lu <tonyluj@gmail.com>
+ajee cai <ajee.cai@gmail.com>
+yinheli <hi@yinheli.com>
+Paul Querna <pquerna@apache.org>
+Cuong Manh Le <cuong.manhle.vn@gmail.com>
+Neil Alexander <neilalexander@users.noreply.github.com>
+Dmitry Shihovtsev <soffokulus@gmail.com>
+Yifan Gu [https://github.com/gyf304]

vendor/github.com/songgao/water/doc.go

+// Package water is a simple TUN/TAP interface library that efficiently works
+// with standard packages like io, bufio, etc.. Use waterutil with it to work
+// with TUN/TAP packets/frames.
+package water

vendor/github.com/songgao/water/params_others.go

+// +build !linux,!darwin,!windows
+
+package water
+
+// PlatformSpeficParams
+type PlatformSpecificParams struct {
+}
+
+func defaultPlatformSpecificParams() PlatformSpecificParams {
+	return PlatformSpecificParams{}
+}