Removed unnecessary code from vendor directory

vendor/golang.org/x/net/bpf/asm.go

@@ -1,41 +0,0 @@
-// Copyright 2016 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package bpf
-
-import "fmt"
-
-// Assemble converts insts into raw instructions suitable for loading
-// into a BPF virtual machine.
-//
-// Currently, no optimization is attempted, the assembled program flow
-// is exactly as provided.
-func Assemble(insts []Instruction) ([]RawInstruction, error) {
-	ret := make([]RawInstruction, len(insts))
-	var err error
-	for i, inst := range insts {
-		ret[i], err = inst.Assemble()
-		if err != nil {
-			return nil, fmt.Errorf("assembling instruction %d: %s", i+1, err)
-		}
-	}
-	return ret, nil
-}
-
-// Disassemble attempts to parse raw back into
-// Instructions. Unrecognized RawInstructions are assumed to be an
-// extension not implemented by this package, and are passed through
-// unchanged to the output. The allDecoded value reports whether insts
-// contains no RawInstructions.
-func Disassemble(raw []RawInstruction) (insts []Instruction, allDecoded bool) {
-	insts = make([]Instruction, len(raw))
-	allDecoded = true
-	for i, r := range raw {
-		insts[i] = r.Disassemble()
-		if _, ok := insts[i].(RawInstruction); ok {
-			allDecoded = false
-		}
-	}
-	return insts, allDecoded
-}

vendor/golang.org/x/net/bpf/constants.go

@@ -1,218 +0,0 @@
-// Copyright 2016 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package bpf
-
-// A Register is a register of the BPF virtual machine.
-type Register uint16
-
-const (
-	// RegA is the accumulator register. RegA is always the
-	// destination register of ALU operations.
-	RegA Register = iota
-	// RegX is the indirection register, used by LoadIndirect
-	// operations.
-	RegX
-)
-
-// An ALUOp is an arithmetic or logic operation.
-type ALUOp uint16
-
-// ALU binary operation types.
-const (
-	ALUOpAdd ALUOp = iota << 4
-	ALUOpSub
-	ALUOpMul
-	ALUOpDiv
-	ALUOpOr
-	ALUOpAnd
-	ALUOpShiftLeft
-	ALUOpShiftRight
-	aluOpNeg // Not exported because it's the only unary ALU operation, and gets its own instruction type.
-	ALUOpMod
-	ALUOpXor
-)
-
-// A JumpTest is a comparison operator used in conditional jumps.
-type JumpTest uint16
-
-// Supported operators for conditional jumps.
-const (
-	// K == A
-	JumpEqual JumpTest = iota
-	// K != A
-	JumpNotEqual
-	// K > A
-	JumpGreaterThan
-	// K < A
-	JumpLessThan
-	// K >= A
-	JumpGreaterOrEqual
-	// K <= A
-	JumpLessOrEqual
-	// K & A != 0
-	JumpBitsSet
-	// K & A == 0
-	JumpBitsNotSet
-)
-
-// An Extension is a function call provided by the kernel that
-// performs advanced operations that are expensive or impossible
-// within the BPF virtual machine.
-//
-// Extensions are only implemented by the Linux kernel.
-//
-// TODO: should we prune this list? Some of these extensions seem
-// either broken or near-impossible to use correctly, whereas other
-// (len, random, ifindex) are quite useful.
-type Extension int
-
-// Extension functions available in the Linux kernel.
-const (
-	// extOffset is the negative maximum number of instructions used
-	// to load instructions by overloading the K argument.
-	extOffset = -0x1000
-	// ExtLen returns the length of the packet.
-	ExtLen Extension = 1
-	// ExtProto returns the packet's L3 protocol type.
-	ExtProto Extension = 0
-	// ExtType returns the packet's type (skb->pkt_type in the kernel)
-	//
-	// TODO: better documentation. How nice an API do we want to
-	// provide for these esoteric extensions?
-	ExtType Extension = 4
-	// ExtPayloadOffset returns the offset of the packet payload, or
-	// the first protocol header that the kernel does not know how to
-	// parse.
-	ExtPayloadOffset Extension = 52
-	// ExtInterfaceIndex returns the index of the interface on which
-	// the packet was received.
-	ExtInterfaceIndex Extension = 8
-	// ExtNetlinkAttr returns the netlink attribute of type X at
-	// offset A.
-	ExtNetlinkAttr Extension = 12
-	// ExtNetlinkAttrNested returns the nested netlink attribute of
-	// type X at offset A.
-	ExtNetlinkAttrNested Extension = 16
-	// ExtMark returns the packet's mark value.
-	ExtMark Extension = 20
-	// ExtQueue returns the packet's assigned hardware queue.
-	ExtQueue Extension = 24
-	// ExtLinkLayerType returns the packet's hardware address type
-	// (e.g. Ethernet, Infiniband).
-	ExtLinkLayerType Extension = 28
-	// ExtRXHash returns the packets receive hash.
-	//
-	// TODO: figure out what this rxhash actually is.
-	ExtRXHash Extension = 32
-	// ExtCPUID returns the ID of the CPU processing the current
-	// packet.
-	ExtCPUID Extension = 36
-	// ExtVLANTag returns the packet's VLAN tag.
-	ExtVLANTag Extension = 44
-	// ExtVLANTagPresent returns non-zero if the packet has a VLAN
-	// tag.
-	//
-	// TODO: I think this might be a lie: it reads bit 0x1000 of the
-	// VLAN header, which changed meaning in recent revisions of the
-	// spec - this extension may now return meaningless information.
-	ExtVLANTagPresent Extension = 48
-	// ExtVLANProto returns 0x8100 if the frame has a VLAN header,
-	// 0x88a8 if the frame has a "Q-in-Q" double VLAN header, or some
-	// other value if no VLAN information is present.
-	ExtVLANProto Extension = 60
-	// ExtRand returns a uniformly random uint32.
-	ExtRand Extension = 56
-)
-
-// The following gives names to various bit patterns used in opcode construction.
-
-const (
-	opMaskCls uint16 = 0x7
-	// opClsLoad masks
-	opMaskLoadDest  = 0x01
-	opMaskLoadWidth = 0x18
-	opMaskLoadMode  = 0xe0
-	// opClsALU
-	opMaskOperandSrc = 0x08
-	opMaskOperator   = 0xf0
-	// opClsJump
-	opMaskJumpConst = 0x0f
-	opMaskJumpCond  = 0xf0
-)
-
-const (
-	// +---------------+-----------------+---+---+---+
-	// | AddrMode (3b) | LoadWidth (2b)  | 0 | 0 | 0 |
-	// +---------------+-----------------+---+---+---+
-	opClsLoadA uint16 = iota
-	// +---------------+-----------------+---+---+---+
-	// | AddrMode (3b) | LoadWidth (2b)  | 0 | 0 | 1 |
-	// +---------------+-----------------+---+---+---+
-	opClsLoadX
-	// +---+---+---+---+---+---+---+---+
-	// | 0 | 0 | 0 | 0 | 0 | 0 | 1 | 0 |
-	// +---+---+---+---+---+---+---+---+
-	opClsStoreA
-	// +---+---+---+---+---+---+---+---+
-	// | 0 | 0 | 0 | 0 | 0 | 0 | 1 | 1 |
-	// +---+---+---+---+---+---+---+---+
-	opClsStoreX
-	// +---------------+-----------------+---+---+---+
-	// | Operator (4b) | OperandSrc (1b) | 1 | 0 | 0 |
-	// +---------------+-----------------+---+---+---+
-	opClsALU
-	// +-----------------------------+---+---+---+---+
-	// |      TestOperator (4b)      | 0 | 1 | 0 | 1 |
-	// +-----------------------------+---+---+---+---+
-	opClsJump
-	// +---+-------------------------+---+---+---+---+
-	// | 0 | 0 | 0 |   RetSrc (1b)   | 0 | 1 | 1 | 0 |
-	// +---+-------------------------+---+---+---+---+
-	opClsReturn
-	// +---+-------------------------+---+---+---+---+
-	// | 0 | 0 | 0 |  TXAorTAX (1b)  | 0 | 1 | 1 | 1 |
-	// +---+-------------------------+---+---+---+---+
-	opClsMisc
-)
-
-const (
-	opAddrModeImmediate uint16 = iota << 5
-	opAddrModeAbsolute
-	opAddrModeIndirect
-	opAddrModeScratch
-	opAddrModePacketLen // actually an extension, not an addressing mode.
-	opAddrModeMemShift
-)
-
-const (
-	opLoadWidth4 uint16 = iota << 3
-	opLoadWidth2
-	opLoadWidth1
-)
-
-// Operator defined by ALUOp*
-
-const (
-	opALUSrcConstant uint16 = iota << 3
-	opALUSrcX
-)
-
-const (
-	opJumpAlways = iota << 4
-	opJumpEqual
-	opJumpGT
-	opJumpGE
-	opJumpSet
-)
-
-const (
-	opRetSrcConstant uint16 = iota << 4
-	opRetSrcA
-)
-
-const (
-	opMiscTAX = 0x00
-	opMiscTXA = 0x80
-)

vendor/golang.org/x/net/bpf/doc.go

@@ -1,82 +0,0 @@
-// Copyright 2016 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-/*
-
-Package bpf implements marshaling and unmarshaling of programs for the
-Berkeley Packet Filter virtual machine, and provides a Go implementation
-of the virtual machine.
-
-BPF's main use is to specify a packet filter for network taps, so that
-the kernel doesn't have to expensively copy every packet it sees to
-userspace. However, it's been repurposed to other areas where running
-user code in-kernel is needed. For example, Linux's seccomp uses BPF
-to apply security policies to system calls. For simplicity, this
-documentation refers only to packets, but other uses of BPF have their
-own data payloads.
-
-BPF programs run in a restricted virtual machine. It has almost no
-access to kernel functions, and while conditional branches are
-allowed, they can only jump forwards, to guarantee that there are no
-infinite loops.
-
-The virtual machine
-
-The BPF VM is an accumulator machine. Its main register, called
-register A, is an implicit source and destination in all arithmetic
-and logic operations. The machine also has 16 scratch registers for
-temporary storage, and an indirection register (register X) for
-indirect memory access. All registers are 32 bits wide.
-
-Each run of a BPF program is given one packet, which is placed in the
-VM's read-only "main memory". LoadAbsolute and LoadIndirect
-instructions can fetch up to 32 bits at a time into register A for
-examination.
-
-The goal of a BPF program is to produce and return a verdict (uint32),
-which tells the kernel what to do with the packet. In the context of
-packet filtering, the returned value is the number of bytes of the
-packet to forward to userspace, or 0 to ignore the packet. Other
-contexts like seccomp define their own return values.
-
-In order to simplify programs, attempts to read past the end of the
-packet terminate the program execution with a verdict of 0 (ignore
-packet). This means that the vast majority of BPF programs don't need
-to do any explicit bounds checking.
-
-In addition to the bytes of the packet, some BPF programs have access
-to extensions, which are essentially calls to kernel utility
-functions. Currently, the only extensions supported by this package
-are the Linux packet filter extensions.
-
-Examples
-
-This packet filter selects all ARP packets.
-
-	bpf.Assemble([]bpf.Instruction{
-		// Load "EtherType" field from the ethernet header.
-		bpf.LoadAbsolute{Off: 12, Size: 2},
-		// Skip over the next instruction if EtherType is not ARP.
-		bpf.JumpIf{Cond: bpf.JumpNotEqual, Val: 0x0806, SkipTrue: 1},
-		// Verdict is "send up to 4k of the packet to userspace."
-		bpf.RetConstant{Val: 4096},
-		// Verdict is "ignore packet."
-		bpf.RetConstant{Val: 0},
-	})
-
-This packet filter captures a random 1% sample of traffic.
-
-	bpf.Assemble([]bpf.Instruction{
-		// Get a 32-bit random number from the Linux kernel.
-		bpf.LoadExtension{Num: bpf.ExtRand},
-		// 1% dice roll?
-		bpf.JumpIf{Cond: bpf.JumpLessThan, Val: 2^32/100, SkipFalse: 1},
-		// Capture.
-		bpf.RetConstant{Val: 4096},
-		// Ignore.
-		bpf.RetConstant{Val: 0},
-	})
-
-*/
-package bpf // import "golang.org/x/net/bpf"

vendor/golang.org/x/net/bpf/instructions.go

@@ -1,704 +0,0 @@
-// Copyright 2016 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package bpf
-
-import "fmt"
-
-// An Instruction is one instruction executed by the BPF virtual
-// machine.
-type Instruction interface {
-	// Assemble assembles the Instruction into a RawInstruction.
-	Assemble() (RawInstruction, error)
-}
-
-// A RawInstruction is a raw BPF virtual machine instruction.
-type RawInstruction struct {
-	// Operation to execute.
-	Op uint16
-	// For conditional jump instructions, the number of instructions
-	// to skip if the condition is true/false.
-	Jt uint8
-	Jf uint8
-	// Constant parameter. The meaning depends on the Op.
-	K uint32
-}
-
-// Assemble implements the Instruction Assemble method.
-func (ri RawInstruction) Assemble() (RawInstruction, error) { return ri, nil }
-
-// Disassemble parses ri into an Instruction and returns it. If ri is
-// not recognized by this package, ri itself is returned.
-func (ri RawInstruction) Disassemble() Instruction {
-	switch ri.Op & opMaskCls {
-	case opClsLoadA, opClsLoadX:
-		reg := Register(ri.Op & opMaskLoadDest)
-		sz := 0
-		switch ri.Op & opMaskLoadWidth {
-		case opLoadWidth4:
-			sz = 4
-		case opLoadWidth2:
-			sz = 2
-		case opLoadWidth1:
-			sz = 1
-		default:
-			return ri
-		}
-		switch ri.Op & opMaskLoadMode {
-		case opAddrModeImmediate:
-			if sz != 4 {
-				return ri
-			}
-			return LoadConstant{Dst: reg, Val: ri.K}
-		case opAddrModeScratch:
-			if sz != 4 || ri.K > 15 {
-				return ri
-			}
-			return LoadScratch{Dst: reg, N: int(ri.K)}
-		case opAddrModeAbsolute:
-			if ri.K > extOffset+0xffffffff {
-				return LoadExtension{Num: Extension(-extOffset + ri.K)}
-			}
-			return LoadAbsolute{Size: sz, Off: ri.K}
-		case opAddrModeIndirect:
-			return LoadIndirect{Size: sz, Off: ri.K}
-		case opAddrModePacketLen:
-			if sz != 4 {
-				return ri
-			}
-			return LoadExtension{Num: ExtLen}
-		case opAddrModeMemShift:
-			return LoadMemShift{Off: ri.K}
-		default:
-			return ri
-		}
-
-	case opClsStoreA:
-		if ri.Op != opClsStoreA || ri.K > 15 {
-			return ri
-		}
-		return StoreScratch{Src: RegA, N: int(ri.K)}
-
-	case opClsStoreX:
-		if ri.Op != opClsStoreX || ri.K > 15 {
-			return ri
-		}
-		return StoreScratch{Src: RegX, N: int(ri.K)}
-
-	case opClsALU:
-		switch op := ALUOp(ri.Op & opMaskOperator); op {
-		case ALUOpAdd, ALUOpSub, ALUOpMul, ALUOpDiv, ALUOpOr, ALUOpAnd, ALUOpShiftLeft, ALUOpShiftRight, ALUOpMod, ALUOpXor:
-			if ri.Op&opMaskOperandSrc != 0 {
-				return ALUOpX{Op: op}
-			}
-			return ALUOpConstant{Op: op, Val: ri.K}
-		case aluOpNeg:
-			return NegateA{}
-		default:
-			return ri
-		}
-
-	case opClsJump:
-		if ri.Op&opMaskJumpConst != opClsJump {
-			return ri
-		}
-		switch ri.Op & opMaskJumpCond {
-		case opJumpAlways:
-			return Jump{Skip: ri.K}
-		case opJumpEqual:
-			if ri.Jt == 0 {
-				return JumpIf{
-					Cond:      JumpNotEqual,
-					Val:       ri.K,
-					SkipTrue:  ri.Jf,
-					SkipFalse: 0,
-				}
-			}
-			return JumpIf{
-				Cond:      JumpEqual,
-				Val:       ri.K,
-				SkipTrue:  ri.Jt,
-				SkipFalse: ri.Jf,
-			}
-		case opJumpGT:
-			if ri.Jt == 0 {
-				return JumpIf{
-					Cond:      JumpLessOrEqual,
-					Val:       ri.K,
-					SkipTrue:  ri.Jf,
-					SkipFalse: 0,
-				}
-			}
-			return JumpIf{
-				Cond:      JumpGreaterThan,
-				Val:       ri.K,
-				SkipTrue:  ri.Jt,
-				SkipFalse: ri.Jf,
-			}
-		case opJumpGE:
-			if ri.Jt == 0 {
-				return JumpIf{
-					Cond:      JumpLessThan,
-					Val:       ri.K,
-					SkipTrue:  ri.Jf,
-					SkipFalse: 0,
-				}
-			}
-			return JumpIf{
-				Cond:      JumpGreaterOrEqual,
-				Val:       ri.K,
-				SkipTrue:  ri.Jt,
-				SkipFalse: ri.Jf,
-			}
-		case opJumpSet:
-			return JumpIf{
-				Cond:      JumpBitsSet,
-				Val:       ri.K,
-				SkipTrue:  ri.Jt,
-				SkipFalse: ri.Jf,
-			}
-		default:
-			return ri
-		}
-
-	case opClsReturn:
-		switch ri.Op {
-		case opClsReturn | opRetSrcA:
-			return RetA{}
-		case opClsReturn | opRetSrcConstant:
-			return RetConstant{Val: ri.K}
-		default:
-			return ri
-		}
-
-	case opClsMisc:
-		switch ri.Op {
-		case opClsMisc | opMiscTAX:
-			return TAX{}
-		case opClsMisc | opMiscTXA:
-			return TXA{}
-		default:
-			return ri
-		}
-
-	default:
-		panic("unreachable") // switch is exhaustive on the bit pattern
-	}
-}
-
-// LoadConstant loads Val into register Dst.
-type LoadConstant struct {
-	Dst Register
-	Val uint32
-}
-
-// Assemble implements the Instruction Assemble method.
-func (a LoadConstant) Assemble() (RawInstruction, error) {
-	return assembleLoad(a.Dst, 4, opAddrModeImmediate, a.Val)
-}
-
-// String returns the the instruction in assembler notation.
-func (a LoadConstant) String() string {
-	switch a.Dst {
-	case RegA:
-		return fmt.Sprintf("ld #%d", a.Val)
-	case RegX:
-		return fmt.Sprintf("ldx #%d", a.Val)
-	default:
-		return fmt.Sprintf("unknown instruction: %#v", a)
-	}
-}
-
-// LoadScratch loads scratch[N] into register Dst.
-type LoadScratch struct {
-	Dst Register
-	N   int // 0-15
-}
-
-// Assemble implements the Instruction Assemble method.
-func (a LoadScratch) Assemble() (RawInstruction, error) {
-	if a.N < 0 || a.N > 15 {
-		return RawInstruction{}, fmt.Errorf("invalid scratch slot %d", a.N)
-	}
-	return assembleLoad(a.Dst, 4, opAddrModeScratch, uint32(a.N))
-}
-
-// String returns the the instruction in assembler notation.
-func (a LoadScratch) String() string {
-	switch a.Dst {
-	case RegA:
-		return fmt.Sprintf("ld M[%d]", a.N)
-	case RegX:
-		return fmt.Sprintf("ldx M[%d]", a.N)
-	default:
-		return fmt.Sprintf("unknown instruction: %#v", a)
-	}
-}
-
-// LoadAbsolute loads packet[Off:Off+Size] as an integer value into
-// register A.
-type LoadAbsolute struct {
-	Off  uint32
-	Size int // 1, 2 or 4
-}
-
-// Assemble implements the Instruction Assemble method.
-func (a LoadAbsolute) Assemble() (RawInstruction, error) {
-	return assembleLoad(RegA, a.Size, opAddrModeAbsolute, a.Off)
-}
-
-// String returns the the instruction in assembler notation.
-func (a LoadAbsolute) String() string {
-	switch a.Size {
-	case 1: // byte
-		return fmt.Sprintf("ldb [%d]", a.Off)
-	case 2: // half word
-		return fmt.Sprintf("ldh [%d]", a.Off)
-	case 4: // word
-		if a.Off > extOffset+0xffffffff {
-			return LoadExtension{Num: Extension(a.Off + 0x1000)}.String()
-		}
-		return fmt.Sprintf("ld [%d]", a.Off)
-	default:
-		return fmt.Sprintf("unknown instruction: %#v", a)
-	}
-}
-
-// LoadIndirect loads packet[X+Off:X+Off+Size] as an integer value
-// into register A.
-type LoadIndirect struct {
-	Off  uint32
-	Size int // 1, 2 or 4
-}
-
-// Assemble implements the Instruction Assemble method.
-func (a LoadIndirect) Assemble() (RawInstruction, error) {
-	return assembleLoad(RegA, a.Size, opAddrModeIndirect, a.Off)
-}
-
-// String returns the the instruction in assembler notation.
-func (a LoadIndirect) String() string {
-	switch a.Size {
-	case 1: // byte
-		return fmt.Sprintf("ldb [x + %d]", a.Off)
-	case 2: // half word
-		return fmt.Sprintf("ldh [x + %d]", a.Off)
-	case 4: // word
-		return fmt.Sprintf("ld [x + %d]", a.Off)
-	default:
-		return fmt.Sprintf("unknown instruction: %#v", a)
-	}
-}
-
-// LoadMemShift multiplies the first 4 bits of the byte at packet[Off]
-// by 4 and stores the result in register X.
-//
-// This instruction is mainly useful to load into X the length of an
-// IPv4 packet header in a single instruction, rather than have to do
-// the arithmetic on the header's first byte by hand.
-type LoadMemShift struct {
-	Off uint32
-}
-
-// Assemble implements the Instruction Assemble method.
-func (a LoadMemShift) Assemble() (RawInstruction, error) {
-	return assembleLoad(RegX, 1, opAddrModeMemShift, a.Off)
-}
-
-// String returns the the instruction in assembler notation.
-func (a LoadMemShift) String() string {
-	return fmt.Sprintf("ldx 4*([%d]&0xf)", a.Off)
-}
-
-// LoadExtension invokes a linux-specific extension and stores the
-// result in register A.
-type LoadExtension struct {
-	Num Extension
-}
-
-// Assemble implements the Instruction Assemble method.
-func (a LoadExtension) Assemble() (RawInstruction, error) {
-	if a.Num == ExtLen {
-		return assembleLoad(RegA, 4, opAddrModePacketLen, 0)
-	}
-	return assembleLoad(RegA, 4, opAddrModeAbsolute, uint32(extOffset+a.Num))
-}
-
-// String returns the the instruction in assembler notation.
-func (a LoadExtension) String() string {
-	switch a.Num {
-	case ExtLen:
-		return "ld #len"
-	case ExtProto:
-		return "ld #proto"
-	case ExtType:
-		return "ld #type"
-	case ExtPayloadOffset:
-		return "ld #poff"
-	case ExtInterfaceIndex:
-		return "ld #ifidx"
-	case ExtNetlinkAttr:
-		return "ld #nla"
-	case ExtNetlinkAttrNested:
-		return "ld #nlan"
-	case ExtMark:
-		return "ld #mark"
-	case ExtQueue:
-		return "ld #queue"
-	case ExtLinkLayerType:
-		return "ld #hatype"
-	case ExtRXHash:
-		return "ld #rxhash"
-	case ExtCPUID:
-		return "ld #cpu"
-	case ExtVLANTag:
-		return "ld #vlan_tci"
-	case ExtVLANTagPresent:
-		return "ld #vlan_avail"
-	case ExtVLANProto:
-		return "ld #vlan_tpid"
-	case ExtRand:
-		return "ld #rand"
-	default:
-		return fmt.Sprintf("unknown instruction: %#v", a)
-	}
-}
-
-// StoreScratch stores register Src into scratch[N].
-type StoreScratch struct {
-	Src Register
-	N   int // 0-15
-}
-
-// Assemble implements the Instruction Assemble method.
-func (a StoreScratch) Assemble() (RawInstruction, error) {
-	if a.N < 0 || a.N > 15 {
-		return RawInstruction{}, fmt.Errorf("invalid scratch slot %d", a.N)
-	}
-	var op uint16
-	switch a.Src {
-	case RegA:
-		op = opClsStoreA
-	case RegX:
-		op = opClsStoreX
-	default:
-		return RawInstruction{}, fmt.Errorf("invalid source register %v", a.Src)
-	}
-
-	return RawInstruction{
-		Op: op,
-		K:  uint32(a.N),
-	}, nil
-}
-
-// String returns the the instruction in assembler notation.
-func (a StoreScratch) String() string {
-	switch a.Src {
-	case RegA:
-		return fmt.Sprintf("st M[%d]", a.N)
-	case RegX:
-		return fmt.Sprintf("stx M[%d]", a.N)
-	default:
-		return fmt.Sprintf("unknown instruction: %#v", a)
-	}
-}
-
-// ALUOpConstant executes A = A <Op> Val.
-type ALUOpConstant struct {
-	Op  ALUOp
-	Val uint32
-}
-
-// Assemble implements the Instruction Assemble method.
-func (a ALUOpConstant) Assemble() (RawInstruction, error) {
-	return RawInstruction{
-		Op: opClsALU | opALUSrcConstant | uint16(a.Op),
-		K:  a.Val,
-	}, nil
-}
-
-// String returns the the instruction in assembler notation.
-func (a ALUOpConstant) String() string {
-	switch a.Op {
-	case ALUOpAdd:
-		return fmt.Sprintf("add #%d", a.Val)
-	case ALUOpSub:
-		return fmt.Sprintf("sub #%d", a.Val)
-	case ALUOpMul:
-		return fmt.Sprintf("mul #%d", a.Val)
-	case ALUOpDiv:
-		return fmt.Sprintf("div #%d", a.Val)
-	case ALUOpMod:
-		return fmt.Sprintf("mod #%d", a.Val)
-	case ALUOpAnd:
-		return fmt.Sprintf("and #%d", a.Val)
-	case ALUOpOr:
-		return fmt.Sprintf("or #%d", a.Val)
-	case ALUOpXor:
-		return fmt.Sprintf("xor #%d", a.Val)
-	case ALUOpShiftLeft:
-		return fmt.Sprintf("lsh #%d", a.Val)
-	case ALUOpShiftRight:
-		return fmt.Sprintf("rsh #%d", a.Val)
-	default:
-		return fmt.Sprintf("unknown instruction: %#v", a)
-	}
-}
-
-// ALUOpX executes A = A <Op> X
-type ALUOpX struct {
-	Op ALUOp
-}
-
-// Assemble implements the Instruction Assemble method.
-func (a ALUOpX) Assemble() (RawInstruction, error) {
-	return RawInstruction{
-		Op: opClsALU | opALUSrcX | uint16(a.Op),
-	}, nil
-}
-
-// String returns the the instruction in assembler notation.
-func (a ALUOpX) String() string {
-	switch a.Op {
-	case ALUOpAdd:
-		return "add x"
-	case ALUOpSub:
-		return "sub x"
-	case ALUOpMul:
-		return "mul x"
-	case ALUOpDiv:
-		return "div x"
-	case ALUOpMod:
-		return "mod x"
-	case ALUOpAnd:
-		return "and x"
-	case ALUOpOr:
-		return "or x"
-	case ALUOpXor:
-		return "xor x"
-	case ALUOpShiftLeft:
-		return "lsh x"
-	case ALUOpShiftRight:
-		return "rsh x"
-	default:
-		return fmt.Sprintf("unknown instruction: %#v", a)
-	}
-}
-
-// NegateA executes A = -A.
-type NegateA struct{}
-
-// Assemble implements the Instruction Assemble method.
-func (a NegateA) Assemble() (RawInstruction, error) {
-	return RawInstruction{
-		Op: opClsALU | uint16(aluOpNeg),
-	}, nil
-}
-
-// String returns the the instruction in assembler notation.
-func (a NegateA) String() string {
-	return fmt.Sprintf("neg")
-}
-
-// Jump skips the following Skip instructions in the program.
-type Jump struct {
-	Skip uint32
-}
-
-// Assemble implements the Instruction Assemble method.
-func (a Jump) Assemble() (RawInstruction, error) {
-	return RawInstruction{
-		Op: opClsJump | opJumpAlways,
-		K:  a.Skip,
-	}, nil
-}
-
-// String returns the the instruction in assembler notation.
-func (a Jump) String() string {
-	return fmt.Sprintf("ja %d", a.Skip)
-}
-
-// JumpIf skips the following Skip instructions in the program if A
-// <Cond> Val is true.
-type JumpIf struct {
-	Cond      JumpTest
-	Val       uint32
-	SkipTrue  uint8
-	SkipFalse uint8
-}
-
-// Assemble implements the Instruction Assemble method.
-func (a JumpIf) Assemble() (RawInstruction, error) {
-	var (
-		cond uint16
-		flip bool
-	)
-	switch a.Cond {
-	case JumpEqual:
-		cond = opJumpEqual
-	case JumpNotEqual:
-		cond, flip = opJumpEqual, true
-	case JumpGreaterThan:
-		cond = opJumpGT
-	case JumpLessThan:
-		cond, flip = opJumpGE, true
-	case JumpGreaterOrEqual:
-		cond = opJumpGE
-	case JumpLessOrEqual:
-		cond, flip = opJumpGT, true
-	case JumpBitsSet:
-		cond = opJumpSet
-	case JumpBitsNotSet:
-		cond, flip = opJumpSet, true
-	default:
-		return RawInstruction{}, fmt.Errorf("unknown JumpTest %v", a.Cond)
-	}
-	jt, jf := a.SkipTrue, a.SkipFalse
-	if flip {
-		jt, jf = jf, jt
-	}
-	return RawInstruction{
-		Op: opClsJump | cond,
-		Jt: jt,
-		Jf: jf,
-		K:  a.Val,
-	}, nil
-}
-
-// String returns the the instruction in assembler notation.
-func (a JumpIf) String() string {
-	switch a.Cond {
-	// K == A
-	case JumpEqual:
-		return conditionalJump(a, "jeq", "jneq")
-	// K != A
-	case JumpNotEqual:
-		return fmt.Sprintf("jneq #%d,%d", a.Val, a.SkipTrue)
-	// K > A
-	case JumpGreaterThan:
-		return conditionalJump(a, "jgt", "jle")
-	// K < A
-	case JumpLessThan:
-		return fmt.Sprintf("jlt #%d,%d", a.Val, a.SkipTrue)
-	// K >= A
-	case JumpGreaterOrEqual:
-		return conditionalJump(a, "jge", "jlt")
-	// K <= A
-	case JumpLessOrEqual:
-		return fmt.Sprintf("jle #%d,%d", a.Val, a.SkipTrue)
-	// K & A != 0
-	case JumpBitsSet:
-		if a.SkipFalse > 0 {
-			return fmt.Sprintf("jset #%d,%d,%d", a.Val, a.SkipTrue, a.SkipFalse)
-		}
-		return fmt.Sprintf("jset #%d,%d", a.Val, a.SkipTrue)
-	// K & A == 0, there is no assembler instruction for JumpBitNotSet, use JumpBitSet and invert skips
-	case JumpBitsNotSet:
-		return JumpIf{Cond: JumpBitsSet, SkipTrue: a.SkipFalse, SkipFalse: a.SkipTrue, Val: a.Val}.String()
-	default:
-		return fmt.Sprintf("unknown instruction: %#v", a)
-	}
-}
-
-func conditionalJump(inst JumpIf, positiveJump, negativeJump string) string {
-	if inst.SkipTrue > 0 {
-		if inst.SkipFalse > 0 {
-			return fmt.Sprintf("%s #%d,%d,%d", positiveJump, inst.Val, inst.SkipTrue, inst.SkipFalse)
-		}
-		return fmt.Sprintf("%s #%d,%d", positiveJump, inst.Val, inst.SkipTrue)
-	}
-	return fmt.Sprintf("%s #%d,%d", negativeJump, inst.Val, inst.SkipFalse)
-}
-
-// RetA exits the BPF program, returning the value of register A.
-type RetA struct{}
-
-// Assemble implements the Instruction Assemble method.
-func (a RetA) Assemble() (RawInstruction, error) {
-	return RawInstruction{
-		Op: opClsReturn | opRetSrcA,
-	}, nil
-}
-
-// String returns the the instruction in assembler notation.
-func (a RetA) String() string {
-	return fmt.Sprintf("ret a")
-}
-
-// RetConstant exits the BPF program, returning a constant value.
-type RetConstant struct {
-	Val uint32
-}
-
-// Assemble implements the Instruction Assemble method.
-func (a RetConstant) Assemble() (RawInstruction, error) {
-	return RawInstruction{
-		Op: opClsReturn | opRetSrcConstant,
-		K:  a.Val,
-	}, nil
-}
-
-// String returns the the instruction in assembler notation.
-func (a RetConstant) String() string {
-	return fmt.Sprintf("ret #%d", a.Val)
-}
-
-// TXA copies the value of register X to register A.
-type TXA struct{}
-
-// Assemble implements the Instruction Assemble method.
-func (a TXA) Assemble() (RawInstruction, error) {
-	return RawInstruction{
-		Op: opClsMisc | opMiscTXA,
-	}, nil
-}
-
-// String returns the the instruction in assembler notation.
-func (a TXA) String() string {
-	return fmt.Sprintf("txa")
-}
-
-// TAX copies the value of register A to register X.
-type TAX struct{}
-
-// Assemble implements the Instruction Assemble method.
-func (a TAX) Assemble() (RawInstruction, error) {
-	return RawInstruction{
-		Op: opClsMisc | opMiscTAX,
-	}, nil
-}
-
-// String returns the the instruction in assembler notation.
-func (a TAX) String() string {
-	return fmt.Sprintf("tax")
-}
-
-func assembleLoad(dst Register, loadSize int, mode uint16, k uint32) (RawInstruction, error) {
-	var (
-		cls uint16
-		sz  uint16
-	)
-	switch dst {
-	case RegA:
-		cls = opClsLoadA
-	case RegX:
-		cls = opClsLoadX
-	default:
-		return RawInstruction{}, fmt.Errorf("invalid target register %v", dst)
-	}
-	switch loadSize {
-	case 1:
-		sz = opLoadWidth1
-	case 2:
-		sz = opLoadWidth2
-	case 4:
-		sz = opLoadWidth4
-	default:
-		return RawInstruction{}, fmt.Errorf("invalid load byte length %d", sz)
-	}
-	return RawInstruction{
-		Op: cls | sz | mode,
-		K:  k,
-	}, nil
-}

vendor/golang.org/x/net/bpf/instructions_test.go

@@ -1,525 +0,0 @@
-// Copyright 2016 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package bpf
-
-import (
-	"fmt"
-	"io/ioutil"
-	"reflect"
-	"strconv"
-	"strings"
-	"testing"
-)
-
-// This is a direct translation of the program in
-// testdata/all_instructions.txt.
-var allInstructions = []Instruction{
-	LoadConstant{Dst: RegA, Val: 42},
-	LoadConstant{Dst: RegX, Val: 42},
-
-	LoadScratch{Dst: RegA, N: 3},
-	LoadScratch{Dst: RegX, N: 3},
-
-	LoadAbsolute{Off: 42, Size: 1},
-	LoadAbsolute{Off: 42, Size: 2},
-	LoadAbsolute{Off: 42, Size: 4},
-
-	LoadIndirect{Off: 42, Size: 1},
-	LoadIndirect{Off: 42, Size: 2},
-	LoadIndirect{Off: 42, Size: 4},
-
-	LoadMemShift{Off: 42},
-
-	LoadExtension{Num: ExtLen},
-	LoadExtension{Num: ExtProto},
-	LoadExtension{Num: ExtType},
-	LoadExtension{Num: ExtRand},
-
-	StoreScratch{Src: RegA, N: 3},
-	StoreScratch{Src: RegX, N: 3},
-
-	ALUOpConstant{Op: ALUOpAdd, Val: 42},
-	ALUOpConstant{Op: ALUOpSub, Val: 42},
-	ALUOpConstant{Op: ALUOpMul, Val: 42},
-	ALUOpConstant{Op: ALUOpDiv, Val: 42},
-	ALUOpConstant{Op: ALUOpOr, Val: 42},
-	ALUOpConstant{Op: ALUOpAnd, Val: 42},
-	ALUOpConstant{Op: ALUOpShiftLeft, Val: 42},
-	ALUOpConstant{Op: ALUOpShiftRight, Val: 42},
-	ALUOpConstant{Op: ALUOpMod, Val: 42},
-	ALUOpConstant{Op: ALUOpXor, Val: 42},
-
-	ALUOpX{Op: ALUOpAdd},
-	ALUOpX{Op: ALUOpSub},
-	ALUOpX{Op: ALUOpMul},
-	ALUOpX{Op: ALUOpDiv},
-	ALUOpX{Op: ALUOpOr},
-	ALUOpX{Op: ALUOpAnd},
-	ALUOpX{Op: ALUOpShiftLeft},
-	ALUOpX{Op: ALUOpShiftRight},
-	ALUOpX{Op: ALUOpMod},
-	ALUOpX{Op: ALUOpXor},
-
-	NegateA{},
-
-	Jump{Skip: 10},
-	JumpIf{Cond: JumpEqual, Val: 42, SkipTrue: 8, SkipFalse: 9},
-	JumpIf{Cond: JumpNotEqual, Val: 42, SkipTrue: 8},
-	JumpIf{Cond: JumpLessThan, Val: 42, SkipTrue: 7},
-	JumpIf{Cond: JumpLessOrEqual, Val: 42, SkipTrue: 6},
-	JumpIf{Cond: JumpGreaterThan, Val: 42, SkipTrue: 4, SkipFalse: 5},
-	JumpIf{Cond: JumpGreaterOrEqual, Val: 42, SkipTrue: 3, SkipFalse: 4},
-	JumpIf{Cond: JumpBitsSet, Val: 42, SkipTrue: 2, SkipFalse: 3},
-
-	TAX{},
-	TXA{},
-
-	RetA{},
-	RetConstant{Val: 42},
-}
-var allInstructionsExpected = "testdata/all_instructions.bpf"
-
-// Check that we produce the same output as the canonical bpf_asm
-// linux kernel tool.
-func TestInterop(t *testing.T) {
-	out, err := Assemble(allInstructions)
-	if err != nil {
-		t.Fatalf("assembly of allInstructions program failed: %s", err)
-	}
-	t.Logf("Assembled program is %d instructions long", len(out))
-
-	bs, err := ioutil.ReadFile(allInstructionsExpected)
-	if err != nil {
-		t.Fatalf("reading %s: %s", allInstructionsExpected, err)
-	}
-	// First statement is the number of statements, last statement is
-	// empty. We just ignore both and rely on slice length.
-	stmts := strings.Split(string(bs), ",")
-	if len(stmts)-2 != len(out) {
-		t.Fatalf("test program lengths don't match: %s has %d, Go implementation has %d", allInstructionsExpected, len(stmts)-2, len(allInstructions))
-	}
-
-	for i, stmt := range stmts[1 : len(stmts)-2] {
-		nums := strings.Split(stmt, " ")
-		if len(nums) != 4 {
-			t.Fatalf("malformed instruction %d in %s: %s", i+1, allInstructionsExpected, stmt)
-		}
-
-		actual := out[i]
-
-		op, err := strconv.ParseUint(nums[0], 10, 16)
-		if err != nil {
-			t.Fatalf("malformed opcode %s in instruction %d of %s", nums[0], i+1, allInstructionsExpected)
-		}
-		if actual.Op != uint16(op) {
-			t.Errorf("opcode mismatch on instruction %d (%#v): got 0x%02x, want 0x%02x", i+1, allInstructions[i], actual.Op, op)
-		}
-
-		jt, err := strconv.ParseUint(nums[1], 10, 8)
-		if err != nil {
-			t.Fatalf("malformed jt offset %s in instruction %d of %s", nums[1], i+1, allInstructionsExpected)
-		}
-		if actual.Jt != uint8(jt) {
-			t.Errorf("jt mismatch on instruction %d (%#v): got %d, want %d", i+1, allInstructions[i], actual.Jt, jt)
-		}
-
-		jf, err := strconv.ParseUint(nums[2], 10, 8)
-		if err != nil {
-			t.Fatalf("malformed jf offset %s in instruction %d of %s", nums[2], i+1, allInstructionsExpected)
-		}
-		if actual.Jf != uint8(jf) {
-			t.Errorf("jf mismatch on instruction %d (%#v): got %d, want %d", i+1, allInstructions[i], actual.Jf, jf)
-		}
-
-		k, err := strconv.ParseUint(nums[3], 10, 32)
-		if err != nil {
-			t.Fatalf("malformed constant %s in instruction %d of %s", nums[3], i+1, allInstructionsExpected)
-		}
-		if actual.K != uint32(k) {
-			t.Errorf("constant mismatch on instruction %d (%#v): got %d, want %d", i+1, allInstructions[i], actual.K, k)
-		}
-	}
-}
-
-// Check that assembly and disassembly match each other.
-func TestAsmDisasm(t *testing.T) {
-	prog1, err := Assemble(allInstructions)
-	if err != nil {
-		t.Fatalf("assembly of allInstructions program failed: %s", err)
-	}
-	t.Logf("Assembled program is %d instructions long", len(prog1))
-
-	got, allDecoded := Disassemble(prog1)
-	if !allDecoded {
-		t.Errorf("Disassemble(Assemble(allInstructions)) produced unrecognized instructions:")
-		for i, inst := range got {
-			if r, ok := inst.(RawInstruction); ok {
-				t.Logf("  insn %d, %#v --> %#v", i+1, allInstructions[i], r)
-			}
-		}
-	}
-
-	if len(allInstructions) != len(got) {
-		t.Fatalf("disassembly changed program size: %d insns before, %d insns after", len(allInstructions), len(got))
-	}
-	if !reflect.DeepEqual(allInstructions, got) {
-		t.Errorf("program mutated by disassembly:")
-		for i := range got {
-			if !reflect.DeepEqual(allInstructions[i], got[i]) {
-				t.Logf("  insn %d, s: %#v, p1: %#v, got: %#v", i+1, allInstructions[i], prog1[i], got[i])
-			}
-		}
-	}
-}
-
-type InvalidInstruction struct{}
-
-func (a InvalidInstruction) Assemble() (RawInstruction, error) {
-	return RawInstruction{}, fmt.Errorf("Invalid Instruction")
-}
-
-func (a InvalidInstruction) String() string {
-	return fmt.Sprintf("unknown instruction: %#v", a)
-}
-
-func TestString(t *testing.T) {
-	testCases := []struct {
-		instruction Instruction
-		assembler   string
-	}{
-		{
-			instruction: LoadConstant{Dst: RegA, Val: 42},
-			assembler:   "ld #42",
-		},
-		{
-			instruction: LoadConstant{Dst: RegX, Val: 42},
-			assembler:   "ldx #42",
-		},
-		{
-			instruction: LoadConstant{Dst: 0xffff, Val: 42},
-			assembler:   "unknown instruction: bpf.LoadConstant{Dst:0xffff, Val:0x2a}",
-		},
-		{
-			instruction: LoadScratch{Dst: RegA, N: 3},
-			assembler:   "ld M[3]",
-		},
-		{
-			instruction: LoadScratch{Dst: RegX, N: 3},
-			assembler:   "ldx M[3]",
-		},
-		{
-			instruction: LoadScratch{Dst: 0xffff, N: 3},
-			assembler:   "unknown instruction: bpf.LoadScratch{Dst:0xffff, N:3}",
-		},
-		{
-			instruction: LoadAbsolute{Off: 42, Size: 1},
-			assembler:   "ldb [42]",
-		},
-		{
-			instruction: LoadAbsolute{Off: 42, Size: 2},
-			assembler:   "ldh [42]",
-		},
-		{
-			instruction: LoadAbsolute{Off: 42, Size: 4},
-			assembler:   "ld [42]",
-		},
-		{
-			instruction: LoadAbsolute{Off: 42, Size: -1},
-			assembler:   "unknown instruction: bpf.LoadAbsolute{Off:0x2a, Size:-1}",
-		},
-		{
-			instruction: LoadIndirect{Off: 42, Size: 1},
-			assembler:   "ldb [x + 42]",
-		},
-		{
-			instruction: LoadIndirect{Off: 42, Size: 2},
-			assembler:   "ldh [x + 42]",
-		},
-		{
-			instruction: LoadIndirect{Off: 42, Size: 4},
-			assembler:   "ld [x + 42]",
-		},
-		{
-			instruction: LoadIndirect{Off: 42, Size: -1},
-			assembler:   "unknown instruction: bpf.LoadIndirect{Off:0x2a, Size:-1}",
-		},
-		{
-			instruction: LoadMemShift{Off: 42},
-			assembler:   "ldx 4*([42]&0xf)",
-		},
-		{
-			instruction: LoadExtension{Num: ExtLen},
-			assembler:   "ld #len",
-		},
-		{
-			instruction: LoadExtension{Num: ExtProto},
-			assembler:   "ld #proto",
-		},
-		{
-			instruction: LoadExtension{Num: ExtType},
-			assembler:   "ld #type",
-		},
-		{
-			instruction: LoadExtension{Num: ExtPayloadOffset},
-			assembler:   "ld #poff",
-		},
-		{
-			instruction: LoadExtension{Num: ExtInterfaceIndex},
-			assembler:   "ld #ifidx",
-		},
-		{
-			instruction: LoadExtension{Num: ExtNetlinkAttr},
-			assembler:   "ld #nla",
-		},
-		{
-			instruction: LoadExtension{Num: ExtNetlinkAttrNested},
-			assembler:   "ld #nlan",
-		},
-		{
-			instruction: LoadExtension{Num: ExtMark},
-			assembler:   "ld #mark",
-		},
-		{
-			instruction: LoadExtension{Num: ExtQueue},
-			assembler:   "ld #queue",
-		},
-		{
-			instruction: LoadExtension{Num: ExtLinkLayerType},
-			assembler:   "ld #hatype",
-		},
-		{
-			instruction: LoadExtension{Num: ExtRXHash},
-			assembler:   "ld #rxhash",
-		},
-		{
-			instruction: LoadExtension{Num: ExtCPUID},
-			assembler:   "ld #cpu",
-		},
-		{
-			instruction: LoadExtension{Num: ExtVLANTag},
-			assembler:   "ld #vlan_tci",
-		},
-		{
-			instruction: LoadExtension{Num: ExtVLANTagPresent},
-			assembler:   "ld #vlan_avail",
-		},
-		{
-			instruction: LoadExtension{Num: ExtVLANProto},
-			assembler:   "ld #vlan_tpid",
-		},
-		{
-			instruction: LoadExtension{Num: ExtRand},
-			assembler:   "ld #rand",
-		},
-		{
-			instruction: LoadAbsolute{Off: 0xfffff038, Size: 4},
-			assembler:   "ld #rand",
-		},
-		{
-			instruction: LoadExtension{Num: 0xfff},
-			assembler:   "unknown instruction: bpf.LoadExtension{Num:4095}",
-		},
-		{
-			instruction: StoreScratch{Src: RegA, N: 3},
-			assembler:   "st M[3]",
-		},
-		{
-			instruction: StoreScratch{Src: RegX, N: 3},
-			assembler:   "stx M[3]",
-		},
-		{
-			instruction: StoreScratch{Src: 0xffff, N: 3},
-			assembler:   "unknown instruction: bpf.StoreScratch{Src:0xffff, N:3}",
-		},
-		{
-			instruction: ALUOpConstant{Op: ALUOpAdd, Val: 42},
-			assembler:   "add #42",
-		},
-		{
-			instruction: ALUOpConstant{Op: ALUOpSub, Val: 42},
-			assembler:   "sub #42",
-		},
-		{
-			instruction: ALUOpConstant{Op: ALUOpMul, Val: 42},
-			assembler:   "mul #42",
-		},
-		{
-			instruction: ALUOpConstant{Op: ALUOpDiv, Val: 42},
-			assembler:   "div #42",
-		},
-		{
-			instruction: ALUOpConstant{Op: ALUOpOr, Val: 42},
-			assembler:   "or #42",
-		},
-		{
-			instruction: ALUOpConstant{Op: ALUOpAnd, Val: 42},
-			assembler:   "and #42",
-		},
-		{
-			instruction: ALUOpConstant{Op: ALUOpShiftLeft, Val: 42},
-			assembler:   "lsh #42",
-		},
-		{
-			instruction: ALUOpConstant{Op: ALUOpShiftRight, Val: 42},
-			assembler:   "rsh #42",
-		},
-		{
-			instruction: ALUOpConstant{Op: ALUOpMod, Val: 42},
-			assembler:   "mod #42",
-		},
-		{
-			instruction: ALUOpConstant{Op: ALUOpXor, Val: 42},
-			assembler:   "xor #42",
-		},
-		{
-			instruction: ALUOpConstant{Op: 0xffff, Val: 42},
-			assembler:   "unknown instruction: bpf.ALUOpConstant{Op:0xffff, Val:0x2a}",
-		},
-		{
-			instruction: ALUOpX{Op: ALUOpAdd},
-			assembler:   "add x",
-		},
-		{
-			instruction: ALUOpX{Op: ALUOpSub},
-			assembler:   "sub x",
-		},
-		{
-			instruction: ALUOpX{Op: ALUOpMul},
-			assembler:   "mul x",
-		},
-		{
-			instruction: ALUOpX{Op: ALUOpDiv},
-			assembler:   "div x",
-		},
-		{
-			instruction: ALUOpX{Op: ALUOpOr},
-			assembler:   "or x",
-		},
-		{
-			instruction: ALUOpX{Op: ALUOpAnd},
-			assembler:   "and x",
-		},
-		{
-			instruction: ALUOpX{Op: ALUOpShiftLeft},
-			assembler:   "lsh x",
-		},
-		{
-			instruction: ALUOpX{Op: ALUOpShiftRight},
-			assembler:   "rsh x",
-		},
-		{
-			instruction: ALUOpX{Op: ALUOpMod},
-			assembler:   "mod x",
-		},
-		{
-			instruction: ALUOpX{Op: ALUOpXor},
-			assembler:   "xor x",
-		},
-		{
-			instruction: ALUOpX{Op: 0xffff},
-			assembler:   "unknown instruction: bpf.ALUOpX{Op:0xffff}",
-		},
-		{
-			instruction: NegateA{},
-			assembler:   "neg",
-		},
-		{
-			instruction: Jump{Skip: 10},
-			assembler:   "ja 10",
-		},
-		{
-			instruction: JumpIf{Cond: JumpEqual, Val: 42, SkipTrue: 8, SkipFalse: 9},
-			assembler:   "jeq #42,8,9",
-		},
-		{
-			instruction: JumpIf{Cond: JumpEqual, Val: 42, SkipTrue: 8},
-			assembler:   "jeq #42,8",
-		},
-		{
-			instruction: JumpIf{Cond: JumpEqual, Val: 42, SkipFalse: 8},
-			assembler:   "jneq #42,8",
-		},
-		{
-			instruction: JumpIf{Cond: JumpNotEqual, Val: 42, SkipTrue: 8},
-			assembler:   "jneq #42,8",
-		},
-		{
-			instruction: JumpIf{Cond: JumpLessThan, Val: 42, SkipTrue: 7},
-			assembler:   "jlt #42,7",
-		},
-		{
-			instruction: JumpIf{Cond: JumpLessOrEqual, Val: 42, SkipTrue: 6},
-			assembler:   "jle #42,6",
-		},
-		{
-			instruction: JumpIf{Cond: JumpGreaterThan, Val: 42, SkipTrue: 4, SkipFalse: 5},
-			assembler:   "jgt #42,4,5",
-		},
-		{
-			instruction: JumpIf{Cond: JumpGreaterThan, Val: 42, SkipTrue: 4},
-			assembler:   "jgt #42,4",
-		},
-		{
-			instruction: JumpIf{Cond: JumpGreaterOrEqual, Val: 42, SkipTrue: 3, SkipFalse: 4},
-			assembler:   "jge #42,3,4",
-		},
-		{
-			instruction: JumpIf{Cond: JumpGreaterOrEqual, Val: 42, SkipTrue: 3},
-			assembler:   "jge #42,3",
-		},
-		{
-			instruction: JumpIf{Cond: JumpBitsSet, Val: 42, SkipTrue: 2, SkipFalse: 3},
-			assembler:   "jset #42,2,3",
-		},
-		{
-			instruction: JumpIf{Cond: JumpBitsSet, Val: 42, SkipTrue: 2},
-			assembler:   "jset #42,2",
-		},
-		{
-			instruction: JumpIf{Cond: JumpBitsNotSet, Val: 42, SkipTrue: 2, SkipFalse: 3},
-			assembler:   "jset #42,3,2",
-		},
-		{
-			instruction: JumpIf{Cond: JumpBitsNotSet, Val: 42, SkipTrue: 2},
-			assembler:   "jset #42,0,2",
-		},
-		{
-			instruction: JumpIf{Cond: 0xffff, Val: 42, SkipTrue: 1, SkipFalse: 2},
-			assembler:   "unknown instruction: bpf.JumpIf{Cond:0xffff, Val:0x2a, SkipTrue:0x1, SkipFalse:0x2}",
-		},
-		{
-			instruction: TAX{},
-			assembler:   "tax",
-		},
-		{
-			instruction: TXA{},
-			assembler:   "txa",
-		},
-		{
-			instruction: RetA{},
-			assembler:   "ret a",
-		},
-		{
-			instruction: RetConstant{Val: 42},
-			assembler:   "ret #42",
-		},
-		// Invalid instruction
-		{
-			instruction: InvalidInstruction{},
-			assembler:   "unknown instruction: bpf.InvalidInstruction{}",
-		},
-	}
-
-	for _, testCase := range testCases {
-		if input, ok := testCase.instruction.(fmt.Stringer); ok {
-			got := input.String()
-			if got != testCase.assembler {
-				t.Errorf("String did not return expected assembler notation, expected: %s, got: %s", testCase.assembler, got)
-			}
-		} else {
-			t.Errorf("Instruction %#v is not a fmt.Stringer", testCase.instruction)
-		}
-	}
-}

vendor/golang.org/x/net/bpf/setter.go

@@ -1,10 +0,0 @@
-// Copyright 2017 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package bpf
-
-// A Setter is a type which can attach a compiled BPF filter to itself.
-type Setter interface {
-	SetBPF(filter []RawInstruction) error
-}

vendor/golang.org/x/net/bpf/testdata/all_instructions.bpf

@@ -1 +0,0 @@
-50,0 0 0 42,1 0 0 42,96 0 0 3,97 0 0 3,48 0 0 42,40 0 0 42,32 0 0 42,80 0 0 42,72 0 0 42,64 0 0 42,177 0 0 42,128 0 0 0,32 0 0 4294963200,32 0 0 4294963204,32 0 0 4294963256,2 0 0 3,3 0 0 3,4 0 0 42,20 0 0 42,36 0 0 42,52 0 0 42,68 0 0 42,84 0 0 42,100 0 0 42,116 0 0 42,148 0 0 42,164 0 0 42,12 0 0 0,28 0 0 0,44 0 0 0,60 0 0 0,76 0 0 0,92 0 0 0,108 0 0 0,124 0 0 0,156 0 0 0,172 0 0 0,132 0 0 0,5 0 0 10,21 8 9 42,21 0 8 42,53 0 7 42,37 0 6 42,37 4 5 42,53 3 4 42,69 2 3 42,7 0 0 0,135 0 0 0,22 0 0 0,6 0 0 0,

vendor/golang.org/x/net/bpf/testdata/all_instructions.txt

@@ -1,79 +0,0 @@
-# This filter is compiled to all_instructions.bpf by the `bpf_asm`
-# tool, which can be found in the linux kernel source tree under
-# tools/net.
-
-# Load immediate
-ld #42
-ldx #42
-
-# Load scratch
-ld M[3]
-ldx M[3]
-
-# Load absolute
-ldb [42]
-ldh [42]
-ld [42]
-
-# Load indirect
-ldb [x + 42]
-ldh [x + 42]
-ld [x + 42]
-
-# Load IPv4 header length
-ldx 4*([42]&0xf)
-
-# Run extension function
-ld #len
-ld #proto
-ld #type
-ld #rand
-
-# Store scratch
-st M[3]
-stx M[3]
-
-# A <op> constant
-add #42
-sub #42
-mul #42
-div #42
-or #42
-and #42
-lsh #42
-rsh #42
-mod #42
-xor #42
-
-# A <op> X
-add x
-sub x
-mul x
-div x
-or x
-and x
-lsh x
-rsh x
-mod x
-xor x
-
-# !A
-neg
-
-# Jumps
-ja end
-jeq #42,prev,end
-jne #42,end
-jlt #42,end
-jle #42,end
-jgt #42,prev,end
-jge #42,prev,end
-jset #42,prev,end
-
-# Register transfers
-tax
-txa
-
-# Returns
-prev: ret a
-end: ret #42

vendor/golang.org/x/net/bpf/vm.go

@@ -1,140 +0,0 @@
-// Copyright 2016 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package bpf
-
-import (
-	"errors"
-	"fmt"
-)
-
-// A VM is an emulated BPF virtual machine.
-type VM struct {
-	filter []Instruction
-}
-
-// NewVM returns a new VM using the input BPF program.
-func NewVM(filter []Instruction) (*VM, error) {
-	if len(filter) == 0 {
-		return nil, errors.New("one or more Instructions must be specified")
-	}
-
-	for i, ins := range filter {
-		check := len(filter) - (i + 1)
-		switch ins := ins.(type) {
-		// Check for out-of-bounds jumps in instructions
-		case Jump:
-			if check <= int(ins.Skip) {
-				return nil, fmt.Errorf("cannot jump %d instructions; jumping past program bounds", ins.Skip)
-			}
-		case JumpIf:
-			if check <= int(ins.SkipTrue) {
-				return nil, fmt.Errorf("cannot jump %d instructions in true case; jumping past program bounds", ins.SkipTrue)
-			}
-			if check <= int(ins.SkipFalse) {
-				return nil, fmt.Errorf("cannot jump %d instructions in false case; jumping past program bounds", ins.SkipFalse)
-			}
-		// Check for division or modulus by zero
-		case ALUOpConstant:
-			if ins.Val != 0 {
-				break
-			}
-
-			switch ins.Op {
-			case ALUOpDiv, ALUOpMod:
-				return nil, errors.New("cannot divide by zero using ALUOpConstant")
-			}
-		// Check for unknown extensions
-		case LoadExtension:
-			switch ins.Num {
-			case ExtLen:
-			default:
-				return nil, fmt.Errorf("extension %d not implemented", ins.Num)
-			}
-		}
-	}
-
-	// Make sure last instruction is a return instruction
-	switch filter[len(filter)-1].(type) {
-	case RetA, RetConstant:
-	default:
-		return nil, errors.New("BPF program must end with RetA or RetConstant")
-	}
-
-	// Though our VM works using disassembled instructions, we
-	// attempt to assemble the input filter anyway to ensure it is compatible
-	// with an operating system VM.
-	_, err := Assemble(filter)
-
-	return &VM{
-		filter: filter,
-	}, err
-}
-
-// Run runs the VM's BPF program against the input bytes.
-// Run returns the number of bytes accepted by the BPF program, and any errors
-// which occurred while processing the program.
-func (v *VM) Run(in []byte) (int, error) {
-	var (
-		// Registers of the virtual machine
-		regA       uint32
-		regX       uint32
-		regScratch [16]uint32
-
-		// OK is true if the program should continue processing the next
-		// instruction, or false if not, causing the loop to break
-		ok = true
-	)
-
-	// TODO(mdlayher): implement:
-	// - NegateA:
-	//   - would require a change from uint32 registers to int32
-	//     registers
-
-	// TODO(mdlayher): add interop tests that check signedness of ALU
-	// operations against kernel implementation, and make sure Go
-	// implementation matches behavior
-
-	for i := 0; i < len(v.filter) && ok; i++ {
-		ins := v.filter[i]
-
-		switch ins := ins.(type) {
-		case ALUOpConstant:
-			regA = aluOpConstant(ins, regA)
-		case ALUOpX:
-			regA, ok = aluOpX(ins, regA, regX)
-		case Jump:
-			i += int(ins.Skip)
-		case JumpIf:
-			jump := jumpIf(ins, regA)
-			i += jump
-		case LoadAbsolute:
-			regA, ok = loadAbsolute(ins, in)
-		case LoadConstant:
-			regA, regX = loadConstant(ins, regA, regX)
-		case LoadExtension:
-			regA = loadExtension(ins, in)
-		case LoadIndirect:
-			regA, ok = loadIndirect(ins, in, regX)
-		case LoadMemShift:
-			regX, ok = loadMemShift(ins, in)
-		case LoadScratch:
-			regA, regX = loadScratch(ins, regScratch, regA, regX)
-		case RetA:
-			return int(regA), nil
-		case RetConstant:
-			return int(ins.Val), nil
-		case StoreScratch:
-			regScratch = storeScratch(ins, regScratch, regA, regX)
-		case TAX:
-			regX = regA
-		case TXA:
-			regA = regX
-		default:
-			return 0, fmt.Errorf("unknown Instruction at index %d: %T", i, ins)
-		}
-	}
-
-	return 0, nil
-}

vendor/golang.org/x/net/bpf/vm_aluop_test.go

@@ -1,512 +0,0 @@
-// Copyright 2016 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package bpf_test
-
-import (
-	"testing"
-
-	"golang.org/x/net/bpf"
-)
-
-func TestVMALUOpAdd(t *testing.T) {
-	vm, done, err := testVM(t, []bpf.Instruction{
-		bpf.LoadAbsolute{
-			Off:  8,
-			Size: 1,
-		},
-		bpf.ALUOpConstant{
-			Op:  bpf.ALUOpAdd,
-			Val: 3,
-		},
-		bpf.RetA{},
-	})
-	if err != nil {
-		t.Fatalf("failed to load BPF program: %v", err)
-	}
-	defer done()
-
-	out, err := vm.Run([]byte{
-		0xff, 0xff, 0xff, 0xff,
-		0xff, 0xff, 0xff, 0xff,
-		8, 2, 3,
-	})
-	if err != nil {
-		t.Fatalf("unexpected error while running program: %v", err)
-	}
-	if want, got := 3, out; want != got {
-		t.Fatalf("unexpected number of output bytes:\n- want: %d\n-  got: %d",
-			want, got)
-	}
-}
-
-func TestVMALUOpSub(t *testing.T) {
-	vm, done, err := testVM(t, []bpf.Instruction{
-		bpf.LoadAbsolute{
-			Off:  8,
-			Size: 1,
-		},
-		bpf.TAX{},
-		bpf.ALUOpX{
-			Op: bpf.ALUOpSub,
-		},
-		bpf.RetA{},
-	})
-	if err != nil {
-		t.Fatalf("failed to load BPF program: %v", err)
-	}
-	defer done()
-
-	out, err := vm.Run([]byte{
-		0xff, 0xff, 0xff, 0xff,
-		0xff, 0xff, 0xff, 0xff,
-		1, 2, 3,
-	})
-	if err != nil {
-		t.Fatalf("unexpected error while running program: %v", err)
-	}
-	if want, got := 0, out; want != got {
-		t.Fatalf("unexpected number of output bytes:\n- want: %d\n-  got: %d",
-			want, got)
-	}
-}
-
-func TestVMALUOpMul(t *testing.T) {
-	vm, done, err := testVM(t, []bpf.Instruction{
-		bpf.LoadAbsolute{
-			Off:  8,
-			Size: 1,
-		},
-		bpf.ALUOpConstant{
-			Op:  bpf.ALUOpMul,
-			Val: 2,
-		},
-		bpf.RetA{},
-	})
-	if err != nil {
-		t.Fatalf("failed to load BPF program: %v", err)
-	}
-	defer done()
-
-	out, err := vm.Run([]byte{
-		0xff, 0xff, 0xff, 0xff,
-		0xff, 0xff, 0xff, 0xff,
-		6, 2, 3, 4,
-	})
-	if err != nil {
-		t.Fatalf("unexpected error while running program: %v", err)
-	}
-	if want, got := 4, out; want != got {
-		t.Fatalf("unexpected number of output bytes:\n- want: %d\n-  got: %d",
-			want, got)
-	}
-}
-
-func TestVMALUOpDiv(t *testing.T) {
-	vm, done, err := testVM(t, []bpf.Instruction{
-		bpf.LoadAbsolute{
-			Off:  8,
-			Size: 1,
-		},
-		bpf.ALUOpConstant{
-			Op:  bpf.ALUOpDiv,
-			Val: 2,
-		},
-		bpf.RetA{},
-	})
-	if err != nil {
-		t.Fatalf("failed to load BPF program: %v", err)
-	}
-	defer done()
-
-	out, err := vm.Run([]byte{
-		0xff, 0xff, 0xff, 0xff,
-		0xff, 0xff, 0xff, 0xff,
-		20, 2, 3, 4,
-	})
-	if err != nil {
-		t.Fatalf("unexpected error while running program: %v", err)
-	}
-	if want, got := 2, out; want != got {
-		t.Fatalf("unexpected number of output bytes:\n- want: %d\n-  got: %d",
-			want, got)
-	}
-}
-
-func TestVMALUOpDivByZeroALUOpConstant(t *testing.T) {
-	_, _, err := testVM(t, []bpf.Instruction{
-		bpf.ALUOpConstant{
-			Op:  bpf.ALUOpDiv,
-			Val: 0,
-		},
-		bpf.RetA{},
-	})
-	if errStr(err) != "cannot divide by zero using ALUOpConstant" {
-		t.Fatalf("unexpected error: %v", err)
-	}
-}
-
-func TestVMALUOpDivByZeroALUOpX(t *testing.T) {
-	vm, done, err := testVM(t, []bpf.Instruction{
-		// Load byte 0 into X
-		bpf.LoadAbsolute{
-			Off:  8,
-			Size: 1,
-		},
-		bpf.TAX{},
-		// Load byte 1 into A
-		bpf.LoadAbsolute{
-			Off:  9,
-			Size: 1,
-		},
-		// Attempt to perform 1/0
-		bpf.ALUOpX{
-			Op: bpf.ALUOpDiv,
-		},
-		// Return 4 bytes if program does not terminate
-		bpf.LoadConstant{
-			Val: 12,
-		},
-		bpf.RetA{},
-	})
-	if err != nil {
-		t.Fatalf("failed to load BPF program: %v", err)
-	}
-	defer done()
-
-	out, err := vm.Run([]byte{
-		0xff, 0xff, 0xff, 0xff,
-		0xff, 0xff, 0xff, 0xff,
-		0, 1, 3, 4,
-	})
-	if err != nil {
-		t.Fatalf("unexpected error while running program: %v", err)
-	}
-	if want, got := 0, out; want != got {
-		t.Fatalf("unexpected number of output bytes:\n- want: %d\n-  got: %d",
-			want, got)
-	}
-}
-
-func TestVMALUOpOr(t *testing.T) {
-	vm, done, err := testVM(t, []bpf.Instruction{
-		bpf.LoadAbsolute{
-			Off:  8,
-			Size: 2,
-		},
-		bpf.ALUOpConstant{
-			Op:  bpf.ALUOpOr,
-			Val: 0x01,
-		},
-		bpf.RetA{},
-	})
-	if err != nil {
-		t.Fatalf("failed to load BPF program: %v", err)
-	}
-	defer done()
-
-	out, err := vm.Run([]byte{
-		0xff, 0xff, 0xff, 0xff,
-		0xff, 0xff, 0xff, 0xff,
-		0x00, 0x10, 0x03, 0x04,
-		0x05, 0x06, 0x07, 0x08,
-		0x09, 0xff,
-	})
-	if err != nil {
-		t.Fatalf("unexpected error while running program: %v", err)
-	}
-	if want, got := 9, out; want != got {
-		t.Fatalf("unexpected number of output bytes:\n- want: %d\n-  got: %d",
-			want, got)
-	}
-}
-
-func TestVMALUOpAnd(t *testing.T) {
-	vm, done, err := testVM(t, []bpf.Instruction{
-		bpf.LoadAbsolute{
-			Off:  8,
-			Size: 2,
-		},
-		bpf.ALUOpConstant{
-			Op:  bpf.ALUOpAnd,
-			Val: 0x0019,
-		},
-		bpf.RetA{},
-	})
-	if err != nil {
-		t.Fatalf("failed to load BPF program: %v", err)
-	}
-	defer done()
-
-	out, err := vm.Run([]byte{
-		0xff, 0xff, 0xff, 0xff,
-		0xff, 0xff, 0xff, 0xff,
-		0xaa, 0x09,
-	})
-	if err != nil {
-		t.Fatalf("unexpected error while running program: %v", err)
-	}
-	if want, got := 1, out; want != got {
-		t.Fatalf("unexpected number of output bytes:\n- want: %d\n-  got: %d",
-			want, got)
-	}
-}
-
-func TestVMALUOpShiftLeft(t *testing.T) {
-	vm, done, err := testVM(t, []bpf.Instruction{
-		bpf.LoadAbsolute{
-			Off:  8,
-			Size: 1,
-		},
-		bpf.ALUOpConstant{
-			Op:  bpf.ALUOpShiftLeft,
-			Val: 0x01,
-		},
-		bpf.JumpIf{
-			Cond:     bpf.JumpEqual,
-			Val:      0x02,
-			SkipTrue: 1,
-		},
-		bpf.RetConstant{
-			Val: 0,
-		},
-		bpf.RetConstant{
-			Val: 9,
-		},
-	})
-	if err != nil {
-		t.Fatalf("failed to load BPF program: %v", err)
-	}
-	defer done()
-
-	out, err := vm.Run([]byte{
-		0xff, 0xff, 0xff, 0xff,
-		0xff, 0xff, 0xff, 0xff,
-		0x01, 0xaa,
-	})
-	if err != nil {
-		t.Fatalf("unexpected error while running program: %v", err)
-	}
-	if want, got := 1, out; want != got {
-		t.Fatalf("unexpected number of output bytes:\n- want: %d\n-  got: %d",
-			want, got)
-	}
-}
-
-func TestVMALUOpShiftRight(t *testing.T) {
-	vm, done, err := testVM(t, []bpf.Instruction{
-		bpf.LoadAbsolute{
-			Off:  8,
-			Size: 1,
-		},
-		bpf.ALUOpConstant{
-			Op:  bpf.ALUOpShiftRight,
-			Val: 0x01,
-		},
-		bpf.JumpIf{
-			Cond:     bpf.JumpEqual,
-			Val:      0x04,
-			SkipTrue: 1,
-		},
-		bpf.RetConstant{
-			Val: 0,
-		},
-		bpf.RetConstant{
-			Val: 9,
-		},
-	})
-	if err != nil {
-		t.Fatalf("failed to load BPF program: %v", err)
-	}
-	defer done()
-
-	out, err := vm.Run([]byte{
-		0xff, 0xff, 0xff, 0xff,
-		0xff, 0xff, 0xff, 0xff,
-		0x08, 0xff, 0xff,
-	})
-	if err != nil {
-		t.Fatalf("unexpected error while running program: %v", err)
-	}
-	if want, got := 1, out; want != got {
-		t.Fatalf("unexpected number of output bytes:\n- want: %d\n-  got: %d",
-			want, got)
-	}
-}
-
-func TestVMALUOpMod(t *testing.T) {
-	vm, done, err := testVM(t, []bpf.Instruction{
-		bpf.LoadAbsolute{
-			Off:  8,
-			Size: 1,
-		},
-		bpf.ALUOpConstant{
-			Op:  bpf.ALUOpMod,
-			Val: 20,
-		},
-		bpf.RetA{},
-	})
-	if err != nil {
-		t.Fatalf("failed to load BPF program: %v", err)
-	}
-	defer done()
-
-	out, err := vm.Run([]byte{
-		0xff, 0xff, 0xff, 0xff,
-		0xff, 0xff, 0xff, 0xff,
-		30, 0, 0,
-	})
-	if err != nil {
-		t.Fatalf("unexpected error while running program: %v", err)
-	}
-	if want, got := 2, out; want != got {
-		t.Fatalf("unexpected number of output bytes:\n- want: %d\n-  got: %d",
-			want, got)
-	}
-}
-
-func TestVMALUOpModByZeroALUOpConstant(t *testing.T) {
-	_, _, err := testVM(t, []bpf.Instruction{
-		bpf.LoadAbsolute{
-			Off:  8,
-			Size: 1,
-		},
-		bpf.ALUOpConstant{
-			Op:  bpf.ALUOpMod,
-			Val: 0,
-		},
-		bpf.RetA{},
-	})
-	if errStr(err) != "cannot divide by zero using ALUOpConstant" {
-		t.Fatalf("unexpected error: %v", err)
-	}
-}
-
-func TestVMALUOpModByZeroALUOpX(t *testing.T) {
-	vm, done, err := testVM(t, []bpf.Instruction{
-		// Load byte 0 into X
-		bpf.LoadAbsolute{
-			Off:  8,
-			Size: 1,
-		},
-		bpf.TAX{},
-		// Load byte 1 into A
-		bpf.LoadAbsolute{
-			Off:  9,
-			Size: 1,
-		},
-		// Attempt to perform 1%0
-		bpf.ALUOpX{
-			Op: bpf.ALUOpMod,
-		},
-		// Return 4 bytes if program does not terminate
-		bpf.LoadConstant{
-			Val: 12,
-		},
-		bpf.RetA{},
-	})
-	if err != nil {
-		t.Fatalf("failed to load BPF program: %v", err)
-	}
-	defer done()
-
-	out, err := vm.Run([]byte{
-		0xff, 0xff, 0xff, 0xff,
-		0xff, 0xff, 0xff, 0xff,
-		0, 1, 3, 4,
-	})
-	if err != nil {
-		t.Fatalf("unexpected error while running program: %v", err)
-	}
-	if want, got := 0, out; want != got {
-		t.Fatalf("unexpected number of output bytes:\n- want: %d\n-  got: %d",
-			want, got)
-	}
-}
-
-func TestVMALUOpXor(t *testing.T) {
-	vm, done, err := testVM(t, []bpf.Instruction{
-		bpf.LoadAbsolute{
-			Off:  8,
-			Size: 1,
-		},
-		bpf.ALUOpConstant{
-			Op:  bpf.ALUOpXor,
-			Val: 0x0a,
-		},
-		bpf.JumpIf{
-			Cond:     bpf.JumpEqual,
-			Val:      0x01,
-			SkipTrue: 1,
-		},
-		bpf.RetConstant{
-			Val: 0,
-		},
-		bpf.RetConstant{
-			Val: 9,
-		},
-	})
-	if err != nil {
-		t.Fatalf("failed to load BPF program: %v", err)
-	}
-	defer done()
-
-	out, err := vm.Run([]byte{
-		0xff, 0xff, 0xff, 0xff,
-		0xff, 0xff, 0xff, 0xff,
-		0x0b, 0x00, 0x00, 0x00,
-	})
-	if err != nil {
-		t.Fatalf("unexpected error while running program: %v", err)
-	}
-	if want, got := 1, out; want != got {
-		t.Fatalf("unexpected number of output bytes:\n- want: %d\n-  got: %d",
-			want, got)
-	}
-}
-
-func TestVMALUOpUnknown(t *testing.T) {
-	vm, done, err := testVM(t, []bpf.Instruction{
-		bpf.LoadAbsolute{
-			Off:  8,
-			Size: 1,
-		},
-		bpf.ALUOpConstant{
-			Op:  bpf.ALUOpAdd,
-			Val: 1,
-		},
-		// Verify that an unknown operation is a no-op
-		bpf.ALUOpConstant{
-			Op: 100,
-		},
-		bpf.JumpIf{
-			Cond:     bpf.JumpEqual,
-			Val:      0x02,
-			SkipTrue: 1,
-		},
-		bpf.RetConstant{
-			Val: 0,
-		},
-		bpf.RetConstant{
-			Val: 9,
-		},
-	})
-	if err != nil {
-		t.Fatalf("failed to load BPF program: %v", err)
-	}
-	defer done()
-
-	out, err := vm.Run([]byte{
-		0xff, 0xff, 0xff, 0xff,
-		0xff, 0xff, 0xff, 0xff,
-		1,
-	})
-	if err != nil {
-		t.Fatalf("unexpected error while running program: %v", err)
-	}
-	if want, got := 1, out; want != got {
-		t.Fatalf("unexpected number of output bytes:\n- want: %d\n-  got: %d",
-			want, got)
-	}
-}

vendor/golang.org/x/net/bpf/vm_bpf_test.go

@@ -1,192 +0,0 @@
-// Copyright 2016 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package bpf_test
-
-import (
-	"net"
-	"runtime"
-	"testing"
-	"time"
-
-	"golang.org/x/net/bpf"
-	"golang.org/x/net/ipv4"
-)
-
-// A virtualMachine is a BPF virtual machine which can process an
-// input packet against a BPF program and render a verdict.
-type virtualMachine interface {
-	Run(in []byte) (int, error)
-}
-
-// canUseOSVM indicates if the OS BPF VM is available on this platform.
-func canUseOSVM() bool {
-	// OS BPF VM can only be used on platforms where x/net/ipv4 supports
-	// attaching a BPF program to a socket.
-	switch runtime.GOOS {
-	case "linux":
-		return true
-	}
-
-	return false
-}
-
-// All BPF tests against both the Go VM and OS VM are assumed to
-// be used with a UDP socket. As a result, the entire contents
-// of a UDP datagram is sent through the BPF program, but only
-// the body after the UDP header will ever be returned in output.
-
-// testVM sets up a Go BPF VM, and if available, a native OS BPF VM
-// for integration testing.
-func testVM(t *testing.T, filter []bpf.Instruction) (virtualMachine, func(), error) {
-	goVM, err := bpf.NewVM(filter)
-	if err != nil {
-		// Some tests expect an error, so this error must be returned
-		// instead of fatally exiting the test
-		return nil, nil, err
-	}
-
-	mvm := &multiVirtualMachine{
-		goVM: goVM,
-
-		t: t,
-	}
-
-	// If available, add the OS VM for tests which verify that both the Go
-	// VM and OS VM have exactly the same output for the same input program
-	// and packet.
-	done := func() {}
-	if canUseOSVM() {
-		osVM, osVMDone := testOSVM(t, filter)
-		done = func() { osVMDone() }
-		mvm.osVM = osVM
-	}
-
-	return mvm, done, nil
-}
-
-// udpHeaderLen is the length of a UDP header.
-const udpHeaderLen = 8
-
-// A multiVirtualMachine is a virtualMachine which can call out to both the Go VM
-// and the native OS VM, if the OS VM is available.
-type multiVirtualMachine struct {
-	goVM virtualMachine
-	osVM virtualMachine
-
-	t *testing.T
-}
-
-func (mvm *multiVirtualMachine) Run(in []byte) (int, error) {
-	if len(in) < udpHeaderLen {
-		mvm.t.Fatalf("input must be at least length of UDP header (%d), got: %d",
-			udpHeaderLen, len(in))
-	}
-
-	// All tests have a UDP header as part of input, because the OS VM
-	// packets always will. For the Go VM, this output is trimmed before
-	// being sent back to tests.
-	goOut, goErr := mvm.goVM.Run(in)
-	if goOut >= udpHeaderLen {
-		goOut -= udpHeaderLen
-	}
-
-	// If Go output is larger than the size of the packet, packet filtering
-	// interop tests must trim the output bytes to the length of the packet.
-	// The BPF VM should not do this on its own, as other uses of it do
-	// not trim the output byte count.
-	trim := len(in) - udpHeaderLen
-	if goOut > trim {
-		goOut = trim
-	}
-
-	// When the OS VM is not available, process using the Go VM alone
-	if mvm.osVM == nil {
-		return goOut, goErr
-	}
-
-	// The OS VM will apply its own UDP header, so remove the pseudo header
-	// that the Go VM needs.
-	osOut, err := mvm.osVM.Run(in[udpHeaderLen:])
-	if err != nil {
-		mvm.t.Fatalf("error while running OS VM: %v", err)
-	}
-
-	// Verify both VMs return same number of bytes
-	var mismatch bool
-	if goOut != osOut {
-		mismatch = true
-		mvm.t.Logf("output byte count does not match:\n- go: %v\n- os: %v", goOut, osOut)
-	}
-
-	if mismatch {
-		mvm.t.Fatal("Go BPF and OS BPF packet outputs do not match")
-	}
-
-	return goOut, goErr
-}
-
-// An osVirtualMachine is a virtualMachine which uses the OS's BPF VM for
-// processing BPF programs.
-type osVirtualMachine struct {
-	l net.PacketConn
-	s net.Conn
-}
-
-// testOSVM creates a virtualMachine which uses the OS's BPF VM by injecting
-// packets into a UDP listener with a BPF program attached to it.
-func testOSVM(t *testing.T, filter []bpf.Instruction) (virtualMachine, func()) {
-	l, err := net.ListenPacket("udp4", "127.0.0.1:0")
-	if err != nil {
-		t.Fatalf("failed to open OS VM UDP listener: %v", err)
-	}
-
-	prog, err := bpf.Assemble(filter)
-	if err != nil {
-		t.Fatalf("failed to compile BPF program: %v", err)
-	}
-
-	p := ipv4.NewPacketConn(l)
-	if err = p.SetBPF(prog); err != nil {
-		t.Fatalf("failed to attach BPF program to listener: %v", err)
-	}
-
-	s, err := net.Dial("udp4", l.LocalAddr().String())
-	if err != nil {
-		t.Fatalf("failed to dial connection to listener: %v", err)
-	}
-
-	done := func() {
-		_ = s.Close()
-		_ = l.Close()
-	}
-
-	return &osVirtualMachine{
-		l: l,
-		s: s,
-	}, done
-}
-
-// Run sends the input bytes into the OS's BPF VM and returns its verdict.
-func (vm *osVirtualMachine) Run(in []byte) (int, error) {
-	go func() {
-		_, _ = vm.s.Write(in)
-	}()
-
-	vm.l.SetDeadline(time.Now().Add(50 * time.Millisecond))
-
-	var b [512]byte
-	n, _, err := vm.l.ReadFrom(b[:])
-	if err != nil {
-		// A timeout indicates that BPF filtered out the packet, and thus,
-		// no input should be returned.
-		if nerr, ok := err.(net.Error); ok && nerr.Timeout() {
-			return n, nil
-		}
-
-		return n, err
-	}
-
-	return n, nil
-}

vendor/golang.org/x/net/bpf/vm_extension_test.go

@@ -1,49 +0,0 @@
-// Copyright 2016 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package bpf_test
-
-import (
-	"testing"
-
-	"golang.org/x/net/bpf"
-)
-
-func TestVMLoadExtensionNotImplemented(t *testing.T) {
-	_, _, err := testVM(t, []bpf.Instruction{
-		bpf.LoadExtension{
-			Num: 100,
-		},
-		bpf.RetA{},
-	})
-	if errStr(err) != "extension 100 not implemented" {
-		t.Fatalf("unexpected error: %v", err)
-	}
-}
-
-func TestVMLoadExtensionExtLen(t *testing.T) {
-	vm, done, err := testVM(t, []bpf.Instruction{
-		bpf.LoadExtension{
-			Num: bpf.ExtLen,
-		},
-		bpf.RetA{},
-	})
-	if err != nil {
-		t.Fatalf("failed to load BPF program: %v", err)
-	}
-	defer done()
-
-	out, err := vm.Run([]byte{
-		0xff, 0xff, 0xff, 0xff,
-		0xff, 0xff, 0xff, 0xff,
-		0, 1, 2, 3,
-	})
-	if err != nil {
-		t.Fatalf("unexpected error while running program: %v", err)
-	}
-	if want, got := 4, out; want != got {
-		t.Fatalf("unexpected number of output bytes:\n- want: %d\n-  got: %d",
-			want, got)
-	}
-}

vendor/golang.org/x/net/bpf/vm_instructions.go

@@ -1,174 +0,0 @@
-// Copyright 2016 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package bpf
-
-import (
-	"encoding/binary"
-	"fmt"
-)
-
-func aluOpConstant(ins ALUOpConstant, regA uint32) uint32 {
-	return aluOpCommon(ins.Op, regA, ins.Val)
-}
-
-func aluOpX(ins ALUOpX, regA uint32, regX uint32) (uint32, bool) {
-	// Guard against division or modulus by zero by terminating
-	// the program, as the OS BPF VM does
-	if regX == 0 {
-		switch ins.Op {
-		case ALUOpDiv, ALUOpMod:
-			return 0, false
-		}
-	}
-
-	return aluOpCommon(ins.Op, regA, regX), true
-}
-
-func aluOpCommon(op ALUOp, regA uint32, value uint32) uint32 {
-	switch op {
-	case ALUOpAdd:
-		return regA + value
-	case ALUOpSub:
-		return regA - value
-	case ALUOpMul:
-		return regA * value
-	case ALUOpDiv:
-		// Division by zero not permitted by NewVM and aluOpX checks
-		return regA / value
-	case ALUOpOr:
-		return regA | value
-	case ALUOpAnd:
-		return regA & value
-	case ALUOpShiftLeft:
-		return regA << value
-	case ALUOpShiftRight:
-		return regA >> value
-	case ALUOpMod:
-		// Modulus by zero not permitted by NewVM and aluOpX checks
-		return regA % value
-	case ALUOpXor:
-		return regA ^ value
-	default:
-		return regA
-	}
-}
-
-func jumpIf(ins JumpIf, value uint32) int {
-	var ok bool
-	inV := uint32(ins.Val)
-
-	switch ins.Cond {
-	case JumpEqual:
-		ok = value == inV
-	case JumpNotEqual:
-		ok = value != inV
-	case JumpGreaterThan:
-		ok = value > inV
-	case JumpLessThan:
-		ok = value < inV
-	case JumpGreaterOrEqual:
-		ok = value >= inV
-	case JumpLessOrEqual:
-		ok = value <= inV
-	case JumpBitsSet:
-		ok = (value & inV) != 0
-	case JumpBitsNotSet:
-		ok = (value & inV) == 0
-	}
-
-	if ok {
-		return int(ins.SkipTrue)
-	}
-
-	return int(ins.SkipFalse)
-}
-
-func loadAbsolute(ins LoadAbsolute, in []byte) (uint32, bool) {
-	offset := int(ins.Off)
-	size := int(ins.Size)
-
-	return loadCommon(in, offset, size)
-}
-
-func loadConstant(ins LoadConstant, regA uint32, regX uint32) (uint32, uint32) {
-	switch ins.Dst {
-	case RegA:
-		regA = ins.Val
-	case RegX:
-		regX = ins.Val
-	}
-
-	return regA, regX
-}
-
-func loadExtension(ins LoadExtension, in []byte) uint32 {
-	switch ins.Num {
-	case ExtLen:
-		return uint32(len(in))
-	default:
-		panic(fmt.Sprintf("unimplemented extension: %d", ins.Num))
-	}
-}
-
-func loadIndirect(ins LoadIndirect, in []byte, regX uint32) (uint32, bool) {
-	offset := int(ins.Off) + int(regX)
-	size := int(ins.Size)
-
-	return loadCommon(in, offset, size)
-}
-
-func loadMemShift(ins LoadMemShift, in []byte) (uint32, bool) {
-	offset := int(ins.Off)
-
-	if !inBounds(len(in), offset, 0) {
-		return 0, false
-	}
-
-	// Mask off high 4 bits and multiply low 4 bits by 4
-	return uint32(in[offset]&0x0f) * 4, true
-}
-
-func inBounds(inLen int, offset int, size int) bool {
-	return offset+size <= inLen
-}
-
-func loadCommon(in []byte, offset int, size int) (uint32, bool) {
-	if !inBounds(len(in), offset, size) {
-		return 0, false
-	}
-
-	switch size {
-	case 1:
-		return uint32(in[offset]), true
-	case 2:
-		return uint32(binary.BigEndian.Uint16(in[offset : offset+size])), true
-	case 4:
-		return uint32(binary.BigEndian.Uint32(in[offset : offset+size])), true
-	default:
-		panic(fmt.Sprintf("invalid load size: %d", size))
-	}
-}
-
-func loadScratch(ins LoadScratch, regScratch [16]uint32, regA uint32, regX uint32) (uint32, uint32) {
-	switch ins.Dst {
-	case RegA:
-		regA = regScratch[ins.N]
-	case RegX:
-		regX = regScratch[ins.N]
-	}
-
-	return regA, regX
-}
-
-func storeScratch(ins StoreScratch, regScratch [16]uint32, regA uint32, regX uint32) [16]uint32 {
-	switch ins.Src {
-	case RegA:
-		regScratch[ins.N] = regA
-	case RegX:
-		regScratch[ins.N] = regX
-	}
-
-	return regScratch
-}

vendor/golang.org/x/net/bpf/vm_jump_test.go

@@ -1,380 +0,0 @@
-// Copyright 2016 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package bpf_test
-
-import (
-	"testing"
-
-	"golang.org/x/net/bpf"
-)
-
-func TestVMJumpOne(t *testing.T) {
-	vm, done, err := testVM(t, []bpf.Instruction{
-		bpf.LoadAbsolute{
-			Off:  8,
-			Size: 1,
-		},
-		bpf.Jump{
-			Skip: 1,
-		},
-		bpf.RetConstant{
-			Val: 0,
-		},
-		bpf.RetConstant{
-			Val: 9,
-		},
-	})
-	if err != nil {
-		t.Fatalf("failed to load BPF program: %v", err)
-	}
-	defer done()
-
-	out, err := vm.Run([]byte{
-		0xff, 0xff, 0xff, 0xff,
-		0xff, 0xff, 0xff, 0xff,
-		1,
-	})
-	if err != nil {
-		t.Fatalf("unexpected error while running program: %v", err)
-	}
-	if want, got := 1, out; want != got {
-		t.Fatalf("unexpected number of output bytes:\n- want: %d\n-  got: %d",
-			want, got)
-	}
-}
-
-func TestVMJumpOutOfProgram(t *testing.T) {
-	_, _, err := testVM(t, []bpf.Instruction{
-		bpf.Jump{
-			Skip: 1,
-		},
-		bpf.RetA{},
-	})
-	if errStr(err) != "cannot jump 1 instructions; jumping past program bounds" {
-		t.Fatalf("unexpected error: %v", err)
-	}
-}
-
-func TestVMJumpIfTrueOutOfProgram(t *testing.T) {
-	_, _, err := testVM(t, []bpf.Instruction{
-		bpf.JumpIf{
-			Cond:     bpf.JumpEqual,
-			SkipTrue: 2,
-		},
-		bpf.RetA{},
-	})
-	if errStr(err) != "cannot jump 2 instructions in true case; jumping past program bounds" {
-		t.Fatalf("unexpected error: %v", err)
-	}
-}
-
-func TestVMJumpIfFalseOutOfProgram(t *testing.T) {
-	_, _, err := testVM(t, []bpf.Instruction{
-		bpf.JumpIf{
-			Cond:      bpf.JumpEqual,
-			SkipFalse: 3,
-		},
-		bpf.RetA{},
-	})
-	if errStr(err) != "cannot jump 3 instructions in false case; jumping past program bounds" {
-		t.Fatalf("unexpected error: %v", err)
-	}
-}
-
-func TestVMJumpIfEqual(t *testing.T) {
-	vm, done, err := testVM(t, []bpf.Instruction{
-		bpf.LoadAbsolute{
-			Off:  8,
-			Size: 1,
-		},
-		bpf.JumpIf{
-			Cond:     bpf.JumpEqual,
-			Val:      1,
-			SkipTrue: 1,
-		},
-		bpf.RetConstant{
-			Val: 0,
-		},
-		bpf.RetConstant{
-			Val: 9,
-		},
-	})
-	if err != nil {
-		t.Fatalf("failed to load BPF program: %v", err)
-	}
-	defer done()
-
-	out, err := vm.Run([]byte{
-		0xff, 0xff, 0xff, 0xff,
-		0xff, 0xff, 0xff, 0xff,
-		1,
-	})
-	if err != nil {
-		t.Fatalf("unexpected error while running program: %v", err)
-	}
-	if want, got := 1, out; want != got {
-		t.Fatalf("unexpected number of output bytes:\n- want: %d\n-  got: %d",
-			want, got)
-	}
-}
-
-func TestVMJumpIfNotEqual(t *testing.T) {
-	vm, done, err := testVM(t, []bpf.Instruction{
-		bpf.LoadAbsolute{
-			Off:  8,
-			Size: 1,
-		},
-		bpf.JumpIf{
-			Cond:      bpf.JumpNotEqual,
-			Val:       1,
-			SkipFalse: 1,
-		},
-		bpf.RetConstant{
-			Val: 0,
-		},
-		bpf.RetConstant{
-			Val: 9,
-		},
-	})
-	if err != nil {
-		t.Fatalf("failed to load BPF program: %v", err)
-	}
-	defer done()
-
-	out, err := vm.Run([]byte{
-		0xff, 0xff, 0xff, 0xff,
-		0xff, 0xff, 0xff, 0xff,
-		1,
-	})
-	if err != nil {
-		t.Fatalf("unexpected error while running program: %v", err)
-	}
-	if want, got := 1, out; want != got {
-		t.Fatalf("unexpected number of output bytes:\n- want: %d\n-  got: %d",
-			want, got)
-	}
-}
-
-func TestVMJumpIfGreaterThan(t *testing.T) {
-	vm, done, err := testVM(t, []bpf.Instruction{
-		bpf.LoadAbsolute{
-			Off:  8,
-			Size: 4,
-		},
-		bpf.JumpIf{
-			Cond:     bpf.JumpGreaterThan,
-			Val:      0x00010202,
-			SkipTrue: 1,
-		},
-		bpf.RetConstant{
-			Val: 0,
-		},
-		bpf.RetConstant{
-			Val: 12,
-		},
-	})
-	if err != nil {
-		t.Fatalf("failed to load BPF program: %v", err)
-	}
-	defer done()
-
-	out, err := vm.Run([]byte{
-		0xff, 0xff, 0xff, 0xff,
-		0xff, 0xff, 0xff, 0xff,
-		0, 1, 2, 3,
-	})
-	if err != nil {
-		t.Fatalf("unexpected error while running program: %v", err)
-	}
-	if want, got := 4, out; want != got {
-		t.Fatalf("unexpected number of output bytes:\n- want: %d\n-  got: %d",
-			want, got)
-	}
-}
-
-func TestVMJumpIfLessThan(t *testing.T) {
-	vm, done, err := testVM(t, []bpf.Instruction{
-		bpf.LoadAbsolute{
-			Off:  8,
-			Size: 4,
-		},
-		bpf.JumpIf{
-			Cond:     bpf.JumpLessThan,
-			Val:      0xff010203,
-			SkipTrue: 1,
-		},
-		bpf.RetConstant{
-			Val: 0,
-		},
-		bpf.RetConstant{
-			Val: 12,
-		},
-	})
-	if err != nil {
-		t.Fatalf("failed to load BPF program: %v", err)
-	}
-	defer done()
-
-	out, err := vm.Run([]byte{
-		0xff, 0xff, 0xff, 0xff,
-		0xff, 0xff, 0xff, 0xff,
-		0, 1, 2, 3,
-	})
-	if err != nil {
-		t.Fatalf("unexpected error while running program: %v", err)
-	}
-	if want, got := 4, out; want != got {
-		t.Fatalf("unexpected number of output bytes:\n- want: %d\n-  got: %d",
-			want, got)
-	}
-}
-
-func TestVMJumpIfGreaterOrEqual(t *testing.T) {
-	vm, done, err := testVM(t, []bpf.Instruction{
-		bpf.LoadAbsolute{
-			Off:  8,
-			Size: 4,
-		},
-		bpf.JumpIf{
-			Cond:     bpf.JumpGreaterOrEqual,
-			Val:      0x00010203,
-			SkipTrue: 1,
-		},
-		bpf.RetConstant{
-			Val: 0,
-		},
-		bpf.RetConstant{
-			Val: 12,
-		},
-	})
-	if err != nil {
-		t.Fatalf("failed to load BPF program: %v", err)
-	}
-	defer done()
-
-	out, err := vm.Run([]byte{
-		0xff, 0xff, 0xff, 0xff,
-		0xff, 0xff, 0xff, 0xff,
-		0, 1, 2, 3,
-	})
-	if err != nil {
-		t.Fatalf("unexpected error while running program: %v", err)
-	}
-	if want, got := 4, out; want != got {
-		t.Fatalf("unexpected number of output bytes:\n- want: %d\n-  got: %d",
-			want, got)
-	}
-}
-
-func TestVMJumpIfLessOrEqual(t *testing.T) {
-	vm, done, err := testVM(t, []bpf.Instruction{
-		bpf.LoadAbsolute{
-			Off:  8,
-			Size: 4,
-		},
-		bpf.JumpIf{
-			Cond:     bpf.JumpLessOrEqual,
-			Val:      0xff010203,
-			SkipTrue: 1,
-		},
-		bpf.RetConstant{
-			Val: 0,
-		},
-		bpf.RetConstant{
-			Val: 12,
-		},
-	})
-	if err != nil {
-		t.Fatalf("failed to load BPF program: %v", err)
-	}
-	defer done()
-
-	out, err := vm.Run([]byte{
-		0xff, 0xff, 0xff, 0xff,
-		0xff, 0xff, 0xff, 0xff,
-		0, 1, 2, 3,
-	})
-	if err != nil {
-		t.Fatalf("unexpected error while running program: %v", err)
-	}
-	if want, got := 4, out; want != got {
-		t.Fatalf("unexpected number of output bytes:\n- want: %d\n-  got: %d",
-			want, got)
-	}
-}
-
-func TestVMJumpIfBitsSet(t *testing.T) {
-	vm, done, err := testVM(t, []bpf.Instruction{
-		bpf.LoadAbsolute{
-			Off:  8,
-			Size: 2,
-		},
-		bpf.JumpIf{
-			Cond:     bpf.JumpBitsSet,
-			Val:      0x1122,
-			SkipTrue: 1,
-		},
-		bpf.RetConstant{
-			Val: 0,
-		},
-		bpf.RetConstant{
-			Val: 10,
-		},
-	})
-	if err != nil {
-		t.Fatalf("failed to load BPF program: %v", err)
-	}
-	defer done()
-
-	out, err := vm.Run([]byte{
-		0xff, 0xff, 0xff, 0xff,
-		0xff, 0xff, 0xff, 0xff,
-		0x01, 0x02,
-	})
-	if err != nil {
-		t.Fatalf("unexpected error while running program: %v", err)
-	}
-	if want, got := 2, out; want != got {
-		t.Fatalf("unexpected number of output bytes:\n- want: %d\n-  got: %d",
-			want, got)
-	}
-}
-
-func TestVMJumpIfBitsNotSet(t *testing.T) {
-	vm, done, err := testVM(t, []bpf.Instruction{
-		bpf.LoadAbsolute{
-			Off:  8,
-			Size: 2,
-		},
-		bpf.JumpIf{
-			Cond:     bpf.JumpBitsNotSet,
-			Val:      0x1221,
-			SkipTrue: 1,
-		},
-		bpf.RetConstant{
-			Val: 0,
-		},
-		bpf.RetConstant{
-			Val: 10,
-		},
-	})
-	if err != nil {
-		t.Fatalf("failed to load BPF program: %v", err)
-	}
-	defer done()
-
-	out, err := vm.Run([]byte{
-		0xff, 0xff, 0xff, 0xff,
-		0xff, 0xff, 0xff, 0xff,
-		0x01, 0x02,
-	})
-	if err != nil {
-		t.Fatalf("unexpected error while running program: %v", err)
-	}
-	if want, got := 2, out; want != got {
-		t.Fatalf("unexpected number of output bytes:\n- want: %d\n-  got: %d",
-			want, got)
-	}
-}

vendor/golang.org/x/net/bpf/vm_load_test.go

@@ -1,246 +0,0 @@
-// Copyright 2016 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package bpf_test
-
-import (
-	"net"
-	"testing"
-
-	"golang.org/x/net/bpf"
-	"golang.org/x/net/ipv4"
-)
-
-func TestVMLoadAbsoluteOffsetOutOfBounds(t *testing.T) {
-	vm, done, err := testVM(t, []bpf.Instruction{
-		bpf.LoadAbsolute{
-			Off:  100,
-			Size: 2,
-		},
-		bpf.RetA{},
-	})
-	if err != nil {
-		t.Fatalf("failed to load BPF program: %v", err)
-	}
-	defer done()
-
-	out, err := vm.Run([]byte{
-		0xff, 0xff, 0xff, 0xff,
-		0xff, 0xff, 0xff, 0xff,
-		0, 1, 2, 3,
-	})
-	if err != nil {
-		t.Fatalf("unexpected error while running program: %v", err)
-	}
-	if want, got := 0, out; want != got {
-		t.Fatalf("unexpected number of output bytes:\n- want: %d\n-  got: %d",
-			want, got)
-	}
-}
-
-func TestVMLoadAbsoluteOffsetPlusSizeOutOfBounds(t *testing.T) {
-	vm, done, err := testVM(t, []bpf.Instruction{
-		bpf.LoadAbsolute{
-			Off:  8,
-			Size: 2,
-		},
-		bpf.RetA{},
-	})
-	if err != nil {
-		t.Fatalf("failed to load BPF program: %v", err)
-	}
-	defer done()
-
-	out, err := vm.Run([]byte{
-		0xff, 0xff, 0xff, 0xff,
-		0xff, 0xff, 0xff, 0xff,
-		0,
-	})
-	if err != nil {
-		t.Fatalf("unexpected error while running program: %v", err)
-	}
-	if want, got := 0, out; want != got {
-		t.Fatalf("unexpected number of output bytes:\n- want: %d\n-  got: %d",
-			want, got)
-	}
-}
-
-func TestVMLoadAbsoluteBadInstructionSize(t *testing.T) {
-	_, _, err := testVM(t, []bpf.Instruction{
-		bpf.LoadAbsolute{
-			Size: 5,
-		},
-		bpf.RetA{},
-	})
-	if errStr(err) != "assembling instruction 1: invalid load byte length 0" {
-		t.Fatalf("unexpected error: %v", err)
-	}
-}
-
-func TestVMLoadConstantOK(t *testing.T) {
-	vm, done, err := testVM(t, []bpf.Instruction{
-		bpf.LoadConstant{
-			Dst: bpf.RegX,
-			Val: 9,
-		},
-		bpf.TXA{},
-		bpf.RetA{},
-	})
-	if err != nil {
-		t.Fatalf("failed to load BPF program: %v", err)
-	}
-	defer done()
-
-	out, err := vm.Run([]byte{
-		0xff, 0xff, 0xff, 0xff,
-		0xff, 0xff, 0xff, 0xff,
-		0,
-	})
-	if err != nil {
-		t.Fatalf("unexpected error while running program: %v", err)
-	}
-	if want, got := 1, out; want != got {
-		t.Fatalf("unexpected number of output bytes:\n- want: %d\n-  got: %d",
-			want, got)
-	}
-}
-
-func TestVMLoadIndirectOutOfBounds(t *testing.T) {
-	vm, done, err := testVM(t, []bpf.Instruction{
-		bpf.LoadIndirect{
-			Off:  100,
-			Size: 1,
-		},
-		bpf.RetA{},
-	})
-	if err != nil {
-		t.Fatalf("failed to load BPF program: %v", err)
-	}
-	defer done()
-
-	out, err := vm.Run([]byte{
-		0xff, 0xff, 0xff, 0xff,
-		0xff, 0xff, 0xff, 0xff,
-		0,
-	})
-	if err != nil {
-		t.Fatalf("unexpected error while running program: %v", err)
-	}
-	if want, got := 0, out; want != got {
-		t.Fatalf("unexpected number of output bytes:\n- want: %d\n-  got: %d",
-			want, got)
-	}
-}
-
-func TestVMLoadMemShiftOutOfBounds(t *testing.T) {
-	vm, done, err := testVM(t, []bpf.Instruction{
-		bpf.LoadMemShift{
-			Off: 100,
-		},
-		bpf.RetA{},
-	})
-	if err != nil {
-		t.Fatalf("failed to load BPF program: %v", err)
-	}
-	defer done()
-
-	out, err := vm.Run([]byte{
-		0xff, 0xff, 0xff, 0xff,
-		0xff, 0xff, 0xff, 0xff,
-		0,
-	})
-	if err != nil {
-		t.Fatalf("unexpected error while running program: %v", err)
-	}
-	if want, got := 0, out; want != got {
-		t.Fatalf("unexpected number of output bytes:\n- want: %d\n-  got: %d",
-			want, got)
-	}
-}
-
-const (
-	dhcp4Port = 53
-)
-
-func TestVMLoadMemShiftLoadIndirectNoResult(t *testing.T) {
-	vm, in, done := testDHCPv4(t)
-	defer done()
-
-	// Append mostly empty UDP header with incorrect DHCPv4 port
-	in = append(in, []byte{
-		0, 0,
-		0, dhcp4Port + 1,
-		0, 0,
-		0, 0,
-	}...)
-
-	out, err := vm.Run(in)
-	if err != nil {
-		t.Fatalf("unexpected error while running program: %v", err)
-	}
-	if want, got := 0, out; want != got {
-		t.Fatalf("unexpected number of output bytes:\n- want: %d\n-  got: %d",
-			want, got)
-	}
-}
-
-func TestVMLoadMemShiftLoadIndirectOK(t *testing.T) {
-	vm, in, done := testDHCPv4(t)
-	defer done()
-
-	// Append mostly empty UDP header with correct DHCPv4 port
-	in = append(in, []byte{
-		0, 0,
-		0, dhcp4Port,
-		0, 0,
-		0, 0,
-	}...)
-
-	out, err := vm.Run(in)
-	if err != nil {
-		t.Fatalf("unexpected error while running program: %v", err)
-	}
-	if want, got := len(in)-8, out; want != got {
-		t.Fatalf("unexpected number of output bytes:\n- want: %d\n-  got: %d",
-			want, got)
-	}
-}
-
-func testDHCPv4(t *testing.T) (virtualMachine, []byte, func()) {
-	// DHCPv4 test data courtesy of David Anderson:
-	// https://github.com/google/netboot/blob/master/dhcp4/conn_linux.go#L59-L70
-	vm, done, err := testVM(t, []bpf.Instruction{
-		// Load IPv4 packet length
-		bpf.LoadMemShift{Off: 8},
-		// Get UDP dport
-		bpf.LoadIndirect{Off: 8 + 2, Size: 2},
-		// Correct dport?
-		bpf.JumpIf{Cond: bpf.JumpEqual, Val: dhcp4Port, SkipFalse: 1},
-		// Accept
-		bpf.RetConstant{Val: 1500},
-		// Ignore
-		bpf.RetConstant{Val: 0},
-	})
-	if err != nil {
-		t.Fatalf("failed to load BPF program: %v", err)
-	}
-
-	// Minimal requirements to make a valid IPv4 header
-	h := &ipv4.Header{
-		Len: ipv4.HeaderLen,
-		Src: net.IPv4(192, 168, 1, 1),
-		Dst: net.IPv4(192, 168, 1, 2),
-	}
-	hb, err := h.Marshal()
-	if err != nil {
-		t.Fatalf("failed to marshal IPv4 header: %v", err)
-	}
-
-	hb = append([]byte{
-		0xff, 0xff, 0xff, 0xff,
-		0xff, 0xff, 0xff, 0xff,
-	}, hb...)
-
-	return vm, hb, done
-}

vendor/golang.org/x/net/bpf/vm_ret_test.go

@@ -1,115 +0,0 @@
-// Copyright 2016 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package bpf_test
-
-import (
-	"testing"
-
-	"golang.org/x/net/bpf"
-)
-
-func TestVMRetA(t *testing.T) {
-	vm, done, err := testVM(t, []bpf.Instruction{
-		bpf.LoadAbsolute{
-			Off:  8,
-			Size: 1,
-		},
-		bpf.RetA{},
-	})
-	if err != nil {
-		t.Fatalf("failed to load BPF program: %v", err)
-	}
-	defer done()
-
-	out, err := vm.Run([]byte{
-		0xff, 0xff, 0xff, 0xff,
-		0xff, 0xff, 0xff, 0xff,
-		9,
-	})
-	if err != nil {
-		t.Fatalf("unexpected error while running program: %v", err)
-	}
-	if want, got := 1, out; want != got {
-		t.Fatalf("unexpected number of output bytes:\n- want: %d\n-  got: %d",
-			want, got)
-	}
-}
-
-func TestVMRetALargerThanInput(t *testing.T) {
-	vm, done, err := testVM(t, []bpf.Instruction{
-		bpf.LoadAbsolute{
-			Off:  8,
-			Size: 2,
-		},
-		bpf.RetA{},
-	})
-	if err != nil {
-		t.Fatalf("failed to load BPF program: %v", err)
-	}
-	defer done()
-
-	out, err := vm.Run([]byte{
-		0xff, 0xff, 0xff, 0xff,
-		0xff, 0xff, 0xff, 0xff,
-		0, 255,
-	})
-	if err != nil {
-		t.Fatalf("unexpected error while running program: %v", err)
-	}
-	if want, got := 2, out; want != got {
-		t.Fatalf("unexpected number of output bytes:\n- want: %d\n-  got: %d",
-			want, got)
-	}
-}
-
-func TestVMRetConstant(t *testing.T) {
-	vm, done, err := testVM(t, []bpf.Instruction{
-		bpf.RetConstant{
-			Val: 9,
-		},
-	})
-	if err != nil {
-		t.Fatalf("failed to load BPF program: %v", err)
-	}
-	defer done()
-
-	out, err := vm.Run([]byte{
-		0xff, 0xff, 0xff, 0xff,
-		0xff, 0xff, 0xff, 0xff,
-		0, 1,
-	})
-	if err != nil {
-		t.Fatalf("unexpected error while running program: %v", err)
-	}
-	if want, got := 1, out; want != got {
-		t.Fatalf("unexpected number of output bytes:\n- want: %d\n-  got: %d",
-			want, got)
-	}
-}
-
-func TestVMRetConstantLargerThanInput(t *testing.T) {
-	vm, done, err := testVM(t, []bpf.Instruction{
-		bpf.RetConstant{
-			Val: 16,
-		},
-	})
-	if err != nil {
-		t.Fatalf("failed to load BPF program: %v", err)
-	}
-	defer done()
-
-	out, err := vm.Run([]byte{
-		0xff, 0xff, 0xff, 0xff,
-		0xff, 0xff, 0xff, 0xff,
-		0, 1,
-	})
-	if err != nil {
-		t.Fatalf("unexpected error while running program: %v", err)
-	}
-	if want, got := 2, out; want != got {
-		t.Fatalf("unexpected number of output bytes:\n- want: %d\n-  got: %d",
-			want, got)
-	}
-}

vendor/golang.org/x/net/bpf/vm_scratch_test.go

@@ -1,247 +0,0 @@
-// Copyright 2016 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package bpf_test
-
-import (
-	"testing"
-
-	"golang.org/x/net/bpf"
-)
-
-func TestVMStoreScratchInvalidScratchRegisterTooSmall(t *testing.T) {
-	_, _, err := testVM(t, []bpf.Instruction{
-		bpf.StoreScratch{
-			Src: bpf.RegA,
-			N:   -1,
-		},
-		bpf.RetA{},
-	})
-	if errStr(err) != "assembling instruction 1: invalid scratch slot -1" {
-		t.Fatalf("unexpected error: %v", err)
-	}
-}
-
-func TestVMStoreScratchInvalidScratchRegisterTooLarge(t *testing.T) {
-	_, _, err := testVM(t, []bpf.Instruction{
-		bpf.StoreScratch{
-			Src: bpf.RegA,
-			N:   16,
-		},
-		bpf.RetA{},
-	})
-	if errStr(err) != "assembling instruction 1: invalid scratch slot 16" {
-		t.Fatalf("unexpected error: %v", err)
-	}
-}
-
-func TestVMStoreScratchUnknownSourceRegister(t *testing.T) {
-	_, _, err := testVM(t, []bpf.Instruction{
-		bpf.StoreScratch{
-			Src: 100,
-			N:   0,
-		},
-		bpf.RetA{},
-	})
-	if errStr(err) != "assembling instruction 1: invalid source register 100" {
-		t.Fatalf("unexpected error: %v", err)
-	}
-}
-
-func TestVMLoadScratchInvalidScratchRegisterTooSmall(t *testing.T) {
-	_, _, err := testVM(t, []bpf.Instruction{
-		bpf.LoadScratch{
-			Dst: bpf.RegX,
-			N:   -1,
-		},
-		bpf.RetA{},
-	})
-	if errStr(err) != "assembling instruction 1: invalid scratch slot -1" {
-		t.Fatalf("unexpected error: %v", err)
-	}
-}
-
-func TestVMLoadScratchInvalidScratchRegisterTooLarge(t *testing.T) {
-	_, _, err := testVM(t, []bpf.Instruction{
-		bpf.LoadScratch{
-			Dst: bpf.RegX,
-			N:   16,
-		},
-		bpf.RetA{},
-	})
-	if errStr(err) != "assembling instruction 1: invalid scratch slot 16" {
-		t.Fatalf("unexpected error: %v", err)
-	}
-}
-
-func TestVMLoadScratchUnknownDestinationRegister(t *testing.T) {
-	_, _, err := testVM(t, []bpf.Instruction{
-		bpf.LoadScratch{
-			Dst: 100,
-			N:   0,
-		},
-		bpf.RetA{},
-	})
-	if errStr(err) != "assembling instruction 1: invalid target register 100" {
-		t.Fatalf("unexpected error: %v", err)
-	}
-}
-
-func TestVMStoreScratchLoadScratchOneValue(t *testing.T) {
-	vm, done, err := testVM(t, []bpf.Instruction{
-		// Load byte 255
-		bpf.LoadAbsolute{
-			Off:  8,
-			Size: 1,
-		},
-		// Copy to X and store in scratch[0]
-		bpf.TAX{},
-		bpf.StoreScratch{
-			Src: bpf.RegX,
-			N:   0,
-		},
-		// Load byte 1
-		bpf.LoadAbsolute{
-			Off:  9,
-			Size: 1,
-		},
-		// Overwrite 1 with 255 from scratch[0]
-		bpf.LoadScratch{
-			Dst: bpf.RegA,
-			N:   0,
-		},
-		// Return 255
-		bpf.RetA{},
-	})
-	if err != nil {
-		t.Fatalf("failed to load BPF program: %v", err)
-	}
-	defer done()
-
-	out, err := vm.Run([]byte{
-		0xff, 0xff, 0xff, 0xff,
-		0xff, 0xff, 0xff, 0xff,
-		255, 1, 2,
-	})
-	if err != nil {
-		t.Fatalf("unexpected error while running program: %v", err)
-	}
-	if want, got := 3, out; want != got {
-		t.Fatalf("unexpected number of output bytes:\n- want: %d\n-  got: %d",
-			want, got)
-	}
-}
-
-func TestVMStoreScratchLoadScratchMultipleValues(t *testing.T) {
-	vm, done, err := testVM(t, []bpf.Instruction{
-		// Load byte 10
-		bpf.LoadAbsolute{
-			Off:  8,
-			Size: 1,
-		},
-		// Store in scratch[0]
-		bpf.StoreScratch{
-			Src: bpf.RegA,
-			N:   0,
-		},
-		// Load byte 20
-		bpf.LoadAbsolute{
-			Off:  9,
-			Size: 1,
-		},
-		// Store in scratch[1]
-		bpf.StoreScratch{
-			Src: bpf.RegA,
-			N:   1,
-		},
-		// Load byte 30
-		bpf.LoadAbsolute{
-			Off:  10,
-			Size: 1,
-		},
-		// Store in scratch[2]
-		bpf.StoreScratch{
-			Src: bpf.RegA,
-			N:   2,
-		},
-		// Load byte 1
-		bpf.LoadAbsolute{
-			Off:  11,
-			Size: 1,
-		},
-		// Store in scratch[3]
-		bpf.StoreScratch{
-			Src: bpf.RegA,
-			N:   3,
-		},
-		// Load in byte 10 to X
-		bpf.LoadScratch{
-			Dst: bpf.RegX,
-			N:   0,
-		},
-		// Copy X -> A
-		bpf.TXA{},
-		// Verify value is 10
-		bpf.JumpIf{
-			Cond:     bpf.JumpEqual,
-			Val:      10,
-			SkipTrue: 1,
-		},
-		// Fail test if incorrect
-		bpf.RetConstant{
-			Val: 0,
-		},
-		// Load in byte 20 to A
-		bpf.LoadScratch{
-			Dst: bpf.RegA,
-			N:   1,
-		},
-		// Verify value is 20
-		bpf.JumpIf{
-			Cond:     bpf.JumpEqual,
-			Val:      20,
-			SkipTrue: 1,
-		},
-		// Fail test if incorrect
-		bpf.RetConstant{
-			Val: 0,
-		},
-		// Load in byte 30 to A
-		bpf.LoadScratch{
-			Dst: bpf.RegA,
-			N:   2,
-		},
-		// Verify value is 30
-		bpf.JumpIf{
-			Cond:     bpf.JumpEqual,
-			Val:      30,
-			SkipTrue: 1,
-		},
-		// Fail test if incorrect
-		bpf.RetConstant{
-			Val: 0,
-		},
-		// Return first two bytes on success
-		bpf.RetConstant{
-			Val: 10,
-		},
-	})
-	if err != nil {
-		t.Fatalf("failed to load BPF program: %v", err)
-	}
-	defer done()
-
-	out, err := vm.Run([]byte{
-		0xff, 0xff, 0xff, 0xff,
-		0xff, 0xff, 0xff, 0xff,
-		10, 20, 30, 1,
-	})
-	if err != nil {
-		t.Fatalf("unexpected error while running program: %v", err)
-	}
-	if want, got := 2, out; want != got {
-		t.Fatalf("unexpected number of output bytes:\n- want: %d\n-  got: %d",
-			want, got)
-	}
-}

vendor/golang.org/x/net/bpf/vm_test.go

@@ -1,144 +0,0 @@
-// Copyright 2016 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package bpf_test
-
-import (
-	"fmt"
-	"testing"
-
-	"golang.org/x/net/bpf"
-)
-
-var _ bpf.Instruction = unknown{}
-
-type unknown struct{}
-
-func (unknown) Assemble() (bpf.RawInstruction, error) {
-	return bpf.RawInstruction{}, nil
-}
-
-func TestVMUnknownInstruction(t *testing.T) {
-	vm, done, err := testVM(t, []bpf.Instruction{
-		bpf.LoadConstant{
-			Dst: bpf.RegA,
-			Val: 100,
-		},
-		// Should terminate the program with an error immediately
-		unknown{},
-		bpf.RetA{},
-	})
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-	defer done()
-
-	_, err = vm.Run([]byte{
-		0xff, 0xff, 0xff, 0xff,
-		0xff, 0xff, 0xff, 0xff,
-		0x00, 0x00,
-	})
-	if errStr(err) != "unknown Instruction at index 1: bpf_test.unknown" {
-		t.Fatalf("unexpected error while running program: %v", err)
-	}
-}
-
-func TestVMNoReturnInstruction(t *testing.T) {
-	_, _, err := testVM(t, []bpf.Instruction{
-		bpf.LoadConstant{
-			Dst: bpf.RegA,
-			Val: 1,
-		},
-	})
-	if errStr(err) != "BPF program must end with RetA or RetConstant" {
-		t.Fatalf("unexpected error: %v", err)
-	}
-}
-
-func TestVMNoInputInstructions(t *testing.T) {
-	_, _, err := testVM(t, []bpf.Instruction{})
-	if errStr(err) != "one or more Instructions must be specified" {
-		t.Fatalf("unexpected error: %v", err)
-	}
-}
-
-// ExampleNewVM demonstrates usage of a VM, using an Ethernet frame
-// as input and checking its EtherType to determine if it should be accepted.
-func ExampleNewVM() {
-	// Offset | Length | Comment
-	// -------------------------
-	//   00   |   06   | Ethernet destination MAC address
-	//   06   |   06   | Ethernet source MAC address
-	//   12   |   02   | Ethernet EtherType
-	const (
-		etOff = 12
-		etLen = 2
-
-		etARP = 0x0806
-	)
-
-	// Set up a VM to filter traffic based on if its EtherType
-	// matches the ARP EtherType.
-	vm, err := bpf.NewVM([]bpf.Instruction{
-		// Load EtherType value from Ethernet header
-		bpf.LoadAbsolute{
-			Off:  etOff,
-			Size: etLen,
-		},
-		// If EtherType is equal to the ARP EtherType, jump to allow
-		// packet to be accepted
-		bpf.JumpIf{
-			Cond:     bpf.JumpEqual,
-			Val:      etARP,
-			SkipTrue: 1,
-		},
-		// EtherType does not match the ARP EtherType
-		bpf.RetConstant{
-			Val: 0,
-		},
-		// EtherType matches the ARP EtherType, accept up to 1500
-		// bytes of packet
-		bpf.RetConstant{
-			Val: 1500,
-		},
-	})
-	if err != nil {
-		panic(fmt.Sprintf("failed to load BPF program: %v", err))
-	}
-
-	// Create an Ethernet frame with the ARP EtherType for testing
-	frame := []byte{
-		0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-		0x00, 0x11, 0x22, 0x33, 0x44, 0x55,
-		0x08, 0x06,
-		// Payload omitted for brevity
-	}
-
-	// Run our VM's BPF program using the Ethernet frame as input
-	out, err := vm.Run(frame)
-	if err != nil {
-		panic(fmt.Sprintf("failed to accept Ethernet frame: %v", err))
-	}
-
-	// BPF VM can return a byte count greater than the number of input
-	// bytes, so trim the output to match the input byte length
-	if out > len(frame) {
-		out = len(frame)
-	}
-
-	fmt.Printf("out: %d bytes", out)
-
-	// Output:
-	// out: 14 bytes
-}
-
-// errStr returns the string representation of an error, or
-// "<nil>" if it is nil.
-func errStr(err error) string {
-	if err == nil {
-		return "<nil>"
-	}
-
-	return err.Error()
-}

vendor/golang.org/x/net/context/context.go

@@ -1,54 +0,0 @@
-// Copyright 2014 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Package context defines the Context type, which carries deadlines,
-// cancelation signals, and other request-scoped values across API boundaries
-// and between processes.
-//
-// Incoming requests to a server should create a Context, and outgoing calls to
-// servers should accept a Context. The chain of function calls between must
-// propagate the Context, optionally replacing it with a modified copy created
-// using WithDeadline, WithTimeout, WithCancel, or WithValue.
-//
-// Programs that use Contexts should follow these rules to keep interfaces
-// consistent across packages and enable static analysis tools to check context
-// propagation:
-//
-// Do not store Contexts inside a struct type; instead, pass a Context
-// explicitly to each function that needs it. The Context should be the first
-// parameter, typically named ctx:
-//
-// 	func DoSomething(ctx context.Context, arg Arg) error {
-// 		// ... use ctx ...
-// 	}
-//
-// Do not pass a nil Context, even if a function permits it. Pass context.TODO
-// if you are unsure about which Context to use.
-//
-// Use context Values only for request-scoped data that transits processes and
-// APIs, not for passing optional parameters to functions.
-//
-// The same Context may be passed to functions running in different goroutines;
-// Contexts are safe for simultaneous use by multiple goroutines.
-//
-// See http://blog.golang.org/context for example code for a server that uses
-// Contexts.
-package context // import "golang.org/x/net/context"
-
-// Background returns a non-nil, empty Context. It is never canceled, has no
-// values, and has no deadline. It is typically used by the main function,
-// initialization, and tests, and as the top-level Context for incoming
-// requests.
-func Background() Context {
-	return background
-}
-
-// TODO returns a non-nil, empty Context. Code should use context.TODO when
-// it's unclear which Context to use or it is not yet available (because the
-// surrounding function has not yet been extended to accept a Context
-// parameter).  TODO is recognized by static analysis tools that determine
-// whether Contexts are propagated correctly in a program.
-func TODO() Context {
-	return todo
-}

vendor/golang.org/x/net/context/context_test.go

@@ -1,583 +0,0 @@
-// Copyright 2014 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 !go1.7
-
-package context
-
-import (
-	"fmt"
-	"math/rand"
-	"runtime"
-	"strings"
-	"sync"
-	"testing"
-	"time"
-)
-
-// otherContext is a Context that's not one of the types defined in context.go.
-// This lets us test code paths that differ based on the underlying type of the
-// Context.
-type otherContext struct {
-	Context
-}
-
-func TestBackground(t *testing.T) {
-	c := Background()
-	if c == nil {
-		t.Fatalf("Background returned nil")
-	}
-	select {
-	case x := <-c.Done():
-		t.Errorf("<-c.Done() == %v want nothing (it should block)", x)
-	default:
-	}
-	if got, want := fmt.Sprint(c), "context.Background"; got != want {
-		t.Errorf("Background().String() = %q want %q", got, want)
-	}
-}
-
-func TestTODO(t *testing.T) {
-	c := TODO()
-	if c == nil {
-		t.Fatalf("TODO returned nil")
-	}
-	select {
-	case x := <-c.Done():
-		t.Errorf("<-c.Done() == %v want nothing (it should block)", x)
-	default:
-	}
-	if got, want := fmt.Sprint(c), "context.TODO"; got != want {
-		t.Errorf("TODO().String() = %q want %q", got, want)
-	}
-}
-
-func TestWithCancel(t *testing.T) {
-	c1, cancel := WithCancel(Background())
-
-	if got, want := fmt.Sprint(c1), "context.Background.WithCancel"; got != want {
-		t.Errorf("c1.String() = %q want %q", got, want)
-	}
-
-	o := otherContext{c1}
-	c2, _ := WithCancel(o)
-	contexts := []Context{c1, o, c2}
-
-	for i, c := range contexts {
-		if d := c.Done(); d == nil {
-			t.Errorf("c[%d].Done() == %v want non-nil", i, d)
-		}
-		if e := c.Err(); e != nil {
-			t.Errorf("c[%d].Err() == %v want nil", i, e)
-		}
-
-		select {
-		case x := <-c.Done():
-			t.Errorf("<-c.Done() == %v want nothing (it should block)", x)
-		default:
-		}
-	}
-
-	cancel()
-	time.Sleep(100 * time.Millisecond) // let cancelation propagate
-
-	for i, c := range contexts {
-		select {
-		case <-c.Done():
-		default:
-			t.Errorf("<-c[%d].Done() blocked, but shouldn't have", i)
-		}
-		if e := c.Err(); e != Canceled {
-			t.Errorf("c[%d].Err() == %v want %v", i, e, Canceled)
-		}
-	}
-}
-
-func TestParentFinishesChild(t *testing.T) {
-	// Context tree:
-	// parent -> cancelChild
-	// parent -> valueChild -> timerChild
-	parent, cancel := WithCancel(Background())
-	cancelChild, stop := WithCancel(parent)
-	defer stop()
-	valueChild := WithValue(parent, "key", "value")
-	timerChild, stop := WithTimeout(valueChild, 10000*time.Hour)
-	defer stop()
-
-	select {
-	case x := <-parent.Done():
-		t.Errorf("<-parent.Done() == %v want nothing (it should block)", x)
-	case x := <-cancelChild.Done():
-		t.Errorf("<-cancelChild.Done() == %v want nothing (it should block)", x)
-	case x := <-timerChild.Done():
-		t.Errorf("<-timerChild.Done() == %v want nothing (it should block)", x)
-	case x := <-valueChild.Done():
-		t.Errorf("<-valueChild.Done() == %v want nothing (it should block)", x)
-	default:
-	}
-
-	// The parent's children should contain the two cancelable children.
-	pc := parent.(*cancelCtx)
-	cc := cancelChild.(*cancelCtx)
-	tc := timerChild.(*timerCtx)
-	pc.mu.Lock()
-	if len(pc.children) != 2 || !pc.children[cc] || !pc.children[tc] {
-		t.Errorf("bad linkage: pc.children = %v, want %v and %v",
-			pc.children, cc, tc)
-	}
-	pc.mu.Unlock()
-
-	if p, ok := parentCancelCtx(cc.Context); !ok || p != pc {
-		t.Errorf("bad linkage: parentCancelCtx(cancelChild.Context) = %v, %v want %v, true", p, ok, pc)
-	}
-	if p, ok := parentCancelCtx(tc.Context); !ok || p != pc {
-		t.Errorf("bad linkage: parentCancelCtx(timerChild.Context) = %v, %v want %v, true", p, ok, pc)
-	}
-
-	cancel()
-
-	pc.mu.Lock()
-	if len(pc.children) != 0 {
-		t.Errorf("pc.cancel didn't clear pc.children = %v", pc.children)
-	}
-	pc.mu.Unlock()
-
-	// parent and children should all be finished.
-	check := func(ctx Context, name string) {
-		select {
-		case <-ctx.Done():
-		default:
-			t.Errorf("<-%s.Done() blocked, but shouldn't have", name)
-		}
-		if e := ctx.Err(); e != Canceled {
-			t.Errorf("%s.Err() == %v want %v", name, e, Canceled)
-		}
-	}
-	check(parent, "parent")
-	check(cancelChild, "cancelChild")
-	check(valueChild, "valueChild")
-	check(timerChild, "timerChild")
-
-	// WithCancel should return a canceled context on a canceled parent.
-	precanceledChild := WithValue(parent, "key", "value")
-	select {
-	case <-precanceledChild.Done():
-	default:
-		t.Errorf("<-precanceledChild.Done() blocked, but shouldn't have")
-	}
-	if e := precanceledChild.Err(); e != Canceled {
-		t.Errorf("precanceledChild.Err() == %v want %v", e, Canceled)
-	}
-}
-
-func TestChildFinishesFirst(t *testing.T) {
-	cancelable, stop := WithCancel(Background())
-	defer stop()
-	for _, parent := range []Context{Background(), cancelable} {
-		child, cancel := WithCancel(parent)
-
-		select {
-		case x := <-parent.Done():
-			t.Errorf("<-parent.Done() == %v want nothing (it should block)", x)
-		case x := <-child.Done():
-			t.Errorf("<-child.Done() == %v want nothing (it should block)", x)
-		default:
-		}
-
-		cc := child.(*cancelCtx)
-		pc, pcok := parent.(*cancelCtx) // pcok == false when parent == Background()
-		if p, ok := parentCancelCtx(cc.Context); ok != pcok || (ok && pc != p) {
-			t.Errorf("bad linkage: parentCancelCtx(cc.Context) = %v, %v want %v, %v", p, ok, pc, pcok)
-		}
-
-		if pcok {
-			pc.mu.Lock()
-			if len(pc.children) != 1 || !pc.children[cc] {
-				t.Errorf("bad linkage: pc.children = %v, cc = %v", pc.children, cc)
-			}
-			pc.mu.Unlock()
-		}
-
-		cancel()
-
-		if pcok {
-			pc.mu.Lock()
-			if len(pc.children) != 0 {
-				t.Errorf("child's cancel didn't remove self from pc.children = %v", pc.children)
-			}
-			pc.mu.Unlock()
-		}
-
-		// child should be finished.
-		select {
-		case <-child.Done():
-		default:
-			t.Errorf("<-child.Done() blocked, but shouldn't have")
-		}
-		if e := child.Err(); e != Canceled {
-			t.Errorf("child.Err() == %v want %v", e, Canceled)
-		}
-
-		// parent should not be finished.
-		select {
-		case x := <-parent.Done():
-			t.Errorf("<-parent.Done() == %v want nothing (it should block)", x)
-		default:
-		}
-		if e := parent.Err(); e != nil {
-			t.Errorf("parent.Err() == %v want nil", e)
-		}
-	}
-}
-
-func testDeadline(c Context, wait time.Duration, t *testing.T) {
-	select {
-	case <-time.After(wait):
-		t.Fatalf("context should have timed out")
-	case <-c.Done():
-	}
-	if e := c.Err(); e != DeadlineExceeded {
-		t.Errorf("c.Err() == %v want %v", e, DeadlineExceeded)
-	}
-}
-
-func TestDeadline(t *testing.T) {
-	t.Parallel()
-	const timeUnit = 500 * time.Millisecond
-	c, _ := WithDeadline(Background(), time.Now().Add(1*timeUnit))
-	if got, prefix := fmt.Sprint(c), "context.Background.WithDeadline("; !strings.HasPrefix(got, prefix) {
-		t.Errorf("c.String() = %q want prefix %q", got, prefix)
-	}
-	testDeadline(c, 2*timeUnit, t)
-
-	c, _ = WithDeadline(Background(), time.Now().Add(1*timeUnit))
-	o := otherContext{c}
-	testDeadline(o, 2*timeUnit, t)
-
-	c, _ = WithDeadline(Background(), time.Now().Add(1*timeUnit))
-	o = otherContext{c}
-	c, _ = WithDeadline(o, time.Now().Add(3*timeUnit))
-	testDeadline(c, 2*timeUnit, t)
-}
-
-func TestTimeout(t *testing.T) {
-	t.Parallel()
-	const timeUnit = 500 * time.Millisecond
-	c, _ := WithTimeout(Background(), 1*timeUnit)
-	if got, prefix := fmt.Sprint(c), "context.Background.WithDeadline("; !strings.HasPrefix(got, prefix) {
-		t.Errorf("c.String() = %q want prefix %q", got, prefix)
-	}
-	testDeadline(c, 2*timeUnit, t)
-
-	c, _ = WithTimeout(Background(), 1*timeUnit)
-	o := otherContext{c}
-	testDeadline(o, 2*timeUnit, t)
-
-	c, _ = WithTimeout(Background(), 1*timeUnit)
-	o = otherContext{c}
-	c, _ = WithTimeout(o, 3*timeUnit)
-	testDeadline(c, 2*timeUnit, t)
-}
-
-func TestCanceledTimeout(t *testing.T) {
-	t.Parallel()
-	const timeUnit = 500 * time.Millisecond
-	c, _ := WithTimeout(Background(), 2*timeUnit)
-	o := otherContext{c}
-	c, cancel := WithTimeout(o, 4*timeUnit)
-	cancel()
-	time.Sleep(1 * timeUnit) // let cancelation propagate
-	select {
-	case <-c.Done():
-	default:
-		t.Errorf("<-c.Done() blocked, but shouldn't have")
-	}
-	if e := c.Err(); e != Canceled {
-		t.Errorf("c.Err() == %v want %v", e, Canceled)
-	}
-}
-
-type key1 int
-type key2 int
-
-var k1 = key1(1)
-var k2 = key2(1) // same int as k1, different type
-var k3 = key2(3) // same type as k2, different int
-
-func TestValues(t *testing.T) {
-	check := func(c Context, nm, v1, v2, v3 string) {
-		if v, ok := c.Value(k1).(string); ok == (len(v1) == 0) || v != v1 {
-			t.Errorf(`%s.Value(k1).(string) = %q, %t want %q, %t`, nm, v, ok, v1, len(v1) != 0)
-		}
-		if v, ok := c.Value(k2).(string); ok == (len(v2) == 0) || v != v2 {
-			t.Errorf(`%s.Value(k2).(string) = %q, %t want %q, %t`, nm, v, ok, v2, len(v2) != 0)
-		}
-		if v, ok := c.Value(k3).(string); ok == (len(v3) == 0) || v != v3 {
-			t.Errorf(`%s.Value(k3).(string) = %q, %t want %q, %t`, nm, v, ok, v3, len(v3) != 0)
-		}
-	}
-
-	c0 := Background()
-	check(c0, "c0", "", "", "")
-
-	c1 := WithValue(Background(), k1, "c1k1")
-	check(c1, "c1", "c1k1", "", "")
-
-	if got, want := fmt.Sprint(c1), `context.Background.WithValue(1, "c1k1")`; got != want {
-		t.Errorf("c.String() = %q want %q", got, want)
-	}
-
-	c2 := WithValue(c1, k2, "c2k2")
-	check(c2, "c2", "c1k1", "c2k2", "")
-
-	c3 := WithValue(c2, k3, "c3k3")
-	check(c3, "c2", "c1k1", "c2k2", "c3k3")
-
-	c4 := WithValue(c3, k1, nil)
-	check(c4, "c4", "", "c2k2", "c3k3")
-
-	o0 := otherContext{Background()}
-	check(o0, "o0", "", "", "")
-
-	o1 := otherContext{WithValue(Background(), k1, "c1k1")}
-	check(o1, "o1", "c1k1", "", "")
-
-	o2 := WithValue(o1, k2, "o2k2")
-	check(o2, "o2", "c1k1", "o2k2", "")
-
-	o3 := otherContext{c4}
-	check(o3, "o3", "", "c2k2", "c3k3")
-
-	o4 := WithValue(o3, k3, nil)
-	check(o4, "o4", "", "c2k2", "")
-}
-
-func TestAllocs(t *testing.T) {
-	bg := Background()
-	for _, test := range []struct {
-		desc       string
-		f          func()
-		limit      float64
-		gccgoLimit float64
-	}{
-		{
-			desc:       "Background()",
-			f:          func() { Background() },
-			limit:      0,
-			gccgoLimit: 0,
-		},
-		{
-			desc: fmt.Sprintf("WithValue(bg, %v, nil)", k1),
-			f: func() {
-				c := WithValue(bg, k1, nil)
-				c.Value(k1)
-			},
-			limit:      3,
-			gccgoLimit: 3,
-		},
-		{
-			desc: "WithTimeout(bg, 15*time.Millisecond)",
-			f: func() {
-				c, _ := WithTimeout(bg, 15*time.Millisecond)
-				<-c.Done()
-			},
-			limit:      8,
-			gccgoLimit: 16,
-		},
-		{
-			desc: "WithCancel(bg)",
-			f: func() {
-				c, cancel := WithCancel(bg)
-				cancel()
-				<-c.Done()
-			},
-			limit:      5,
-			gccgoLimit: 8,
-		},
-		{
-			desc: "WithTimeout(bg, 100*time.Millisecond)",
-			f: func() {
-				c, cancel := WithTimeout(bg, 100*time.Millisecond)
-				cancel()
-				<-c.Done()
-			},
-			limit:      8,
-			gccgoLimit: 25,
-		},
-	} {
-		limit := test.limit
-		if runtime.Compiler == "gccgo" {
-			// gccgo does not yet do escape analysis.
-			// TODO(iant): Remove this when gccgo does do escape analysis.
-			limit = test.gccgoLimit
-		}
-		if n := testing.AllocsPerRun(100, test.f); n > limit {
-			t.Errorf("%s allocs = %f want %d", test.desc, n, int(limit))
-		}
-	}
-}
-
-func TestSimultaneousCancels(t *testing.T) {
-	root, cancel := WithCancel(Background())
-	m := map[Context]CancelFunc{root: cancel}
-	q := []Context{root}
-	// Create a tree of contexts.
-	for len(q) != 0 && len(m) < 100 {
-		parent := q[0]
-		q = q[1:]
-		for i := 0; i < 4; i++ {
-			ctx, cancel := WithCancel(parent)
-			m[ctx] = cancel
-			q = append(q, ctx)
-		}
-	}
-	// Start all the cancels in a random order.
-	var wg sync.WaitGroup
-	wg.Add(len(m))
-	for _, cancel := range m {
-		go func(cancel CancelFunc) {
-			cancel()
-			wg.Done()
-		}(cancel)
-	}
-	// Wait on all the contexts in a random order.
-	for ctx := range m {
-		select {
-		case <-ctx.Done():
-		case <-time.After(1 * time.Second):
-			buf := make([]byte, 10<<10)
-			n := runtime.Stack(buf, true)
-			t.Fatalf("timed out waiting for <-ctx.Done(); stacks:\n%s", buf[:n])
-		}
-	}
-	// Wait for all the cancel functions to return.
-	done := make(chan struct{})
-	go func() {
-		wg.Wait()
-		close(done)
-	}()
-	select {
-	case <-done:
-	case <-time.After(1 * time.Second):
-		buf := make([]byte, 10<<10)
-		n := runtime.Stack(buf, true)
-		t.Fatalf("timed out waiting for cancel functions; stacks:\n%s", buf[:n])
-	}
-}
-
-func TestInterlockedCancels(t *testing.T) {
-	parent, cancelParent := WithCancel(Background())
-	child, cancelChild := WithCancel(parent)
-	go func() {
-		parent.Done()
-		cancelChild()
-	}()
-	cancelParent()
-	select {
-	case <-child.Done():
-	case <-time.After(1 * time.Second):
-		buf := make([]byte, 10<<10)
-		n := runtime.Stack(buf, true)
-		t.Fatalf("timed out waiting for child.Done(); stacks:\n%s", buf[:n])
-	}
-}
-
-func TestLayersCancel(t *testing.T) {
-	testLayers(t, time.Now().UnixNano(), false)
-}
-
-func TestLayersTimeout(t *testing.T) {
-	testLayers(t, time.Now().UnixNano(), true)
-}
-
-func testLayers(t *testing.T, seed int64, testTimeout bool) {
-	rand.Seed(seed)
-	errorf := func(format string, a ...interface{}) {
-		t.Errorf(fmt.Sprintf("seed=%d: %s", seed, format), a...)
-	}
-	const (
-		timeout   = 200 * time.Millisecond
-		minLayers = 30
-	)
-	type value int
-	var (
-		vals      []*value
-		cancels   []CancelFunc
-		numTimers int
-		ctx       = Background()
-	)
-	for i := 0; i < minLayers || numTimers == 0 || len(cancels) == 0 || len(vals) == 0; i++ {
-		switch rand.Intn(3) {
-		case 0:
-			v := new(value)
-			ctx = WithValue(ctx, v, v)
-			vals = append(vals, v)
-		case 1:
-			var cancel CancelFunc
-			ctx, cancel = WithCancel(ctx)
-			cancels = append(cancels, cancel)
-		case 2:
-			var cancel CancelFunc
-			ctx, cancel = WithTimeout(ctx, timeout)
-			cancels = append(cancels, cancel)
-			numTimers++
-		}
-	}
-	checkValues := func(when string) {
-		for _, key := range vals {
-			if val := ctx.Value(key).(*value); key != val {
-				errorf("%s: ctx.Value(%p) = %p want %p", when, key, val, key)
-			}
-		}
-	}
-	select {
-	case <-ctx.Done():
-		errorf("ctx should not be canceled yet")
-	default:
-	}
-	if s, prefix := fmt.Sprint(ctx), "context.Background."; !strings.HasPrefix(s, prefix) {
-		t.Errorf("ctx.String() = %q want prefix %q", s, prefix)
-	}
-	t.Log(ctx)
-	checkValues("before cancel")
-	if testTimeout {
-		select {
-		case <-ctx.Done():
-		case <-time.After(timeout + 100*time.Millisecond):
-			errorf("ctx should have timed out")
-		}
-		checkValues("after timeout")
-	} else {
-		cancel := cancels[rand.Intn(len(cancels))]
-		cancel()
-		select {
-		case <-ctx.Done():
-		default:
-			errorf("ctx should be canceled")
-		}
-		checkValues("after cancel")
-	}
-}
-
-func TestCancelRemoves(t *testing.T) {
-	checkChildren := func(when string, ctx Context, want int) {
-		if got := len(ctx.(*cancelCtx).children); got != want {
-			t.Errorf("%s: context has %d children, want %d", when, got, want)
-		}
-	}
-
-	ctx, _ := WithCancel(Background())
-	checkChildren("after creation", ctx, 0)
-	_, cancel := WithCancel(ctx)
-	checkChildren("with WithCancel child ", ctx, 1)
-	cancel()
-	checkChildren("after cancelling WithCancel child", ctx, 0)
-
-	ctx, _ = WithCancel(Background())
-	checkChildren("after creation", ctx, 0)
-	_, cancel = WithTimeout(ctx, 60*time.Minute)
-	checkChildren("with WithTimeout child ", ctx, 1)
-	cancel()
-	checkChildren("after cancelling WithTimeout child", ctx, 0)
-}

vendor/golang.org/x/net/context/ctxhttp/ctxhttp.go

@@ -1,74 +0,0 @@
-// Copyright 2016 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 go1.7
-
-// Package ctxhttp provides helper functions for performing context-aware HTTP requests.
-package ctxhttp // import "golang.org/x/net/context/ctxhttp"
-
-import (
-	"io"
-	"net/http"
-	"net/url"
-	"strings"
-
-	"golang.org/x/net/context"
-)
-
-// Do sends an HTTP request with the provided http.Client and returns
-// an HTTP response.
-//
-// If the client is nil, http.DefaultClient is used.
-//
-// The provided ctx must be non-nil. If it is canceled or times out,
-// ctx.Err() will be returned.
-func Do(ctx context.Context, client *http.Client, req *http.Request) (*http.Response, error) {
-	if client == nil {
-		client = http.DefaultClient
-	}
-	resp, err := client.Do(req.WithContext(ctx))
-	// If we got an error, and the context has been canceled,
-	// the context's error is probably more useful.
-	if err != nil {
-		select {
-		case <-ctx.Done():
-			err = ctx.Err()
-		default:
-		}
-	}
-	return resp, err
-}
-
-// Get issues a GET request via the Do function.
-func Get(ctx context.Context, client *http.Client, url string) (*http.Response, error) {
-	req, err := http.NewRequest("GET", url, nil)
-	if err != nil {
-		return nil, err
-	}
-	return Do(ctx, client, req)
-}
-
-// Head issues a HEAD request via the Do function.
-func Head(ctx context.Context, client *http.Client, url string) (*http.Response, error) {
-	req, err := http.NewRequest("HEAD", url, nil)
-	if err != nil {
-		return nil, err
-	}
-	return Do(ctx, client, req)
-}
-
-// Post issues a POST request via the Do function.
-func Post(ctx context.Context, client *http.Client, url string, bodyType string, body io.Reader) (*http.Response, error) {
-	req, err := http.NewRequest("POST", url, body)
-	if err != nil {
-		return nil, err
-	}
-	req.Header.Set("Content-Type", bodyType)
-	return Do(ctx, client, req)
-}
-
-// PostForm issues a POST request via the Do function.
-func PostForm(ctx context.Context, client *http.Client, url string, data url.Values) (*http.Response, error) {
-	return Post(ctx, client, url, "application/x-www-form-urlencoded", strings.NewReader(data.Encode()))
-}

vendor/golang.org/x/net/context/ctxhttp/ctxhttp_17_test.go

@@ -1,29 +0,0 @@
-// Copyright 2015 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,go1.7
-
-package ctxhttp
-
-import (
-	"io"
-	"net/http"
-	"net/http/httptest"
-	"testing"
-
-	"context"
-)
-
-func TestGo17Context(t *testing.T) {
-	ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		io.WriteString(w, "ok")
-	}))
-	defer ts.Close()
-	ctx := context.Background()
-	resp, err := Get(ctx, http.DefaultClient, ts.URL)
-	if resp == nil || err != nil {
-		t.Fatalf("error received from client: %v %v", err, resp)
-	}
-	resp.Body.Close()
-}

vendor/golang.org/x/net/context/ctxhttp/ctxhttp_pre17.go

@@ -1,147 +0,0 @@
-// Copyright 2015 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 !go1.7
-
-package ctxhttp // import "golang.org/x/net/context/ctxhttp"
-
-import (
-	"io"
-	"net/http"
-	"net/url"
-	"strings"
-
-	"golang.org/x/net/context"
-)
-
-func nop() {}
-
-var (
-	testHookContextDoneBeforeHeaders = nop
-	testHookDoReturned               = nop
-	testHookDidBodyClose             = nop
-)
-
-// Do sends an HTTP request with the provided http.Client and returns an HTTP response.
-// If the client is nil, http.DefaultClient is used.
-// If the context is canceled or times out, ctx.Err() will be returned.
-func Do(ctx context.Context, client *http.Client, req *http.Request) (*http.Response, error) {
-	if client == nil {
-		client = http.DefaultClient
-	}
-
-	// TODO(djd): Respect any existing value of req.Cancel.
-	cancel := make(chan struct{})
-	req.Cancel = cancel
-
-	type responseAndError struct {
-		resp *http.Response
-		err  error
-	}
-	result := make(chan responseAndError, 1)
-
-	// Make local copies of test hooks closed over by goroutines below.
-	// Prevents data races in tests.
-	testHookDoReturned := testHookDoReturned
-	testHookDidBodyClose := testHookDidBodyClose
-
-	go func() {
-		resp, err := client.Do(req)
-		testHookDoReturned()
-		result <- responseAndError{resp, err}
-	}()
-
-	var resp *http.Response
-
-	select {
-	case <-ctx.Done():
-		testHookContextDoneBeforeHeaders()
-		close(cancel)
-		// Clean up after the goroutine calling client.Do:
-		go func() {
-			if r := <-result; r.resp != nil {
-				testHookDidBodyClose()
-				r.resp.Body.Close()
-			}
-		}()
-		return nil, ctx.Err()
-	case r := <-result:
-		var err error
-		resp, err = r.resp, r.err
-		if err != nil {
-			return resp, err
-		}
-	}
-
-	c := make(chan struct{})
-	go func() {
-		select {
-		case <-ctx.Done():
-			close(cancel)
-		case <-c:
-			// The response's Body is closed.
-		}
-	}()
-	resp.Body = &notifyingReader{resp.Body, c}
-
-	return resp, nil
-}
-
-// Get issues a GET request via the Do function.
-func Get(ctx context.Context, client *http.Client, url string) (*http.Response, error) {
-	req, err := http.NewRequest("GET", url, nil)
-	if err != nil {
-		return nil, err
-	}
-	return Do(ctx, client, req)
-}
-
-// Head issues a HEAD request via the Do function.
-func Head(ctx context.Context, client *http.Client, url string) (*http.Response, error) {
-	req, err := http.NewRequest("HEAD", url, nil)
-	if err != nil {
-		return nil, err
-	}
-	return Do(ctx, client, req)
-}
-
-// Post issues a POST request via the Do function.
-func Post(ctx context.Context, client *http.Client, url string, bodyType string, body io.Reader) (*http.Response, error) {
-	req, err := http.NewRequest("POST", url, body)
-	if err != nil {
-		return nil, err
-	}
-	req.Header.Set("Content-Type", bodyType)
-	return Do(ctx, client, req)
-}
-
-// PostForm issues a POST request via the Do function.
-func PostForm(ctx context.Context, client *http.Client, url string, data url.Values) (*http.Response, error) {
-	return Post(ctx, client, url, "application/x-www-form-urlencoded", strings.NewReader(data.Encode()))
-}
-
-// notifyingReader is an io.ReadCloser that closes the notify channel after
-// Close is called or a Read fails on the underlying ReadCloser.
-type notifyingReader struct {
-	io.ReadCloser
-	notify chan<- struct{}
-}
-
-func (r *notifyingReader) Read(p []byte) (int, error) {
-	n, err := r.ReadCloser.Read(p)
-	if err != nil && r.notify != nil {
-		close(r.notify)
-		r.notify = nil
-	}
-	return n, err
-}
-
-func (r *notifyingReader) Close() error {
-	err := r.ReadCloser.Close()
-	if r.notify != nil {
-		close(r.notify)
-		r.notify = nil
-	}
-	return err
-}

vendor/golang.org/x/net/context/ctxhttp/ctxhttp_pre17_test.go

@@ -1,79 +0,0 @@
-// Copyright 2015 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,!go1.7
-
-package ctxhttp
-
-import (
-	"net"
-	"net/http"
-	"net/http/httptest"
-	"sync"
-	"testing"
-	"time"
-
-	"golang.org/x/net/context"
-)
-
-// golang.org/issue/14065
-func TestClosesResponseBodyOnCancel(t *testing.T) {
-	defer func() { testHookContextDoneBeforeHeaders = nop }()
-	defer func() { testHookDoReturned = nop }()
-	defer func() { testHookDidBodyClose = nop }()
-
-	ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {}))
-	defer ts.Close()
-
-	ctx, cancel := context.WithCancel(context.Background())
-
-	// closed when Do enters select case <-ctx.Done()
-	enteredDonePath := make(chan struct{})
-
-	testHookContextDoneBeforeHeaders = func() {
-		close(enteredDonePath)
-	}
-
-	testHookDoReturned = func() {
-		// We now have the result (the Flush'd headers) at least,
-		// so we can cancel the request.
-		cancel()
-
-		// But block the client.Do goroutine from sending
-		// until Do enters into the <-ctx.Done() path, since
-		// otherwise if both channels are readable, select
-		// picks a random one.
-		<-enteredDonePath
-	}
-
-	sawBodyClose := make(chan struct{})
-	testHookDidBodyClose = func() { close(sawBodyClose) }
-
-	tr := &http.Transport{}
-	defer tr.CloseIdleConnections()
-	c := &http.Client{Transport: tr}
-	req, _ := http.NewRequest("GET", ts.URL, nil)
-	_, doErr := Do(ctx, c, req)
-
-	select {
-	case <-sawBodyClose:
-	case <-time.After(5 * time.Second):
-		t.Fatal("timeout waiting for body to close")
-	}
-
-	if doErr != ctx.Err() {
-		t.Errorf("Do error = %v; want %v", doErr, ctx.Err())
-	}
-}
-
-type noteCloseConn struct {
-	net.Conn
-	onceClose sync.Once
-	closefn   func()
-}
-
-func (c *noteCloseConn) Close() error {
-	c.onceClose.Do(c.closefn)
-	return c.Conn.Close()
-}

vendor/golang.org/x/net/context/ctxhttp/ctxhttp_test.go

@@ -1,105 +0,0 @@
-// Copyright 2015 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 ctxhttp
-
-import (
-	"io"
-	"io/ioutil"
-	"net/http"
-	"net/http/httptest"
-	"testing"
-	"time"
-
-	"golang.org/x/net/context"
-)
-
-const (
-	requestDuration = 100 * time.Millisecond
-	requestBody     = "ok"
-)
-
-func okHandler(w http.ResponseWriter, r *http.Request) {
-	time.Sleep(requestDuration)
-	io.WriteString(w, requestBody)
-}
-
-func TestNoTimeout(t *testing.T) {
-	ts := httptest.NewServer(http.HandlerFunc(okHandler))
-	defer ts.Close()
-
-	ctx := context.Background()
-	res, err := Get(ctx, nil, ts.URL)
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer res.Body.Close()
-	slurp, err := ioutil.ReadAll(res.Body)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if string(slurp) != requestBody {
-		t.Errorf("body = %q; want %q", slurp, requestBody)
-	}
-}
-
-func TestCancelBeforeHeaders(t *testing.T) {
-	ctx, cancel := context.WithCancel(context.Background())
-
-	blockServer := make(chan struct{})
-	ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		cancel()
-		<-blockServer
-		io.WriteString(w, requestBody)
-	}))
-	defer ts.Close()
-	defer close(blockServer)
-
-	res, err := Get(ctx, nil, ts.URL)
-	if err == nil {
-		res.Body.Close()
-		t.Fatal("Get returned unexpected nil error")
-	}
-	if err != context.Canceled {
-		t.Errorf("err = %v; want %v", err, context.Canceled)
-	}
-}
-
-func TestCancelAfterHangingRequest(t *testing.T) {
-	ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		w.WriteHeader(http.StatusOK)
-		w.(http.Flusher).Flush()
-		<-w.(http.CloseNotifier).CloseNotify()
-	}))
-	defer ts.Close()
-
-	ctx, cancel := context.WithCancel(context.Background())
-	resp, err := Get(ctx, nil, ts.URL)
-	if err != nil {
-		t.Fatalf("unexpected error in Get: %v", err)
-	}
-
-	// Cancel befer reading the body.
-	// Reading Request.Body should fail, since the request was
-	// canceled before anything was written.
-	cancel()
-
-	done := make(chan struct{})
-
-	go func() {
-		b, err := ioutil.ReadAll(resp.Body)
-		if len(b) != 0 || err == nil {
-			t.Errorf(`Read got (%q, %v); want ("", error)`, b, err)
-		}
-		close(done)
-	}()
-
-	select {
-	case <-time.After(1 * time.Second):
-		t.Errorf("Test timed out")
-	case <-done:
-	}
-}

vendor/golang.org/x/net/context/go17.go

@@ -1,72 +0,0 @@
-// Copyright 2016 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 go1.7
-
-package context
-
-import (
-	"context" // standard library's context, as of Go 1.7
-	"time"
-)
-
-var (
-	todo       = context.TODO()
-	background = context.Background()
-)
-
-// Canceled is the error returned by Context.Err when the context is canceled.
-var Canceled = context.Canceled
-
-// DeadlineExceeded is the error returned by Context.Err when the context's
-// deadline passes.
-var DeadlineExceeded = context.DeadlineExceeded
-
-// WithCancel returns a copy of parent with a new Done channel. The returned
-// context's Done channel is closed when the returned cancel function is called
-// or when the parent context's Done channel is closed, whichever happens first.
-//
-// Canceling this context releases resources associated with it, so code should
-// call cancel as soon as the operations running in this Context complete.
-func WithCancel(parent Context) (ctx Context, cancel CancelFunc) {
-	ctx, f := context.WithCancel(parent)
-	return ctx, CancelFunc(f)
-}
-
-// WithDeadline returns a copy of the parent context with the deadline adjusted
-// to be no later than d. If the parent's deadline is already earlier than d,
-// WithDeadline(parent, d) is semantically equivalent to parent. The returned
-// context's Done channel is closed when the deadline expires, when the returned
-// cancel function is called, or when the parent context's Done channel is
-// closed, whichever happens first.
-//
-// Canceling this context releases resources associated with it, so code should
-// call cancel as soon as the operations running in this Context complete.
-func WithDeadline(parent Context, deadline time.Time) (Context, CancelFunc) {
-	ctx, f := context.WithDeadline(parent, deadline)
-	return ctx, CancelFunc(f)
-}
-
-// WithTimeout returns WithDeadline(parent, time.Now().Add(timeout)).
-//
-// Canceling this context releases resources associated with it, so code should
-// call cancel as soon as the operations running in this Context complete:
-//
-// 	func slowOperationWithTimeout(ctx context.Context) (Result, error) {
-// 		ctx, cancel := context.WithTimeout(ctx, 100*time.Millisecond)
-// 		defer cancel()  // releases resources if slowOperation completes before timeout elapses
-// 		return slowOperation(ctx)
-// 	}
-func WithTimeout(parent Context, timeout time.Duration) (Context, CancelFunc) {
-	return WithDeadline(parent, time.Now().Add(timeout))
-}
-
-// WithValue returns a copy of parent in which the value associated with key is
-// val.
-//
-// Use context Values only for request-scoped data that transits processes and
-// APIs, not for passing optional parameters to functions.
-func WithValue(parent Context, key interface{}, val interface{}) Context {
-	return context.WithValue(parent, key, val)
-}

vendor/golang.org/x/net/context/go19.go

@@ -1,20 +0,0 @@
-// Copyright 2017 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 go1.9
-
-package context
-
-import "context" // standard library's context, as of Go 1.7
-
-// A Context carries a deadline, a cancelation signal, and other values across
-// API boundaries.
-//
-// Context's methods may be called by multiple goroutines simultaneously.
-type Context = context.Context
-
-// A CancelFunc tells an operation to abandon its work.
-// A CancelFunc does not wait for the work to stop.
-// After the first call, subsequent calls to a CancelFunc do nothing.
-type CancelFunc = context.CancelFunc

vendor/golang.org/x/net/context/pre_go17.go

@@ -1,300 +0,0 @@
-// Copyright 2014 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 !go1.7
-
-package context
-
-import (
-	"errors"
-	"fmt"
-	"sync"
-	"time"
-)
-
-// An emptyCtx is never canceled, has no values, and has no deadline. It is not
-// struct{}, since vars of this type must have distinct addresses.
-type emptyCtx int
-
-func (*emptyCtx) Deadline() (deadline time.Time, ok bool) {
-	return
-}
-
-func (*emptyCtx) Done() <-chan struct{} {
-	return nil
-}
-
-func (*emptyCtx) Err() error {
-	return nil
-}
-
-func (*emptyCtx) Value(key interface{}) interface{} {
-	return nil
-}
-
-func (e *emptyCtx) String() string {
-	switch e {
-	case background:
-		return "context.Background"
-	case todo:
-		return "context.TODO"
-	}
-	return "unknown empty Context"
-}
-
-var (
-	background = new(emptyCtx)
-	todo       = new(emptyCtx)
-)
-
-// Canceled is the error returned by Context.Err when the context is canceled.
-var Canceled = errors.New("context canceled")
-
-// DeadlineExceeded is the error returned by Context.Err when the context's
-// deadline passes.
-var DeadlineExceeded = errors.New("context deadline exceeded")
-
-// WithCancel returns a copy of parent with a new Done channel. The returned
-// context's Done channel is closed when the returned cancel function is called
-// or when the parent context's Done channel is closed, whichever happens first.
-//
-// Canceling this context releases resources associated with it, so code should
-// call cancel as soon as the operations running in this Context complete.
-func WithCancel(parent Context) (ctx Context, cancel CancelFunc) {
-	c := newCancelCtx(parent)
-	propagateCancel(parent, c)
-	return c, func() { c.cancel(true, Canceled) }
-}
-
-// newCancelCtx returns an initialized cancelCtx.
-func newCancelCtx(parent Context) *cancelCtx {
-	return &cancelCtx{
-		Context: parent,
-		done:    make(chan struct{}),
-	}
-}
-
-// propagateCancel arranges for child to be canceled when parent is.
-func propagateCancel(parent Context, child canceler) {
-	if parent.Done() == nil {
-		return // parent is never canceled
-	}
-	if p, ok := parentCancelCtx(parent); ok {
-		p.mu.Lock()
-		if p.err != nil {
-			// parent has already been canceled
-			child.cancel(false, p.err)
-		} else {
-			if p.children == nil {
-				p.children = make(map[canceler]bool)
-			}
-			p.children[child] = true
-		}
-		p.mu.Unlock()
-	} else {
-		go func() {
-			select {
-			case <-parent.Done():
-				child.cancel(false, parent.Err())
-			case <-child.Done():
-			}
-		}()
-	}
-}
-
-// parentCancelCtx follows a chain of parent references until it finds a
-// *cancelCtx. This function understands how each of the concrete types in this
-// package represents its parent.
-func parentCancelCtx(parent Context) (*cancelCtx, bool) {
-	for {
-		switch c := parent.(type) {
-		case *cancelCtx:
-			return c, true
-		case *timerCtx:
-			return c.cancelCtx, true
-		case *valueCtx:
-			parent = c.Context
-		default:
-			return nil, false
-		}
-	}
-}
-
-// removeChild removes a context from its parent.
-func removeChild(parent Context, child canceler) {
-	p, ok := parentCancelCtx(parent)
-	if !ok {
-		return
-	}
-	p.mu.Lock()
-	if p.children != nil {
-		delete(p.children, child)
-	}
-	p.mu.Unlock()
-}
-
-// A canceler is a context type that can be canceled directly. The
-// implementations are *cancelCtx and *timerCtx.
-type canceler interface {
-	cancel(removeFromParent bool, err error)
-	Done() <-chan struct{}
-}
-
-// A cancelCtx can be canceled. When canceled, it also cancels any children
-// that implement canceler.
-type cancelCtx struct {
-	Context
-
-	done chan struct{} // closed by the first cancel call.
-
-	mu       sync.Mutex
-	children map[canceler]bool // set to nil by the first cancel call
-	err      error             // set to non-nil by the first cancel call
-}
-
-func (c *cancelCtx) Done() <-chan struct{} {
-	return c.done
-}
-
-func (c *cancelCtx) Err() error {
-	c.mu.Lock()
-	defer c.mu.Unlock()
-	return c.err
-}
-
-func (c *cancelCtx) String() string {
-	return fmt.Sprintf("%v.WithCancel", c.Context)
-}
-
-// cancel closes c.done, cancels each of c's children, and, if
-// removeFromParent is true, removes c from its parent's children.
-func (c *cancelCtx) cancel(removeFromParent bool, err error) {
-	if err == nil {
-		panic("context: internal error: missing cancel error")
-	}
-	c.mu.Lock()
-	if c.err != nil {
-		c.mu.Unlock()
-		return // already canceled
-	}
-	c.err = err
-	close(c.done)
-	for child := range c.children {
-		// NOTE: acquiring the child's lock while holding parent's lock.
-		child.cancel(false, err)
-	}
-	c.children = nil
-	c.mu.Unlock()
-
-	if removeFromParent {
-		removeChild(c.Context, c)
-	}
-}
-
-// WithDeadline returns a copy of the parent context with the deadline adjusted
-// to be no later than d. If the parent's deadline is already earlier than d,
-// WithDeadline(parent, d) is semantically equivalent to parent. The returned
-// context's Done channel is closed when the deadline expires, when the returned
-// cancel function is called, or when the parent context's Done channel is
-// closed, whichever happens first.
-//
-// Canceling this context releases resources associated with it, so code should
-// call cancel as soon as the operations running in this Context complete.
-func WithDeadline(parent Context, deadline time.Time) (Context, CancelFunc) {
-	if cur, ok := parent.Deadline(); ok && cur.Before(deadline) {
-		// The current deadline is already sooner than the new one.
-		return WithCancel(parent)
-	}
-	c := &timerCtx{
-		cancelCtx: newCancelCtx(parent),
-		deadline:  deadline,
-	}
-	propagateCancel(parent, c)
-	d := deadline.Sub(time.Now())
-	if d <= 0 {
-		c.cancel(true, DeadlineExceeded) // deadline has already passed
-		return c, func() { c.cancel(true, Canceled) }
-	}
-	c.mu.Lock()
-	defer c.mu.Unlock()
-	if c.err == nil {
-		c.timer = time.AfterFunc(d, func() {
-			c.cancel(true, DeadlineExceeded)
-		})
-	}
-	return c, func() { c.cancel(true, Canceled) }
-}
-
-// A timerCtx carries a timer and a deadline. It embeds a cancelCtx to
-// implement Done and Err. It implements cancel by stopping its timer then
-// delegating to cancelCtx.cancel.
-type timerCtx struct {
-	*cancelCtx
-	timer *time.Timer // Under cancelCtx.mu.
-
-	deadline time.Time
-}
-
-func (c *timerCtx) Deadline() (deadline time.Time, ok bool) {
-	return c.deadline, true
-}
-
-func (c *timerCtx) String() string {
-	return fmt.Sprintf("%v.WithDeadline(%s [%s])", c.cancelCtx.Context, c.deadline, c.deadline.Sub(time.Now()))
-}
-
-func (c *timerCtx) cancel(removeFromParent bool, err error) {
-	c.cancelCtx.cancel(false, err)
-	if removeFromParent {
-		// Remove this timerCtx from its parent cancelCtx's children.
-		removeChild(c.cancelCtx.Context, c)
-	}
-	c.mu.Lock()
-	if c.timer != nil {
-		c.timer.Stop()
-		c.timer = nil
-	}
-	c.mu.Unlock()
-}
-
-// WithTimeout returns WithDeadline(parent, time.Now().Add(timeout)).
-//
-// Canceling this context releases resources associated with it, so code should
-// call cancel as soon as the operations running in this Context complete:
-//
-// 	func slowOperationWithTimeout(ctx context.Context) (Result, error) {
-// 		ctx, cancel := context.WithTimeout(ctx, 100*time.Millisecond)
-// 		defer cancel()  // releases resources if slowOperation completes before timeout elapses
-// 		return slowOperation(ctx)
-// 	}
-func WithTimeout(parent Context, timeout time.Duration) (Context, CancelFunc) {
-	return WithDeadline(parent, time.Now().Add(timeout))
-}
-
-// WithValue returns a copy of parent in which the value associated with key is
-// val.
-//
-// Use context Values only for request-scoped data that transits processes and
-// APIs, not for passing optional parameters to functions.
-func WithValue(parent Context, key interface{}, val interface{}) Context {
-	return &valueCtx{parent, key, val}
-}
-
-// A valueCtx carries a key-value pair. It implements Value for that key and
-// delegates all other calls to the embedded Context.
-type valueCtx struct {
-	Context
-	key, val interface{}
-}
-
-func (c *valueCtx) String() string {
-	return fmt.Sprintf("%v.WithValue(%#v, %#v)", c.Context, c.key, c.val)
-}
-
-func (c *valueCtx) Value(key interface{}) interface{} {
-	if c.key == key {
-		return c.val
-	}
-	return c.Context.Value(key)
-}

vendor/golang.org/x/net/context/pre_go19.go

@@ -1,109 +0,0 @@
-// Copyright 2014 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 !go1.9
-
-package context
-
-import "time"
-
-// A Context carries a deadline, a cancelation signal, and other values across
-// API boundaries.
-//
-// Context's methods may be called by multiple goroutines simultaneously.
-type Context interface {
-	// Deadline returns the time when work done on behalf of this context
-	// should be canceled. Deadline returns ok==false when no deadline is
-	// set. Successive calls to Deadline return the same results.
-	Deadline() (deadline time.Time, ok bool)
-
-	// Done returns a channel that's closed when work done on behalf of this
-	// context should be canceled. Done may return nil if this context can
-	// never be canceled. Successive calls to Done return the same value.
-	//
-	// WithCancel arranges for Done to be closed when cancel is called;
-	// WithDeadline arranges for Done to be closed when the deadline
-	// expires; WithTimeout arranges for Done to be closed when the timeout
-	// elapses.
-	//
-	// Done is provided for use in select statements:
-	//
-	//  // Stream generates values with DoSomething and sends them to out
-	//  // until DoSomething returns an error or ctx.Done is closed.
-	//  func Stream(ctx context.Context, out chan<- Value) error {
-	//  	for {
-	//  		v, err := DoSomething(ctx)
-	//  		if err != nil {
-	//  			return err
-	//  		}
-	//  		select {
-	//  		case <-ctx.Done():
-	//  			return ctx.Err()
-	//  		case out <- v:
-	//  		}
-	//  	}
-	//  }
-	//
-	// See http://blog.golang.org/pipelines for more examples of how to use
-	// a Done channel for cancelation.
-	Done() <-chan struct{}
-
-	// Err returns a non-nil error value after Done is closed. Err returns
-	// Canceled if the context was canceled or DeadlineExceeded if the
-	// context's deadline passed. No other values for Err are defined.
-	// After Done is closed, successive calls to Err return the same value.
-	Err() error
-
-	// Value returns the value associated with this context for key, or nil
-	// if no value is associated with key. Successive calls to Value with
-	// the same key returns the same result.
-	//
-	// Use context values only for request-scoped data that transits
-	// processes and API boundaries, not for passing optional parameters to
-	// functions.
-	//
-	// A key identifies a specific value in a Context. Functions that wish
-	// to store values in Context typically allocate a key in a global
-	// variable then use that key as the argument to context.WithValue and
-	// Context.Value. A key can be any type that supports equality;
-	// packages should define keys as an unexported type to avoid
-	// collisions.
-	//
-	// Packages that define a Context key should provide type-safe accessors
-	// for the values stores using that key:
-	//
-	// 	// Package user defines a User type that's stored in Contexts.
-	// 	package user
-	//
-	// 	import "golang.org/x/net/context"
-	//
-	// 	// User is the type of value stored in the Contexts.
-	// 	type User struct {...}
-	//
-	// 	// key is an unexported type for keys defined in this package.
-	// 	// This prevents collisions with keys defined in other packages.
-	// 	type key int
-	//
-	// 	// userKey is the key for user.User values in Contexts. It is
-	// 	// unexported; clients use user.NewContext and user.FromContext
-	// 	// instead of using this key directly.
-	// 	var userKey key = 0
-	//
-	// 	// NewContext returns a new Context that carries value u.
-	// 	func NewContext(ctx context.Context, u *User) context.Context {
-	// 		return context.WithValue(ctx, userKey, u)
-	// 	}
-	//
-	// 	// FromContext returns the User value stored in ctx, if any.
-	// 	func FromContext(ctx context.Context) (*User, bool) {
-	// 		u, ok := ctx.Value(userKey).(*User)
-	// 		return u, ok
-	// 	}
-	Value(key interface{}) interface{}
-}
-
-// A CancelFunc tells an operation to abandon its work.
-// A CancelFunc does not wait for the work to stop.
-// After the first call, subsequent calls to a CancelFunc do nothing.
-type CancelFunc func()

vendor/golang.org/x/net/context/withtimeout_test.go

@@ -1,31 +0,0 @@
-// Copyright 2014 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package context_test
-
-import (
-	"fmt"
-	"time"
-
-	"golang.org/x/net/context"
-)
-
-// This example passes a context with a timeout to tell a blocking function that
-// it should abandon its work after the timeout elapses.
-func ExampleWithTimeout() {
-	// Pass a context with a timeout to tell a blocking function that it
-	// should abandon its work after the timeout elapses.
-	ctx, cancel := context.WithTimeout(context.Background(), 50*time.Millisecond)
-	defer cancel()
-
-	select {
-	case <-time.After(1 * time.Second):
-		fmt.Println("overslept")
-	case <-ctx.Done():
-		fmt.Println(ctx.Err()) // prints "context deadline exceeded"
-	}
-
-	// Output:
-	// context deadline exceeded
-}

vendor/golang.org/x/net/dict/dict.go

@@ -1,210 +0,0 @@
-// Copyright 2010 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Package dict implements the Dictionary Server Protocol
-// as defined in RFC 2229.
-package dict // import "golang.org/x/net/dict"
-
-import (
-	"net/textproto"
-	"strconv"
-	"strings"
-)
-
-// A Client represents a client connection to a dictionary server.
-type Client struct {
-	text *textproto.Conn
-}
-
-// Dial returns a new client connected to a dictionary server at
-// addr on the given network.
-func Dial(network, addr string) (*Client, error) {
-	text, err := textproto.Dial(network, addr)
-	if err != nil {
-		return nil, err
-	}
-	_, _, err = text.ReadCodeLine(220)
-	if err != nil {
-		text.Close()
-		return nil, err
-	}
-	return &Client{text: text}, nil
-}
-
-// Close closes the connection to the dictionary server.
-func (c *Client) Close() error {
-	return c.text.Close()
-}
-
-// A Dict represents a dictionary available on the server.
-type Dict struct {
-	Name string // short name of dictionary
-	Desc string // long description
-}
-
-// Dicts returns a list of the dictionaries available on the server.
-func (c *Client) Dicts() ([]Dict, error) {
-	id, err := c.text.Cmd("SHOW DB")
-	if err != nil {
-		return nil, err
-	}
-
-	c.text.StartResponse(id)
-	defer c.text.EndResponse(id)
-
-	_, _, err = c.text.ReadCodeLine(110)
-	if err != nil {
-		return nil, err
-	}
-	lines, err := c.text.ReadDotLines()
-	if err != nil {
-		return nil, err
-	}
-	_, _, err = c.text.ReadCodeLine(250)
-
-	dicts := make([]Dict, len(lines))
-	for i := range dicts {
-		d := &dicts[i]
-		a, _ := fields(lines[i])
-		if len(a) < 2 {
-			return nil, textproto.ProtocolError("invalid dictionary: " + lines[i])
-		}
-		d.Name = a[0]
-		d.Desc = a[1]
-	}
-	return dicts, err
-}
-
-// A Defn represents a definition.
-type Defn struct {
-	Dict Dict   // Dict where definition was found
-	Word string // Word being defined
-	Text []byte // Definition text, typically multiple lines
-}
-
-// Define requests the definition of the given word.
-// The argument dict names the dictionary to use,
-// the Name field of a Dict returned by Dicts.
-//
-// The special dictionary name "*" means to look in all the
-// server's dictionaries.
-// The special dictionary name "!" means to look in all the
-// server's dictionaries in turn, stopping after finding the word
-// in one of them.
-func (c *Client) Define(dict, word string) ([]*Defn, error) {
-	id, err := c.text.Cmd("DEFINE %s %q", dict, word)
-	if err != nil {
-		return nil, err
-	}
-
-	c.text.StartResponse(id)
-	defer c.text.EndResponse(id)
-
-	_, line, err := c.text.ReadCodeLine(150)
-	if err != nil {
-		return nil, err
-	}
-	a, _ := fields(line)
-	if len(a) < 1 {
-		return nil, textproto.ProtocolError("malformed response: " + line)
-	}
-	n, err := strconv.Atoi(a[0])
-	if err != nil {
-		return nil, textproto.ProtocolError("invalid definition count: " + a[0])
-	}
-	def := make([]*Defn, n)
-	for i := 0; i < n; i++ {
-		_, line, err = c.text.ReadCodeLine(151)
-		if err != nil {
-			return nil, err
-		}
-		a, _ := fields(line)
-		if len(a) < 3 {
-			// skip it, to keep protocol in sync
-			i--
-			n--
-			def = def[0:n]
-			continue
-		}
-		d := &Defn{Word: a[0], Dict: Dict{a[1], a[2]}}
-		d.Text, err = c.text.ReadDotBytes()
-		if err != nil {
-			return nil, err
-		}
-		def[i] = d
-	}
-	_, _, err = c.text.ReadCodeLine(250)
-	return def, err
-}
-
-// Fields returns the fields in s.
-// Fields are space separated unquoted words
-// or quoted with single or double quote.
-func fields(s string) ([]string, error) {
-	var v []string
-	i := 0
-	for {
-		for i < len(s) && (s[i] == ' ' || s[i] == '\t') {
-			i++
-		}
-		if i >= len(s) {
-			break
-		}
-		if s[i] == '"' || s[i] == '\'' {
-			q := s[i]
-			// quoted string
-			var j int
-			for j = i + 1; ; j++ {
-				if j >= len(s) {
-					return nil, textproto.ProtocolError("malformed quoted string")
-				}
-				if s[j] == '\\' {
-					j++
-					continue
-				}
-				if s[j] == q {
-					j++
-					break
-				}
-			}
-			v = append(v, unquote(s[i+1:j-1]))
-			i = j
-		} else {
-			// atom
-			var j int
-			for j = i; j < len(s); j++ {
-				if s[j] == ' ' || s[j] == '\t' || s[j] == '\\' || s[j] == '"' || s[j] == '\'' {
-					break
-				}
-			}
-			v = append(v, s[i:j])
-			i = j
-		}
-		if i < len(s) {
-			c := s[i]
-			if c != ' ' && c != '\t' {
-				return nil, textproto.ProtocolError("quotes not on word boundaries")
-			}
-		}
-	}
-	return v, nil
-}
-
-func unquote(s string) string {
-	if strings.Index(s, "\\") < 0 {
-		return s
-	}
-	b := []byte(s)
-	w := 0
-	for r := 0; r < len(b); r++ {
-		c := b[r]
-		if c == '\\' {
-			r++
-			c = b[r]
-		}
-		b[w] = c
-		w++
-	}
-	return string(b[0:w])
-}

vendor/golang.org/x/net/dns/dnsmessage/example_test.go

@@ -1,132 +0,0 @@
-// Copyright 2017 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package dnsmessage_test
-
-import (
-	"fmt"
-	"net"
-	"strings"
-
-	"golang.org/x/net/dns/dnsmessage"
-)
-
-func mustNewName(name string) dnsmessage.Name {
-	n, err := dnsmessage.NewName(name)
-	if err != nil {
-		panic(err)
-	}
-	return n
-}
-
-func ExampleParser() {
-	msg := dnsmessage.Message{
-		Header: dnsmessage.Header{Response: true, Authoritative: true},
-		Questions: []dnsmessage.Question{
-			{
-				Name:  mustNewName("foo.bar.example.com."),
-				Type:  dnsmessage.TypeA,
-				Class: dnsmessage.ClassINET,
-			},
-			{
-				Name:  mustNewName("bar.example.com."),
-				Type:  dnsmessage.TypeA,
-				Class: dnsmessage.ClassINET,
-			},
-		},
-		Answers: []dnsmessage.Resource{
-			{
-				dnsmessage.ResourceHeader{
-					Name:  mustNewName("foo.bar.example.com."),
-					Type:  dnsmessage.TypeA,
-					Class: dnsmessage.ClassINET,
-				},
-				&dnsmessage.AResource{[4]byte{127, 0, 0, 1}},
-			},
-			{
-				dnsmessage.ResourceHeader{
-					Name:  mustNewName("bar.example.com."),
-					Type:  dnsmessage.TypeA,
-					Class: dnsmessage.ClassINET,
-				},
-				&dnsmessage.AResource{[4]byte{127, 0, 0, 2}},
-			},
-		},
-	}
-
-	buf, err := msg.Pack()
-	if err != nil {
-		panic(err)
-	}
-
-	wantName := "bar.example.com."
-
-	var p dnsmessage.Parser
-	if _, err := p.Start(buf); err != nil {
-		panic(err)
-	}
-
-	for {
-		q, err := p.Question()
-		if err == dnsmessage.ErrSectionDone {
-			break
-		}
-		if err != nil {
-			panic(err)
-		}
-
-		if q.Name.String() != wantName {
-			continue
-		}
-
-		fmt.Println("Found question for name", wantName)
-		if err := p.SkipAllQuestions(); err != nil {
-			panic(err)
-		}
-		break
-	}
-
-	var gotIPs []net.IP
-	for {
-		h, err := p.AnswerHeader()
-		if err == dnsmessage.ErrSectionDone {
-			break
-		}
-		if err != nil {
-			panic(err)
-		}
-
-		if (h.Type != dnsmessage.TypeA && h.Type != dnsmessage.TypeAAAA) || h.Class != dnsmessage.ClassINET {
-			continue
-		}
-
-		if !strings.EqualFold(h.Name.String(), wantName) {
-			if err := p.SkipAnswer(); err != nil {
-				panic(err)
-			}
-			continue
-		}
-
-		switch h.Type {
-		case dnsmessage.TypeA:
-			r, err := p.AResource()
-			if err != nil {
-				panic(err)
-			}
-			gotIPs = append(gotIPs, r.A[:])
-		case dnsmessage.TypeAAAA:
-			r, err := p.AAAAResource()
-			if err != nil {
-				panic(err)
-			}
-			gotIPs = append(gotIPs, r.AAAA[:])
-		}
-	}
-
-	fmt.Printf("Found A/AAAA records for name %s: %v\n", wantName, gotIPs)
-
-	// Output:
-	// Found question for name bar.example.com.
-	// Found A/AAAA records for name bar.example.com.: [127.0.0.2]
-}

vendor/golang.org/x/net/http2/.gitignore

@@ -1,2 +0,0 @@
-*~
-h2i/h2i

vendor/golang.org/x/net/http2/Dockerfile

@@ -1,51 +0,0 @@
-#
-# This Dockerfile builds a recent curl with HTTP/2 client support, using
-# a recent nghttp2 build.
-#
-# See the Makefile for how to tag it. If Docker and that image is found, the
-# Go tests use this curl binary for integration tests.
-#
-
-FROM ubuntu:trusty
-
-RUN apt-get update && \
-    apt-get upgrade -y && \
-    apt-get install -y git-core build-essential wget
-
-RUN apt-get install -y --no-install-recommends \
-       autotools-dev libtool pkg-config zlib1g-dev \
-       libcunit1-dev libssl-dev libxml2-dev libevent-dev \
-       automake autoconf
-
-# The list of packages nghttp2 recommends for h2load:
-RUN apt-get install -y --no-install-recommends make binutils \
-        autoconf automake autotools-dev \
-        libtool pkg-config zlib1g-dev libcunit1-dev libssl-dev libxml2-dev \
-        libev-dev libevent-dev libjansson-dev libjemalloc-dev \
-        cython python3.4-dev python-setuptools
-
-# Note: setting NGHTTP2_VER before the git clone, so an old git clone isn't cached:
-ENV NGHTTP2_VER 895da9a
-RUN cd /root && git clone https://github.com/tatsuhiro-t/nghttp2.git
-
-WORKDIR /root/nghttp2
-RUN git reset --hard $NGHTTP2_VER
-RUN autoreconf -i
-RUN automake
-RUN autoconf
-RUN ./configure
-RUN make
-RUN make install
-
-WORKDIR /root
-RUN wget http://curl.haxx.se/download/curl-7.45.0.tar.gz
-RUN tar -zxvf curl-7.45.0.tar.gz
-WORKDIR /root/curl-7.45.0
-RUN ./configure --with-ssl --with-nghttp2=/usr/local
-RUN make
-RUN make install
-RUN ldconfig
-
-CMD ["-h"]
-ENTRYPOINT ["/usr/local/bin/curl"]
-

vendor/golang.org/x/net/http2/Makefile

@@ -1,3 +0,0 @@
-curlimage:
-	docker build -t gohttp2/curl .
-

vendor/golang.org/x/net/http2/README

@@ -1,20 +0,0 @@
-This is a work-in-progress HTTP/2 implementation for Go.
-
-It will eventually live in the Go standard library and won't require
-any changes to your code to use.  It will just be automatic.
-
-Status:
-
-* The server support is pretty good. A few things are missing
-  but are being worked on.
-* The client work has just started but shares a lot of code
-  is coming along much quicker.
-
-Docs are at https://godoc.org/golang.org/x/net/http2
-
-Demo test server at https://http2.golang.org/
-
-Help & bug reports welcome!
-
-Contributing: https://golang.org/doc/contribute.html
-Bugs:         https://golang.org/issue/new?title=x/net/http2:+

vendor/golang.org/x/net/http2/ciphers.go

@@ -1,641 +0,0 @@
-// Copyright 2017 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package http2
-
-// A list of the possible cipher suite ids. Taken from
-// http://www.iana.org/assignments/tls-parameters/tls-parameters.txt
-
-const (
-	cipher_TLS_NULL_WITH_NULL_NULL               uint16 = 0x0000
-	cipher_TLS_RSA_WITH_NULL_MD5                 uint16 = 0x0001
-	cipher_TLS_RSA_WITH_NULL_SHA                 uint16 = 0x0002
-	cipher_TLS_RSA_EXPORT_WITH_RC4_40_MD5        uint16 = 0x0003
-	cipher_TLS_RSA_WITH_RC4_128_MD5              uint16 = 0x0004
-	cipher_TLS_RSA_WITH_RC4_128_SHA              uint16 = 0x0005
-	cipher_TLS_RSA_EXPORT_WITH_RC2_CBC_40_MD5    uint16 = 0x0006
-	cipher_TLS_RSA_WITH_IDEA_CBC_SHA             uint16 = 0x0007
-	cipher_TLS_RSA_EXPORT_WITH_DES40_CBC_SHA     uint16 = 0x0008
-	cipher_TLS_RSA_WITH_DES_CBC_SHA              uint16 = 0x0009
-	cipher_TLS_RSA_WITH_3DES_EDE_CBC_SHA         uint16 = 0x000A
-	cipher_TLS_DH_DSS_EXPORT_WITH_DES40_CBC_SHA  uint16 = 0x000B
-	cipher_TLS_DH_DSS_WITH_DES_CBC_SHA           uint16 = 0x000C
-	cipher_TLS_DH_DSS_WITH_3DES_EDE_CBC_SHA      uint16 = 0x000D
-	cipher_TLS_DH_RSA_EXPORT_WITH_DES40_CBC_SHA  uint16 = 0x000E
-	cipher_TLS_DH_RSA_WITH_DES_CBC_SHA           uint16 = 0x000F
-	cipher_TLS_DH_RSA_WITH_3DES_EDE_CBC_SHA      uint16 = 0x0010
-	cipher_TLS_DHE_DSS_EXPORT_WITH_DES40_CBC_SHA uint16 = 0x0011
-	cipher_TLS_DHE_DSS_WITH_DES_CBC_SHA          uint16 = 0x0012
-	cipher_TLS_DHE_DSS_WITH_3DES_EDE_CBC_SHA     uint16 = 0x0013
-	cipher_TLS_DHE_RSA_EXPORT_WITH_DES40_CBC_SHA uint16 = 0x0014
-	cipher_TLS_DHE_RSA_WITH_DES_CBC_SHA          uint16 = 0x0015
-	cipher_TLS_DHE_RSA_WITH_3DES_EDE_CBC_SHA     uint16 = 0x0016
-	cipher_TLS_DH_anon_EXPORT_WITH_RC4_40_MD5    uint16 = 0x0017
-	cipher_TLS_DH_anon_WITH_RC4_128_MD5          uint16 = 0x0018
-	cipher_TLS_DH_anon_EXPORT_WITH_DES40_CBC_SHA uint16 = 0x0019
-	cipher_TLS_DH_anon_WITH_DES_CBC_SHA          uint16 = 0x001A
-	cipher_TLS_DH_anon_WITH_3DES_EDE_CBC_SHA     uint16 = 0x001B
-	// Reserved uint16 =  0x001C-1D
-	cipher_TLS_KRB5_WITH_DES_CBC_SHA             uint16 = 0x001E
-	cipher_TLS_KRB5_WITH_3DES_EDE_CBC_SHA        uint16 = 0x001F
-	cipher_TLS_KRB5_WITH_RC4_128_SHA             uint16 = 0x0020
-	cipher_TLS_KRB5_WITH_IDEA_CBC_SHA            uint16 = 0x0021
-	cipher_TLS_KRB5_WITH_DES_CBC_MD5             uint16 = 0x0022
-	cipher_TLS_KRB5_WITH_3DES_EDE_CBC_MD5        uint16 = 0x0023
-	cipher_TLS_KRB5_WITH_RC4_128_MD5             uint16 = 0x0024
-	cipher_TLS_KRB5_WITH_IDEA_CBC_MD5            uint16 = 0x0025
-	cipher_TLS_KRB5_EXPORT_WITH_DES_CBC_40_SHA   uint16 = 0x0026
-	cipher_TLS_KRB5_EXPORT_WITH_RC2_CBC_40_SHA   uint16 = 0x0027
-	cipher_TLS_KRB5_EXPORT_WITH_RC4_40_SHA       uint16 = 0x0028
-	cipher_TLS_KRB5_EXPORT_WITH_DES_CBC_40_MD5   uint16 = 0x0029
-	cipher_TLS_KRB5_EXPORT_WITH_RC2_CBC_40_MD5   uint16 = 0x002A
-	cipher_TLS_KRB5_EXPORT_WITH_RC4_40_MD5       uint16 = 0x002B
-	cipher_TLS_PSK_WITH_NULL_SHA                 uint16 = 0x002C
-	cipher_TLS_DHE_PSK_WITH_NULL_SHA             uint16 = 0x002D
-	cipher_TLS_RSA_PSK_WITH_NULL_SHA             uint16 = 0x002E
-	cipher_TLS_RSA_WITH_AES_128_CBC_SHA          uint16 = 0x002F
-	cipher_TLS_DH_DSS_WITH_AES_128_CBC_SHA       uint16 = 0x0030
-	cipher_TLS_DH_RSA_WITH_AES_128_CBC_SHA       uint16 = 0x0031
-	cipher_TLS_DHE_DSS_WITH_AES_128_CBC_SHA      uint16 = 0x0032
-	cipher_TLS_DHE_RSA_WITH_AES_128_CBC_SHA      uint16 = 0x0033
-	cipher_TLS_DH_anon_WITH_AES_128_CBC_SHA      uint16 = 0x0034
-	cipher_TLS_RSA_WITH_AES_256_CBC_SHA          uint16 = 0x0035
-	cipher_TLS_DH_DSS_WITH_AES_256_CBC_SHA       uint16 = 0x0036
-	cipher_TLS_DH_RSA_WITH_AES_256_CBC_SHA       uint16 = 0x0037
-	cipher_TLS_DHE_DSS_WITH_AES_256_CBC_SHA      uint16 = 0x0038
-	cipher_TLS_DHE_RSA_WITH_AES_256_CBC_SHA      uint16 = 0x0039
-	cipher_TLS_DH_anon_WITH_AES_256_CBC_SHA      uint16 = 0x003A
-	cipher_TLS_RSA_WITH_NULL_SHA256              uint16 = 0x003B
-	cipher_TLS_RSA_WITH_AES_128_CBC_SHA256       uint16 = 0x003C
-	cipher_TLS_RSA_WITH_AES_256_CBC_SHA256       uint16 = 0x003D
-	cipher_TLS_DH_DSS_WITH_AES_128_CBC_SHA256    uint16 = 0x003E
-	cipher_TLS_DH_RSA_WITH_AES_128_CBC_SHA256    uint16 = 0x003F
-	cipher_TLS_DHE_DSS_WITH_AES_128_CBC_SHA256   uint16 = 0x0040
-	cipher_TLS_RSA_WITH_CAMELLIA_128_CBC_SHA     uint16 = 0x0041
-	cipher_TLS_DH_DSS_WITH_CAMELLIA_128_CBC_SHA  uint16 = 0x0042
-	cipher_TLS_DH_RSA_WITH_CAMELLIA_128_CBC_SHA  uint16 = 0x0043
-	cipher_TLS_DHE_DSS_WITH_CAMELLIA_128_CBC_SHA uint16 = 0x0044
-	cipher_TLS_DHE_RSA_WITH_CAMELLIA_128_CBC_SHA uint16 = 0x0045
-	cipher_TLS_DH_anon_WITH_CAMELLIA_128_CBC_SHA uint16 = 0x0046
-	// Reserved uint16 =  0x0047-4F
-	// Reserved uint16 =  0x0050-58
-	// Reserved uint16 =  0x0059-5C
-	// Unassigned uint16 =  0x005D-5F
-	// Reserved uint16 =  0x0060-66
-	cipher_TLS_DHE_RSA_WITH_AES_128_CBC_SHA256 uint16 = 0x0067
-	cipher_TLS_DH_DSS_WITH_AES_256_CBC_SHA256  uint16 = 0x0068
-	cipher_TLS_DH_RSA_WITH_AES_256_CBC_SHA256  uint16 = 0x0069
-	cipher_TLS_DHE_DSS_WITH_AES_256_CBC_SHA256 uint16 = 0x006A
-	cipher_TLS_DHE_RSA_WITH_AES_256_CBC_SHA256 uint16 = 0x006B
-	cipher_TLS_DH_anon_WITH_AES_128_CBC_SHA256 uint16 = 0x006C
-	cipher_TLS_DH_anon_WITH_AES_256_CBC_SHA256 uint16 = 0x006D
-	// Unassigned uint16 =  0x006E-83
-	cipher_TLS_RSA_WITH_CAMELLIA_256_CBC_SHA        uint16 = 0x0084
-	cipher_TLS_DH_DSS_WITH_CAMELLIA_256_CBC_SHA     uint16 = 0x0085
-	cipher_TLS_DH_RSA_WITH_CAMELLIA_256_CBC_SHA     uint16 = 0x0086
-	cipher_TLS_DHE_DSS_WITH_CAMELLIA_256_CBC_SHA    uint16 = 0x0087
-	cipher_TLS_DHE_RSA_WITH_CAMELLIA_256_CBC_SHA    uint16 = 0x0088
-	cipher_TLS_DH_anon_WITH_CAMELLIA_256_CBC_SHA    uint16 = 0x0089
-	cipher_TLS_PSK_WITH_RC4_128_SHA                 uint16 = 0x008A
-	cipher_TLS_PSK_WITH_3DES_EDE_CBC_SHA            uint16 = 0x008B
-	cipher_TLS_PSK_WITH_AES_128_CBC_SHA             uint16 = 0x008C
-	cipher_TLS_PSK_WITH_AES_256_CBC_SHA             uint16 = 0x008D
-	cipher_TLS_DHE_PSK_WITH_RC4_128_SHA             uint16 = 0x008E
-	cipher_TLS_DHE_PSK_WITH_3DES_EDE_CBC_SHA        uint16 = 0x008F
-	cipher_TLS_DHE_PSK_WITH_AES_128_CBC_SHA         uint16 = 0x0090
-	cipher_TLS_DHE_PSK_WITH_AES_256_CBC_SHA         uint16 = 0x0091
-	cipher_TLS_RSA_PSK_WITH_RC4_128_SHA             uint16 = 0x0092
-	cipher_TLS_RSA_PSK_WITH_3DES_EDE_CBC_SHA        uint16 = 0x0093
-	cipher_TLS_RSA_PSK_WITH_AES_128_CBC_SHA         uint16 = 0x0094
-	cipher_TLS_RSA_PSK_WITH_AES_256_CBC_SHA         uint16 = 0x0095
-	cipher_TLS_RSA_WITH_SEED_CBC_SHA                uint16 = 0x0096
-	cipher_TLS_DH_DSS_WITH_SEED_CBC_SHA             uint16 = 0x0097
-	cipher_TLS_DH_RSA_WITH_SEED_CBC_SHA             uint16 = 0x0098
-	cipher_TLS_DHE_DSS_WITH_SEED_CBC_SHA            uint16 = 0x0099
-	cipher_TLS_DHE_RSA_WITH_SEED_CBC_SHA            uint16 = 0x009A
-	cipher_TLS_DH_anon_WITH_SEED_CBC_SHA            uint16 = 0x009B
-	cipher_TLS_RSA_WITH_AES_128_GCM_SHA256          uint16 = 0x009C
-	cipher_TLS_RSA_WITH_AES_256_GCM_SHA384          uint16 = 0x009D
-	cipher_TLS_DHE_RSA_WITH_AES_128_GCM_SHA256      uint16 = 0x009E
-	cipher_TLS_DHE_RSA_WITH_AES_256_GCM_SHA384      uint16 = 0x009F
-	cipher_TLS_DH_RSA_WITH_AES_128_GCM_SHA256       uint16 = 0x00A0
-	cipher_TLS_DH_RSA_WITH_AES_256_GCM_SHA384       uint16 = 0x00A1
-	cipher_TLS_DHE_DSS_WITH_AES_128_GCM_SHA256      uint16 = 0x00A2
-	cipher_TLS_DHE_DSS_WITH_AES_256_GCM_SHA384      uint16 = 0x00A3
-	cipher_TLS_DH_DSS_WITH_AES_128_GCM_SHA256       uint16 = 0x00A4
-	cipher_TLS_DH_DSS_WITH_AES_256_GCM_SHA384       uint16 = 0x00A5
-	cipher_TLS_DH_anon_WITH_AES_128_GCM_SHA256      uint16 = 0x00A6
-	cipher_TLS_DH_anon_WITH_AES_256_GCM_SHA384      uint16 = 0x00A7
-	cipher_TLS_PSK_WITH_AES_128_GCM_SHA256          uint16 = 0x00A8
-	cipher_TLS_PSK_WITH_AES_256_GCM_SHA384          uint16 = 0x00A9
-	cipher_TLS_DHE_PSK_WITH_AES_128_GCM_SHA256      uint16 = 0x00AA
-	cipher_TLS_DHE_PSK_WITH_AES_256_GCM_SHA384      uint16 = 0x00AB
-	cipher_TLS_RSA_PSK_WITH_AES_128_GCM_SHA256      uint16 = 0x00AC
-	cipher_TLS_RSA_PSK_WITH_AES_256_GCM_SHA384      uint16 = 0x00AD
-	cipher_TLS_PSK_WITH_AES_128_CBC_SHA256          uint16 = 0x00AE
-	cipher_TLS_PSK_WITH_AES_256_CBC_SHA384          uint16 = 0x00AF
-	cipher_TLS_PSK_WITH_NULL_SHA256                 uint16 = 0x00B0
-	cipher_TLS_PSK_WITH_NULL_SHA384                 uint16 = 0x00B1
-	cipher_TLS_DHE_PSK_WITH_AES_128_CBC_SHA256      uint16 = 0x00B2
-	cipher_TLS_DHE_PSK_WITH_AES_256_CBC_SHA384      uint16 = 0x00B3
-	cipher_TLS_DHE_PSK_WITH_NULL_SHA256             uint16 = 0x00B4
-	cipher_TLS_DHE_PSK_WITH_NULL_SHA384             uint16 = 0x00B5
-	cipher_TLS_RSA_PSK_WITH_AES_128_CBC_SHA256      uint16 = 0x00B6
-	cipher_TLS_RSA_PSK_WITH_AES_256_CBC_SHA384      uint16 = 0x00B7
-	cipher_TLS_RSA_PSK_WITH_NULL_SHA256             uint16 = 0x00B8
-	cipher_TLS_RSA_PSK_WITH_NULL_SHA384             uint16 = 0x00B9
-	cipher_TLS_RSA_WITH_CAMELLIA_128_CBC_SHA256     uint16 = 0x00BA
-	cipher_TLS_DH_DSS_WITH_CAMELLIA_128_CBC_SHA256  uint16 = 0x00BB
-	cipher_TLS_DH_RSA_WITH_CAMELLIA_128_CBC_SHA256  uint16 = 0x00BC
-	cipher_TLS_DHE_DSS_WITH_CAMELLIA_128_CBC_SHA256 uint16 = 0x00BD
-	cipher_TLS_DHE_RSA_WITH_CAMELLIA_128_CBC_SHA256 uint16 = 0x00BE
-	cipher_TLS_DH_anon_WITH_CAMELLIA_128_CBC_SHA256 uint16 = 0x00BF
-	cipher_TLS_RSA_WITH_CAMELLIA_256_CBC_SHA256     uint16 = 0x00C0
-	cipher_TLS_DH_DSS_WITH_CAMELLIA_256_CBC_SHA256  uint16 = 0x00C1
-	cipher_TLS_DH_RSA_WITH_CAMELLIA_256_CBC_SHA256  uint16 = 0x00C2
-	cipher_TLS_DHE_DSS_WITH_CAMELLIA_256_CBC_SHA256 uint16 = 0x00C3
-	cipher_TLS_DHE_RSA_WITH_CAMELLIA_256_CBC_SHA256 uint16 = 0x00C4
-	cipher_TLS_DH_anon_WITH_CAMELLIA_256_CBC_SHA256 uint16 = 0x00C5
-	// Unassigned uint16 =  0x00C6-FE
-	cipher_TLS_EMPTY_RENEGOTIATION_INFO_SCSV uint16 = 0x00FF
-	// Unassigned uint16 =  0x01-55,*
-	cipher_TLS_FALLBACK_SCSV uint16 = 0x5600
-	// Unassigned                                   uint16 = 0x5601 - 0xC000
-	cipher_TLS_ECDH_ECDSA_WITH_NULL_SHA                 uint16 = 0xC001
-	cipher_TLS_ECDH_ECDSA_WITH_RC4_128_SHA              uint16 = 0xC002
-	cipher_TLS_ECDH_ECDSA_WITH_3DES_EDE_CBC_SHA         uint16 = 0xC003
-	cipher_TLS_ECDH_ECDSA_WITH_AES_128_CBC_SHA          uint16 = 0xC004
-	cipher_TLS_ECDH_ECDSA_WITH_AES_256_CBC_SHA          uint16 = 0xC005
-	cipher_TLS_ECDHE_ECDSA_WITH_NULL_SHA                uint16 = 0xC006
-	cipher_TLS_ECDHE_ECDSA_WITH_RC4_128_SHA             uint16 = 0xC007
-	cipher_TLS_ECDHE_ECDSA_WITH_3DES_EDE_CBC_SHA        uint16 = 0xC008
-	cipher_TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA         uint16 = 0xC009
-	cipher_TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA         uint16 = 0xC00A
-	cipher_TLS_ECDH_RSA_WITH_NULL_SHA                   uint16 = 0xC00B
-	cipher_TLS_ECDH_RSA_WITH_RC4_128_SHA                uint16 = 0xC00C
-	cipher_TLS_ECDH_RSA_WITH_3DES_EDE_CBC_SHA           uint16 = 0xC00D
-	cipher_TLS_ECDH_RSA_WITH_AES_128_CBC_SHA            uint16 = 0xC00E
-	cipher_TLS_ECDH_RSA_WITH_AES_256_CBC_SHA            uint16 = 0xC00F
-	cipher_TLS_ECDHE_RSA_WITH_NULL_SHA                  uint16 = 0xC010
-	cipher_TLS_ECDHE_RSA_WITH_RC4_128_SHA               uint16 = 0xC011
-	cipher_TLS_ECDHE_RSA_WITH_3DES_EDE_CBC_SHA          uint16 = 0xC012
-	cipher_TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA           uint16 = 0xC013
-	cipher_TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA           uint16 = 0xC014
-	cipher_TLS_ECDH_anon_WITH_NULL_SHA                  uint16 = 0xC015
-	cipher_TLS_ECDH_anon_WITH_RC4_128_SHA               uint16 = 0xC016
-	cipher_TLS_ECDH_anon_WITH_3DES_EDE_CBC_SHA          uint16 = 0xC017
-	cipher_TLS_ECDH_anon_WITH_AES_128_CBC_SHA           uint16 = 0xC018
-	cipher_TLS_ECDH_anon_WITH_AES_256_CBC_SHA           uint16 = 0xC019
-	cipher_TLS_SRP_SHA_WITH_3DES_EDE_CBC_SHA            uint16 = 0xC01A
-	cipher_TLS_SRP_SHA_RSA_WITH_3DES_EDE_CBC_SHA        uint16 = 0xC01B
-	cipher_TLS_SRP_SHA_DSS_WITH_3DES_EDE_CBC_SHA        uint16 = 0xC01C
-	cipher_TLS_SRP_SHA_WITH_AES_128_CBC_SHA             uint16 = 0xC01D
-	cipher_TLS_SRP_SHA_RSA_WITH_AES_128_CBC_SHA         uint16 = 0xC01E
-	cipher_TLS_SRP_SHA_DSS_WITH_AES_128_CBC_SHA         uint16 = 0xC01F
-	cipher_TLS_SRP_SHA_WITH_AES_256_CBC_SHA             uint16 = 0xC020
-	cipher_TLS_SRP_SHA_RSA_WITH_AES_256_CBC_SHA         uint16 = 0xC021
-	cipher_TLS_SRP_SHA_DSS_WITH_AES_256_CBC_SHA         uint16 = 0xC022
-	cipher_TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256      uint16 = 0xC023
-	cipher_TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA384      uint16 = 0xC024
-	cipher_TLS_ECDH_ECDSA_WITH_AES_128_CBC_SHA256       uint16 = 0xC025
-	cipher_TLS_ECDH_ECDSA_WITH_AES_256_CBC_SHA384       uint16 = 0xC026
-	cipher_TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256        uint16 = 0xC027
-	cipher_TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA384        uint16 = 0xC028
-	cipher_TLS_ECDH_RSA_WITH_AES_128_CBC_SHA256         uint16 = 0xC029
-	cipher_TLS_ECDH_RSA_WITH_AES_256_CBC_SHA384         uint16 = 0xC02A
-	cipher_TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256      uint16 = 0xC02B
-	cipher_TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384      uint16 = 0xC02C
-	cipher_TLS_ECDH_ECDSA_WITH_AES_128_GCM_SHA256       uint16 = 0xC02D
-	cipher_TLS_ECDH_ECDSA_WITH_AES_256_GCM_SHA384       uint16 = 0xC02E
-	cipher_TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256        uint16 = 0xC02F
-	cipher_TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384        uint16 = 0xC030
-	cipher_TLS_ECDH_RSA_WITH_AES_128_GCM_SHA256         uint16 = 0xC031
-	cipher_TLS_ECDH_RSA_WITH_AES_256_GCM_SHA384         uint16 = 0xC032
-	cipher_TLS_ECDHE_PSK_WITH_RC4_128_SHA               uint16 = 0xC033
-	cipher_TLS_ECDHE_PSK_WITH_3DES_EDE_CBC_SHA          uint16 = 0xC034
-	cipher_TLS_ECDHE_PSK_WITH_AES_128_CBC_SHA           uint16 = 0xC035
-	cipher_TLS_ECDHE_PSK_WITH_AES_256_CBC_SHA           uint16 = 0xC036
-	cipher_TLS_ECDHE_PSK_WITH_AES_128_CBC_SHA256        uint16 = 0xC037
-	cipher_TLS_ECDHE_PSK_WITH_AES_256_CBC_SHA384        uint16 = 0xC038
-	cipher_TLS_ECDHE_PSK_WITH_NULL_SHA                  uint16 = 0xC039
-	cipher_TLS_ECDHE_PSK_WITH_NULL_SHA256               uint16 = 0xC03A
-	cipher_TLS_ECDHE_PSK_WITH_NULL_SHA384               uint16 = 0xC03B
-	cipher_TLS_RSA_WITH_ARIA_128_CBC_SHA256             uint16 = 0xC03C
-	cipher_TLS_RSA_WITH_ARIA_256_CBC_SHA384             uint16 = 0xC03D
-	cipher_TLS_DH_DSS_WITH_ARIA_128_CBC_SHA256          uint16 = 0xC03E
-	cipher_TLS_DH_DSS_WITH_ARIA_256_CBC_SHA384          uint16 = 0xC03F
-	cipher_TLS_DH_RSA_WITH_ARIA_128_CBC_SHA256          uint16 = 0xC040
-	cipher_TLS_DH_RSA_WITH_ARIA_256_CBC_SHA384          uint16 = 0xC041
-	cipher_TLS_DHE_DSS_WITH_ARIA_128_CBC_SHA256         uint16 = 0xC042
-	cipher_TLS_DHE_DSS_WITH_ARIA_256_CBC_SHA384         uint16 = 0xC043
-	cipher_TLS_DHE_RSA_WITH_ARIA_128_CBC_SHA256         uint16 = 0xC044
-	cipher_TLS_DHE_RSA_WITH_ARIA_256_CBC_SHA384         uint16 = 0xC045
-	cipher_TLS_DH_anon_WITH_ARIA_128_CBC_SHA256         uint16 = 0xC046
-	cipher_TLS_DH_anon_WITH_ARIA_256_CBC_SHA384         uint16 = 0xC047
-	cipher_TLS_ECDHE_ECDSA_WITH_ARIA_128_CBC_SHA256     uint16 = 0xC048
-	cipher_TLS_ECDHE_ECDSA_WITH_ARIA_256_CBC_SHA384     uint16 = 0xC049
-	cipher_TLS_ECDH_ECDSA_WITH_ARIA_128_CBC_SHA256      uint16 = 0xC04A
-	cipher_TLS_ECDH_ECDSA_WITH_ARIA_256_CBC_SHA384      uint16 = 0xC04B
-	cipher_TLS_ECDHE_RSA_WITH_ARIA_128_CBC_SHA256       uint16 = 0xC04C
-	cipher_TLS_ECDHE_RSA_WITH_ARIA_256_CBC_SHA384       uint16 = 0xC04D
-	cipher_TLS_ECDH_RSA_WITH_ARIA_128_CBC_SHA256        uint16 = 0xC04E
-	cipher_TLS_ECDH_RSA_WITH_ARIA_256_CBC_SHA384        uint16 = 0xC04F
-	cipher_TLS_RSA_WITH_ARIA_128_GCM_SHA256             uint16 = 0xC050
-	cipher_TLS_RSA_WITH_ARIA_256_GCM_SHA384             uint16 = 0xC051
-	cipher_TLS_DHE_RSA_WITH_ARIA_128_GCM_SHA256         uint16 = 0xC052
-	cipher_TLS_DHE_RSA_WITH_ARIA_256_GCM_SHA384         uint16 = 0xC053
-	cipher_TLS_DH_RSA_WITH_ARIA_128_GCM_SHA256          uint16 = 0xC054
-	cipher_TLS_DH_RSA_WITH_ARIA_256_GCM_SHA384          uint16 = 0xC055
-	cipher_TLS_DHE_DSS_WITH_ARIA_128_GCM_SHA256         uint16 = 0xC056
-	cipher_TLS_DHE_DSS_WITH_ARIA_256_GCM_SHA384         uint16 = 0xC057
-	cipher_TLS_DH_DSS_WITH_ARIA_128_GCM_SHA256          uint16 = 0xC058
-	cipher_TLS_DH_DSS_WITH_ARIA_256_GCM_SHA384          uint16 = 0xC059
-	cipher_TLS_DH_anon_WITH_ARIA_128_GCM_SHA256         uint16 = 0xC05A
-	cipher_TLS_DH_anon_WITH_ARIA_256_GCM_SHA384         uint16 = 0xC05B
-	cipher_TLS_ECDHE_ECDSA_WITH_ARIA_128_GCM_SHA256     uint16 = 0xC05C
-	cipher_TLS_ECDHE_ECDSA_WITH_ARIA_256_GCM_SHA384     uint16 = 0xC05D
-	cipher_TLS_ECDH_ECDSA_WITH_ARIA_128_GCM_SHA256      uint16 = 0xC05E
-	cipher_TLS_ECDH_ECDSA_WITH_ARIA_256_GCM_SHA384      uint16 = 0xC05F
-	cipher_TLS_ECDHE_RSA_WITH_ARIA_128_GCM_SHA256       uint16 = 0xC060
-	cipher_TLS_ECDHE_RSA_WITH_ARIA_256_GCM_SHA384       uint16 = 0xC061
-	cipher_TLS_ECDH_RSA_WITH_ARIA_128_GCM_SHA256        uint16 = 0xC062
-	cipher_TLS_ECDH_RSA_WITH_ARIA_256_GCM_SHA384        uint16 = 0xC063
-	cipher_TLS_PSK_WITH_ARIA_128_CBC_SHA256             uint16 = 0xC064
-	cipher_TLS_PSK_WITH_ARIA_256_CBC_SHA384             uint16 = 0xC065
-	cipher_TLS_DHE_PSK_WITH_ARIA_128_CBC_SHA256         uint16 = 0xC066
-	cipher_TLS_DHE_PSK_WITH_ARIA_256_CBC_SHA384         uint16 = 0xC067
-	cipher_TLS_RSA_PSK_WITH_ARIA_128_CBC_SHA256         uint16 = 0xC068
-	cipher_TLS_RSA_PSK_WITH_ARIA_256_CBC_SHA384         uint16 = 0xC069
-	cipher_TLS_PSK_WITH_ARIA_128_GCM_SHA256             uint16 = 0xC06A
-	cipher_TLS_PSK_WITH_ARIA_256_GCM_SHA384             uint16 = 0xC06B
-	cipher_TLS_DHE_PSK_WITH_ARIA_128_GCM_SHA256         uint16 = 0xC06C
-	cipher_TLS_DHE_PSK_WITH_ARIA_256_GCM_SHA384         uint16 = 0xC06D
-	cipher_TLS_RSA_PSK_WITH_ARIA_128_GCM_SHA256         uint16 = 0xC06E
-	cipher_TLS_RSA_PSK_WITH_ARIA_256_GCM_SHA384         uint16 = 0xC06F
-	cipher_TLS_ECDHE_PSK_WITH_ARIA_128_CBC_SHA256       uint16 = 0xC070
-	cipher_TLS_ECDHE_PSK_WITH_ARIA_256_CBC_SHA384       uint16 = 0xC071
-	cipher_TLS_ECDHE_ECDSA_WITH_CAMELLIA_128_CBC_SHA256 uint16 = 0xC072
-	cipher_TLS_ECDHE_ECDSA_WITH_CAMELLIA_256_CBC_SHA384 uint16 = 0xC073
-	cipher_TLS_ECDH_ECDSA_WITH_CAMELLIA_128_CBC_SHA256  uint16 = 0xC074
-	cipher_TLS_ECDH_ECDSA_WITH_CAMELLIA_256_CBC_SHA384  uint16 = 0xC075
-	cipher_TLS_ECDHE_RSA_WITH_CAMELLIA_128_CBC_SHA256   uint16 = 0xC076
-	cipher_TLS_ECDHE_RSA_WITH_CAMELLIA_256_CBC_SHA384   uint16 = 0xC077
-	cipher_TLS_ECDH_RSA_WITH_CAMELLIA_128_CBC_SHA256    uint16 = 0xC078
-	cipher_TLS_ECDH_RSA_WITH_CAMELLIA_256_CBC_SHA384    uint16 = 0xC079
-	cipher_TLS_RSA_WITH_CAMELLIA_128_GCM_SHA256         uint16 = 0xC07A
-	cipher_TLS_RSA_WITH_CAMELLIA_256_GCM_SHA384         uint16 = 0xC07B
-	cipher_TLS_DHE_RSA_WITH_CAMELLIA_128_GCM_SHA256     uint16 = 0xC07C
-	cipher_TLS_DHE_RSA_WITH_CAMELLIA_256_GCM_SHA384     uint16 = 0xC07D
-	cipher_TLS_DH_RSA_WITH_CAMELLIA_128_GCM_SHA256      uint16 = 0xC07E
-	cipher_TLS_DH_RSA_WITH_CAMELLIA_256_GCM_SHA384      uint16 = 0xC07F
-	cipher_TLS_DHE_DSS_WITH_CAMELLIA_128_GCM_SHA256     uint16 = 0xC080
-	cipher_TLS_DHE_DSS_WITH_CAMELLIA_256_GCM_SHA384     uint16 = 0xC081
-	cipher_TLS_DH_DSS_WITH_CAMELLIA_128_GCM_SHA256      uint16 = 0xC082
-	cipher_TLS_DH_DSS_WITH_CAMELLIA_256_GCM_SHA384      uint16 = 0xC083
-	cipher_TLS_DH_anon_WITH_CAMELLIA_128_GCM_SHA256     uint16 = 0xC084
-	cipher_TLS_DH_anon_WITH_CAMELLIA_256_GCM_SHA384     uint16 = 0xC085
-	cipher_TLS_ECDHE_ECDSA_WITH_CAMELLIA_128_GCM_SHA256 uint16 = 0xC086
-	cipher_TLS_ECDHE_ECDSA_WITH_CAMELLIA_256_GCM_SHA384 uint16 = 0xC087
-	cipher_TLS_ECDH_ECDSA_WITH_CAMELLIA_128_GCM_SHA256  uint16 = 0xC088
-	cipher_TLS_ECDH_ECDSA_WITH_CAMELLIA_256_GCM_SHA384  uint16 = 0xC089
-	cipher_TLS_ECDHE_RSA_WITH_CAMELLIA_128_GCM_SHA256   uint16 = 0xC08A
-	cipher_TLS_ECDHE_RSA_WITH_CAMELLIA_256_GCM_SHA384   uint16 = 0xC08B
-	cipher_TLS_ECDH_RSA_WITH_CAMELLIA_128_GCM_SHA256    uint16 = 0xC08C
-	cipher_TLS_ECDH_RSA_WITH_CAMELLIA_256_GCM_SHA384    uint16 = 0xC08D
-	cipher_TLS_PSK_WITH_CAMELLIA_128_GCM_SHA256         uint16 = 0xC08E
-	cipher_TLS_PSK_WITH_CAMELLIA_256_GCM_SHA384         uint16 = 0xC08F
-	cipher_TLS_DHE_PSK_WITH_CAMELLIA_128_GCM_SHA256     uint16 = 0xC090
-	cipher_TLS_DHE_PSK_WITH_CAMELLIA_256_GCM_SHA384     uint16 = 0xC091
-	cipher_TLS_RSA_PSK_WITH_CAMELLIA_128_GCM_SHA256     uint16 = 0xC092
-	cipher_TLS_RSA_PSK_WITH_CAMELLIA_256_GCM_SHA384     uint16 = 0xC093
-	cipher_TLS_PSK_WITH_CAMELLIA_128_CBC_SHA256         uint16 = 0xC094
-	cipher_TLS_PSK_WITH_CAMELLIA_256_CBC_SHA384         uint16 = 0xC095
-	cipher_TLS_DHE_PSK_WITH_CAMELLIA_128_CBC_SHA256     uint16 = 0xC096
-	cipher_TLS_DHE_PSK_WITH_CAMELLIA_256_CBC_SHA384     uint16 = 0xC097
-	cipher_TLS_RSA_PSK_WITH_CAMELLIA_128_CBC_SHA256     uint16 = 0xC098
-	cipher_TLS_RSA_PSK_WITH_CAMELLIA_256_CBC_SHA384     uint16 = 0xC099
-	cipher_TLS_ECDHE_PSK_WITH_CAMELLIA_128_CBC_SHA256   uint16 = 0xC09A
-	cipher_TLS_ECDHE_PSK_WITH_CAMELLIA_256_CBC_SHA384   uint16 = 0xC09B
-	cipher_TLS_RSA_WITH_AES_128_CCM                     uint16 = 0xC09C
-	cipher_TLS_RSA_WITH_AES_256_CCM                     uint16 = 0xC09D
-	cipher_TLS_DHE_RSA_WITH_AES_128_CCM                 uint16 = 0xC09E
-	cipher_TLS_DHE_RSA_WITH_AES_256_CCM                 uint16 = 0xC09F
-	cipher_TLS_RSA_WITH_AES_128_CCM_8                   uint16 = 0xC0A0
-	cipher_TLS_RSA_WITH_AES_256_CCM_8                   uint16 = 0xC0A1
-	cipher_TLS_DHE_RSA_WITH_AES_128_CCM_8               uint16 = 0xC0A2
-	cipher_TLS_DHE_RSA_WITH_AES_256_CCM_8               uint16 = 0xC0A3
-	cipher_TLS_PSK_WITH_AES_128_CCM                     uint16 = 0xC0A4
-	cipher_TLS_PSK_WITH_AES_256_CCM                     uint16 = 0xC0A5
-	cipher_TLS_DHE_PSK_WITH_AES_128_CCM                 uint16 = 0xC0A6
-	cipher_TLS_DHE_PSK_WITH_AES_256_CCM                 uint16 = 0xC0A7
-	cipher_TLS_PSK_WITH_AES_128_CCM_8                   uint16 = 0xC0A8
-	cipher_TLS_PSK_WITH_AES_256_CCM_8                   uint16 = 0xC0A9
-	cipher_TLS_PSK_DHE_WITH_AES_128_CCM_8               uint16 = 0xC0AA
-	cipher_TLS_PSK_DHE_WITH_AES_256_CCM_8               uint16 = 0xC0AB
-	cipher_TLS_ECDHE_ECDSA_WITH_AES_128_CCM             uint16 = 0xC0AC
-	cipher_TLS_ECDHE_ECDSA_WITH_AES_256_CCM             uint16 = 0xC0AD
-	cipher_TLS_ECDHE_ECDSA_WITH_AES_128_CCM_8           uint16 = 0xC0AE
-	cipher_TLS_ECDHE_ECDSA_WITH_AES_256_CCM_8           uint16 = 0xC0AF
-	// Unassigned uint16 =  0xC0B0-FF
-	// Unassigned uint16 =  0xC1-CB,*
-	// Unassigned uint16 =  0xCC00-A7
-	cipher_TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305_SHA256   uint16 = 0xCCA8
-	cipher_TLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305_SHA256 uint16 = 0xCCA9
-	cipher_TLS_DHE_RSA_WITH_CHACHA20_POLY1305_SHA256     uint16 = 0xCCAA
-	cipher_TLS_PSK_WITH_CHACHA20_POLY1305_SHA256         uint16 = 0xCCAB
-	cipher_TLS_ECDHE_PSK_WITH_CHACHA20_POLY1305_SHA256   uint16 = 0xCCAC
-	cipher_TLS_DHE_PSK_WITH_CHACHA20_POLY1305_SHA256     uint16 = 0xCCAD
-	cipher_TLS_RSA_PSK_WITH_CHACHA20_POLY1305_SHA256     uint16 = 0xCCAE
-)
-
-// isBadCipher reports whether the cipher is blacklisted by the HTTP/2 spec.
-// References:
-// https://tools.ietf.org/html/rfc7540#appendix-A
-// Reject cipher suites from Appendix A.
-// "This list includes those cipher suites that do not
-// offer an ephemeral key exchange and those that are
-// based on the TLS null, stream or block cipher type"
-func isBadCipher(cipher uint16) bool {
-	switch cipher {
-	case cipher_TLS_NULL_WITH_NULL_NULL,
-		cipher_TLS_RSA_WITH_NULL_MD5,
-		cipher_TLS_RSA_WITH_NULL_SHA,
-		cipher_TLS_RSA_EXPORT_WITH_RC4_40_MD5,
-		cipher_TLS_RSA_WITH_RC4_128_MD5,
-		cipher_TLS_RSA_WITH_RC4_128_SHA,
-		cipher_TLS_RSA_EXPORT_WITH_RC2_CBC_40_MD5,
-		cipher_TLS_RSA_WITH_IDEA_CBC_SHA,
-		cipher_TLS_RSA_EXPORT_WITH_DES40_CBC_SHA,
-		cipher_TLS_RSA_WITH_DES_CBC_SHA,
-		cipher_TLS_RSA_WITH_3DES_EDE_CBC_SHA,
-		cipher_TLS_DH_DSS_EXPORT_WITH_DES40_CBC_SHA,
-		cipher_TLS_DH_DSS_WITH_DES_CBC_SHA,
-		cipher_TLS_DH_DSS_WITH_3DES_EDE_CBC_SHA,
-		cipher_TLS_DH_RSA_EXPORT_WITH_DES40_CBC_SHA,
-		cipher_TLS_DH_RSA_WITH_DES_CBC_SHA,
-		cipher_TLS_DH_RSA_WITH_3DES_EDE_CBC_SHA,
-		cipher_TLS_DHE_DSS_EXPORT_WITH_DES40_CBC_SHA,
-		cipher_TLS_DHE_DSS_WITH_DES_CBC_SHA,
-		cipher_TLS_DHE_DSS_WITH_3DES_EDE_CBC_SHA,
-		cipher_TLS_DHE_RSA_EXPORT_WITH_DES40_CBC_SHA,
-		cipher_TLS_DHE_RSA_WITH_DES_CBC_SHA,
-		cipher_TLS_DHE_RSA_WITH_3DES_EDE_CBC_SHA,
-		cipher_TLS_DH_anon_EXPORT_WITH_RC4_40_MD5,
-		cipher_TLS_DH_anon_WITH_RC4_128_MD5,
-		cipher_TLS_DH_anon_EXPORT_WITH_DES40_CBC_SHA,
-		cipher_TLS_DH_anon_WITH_DES_CBC_SHA,
-		cipher_TLS_DH_anon_WITH_3DES_EDE_CBC_SHA,
-		cipher_TLS_KRB5_WITH_DES_CBC_SHA,
-		cipher_TLS_KRB5_WITH_3DES_EDE_CBC_SHA,
-		cipher_TLS_KRB5_WITH_RC4_128_SHA,
-		cipher_TLS_KRB5_WITH_IDEA_CBC_SHA,
-		cipher_TLS_KRB5_WITH_DES_CBC_MD5,
-		cipher_TLS_KRB5_WITH_3DES_EDE_CBC_MD5,
-		cipher_TLS_KRB5_WITH_RC4_128_MD5,
-		cipher_TLS_KRB5_WITH_IDEA_CBC_MD5,
-		cipher_TLS_KRB5_EXPORT_WITH_DES_CBC_40_SHA,
-		cipher_TLS_KRB5_EXPORT_WITH_RC2_CBC_40_SHA,
-		cipher_TLS_KRB5_EXPORT_WITH_RC4_40_SHA,
-		cipher_TLS_KRB5_EXPORT_WITH_DES_CBC_40_MD5,
-		cipher_TLS_KRB5_EXPORT_WITH_RC2_CBC_40_MD5,
-		cipher_TLS_KRB5_EXPORT_WITH_RC4_40_MD5,
-		cipher_TLS_PSK_WITH_NULL_SHA,
-		cipher_TLS_DHE_PSK_WITH_NULL_SHA,
-		cipher_TLS_RSA_PSK_WITH_NULL_SHA,
-		cipher_TLS_RSA_WITH_AES_128_CBC_SHA,
-		cipher_TLS_DH_DSS_WITH_AES_128_CBC_SHA,
-		cipher_TLS_DH_RSA_WITH_AES_128_CBC_SHA,
-		cipher_TLS_DHE_DSS_WITH_AES_128_CBC_SHA,
-		cipher_TLS_DHE_RSA_WITH_AES_128_CBC_SHA,
-		cipher_TLS_DH_anon_WITH_AES_128_CBC_SHA,
-		cipher_TLS_RSA_WITH_AES_256_CBC_SHA,
-		cipher_TLS_DH_DSS_WITH_AES_256_CBC_SHA,
-		cipher_TLS_DH_RSA_WITH_AES_256_CBC_SHA,
-		cipher_TLS_DHE_DSS_WITH_AES_256_CBC_SHA,
-		cipher_TLS_DHE_RSA_WITH_AES_256_CBC_SHA,
-		cipher_TLS_DH_anon_WITH_AES_256_CBC_SHA,
-		cipher_TLS_RSA_WITH_NULL_SHA256,
-		cipher_TLS_RSA_WITH_AES_128_CBC_SHA256,
-		cipher_TLS_RSA_WITH_AES_256_CBC_SHA256,
-		cipher_TLS_DH_DSS_WITH_AES_128_CBC_SHA256,
-		cipher_TLS_DH_RSA_WITH_AES_128_CBC_SHA256,
-		cipher_TLS_DHE_DSS_WITH_AES_128_CBC_SHA256,
-		cipher_TLS_RSA_WITH_CAMELLIA_128_CBC_SHA,
-		cipher_TLS_DH_DSS_WITH_CAMELLIA_128_CBC_SHA,
-		cipher_TLS_DH_RSA_WITH_CAMELLIA_128_CBC_SHA,
-		cipher_TLS_DHE_DSS_WITH_CAMELLIA_128_CBC_SHA,
-		cipher_TLS_DHE_RSA_WITH_CAMELLIA_128_CBC_SHA,
-		cipher_TLS_DH_anon_WITH_CAMELLIA_128_CBC_SHA,
-		cipher_TLS_DHE_RSA_WITH_AES_128_CBC_SHA256,
-		cipher_TLS_DH_DSS_WITH_AES_256_CBC_SHA256,
-		cipher_TLS_DH_RSA_WITH_AES_256_CBC_SHA256,
-		cipher_TLS_DHE_DSS_WITH_AES_256_CBC_SHA256,
-		cipher_TLS_DHE_RSA_WITH_AES_256_CBC_SHA256,
-		cipher_TLS_DH_anon_WITH_AES_128_CBC_SHA256,
-		cipher_TLS_DH_anon_WITH_AES_256_CBC_SHA256,
-		cipher_TLS_RSA_WITH_CAMELLIA_256_CBC_SHA,
-		cipher_TLS_DH_DSS_WITH_CAMELLIA_256_CBC_SHA,
-		cipher_TLS_DH_RSA_WITH_CAMELLIA_256_CBC_SHA,
-		cipher_TLS_DHE_DSS_WITH_CAMELLIA_256_CBC_SHA,
-		cipher_TLS_DHE_RSA_WITH_CAMELLIA_256_CBC_SHA,
-		cipher_TLS_DH_anon_WITH_CAMELLIA_256_CBC_SHA,
-		cipher_TLS_PSK_WITH_RC4_128_SHA,
-		cipher_TLS_PSK_WITH_3DES_EDE_CBC_SHA,
-		cipher_TLS_PSK_WITH_AES_128_CBC_SHA,
-		cipher_TLS_PSK_WITH_AES_256_CBC_SHA,
-		cipher_TLS_DHE_PSK_WITH_RC4_128_SHA,
-		cipher_TLS_DHE_PSK_WITH_3DES_EDE_CBC_SHA,
-		cipher_TLS_DHE_PSK_WITH_AES_128_CBC_SHA,
-		cipher_TLS_DHE_PSK_WITH_AES_256_CBC_SHA,
-		cipher_TLS_RSA_PSK_WITH_RC4_128_SHA,
-		cipher_TLS_RSA_PSK_WITH_3DES_EDE_CBC_SHA,
-		cipher_TLS_RSA_PSK_WITH_AES_128_CBC_SHA,
-		cipher_TLS_RSA_PSK_WITH_AES_256_CBC_SHA,
-		cipher_TLS_RSA_WITH_SEED_CBC_SHA,
-		cipher_TLS_DH_DSS_WITH_SEED_CBC_SHA,
-		cipher_TLS_DH_RSA_WITH_SEED_CBC_SHA,
-		cipher_TLS_DHE_DSS_WITH_SEED_CBC_SHA,
-		cipher_TLS_DHE_RSA_WITH_SEED_CBC_SHA,
-		cipher_TLS_DH_anon_WITH_SEED_CBC_SHA,
-		cipher_TLS_RSA_WITH_AES_128_GCM_SHA256,
-		cipher_TLS_RSA_WITH_AES_256_GCM_SHA384,
-		cipher_TLS_DH_RSA_WITH_AES_128_GCM_SHA256,
-		cipher_TLS_DH_RSA_WITH_AES_256_GCM_SHA384,
-		cipher_TLS_DH_DSS_WITH_AES_128_GCM_SHA256,
-		cipher_TLS_DH_DSS_WITH_AES_256_GCM_SHA384,
-		cipher_TLS_DH_anon_WITH_AES_128_GCM_SHA256,
-		cipher_TLS_DH_anon_WITH_AES_256_GCM_SHA384,
-		cipher_TLS_PSK_WITH_AES_128_GCM_SHA256,
-		cipher_TLS_PSK_WITH_AES_256_GCM_SHA384,
-		cipher_TLS_RSA_PSK_WITH_AES_128_GCM_SHA256,
-		cipher_TLS_RSA_PSK_WITH_AES_256_GCM_SHA384,
-		cipher_TLS_PSK_WITH_AES_128_CBC_SHA256,
-		cipher_TLS_PSK_WITH_AES_256_CBC_SHA384,
-		cipher_TLS_PSK_WITH_NULL_SHA256,
-		cipher_TLS_PSK_WITH_NULL_SHA384,
-		cipher_TLS_DHE_PSK_WITH_AES_128_CBC_SHA256,
-		cipher_TLS_DHE_PSK_WITH_AES_256_CBC_SHA384,
-		cipher_TLS_DHE_PSK_WITH_NULL_SHA256,
-		cipher_TLS_DHE_PSK_WITH_NULL_SHA384,
-		cipher_TLS_RSA_PSK_WITH_AES_128_CBC_SHA256,
-		cipher_TLS_RSA_PSK_WITH_AES_256_CBC_SHA384,
-		cipher_TLS_RSA_PSK_WITH_NULL_SHA256,
-		cipher_TLS_RSA_PSK_WITH_NULL_SHA384,
-		cipher_TLS_RSA_WITH_CAMELLIA_128_CBC_SHA256,
-		cipher_TLS_DH_DSS_WITH_CAMELLIA_128_CBC_SHA256,
-		cipher_TLS_DH_RSA_WITH_CAMELLIA_128_CBC_SHA256,
-		cipher_TLS_DHE_DSS_WITH_CAMELLIA_128_CBC_SHA256,
-		cipher_TLS_DHE_RSA_WITH_CAMELLIA_128_CBC_SHA256,
-		cipher_TLS_DH_anon_WITH_CAMELLIA_128_CBC_SHA256,
-		cipher_TLS_RSA_WITH_CAMELLIA_256_CBC_SHA256,
-		cipher_TLS_DH_DSS_WITH_CAMELLIA_256_CBC_SHA256,
-		cipher_TLS_DH_RSA_WITH_CAMELLIA_256_CBC_SHA256,
-		cipher_TLS_DHE_DSS_WITH_CAMELLIA_256_CBC_SHA256,
-		cipher_TLS_DHE_RSA_WITH_CAMELLIA_256_CBC_SHA256,
-		cipher_TLS_DH_anon_WITH_CAMELLIA_256_CBC_SHA256,
-		cipher_TLS_EMPTY_RENEGOTIATION_INFO_SCSV,
-		cipher_TLS_ECDH_ECDSA_WITH_NULL_SHA,
-		cipher_TLS_ECDH_ECDSA_WITH_RC4_128_SHA,
-		cipher_TLS_ECDH_ECDSA_WITH_3DES_EDE_CBC_SHA,
-		cipher_TLS_ECDH_ECDSA_WITH_AES_128_CBC_SHA,
-		cipher_TLS_ECDH_ECDSA_WITH_AES_256_CBC_SHA,
-		cipher_TLS_ECDHE_ECDSA_WITH_NULL_SHA,
-		cipher_TLS_ECDHE_ECDSA_WITH_RC4_128_SHA,
-		cipher_TLS_ECDHE_ECDSA_WITH_3DES_EDE_CBC_SHA,
-		cipher_TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA,
-		cipher_TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA,
-		cipher_TLS_ECDH_RSA_WITH_NULL_SHA,
-		cipher_TLS_ECDH_RSA_WITH_RC4_128_SHA,
-		cipher_TLS_ECDH_RSA_WITH_3DES_EDE_CBC_SHA,
-		cipher_TLS_ECDH_RSA_WITH_AES_128_CBC_SHA,
-		cipher_TLS_ECDH_RSA_WITH_AES_256_CBC_SHA,
-		cipher_TLS_ECDHE_RSA_WITH_NULL_SHA,
-		cipher_TLS_ECDHE_RSA_WITH_RC4_128_SHA,
-		cipher_TLS_ECDHE_RSA_WITH_3DES_EDE_CBC_SHA,
-		cipher_TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA,
-		cipher_TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA,
-		cipher_TLS_ECDH_anon_WITH_NULL_SHA,
-		cipher_TLS_ECDH_anon_WITH_RC4_128_SHA,
-		cipher_TLS_ECDH_anon_WITH_3DES_EDE_CBC_SHA,
-		cipher_TLS_ECDH_anon_WITH_AES_128_CBC_SHA,
-		cipher_TLS_ECDH_anon_WITH_AES_256_CBC_SHA,
-		cipher_TLS_SRP_SHA_WITH_3DES_EDE_CBC_SHA,
-		cipher_TLS_SRP_SHA_RSA_WITH_3DES_EDE_CBC_SHA,
-		cipher_TLS_SRP_SHA_DSS_WITH_3DES_EDE_CBC_SHA,
-		cipher_TLS_SRP_SHA_WITH_AES_128_CBC_SHA,
-		cipher_TLS_SRP_SHA_RSA_WITH_AES_128_CBC_SHA,
-		cipher_TLS_SRP_SHA_DSS_WITH_AES_128_CBC_SHA,
-		cipher_TLS_SRP_SHA_WITH_AES_256_CBC_SHA,
-		cipher_TLS_SRP_SHA_RSA_WITH_AES_256_CBC_SHA,
-		cipher_TLS_SRP_SHA_DSS_WITH_AES_256_CBC_SHA,
-		cipher_TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256,
-		cipher_TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA384,
-		cipher_TLS_ECDH_ECDSA_WITH_AES_128_CBC_SHA256,
-		cipher_TLS_ECDH_ECDSA_WITH_AES_256_CBC_SHA384,
-		cipher_TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256,
-		cipher_TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA384,
-		cipher_TLS_ECDH_RSA_WITH_AES_128_CBC_SHA256,
-		cipher_TLS_ECDH_RSA_WITH_AES_256_CBC_SHA384,
-		cipher_TLS_ECDH_ECDSA_WITH_AES_128_GCM_SHA256,
-		cipher_TLS_ECDH_ECDSA_WITH_AES_256_GCM_SHA384,
-		cipher_TLS_ECDH_RSA_WITH_AES_128_GCM_SHA256,
-		cipher_TLS_ECDH_RSA_WITH_AES_256_GCM_SHA384,
-		cipher_TLS_ECDHE_PSK_WITH_RC4_128_SHA,
-		cipher_TLS_ECDHE_PSK_WITH_3DES_EDE_CBC_SHA,
-		cipher_TLS_ECDHE_PSK_WITH_AES_128_CBC_SHA,
-		cipher_TLS_ECDHE_PSK_WITH_AES_256_CBC_SHA,
-		cipher_TLS_ECDHE_PSK_WITH_AES_128_CBC_SHA256,
-		cipher_TLS_ECDHE_PSK_WITH_AES_256_CBC_SHA384,
-		cipher_TLS_ECDHE_PSK_WITH_NULL_SHA,
-		cipher_TLS_ECDHE_PSK_WITH_NULL_SHA256,
-		cipher_TLS_ECDHE_PSK_WITH_NULL_SHA384,
-		cipher_TLS_RSA_WITH_ARIA_128_CBC_SHA256,
-		cipher_TLS_RSA_WITH_ARIA_256_CBC_SHA384,
-		cipher_TLS_DH_DSS_WITH_ARIA_128_CBC_SHA256,
-		cipher_TLS_DH_DSS_WITH_ARIA_256_CBC_SHA384,
-		cipher_TLS_DH_RSA_WITH_ARIA_128_CBC_SHA256,
-		cipher_TLS_DH_RSA_WITH_ARIA_256_CBC_SHA384,
-		cipher_TLS_DHE_DSS_WITH_ARIA_128_CBC_SHA256,
-		cipher_TLS_DHE_DSS_WITH_ARIA_256_CBC_SHA384,
-		cipher_TLS_DHE_RSA_WITH_ARIA_128_CBC_SHA256,
-		cipher_TLS_DHE_RSA_WITH_ARIA_256_CBC_SHA384,
-		cipher_TLS_DH_anon_WITH_ARIA_128_CBC_SHA256,
-		cipher_TLS_DH_anon_WITH_ARIA_256_CBC_SHA384,
-		cipher_TLS_ECDHE_ECDSA_WITH_ARIA_128_CBC_SHA256,
-		cipher_TLS_ECDHE_ECDSA_WITH_ARIA_256_CBC_SHA384,
-		cipher_TLS_ECDH_ECDSA_WITH_ARIA_128_CBC_SHA256,
-		cipher_TLS_ECDH_ECDSA_WITH_ARIA_256_CBC_SHA384,
-		cipher_TLS_ECDHE_RSA_WITH_ARIA_128_CBC_SHA256,
-		cipher_TLS_ECDHE_RSA_WITH_ARIA_256_CBC_SHA384,
-		cipher_TLS_ECDH_RSA_WITH_ARIA_128_CBC_SHA256,
-		cipher_TLS_ECDH_RSA_WITH_ARIA_256_CBC_SHA384,
-		cipher_TLS_RSA_WITH_ARIA_128_GCM_SHA256,
-		cipher_TLS_RSA_WITH_ARIA_256_GCM_SHA384,
-		cipher_TLS_DH_RSA_WITH_ARIA_128_GCM_SHA256,
-		cipher_TLS_DH_RSA_WITH_ARIA_256_GCM_SHA384,
-		cipher_TLS_DH_DSS_WITH_ARIA_128_GCM_SHA256,
-		cipher_TLS_DH_DSS_WITH_ARIA_256_GCM_SHA384,
-		cipher_TLS_DH_anon_WITH_ARIA_128_GCM_SHA256,
-		cipher_TLS_DH_anon_WITH_ARIA_256_GCM_SHA384,
-		cipher_TLS_ECDH_ECDSA_WITH_ARIA_128_GCM_SHA256,
-		cipher_TLS_ECDH_ECDSA_WITH_ARIA_256_GCM_SHA384,
-		cipher_TLS_ECDH_RSA_WITH_ARIA_128_GCM_SHA256,
-		cipher_TLS_ECDH_RSA_WITH_ARIA_256_GCM_SHA384,
-		cipher_TLS_PSK_WITH_ARIA_128_CBC_SHA256,
-		cipher_TLS_PSK_WITH_ARIA_256_CBC_SHA384,
-		cipher_TLS_DHE_PSK_WITH_ARIA_128_CBC_SHA256,
-		cipher_TLS_DHE_PSK_WITH_ARIA_256_CBC_SHA384,
-		cipher_TLS_RSA_PSK_WITH_ARIA_128_CBC_SHA256,
-		cipher_TLS_RSA_PSK_WITH_ARIA_256_CBC_SHA384,
-		cipher_TLS_PSK_WITH_ARIA_128_GCM_SHA256,
-		cipher_TLS_PSK_WITH_ARIA_256_GCM_SHA384,
-		cipher_TLS_RSA_PSK_WITH_ARIA_128_GCM_SHA256,
-		cipher_TLS_RSA_PSK_WITH_ARIA_256_GCM_SHA384,
-		cipher_TLS_ECDHE_PSK_WITH_ARIA_128_CBC_SHA256,
-		cipher_TLS_ECDHE_PSK_WITH_ARIA_256_CBC_SHA384,
-		cipher_TLS_ECDHE_ECDSA_WITH_CAMELLIA_128_CBC_SHA256,
-		cipher_TLS_ECDHE_ECDSA_WITH_CAMELLIA_256_CBC_SHA384,
-		cipher_TLS_ECDH_ECDSA_WITH_CAMELLIA_128_CBC_SHA256,
-		cipher_TLS_ECDH_ECDSA_WITH_CAMELLIA_256_CBC_SHA384,
-		cipher_TLS_ECDHE_RSA_WITH_CAMELLIA_128_CBC_SHA256,
-		cipher_TLS_ECDHE_RSA_WITH_CAMELLIA_256_CBC_SHA384,
-		cipher_TLS_ECDH_RSA_WITH_CAMELLIA_128_CBC_SHA256,
-		cipher_TLS_ECDH_RSA_WITH_CAMELLIA_256_CBC_SHA384,
-		cipher_TLS_RSA_WITH_CAMELLIA_128_GCM_SHA256,
-		cipher_TLS_RSA_WITH_CAMELLIA_256_GCM_SHA384,
-		cipher_TLS_DH_RSA_WITH_CAMELLIA_128_GCM_SHA256,
-		cipher_TLS_DH_RSA_WITH_CAMELLIA_256_GCM_SHA384,
-		cipher_TLS_DH_DSS_WITH_CAMELLIA_128_GCM_SHA256,
-		cipher_TLS_DH_DSS_WITH_CAMELLIA_256_GCM_SHA384,
-		cipher_TLS_DH_anon_WITH_CAMELLIA_128_GCM_SHA256,
-		cipher_TLS_DH_anon_WITH_CAMELLIA_256_GCM_SHA384,
-		cipher_TLS_ECDH_ECDSA_WITH_CAMELLIA_128_GCM_SHA256,
-		cipher_TLS_ECDH_ECDSA_WITH_CAMELLIA_256_GCM_SHA384,
-		cipher_TLS_ECDH_RSA_WITH_CAMELLIA_128_GCM_SHA256,
-		cipher_TLS_ECDH_RSA_WITH_CAMELLIA_256_GCM_SHA384,
-		cipher_TLS_PSK_WITH_CAMELLIA_128_GCM_SHA256,
-		cipher_TLS_PSK_WITH_CAMELLIA_256_GCM_SHA384,
-		cipher_TLS_RSA_PSK_WITH_CAMELLIA_128_GCM_SHA256,
-		cipher_TLS_RSA_PSK_WITH_CAMELLIA_256_GCM_SHA384,
-		cipher_TLS_PSK_WITH_CAMELLIA_128_CBC_SHA256,
-		cipher_TLS_PSK_WITH_CAMELLIA_256_CBC_SHA384,
-		cipher_TLS_DHE_PSK_WITH_CAMELLIA_128_CBC_SHA256,
-		cipher_TLS_DHE_PSK_WITH_CAMELLIA_256_CBC_SHA384,
-		cipher_TLS_RSA_PSK_WITH_CAMELLIA_128_CBC_SHA256,
-		cipher_TLS_RSA_PSK_WITH_CAMELLIA_256_CBC_SHA384,
-		cipher_TLS_ECDHE_PSK_WITH_CAMELLIA_128_CBC_SHA256,
-		cipher_TLS_ECDHE_PSK_WITH_CAMELLIA_256_CBC_SHA384,
-		cipher_TLS_RSA_WITH_AES_128_CCM,
-		cipher_TLS_RSA_WITH_AES_256_CCM,
-		cipher_TLS_RSA_WITH_AES_128_CCM_8,
-		cipher_TLS_RSA_WITH_AES_256_CCM_8,
-		cipher_TLS_PSK_WITH_AES_128_CCM,
-		cipher_TLS_PSK_WITH_AES_256_CCM,
-		cipher_TLS_PSK_WITH_AES_128_CCM_8,
-		cipher_TLS_PSK_WITH_AES_256_CCM_8:
-		return true
-	default:
-		return false
-	}
-}

vendor/golang.org/x/net/http2/ciphers_test.go

@@ -1,309 +0,0 @@
-// Copyright 2017 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package http2
-
-import "testing"
-
-func TestIsBadCipherBad(t *testing.T) {
-	for _, c := range badCiphers {
-		if !isBadCipher(c) {
-			t.Errorf("Wrong result for isBadCipher(%d), want true", c)
-		}
-	}
-}
-
-// verify we don't give false positives on ciphers not on blacklist
-func TestIsBadCipherGood(t *testing.T) {
-	goodCiphers := map[uint16]string{
-		cipher_TLS_DHE_RSA_WITH_AES_256_CCM:                "cipher_TLS_DHE_RSA_WITH_AES_256_CCM",
-		cipher_TLS_ECDHE_ECDSA_WITH_AES_128_CCM:            "cipher_TLS_ECDHE_ECDSA_WITH_AES_128_CCM",
-		cipher_TLS_ECDHE_PSK_WITH_CHACHA20_POLY1305_SHA256: "cipher_TLS_ECDHE_PSK_WITH_CHACHA20_POLY1305_SHA256",
-	}
-	for c, name := range goodCiphers {
-		if isBadCipher(c) {
-			t.Errorf("Wrong result for isBadCipher(%d) %s, want false", c, name)
-		}
-	}
-}
-
-// copied from https://http2.github.io/http2-spec/#BadCipherSuites,
-var badCiphers = []uint16{
-	cipher_TLS_NULL_WITH_NULL_NULL,
-	cipher_TLS_RSA_WITH_NULL_MD5,
-	cipher_TLS_RSA_WITH_NULL_SHA,
-	cipher_TLS_RSA_EXPORT_WITH_RC4_40_MD5,
-	cipher_TLS_RSA_WITH_RC4_128_MD5,
-	cipher_TLS_RSA_WITH_RC4_128_SHA,
-	cipher_TLS_RSA_EXPORT_WITH_RC2_CBC_40_MD5,
-	cipher_TLS_RSA_WITH_IDEA_CBC_SHA,
-	cipher_TLS_RSA_EXPORT_WITH_DES40_CBC_SHA,
-	cipher_TLS_RSA_WITH_DES_CBC_SHA,
-	cipher_TLS_RSA_WITH_3DES_EDE_CBC_SHA,
-	cipher_TLS_DH_DSS_EXPORT_WITH_DES40_CBC_SHA,
-	cipher_TLS_DH_DSS_WITH_DES_CBC_SHA,
-	cipher_TLS_DH_DSS_WITH_3DES_EDE_CBC_SHA,
-	cipher_TLS_DH_RSA_EXPORT_WITH_DES40_CBC_SHA,
-	cipher_TLS_DH_RSA_WITH_DES_CBC_SHA,
-	cipher_TLS_DH_RSA_WITH_3DES_EDE_CBC_SHA,
-	cipher_TLS_DHE_DSS_EXPORT_WITH_DES40_CBC_SHA,
-	cipher_TLS_DHE_DSS_WITH_DES_CBC_SHA,
-	cipher_TLS_DHE_DSS_WITH_3DES_EDE_CBC_SHA,
-	cipher_TLS_DHE_RSA_EXPORT_WITH_DES40_CBC_SHA,
-	cipher_TLS_DHE_RSA_WITH_DES_CBC_SHA,
-	cipher_TLS_DHE_RSA_WITH_3DES_EDE_CBC_SHA,
-	cipher_TLS_DH_anon_EXPORT_WITH_RC4_40_MD5,
-	cipher_TLS_DH_anon_WITH_RC4_128_MD5,
-	cipher_TLS_DH_anon_EXPORT_WITH_DES40_CBC_SHA,
-	cipher_TLS_DH_anon_WITH_DES_CBC_SHA,
-	cipher_TLS_DH_anon_WITH_3DES_EDE_CBC_SHA,
-	cipher_TLS_KRB5_WITH_DES_CBC_SHA,
-	cipher_TLS_KRB5_WITH_3DES_EDE_CBC_SHA,
-	cipher_TLS_KRB5_WITH_RC4_128_SHA,
-	cipher_TLS_KRB5_WITH_IDEA_CBC_SHA,
-	cipher_TLS_KRB5_WITH_DES_CBC_MD5,
-	cipher_TLS_KRB5_WITH_3DES_EDE_CBC_MD5,
-	cipher_TLS_KRB5_WITH_RC4_128_MD5,
-	cipher_TLS_KRB5_WITH_IDEA_CBC_MD5,
-	cipher_TLS_KRB5_EXPORT_WITH_DES_CBC_40_SHA,
-	cipher_TLS_KRB5_EXPORT_WITH_RC2_CBC_40_SHA,
-	cipher_TLS_KRB5_EXPORT_WITH_RC4_40_SHA,
-	cipher_TLS_KRB5_EXPORT_WITH_DES_CBC_40_MD5,
-	cipher_TLS_KRB5_EXPORT_WITH_RC2_CBC_40_MD5,
-	cipher_TLS_KRB5_EXPORT_WITH_RC4_40_MD5,
-	cipher_TLS_PSK_WITH_NULL_SHA,
-	cipher_TLS_DHE_PSK_WITH_NULL_SHA,
-	cipher_TLS_RSA_PSK_WITH_NULL_SHA,
-	cipher_TLS_RSA_WITH_AES_128_CBC_SHA,
-	cipher_TLS_DH_DSS_WITH_AES_128_CBC_SHA,
-	cipher_TLS_DH_RSA_WITH_AES_128_CBC_SHA,
-	cipher_TLS_DHE_DSS_WITH_AES_128_CBC_SHA,
-	cipher_TLS_DHE_RSA_WITH_AES_128_CBC_SHA,
-	cipher_TLS_DH_anon_WITH_AES_128_CBC_SHA,
-	cipher_TLS_RSA_WITH_AES_256_CBC_SHA,
-	cipher_TLS_DH_DSS_WITH_AES_256_CBC_SHA,
-	cipher_TLS_DH_RSA_WITH_AES_256_CBC_SHA,
-	cipher_TLS_DHE_DSS_WITH_AES_256_CBC_SHA,
-	cipher_TLS_DHE_RSA_WITH_AES_256_CBC_SHA,
-	cipher_TLS_DH_anon_WITH_AES_256_CBC_SHA,
-	cipher_TLS_RSA_WITH_NULL_SHA256,
-	cipher_TLS_RSA_WITH_AES_128_CBC_SHA256,
-	cipher_TLS_RSA_WITH_AES_256_CBC_SHA256,
-	cipher_TLS_DH_DSS_WITH_AES_128_CBC_SHA256,
-	cipher_TLS_DH_RSA_WITH_AES_128_CBC_SHA256,
-	cipher_TLS_DHE_DSS_WITH_AES_128_CBC_SHA256,
-	cipher_TLS_RSA_WITH_CAMELLIA_128_CBC_SHA,
-	cipher_TLS_DH_DSS_WITH_CAMELLIA_128_CBC_SHA,
-	cipher_TLS_DH_RSA_WITH_CAMELLIA_128_CBC_SHA,
-	cipher_TLS_DHE_DSS_WITH_CAMELLIA_128_CBC_SHA,
-	cipher_TLS_DHE_RSA_WITH_CAMELLIA_128_CBC_SHA,
-	cipher_TLS_DH_anon_WITH_CAMELLIA_128_CBC_SHA,
-	cipher_TLS_DHE_RSA_WITH_AES_128_CBC_SHA256,
-	cipher_TLS_DH_DSS_WITH_AES_256_CBC_SHA256,
-	cipher_TLS_DH_RSA_WITH_AES_256_CBC_SHA256,
-	cipher_TLS_DHE_DSS_WITH_AES_256_CBC_SHA256,
-	cipher_TLS_DHE_RSA_WITH_AES_256_CBC_SHA256,
-	cipher_TLS_DH_anon_WITH_AES_128_CBC_SHA256,
-	cipher_TLS_DH_anon_WITH_AES_256_CBC_SHA256,
-	cipher_TLS_RSA_WITH_CAMELLIA_256_CBC_SHA,
-	cipher_TLS_DH_DSS_WITH_CAMELLIA_256_CBC_SHA,
-	cipher_TLS_DH_RSA_WITH_CAMELLIA_256_CBC_SHA,
-	cipher_TLS_DHE_DSS_WITH_CAMELLIA_256_CBC_SHA,
-	cipher_TLS_DHE_RSA_WITH_CAMELLIA_256_CBC_SHA,
-	cipher_TLS_DH_anon_WITH_CAMELLIA_256_CBC_SHA,
-	cipher_TLS_PSK_WITH_RC4_128_SHA,
-	cipher_TLS_PSK_WITH_3DES_EDE_CBC_SHA,
-	cipher_TLS_PSK_WITH_AES_128_CBC_SHA,
-	cipher_TLS_PSK_WITH_AES_256_CBC_SHA,
-	cipher_TLS_DHE_PSK_WITH_RC4_128_SHA,
-	cipher_TLS_DHE_PSK_WITH_3DES_EDE_CBC_SHA,
-	cipher_TLS_DHE_PSK_WITH_AES_128_CBC_SHA,
-	cipher_TLS_DHE_PSK_WITH_AES_256_CBC_SHA,
-	cipher_TLS_RSA_PSK_WITH_RC4_128_SHA,
-	cipher_TLS_RSA_PSK_WITH_3DES_EDE_CBC_SHA,
-	cipher_TLS_RSA_PSK_WITH_AES_128_CBC_SHA,
-	cipher_TLS_RSA_PSK_WITH_AES_256_CBC_SHA,
-	cipher_TLS_RSA_WITH_SEED_CBC_SHA,
-	cipher_TLS_DH_DSS_WITH_SEED_CBC_SHA,
-	cipher_TLS_DH_RSA_WITH_SEED_CBC_SHA,
-	cipher_TLS_DHE_DSS_WITH_SEED_CBC_SHA,
-	cipher_TLS_DHE_RSA_WITH_SEED_CBC_SHA,
-	cipher_TLS_DH_anon_WITH_SEED_CBC_SHA,
-	cipher_TLS_RSA_WITH_AES_128_GCM_SHA256,
-	cipher_TLS_RSA_WITH_AES_256_GCM_SHA384,
-	cipher_TLS_DH_RSA_WITH_AES_128_GCM_SHA256,
-	cipher_TLS_DH_RSA_WITH_AES_256_GCM_SHA384,
-	cipher_TLS_DH_DSS_WITH_AES_128_GCM_SHA256,
-	cipher_TLS_DH_DSS_WITH_AES_256_GCM_SHA384,
-	cipher_TLS_DH_anon_WITH_AES_128_GCM_SHA256,
-	cipher_TLS_DH_anon_WITH_AES_256_GCM_SHA384,
-	cipher_TLS_PSK_WITH_AES_128_GCM_SHA256,
-	cipher_TLS_PSK_WITH_AES_256_GCM_SHA384,
-	cipher_TLS_RSA_PSK_WITH_AES_128_GCM_SHA256,
-	cipher_TLS_RSA_PSK_WITH_AES_256_GCM_SHA384,
-	cipher_TLS_PSK_WITH_AES_128_CBC_SHA256,
-	cipher_TLS_PSK_WITH_AES_256_CBC_SHA384,
-	cipher_TLS_PSK_WITH_NULL_SHA256,
-	cipher_TLS_PSK_WITH_NULL_SHA384,
-	cipher_TLS_DHE_PSK_WITH_AES_128_CBC_SHA256,
-	cipher_TLS_DHE_PSK_WITH_AES_256_CBC_SHA384,
-	cipher_TLS_DHE_PSK_WITH_NULL_SHA256,
-	cipher_TLS_DHE_PSK_WITH_NULL_SHA384,
-	cipher_TLS_RSA_PSK_WITH_AES_128_CBC_SHA256,
-	cipher_TLS_RSA_PSK_WITH_AES_256_CBC_SHA384,
-	cipher_TLS_RSA_PSK_WITH_NULL_SHA256,
-	cipher_TLS_RSA_PSK_WITH_NULL_SHA384,
-	cipher_TLS_RSA_WITH_CAMELLIA_128_CBC_SHA256,
-	cipher_TLS_DH_DSS_WITH_CAMELLIA_128_CBC_SHA256,
-	cipher_TLS_DH_RSA_WITH_CAMELLIA_128_CBC_SHA256,
-	cipher_TLS_DHE_DSS_WITH_CAMELLIA_128_CBC_SHA256,
-	cipher_TLS_DHE_RSA_WITH_CAMELLIA_128_CBC_SHA256,
-	cipher_TLS_DH_anon_WITH_CAMELLIA_128_CBC_SHA256,
-	cipher_TLS_RSA_WITH_CAMELLIA_256_CBC_SHA256,
-	cipher_TLS_DH_DSS_WITH_CAMELLIA_256_CBC_SHA256,
-	cipher_TLS_DH_RSA_WITH_CAMELLIA_256_CBC_SHA256,
-	cipher_TLS_DHE_DSS_WITH_CAMELLIA_256_CBC_SHA256,
-	cipher_TLS_DHE_RSA_WITH_CAMELLIA_256_CBC_SHA256,
-	cipher_TLS_DH_anon_WITH_CAMELLIA_256_CBC_SHA256,
-	cipher_TLS_EMPTY_RENEGOTIATION_INFO_SCSV,
-	cipher_TLS_ECDH_ECDSA_WITH_NULL_SHA,
-	cipher_TLS_ECDH_ECDSA_WITH_RC4_128_SHA,
-	cipher_TLS_ECDH_ECDSA_WITH_3DES_EDE_CBC_SHA,
-	cipher_TLS_ECDH_ECDSA_WITH_AES_128_CBC_SHA,
-	cipher_TLS_ECDH_ECDSA_WITH_AES_256_CBC_SHA,
-	cipher_TLS_ECDHE_ECDSA_WITH_NULL_SHA,
-	cipher_TLS_ECDHE_ECDSA_WITH_RC4_128_SHA,
-	cipher_TLS_ECDHE_ECDSA_WITH_3DES_EDE_CBC_SHA,
-	cipher_TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA,
-	cipher_TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA,
-	cipher_TLS_ECDH_RSA_WITH_NULL_SHA,
-	cipher_TLS_ECDH_RSA_WITH_RC4_128_SHA,
-	cipher_TLS_ECDH_RSA_WITH_3DES_EDE_CBC_SHA,
-	cipher_TLS_ECDH_RSA_WITH_AES_128_CBC_SHA,
-	cipher_TLS_ECDH_RSA_WITH_AES_256_CBC_SHA,
-	cipher_TLS_ECDHE_RSA_WITH_NULL_SHA,
-	cipher_TLS_ECDHE_RSA_WITH_RC4_128_SHA,
-	cipher_TLS_ECDHE_RSA_WITH_3DES_EDE_CBC_SHA,
-	cipher_TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA,
-	cipher_TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA,
-	cipher_TLS_ECDH_anon_WITH_NULL_SHA,
-	cipher_TLS_ECDH_anon_WITH_RC4_128_SHA,
-	cipher_TLS_ECDH_anon_WITH_3DES_EDE_CBC_SHA,
-	cipher_TLS_ECDH_anon_WITH_AES_128_CBC_SHA,
-	cipher_TLS_ECDH_anon_WITH_AES_256_CBC_SHA,
-	cipher_TLS_SRP_SHA_WITH_3DES_EDE_CBC_SHA,
-	cipher_TLS_SRP_SHA_RSA_WITH_3DES_EDE_CBC_SHA,
-	cipher_TLS_SRP_SHA_DSS_WITH_3DES_EDE_CBC_SHA,
-	cipher_TLS_SRP_SHA_WITH_AES_128_CBC_SHA,
-	cipher_TLS_SRP_SHA_RSA_WITH_AES_128_CBC_SHA,
-	cipher_TLS_SRP_SHA_DSS_WITH_AES_128_CBC_SHA,
-	cipher_TLS_SRP_SHA_WITH_AES_256_CBC_SHA,
-	cipher_TLS_SRP_SHA_RSA_WITH_AES_256_CBC_SHA,
-	cipher_TLS_SRP_SHA_DSS_WITH_AES_256_CBC_SHA,
-	cipher_TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256,
-	cipher_TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA384,
-	cipher_TLS_ECDH_ECDSA_WITH_AES_128_CBC_SHA256,
-	cipher_TLS_ECDH_ECDSA_WITH_AES_256_CBC_SHA384,
-	cipher_TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256,
-	cipher_TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA384,
-	cipher_TLS_ECDH_RSA_WITH_AES_128_CBC_SHA256,
-	cipher_TLS_ECDH_RSA_WITH_AES_256_CBC_SHA384,
-	cipher_TLS_ECDH_ECDSA_WITH_AES_128_GCM_SHA256,
-	cipher_TLS_ECDH_ECDSA_WITH_AES_256_GCM_SHA384,
-	cipher_TLS_ECDH_RSA_WITH_AES_128_GCM_SHA256,
-	cipher_TLS_ECDH_RSA_WITH_AES_256_GCM_SHA384,
-	cipher_TLS_ECDHE_PSK_WITH_RC4_128_SHA,
-	cipher_TLS_ECDHE_PSK_WITH_3DES_EDE_CBC_SHA,
-	cipher_TLS_ECDHE_PSK_WITH_AES_128_CBC_SHA,
-	cipher_TLS_ECDHE_PSK_WITH_AES_256_CBC_SHA,
-	cipher_TLS_ECDHE_PSK_WITH_AES_128_CBC_SHA256,
-	cipher_TLS_ECDHE_PSK_WITH_AES_256_CBC_SHA384,
-	cipher_TLS_ECDHE_PSK_WITH_NULL_SHA,
-	cipher_TLS_ECDHE_PSK_WITH_NULL_SHA256,
-	cipher_TLS_ECDHE_PSK_WITH_NULL_SHA384,
-	cipher_TLS_RSA_WITH_ARIA_128_CBC_SHA256,
-	cipher_TLS_RSA_WITH_ARIA_256_CBC_SHA384,
-	cipher_TLS_DH_DSS_WITH_ARIA_128_CBC_SHA256,
-	cipher_TLS_DH_DSS_WITH_ARIA_256_CBC_SHA384,
-	cipher_TLS_DH_RSA_WITH_ARIA_128_CBC_SHA256,
-	cipher_TLS_DH_RSA_WITH_ARIA_256_CBC_SHA384,
-	cipher_TLS_DHE_DSS_WITH_ARIA_128_CBC_SHA256,
-	cipher_TLS_DHE_DSS_WITH_ARIA_256_CBC_SHA384,
-	cipher_TLS_DHE_RSA_WITH_ARIA_128_CBC_SHA256,
-	cipher_TLS_DHE_RSA_WITH_ARIA_256_CBC_SHA384,
-	cipher_TLS_DH_anon_WITH_ARIA_128_CBC_SHA256,
-	cipher_TLS_DH_anon_WITH_ARIA_256_CBC_SHA384,
-	cipher_TLS_ECDHE_ECDSA_WITH_ARIA_128_CBC_SHA256,
-	cipher_TLS_ECDHE_ECDSA_WITH_ARIA_256_CBC_SHA384,
-	cipher_TLS_ECDH_ECDSA_WITH_ARIA_128_CBC_SHA256,
-	cipher_TLS_ECDH_ECDSA_WITH_ARIA_256_CBC_SHA384,
-	cipher_TLS_ECDHE_RSA_WITH_ARIA_128_CBC_SHA256,
-	cipher_TLS_ECDHE_RSA_WITH_ARIA_256_CBC_SHA384,
-	cipher_TLS_ECDH_RSA_WITH_ARIA_128_CBC_SHA256,
-	cipher_TLS_ECDH_RSA_WITH_ARIA_256_CBC_SHA384,
-	cipher_TLS_RSA_WITH_ARIA_128_GCM_SHA256,
-	cipher_TLS_RSA_WITH_ARIA_256_GCM_SHA384,
-	cipher_TLS_DH_RSA_WITH_ARIA_128_GCM_SHA256,
-	cipher_TLS_DH_RSA_WITH_ARIA_256_GCM_SHA384,
-	cipher_TLS_DH_DSS_WITH_ARIA_128_GCM_SHA256,
-	cipher_TLS_DH_DSS_WITH_ARIA_256_GCM_SHA384,
-	cipher_TLS_DH_anon_WITH_ARIA_128_GCM_SHA256,
-	cipher_TLS_DH_anon_WITH_ARIA_256_GCM_SHA384,
-	cipher_TLS_ECDH_ECDSA_WITH_ARIA_128_GCM_SHA256,
-	cipher_TLS_ECDH_ECDSA_WITH_ARIA_256_GCM_SHA384,
-	cipher_TLS_ECDH_RSA_WITH_ARIA_128_GCM_SHA256,
-	cipher_TLS_ECDH_RSA_WITH_ARIA_256_GCM_SHA384,
-	cipher_TLS_PSK_WITH_ARIA_128_CBC_SHA256,
-	cipher_TLS_PSK_WITH_ARIA_256_CBC_SHA384,
-	cipher_TLS_DHE_PSK_WITH_ARIA_128_CBC_SHA256,
-	cipher_TLS_DHE_PSK_WITH_ARIA_256_CBC_SHA384,
-	cipher_TLS_RSA_PSK_WITH_ARIA_128_CBC_SHA256,
-	cipher_TLS_RSA_PSK_WITH_ARIA_256_CBC_SHA384,
-	cipher_TLS_PSK_WITH_ARIA_128_GCM_SHA256,
-	cipher_TLS_PSK_WITH_ARIA_256_GCM_SHA384,
-	cipher_TLS_RSA_PSK_WITH_ARIA_128_GCM_SHA256,
-	cipher_TLS_RSA_PSK_WITH_ARIA_256_GCM_SHA384,
-	cipher_TLS_ECDHE_PSK_WITH_ARIA_128_CBC_SHA256,
-	cipher_TLS_ECDHE_PSK_WITH_ARIA_256_CBC_SHA384,
-	cipher_TLS_ECDHE_ECDSA_WITH_CAMELLIA_128_CBC_SHA256,
-	cipher_TLS_ECDHE_ECDSA_WITH_CAMELLIA_256_CBC_SHA384,
-	cipher_TLS_ECDH_ECDSA_WITH_CAMELLIA_128_CBC_SHA256,
-	cipher_TLS_ECDH_ECDSA_WITH_CAMELLIA_256_CBC_SHA384,
-	cipher_TLS_ECDHE_RSA_WITH_CAMELLIA_128_CBC_SHA256,
-	cipher_TLS_ECDHE_RSA_WITH_CAMELLIA_256_CBC_SHA384,
-	cipher_TLS_ECDH_RSA_WITH_CAMELLIA_128_CBC_SHA256,
-	cipher_TLS_ECDH_RSA_WITH_CAMELLIA_256_CBC_SHA384,
-	cipher_TLS_RSA_WITH_CAMELLIA_128_GCM_SHA256,
-	cipher_TLS_RSA_WITH_CAMELLIA_256_GCM_SHA384,
-	cipher_TLS_DH_RSA_WITH_CAMELLIA_128_GCM_SHA256,
-	cipher_TLS_DH_RSA_WITH_CAMELLIA_256_GCM_SHA384,
-	cipher_TLS_DH_DSS_WITH_CAMELLIA_128_GCM_SHA256,
-	cipher_TLS_DH_DSS_WITH_CAMELLIA_256_GCM_SHA384,
-	cipher_TLS_DH_anon_WITH_CAMELLIA_128_GCM_SHA256,
-	cipher_TLS_DH_anon_WITH_CAMELLIA_256_GCM_SHA384,
-	cipher_TLS_ECDH_ECDSA_WITH_CAMELLIA_128_GCM_SHA256,
-	cipher_TLS_ECDH_ECDSA_WITH_CAMELLIA_256_GCM_SHA384,
-	cipher_TLS_ECDH_RSA_WITH_CAMELLIA_128_GCM_SHA256,
-	cipher_TLS_ECDH_RSA_WITH_CAMELLIA_256_GCM_SHA384,
-	cipher_TLS_PSK_WITH_CAMELLIA_128_GCM_SHA256,
-	cipher_TLS_PSK_WITH_CAMELLIA_256_GCM_SHA384,
-	cipher_TLS_RSA_PSK_WITH_CAMELLIA_128_GCM_SHA256,
-	cipher_TLS_RSA_PSK_WITH_CAMELLIA_256_GCM_SHA384,
-	cipher_TLS_PSK_WITH_CAMELLIA_128_CBC_SHA256,
-	cipher_TLS_PSK_WITH_CAMELLIA_256_CBC_SHA384,
-	cipher_TLS_DHE_PSK_WITH_CAMELLIA_128_CBC_SHA256,
-	cipher_TLS_DHE_PSK_WITH_CAMELLIA_256_CBC_SHA384,
-	cipher_TLS_RSA_PSK_WITH_CAMELLIA_128_CBC_SHA256,
-	cipher_TLS_RSA_PSK_WITH_CAMELLIA_256_CBC_SHA384,
-	cipher_TLS_ECDHE_PSK_WITH_CAMELLIA_128_CBC_SHA256,
-	cipher_TLS_ECDHE_PSK_WITH_CAMELLIA_256_CBC_SHA384,
-	cipher_TLS_RSA_WITH_AES_128_CCM,
-	cipher_TLS_RSA_WITH_AES_256_CCM,
-	cipher_TLS_RSA_WITH_AES_128_CCM_8,
-	cipher_TLS_RSA_WITH_AES_256_CCM_8,
-	cipher_TLS_PSK_WITH_AES_128_CCM,
-	cipher_TLS_PSK_WITH_AES_256_CCM,
-	cipher_TLS_PSK_WITH_AES_128_CCM_8,
-	cipher_TLS_PSK_WITH_AES_256_CCM_8,
-}

vendor/golang.org/x/net/http2/client_conn_pool.go

@@ -1,256 +0,0 @@
-// Copyright 2015 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.
-
-// Transport code's client connection pooling.
-
-package http2
-
-import (
-	"crypto/tls"
-	"net/http"
-	"sync"
-)
-
-// ClientConnPool manages a pool of HTTP/2 client connections.
-type ClientConnPool interface {
-	GetClientConn(req *http.Request, addr string) (*ClientConn, error)
-	MarkDead(*ClientConn)
-}
-
-// clientConnPoolIdleCloser is the interface implemented by ClientConnPool
-// implementations which can close their idle connections.
-type clientConnPoolIdleCloser interface {
-	ClientConnPool
-	closeIdleConnections()
-}
-
-var (
-	_ clientConnPoolIdleCloser = (*clientConnPool)(nil)
-	_ clientConnPoolIdleCloser = noDialClientConnPool{}
-)
-
-// TODO: use singleflight for dialing and addConnCalls?
-type clientConnPool struct {
-	t *Transport
-
-	mu sync.Mutex // TODO: maybe switch to RWMutex
-	// TODO: add support for sharing conns based on cert names
-	// (e.g. share conn for googleapis.com and appspot.com)
-	conns        map[string][]*ClientConn // key is host:port
-	dialing      map[string]*dialCall     // currently in-flight dials
-	keys         map[*ClientConn][]string
-	addConnCalls map[string]*addConnCall // in-flight addConnIfNeede calls
-}
-
-func (p *clientConnPool) GetClientConn(req *http.Request, addr string) (*ClientConn, error) {
-	return p.getClientConn(req, addr, dialOnMiss)
-}
-
-const (
-	dialOnMiss   = true
-	noDialOnMiss = false
-)
-
-func (p *clientConnPool) getClientConn(req *http.Request, addr string, dialOnMiss bool) (*ClientConn, error) {
-	if isConnectionCloseRequest(req) && dialOnMiss {
-		// It gets its own connection.
-		const singleUse = true
-		cc, err := p.t.dialClientConn(addr, singleUse)
-		if err != nil {
-			return nil, err
-		}
-		return cc, nil
-	}
-	p.mu.Lock()
-	for _, cc := range p.conns[addr] {
-		if cc.CanTakeNewRequest() {
-			p.mu.Unlock()
-			return cc, nil
-		}
-	}
-	if !dialOnMiss {
-		p.mu.Unlock()
-		return nil, ErrNoCachedConn
-	}
-	call := p.getStartDialLocked(addr)
-	p.mu.Unlock()
-	<-call.done
-	return call.res, call.err
-}
-
-// dialCall is an in-flight Transport dial call to a host.
-type dialCall struct {
-	p    *clientConnPool
-	done chan struct{} // closed when done
-	res  *ClientConn   // valid after done is closed
-	err  error         // valid after done is closed
-}
-
-// requires p.mu is held.
-func (p *clientConnPool) getStartDialLocked(addr string) *dialCall {
-	if call, ok := p.dialing[addr]; ok {
-		// A dial is already in-flight. Don't start another.
-		return call
-	}
-	call := &dialCall{p: p, done: make(chan struct{})}
-	if p.dialing == nil {
-		p.dialing = make(map[string]*dialCall)
-	}
-	p.dialing[addr] = call
-	go call.dial(addr)
-	return call
-}
-
-// run in its own goroutine.
-func (c *dialCall) dial(addr string) {
-	const singleUse = false // shared conn
-	c.res, c.err = c.p.t.dialClientConn(addr, singleUse)
-	close(c.done)
-
-	c.p.mu.Lock()
-	delete(c.p.dialing, addr)
-	if c.err == nil {
-		c.p.addConnLocked(addr, c.res)
-	}
-	c.p.mu.Unlock()
-}
-
-// addConnIfNeeded makes a NewClientConn out of c if a connection for key doesn't
-// already exist. It coalesces concurrent calls with the same key.
-// This is used by the http1 Transport code when it creates a new connection. Because
-// the http1 Transport doesn't de-dup TCP dials to outbound hosts (because it doesn't know
-// the protocol), it can get into a situation where it has multiple TLS connections.
-// This code decides which ones live or die.
-// The return value used is whether c was used.
-// c is never closed.
-func (p *clientConnPool) addConnIfNeeded(key string, t *Transport, c *tls.Conn) (used bool, err error) {
-	p.mu.Lock()
-	for _, cc := range p.conns[key] {
-		if cc.CanTakeNewRequest() {
-			p.mu.Unlock()
-			return false, nil
-		}
-	}
-	call, dup := p.addConnCalls[key]
-	if !dup {
-		if p.addConnCalls == nil {
-			p.addConnCalls = make(map[string]*addConnCall)
-		}
-		call = &addConnCall{
-			p:    p,
-			done: make(chan struct{}),
-		}
-		p.addConnCalls[key] = call
-		go call.run(t, key, c)
-	}
-	p.mu.Unlock()
-
-	<-call.done
-	if call.err != nil {
-		return false, call.err
-	}
-	return !dup, nil
-}
-
-type addConnCall struct {
-	p    *clientConnPool
-	done chan struct{} // closed when done
-	err  error
-}
-
-func (c *addConnCall) run(t *Transport, key string, tc *tls.Conn) {
-	cc, err := t.NewClientConn(tc)
-
-	p := c.p
-	p.mu.Lock()
-	if err != nil {
-		c.err = err
-	} else {
-		p.addConnLocked(key, cc)
-	}
-	delete(p.addConnCalls, key)
-	p.mu.Unlock()
-	close(c.done)
-}
-
-func (p *clientConnPool) addConn(key string, cc *ClientConn) {
-	p.mu.Lock()
-	p.addConnLocked(key, cc)
-	p.mu.Unlock()
-}
-
-// p.mu must be held
-func (p *clientConnPool) addConnLocked(key string, cc *ClientConn) {
-	for _, v := range p.conns[key] {
-		if v == cc {
-			return
-		}
-	}
-	if p.conns == nil {
-		p.conns = make(map[string][]*ClientConn)
-	}
-	if p.keys == nil {
-		p.keys = make(map[*ClientConn][]string)
-	}
-	p.conns[key] = append(p.conns[key], cc)
-	p.keys[cc] = append(p.keys[cc], key)
-}
-
-func (p *clientConnPool) MarkDead(cc *ClientConn) {
-	p.mu.Lock()
-	defer p.mu.Unlock()
-	for _, key := range p.keys[cc] {
-		vv, ok := p.conns[key]
-		if !ok {
-			continue
-		}
-		newList := filterOutClientConn(vv, cc)
-		if len(newList) > 0 {
-			p.conns[key] = newList
-		} else {
-			delete(p.conns, key)
-		}
-	}
-	delete(p.keys, cc)
-}
-
-func (p *clientConnPool) closeIdleConnections() {
-	p.mu.Lock()
-	defer p.mu.Unlock()
-	// TODO: don't close a cc if it was just added to the pool
-	// milliseconds ago and has never been used. There's currently
-	// a small race window with the HTTP/1 Transport's integration
-	// where it can add an idle conn just before using it, and
-	// somebody else can concurrently call CloseIdleConns and
-	// break some caller's RoundTrip.
-	for _, vv := range p.conns {
-		for _, cc := range vv {
-			cc.closeIfIdle()
-		}
-	}
-}
-
-func filterOutClientConn(in []*ClientConn, exclude *ClientConn) []*ClientConn {
-	out := in[:0]
-	for _, v := range in {
-		if v != exclude {
-			out = append(out, v)
-		}
-	}
-	// If we filtered it out, zero out the last item to prevent
-	// the GC from seeing it.
-	if len(in) != len(out) {
-		in[len(in)-1] = nil
-	}
-	return out
-}
-
-// noDialClientConnPool is an implementation of http2.ClientConnPool
-// which never dials. We let the HTTP/1.1 client dial and use its TLS
-// connection instead.
-type noDialClientConnPool struct{ *clientConnPool }
-
-func (p noDialClientConnPool) GetClientConn(req *http.Request, addr string) (*ClientConn, error) {
-	return p.getClientConn(req, addr, noDialOnMiss)
-}

vendor/golang.org/x/net/http2/configure_transport.go

@@ -1,80 +0,0 @@
-// Copyright 2015 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 go1.6
-
-package http2
-
-import (
-	"crypto/tls"
-	"fmt"
-	"net/http"
-)
-
-func configureTransport(t1 *http.Transport) (*Transport, error) {
-	connPool := new(clientConnPool)
-	t2 := &Transport{
-		ConnPool: noDialClientConnPool{connPool},
-		t1:       t1,
-	}
-	connPool.t = t2
-	if err := registerHTTPSProtocol(t1, noDialH2RoundTripper{t2}); err != nil {
-		return nil, err
-	}
-	if t1.TLSClientConfig == nil {
-		t1.TLSClientConfig = new(tls.Config)
-	}
-	if !strSliceContains(t1.TLSClientConfig.NextProtos, "h2") {
-		t1.TLSClientConfig.NextProtos = append([]string{"h2"}, t1.TLSClientConfig.NextProtos...)
-	}
-	if !strSliceContains(t1.TLSClientConfig.NextProtos, "http/1.1") {
-		t1.TLSClientConfig.NextProtos = append(t1.TLSClientConfig.NextProtos, "http/1.1")
-	}
-	upgradeFn := func(authority string, c *tls.Conn) http.RoundTripper {
-		addr := authorityAddr("https", authority)
-		if used, err := connPool.addConnIfNeeded(addr, t2, c); err != nil {
-			go c.Close()
-			return erringRoundTripper{err}
-		} else if !used {
-			// Turns out we don't need this c.
-			// For example, two goroutines made requests to the same host
-			// at the same time, both kicking off TCP dials. (since protocol
-			// was unknown)
-			go c.Close()
-		}
-		return t2
-	}
-	if m := t1.TLSNextProto; len(m) == 0 {
-		t1.TLSNextProto = map[string]func(string, *tls.Conn) http.RoundTripper{
-			"h2": upgradeFn,
-		}
-	} else {
-		m["h2"] = upgradeFn
-	}
-	return t2, nil
-}
-
-// registerHTTPSProtocol calls Transport.RegisterProtocol but
-// converting panics into errors.
-func registerHTTPSProtocol(t *http.Transport, rt http.RoundTripper) (err error) {
-	defer func() {
-		if e := recover(); e != nil {
-			err = fmt.Errorf("%v", e)
-		}
-	}()
-	t.RegisterProtocol("https", rt)
-	return nil
-}
-
-// noDialH2RoundTripper is a RoundTripper which only tries to complete the request
-// if there's already has a cached connection to the host.
-type noDialH2RoundTripper struct{ t *Transport }
-
-func (rt noDialH2RoundTripper) RoundTrip(req *http.Request) (*http.Response, error) {
-	res, err := rt.t.RoundTrip(req)
-	if err == ErrNoCachedConn {
-		return nil, http.ErrSkipAltProtocol
-	}
-	return res, err
-}

vendor/golang.org/x/net/http2/databuffer.go

@@ -1,146 +0,0 @@
-// Copyright 2014 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package http2
-
-import (
-	"errors"
-	"fmt"
-	"sync"
-)
-
-// Buffer chunks are allocated from a pool to reduce pressure on GC.
-// The maximum wasted space per dataBuffer is 2x the largest size class,
-// which happens when the dataBuffer has multiple chunks and there is
-// one unread byte in both the first and last chunks. We use a few size
-// classes to minimize overheads for servers that typically receive very
-// small request bodies.
-//
-// TODO: Benchmark to determine if the pools are necessary. The GC may have
-// improved enough that we can instead allocate chunks like this:
-// make([]byte, max(16<<10, expectedBytesRemaining))
-var (
-	dataChunkSizeClasses = []int{
-		1 << 10,
-		2 << 10,
-		4 << 10,
-		8 << 10,
-		16 << 10,
-	}
-	dataChunkPools = [...]sync.Pool{
-		{New: func() interface{} { return make([]byte, 1<<10) }},
-		{New: func() interface{} { return make([]byte, 2<<10) }},
-		{New: func() interface{} { return make([]byte, 4<<10) }},
-		{New: func() interface{} { return make([]byte, 8<<10) }},
-		{New: func() interface{} { return make([]byte, 16<<10) }},
-	}
-)
-
-func getDataBufferChunk(size int64) []byte {
-	i := 0
-	for ; i < len(dataChunkSizeClasses)-1; i++ {
-		if size <= int64(dataChunkSizeClasses[i]) {
-			break
-		}
-	}
-	return dataChunkPools[i].Get().([]byte)
-}
-
-func putDataBufferChunk(p []byte) {
-	for i, n := range dataChunkSizeClasses {
-		if len(p) == n {
-			dataChunkPools[i].Put(p)
-			return
-		}
-	}
-	panic(fmt.Sprintf("unexpected buffer len=%v", len(p)))
-}
-
-// dataBuffer is an io.ReadWriter backed by a list of data chunks.
-// Each dataBuffer is used to read DATA frames on a single stream.
-// The buffer is divided into chunks so the server can limit the
-// total memory used by a single connection without limiting the
-// request body size on any single stream.
-type dataBuffer struct {
-	chunks   [][]byte
-	r        int   // next byte to read is chunks[0][r]
-	w        int   // next byte to write is chunks[len(chunks)-1][w]
-	size     int   // total buffered bytes
-	expected int64 // we expect at least this many bytes in future Write calls (ignored if <= 0)
-}
-
-var errReadEmpty = errors.New("read from empty dataBuffer")
-
-// Read copies bytes from the buffer into p.
-// It is an error to read when no data is available.
-func (b *dataBuffer) Read(p []byte) (int, error) {
-	if b.size == 0 {
-		return 0, errReadEmpty
-	}
-	var ntotal int
-	for len(p) > 0 && b.size > 0 {
-		readFrom := b.bytesFromFirstChunk()
-		n := copy(p, readFrom)
-		p = p[n:]
-		ntotal += n
-		b.r += n
-		b.size -= n
-		// If the first chunk has been consumed, advance to the next chunk.
-		if b.r == len(b.chunks[0]) {
-			putDataBufferChunk(b.chunks[0])
-			end := len(b.chunks) - 1
-			copy(b.chunks[:end], b.chunks[1:])
-			b.chunks[end] = nil
-			b.chunks = b.chunks[:end]
-			b.r = 0
-		}
-	}
-	return ntotal, nil
-}
-
-func (b *dataBuffer) bytesFromFirstChunk() []byte {
-	if len(b.chunks) == 1 {
-		return b.chunks[0][b.r:b.w]
-	}
-	return b.chunks[0][b.r:]
-}
-
-// Len returns the number of bytes of the unread portion of the buffer.
-func (b *dataBuffer) Len() int {
-	return b.size
-}
-
-// Write appends p to the buffer.
-func (b *dataBuffer) Write(p []byte) (int, error) {
-	ntotal := len(p)
-	for len(p) > 0 {
-		// If the last chunk is empty, allocate a new chunk. Try to allocate
-		// enough to fully copy p plus any additional bytes we expect to
-		// receive. However, this may allocate less than len(p).
-		want := int64(len(p))
-		if b.expected > want {
-			want = b.expected
-		}
-		chunk := b.lastChunkOrAlloc(want)
-		n := copy(chunk[b.w:], p)
-		p = p[n:]
-		b.w += n
-		b.size += n
-		b.expected -= int64(n)
-	}
-	return ntotal, nil
-}
-
-func (b *dataBuffer) lastChunkOrAlloc(want int64) []byte {
-	if len(b.chunks) != 0 {
-		last := b.chunks[len(b.chunks)-1]
-		if b.w < len(last) {
-			return last
-		}
-	}
-	chunk := getDataBufferChunk(want)
-	b.chunks = append(b.chunks, chunk)
-	b.w = 0
-	return chunk
-}

vendor/golang.org/x/net/http2/databuffer_test.go

@@ -1,157 +0,0 @@
-// Copyright 2017 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 go1.7
-
-package http2
-
-import (
-	"bytes"
-	"fmt"
-	"reflect"
-	"testing"
-)
-
-func fmtDataChunk(chunk []byte) string {
-	out := ""
-	var last byte
-	var count int
-	for _, c := range chunk {
-		if c != last {
-			if count > 0 {
-				out += fmt.Sprintf(" x %d ", count)
-				count = 0
-			}
-			out += string([]byte{c})
-			last = c
-		}
-		count++
-	}
-	if count > 0 {
-		out += fmt.Sprintf(" x %d", count)
-	}
-	return out
-}
-
-func fmtDataChunks(chunks [][]byte) string {
-	var out string
-	for _, chunk := range chunks {
-		out += fmt.Sprintf("{%q}", fmtDataChunk(chunk))
-	}
-	return out
-}
-
-func testDataBuffer(t *testing.T, wantBytes []byte, setup func(t *testing.T) *dataBuffer) {
-	// Run setup, then read the remaining bytes from the dataBuffer and check
-	// that they match wantBytes. We use different read sizes to check corner
-	// cases in Read.
-	for _, readSize := range []int{1, 2, 1 * 1024, 32 * 1024} {
-		t.Run(fmt.Sprintf("ReadSize=%d", readSize), func(t *testing.T) {
-			b := setup(t)
-			buf := make([]byte, readSize)
-			var gotRead bytes.Buffer
-			for {
-				n, err := b.Read(buf)
-				gotRead.Write(buf[:n])
-				if err == errReadEmpty {
-					break
-				}
-				if err != nil {
-					t.Fatalf("error after %v bytes: %v", gotRead.Len(), err)
-				}
-			}
-			if got, want := gotRead.Bytes(), wantBytes; !bytes.Equal(got, want) {
-				t.Errorf("FinalRead=%q, want %q", fmtDataChunk(got), fmtDataChunk(want))
-			}
-		})
-	}
-}
-
-func TestDataBufferAllocation(t *testing.T) {
-	writes := [][]byte{
-		bytes.Repeat([]byte("a"), 1*1024-1),
-		[]byte("a"),
-		bytes.Repeat([]byte("b"), 4*1024-1),
-		[]byte("b"),
-		bytes.Repeat([]byte("c"), 8*1024-1),
-		[]byte("c"),
-		bytes.Repeat([]byte("d"), 16*1024-1),
-		[]byte("d"),
-		bytes.Repeat([]byte("e"), 32*1024),
-	}
-	var wantRead bytes.Buffer
-	for _, p := range writes {
-		wantRead.Write(p)
-	}
-
-	testDataBuffer(t, wantRead.Bytes(), func(t *testing.T) *dataBuffer {
-		b := &dataBuffer{}
-		for _, p := range writes {
-			if n, err := b.Write(p); n != len(p) || err != nil {
-				t.Fatalf("Write(%q x %d)=%v,%v want %v,nil", p[:1], len(p), n, err, len(p))
-			}
-		}
-		want := [][]byte{
-			bytes.Repeat([]byte("a"), 1*1024),
-			bytes.Repeat([]byte("b"), 4*1024),
-			bytes.Repeat([]byte("c"), 8*1024),
-			bytes.Repeat([]byte("d"), 16*1024),
-			bytes.Repeat([]byte("e"), 16*1024),
-			bytes.Repeat([]byte("e"), 16*1024),
-		}
-		if !reflect.DeepEqual(b.chunks, want) {
-			t.Errorf("dataBuffer.chunks\ngot:  %s\nwant: %s", fmtDataChunks(b.chunks), fmtDataChunks(want))
-		}
-		return b
-	})
-}
-
-func TestDataBufferAllocationWithExpected(t *testing.T) {
-	writes := [][]byte{
-		bytes.Repeat([]byte("a"), 1*1024), // allocates 16KB
-		bytes.Repeat([]byte("b"), 14*1024),
-		bytes.Repeat([]byte("c"), 15*1024), // allocates 16KB more
-		bytes.Repeat([]byte("d"), 2*1024),
-		bytes.Repeat([]byte("e"), 1*1024), // overflows 32KB expectation, allocates just 1KB
-	}
-	var wantRead bytes.Buffer
-	for _, p := range writes {
-		wantRead.Write(p)
-	}
-
-	testDataBuffer(t, wantRead.Bytes(), func(t *testing.T) *dataBuffer {
-		b := &dataBuffer{expected: 32 * 1024}
-		for _, p := range writes {
-			if n, err := b.Write(p); n != len(p) || err != nil {
-				t.Fatalf("Write(%q x %d)=%v,%v want %v,nil", p[:1], len(p), n, err, len(p))
-			}
-		}
-		want := [][]byte{
-			append(bytes.Repeat([]byte("a"), 1*1024), append(bytes.Repeat([]byte("b"), 14*1024), bytes.Repeat([]byte("c"), 1*1024)...)...),
-			append(bytes.Repeat([]byte("c"), 14*1024), bytes.Repeat([]byte("d"), 2*1024)...),
-			bytes.Repeat([]byte("e"), 1*1024),
-		}
-		if !reflect.DeepEqual(b.chunks, want) {
-			t.Errorf("dataBuffer.chunks\ngot:  %s\nwant: %s", fmtDataChunks(b.chunks), fmtDataChunks(want))
-		}
-		return b
-	})
-}
-
-func TestDataBufferWriteAfterPartialRead(t *testing.T) {
-	testDataBuffer(t, []byte("cdxyz"), func(t *testing.T) *dataBuffer {
-		b := &dataBuffer{}
-		if n, err := b.Write([]byte("abcd")); n != 4 || err != nil {
-			t.Fatalf("Write(\"abcd\")=%v,%v want 4,nil", n, err)
-		}
-		p := make([]byte, 2)
-		if n, err := b.Read(p); n != 2 || err != nil || !bytes.Equal(p, []byte("ab")) {
-			t.Fatalf("Read()=%q,%v,%v want \"ab\",2,nil", p, n, err)
-		}
-		if n, err := b.Write([]byte("xyz")); n != 3 || err != nil {
-			t.Fatalf("Write(\"xyz\")=%v,%v want 3,nil", n, err)
-		}
-		return b
-	})
-}

vendor/golang.org/x/net/http2/errors.go

@@ -1,133 +0,0 @@
-// Copyright 2014 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package http2
-
-import (
-	"errors"
-	"fmt"
-)
-
-// An ErrCode is an unsigned 32-bit error code as defined in the HTTP/2 spec.
-type ErrCode uint32
-
-const (
-	ErrCodeNo                 ErrCode = 0x0
-	ErrCodeProtocol           ErrCode = 0x1
-	ErrCodeInternal           ErrCode = 0x2
-	ErrCodeFlowControl        ErrCode = 0x3
-	ErrCodeSettingsTimeout    ErrCode = 0x4
-	ErrCodeStreamClosed       ErrCode = 0x5
-	ErrCodeFrameSize          ErrCode = 0x6
-	ErrCodeRefusedStream      ErrCode = 0x7
-	ErrCodeCancel             ErrCode = 0x8
-	ErrCodeCompression        ErrCode = 0x9
-	ErrCodeConnect            ErrCode = 0xa
-	ErrCodeEnhanceYourCalm    ErrCode = 0xb
-	ErrCodeInadequateSecurity ErrCode = 0xc
-	ErrCodeHTTP11Required     ErrCode = 0xd
-)
-
-var errCodeName = map[ErrCode]string{
-	ErrCodeNo:                 "NO_ERROR",
-	ErrCodeProtocol:           "PROTOCOL_ERROR",
-	ErrCodeInternal:           "INTERNAL_ERROR",
-	ErrCodeFlowControl:        "FLOW_CONTROL_ERROR",
-	ErrCodeSettingsTimeout:    "SETTINGS_TIMEOUT",
-	ErrCodeStreamClosed:       "STREAM_CLOSED",
-	ErrCodeFrameSize:          "FRAME_SIZE_ERROR",
-	ErrCodeRefusedStream:      "REFUSED_STREAM",
-	ErrCodeCancel:             "CANCEL",
-	ErrCodeCompression:        "COMPRESSION_ERROR",
-	ErrCodeConnect:            "CONNECT_ERROR",
-	ErrCodeEnhanceYourCalm:    "ENHANCE_YOUR_CALM",
-	ErrCodeInadequateSecurity: "INADEQUATE_SECURITY",
-	ErrCodeHTTP11Required:     "HTTP_1_1_REQUIRED",
-}
-
-func (e ErrCode) String() string {
-	if s, ok := errCodeName[e]; ok {
-		return s
-	}
-	return fmt.Sprintf("unknown error code 0x%x", uint32(e))
-}
-
-// ConnectionError is an error that results in the termination of the
-// entire connection.
-type ConnectionError ErrCode
-
-func (e ConnectionError) Error() string { return fmt.Sprintf("connection error: %s", ErrCode(e)) }
-
-// StreamError is an error that only affects one stream within an
-// HTTP/2 connection.
-type StreamError struct {
-	StreamID uint32
-	Code     ErrCode
-	Cause    error // optional additional detail
-}
-
-func streamError(id uint32, code ErrCode) StreamError {
-	return StreamError{StreamID: id, Code: code}
-}
-
-func (e StreamError) Error() string {
-	if e.Cause != nil {
-		return fmt.Sprintf("stream error: stream ID %d; %v; %v", e.StreamID, e.Code, e.Cause)
-	}
-	return fmt.Sprintf("stream error: stream ID %d; %v", e.StreamID, e.Code)
-}
-
-// 6.9.1 The Flow Control Window
-// "If a sender receives a WINDOW_UPDATE that causes a flow control
-// window to exceed this maximum it MUST terminate either the stream
-// or the connection, as appropriate. For streams, [...]; for the
-// connection, a GOAWAY frame with a FLOW_CONTROL_ERROR code."
-type goAwayFlowError struct{}
-
-func (goAwayFlowError) Error() string { return "connection exceeded flow control window size" }
-
-// connError represents an HTTP/2 ConnectionError error code, along
-// with a string (for debugging) explaining why.
-//
-// Errors of this type are only returned by the frame parser functions
-// and converted into ConnectionError(Code), after stashing away
-// the Reason into the Framer's errDetail field, accessible via
-// the (*Framer).ErrorDetail method.
-type connError struct {
-	Code   ErrCode // the ConnectionError error code
-	Reason string  // additional reason
-}
-
-func (e connError) Error() string {
-	return fmt.Sprintf("http2: connection error: %v: %v", e.Code, e.Reason)
-}
-
-type pseudoHeaderError string
-
-func (e pseudoHeaderError) Error() string {
-	return fmt.Sprintf("invalid pseudo-header %q", string(e))
-}
-
-type duplicatePseudoHeaderError string
-
-func (e duplicatePseudoHeaderError) Error() string {
-	return fmt.Sprintf("duplicate pseudo-header %q", string(e))
-}
-
-type headerFieldNameError string
-
-func (e headerFieldNameError) Error() string {
-	return fmt.Sprintf("invalid header field name %q", string(e))
-}
-
-type headerFieldValueError string
-
-func (e headerFieldValueError) Error() string {
-	return fmt.Sprintf("invalid header field value %q", string(e))
-}
-
-var (
-	errMixPseudoHeaderTypes = errors.New("mix of request and response pseudo headers")
-	errPseudoAfterRegular   = errors.New("pseudo header field after regular")
-)

vendor/golang.org/x/net/http2/errors_test.go

@@ -1,24 +0,0 @@
-// Copyright 2014 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package http2
-
-import "testing"
-
-func TestErrCodeString(t *testing.T) {
-	tests := []struct {
-		err  ErrCode
-		want string
-	}{
-		{ErrCodeProtocol, "PROTOCOL_ERROR"},
-		{0xd, "HTTP_1_1_REQUIRED"},
-		{0xf, "unknown error code 0xf"},
-	}
-	for i, tt := range tests {
-		got := tt.err.String()
-		if got != tt.want {
-			t.Errorf("%d. Error = %q; want %q", i, got, tt.want)
-		}
-	}
-}

vendor/golang.org/x/net/http2/flow.go

@@ -1,50 +0,0 @@
-// Copyright 2014 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.
-
-// Flow control
-
-package http2
-
-// flow is the flow control window's size.
-type flow struct {
-	// n is the number of DATA bytes we're allowed to send.
-	// A flow is kept both on a conn and a per-stream.
-	n int32
-
-	// conn points to the shared connection-level flow that is
-	// shared by all streams on that conn. It is nil for the flow
-	// that's on the conn directly.
-	conn *flow
-}
-
-func (f *flow) setConnFlow(cf *flow) { f.conn = cf }
-
-func (f *flow) available() int32 {
-	n := f.n
-	if f.conn != nil && f.conn.n < n {
-		n = f.conn.n
-	}
-	return n
-}
-
-func (f *flow) take(n int32) {
-	if n > f.available() {
-		panic("internal error: took too much")
-	}
-	f.n -= n
-	if f.conn != nil {
-		f.conn.n -= n
-	}
-}
-
-// add adds n bytes (positive or negative) to the flow control window.
-// It returns false if the sum would exceed 2^31-1.
-func (f *flow) add(n int32) bool {
-	remain := (1<<31 - 1) - f.n
-	if n > remain {
-		return false
-	}
-	f.n += n
-	return true
-}

vendor/golang.org/x/net/http2/flow_test.go

@@ -1,53 +0,0 @@
-// Copyright 2014 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package http2
-
-import "testing"
-
-func TestFlow(t *testing.T) {
-	var st flow
-	var conn flow
-	st.add(3)
-	conn.add(2)
-
-	if got, want := st.available(), int32(3); got != want {
-		t.Errorf("available = %d; want %d", got, want)
-	}
-	st.setConnFlow(&conn)
-	if got, want := st.available(), int32(2); got != want {
-		t.Errorf("after parent setup, available = %d; want %d", got, want)
-	}
-
-	st.take(2)
-	if got, want := conn.available(), int32(0); got != want {
-		t.Errorf("after taking 2, conn = %d; want %d", got, want)
-	}
-	if got, want := st.available(), int32(0); got != want {
-		t.Errorf("after taking 2, stream = %d; want %d", got, want)
-	}
-}
-
-func TestFlowAdd(t *testing.T) {
-	var f flow
-	if !f.add(1) {
-		t.Fatal("failed to add 1")
-	}
-	if !f.add(-1) {
-		t.Fatal("failed to add -1")
-	}
-	if got, want := f.available(), int32(0); got != want {
-		t.Fatalf("size = %d; want %d", got, want)
-	}
-	if !f.add(1<<31 - 1) {
-		t.Fatal("failed to add 2^31-1")
-	}
-	if got, want := f.available(), int32(1<<31-1); got != want {
-		t.Fatalf("size = %d; want %d", got, want)
-	}
-	if f.add(1) {
-		t.Fatal("adding 1 to max shouldn't be allowed")
-	}
-
-}

vendor/golang.org/x/net/http2/go16.go

@@ -1,16 +0,0 @@
-// Copyright 2016 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 go1.6
-
-package http2
-
-import (
-	"net/http"
-	"time"
-)
-
-func transportExpectContinueTimeout(t1 *http.Transport) time.Duration {
-	return t1.ExpectContinueTimeout
-}

vendor/golang.org/x/net/http2/go17.go

@@ -1,106 +0,0 @@
-// Copyright 2016 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 go1.7
-
-package http2
-
-import (
-	"context"
-	"net"
-	"net/http"
-	"net/http/httptrace"
-	"time"
-)
-
-type contextContext interface {
-	context.Context
-}
-
-func serverConnBaseContext(c net.Conn, opts *ServeConnOpts) (ctx contextContext, cancel func()) {
-	ctx, cancel = context.WithCancel(context.Background())
-	ctx = context.WithValue(ctx, http.LocalAddrContextKey, c.LocalAddr())
-	if hs := opts.baseConfig(); hs != nil {
-		ctx = context.WithValue(ctx, http.ServerContextKey, hs)
-	}
-	return
-}
-
-func contextWithCancel(ctx contextContext) (_ contextContext, cancel func()) {
-	return context.WithCancel(ctx)
-}
-
-func requestWithContext(req *http.Request, ctx contextContext) *http.Request {
-	return req.WithContext(ctx)
-}
-
-type clientTrace httptrace.ClientTrace
-
-func reqContext(r *http.Request) context.Context { return r.Context() }
-
-func (t *Transport) idleConnTimeout() time.Duration {
-	if t.t1 != nil {
-		return t.t1.IdleConnTimeout
-	}
-	return 0
-}
-
-func setResponseUncompressed(res *http.Response) { res.Uncompressed = true }
-
-func traceGotConn(req *http.Request, cc *ClientConn) {
-	trace := httptrace.ContextClientTrace(req.Context())
-	if trace == nil || trace.GotConn == nil {
-		return
-	}
-	ci := httptrace.GotConnInfo{Conn: cc.tconn}
-	cc.mu.Lock()
-	ci.Reused = cc.nextStreamID > 1
-	ci.WasIdle = len(cc.streams) == 0 && ci.Reused
-	if ci.WasIdle && !cc.lastActive.IsZero() {
-		ci.IdleTime = time.Now().Sub(cc.lastActive)
-	}
-	cc.mu.Unlock()
-
-	trace.GotConn(ci)
-}
-
-func traceWroteHeaders(trace *clientTrace) {
-	if trace != nil && trace.WroteHeaders != nil {
-		trace.WroteHeaders()
-	}
-}
-
-func traceGot100Continue(trace *clientTrace) {
-	if trace != nil && trace.Got100Continue != nil {
-		trace.Got100Continue()
-	}
-}
-
-func traceWait100Continue(trace *clientTrace) {
-	if trace != nil && trace.Wait100Continue != nil {
-		trace.Wait100Continue()
-	}
-}
-
-func traceWroteRequest(trace *clientTrace, err error) {
-	if trace != nil && trace.WroteRequest != nil {
-		trace.WroteRequest(httptrace.WroteRequestInfo{Err: err})
-	}
-}
-
-func traceFirstResponseByte(trace *clientTrace) {
-	if trace != nil && trace.GotFirstResponseByte != nil {
-		trace.GotFirstResponseByte()
-	}
-}
-
-func requestTrace(req *http.Request) *clientTrace {
-	trace := httptrace.ContextClientTrace(req.Context())
-	return (*clientTrace)(trace)
-}
-
-// Ping sends a PING frame to the server and waits for the ack.
-func (cc *ClientConn) Ping(ctx context.Context) error {
-	return cc.ping(ctx)
-}

vendor/golang.org/x/net/http2/go17_not18.go

@@ -1,36 +0,0 @@
-// Copyright 2016 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 go1.7,!go1.8
-
-package http2
-
-import "crypto/tls"
-
-// temporary copy of Go 1.7's private tls.Config.clone:
-func cloneTLSConfig(c *tls.Config) *tls.Config {
-	return &tls.Config{
-		Rand:                        c.Rand,
-		Time:                        c.Time,
-		Certificates:                c.Certificates,
-		NameToCertificate:           c.NameToCertificate,
-		GetCertificate:              c.GetCertificate,
-		RootCAs:                     c.RootCAs,
-		NextProtos:                  c.NextProtos,
-		ServerName:                  c.ServerName,
-		ClientAuth:                  c.ClientAuth,
-		ClientCAs:                   c.ClientCAs,
-		InsecureSkipVerify:          c.InsecureSkipVerify,
-		CipherSuites:                c.CipherSuites,
-		PreferServerCipherSuites:    c.PreferServerCipherSuites,
-		SessionTicketsDisabled:      c.SessionTicketsDisabled,
-		SessionTicketKey:            c.SessionTicketKey,
-		ClientSessionCache:          c.ClientSessionCache,
-		MinVersion:                  c.MinVersion,
-		MaxVersion:                  c.MaxVersion,
-		CurvePreferences:            c.CurvePreferences,
-		DynamicRecordSizingDisabled: c.DynamicRecordSizingDisabled,
-		Renegotiation:               c.Renegotiation,
-	}
-}

vendor/golang.org/x/net/http2/go18.go

@@ -1,56 +0,0 @@
-// Copyright 2015 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 go1.8
-
-package http2
-
-import (
-	"crypto/tls"
-	"io"
-	"net/http"
-)
-
-func cloneTLSConfig(c *tls.Config) *tls.Config {
-	c2 := c.Clone()
-	c2.GetClientCertificate = c.GetClientCertificate // golang.org/issue/19264
-	return c2
-}
-
-var _ http.Pusher = (*responseWriter)(nil)
-
-// Push implements http.Pusher.
-func (w *responseWriter) Push(target string, opts *http.PushOptions) error {
-	internalOpts := pushOptions{}
-	if opts != nil {
-		internalOpts.Method = opts.Method
-		internalOpts.Header = opts.Header
-	}
-	return w.push(target, internalOpts)
-}
-
-func configureServer18(h1 *http.Server, h2 *Server) error {
-	if h2.IdleTimeout == 0 {
-		if h1.IdleTimeout != 0 {
-			h2.IdleTimeout = h1.IdleTimeout
-		} else {
-			h2.IdleTimeout = h1.ReadTimeout
-		}
-	}
-	return nil
-}
-
-func shouldLogPanic(panicValue interface{}) bool {
-	return panicValue != nil && panicValue != http.ErrAbortHandler
-}
-
-func reqGetBody(req *http.Request) func() (io.ReadCloser, error) {
-	return req.GetBody
-}
-
-func reqBodyIsNoBody(body io.ReadCloser) bool {
-	return body == http.NoBody
-}
-
-func go18httpNoBody() io.ReadCloser { return http.NoBody } // for tests only

vendor/golang.org/x/net/http2/go18_test.go

@@ -1,79 +0,0 @@
-// Copyright 2016 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 go1.8
-
-package http2
-
-import (
-	"crypto/tls"
-	"net/http"
-	"testing"
-	"time"
-)
-
-// Tests that http2.Server.IdleTimeout is initialized from
-// http.Server.{Idle,Read}Timeout. http.Server.IdleTimeout was
-// added in Go 1.8.
-func TestConfigureServerIdleTimeout_Go18(t *testing.T) {
-	const timeout = 5 * time.Second
-	const notThisOne = 1 * time.Second
-
-	// With a zero http2.Server, verify that it copies IdleTimeout:
-	{
-		s1 := &http.Server{
-			IdleTimeout: timeout,
-			ReadTimeout: notThisOne,
-		}
-		s2 := &Server{}
-		if err := ConfigureServer(s1, s2); err != nil {
-			t.Fatal(err)
-		}
-		if s2.IdleTimeout != timeout {
-			t.Errorf("s2.IdleTimeout = %v; want %v", s2.IdleTimeout, timeout)
-		}
-	}
-
-	// And that it falls back to ReadTimeout:
-	{
-		s1 := &http.Server{
-			ReadTimeout: timeout,
-		}
-		s2 := &Server{}
-		if err := ConfigureServer(s1, s2); err != nil {
-			t.Fatal(err)
-		}
-		if s2.IdleTimeout != timeout {
-			t.Errorf("s2.IdleTimeout = %v; want %v", s2.IdleTimeout, timeout)
-		}
-	}
-
-	// Verify that s1's IdleTimeout doesn't overwrite an existing setting:
-	{
-		s1 := &http.Server{
-			IdleTimeout: notThisOne,
-		}
-		s2 := &Server{
-			IdleTimeout: timeout,
-		}
-		if err := ConfigureServer(s1, s2); err != nil {
-			t.Fatal(err)
-		}
-		if s2.IdleTimeout != timeout {
-			t.Errorf("s2.IdleTimeout = %v; want %v", s2.IdleTimeout, timeout)
-		}
-	}
-}
-
-func TestCertClone(t *testing.T) {
-	c := &tls.Config{
-		GetClientCertificate: func(*tls.CertificateRequestInfo) (*tls.Certificate, error) {
-			panic("shouldn't be called")
-		},
-	}
-	c2 := cloneTLSConfig(c)
-	if c2.GetClientCertificate == nil {
-		t.Error("GetClientCertificate is nil")
-	}
-}

vendor/golang.org/x/net/http2/go19.go

@@ -1,16 +0,0 @@
-// Copyright 2015 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 go1.9
-
-package http2
-
-import (
-	"net/http"
-)
-
-func configureServer19(s *http.Server, conf *Server) error {
-	s.RegisterOnShutdown(conf.state.startGracefulShutdown)
-	return nil
-}

vendor/golang.org/x/net/http2/go19_test.go

@@ -1,60 +0,0 @@
-// Copyright 2017 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 go1.9
-
-package http2
-
-import (
-	"context"
-	"net/http"
-	"reflect"
-	"testing"
-	"time"
-)
-
-func TestServerGracefulShutdown(t *testing.T) {
-	var st *serverTester
-	handlerDone := make(chan struct{})
-	st = newServerTester(t, func(w http.ResponseWriter, r *http.Request) {
-		defer close(handlerDone)
-		go st.ts.Config.Shutdown(context.Background())
-
-		ga := st.wantGoAway()
-		if ga.ErrCode != ErrCodeNo {
-			t.Errorf("GOAWAY error = %v; want ErrCodeNo", ga.ErrCode)
-		}
-		if ga.LastStreamID != 1 {
-			t.Errorf("GOAWAY LastStreamID = %v; want 1", ga.LastStreamID)
-		}
-
-		w.Header().Set("x-foo", "bar")
-	})
-	defer st.Close()
-
-	st.greet()
-	st.bodylessReq1()
-
-	select {
-	case <-handlerDone:
-	case <-time.After(5 * time.Second):
-		t.Fatalf("server did not shutdown?")
-	}
-	hf := st.wantHeaders()
-	goth := st.decodeHeader(hf.HeaderBlockFragment())
-	wanth := [][2]string{
-		{":status", "200"},
-		{"x-foo", "bar"},
-		{"content-type", "text/plain; charset=utf-8"},
-		{"content-length", "0"},
-	}
-	if !reflect.DeepEqual(goth, wanth) {
-		t.Errorf("Got headers %v; want %v", goth, wanth)
-	}
-
-	n, err := st.cc.Read([]byte{0})
-	if n != 0 || err == nil {
-		t.Errorf("Read = %v, %v; want 0, non-nil", n, err)
-	}
-}

vendor/golang.org/x/net/http2/gotrack.go

@@ -1,170 +0,0 @@
-// Copyright 2014 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.
-
-// Defensive debug-only utility to track that functions run on the
-// goroutine that they're supposed to.
-
-package http2
-
-import (
-	"bytes"
-	"errors"
-	"fmt"
-	"os"
-	"runtime"
-	"strconv"
-	"sync"
-)
-
-var DebugGoroutines = os.Getenv("DEBUG_HTTP2_GOROUTINES") == "1"
-
-type goroutineLock uint64
-
-func newGoroutineLock() goroutineLock {
-	if !DebugGoroutines {
-		return 0
-	}
-	return goroutineLock(curGoroutineID())
-}
-
-func (g goroutineLock) check() {
-	if !DebugGoroutines {
-		return
-	}
-	if curGoroutineID() != uint64(g) {
-		panic("running on the wrong goroutine")
-	}
-}
-
-func (g goroutineLock) checkNotOn() {
-	if !DebugGoroutines {
-		return
-	}
-	if curGoroutineID() == uint64(g) {
-		panic("running on the wrong goroutine")
-	}
-}
-
-var goroutineSpace = []byte("goroutine ")
-
-func curGoroutineID() uint64 {
-	bp := littleBuf.Get().(*[]byte)
-	defer littleBuf.Put(bp)
-	b := *bp
-	b = b[:runtime.Stack(b, false)]
-	// Parse the 4707 out of "goroutine 4707 ["
-	b = bytes.TrimPrefix(b, goroutineSpace)
-	i := bytes.IndexByte(b, ' ')
-	if i < 0 {
-		panic(fmt.Sprintf("No space found in %q", b))
-	}
-	b = b[:i]
-	n, err := parseUintBytes(b, 10, 64)
-	if err != nil {
-		panic(fmt.Sprintf("Failed to parse goroutine ID out of %q: %v", b, err))
-	}
-	return n
-}
-
-var littleBuf = sync.Pool{
-	New: func() interface{} {
-		buf := make([]byte, 64)
-		return &buf
-	},
-}
-
-// parseUintBytes is like strconv.ParseUint, but using a []byte.
-func parseUintBytes(s []byte, base int, bitSize int) (n uint64, err error) {
-	var cutoff, maxVal uint64
-
-	if bitSize == 0 {
-		bitSize = int(strconv.IntSize)
-	}
-
-	s0 := s
-	switch {
-	case len(s) < 1:
-		err = strconv.ErrSyntax
-		goto Error
-
-	case 2 <= base && base <= 36:
-		// valid base; nothing to do
-
-	case base == 0:
-		// Look for octal, hex prefix.
-		switch {
-		case s[0] == '0' && len(s) > 1 && (s[1] == 'x' || s[1] == 'X'):
-			base = 16
-			s = s[2:]
-			if len(s) < 1 {
-				err = strconv.ErrSyntax
-				goto Error
-			}
-		case s[0] == '0':
-			base = 8
-		default:
-			base = 10
-		}
-
-	default:
-		err = errors.New("invalid base " + strconv.Itoa(base))
-		goto Error
-	}
-
-	n = 0
-	cutoff = cutoff64(base)
-	maxVal = 1<<uint(bitSize) - 1
-
-	for i := 0; i < len(s); i++ {
-		var v byte
-		d := s[i]
-		switch {
-		case '0' <= d && d <= '9':
-			v = d - '0'
-		case 'a' <= d && d <= 'z':
-			v = d - 'a' + 10
-		case 'A' <= d && d <= 'Z':
-			v = d - 'A' + 10
-		default:
-			n = 0
-			err = strconv.ErrSyntax
-			goto Error
-		}
-		if int(v) >= base {
-			n = 0
-			err = strconv.ErrSyntax
-			goto Error
-		}
-
-		if n >= cutoff {
-			// n*base overflows
-			n = 1<<64 - 1
-			err = strconv.ErrRange
-			goto Error
-		}
-		n *= uint64(base)
-
-		n1 := n + uint64(v)
-		if n1 < n || n1 > maxVal {
-			// n+v overflows
-			n = 1<<64 - 1
-			err = strconv.ErrRange
-			goto Error
-		}
-		n = n1
-	}
-
-	return n, nil
-
-Error:
-	return n, &strconv.NumError{Func: "ParseUint", Num: string(s0), Err: err}
-}
-
-// Return the first number n such that n*base >= 1<<64.
-func cutoff64(base int) uint64 {
-	if base < 2 {
-		return 0
-	}
-	return (1<<64-1)/uint64(base) + 1
-}

vendor/golang.org/x/net/http2/gotrack_test.go

@@ -1,33 +0,0 @@
-// Copyright 2014 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package http2
-
-import (
-	"fmt"
-	"strings"
-	"testing"
-)
-
-func TestGoroutineLock(t *testing.T) {
-	oldDebug := DebugGoroutines
-	DebugGoroutines = true
-	defer func() { DebugGoroutines = oldDebug }()
-
-	g := newGoroutineLock()
-	g.check()
-
-	sawPanic := make(chan interface{})
-	go func() {
-		defer func() { sawPanic <- recover() }()
-		g.check() // should panic
-	}()
-	e := <-sawPanic
-	if e == nil {
-		t.Fatal("did not see panic from check in other goroutine")
-	}
-	if !strings.Contains(fmt.Sprint(e), "wrong goroutine") {
-		t.Errorf("expected on see panic about running on the wrong goroutine; got %v", e)
-	}
-}

vendor/golang.org/x/net/http2/h2demo/.gitignore

@@ -1,5 +0,0 @@
-h2demo
-h2demo.linux
-client-id.dat
-client-secret.dat
-token.dat

vendor/golang.org/x/net/http2/h2demo/Makefile

@@ -1,8 +0,0 @@
-h2demo.linux: h2demo.go
-	GOOS=linux go build --tags=h2demo -o h2demo.linux .
-
-FORCE:
-
-upload: FORCE
-	go install golang.org/x/build/cmd/upload
-	upload --verbose --osarch=linux-amd64 --tags=h2demo --file=go:golang.org/x/net/http2/h2demo --public http2-demo-server-tls/h2demo

vendor/golang.org/x/net/http2/h2demo/README

@@ -1,16 +0,0 @@
-
-Client:
- -- Firefox nightly with about:config network.http.spdy.enabled.http2draft set true
- -- Chrome: go to chrome://flags/#enable-spdy4, save and restart (button at bottom)
-
-Make CA:
-$ openssl genrsa -out rootCA.key 2048
-$ openssl req -x509 -new -nodes -key rootCA.key -days 1024 -out rootCA.pem
-... install that to Firefox
-
-Make cert:
-$ openssl genrsa -out server.key 2048
-$ openssl req -new -key server.key -out server.csr
-$ openssl x509 -req -in server.csr -CA rootCA.pem -CAkey rootCA.key -CAcreateserial -out server.crt -days 500
-
-

vendor/golang.org/x/net/http2/h2demo/h2demo.go

@@ -1,538 +0,0 @@
-// Copyright 2014 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 h2demo
-
-package main
-
-import (
-	"bytes"
-	"crypto/tls"
-	"flag"
-	"fmt"
-	"hash/crc32"
-	"image"
-	"image/jpeg"
-	"io"
-	"io/ioutil"
-	"log"
-	"net"
-	"net/http"
-	"os"
-	"path"
-	"regexp"
-	"runtime"
-	"strconv"
-	"strings"
-	"sync"
-	"time"
-
-	"go4.org/syncutil/singleflight"
-	"golang.org/x/crypto/acme/autocert"
-	"golang.org/x/net/http2"
-)
-
-var (
-	prod = flag.Bool("prod", false, "Whether to configure itself to be the production http2.golang.org server.")
-
-	httpsAddr = flag.String("https_addr", "localhost:4430", "TLS address to listen on ('host:port' or ':port'). Required.")
-	httpAddr  = flag.String("http_addr", "", "Plain HTTP address to listen on ('host:port', or ':port'). Empty means no HTTP.")
-
-	hostHTTP  = flag.String("http_host", "", "Optional host or host:port to use for http:// links to this service. By default, this is implied from -http_addr.")
-	hostHTTPS = flag.String("https_host", "", "Optional host or host:port to use for http:// links to this service. By default, this is implied from -https_addr.")
-)
-
-func homeOldHTTP(w http.ResponseWriter, r *http.Request) {
-	io.WriteString(w, `<html>
-<body>
-<h1>Go + HTTP/2</h1>
-<p>Welcome to <a href="https://golang.org/">the Go language</a>'s <a href="https://http2.github.io/">HTTP/2</a> demo & interop server.</p>
-<p>Unfortunately, you're <b>not</b> using HTTP/2 right now. To do so:</p>
-<ul>
-   <li>Use Firefox Nightly or go to <b>about:config</b> and enable "network.http.spdy.enabled.http2draft"</li>
-   <li>Use Google Chrome Canary and/or go to <b>chrome://flags/#enable-spdy4</b> to <i>Enable SPDY/4</i> (Chrome's name for HTTP/2)</li>
-</ul>
-<p>See code & instructions for connecting at <a href="https://github.com/golang/net/tree/master/http2">https://github.com/golang/net/tree/master/http2</a>.</p>
-
-</body></html>`)
-}
-
-func home(w http.ResponseWriter, r *http.Request) {
-	if r.URL.Path != "/" {
-		http.NotFound(w, r)
-		return
-	}
-	io.WriteString(w, `<html>
-<body>
-<h1>Go + HTTP/2</h1>
-
-<p>Welcome to <a href="https://golang.org/">the Go language</a>'s <a
-href="https://http2.github.io/">HTTP/2</a> demo & interop server.</p>
-
-<p>Congratulations, <b>you're using HTTP/2 right now</b>.</p>
-
-<p>This server exists for others in the HTTP/2 community to test their HTTP/2 client implementations and point out flaws in our server.</p>
-
-<p>
-The code is at <a href="https://golang.org/x/net/http2">golang.org/x/net/http2</a> and
-is used transparently by the Go standard library from Go 1.6 and later.
-</p>
-
-<p>Contact info: <i>bradfitz@golang.org</i>, or <a
-href="https://golang.org/s/http2bug">file a bug</a>.</p>
-
-<h2>Handlers for testing</h2>
-<ul>
-  <li>GET <a href="/reqinfo">/reqinfo</a> to dump the request + headers received</li>
-  <li>GET <a href="/clockstream">/clockstream</a> streams the current time every second</li>
-  <li>GET <a href="/gophertiles">/gophertiles</a> to see a page with a bunch of images</li>
-  <li>GET <a href="/serverpush">/serverpush</a> to see a page with server push</li>
-  <li>GET <a href="/file/gopher.png">/file/gopher.png</a> for a small file (does If-Modified-Since, Content-Range, etc)</li>
-  <li>GET <a href="/file/go.src.tar.gz">/file/go.src.tar.gz</a> for a larger file (~10 MB)</li>
-  <li>GET <a href="/redirect">/redirect</a> to redirect back to / (this page)</li>
-  <li>GET <a href="/goroutines">/goroutines</a> to see all active goroutines in this server</li>
-  <li>PUT something to <a href="/crc32">/crc32</a> to get a count of number of bytes and its CRC-32</li>
-  <li>PUT something to <a href="/ECHO">/ECHO</a> and it will be streamed back to you capitalized</li>
-</ul>
-
-</body></html>`)
-}
-
-func reqInfoHandler(w http.ResponseWriter, r *http.Request) {
-	w.Header().Set("Content-Type", "text/plain")
-	fmt.Fprintf(w, "Method: %s\n", r.Method)
-	fmt.Fprintf(w, "Protocol: %s\n", r.Proto)
-	fmt.Fprintf(w, "Host: %s\n", r.Host)
-	fmt.Fprintf(w, "RemoteAddr: %s\n", r.RemoteAddr)
-	fmt.Fprintf(w, "RequestURI: %q\n", r.RequestURI)
-	fmt.Fprintf(w, "URL: %#v\n", r.URL)
-	fmt.Fprintf(w, "Body.ContentLength: %d (-1 means unknown)\n", r.ContentLength)
-	fmt.Fprintf(w, "Close: %v (relevant for HTTP/1 only)\n", r.Close)
-	fmt.Fprintf(w, "TLS: %#v\n", r.TLS)
-	fmt.Fprintf(w, "\nHeaders:\n")
-	r.Header.Write(w)
-}
-
-func crcHandler(w http.ResponseWriter, r *http.Request) {
-	if r.Method != "PUT" {
-		http.Error(w, "PUT required.", 400)
-		return
-	}
-	crc := crc32.NewIEEE()
-	n, err := io.Copy(crc, r.Body)
-	if err == nil {
-		w.Header().Set("Content-Type", "text/plain")
-		fmt.Fprintf(w, "bytes=%d, CRC32=%x", n, crc.Sum(nil))
-	}
-}
-
-type capitalizeReader struct {
-	r io.Reader
-}
-
-func (cr capitalizeReader) Read(p []byte) (n int, err error) {
-	n, err = cr.r.Read(p)
-	for i, b := range p[:n] {
-		if b >= 'a' && b <= 'z' {
-			p[i] = b - ('a' - 'A')
-		}
-	}
-	return
-}
-
-type flushWriter struct {
-	w io.Writer
-}
-
-func (fw flushWriter) Write(p []byte) (n int, err error) {
-	n, err = fw.w.Write(p)
-	if f, ok := fw.w.(http.Flusher); ok {
-		f.Flush()
-	}
-	return
-}
-
-func echoCapitalHandler(w http.ResponseWriter, r *http.Request) {
-	if r.Method != "PUT" {
-		http.Error(w, "PUT required.", 400)
-		return
-	}
-	io.Copy(flushWriter{w}, capitalizeReader{r.Body})
-}
-
-var (
-	fsGrp   singleflight.Group
-	fsMu    sync.Mutex // guards fsCache
-	fsCache = map[string]http.Handler{}
-)
-
-// fileServer returns a file-serving handler that proxies URL.
-// It lazily fetches URL on the first access and caches its contents forever.
-func fileServer(url string, latency time.Duration) http.Handler {
-	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		if latency > 0 {
-			time.Sleep(latency)
-		}
-		hi, err := fsGrp.Do(url, func() (interface{}, error) {
-			fsMu.Lock()
-			if h, ok := fsCache[url]; ok {
-				fsMu.Unlock()
-				return h, nil
-			}
-			fsMu.Unlock()
-
-			res, err := http.Get(url)
-			if err != nil {
-				return nil, err
-			}
-			defer res.Body.Close()
-			slurp, err := ioutil.ReadAll(res.Body)
-			if err != nil {
-				return nil, err
-			}
-
-			modTime := time.Now()
-			var h http.Handler = http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-				http.ServeContent(w, r, path.Base(url), modTime, bytes.NewReader(slurp))
-			})
-			fsMu.Lock()
-			fsCache[url] = h
-			fsMu.Unlock()
-			return h, nil
-		})
-		if err != nil {
-			http.Error(w, err.Error(), 500)
-			return
-		}
-		hi.(http.Handler).ServeHTTP(w, r)
-	})
-}
-
-func clockStreamHandler(w http.ResponseWriter, r *http.Request) {
-	clientGone := w.(http.CloseNotifier).CloseNotify()
-	w.Header().Set("Content-Type", "text/plain")
-	ticker := time.NewTicker(1 * time.Second)
-	defer ticker.Stop()
-	fmt.Fprintf(w, "# ~1KB of junk to force browsers to start rendering immediately: \n")
-	io.WriteString(w, strings.Repeat("# xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx\n", 13))
-
-	for {
-		fmt.Fprintf(w, "%v\n", time.Now())
-		w.(http.Flusher).Flush()
-		select {
-		case <-ticker.C:
-		case <-clientGone:
-			log.Printf("Client %v disconnected from the clock", r.RemoteAddr)
-			return
-		}
-	}
-}
-
-func registerHandlers() {
-	tiles := newGopherTilesHandler()
-	push := newPushHandler()
-
-	mux2 := http.NewServeMux()
-	http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
-		switch {
-		case r.URL.Path == "/gophertiles":
-			tiles.ServeHTTP(w, r) // allow HTTP/2 + HTTP/1.x
-			return
-		case strings.HasPrefix(r.URL.Path, "/serverpush"):
-			push.ServeHTTP(w, r) // allow HTTP/2 + HTTP/1.x
-			return
-		case r.TLS == nil: // do not allow HTTP/1.x for anything else
-			http.Redirect(w, r, "https://"+httpsHost()+"/", http.StatusFound)
-			return
-		}
-		if r.ProtoMajor == 1 {
-			if r.URL.Path == "/reqinfo" {
-				reqInfoHandler(w, r)
-				return
-			}
-			homeOldHTTP(w, r)
-			return
-		}
-		mux2.ServeHTTP(w, r)
-	})
-	mux2.HandleFunc("/", home)
-	mux2.Handle("/file/gopher.png", fileServer("https://golang.org/doc/gopher/frontpage.png", 0))
-	mux2.Handle("/file/go.src.tar.gz", fileServer("https://storage.googleapis.com/golang/go1.4.1.src.tar.gz", 0))
-	mux2.HandleFunc("/reqinfo", reqInfoHandler)
-	mux2.HandleFunc("/crc32", crcHandler)
-	mux2.HandleFunc("/ECHO", echoCapitalHandler)
-	mux2.HandleFunc("/clockstream", clockStreamHandler)
-	mux2.Handle("/gophertiles", tiles)
-	mux2.HandleFunc("/redirect", func(w http.ResponseWriter, r *http.Request) {
-		http.Redirect(w, r, "/", http.StatusFound)
-	})
-	stripHomedir := regexp.MustCompile(`/(Users|home)/\w+`)
-	mux2.HandleFunc("/goroutines", func(w http.ResponseWriter, r *http.Request) {
-		w.Header().Set("Content-Type", "text/plain; charset=utf-8")
-		buf := make([]byte, 2<<20)
-		w.Write(stripHomedir.ReplaceAll(buf[:runtime.Stack(buf, true)], nil))
-	})
-}
-
-var pushResources = map[string]http.Handler{
-	"/serverpush/static/jquery.min.js": fileServer("https://ajax.googleapis.com/ajax/libs/jquery/1.8.2/jquery.min.js", 100*time.Millisecond),
-	"/serverpush/static/godocs.js":     fileServer("https://golang.org/lib/godoc/godocs.js", 100*time.Millisecond),
-	"/serverpush/static/playground.js": fileServer("https://golang.org/lib/godoc/playground.js", 100*time.Millisecond),
-	"/serverpush/static/style.css":     fileServer("https://golang.org/lib/godoc/style.css", 100*time.Millisecond),
-}
-
-func newPushHandler() http.Handler {
-	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		for path, handler := range pushResources {
-			if r.URL.Path == path {
-				handler.ServeHTTP(w, r)
-				return
-			}
-		}
-
-		cacheBust := time.Now().UnixNano()
-		if pusher, ok := w.(http.Pusher); ok {
-			for path := range pushResources {
-				url := fmt.Sprintf("%s?%d", path, cacheBust)
-				if err := pusher.Push(url, nil); err != nil {
-					log.Printf("Failed to push %v: %v", path, err)
-				}
-			}
-		}
-		time.Sleep(100 * time.Millisecond) // fake network latency + parsing time
-		if err := pushTmpl.Execute(w, struct {
-			CacheBust int64
-			HTTPSHost string
-			HTTPHost  string
-		}{
-			CacheBust: cacheBust,
-			HTTPSHost: httpsHost(),
-			HTTPHost:  httpHost(),
-		}); err != nil {
-			log.Printf("Executing server push template: %v", err)
-		}
-	})
-}
-
-func newGopherTilesHandler() http.Handler {
-	const gopherURL = "https://blog.golang.org/go-programming-language-turns-two_gophers.jpg"
-	res, err := http.Get(gopherURL)
-	if err != nil {
-		log.Fatal(err)
-	}
-	if res.StatusCode != 200 {
-		log.Fatalf("Error fetching %s: %v", gopherURL, res.Status)
-	}
-	slurp, err := ioutil.ReadAll(res.Body)
-	res.Body.Close()
-	if err != nil {
-		log.Fatal(err)
-	}
-	im, err := jpeg.Decode(bytes.NewReader(slurp))
-	if err != nil {
-		if len(slurp) > 1024 {
-			slurp = slurp[:1024]
-		}
-		log.Fatalf("Failed to decode gopher image: %v (got %q)", err, slurp)
-	}
-
-	type subImager interface {
-		SubImage(image.Rectangle) image.Image
-	}
-	const tileSize = 32
-	xt := im.Bounds().Max.X / tileSize
-	yt := im.Bounds().Max.Y / tileSize
-	var tile [][][]byte // y -> x -> jpeg bytes
-	for yi := 0; yi < yt; yi++ {
-		var row [][]byte
-		for xi := 0; xi < xt; xi++ {
-			si := im.(subImager).SubImage(image.Rectangle{
-				Min: image.Point{xi * tileSize, yi * tileSize},
-				Max: image.Point{(xi + 1) * tileSize, (yi + 1) * tileSize},
-			})
-			buf := new(bytes.Buffer)
-			if err := jpeg.Encode(buf, si, &jpeg.Options{Quality: 90}); err != nil {
-				log.Fatal(err)
-			}
-			row = append(row, buf.Bytes())
-		}
-		tile = append(tile, row)
-	}
-	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		ms, _ := strconv.Atoi(r.FormValue("latency"))
-		const nanosPerMilli = 1e6
-		if r.FormValue("x") != "" {
-			x, _ := strconv.Atoi(r.FormValue("x"))
-			y, _ := strconv.Atoi(r.FormValue("y"))
-			if ms <= 1000 {
-				time.Sleep(time.Duration(ms) * nanosPerMilli)
-			}
-			if x >= 0 && x < xt && y >= 0 && y < yt {
-				http.ServeContent(w, r, "", time.Time{}, bytes.NewReader(tile[y][x]))
-				return
-			}
-		}
-		io.WriteString(w, "<html><body onload='showtimes()'>")
-		fmt.Fprintf(w, "A grid of %d tiled images is below. Compare:<p>", xt*yt)
-		for _, ms := range []int{0, 30, 200, 1000} {
-			d := time.Duration(ms) * nanosPerMilli
-			fmt.Fprintf(w, "[<a href='https://%s/gophertiles?latency=%d'>HTTP/2, %v latency</a>] [<a href='http://%s/gophertiles?latency=%d'>HTTP/1, %v latency</a>]<br>\n",
-				httpsHost(), ms, d,
-				httpHost(), ms, d,
-			)
-		}
-		io.WriteString(w, "<p>\n")
-		cacheBust := time.Now().UnixNano()
-		for y := 0; y < yt; y++ {
-			for x := 0; x < xt; x++ {
-				fmt.Fprintf(w, "<img width=%d height=%d src='/gophertiles?x=%d&y=%d&cachebust=%d&latency=%d'>",
-					tileSize, tileSize, x, y, cacheBust, ms)
-			}
-			io.WriteString(w, "<br/>\n")
-		}
-		io.WriteString(w, `<p><div id='loadtimes'></div></p>
-<script>
-function showtimes() {
-	var times = 'Times from connection start:<br>'
-	times += 'DOM loaded: ' + (window.performance.timing.domContentLoadedEventEnd - window.performance.timing.connectStart) + 'ms<br>'
-	times += 'DOM complete (images loaded): ' + (window.performance.timing.domComplete - window.performance.timing.connectStart) + 'ms<br>'
-	document.getElementById('loadtimes').innerHTML = times
-}
-</script>
-<hr><a href='/'>&lt;&lt Back to Go HTTP/2 demo server</a></body></html>`)
-	})
-}
-
-func httpsHost() string {
-	if *hostHTTPS != "" {
-		return *hostHTTPS
-	}
-	if v := *httpsAddr; strings.HasPrefix(v, ":") {
-		return "localhost" + v
-	} else {
-		return v
-	}
-}
-
-func httpHost() string {
-	if *hostHTTP != "" {
-		return *hostHTTP
-	}
-	if v := *httpAddr; strings.HasPrefix(v, ":") {
-		return "localhost" + v
-	} else {
-		return v
-	}
-}
-
-func serveProdTLS() error {
-	const cacheDir = "/var/cache/autocert"
-	if err := os.MkdirAll(cacheDir, 0700); err != nil {
-		return err
-	}
-	m := autocert.Manager{
-		Cache:      autocert.DirCache(cacheDir),
-		Prompt:     autocert.AcceptTOS,
-		HostPolicy: autocert.HostWhitelist("http2.golang.org"),
-	}
-	srv := &http.Server{
-		TLSConfig: &tls.Config{
-			GetCertificate: m.GetCertificate,
-		},
-	}
-	http2.ConfigureServer(srv, &http2.Server{
-		NewWriteScheduler: func() http2.WriteScheduler {
-			return http2.NewPriorityWriteScheduler(nil)
-		},
-	})
-	ln, err := net.Listen("tcp", ":443")
-	if err != nil {
-		return err
-	}
-	return srv.Serve(tls.NewListener(tcpKeepAliveListener{ln.(*net.TCPListener)}, srv.TLSConfig))
-}
-
-type tcpKeepAliveListener struct {
-	*net.TCPListener
-}
-
-func (ln tcpKeepAliveListener) Accept() (c net.Conn, err error) {
-	tc, err := ln.AcceptTCP()
-	if err != nil {
-		return
-	}
-	tc.SetKeepAlive(true)
-	tc.SetKeepAlivePeriod(3 * time.Minute)
-	return tc, nil
-}
-
-func serveProd() error {
-	errc := make(chan error, 2)
-	go func() { errc <- http.ListenAndServe(":80", nil) }()
-	go func() { errc <- serveProdTLS() }()
-	return <-errc
-}
-
-const idleTimeout = 5 * time.Minute
-const activeTimeout = 10 * time.Minute
-
-// TODO: put this into the standard library and actually send
-// PING frames and GOAWAY, etc: golang.org/issue/14204
-func idleTimeoutHook() func(net.Conn, http.ConnState) {
-	var mu sync.Mutex
-	m := map[net.Conn]*time.Timer{}
-	return func(c net.Conn, cs http.ConnState) {
-		mu.Lock()
-		defer mu.Unlock()
-		if t, ok := m[c]; ok {
-			delete(m, c)
-			t.Stop()
-		}
-		var d time.Duration
-		switch cs {
-		case http.StateNew, http.StateIdle:
-			d = idleTimeout
-		case http.StateActive:
-			d = activeTimeout
-		default:
-			return
-		}
-		m[c] = time.AfterFunc(d, func() {
-			log.Printf("closing idle conn %v after %v", c.RemoteAddr(), d)
-			go c.Close()
-		})
-	}
-}
-
-func main() {
-	var srv http.Server
-	flag.BoolVar(&http2.VerboseLogs, "verbose", false, "Verbose HTTP/2 debugging.")
-	flag.Parse()
-	srv.Addr = *httpsAddr
-	srv.ConnState = idleTimeoutHook()
-
-	registerHandlers()
-
-	if *prod {
-		*hostHTTP = "http2.golang.org"
-		*hostHTTPS = "http2.golang.org"
-		log.Fatal(serveProd())
-	}
-
-	url := "https://" + httpsHost() + "/"
-	log.Printf("Listening on " + url)
-	http2.ConfigureServer(&srv, &http2.Server{})
-
-	if *httpAddr != "" {
-		go func() {
-			log.Printf("Listening on http://" + httpHost() + "/ (for unencrypted HTTP/1)")
-			log.Fatal(http.ListenAndServe(*httpAddr, nil))
-		}()
-	}
-
-	go func() {
-		log.Fatal(srv.ListenAndServeTLS("server.crt", "server.key"))
-	}()
-	select {}
-}

vendor/golang.org/x/net/http2/h2demo/launch.go

@@ -1,302 +0,0 @@
-// Copyright 2014 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 ignore
-
-package main
-
-import (
-	"bufio"
-	"bytes"
-	"encoding/json"
-	"flag"
-	"fmt"
-	"io"
-	"io/ioutil"
-	"log"
-	"net/http"
-	"os"
-	"strings"
-	"time"
-
-	"golang.org/x/oauth2"
-	"golang.org/x/oauth2/google"
-	compute "google.golang.org/api/compute/v1"
-)
-
-var (
-	proj     = flag.String("project", "symbolic-datum-552", "name of Project")
-	zone     = flag.String("zone", "us-central1-a", "GCE zone")
-	mach     = flag.String("machinetype", "n1-standard-1", "Machine type")
-	instName = flag.String("instance_name", "http2-demo", "Name of VM instance.")
-	sshPub   = flag.String("ssh_public_key", "", "ssh public key file to authorize. Can modify later in Google's web UI anyway.")
-	staticIP = flag.String("static_ip", "130.211.116.44", "Static IP to use. If empty, automatic.")
-
-	writeObject  = flag.String("write_object", "", "If non-empty, a VM isn't created and the flag value is Google Cloud Storage bucket/object to write. The contents from stdin.")
-	publicObject = flag.Bool("write_object_is_public", false, "Whether the object created by --write_object should be public.")
-)
-
-func readFile(v string) string {
-	slurp, err := ioutil.ReadFile(v)
-	if err != nil {
-		log.Fatalf("Error reading %s: %v", v, err)
-	}
-	return strings.TrimSpace(string(slurp))
-}
-
-var config = &oauth2.Config{
-	// The client-id and secret should be for an "Installed Application" when using
-	// the CLI. Later we'll use a web application with a callback.
-	ClientID:     readFile("client-id.dat"),
-	ClientSecret: readFile("client-secret.dat"),
-	Endpoint:     google.Endpoint,
-	Scopes: []string{
-		compute.DevstorageFullControlScope,
-		compute.ComputeScope,
-		"https://www.googleapis.com/auth/sqlservice",
-		"https://www.googleapis.com/auth/sqlservice.admin",
-	},
-	RedirectURL: "urn:ietf:wg:oauth:2.0:oob",
-}
-
-const baseConfig = `#cloud-config
-coreos:
-  units:
-    - name: h2demo.service
-      command: start
-      content: |
-        [Unit]
-        Description=HTTP2 Demo
-        
-        [Service]
-        ExecStartPre=/bin/bash -c 'mkdir -p /opt/bin && curl -s -o /opt/bin/h2demo http://storage.googleapis.com/http2-demo-server-tls/h2demo && chmod +x /opt/bin/h2demo'
-        ExecStart=/opt/bin/h2demo --prod
-        RestartSec=5s
-        Restart=always
-        Type=simple
-        
-        [Install]
-        WantedBy=multi-user.target
-`
-
-func main() {
-	flag.Parse()
-	if *proj == "" {
-		log.Fatalf("Missing --project flag")
-	}
-	prefix := "https://www.googleapis.com/compute/v1/projects/" + *proj
-	machType := prefix + "/zones/" + *zone + "/machineTypes/" + *mach
-
-	const tokenFileName = "token.dat"
-	tokenFile := tokenCacheFile(tokenFileName)
-	tokenSource := oauth2.ReuseTokenSource(nil, tokenFile)
-	token, err := tokenSource.Token()
-	if err != nil {
-		if *writeObject != "" {
-			log.Fatalf("Can't use --write_object without a valid token.dat file already cached.")
-		}
-		log.Printf("Error getting token from %s: %v", tokenFileName, err)
-		log.Printf("Get auth code from %v", config.AuthCodeURL("my-state"))
-		fmt.Print("\nEnter auth code: ")
-		sc := bufio.NewScanner(os.Stdin)
-		sc.Scan()
-		authCode := strings.TrimSpace(sc.Text())
-		token, err = config.Exchange(oauth2.NoContext, authCode)
-		if err != nil {
-			log.Fatalf("Error exchanging auth code for a token: %v", err)
-		}
-		if err := tokenFile.WriteToken(token); err != nil {
-			log.Fatalf("Error writing to %s: %v", tokenFileName, err)
-		}
-		tokenSource = oauth2.ReuseTokenSource(token, nil)
-	}
-
-	oauthClient := oauth2.NewClient(oauth2.NoContext, tokenSource)
-
-	if *writeObject != "" {
-		writeCloudStorageObject(oauthClient)
-		return
-	}
-
-	computeService, _ := compute.New(oauthClient)
-
-	natIP := *staticIP
-	if natIP == "" {
-		// Try to find it by name.
-		aggAddrList, err := computeService.Addresses.AggregatedList(*proj).Do()
-		if err != nil {
-			log.Fatal(err)
-		}
-		// http://godoc.org/code.google.com/p/google-api-go-client/compute/v1#AddressAggregatedList
-	IPLoop:
-		for _, asl := range aggAddrList.Items {
-			for _, addr := range asl.Addresses {
-				if addr.Name == *instName+"-ip" && addr.Status == "RESERVED" {
-					natIP = addr.Address
-					break IPLoop
-				}
-			}
-		}
-	}
-
-	cloudConfig := baseConfig
-	if *sshPub != "" {
-		key := strings.TrimSpace(readFile(*sshPub))
-		cloudConfig += fmt.Sprintf("\nssh_authorized_keys:\n    - %s\n", key)
-	}
-	if os.Getenv("USER") == "bradfitz" {
-		cloudConfig += fmt.Sprintf("\nssh_authorized_keys:\n    - %s\n", "ssh-rsa AAAAB3NzaC1yc2EAAAABIwAAAIEAwks9dwWKlRC+73gRbvYtVg0vdCwDSuIlyt4z6xa/YU/jTDynM4R4W10hm2tPjy8iR1k8XhDv4/qdxe6m07NjG/By1tkmGpm1mGwho4Pr5kbAAy/Qg+NLCSdAYnnE00FQEcFOC15GFVMOW2AzDGKisReohwH9eIzHPzdYQNPRWXE= bradfitz@papag.bradfitz.com")
-	}
-	const maxCloudConfig = 32 << 10 // per compute API docs
-	if len(cloudConfig) > maxCloudConfig {
-		log.Fatalf("cloud config length of %d bytes is over %d byte limit", len(cloudConfig), maxCloudConfig)
-	}
-
-	instance := &compute.Instance{
-		Name:        *instName,
-		Description: "Go Builder",
-		MachineType: machType,
-		Disks:       []*compute.AttachedDisk{instanceDisk(computeService)},
-		Tags: &compute.Tags{
-			Items: []string{"http-server", "https-server"},
-		},
-		Metadata: &compute.Metadata{
-			Items: []*compute.MetadataItems{
-				{
-					Key:   "user-data",
-					Value: &cloudConfig,
-				},
-			},
-		},
-		NetworkInterfaces: []*compute.NetworkInterface{
-			{
-				AccessConfigs: []*compute.AccessConfig{
-					{
-						Type:  "ONE_TO_ONE_NAT",
-						Name:  "External NAT",
-						NatIP: natIP,
-					},
-				},
-				Network: prefix + "/global/networks/default",
-			},
-		},
-		ServiceAccounts: []*compute.ServiceAccount{
-			{
-				Email: "default",
-				Scopes: []string{
-					compute.DevstorageFullControlScope,
-					compute.ComputeScope,
-				},
-			},
-		},
-	}
-
-	log.Printf("Creating instance...")
-	op, err := computeService.Instances.Insert(*proj, *zone, instance).Do()
-	if err != nil {
-		log.Fatalf("Failed to create instance: %v", err)
-	}
-	opName := op.Name
-	log.Printf("Created. Waiting on operation %v", opName)
-OpLoop:
-	for {
-		time.Sleep(2 * time.Second)
-		op, err := computeService.ZoneOperations.Get(*proj, *zone, opName).Do()
-		if err != nil {
-			log.Fatalf("Failed to get op %s: %v", opName, err)
-		}
-		switch op.Status {
-		case "PENDING", "RUNNING":
-			log.Printf("Waiting on operation %v", opName)
-			continue
-		case "DONE":
-			if op.Error != nil {
-				for _, operr := range op.Error.Errors {
-					log.Printf("Error: %+v", operr)
-				}
-				log.Fatalf("Failed to start.")
-			}
-			log.Printf("Success. %+v", op)
-			break OpLoop
-		default:
-			log.Fatalf("Unknown status %q: %+v", op.Status, op)
-		}
-	}
-
-	inst, err := computeService.Instances.Get(*proj, *zone, *instName).Do()
-	if err != nil {
-		log.Fatalf("Error getting instance after creation: %v", err)
-	}
-	ij, _ := json.MarshalIndent(inst, "", "    ")
-	log.Printf("Instance: %s", ij)
-}
-
-func instanceDisk(svc *compute.Service) *compute.AttachedDisk {
-	const imageURL = "https://www.googleapis.com/compute/v1/projects/coreos-cloud/global/images/coreos-stable-444-5-0-v20141016"
-	diskName := *instName + "-disk"
-
-	return &compute.AttachedDisk{
-		AutoDelete: true,
-		Boot:       true,
-		Type:       "PERSISTENT",
-		InitializeParams: &compute.AttachedDiskInitializeParams{
-			DiskName:    diskName,
-			SourceImage: imageURL,
-			DiskSizeGb:  50,
-		},
-	}
-}
-
-func writeCloudStorageObject(httpClient *http.Client) {
-	content := os.Stdin
-	const maxSlurp = 1 << 20
-	var buf bytes.Buffer
-	n, err := io.CopyN(&buf, content, maxSlurp)
-	if err != nil && err != io.EOF {
-		log.Fatalf("Error reading from stdin: %v, %v", n, err)
-	}
-	contentType := http.DetectContentType(buf.Bytes())
-
-	req, err := http.NewRequest("PUT", "https://storage.googleapis.com/"+*writeObject, io.MultiReader(&buf, content))
-	if err != nil {
-		log.Fatal(err)
-	}
-	req.Header.Set("x-goog-api-version", "2")
-	if *publicObject {
-		req.Header.Set("x-goog-acl", "public-read")
-	}
-	req.Header.Set("Content-Type", contentType)
-	res, err := httpClient.Do(req)
-	if err != nil {
-		log.Fatal(err)
-	}
-	if res.StatusCode != 200 {
-		res.Write(os.Stderr)
-		log.Fatalf("Failed.")
-	}
-	log.Printf("Success.")
-	os.Exit(0)
-}
-
-type tokenCacheFile string
-
-func (f tokenCacheFile) Token() (*oauth2.Token, error) {
-	slurp, err := ioutil.ReadFile(string(f))
-	if err != nil {
-		return nil, err
-	}
-	t := new(oauth2.Token)
-	if err := json.Unmarshal(slurp, t); err != nil {
-		return nil, err
-	}
-	return t, nil
-}
-
-func (f tokenCacheFile) WriteToken(t *oauth2.Token) error {
-	jt, err := json.Marshal(t)
-	if err != nil {
-		return err
-	}
-	return ioutil.WriteFile(string(f), jt, 0600)
-}

vendor/golang.org/x/net/http2/h2demo/rootCA.key

@@ -1,27 +0,0 @@
------BEGIN RSA PRIVATE KEY-----
-MIIEowIBAAKCAQEAt5fAjp4fTcekWUTfzsp0kyih1OYbsGL0KX1eRbSSR8Od0+9Q
-62Hyny+GFwMTb4A/KU8mssoHvcceSAAbwfbxFK/+s51TobqUnORZrOoTZjkUygby
-XDSK99YBbcR1Pip8vwMTm4XKuLtCigeBBdjjAQdgUO28LENGlsMnmeYkJfODVGnV
-mr5Ltb9ANA8IKyTfsnHJ4iOCS/PlPbUj2q7YnoVLposUBMlgUb/CykX3mOoLb4yJ
-JQyA/iST6ZxiIEj36D4yWZ5lg7YJl+UiiBQHGCnPdGyipqV06ex0heYWcaiW8LWZ
-SUQ93jQ+WVCH8hT7DQO1dmsvUmXlq/JeAlwQ/QIDAQABAoIBAFFHV7JMAqPWnMYA
-nezY6J81v9+XN+7xABNWM2Q8uv4WdksbigGLTXR3/680Z2hXqJ7LMeC5XJACFT/e
-/Gr0vmpgOCygnCPfjGehGKpavtfksXV3edikUlnCXsOP1C//c1bFL+sMYmFCVgTx
-qYdDK8yKzXNGrKYT6q5YG7IglyRNV1rsQa8lM/5taFYiD1Ck/3tQi3YIq8Lcuser
-hrxsMABcQ6mi+EIvG6Xr4mfJug0dGJMHG4RG1UGFQn6RXrQq2+q53fC8ZbVUSi0j
-NQ918aKFzktwv+DouKU0ME4I9toks03gM860bAL7zCbKGmwR3hfgX/TqzVCWpG9E
-LDVfvekCgYEA8fk9N53jbBRmULUGEf4qWypcLGiZnNU0OeXWpbPV9aa3H0VDytA7
-8fCN2dPAVDPqlthMDdVe983NCNwp2Yo8ZimDgowyIAKhdC25s1kejuaiH9OAPj3c
-0f8KbriYX4n8zNHxFwK6Ae3pQ6EqOLJVCUsziUaZX9nyKY5aZlyX6xcCgYEAwjws
-K62PjC64U5wYddNLp+kNdJ4edx+a7qBb3mEgPvSFT2RO3/xafJyG8kQB30Mfstjd
-bRxyUV6N0vtX1zA7VQtRUAvfGCecpMo+VQZzcHXKzoRTnQ7eZg4Lmj5fQ9tOAKAo
-QCVBoSW/DI4PZL26CAMDcAba4Pa22ooLapoRIQsCgYA6pIfkkbxLNkpxpt2YwLtt
-Kr/590O7UaR9n6k8sW/aQBRDXNsILR1KDl2ifAIxpf9lnXgZJiwE7HiTfCAcW7c1
-nzwDCI0hWuHcMTS/NYsFYPnLsstyyjVZI3FY0h4DkYKV9Q9z3zJLQ2hz/nwoD3gy
-b2pHC7giFcTts1VPV4Nt8wKBgHeFn4ihHJweg76vZz3Z78w7VNRWGFklUalVdDK7
-gaQ7w2y/ROn/146mo0OhJaXFIFRlrpvdzVrU3GDf2YXJYDlM5ZRkObwbZADjksev
-WInzcgDy3KDg7WnPasRXbTfMU4t/AkW2p1QKbi3DnSVYuokDkbH2Beo45vxDxhKr
-C69RAoGBAIyo3+OJenoZmoNzNJl2WPW5MeBUzSh8T/bgyjFTdqFHF5WiYRD/lfHj
-x9Glyw2nutuT4hlOqHvKhgTYdDMsF2oQ72fe3v8Q5FU7FuKndNPEAyvKNXZaShVA
-hnlhv5DjXKb0wFWnt5PCCiQLtzG0yyHaITrrEme7FikkIcTxaX/Y
------END RSA PRIVATE KEY-----

vendor/golang.org/x/net/http2/h2demo/rootCA.pem

@@ -1,26 +0,0 @@
------BEGIN CERTIFICATE-----
-MIIEWjCCA0KgAwIBAgIJALfRlWsI8YQHMA0GCSqGSIb3DQEBBQUAMHsxCzAJBgNV
-BAYTAlVTMQswCQYDVQQIEwJDQTEWMBQGA1UEBxMNU2FuIEZyYW5jaXNjbzEUMBIG
-A1UEChMLQnJhZGZpdHppbmMxEjAQBgNVBAMTCWxvY2FsaG9zdDEdMBsGCSqGSIb3
-DQEJARYOYnJhZEBkYW5nYS5jb20wHhcNMTQwNzE1MjA0NjA1WhcNMTcwNTA0MjA0
-NjA1WjB7MQswCQYDVQQGEwJVUzELMAkGA1UECBMCQ0ExFjAUBgNVBAcTDVNhbiBG
-cmFuY2lzY28xFDASBgNVBAoTC0JyYWRmaXR6aW5jMRIwEAYDVQQDEwlsb2NhbGhv
-c3QxHTAbBgkqhkiG9w0BCQEWDmJyYWRAZGFuZ2EuY29tMIIBIjANBgkqhkiG9w0B
-AQEFAAOCAQ8AMIIBCgKCAQEAt5fAjp4fTcekWUTfzsp0kyih1OYbsGL0KX1eRbSS
-R8Od0+9Q62Hyny+GFwMTb4A/KU8mssoHvcceSAAbwfbxFK/+s51TobqUnORZrOoT
-ZjkUygbyXDSK99YBbcR1Pip8vwMTm4XKuLtCigeBBdjjAQdgUO28LENGlsMnmeYk
-JfODVGnVmr5Ltb9ANA8IKyTfsnHJ4iOCS/PlPbUj2q7YnoVLposUBMlgUb/CykX3
-mOoLb4yJJQyA/iST6ZxiIEj36D4yWZ5lg7YJl+UiiBQHGCnPdGyipqV06ex0heYW
-caiW8LWZSUQ93jQ+WVCH8hT7DQO1dmsvUmXlq/JeAlwQ/QIDAQABo4HgMIHdMB0G
-A1UdDgQWBBRcAROthS4P4U7vTfjByC569R7E6DCBrQYDVR0jBIGlMIGigBRcAROt
-hS4P4U7vTfjByC569R7E6KF/pH0wezELMAkGA1UEBhMCVVMxCzAJBgNVBAgTAkNB
-MRYwFAYDVQQHEw1TYW4gRnJhbmNpc2NvMRQwEgYDVQQKEwtCcmFkZml0emluYzES
-MBAGA1UEAxMJbG9jYWxob3N0MR0wGwYJKoZIhvcNAQkBFg5icmFkQGRhbmdhLmNv
-bYIJALfRlWsI8YQHMAwGA1UdEwQFMAMBAf8wDQYJKoZIhvcNAQEFBQADggEBAG6h
-U9f9sNH0/6oBbGGy2EVU0UgITUQIrFWo9rFkrW5k/XkDjQm+3lzjT0iGR4IxE/Ao
-eU6sQhua7wrWeFEn47GL98lnCsJdD7oZNhFmQ95Tb/LnDUjs5Yj9brP0NWzXfYU4
-UK2ZnINJRcJpB8iRCaCxE8DdcUF0XqIEq6pA272snoLmiXLMvNl3kYEdm+je6voD
-58SNVEUsztzQyXmJEhCpwVI0A6QCjzXj+qvpmw3ZZHi8JwXei8ZZBLTSFBki8Z7n
-sH9BBH38/SzUmAN4QHSPy1gjqm00OAE8NaYDkh/bzE4d7mLGGMWp/WE3KPSu82HF
-kPe6XoSbiLm/kxk32T0=
------END CERTIFICATE-----

vendor/golang.org/x/net/http2/h2demo/rootCA.srl

@@ -1 +0,0 @@
-E2CE26BF3285059C

vendor/golang.org/x/net/http2/h2demo/server.crt

@@ -1,20 +0,0 @@
------BEGIN CERTIFICATE-----
-MIIDPjCCAiYCCQDizia/MoUFnDANBgkqhkiG9w0BAQUFADB7MQswCQYDVQQGEwJV
-UzELMAkGA1UECBMCQ0ExFjAUBgNVBAcTDVNhbiBGcmFuY2lzY28xFDASBgNVBAoT
-C0JyYWRmaXR6aW5jMRIwEAYDVQQDEwlsb2NhbGhvc3QxHTAbBgkqhkiG9w0BCQEW
-DmJyYWRAZGFuZ2EuY29tMB4XDTE0MDcxNTIwNTAyN1oXDTE1MTEyNzIwNTAyN1ow
-RzELMAkGA1UEBhMCVVMxCzAJBgNVBAgTAkNBMQswCQYDVQQHEwJTRjEeMBwGA1UE
-ChMVYnJhZGZpdHogaHR0cDIgc2VydmVyMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8A
-MIIBCgKCAQEAs1Y9CyLFrdL8VQWN1WaifDqaZFnoqjHhCMlc1TfG2zA+InDifx2l
-gZD3o8FeNnAcfM2sPlk3+ZleOYw9P/CklFVDlvqmpCv9ss/BEp/dDaWvy1LmJ4c2
-dbQJfmTxn7CV1H3TsVJvKdwFmdoABb41NoBp6+NNO7OtDyhbIMiCI0pL3Nefb3HL
-A7hIMo3DYbORTtJLTIH9W8YKrEWL0lwHLrYFx/UdutZnv+HjdmO6vCN4na55mjws
-/vjKQUmc7xeY7Xe20xDEG2oDKVkL2eD7FfyrYMS3rO1ExP2KSqlXYG/1S9I/fz88
-F0GK7HX55b5WjZCl2J3ERVdnv/0MQv+sYQIDAQABMA0GCSqGSIb3DQEBBQUAA4IB
-AQC0zL+n/YpRZOdulSu9tS8FxrstXqGWoxfe+vIUgqfMZ5+0MkjJ/vW0FqlLDl2R
-rn4XaR3e7FmWkwdDVbq/UB6lPmoAaFkCgh9/5oapMaclNVNnfF3fjCJfRr+qj/iD
-EmJStTIN0ZuUjAlpiACmfnpEU55PafT5Zx+i1yE4FGjw8bJpFoyD4Hnm54nGjX19
-KeCuvcYFUPnBm3lcL0FalF2AjqV02WTHYNQk7YF/oeO7NKBoEgvGvKG3x+xaOeBI
-dwvdq175ZsGul30h+QjrRlXhH/twcuaT3GSdoysDl9cCYE8f1Mk8PD6gan3uBCJU
-90p6/CbU71bGbfpM2PHot2fm
------END CERTIFICATE-----

vendor/golang.org/x/net/http2/h2demo/server.key

@@ -1,27 +0,0 @@
------BEGIN RSA PRIVATE KEY-----
-MIIEowIBAAKCAQEAs1Y9CyLFrdL8VQWN1WaifDqaZFnoqjHhCMlc1TfG2zA+InDi
-fx2lgZD3o8FeNnAcfM2sPlk3+ZleOYw9P/CklFVDlvqmpCv9ss/BEp/dDaWvy1Lm
-J4c2dbQJfmTxn7CV1H3TsVJvKdwFmdoABb41NoBp6+NNO7OtDyhbIMiCI0pL3Nef
-b3HLA7hIMo3DYbORTtJLTIH9W8YKrEWL0lwHLrYFx/UdutZnv+HjdmO6vCN4na55
-mjws/vjKQUmc7xeY7Xe20xDEG2oDKVkL2eD7FfyrYMS3rO1ExP2KSqlXYG/1S9I/
-fz88F0GK7HX55b5WjZCl2J3ERVdnv/0MQv+sYQIDAQABAoIBADQ2spUwbY+bcz4p
-3M66ECrNQTBggP40gYl2XyHxGGOu2xhZ94f9ELf1hjRWU2DUKWco1rJcdZClV6q3
-qwmXvcM2Q/SMS8JW0ImkNVl/0/NqPxGatEnj8zY30d/L8hGFb0orzFu/XYA5gCP4
-NbN2WrXgk3ZLeqwcNxHHtSiJWGJ/fPyeDWAu/apy75u9Xf2GlzBZmV6HYD9EfK80
-LTlI60f5FO487CrJnboL7ovPJrIHn+k05xRQqwma4orpz932rTXnTjs9Lg6KtbQN
-a7PrqfAntIISgr11a66Mng3IYH1lYqJsWJJwX/xHT4WLEy0EH4/0+PfYemJekz2+
-Co62drECgYEA6O9zVJZXrLSDsIi54cfxA7nEZWm5CAtkYWeAHa4EJ+IlZ7gIf9sL
-W8oFcEfFGpvwVqWZ+AsQ70dsjXAv3zXaG0tmg9FtqWp7pzRSMPidifZcQwWkKeTO
-gJnFmnVyed8h6GfjTEu4gxo1/S5U0V+mYSha01z5NTnN6ltKx1Or3b0CgYEAxRgm
-S30nZxnyg/V7ys61AZhst1DG2tkZXEMcA7dYhabMoXPJAP/EfhlWwpWYYUs/u0gS
-Wwmf5IivX5TlYScgmkvb/NYz0u4ZmOXkLTnLPtdKKFXhjXJcHjUP67jYmOxNlJLp
-V4vLRnFxTpffAV+OszzRxsXX6fvruwZBANYJeXUCgYBVouLFsFgfWGYp2rpr9XP4
-KK25kvrBqF6JKOIDB1zjxNJ3pUMKrl8oqccCFoCyXa4oTM2kUX0yWxHfleUjrMq4
-yimwQKiOZmV7fVLSSjSw6e/VfBd0h3gb82ygcplZkN0IclkwTY5SNKqwn/3y07V5
-drqdhkrgdJXtmQ6O5YYECQKBgATERcDToQ1USlI4sKrB/wyv1AlG8dg/IebiVJ4e
-ZAyvcQmClFzq0qS+FiQUnB/WQw9TeeYrwGs1hxBHuJh16srwhLyDrbMvQP06qh8R
-48F8UXXSRec22dV9MQphaROhu2qZdv1AC0WD3tqov6L33aqmEOi+xi8JgbT/PLk5
-c/c1AoGBAI1A/02ryksW6/wc7/6SP2M2rTy4m1sD/GnrTc67EHnRcVBdKO6qH2RY
-nqC8YcveC2ZghgPTDsA3VGuzuBXpwY6wTyV99q6jxQJ6/xcrD9/NUG6Uwv/xfCxl
-IJLeBYEqQundSSny3VtaAUK8Ul1nxpTvVRNwtcyWTo8RHAAyNPWd
------END RSA PRIVATE KEY-----

vendor/golang.org/x/net/http2/h2i/README.md

@@ -1,97 +0,0 @@
-# h2i
-
-**h2i** is an interactive HTTP/2 ("h2") console debugger. Miss the good ol'
-days of telnetting to your HTTP/1.n servers? We're bringing you
-back.
-
-Features:
-- send raw HTTP/2 frames
- - PING
- - SETTINGS
- - HEADERS
- - etc
-- type in HTTP/1.n and have it auto-HPACK/frame-ify it for HTTP/2
-- pretty print all received HTTP/2 frames from the peer (including HPACK decoding)
-- tab completion of commands, options
-
-Not yet features, but soon:
-- unnecessary CONTINUATION frames on short boundaries, to test peer implementations 
-- request bodies (DATA frames)
-- send invalid frames for testing server implementations (supported by underlying Framer)
-
-Later:
-- act like a server
-
-## Installation
-
-```
-$ go get golang.org/x/net/http2/h2i
-$ h2i <host>
-```
-
-## Demo
-
-```
-$ h2i
-Usage: h2i <hostname>
-  
-  -insecure
-        Whether to skip TLS cert validation
-  -nextproto string
-        Comma-separated list of NPN/ALPN protocol names to negotiate. (default "h2,h2-14")
-
-$ h2i google.com
-Connecting to google.com:443 ...
-Connected to 74.125.224.41:443
-Negotiated protocol "h2-14"
-[FrameHeader SETTINGS len=18]
-  [MAX_CONCURRENT_STREAMS = 100]
-  [INITIAL_WINDOW_SIZE = 1048576]
-  [MAX_FRAME_SIZE = 16384]
-[FrameHeader WINDOW_UPDATE len=4]
-  Window-Increment = 983041
-  
-h2i> PING h2iSayHI
-[FrameHeader PING flags=ACK len=8]
-  Data = "h2iSayHI"
-h2i> headers
-(as HTTP/1.1)> GET / HTTP/1.1
-(as HTTP/1.1)> Host: ip.appspot.com
-(as HTTP/1.1)> User-Agent: h2i/brad-n-blake
-(as HTTP/1.1)>  
-Opening Stream-ID 1:
- :authority = ip.appspot.com
- :method = GET
- :path = /
- :scheme = https
- user-agent = h2i/brad-n-blake
-[FrameHeader HEADERS flags=END_HEADERS stream=1 len=77]
-  :status = "200"
-  alternate-protocol = "443:quic,p=1"
-  content-length = "15"
-  content-type = "text/html"
-  date = "Fri, 01 May 2015 23:06:56 GMT"
-  server = "Google Frontend"
-[FrameHeader DATA flags=END_STREAM stream=1 len=15]
-  "173.164.155.78\n"
-[FrameHeader PING len=8]
-  Data = "\x00\x00\x00\x00\x00\x00\x00\x00"
-h2i> ping  
-[FrameHeader PING flags=ACK len=8]  
-  Data = "h2i_ping"  
-h2i> ping  
-[FrameHeader PING flags=ACK len=8]
-  Data = "h2i_ping"
-h2i> ping
-[FrameHeader GOAWAY len=22]
-  Last-Stream-ID = 1; Error-Code = PROTOCOL_ERROR (1)
-
-ReadFrame: EOF
-```
-
-## Status
-
-Quick few hour hack. So much yet to do. Feel free to file issues for
-bugs or wishlist items, but [@bmizerany](https://github.com/bmizerany/)
-and I aren't yet accepting pull requests until things settle down.
-

vendor/golang.org/x/net/http2/h2i/h2i.go

@@ -1,522 +0,0 @@
-// Copyright 2015 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,!solaris
-
-/*
-The h2i command is an interactive HTTP/2 console.
-
-Usage:
-  $ h2i [flags] <hostname>
-
-Interactive commands in the console: (all parts case-insensitive)
-
-  ping [data]
-  settings ack
-  settings FOO=n BAR=z
-  headers      (open a new stream by typing HTTP/1.1)
-*/
-package main
-
-import (
-	"bufio"
-	"bytes"
-	"crypto/tls"
-	"errors"
-	"flag"
-	"fmt"
-	"io"
-	"log"
-	"net"
-	"net/http"
-	"os"
-	"regexp"
-	"strconv"
-	"strings"
-
-	"golang.org/x/crypto/ssh/terminal"
-	"golang.org/x/net/http2"
-	"golang.org/x/net/http2/hpack"
-)
-
-// Flags
-var (
-	flagNextProto = flag.String("nextproto", "h2,h2-14", "Comma-separated list of NPN/ALPN protocol names to negotiate.")
-	flagInsecure  = flag.Bool("insecure", false, "Whether to skip TLS cert validation")
-	flagSettings  = flag.String("settings", "empty", "comma-separated list of KEY=value settings for the initial SETTINGS frame. The magic value 'empty' sends an empty initial settings frame, and the magic value 'omit' causes no initial settings frame to be sent.")
-	flagDial      = flag.String("dial", "", "optional ip:port to dial, to connect to a host:port but use a different SNI name (including a SNI name without DNS)")
-)
-
-type command struct {
-	run func(*h2i, []string) error // required
-
-	// complete optionally specifies tokens (case-insensitive) which are
-	// valid for this subcommand.
-	complete func() []string
-}
-
-var commands = map[string]command{
-	"ping": {run: (*h2i).cmdPing},
-	"settings": {
-		run: (*h2i).cmdSettings,
-		complete: func() []string {
-			return []string{
-				"ACK",
-				http2.SettingHeaderTableSize.String(),
-				http2.SettingEnablePush.String(),
-				http2.SettingMaxConcurrentStreams.String(),
-				http2.SettingInitialWindowSize.String(),
-				http2.SettingMaxFrameSize.String(),
-				http2.SettingMaxHeaderListSize.String(),
-			}
-		},
-	},
-	"quit":    {run: (*h2i).cmdQuit},
-	"headers": {run: (*h2i).cmdHeaders},
-}
-
-func usage() {
-	fmt.Fprintf(os.Stderr, "Usage: h2i <hostname>\n\n")
-	flag.PrintDefaults()
-}
-
-// withPort adds ":443" if another port isn't already present.
-func withPort(host string) string {
-	if _, _, err := net.SplitHostPort(host); err != nil {
-		return net.JoinHostPort(host, "443")
-	}
-	return host
-}
-
-// withoutPort strips the port from addr if present.
-func withoutPort(addr string) string {
-	if h, _, err := net.SplitHostPort(addr); err == nil {
-		return h
-	}
-	return addr
-}
-
-// h2i is the app's state.
-type h2i struct {
-	host   string
-	tc     *tls.Conn
-	framer *http2.Framer
-	term   *terminal.Terminal
-
-	// owned by the command loop:
-	streamID uint32
-	hbuf     bytes.Buffer
-	henc     *hpack.Encoder
-
-	// owned by the readFrames loop:
-	peerSetting map[http2.SettingID]uint32
-	hdec        *hpack.Decoder
-}
-
-func main() {
-	flag.Usage = usage
-	flag.Parse()
-	if flag.NArg() != 1 {
-		usage()
-		os.Exit(2)
-	}
-	log.SetFlags(0)
-
-	host := flag.Arg(0)
-	app := &h2i{
-		host:        host,
-		peerSetting: make(map[http2.SettingID]uint32),
-	}
-	app.henc = hpack.NewEncoder(&app.hbuf)
-
-	if err := app.Main(); err != nil {
-		if app.term != nil {
-			app.logf("%v\n", err)
-		} else {
-			fmt.Fprintf(os.Stderr, "%v\n", err)
-		}
-		os.Exit(1)
-	}
-	fmt.Fprintf(os.Stdout, "\n")
-}
-
-func (app *h2i) Main() error {
-	cfg := &tls.Config{
-		ServerName:         withoutPort(app.host),
-		NextProtos:         strings.Split(*flagNextProto, ","),
-		InsecureSkipVerify: *flagInsecure,
-	}
-
-	hostAndPort := *flagDial
-	if hostAndPort == "" {
-		hostAndPort = withPort(app.host)
-	}
-	log.Printf("Connecting to %s ...", hostAndPort)
-	tc, err := tls.Dial("tcp", hostAndPort, cfg)
-	if err != nil {
-		return fmt.Errorf("Error dialing %s: %v", hostAndPort, err)
-	}
-	log.Printf("Connected to %v", tc.RemoteAddr())
-	defer tc.Close()
-
-	if err := tc.Handshake(); err != nil {
-		return fmt.Errorf("TLS handshake: %v", err)
-	}
-	if !*flagInsecure {
-		if err := tc.VerifyHostname(app.host); err != nil {
-			return fmt.Errorf("VerifyHostname: %v", err)
-		}
-	}
-	state := tc.ConnectionState()
-	log.Printf("Negotiated protocol %q", state.NegotiatedProtocol)
-	if !state.NegotiatedProtocolIsMutual || state.NegotiatedProtocol == "" {
-		return fmt.Errorf("Could not negotiate protocol mutually")
-	}
-
-	if _, err := io.WriteString(tc, http2.ClientPreface); err != nil {
-		return err
-	}
-
-	app.framer = http2.NewFramer(tc, tc)
-
-	oldState, err := terminal.MakeRaw(int(os.Stdin.Fd()))
-	if err != nil {
-		return err
-	}
-	defer terminal.Restore(0, oldState)
-
-	var screen = struct {
-		io.Reader
-		io.Writer
-	}{os.Stdin, os.Stdout}
-
-	app.term = terminal.NewTerminal(screen, "h2i> ")
-	lastWord := regexp.MustCompile(`.+\W(\w+)$`)
-	app.term.AutoCompleteCallback = func(line string, pos int, key rune) (newLine string, newPos int, ok bool) {
-		if key != '\t' {
-			return
-		}
-		if pos != len(line) {
-			// TODO: we're being lazy for now, only supporting tab completion at the end.
-			return
-		}
-		// Auto-complete for the command itself.
-		if !strings.Contains(line, " ") {
-			var name string
-			name, _, ok = lookupCommand(line)
-			if !ok {
-				return
-			}
-			return name, len(name), true
-		}
-		_, c, ok := lookupCommand(line[:strings.IndexByte(line, ' ')])
-		if !ok || c.complete == nil {
-			return
-		}
-		if strings.HasSuffix(line, " ") {
-			app.logf("%s", strings.Join(c.complete(), " "))
-			return line, pos, true
-		}
-		m := lastWord.FindStringSubmatch(line)
-		if m == nil {
-			return line, len(line), true
-		}
-		soFar := m[1]
-		var match []string
-		for _, cand := range c.complete() {
-			if len(soFar) > len(cand) || !strings.EqualFold(cand[:len(soFar)], soFar) {
-				continue
-			}
-			match = append(match, cand)
-		}
-		if len(match) == 0 {
-			return
-		}
-		if len(match) > 1 {
-			// TODO: auto-complete any common prefix
-			app.logf("%s", strings.Join(match, " "))
-			return line, pos, true
-		}
-		newLine = line[:len(line)-len(soFar)] + match[0]
-		return newLine, len(newLine), true
-
-	}
-
-	errc := make(chan error, 2)
-	go func() { errc <- app.readFrames() }()
-	go func() { errc <- app.readConsole() }()
-	return <-errc
-}
-
-func (app *h2i) logf(format string, args ...interface{}) {
-	fmt.Fprintf(app.term, format+"\r\n", args...)
-}
-
-func (app *h2i) readConsole() error {
-	if s := *flagSettings; s != "omit" {
-		var args []string
-		if s != "empty" {
-			args = strings.Split(s, ",")
-		}
-		_, c, ok := lookupCommand("settings")
-		if !ok {
-			panic("settings command not found")
-		}
-		c.run(app, args)
-	}
-
-	for {
-		line, err := app.term.ReadLine()
-		if err == io.EOF {
-			return nil
-		}
-		if err != nil {
-			return fmt.Errorf("terminal.ReadLine: %v", err)
-		}
-		f := strings.Fields(line)
-		if len(f) == 0 {
-			continue
-		}
-		cmd, args := f[0], f[1:]
-		if _, c, ok := lookupCommand(cmd); ok {
-			err = c.run(app, args)
-		} else {
-			app.logf("Unknown command %q", line)
-		}
-		if err == errExitApp {
-			return nil
-		}
-		if err != nil {
-			return err
-		}
-	}
-}
-
-func lookupCommand(prefix string) (name string, c command, ok bool) {
-	prefix = strings.ToLower(prefix)
-	if c, ok = commands[prefix]; ok {
-		return prefix, c, ok
-	}
-
-	for full, candidate := range commands {
-		if strings.HasPrefix(full, prefix) {
-			if c.run != nil {
-				return "", command{}, false // ambiguous
-			}
-			c = candidate
-			name = full
-		}
-	}
-	return name, c, c.run != nil
-}
-
-var errExitApp = errors.New("internal sentinel error value to quit the console reading loop")
-
-func (a *h2i) cmdQuit(args []string) error {
-	if len(args) > 0 {
-		a.logf("the QUIT command takes no argument")
-		return nil
-	}
-	return errExitApp
-}
-
-func (a *h2i) cmdSettings(args []string) error {
-	if len(args) == 1 && strings.EqualFold(args[0], "ACK") {
-		return a.framer.WriteSettingsAck()
-	}
-	var settings []http2.Setting
-	for _, arg := range args {
-		if strings.EqualFold(arg, "ACK") {
-			a.logf("Error: ACK must be only argument with the SETTINGS command")
-			return nil
-		}
-		eq := strings.Index(arg, "=")
-		if eq == -1 {
-			a.logf("Error: invalid argument %q (expected SETTING_NAME=nnnn)", arg)
-			return nil
-		}
-		sid, ok := settingByName(arg[:eq])
-		if !ok {
-			a.logf("Error: unknown setting name %q", arg[:eq])
-			return nil
-		}
-		val, err := strconv.ParseUint(arg[eq+1:], 10, 32)
-		if err != nil {
-			a.logf("Error: invalid argument %q (expected SETTING_NAME=nnnn)", arg)
-			return nil
-		}
-		settings = append(settings, http2.Setting{
-			ID:  sid,
-			Val: uint32(val),
-		})
-	}
-	a.logf("Sending: %v", settings)
-	return a.framer.WriteSettings(settings...)
-}
-
-func settingByName(name string) (http2.SettingID, bool) {
-	for _, sid := range [...]http2.SettingID{
-		http2.SettingHeaderTableSize,
-		http2.SettingEnablePush,
-		http2.SettingMaxConcurrentStreams,
-		http2.SettingInitialWindowSize,
-		http2.SettingMaxFrameSize,
-		http2.SettingMaxHeaderListSize,
-	} {
-		if strings.EqualFold(sid.String(), name) {
-			return sid, true
-		}
-	}
-	return 0, false
-}
-
-func (app *h2i) cmdPing(args []string) error {
-	if len(args) > 1 {
-		app.logf("invalid PING usage: only accepts 0 or 1 args")
-		return nil // nil means don't end the program
-	}
-	var data [8]byte
-	if len(args) == 1 {
-		copy(data[:], args[0])
-	} else {
-		copy(data[:], "h2i_ping")
-	}
-	return app.framer.WritePing(false, data)
-}
-
-func (app *h2i) cmdHeaders(args []string) error {
-	if len(args) > 0 {
-		app.logf("Error: HEADERS doesn't yet take arguments.")
-		// TODO: flags for restricting window size, to force CONTINUATION
-		// frames.
-		return nil
-	}
-	var h1req bytes.Buffer
-	app.term.SetPrompt("(as HTTP/1.1)> ")
-	defer app.term.SetPrompt("h2i> ")
-	for {
-		line, err := app.term.ReadLine()
-		if err != nil {
-			return err
-		}
-		h1req.WriteString(line)
-		h1req.WriteString("\r\n")
-		if line == "" {
-			break
-		}
-	}
-	req, err := http.ReadRequest(bufio.NewReader(&h1req))
-	if err != nil {
-		app.logf("Invalid HTTP/1.1 request: %v", err)
-		return nil
-	}
-	if app.streamID == 0 {
-		app.streamID = 1
-	} else {
-		app.streamID += 2
-	}
-	app.logf("Opening Stream-ID %d:", app.streamID)
-	hbf := app.encodeHeaders(req)
-	if len(hbf) > 16<<10 {
-		app.logf("TODO: h2i doesn't yet write CONTINUATION frames. Copy it from transport.go")
-		return nil
-	}
-	return app.framer.WriteHeaders(http2.HeadersFrameParam{
-		StreamID:      app.streamID,
-		BlockFragment: hbf,
-		EndStream:     req.Method == "GET" || req.Method == "HEAD", // good enough for now
-		EndHeaders:    true,                                        // for now
-	})
-}
-
-func (app *h2i) readFrames() error {
-	for {
-		f, err := app.framer.ReadFrame()
-		if err != nil {
-			return fmt.Errorf("ReadFrame: %v", err)
-		}
-		app.logf("%v", f)
-		switch f := f.(type) {
-		case *http2.PingFrame:
-			app.logf("  Data = %q", f.Data)
-		case *http2.SettingsFrame:
-			f.ForeachSetting(func(s http2.Setting) error {
-				app.logf("  %v", s)
-				app.peerSetting[s.ID] = s.Val
-				return nil
-			})
-		case *http2.WindowUpdateFrame:
-			app.logf("  Window-Increment = %v", f.Increment)
-		case *http2.GoAwayFrame:
-			app.logf("  Last-Stream-ID = %d; Error-Code = %v (%d)", f.LastStreamID, f.ErrCode, f.ErrCode)
-		case *http2.DataFrame:
-			app.logf("  %q", f.Data())
-		case *http2.HeadersFrame:
-			if f.HasPriority() {
-				app.logf("  PRIORITY = %v", f.Priority)
-			}
-			if app.hdec == nil {
-				// TODO: if the user uses h2i to send a SETTINGS frame advertising
-				// something larger, we'll need to respect SETTINGS_HEADER_TABLE_SIZE
-				// and stuff here instead of using the 4k default. But for now:
-				tableSize := uint32(4 << 10)
-				app.hdec = hpack.NewDecoder(tableSize, app.onNewHeaderField)
-			}
-			app.hdec.Write(f.HeaderBlockFragment())
-		case *http2.PushPromiseFrame:
-			if app.hdec == nil {
-				// TODO: if the user uses h2i to send a SETTINGS frame advertising
-				// something larger, we'll need to respect SETTINGS_HEADER_TABLE_SIZE
-				// and stuff here instead of using the 4k default. But for now:
-				tableSize := uint32(4 << 10)
-				app.hdec = hpack.NewDecoder(tableSize, app.onNewHeaderField)
-			}
-			app.hdec.Write(f.HeaderBlockFragment())
-		}
-	}
-}
-
-// called from readLoop
-func (app *h2i) onNewHeaderField(f hpack.HeaderField) {
-	if f.Sensitive {
-		app.logf("  %s = %q (SENSITIVE)", f.Name, f.Value)
-	}
-	app.logf("  %s = %q", f.Name, f.Value)
-}
-
-func (app *h2i) encodeHeaders(req *http.Request) []byte {
-	app.hbuf.Reset()
-
-	// TODO(bradfitz): figure out :authority-vs-Host stuff between http2 and Go
-	host := req.Host
-	if host == "" {
-		host = req.URL.Host
-	}
-
-	path := req.RequestURI
-	if path == "" {
-		path = "/"
-	}
-
-	app.writeHeader(":authority", host) // probably not right for all sites
-	app.writeHeader(":method", req.Method)
-	app.writeHeader(":path", path)
-	app.writeHeader(":scheme", "https")
-
-	for k, vv := range req.Header {
-		lowKey := strings.ToLower(k)
-		if lowKey == "host" {
-			continue
-		}
-		for _, v := range vv {
-			app.writeHeader(lowKey, v)
-		}
-	}
-	return app.hbuf.Bytes()
-}
-
-func (app *h2i) writeHeader(name, value string) {
-	app.henc.WriteField(hpack.HeaderField{Name: name, Value: value})
-	app.logf(" %s = %s", name, value)
-}

vendor/golang.org/x/net/http2/headermap.go

@@ -1,78 +0,0 @@
-// Copyright 2014 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package http2
-
-import (
-	"net/http"
-	"strings"
-)
-
-var (
-	commonLowerHeader = map[string]string{} // Go-Canonical-Case -> lower-case
-	commonCanonHeader = map[string]string{} // lower-case -> Go-Canonical-Case
-)
-
-func init() {
-	for _, v := range []string{
-		"accept",
-		"accept-charset",
-		"accept-encoding",
-		"accept-language",
-		"accept-ranges",
-		"age",
-		"access-control-allow-origin",
-		"allow",
-		"authorization",
-		"cache-control",
-		"content-disposition",
-		"content-encoding",
-		"content-language",
-		"content-length",
-		"content-location",
-		"content-range",
-		"content-type",
-		"cookie",
-		"date",
-		"etag",
-		"expect",
-		"expires",
-		"from",
-		"host",
-		"if-match",
-		"if-modified-since",
-		"if-none-match",
-		"if-unmodified-since",
-		"last-modified",
-		"link",
-		"location",
-		"max-forwards",
-		"proxy-authenticate",
-		"proxy-authorization",
-		"range",
-		"referer",
-		"refresh",
-		"retry-after",
-		"server",
-		"set-cookie",
-		"strict-transport-security",
-		"trailer",
-		"transfer-encoding",
-		"user-agent",
-		"vary",
-		"via",
-		"www-authenticate",
-	} {
-		chk := http.CanonicalHeaderKey(v)
-		commonLowerHeader[chk] = v
-		commonCanonHeader[v] = chk
-	}
-}
-
-func lowerHeader(v string) string {
-	if s, ok := commonLowerHeader[v]; ok {
-		return s
-	}
-	return strings.ToLower(v)
-}

vendor/golang.org/x/net/http2/hpack/encode.go

@@ -1,240 +0,0 @@
-// Copyright 2014 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package hpack
-
-import (
-	"io"
-)
-
-const (
-	uint32Max              = ^uint32(0)
-	initialHeaderTableSize = 4096
-)
-
-type Encoder struct {
-	dynTab dynamicTable
-	// minSize is the minimum table size set by
-	// SetMaxDynamicTableSize after the previous Header Table Size
-	// Update.
-	minSize uint32
-	// maxSizeLimit is the maximum table size this encoder
-	// supports. This will protect the encoder from too large
-	// size.
-	maxSizeLimit uint32
-	// tableSizeUpdate indicates whether "Header Table Size
-	// Update" is required.
-	tableSizeUpdate bool
-	w               io.Writer
-	buf             []byte
-}
-
-// NewEncoder returns a new Encoder which performs HPACK encoding. An
-// encoded data is written to w.
-func NewEncoder(w io.Writer) *Encoder {
-	e := &Encoder{
-		minSize:         uint32Max,
-		maxSizeLimit:    initialHeaderTableSize,
-		tableSizeUpdate: false,
-		w:               w,
-	}
-	e.dynTab.table.init()
-	e.dynTab.setMaxSize(initialHeaderTableSize)
-	return e
-}
-
-// WriteField encodes f into a single Write to e's underlying Writer.
-// This function may also produce bytes for "Header Table Size Update"
-// if necessary. If produced, it is done before encoding f.
-func (e *Encoder) WriteField(f HeaderField) error {
-	e.buf = e.buf[:0]
-
-	if e.tableSizeUpdate {
-		e.tableSizeUpdate = false
-		if e.minSize < e.dynTab.maxSize {
-			e.buf = appendTableSize(e.buf, e.minSize)
-		}
-		e.minSize = uint32Max
-		e.buf = appendTableSize(e.buf, e.dynTab.maxSize)
-	}
-
-	idx, nameValueMatch := e.searchTable(f)
-	if nameValueMatch {
-		e.buf = appendIndexed(e.buf, idx)
-	} else {
-		indexing := e.shouldIndex(f)
-		if indexing {
-			e.dynTab.add(f)
-		}
-
-		if idx == 0 {
-			e.buf = appendNewName(e.buf, f, indexing)
-		} else {
-			e.buf = appendIndexedName(e.buf, f, idx, indexing)
-		}
-	}
-	n, err := e.w.Write(e.buf)
-	if err == nil && n != len(e.buf) {
-		err = io.ErrShortWrite
-	}
-	return err
-}
-
-// searchTable searches f in both stable and dynamic header tables.
-// The static header table is searched first. Only when there is no
-// exact match for both name and value, the dynamic header table is
-// then searched. If there is no match, i is 0. If both name and value
-// match, i is the matched index and nameValueMatch becomes true. If
-// only name matches, i points to that index and nameValueMatch
-// becomes false.
-func (e *Encoder) searchTable(f HeaderField) (i uint64, nameValueMatch bool) {
-	i, nameValueMatch = staticTable.search(f)
-	if nameValueMatch {
-		return i, true
-	}
-
-	j, nameValueMatch := e.dynTab.table.search(f)
-	if nameValueMatch || (i == 0 && j != 0) {
-		return j + uint64(staticTable.len()), nameValueMatch
-	}
-
-	return i, false
-}
-
-// SetMaxDynamicTableSize changes the dynamic header table size to v.
-// The actual size is bounded by the value passed to
-// SetMaxDynamicTableSizeLimit.
-func (e *Encoder) SetMaxDynamicTableSize(v uint32) {
-	if v > e.maxSizeLimit {
-		v = e.maxSizeLimit
-	}
-	if v < e.minSize {
-		e.minSize = v
-	}
-	e.tableSizeUpdate = true
-	e.dynTab.setMaxSize(v)
-}
-
-// SetMaxDynamicTableSizeLimit changes the maximum value that can be
-// specified in SetMaxDynamicTableSize to v. By default, it is set to
-// 4096, which is the same size of the default dynamic header table
-// size described in HPACK specification. If the current maximum
-// dynamic header table size is strictly greater than v, "Header Table
-// Size Update" will be done in the next WriteField call and the
-// maximum dynamic header table size is truncated to v.
-func (e *Encoder) SetMaxDynamicTableSizeLimit(v uint32) {
-	e.maxSizeLimit = v
-	if e.dynTab.maxSize > v {
-		e.tableSizeUpdate = true
-		e.dynTab.setMaxSize(v)
-	}
-}
-
-// shouldIndex reports whether f should be indexed.
-func (e *Encoder) shouldIndex(f HeaderField) bool {
-	return !f.Sensitive && f.Size() <= e.dynTab.maxSize
-}
-
-// appendIndexed appends index i, as encoded in "Indexed Header Field"
-// representation, to dst and returns the extended buffer.
-func appendIndexed(dst []byte, i uint64) []byte {
-	first := len(dst)
-	dst = appendVarInt(dst, 7, i)
-	dst[first] |= 0x80
-	return dst
-}
-
-// appendNewName appends f, as encoded in one of "Literal Header field
-// - New Name" representation variants, to dst and returns the
-// extended buffer.
-//
-// If f.Sensitive is true, "Never Indexed" representation is used. If
-// f.Sensitive is false and indexing is true, "Inremental Indexing"
-// representation is used.
-func appendNewName(dst []byte, f HeaderField, indexing bool) []byte {
-	dst = append(dst, encodeTypeByte(indexing, f.Sensitive))
-	dst = appendHpackString(dst, f.Name)
-	return appendHpackString(dst, f.Value)
-}
-
-// appendIndexedName appends f and index i referring indexed name
-// entry, as encoded in one of "Literal Header field - Indexed Name"
-// representation variants, to dst and returns the extended buffer.
-//
-// If f.Sensitive is true, "Never Indexed" representation is used. If
-// f.Sensitive is false and indexing is true, "Incremental Indexing"
-// representation is used.
-func appendIndexedName(dst []byte, f HeaderField, i uint64, indexing bool) []byte {
-	first := len(dst)
-	var n byte
-	if indexing {
-		n = 6
-	} else {
-		n = 4
-	}
-	dst = appendVarInt(dst, n, i)
-	dst[first] |= encodeTypeByte(indexing, f.Sensitive)
-	return appendHpackString(dst, f.Value)
-}
-
-// appendTableSize appends v, as encoded in "Header Table Size Update"
-// representation, to dst and returns the extended buffer.
-func appendTableSize(dst []byte, v uint32) []byte {
-	first := len(dst)
-	dst = appendVarInt(dst, 5, uint64(v))
-	dst[first] |= 0x20
-	return dst
-}
-
-// appendVarInt appends i, as encoded in variable integer form using n
-// bit prefix, to dst and returns the extended buffer.
-//
-// See
-// http://http2.github.io/http2-spec/compression.html#integer.representation
-func appendVarInt(dst []byte, n byte, i uint64) []byte {
-	k := uint64((1 << n) - 1)
-	if i < k {
-		return append(dst, byte(i))
-	}
-	dst = append(dst, byte(k))
-	i -= k
-	for ; i >= 128; i >>= 7 {
-		dst = append(dst, byte(0x80|(i&0x7f)))
-	}
-	return append(dst, byte(i))
-}
-
-// appendHpackString appends s, as encoded in "String Literal"
-// representation, to dst and returns the the extended buffer.
-//
-// s will be encoded in Huffman codes only when it produces strictly
-// shorter byte string.
-func appendHpackString(dst []byte, s string) []byte {
-	huffmanLength := HuffmanEncodeLength(s)
-	if huffmanLength < uint64(len(s)) {
-		first := len(dst)
-		dst = appendVarInt(dst, 7, huffmanLength)
-		dst = AppendHuffmanString(dst, s)
-		dst[first] |= 0x80
-	} else {
-		dst = appendVarInt(dst, 7, uint64(len(s)))
-		dst = append(dst, s...)
-	}
-	return dst
-}
-
-// encodeTypeByte returns type byte. If sensitive is true, type byte
-// for "Never Indexed" representation is returned. If sensitive is
-// false and indexing is true, type byte for "Incremental Indexing"
-// representation is returned. Otherwise, type byte for "Without
-// Indexing" is returned.
-func encodeTypeByte(indexing, sensitive bool) byte {
-	if sensitive {
-		return 0x10
-	}
-	if indexing {
-		return 0x40
-	}
-	return 0
-}

vendor/golang.org/x/net/http2/hpack/encode_test.go

@@ -1,386 +0,0 @@
-// Copyright 2014 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package hpack
-
-import (
-	"bytes"
-	"encoding/hex"
-	"fmt"
-	"math/rand"
-	"reflect"
-	"strings"
-	"testing"
-)
-
-func TestEncoderTableSizeUpdate(t *testing.T) {
-	tests := []struct {
-		size1, size2 uint32
-		wantHex      string
-	}{
-		// Should emit 2 table size updates (2048 and 4096)
-		{2048, 4096, "3fe10f 3fe11f 82"},
-
-		// Should emit 1 table size update (2048)
-		{16384, 2048, "3fe10f 82"},
-	}
-	for _, tt := range tests {
-		var buf bytes.Buffer
-		e := NewEncoder(&buf)
-		e.SetMaxDynamicTableSize(tt.size1)
-		e.SetMaxDynamicTableSize(tt.size2)
-		if err := e.WriteField(pair(":method", "GET")); err != nil {
-			t.Fatal(err)
-		}
-		want := removeSpace(tt.wantHex)
-		if got := hex.EncodeToString(buf.Bytes()); got != want {
-			t.Errorf("e.SetDynamicTableSize %v, %v = %q; want %q", tt.size1, tt.size2, got, want)
-		}
-	}
-}
-
-func TestEncoderWriteField(t *testing.T) {
-	var buf bytes.Buffer
-	e := NewEncoder(&buf)
-	var got []HeaderField
-	d := NewDecoder(4<<10, func(f HeaderField) {
-		got = append(got, f)
-	})
-
-	tests := []struct {
-		hdrs []HeaderField
-	}{
-		{[]HeaderField{
-			pair(":method", "GET"),
-			pair(":scheme", "http"),
-			pair(":path", "/"),
-			pair(":authority", "www.example.com"),
-		}},
-		{[]HeaderField{
-			pair(":method", "GET"),
-			pair(":scheme", "http"),
-			pair(":path", "/"),
-			pair(":authority", "www.example.com"),
-			pair("cache-control", "no-cache"),
-		}},
-		{[]HeaderField{
-			pair(":method", "GET"),
-			pair(":scheme", "https"),
-			pair(":path", "/index.html"),
-			pair(":authority", "www.example.com"),
-			pair("custom-key", "custom-value"),
-		}},
-	}
-	for i, tt := range tests {
-		buf.Reset()
-		got = got[:0]
-		for _, hf := range tt.hdrs {
-			if err := e.WriteField(hf); err != nil {
-				t.Fatal(err)
-			}
-		}
-		_, err := d.Write(buf.Bytes())
-		if err != nil {
-			t.Errorf("%d. Decoder Write = %v", i, err)
-		}
-		if !reflect.DeepEqual(got, tt.hdrs) {
-			t.Errorf("%d. Decoded %+v; want %+v", i, got, tt.hdrs)
-		}
-	}
-}
-
-func TestEncoderSearchTable(t *testing.T) {
-	e := NewEncoder(nil)
-
-	e.dynTab.add(pair("foo", "bar"))
-	e.dynTab.add(pair("blake", "miz"))
-	e.dynTab.add(pair(":method", "GET"))
-
-	tests := []struct {
-		hf        HeaderField
-		wantI     uint64
-		wantMatch bool
-	}{
-		// Name and Value match
-		{pair("foo", "bar"), uint64(staticTable.len()) + 3, true},
-		{pair("blake", "miz"), uint64(staticTable.len()) + 2, true},
-		{pair(":method", "GET"), 2, true},
-
-		// Only name match because Sensitive == true. This is allowed to match
-		// any ":method" entry. The current implementation uses the last entry
-		// added in newStaticTable.
-		{HeaderField{":method", "GET", true}, 3, false},
-
-		// Only Name matches
-		{pair("foo", "..."), uint64(staticTable.len()) + 3, false},
-		{pair("blake", "..."), uint64(staticTable.len()) + 2, false},
-		// As before, this is allowed to match any ":method" entry.
-		{pair(":method", "..."), 3, false},
-
-		// None match
-		{pair("foo-", "bar"), 0, false},
-	}
-	for _, tt := range tests {
-		if gotI, gotMatch := e.searchTable(tt.hf); gotI != tt.wantI || gotMatch != tt.wantMatch {
-			t.Errorf("d.search(%+v) = %v, %v; want %v, %v", tt.hf, gotI, gotMatch, tt.wantI, tt.wantMatch)
-		}
-	}
-}
-
-func TestAppendVarInt(t *testing.T) {
-	tests := []struct {
-		n    byte
-		i    uint64
-		want []byte
-	}{
-		// Fits in a byte:
-		{1, 0, []byte{0}},
-		{2, 2, []byte{2}},
-		{3, 6, []byte{6}},
-		{4, 14, []byte{14}},
-		{5, 30, []byte{30}},
-		{6, 62, []byte{62}},
-		{7, 126, []byte{126}},
-		{8, 254, []byte{254}},
-
-		// Multiple bytes:
-		{5, 1337, []byte{31, 154, 10}},
-	}
-	for _, tt := range tests {
-		got := appendVarInt(nil, tt.n, tt.i)
-		if !bytes.Equal(got, tt.want) {
-			t.Errorf("appendVarInt(nil, %v, %v) = %v; want %v", tt.n, tt.i, got, tt.want)
-		}
-	}
-}
-
-func TestAppendHpackString(t *testing.T) {
-	tests := []struct {
-		s, wantHex string
-	}{
-		// Huffman encoded
-		{"www.example.com", "8c f1e3 c2e5 f23a 6ba0 ab90 f4ff"},
-
-		// Not Huffman encoded
-		{"a", "01 61"},
-
-		// zero length
-		{"", "00"},
-	}
-	for _, tt := range tests {
-		want := removeSpace(tt.wantHex)
-		buf := appendHpackString(nil, tt.s)
-		if got := hex.EncodeToString(buf); want != got {
-			t.Errorf("appendHpackString(nil, %q) = %q; want %q", tt.s, got, want)
-		}
-	}
-}
-
-func TestAppendIndexed(t *testing.T) {
-	tests := []struct {
-		i       uint64
-		wantHex string
-	}{
-		// 1 byte
-		{1, "81"},
-		{126, "fe"},
-
-		// 2 bytes
-		{127, "ff00"},
-		{128, "ff01"},
-	}
-	for _, tt := range tests {
-		want := removeSpace(tt.wantHex)
-		buf := appendIndexed(nil, tt.i)
-		if got := hex.EncodeToString(buf); want != got {
-			t.Errorf("appendIndex(nil, %v) = %q; want %q", tt.i, got, want)
-		}
-	}
-}
-
-func TestAppendNewName(t *testing.T) {
-	tests := []struct {
-		f        HeaderField
-		indexing bool
-		wantHex  string
-	}{
-		// Incremental indexing
-		{HeaderField{"custom-key", "custom-value", false}, true, "40 88 25a8 49e9 5ba9 7d7f 89 25a8 49e9 5bb8 e8b4 bf"},
-
-		// Without indexing
-		{HeaderField{"custom-key", "custom-value", false}, false, "00 88 25a8 49e9 5ba9 7d7f 89 25a8 49e9 5bb8 e8b4 bf"},
-
-		// Never indexed
-		{HeaderField{"custom-key", "custom-value", true}, true, "10 88 25a8 49e9 5ba9 7d7f 89 25a8 49e9 5bb8 e8b4 bf"},
-		{HeaderField{"custom-key", "custom-value", true}, false, "10 88 25a8 49e9 5ba9 7d7f 89 25a8 49e9 5bb8 e8b4 bf"},
-	}
-	for _, tt := range tests {
-		want := removeSpace(tt.wantHex)
-		buf := appendNewName(nil, tt.f, tt.indexing)
-		if got := hex.EncodeToString(buf); want != got {
-			t.Errorf("appendNewName(nil, %+v, %v) = %q; want %q", tt.f, tt.indexing, got, want)
-		}
-	}
-}
-
-func TestAppendIndexedName(t *testing.T) {
-	tests := []struct {
-		f        HeaderField
-		i        uint64
-		indexing bool
-		wantHex  string
-	}{
-		// Incremental indexing
-		{HeaderField{":status", "302", false}, 8, true, "48 82 6402"},
-
-		// Without indexing
-		{HeaderField{":status", "302", false}, 8, false, "08 82 6402"},
-
-		// Never indexed
-		{HeaderField{":status", "302", true}, 8, true, "18 82 6402"},
-		{HeaderField{":status", "302", true}, 8, false, "18 82 6402"},
-	}
-	for _, tt := range tests {
-		want := removeSpace(tt.wantHex)
-		buf := appendIndexedName(nil, tt.f, tt.i, tt.indexing)
-		if got := hex.EncodeToString(buf); want != got {
-			t.Errorf("appendIndexedName(nil, %+v, %v) = %q; want %q", tt.f, tt.indexing, got, want)
-		}
-	}
-}
-
-func TestAppendTableSize(t *testing.T) {
-	tests := []struct {
-		i       uint32
-		wantHex string
-	}{
-		// Fits into 1 byte
-		{30, "3e"},
-
-		// Extra byte
-		{31, "3f00"},
-		{32, "3f01"},
-	}
-	for _, tt := range tests {
-		want := removeSpace(tt.wantHex)
-		buf := appendTableSize(nil, tt.i)
-		if got := hex.EncodeToString(buf); want != got {
-			t.Errorf("appendTableSize(nil, %v) = %q; want %q", tt.i, got, want)
-		}
-	}
-}
-
-func TestEncoderSetMaxDynamicTableSize(t *testing.T) {
-	var buf bytes.Buffer
-	e := NewEncoder(&buf)
-	tests := []struct {
-		v           uint32
-		wantUpdate  bool
-		wantMinSize uint32
-		wantMaxSize uint32
-	}{
-		// Set new table size to 2048
-		{2048, true, 2048, 2048},
-
-		// Set new table size to 16384, but still limited to
-		// 4096
-		{16384, true, 2048, 4096},
-	}
-	for _, tt := range tests {
-		e.SetMaxDynamicTableSize(tt.v)
-		if got := e.tableSizeUpdate; tt.wantUpdate != got {
-			t.Errorf("e.tableSizeUpdate = %v; want %v", got, tt.wantUpdate)
-		}
-		if got := e.minSize; tt.wantMinSize != got {
-			t.Errorf("e.minSize = %v; want %v", got, tt.wantMinSize)
-		}
-		if got := e.dynTab.maxSize; tt.wantMaxSize != got {
-			t.Errorf("e.maxSize = %v; want %v", got, tt.wantMaxSize)
-		}
-	}
-}
-
-func TestEncoderSetMaxDynamicTableSizeLimit(t *testing.T) {
-	e := NewEncoder(nil)
-	// 4095 < initialHeaderTableSize means maxSize is truncated to
-	// 4095.
-	e.SetMaxDynamicTableSizeLimit(4095)
-	if got, want := e.dynTab.maxSize, uint32(4095); got != want {
-		t.Errorf("e.dynTab.maxSize = %v; want %v", got, want)
-	}
-	if got, want := e.maxSizeLimit, uint32(4095); got != want {
-		t.Errorf("e.maxSizeLimit = %v; want %v", got, want)
-	}
-	if got, want := e.tableSizeUpdate, true; got != want {
-		t.Errorf("e.tableSizeUpdate = %v; want %v", got, want)
-	}
-	// maxSize will be truncated to maxSizeLimit
-	e.SetMaxDynamicTableSize(16384)
-	if got, want := e.dynTab.maxSize, uint32(4095); got != want {
-		t.Errorf("e.dynTab.maxSize = %v; want %v", got, want)
-	}
-	// 8192 > current maxSizeLimit, so maxSize does not change.
-	e.SetMaxDynamicTableSizeLimit(8192)
-	if got, want := e.dynTab.maxSize, uint32(4095); got != want {
-		t.Errorf("e.dynTab.maxSize = %v; want %v", got, want)
-	}
-	if got, want := e.maxSizeLimit, uint32(8192); got != want {
-		t.Errorf("e.maxSizeLimit = %v; want %v", got, want)
-	}
-}
-
-func removeSpace(s string) string {
-	return strings.Replace(s, " ", "", -1)
-}
-
-func BenchmarkEncoderSearchTable(b *testing.B) {
-	e := NewEncoder(nil)
-
-	// A sample of possible header fields.
-	// This is not based on any actual data from HTTP/2 traces.
-	var possible []HeaderField
-	for _, f := range staticTable.ents {
-		if f.Value == "" {
-			possible = append(possible, f)
-			continue
-		}
-		// Generate 5 random values, except for cookie and set-cookie,
-		// which we know can have many values in practice.
-		num := 5
-		if f.Name == "cookie" || f.Name == "set-cookie" {
-			num = 25
-		}
-		for i := 0; i < num; i++ {
-			f.Value = fmt.Sprintf("%s-%d", f.Name, i)
-			possible = append(possible, f)
-		}
-	}
-	for k := 0; k < 10; k++ {
-		f := HeaderField{
-			Name:      fmt.Sprintf("x-header-%d", k),
-			Sensitive: rand.Int()%2 == 0,
-		}
-		for i := 0; i < 5; i++ {
-			f.Value = fmt.Sprintf("%s-%d", f.Name, i)
-			possible = append(possible, f)
-		}
-	}
-
-	// Add a random sample to the dynamic table. This very loosely simulates
-	// a history of 100 requests with 20 header fields per request.
-	for r := 0; r < 100*20; r++ {
-		f := possible[rand.Int31n(int32(len(possible)))]
-		// Skip if this is in the staticTable verbatim.
-		if _, has := staticTable.search(f); !has {
-			e.dynTab.add(f)
-		}
-	}
-
-	b.ResetTimer()
-	for n := 0; n < b.N; n++ {
-		for _, f := range possible {
-			e.searchTable(f)
-		}
-	}
-}

vendor/golang.org/x/net/http2/hpack/hpack.go

@@ -1,490 +0,0 @@
-// Copyright 2014 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Package hpack implements HPACK, a compression format for
-// efficiently representing HTTP header fields in the context of HTTP/2.
-//
-// See http://tools.ietf.org/html/draft-ietf-httpbis-header-compression-09
-package hpack
-
-import (
-	"bytes"
-	"errors"
-	"fmt"
-)
-
-// A DecodingError is something the spec defines as a decoding error.
-type DecodingError struct {
-	Err error
-}
-
-func (de DecodingError) Error() string {
-	return fmt.Sprintf("decoding error: %v", de.Err)
-}
-
-// An InvalidIndexError is returned when an encoder references a table
-// entry before the static table or after the end of the dynamic table.
-type InvalidIndexError int
-
-func (e InvalidIndexError) Error() string {
-	return fmt.Sprintf("invalid indexed representation index %d", int(e))
-}
-
-// A HeaderField is a name-value pair. Both the name and value are
-// treated as opaque sequences of octets.
-type HeaderField struct {
-	Name, Value string
-
-	// Sensitive means that this header field should never be
-	// indexed.
-	Sensitive bool
-}
-
-// IsPseudo reports whether the header field is an http2 pseudo header.
-// That is, it reports whether it starts with a colon.
-// It is not otherwise guaranteed to be a valid pseudo header field,
-// though.
-func (hf HeaderField) IsPseudo() bool {
-	return len(hf.Name) != 0 && hf.Name[0] == ':'
-}
-
-func (hf HeaderField) String() string {
-	var suffix string
-	if hf.Sensitive {
-		suffix = " (sensitive)"
-	}
-	return fmt.Sprintf("header field %q = %q%s", hf.Name, hf.Value, suffix)
-}
-
-// Size returns the size of an entry per RFC 7541 section 4.1.
-func (hf HeaderField) Size() uint32 {
-	// http://http2.github.io/http2-spec/compression.html#rfc.section.4.1
-	// "The size of the dynamic table is the sum of the size of
-	// its entries. The size of an entry is the sum of its name's
-	// length in octets (as defined in Section 5.2), its value's
-	// length in octets (see Section 5.2), plus 32.  The size of
-	// an entry is calculated using the length of the name and
-	// value without any Huffman encoding applied."
-
-	// This can overflow if somebody makes a large HeaderField
-	// Name and/or Value by hand, but we don't care, because that
-	// won't happen on the wire because the encoding doesn't allow
-	// it.
-	return uint32(len(hf.Name) + len(hf.Value) + 32)
-}
-
-// A Decoder is the decoding context for incremental processing of
-// header blocks.
-type Decoder struct {
-	dynTab dynamicTable
-	emit   func(f HeaderField)
-
-	emitEnabled bool // whether calls to emit are enabled
-	maxStrLen   int  // 0 means unlimited
-
-	// buf is the unparsed buffer. It's only written to
-	// saveBuf if it was truncated in the middle of a header
-	// block. Because it's usually not owned, we can only
-	// process it under Write.
-	buf []byte // not owned; only valid during Write
-
-	// saveBuf is previous data passed to Write which we weren't able
-	// to fully parse before. Unlike buf, we own this data.
-	saveBuf bytes.Buffer
-}
-
-// NewDecoder returns a new decoder with the provided maximum dynamic
-// table size. The emitFunc will be called for each valid field
-// parsed, in the same goroutine as calls to Write, before Write returns.
-func NewDecoder(maxDynamicTableSize uint32, emitFunc func(f HeaderField)) *Decoder {
-	d := &Decoder{
-		emit:        emitFunc,
-		emitEnabled: true,
-	}
-	d.dynTab.table.init()
-	d.dynTab.allowedMaxSize = maxDynamicTableSize
-	d.dynTab.setMaxSize(maxDynamicTableSize)
-	return d
-}
-
-// ErrStringLength is returned by Decoder.Write when the max string length
-// (as configured by Decoder.SetMaxStringLength) would be violated.
-var ErrStringLength = errors.New("hpack: string too long")
-
-// SetMaxStringLength sets the maximum size of a HeaderField name or
-// value string. If a string exceeds this length (even after any
-// decompression), Write will return ErrStringLength.
-// A value of 0 means unlimited and is the default from NewDecoder.
-func (d *Decoder) SetMaxStringLength(n int) {
-	d.maxStrLen = n
-}
-
-// SetEmitFunc changes the callback used when new header fields
-// are decoded.
-// It must be non-nil. It does not affect EmitEnabled.
-func (d *Decoder) SetEmitFunc(emitFunc func(f HeaderField)) {
-	d.emit = emitFunc
-}
-
-// SetEmitEnabled controls whether the emitFunc provided to NewDecoder
-// should be called. The default is true.
-//
-// This facility exists to let servers enforce MAX_HEADER_LIST_SIZE
-// while still decoding and keeping in-sync with decoder state, but
-// without doing unnecessary decompression or generating unnecessary
-// garbage for header fields past the limit.
-func (d *Decoder) SetEmitEnabled(v bool) { d.emitEnabled = v }
-
-// EmitEnabled reports whether calls to the emitFunc provided to NewDecoder
-// are currently enabled. The default is true.
-func (d *Decoder) EmitEnabled() bool { return d.emitEnabled }
-
-// TODO: add method *Decoder.Reset(maxSize, emitFunc) to let callers re-use Decoders and their
-// underlying buffers for garbage reasons.
-
-func (d *Decoder) SetMaxDynamicTableSize(v uint32) {
-	d.dynTab.setMaxSize(v)
-}
-
-// SetAllowedMaxDynamicTableSize sets the upper bound that the encoded
-// stream (via dynamic table size updates) may set the maximum size
-// to.
-func (d *Decoder) SetAllowedMaxDynamicTableSize(v uint32) {
-	d.dynTab.allowedMaxSize = v
-}
-
-type dynamicTable struct {
-	// http://http2.github.io/http2-spec/compression.html#rfc.section.2.3.2
-	table          headerFieldTable
-	size           uint32 // in bytes
-	maxSize        uint32 // current maxSize
-	allowedMaxSize uint32 // maxSize may go up to this, inclusive
-}
-
-func (dt *dynamicTable) setMaxSize(v uint32) {
-	dt.maxSize = v
-	dt.evict()
-}
-
-func (dt *dynamicTable) add(f HeaderField) {
-	dt.table.addEntry(f)
-	dt.size += f.Size()
-	dt.evict()
-}
-
-// If we're too big, evict old stuff.
-func (dt *dynamicTable) evict() {
-	var n int
-	for dt.size > dt.maxSize && n < dt.table.len() {
-		dt.size -= dt.table.ents[n].Size()
-		n++
-	}
-	dt.table.evictOldest(n)
-}
-
-func (d *Decoder) maxTableIndex() int {
-	// This should never overflow. RFC 7540 Section 6.5.2 limits the size of
-	// the dynamic table to 2^32 bytes, where each entry will occupy more than
-	// one byte. Further, the staticTable has a fixed, small length.
-	return d.dynTab.table.len() + staticTable.len()
-}
-
-func (d *Decoder) at(i uint64) (hf HeaderField, ok bool) {
-	// See Section 2.3.3.
-	if i == 0 {
-		return
-	}
-	if i <= uint64(staticTable.len()) {
-		return staticTable.ents[i-1], true
-	}
-	if i > uint64(d.maxTableIndex()) {
-		return
-	}
-	// In the dynamic table, newer entries have lower indices.
-	// However, dt.ents[0] is the oldest entry. Hence, dt.ents is
-	// the reversed dynamic table.
-	dt := d.dynTab.table
-	return dt.ents[dt.len()-(int(i)-staticTable.len())], true
-}
-
-// Decode decodes an entire block.
-//
-// TODO: remove this method and make it incremental later? This is
-// easier for debugging now.
-func (d *Decoder) DecodeFull(p []byte) ([]HeaderField, error) {
-	var hf []HeaderField
-	saveFunc := d.emit
-	defer func() { d.emit = saveFunc }()
-	d.emit = func(f HeaderField) { hf = append(hf, f) }
-	if _, err := d.Write(p); err != nil {
-		return nil, err
-	}
-	if err := d.Close(); err != nil {
-		return nil, err
-	}
-	return hf, nil
-}
-
-func (d *Decoder) Close() error {
-	if d.saveBuf.Len() > 0 {
-		d.saveBuf.Reset()
-		return DecodingError{errors.New("truncated headers")}
-	}
-	return nil
-}
-
-func (d *Decoder) Write(p []byte) (n int, err error) {
-	if len(p) == 0 {
-		// Prevent state machine CPU attacks (making us redo
-		// work up to the point of finding out we don't have
-		// enough data)
-		return
-	}
-	// Only copy the data if we have to. Optimistically assume
-	// that p will contain a complete header block.
-	if d.saveBuf.Len() == 0 {
-		d.buf = p
-	} else {
-		d.saveBuf.Write(p)
-		d.buf = d.saveBuf.Bytes()
-		d.saveBuf.Reset()
-	}
-
-	for len(d.buf) > 0 {
-		err = d.parseHeaderFieldRepr()
-		if err == errNeedMore {
-			// Extra paranoia, making sure saveBuf won't
-			// get too large. All the varint and string
-			// reading code earlier should already catch
-			// overlong things and return ErrStringLength,
-			// but keep this as a last resort.
-			const varIntOverhead = 8 // conservative
-			if d.maxStrLen != 0 && int64(len(d.buf)) > 2*(int64(d.maxStrLen)+varIntOverhead) {
-				return 0, ErrStringLength
-			}
-			d.saveBuf.Write(d.buf)
-			return len(p), nil
-		}
-		if err != nil {
-			break
-		}
-	}
-	return len(p), err
-}
-
-// errNeedMore is an internal sentinel error value that means the
-// buffer is truncated and we need to read more data before we can
-// continue parsing.
-var errNeedMore = errors.New("need more data")
-
-type indexType int
-
-const (
-	indexedTrue indexType = iota
-	indexedFalse
-	indexedNever
-)
-
-func (v indexType) indexed() bool   { return v == indexedTrue }
-func (v indexType) sensitive() bool { return v == indexedNever }
-
-// returns errNeedMore if there isn't enough data available.
-// any other error is fatal.
-// consumes d.buf iff it returns nil.
-// precondition: must be called with len(d.buf) > 0
-func (d *Decoder) parseHeaderFieldRepr() error {
-	b := d.buf[0]
-	switch {
-	case b&128 != 0:
-		// Indexed representation.
-		// High bit set?
-		// http://http2.github.io/http2-spec/compression.html#rfc.section.6.1
-		return d.parseFieldIndexed()
-	case b&192 == 64:
-		// 6.2.1 Literal Header Field with Incremental Indexing
-		// 0b10xxxxxx: top two bits are 10
-		// http://http2.github.io/http2-spec/compression.html#rfc.section.6.2.1
-		return d.parseFieldLiteral(6, indexedTrue)
-	case b&240 == 0:
-		// 6.2.2 Literal Header Field without Indexing
-		// 0b0000xxxx: top four bits are 0000
-		// http://http2.github.io/http2-spec/compression.html#rfc.section.6.2.2
-		return d.parseFieldLiteral(4, indexedFalse)
-	case b&240 == 16:
-		// 6.2.3 Literal Header Field never Indexed
-		// 0b0001xxxx: top four bits are 0001
-		// http://http2.github.io/http2-spec/compression.html#rfc.section.6.2.3
-		return d.parseFieldLiteral(4, indexedNever)
-	case b&224 == 32:
-		// 6.3 Dynamic Table Size Update
-		// Top three bits are '001'.
-		// http://http2.github.io/http2-spec/compression.html#rfc.section.6.3
-		return d.parseDynamicTableSizeUpdate()
-	}
-
-	return DecodingError{errors.New("invalid encoding")}
-}
-
-// (same invariants and behavior as parseHeaderFieldRepr)
-func (d *Decoder) parseFieldIndexed() error {
-	buf := d.buf
-	idx, buf, err := readVarInt(7, buf)
-	if err != nil {
-		return err
-	}
-	hf, ok := d.at(idx)
-	if !ok {
-		return DecodingError{InvalidIndexError(idx)}
-	}
-	d.buf = buf
-	return d.callEmit(HeaderField{Name: hf.Name, Value: hf.Value})
-}
-
-// (same invariants and behavior as parseHeaderFieldRepr)
-func (d *Decoder) parseFieldLiteral(n uint8, it indexType) error {
-	buf := d.buf
-	nameIdx, buf, err := readVarInt(n, buf)
-	if err != nil {
-		return err
-	}
-
-	var hf HeaderField
-	wantStr := d.emitEnabled || it.indexed()
-	if nameIdx > 0 {
-		ihf, ok := d.at(nameIdx)
-		if !ok {
-			return DecodingError{InvalidIndexError(nameIdx)}
-		}
-		hf.Name = ihf.Name
-	} else {
-		hf.Name, buf, err = d.readString(buf, wantStr)
-		if err != nil {
-			return err
-		}
-	}
-	hf.Value, buf, err = d.readString(buf, wantStr)
-	if err != nil {
-		return err
-	}
-	d.buf = buf
-	if it.indexed() {
-		d.dynTab.add(hf)
-	}
-	hf.Sensitive = it.sensitive()
-	return d.callEmit(hf)
-}
-
-func (d *Decoder) callEmit(hf HeaderField) error {
-	if d.maxStrLen != 0 {
-		if len(hf.Name) > d.maxStrLen || len(hf.Value) > d.maxStrLen {
-			return ErrStringLength
-		}
-	}
-	if d.emitEnabled {
-		d.emit(hf)
-	}
-	return nil
-}
-
-// (same invariants and behavior as parseHeaderFieldRepr)
-func (d *Decoder) parseDynamicTableSizeUpdate() error {
-	buf := d.buf
-	size, buf, err := readVarInt(5, buf)
-	if err != nil {
-		return err
-	}
-	if size > uint64(d.dynTab.allowedMaxSize) {
-		return DecodingError{errors.New("dynamic table size update too large")}
-	}
-	d.dynTab.setMaxSize(uint32(size))
-	d.buf = buf
-	return nil
-}
-
-var errVarintOverflow = DecodingError{errors.New("varint integer overflow")}
-
-// readVarInt reads an unsigned variable length integer off the
-// beginning of p. n is the parameter as described in
-// http://http2.github.io/http2-spec/compression.html#rfc.section.5.1.
-//
-// n must always be between 1 and 8.
-//
-// The returned remain buffer is either a smaller suffix of p, or err != nil.
-// The error is errNeedMore if p doesn't contain a complete integer.
-func readVarInt(n byte, p []byte) (i uint64, remain []byte, err error) {
-	if n < 1 || n > 8 {
-		panic("bad n")
-	}
-	if len(p) == 0 {
-		return 0, p, errNeedMore
-	}
-	i = uint64(p[0])
-	if n < 8 {
-		i &= (1 << uint64(n)) - 1
-	}
-	if i < (1<<uint64(n))-1 {
-		return i, p[1:], nil
-	}
-
-	origP := p
-	p = p[1:]
-	var m uint64
-	for len(p) > 0 {
-		b := p[0]
-		p = p[1:]
-		i += uint64(b&127) << m
-		if b&128 == 0 {
-			return i, p, nil
-		}
-		m += 7
-		if m >= 63 { // TODO: proper overflow check. making this up.
-			return 0, origP, errVarintOverflow
-		}
-	}
-	return 0, origP, errNeedMore
-}
-
-// readString decodes an hpack string from p.
-//
-// wantStr is whether s will be used. If false, decompression and
-// []byte->string garbage are skipped if s will be ignored
-// anyway. This does mean that huffman decoding errors for non-indexed
-// strings past the MAX_HEADER_LIST_SIZE are ignored, but the server
-// is returning an error anyway, and because they're not indexed, the error
-// won't affect the decoding state.
-func (d *Decoder) readString(p []byte, wantStr bool) (s string, remain []byte, err error) {
-	if len(p) == 0 {
-		return "", p, errNeedMore
-	}
-	isHuff := p[0]&128 != 0
-	strLen, p, err := readVarInt(7, p)
-	if err != nil {
-		return "", p, err
-	}
-	if d.maxStrLen != 0 && strLen > uint64(d.maxStrLen) {
-		return "", nil, ErrStringLength
-	}
-	if uint64(len(p)) < strLen {
-		return "", p, errNeedMore
-	}
-	if !isHuff {
-		if wantStr {
-			s = string(p[:strLen])
-		}
-		return s, p[strLen:], nil
-	}
-
-	if wantStr {
-		buf := bufPool.Get().(*bytes.Buffer)
-		buf.Reset() // don't trust others
-		defer bufPool.Put(buf)
-		if err := huffmanDecode(buf, d.maxStrLen, p[:strLen]); err != nil {
-			buf.Reset()
-			return "", nil, err
-		}
-		s = buf.String()
-		buf.Reset() // be nice to GC
-	}
-	return s, p[strLen:], nil
-}

vendor/golang.org/x/net/http2/hpack/hpack_test.go

@@ -1,722 +0,0 @@
-// Copyright 2014 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package hpack
-
-import (
-	"bytes"
-	"encoding/hex"
-	"fmt"
-	"math/rand"
-	"reflect"
-	"strings"
-	"testing"
-	"time"
-)
-
-func (d *Decoder) mustAt(idx int) HeaderField {
-	if hf, ok := d.at(uint64(idx)); !ok {
-		panic(fmt.Sprintf("bogus index %d", idx))
-	} else {
-		return hf
-	}
-}
-
-func TestDynamicTableAt(t *testing.T) {
-	d := NewDecoder(4096, nil)
-	at := d.mustAt
-	if got, want := at(2), (pair(":method", "GET")); got != want {
-		t.Errorf("at(2) = %v; want %v", got, want)
-	}
-	d.dynTab.add(pair("foo", "bar"))
-	d.dynTab.add(pair("blake", "miz"))
-	if got, want := at(staticTable.len()+1), (pair("blake", "miz")); got != want {
-		t.Errorf("at(dyn 1) = %v; want %v", got, want)
-	}
-	if got, want := at(staticTable.len()+2), (pair("foo", "bar")); got != want {
-		t.Errorf("at(dyn 2) = %v; want %v", got, want)
-	}
-	if got, want := at(3), (pair(":method", "POST")); got != want {
-		t.Errorf("at(3) = %v; want %v", got, want)
-	}
-}
-
-func TestDynamicTableSizeEvict(t *testing.T) {
-	d := NewDecoder(4096, nil)
-	if want := uint32(0); d.dynTab.size != want {
-		t.Fatalf("size = %d; want %d", d.dynTab.size, want)
-	}
-	add := d.dynTab.add
-	add(pair("blake", "eats pizza"))
-	if want := uint32(15 + 32); d.dynTab.size != want {
-		t.Fatalf("after pizza, size = %d; want %d", d.dynTab.size, want)
-	}
-	add(pair("foo", "bar"))
-	if want := uint32(15 + 32 + 6 + 32); d.dynTab.size != want {
-		t.Fatalf("after foo bar, size = %d; want %d", d.dynTab.size, want)
-	}
-	d.dynTab.setMaxSize(15 + 32 + 1 /* slop */)
-	if want := uint32(6 + 32); d.dynTab.size != want {
-		t.Fatalf("after setMaxSize, size = %d; want %d", d.dynTab.size, want)
-	}
-	if got, want := d.mustAt(staticTable.len()+1), (pair("foo", "bar")); got != want {
-		t.Errorf("at(dyn 1) = %v; want %v", got, want)
-	}
-	add(pair("long", strings.Repeat("x", 500)))
-	if want := uint32(0); d.dynTab.size != want {
-		t.Fatalf("after big one, size = %d; want %d", d.dynTab.size, want)
-	}
-}
-
-func TestDecoderDecode(t *testing.T) {
-	tests := []struct {
-		name       string
-		in         []byte
-		want       []HeaderField
-		wantDynTab []HeaderField // newest entry first
-	}{
-		// C.2.1 Literal Header Field with Indexing
-		// http://http2.github.io/http2-spec/compression.html#rfc.section.C.2.1
-		{"C.2.1", dehex("400a 6375 7374 6f6d 2d6b 6579 0d63 7573 746f 6d2d 6865 6164 6572"),
-			[]HeaderField{pair("custom-key", "custom-header")},
-			[]HeaderField{pair("custom-key", "custom-header")},
-		},
-
-		// C.2.2 Literal Header Field without Indexing
-		// http://http2.github.io/http2-spec/compression.html#rfc.section.C.2.2
-		{"C.2.2", dehex("040c 2f73 616d 706c 652f 7061 7468"),
-			[]HeaderField{pair(":path", "/sample/path")},
-			[]HeaderField{}},
-
-		// C.2.3 Literal Header Field never Indexed
-		// http://http2.github.io/http2-spec/compression.html#rfc.section.C.2.3
-		{"C.2.3", dehex("1008 7061 7373 776f 7264 0673 6563 7265 74"),
-			[]HeaderField{{"password", "secret", true}},
-			[]HeaderField{}},
-
-		// C.2.4 Indexed Header Field
-		// http://http2.github.io/http2-spec/compression.html#rfc.section.C.2.4
-		{"C.2.4", []byte("\x82"),
-			[]HeaderField{pair(":method", "GET")},
-			[]HeaderField{}},
-	}
-	for _, tt := range tests {
-		d := NewDecoder(4096, nil)
-		hf, err := d.DecodeFull(tt.in)
-		if err != nil {
-			t.Errorf("%s: %v", tt.name, err)
-			continue
-		}
-		if !reflect.DeepEqual(hf, tt.want) {
-			t.Errorf("%s: Got %v; want %v", tt.name, hf, tt.want)
-		}
-		gotDynTab := d.dynTab.reverseCopy()
-		if !reflect.DeepEqual(gotDynTab, tt.wantDynTab) {
-			t.Errorf("%s: dynamic table after = %v; want %v", tt.name, gotDynTab, tt.wantDynTab)
-		}
-	}
-}
-
-func (dt *dynamicTable) reverseCopy() (hf []HeaderField) {
-	hf = make([]HeaderField, len(dt.table.ents))
-	for i := range hf {
-		hf[i] = dt.table.ents[len(dt.table.ents)-1-i]
-	}
-	return
-}
-
-type encAndWant struct {
-	enc         []byte
-	want        []HeaderField
-	wantDynTab  []HeaderField
-	wantDynSize uint32
-}
-
-// C.3 Request Examples without Huffman Coding
-// http://http2.github.io/http2-spec/compression.html#rfc.section.C.3
-func TestDecodeC3_NoHuffman(t *testing.T) {
-	testDecodeSeries(t, 4096, []encAndWant{
-		{dehex("8286 8441 0f77 7777 2e65 7861 6d70 6c65 2e63 6f6d"),
-			[]HeaderField{
-				pair(":method", "GET"),
-				pair(":scheme", "http"),
-				pair(":path", "/"),
-				pair(":authority", "www.example.com"),
-			},
-			[]HeaderField{
-				pair(":authority", "www.example.com"),
-			},
-			57,
-		},
-		{dehex("8286 84be 5808 6e6f 2d63 6163 6865"),
-			[]HeaderField{
-				pair(":method", "GET"),
-				pair(":scheme", "http"),
-				pair(":path", "/"),
-				pair(":authority", "www.example.com"),
-				pair("cache-control", "no-cache"),
-			},
-			[]HeaderField{
-				pair("cache-control", "no-cache"),
-				pair(":authority", "www.example.com"),
-			},
-			110,
-		},
-		{dehex("8287 85bf 400a 6375 7374 6f6d 2d6b 6579 0c63 7573 746f 6d2d 7661 6c75 65"),
-			[]HeaderField{
-				pair(":method", "GET"),
-				pair(":scheme", "https"),
-				pair(":path", "/index.html"),
-				pair(":authority", "www.example.com"),
-				pair("custom-key", "custom-value"),
-			},
-			[]HeaderField{
-				pair("custom-key", "custom-value"),
-				pair("cache-control", "no-cache"),
-				pair(":authority", "www.example.com"),
-			},
-			164,
-		},
-	})
-}
-
-// C.4 Request Examples with Huffman Coding
-// http://http2.github.io/http2-spec/compression.html#rfc.section.C.4
-func TestDecodeC4_Huffman(t *testing.T) {
-	testDecodeSeries(t, 4096, []encAndWant{
-		{dehex("8286 8441 8cf1 e3c2 e5f2 3a6b a0ab 90f4 ff"),
-			[]HeaderField{
-				pair(":method", "GET"),
-				pair(":scheme", "http"),
-				pair(":path", "/"),
-				pair(":authority", "www.example.com"),
-			},
-			[]HeaderField{
-				pair(":authority", "www.example.com"),
-			},
-			57,
-		},
-		{dehex("8286 84be 5886 a8eb 1064 9cbf"),
-			[]HeaderField{
-				pair(":method", "GET"),
-				pair(":scheme", "http"),
-				pair(":path", "/"),
-				pair(":authority", "www.example.com"),
-				pair("cache-control", "no-cache"),
-			},
-			[]HeaderField{
-				pair("cache-control", "no-cache"),
-				pair(":authority", "www.example.com"),
-			},
-			110,
-		},
-		{dehex("8287 85bf 4088 25a8 49e9 5ba9 7d7f 8925 a849 e95b b8e8 b4bf"),
-			[]HeaderField{
-				pair(":method", "GET"),
-				pair(":scheme", "https"),
-				pair(":path", "/index.html"),
-				pair(":authority", "www.example.com"),
-				pair("custom-key", "custom-value"),
-			},
-			[]HeaderField{
-				pair("custom-key", "custom-value"),
-				pair("cache-control", "no-cache"),
-				pair(":authority", "www.example.com"),
-			},
-			164,
-		},
-	})
-}
-
-// http://http2.github.io/http2-spec/compression.html#rfc.section.C.5
-// "This section shows several consecutive header lists, corresponding
-// to HTTP responses, on the same connection. The HTTP/2 setting
-// parameter SETTINGS_HEADER_TABLE_SIZE is set to the value of 256
-// octets, causing some evictions to occur."
-func TestDecodeC5_ResponsesNoHuff(t *testing.T) {
-	testDecodeSeries(t, 256, []encAndWant{
-		{dehex(`
-4803 3330 3258 0770 7269 7661 7465 611d
-4d6f 6e2c 2032 3120 4f63 7420 3230 3133
-2032 303a 3133 3a32 3120 474d 546e 1768
-7474 7073 3a2f 2f77 7777 2e65 7861 6d70
-6c65 2e63 6f6d
-`),
-			[]HeaderField{
-				pair(":status", "302"),
-				pair("cache-control", "private"),
-				pair("date", "Mon, 21 Oct 2013 20:13:21 GMT"),
-				pair("location", "https://www.example.com"),
-			},
-			[]HeaderField{
-				pair("location", "https://www.example.com"),
-				pair("date", "Mon, 21 Oct 2013 20:13:21 GMT"),
-				pair("cache-control", "private"),
-				pair(":status", "302"),
-			},
-			222,
-		},
-		{dehex("4803 3330 37c1 c0bf"),
-			[]HeaderField{
-				pair(":status", "307"),
-				pair("cache-control", "private"),
-				pair("date", "Mon, 21 Oct 2013 20:13:21 GMT"),
-				pair("location", "https://www.example.com"),
-			},
-			[]HeaderField{
-				pair(":status", "307"),
-				pair("location", "https://www.example.com"),
-				pair("date", "Mon, 21 Oct 2013 20:13:21 GMT"),
-				pair("cache-control", "private"),
-			},
-			222,
-		},
-		{dehex(`
-88c1 611d 4d6f 6e2c 2032 3120 4f63 7420
-3230 3133 2032 303a 3133 3a32 3220 474d
-54c0 5a04 677a 6970 7738 666f 6f3d 4153
-444a 4b48 514b 425a 584f 5157 454f 5049
-5541 5851 5745 4f49 553b 206d 6178 2d61
-6765 3d33 3630 303b 2076 6572 7369 6f6e
-3d31
-`),
-			[]HeaderField{
-				pair(":status", "200"),
-				pair("cache-control", "private"),
-				pair("date", "Mon, 21 Oct 2013 20:13:22 GMT"),
-				pair("location", "https://www.example.com"),
-				pair("content-encoding", "gzip"),
-				pair("set-cookie", "foo=ASDJKHQKBZXOQWEOPIUAXQWEOIU; max-age=3600; version=1"),
-			},
-			[]HeaderField{
-				pair("set-cookie", "foo=ASDJKHQKBZXOQWEOPIUAXQWEOIU; max-age=3600; version=1"),
-				pair("content-encoding", "gzip"),
-				pair("date", "Mon, 21 Oct 2013 20:13:22 GMT"),
-			},
-			215,
-		},
-	})
-}
-
-// http://http2.github.io/http2-spec/compression.html#rfc.section.C.6
-// "This section shows the same examples as the previous section, but
-// using Huffman encoding for the literal values. The HTTP/2 setting
-// parameter SETTINGS_HEADER_TABLE_SIZE is set to the value of 256
-// octets, causing some evictions to occur. The eviction mechanism
-// uses the length of the decoded literal values, so the same
-// evictions occurs as in the previous section."
-func TestDecodeC6_ResponsesHuffman(t *testing.T) {
-	testDecodeSeries(t, 256, []encAndWant{
-		{dehex(`
-4882 6402 5885 aec3 771a 4b61 96d0 7abe
-9410 54d4 44a8 2005 9504 0b81 66e0 82a6
-2d1b ff6e 919d 29ad 1718 63c7 8f0b 97c8
-e9ae 82ae 43d3
-`),
-			[]HeaderField{
-				pair(":status", "302"),
-				pair("cache-control", "private"),
-				pair("date", "Mon, 21 Oct 2013 20:13:21 GMT"),
-				pair("location", "https://www.example.com"),
-			},
-			[]HeaderField{
-				pair("location", "https://www.example.com"),
-				pair("date", "Mon, 21 Oct 2013 20:13:21 GMT"),
-				pair("cache-control", "private"),
-				pair(":status", "302"),
-			},
-			222,
-		},
-		{dehex("4883 640e ffc1 c0bf"),
-			[]HeaderField{
-				pair(":status", "307"),
-				pair("cache-control", "private"),
-				pair("date", "Mon, 21 Oct 2013 20:13:21 GMT"),
-				pair("location", "https://www.example.com"),
-			},
-			[]HeaderField{
-				pair(":status", "307"),
-				pair("location", "https://www.example.com"),
-				pair("date", "Mon, 21 Oct 2013 20:13:21 GMT"),
-				pair("cache-control", "private"),
-			},
-			222,
-		},
-		{dehex(`
-88c1 6196 d07a be94 1054 d444 a820 0595
-040b 8166 e084 a62d 1bff c05a 839b d9ab
-77ad 94e7 821d d7f2 e6c7 b335 dfdf cd5b
-3960 d5af 2708 7f36 72c1 ab27 0fb5 291f
-9587 3160 65c0 03ed 4ee5 b106 3d50 07
-`),
-			[]HeaderField{
-				pair(":status", "200"),
-				pair("cache-control", "private"),
-				pair("date", "Mon, 21 Oct 2013 20:13:22 GMT"),
-				pair("location", "https://www.example.com"),
-				pair("content-encoding", "gzip"),
-				pair("set-cookie", "foo=ASDJKHQKBZXOQWEOPIUAXQWEOIU; max-age=3600; version=1"),
-			},
-			[]HeaderField{
-				pair("set-cookie", "foo=ASDJKHQKBZXOQWEOPIUAXQWEOIU; max-age=3600; version=1"),
-				pair("content-encoding", "gzip"),
-				pair("date", "Mon, 21 Oct 2013 20:13:22 GMT"),
-			},
-			215,
-		},
-	})
-}
-
-func testDecodeSeries(t *testing.T, size uint32, steps []encAndWant) {
-	d := NewDecoder(size, nil)
-	for i, step := range steps {
-		hf, err := d.DecodeFull(step.enc)
-		if err != nil {
-			t.Fatalf("Error at step index %d: %v", i, err)
-		}
-		if !reflect.DeepEqual(hf, step.want) {
-			t.Fatalf("At step index %d: Got headers %v; want %v", i, hf, step.want)
-		}
-		gotDynTab := d.dynTab.reverseCopy()
-		if !reflect.DeepEqual(gotDynTab, step.wantDynTab) {
-			t.Errorf("After step index %d, dynamic table = %v; want %v", i, gotDynTab, step.wantDynTab)
-		}
-		if d.dynTab.size != step.wantDynSize {
-			t.Errorf("After step index %d, dynamic table size = %v; want %v", i, d.dynTab.size, step.wantDynSize)
-		}
-	}
-}
-
-func TestHuffmanDecodeExcessPadding(t *testing.T) {
-	tests := [][]byte{
-		{0xff},                                   // Padding Exceeds 7 bits
-		{0x1f, 0xff},                             // {"a", 1 byte excess padding}
-		{0x1f, 0xff, 0xff},                       // {"a", 2 byte excess padding}
-		{0x1f, 0xff, 0xff, 0xff},                 // {"a", 3 byte excess padding}
-		{0xff, 0x9f, 0xff, 0xff, 0xff},           // {"a", 29 bit excess padding}
-		{'R', 0xbc, '0', 0xff, 0xff, 0xff, 0xff}, // Padding ends on partial symbol.
-	}
-	for i, in := range tests {
-		var buf bytes.Buffer
-		if _, err := HuffmanDecode(&buf, in); err != ErrInvalidHuffman {
-			t.Errorf("test-%d: decode(%q) = %v; want ErrInvalidHuffman", i, in, err)
-		}
-	}
-}
-
-func TestHuffmanDecodeEOS(t *testing.T) {
-	in := []byte{0xff, 0xff, 0xff, 0xff, 0xfc} // {EOS, "?"}
-	var buf bytes.Buffer
-	if _, err := HuffmanDecode(&buf, in); err != ErrInvalidHuffman {
-		t.Errorf("error = %v; want ErrInvalidHuffman", err)
-	}
-}
-
-func TestHuffmanDecodeMaxLengthOnTrailingByte(t *testing.T) {
-	in := []byte{0x00, 0x01} // {"0", "0", "0"}
-	var buf bytes.Buffer
-	if err := huffmanDecode(&buf, 2, in); err != ErrStringLength {
-		t.Errorf("error = %v; want ErrStringLength", err)
-	}
-}
-
-func TestHuffmanDecodeCorruptPadding(t *testing.T) {
-	in := []byte{0x00}
-	var buf bytes.Buffer
-	if _, err := HuffmanDecode(&buf, in); err != ErrInvalidHuffman {
-		t.Errorf("error = %v; want ErrInvalidHuffman", err)
-	}
-}
-
-func TestHuffmanDecode(t *testing.T) {
-	tests := []struct {
-		inHex, want string
-	}{
-		{"f1e3 c2e5 f23a 6ba0 ab90 f4ff", "www.example.com"},
-		{"a8eb 1064 9cbf", "no-cache"},
-		{"25a8 49e9 5ba9 7d7f", "custom-key"},
-		{"25a8 49e9 5bb8 e8b4 bf", "custom-value"},
-		{"6402", "302"},
-		{"aec3 771a 4b", "private"},
-		{"d07a be94 1054 d444 a820 0595 040b 8166 e082 a62d 1bff", "Mon, 21 Oct 2013 20:13:21 GMT"},
-		{"9d29 ad17 1863 c78f 0b97 c8e9 ae82 ae43 d3", "https://www.example.com"},
-		{"9bd9 ab", "gzip"},
-		{"94e7 821d d7f2 e6c7 b335 dfdf cd5b 3960 d5af 2708 7f36 72c1 ab27 0fb5 291f 9587 3160 65c0 03ed 4ee5 b106 3d50 07",
-			"foo=ASDJKHQKBZXOQWEOPIUAXQWEOIU; max-age=3600; version=1"},
-	}
-	for i, tt := range tests {
-		var buf bytes.Buffer
-		in, err := hex.DecodeString(strings.Replace(tt.inHex, " ", "", -1))
-		if err != nil {
-			t.Errorf("%d. hex input error: %v", i, err)
-			continue
-		}
-		if _, err := HuffmanDecode(&buf, in); err != nil {
-			t.Errorf("%d. decode error: %v", i, err)
-			continue
-		}
-		if got := buf.String(); tt.want != got {
-			t.Errorf("%d. decode = %q; want %q", i, got, tt.want)
-		}
-	}
-}
-
-func TestAppendHuffmanString(t *testing.T) {
-	tests := []struct {
-		in, want string
-	}{
-		{"www.example.com", "f1e3 c2e5 f23a 6ba0 ab90 f4ff"},
-		{"no-cache", "a8eb 1064 9cbf"},
-		{"custom-key", "25a8 49e9 5ba9 7d7f"},
-		{"custom-value", "25a8 49e9 5bb8 e8b4 bf"},
-		{"302", "6402"},
-		{"private", "aec3 771a 4b"},
-		{"Mon, 21 Oct 2013 20:13:21 GMT", "d07a be94 1054 d444 a820 0595 040b 8166 e082 a62d 1bff"},
-		{"https://www.example.com", "9d29 ad17 1863 c78f 0b97 c8e9 ae82 ae43 d3"},
-		{"gzip", "9bd9 ab"},
-		{"foo=ASDJKHQKBZXOQWEOPIUAXQWEOIU; max-age=3600; version=1",
-			"94e7 821d d7f2 e6c7 b335 dfdf cd5b 3960 d5af 2708 7f36 72c1 ab27 0fb5 291f 9587 3160 65c0 03ed 4ee5 b106 3d50 07"},
-	}
-	for i, tt := range tests {
-		buf := []byte{}
-		want := strings.Replace(tt.want, " ", "", -1)
-		buf = AppendHuffmanString(buf, tt.in)
-		if got := hex.EncodeToString(buf); want != got {
-			t.Errorf("%d. encode = %q; want %q", i, got, want)
-		}
-	}
-}
-
-func TestHuffmanMaxStrLen(t *testing.T) {
-	const msg = "Some string"
-	huff := AppendHuffmanString(nil, msg)
-
-	testGood := func(max int) {
-		var out bytes.Buffer
-		if err := huffmanDecode(&out, max, huff); err != nil {
-			t.Errorf("For maxLen=%d, unexpected error: %v", max, err)
-		}
-		if out.String() != msg {
-			t.Errorf("For maxLen=%d, out = %q; want %q", max, out.String(), msg)
-		}
-	}
-	testGood(0)
-	testGood(len(msg))
-	testGood(len(msg) + 1)
-
-	var out bytes.Buffer
-	if err := huffmanDecode(&out, len(msg)-1, huff); err != ErrStringLength {
-		t.Errorf("err = %v; want ErrStringLength", err)
-	}
-}
-
-func TestHuffmanRoundtripStress(t *testing.T) {
-	const Len = 50 // of uncompressed string
-	input := make([]byte, Len)
-	var output bytes.Buffer
-	var huff []byte
-
-	n := 5000
-	if testing.Short() {
-		n = 100
-	}
-	seed := time.Now().UnixNano()
-	t.Logf("Seed = %v", seed)
-	src := rand.New(rand.NewSource(seed))
-	var encSize int64
-	for i := 0; i < n; i++ {
-		for l := range input {
-			input[l] = byte(src.Intn(256))
-		}
-		huff = AppendHuffmanString(huff[:0], string(input))
-		encSize += int64(len(huff))
-		output.Reset()
-		if err := huffmanDecode(&output, 0, huff); err != nil {
-			t.Errorf("Failed to decode %q -> %q -> error %v", input, huff, err)
-			continue
-		}
-		if !bytes.Equal(output.Bytes(), input) {
-			t.Errorf("Roundtrip failure on %q -> %q -> %q", input, huff, output.Bytes())
-		}
-	}
-	t.Logf("Compressed size of original: %0.02f%% (%v -> %v)", 100*(float64(encSize)/(Len*float64(n))), Len*n, encSize)
-}
-
-func TestHuffmanDecodeFuzz(t *testing.T) {
-	const Len = 50 // of compressed
-	var buf, zbuf bytes.Buffer
-
-	n := 5000
-	if testing.Short() {
-		n = 100
-	}
-	seed := time.Now().UnixNano()
-	t.Logf("Seed = %v", seed)
-	src := rand.New(rand.NewSource(seed))
-	numFail := 0
-	for i := 0; i < n; i++ {
-		zbuf.Reset()
-		if i == 0 {
-			// Start with at least one invalid one.
-			zbuf.WriteString("00\x91\xff\xff\xff\xff\xc8")
-		} else {
-			for l := 0; l < Len; l++ {
-				zbuf.WriteByte(byte(src.Intn(256)))
-			}
-		}
-
-		buf.Reset()
-		if err := huffmanDecode(&buf, 0, zbuf.Bytes()); err != nil {
-			if err == ErrInvalidHuffman {
-				numFail++
-				continue
-			}
-			t.Errorf("Failed to decode %q: %v", zbuf.Bytes(), err)
-			continue
-		}
-	}
-	t.Logf("%0.02f%% are invalid (%d / %d)", 100*float64(numFail)/float64(n), numFail, n)
-	if numFail < 1 {
-		t.Error("expected at least one invalid huffman encoding (test starts with one)")
-	}
-}
-
-func TestReadVarInt(t *testing.T) {
-	type res struct {
-		i        uint64
-		consumed int
-		err      error
-	}
-	tests := []struct {
-		n    byte
-		p    []byte
-		want res
-	}{
-		// Fits in a byte:
-		{1, []byte{0}, res{0, 1, nil}},
-		{2, []byte{2}, res{2, 1, nil}},
-		{3, []byte{6}, res{6, 1, nil}},
-		{4, []byte{14}, res{14, 1, nil}},
-		{5, []byte{30}, res{30, 1, nil}},
-		{6, []byte{62}, res{62, 1, nil}},
-		{7, []byte{126}, res{126, 1, nil}},
-		{8, []byte{254}, res{254, 1, nil}},
-
-		// Doesn't fit in a byte:
-		{1, []byte{1}, res{0, 0, errNeedMore}},
-		{2, []byte{3}, res{0, 0, errNeedMore}},
-		{3, []byte{7}, res{0, 0, errNeedMore}},
-		{4, []byte{15}, res{0, 0, errNeedMore}},
-		{5, []byte{31}, res{0, 0, errNeedMore}},
-		{6, []byte{63}, res{0, 0, errNeedMore}},
-		{7, []byte{127}, res{0, 0, errNeedMore}},
-		{8, []byte{255}, res{0, 0, errNeedMore}},
-
-		// Ignoring top bits:
-		{5, []byte{255, 154, 10}, res{1337, 3, nil}}, // high dummy three bits: 111
-		{5, []byte{159, 154, 10}, res{1337, 3, nil}}, // high dummy three bits: 100
-		{5, []byte{191, 154, 10}, res{1337, 3, nil}}, // high dummy three bits: 101
-
-		// Extra byte:
-		{5, []byte{191, 154, 10, 2}, res{1337, 3, nil}}, // extra byte
-
-		// Short a byte:
-		{5, []byte{191, 154}, res{0, 0, errNeedMore}},
-
-		// integer overflow:
-		{1, []byte{255, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128}, res{0, 0, errVarintOverflow}},
-	}
-	for _, tt := range tests {
-		i, remain, err := readVarInt(tt.n, tt.p)
-		consumed := len(tt.p) - len(remain)
-		got := res{i, consumed, err}
-		if got != tt.want {
-			t.Errorf("readVarInt(%d, %v ~ %x) = %+v; want %+v", tt.n, tt.p, tt.p, got, tt.want)
-		}
-	}
-}
-
-// Fuzz crash, originally reported at https://github.com/bradfitz/http2/issues/56
-func TestHuffmanFuzzCrash(t *testing.T) {
-	got, err := HuffmanDecodeToString([]byte("00\x91\xff\xff\xff\xff\xc8"))
-	if got != "" {
-		t.Errorf("Got %q; want empty string", got)
-	}
-	if err != ErrInvalidHuffman {
-		t.Errorf("Err = %v; want ErrInvalidHuffman", err)
-	}
-}
-
-func pair(name, value string) HeaderField {
-	return HeaderField{Name: name, Value: value}
-}
-
-func dehex(s string) []byte {
-	s = strings.Replace(s, " ", "", -1)
-	s = strings.Replace(s, "\n", "", -1)
-	b, err := hex.DecodeString(s)
-	if err != nil {
-		panic(err)
-	}
-	return b
-}
-
-func TestEmitEnabled(t *testing.T) {
-	var buf bytes.Buffer
-	enc := NewEncoder(&buf)
-	enc.WriteField(HeaderField{Name: "foo", Value: "bar"})
-	enc.WriteField(HeaderField{Name: "foo", Value: "bar"})
-
-	numCallback := 0
-	var dec *Decoder
-	dec = NewDecoder(8<<20, func(HeaderField) {
-		numCallback++
-		dec.SetEmitEnabled(false)
-	})
-	if !dec.EmitEnabled() {
-		t.Errorf("initial emit enabled = false; want true")
-	}
-	if _, err := dec.Write(buf.Bytes()); err != nil {
-		t.Error(err)
-	}
-	if numCallback != 1 {
-		t.Errorf("num callbacks = %d; want 1", numCallback)
-	}
-	if dec.EmitEnabled() {
-		t.Errorf("emit enabled = true; want false")
-	}
-}
-
-func TestSaveBufLimit(t *testing.T) {
-	const maxStr = 1 << 10
-	var got []HeaderField
-	dec := NewDecoder(initialHeaderTableSize, func(hf HeaderField) {
-		got = append(got, hf)
-	})
-	dec.SetMaxStringLength(maxStr)
-	var frag []byte
-	frag = append(frag[:0], encodeTypeByte(false, false))
-	frag = appendVarInt(frag, 7, 3)
-	frag = append(frag, "foo"...)
-	frag = appendVarInt(frag, 7, 3)
-	frag = append(frag, "bar"...)
-
-	if _, err := dec.Write(frag); err != nil {
-		t.Fatal(err)
-	}
-
-	want := []HeaderField{{Name: "foo", Value: "bar"}}
-	if !reflect.DeepEqual(got, want) {
-		t.Errorf("After small writes, got %v; want %v", got, want)
-	}
-
-	frag = append(frag[:0], encodeTypeByte(false, false))
-	frag = appendVarInt(frag, 7, maxStr*3)
-	frag = append(frag, make([]byte, maxStr*3)...)
-
-	_, err := dec.Write(frag)
-	if err != ErrStringLength {
-		t.Fatalf("Write error = %v; want ErrStringLength", err)
-	}
-}

vendor/golang.org/x/net/http2/hpack/huffman.go

@@ -1,212 +0,0 @@
-// Copyright 2014 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package hpack
-
-import (
-	"bytes"
-	"errors"
-	"io"
-	"sync"
-)
-
-var bufPool = sync.Pool{
-	New: func() interface{} { return new(bytes.Buffer) },
-}
-
-// HuffmanDecode decodes the string in v and writes the expanded
-// result to w, returning the number of bytes written to w and the
-// Write call's return value. At most one Write call is made.
-func HuffmanDecode(w io.Writer, v []byte) (int, error) {
-	buf := bufPool.Get().(*bytes.Buffer)
-	buf.Reset()
-	defer bufPool.Put(buf)
-	if err := huffmanDecode(buf, 0, v); err != nil {
-		return 0, err
-	}
-	return w.Write(buf.Bytes())
-}
-
-// HuffmanDecodeToString decodes the string in v.
-func HuffmanDecodeToString(v []byte) (string, error) {
-	buf := bufPool.Get().(*bytes.Buffer)
-	buf.Reset()
-	defer bufPool.Put(buf)
-	if err := huffmanDecode(buf, 0, v); err != nil {
-		return "", err
-	}
-	return buf.String(), nil
-}
-
-// ErrInvalidHuffman is returned for errors found decoding
-// Huffman-encoded strings.
-var ErrInvalidHuffman = errors.New("hpack: invalid Huffman-encoded data")
-
-// huffmanDecode decodes v to buf.
-// If maxLen is greater than 0, attempts to write more to buf than
-// maxLen bytes will return ErrStringLength.
-func huffmanDecode(buf *bytes.Buffer, maxLen int, v []byte) error {
-	n := rootHuffmanNode
-	// cur is the bit buffer that has not been fed into n.
-	// cbits is the number of low order bits in cur that are valid.
-	// sbits is the number of bits of the symbol prefix being decoded.
-	cur, cbits, sbits := uint(0), uint8(0), uint8(0)
-	for _, b := range v {
-		cur = cur<<8 | uint(b)
-		cbits += 8
-		sbits += 8
-		for cbits >= 8 {
-			idx := byte(cur >> (cbits - 8))
-			n = n.children[idx]
-			if n == nil {
-				return ErrInvalidHuffman
-			}
-			if n.children == nil {
-				if maxLen != 0 && buf.Len() == maxLen {
-					return ErrStringLength
-				}
-				buf.WriteByte(n.sym)
-				cbits -= n.codeLen
-				n = rootHuffmanNode
-				sbits = cbits
-			} else {
-				cbits -= 8
-			}
-		}
-	}
-	for cbits > 0 {
-		n = n.children[byte(cur<<(8-cbits))]
-		if n == nil {
-			return ErrInvalidHuffman
-		}
-		if n.children != nil || n.codeLen > cbits {
-			break
-		}
-		if maxLen != 0 && buf.Len() == maxLen {
-			return ErrStringLength
-		}
-		buf.WriteByte(n.sym)
-		cbits -= n.codeLen
-		n = rootHuffmanNode
-		sbits = cbits
-	}
-	if sbits > 7 {
-		// Either there was an incomplete symbol, or overlong padding.
-		// Both are decoding errors per RFC 7541 section 5.2.
-		return ErrInvalidHuffman
-	}
-	if mask := uint(1<<cbits - 1); cur&mask != mask {
-		// Trailing bits must be a prefix of EOS per RFC 7541 section 5.2.
-		return ErrInvalidHuffman
-	}
-
-	return nil
-}
-
-type node struct {
-	// children is non-nil for internal nodes
-	children []*node
-
-	// The following are only valid if children is nil:
-	codeLen uint8 // number of bits that led to the output of sym
-	sym     byte  // output symbol
-}
-
-func newInternalNode() *node {
-	return &node{children: make([]*node, 256)}
-}
-
-var rootHuffmanNode = newInternalNode()
-
-func init() {
-	if len(huffmanCodes) != 256 {
-		panic("unexpected size")
-	}
-	for i, code := range huffmanCodes {
-		addDecoderNode(byte(i), code, huffmanCodeLen[i])
-	}
-}
-
-func addDecoderNode(sym byte, code uint32, codeLen uint8) {
-	cur := rootHuffmanNode
-	for codeLen > 8 {
-		codeLen -= 8
-		i := uint8(code >> codeLen)
-		if cur.children[i] == nil {
-			cur.children[i] = newInternalNode()
-		}
-		cur = cur.children[i]
-	}
-	shift := 8 - codeLen
-	start, end := int(uint8(code<<shift)), int(1<<shift)
-	for i := start; i < start+end; i++ {
-		cur.children[i] = &node{sym: sym, codeLen: codeLen}
-	}
-}
-
-// AppendHuffmanString appends s, as encoded in Huffman codes, to dst
-// and returns the extended buffer.
-func AppendHuffmanString(dst []byte, s string) []byte {
-	rembits := uint8(8)
-
-	for i := 0; i < len(s); i++ {
-		if rembits == 8 {
-			dst = append(dst, 0)
-		}
-		dst, rembits = appendByteToHuffmanCode(dst, rembits, s[i])
-	}
-
-	if rembits < 8 {
-		// special EOS symbol
-		code := uint32(0x3fffffff)
-		nbits := uint8(30)
-
-		t := uint8(code >> (nbits - rembits))
-		dst[len(dst)-1] |= t
-	}
-
-	return dst
-}
-
-// HuffmanEncodeLength returns the number of bytes required to encode
-// s in Huffman codes. The result is round up to byte boundary.
-func HuffmanEncodeLength(s string) uint64 {
-	n := uint64(0)
-	for i := 0; i < len(s); i++ {
-		n += uint64(huffmanCodeLen[s[i]])
-	}
-	return (n + 7) / 8
-}
-
-// appendByteToHuffmanCode appends Huffman code for c to dst and
-// returns the extended buffer and the remaining bits in the last
-// element. The appending is not byte aligned and the remaining bits
-// in the last element of dst is given in rembits.
-func appendByteToHuffmanCode(dst []byte, rembits uint8, c byte) ([]byte, uint8) {
-	code := huffmanCodes[c]
-	nbits := huffmanCodeLen[c]
-
-	for {
-		if rembits > nbits {
-			t := uint8(code << (rembits - nbits))
-			dst[len(dst)-1] |= t
-			rembits -= nbits
-			break
-		}
-
-		t := uint8(code >> (nbits - rembits))
-		dst[len(dst)-1] |= t
-
-		nbits -= rembits
-		rembits = 8
-
-		if nbits == 0 {
-			break
-		}
-
-		dst = append(dst, 0)
-	}
-
-	return dst, rembits
-}

vendor/golang.org/x/net/http2/hpack/tables.go

@@ -1,479 +0,0 @@
-// Copyright 2014 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package hpack
-
-import (
-	"fmt"
-)
-
-// headerFieldTable implements a list of HeaderFields.
-// This is used to implement the static and dynamic tables.
-type headerFieldTable struct {
-	// For static tables, entries are never evicted.
-	//
-	// For dynamic tables, entries are evicted from ents[0] and added to the end.
-	// Each entry has a unique id that starts at one and increments for each
-	// entry that is added. This unique id is stable across evictions, meaning
-	// it can be used as a pointer to a specific entry. As in hpack, unique ids
-	// are 1-based. The unique id for ents[k] is k + evictCount + 1.
-	//
-	// Zero is not a valid unique id.
-	//
-	// evictCount should not overflow in any remotely practical situation. In
-	// practice, we will have one dynamic table per HTTP/2 connection. If we
-	// assume a very powerful server that handles 1M QPS per connection and each
-	// request adds (then evicts) 100 entries from the table, it would still take
-	// 2M years for evictCount to overflow.
-	ents       []HeaderField
-	evictCount uint64
-
-	// byName maps a HeaderField name to the unique id of the newest entry with
-	// the same name. See above for a definition of "unique id".
-	byName map[string]uint64
-
-	// byNameValue maps a HeaderField name/value pair to the unique id of the newest
-	// entry with the same name and value. See above for a definition of "unique id".
-	byNameValue map[pairNameValue]uint64
-}
-
-type pairNameValue struct {
-	name, value string
-}
-
-func (t *headerFieldTable) init() {
-	t.byName = make(map[string]uint64)
-	t.byNameValue = make(map[pairNameValue]uint64)
-}
-
-// len reports the number of entries in the table.
-func (t *headerFieldTable) len() int {
-	return len(t.ents)
-}
-
-// addEntry adds a new entry.
-func (t *headerFieldTable) addEntry(f HeaderField) {
-	id := uint64(t.len()) + t.evictCount + 1
-	t.byName[f.Name] = id
-	t.byNameValue[pairNameValue{f.Name, f.Value}] = id
-	t.ents = append(t.ents, f)
-}
-
-// evictOldest evicts the n oldest entries in the table.
-func (t *headerFieldTable) evictOldest(n int) {
-	if n > t.len() {
-		panic(fmt.Sprintf("evictOldest(%v) on table with %v entries", n, t.len()))
-	}
-	for k := 0; k < n; k++ {
-		f := t.ents[k]
-		id := t.evictCount + uint64(k) + 1
-		if t.byName[f.Name] == id {
-			delete(t.byName, f.Name)
-		}
-		if p := (pairNameValue{f.Name, f.Value}); t.byNameValue[p] == id {
-			delete(t.byNameValue, p)
-		}
-	}
-	copy(t.ents, t.ents[n:])
-	for k := t.len() - n; k < t.len(); k++ {
-		t.ents[k] = HeaderField{} // so strings can be garbage collected
-	}
-	t.ents = t.ents[:t.len()-n]
-	if t.evictCount+uint64(n) < t.evictCount {
-		panic("evictCount overflow")
-	}
-	t.evictCount += uint64(n)
-}
-
-// search finds f in the table. If there is no match, i is 0.
-// If both name and value match, i is the matched index and nameValueMatch
-// becomes true. If only name matches, i points to that index and
-// nameValueMatch becomes false.
-//
-// The returned index is a 1-based HPACK index. For dynamic tables, HPACK says
-// that index 1 should be the newest entry, but t.ents[0] is the oldest entry,
-// meaning t.ents is reversed for dynamic tables. Hence, when t is a dynamic
-// table, the return value i actually refers to the entry t.ents[t.len()-i].
-//
-// All tables are assumed to be a dynamic tables except for the global
-// staticTable pointer.
-//
-// See Section 2.3.3.
-func (t *headerFieldTable) search(f HeaderField) (i uint64, nameValueMatch bool) {
-	if !f.Sensitive {
-		if id := t.byNameValue[pairNameValue{f.Name, f.Value}]; id != 0 {
-			return t.idToIndex(id), true
-		}
-	}
-	if id := t.byName[f.Name]; id != 0 {
-		return t.idToIndex(id), false
-	}
-	return 0, false
-}
-
-// idToIndex converts a unique id to an HPACK index.
-// See Section 2.3.3.
-func (t *headerFieldTable) idToIndex(id uint64) uint64 {
-	if id <= t.evictCount {
-		panic(fmt.Sprintf("id (%v) <= evictCount (%v)", id, t.evictCount))
-	}
-	k := id - t.evictCount - 1 // convert id to an index t.ents[k]
-	if t != staticTable {
-		return uint64(t.len()) - k // dynamic table
-	}
-	return k + 1
-}
-
-// http://tools.ietf.org/html/draft-ietf-httpbis-header-compression-07#appendix-B
-var staticTable = newStaticTable()
-var staticTableEntries = [...]HeaderField{
-	{Name: ":authority"},
-	{Name: ":method", Value: "GET"},
-	{Name: ":method", Value: "POST"},
-	{Name: ":path", Value: "/"},
-	{Name: ":path", Value: "/index.html"},
-	{Name: ":scheme", Value: "http"},
-	{Name: ":scheme", Value: "https"},
-	{Name: ":status", Value: "200"},
-	{Name: ":status", Value: "204"},
-	{Name: ":status", Value: "206"},
-	{Name: ":status", Value: "304"},
-	{Name: ":status", Value: "400"},
-	{Name: ":status", Value: "404"},
-	{Name: ":status", Value: "500"},
-	{Name: "accept-charset"},
-	{Name: "accept-encoding", Value: "gzip, deflate"},
-	{Name: "accept-language"},
-	{Name: "accept-ranges"},
-	{Name: "accept"},
-	{Name: "access-control-allow-origin"},
-	{Name: "age"},
-	{Name: "allow"},
-	{Name: "authorization"},
-	{Name: "cache-control"},
-	{Name: "content-disposition"},
-	{Name: "content-encoding"},
-	{Name: "content-language"},
-	{Name: "content-length"},
-	{Name: "content-location"},
-	{Name: "content-range"},
-	{Name: "content-type"},
-	{Name: "cookie"},
-	{Name: "date"},
-	{Name: "etag"},
-	{Name: "expect"},
-	{Name: "expires"},
-	{Name: "from"},
-	{Name: "host"},
-	{Name: "if-match"},
-	{Name: "if-modified-since"},
-	{Name: "if-none-match"},
-	{Name: "if-range"},
-	{Name: "if-unmodified-since"},
-	{Name: "last-modified"},
-	{Name: "link"},
-	{Name: "location"},
-	{Name: "max-forwards"},
-	{Name: "proxy-authenticate"},
-	{Name: "proxy-authorization"},
-	{Name: "range"},
-	{Name: "referer"},
-	{Name: "refresh"},
-	{Name: "retry-after"},
-	{Name: "server"},
-	{Name: "set-cookie"},
-	{Name: "strict-transport-security"},
-	{Name: "transfer-encoding"},
-	{Name: "user-agent"},
-	{Name: "vary"},
-	{Name: "via"},
-	{Name: "www-authenticate"},
-}
-
-func newStaticTable() *headerFieldTable {
-	t := &headerFieldTable{}
-	t.init()
-	for _, e := range staticTableEntries[:] {
-		t.addEntry(e)
-	}
-	return t
-}
-
-var huffmanCodes = [256]uint32{
-	0x1ff8,
-	0x7fffd8,
-	0xfffffe2,
-	0xfffffe3,
-	0xfffffe4,
-	0xfffffe5,
-	0xfffffe6,
-	0xfffffe7,
-	0xfffffe8,
-	0xffffea,
-	0x3ffffffc,
-	0xfffffe9,
-	0xfffffea,
-	0x3ffffffd,
-	0xfffffeb,
-	0xfffffec,
-	0xfffffed,
-	0xfffffee,
-	0xfffffef,
-	0xffffff0,
-	0xffffff1,
-	0xffffff2,
-	0x3ffffffe,
-	0xffffff3,
-	0xffffff4,
-	0xffffff5,
-	0xffffff6,
-	0xffffff7,
-	0xffffff8,
-	0xffffff9,
-	0xffffffa,
-	0xffffffb,
-	0x14,
-	0x3f8,
-	0x3f9,
-	0xffa,
-	0x1ff9,
-	0x15,
-	0xf8,
-	0x7fa,
-	0x3fa,
-	0x3fb,
-	0xf9,
-	0x7fb,
-	0xfa,
-	0x16,
-	0x17,
-	0x18,
-	0x0,
-	0x1,
-	0x2,
-	0x19,
-	0x1a,
-	0x1b,
-	0x1c,
-	0x1d,
-	0x1e,
-	0x1f,
-	0x5c,
-	0xfb,
-	0x7ffc,
-	0x20,
-	0xffb,
-	0x3fc,
-	0x1ffa,
-	0x21,
-	0x5d,
-	0x5e,
-	0x5f,
-	0x60,
-	0x61,
-	0x62,
-	0x63,
-	0x64,
-	0x65,
-	0x66,
-	0x67,
-	0x68,
-	0x69,
-	0x6a,
-	0x6b,
-	0x6c,
-	0x6d,
-	0x6e,
-	0x6f,
-	0x70,
-	0x71,
-	0x72,
-	0xfc,
-	0x73,
-	0xfd,
-	0x1ffb,
-	0x7fff0,
-	0x1ffc,
-	0x3ffc,
-	0x22,
-	0x7ffd,
-	0x3,
-	0x23,
-	0x4,
-	0x24,
-	0x5,
-	0x25,
-	0x26,
-	0x27,
-	0x6,
-	0x74,
-	0x75,
-	0x28,
-	0x29,
-	0x2a,
-	0x7,
-	0x2b,
-	0x76,
-	0x2c,
-	0x8,
-	0x9,
-	0x2d,
-	0x77,
-	0x78,
-	0x79,
-	0x7a,
-	0x7b,
-	0x7ffe,
-	0x7fc,
-	0x3ffd,
-	0x1ffd,
-	0xffffffc,
-	0xfffe6,
-	0x3fffd2,
-	0xfffe7,
-	0xfffe8,
-	0x3fffd3,
-	0x3fffd4,
-	0x3fffd5,
-	0x7fffd9,
-	0x3fffd6,
-	0x7fffda,
-	0x7fffdb,
-	0x7fffdc,
-	0x7fffdd,
-	0x7fffde,
-	0xffffeb,
-	0x7fffdf,
-	0xffffec,
-	0xffffed,
-	0x3fffd7,
-	0x7fffe0,
-	0xffffee,
-	0x7fffe1,
-	0x7fffe2,
-	0x7fffe3,
-	0x7fffe4,
-	0x1fffdc,
-	0x3fffd8,
-	0x7fffe5,
-	0x3fffd9,
-	0x7fffe6,
-	0x7fffe7,
-	0xffffef,
-	0x3fffda,
-	0x1fffdd,
-	0xfffe9,
-	0x3fffdb,
-	0x3fffdc,
-	0x7fffe8,
-	0x7fffe9,
-	0x1fffde,
-	0x7fffea,
-	0x3fffdd,
-	0x3fffde,
-	0xfffff0,
-	0x1fffdf,
-	0x3fffdf,
-	0x7fffeb,
-	0x7fffec,
-	0x1fffe0,
-	0x1fffe1,
-	0x3fffe0,
-	0x1fffe2,
-	0x7fffed,
-	0x3fffe1,
-	0x7fffee,
-	0x7fffef,
-	0xfffea,
-	0x3fffe2,
-	0x3fffe3,
-	0x3fffe4,
-	0x7ffff0,
-	0x3fffe5,
-	0x3fffe6,
-	0x7ffff1,
-	0x3ffffe0,
-	0x3ffffe1,
-	0xfffeb,
-	0x7fff1,
-	0x3fffe7,
-	0x7ffff2,
-	0x3fffe8,
-	0x1ffffec,
-	0x3ffffe2,
-	0x3ffffe3,
-	0x3ffffe4,
-	0x7ffffde,
-	0x7ffffdf,
-	0x3ffffe5,
-	0xfffff1,
-	0x1ffffed,
-	0x7fff2,
-	0x1fffe3,
-	0x3ffffe6,
-	0x7ffffe0,
-	0x7ffffe1,
-	0x3ffffe7,
-	0x7ffffe2,
-	0xfffff2,
-	0x1fffe4,
-	0x1fffe5,
-	0x3ffffe8,
-	0x3ffffe9,
-	0xffffffd,
-	0x7ffffe3,
-	0x7ffffe4,
-	0x7ffffe5,
-	0xfffec,
-	0xfffff3,
-	0xfffed,
-	0x1fffe6,
-	0x3fffe9,
-	0x1fffe7,
-	0x1fffe8,
-	0x7ffff3,
-	0x3fffea,
-	0x3fffeb,
-	0x1ffffee,
-	0x1ffffef,
-	0xfffff4,
-	0xfffff5,
-	0x3ffffea,
-	0x7ffff4,
-	0x3ffffeb,
-	0x7ffffe6,
-	0x3ffffec,
-	0x3ffffed,
-	0x7ffffe7,
-	0x7ffffe8,
-	0x7ffffe9,
-	0x7ffffea,
-	0x7ffffeb,
-	0xffffffe,
-	0x7ffffec,
-	0x7ffffed,
-	0x7ffffee,
-	0x7ffffef,
-	0x7fffff0,
-	0x3ffffee,
-}
-
-var huffmanCodeLen = [256]uint8{
-	13, 23, 28, 28, 28, 28, 28, 28, 28, 24, 30, 28, 28, 30, 28, 28,
-	28, 28, 28, 28, 28, 28, 30, 28, 28, 28, 28, 28, 28, 28, 28, 28,
-	6, 10, 10, 12, 13, 6, 8, 11, 10, 10, 8, 11, 8, 6, 6, 6,
-	5, 5, 5, 6, 6, 6, 6, 6, 6, 6, 7, 8, 15, 6, 12, 10,
-	13, 6, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
-	7, 7, 7, 7, 7, 7, 7, 7, 8, 7, 8, 13, 19, 13, 14, 6,
-	15, 5, 6, 5, 6, 5, 6, 6, 6, 5, 7, 7, 6, 6, 6, 5,
-	6, 7, 6, 5, 5, 6, 7, 7, 7, 7, 7, 15, 11, 14, 13, 28,
-	20, 22, 20, 20, 22, 22, 22, 23, 22, 23, 23, 23, 23, 23, 24, 23,
-	24, 24, 22, 23, 24, 23, 23, 23, 23, 21, 22, 23, 22, 23, 23, 24,
-	22, 21, 20, 22, 22, 23, 23, 21, 23, 22, 22, 24, 21, 22, 23, 23,
-	21, 21, 22, 21, 23, 22, 23, 23, 20, 22, 22, 22, 23, 22, 22, 23,
-	26, 26, 20, 19, 22, 23, 22, 25, 26, 26, 26, 27, 27, 26, 24, 25,
-	19, 21, 26, 27, 27, 26, 27, 24, 21, 21, 26, 26, 28, 27, 27, 27,
-	20, 24, 20, 21, 22, 21, 21, 23, 22, 22, 25, 25, 24, 24, 26, 23,
-	26, 27, 26, 26, 27, 27, 27, 27, 27, 28, 27, 27, 27, 27, 27, 26,
-}

vendor/golang.org/x/net/http2/hpack/tables_test.go

@@ -1,214 +0,0 @@
-// Copyright 2017 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package hpack
-
-import (
-	"bufio"
-	"regexp"
-	"strconv"
-	"strings"
-	"testing"
-)
-
-func TestHeaderFieldTable(t *testing.T) {
-	table := &headerFieldTable{}
-	table.init()
-	table.addEntry(pair("key1", "value1-1"))
-	table.addEntry(pair("key2", "value2-1"))
-	table.addEntry(pair("key1", "value1-2"))
-	table.addEntry(pair("key3", "value3-1"))
-	table.addEntry(pair("key4", "value4-1"))
-	table.addEntry(pair("key2", "value2-2"))
-
-	// Tests will be run twice: once before evicting anything, and
-	// again after evicting the three oldest entries.
-	tests := []struct {
-		f                 HeaderField
-		beforeWantStaticI uint64
-		beforeWantMatch   bool
-		afterWantStaticI  uint64
-		afterWantMatch    bool
-	}{
-		{HeaderField{"key1", "value1-1", false}, 1, true, 0, false},
-		{HeaderField{"key1", "value1-2", false}, 3, true, 0, false},
-		{HeaderField{"key1", "value1-3", false}, 3, false, 0, false},
-		{HeaderField{"key2", "value2-1", false}, 2, true, 3, false},
-		{HeaderField{"key2", "value2-2", false}, 6, true, 3, true},
-		{HeaderField{"key2", "value2-3", false}, 6, false, 3, false},
-		{HeaderField{"key4", "value4-1", false}, 5, true, 2, true},
-		// Name match only, because sensitive.
-		{HeaderField{"key4", "value4-1", true}, 5, false, 2, false},
-		// Key not found.
-		{HeaderField{"key5", "value5-x", false}, 0, false, 0, false},
-	}
-
-	staticToDynamic := func(i uint64) uint64 {
-		if i == 0 {
-			return 0
-		}
-		return uint64(table.len()) - i + 1 // dynamic is the reversed table
-	}
-
-	searchStatic := func(f HeaderField) (uint64, bool) {
-		old := staticTable
-		staticTable = table
-		defer func() { staticTable = old }()
-		return staticTable.search(f)
-	}
-
-	searchDynamic := func(f HeaderField) (uint64, bool) {
-		return table.search(f)
-	}
-
-	for _, test := range tests {
-		gotI, gotMatch := searchStatic(test.f)
-		if wantI, wantMatch := test.beforeWantStaticI, test.beforeWantMatch; gotI != wantI || gotMatch != wantMatch {
-			t.Errorf("before evictions: searchStatic(%+v)=%v,%v want %v,%v", test.f, gotI, gotMatch, wantI, wantMatch)
-		}
-		gotI, gotMatch = searchDynamic(test.f)
-		wantDynamicI := staticToDynamic(test.beforeWantStaticI)
-		if wantI, wantMatch := wantDynamicI, test.beforeWantMatch; gotI != wantI || gotMatch != wantMatch {
-			t.Errorf("before evictions: searchDynamic(%+v)=%v,%v want %v,%v", test.f, gotI, gotMatch, wantI, wantMatch)
-		}
-	}
-
-	table.evictOldest(3)
-
-	for _, test := range tests {
-		gotI, gotMatch := searchStatic(test.f)
-		if wantI, wantMatch := test.afterWantStaticI, test.afterWantMatch; gotI != wantI || gotMatch != wantMatch {
-			t.Errorf("after evictions: searchStatic(%+v)=%v,%v want %v,%v", test.f, gotI, gotMatch, wantI, wantMatch)
-		}
-		gotI, gotMatch = searchDynamic(test.f)
-		wantDynamicI := staticToDynamic(test.afterWantStaticI)
-		if wantI, wantMatch := wantDynamicI, test.afterWantMatch; gotI != wantI || gotMatch != wantMatch {
-			t.Errorf("after evictions: searchDynamic(%+v)=%v,%v want %v,%v", test.f, gotI, gotMatch, wantI, wantMatch)
-		}
-	}
-}
-
-func TestHeaderFieldTable_LookupMapEviction(t *testing.T) {
-	table := &headerFieldTable{}
-	table.init()
-	table.addEntry(pair("key1", "value1-1"))
-	table.addEntry(pair("key2", "value2-1"))
-	table.addEntry(pair("key1", "value1-2"))
-	table.addEntry(pair("key3", "value3-1"))
-	table.addEntry(pair("key4", "value4-1"))
-	table.addEntry(pair("key2", "value2-2"))
-
-	// evict all pairs
-	table.evictOldest(table.len())
-
-	if l := table.len(); l > 0 {
-		t.Errorf("table.len() = %d, want 0", l)
-	}
-
-	if l := len(table.byName); l > 0 {
-		t.Errorf("len(table.byName) = %d, want 0", l)
-	}
-
-	if l := len(table.byNameValue); l > 0 {
-		t.Errorf("len(table.byNameValue) = %d, want 0", l)
-	}
-}
-
-func TestStaticTable(t *testing.T) {
-	fromSpec := `
-          +-------+-----------------------------+---------------+
-          | 1     | :authority                  |               |
-          | 2     | :method                     | GET           |
-          | 3     | :method                     | POST          |
-          | 4     | :path                       | /             |
-          | 5     | :path                       | /index.html   |
-          | 6     | :scheme                     | http          |
-          | 7     | :scheme                     | https         |
-          | 8     | :status                     | 200           |
-          | 9     | :status                     | 204           |
-          | 10    | :status                     | 206           |
-          | 11    | :status                     | 304           |
-          | 12    | :status                     | 400           |
-          | 13    | :status                     | 404           |
-          | 14    | :status                     | 500           |
-          | 15    | accept-charset              |               |
-          | 16    | accept-encoding             | gzip, deflate |
-          | 17    | accept-language             |               |
-          | 18    | accept-ranges               |               |
-          | 19    | accept                      |               |
-          | 20    | access-control-allow-origin |               |
-          | 21    | age                         |               |
-          | 22    | allow                       |               |
-          | 23    | authorization               |               |
-          | 24    | cache-control               |               |
-          | 25    | content-disposition         |               |
-          | 26    | content-encoding            |               |
-          | 27    | content-language            |               |
-          | 28    | content-length              |               |
-          | 29    | content-location            |               |
-          | 30    | content-range               |               |
-          | 31    | content-type                |               |
-          | 32    | cookie                      |               |
-          | 33    | date                        |               |
-          | 34    | etag                        |               |
-          | 35    | expect                      |               |
-          | 36    | expires                     |               |
-          | 37    | from                        |               |
-          | 38    | host                        |               |
-          | 39    | if-match                    |               |
-          | 40    | if-modified-since           |               |
-          | 41    | if-none-match               |               |
-          | 42    | if-range                    |               |
-          | 43    | if-unmodified-since         |               |
-          | 44    | last-modified               |               |
-          | 45    | link                        |               |
-          | 46    | location                    |               |
-          | 47    | max-forwards                |               |
-          | 48    | proxy-authenticate          |               |
-          | 49    | proxy-authorization         |               |
-          | 50    | range                       |               |
-          | 51    | referer                     |               |
-          | 52    | refresh                     |               |
-          | 53    | retry-after                 |               |
-          | 54    | server                      |               |
-          | 55    | set-cookie                  |               |
-          | 56    | strict-transport-security   |               |
-          | 57    | transfer-encoding           |               |
-          | 58    | user-agent                  |               |
-          | 59    | vary                        |               |
-          | 60    | via                         |               |
-          | 61    | www-authenticate            |               |
-          +-------+-----------------------------+---------------+
-`
-	bs := bufio.NewScanner(strings.NewReader(fromSpec))
-	re := regexp.MustCompile(`\| (\d+)\s+\| (\S+)\s*\| (\S(.*\S)?)?\s+\|`)
-	for bs.Scan() {
-		l := bs.Text()
-		if !strings.Contains(l, "|") {
-			continue
-		}
-		m := re.FindStringSubmatch(l)
-		if m == nil {
-			continue
-		}
-		i, err := strconv.Atoi(m[1])
-		if err != nil {
-			t.Errorf("Bogus integer on line %q", l)
-			continue
-		}
-		if i < 1 || i > staticTable.len() {
-			t.Errorf("Bogus index %d on line %q", i, l)
-			continue
-		}
-		if got, want := staticTable.ents[i-1].Name, m[2]; got != want {
-			t.Errorf("header index %d name = %q; want %q", i, got, want)
-		}
-		if got, want := staticTable.ents[i-1].Value, m[3]; got != want {
-			t.Errorf("header index %d value = %q; want %q", i, got, want)
-		}
-	}
-	if err := bs.Err(); err != nil {
-		t.Error(err)
-	}
-}

vendor/golang.org/x/net/http2/http2.go

@@ -1,391 +0,0 @@
-// Copyright 2014 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Package http2 implements the HTTP/2 protocol.
-//
-// This package is low-level and intended to be used directly by very
-// few people. Most users will use it indirectly through the automatic
-// use by the net/http package (from Go 1.6 and later).
-// For use in earlier Go versions see ConfigureServer. (Transport support
-// requires Go 1.6 or later)
-//
-// See https://http2.github.io/ for more information on HTTP/2.
-//
-// See https://http2.golang.org/ for a test server running this code.
-//
-package http2 // import "golang.org/x/net/http2"
-
-import (
-	"bufio"
-	"crypto/tls"
-	"errors"
-	"fmt"
-	"io"
-	"net/http"
-	"os"
-	"sort"
-	"strconv"
-	"strings"
-	"sync"
-
-	"golang.org/x/net/lex/httplex"
-)
-
-var (
-	VerboseLogs    bool
-	logFrameWrites bool
-	logFrameReads  bool
-	inTests        bool
-)
-
-func init() {
-	e := os.Getenv("GODEBUG")
-	if strings.Contains(e, "http2debug=1") {
-		VerboseLogs = true
-	}
-	if strings.Contains(e, "http2debug=2") {
-		VerboseLogs = true
-		logFrameWrites = true
-		logFrameReads = true
-	}
-}
-
-const (
-	// ClientPreface is the string that must be sent by new
-	// connections from clients.
-	ClientPreface = "PRI * HTTP/2.0\r\n\r\nSM\r\n\r\n"
-
-	// SETTINGS_MAX_FRAME_SIZE default
-	// http://http2.github.io/http2-spec/#rfc.section.6.5.2
-	initialMaxFrameSize = 16384
-
-	// NextProtoTLS is the NPN/ALPN protocol negotiated during
-	// HTTP/2's TLS setup.
-	NextProtoTLS = "h2"
-
-	// http://http2.github.io/http2-spec/#SettingValues
-	initialHeaderTableSize = 4096
-
-	initialWindowSize = 65535 // 6.9.2 Initial Flow Control Window Size
-
-	defaultMaxReadFrameSize = 1 << 20
-)
-
-var (
-	clientPreface = []byte(ClientPreface)
-)
-
-type streamState int
-
-// HTTP/2 stream states.
-//
-// See http://tools.ietf.org/html/rfc7540#section-5.1.
-//
-// For simplicity, the server code merges "reserved (local)" into
-// "half-closed (remote)". This is one less state transition to track.
-// The only downside is that we send PUSH_PROMISEs slightly less
-// liberally than allowable. More discussion here:
-// https://lists.w3.org/Archives/Public/ietf-http-wg/2016JulSep/0599.html
-//
-// "reserved (remote)" is omitted since the client code does not
-// support server push.
-const (
-	stateIdle streamState = iota
-	stateOpen
-	stateHalfClosedLocal
-	stateHalfClosedRemote
-	stateClosed
-)
-
-var stateName = [...]string{
-	stateIdle:             "Idle",
-	stateOpen:             "Open",
-	stateHalfClosedLocal:  "HalfClosedLocal",
-	stateHalfClosedRemote: "HalfClosedRemote",
-	stateClosed:           "Closed",
-}
-
-func (st streamState) String() string {
-	return stateName[st]
-}
-
-// Setting is a setting parameter: which setting it is, and its value.
-type Setting struct {
-	// ID is which setting is being set.
-	// See http://http2.github.io/http2-spec/#SettingValues
-	ID SettingID
-
-	// Val is the value.
-	Val uint32
-}
-
-func (s Setting) String() string {
-	return fmt.Sprintf("[%v = %d]", s.ID, s.Val)
-}
-
-// Valid reports whether the setting is valid.
-func (s Setting) Valid() error {
-	// Limits and error codes from 6.5.2 Defined SETTINGS Parameters
-	switch s.ID {
-	case SettingEnablePush:
-		if s.Val != 1 && s.Val != 0 {
-			return ConnectionError(ErrCodeProtocol)
-		}
-	case SettingInitialWindowSize:
-		if s.Val > 1<<31-1 {
-			return ConnectionError(ErrCodeFlowControl)
-		}
-	case SettingMaxFrameSize:
-		if s.Val < 16384 || s.Val > 1<<24-1 {
-			return ConnectionError(ErrCodeProtocol)
-		}
-	}
-	return nil
-}
-
-// A SettingID is an HTTP/2 setting as defined in
-// http://http2.github.io/http2-spec/#iana-settings
-type SettingID uint16
-
-const (
-	SettingHeaderTableSize      SettingID = 0x1
-	SettingEnablePush           SettingID = 0x2
-	SettingMaxConcurrentStreams SettingID = 0x3
-	SettingInitialWindowSize    SettingID = 0x4
-	SettingMaxFrameSize         SettingID = 0x5
-	SettingMaxHeaderListSize    SettingID = 0x6
-)
-
-var settingName = map[SettingID]string{
-	SettingHeaderTableSize:      "HEADER_TABLE_SIZE",
-	SettingEnablePush:           "ENABLE_PUSH",
-	SettingMaxConcurrentStreams: "MAX_CONCURRENT_STREAMS",
-	SettingInitialWindowSize:    "INITIAL_WINDOW_SIZE",
-	SettingMaxFrameSize:         "MAX_FRAME_SIZE",
-	SettingMaxHeaderListSize:    "MAX_HEADER_LIST_SIZE",
-}
-
-func (s SettingID) String() string {
-	if v, ok := settingName[s]; ok {
-		return v
-	}
-	return fmt.Sprintf("UNKNOWN_SETTING_%d", uint16(s))
-}
-
-var (
-	errInvalidHeaderFieldName  = errors.New("http2: invalid header field name")
-	errInvalidHeaderFieldValue = errors.New("http2: invalid header field value")
-)
-
-// validWireHeaderFieldName reports whether v is a valid header field
-// name (key). See httplex.ValidHeaderName for the base rules.
-//
-// Further, http2 says:
-//   "Just as in HTTP/1.x, header field names are strings of ASCII
-//   characters that are compared in a case-insensitive
-//   fashion. However, header field names MUST be converted to
-//   lowercase prior to their encoding in HTTP/2. "
-func validWireHeaderFieldName(v string) bool {
-	if len(v) == 0 {
-		return false
-	}
-	for _, r := range v {
-		if !httplex.IsTokenRune(r) {
-			return false
-		}
-		if 'A' <= r && r <= 'Z' {
-			return false
-		}
-	}
-	return true
-}
-
-var httpCodeStringCommon = map[int]string{} // n -> strconv.Itoa(n)
-
-func init() {
-	for i := 100; i <= 999; i++ {
-		if v := http.StatusText(i); v != "" {
-			httpCodeStringCommon[i] = strconv.Itoa(i)
-		}
-	}
-}
-
-func httpCodeString(code int) string {
-	if s, ok := httpCodeStringCommon[code]; ok {
-		return s
-	}
-	return strconv.Itoa(code)
-}
-
-// from pkg io
-type stringWriter interface {
-	WriteString(s string) (n int, err error)
-}
-
-// A gate lets two goroutines coordinate their activities.
-type gate chan struct{}
-
-func (g gate) Done() { g <- struct{}{} }
-func (g gate) Wait() { <-g }
-
-// A closeWaiter is like a sync.WaitGroup but only goes 1 to 0 (open to closed).
-type closeWaiter chan struct{}
-
-// Init makes a closeWaiter usable.
-// It exists because so a closeWaiter value can be placed inside a
-// larger struct and have the Mutex and Cond's memory in the same
-// allocation.
-func (cw *closeWaiter) Init() {
-	*cw = make(chan struct{})
-}
-
-// Close marks the closeWaiter as closed and unblocks any waiters.
-func (cw closeWaiter) Close() {
-	close(cw)
-}
-
-// Wait waits for the closeWaiter to become closed.
-func (cw closeWaiter) Wait() {
-	<-cw
-}
-
-// bufferedWriter is a buffered writer that writes to w.
-// Its buffered writer is lazily allocated as needed, to minimize
-// idle memory usage with many connections.
-type bufferedWriter struct {
-	w  io.Writer     // immutable
-	bw *bufio.Writer // non-nil when data is buffered
-}
-
-func newBufferedWriter(w io.Writer) *bufferedWriter {
-	return &bufferedWriter{w: w}
-}
-
-// bufWriterPoolBufferSize is the size of bufio.Writer's
-// buffers created using bufWriterPool.
-//
-// TODO: pick a less arbitrary value? this is a bit under
-// (3 x typical 1500 byte MTU) at least. Other than that,
-// not much thought went into it.
-const bufWriterPoolBufferSize = 4 << 10
-
-var bufWriterPool = sync.Pool{
-	New: func() interface{} {
-		return bufio.NewWriterSize(nil, bufWriterPoolBufferSize)
-	},
-}
-
-func (w *bufferedWriter) Available() int {
-	if w.bw == nil {
-		return bufWriterPoolBufferSize
-	}
-	return w.bw.Available()
-}
-
-func (w *bufferedWriter) Write(p []byte) (n int, err error) {
-	if w.bw == nil {
-		bw := bufWriterPool.Get().(*bufio.Writer)
-		bw.Reset(w.w)
-		w.bw = bw
-	}
-	return w.bw.Write(p)
-}
-
-func (w *bufferedWriter) Flush() error {
-	bw := w.bw
-	if bw == nil {
-		return nil
-	}
-	err := bw.Flush()
-	bw.Reset(nil)
-	bufWriterPool.Put(bw)
-	w.bw = nil
-	return err
-}
-
-func mustUint31(v int32) uint32 {
-	if v < 0 || v > 2147483647 {
-		panic("out of range")
-	}
-	return uint32(v)
-}
-
-// bodyAllowedForStatus reports whether a given response status code
-// permits a body. See RFC 2616, section 4.4.
-func bodyAllowedForStatus(status int) bool {
-	switch {
-	case status >= 100 && status <= 199:
-		return false
-	case status == 204:
-		return false
-	case status == 304:
-		return false
-	}
-	return true
-}
-
-type httpError struct {
-	msg     string
-	timeout bool
-}
-
-func (e *httpError) Error() string   { return e.msg }
-func (e *httpError) Timeout() bool   { return e.timeout }
-func (e *httpError) Temporary() bool { return true }
-
-var errTimeout error = &httpError{msg: "http2: timeout awaiting response headers", timeout: true}
-
-type connectionStater interface {
-	ConnectionState() tls.ConnectionState
-}
-
-var sorterPool = sync.Pool{New: func() interface{} { return new(sorter) }}
-
-type sorter struct {
-	v []string // owned by sorter
-}
-
-func (s *sorter) Len() int           { return len(s.v) }
-func (s *sorter) Swap(i, j int)      { s.v[i], s.v[j] = s.v[j], s.v[i] }
-func (s *sorter) Less(i, j int) bool { return s.v[i] < s.v[j] }
-
-// Keys returns the sorted keys of h.
-//
-// The returned slice is only valid until s used again or returned to
-// its pool.
-func (s *sorter) Keys(h http.Header) []string {
-	keys := s.v[:0]
-	for k := range h {
-		keys = append(keys, k)
-	}
-	s.v = keys
-	sort.Sort(s)
-	return keys
-}
-
-func (s *sorter) SortStrings(ss []string) {
-	// Our sorter works on s.v, which sorter owns, so
-	// stash it away while we sort the user's buffer.
-	save := s.v
-	s.v = ss
-	sort.Sort(s)
-	s.v = save
-}
-
-// validPseudoPath reports whether v is a valid :path pseudo-header
-// value. It must be either:
-//
-//     *) a non-empty string starting with '/'
-//     *) the string '*', for OPTIONS requests.
-//
-// For now this is only used a quick check for deciding when to clean
-// up Opaque URLs before sending requests from the Transport.
-// See golang.org/issue/16847
-//
-// We used to enforce that the path also didn't start with "//", but
-// Google's GFE accepts such paths and Chrome sends them, so ignore
-// that part of the spec. See golang.org/issue/19103.
-func validPseudoPath(v string) bool {
-	return (len(v) > 0 && v[0] == '/') || v == "*"
-}

vendor/golang.org/x/net/http2/http2_test.go

@@ -1,199 +0,0 @@
-// Copyright 2014 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package http2
-
-import (
-	"bytes"
-	"errors"
-	"flag"
-	"fmt"
-	"net/http"
-	"os/exec"
-	"strconv"
-	"strings"
-	"testing"
-
-	"golang.org/x/net/http2/hpack"
-)
-
-var knownFailing = flag.Bool("known_failing", false, "Run known-failing tests.")
-
-func condSkipFailingTest(t *testing.T) {
-	if !*knownFailing {
-		t.Skip("Skipping known-failing test without --known_failing")
-	}
-}
-
-func init() {
-	inTests = true
-	DebugGoroutines = true
-	flag.BoolVar(&VerboseLogs, "verboseh2", VerboseLogs, "Verbose HTTP/2 debug logging")
-}
-
-func TestSettingString(t *testing.T) {
-	tests := []struct {
-		s    Setting
-		want string
-	}{
-		{Setting{SettingMaxFrameSize, 123}, "[MAX_FRAME_SIZE = 123]"},
-		{Setting{1<<16 - 1, 123}, "[UNKNOWN_SETTING_65535 = 123]"},
-	}
-	for i, tt := range tests {
-		got := fmt.Sprint(tt.s)
-		if got != tt.want {
-			t.Errorf("%d. for %#v, string = %q; want %q", i, tt.s, got, tt.want)
-		}
-	}
-}
-
-type twriter struct {
-	t  testing.TB
-	st *serverTester // optional
-}
-
-func (w twriter) Write(p []byte) (n int, err error) {
-	if w.st != nil {
-		ps := string(p)
-		for _, phrase := range w.st.logFilter {
-			if strings.Contains(ps, phrase) {
-				return len(p), nil // no logging
-			}
-		}
-	}
-	w.t.Logf("%s", p)
-	return len(p), nil
-}
-
-// like encodeHeader, but don't add implicit pseudo headers.
-func encodeHeaderNoImplicit(t *testing.T, headers ...string) []byte {
-	var buf bytes.Buffer
-	enc := hpack.NewEncoder(&buf)
-	for len(headers) > 0 {
-		k, v := headers[0], headers[1]
-		headers = headers[2:]
-		if err := enc.WriteField(hpack.HeaderField{Name: k, Value: v}); err != nil {
-			t.Fatalf("HPACK encoding error for %q/%q: %v", k, v, err)
-		}
-	}
-	return buf.Bytes()
-}
-
-// Verify that curl has http2.
-func requireCurl(t *testing.T) {
-	out, err := dockerLogs(curl(t, "--version"))
-	if err != nil {
-		t.Skipf("failed to determine curl features; skipping test")
-	}
-	if !strings.Contains(string(out), "HTTP2") {
-		t.Skip("curl doesn't support HTTP2; skipping test")
-	}
-}
-
-func curl(t *testing.T, args ...string) (container string) {
-	out, err := exec.Command("docker", append([]string{"run", "-d", "--net=host", "gohttp2/curl"}, args...)...).Output()
-	if err != nil {
-		t.Skipf("Failed to run curl in docker: %v, %s", err, out)
-	}
-	return strings.TrimSpace(string(out))
-}
-
-// Verify that h2load exists.
-func requireH2load(t *testing.T) {
-	out, err := dockerLogs(h2load(t, "--version"))
-	if err != nil {
-		t.Skipf("failed to probe h2load; skipping test: %s", out)
-	}
-	if !strings.Contains(string(out), "h2load nghttp2/") {
-		t.Skipf("h2load not present; skipping test. (Output=%q)", out)
-	}
-}
-
-func h2load(t *testing.T, args ...string) (container string) {
-	out, err := exec.Command("docker", append([]string{"run", "-d", "--net=host", "--entrypoint=/usr/local/bin/h2load", "gohttp2/curl"}, args...)...).Output()
-	if err != nil {
-		t.Skipf("Failed to run h2load in docker: %v, %s", err, out)
-	}
-	return strings.TrimSpace(string(out))
-}
-
-type puppetCommand struct {
-	fn   func(w http.ResponseWriter, r *http.Request)
-	done chan<- bool
-}
-
-type handlerPuppet struct {
-	ch chan puppetCommand
-}
-
-func newHandlerPuppet() *handlerPuppet {
-	return &handlerPuppet{
-		ch: make(chan puppetCommand),
-	}
-}
-
-func (p *handlerPuppet) act(w http.ResponseWriter, r *http.Request) {
-	for cmd := range p.ch {
-		cmd.fn(w, r)
-		cmd.done <- true
-	}
-}
-
-func (p *handlerPuppet) done() { close(p.ch) }
-func (p *handlerPuppet) do(fn func(http.ResponseWriter, *http.Request)) {
-	done := make(chan bool)
-	p.ch <- puppetCommand{fn, done}
-	<-done
-}
-func dockerLogs(container string) ([]byte, error) {
-	out, err := exec.Command("docker", "wait", container).CombinedOutput()
-	if err != nil {
-		return out, err
-	}
-	exitStatus, err := strconv.Atoi(strings.TrimSpace(string(out)))
-	if err != nil {
-		return out, errors.New("unexpected exit status from docker wait")
-	}
-	out, err = exec.Command("docker", "logs", container).CombinedOutput()
-	exec.Command("docker", "rm", container).Run()
-	if err == nil && exitStatus != 0 {
-		err = fmt.Errorf("exit status %d: %s", exitStatus, out)
-	}
-	return out, err
-}
-
-func kill(container string) {
-	exec.Command("docker", "kill", container).Run()
-	exec.Command("docker", "rm", container).Run()
-}
-
-func cleanDate(res *http.Response) {
-	if d := res.Header["Date"]; len(d) == 1 {
-		d[0] = "XXX"
-	}
-}
-
-func TestSorterPoolAllocs(t *testing.T) {
-	ss := []string{"a", "b", "c"}
-	h := http.Header{
-		"a": nil,
-		"b": nil,
-		"c": nil,
-	}
-	sorter := new(sorter)
-
-	if allocs := testing.AllocsPerRun(100, func() {
-		sorter.SortStrings(ss)
-	}); allocs >= 1 {
-		t.Logf("SortStrings allocs = %v; want <1", allocs)
-	}
-
-	if allocs := testing.AllocsPerRun(5, func() {
-		if len(sorter.Keys(h)) != 3 {
-			t.Fatal("wrong result")
-		}
-	}); allocs > 0 {
-		t.Logf("Keys allocs = %v; want <1", allocs)
-	}
-}

vendor/golang.org/x/net/http2/not_go16.go

@@ -1,21 +0,0 @@
-// Copyright 2015 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 !go1.6
-
-package http2
-
-import (
-	"net/http"
-	"time"
-)
-
-func configureTransport(t1 *http.Transport) (*Transport, error) {
-	return nil, errTransportVersion
-}
-
-func transportExpectContinueTimeout(t1 *http.Transport) time.Duration {
-	return 0
-
-}

vendor/golang.org/x/net/http2/not_go17.go

@@ -1,87 +0,0 @@
-// Copyright 2016 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 !go1.7
-
-package http2
-
-import (
-	"crypto/tls"
-	"net"
-	"net/http"
-	"time"
-)
-
-type contextContext interface {
-	Done() <-chan struct{}
-	Err() error
-}
-
-type fakeContext struct{}
-
-func (fakeContext) Done() <-chan struct{} { return nil }
-func (fakeContext) Err() error            { panic("should not be called") }
-
-func reqContext(r *http.Request) fakeContext {
-	return fakeContext{}
-}
-
-func setResponseUncompressed(res *http.Response) {
-	// Nothing.
-}
-
-type clientTrace struct{}
-
-func requestTrace(*http.Request) *clientTrace { return nil }
-func traceGotConn(*http.Request, *ClientConn) {}
-func traceFirstResponseByte(*clientTrace)     {}
-func traceWroteHeaders(*clientTrace)          {}
-func traceWroteRequest(*clientTrace, error)   {}
-func traceGot100Continue(trace *clientTrace)  {}
-func traceWait100Continue(trace *clientTrace) {}
-
-func nop() {}
-
-func serverConnBaseContext(c net.Conn, opts *ServeConnOpts) (ctx contextContext, cancel func()) {
-	return nil, nop
-}
-
-func contextWithCancel(ctx contextContext) (_ contextContext, cancel func()) {
-	return ctx, nop
-}
-
-func requestWithContext(req *http.Request, ctx contextContext) *http.Request {
-	return req
-}
-
-// temporary copy of Go 1.6's private tls.Config.clone:
-func cloneTLSConfig(c *tls.Config) *tls.Config {
-	return &tls.Config{
-		Rand:                     c.Rand,
-		Time:                     c.Time,
-		Certificates:             c.Certificates,
-		NameToCertificate:        c.NameToCertificate,
-		GetCertificate:           c.GetCertificate,
-		RootCAs:                  c.RootCAs,
-		NextProtos:               c.NextProtos,
-		ServerName:               c.ServerName,
-		ClientAuth:               c.ClientAuth,
-		ClientCAs:                c.ClientCAs,
-		InsecureSkipVerify:       c.InsecureSkipVerify,
-		CipherSuites:             c.CipherSuites,
-		PreferServerCipherSuites: c.PreferServerCipherSuites,
-		SessionTicketsDisabled:   c.SessionTicketsDisabled,
-		SessionTicketKey:         c.SessionTicketKey,
-		ClientSessionCache:       c.ClientSessionCache,
-		MinVersion:               c.MinVersion,
-		MaxVersion:               c.MaxVersion,
-		CurvePreferences:         c.CurvePreferences,
-	}
-}
-
-func (cc *ClientConn) Ping(ctx contextContext) error {
-	return cc.ping(ctx)
-}
-
-func (t *Transport) idleConnTimeout() time.Duration { return 0 }

vendor/golang.org/x/net/http2/not_go18.go

@@ -1,29 +0,0 @@
-// Copyright 2016 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 !go1.8
-
-package http2
-
-import (
-	"io"
-	"net/http"
-)
-
-func configureServer18(h1 *http.Server, h2 *Server) error {
-	// No IdleTimeout to sync prior to Go 1.8.
-	return nil
-}
-
-func shouldLogPanic(panicValue interface{}) bool {
-	return panicValue != nil
-}
-
-func reqGetBody(req *http.Request) func() (io.ReadCloser, error) {
-	return nil
-}
-
-func reqBodyIsNoBody(io.ReadCloser) bool { return false }
-
-func go18httpNoBody() io.ReadCloser { return nil } // for tests only

vendor/golang.org/x/net/http2/not_go19.go

@@ -1,16 +0,0 @@
-// Copyright 2016 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 !go1.9
-
-package http2
-
-import (
-	"net/http"
-)
-
-func configureServer19(s *http.Server, conf *Server) error {
-	// not supported prior to go1.9
-	return nil
-}

vendor/golang.org/x/net/http2/pipe.go

@@ -1,163 +0,0 @@
-// Copyright 2014 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package http2
-
-import (
-	"errors"
-	"io"
-	"sync"
-)
-
-// pipe is a goroutine-safe io.Reader/io.Writer pair. It's like
-// io.Pipe except there are no PipeReader/PipeWriter halves, and the
-// underlying buffer is an interface. (io.Pipe is always unbuffered)
-type pipe struct {
-	mu       sync.Mutex
-	c        sync.Cond     // c.L lazily initialized to &p.mu
-	b        pipeBuffer    // nil when done reading
-	err      error         // read error once empty. non-nil means closed.
-	breakErr error         // immediate read error (caller doesn't see rest of b)
-	donec    chan struct{} // closed on error
-	readFn   func()        // optional code to run in Read before error
-}
-
-type pipeBuffer interface {
-	Len() int
-	io.Writer
-	io.Reader
-}
-
-func (p *pipe) Len() int {
-	p.mu.Lock()
-	defer p.mu.Unlock()
-	if p.b == nil {
-		return 0
-	}
-	return p.b.Len()
-}
-
-// Read waits until data is available and copies bytes
-// from the buffer into p.
-func (p *pipe) Read(d []byte) (n int, err error) {
-	p.mu.Lock()
-	defer p.mu.Unlock()
-	if p.c.L == nil {
-		p.c.L = &p.mu
-	}
-	for {
-		if p.breakErr != nil {
-			return 0, p.breakErr
-		}
-		if p.b != nil && p.b.Len() > 0 {
-			return p.b.Read(d)
-		}
-		if p.err != nil {
-			if p.readFn != nil {
-				p.readFn()     // e.g. copy trailers
-				p.readFn = nil // not sticky like p.err
-			}
-			p.b = nil
-			return 0, p.err
-		}
-		p.c.Wait()
-	}
-}
-
-var errClosedPipeWrite = errors.New("write on closed buffer")
-
-// Write copies bytes from p into the buffer and wakes a reader.
-// It is an error to write more data than the buffer can hold.
-func (p *pipe) Write(d []byte) (n int, err error) {
-	p.mu.Lock()
-	defer p.mu.Unlock()
-	if p.c.L == nil {
-		p.c.L = &p.mu
-	}
-	defer p.c.Signal()
-	if p.err != nil {
-		return 0, errClosedPipeWrite
-	}
-	if p.breakErr != nil {
-		return len(d), nil // discard when there is no reader
-	}
-	return p.b.Write(d)
-}
-
-// CloseWithError causes the next Read (waking up a current blocked
-// Read if needed) to return the provided err after all data has been
-// read.
-//
-// The error must be non-nil.
-func (p *pipe) CloseWithError(err error) { p.closeWithError(&p.err, err, nil) }
-
-// BreakWithError causes the next Read (waking up a current blocked
-// Read if needed) to return the provided err immediately, without
-// waiting for unread data.
-func (p *pipe) BreakWithError(err error) { p.closeWithError(&p.breakErr, err, nil) }
-
-// closeWithErrorAndCode is like CloseWithError but also sets some code to run
-// in the caller's goroutine before returning the error.
-func (p *pipe) closeWithErrorAndCode(err error, fn func()) { p.closeWithError(&p.err, err, fn) }
-
-func (p *pipe) closeWithError(dst *error, err error, fn func()) {
-	if err == nil {
-		panic("err must be non-nil")
-	}
-	p.mu.Lock()
-	defer p.mu.Unlock()
-	if p.c.L == nil {
-		p.c.L = &p.mu
-	}
-	defer p.c.Signal()
-	if *dst != nil {
-		// Already been done.
-		return
-	}
-	p.readFn = fn
-	if dst == &p.breakErr {
-		p.b = nil
-	}
-	*dst = err
-	p.closeDoneLocked()
-}
-
-// requires p.mu be held.
-func (p *pipe) closeDoneLocked() {
-	if p.donec == nil {
-		return
-	}
-	// Close if unclosed. This isn't racy since we always
-	// hold p.mu while closing.
-	select {
-	case <-p.donec:
-	default:
-		close(p.donec)
-	}
-}
-
-// Err returns the error (if any) first set by BreakWithError or CloseWithError.
-func (p *pipe) Err() error {
-	p.mu.Lock()
-	defer p.mu.Unlock()
-	if p.breakErr != nil {
-		return p.breakErr
-	}
-	return p.err
-}
-
-// Done returns a channel which is closed if and when this pipe is closed
-// with CloseWithError.
-func (p *pipe) Done() <-chan struct{} {
-	p.mu.Lock()
-	defer p.mu.Unlock()
-	if p.donec == nil {
-		p.donec = make(chan struct{})
-		if p.err != nil || p.breakErr != nil {
-			// Already hit an error.
-			p.closeDoneLocked()
-		}
-	}
-	return p.donec
-}

vendor/golang.org/x/net/http2/pipe_test.go

@@ -1,130 +0,0 @@
-// Copyright 2014 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package http2
-
-import (
-	"bytes"
-	"errors"
-	"io"
-	"io/ioutil"
-	"testing"
-)
-
-func TestPipeClose(t *testing.T) {
-	var p pipe
-	p.b = new(bytes.Buffer)
-	a := errors.New("a")
-	b := errors.New("b")
-	p.CloseWithError(a)
-	p.CloseWithError(b)
-	_, err := p.Read(make([]byte, 1))
-	if err != a {
-		t.Errorf("err = %v want %v", err, a)
-	}
-}
-
-func TestPipeDoneChan(t *testing.T) {
-	var p pipe
-	done := p.Done()
-	select {
-	case <-done:
-		t.Fatal("done too soon")
-	default:
-	}
-	p.CloseWithError(io.EOF)
-	select {
-	case <-done:
-	default:
-		t.Fatal("should be done")
-	}
-}
-
-func TestPipeDoneChan_ErrFirst(t *testing.T) {
-	var p pipe
-	p.CloseWithError(io.EOF)
-	done := p.Done()
-	select {
-	case <-done:
-	default:
-		t.Fatal("should be done")
-	}
-}
-
-func TestPipeDoneChan_Break(t *testing.T) {
-	var p pipe
-	done := p.Done()
-	select {
-	case <-done:
-		t.Fatal("done too soon")
-	default:
-	}
-	p.BreakWithError(io.EOF)
-	select {
-	case <-done:
-	default:
-		t.Fatal("should be done")
-	}
-}
-
-func TestPipeDoneChan_Break_ErrFirst(t *testing.T) {
-	var p pipe
-	p.BreakWithError(io.EOF)
-	done := p.Done()
-	select {
-	case <-done:
-	default:
-		t.Fatal("should be done")
-	}
-}
-
-func TestPipeCloseWithError(t *testing.T) {
-	p := &pipe{b: new(bytes.Buffer)}
-	const body = "foo"
-	io.WriteString(p, body)
-	a := errors.New("test error")
-	p.CloseWithError(a)
-	all, err := ioutil.ReadAll(p)
-	if string(all) != body {
-		t.Errorf("read bytes = %q; want %q", all, body)
-	}
-	if err != a {
-		t.Logf("read error = %v, %v", err, a)
-	}
-	// Read and Write should fail.
-	if n, err := p.Write([]byte("abc")); err != errClosedPipeWrite || n != 0 {
-		t.Errorf("Write(abc) after close\ngot %v, %v\nwant 0, %v", n, err, errClosedPipeWrite)
-	}
-	if n, err := p.Read(make([]byte, 1)); err == nil || n != 0 {
-		t.Errorf("Read() after close\ngot %v, nil\nwant 0, %v", n, errClosedPipeWrite)
-	}
-}
-
-func TestPipeBreakWithError(t *testing.T) {
-	p := &pipe{b: new(bytes.Buffer)}
-	io.WriteString(p, "foo")
-	a := errors.New("test err")
-	p.BreakWithError(a)
-	all, err := ioutil.ReadAll(p)
-	if string(all) != "" {
-		t.Errorf("read bytes = %q; want empty string", all)
-	}
-	if err != a {
-		t.Logf("read error = %v, %v", err, a)
-	}
-	if p.b != nil {
-		t.Errorf("buffer should be nil after BreakWithError")
-	}
-	// Write should succeed silently.
-	if n, err := p.Write([]byte("abc")); err != nil || n != 3 {
-		t.Errorf("Write(abc) after break\ngot %v, %v\nwant 0, nil", n, err)
-	}
-	if p.b != nil {
-		t.Errorf("buffer should be nil after Write")
-	}
-	// Read should fail.
-	if n, err := p.Read(make([]byte, 1)); err == nil || n != 0 {
-		t.Errorf("Read() after close\ngot %v, nil\nwant 0, not nil", n)
-	}
-}

vendor/golang.org/x/net/http2/server_push_test.go

@@ -1,521 +0,0 @@
-// Copyright 2016 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 go1.8
-
-package http2
-
-import (
-	"errors"
-	"fmt"
-	"io"
-	"io/ioutil"
-	"net/http"
-	"reflect"
-	"strconv"
-	"sync"
-	"testing"
-	"time"
-)
-
-func TestServer_Push_Success(t *testing.T) {
-	const (
-		mainBody   = "<html>index page</html>"
-		pushedBody = "<html>pushed page</html>"
-		userAgent  = "testagent"
-		cookie     = "testcookie"
-	)
-
-	var stURL string
-	checkPromisedReq := func(r *http.Request, wantMethod string, wantH http.Header) error {
-		if got, want := r.Method, wantMethod; got != want {
-			return fmt.Errorf("promised Req.Method=%q, want %q", got, want)
-		}
-		if got, want := r.Header, wantH; !reflect.DeepEqual(got, want) {
-			return fmt.Errorf("promised Req.Header=%q, want %q", got, want)
-		}
-		if got, want := "https://"+r.Host, stURL; got != want {
-			return fmt.Errorf("promised Req.Host=%q, want %q", got, want)
-		}
-		if r.Body == nil {
-			return fmt.Errorf("nil Body")
-		}
-		if buf, err := ioutil.ReadAll(r.Body); err != nil || len(buf) != 0 {
-			return fmt.Errorf("ReadAll(Body)=%q,%v, want '',nil", buf, err)
-		}
-		return nil
-	}
-
-	errc := make(chan error, 3)
-	st := newServerTester(t, func(w http.ResponseWriter, r *http.Request) {
-		switch r.URL.RequestURI() {
-		case "/":
-			// Push "/pushed?get" as a GET request, using an absolute URL.
-			opt := &http.PushOptions{
-				Header: http.Header{
-					"User-Agent": {userAgent},
-				},
-			}
-			if err := w.(http.Pusher).Push(stURL+"/pushed?get", opt); err != nil {
-				errc <- fmt.Errorf("error pushing /pushed?get: %v", err)
-				return
-			}
-			// Push "/pushed?head" as a HEAD request, using a path.
-			opt = &http.PushOptions{
-				Method: "HEAD",
-				Header: http.Header{
-					"User-Agent": {userAgent},
-					"Cookie":     {cookie},
-				},
-			}
-			if err := w.(http.Pusher).Push("/pushed?head", opt); err != nil {
-				errc <- fmt.Errorf("error pushing /pushed?head: %v", err)
-				return
-			}
-			w.Header().Set("Content-Type", "text/html")
-			w.Header().Set("Content-Length", strconv.Itoa(len(mainBody)))
-			w.WriteHeader(200)
-			io.WriteString(w, mainBody)
-			errc <- nil
-
-		case "/pushed?get":
-			wantH := http.Header{}
-			wantH.Set("User-Agent", userAgent)
-			if err := checkPromisedReq(r, "GET", wantH); err != nil {
-				errc <- fmt.Errorf("/pushed?get: %v", err)
-				return
-			}
-			w.Header().Set("Content-Type", "text/html")
-			w.Header().Set("Content-Length", strconv.Itoa(len(pushedBody)))
-			w.WriteHeader(200)
-			io.WriteString(w, pushedBody)
-			errc <- nil
-
-		case "/pushed?head":
-			wantH := http.Header{}
-			wantH.Set("User-Agent", userAgent)
-			wantH.Set("Cookie", cookie)
-			if err := checkPromisedReq(r, "HEAD", wantH); err != nil {
-				errc <- fmt.Errorf("/pushed?head: %v", err)
-				return
-			}
-			w.WriteHeader(204)
-			errc <- nil
-
-		default:
-			errc <- fmt.Errorf("unknown RequestURL %q", r.URL.RequestURI())
-		}
-	})
-	stURL = st.ts.URL
-
-	// Send one request, which should push two responses.
-	st.greet()
-	getSlash(st)
-	for k := 0; k < 3; k++ {
-		select {
-		case <-time.After(2 * time.Second):
-			t.Errorf("timeout waiting for handler %d to finish", k)
-		case err := <-errc:
-			if err != nil {
-				t.Fatal(err)
-			}
-		}
-	}
-
-	checkPushPromise := func(f Frame, promiseID uint32, wantH [][2]string) error {
-		pp, ok := f.(*PushPromiseFrame)
-		if !ok {
-			return fmt.Errorf("got a %T; want *PushPromiseFrame", f)
-		}
-		if !pp.HeadersEnded() {
-			return fmt.Errorf("want END_HEADERS flag in PushPromiseFrame")
-		}
-		if got, want := pp.PromiseID, promiseID; got != want {
-			return fmt.Errorf("got PromiseID %v; want %v", got, want)
-		}
-		gotH := st.decodeHeader(pp.HeaderBlockFragment())
-		if !reflect.DeepEqual(gotH, wantH) {
-			return fmt.Errorf("got promised headers %v; want %v", gotH, wantH)
-		}
-		return nil
-	}
-	checkHeaders := func(f Frame, wantH [][2]string) error {
-		hf, ok := f.(*HeadersFrame)
-		if !ok {
-			return fmt.Errorf("got a %T; want *HeadersFrame", f)
-		}
-		gotH := st.decodeHeader(hf.HeaderBlockFragment())
-		if !reflect.DeepEqual(gotH, wantH) {
-			return fmt.Errorf("got response headers %v; want %v", gotH, wantH)
-		}
-		return nil
-	}
-	checkData := func(f Frame, wantData string) error {
-		df, ok := f.(*DataFrame)
-		if !ok {
-			return fmt.Errorf("got a %T; want *DataFrame", f)
-		}
-		if gotData := string(df.Data()); gotData != wantData {
-			return fmt.Errorf("got response data %q; want %q", gotData, wantData)
-		}
-		return nil
-	}
-
-	// Stream 1 has 2 PUSH_PROMISE + HEADERS + DATA
-	// Stream 2 has HEADERS + DATA
-	// Stream 4 has HEADERS
-	expected := map[uint32][]func(Frame) error{
-		1: {
-			func(f Frame) error {
-				return checkPushPromise(f, 2, [][2]string{
-					{":method", "GET"},
-					{":scheme", "https"},
-					{":authority", st.ts.Listener.Addr().String()},
-					{":path", "/pushed?get"},
-					{"user-agent", userAgent},
-				})
-			},
-			func(f Frame) error {
-				return checkPushPromise(f, 4, [][2]string{
-					{":method", "HEAD"},
-					{":scheme", "https"},
-					{":authority", st.ts.Listener.Addr().String()},
-					{":path", "/pushed?head"},
-					{"cookie", cookie},
-					{"user-agent", userAgent},
-				})
-			},
-			func(f Frame) error {
-				return checkHeaders(f, [][2]string{
-					{":status", "200"},
-					{"content-type", "text/html"},
-					{"content-length", strconv.Itoa(len(mainBody))},
-				})
-			},
-			func(f Frame) error {
-				return checkData(f, mainBody)
-			},
-		},
-		2: {
-			func(f Frame) error {
-				return checkHeaders(f, [][2]string{
-					{":status", "200"},
-					{"content-type", "text/html"},
-					{"content-length", strconv.Itoa(len(pushedBody))},
-				})
-			},
-			func(f Frame) error {
-				return checkData(f, pushedBody)
-			},
-		},
-		4: {
-			func(f Frame) error {
-				return checkHeaders(f, [][2]string{
-					{":status", "204"},
-				})
-			},
-		},
-	}
-
-	consumed := map[uint32]int{}
-	for k := 0; len(expected) > 0; k++ {
-		f, err := st.readFrame()
-		if err != nil {
-			for id, left := range expected {
-				t.Errorf("stream %d: missing %d frames", id, len(left))
-			}
-			t.Fatalf("readFrame %d: %v", k, err)
-		}
-		id := f.Header().StreamID
-		label := fmt.Sprintf("stream %d, frame %d", id, consumed[id])
-		if len(expected[id]) == 0 {
-			t.Fatalf("%s: unexpected frame %#+v", label, f)
-		}
-		check := expected[id][0]
-		expected[id] = expected[id][1:]
-		if len(expected[id]) == 0 {
-			delete(expected, id)
-		}
-		if err := check(f); err != nil {
-			t.Fatalf("%s: %v", label, err)
-		}
-		consumed[id]++
-	}
-}
-
-func TestServer_Push_SuccessNoRace(t *testing.T) {
-	// Regression test for issue #18326. Ensure the request handler can mutate
-	// pushed request headers without racing with the PUSH_PROMISE write.
-	errc := make(chan error, 2)
-	st := newServerTester(t, func(w http.ResponseWriter, r *http.Request) {
-		switch r.URL.RequestURI() {
-		case "/":
-			opt := &http.PushOptions{
-				Header: http.Header{"User-Agent": {"testagent"}},
-			}
-			if err := w.(http.Pusher).Push("/pushed", opt); err != nil {
-				errc <- fmt.Errorf("error pushing: %v", err)
-				return
-			}
-			w.WriteHeader(200)
-			errc <- nil
-
-		case "/pushed":
-			// Update request header, ensure there is no race.
-			r.Header.Set("User-Agent", "newagent")
-			r.Header.Set("Cookie", "cookie")
-			w.WriteHeader(200)
-			errc <- nil
-
-		default:
-			errc <- fmt.Errorf("unknown RequestURL %q", r.URL.RequestURI())
-		}
-	})
-
-	// Send one request, which should push one response.
-	st.greet()
-	getSlash(st)
-	for k := 0; k < 2; k++ {
-		select {
-		case <-time.After(2 * time.Second):
-			t.Errorf("timeout waiting for handler %d to finish", k)
-		case err := <-errc:
-			if err != nil {
-				t.Fatal(err)
-			}
-		}
-	}
-}
-
-func TestServer_Push_RejectRecursivePush(t *testing.T) {
-	// Expect two requests, but might get three if there's a bug and the second push succeeds.
-	errc := make(chan error, 3)
-	handler := func(w http.ResponseWriter, r *http.Request) error {
-		baseURL := "https://" + r.Host
-		switch r.URL.Path {
-		case "/":
-			if err := w.(http.Pusher).Push(baseURL+"/push1", nil); err != nil {
-				return fmt.Errorf("first Push()=%v, want nil", err)
-			}
-			return nil
-
-		case "/push1":
-			if got, want := w.(http.Pusher).Push(baseURL+"/push2", nil), ErrRecursivePush; got != want {
-				return fmt.Errorf("Push()=%v, want %v", got, want)
-			}
-			return nil
-
-		default:
-			return fmt.Errorf("unexpected path: %q", r.URL.Path)
-		}
-	}
-	st := newServerTester(t, func(w http.ResponseWriter, r *http.Request) {
-		errc <- handler(w, r)
-	})
-	defer st.Close()
-	st.greet()
-	getSlash(st)
-	if err := <-errc; err != nil {
-		t.Errorf("First request failed: %v", err)
-	}
-	if err := <-errc; err != nil {
-		t.Errorf("Second request failed: %v", err)
-	}
-}
-
-func testServer_Push_RejectSingleRequest(t *testing.T, doPush func(http.Pusher, *http.Request) error, settings ...Setting) {
-	// Expect one request, but might get two if there's a bug and the push succeeds.
-	errc := make(chan error, 2)
-	st := newServerTester(t, func(w http.ResponseWriter, r *http.Request) {
-		errc <- doPush(w.(http.Pusher), r)
-	})
-	defer st.Close()
-	st.greet()
-	if err := st.fr.WriteSettings(settings...); err != nil {
-		st.t.Fatalf("WriteSettings: %v", err)
-	}
-	st.wantSettingsAck()
-	getSlash(st)
-	if err := <-errc; err != nil {
-		t.Error(err)
-	}
-	// Should not get a PUSH_PROMISE frame.
-	hf := st.wantHeaders()
-	if !hf.StreamEnded() {
-		t.Error("stream should end after headers")
-	}
-}
-
-func TestServer_Push_RejectIfDisabled(t *testing.T) {
-	testServer_Push_RejectSingleRequest(t,
-		func(p http.Pusher, r *http.Request) error {
-			if got, want := p.Push("https://"+r.Host+"/pushed", nil), http.ErrNotSupported; got != want {
-				return fmt.Errorf("Push()=%v, want %v", got, want)
-			}
-			return nil
-		},
-		Setting{SettingEnablePush, 0})
-}
-
-func TestServer_Push_RejectWhenNoConcurrentStreams(t *testing.T) {
-	testServer_Push_RejectSingleRequest(t,
-		func(p http.Pusher, r *http.Request) error {
-			if got, want := p.Push("https://"+r.Host+"/pushed", nil), ErrPushLimitReached; got != want {
-				return fmt.Errorf("Push()=%v, want %v", got, want)
-			}
-			return nil
-		},
-		Setting{SettingMaxConcurrentStreams, 0})
-}
-
-func TestServer_Push_RejectWrongScheme(t *testing.T) {
-	testServer_Push_RejectSingleRequest(t,
-		func(p http.Pusher, r *http.Request) error {
-			if err := p.Push("http://"+r.Host+"/pushed", nil); err == nil {
-				return errors.New("Push() should have failed (push target URL is http)")
-			}
-			return nil
-		})
-}
-
-func TestServer_Push_RejectMissingHost(t *testing.T) {
-	testServer_Push_RejectSingleRequest(t,
-		func(p http.Pusher, r *http.Request) error {
-			if err := p.Push("https:pushed", nil); err == nil {
-				return errors.New("Push() should have failed (push target URL missing host)")
-			}
-			return nil
-		})
-}
-
-func TestServer_Push_RejectRelativePath(t *testing.T) {
-	testServer_Push_RejectSingleRequest(t,
-		func(p http.Pusher, r *http.Request) error {
-			if err := p.Push("../test", nil); err == nil {
-				return errors.New("Push() should have failed (push target is a relative path)")
-			}
-			return nil
-		})
-}
-
-func TestServer_Push_RejectForbiddenMethod(t *testing.T) {
-	testServer_Push_RejectSingleRequest(t,
-		func(p http.Pusher, r *http.Request) error {
-			if err := p.Push("https://"+r.Host+"/pushed", &http.PushOptions{Method: "POST"}); err == nil {
-				return errors.New("Push() should have failed (cannot promise a POST)")
-			}
-			return nil
-		})
-}
-
-func TestServer_Push_RejectForbiddenHeader(t *testing.T) {
-	testServer_Push_RejectSingleRequest(t,
-		func(p http.Pusher, r *http.Request) error {
-			header := http.Header{
-				"Content-Length":   {"10"},
-				"Content-Encoding": {"gzip"},
-				"Trailer":          {"Foo"},
-				"Te":               {"trailers"},
-				"Host":             {"test.com"},
-				":authority":       {"test.com"},
-			}
-			if err := p.Push("https://"+r.Host+"/pushed", &http.PushOptions{Header: header}); err == nil {
-				return errors.New("Push() should have failed (forbidden headers)")
-			}
-			return nil
-		})
-}
-
-func TestServer_Push_StateTransitions(t *testing.T) {
-	const body = "foo"
-
-	gotPromise := make(chan bool)
-	finishedPush := make(chan bool)
-
-	st := newServerTester(t, func(w http.ResponseWriter, r *http.Request) {
-		switch r.URL.RequestURI() {
-		case "/":
-			if err := w.(http.Pusher).Push("/pushed", nil); err != nil {
-				t.Errorf("Push error: %v", err)
-			}
-			// Don't finish this request until the push finishes so we don't
-			// nondeterministically interleave output frames with the push.
-			<-finishedPush
-		case "/pushed":
-			<-gotPromise
-		}
-		w.Header().Set("Content-Type", "text/html")
-		w.Header().Set("Content-Length", strconv.Itoa(len(body)))
-		w.WriteHeader(200)
-		io.WriteString(w, body)
-	})
-	defer st.Close()
-
-	st.greet()
-	if st.stream(2) != nil {
-		t.Fatal("stream 2 should be empty")
-	}
-	if got, want := st.streamState(2), stateIdle; got != want {
-		t.Fatalf("streamState(2)=%v, want %v", got, want)
-	}
-	getSlash(st)
-	// After the PUSH_PROMISE is sent, the stream should be stateHalfClosedRemote.
-	st.wantPushPromise()
-	if got, want := st.streamState(2), stateHalfClosedRemote; got != want {
-		t.Fatalf("streamState(2)=%v, want %v", got, want)
-	}
-	// We stall the HTTP handler for "/pushed" until the above check. If we don't
-	// stall the handler, then the handler might write HEADERS and DATA and finish
-	// the stream before we check st.streamState(2) -- should that happen, we'll
-	// see stateClosed and fail the above check.
-	close(gotPromise)
-	st.wantHeaders()
-	if df := st.wantData(); !df.StreamEnded() {
-		t.Fatal("expected END_STREAM flag on DATA")
-	}
-	if got, want := st.streamState(2), stateClosed; got != want {
-		t.Fatalf("streamState(2)=%v, want %v", got, want)
-	}
-	close(finishedPush)
-}
-
-func TestServer_Push_RejectAfterGoAway(t *testing.T) {
-	var readyOnce sync.Once
-	ready := make(chan struct{})
-	errc := make(chan error, 2)
-	st := newServerTester(t, func(w http.ResponseWriter, r *http.Request) {
-		select {
-		case <-ready:
-		case <-time.After(5 * time.Second):
-			errc <- fmt.Errorf("timeout waiting for GOAWAY to be processed")
-		}
-		if got, want := w.(http.Pusher).Push("https://"+r.Host+"/pushed", nil), http.ErrNotSupported; got != want {
-			errc <- fmt.Errorf("Push()=%v, want %v", got, want)
-		}
-		errc <- nil
-	})
-	defer st.Close()
-	st.greet()
-	getSlash(st)
-
-	// Send GOAWAY and wait for it to be processed.
-	st.fr.WriteGoAway(1, ErrCodeNo, nil)
-	go func() {
-		for {
-			select {
-			case <-ready:
-				return
-			default:
-			}
-			st.sc.serveMsgCh <- func(loopNum int) {
-				if !st.sc.pushEnabled {
-					readyOnce.Do(func() { close(ready) })
-				}
-			}
-		}
-	}()
-	if err := <-errc; err != nil {
-		t.Error(err)
-	}
-}

vendor/golang.org/x/net/http2/write.go

@@ -1,370 +0,0 @@
-// Copyright 2014 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package http2
-
-import (
-	"bytes"
-	"fmt"
-	"log"
-	"net/http"
-	"net/url"
-	"time"
-
-	"golang.org/x/net/http2/hpack"
-	"golang.org/x/net/lex/httplex"
-)
-
-// writeFramer is implemented by any type that is used to write frames.
-type writeFramer interface {
-	writeFrame(writeContext) error
-
-	// staysWithinBuffer reports whether this writer promises that
-	// it will only write less than or equal to size bytes, and it
-	// won't Flush the write context.
-	staysWithinBuffer(size int) bool
-}
-
-// writeContext is the interface needed by the various frame writer
-// types below. All the writeFrame methods below are scheduled via the
-// frame writing scheduler (see writeScheduler in writesched.go).
-//
-// This interface is implemented by *serverConn.
-//
-// TODO: decide whether to a) use this in the client code (which didn't
-// end up using this yet, because it has a simpler design, not
-// currently implementing priorities), or b) delete this and
-// make the server code a bit more concrete.
-type writeContext interface {
-	Framer() *Framer
-	Flush() error
-	CloseConn() error
-	// HeaderEncoder returns an HPACK encoder that writes to the
-	// returned buffer.
-	HeaderEncoder() (*hpack.Encoder, *bytes.Buffer)
-}
-
-// writeEndsStream reports whether w writes a frame that will transition
-// the stream to a half-closed local state. This returns false for RST_STREAM,
-// which closes the entire stream (not just the local half).
-func writeEndsStream(w writeFramer) bool {
-	switch v := w.(type) {
-	case *writeData:
-		return v.endStream
-	case *writeResHeaders:
-		return v.endStream
-	case nil:
-		// This can only happen if the caller reuses w after it's
-		// been intentionally nil'ed out to prevent use. Keep this
-		// here to catch future refactoring breaking it.
-		panic("writeEndsStream called on nil writeFramer")
-	}
-	return false
-}
-
-type flushFrameWriter struct{}
-
-func (flushFrameWriter) writeFrame(ctx writeContext) error {
-	return ctx.Flush()
-}
-
-func (flushFrameWriter) staysWithinBuffer(max int) bool { return false }
-
-type writeSettings []Setting
-
-func (s writeSettings) staysWithinBuffer(max int) bool {
-	const settingSize = 6 // uint16 + uint32
-	return frameHeaderLen+settingSize*len(s) <= max
-
-}
-
-func (s writeSettings) writeFrame(ctx writeContext) error {
-	return ctx.Framer().WriteSettings([]Setting(s)...)
-}
-
-type writeGoAway struct {
-	maxStreamID uint32
-	code        ErrCode
-}
-
-func (p *writeGoAway) writeFrame(ctx writeContext) error {
-	err := ctx.Framer().WriteGoAway(p.maxStreamID, p.code, nil)
-	if p.code != 0 {
-		ctx.Flush() // ignore error: we're hanging up on them anyway
-		time.Sleep(50 * time.Millisecond)
-		ctx.CloseConn()
-	}
-	return err
-}
-
-func (*writeGoAway) staysWithinBuffer(max int) bool { return false } // flushes
-
-type writeData struct {
-	streamID  uint32
-	p         []byte
-	endStream bool
-}
-
-func (w *writeData) String() string {
-	return fmt.Sprintf("writeData(stream=%d, p=%d, endStream=%v)", w.streamID, len(w.p), w.endStream)
-}
-
-func (w *writeData) writeFrame(ctx writeContext) error {
-	return ctx.Framer().WriteData(w.streamID, w.endStream, w.p)
-}
-
-func (w *writeData) staysWithinBuffer(max int) bool {
-	return frameHeaderLen+len(w.p) <= max
-}
-
-// handlerPanicRST is the message sent from handler goroutines when
-// the handler panics.
-type handlerPanicRST struct {
-	StreamID uint32
-}
-
-func (hp handlerPanicRST) writeFrame(ctx writeContext) error {
-	return ctx.Framer().WriteRSTStream(hp.StreamID, ErrCodeInternal)
-}
-
-func (hp handlerPanicRST) staysWithinBuffer(max int) bool { return frameHeaderLen+4 <= max }
-
-func (se StreamError) writeFrame(ctx writeContext) error {
-	return ctx.Framer().WriteRSTStream(se.StreamID, se.Code)
-}
-
-func (se StreamError) staysWithinBuffer(max int) bool { return frameHeaderLen+4 <= max }
-
-type writePingAck struct{ pf *PingFrame }
-
-func (w writePingAck) writeFrame(ctx writeContext) error {
-	return ctx.Framer().WritePing(true, w.pf.Data)
-}
-
-func (w writePingAck) staysWithinBuffer(max int) bool { return frameHeaderLen+len(w.pf.Data) <= max }
-
-type writeSettingsAck struct{}
-
-func (writeSettingsAck) writeFrame(ctx writeContext) error {
-	return ctx.Framer().WriteSettingsAck()
-}
-
-func (writeSettingsAck) staysWithinBuffer(max int) bool { return frameHeaderLen <= max }
-
-// splitHeaderBlock splits headerBlock into fragments so that each fragment fits
-// in a single frame, then calls fn for each fragment. firstFrag/lastFrag are true
-// for the first/last fragment, respectively.
-func splitHeaderBlock(ctx writeContext, headerBlock []byte, fn func(ctx writeContext, frag []byte, firstFrag, lastFrag bool) error) error {
-	// For now we're lazy and just pick the minimum MAX_FRAME_SIZE
-	// that all peers must support (16KB). Later we could care
-	// more and send larger frames if the peer advertised it, but
-	// there's little point. Most headers are small anyway (so we
-	// generally won't have CONTINUATION frames), and extra frames
-	// only waste 9 bytes anyway.
-	const maxFrameSize = 16384
-
-	first := true
-	for len(headerBlock) > 0 {
-		frag := headerBlock
-		if len(frag) > maxFrameSize {
-			frag = frag[:maxFrameSize]
-		}
-		headerBlock = headerBlock[len(frag):]
-		if err := fn(ctx, frag, first, len(headerBlock) == 0); err != nil {
-			return err
-		}
-		first = false
-	}
-	return nil
-}
-
-// writeResHeaders is a request to write a HEADERS and 0+ CONTINUATION frames
-// for HTTP response headers or trailers from a server handler.
-type writeResHeaders struct {
-	streamID    uint32
-	httpResCode int         // 0 means no ":status" line
-	h           http.Header // may be nil
-	trailers    []string    // if non-nil, which keys of h to write. nil means all.
-	endStream   bool
-
-	date          string
-	contentType   string
-	contentLength string
-}
-
-func encKV(enc *hpack.Encoder, k, v string) {
-	if VerboseLogs {
-		log.Printf("http2: server encoding header %q = %q", k, v)
-	}
-	enc.WriteField(hpack.HeaderField{Name: k, Value: v})
-}
-
-func (w *writeResHeaders) staysWithinBuffer(max int) bool {
-	// TODO: this is a common one. It'd be nice to return true
-	// here and get into the fast path if we could be clever and
-	// calculate the size fast enough, or at least a conservative
-	// uppper bound that usually fires. (Maybe if w.h and
-	// w.trailers are nil, so we don't need to enumerate it.)
-	// Otherwise I'm afraid that just calculating the length to
-	// answer this question would be slower than the ~2µs benefit.
-	return false
-}
-
-func (w *writeResHeaders) writeFrame(ctx writeContext) error {
-	enc, buf := ctx.HeaderEncoder()
-	buf.Reset()
-
-	if w.httpResCode != 0 {
-		encKV(enc, ":status", httpCodeString(w.httpResCode))
-	}
-
-	encodeHeaders(enc, w.h, w.trailers)
-
-	if w.contentType != "" {
-		encKV(enc, "content-type", w.contentType)
-	}
-	if w.contentLength != "" {
-		encKV(enc, "content-length", w.contentLength)
-	}
-	if w.date != "" {
-		encKV(enc, "date", w.date)
-	}
-
-	headerBlock := buf.Bytes()
-	if len(headerBlock) == 0 && w.trailers == nil {
-		panic("unexpected empty hpack")
-	}
-
-	return splitHeaderBlock(ctx, headerBlock, w.writeHeaderBlock)
-}
-
-func (w *writeResHeaders) writeHeaderBlock(ctx writeContext, frag []byte, firstFrag, lastFrag bool) error {
-	if firstFrag {
-		return ctx.Framer().WriteHeaders(HeadersFrameParam{
-			StreamID:      w.streamID,
-			BlockFragment: frag,
-			EndStream:     w.endStream,
-			EndHeaders:    lastFrag,
-		})
-	} else {
-		return ctx.Framer().WriteContinuation(w.streamID, lastFrag, frag)
-	}
-}
-
-// writePushPromise is a request to write a PUSH_PROMISE and 0+ CONTINUATION frames.
-type writePushPromise struct {
-	streamID uint32   // pusher stream
-	method   string   // for :method
-	url      *url.URL // for :scheme, :authority, :path
-	h        http.Header
-
-	// Creates an ID for a pushed stream. This runs on serveG just before
-	// the frame is written. The returned ID is copied to promisedID.
-	allocatePromisedID func() (uint32, error)
-	promisedID         uint32
-}
-
-func (w *writePushPromise) staysWithinBuffer(max int) bool {
-	// TODO: see writeResHeaders.staysWithinBuffer
-	return false
-}
-
-func (w *writePushPromise) writeFrame(ctx writeContext) error {
-	enc, buf := ctx.HeaderEncoder()
-	buf.Reset()
-
-	encKV(enc, ":method", w.method)
-	encKV(enc, ":scheme", w.url.Scheme)
-	encKV(enc, ":authority", w.url.Host)
-	encKV(enc, ":path", w.url.RequestURI())
-	encodeHeaders(enc, w.h, nil)
-
-	headerBlock := buf.Bytes()
-	if len(headerBlock) == 0 {
-		panic("unexpected empty hpack")
-	}
-
-	return splitHeaderBlock(ctx, headerBlock, w.writeHeaderBlock)
-}
-
-func (w *writePushPromise) writeHeaderBlock(ctx writeContext, frag []byte, firstFrag, lastFrag bool) error {
-	if firstFrag {
-		return ctx.Framer().WritePushPromise(PushPromiseParam{
-			StreamID:      w.streamID,
-			PromiseID:     w.promisedID,
-			BlockFragment: frag,
-			EndHeaders:    lastFrag,
-		})
-	} else {
-		return ctx.Framer().WriteContinuation(w.streamID, lastFrag, frag)
-	}
-}
-
-type write100ContinueHeadersFrame struct {
-	streamID uint32
-}
-
-func (w write100ContinueHeadersFrame) writeFrame(ctx writeContext) error {
-	enc, buf := ctx.HeaderEncoder()
-	buf.Reset()
-	encKV(enc, ":status", "100")
-	return ctx.Framer().WriteHeaders(HeadersFrameParam{
-		StreamID:      w.streamID,
-		BlockFragment: buf.Bytes(),
-		EndStream:     false,
-		EndHeaders:    true,
-	})
-}
-
-func (w write100ContinueHeadersFrame) staysWithinBuffer(max int) bool {
-	// Sloppy but conservative:
-	return 9+2*(len(":status")+len("100")) <= max
-}
-
-type writeWindowUpdate struct {
-	streamID uint32 // or 0 for conn-level
-	n        uint32
-}
-
-func (wu writeWindowUpdate) staysWithinBuffer(max int) bool { return frameHeaderLen+4 <= max }
-
-func (wu writeWindowUpdate) writeFrame(ctx writeContext) error {
-	return ctx.Framer().WriteWindowUpdate(wu.streamID, wu.n)
-}
-
-// encodeHeaders encodes an http.Header. If keys is not nil, then (k, h[k])
-// is encoded only only if k is in keys.
-func encodeHeaders(enc *hpack.Encoder, h http.Header, keys []string) {
-	if keys == nil {
-		sorter := sorterPool.Get().(*sorter)
-		// Using defer here, since the returned keys from the
-		// sorter.Keys method is only valid until the sorter
-		// is returned:
-		defer sorterPool.Put(sorter)
-		keys = sorter.Keys(h)
-	}
-	for _, k := range keys {
-		vv := h[k]
-		k = lowerHeader(k)
-		if !validWireHeaderFieldName(k) {
-			// Skip it as backup paranoia. Per
-			// golang.org/issue/14048, these should
-			// already be rejected at a higher level.
-			continue
-		}
-		isTE := k == "transfer-encoding"
-		for _, v := range vv {
-			if !httplex.ValidHeaderFieldValue(v) {
-				// TODO: return an error? golang.org/issue/14048
-				// For now just omit it.
-				continue
-			}
-			// TODO: more of "8.1.2.2 Connection-Specific Header Fields"
-			if isTE && v != "trailers" {
-				continue
-			}
-			encKV(enc, k, v)
-		}
-	}
-}

vendor/golang.org/x/net/http2/writesched.go

@@ -1,242 +0,0 @@
-// Copyright 2014 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package http2
-
-import "fmt"
-
-// WriteScheduler is the interface implemented by HTTP/2 write schedulers.
-// Methods are never called concurrently.
-type WriteScheduler interface {
-	// OpenStream opens a new stream in the write scheduler.
-	// It is illegal to call this with streamID=0 or with a streamID that is
-	// already open -- the call may panic.
-	OpenStream(streamID uint32, options OpenStreamOptions)
-
-	// CloseStream closes a stream in the write scheduler. Any frames queued on
-	// this stream should be discarded. It is illegal to call this on a stream
-	// that is not open -- the call may panic.
-	CloseStream(streamID uint32)
-
-	// AdjustStream adjusts the priority of the given stream. This may be called
-	// on a stream that has not yet been opened or has been closed. Note that
-	// RFC 7540 allows PRIORITY frames to be sent on streams in any state. See:
-	// https://tools.ietf.org/html/rfc7540#section-5.1
-	AdjustStream(streamID uint32, priority PriorityParam)
-
-	// Push queues a frame in the scheduler. In most cases, this will not be
-	// called with wr.StreamID()!=0 unless that stream is currently open. The one
-	// exception is RST_STREAM frames, which may be sent on idle or closed streams.
-	Push(wr FrameWriteRequest)
-
-	// Pop dequeues the next frame to write. Returns false if no frames can
-	// be written. Frames with a given wr.StreamID() are Pop'd in the same
-	// order they are Push'd.
-	Pop() (wr FrameWriteRequest, ok bool)
-}
-
-// OpenStreamOptions specifies extra options for WriteScheduler.OpenStream.
-type OpenStreamOptions struct {
-	// PusherID is zero if the stream was initiated by the client. Otherwise,
-	// PusherID names the stream that pushed the newly opened stream.
-	PusherID uint32
-}
-
-// FrameWriteRequest is a request to write a frame.
-type FrameWriteRequest struct {
-	// write is the interface value that does the writing, once the
-	// WriteScheduler has selected this frame to write. The write
-	// functions are all defined in write.go.
-	write writeFramer
-
-	// stream is the stream on which this frame will be written.
-	// nil for non-stream frames like PING and SETTINGS.
-	stream *stream
-
-	// done, if non-nil, must be a buffered channel with space for
-	// 1 message and is sent the return value from write (or an
-	// earlier error) when the frame has been written.
-	done chan error
-}
-
-// StreamID returns the id of the stream this frame will be written to.
-// 0 is used for non-stream frames such as PING and SETTINGS.
-func (wr FrameWriteRequest) StreamID() uint32 {
-	if wr.stream == nil {
-		if se, ok := wr.write.(StreamError); ok {
-			// (*serverConn).resetStream doesn't set
-			// stream because it doesn't necessarily have
-			// one. So special case this type of write
-			// message.
-			return se.StreamID
-		}
-		return 0
-	}
-	return wr.stream.id
-}
-
-// DataSize returns the number of flow control bytes that must be consumed
-// to write this entire frame. This is 0 for non-DATA frames.
-func (wr FrameWriteRequest) DataSize() int {
-	if wd, ok := wr.write.(*writeData); ok {
-		return len(wd.p)
-	}
-	return 0
-}
-
-// Consume consumes min(n, available) bytes from this frame, where available
-// is the number of flow control bytes available on the stream. Consume returns
-// 0, 1, or 2 frames, where the integer return value gives the number of frames
-// returned.
-//
-// If flow control prevents consuming any bytes, this returns (_, _, 0). If
-// the entire frame was consumed, this returns (wr, _, 1). Otherwise, this
-// returns (consumed, rest, 2), where 'consumed' contains the consumed bytes and
-// 'rest' contains the remaining bytes. The consumed bytes are deducted from the
-// underlying stream's flow control budget.
-func (wr FrameWriteRequest) Consume(n int32) (FrameWriteRequest, FrameWriteRequest, int) {
-	var empty FrameWriteRequest
-
-	// Non-DATA frames are always consumed whole.
-	wd, ok := wr.write.(*writeData)
-	if !ok || len(wd.p) == 0 {
-		return wr, empty, 1
-	}
-
-	// Might need to split after applying limits.
-	allowed := wr.stream.flow.available()
-	if n < allowed {
-		allowed = n
-	}
-	if wr.stream.sc.maxFrameSize < allowed {
-		allowed = wr.stream.sc.maxFrameSize
-	}
-	if allowed <= 0 {
-		return empty, empty, 0
-	}
-	if len(wd.p) > int(allowed) {
-		wr.stream.flow.take(allowed)
-		consumed := FrameWriteRequest{
-			stream: wr.stream,
-			write: &writeData{
-				streamID: wd.streamID,
-				p:        wd.p[:allowed],
-				// Even if the original had endStream set, there
-				// are bytes remaining because len(wd.p) > allowed,
-				// so we know endStream is false.
-				endStream: false,
-			},
-			// Our caller is blocking on the final DATA frame, not
-			// this intermediate frame, so no need to wait.
-			done: nil,
-		}
-		rest := FrameWriteRequest{
-			stream: wr.stream,
-			write: &writeData{
-				streamID:  wd.streamID,
-				p:         wd.p[allowed:],
-				endStream: wd.endStream,
-			},
-			done: wr.done,
-		}
-		return consumed, rest, 2
-	}
-
-	// The frame is consumed whole.
-	// NB: This cast cannot overflow because allowed is <= math.MaxInt32.
-	wr.stream.flow.take(int32(len(wd.p)))
-	return wr, empty, 1
-}
-
-// String is for debugging only.
-func (wr FrameWriteRequest) String() string {
-	var des string
-	if s, ok := wr.write.(fmt.Stringer); ok {
-		des = s.String()
-	} else {
-		des = fmt.Sprintf("%T", wr.write)
-	}
-	return fmt.Sprintf("[FrameWriteRequest stream=%d, ch=%v, writer=%v]", wr.StreamID(), wr.done != nil, des)
-}
-
-// replyToWriter sends err to wr.done and panics if the send must block
-// This does nothing if wr.done is nil.
-func (wr *FrameWriteRequest) replyToWriter(err error) {
-	if wr.done == nil {
-		return
-	}
-	select {
-	case wr.done <- err:
-	default:
-		panic(fmt.Sprintf("unbuffered done channel passed in for type %T", wr.write))
-	}
-	wr.write = nil // prevent use (assume it's tainted after wr.done send)
-}
-
-// writeQueue is used by implementations of WriteScheduler.
-type writeQueue struct {
-	s []FrameWriteRequest
-}
-
-func (q *writeQueue) empty() bool { return len(q.s) == 0 }
-
-func (q *writeQueue) push(wr FrameWriteRequest) {
-	q.s = append(q.s, wr)
-}
-
-func (q *writeQueue) shift() FrameWriteRequest {
-	if len(q.s) == 0 {
-		panic("invalid use of queue")
-	}
-	wr := q.s[0]
-	// TODO: less copy-happy queue.
-	copy(q.s, q.s[1:])
-	q.s[len(q.s)-1] = FrameWriteRequest{}
-	q.s = q.s[:len(q.s)-1]
-	return wr
-}
-
-// consume consumes up to n bytes from q.s[0]. If the frame is
-// entirely consumed, it is removed from the queue. If the frame
-// is partially consumed, the frame is kept with the consumed
-// bytes removed. Returns true iff any bytes were consumed.
-func (q *writeQueue) consume(n int32) (FrameWriteRequest, bool) {
-	if len(q.s) == 0 {
-		return FrameWriteRequest{}, false
-	}
-	consumed, rest, numresult := q.s[0].Consume(n)
-	switch numresult {
-	case 0:
-		return FrameWriteRequest{}, false
-	case 1:
-		q.shift()
-	case 2:
-		q.s[0] = rest
-	}
-	return consumed, true
-}
-
-type writeQueuePool []*writeQueue
-
-// put inserts an unused writeQueue into the pool.
-func (p *writeQueuePool) put(q *writeQueue) {
-	for i := range q.s {
-		q.s[i] = FrameWriteRequest{}
-	}
-	q.s = q.s[:0]
-	*p = append(*p, q)
-}
-
-// get returns an empty writeQueue.
-func (p *writeQueuePool) get() *writeQueue {
-	ln := len(*p)
-	if ln == 0 {
-		return new(writeQueue)
-	}
-	x := ln - 1
-	q := (*p)[x]
-	(*p)[x] = nil
-	*p = (*p)[:x]
-	return q
-}

vendor/golang.org/x/net/http2/writesched_priority.go

@@ -1,452 +0,0 @@
-// Copyright 2016 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package http2
-
-import (
-	"fmt"
-	"math"
-	"sort"
-)
-
-// RFC 7540, Section 5.3.5: the default weight is 16.
-const priorityDefaultWeight = 15 // 16 = 15 + 1
-
-// PriorityWriteSchedulerConfig configures a priorityWriteScheduler.
-type PriorityWriteSchedulerConfig struct {
-	// MaxClosedNodesInTree controls the maximum number of closed streams to
-	// retain in the priority tree. Setting this to zero saves a small amount
-	// of memory at the cost of performance.
-	//
-	// See RFC 7540, Section 5.3.4:
-	//   "It is possible for a stream to become closed while prioritization
-	//   information ... is in transit. ... This potentially creates suboptimal
-	//   prioritization, since the stream could be given a priority that is
-	//   different from what is intended. To avoid these problems, an endpoint
-	//   SHOULD retain stream prioritization state for a period after streams
-	//   become closed. The longer state is retained, the lower the chance that
-	//   streams are assigned incorrect or default priority values."
-	MaxClosedNodesInTree int
-
-	// MaxIdleNodesInTree controls the maximum number of idle streams to
-	// retain in the priority tree. Setting this to zero saves a small amount
-	// of memory at the cost of performance.
-	//
-	// See RFC 7540, Section 5.3.4:
-	//   Similarly, streams that are in the "idle" state can be assigned
-	//   priority or become a parent of other streams. This allows for the
-	//   creation of a grouping node in the dependency tree, which enables
-	//   more flexible expressions of priority. Idle streams begin with a
-	//   default priority (Section 5.3.5).
-	MaxIdleNodesInTree int
-
-	// ThrottleOutOfOrderWrites enables write throttling to help ensure that
-	// data is delivered in priority order. This works around a race where
-	// stream B depends on stream A and both streams are about to call Write
-	// to queue DATA frames. If B wins the race, a naive scheduler would eagerly
-	// write as much data from B as possible, but this is suboptimal because A
-	// is a higher-priority stream. With throttling enabled, we write a small
-	// amount of data from B to minimize the amount of bandwidth that B can
-	// steal from A.
-	ThrottleOutOfOrderWrites bool
-}
-
-// NewPriorityWriteScheduler constructs a WriteScheduler that schedules
-// frames by following HTTP/2 priorities as described in RFC 7540 Section 5.3.
-// If cfg is nil, default options are used.
-func NewPriorityWriteScheduler(cfg *PriorityWriteSchedulerConfig) WriteScheduler {
-	if cfg == nil {
-		// For justification of these defaults, see:
-		// https://docs.google.com/document/d/1oLhNg1skaWD4_DtaoCxdSRN5erEXrH-KnLrMwEpOtFY
-		cfg = &PriorityWriteSchedulerConfig{
-			MaxClosedNodesInTree:     10,
-			MaxIdleNodesInTree:       10,
-			ThrottleOutOfOrderWrites: false,
-		}
-	}
-
-	ws := &priorityWriteScheduler{
-		nodes:                make(map[uint32]*priorityNode),
-		maxClosedNodesInTree: cfg.MaxClosedNodesInTree,
-		maxIdleNodesInTree:   cfg.MaxIdleNodesInTree,
-		enableWriteThrottle:  cfg.ThrottleOutOfOrderWrites,
-	}
-	ws.nodes[0] = &ws.root
-	if cfg.ThrottleOutOfOrderWrites {
-		ws.writeThrottleLimit = 1024
-	} else {
-		ws.writeThrottleLimit = math.MaxInt32
-	}
-	return ws
-}
-
-type priorityNodeState int
-
-const (
-	priorityNodeOpen priorityNodeState = iota
-	priorityNodeClosed
-	priorityNodeIdle
-)
-
-// priorityNode is a node in an HTTP/2 priority tree.
-// Each node is associated with a single stream ID.
-// See RFC 7540, Section 5.3.
-type priorityNode struct {
-	q            writeQueue        // queue of pending frames to write
-	id           uint32            // id of the stream, or 0 for the root of the tree
-	weight       uint8             // the actual weight is weight+1, so the value is in [1,256]
-	state        priorityNodeState // open | closed | idle
-	bytes        int64             // number of bytes written by this node, or 0 if closed
-	subtreeBytes int64             // sum(node.bytes) of all nodes in this subtree
-
-	// These links form the priority tree.
-	parent     *priorityNode
-	kids       *priorityNode // start of the kids list
-	prev, next *priorityNode // doubly-linked list of siblings
-}
-
-func (n *priorityNode) setParent(parent *priorityNode) {
-	if n == parent {
-		panic("setParent to self")
-	}
-	if n.parent == parent {
-		return
-	}
-	// Unlink from current parent.
-	if parent := n.parent; parent != nil {
-		if n.prev == nil {
-			parent.kids = n.next
-		} else {
-			n.prev.next = n.next
-		}
-		if n.next != nil {
-			n.next.prev = n.prev
-		}
-	}
-	// Link to new parent.
-	// If parent=nil, remove n from the tree.
-	// Always insert at the head of parent.kids (this is assumed by walkReadyInOrder).
-	n.parent = parent
-	if parent == nil {
-		n.next = nil
-		n.prev = nil
-	} else {
-		n.next = parent.kids
-		n.prev = nil
-		if n.next != nil {
-			n.next.prev = n
-		}
-		parent.kids = n
-	}
-}
-
-func (n *priorityNode) addBytes(b int64) {
-	n.bytes += b
-	for ; n != nil; n = n.parent {
-		n.subtreeBytes += b
-	}
-}
-
-// walkReadyInOrder iterates over the tree in priority order, calling f for each node
-// with a non-empty write queue. When f returns true, this funcion returns true and the
-// walk halts. tmp is used as scratch space for sorting.
-//
-// f(n, openParent) takes two arguments: the node to visit, n, and a bool that is true
-// if any ancestor p of n is still open (ignoring the root node).
-func (n *priorityNode) walkReadyInOrder(openParent bool, tmp *[]*priorityNode, f func(*priorityNode, bool) bool) bool {
-	if !n.q.empty() && f(n, openParent) {
-		return true
-	}
-	if n.kids == nil {
-		return false
-	}
-
-	// Don't consider the root "open" when updating openParent since
-	// we can't send data frames on the root stream (only control frames).
-	if n.id != 0 {
-		openParent = openParent || (n.state == priorityNodeOpen)
-	}
-
-	// Common case: only one kid or all kids have the same weight.
-	// Some clients don't use weights; other clients (like web browsers)
-	// use mostly-linear priority trees.
-	w := n.kids.weight
-	needSort := false
-	for k := n.kids.next; k != nil; k = k.next {
-		if k.weight != w {
-			needSort = true
-			break
-		}
-	}
-	if !needSort {
-		for k := n.kids; k != nil; k = k.next {
-			if k.walkReadyInOrder(openParent, tmp, f) {
-				return true
-			}
-		}
-		return false
-	}
-
-	// Uncommon case: sort the child nodes. We remove the kids from the parent,
-	// then re-insert after sorting so we can reuse tmp for future sort calls.
-	*tmp = (*tmp)[:0]
-	for n.kids != nil {
-		*tmp = append(*tmp, n.kids)
-		n.kids.setParent(nil)
-	}
-	sort.Sort(sortPriorityNodeSiblings(*tmp))
-	for i := len(*tmp) - 1; i >= 0; i-- {
-		(*tmp)[i].setParent(n) // setParent inserts at the head of n.kids
-	}
-	for k := n.kids; k != nil; k = k.next {
-		if k.walkReadyInOrder(openParent, tmp, f) {
-			return true
-		}
-	}
-	return false
-}
-
-type sortPriorityNodeSiblings []*priorityNode
-
-func (z sortPriorityNodeSiblings) Len() int      { return len(z) }
-func (z sortPriorityNodeSiblings) Swap(i, k int) { z[i], z[k] = z[k], z[i] }
-func (z sortPriorityNodeSiblings) Less(i, k int) bool {
-	// Prefer the subtree that has sent fewer bytes relative to its weight.
-	// See sections 5.3.2 and 5.3.4.
-	wi, bi := float64(z[i].weight+1), float64(z[i].subtreeBytes)
-	wk, bk := float64(z[k].weight+1), float64(z[k].subtreeBytes)
-	if bi == 0 && bk == 0 {
-		return wi >= wk
-	}
-	if bk == 0 {
-		return false
-	}
-	return bi/bk <= wi/wk
-}
-
-type priorityWriteScheduler struct {
-	// root is the root of the priority tree, where root.id = 0.
-	// The root queues control frames that are not associated with any stream.
-	root priorityNode
-
-	// nodes maps stream ids to priority tree nodes.
-	nodes map[uint32]*priorityNode
-
-	// maxID is the maximum stream id in nodes.
-	maxID uint32
-
-	// lists of nodes that have been closed or are idle, but are kept in
-	// the tree for improved prioritization. When the lengths exceed either
-	// maxClosedNodesInTree or maxIdleNodesInTree, old nodes are discarded.
-	closedNodes, idleNodes []*priorityNode
-
-	// From the config.
-	maxClosedNodesInTree int
-	maxIdleNodesInTree   int
-	writeThrottleLimit   int32
-	enableWriteThrottle  bool
-
-	// tmp is scratch space for priorityNode.walkReadyInOrder to reduce allocations.
-	tmp []*priorityNode
-
-	// pool of empty queues for reuse.
-	queuePool writeQueuePool
-}
-
-func (ws *priorityWriteScheduler) OpenStream(streamID uint32, options OpenStreamOptions) {
-	// The stream may be currently idle but cannot be opened or closed.
-	if curr := ws.nodes[streamID]; curr != nil {
-		if curr.state != priorityNodeIdle {
-			panic(fmt.Sprintf("stream %d already opened", streamID))
-		}
-		curr.state = priorityNodeOpen
-		return
-	}
-
-	// RFC 7540, Section 5.3.5:
-	//  "All streams are initially assigned a non-exclusive dependency on stream 0x0.
-	//  Pushed streams initially depend on their associated stream. In both cases,
-	//  streams are assigned a default weight of 16."
-	parent := ws.nodes[options.PusherID]
-	if parent == nil {
-		parent = &ws.root
-	}
-	n := &priorityNode{
-		q:      *ws.queuePool.get(),
-		id:     streamID,
-		weight: priorityDefaultWeight,
-		state:  priorityNodeOpen,
-	}
-	n.setParent(parent)
-	ws.nodes[streamID] = n
-	if streamID > ws.maxID {
-		ws.maxID = streamID
-	}
-}
-
-func (ws *priorityWriteScheduler) CloseStream(streamID uint32) {
-	if streamID == 0 {
-		panic("violation of WriteScheduler interface: cannot close stream 0")
-	}
-	if ws.nodes[streamID] == nil {
-		panic(fmt.Sprintf("violation of WriteScheduler interface: unknown stream %d", streamID))
-	}
-	if ws.nodes[streamID].state != priorityNodeOpen {
-		panic(fmt.Sprintf("violation of WriteScheduler interface: stream %d already closed", streamID))
-	}
-
-	n := ws.nodes[streamID]
-	n.state = priorityNodeClosed
-	n.addBytes(-n.bytes)
-
-	q := n.q
-	ws.queuePool.put(&q)
-	n.q.s = nil
-	if ws.maxClosedNodesInTree > 0 {
-		ws.addClosedOrIdleNode(&ws.closedNodes, ws.maxClosedNodesInTree, n)
-	} else {
-		ws.removeNode(n)
-	}
-}
-
-func (ws *priorityWriteScheduler) AdjustStream(streamID uint32, priority PriorityParam) {
-	if streamID == 0 {
-		panic("adjustPriority on root")
-	}
-
-	// If streamID does not exist, there are two cases:
-	// - A closed stream that has been removed (this will have ID <= maxID)
-	// - An idle stream that is being used for "grouping" (this will have ID > maxID)
-	n := ws.nodes[streamID]
-	if n == nil {
-		if streamID <= ws.maxID || ws.maxIdleNodesInTree == 0 {
-			return
-		}
-		ws.maxID = streamID
-		n = &priorityNode{
-			q:      *ws.queuePool.get(),
-			id:     streamID,
-			weight: priorityDefaultWeight,
-			state:  priorityNodeIdle,
-		}
-		n.setParent(&ws.root)
-		ws.nodes[streamID] = n
-		ws.addClosedOrIdleNode(&ws.idleNodes, ws.maxIdleNodesInTree, n)
-	}
-
-	// Section 5.3.1: A dependency on a stream that is not currently in the tree
-	// results in that stream being given a default priority (Section 5.3.5).
-	parent := ws.nodes[priority.StreamDep]
-	if parent == nil {
-		n.setParent(&ws.root)
-		n.weight = priorityDefaultWeight
-		return
-	}
-
-	// Ignore if the client tries to make a node its own parent.
-	if n == parent {
-		return
-	}
-
-	// Section 5.3.3:
-	//   "If a stream is made dependent on one of its own dependencies, the
-	//   formerly dependent stream is first moved to be dependent on the
-	//   reprioritized stream's previous parent. The moved dependency retains
-	//   its weight."
-	//
-	// That is: if parent depends on n, move parent to depend on n.parent.
-	for x := parent.parent; x != nil; x = x.parent {
-		if x == n {
-			parent.setParent(n.parent)
-			break
-		}
-	}
-
-	// Section 5.3.3: The exclusive flag causes the stream to become the sole
-	// dependency of its parent stream, causing other dependencies to become
-	// dependent on the exclusive stream.
-	if priority.Exclusive {
-		k := parent.kids
-		for k != nil {
-			next := k.next
-			if k != n {
-				k.setParent(n)
-			}
-			k = next
-		}
-	}
-
-	n.setParent(parent)
-	n.weight = priority.Weight
-}
-
-func (ws *priorityWriteScheduler) Push(wr FrameWriteRequest) {
-	var n *priorityNode
-	if id := wr.StreamID(); id == 0 {
-		n = &ws.root
-	} else {
-		n = ws.nodes[id]
-		if n == nil {
-			// id is an idle or closed stream. wr should not be a HEADERS or
-			// DATA frame. However, wr can be a RST_STREAM. In this case, we
-			// push wr onto the root, rather than creating a new priorityNode,
-			// since RST_STREAM is tiny and the stream's priority is unknown
-			// anyway. See issue #17919.
-			if wr.DataSize() > 0 {
-				panic("add DATA on non-open stream")
-			}
-			n = &ws.root
-		}
-	}
-	n.q.push(wr)
-}
-
-func (ws *priorityWriteScheduler) Pop() (wr FrameWriteRequest, ok bool) {
-	ws.root.walkReadyInOrder(false, &ws.tmp, func(n *priorityNode, openParent bool) bool {
-		limit := int32(math.MaxInt32)
-		if openParent {
-			limit = ws.writeThrottleLimit
-		}
-		wr, ok = n.q.consume(limit)
-		if !ok {
-			return false
-		}
-		n.addBytes(int64(wr.DataSize()))
-		// If B depends on A and B continuously has data available but A
-		// does not, gradually increase the throttling limit to allow B to
-		// steal more and more bandwidth from A.
-		if openParent {
-			ws.writeThrottleLimit += 1024
-			if ws.writeThrottleLimit < 0 {
-				ws.writeThrottleLimit = math.MaxInt32
-			}
-		} else if ws.enableWriteThrottle {
-			ws.writeThrottleLimit = 1024
-		}
-		return true
-	})
-	return wr, ok
-}
-
-func (ws *priorityWriteScheduler) addClosedOrIdleNode(list *[]*priorityNode, maxSize int, n *priorityNode) {
-	if maxSize == 0 {
-		return
-	}
-	if len(*list) == maxSize {
-		// Remove the oldest node, then shift left.
-		ws.removeNode((*list)[0])
-		x := (*list)[1:]
-		copy(*list, x)
-		*list = (*list)[:len(x)]
-	}
-	*list = append(*list, n)
-}
-
-func (ws *priorityWriteScheduler) removeNode(n *priorityNode) {
-	for k := n.kids; k != nil; k = k.next {
-		k.setParent(n.parent)
-	}
-	n.setParent(nil)
-	delete(ws.nodes, n.id)
-}

vendor/golang.org/x/net/http2/writesched_priority_test.go

@@ -1,541 +0,0 @@
-// Copyright 2016 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package http2
-
-import (
-	"bytes"
-	"fmt"
-	"sort"
-	"testing"
-)
-
-func defaultPriorityWriteScheduler() *priorityWriteScheduler {
-	return NewPriorityWriteScheduler(nil).(*priorityWriteScheduler)
-}
-
-func checkPriorityWellFormed(ws *priorityWriteScheduler) error {
-	for id, n := range ws.nodes {
-		if id != n.id {
-			return fmt.Errorf("bad ws.nodes: ws.nodes[%d] = %d", id, n.id)
-		}
-		if n.parent == nil {
-			if n.next != nil || n.prev != nil {
-				return fmt.Errorf("bad node %d: nil parent but prev/next not nil", id)
-			}
-			continue
-		}
-		found := false
-		for k := n.parent.kids; k != nil; k = k.next {
-			if k.id == id {
-				found = true
-				break
-			}
-		}
-		if !found {
-			return fmt.Errorf("bad node %d: not found in parent %d kids list", id, n.parent.id)
-		}
-	}
-	return nil
-}
-
-func fmtTree(ws *priorityWriteScheduler, fmtNode func(*priorityNode) string) string {
-	var ids []int
-	for _, n := range ws.nodes {
-		ids = append(ids, int(n.id))
-	}
-	sort.Ints(ids)
-
-	var buf bytes.Buffer
-	for _, id := range ids {
-		if buf.Len() != 0 {
-			buf.WriteString(" ")
-		}
-		if id == 0 {
-			buf.WriteString(fmtNode(&ws.root))
-		} else {
-			buf.WriteString(fmtNode(ws.nodes[uint32(id)]))
-		}
-	}
-	return buf.String()
-}
-
-func fmtNodeParentSkipRoot(n *priorityNode) string {
-	switch {
-	case n.id == 0:
-		return ""
-	case n.parent == nil:
-		return fmt.Sprintf("%d{parent:nil}", n.id)
-	default:
-		return fmt.Sprintf("%d{parent:%d}", n.id, n.parent.id)
-	}
-}
-
-func fmtNodeWeightParentSkipRoot(n *priorityNode) string {
-	switch {
-	case n.id == 0:
-		return ""
-	case n.parent == nil:
-		return fmt.Sprintf("%d{weight:%d,parent:nil}", n.id, n.weight)
-	default:
-		return fmt.Sprintf("%d{weight:%d,parent:%d}", n.id, n.weight, n.parent.id)
-	}
-}
-
-func TestPriorityTwoStreams(t *testing.T) {
-	ws := defaultPriorityWriteScheduler()
-	ws.OpenStream(1, OpenStreamOptions{})
-	ws.OpenStream(2, OpenStreamOptions{})
-
-	want := "1{weight:15,parent:0} 2{weight:15,parent:0}"
-	if got := fmtTree(ws, fmtNodeWeightParentSkipRoot); got != want {
-		t.Errorf("After open\ngot  %q\nwant %q", got, want)
-	}
-
-	// Move 1's parent to 2.
-	ws.AdjustStream(1, PriorityParam{
-		StreamDep: 2,
-		Weight:    32,
-		Exclusive: false,
-	})
-	want = "1{weight:32,parent:2} 2{weight:15,parent:0}"
-	if got := fmtTree(ws, fmtNodeWeightParentSkipRoot); got != want {
-		t.Errorf("After adjust\ngot  %q\nwant %q", got, want)
-	}
-
-	if err := checkPriorityWellFormed(ws); err != nil {
-		t.Error(err)
-	}
-}
-
-func TestPriorityAdjustExclusiveZero(t *testing.T) {
-	// 1, 2, and 3 are all children of the 0 stream.
-	// Exclusive reprioritization to any of the streams should bring
-	// the rest of the streams under the reprioritized stream.
-	ws := defaultPriorityWriteScheduler()
-	ws.OpenStream(1, OpenStreamOptions{})
-	ws.OpenStream(2, OpenStreamOptions{})
-	ws.OpenStream(3, OpenStreamOptions{})
-
-	want := "1{weight:15,parent:0} 2{weight:15,parent:0} 3{weight:15,parent:0}"
-	if got := fmtTree(ws, fmtNodeWeightParentSkipRoot); got != want {
-		t.Errorf("After open\ngot  %q\nwant %q", got, want)
-	}
-
-	ws.AdjustStream(2, PriorityParam{
-		StreamDep: 0,
-		Weight:    20,
-		Exclusive: true,
-	})
-	want = "1{weight:15,parent:2} 2{weight:20,parent:0} 3{weight:15,parent:2}"
-	if got := fmtTree(ws, fmtNodeWeightParentSkipRoot); got != want {
-		t.Errorf("After adjust\ngot  %q\nwant %q", got, want)
-	}
-
-	if err := checkPriorityWellFormed(ws); err != nil {
-		t.Error(err)
-	}
-}
-
-func TestPriorityAdjustOwnParent(t *testing.T) {
-	// Assigning a node as its own parent should have no effect.
-	ws := defaultPriorityWriteScheduler()
-	ws.OpenStream(1, OpenStreamOptions{})
-	ws.OpenStream(2, OpenStreamOptions{})
-	ws.AdjustStream(2, PriorityParam{
-		StreamDep: 2,
-		Weight:    20,
-		Exclusive: true,
-	})
-	want := "1{weight:15,parent:0} 2{weight:15,parent:0}"
-	if got := fmtTree(ws, fmtNodeWeightParentSkipRoot); got != want {
-		t.Errorf("After adjust\ngot  %q\nwant %q", got, want)
-	}
-	if err := checkPriorityWellFormed(ws); err != nil {
-		t.Error(err)
-	}
-}
-
-func TestPriorityClosedStreams(t *testing.T) {
-	ws := NewPriorityWriteScheduler(&PriorityWriteSchedulerConfig{MaxClosedNodesInTree: 2}).(*priorityWriteScheduler)
-	ws.OpenStream(1, OpenStreamOptions{})
-	ws.OpenStream(2, OpenStreamOptions{PusherID: 1})
-	ws.OpenStream(3, OpenStreamOptions{PusherID: 2})
-	ws.OpenStream(4, OpenStreamOptions{PusherID: 3})
-
-	// Close the first three streams. We lose 1, but keep 2 and 3.
-	ws.CloseStream(1)
-	ws.CloseStream(2)
-	ws.CloseStream(3)
-
-	want := "2{weight:15,parent:0} 3{weight:15,parent:2} 4{weight:15,parent:3}"
-	if got := fmtTree(ws, fmtNodeWeightParentSkipRoot); got != want {
-		t.Errorf("After close\ngot  %q\nwant %q", got, want)
-	}
-	if err := checkPriorityWellFormed(ws); err != nil {
-		t.Error(err)
-	}
-
-	// Adding a stream as an exclusive child of 1 gives it default
-	// priorities, since 1 is gone.
-	ws.OpenStream(5, OpenStreamOptions{})
-	ws.AdjustStream(5, PriorityParam{StreamDep: 1, Weight: 15, Exclusive: true})
-
-	// Adding a stream as an exclusive child of 2 should work, since 2 is not gone.
-	ws.OpenStream(6, OpenStreamOptions{})
-	ws.AdjustStream(6, PriorityParam{StreamDep: 2, Weight: 15, Exclusive: true})
-
-	want = "2{weight:15,parent:0} 3{weight:15,parent:6} 4{weight:15,parent:3} 5{weight:15,parent:0} 6{weight:15,parent:2}"
-	if got := fmtTree(ws, fmtNodeWeightParentSkipRoot); got != want {
-		t.Errorf("After add streams\ngot  %q\nwant %q", got, want)
-	}
-	if err := checkPriorityWellFormed(ws); err != nil {
-		t.Error(err)
-	}
-}
-
-func TestPriorityClosedStreamsDisabled(t *testing.T) {
-	ws := NewPriorityWriteScheduler(&PriorityWriteSchedulerConfig{}).(*priorityWriteScheduler)
-	ws.OpenStream(1, OpenStreamOptions{})
-	ws.OpenStream(2, OpenStreamOptions{PusherID: 1})
-	ws.OpenStream(3, OpenStreamOptions{PusherID: 2})
-
-	// Close the first two streams. We keep only 3.
-	ws.CloseStream(1)
-	ws.CloseStream(2)
-
-	want := "3{weight:15,parent:0}"
-	if got := fmtTree(ws, fmtNodeWeightParentSkipRoot); got != want {
-		t.Errorf("After close\ngot  %q\nwant %q", got, want)
-	}
-	if err := checkPriorityWellFormed(ws); err != nil {
-		t.Error(err)
-	}
-}
-
-func TestPriorityIdleStreams(t *testing.T) {
-	ws := NewPriorityWriteScheduler(&PriorityWriteSchedulerConfig{MaxIdleNodesInTree: 2}).(*priorityWriteScheduler)
-	ws.AdjustStream(1, PriorityParam{StreamDep: 0, Weight: 15}) // idle
-	ws.AdjustStream(2, PriorityParam{StreamDep: 0, Weight: 15}) // idle
-	ws.AdjustStream(3, PriorityParam{StreamDep: 2, Weight: 20}) // idle
-	ws.OpenStream(4, OpenStreamOptions{})
-	ws.OpenStream(5, OpenStreamOptions{})
-	ws.OpenStream(6, OpenStreamOptions{})
-	ws.AdjustStream(4, PriorityParam{StreamDep: 1, Weight: 15})
-	ws.AdjustStream(5, PriorityParam{StreamDep: 2, Weight: 15})
-	ws.AdjustStream(6, PriorityParam{StreamDep: 3, Weight: 15})
-
-	want := "2{weight:15,parent:0} 3{weight:20,parent:2} 4{weight:15,parent:0} 5{weight:15,parent:2} 6{weight:15,parent:3}"
-	if got := fmtTree(ws, fmtNodeWeightParentSkipRoot); got != want {
-		t.Errorf("After open\ngot  %q\nwant %q", got, want)
-	}
-	if err := checkPriorityWellFormed(ws); err != nil {
-		t.Error(err)
-	}
-}
-
-func TestPriorityIdleStreamsDisabled(t *testing.T) {
-	ws := NewPriorityWriteScheduler(&PriorityWriteSchedulerConfig{}).(*priorityWriteScheduler)
-	ws.AdjustStream(1, PriorityParam{StreamDep: 0, Weight: 15}) // idle
-	ws.AdjustStream(2, PriorityParam{StreamDep: 0, Weight: 15}) // idle
-	ws.AdjustStream(3, PriorityParam{StreamDep: 2, Weight: 20}) // idle
-	ws.OpenStream(4, OpenStreamOptions{})
-
-	want := "4{weight:15,parent:0}"
-	if got := fmtTree(ws, fmtNodeWeightParentSkipRoot); got != want {
-		t.Errorf("After open\ngot  %q\nwant %q", got, want)
-	}
-	if err := checkPriorityWellFormed(ws); err != nil {
-		t.Error(err)
-	}
-}
-
-func TestPrioritySection531NonExclusive(t *testing.T) {
-	// Example from RFC 7540 Section 5.3.1.
-	// A,B,C,D = 1,2,3,4
-	ws := defaultPriorityWriteScheduler()
-	ws.OpenStream(1, OpenStreamOptions{})
-	ws.OpenStream(2, OpenStreamOptions{PusherID: 1})
-	ws.OpenStream(3, OpenStreamOptions{PusherID: 1})
-	ws.OpenStream(4, OpenStreamOptions{})
-	ws.AdjustStream(4, PriorityParam{
-		StreamDep: 1,
-		Weight:    15,
-		Exclusive: false,
-	})
-	want := "1{parent:0} 2{parent:1} 3{parent:1} 4{parent:1}"
-	if got := fmtTree(ws, fmtNodeParentSkipRoot); got != want {
-		t.Errorf("After adjust\ngot  %q\nwant %q", got, want)
-	}
-	if err := checkPriorityWellFormed(ws); err != nil {
-		t.Error(err)
-	}
-}
-
-func TestPrioritySection531Exclusive(t *testing.T) {
-	// Example from RFC 7540 Section 5.3.1.
-	// A,B,C,D = 1,2,3,4
-	ws := defaultPriorityWriteScheduler()
-	ws.OpenStream(1, OpenStreamOptions{})
-	ws.OpenStream(2, OpenStreamOptions{PusherID: 1})
-	ws.OpenStream(3, OpenStreamOptions{PusherID: 1})
-	ws.OpenStream(4, OpenStreamOptions{})
-	ws.AdjustStream(4, PriorityParam{
-		StreamDep: 1,
-		Weight:    15,
-		Exclusive: true,
-	})
-	want := "1{parent:0} 2{parent:4} 3{parent:4} 4{parent:1}"
-	if got := fmtTree(ws, fmtNodeParentSkipRoot); got != want {
-		t.Errorf("After adjust\ngot  %q\nwant %q", got, want)
-	}
-	if err := checkPriorityWellFormed(ws); err != nil {
-		t.Error(err)
-	}
-}
-
-func makeSection533Tree() *priorityWriteScheduler {
-	// Initial tree from RFC 7540 Section 5.3.3.
-	// A,B,C,D,E,F = 1,2,3,4,5,6
-	ws := defaultPriorityWriteScheduler()
-	ws.OpenStream(1, OpenStreamOptions{})
-	ws.OpenStream(2, OpenStreamOptions{PusherID: 1})
-	ws.OpenStream(3, OpenStreamOptions{PusherID: 1})
-	ws.OpenStream(4, OpenStreamOptions{PusherID: 3})
-	ws.OpenStream(5, OpenStreamOptions{PusherID: 3})
-	ws.OpenStream(6, OpenStreamOptions{PusherID: 4})
-	return ws
-}
-
-func TestPrioritySection533NonExclusive(t *testing.T) {
-	// Example from RFC 7540 Section 5.3.3.
-	// A,B,C,D,E,F = 1,2,3,4,5,6
-	ws := defaultPriorityWriteScheduler()
-	ws.OpenStream(1, OpenStreamOptions{})
-	ws.OpenStream(2, OpenStreamOptions{PusherID: 1})
-	ws.OpenStream(3, OpenStreamOptions{PusherID: 1})
-	ws.OpenStream(4, OpenStreamOptions{PusherID: 3})
-	ws.OpenStream(5, OpenStreamOptions{PusherID: 3})
-	ws.OpenStream(6, OpenStreamOptions{PusherID: 4})
-	ws.AdjustStream(1, PriorityParam{
-		StreamDep: 4,
-		Weight:    15,
-		Exclusive: false,
-	})
-	want := "1{parent:4} 2{parent:1} 3{parent:1} 4{parent:0} 5{parent:3} 6{parent:4}"
-	if got := fmtTree(ws, fmtNodeParentSkipRoot); got != want {
-		t.Errorf("After adjust\ngot  %q\nwant %q", got, want)
-	}
-	if err := checkPriorityWellFormed(ws); err != nil {
-		t.Error(err)
-	}
-}
-
-func TestPrioritySection533Exclusive(t *testing.T) {
-	// Example from RFC 7540 Section 5.3.3.
-	// A,B,C,D,E,F = 1,2,3,4,5,6
-	ws := defaultPriorityWriteScheduler()
-	ws.OpenStream(1, OpenStreamOptions{})
-	ws.OpenStream(2, OpenStreamOptions{PusherID: 1})
-	ws.OpenStream(3, OpenStreamOptions{PusherID: 1})
-	ws.OpenStream(4, OpenStreamOptions{PusherID: 3})
-	ws.OpenStream(5, OpenStreamOptions{PusherID: 3})
-	ws.OpenStream(6, OpenStreamOptions{PusherID: 4})
-	ws.AdjustStream(1, PriorityParam{
-		StreamDep: 4,
-		Weight:    15,
-		Exclusive: true,
-	})
-	want := "1{parent:4} 2{parent:1} 3{parent:1} 4{parent:0} 5{parent:3} 6{parent:1}"
-	if got := fmtTree(ws, fmtNodeParentSkipRoot); got != want {
-		t.Errorf("After adjust\ngot  %q\nwant %q", got, want)
-	}
-	if err := checkPriorityWellFormed(ws); err != nil {
-		t.Error(err)
-	}
-}
-
-func checkPopAll(ws WriteScheduler, order []uint32) error {
-	for k, id := range order {
-		wr, ok := ws.Pop()
-		if !ok {
-			return fmt.Errorf("Pop[%d]: got ok=false, want %d (order=%v)", k, id, order)
-		}
-		if got := wr.StreamID(); got != id {
-			return fmt.Errorf("Pop[%d]: got %v, want %d (order=%v)", k, got, id, order)
-		}
-	}
-	wr, ok := ws.Pop()
-	if ok {
-		return fmt.Errorf("Pop[%d]: got %v, want ok=false (order=%v)", len(order), wr.StreamID(), order)
-	}
-	return nil
-}
-
-func TestPriorityPopFrom533Tree(t *testing.T) {
-	ws := makeSection533Tree()
-
-	ws.Push(makeWriteHeadersRequest(3 /*C*/))
-	ws.Push(makeWriteNonStreamRequest())
-	ws.Push(makeWriteHeadersRequest(5 /*E*/))
-	ws.Push(makeWriteHeadersRequest(1 /*A*/))
-	t.Log("tree:", fmtTree(ws, fmtNodeParentSkipRoot))
-
-	if err := checkPopAll(ws, []uint32{0 /*NonStream*/, 1, 3, 5}); err != nil {
-		t.Error(err)
-	}
-}
-
-func TestPriorityPopFromLinearTree(t *testing.T) {
-	ws := defaultPriorityWriteScheduler()
-	ws.OpenStream(1, OpenStreamOptions{})
-	ws.OpenStream(2, OpenStreamOptions{PusherID: 1})
-	ws.OpenStream(3, OpenStreamOptions{PusherID: 2})
-	ws.OpenStream(4, OpenStreamOptions{PusherID: 3})
-
-	ws.Push(makeWriteHeadersRequest(3))
-	ws.Push(makeWriteHeadersRequest(4))
-	ws.Push(makeWriteHeadersRequest(1))
-	ws.Push(makeWriteHeadersRequest(2))
-	ws.Push(makeWriteNonStreamRequest())
-	ws.Push(makeWriteNonStreamRequest())
-	t.Log("tree:", fmtTree(ws, fmtNodeParentSkipRoot))
-
-	if err := checkPopAll(ws, []uint32{0, 0 /*NonStreams*/, 1, 2, 3, 4}); err != nil {
-		t.Error(err)
-	}
-}
-
-func TestPriorityFlowControl(t *testing.T) {
-	ws := NewPriorityWriteScheduler(&PriorityWriteSchedulerConfig{ThrottleOutOfOrderWrites: false})
-	ws.OpenStream(1, OpenStreamOptions{})
-	ws.OpenStream(2, OpenStreamOptions{PusherID: 1})
-
-	sc := &serverConn{maxFrameSize: 16}
-	st1 := &stream{id: 1, sc: sc}
-	st2 := &stream{id: 2, sc: sc}
-
-	ws.Push(FrameWriteRequest{&writeData{1, make([]byte, 16), false}, st1, nil})
-	ws.Push(FrameWriteRequest{&writeData{2, make([]byte, 16), false}, st2, nil})
-	ws.AdjustStream(2, PriorityParam{StreamDep: 1})
-
-	// No flow-control bytes available.
-	if wr, ok := ws.Pop(); ok {
-		t.Fatalf("Pop(limited by flow control)=%v,true, want false", wr)
-	}
-
-	// Add enough flow-control bytes to write st2 in two Pop calls.
-	// Should write data from st2 even though it's lower priority than st1.
-	for i := 1; i <= 2; i++ {
-		st2.flow.add(8)
-		wr, ok := ws.Pop()
-		if !ok {
-			t.Fatalf("Pop(%d)=false, want true", i)
-		}
-		if got, want := wr.DataSize(), 8; got != want {
-			t.Fatalf("Pop(%d)=%d bytes, want %d bytes", i, got, want)
-		}
-	}
-}
-
-func TestPriorityThrottleOutOfOrderWrites(t *testing.T) {
-	ws := NewPriorityWriteScheduler(&PriorityWriteSchedulerConfig{ThrottleOutOfOrderWrites: true})
-	ws.OpenStream(1, OpenStreamOptions{})
-	ws.OpenStream(2, OpenStreamOptions{PusherID: 1})
-
-	sc := &serverConn{maxFrameSize: 4096}
-	st1 := &stream{id: 1, sc: sc}
-	st2 := &stream{id: 2, sc: sc}
-	st1.flow.add(4096)
-	st2.flow.add(4096)
-	ws.Push(FrameWriteRequest{&writeData{2, make([]byte, 4096), false}, st2, nil})
-	ws.AdjustStream(2, PriorityParam{StreamDep: 1})
-
-	// We have enough flow-control bytes to write st2 in a single Pop call.
-	// However, due to out-of-order write throttling, the first call should
-	// only write 1KB.
-	wr, ok := ws.Pop()
-	if !ok {
-		t.Fatalf("Pop(st2.first)=false, want true")
-	}
-	if got, want := wr.StreamID(), uint32(2); got != want {
-		t.Fatalf("Pop(st2.first)=stream %d, want stream %d", got, want)
-	}
-	if got, want := wr.DataSize(), 1024; got != want {
-		t.Fatalf("Pop(st2.first)=%d bytes, want %d bytes", got, want)
-	}
-
-	// Now add data on st1. This should take precedence.
-	ws.Push(FrameWriteRequest{&writeData{1, make([]byte, 4096), false}, st1, nil})
-	wr, ok = ws.Pop()
-	if !ok {
-		t.Fatalf("Pop(st1)=false, want true")
-	}
-	if got, want := wr.StreamID(), uint32(1); got != want {
-		t.Fatalf("Pop(st1)=stream %d, want stream %d", got, want)
-	}
-	if got, want := wr.DataSize(), 4096; got != want {
-		t.Fatalf("Pop(st1)=%d bytes, want %d bytes", got, want)
-	}
-
-	// Should go back to writing 1KB from st2.
-	wr, ok = ws.Pop()
-	if !ok {
-		t.Fatalf("Pop(st2.last)=false, want true")
-	}
-	if got, want := wr.StreamID(), uint32(2); got != want {
-		t.Fatalf("Pop(st2.last)=stream %d, want stream %d", got, want)
-	}
-	if got, want := wr.DataSize(), 1024; got != want {
-		t.Fatalf("Pop(st2.last)=%d bytes, want %d bytes", got, want)
-	}
-}
-
-func TestPriorityWeights(t *testing.T) {
-	ws := defaultPriorityWriteScheduler()
-	ws.OpenStream(1, OpenStreamOptions{})
-	ws.OpenStream(2, OpenStreamOptions{})
-
-	sc := &serverConn{maxFrameSize: 8}
-	st1 := &stream{id: 1, sc: sc}
-	st2 := &stream{id: 2, sc: sc}
-	st1.flow.add(40)
-	st2.flow.add(40)
-
-	ws.Push(FrameWriteRequest{&writeData{1, make([]byte, 40), false}, st1, nil})
-	ws.Push(FrameWriteRequest{&writeData{2, make([]byte, 40), false}, st2, nil})
-	ws.AdjustStream(1, PriorityParam{StreamDep: 0, Weight: 34})
-	ws.AdjustStream(2, PriorityParam{StreamDep: 0, Weight: 9})
-
-	// st1 gets 3.5x the bandwidth of st2 (3.5 = (34+1)/(9+1)).
-	// The maximum frame size is 8 bytes. The write sequence should be:
-	//   st1, total bytes so far is (st1=8,  st=0)
-	//   st2, total bytes so far is (st1=8,  st=8)
-	//   st1, total bytes so far is (st1=16, st=8)
-	//   st1, total bytes so far is (st1=24, st=8)   // 3x bandwidth
-	//   st1, total bytes so far is (st1=32, st=8)   // 4x bandwidth
-	//   st2, total bytes so far is (st1=32, st=16)  // 2x bandwidth
-	//   st1, total bytes so far is (st1=40, st=16)
-	//   st2, total bytes so far is (st1=40, st=24)
-	//   st2, total bytes so far is (st1=40, st=32)
-	//   st2, total bytes so far is (st1=40, st=40)
-	if err := checkPopAll(ws, []uint32{1, 2, 1, 1, 1, 2, 1, 2, 2, 2}); err != nil {
-		t.Error(err)
-	}
-}
-
-func TestPriorityRstStreamOnNonOpenStreams(t *testing.T) {
-	ws := NewPriorityWriteScheduler(&PriorityWriteSchedulerConfig{
-		MaxClosedNodesInTree: 0,
-		MaxIdleNodesInTree:   0,
-	})
-	ws.OpenStream(1, OpenStreamOptions{})
-	ws.CloseStream(1)
-	ws.Push(FrameWriteRequest{write: streamError(1, ErrCodeProtocol)})
-	ws.Push(FrameWriteRequest{write: streamError(2, ErrCodeProtocol)})
-
-	if err := checkPopAll(ws, []uint32{1, 2}); err != nil {
-		t.Error(err)
-	}
-}

vendor/golang.org/x/net/http2/writesched_random.go

@@ -1,72 +0,0 @@
-// Copyright 2014 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package http2
-
-import "math"
-
-// NewRandomWriteScheduler constructs a WriteScheduler that ignores HTTP/2
-// priorities. Control frames like SETTINGS and PING are written before DATA
-// frames, but if no control frames are queued and multiple streams have queued
-// HEADERS or DATA frames, Pop selects a ready stream arbitrarily.
-func NewRandomWriteScheduler() WriteScheduler {
-	return &randomWriteScheduler{sq: make(map[uint32]*writeQueue)}
-}
-
-type randomWriteScheduler struct {
-	// zero are frames not associated with a specific stream.
-	zero writeQueue
-
-	// sq contains the stream-specific queues, keyed by stream ID.
-	// When a stream is idle or closed, it's deleted from the map.
-	sq map[uint32]*writeQueue
-
-	// pool of empty queues for reuse.
-	queuePool writeQueuePool
-}
-
-func (ws *randomWriteScheduler) OpenStream(streamID uint32, options OpenStreamOptions) {
-	// no-op: idle streams are not tracked
-}
-
-func (ws *randomWriteScheduler) CloseStream(streamID uint32) {
-	q, ok := ws.sq[streamID]
-	if !ok {
-		return
-	}
-	delete(ws.sq, streamID)
-	ws.queuePool.put(q)
-}
-
-func (ws *randomWriteScheduler) AdjustStream(streamID uint32, priority PriorityParam) {
-	// no-op: priorities are ignored
-}
-
-func (ws *randomWriteScheduler) Push(wr FrameWriteRequest) {
-	id := wr.StreamID()
-	if id == 0 {
-		ws.zero.push(wr)
-		return
-	}
-	q, ok := ws.sq[id]
-	if !ok {
-		q = ws.queuePool.get()
-		ws.sq[id] = q
-	}
-	q.push(wr)
-}
-
-func (ws *randomWriteScheduler) Pop() (FrameWriteRequest, bool) {
-	// Control frames first.
-	if !ws.zero.empty() {
-		return ws.zero.shift(), true
-	}
-	// Iterate over all non-idle streams until finding one that can be consumed.
-	for _, q := range ws.sq {
-		if wr, ok := q.consume(math.MaxInt32); ok {
-			return wr, true
-		}
-	}
-	return FrameWriteRequest{}, false
-}